LADX: no pickle

* fix appimage executable reference

* adjust working dir

* use argv0 instead of appimage directly

* set noexe on frozen

.github/workflows/build.yml

@@ -9,22 +9,25 @@ on:
       - 'setup.py'
       - 'requirements.txt'
       - '*.iss'
+      - 'worlds/*/archipelago.json'
   pull_request:
     paths:
       - '.github/workflows/build.yml'
       - 'setup.py'
       - 'requirements.txt'
       - '*.iss'
+      - 'worlds/*/archipelago.json'
   workflow_dispatch:
 
 env:
   ENEMIZER_VERSION: 7.1
   # NOTE: since appimage/appimagetool and appimage/type2-runtime does not have tags anymore,
   #       we check the sha256 and require manual intervention if it was updated.
-  APPIMAGETOOL_VERSION: continuous
-  APPIMAGETOOL_X86_64_HASH: '29348a20b80827cd261c28e95172ff828b69d43d4e4e18e3fd069e2c8693c94e'
-  APPIMAGE_RUNTIME_VERSION: continuous
-  APPIMAGE_RUNTIME_X86_64_HASH: 'e70ffa9b69b211574d0917adc482dd66f25a0083427b5945783965d55b0b0a8b'
+  APPIMAGE_FORK: 'PopTracker'
+  APPIMAGETOOL_VERSION: 'r-2025-11-18'
+  APPIMAGETOOL_X86_64_HASH: '4577a452b30af2337123fbb383aea154b618e51ad5448c3b62085cbbbfbfd9a2'
+  APPIMAGE_RUNTIME_VERSION: 'r-2025-11-07'
+  APPIMAGE_RUNTIME_X86_64_HASH: '27ddd3f78e483fc5f7856e413d7c17092917f8c35bfe3318a0d378aa9435ad17'
 
 permissions:  # permissions required for attestation
   id-token: 'write'
@@ -139,9 +142,9 @@ jobs:
       - name: Install build-time dependencies
         run: |
           echo "PYTHON=python3.12" >> $GITHUB_ENV
-          wget -nv https://github.com/AppImage/appimagetool/releases/download/$APPIMAGETOOL_VERSION/appimagetool-x86_64.AppImage
+          wget -nv https://github.com/$APPIMAGE_FORK/appimagetool/releases/download/$APPIMAGETOOL_VERSION/appimagetool-x86_64.AppImage
           echo "$APPIMAGETOOL_X86_64_HASH appimagetool-x86_64.AppImage" | sha256sum -c
-          wget -nv https://github.com/AppImage/type2-runtime/releases/download/$APPIMAGE_RUNTIME_VERSION/runtime-x86_64
+          wget -nv https://github.com/$APPIMAGE_FORK/type2-runtime/releases/download/$APPIMAGE_RUNTIME_VERSION/runtime-x86_64
           echo "$APPIMAGE_RUNTIME_X86_64_HASH runtime-x86_64" | sha256sum -c
           chmod a+rx appimagetool-x86_64.AppImage
           ./appimagetool-x86_64.AppImage --appimage-extract

.github/workflows/docker.yml

@@ -0,0 +1,154 @@
+name: Build and Publish Docker Images
+
+on:
+  push:
+    paths:
+      - "**"
+      - "!docs/**"
+      - "!deploy/**"
+      - "!setup.py"
+      - "!.gitignore"
+      - "!.github/workflows/**"
+      - ".github/workflows/docker.yml"
+    branches:
+      - "main"
+    tags:
+      - "v?[0-9]+.[0-9]+.[0-9]*"
+  workflow_dispatch:
+
+env:
+  REGISTRY: ghcr.io
+
+jobs:
+  prepare:
+    runs-on: ubuntu-latest
+    outputs:
+      image-name: ${{ steps.image.outputs.name }}
+      tags: ${{ steps.meta.outputs.tags }}
+      labels: ${{ steps.meta.outputs.labels }}
+      package-name: ${{ steps.package.outputs.name }}
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Set lowercase image name
+        id: image
+        run: |
+          echo "name=${GITHUB_REPOSITORY,,}" >> $GITHUB_OUTPUT
+
+      - name: Set package name
+        id: package
+        run: |
+          echo "name=$(basename ${GITHUB_REPOSITORY,,})" >> $GITHUB_OUTPUT
+
+      - name: Extract metadata
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: ${{ env.REGISTRY }}/${{ steps.image.outputs.name }}
+          tags: |
+            type=ref,event=branch,enable={{is_not_default_branch}}
+            type=semver,pattern={{version}}
+            type=semver,pattern={{major}}.{{minor}}
+            type=raw,value=nightly,enable={{is_default_branch}}
+
+      - name: Compute final tags
+        id: final-tags
+        run: |
+          readarray -t tags <<< "${{ steps.meta.outputs.tags }}"
+
+          if [[ "${{ github.ref_type }}" == "tag" ]]; then
+            tag="${{ github.ref_name }}"
+            if [[ "$tag" =~ ^v?[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
+              full_latest="${{ env.REGISTRY }}/${{ steps.image.outputs.name }}:latest"
+              # Check if latest is already in tags to avoid duplicates
+              if ! printf '%s\n' "${tags[@]}" | grep -q "^$full_latest$"; then
+                tags+=("$full_latest")
+              fi
+            fi
+          fi
+
+          # Set multiline output
+          echo "tags<<EOF" >> $GITHUB_OUTPUT
+          printf '%s\n' "${tags[@]}" >> $GITHUB_OUTPUT
+          echo "EOF" >> $GITHUB_OUTPUT
+
+  build:
+    needs: prepare
+    runs-on: ${{ matrix.runner }}
+    permissions:
+      contents: read
+      packages: write
+    strategy:
+      matrix:
+        include:
+          - platform: amd64
+            runner: ubuntu-latest
+            suffix: amd64
+            cache-scope: amd64
+          - platform: arm64
+            runner: ubuntu-24.04-arm
+            suffix: arm64
+            cache-scope: arm64
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Log in to GitHub Container Registry
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.REGISTRY }}
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Compute suffixed tags
+        id: tags
+        run: |
+          readarray -t tags <<< "${{ needs.prepare.outputs.tags }}"
+          suffixed=()
+          for t in "${tags[@]}"; do
+            suffixed+=("$t-${{ matrix.suffix }}")
+          done
+          echo "tags=$(IFS=','; echo "${suffixed[*]}")" >> $GITHUB_OUTPUT
+
+      - name: Build and push Docker image
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          file: ./Dockerfile
+          platforms: linux/${{ matrix.platform }}
+          push: true
+          tags: ${{ steps.tags.outputs.tags }}
+          labels: ${{ needs.prepare.outputs.labels }}
+          cache-from: type=gha,scope=${{ matrix.cache-scope }}
+          cache-to: type=gha,mode=max,scope=${{ matrix.cache-scope }}
+          provenance: false
+
+  manifest:
+    needs: [prepare, build]
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+    steps:
+      - name: Log in to GitHub Container Registry
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.REGISTRY }}
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Create and push multi-arch manifest
+        run: |
+          readarray -t tag_array <<< "${{ needs.prepare.outputs.tags }}"
+
+          for tag in "${tag_array[@]}"; do
+            docker manifest create "$tag" \
+              "$tag-amd64" \
+              "$tag-arm64"
+            
+            docker manifest push "$tag"
+          done

.github/workflows/label-pull-requests.yml

@@ -12,7 +12,6 @@ env:
 jobs:
   labeler:
     name: 'Apply content-based labels'
-    if: github.event.action == 'opened' || github.event.action == 'reopened' || github.event.action == 'synchronize'
     runs-on: ubuntu-latest
     steps:
       - uses: actions/labeler@v5

.github/workflows/release.yml

@@ -11,10 +11,11 @@ env:
   ENEMIZER_VERSION: 7.1
   # NOTE: since appimage/appimagetool and appimage/type2-runtime does not have tags anymore,
   #       we check the sha256 and require manual intervention if it was updated.
-  APPIMAGETOOL_VERSION: continuous
-  APPIMAGETOOL_X86_64_HASH: '29348a20b80827cd261c28e95172ff828b69d43d4e4e18e3fd069e2c8693c94e'
-  APPIMAGE_RUNTIME_VERSION: continuous
-  APPIMAGE_RUNTIME_X86_64_HASH: 'e70ffa9b69b211574d0917adc482dd66f25a0083427b5945783965d55b0b0a8b'
+  APPIMAGE_FORK: 'PopTracker'
+  APPIMAGETOOL_VERSION: 'r-2025-11-18'
+  APPIMAGETOOL_X86_64_HASH: '4577a452b30af2337123fbb383aea154b618e51ad5448c3b62085cbbbfbfd9a2'
+  APPIMAGE_RUNTIME_VERSION: 'r-2025-11-07'
+  APPIMAGE_RUNTIME_X86_64_HASH: '27ddd3f78e483fc5f7856e413d7c17092917f8c35bfe3318a0d378aa9435ad17'
 
 permissions:  # permissions required for attestation
   id-token: 'write'
@@ -127,9 +128,9 @@ jobs:
       - name: Install build-time dependencies
         run: |
           echo "PYTHON=python3.12" >> $GITHUB_ENV
-          wget -nv https://github.com/AppImage/appimagetool/releases/download/$APPIMAGETOOL_VERSION/appimagetool-x86_64.AppImage
+          wget -nv https://github.com/$APPIMAGE_FORK/appimagetool/releases/download/$APPIMAGETOOL_VERSION/appimagetool-x86_64.AppImage
           echo "$APPIMAGETOOL_X86_64_HASH appimagetool-x86_64.AppImage" | sha256sum -c
-          wget -nv https://github.com/AppImage/type2-runtime/releases/download/$APPIMAGE_RUNTIME_VERSION/runtime-x86_64
+          wget -nv https://github.com/$APPIMAGE_FORK/type2-runtime/releases/download/$APPIMAGE_RUNTIME_VERSION/runtime-x86_64
           echo "$APPIMAGE_RUNTIME_X86_64_HASH runtime-x86_64" | sha256sum -c
           chmod a+rx appimagetool-x86_64.AppImage
           ./appimagetool-x86_64.AppImage --appimage-extract

.github/workflows/unittests.yml

@@ -59,7 +59,7 @@ jobs:
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip
-        pip install pytest pytest-subtests pytest-xdist
+        pip install -r ci-requirements.txt
         python ModuleUpdate.py --yes --force --append "WebHostLib/requirements.txt"
         python Launcher.py --update_settings  # make sure host.yaml exists for tests
     - name: Unittests

.run/Build APWorld.run.xml

@@ -0,0 +1,24 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="Build APWorld" type="PythonConfigurationType" factoryName="Python">
+    <module name="Archipelago" />
+    <option name="ENV_FILES" value="" />
+    <option name="INTERPRETER_OPTIONS" value="" />
+    <option name="PARENT_ENVS" value="true" />
+    <envs>
+      <env name="PYTHONUNBUFFERED" value="1" />
+    </envs>
+    <option name="SDK_HOME" value="" />
+    <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$/" />
+    <option name="IS_MODULE_SDK" value="true" />
+    <option name="ADD_CONTENT_ROOTS" value="true" />
+    <option name="ADD_SOURCE_ROOTS" value="true" />
+    <option name="SCRIPT_NAME" value="$PROJECT_DIR$/Launcher.py" />
+    <option name="PARAMETERS" value="&quot;Build APWorlds&quot;" />
+    <option name="SHOW_COMMAND_LINE" value="false" />
+    <option name="EMULATE_TERMINAL" value="false" />
+    <option name="MODULE_MODE" value="false" />
+    <option name="REDIRECT_INPUT" value="false" />
+    <option name="INPUT_FILE" value="" />
+    <method v="2" />
+  </configuration>
+</component>

BaseClasses.py

@@ -261,6 +261,7 @@ class MultiWorld():
                         "local_items": set(item_link.get("local_items", [])),
                         "non_local_items": set(item_link.get("non_local_items", [])),
                         "link_replacement": replacement_prio.index(item_link["link_replacement"]),
+                        "skip_if_solo": item_link.get("skip_if_solo", False),
                     }
 
         for _name, item_link in item_links.items():
@@ -284,6 +285,8 @@ class MultiWorld():
 
         for group_name, item_link in item_links.items():
             game = item_link["game"]
+            if item_link["skip_if_solo"] and len(item_link["players"]) == 1:
+                continue
             group_id, group = self.add_group(group_name, game, set(item_link["players"]))
 
             group["item_pool"] = item_link["item_pool"]
@@ -1343,8 +1346,7 @@ class Region:
         for entrance in self.entrances:  # BFS might be better here, trying DFS for now.
             return entrance.parent_region.get_connecting_entrance(is_main_entrance)
 
-    def add_locations(self, locations: Dict[str, Optional[int]],
-                      location_type: Optional[type[Location]] = None) -> None:
+    def add_locations(self, locations: Mapping[str, int | None], location_type: type[Location] | None = None) -> None:
         """
         Adds locations to the Region object, where location_type is your Location class and locations is a dict of
         location names to address.
@@ -1432,8 +1434,8 @@ class Region:
         entrance.connect(self)
         return entrance
 
-    def add_exits(self, exits: Union[Iterable[str], Dict[str, Optional[str]]],
-                  rules: Dict[str, Callable[[CollectionState], bool]] = None) -> List[Entrance]:
+    def add_exits(self, exits: Iterable[str] | Mapping[str, str | None],
+                  rules: Mapping[str, Callable[[CollectionState], bool]] | None = None) -> List[Entrance]:
         """
         Connects current region to regions in exit dictionary. Passed region names must exist first.
 
@@ -1441,7 +1443,7 @@ class Region:
                       created entrances will be named "self.name -> connecting_region"
         :param rules: rules for the exits from this region. format is {"connecting_region": rule}
         """
-        if not isinstance(exits, Dict):
+        if not isinstance(exits, Mapping):
             exits = dict.fromkeys(exits)
         return [
             self.connect(
@@ -1719,9 +1721,10 @@ class Spoiler:
                 logging.debug('The following items could not be reached: %s', ['%s (Player %d) at %s (Player %d)' % (
                     location.item.name, location.item.player, location.name, location.player) for location in
                                                                                sphere_candidates])
-                if any([multiworld.worlds[location.item.player].options.accessibility != 'minimal' for location in sphere_candidates]):
-                    raise RuntimeError(f'Not all progression items reachable ({sphere_candidates}). '
-                                       f'Something went terribly wrong here.')
+                if not multiworld.has_beaten_game(state):
+                    raise RuntimeError("During playthrough generation, the game was determined to be unbeatable. "
+                                       "Something went terribly wrong here. "
+                                       f"Unreachable progression items: {sphere_candidates}")
                 else:
                     self.unreachables = sphere_candidates
                     break
@@ -1855,6 +1858,9 @@ class Spoiler:
                     Utils.__version__, self.multiworld.seed))
             outfile.write('Filling Algorithm:               %s\n' % self.multiworld.algorithm)
             outfile.write('Players:                         %d\n' % self.multiworld.players)
+            if self.multiworld.players > 1:
+                loc_count = len([loc for loc in self.multiworld.get_locations() if not loc.is_event])
+                outfile.write('Total Location Count:            %d\n' % loc_count)
             outfile.write(f'Plando Options:                  {self.multiworld.plando_options}\n')
             AutoWorld.call_stage(self.multiworld, "write_spoiler_header", outfile)
 
@@ -1863,6 +1869,9 @@ class Spoiler:
                     outfile.write('\nPlayer %d: %s\n' % (player, self.multiworld.get_player_name(player)))
                 outfile.write('Game:                            %s\n' % self.multiworld.game[player])
 
+                loc_count = len([loc for loc in self.multiworld.get_locations(player) if not loc.is_event])
+                outfile.write('Location Count:                  %d\n' % loc_count)
+
                 for f_option, option in self.multiworld.worlds[player].options_dataclass.type_hints.items():
                     write_option(f_option, option)
 

CommonClient.py

@@ -323,7 +323,7 @@ class CommonContext:
     hint_cost: int | None
     """Current Hint Cost per Hint from the server"""
     hint_points: int | None
-    """Current avaliable Hint Points from the server"""
+    """Current available Hint Points from the server"""
     player_names: dict[int, str]
     """Current lookup of slot number to player display name from server (includes aliases)"""
 
@@ -572,6 +572,10 @@ class CommonContext:
         return print_json_packet.get("type", "") == "ItemSend" \
             and not self.slot_concerns_self(print_json_packet["receiving"]) \
             and not self.slot_concerns_self(print_json_packet["item"].player)
+    
+    def is_connection_change(self, print_json_packet: dict) -> bool:
+        """Helper function for filtering out connection changes."""
+        return print_json_packet.get("type", "") in ["Join","Part"]
 
     def on_print(self, args: dict):
         logger.info(args["text"])
@@ -856,9 +860,9 @@ async def server_loop(ctx: CommonContext, address: typing.Optional[str] = None)
 
     server_url = urllib.parse.urlparse(address)
     if server_url.username:
-        ctx.username = server_url.username
+        ctx.username = urllib.parse.unquote(server_url.username)
     if server_url.password:
-        ctx.password = server_url.password
+        ctx.password = urllib.parse.unquote(server_url.password)
 
     def reconnect_hint() -> str:
         return ", type /connect to reconnect" if ctx.server_address else ""

Fill.py

@@ -129,6 +129,10 @@ def fill_restrictive(multiworld: MultiWorld, base_state: CollectionState, locati
                                      for i, location in enumerate(placements))
                     for (i, location, unsafe) in swap_attempts:
                         placed_item = location.item
+                        if item_to_place == placed_item:
+                            # The number of allowed swaps is limited, so do not allow a swap of an item with a copy of
+                            # itself.
+                            continue
                         # Unplaceable items can sometimes be swapped infinitely. Limit the
                         # number of times we will swap an individual item to prevent this
                         swap_count = swapped_items[placed_item.player, placed_item.name, unsafe]

Generate.py

@@ -23,7 +23,7 @@ from BaseClasses import seeddigits, get_seed, PlandoOptions
 from Utils import parse_yamls, version_tuple, __version__, tuplize_version
 
 
-def mystery_argparse():
+def mystery_argparse(argv: list[str] | None = None):
     from settings import get_settings
     settings = get_settings()
     defaults = settings.generator
@@ -57,7 +57,7 @@ def mystery_argparse():
     parser.add_argument("--spoiler_only", action="store_true",
                         help="Skips generation assertion and multidata, outputting only a spoiler log. "
                              "Intended for debugging and testing purposes.")
-    args = parser.parse_args()
+    args = parser.parse_args(argv)
 
     if args.skip_output and args.spoiler_only:
         parser.error("Cannot mix --skip_output and --spoiler_only")
@@ -189,6 +189,11 @@ def main(args=None) -> tuple[argparse.Namespace, int]:
                                         yaml[category][key] = option
                             elif category_name not in yaml:
                                 logging.warning(f"Meta: Category {category_name} is not present in {path}.")
+                            elif key == "triggers":
+                                if "triggers" not in yaml[category_name]:
+                                    yaml[category_name][key] = []
+                                for trigger in option:
+                                    yaml[category_name][key].append(trigger)
                             else:
                                 yaml[category_name][key] = option
 
@@ -342,7 +347,9 @@ def update_weights(weights: dict, new_weights: dict, update_type: str, name: str
             elif isinstance(new_value, list):
                 cleaned_value.extend(new_value)
             elif isinstance(new_value, dict):
-                cleaned_value = dict(Counter(cleaned_value) + Counter(new_value))
+                counter_value = Counter(cleaned_value)
+                counter_value.update(new_value)
+                cleaned_value = dict(counter_value)
             else:
                 raise Exception(f"Cannot apply merge to non-dict, set, or list type {option_name},"
                                 f" received {type(new_value).__name__}.")
@@ -356,13 +363,18 @@ def update_weights(weights: dict, new_weights: dict, update_type: str, name: str
                 for element in new_value:
                     cleaned_value.remove(element)
             elif isinstance(new_value, dict):
-                cleaned_value = dict(Counter(cleaned_value) - Counter(new_value))
+                counter_value = Counter(cleaned_value)
+                counter_value.subtract(new_value)
+                cleaned_value = dict(counter_value)
             else:
                 raise Exception(f"Cannot apply remove to non-dict, set, or list type {option_name},"
                                 f" received {type(new_value).__name__}.")
             cleaned_weights[option_name] = cleaned_value
         else:
-            cleaned_weights[option_name] = new_weights[option]
+            # Options starting with + and - may modify values in-place, and new_weights may be shared by multiple slots
+            # using the same .yaml, so ensure that the new value is a copy.
+            cleaned_value = copy.deepcopy(new_weights[option])
+            cleaned_weights[option_name] = cleaned_value
     new_options = set(cleaned_weights) - set(weights)
     weights.update(cleaned_weights)
     if new_options:
@@ -385,6 +397,8 @@ def roll_meta_option(option_key, game: str, category_dict: dict) -> Any:
             if options[option_key].supports_weighting:
                 return get_choice(option_key, category_dict)
             return category_dict[option_key]
+        if option_key == "triggers":
+            return category_dict[option_key]
     raise Options.OptionError(f"Error generating meta option {option_key} for {game}.")
 
 
@@ -486,7 +500,22 @@ def roll_settings(weights: dict, plando_options: PlandoOptions = PlandoOptions.b
             if required_plando_options:
                 raise Exception(f"Settings reports required plando module {str(required_plando_options)}, "
                                 f"which is not enabled.")
-
+        games = requirements.get("game", {})
+        for game, version in games.items():
+            if game not in AutoWorldRegister.world_types:
+                continue
+            if not version:
+                raise Exception(f"Invalid version for game {game}: {version}.")
+            if isinstance(version, str):
+                version = {"min": version}
+            if "min" in version and tuplize_version(version["min"]) > AutoWorldRegister.world_types[game].world_version:
+                raise Exception(f"Settings reports required version of world \"{game}\" is at least {version['min']}, "
+                                f"however world is of version "
+                                f"{AutoWorldRegister.world_types[game].world_version.as_simple_string()}.")
+            if "max" in version and tuplize_version(version["max"]) < AutoWorldRegister.world_types[game].world_version:
+                raise Exception(f"Settings reports required version of world \"{game}\" is no later than {version['max']}, "
+                                f"however world is of version "
+                                f"{AutoWorldRegister.world_types[game].world_version.as_simple_string()}.")
     ret = argparse.Namespace()
     for option_key in Options.PerGameCommonOptions.type_hints:
         if option_key in weights and option_key not in Options.CommonOptions.type_hints:

KH1Client.py

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

KH2Client.py

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

Launcher.py

@@ -75,12 +75,17 @@ def open_patch():
             launch([*exe, file], component.cli)
 
 
-def generate_yamls():
+def generate_yamls(*args):
     from Options import generate_yaml_templates
 
+    parser = argparse.ArgumentParser(description="Generate Template Options", usage="[-h] [--skip_open_folder]")
+    parser.add_argument("--skip_open_folder", action="store_true")
+    args = parser.parse_args(args)
+
     target = Utils.user_path("Players", "Templates")
     generate_yaml_templates(target, False)
-    open_folder(target)
+    if not args.skip_open_folder:
+        open_folder(target)
 
 
 def browse_files():
@@ -213,12 +218,17 @@ def launch(exe, in_terminal=False):
 
 def create_shortcut(button: Any, component: Component) -> None:
     from pyshortcuts import make_shortcut
-    script = sys.argv[0]
-    wkdir = Utils.local_path()
+    env = os.environ
+    if "APPIMAGE" in env:
+        script = env["ARGV0"]
+        wkdir = None # defaults to ~ on Linux
+    else:
+        script = sys.argv[0]
+        wkdir = Utils.local_path()
 
     script = f"{script} \"{component.display_name}\""
     make_shortcut(script, name=f"Archipelago {component.display_name}", icon=local_path("data", "icon.ico"),
-                  startmenu=False, terminal=False, working_dir=wkdir)
+                  startmenu=False, terminal=False, working_dir=wkdir, noexe=Utils.is_frozen())
     button.menu.dismiss()
 
 

Main.py

@@ -54,12 +54,17 @@ def main(args, seed=None, baked_server_options: dict[str, object] | None = None)
     logger.info(f"Found {len(AutoWorld.AutoWorldRegister.world_types)} World Types:")
     longest_name = max(len(text) for text in AutoWorld.AutoWorldRegister.world_types)
 
-    item_count = len(str(max(len(cls.item_names) for cls in AutoWorld.AutoWorldRegister.world_types.values())))
-    location_count = len(str(max(len(cls.location_names) for cls in AutoWorld.AutoWorldRegister.world_types.values())))
+    world_classes = AutoWorld.AutoWorldRegister.world_types.values()
+
+    version_count = max(len(cls.world_version.as_simple_string()) for cls in world_classes)
+    item_count = len(str(max(len(cls.item_names) for cls in world_classes)))
+    location_count = len(str(max(len(cls.location_names) for cls in world_classes)))
 
     for name, cls in AutoWorld.AutoWorldRegister.world_types.items():
         if not cls.hidden and len(cls.item_names) > 0:
-            logger.info(f" {name:{longest_name}}: Items: {len(cls.item_names):{item_count}} | "
+            logger.info(f" {name:{longest_name}}: "
+                        f"v{cls.world_version.as_simple_string():{version_count}} | "
+                        f"Items: {len(cls.item_names):{item_count}} | "
                         f"Locations: {len(cls.location_names):{location_count}}")
 
     del item_count, location_count
@@ -321,7 +326,7 @@ def main(args, seed=None, baked_server_options: dict[str, object] | None = None)
                     if current_sphere:
                         spheres.append(dict(current_sphere))
 
-                multidata: NetUtils.MultiData | bytes = {
+                multidata: NetUtils.MultiData = {
                     "slot_data": slot_data,
                     "slot_info": slot_info,
                     "connect_names": {name: (0, player) for player, name in multiworld.player_name.items()},
@@ -345,11 +350,11 @@ def main(args, seed=None, baked_server_options: dict[str, object] | None = None)
                 for key in ("slot_data", "er_hint_data"):
                     multidata[key] = convert_to_base_types(multidata[key])
 
-                multidata = zlib.compress(restricted_dumps(multidata), 9)
+                serialized_multidata = zlib.compress(restricted_dumps(multidata), 9)
 
                 with open(os.path.join(temp_dir, f'{outfilebase}.archipelago'), 'wb') as f:
                     f.write(bytes([3]))  # version of format
-                    f.write(multidata)
+                    f.write(serialized_multidata)
 
             output_file_futures.append(pool.submit(write_multidata))
             if not check_accessibility_task.result():

MultiServer.py

@@ -32,7 +32,7 @@ if typing.TYPE_CHECKING:
 
 import colorama
 import websockets
-from websockets.extensions.permessage_deflate import PerMessageDeflate
+from websockets.extensions.permessage_deflate import PerMessageDeflate, ServerPerMessageDeflateFactory
 try:
     # ponyorm is a requirement for webhost, not default server, so may not be importable
     from pony.orm.dbapiprovider import OperationalError
@@ -50,6 +50,15 @@ from BaseClasses import ItemClassification
 min_client_version = Version(0, 5, 0)
 colorama.just_fix_windows_console()
 
+no_version = Version(0, 0, 0)
+assert isinstance(no_version, tuple)  # assert immutable
+
+server_per_message_deflate_factory = ServerPerMessageDeflateFactory(
+    server_max_window_bits=11,
+    client_max_window_bits=11,
+    compress_settings={"memLevel": 4},
+)
+
 
 def remove_from_list(container, value):
     try:
@@ -125,8 +134,31 @@ def get_saving_second(seed_name: str, interval: int = 60) -> int:
 
 
 class Client(Endpoint):
-    version = Version(0, 0, 0)
-    tags: typing.List[str]
+    __slots__ = (
+        "__weakref__",
+        "version",
+        "auth",
+        "team",
+        "slot",
+        "send_index",
+        "tags",
+        "messageprocessor",
+        "ctx",
+        "remote_items",
+        "remote_start_inventory",
+        "no_items",
+        "no_locations",
+        "no_text",
+    )
+
+    version: Version
+    auth: bool
+    team: int | None
+    slot: int | None
+    send_index: int
+    tags: list[str]
+    messageprocessor: ClientMessageProcessor
+    ctx: weakref.ref[Context]
     remote_items: bool
     remote_start_inventory: bool
     no_items: bool
@@ -135,6 +167,7 @@ class Client(Endpoint):
 
     def __init__(self, socket: "ServerConnection", ctx: Context) -> None:
         super().__init__(socket)
+        self.version = no_version
         self.auth = False
         self.team = None
         self.slot = None
@@ -142,6 +175,11 @@ class Client(Endpoint):
         self.tags = []
         self.messageprocessor = client_message_processor(ctx, self)
         self.ctx = weakref.ref(ctx)
+        self.remote_items = False
+        self.remote_start_inventory = False
+        self.no_items = False
+        self.no_locations = False
+        self.no_text = False
 
     @property
     def items_handling(self):
@@ -179,6 +217,7 @@ class Context:
                       "release_mode": str,
                       "remaining_mode": str,
                       "collect_mode": str,
+                      "countdown_mode": str,
                       "item_cheat": bool,
                       "compatibility": int}
     # team -> slot id -> list of clients authenticated to slot.
@@ -208,8 +247,8 @@ class Context:
 
     def __init__(self, host: str, port: int, server_password: str, password: str, location_check_points: int,
                  hint_cost: int, item_cheat: bool, release_mode: str = "disabled", collect_mode="disabled",
-                 remaining_mode: str = "disabled", auto_shutdown: typing.SupportsFloat = 0, compatibility: int = 2,
-                 log_network: bool = False, logger: logging.Logger = logging.getLogger()):
+                 countdown_mode: str = "auto", remaining_mode: str = "disabled", auto_shutdown: typing.SupportsFloat = 0, 
+                 compatibility: int = 2, log_network: bool = False, logger: logging.Logger = logging.getLogger()):
         self.logger = logger
         super(Context, self).__init__()
         self.slot_info = {}
@@ -242,6 +281,7 @@ class Context:
         self.release_mode: str = release_mode
         self.remaining_mode: str = remaining_mode
         self.collect_mode: str = collect_mode
+        self.countdown_mode: str = countdown_mode
         self.item_cheat = item_cheat
         self.exit_event = asyncio.Event()
         self.client_activity_timers: typing.Dict[
@@ -453,7 +493,7 @@ class Context:
         self.read_data["race_mode"] = lambda: decoded_obj.get("race_mode", 0)
         mdata_ver = decoded_obj["minimum_versions"]["server"]
         if mdata_ver > version_tuple:
-            raise RuntimeError(f"Supplied Multidata (.archipelago) requires a server of at least version {mdata_ver},"
+            raise RuntimeError(f"Supplied Multidata (.archipelago) requires a server of at least version {mdata_ver}, "
                                f"however this server is of version {version_tuple}")
         self.generator_version = Version(*decoded_obj["version"])
         clients_ver = decoded_obj["minimum_versions"].get("clients", {})
@@ -627,6 +667,7 @@ class Context:
                              "server_password": self.server_password, "password": self.password,
                              "release_mode": self.release_mode,
                              "remaining_mode": self.remaining_mode, "collect_mode": self.collect_mode,
+                             "countdown_mode": self.countdown_mode,
                              "item_cheat": self.item_cheat, "compatibility": self.compatibility}
 
         }
@@ -661,6 +702,7 @@ class Context:
             self.release_mode = savedata["game_options"]["release_mode"]
             self.remaining_mode = savedata["game_options"]["remaining_mode"]
             self.collect_mode = savedata["game_options"]["collect_mode"]
+            self.countdown_mode = savedata["game_options"].get("countdown_mode", self.countdown_mode)
             self.item_cheat = savedata["game_options"]["item_cheat"]
             self.compatibility = savedata["game_options"]["compatibility"]
 
@@ -1135,8 +1177,13 @@ def register_location_checks(ctx: Context, team: int, slot: int, locations: typi
         ctx.save()
 
 
-def collect_hints(ctx: Context, team: int, slot: int, item: typing.Union[int, str], auto_status: HintStatus) \
-        -> typing.List[Hint]:
+def collect_hints(ctx: Context, team: int, slot: int, item: typing.Union[int, str],
+                  status: HintStatus | None = None) -> typing.List[Hint]:
+    """
+    Collect a new hint for a given item id or name, with a given status.
+    If status is None (which is the default value), an automatic status will be determined from the item's quality.
+    """
+
     hints = []
     slots: typing.Set[int] = {slot}
     for group_id, group in ctx.groups.items():
@@ -1152,25 +1199,39 @@ def collect_hints(ctx: Context, team: int, slot: int, item: typing.Union[int, st
         else:
             found = location_id in ctx.location_checks[team, finding_player]
             entrance = ctx.er_hint_data.get(finding_player, {}).get(location_id, "")
-            new_status = auto_status
+
+            hint_status = status  # Assign again because we're in a for loop
             if found:
-                new_status = HintStatus.HINT_FOUND
-            elif item_flags & ItemClassification.trap:
-                new_status = HintStatus.HINT_AVOID
-            hints.append(Hint(receiving_player, finding_player, location_id, item_id, found, entrance,
-                                       item_flags, new_status))
+                hint_status = HintStatus.HINT_FOUND
+            elif hint_status is None:
+                if item_flags & ItemClassification.trap:
+                    hint_status = HintStatus.HINT_AVOID
+                else:
+                    hint_status = HintStatus.HINT_PRIORITY
+
+            hints.append(
+                Hint(receiving_player, finding_player, location_id, item_id, found, entrance, item_flags, hint_status)
+            )
 
     return hints
 
 
-def collect_hint_location_name(ctx: Context, team: int, slot: int, location: str, auto_status: HintStatus) \
-        -> typing.List[Hint]:
+def collect_hint_location_name(ctx: Context, team: int, slot: int, location: str,
+                               status: HintStatus | None = HintStatus.HINT_UNSPECIFIED) -> typing.List[Hint]:
+    """
+    Collect a new hint for a given location name, with a given status (defaults to "unspecified").
+    If None is passed for the status, then an automatic status will be determined from the item's quality.
+    """
     seeked_location: int = ctx.location_names_for_game(ctx.games[slot])[location]
-    return collect_hint_location_id(ctx, team, slot, seeked_location, auto_status)
+    return collect_hint_location_id(ctx, team, slot, seeked_location, status)
 
 
-def collect_hint_location_id(ctx: Context, team: int, slot: int, seeked_location: int, auto_status: HintStatus) \
-        -> typing.List[Hint]:
+def collect_hint_location_id(ctx: Context, team: int, slot: int, seeked_location: int,
+                             status: HintStatus | None = HintStatus.HINT_UNSPECIFIED) -> typing.List[Hint]:
+    """
+    Collect a new hint for a given location id, with a given status (defaults to "unspecified").
+    If None is passed for the status, then an automatic status will be determined from the item's quality.
+    """
     prev_hint = ctx.get_hint(team, slot, seeked_location)
     if prev_hint:
         return [prev_hint]
@@ -1180,13 +1241,16 @@ def collect_hint_location_id(ctx: Context, team: int, slot: int, seeked_location
 
         found = seeked_location in ctx.location_checks[team, slot]
         entrance = ctx.er_hint_data.get(slot, {}).get(seeked_location, "")
-        new_status = auto_status
+
         if found:
-            new_status = HintStatus.HINT_FOUND
-        elif item_flags & ItemClassification.trap:
-            new_status = HintStatus.HINT_AVOID
-        return [Hint(receiving_player, slot, seeked_location, item_id, found, entrance, item_flags,
-                              new_status)]
+            status = HintStatus.HINT_FOUND
+        elif status is None:
+            if item_flags & ItemClassification.trap:
+                status = HintStatus.HINT_AVOID
+            else:
+                status = HintStatus.HINT_PRIORITY
+
+        return [Hint(receiving_player, slot, seeked_location, item_id, found, entrance, item_flags, status)]
     return []
 
 
@@ -1300,7 +1364,8 @@ class CommandProcessor(metaclass=CommandMeta):
                         argname += "=" + parameter.default
                 argtext += argname
                 argtext += " "
-            s += f"{self.marker}{command} {argtext}\n    {method.__doc__}\n"
+            doctext = '\n    '.join(inspect.getdoc(method).split('\n'))
+            s += f"{self.marker}{command} {argtext}\n    {doctext}\n"
         return s
 
     def _cmd_help(self):
@@ -1329,19 +1394,6 @@ class CommandProcessor(metaclass=CommandMeta):
 class CommonCommandProcessor(CommandProcessor):
     ctx: Context
 
-    def _cmd_countdown(self, seconds: str = "10") -> bool:
-        """Start a countdown in seconds"""
-        try:
-            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
-
     def _cmd_options(self):
         """List all current options. Warning: lists password."""
         self.output("Current options:")
@@ -1483,6 +1535,23 @@ class ClientMessageProcessor(CommonCommandProcessor):
                     " You can ask the server admin for a /collect")
                 return False
 
+    def _cmd_countdown(self, seconds: str = "10") -> bool:
+        """Start a countdown in seconds"""
+        if self.ctx.countdown_mode == "disabled" or \
+           self.ctx.countdown_mode == "auto" and len(self.ctx.player_names) >= 30:
+            self.output("Sorry, client countdowns have been disabled on this server. You can ask the server admin for a /countdown")
+            return False
+        try:
+            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
+
     def _cmd_remaining(self) -> bool:
         """List remaining items in your game, but not their location or recipient"""
         if self.ctx.remaining_mode == "enabled":
@@ -1610,7 +1679,6 @@ class ClientMessageProcessor(CommonCommandProcessor):
     def get_hints(self, input_text: str, for_location: bool = False) -> bool:
         points_available = get_client_points(self.ctx, self.client)
         cost = self.ctx.get_hint_cost(self.client.slot)
-        auto_status = HintStatus.HINT_UNSPECIFIED if for_location else HintStatus.HINT_PRIORITY
         if not input_text:
             hints = {hint.re_check(self.ctx, self.client.team) for hint in
                      self.ctx.hints[self.client.team, self.client.slot]}
@@ -1636,9 +1704,9 @@ class ClientMessageProcessor(CommonCommandProcessor):
                 self.output(f"Sorry, \"{hint_name}\" is marked as non-hintable.")
                 hints = []
             elif not for_location:
-                hints = collect_hints(self.ctx, self.client.team, self.client.slot, hint_id, auto_status)
+                hints = collect_hints(self.ctx, self.client.team, self.client.slot, hint_id)
             else:
-                hints = collect_hint_location_id(self.ctx, self.client.team, self.client.slot, hint_id, auto_status)
+                hints = collect_hint_location_id(self.ctx, self.client.team, self.client.slot, hint_id)
 
         else:
             game = self.ctx.games[self.client.slot]
@@ -1658,16 +1726,18 @@ class ClientMessageProcessor(CommonCommandProcessor):
                     hints = []
                     for item_name in self.ctx.item_name_groups[game][hint_name]:
                         if item_name in self.ctx.item_names_for_game(game):  # ensure item has an ID
-                            hints.extend(collect_hints(self.ctx, self.client.team, self.client.slot, item_name, auto_status))
+                            hints.extend(collect_hints(self.ctx, self.client.team, self.client.slot, item_name))
                 elif not for_location and hint_name in self.ctx.item_names_for_game(game):  # item name
-                    hints = collect_hints(self.ctx, self.client.team, self.client.slot, hint_name, auto_status)
+                    hints = collect_hints(self.ctx, self.client.team, self.client.slot, hint_name)
                 elif hint_name in self.ctx.location_name_groups[game]:  # location group name
                     hints = []
                     for loc_name in self.ctx.location_name_groups[game][hint_name]:
                         if loc_name in self.ctx.location_names_for_game(game):
-                            hints.extend(collect_hint_location_name(self.ctx, self.client.team, self.client.slot, loc_name, auto_status))
+                            hints.extend(
+                                collect_hint_location_name(self.ctx, self.client.team, self.client.slot, loc_name)
+                            )
                 else:  # location name
-                    hints = collect_hint_location_name(self.ctx, self.client.team, self.client.slot, hint_name, auto_status)
+                    hints = collect_hint_location_name(self.ctx, self.client.team, self.client.slot, hint_name)
 
             else:
                 self.output(response)
@@ -1945,8 +2015,7 @@ async def process_client_cmd(ctx: Context, client: Client, args: dict):
 
                 target_item, target_player, flags = ctx.locations[client.slot][location]
                 if create_as_hint:
-                    hints.extend(collect_hint_location_id(ctx, client.team, client.slot, location,
-                                                          HintStatus.HINT_UNSPECIFIED))
+                    hints.extend(collect_hint_location_id(ctx, client.team, client.slot, location))
                 locs.append(NetworkItem(target_item, location, target_player, flags))
             ctx.notify_hints(client.team, hints, only_new=create_as_hint == 2, persist_even_if_found=True)
             if locs and create_as_hint:
@@ -2238,6 +2307,19 @@ class ServerCommandProcessor(CommonCommandProcessor):
         self.output(f"Could not find player {player_name} to collect")
         return False
 
+    def _cmd_countdown(self, seconds: str = "10") -> bool:
+        """Start a countdown in seconds"""
+        try:
+            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
+
     @mark_raw
     def _cmd_release(self, player_name: str) -> bool:
         """Send out the remaining items from a player to their intended recipients."""
@@ -2359,9 +2441,9 @@ class ServerCommandProcessor(CommonCommandProcessor):
                     hints = []
                     for item_name_from_group in self.ctx.item_name_groups[game][item]:
                         if item_name_from_group in self.ctx.item_names_for_game(game):  # ensure item has an ID
-                            hints.extend(collect_hints(self.ctx, team, slot, item_name_from_group, HintStatus.HINT_PRIORITY))
+                            hints.extend(collect_hints(self.ctx, team, slot, item_name_from_group))
                 else:  # item name or id
-                    hints = collect_hints(self.ctx, team, slot, item, HintStatus.HINT_PRIORITY)
+                    hints = collect_hints(self.ctx, team, slot, item)
 
                 if hints:
                     self.ctx.notify_hints(team, hints)
@@ -2395,17 +2477,14 @@ class ServerCommandProcessor(CommonCommandProcessor):
 
             if usable:
                 if isinstance(location, int):
-                    hints = collect_hint_location_id(self.ctx, team, slot, location,
-                                                     HintStatus.HINT_UNSPECIFIED)
+                    hints = collect_hint_location_id(self.ctx, team, slot, location)
                 elif game in self.ctx.location_name_groups and location in self.ctx.location_name_groups[game]:
                     hints = []
                     for loc_name_from_group in self.ctx.location_name_groups[game][location]:
                         if loc_name_from_group in self.ctx.location_names_for_game(game):
-                            hints.extend(collect_hint_location_name(self.ctx, team, slot, loc_name_from_group,
-                                                                    HintStatus.HINT_UNSPECIFIED))
+                            hints.extend(collect_hint_location_name(self.ctx, team, slot, loc_name_from_group))
                 else:
-                    hints = collect_hint_location_name(self.ctx, team, slot, location,
-                                                       HintStatus.HINT_UNSPECIFIED)
+                    hints = collect_hint_location_name(self.ctx, team, slot, location)
                 if hints:
                     self.ctx.notify_hints(team, hints)
                 else:
@@ -2433,6 +2512,11 @@ class ServerCommandProcessor(CommonCommandProcessor):
         elif value_type == str and option_name.endswith("password"):
             def value_type(input_text: str):
                 return None if input_text.lower() in {"null", "none", '""', "''"} else input_text
+        elif option_name == "countdown_mode":
+            valid_values = {"enabled", "disabled", "auto"}
+            if option_value.lower() not in valid_values:
+                self.output(f"Unrecognized {option_name} value '{option_value}', known: {', '.join(valid_values)}")
+                return False
         elif value_type == str and option_name.endswith("mode"):
             valid_values = {"goal", "enabled", "disabled"}
             valid_values.update(("auto", "auto_enabled") if option_name != "remaining_mode" else [])
@@ -2520,6 +2604,13 @@ def parse_args() -> argparse.Namespace:
                              goal:     !collect can be used after goal completion
                              auto-enabled: !collect is available and automatically triggered on goal completion
                              ''')
+    parser.add_argument('--countdown_mode', default=defaults["countdown_mode"], nargs='?',
+                        choices=['enabled', 'disabled', "auto"], help='''\
+                                Select !countdown Accessibility. (default: %(default)s)
+                                enabled:  !countdown is always available
+                                disabled: !countdown is never available
+                                auto:     !countdown is available for rooms with less than 30 players
+                                ''')
     parser.add_argument('--remaining_mode', default=defaults["remaining_mode"], nargs='?',
                         choices=['enabled', 'disabled', "goal"], help='''\
                              Select !remaining Accessibility. (default: %(default)s)
@@ -2585,7 +2676,7 @@ async def main(args: argparse.Namespace):
 
     ctx = Context(args.host, args.port, args.server_password, args.password, args.location_check_points,
                   args.hint_cost, not args.disable_item_cheat, args.release_mode, args.collect_mode,
-                  args.remaining_mode,
+                  args.countdown_mode, args.remaining_mode,
                   args.auto_shutdown, args.compatibility, args.log_network)
     data_filename = args.multidata
 
@@ -2620,7 +2711,13 @@ async def main(args: argparse.Namespace):
 
     ssl_context = load_server_cert(args.cert, args.cert_key) if args.cert else None
 
-    ctx.server = websockets.serve(functools.partial(server, ctx=ctx), host=ctx.host, port=ctx.port, ssl=ssl_context)
+    ctx.server = websockets.serve(
+        functools.partial(server, ctx=ctx),
+        host=ctx.host,
+        port=ctx.port,
+        ssl=ssl_context,
+        extensions=[server_per_message_deflate_factory],
+    )
     ip = args.host if args.host else Utils.get_public_ipv4()
     logging.info('Hosting game at %s:%d (%s)' % (ip, ctx.port,
                                                  'No password' if not ctx.password else 'Password: %s' % ctx.password))

NetUtils.py

@@ -174,6 +174,8 @@ decode = JSONDecoder(object_hook=_object_hook).decode
 
 
 class Endpoint:
+    __slots__ = ("socket",)
+
     socket: "ServerConnection"
 
     def __init__(self, socket):

Options.py

@@ -688,6 +688,12 @@ class Range(NumericOption):
     range_start = 0
     range_end = 1
 
+    _RANDOM_OPTS = [
+        "random", "random-low", "random-middle", "random-high", 
+        "random-range-low-<min>-<max>", "random-range-middle-<min>-<max>",
+        "random-range-high-<min>-<max>", "random-range-<min>-<max>",
+    ]
+
     def __init__(self, value: int):
         if value < self.range_start:
             raise Exception(f"{value} is lower than minimum {self.range_start} for option {self.__class__.__name__}")
@@ -713,9 +719,26 @@ class Range(NumericOption):
             # these are the conditions where "true" and "false" make sense
             if text == "true":
                 return cls.from_any(cls.default)
-            else:  # "false"
-                return cls(0)
-        return cls(int(text))
+            # "false"
+            return cls(0)
+
+        try:
+            num = int(text)
+        except ValueError:
+            # text is not a number
+            # Handle conditionally acceptable values here rather than in the f-string
+            default = ""
+            truefalse = ""
+            if hasattr(cls, "default"):
+                default = ", default"
+                if cls.range_start == 0 and cls.default != 0:
+                    truefalse = ", \"true\", \"false\""
+            raise Exception(f"Invalid range value {text!r}. Acceptable values are: "
+                            f"<int>{default}, high, low{truefalse}, "
+                            f"{', '.join(cls._RANDOM_OPTS)}.")
+
+        return cls(num)
+
 
     @classmethod
     def weighted_range(cls, text) -> Range:
@@ -731,9 +754,7 @@ class Range(NumericOption):
             return cls(random.randint(cls.range_start, cls.range_end))
         else:
             raise Exception(f"random text \"{text}\" did not resolve to a recognized pattern. "
-                            f"Acceptable values are: random, random-high, random-middle, random-low, "
-                            f"random-range-low-<min>-<max>, random-range-middle-<min>-<max>, "
-                            f"random-range-high-<min>-<max>, or random-range-<min>-<max>.")
+                            f"Acceptable values are: {', '.join(cls._RANDOM_OPTS)}.")
 
     @classmethod
     def custom_range(cls, text) -> Range:
@@ -1018,6 +1039,8 @@ class PlandoTexts(Option[typing.List[PlandoText]], VerifyKeys):
     supports_weighting = False
     display_name = "Plando Texts"
 
+    visibility = Visibility.template | Visibility.complex_ui | Visibility.spoiler
+
     def __init__(self, value: typing.Iterable[PlandoText]) -> None:
         self.value = list(deepcopy(value))
         super().__init__()
@@ -1144,6 +1167,8 @@ class PlandoConnections(Option[typing.List[PlandoConnection]], metaclass=Connect
     entrances: typing.ClassVar[typing.AbstractSet[str]]
     exits: typing.ClassVar[typing.AbstractSet[str]]
 
+    visibility = Visibility.template | Visibility.complex_ui | Visibility.spoiler
+
     duplicate_exits: bool = False
     """Whether or not exits should be allowed to be duplicate."""
 
@@ -1380,7 +1405,7 @@ class NonLocalItems(ItemSet):
 
 
 class StartInventory(ItemDict):
-    """Start with these items."""
+    """Start with the specified amount of these items. Example: "Bomb: 1" """
     verify_item_name = True
     display_name = "Start Inventory"
     rich_text_doc = True
@@ -1388,7 +1413,7 @@ class StartInventory(ItemDict):
 
 
 class StartInventoryPool(StartInventory):
-    """Start with these items and don't place them in the world.
+    """Start with the specified amount of these items and don't place them in the world. Example: "Bomb: 1"
 
     The game decides what the replacement items will be.
     """
@@ -1435,6 +1460,7 @@ class DeathLink(Toggle):
 class ItemLinks(OptionList):
     """Share part of your item pool with other players."""
     display_name = "Item Links"
+    visibility = Visibility.template | Visibility.complex_ui | Visibility.spoiler
     rich_text_doc = True
     default = []
     schema = Schema([
@@ -1446,6 +1472,7 @@ class ItemLinks(OptionList):
             Optional("local_items"): [And(str, len)],
             Optional("non_local_items"): [And(str, len)],
             Optional("link_replacement"): Or(None, bool),
+            Optional("skip_if_solo"): Or(None, bool),
         }
     ])
 
@@ -1473,8 +1500,10 @@ class ItemLinks(OptionList):
         super(ItemLinks, self).verify(world, player_name, plando_options)
         existing_links = set()
         for link in self.value:
+            link["name"] = link["name"].strip()[:16].strip()
             if link["name"] in existing_links:
-                raise Exception(f"You cannot have more than one link named {link['name']}.")
+                raise Exception(f"Item link names are limited to their first 16 characters and must be unique. "
+                                f"You have more than one link named '{link['name']}'.")
             existing_links.add(link["name"])
 
             pool = self.verify_items(link["item_pool"], link["name"], "item_pool", world)
@@ -1516,6 +1545,7 @@ class PlandoItems(Option[typing.List[PlandoItem]]):
     default = ()
     supports_weighting = False
     display_name = "Plando Items"
+    visibility = Visibility.template | Visibility.spoiler
 
     def __init__(self, value: typing.Iterable[PlandoItem]) -> None:
         self.value = list(deepcopy(value))
@@ -1723,11 +1753,16 @@ def generate_yaml_templates(target_folder: typing.Union[str, "pathlib.Path"], ge
 
     def dictify_range(option: Range):
         data = {option.default: 50}
-        for sub_option in ["random", "random-low", "random-high"]:
+        for sub_option in ["random", "random-low", "random-high",
+                           f"random-range-{option.range_start}-{option.range_end}"]:
             if sub_option != option.default:
                 data[sub_option] = 0
-
-        notes = {}
+        notes = {
+            "random-low": "random value weighted towards lower values",
+            "random-high": "random value weighted towards higher values",
+            f"random-range-{option.range_start}-{option.range_end}": f"random value between "
+                                                                     f"{option.range_start} and {option.range_end}"
+        }
         for name, number in getattr(option, "special_range_names", {}).items():
             notes[name] = f"equivalent to {number}"
             if number in data:
@@ -1752,7 +1787,10 @@ def generate_yaml_templates(target_folder: typing.Union[str, "pathlib.Path"], ge
 
             res = template.render(
                 option_groups=option_groups,
-                __version__=__version__, game=game_name, yaml_dump=yaml_dump_scalar,
+                __version__=__version__,
+                game=game_name,
+                world_version=world.world_version.as_simple_string(),
+                yaml_dump=yaml_dump_scalar,
                 dictify_range=dictify_range,
                 cleandoc=cleandoc,
             )

OptionsCreator.py

@@ -0,0 +1,674 @@
+if __name__ == "__main__":
+    import ModuleUpdate
+
+    ModuleUpdate.update()
+
+
+from kvui import (ThemedApp, ScrollBox, MainLayout, ContainerLayout, dp, Widget, MDBoxLayout, TooltipLabel, MDLabel,
+                  ToggleButton, MarkupDropdown, ResizableTextField)
+from kivy.uix.behaviors.button import ButtonBehavior
+from kivymd.uix.behaviors import RotateBehavior
+from kivymd.uix.anchorlayout import MDAnchorLayout
+from kivymd.uix.expansionpanel import MDExpansionPanel, MDExpansionPanelContent, MDExpansionPanelHeader
+from kivymd.uix.list import MDListItem, MDListItemTrailingIcon, MDListItemSupportingText
+from kivymd.uix.slider import MDSlider
+from kivymd.uix.snackbar import MDSnackbar, MDSnackbarText
+from kivymd.uix.menu import MDDropdownMenu
+from kivymd.uix.button import MDButton, MDButtonText, MDIconButton
+from kivymd.uix.dialog import MDDialog
+from kivy.core.text.markup import MarkupLabel
+from kivy.utils import escape_markup
+from kivy.lang.builder import Builder
+from kivy.properties import ObjectProperty
+from textwrap import dedent
+from copy import deepcopy
+import Utils
+import typing
+import webbrowser
+import re
+from urllib.parse import urlparse
+from worlds.AutoWorld import AutoWorldRegister, World
+from Options import (Option, Toggle, TextChoice, Choice, FreeText, NamedRange, Range, OptionSet, OptionList, Removed,
+                     OptionCounter, Visibility)
+
+
+def validate_url(x):
+    try:
+        result = urlparse(x)
+        return all([result.scheme, result.netloc])
+    except AttributeError:
+        return False
+
+
+def filter_tooltip(tooltip):
+    if tooltip is None:
+        tooltip = "No tooltip available."
+    tooltip = dedent(tooltip).strip().replace("\n", "<br>").replace("&", "&amp;") \
+        .replace("[", "&bl;").replace("]", "&br;")
+    tooltip = re.sub(r"\*\*(.+?)\*\*", r"[b]\g<1>[/b]", tooltip)
+    tooltip = re.sub(r"\*(.+?)\*", r"[i]\g<1>[/i]", tooltip)
+    return escape_markup(tooltip)
+
+
+def option_can_be_randomized(option: typing.Type[Option]):
+    # most options can be randomized, so we should just check for those that cannot
+    if not option.supports_weighting:
+        return False
+    elif issubclass(option, FreeText) and not issubclass(option, TextChoice):
+        return False
+    return True
+
+
+def check_random(value: typing.Any):
+    if not isinstance(value, str):
+        return value  # cannot be random if evaluated
+    if value.startswith("random-"):
+        return "random"
+    return value
+
+
+class TrailingPressedIconButton(ButtonBehavior, RotateBehavior, MDListItemTrailingIcon):
+    pass
+
+
+class WorldButton(ToggleButton):
+    world_cls: typing.Type[World]
+
+
+class VisualRange(MDBoxLayout):
+    option: typing.Type[Range]
+    name: str
+    tag: MDLabel = ObjectProperty(None)
+    slider: MDSlider = ObjectProperty(None)
+
+    def __init__(self, *args, option: typing.Type[Range], name: str, **kwargs):
+        self.option = option
+        self.name = name
+        super().__init__(*args, **kwargs)
+
+        def update_points(*update_args):
+            pass
+
+        self.slider._update_points = update_points
+
+
+class VisualChoice(MDButton):
+    option: typing.Type[Choice]
+    name: str
+    text: MDButtonText = ObjectProperty(None)
+
+    def __init__(self, *args, option: typing.Type[Choice], name: str, **kwargs):
+        self.option = option
+        self.name = name
+        super().__init__(*args, **kwargs)
+
+
+class VisualNamedRange(MDBoxLayout):
+    option: typing.Type[NamedRange]
+    name: str
+    range: VisualRange = ObjectProperty(None)
+    choice: MDButton = ObjectProperty(None)
+
+    def __init__(self, *args, option: typing.Type[NamedRange], name: str, range_widget: VisualRange, **kwargs):
+        self.option = option
+        self.name = name
+        super().__init__(*args, **kwargs)
+        self.range = range_widget
+        self.add_widget(self.range)
+
+
+class VisualFreeText(ResizableTextField):
+    option: typing.Type[FreeText] | typing.Type[TextChoice]
+    name: str
+
+    def __init__(self, *args, option: typing.Type[FreeText] | typing.Type[TextChoice], name: str, **kwargs):
+        self.option = option
+        self.name = name
+        super().__init__(*args, **kwargs)
+
+
+class VisualTextChoice(MDBoxLayout):
+    option: typing.Type[TextChoice]
+    name: str
+    choice: VisualChoice = ObjectProperty(None)
+    text: VisualFreeText = ObjectProperty(None)
+
+    def __init__(self, *args, option: typing.Type[TextChoice], name: str, choice: VisualChoice,
+                 text: VisualFreeText, **kwargs):
+        self.option = option
+        self.name = name
+        super(MDBoxLayout, self).__init__(*args, **kwargs)
+        self.choice = choice
+        self.text = text
+        self.add_widget(self.choice)
+        self.add_widget(self.text)
+
+
+class VisualToggle(MDBoxLayout):
+    button: MDIconButton = ObjectProperty(None)
+    option: typing.Type[Toggle]
+    name: str
+
+    def __init__(self, *args, option: typing.Type[Toggle], name: str, **kwargs):
+        self.option = option
+        self.name = name
+        super().__init__(*args, **kwargs)
+
+
+class CounterItemValue(ResizableTextField):
+    pat = re.compile('[^0-9]')
+
+    def insert_text(self, substring, from_undo=False):
+        return super().insert_text(re.sub(self.pat, "", substring), from_undo=from_undo)
+
+
+class VisualListSetCounter(MDDialog):
+    button: MDIconButton = ObjectProperty(None)
+    option: typing.Type[OptionSet] | typing.Type[OptionList] | typing.Type[OptionCounter]
+    scrollbox: ScrollBox = ObjectProperty(None)
+    add: MDIconButton = ObjectProperty(None)
+    save: MDButton = ObjectProperty(None)
+    input: ResizableTextField = ObjectProperty(None)
+    dropdown: MDDropdownMenu
+    valid_keys: typing.Iterable[str]
+
+    def __init__(self, *args, option: typing.Type[OptionSet] | typing.Type[OptionList],
+                 name: str, valid_keys: typing.Iterable[str], **kwargs):
+        self.option = option
+        self.name = name
+        self.valid_keys = valid_keys
+        super().__init__(*args, **kwargs)
+        self.dropdown = MarkupDropdown(caller=self.input, border_margin=dp(2),
+                                       width=self.input.width, position="bottom")
+        self.input.bind(text=self.on_text)
+        self.input.bind(on_text_validate=self.validate_add)
+
+    def validate_add(self, instance):
+        if self.valid_keys:
+            if self.input.text not in self.valid_keys:
+                MDSnackbar(MDSnackbarText(text="Item must be a valid key for this option."), y=dp(24),
+                           pos_hint={"center_x": 0.5}, size_hint_x=0.5).open()
+                return
+
+        if not issubclass(self.option, OptionList):
+            if any(self.input.text == child.text.text for child in self.scrollbox.layout.children):
+                MDSnackbar(MDSnackbarText(text="This value is already in the set."), y=dp(24),
+                           pos_hint={"center_x": 0.5}, size_hint_x=0.5).open()
+                return
+
+        self.add_set_item(self.input.text)
+        self.input.set_text(self.input, "")
+
+    def remove_item(self, button: MDIconButton):
+        list_item = button.parent
+        self.scrollbox.layout.remove_widget(list_item)
+
+    def add_set_item(self, key: str, value: int | None = None):
+        text = MDListItemSupportingText(text=key, id="value")
+        if issubclass(self.option, OptionCounter):
+            value_txt = CounterItemValue(text=str(value) if value else "1")
+            item = MDListItem(text,
+                              value_txt,
+                              MDIconButton(icon="minus", on_release=self.remove_item), focus_behavior=False)
+            item.value = value_txt
+        else:
+            item = MDListItem(text, MDIconButton(icon="minus", on_release=self.remove_item), focus_behavior=False)
+        item.text = text
+        self.scrollbox.layout.add_widget(item)
+
+    def on_text(self, instance, value):
+        if not self.valid_keys:
+            return
+        if len(value) >= 3:
+            self.dropdown.items.clear()
+
+            def on_press(txt):
+                split_text = MarkupLabel(text=txt, markup=True).markup
+                self.input.set_text(self.input, "".join(text_frag for text_frag in split_text
+                                                        if not text_frag.startswith("[")))
+                self.input.focus = True
+                self.dropdown.dismiss()
+
+            lowered = value.lower()
+            for item_name in self.valid_keys:
+                try:
+                    index = item_name.lower().index(lowered)
+                except ValueError:
+                    pass  # substring not found
+                else:
+                    text = escape_markup(item_name)
+                    text = text[:index] + "[b]" + text[index:index + len(value)] + "[/b]" + text[index + len(value):]
+                    self.dropdown.items.append({
+                        "text": text,
+                        "on_release": lambda txt=text: on_press(txt),
+                        "markup": True
+                    })
+            if not self.dropdown.parent:
+                self.dropdown.open()
+        else:
+            self.dropdown.dismiss()
+
+
+class OptionsCreator(ThemedApp):
+    base_title: str = "Archipelago Options Creator"
+    container: ContainerLayout
+    main_layout: MainLayout
+    scrollbox: ScrollBox
+    main_panel: MainLayout
+    player_options: MainLayout
+    option_layout: MainLayout
+    name_input: ResizableTextField
+    game_label: MDLabel
+    current_game: str
+    options: typing.Dict[str, typing.Any]
+
+    def __init__(self):
+        self.title = self.base_title + " " + Utils.__version__
+        self.icon = r"data/icon.png"
+        self.current_game = ""
+        self.options = {}
+        super().__init__()
+
+    def export_options(self, button: Widget):
+        if 0 < len(self.name_input.text) < 17 and self.current_game:
+            file_name = Utils.save_filename("Export Options File As...", [("YAML", ["*.yaml"])],
+                                            Utils.get_file_safe_name(f"{self.name_input.text}.yaml"))
+            options = {
+                "name": self.name_input.text,
+                "description": f"YAML generated by Archipelago {Utils.__version__}.",
+                "game": self.current_game,
+                self.current_game: {k: check_random(v) for k, v in self.options.items()}
+            }
+            try:
+                with open(file_name, 'w') as f:
+                    f.write(Utils.dump(options, sort_keys=False))
+                    f.close()
+                    MDSnackbar(MDSnackbarText(text="File saved successfully."), y=dp(24), pos_hint={"center_x": 0.5},
+                               size_hint_x=0.5).open()
+            except FileNotFoundError:
+                MDSnackbar(MDSnackbarText(text="Saving cancelled."), y=dp(24), pos_hint={"center_x": 0.5},
+                           size_hint_x=0.5).open()
+        elif not self.name_input.text:
+            MDSnackbar(MDSnackbarText(text="Name must not be empty."), y=dp(24), pos_hint={"center_x": 0.5},
+                       size_hint_x=0.5).open()
+        elif not self.current_game:
+            MDSnackbar(MDSnackbarText(text="You must select a game to play."), y=dp(24), pos_hint={"center_x": 0.5},
+                       size_hint_x=0.5).open()
+        else:
+            MDSnackbar(MDSnackbarText(text="Name cannot be longer than 16 characters."), y=dp(24),
+                       pos_hint={"center_x": 0.5}, size_hint_x=0.5).open()
+
+    def create_range(self, option: typing.Type[Range], name: str):
+        def update_text(range_box: VisualRange):
+            self.options[name] = int(range_box.slider.value)
+            range_box.tag.text = str(int(range_box.slider.value))
+            return
+
+        box = VisualRange(option=option, name=name)
+        box.slider.bind(on_touch_move=lambda _, _1: update_text(box))
+        self.options[name] = option.default
+        return box
+
+    def create_named_range(self, option: typing.Type[NamedRange], name: str):
+        def set_to_custom(range_box: VisualNamedRange):
+            if (not self.options[name] == range_box.range.slider.value) \
+                    and (not self.options[name] in option.special_range_names or
+                         range_box.range.slider.value != option.special_range_names[self.options[name]]):
+                # we should validate the touch here,
+                # but this is much cheaper
+                self.options[name] = int(range_box.range.slider.value)
+                range_box.range.tag.text = str(int(range_box.range.slider.value))
+                set_button_text(range_box.choice, "Custom")
+
+        def set_button_text(button: MDButton, text: str):
+            button.text.text = text
+
+        def set_value(text: str, range_box: VisualNamedRange):
+            range_box.range.slider.value = min(max(option.special_range_names[text.lower()], option.range_start),
+                                               option.range_end)
+            range_box.range.tag.text = str(int(range_box.range.slider.value))
+            set_button_text(range_box.choice, text)
+            self.options[name] = text.lower()
+            range_box.range.slider.dropdown.dismiss()
+
+        def open_dropdown(button):
+            # for some reason this fixes an issue causing some to not open
+            box.range.slider.dropdown.open()
+
+        box = VisualNamedRange(option=option, name=name, range_widget=self.create_range(option, name))
+        if option.default in option.special_range_names:
+            # value can get mismatched in this case
+            box.range.slider.value = min(max(option.special_range_names[option.default], option.range_start),
+                                               option.range_end)
+            box.range.tag.text = str(int(box.range.slider.value))
+        box.range.slider.bind(on_touch_move=lambda _, _2: set_to_custom(box))
+        items = [
+            {
+                "text": choice.title(),
+                "on_release": lambda text=choice.title(): set_value(text, box)
+            }
+            for choice in option.special_range_names
+        ]
+        box.range.slider.dropdown = MDDropdownMenu(caller=box.choice, items=items)
+        box.choice.bind(on_release=open_dropdown)
+        self.options[name] = option.default
+        return box
+
+    def create_free_text(self, option: typing.Type[FreeText] | typing.Type[TextChoice], name: str):
+        text = VisualFreeText(option=option, name=name)
+
+        def set_value(instance):
+            self.options[name] = instance.text
+
+        text.bind(on_text_validate=set_value)
+        return text
+
+    def create_choice(self, option: typing.Type[Choice], name: str):
+        def set_button_text(button: VisualChoice, text: str):
+            button.text.text = text
+
+        def set_value(text, value):
+            set_button_text(main_button, text)
+            self.options[name] = value
+            dropdown.dismiss()
+
+        def open_dropdown(button):
+            # for some reason this fixes an issue causing some to not open
+            dropdown.open()
+
+        default_string = isinstance(option.default, str)
+        main_button = VisualChoice(option=option, name=name)
+        main_button.bind(on_release=open_dropdown)
+
+        items = [
+            {
+                "text": option.get_option_name(choice),
+                "on_release": lambda val=choice: set_value(option.get_option_name(val), option.name_lookup[val])
+            }
+            for choice in option.name_lookup
+        ]
+        dropdown = MDDropdownMenu(caller=main_button, items=items)
+        self.options[name] = option.name_lookup[option.default] if not default_string else option.default
+        return main_button
+
+    def create_text_choice(self, option: typing.Type[TextChoice], name: str):
+        def set_button_text(button: MDButton, text: str):
+            for child in button.children:
+                if isinstance(child, MDButtonText):
+                    child.text = text
+
+        box = VisualTextChoice(option=option, name=name, choice=self.create_choice(option, name),
+                               text=self.create_free_text(option, name))
+
+        def set_value(instance):
+            set_button_text(box.choice, "Custom")
+            self.options[name] = instance.text
+
+        box.text.bind(on_text_validate=set_value)
+        return box
+
+    def create_toggle(self, option: typing.Type[Toggle], name: str) -> Widget:
+        def set_value(instance: MDIconButton):
+            if instance.icon == "checkbox-outline":
+                instance.icon = "checkbox-blank-outline"
+            else:
+                instance.icon = "checkbox-outline"
+            self.options[name] = bool(not self.options[name])
+
+        self.options[name] = bool(option.default)
+        checkbox = VisualToggle(option=option, name=name)
+        checkbox.button.bind(on_release=set_value)
+
+        return checkbox
+
+    def create_popup(self, option: typing.Type[OptionList] | typing.Type[OptionSet] | typing.Type[OptionCounter],
+                     name: str, world: typing.Type[World]):
+
+        valid_keys = sorted(option.valid_keys)
+        if option.verify_item_name:
+            valid_keys += list(world.item_name_to_id.keys())
+        if option.verify_location_name:
+            valid_keys += list(world.location_name_to_id.keys())
+
+        if not issubclass(option, OptionCounter):
+            def apply_changes(button):
+                self.options[name].clear()
+                for list_item in dialog.scrollbox.layout.children:
+                    self.options[name].append(getattr(list_item.text, "text"))
+                dialog.dismiss()
+        else:
+            def apply_changes(button):
+                self.options[name].clear()
+                for list_item in dialog.scrollbox.layout.children:
+                    self.options[name][getattr(list_item.text, "text")] = int(getattr(list_item.value, "text"))
+                dialog.dismiss()
+
+        dialog = VisualListSetCounter(option=option, name=name, valid_keys=valid_keys)
+        dialog.ids.container.spacing = dp(30)
+        dialog.scrollbox.layout.theme_bg_color = "Custom"
+        dialog.scrollbox.layout.md_bg_color = self.theme_cls.surfaceContainerLowColor
+        dialog.scrollbox.layout.spacing = dp(5)
+        dialog.scrollbox.layout.padding = [0, dp(5), 0, 0]
+
+        if name not in self.options:
+            # convert from non-mutable to mutable
+            # We use list syntax even for sets, set behavior is enforced through GUI
+            if issubclass(option, OptionCounter):
+                self.options[name] = deepcopy(option.default)
+            else:
+                self.options[name] = sorted(option.default)
+
+        if issubclass(option, OptionCounter):
+            for value in sorted(self.options[name]):
+                dialog.add_set_item(value, self.options[name].get(value, None))
+        else:
+            for value in sorted(self.options[name]):
+                dialog.add_set_item(value)
+
+        dialog.save.bind(on_release=apply_changes)
+        dialog.open()
+
+    def create_option_set_list_counter(self, option: typing.Type[OptionList] | typing.Type[OptionSet] |
+                                       typing.Type[OptionCounter], name: str, world: typing.Type[World]):
+        main_button = MDButton(MDButtonText(text="Edit"), on_release=lambda x: self.create_popup(option, name, world))
+        return main_button
+
+    def create_option(self, option: typing.Type[Option], name: str, world: typing.Type[World]) -> Widget:
+        option_base = MDBoxLayout(orientation="vertical", size_hint_y=None, padding=[0, 0, dp(5), dp(5)])
+
+        tooltip = filter_tooltip(option.__doc__)
+        option_label = TooltipLabel(text=f"[ref=0|{tooltip}]{getattr(option, 'display_name', name)}")
+        label_box = MDBoxLayout(orientation="horizontal")
+        label_anchor = MDAnchorLayout(anchor_x="right", anchor_y="center")
+        label_anchor.add_widget(option_label)
+        label_box.add_widget(label_anchor)
+
+        option_base.add_widget(label_box)
+        if issubclass(option, NamedRange):
+            option_base.add_widget(self.create_named_range(option, name))
+        elif issubclass(option, Range):
+            option_base.add_widget(self.create_range(option, name))
+        elif issubclass(option, Toggle):
+            option_base.add_widget(self.create_toggle(option, name))
+        elif issubclass(option, TextChoice):
+            option_base.add_widget(self.create_text_choice(option, name))
+        elif issubclass(option, Choice):
+            option_base.add_widget(self.create_choice(option, name))
+        elif issubclass(option, FreeText):
+            option_base.add_widget(self.create_free_text(option, name))
+        elif any(issubclass(option, cls) for cls in (OptionSet, OptionList, OptionCounter)):
+            option_base.add_widget(self.create_option_set_list_counter(option, name, world))
+        else:
+            option_base.add_widget(MDLabel(text="This option isn't supported by the option creator.\n"
+                                                "Please edit your yaml manually to set this option."))
+
+        if option_can_be_randomized(option):
+            def randomize_option(instance: Widget, value: str):
+                value = value == "down"
+                if value:
+                    self.options[name] = "random-" + str(self.options[name])
+                else:
+                    self.options[name] = self.options[name].replace("random-", "")
+                    if self.options[name].isnumeric() or self.options[name] in ("True", "False"):
+                        self.options[name] = eval(self.options[name])
+
+                base_object = instance.parent.parent
+                label_object = instance.parent
+                for child in base_object.children:
+                    if child is not label_object:
+                        child.disabled = value
+
+            default_random = option.default == "random"
+            random_toggle = ToggleButton(MDButtonText(text="Random?"), size_hint_x=None, width=dp(100),
+                                         state="down" if default_random else "normal")
+            random_toggle.bind(state=randomize_option)
+            label_box.add_widget(random_toggle)
+            if default_random:
+                randomize_option(random_toggle, "down")
+
+        return option_base
+
+    def create_options_panel(self, world_button: WorldButton):
+        self.option_layout.clear_widgets()
+        self.options.clear()
+        cls: typing.Type[World] = world_button.world_cls
+
+        self.current_game = cls.game
+        if not cls.web.options_page:
+            self.current_game = "None"
+            return
+        elif isinstance(cls.web.options_page, str):
+            self.current_game = "None"
+            if validate_url(cls.web.options_page):
+                webbrowser.open(cls.web.options_page)
+                MDSnackbar(MDSnackbarText(text="Launching in default browser..."), y=dp(24), pos_hint={"center_x": 0.5},
+                           size_hint_x=0.5).open()
+                world_button.state = "normal"
+            else:
+                # attach onto archipelago.gg and see if we pass
+                new_url = "https://archipelago.gg/" + cls.web.options_page
+                if validate_url(new_url):
+                    webbrowser.open(new_url)
+                    MDSnackbar(MDSnackbarText(text="Launching in default browser..."), y=dp(24),
+                               pos_hint={"center_x": 0.5},
+                               size_hint_x=0.5).open()
+                else:
+                    MDSnackbar(MDSnackbarText(text="Invalid options page, please report to world developer."), y=dp(24),
+                               pos_hint={"center_x": 0.5},
+                               size_hint_x=0.5).open()
+                world_button.state = "normal"
+                # else just fall through
+        else:
+            expansion_box = ScrollBox()
+            expansion_box.layout.orientation = "vertical"
+            expansion_box.layout.spacing = dp(3)
+            expansion_box.scroll_type = ["bars"]
+            expansion_box.do_scroll_x = False
+            group_names = ["Game Options", *(group.name for group in cls.web.option_groups)]
+            groups = {name: [] for name in group_names}
+            for name, option in cls.options_dataclass.type_hints.items():
+                group = next((group.name for group in cls.web.option_groups if option in group.options), "Game Options")
+                groups[group].append((name, option))
+
+            for group, options in groups.items():
+                options = [(name, option) for name, option in options
+                           if name and option.visibility & Visibility.simple_ui]
+                if not options:
+                    continue  # Game Options can be empty if every other option is in another group
+                    # Can also have an option group of options that should not render on simple ui
+                group_item = MDExpansionPanel(size_hint_y=None)
+                group_header = MDExpansionPanelHeader(MDListItem(MDListItemSupportingText(text=group),
+                                                                 TrailingPressedIconButton(icon="chevron-right",
+                                                                                           on_release=lambda x,
+                                                                                           item=group_item:
+                                                                                           self.tap_expansion_chevron(
+                                                                                               item, x)),
+                                                                 md_bg_color=self.theme_cls.surfaceContainerLowestColor,
+                                                                 theme_bg_color="Custom",
+                                                                 on_release=lambda x, item=group_item:
+                                                                 self.tap_expansion_chevron(item, x)))
+                group_content = MDExpansionPanelContent(orientation="vertical", theme_bg_color="Custom",
+                                                        md_bg_color=self.theme_cls.surfaceContainerLowestColor,
+                                                        padding=[dp(12), dp(100), dp(12), 0],
+                                                        spacing=dp(3))
+                group_item.add_widget(group_header)
+                group_item.add_widget(group_content)
+                group_box = ScrollBox()
+                group_box.layout.orientation = "vertical"
+                group_box.layout.spacing = dp(3)
+                for name, option in options:
+                    group_content.add_widget(self.create_option(option, name, cls))
+                expansion_box.layout.add_widget(group_item)
+            self.option_layout.add_widget(expansion_box)
+        self.game_label.text = f"Game: {self.current_game}"
+
+    @staticmethod
+    def tap_expansion_chevron(panel: MDExpansionPanel, chevron: TrailingPressedIconButton | MDListItem):
+        if isinstance(chevron, MDListItem):
+            chevron = next((child for child in chevron.ids.trailing_container.children
+                            if isinstance(child, TrailingPressedIconButton)), None)
+        panel.open() if not panel.is_open else panel.close()
+        if chevron:
+            panel.set_chevron_down(
+                chevron
+            ) if not panel.is_open else panel.set_chevron_up(chevron)
+
+    def build(self):
+        self.set_colors()
+        self.options = {}
+        self.container = Builder.load_file(Utils.local_path("data/optionscreator.kv"))
+        self.root = self.container
+        self.main_layout = self.container.ids.main
+        self.scrollbox = self.container.ids.scrollbox
+
+        def world_button_action(world_btn: WorldButton):
+            if self.current_game != world_btn.world_cls.game:
+                old_button = next((button for button in self.scrollbox.layout.children
+                                   if button.world_cls.game == self.current_game), None)
+                if old_button:
+                    old_button.state = "normal"
+            else:
+                world_btn.state = "down"
+            self.create_options_panel(world_btn)
+
+        for world, cls in sorted(AutoWorldRegister.world_types.items(), key=lambda x: x[0]):
+            if world == "Archipelago":
+                continue
+            world_text = MDButtonText(text=world, size_hint_y=None, width=dp(150),
+                                      pos_hint={"x": 0.03, "center_y": 0.5})
+            world_text.text_size = (world_text.width, None)
+            world_text.bind(width=lambda *x, text=world_text: text.setter('text_size')(text, (text.width, None)),
+                            texture_size=lambda *x, text=world_text: text.setter("height")(text,
+                                                                                           world_text.texture_size[1]))
+            world_button = WorldButton(world_text, size_hint_x=None, width=dp(150), theme_width="Custom",
+                                       radius=(dp(5), dp(5), dp(5), dp(5)))
+            world_button.bind(on_release=world_button_action)
+            world_button.world_cls = cls
+            self.scrollbox.layout.add_widget(world_button)
+        self.main_panel = self.container.ids.player_layout
+        self.player_options = self.container.ids.player_options
+        self.game_label = self.container.ids.game
+        self.name_input = self.container.ids.player_name
+        self.option_layout = self.container.ids.options
+
+        def set_height(instance, value):
+            instance.height = value[1]
+
+        self.game_label.bind(texture_size=set_height)
+
+        # Uncomment to re-enable the Kivy console/live editor
+        # Ctrl-E to enable it, make sure numlock/capslock is disabled
+        # from kivy.modules.console import create_console
+        # from kivy.core.window import Window
+        # create_console(Window, self.container)
+
+        return self.container
+
+
+def launch():
+    OptionsCreator().run()
+
+
+if __name__ == "__main__":
+    Utils.init_logging("OptionsCreator")
+    launch()

README.md

@@ -82,6 +82,7 @@ Currently, the following games are supported:
 * Paint
 * Celeste (Open World)
 * Choo-Choo Charles
+* APQuest
 
 For setup and instructions check out our [tutorials page](https://archipelago.gg/tutorial/).
 Downloads can be found at [Releases](https://github.com/ArchipelagoMW/Archipelago/releases), including compiled

SNIClient.py

@@ -18,7 +18,7 @@ from json import loads, dumps
 from CommonClient import CommonContext, server_loop, ClientCommandProcessor, gui_enabled, get_base_parser
 
 import Utils
-from settings import Settings
+import settings
 from Utils import async_start
 from MultiServer import mark_raw
 if typing.TYPE_CHECKING:
@@ -286,7 +286,7 @@ class SNESState(enum.IntEnum):
 
 
 def launch_sni() -> None:
-    sni_path = Settings.sni_options.sni_path
+    sni_path = settings.get_settings().sni_options.sni_path
 
     if not os.path.isdir(sni_path):
         sni_path = Utils.local_path(sni_path)
@@ -669,7 +669,7 @@ async def game_watcher(ctx: SNIContext) -> None:
 
 
 async def run_game(romfile: str) -> None:
-    auto_start = Settings.sni_options.snes_rom_start
+    auto_start = settings.get_settings().sni_options.snes_rom_start
     if auto_start is True:
         import webbrowser
         webbrowser.open(romfile)

Utils.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import asyncio
+import concurrent.futures
 import json
 import typing
 import builtins
@@ -35,7 +36,7 @@ if typing.TYPE_CHECKING:
 
 
 def tuplize_version(version: str) -> Version:
-    return Version(*(int(piece, 10) for piece in version.split(".")))
+    return Version(*(int(piece) for piece in version.split(".")))
 
 
 class Version(typing.NamedTuple):
@@ -47,7 +48,7 @@ class Version(typing.NamedTuple):
         return ".".join(str(item) for item in self)
 
 
-__version__ = "0.6.4"
+__version__ = "0.6.6"
 version_tuple = tuplize_version(__version__)
 
 is_linux = sys.platform.startswith("linux")
@@ -313,20 +314,18 @@ def get_public_ipv6() -> str:
     return ip
 
 
-OptionsType = Settings  # TODO: remove when removing get_options
-
-
 def get_options() -> Settings:
-    # TODO: switch to Utils.deprecate after 0.4.4
-    warnings.warn("Utils.get_options() is deprecated. Use the settings API instead.", DeprecationWarning)
+    deprecate("Utils.get_options() is deprecated. Use the settings API instead.")
     return get_settings()
 
 
-def persistent_store(category: str, key: str, value: typing.Any):
-    path = user_path("_persistent_storage.yaml")
+def persistent_store(category: str, key: str, value: typing.Any, force_store: bool = False):
     storage = persistent_load()
+    if not force_store and category in storage and key in storage[category] and storage[category][key] == value:
+        return  # no changes necessary
     category_dict = storage.setdefault(category, {})
     category_dict[key] = value
+    path = user_path("_persistent_storage.yaml")
     with open(path, "wt") as f:
         f.write(dump(storage, Dumper=Dumper))
 
@@ -475,7 +474,7 @@ class RestrictedUnpickler(pickle.Unpickler):
                 mod = importlib.import_module(module)
             obj = getattr(mod, name)
             if issubclass(obj, (self.options_module.Option, self.options_module.PlandoConnection,
-                                self.options_module.PlandoText)):
+                                self.options_module.PlandoItem, self.options_module.PlandoText)):
                 return obj
         # Forbid everything else.
         raise pickle.UnpicklingError(f"global '{module}.{name}' is forbidden")
@@ -718,13 +717,22 @@ def get_intended_text(input_text: str, possible_answers) -> typing.Tuple[str, bo
 
 
 def get_input_text_from_response(text: str, command: str) -> typing.Optional[str]:
+    """
+    Parses the response text from `get_intended_text` to find the suggested input and autocomplete the command in
+    arguments with it.
+
+    :param text: The response text from `get_intended_text`.
+    :param command: The command to which the input text should be added. Must contain the prefix used by the command
+                    (`!` or `/`).
+    :return: The command with the suggested input text appended, or None if no suggestion was found.
+    """
     if "did you mean " in text:
         for question in ("Didn't find something that closely matches",
                          "Too many close matches"):
             if text.startswith(question):
                 name = get_text_between(text, "did you mean '",
                                         "'? (")
-                return f"!{command} {name}"
+                return f"{command} {name}"
     elif text.startswith("Missing: "):
         return text.replace("Missing: ", "!hint_location ")
     return None
@@ -743,6 +751,11 @@ def _mp_open_filename(res: "multiprocessing.Queue[typing.Optional[str]]", *args:
     res.put(open_filename(*args))
 
 
+def _mp_save_filename(res: "multiprocessing.Queue[typing.Optional[str]]", *args: Any) -> None:
+    if is_kivy_running():
+        raise RuntimeError("kivy should not be running in multiprocess")
+    res.put(save_filename(*args))
+    
 def _run_for_stdout(*args: str):
     env = os.environ
     if "LD_LIBRARY_PATH" in env:
@@ -793,6 +806,51 @@ def open_filename(title: str, filetypes: typing.Iterable[typing.Tuple[str, typin
                                                   initialfile=suggest or None)
 
 
+def save_filename(title: str, filetypes: typing.Iterable[typing.Tuple[str, typing.Iterable[str]]], suggest: str = "") \
+        -> typing.Optional[str]:
+    logging.info(f"Opening file save dialog for {title}.")
+
+    def run(*args: str):
+        return subprocess.run(args, capture_output=True, text=True).stdout.split("\n", 1)[0] or None
+
+    if is_linux:
+        # prefer native dialog
+        from shutil import which
+        kdialog = which("kdialog")
+        if kdialog:
+            k_filters = '|'.join((f'{text} (*{" *".join(ext)})' for (text, ext) in filetypes))
+            return run(kdialog, f"--title={title}", "--getsavefilename", suggest or ".", k_filters)
+        zenity = which("zenity")
+        if zenity:
+            z_filters = (f'--file-filter={text} ({", ".join(ext)}) | *{" *".join(ext)}' for (text, ext) in filetypes)
+            selection = (f"--filename={suggest}",) if suggest else ()
+            return run(zenity, f"--title={title}", "--file-selection", "--save", *z_filters, *selection)
+
+    # fall back to tk
+    try:
+        import tkinter
+        import tkinter.filedialog
+    except Exception as e:
+        logging.error('Could not load tkinter, which is likely not installed. '
+                      f'This attempt was made because save_filename was used for "{title}".')
+        raise e
+    else:
+        if is_macos and is_kivy_running():
+            # on macOS, mixing kivy and tk does not work, so spawn a new process
+            # FIXME: performance of this is pretty bad, and we should (also) look into alternatives
+            from multiprocessing import Process, Queue
+            res: "Queue[typing.Optional[str]]" = Queue()
+            Process(target=_mp_save_filename, args=(res, title, filetypes, suggest)).start()
+            return res.get()
+        try:
+            root = tkinter.Tk()
+        except tkinter.TclError:
+            return None  # GUI not available. None is the same as a user clicking "cancel"
+        root.withdraw()
+        return tkinter.filedialog.asksaveasfilename(title=title, filetypes=((t[0], ' '.join(t[1])) for t in filetypes),
+                                                    initialfile=suggest or None)
+
+
 def _mp_open_directory(res: "multiprocessing.Queue[typing.Optional[str]]", *args: Any) -> None:
     if is_kivy_running():
         raise RuntimeError("kivy should not be running in multiprocess")
@@ -1127,3 +1185,40 @@ def is_iterable_except_str(obj: object) -> TypeGuard[typing.Iterable[typing.Any]
     if isinstance(obj, str):
         return False
     return isinstance(obj, typing.Iterable)
+
+
+class DaemonThreadPoolExecutor(concurrent.futures.ThreadPoolExecutor):
+    """
+    ThreadPoolExecutor that uses daemonic threads that do not keep the program alive.
+    NOTE: use this with caution because killed threads will not properly clean up.
+    """
+
+    def _adjust_thread_count(self):
+        # see upstream ThreadPoolExecutor for details
+        import threading
+        import weakref
+        from concurrent.futures.thread import _worker
+
+        if self._idle_semaphore.acquire(timeout=0):
+            return
+
+        def weakref_cb(_, q=self._work_queue):
+            q.put(None)
+
+        num_threads = len(self._threads)
+        if num_threads < self._max_workers:
+            thread_name = f"{self._thread_name_prefix or self}_{num_threads}"
+            t = threading.Thread(
+                name=thread_name,
+                target=_worker,
+                args=(
+                    weakref.ref(self, weakref_cb),
+                    self._work_queue,
+                    self._initializer,
+                    self._initargs,
+                ),
+                daemon=True,
+            )
+            t.start()
+            self._threads.add(t)
+            # NOTE: don't add to _threads_queues so we don't block on shutdown

WebHost.py

@@ -109,6 +109,13 @@ if __name__ == "__main__":
         logging.exception(e)
         logging.warning("Could not update LttP sprites.")
     app = get_app()
+    from worlds import AutoWorldRegister
+    # Update to only valid WebHost worlds
+    invalid_worlds = {name for name, world in AutoWorldRegister.world_types.items()
+                      if not hasattr(world.web, "tutorials")}
+    if invalid_worlds:
+        logging.error(f"Following worlds not loaded as they are invalid for WebHost: {invalid_worlds}")
+    AutoWorldRegister.world_types = {k: v for k, v in AutoWorldRegister.world_types.items() if k not in invalid_worlds}
     create_options_files()
     copy_tutorials_files_to_static()
     if app.config["SELFLAUNCH"]:

WebHostLib/__init__.py

@@ -1,6 +1,7 @@
 import base64
 import os
 import socket
+import typing
 import uuid
 
 from flask import Flask
@@ -61,20 +62,21 @@ cache = Cache()
 Compress(app)
 
 
-def to_python(value):
+def to_python(value: str) -> uuid.UUID:
     return uuid.UUID(bytes=base64.urlsafe_b64decode(value + '=='))
 
 
-def to_url(value):
+def to_url(value: uuid.UUID) -> str:
     return base64.urlsafe_b64encode(value.bytes).rstrip(b'=').decode('ascii')
 
 
 class B64UUIDConverter(BaseConverter):
 
-    def to_python(self, value):
+    def to_python(self, value: str) -> uuid.UUID:
         return to_python(value)
 
-    def to_url(self, value):
+    def to_url(self, value: typing.Any) -> str:
+        assert isinstance(value, uuid.UUID)
         return to_url(value)
 
 
@@ -84,7 +86,7 @@ app.jinja_env.filters["suuid"] = to_url
 app.jinja_env.filters["title_sorted"] = title_sorted
 
 
-def register():
+def register() -> None:
     """Import submodules, triggering their registering on flask routing.
     Note: initializes worlds subsystem."""
     import importlib

WebHostLib/api/tracker.py

@@ -11,6 +11,59 @@ from WebHostLib.models import Room
 from WebHostLib.tracker import TrackerData
 
 
+class PlayerAlias(TypedDict):
+    team: int
+    player: int
+    alias: str | None
+
+
+class PlayerItemsReceived(TypedDict):
+    team: int
+    player: int
+    items: list[NetworkItem]
+
+
+class PlayerChecksDone(TypedDict):
+    team: int
+    player: int
+    locations: list[int]
+
+
+class TeamTotalChecks(TypedDict):
+    team: int
+    checks_done: int
+
+
+class PlayerHints(TypedDict):
+    team: int
+    player: int
+    hints: list[Hint]
+
+
+class PlayerTimer(TypedDict):
+    team: int
+    player: int
+    time: datetime | None
+
+
+class PlayerStatus(TypedDict):
+    team: int
+    player: int
+    status: ClientStatus
+
+
+class PlayerLocationsTotal(TypedDict):
+    team: int
+    player: int
+    total_locations: int
+
+
+class PlayerGame(TypedDict):
+    team: int
+    player: int
+    game: str
+
+
 @api_endpoints.route("/tracker/<suuid:tracker>")
 @cache.memoize(timeout=60)
 def tracker_data(tracker: UUID) -> dict[str, Any]:
@@ -29,122 +82,80 @@ def tracker_data(tracker: UUID) -> dict[str, Any]:
 
     all_players: dict[int, list[int]] = tracker_data.get_all_players()
 
-    class PlayerAlias(TypedDict):
-        player: int
-        name: str | None
-
-    player_aliases: list[dict[str, int | list[PlayerAlias]]] = []
+    player_aliases: list[PlayerAlias] = []
     """Slot aliases of all players."""
     for team, players in all_players.items():
-        team_player_aliases: list[PlayerAlias] = []
-        team_aliases = {"team": team, "players": team_player_aliases}
-        player_aliases.append(team_aliases)
         for player in players:
-            team_player_aliases.append({"player": player, "alias": tracker_data.get_player_alias(team, player)})
+            player_aliases.append(
+                {"team": team, "player": player, "alias": tracker_data.get_player_alias(team, player)})
 
-    class PlayerItemsReceived(TypedDict):
-        player: int
-        items: list[NetworkItem]
-
-    player_items_received: list[dict[str, int | list[PlayerItemsReceived]]] = []
+    player_items_received: list[PlayerItemsReceived] = []
     """Items received by each player."""
     for team, players in all_players.items():
-        player_received_items: list[PlayerItemsReceived] = []
-        team_items_received = {"team": team, "players": player_received_items}
-        player_items_received.append(team_items_received)
         for player in players:
-            player_received_items.append(
-                {"player": player, "items": tracker_data.get_player_received_items(team, player)})
+            player_items_received.append(
+                {"team": team, "player": player, "items": tracker_data.get_player_received_items(team, player)})
 
-    class PlayerChecksDone(TypedDict):
-        player: int
-        locations: list[int]
-
-    player_checks_done: list[dict[str, int | list[PlayerChecksDone]]] = []
+    player_checks_done: list[PlayerChecksDone] = []
     """ID of all locations checked by each player."""
     for team, players in all_players.items():
-        per_player_checks: list[PlayerChecksDone] = []
-        team_checks_done = {"team": team, "players": per_player_checks}
-        player_checks_done.append(team_checks_done)
         for player in players:
-            per_player_checks.append(
-                {"player": player, "locations": sorted(tracker_data.get_player_checked_locations(team, player))})
+            player_checks_done.append(
+                {"team": team, "player": player,
+                 "locations": sorted(tracker_data.get_player_checked_locations(team, player))})
 
-    total_checks_done: list[dict[str, int]] = [
+    total_checks_done: list[TeamTotalChecks] = [
         {"team": team, "checks_done": checks_done}
         for team, checks_done in tracker_data.get_team_locations_checked_count().items()
     ]
     """Total number of locations checked for the entire multiworld per team."""
 
-    class PlayerHints(TypedDict):
-        player: int
-        hints: list[Hint]
-
-    hints: list[dict[str, int | list[PlayerHints]]] = []
+    hints: list[PlayerHints] = []
     """Hints that all players have used or received."""
     for team, players in tracker_data.get_all_slots().items():
-        per_player_hints: list[PlayerHints] = []
-        team_hints = {"team": team, "players": per_player_hints}
-        hints.append(team_hints)
         for player in players:
             player_hints = sorted(tracker_data.get_player_hints(team, player))
-            per_player_hints.append({"player": player, "hints": player_hints})
-            slot_info = tracker_data.get_slot_info(team, player)
+            hints.append({"team": team, "player": player, "hints": player_hints})
+            slot_info = tracker_data.get_slot_info(player)
             # this assumes groups are always after players
             if slot_info.type != SlotType.group:
                 continue
             for member in slot_info.group_members:
-                team_hints[member]["hints"] += player_hints
+                hints[member - 1]["hints"] += player_hints
 
-    class PlayerTimer(TypedDict):
-        player: int
-        time: datetime | None
-
-    activity_timers: list[dict[str, int | list[PlayerTimer]]] = []
+    activity_timers: list[PlayerTimer] = []
     """Time of last activity per player. Returned as RFC 1123 format and null if no connection has been made."""
     for team, players in all_players.items():
-        player_timers: list[PlayerTimer] = []
-        team_timers = {"team": team, "players": player_timers}
-        activity_timers.append(team_timers)
         for player in players:
-            player_timers.append({"player": player, "time": None})
+            activity_timers.append({"team": team, "player": player, "time": None})
 
-    client_activity_timers: tuple[tuple[int, int], float] = tracker_data._multisave.get("client_activity_timers", ())
-    for (team, player), timestamp in client_activity_timers:
-        # use index since we can rely on order
-        # FIX: key is "players" (not "player_timers")
-        activity_timers[team]["players"][player - 1]["time"] = datetime.fromtimestamp(timestamp, timezone.utc)
+    for (team, player), timestamp in tracker_data._multisave.get("client_activity_timers", []):
+        for entry in activity_timers:
+            if entry["team"] == team and entry["player"] == player:
+                entry["time"] = datetime.fromtimestamp(timestamp, timezone.utc)
+                break
 
-
-    connection_timers: list[dict[str, int | list[PlayerTimer]]] = []
+    connection_timers: list[PlayerTimer] = []
     """Time of last connection per player. Returned as RFC 1123 format and null if no connection has been made."""
     for team, players in all_players.items():
-        player_timers: list[PlayerTimer] = []
-        team_connection_timers = {"team": team, "players": player_timers}
-        connection_timers.append(team_connection_timers)
         for player in players:
-            player_timers.append({"player": player, "time": None})
+            connection_timers.append({"team": team, "player": player, "time": None})
 
-    client_connection_timers: tuple[tuple[int, int], float] = tracker_data._multisave.get(
-        "client_connection_timers", ())
-    for (team, player), timestamp in client_connection_timers:
-        connection_timers[team]["players"][player - 1]["time"] = datetime.fromtimestamp(timestamp, timezone.utc)
+    for (team, player), timestamp in tracker_data._multisave.get("client_connection_timers", []):
+        # find the matching entry
+        for entry in connection_timers:
+            if entry["team"] == team and entry["player"] == player:
+                entry["time"] = datetime.fromtimestamp(timestamp, timezone.utc)
+                break
 
-    class PlayerStatus(TypedDict):
-        player: int
-        status: ClientStatus
-
-    player_status: list[dict[str, int | list[PlayerStatus]]] = []
+    player_status: list[PlayerStatus] = []
     """The current client status for each player."""
     for team, players in all_players.items():
-        player_statuses: list[PlayerStatus] = []
-        team_status = {"team": team, "players": player_statuses}
-        player_status.append(team_status)
         for player in players:
-            player_statuses.append({"player": player, "status": tracker_data.get_player_client_status(team, player)})
+            player_status.append(
+                {"team": team, "player": player, "status": tracker_data.get_player_client_status(team, player)})
 
     return {
-        **get_static_tracker_data(room),
         "aliases": player_aliases,
         "player_items_received": player_items_received,
         "player_checks_done": player_checks_done,
@@ -153,80 +164,95 @@ def tracker_data(tracker: UUID) -> dict[str, Any]:
         "activity_timers": activity_timers,
         "connection_timers": connection_timers,
         "player_status": player_status,
-        "datapackage": tracker_data._multidata["datapackage"],
     }
 
-@cache.memoize()
-def get_static_tracker_data(room: Room) -> dict[str, Any]:
-    """
-    Builds and caches the static data for this active session tracker, so that it doesn't need to be recalculated.
-    """
 
+class PlayerGroups(TypedDict):
+    slot: int
+    name: str
+    members: list[int]
+
+
+class PlayerSlotData(TypedDict):
+    player: int
+    slot_data: dict[str, Any]
+
+
+@api_endpoints.route("/static_tracker/<suuid:tracker>")
+@cache.memoize(timeout=300)
+def static_tracker_data(tracker: UUID) -> dict[str, Any]:
+    """
+    Outputs json data to <root_path>/api/static_tracker/<id of current session tracker>.
+
+    :param tracker: UUID of current session tracker.
+
+    :return: Static tracking data for all players in the room. Typing and docstrings describe the format of each value.
+    """
+    room: Room | None = Room.get(tracker=tracker)
+    if not room:
+        abort(404)
     tracker_data = TrackerData(room)
 
     all_players: dict[int, list[int]] = tracker_data.get_all_players()
 
-    class PlayerGroups(TypedDict):
-        slot: int
-        name: str
-        members: list[int]
-
-    groups: list[dict[str, int | list[PlayerGroups]]] = []
+    groups: list[PlayerGroups] = []
     """The Slot ID of groups and the IDs of the group's members."""
     for team, players in tracker_data.get_all_slots().items():
-        groups_in_team: list[PlayerGroups] = []
-        team_groups = {"team": team, "groups": groups_in_team}
-        groups.append(team_groups)
         for player in players:
-            slot_info = tracker_data.get_slot_info(team, player)
+            slot_info = tracker_data.get_slot_info(player)
             if slot_info.type != SlotType.group or not slot_info.group_members:
                 continue
-            groups_in_team.append(
+            groups.append(
                 {
                     "slot": player,
                     "name": slot_info.name,
                     "members": list(slot_info.group_members),
                 })
-    class PlayerName(TypedDict):
-        player: int
-        name: str
+        break
 
-    player_names: list[dict[str, str | list[PlayerName]]] = []
-    """Slot names of all players."""
+    player_locations_total: list[PlayerLocationsTotal] = []
     for team, players in all_players.items():
-        per_team_player_names: list[PlayerName] = []
-        team_names = {"team": team, "players": per_team_player_names}
-        player_names.append(team_names)
         for player in players:
-            per_team_player_names.append({"player": player, "name": tracker_data.get_player_name(team, player)})
+            player_locations_total.append(
+                {"team": team, "player": player, "total_locations": len(tracker_data.get_player_locations(player))})
 
-    class PlayerGame(TypedDict):
-        player: int
-        game: str
-
-    games: list[dict[str, int | list[PlayerGame]]] = []
-    """The game each player is playing."""
+    player_game: list[PlayerGame] = []
+    """The played game per player slot."""
     for team, players in all_players.items():
-        player_games: list[PlayerGame] = []
-        team_games = {"team": team, "players": player_games}
-        games.append(team_games)
         for player in players:
-            player_games.append({"player": player, "game": tracker_data.get_player_game(team, player)})
-
-    class PlayerSlotData(TypedDict):
-        player: int
-        slot_data: dict[str, Any]
-
-    slot_data: list[dict[str, int | list[PlayerSlotData]]] = []
-    """Slot data for each player."""
-    for team, players in all_players.items():
-        player_slot_data: list[PlayerSlotData] = []
-        team_slot_data = {"team": team, "players": player_slot_data}
-        slot_data.append(team_slot_data)
-        for player in players:
-            player_slot_data.append({"player": player, "slot_data": tracker_data.get_slot_data(team, player)})
+            player_game.append({"team": team, "player": player, "game": tracker_data.get_player_game(player)})
 
     return {
         "groups": groups,
-        "slot_data": slot_data,
+        "datapackage": tracker_data._multidata["datapackage"],
+        "player_locations_total": player_locations_total,
+        "player_game": player_game,
     }
+
+
+# It should be exceedingly rare that slot data is needed, so it's separated out.
+@api_endpoints.route("/slot_data_tracker/<suuid:tracker>")
+@cache.memoize(timeout=300)
+def tracker_slot_data(tracker: UUID) -> list[PlayerSlotData]:
+    """
+    Outputs json data to <root_path>/api/slot_data_tracker/<id of current session tracker>.
+
+    :param tracker: UUID of current session tracker.
+
+    :return: Slot data for all players in the room. Typing completely arbitrary per game.
+    """
+    room: Room | None = Room.get(tracker=tracker)
+    if not room:
+        abort(404)
+    tracker_data = TrackerData(room)
+
+    all_players: dict[int, list[int]] = tracker_data.get_all_players()
+
+    slot_data: list[PlayerSlotData] = []
+    """Slot data for each player."""
+    for team, players in all_players.items():
+        for player in players:
+            slot_data.append({"player": player, "slot_data": tracker_data.get_slot_data(player)})
+        break
+
+    return slot_data

WebHostLib/autolauncher.py

@@ -17,7 +17,7 @@ from .locker import Locker, AlreadyRunningException
 _stop_event = Event()
 
 
-def stop():
+def stop() -> None:
     """Stops previously launched threads"""
     global _stop_event
     stop_event = _stop_event
@@ -36,25 +36,39 @@ def handle_generation_failure(result: BaseException):
         logging.exception(e)
 
 
-def _mp_gen_game(gen_options: dict, meta: dict[str, Any] | None = None, owner=None, sid=None) -> PrimaryKey | None:
+def _mp_gen_game(
+    gen_options: dict,
+    meta: dict[str, Any] | None = None,
+    owner=None,
+    sid=None,
+    timeout: int|None = None,
+) -> PrimaryKey | None:
     from setproctitle import setproctitle
 
     setproctitle(f"Generator ({sid})")
-    res = gen_game(gen_options, meta=meta, owner=owner, sid=sid)
-    setproctitle(f"Generator (idle)")
-    return res
+    try:
+        return gen_game(gen_options, meta=meta, owner=owner, sid=sid, timeout=timeout)
+    finally:
+        setproctitle(f"Generator (idle)")
 
 
-def launch_generator(pool: multiprocessing.pool.Pool, generation: Generation):
+def launch_generator(pool: multiprocessing.pool.Pool, generation: Generation, timeout: int|None) -> None:
     try:
         meta = json.loads(generation.meta)
         options = restricted_loads(generation.options)
         logging.info(f"Generating {generation.id} for {len(options)} players")
-        pool.apply_async(_mp_gen_game, (options,),
-                         {"meta": meta,
-                          "sid": generation.id,
-                          "owner": generation.owner},
-                         handle_generation_success, handle_generation_failure)
+        pool.apply_async(
+            _mp_gen_game,
+            (options,),
+            {
+                "meta": meta,
+                "sid": generation.id,
+                "owner": generation.owner,
+                "timeout": timeout,
+            },
+            handle_generation_success,
+            handle_generation_failure,
+        )
     except Exception as e:
         generation.state = STATE_ERROR
         commit()
@@ -135,6 +149,7 @@ def autogen(config: dict):
 
                 with multiprocessing.Pool(config["GENERATORS"], initializer=init_generator,
                                           initargs=(config,), maxtasksperchild=10) as generator_pool:
+                    job_time = config["JOB_TIME"]
                     with db_session:
                         to_start = select(generation for generation in Generation if generation.state == STATE_STARTED)
 
@@ -145,7 +160,7 @@ def autogen(config: dict):
                                 if sid:
                                     generation.delete()
                                 else:
-                                    launch_generator(generator_pool, generation)
+                                    launch_generator(generator_pool, generation, timeout=job_time)
 
                             commit()
                         select(generation for generation in Generation if generation.state == STATE_ERROR).delete()
@@ -157,7 +172,7 @@ def autogen(config: dict):
                                 generation for generation in Generation
                                 if generation.state == STATE_QUEUED).for_update()
                             for generation in to_start:
-                                launch_generator(generator_pool, generation)
+                                launch_generator(generator_pool, generation, timeout=job_time)
         except AlreadyRunningException:
             logging.info("Autogen reports as already running, not starting another.")
 

WebHostLib/customserver.py

@@ -19,7 +19,10 @@ from pony.orm import commit, db_session, select
 
 import Utils
 
-from MultiServer import Context, server, auto_shutdown, ServerCommandProcessor, ClientMessageProcessor, load_server_cert
+from MultiServer import (
+    Context, server, auto_shutdown, ServerCommandProcessor, ClientMessageProcessor, load_server_cert,
+    server_per_message_deflate_factory,
+)
 from Utils import restricted_loads, cache_argsless
 from .locker import Locker
 from .models import Command, GameDataPackage, Room, db
@@ -97,6 +100,7 @@ class WebHostContext(Context):
                         self.main_loop.call_soon_threadsafe(cmdprocessor, command.commandtext)
                         command.delete()
                     commit()
+            del commands
             time.sleep(5)
 
     @db_session
@@ -146,13 +150,13 @@ class WebHostContext(Context):
             self.location_name_groups = static_location_name_groups
         return self._load(multidata, game_data_packages, True)
 
-    @db_session
     def init_save(self, enabled: bool = True):
         self.saving = enabled
         if self.saving:
-            savegame_data = Room.get(id=self.room_id).multisave
-            if savegame_data:
-                self.set_save(restricted_loads(Room.get(id=self.room_id).multisave))
+            with db_session:
+                savegame_data = Room.get(id=self.room_id).multisave
+                if savegame_data:
+                    self.set_save(restricted_loads(Room.get(id=self.room_id).multisave))
             self._start_async_saving(atexit_save=False)
         threading.Thread(target=self.listen_to_db_commands, daemon=True).start()
 
@@ -282,8 +286,12 @@ def run_server_process(name: str, ponyconfig: dict, static_server_data: dict,
                 assert ctx.server is None
                 try:
                     ctx.server = websockets.serve(
-                        functools.partial(server, ctx=ctx), ctx.host, ctx.port, ssl=get_ssl_context())
-
+                        functools.partial(server, ctx=ctx),
+                        ctx.host,
+                        ctx.port,
+                        ssl=get_ssl_context(),
+                        extensions=[server_per_message_deflate_factory],
+                    )
                     await ctx.server
                 except OSError:  # likely port in use
                     ctx.server = websockets.serve(
@@ -304,6 +312,7 @@ def run_server_process(name: str, ponyconfig: dict, static_server_data: dict,
                     with db_session:
                         room = Room.get(id=ctx.room_id)
                         room.last_port = port
+                    del room
                 else:
                     ctx.logger.exception("Could not determine port. Likely hosting failure.")
                 with db_session:
@@ -322,6 +331,7 @@ def run_server_process(name: str, ponyconfig: dict, static_server_data: dict,
                 with db_session:
                     room = Room.get(id=room_id)
                     room.last_port = -1
+                del room
                 logger.exception(e)
                 raise
             else:
@@ -333,11 +343,12 @@ def run_server_process(name: str, ponyconfig: dict, static_server_data: dict,
                     ctx.save_dirty = False  # make sure the saving thread does not write to DB after final wakeup
                     ctx.exit_event.set()  # make sure the saving thread stops at some point
                     # NOTE: async saving should probably be an async task and could be merged with shutdown_task
-                    with (db_session):
+                    with db_session:
                         # ensure the Room does not spin up again on its own, minute of safety buffer
                         room = Room.get(id=room_id)
                         room.last_activity = datetime.datetime.utcnow() - \
                                              datetime.timedelta(minutes=1, seconds=room.timeout)
+                    del room
                     logging.info(f"Shutting down room {room_id} on {name}.")
                 finally:
                     await asyncio.sleep(5)

WebHostLib/generate.py

@@ -14,7 +14,7 @@ from pony.orm import commit, db_session
 from BaseClasses import get_seed, seeddigits
 from Generate import PlandoOptions, handle_name, mystery_argparse
 from Main import main as ERmain
-from Utils import __version__, restricted_dumps
+from Utils import __version__, restricted_dumps, DaemonThreadPoolExecutor
 from WebHostLib import app
 from settings import ServerOptions, GeneratorOptions
 from .check import get_yaml_data, roll_options
@@ -33,6 +33,7 @@ def get_meta(options_source: dict, race: bool = False) -> dict[str, list[str] |
         "release_mode": str(options_source.get("release_mode", ServerOptions.release_mode)),
         "remaining_mode": str(options_source.get("remaining_mode", ServerOptions.remaining_mode)),
         "collect_mode": str(options_source.get("collect_mode", ServerOptions.collect_mode)),
+        "countdown_mode": str(options_source.get("countdown_mode", ServerOptions.countdown_mode)),
         "item_cheat": bool(int(options_source.get("item_cheat", not ServerOptions.disable_item_cheat))),
         "server_password": str(options_source.get("server_password", None)),
     }
@@ -72,6 +73,10 @@ def generate(race=False):
     return render_template("generate.html", race=race, version=__version__)
 
 
+def format_exception(e: BaseException) -> str:
+    return f"{e.__class__.__name__}: {e}"
+
+
 def start_generation(options: dict[str, dict | str], meta: dict[str, Any]):
     results, gen_options = roll_options(options, set(meta["plando_options"]))
 
@@ -92,7 +97,9 @@ def start_generation(options: dict[str, dict | str], meta: dict[str, Any]):
         except PicklingError as e:
             from .autolauncher import handle_generation_failure
             handle_generation_failure(e)
-            return render_template("seedError.html", seed_error=("PicklingError: " + str(e)))
+            meta["error"] = format_exception(e)
+            details = json.dumps(meta, indent=4).strip()
+            return render_template("seedError.html", seed_error=meta["error"], details=details)
 
         commit()
 
@@ -100,16 +107,18 @@ def start_generation(options: dict[str, dict | str], meta: dict[str, Any]):
     else:
         try:
             seed_id = gen_game({name: vars(options) for name, options in gen_options.items()},
-                               meta=meta, owner=session["_id"].int)
+                               meta=meta, owner=session["_id"].int, timeout=app.config["JOB_TIME"])
         except BaseException as e:
             from .autolauncher import handle_generation_failure
             handle_generation_failure(e)
-            return render_template("seedError.html", seed_error=(e.__class__.__name__ + ": " + str(e)))
+            meta["error"] = format_exception(e)
+            details = json.dumps(meta, indent=4).strip()
+            return render_template("seedError.html", seed_error=meta["error"], details=details)
 
         return redirect(url_for("view_seed", seed=seed_id))
 
 
-def gen_game(gen_options: dict, meta: dict[str, Any] | None = None, owner=None, sid=None):
+def gen_game(gen_options: dict, meta: dict[str, Any] | None = None, owner=None, sid=None, timeout: int|None = None):
     if meta is None:
         meta = {}
 
@@ -128,7 +137,7 @@ def gen_game(gen_options: dict, meta: dict[str, Any] | None = None, owner=None,
 
         seedname = "W" + (f"{random.randint(0, pow(10, seeddigits) - 1)}".zfill(seeddigits))
 
-        args = mystery_argparse()
+        args = mystery_argparse([])  # Just to set up the Namespace with defaults
         args.multi = playercount
         args.seed = seed
         args.name = {x: "" for x in range(1, playercount + 1)}  # only so it can be overwritten in mystery
@@ -163,11 +172,12 @@ def gen_game(gen_options: dict, meta: dict[str, Any] | None = None, owner=None,
         ERmain(args, seed, baked_server_options=meta["server_options"])
 
         return upload_to_db(target.name, sid, owner, race)
-    thread_pool = concurrent.futures.ThreadPoolExecutor(max_workers=1)
+
+    thread_pool = DaemonThreadPoolExecutor(max_workers=1)
     thread = thread_pool.submit(task)
 
     try:
-        return thread.result(app.config["JOB_TIME"])
+        return thread.result(timeout)
     except concurrent.futures.TimeoutError as e:
         if sid:
             with db_session:
@@ -175,11 +185,14 @@ def gen_game(gen_options: dict, meta: dict[str, Any] | None = None, owner=None,
                 if gen is not None:
                     gen.state = STATE_ERROR
                     meta = json.loads(gen.meta)
-                    meta["error"] = (
-                            "Allowed time for Generation exceeded, please consider generating locally instead. " +
-                            e.__class__.__name__ + ": " + str(e))
+                    meta["error"] = ("Allowed time for Generation exceeded, " +
+                                     "please consider generating locally instead. " +
+                                     format_exception(e))
                     gen.meta = json.dumps(meta)
                     commit()
+    except (KeyboardInterrupt, SystemExit):
+        # don't update db, retry next time
+        raise
     except BaseException as e:
         if sid:
             with db_session:
@@ -187,10 +200,15 @@ def gen_game(gen_options: dict, meta: dict[str, Any] | None = None, owner=None,
                 if gen is not None:
                     gen.state = STATE_ERROR
                     meta = json.loads(gen.meta)
-                    meta["error"] = (e.__class__.__name__ + ": " + str(e))
+                    meta["error"] = format_exception(e)
                     gen.meta = json.dumps(meta)
                     commit()
         raise
+    finally:
+        # free resources claimed by thread pool, if possible
+        # NOTE: Timeout depends on the process being killed at some point
+        #       since we can't actually cancel a running gen at the moment.
+        thread_pool.shutdown(wait=False, cancel_futures=True)
 
 
 @app.route('/wait/<suuid:seed>')
@@ -204,7 +222,9 @@ def wait_seed(seed: UUID):
     if not generation:
         return "Generation not found."
     elif generation.state == STATE_ERROR:
-        return render_template("seedError.html", seed_error=generation.meta)
+        meta = json.loads(generation.meta)
+        details = json.dumps(meta, indent=4).strip()
+        return render_template("seedError.html", seed_error=meta["error"], details=details)
     return render_template("waitSeed.html", seed_id=seed_id)
 
 

WebHostLib/markdown.py

@@ -0,0 +1,90 @@
+import re
+from collections import Counter
+
+import mistune
+from werkzeug.utils import secure_filename
+
+
+__all__ = [
+    "ImgUrlRewriteInlineParser",
+    'render_markdown',
+]
+
+
+class ImgUrlRewriteInlineParser(mistune.InlineParser):
+    relative_url_base: str
+
+    def __init__(self, relative_url_base: str, hard_wrap: bool = False) -> None:
+        super().__init__(hard_wrap)
+        self.relative_url_base = relative_url_base
+
+    @staticmethod
+    def _find_game_name_by_folder_name(name: str) -> str | None:
+        from worlds.AutoWorld import AutoWorldRegister
+
+        for world_name, world_type in AutoWorldRegister.world_types.items():
+            if world_type.__module__ == f"worlds.{name}":
+                return world_name
+        return None
+
+    def parse_link(self, m: re.Match[str], state: mistune.InlineState) -> int | None:
+        res = super().parse_link(m, state)
+        if res is not None and state.tokens and state.tokens[-1]["type"] == "image":
+            image_token = state.tokens[-1]
+            url: str = image_token["attrs"]["url"]
+            if not url.startswith("/") and not "://" in url:
+                # replace relative URL to another world's doc folder with the webhost folder layout
+                if url.startswith("../../") and "/docs/" in self.relative_url_base:
+                    parts = url.split("/", 4)
+                    if parts[2] != ".." and parts[3] == "docs":
+                        game_name = self._find_game_name_by_folder_name(parts[2])
+                        if game_name is not None:
+                            url = "/".join(parts[1:2] + [secure_filename(game_name)] + parts[4:])
+                # change relative URL to point to deployment folder
+                url = f"{self.relative_url_base}/{url}"
+                image_token['attrs']['url'] = url
+        return res
+
+
+def render_markdown(path: str, img_url_base: str | None = None) -> str:
+    markdown = mistune.create_markdown(
+        escape=False,
+        plugins=[
+            "strikethrough",
+            "footnotes",
+            "table",
+            "speedup",
+        ],
+    )
+
+    heading_id_count: Counter[str] = Counter()
+
+    def heading_id(text: str) -> str:
+        nonlocal heading_id_count
+
+        # there is no good way to do this without regex
+        s = re.sub(r"[^\w\- ]", "", text.lower()).replace(" ", "-").strip("-")
+        n = heading_id_count[s]
+        heading_id_count[s] += 1
+        if n > 0:
+            s += f"-{n}"
+        return s
+
+    def id_hook(_: mistune.Markdown, state: mistune.BlockState) -> None:
+        for tok in state.tokens:
+            if tok["type"] == "heading" and tok["attrs"]["level"] < 4:
+                text = tok["text"]
+                assert isinstance(text, str)
+                unique_id = heading_id(text)
+                tok["attrs"]["id"] = unique_id
+                tok["text"] = f"<a href=\"#{unique_id}\">{text}</a>"  # make header link to itself
+
+    markdown.before_render_hooks.append(id_hook)
+    if img_url_base:
+        markdown.inline = ImgUrlRewriteInlineParser(img_url_base)
+
+    with open(path, encoding="utf-8-sig") as f:
+        document = f.read()
+    html = markdown(document)
+    assert isinstance(html, str), "Unexpected mistune renderer in render_markdown"
+    return html

WebHostLib/misc.py

@@ -1,5 +1,7 @@
 import datetime
 import os
+import warnings
+from enum import StrEnum
 from typing import Any, IO, Dict, Iterator, List, Tuple, Union
 
 import jinja2.exceptions
@@ -9,14 +11,29 @@ from werkzeug.utils import secure_filename
 
 from worlds.AutoWorld import AutoWorldRegister, World
 from . import app, cache
+from .markdown import render_markdown
 from .models import Seed, Room, Command, UUID, uuid4
 from Utils import title_sorted
 
+class WebWorldTheme(StrEnum):
+    DIRT = "dirt"
+    GRASS = "grass"
+    GRASS_FLOWERS = "grassFlowers"
+    ICE = "ice"
+    JUNGLE = "jungle"
+    OCEAN = "ocean"
+    PARTY_TIME = "partyTime"
+    STONE = "stone"
 
 def get_world_theme(game_name: str) -> str:
-    if game_name in AutoWorldRegister.world_types:
-        return AutoWorldRegister.world_types[game_name].web.theme
-    return 'grass'
+    if game_name not in AutoWorldRegister.world_types:
+        return "grass"
+    chosen_theme = AutoWorldRegister.world_types[game_name].web.theme
+    available_themes = [theme.value for theme in WebWorldTheme]
+    if chosen_theme not in available_themes:
+        warnings.warn(f"Theme '{chosen_theme}' for {game_name} not valid, switching to default 'grass' theme.")
+        return "grass"
+    return chosen_theme
 
 
 def get_visible_worlds() -> dict[str, type(World)]:
@@ -27,49 +44,6 @@ def get_visible_worlds() -> dict[str, type(World)]:
     return worlds
 
 
-def render_markdown(path: str) -> str:
-    import mistune
-    from collections import Counter
-
-    markdown = mistune.create_markdown(
-        escape=False,
-        plugins=[
-            "strikethrough",
-            "footnotes",
-            "table",
-            "speedup",
-        ],
-    )
-
-    heading_id_count: Counter[str] = Counter()
-
-    def heading_id(text: str) -> str:
-        nonlocal heading_id_count
-        import re  # there is no good way to do this without regex
-
-        s = re.sub(r"[^\w\- ]", "", text.lower()).replace(" ", "-").strip("-")
-        n = heading_id_count[s]
-        heading_id_count[s] += 1
-        if n > 0:
-            s += f"-{n}"
-        return s
-
-    def id_hook(_: mistune.Markdown, state: mistune.BlockState) -> None:
-        for tok in state.tokens:
-            if tok["type"] == "heading" and tok["attrs"]["level"] < 4:
-                text = tok["text"]
-                assert isinstance(text, str)
-                unique_id = heading_id(text)
-                tok["attrs"]["id"] = unique_id
-                tok["text"] = f"<a href=\"#{unique_id}\">{text}</a>"  # make header link to itself
-
-    markdown.before_render_hooks.append(id_hook)
-
-    with open(path, encoding="utf-8-sig") as f:
-        document = f.read()
-    return markdown(document)
-
-
 @app.errorhandler(404)
 @app.errorhandler(jinja2.exceptions.TemplateNotFound)
 def page_not_found(err):
@@ -91,10 +65,9 @@ def game_info(game, lang):
         theme = get_world_theme(game)
         secure_game_name = secure_filename(game)
         lang = secure_filename(lang)
-        document = render_markdown(os.path.join(
-            app.static_folder, "generated", "docs",
-            secure_game_name, f"{lang}_{secure_game_name}.md"
-        ))
+        file_dir = os.path.join(app.static_folder, "generated", "docs", secure_game_name)
+        file_dir_url = url_for("static", filename=f"generated/docs/{secure_game_name}")
+        document = render_markdown(os.path.join(file_dir, f"{lang}_{secure_game_name}.md"), file_dir_url)
         return render_template(
             "markdown_document.html",
             title=f"{game} Guide",
@@ -119,10 +92,9 @@ def tutorial(game: str, file: str):
         theme = get_world_theme(game)
         secure_game_name = secure_filename(game)
         file = secure_filename(file)
-        document = render_markdown(os.path.join(
-            app.static_folder, "generated", "docs",
-            secure_game_name, file+".md"
-        ))
+        file_dir = os.path.join(app.static_folder, "generated", "docs", secure_game_name)
+        file_dir_url = url_for("static", filename=f"generated/docs/{secure_game_name}")
+        document = render_markdown(os.path.join(file_dir, f"{file}.md"), file_dir_url)
         return render_template(
             "markdown_document.html",
             title=f"{game} Guide",
@@ -260,7 +232,10 @@ def host_room(room: UUID):
     # indicate that the page should reload to get the assigned port
     should_refresh = ((not room.last_port and now - room.creation_time < datetime.timedelta(seconds=3))
                       or room.last_activity < now - datetime.timedelta(seconds=room.timeout))
-    with db_session:
+
+    if now - room.last_activity > datetime.timedelta(minutes=1):
+        # we only set last_activity if needed, otherwise parallel access on /room will cause an internal server error
+        # due to "pony.orm.core.OptimisticCheckError: Object Room was updated outside of current transaction"
         room.last_activity = now  # will trigger a spinup, if it's not already running
 
     browser_tokens = "Mozilla", "Chrome", "Safari"
@@ -268,9 +243,9 @@ def host_room(room: UUID):
                  or "Discordbot" in request.user_agent.string
                  or not any(browser_token in request.user_agent.string for browser_token in browser_tokens))
 
-    def get_log(max_size: int = 0 if automated else 1024000) -> str:
+    def get_log(max_size: int = 0 if automated else 1024000) -> Tuple[str, int]:
         if max_size == 0:
-            return "…"
+            return "…", 0
         try:
             with open(os.path.join("logs", str(room.id) + ".txt"), "rb") as log:
                 raw_size = 0
@@ -281,9 +256,9 @@ def host_room(room: UUID):
                         break
                     raw_size += len(block)
                     fragments.append(block.decode("utf-8"))
-                return "".join(fragments)
+                return "".join(fragments), raw_size
         except FileNotFoundError:
-            return ""
+            return "", 0
 
     return render_template("hostRoom.html", room=room, should_refresh=should_refresh, get_log=get_log)
 

WebHostLib/options.py

@@ -13,6 +13,7 @@ from Utils import local_path
 from worlds.AutoWorld import AutoWorldRegister
 from . import app, cache
 from .generate import get_meta
+from .misc import get_world_theme
 
 
 def create() -> None:
@@ -22,12 +23,6 @@ def create() -> None:
     Options.generate_yaml_templates(yaml_folder)
 
 
-def get_world_theme(game_name: str) -> str:
-    if game_name in AutoWorldRegister.world_types:
-        return AutoWorldRegister.world_types[game_name].web.theme
-    return 'grass'
-
-
 def render_options_page(template: str, world_name: str, is_complex: bool = False) -> Union[Response, str]:
     world = AutoWorldRegister.world_types[world_name]
     if world.hidden or world.web.options_page is False:
@@ -76,7 +71,7 @@ def filter_rst_to_html(text: str) -> str:
         lines = text.splitlines()
         text = lines[0] + "\n" + dedent("\n".join(lines[1:]))
 
-    return publish_parts(text, writer_name='html', settings=None, settings_overrides={
+    return publish_parts(text, writer='html', settings=None, settings_overrides={
         'raw_enable': False,
         'file_insertion_enabled': False,
         'output_encoding': 'unicode'
@@ -231,7 +226,7 @@ def generate_yaml(game: str):
             if key_parts[-1] == "qty":
                 if key_parts[0] not in options:
                     options[key_parts[0]] = {}
-                if val != "0":
+                if val and val != "0":
                     options[key_parts[0]][key_parts[1]] = int(val)
                 del options[key]
 

WebHostLib/requirements.txt

@@ -4,9 +4,10 @@ pony>=0.7.19; python_version <= '3.12'
 pony @ git+https://github.com/black-sliver/pony@7feb1221953b7fa4a6735466bf21a8b4d35e33ba#0.7.19; python_version >= '3.13'
 waitress>=3.0.2
 Flask-Caching>=2.3.0
-Flask-Compress>=1.17
+Flask-Compress==1.18  # pkg_resources can't resolve the "backports.zstd" dependency of >1.18, breaking ModuleUpdate.py
 Flask-Limiter>=3.12
 bokeh>=3.6.3
 markupsafe>=3.0.2
 setproctitle>=1.3.5
 mistune>=3.1.3
+docutils>=0.22.2

WebHostLib/static/assets/faq/en.md

@@ -23,7 +23,7 @@ players to rely upon each other to complete their game.
 While a multiworld game traditionally requires all players to be playing the same game, a multi-game multiworld allows
 players to randomize any of the supported games, and send items between them. This allows players of different
 games to interact with one another in a single multiplayer environment.  Archipelago supports multi-game multiworlds.
-Here is a list of our [Supported Games](https://archipelago.gg/games).
+Here is a list of our [Supported Games](/games).
 
 ## Can I generate a single-player game with Archipelago?
 
@@ -33,7 +33,7 @@ play, open the Settings Page, pick your settings, and click Generate Game.
 
 ## How do I get started?
 
-We have a [Getting Started](https://archipelago.gg/tutorial/Archipelago/setup/en) guide that will help you get the
+We have a [Getting Started](/tutorial/Archipelago/setup/en) guide that will help you get the
 software set up. You can use that guide to learn how to generate multiworlds. There are also basic instructions for
 including multiple games, and hosting multiworlds on the website for ease and convenience.
 
@@ -57,7 +57,7 @@ their multiworld.
 
 If a player must leave early, they can use Archipelago's release system. When a player releases their game, all items
 in that game belonging to other players are sent out automatically. This allows other players to continue to play
-uninterrupted. Here is a list of all of our [Server Commands](https://archipelago.gg/tutorial/Archipelago/commands/en).
+uninterrupted. Here is a list of all of our [Server Commands](/tutorial/Archipelago/commands/en).
 
 ## What happens if an item is placed somewhere it is impossible to get?
 
@@ -66,7 +66,7 @@ is to ensure items necessary to complete the game will be accessible to the play
 rules allowing certain items to be placed in normally unreachable locations, provided the player has indicated they are
 comfortable exploiting certain glitches in the game.
 
-## I want to add a game to the Archipelago randomizer. How do I do that?
+## I want to develop a game implementation for Archipelago. How do I do that?
 
 The best way to get started is to take a look at our code on GitHub:  
 [Archipelago GitHub Page](https://github.com/ArchipelagoMW/Archipelago).
@@ -77,4 +77,5 @@ There, you will find examples of games in the `worlds` folder:
 You may also find developer documentation in the `docs` folder:  
 [/docs Folder in Archipelago Code](https://github.com/ArchipelagoMW/Archipelago/tree/main/docs).
 
-If you have more questions, feel free to ask in the **#ap-world-dev** channel on our Discord.
+If you have more questions regarding development of a game implementation, feel free to ask in the **#ap-world-dev** 
+channel on our Discord.

WebHostLib/static/styles/sc2Tracker.css

@@ -241,12 +241,9 @@ input[type="checkbox"]{
 }
 
 /* Hidden items */
-.hidden-class:not(:has(img.acquired)){
+.hidden-class:not(:has(.f:not(.unacquired))), .hidden-item{
   display: none;
 }
-.hidden-item:not(.acquired){
-  display:none;
-}
 
 /* Keys */
 #keys ol, #keys ul{

WebHostLib/static/styles/themes/ocean-island.css

@@ -72,3 +72,13 @@ code{
     padding-right: 0.25rem;
     color: #000000;
 }
+
+code.grassy {
+    background-color: #b5e9a4;
+    border: 1px solid #2a6c2f;
+    white-space: preserve;
+    text-align: left;
+    display: block;
+    font-size: 14px;
+    line-height: 20px;
+}

WebHostLib/static/styles/waitSeed.css

@@ -13,3 +13,7 @@
     min-height: 360px;
     text-align: center;
 }
+
+h2, h4 {
+    color: #ffffff;
+}

WebHostLib/templates/genericTracker.html

@@ -98,7 +98,7 @@
                             <td>
                                 {% if hint.finding_player == player %}
                                     <b>{{ player_names_with_alias[(team, hint.finding_player)] }}</b>
-                                {% elif get_slot_info(team, hint.finding_player).type == 2 %}
+                                {% elif get_slot_info(hint.finding_player).type == 2 %}
                                     <i>{{ player_names_with_alias[(team, hint.finding_player)] }}</i>
                                 {% else %}
                                     <a href="{{ url_for("get_player_tracker", tracker=room.tracker, tracked_team=team, tracked_player=hint.finding_player) }}">
@@ -109,7 +109,7 @@
                             <td>
                                 {% if hint.receiving_player == player %}
                                     <b>{{ player_names_with_alias[(team, hint.receiving_player)] }}</b>
-                                {% elif get_slot_info(team, hint.receiving_player).type == 2 %}
+                                {% elif get_slot_info(hint.receiving_player).type == 2 %}
                                     <i>{{ player_names_with_alias[(team, hint.receiving_player)] }}</i>
                                 {% else %}
                                     <a href="{{ url_for("get_player_tracker", tracker=room.tracker, tracked_team=team, tracked_player=hint.receiving_player) }}">

WebHostLib/templates/hostRoom.html

@@ -58,8 +58,7 @@
                     Open Log File...
                 </a>
             </div>
-        {%  set log = get_log() -%}
-        {%- set log_len = log | length - 1 if log.endswith("…") else log | length -%}
+        {%  set log, log_len = get_log() -%}
         <div id="logger" style="white-space: pre">{{ log }}</div>
         <script>
           let url = '{{ url_for('display_log', room = room.id) }}';

WebHostLib/templates/multispheretracker.html

@@ -45,15 +45,15 @@
                     {%- set current_sphere = loop.index %}
                     {%- for player, sphere_location_ids in sphere.items() %}
                         {%- set checked_locations = tracker_data.get_player_checked_locations(team, player) %}
-                        {%- set finder_game = tracker_data.get_player_game(team, player) %}
-                        {%- set player_location_data = tracker_data.get_player_locations(team, player) %}
+                        {%- set finder_game = tracker_data.get_player_game(player) %}
+                        {%- set player_location_data = tracker_data.get_player_locations(player) %}
                         {%- for location_id in sphere_location_ids.intersection(checked_locations) %}
                         <tr>
                             {%- set item_id, receiver, item_flags = player_location_data[location_id] %}
-                            {%- set receiver_game = tracker_data.get_player_game(team, receiver) %}
+                            {%- set receiver_game = tracker_data.get_player_game(receiver) %}
                             <td>{{ current_sphere }}</td>
-                            <td>{{ tracker_data.get_player_name(team, player) }}</td>
-                            <td>{{ tracker_data.get_player_name(team, receiver) }}</td>
+                            <td>{{ tracker_data.get_player_name(player) }}</td>
+                            <td>{{ tracker_data.get_player_name(receiver) }}</td>
                             <td>{{ tracker_data.item_id_to_name[receiver_game][item_id] }}</td>
                             <td>{{ tracker_data.location_id_to_name[finder_game][location_id] }}</td>
                             <td>{{ finder_game }}</td>

WebHostLib/templates/multitrackerHintTable.html

@@ -22,14 +22,14 @@
                 -%}
                     <tr>
                         <td>
-                            {% if get_slot_info(team, hint.finding_player).type == 2 %}
+                            {% if get_slot_info(hint.finding_player).type == 2 %}
                                 <i>{{ player_names_with_alias[(team, hint.finding_player)] }}</i>
                             {% else %}
                                 {{ player_names_with_alias[(team, hint.finding_player)] }}
                             {% endif %}
                         </td>
                         <td>
-                            {% if get_slot_info(team, hint.receiving_player).type == 2 %}
+                            {% if get_slot_info(hint.receiving_player).type == 2 %}
                                 <i>{{ player_names_with_alias[(team, hint.receiving_player)] }}</i>
                             {% else %}
                                 {{ player_names_with_alias[(team, hint.receiving_player)] }}

WebHostLib/templates/seedError.html

@@ -4,16 +4,20 @@
 
 {% block head %}
     <title>Generation failed, please retry.</title>
-    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename="styles/waitSeed.css") }}"/>
+    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename='styles/waitSeed.css') }}"/>
 {% endblock %}
 
 {% block body %}
     {% include 'header/oceanIslandHeader.html' %}
     <div id="wait-seed-wrapper" class="grass-island">
         <div id="wait-seed">
-            <h1>Generation failed</h1>
-			<h2>please retry</h2>
-            {{ seed_error }}
+            <h1>Generation Failed</h1>
+            <h2>Please try again!</h2>
+            <p>{{ seed_error }}</p>
+            <h4>More details:</h4>
+            <p>
+                <code class="grassy">{{ details }}</code>
+            </p>
         </div>
     </div>
 {% endblock %}

WebHostLib/templates/supportedGames.html

@@ -31,6 +31,9 @@
     {% include 'header/oceanHeader.html' %}
     <div id="games" class="markdown">
         <h1>Currently Supported Games</h1>
+        <p>Below are the games that are currently included with the Archipelago software. To play a game that is not on
+        this page, please refer to the <a href="/tutorial/Archipelago/setup/en#playing-with-custom-worlds">playing with
+        custom worlds</a> section of the setup guide.</p>
         <div class="js-only">
             <label for="game-search">Search for your game below!</label><br />
             <div class="page-controls">

WebHostLib/tracker.py

@@ -17,7 +17,6 @@ from .models import GameDataPackage, Room
 # Multisave is currently updated, at most, every minute.
 TRACKER_CACHE_TIMEOUT_IN_SECONDS = 60
 
-_multidata_cache = {}
 _multiworld_trackers: Dict[str, Callable] = {}
 _player_trackers: Dict[str, Callable] = {}
 
@@ -85,27 +84,27 @@ class TrackerData:
         """Retrieves the seed name."""
         return self._multidata["seed_name"]
 
-    def get_slot_data(self, team: int, player: int) -> Dict[str, Any]:
+    def get_slot_data(self, player: int) -> Dict[str, Any]:
         """Retrieves the slot data for a given player."""
         return self._multidata["slot_data"][player]
 
-    def get_slot_info(self, team: int, player: int) -> NetworkSlot:
+    def get_slot_info(self, player: int) -> NetworkSlot:
         """Retrieves the NetworkSlot data for a given player."""
         return self._multidata["slot_info"][player]
 
-    def get_player_name(self, team: int, player: int) -> str:
+    def get_player_name(self, player: int) -> str:
         """Retrieves the slot name for a given player."""
-        return self.get_slot_info(team, player).name
+        return self.get_slot_info(player).name
 
-    def get_player_game(self, team: int, player: int) -> str:
+    def get_player_game(self, player: int) -> str:
         """Retrieves the game for a given player."""
-        return self.get_slot_info(team, player).game
+        return self.get_slot_info(player).game
 
-    def get_player_locations(self, team: int, player: int) -> Dict[int, ItemMetadata]:
+    def get_player_locations(self, player: int) -> Dict[int, ItemMetadata]:
         """Retrieves all locations with their containing item's metadata for a given player."""
         return self._multidata["locations"][player]
 
-    def get_player_starting_inventory(self, team: int, player: int) -> List[int]:
+    def get_player_starting_inventory(self, player: int) -> List[int]:
         """Retrieves a list of all item codes a given slot starts with."""
         return self._multidata["precollected_items"][player]
 
@@ -116,7 +115,7 @@ class TrackerData:
     @_cache_results
     def get_player_missing_locations(self, team: int, player: int) -> Set[int]:
         """Retrieves the set of all locations not marked complete by this player."""
-        return set(self.get_player_locations(team, player)) - self.get_player_checked_locations(team, player)
+        return set(self.get_player_locations(player)) - self.get_player_checked_locations(team, player)
 
     def get_player_received_items(self, team: int, player: int) -> List[NetworkItem]:
         """Returns all items received to this player in order of received."""
@@ -126,7 +125,7 @@ class TrackerData:
     def get_player_inventory_counts(self, team: int, player: int) -> collections.Counter:
         """Retrieves a dictionary of all items received by their id and their received count."""
         received_items = self.get_player_received_items(team, player)
-        starting_items = self.get_player_starting_inventory(team, player)
+        starting_items = self.get_player_starting_inventory(player)
         inventory = collections.Counter()
         for item in received_items:
             inventory[item.item] += 1
@@ -179,7 +178,7 @@ class TrackerData:
     def get_team_locations_total_count(self) -> Dict[int, int]:
         """Retrieves a dictionary of total player locations each team has."""
         return {
-            team: sum(len(self.get_player_locations(team, player)) for player in players)
+            team: sum(len(self.get_player_locations(player)) for player in players)
             for team, players in self.get_all_players().items()
         }
 
@@ -210,7 +209,7 @@ class TrackerData:
         return {
             0: [
                 player for player, slot_info in self._multidata["slot_info"].items()
-                if self.get_slot_info(0, player).type == SlotType.player
+                if self.get_slot_info(player).type == SlotType.player
             ]
         }
 
@@ -226,7 +225,7 @@ class TrackerData:
     def get_room_locations(self) -> Dict[TeamPlayer, Dict[int, ItemMetadata]]:
         """Retrieves a dictionary of all locations and their associated item metadata per player."""
         return {
-            (team, player): self.get_player_locations(team, player)
+            (team, player): self.get_player_locations(player)
             for team, players in self.get_all_players().items() for player in players
         }
 
@@ -234,7 +233,7 @@ class TrackerData:
     def get_room_games(self) -> Dict[TeamPlayer, str]:
         """Retrieves a dictionary of games for each player."""
         return {
-            (team, player): self.get_player_game(team, player)
+            (team, player): self.get_player_game(player)
             for team, players in self.get_all_slots().items() for player in players
         }
 
@@ -262,9 +261,9 @@ class TrackerData:
             for player in players:
                 alias = self.get_player_alias(team, player)
                 if alias:
-                    long_player_names[team, player] = f"{alias} ({self.get_player_name(team, player)})"
+                    long_player_names[team, player] = f"{alias} ({self.get_player_name(player)})"
                 else:
-                    long_player_names[team, player] = self.get_player_name(team, player)
+                    long_player_names[team, player] = self.get_player_name(player)
 
         return long_player_names
 
@@ -344,7 +343,7 @@ def get_timeout_and_player_tracker(room: Room, tracked_team: int, tracked_player
     tracker_data = TrackerData(room)
 
     # Load and render the game-specific player tracker, or fallback to generic tracker if none exists.
-    game_specific_tracker = _player_trackers.get(tracker_data.get_player_game(tracked_team, tracked_player), None)
+    game_specific_tracker = _player_trackers.get(tracker_data.get_player_game(tracked_player), None)
     if game_specific_tracker and not generic:
         tracker = game_specific_tracker(tracker_data, tracked_team, tracked_player)
     else:
@@ -409,10 +408,10 @@ def get_enabled_multiworld_trackers(room: Room) -> Dict[str, Callable]:
 
 
 def render_generic_tracker(tracker_data: TrackerData, team: int, player: int) -> str:
-    game = tracker_data.get_player_game(team, player)
+    game = tracker_data.get_player_game(player)
 
     received_items_in_order = {}
-    starting_inventory = tracker_data.get_player_starting_inventory(team, player)
+    starting_inventory = tracker_data.get_player_starting_inventory(player)
     for index, item in enumerate(starting_inventory):
         received_items_in_order[item] = index
     for index, network_item in enumerate(tracker_data.get_player_received_items(team, player),
@@ -428,7 +427,7 @@ def render_generic_tracker(tracker_data: TrackerData, team: int, player: int) ->
         player=player,
         player_name=tracker_data.get_room_long_player_names()[team, player],
         inventory=tracker_data.get_player_inventory_counts(team, player),
-        locations=tracker_data.get_player_locations(team, player),
+        locations=tracker_data.get_player_locations(player),
         checked_locations=tracker_data.get_player_checked_locations(team, player),
         received_items=received_items_in_order,
         saving_second=tracker_data.get_room_saving_second(),
@@ -500,7 +499,7 @@ if "Factorio" in network_data_package["games"]:
                 tracker_data.item_id_to_name["Factorio"][item_id]: count
                 for item_id, count in tracker_data.get_player_inventory_counts(team, player).items()
             }) for team, players in tracker_data.get_all_players().items() for player in players
-            if tracker_data.get_player_game(team, player) == "Factorio"
+            if tracker_data.get_player_game(player) == "Factorio"
         }
 
         return render_template(
@@ -589,7 +588,7 @@ if "A Link to the Past" in network_data_package["games"]:
 
         # Highlight 'bombs' if we received any bomb upgrades in bombless start.
         # In race mode, we'll just assume bombless start for simplicity.
-        if tracker_data.get_slot_data(team, player).get("bombless_start", True):
+        if tracker_data.get_slot_data(player).get("bombless_start", True):
             inventory["Bombs"] = sum(count for item, count in inventory.items() if item.startswith("Bomb Upgrade"))
         else:
             inventory["Bombs"] = 1
@@ -605,7 +604,7 @@ if "A Link to the Past" in network_data_package["games"]:
                 for code, count in tracker_data.get_player_inventory_counts(team, player).items()
             })
             for team, players in tracker_data.get_all_players().items()
-            for player in players if tracker_data.get_slot_info(team, player).game == "A Link to the Past"
+            for player in players if tracker_data.get_slot_info(player).game == "A Link to the Past"
         }
 
         # Translate non-progression items to progression items for tracker simplicity.
@@ -624,7 +623,7 @@ if "A Link to the Past" in network_data_package["games"]:
                 for region_name in known_regions
             }
             for team, players in tracker_data.get_all_players().items()
-            for player in players if tracker_data.get_slot_info(team, player).game == "A Link to the Past"
+            for player in players if tracker_data.get_slot_info(player).game == "A Link to the Past"
         }
 
         # Get a totals count.
@@ -698,7 +697,7 @@ if "A Link to the Past" in network_data_package["games"]:
             team=team,
             player=player,
             inventory=inventory,
-            player_name=tracker_data.get_player_name(team, player),
+            player_name=tracker_data.get_player_name(player),
             regions=regions,
             known_regions=known_regions,
         )
@@ -845,7 +844,7 @@ if "Ocarina of Time" in network_data_package["games"]:
                 return full_name[len(area):]
             return full_name
 
-        locations = tracker_data.get_player_locations(team, player)
+        locations = tracker_data.get_player_locations(player)
         checked_locations = tracker_data.get_player_checked_locations(team, player).intersection(set(locations))
         location_info = {}
         checks_done = {}
@@ -907,7 +906,7 @@ if "Ocarina of Time" in network_data_package["games"]:
             player=player,
             team=team,
             room=tracker_data.room,
-            player_name=tracker_data.get_player_name(team, player),
+            player_name=tracker_data.get_player_name(player),
             icons=icons,
             acquired_items={lookup_any_item_id_to_name[id] for id, count in inventory.items() if count > 0},
             checks_done=checks_done, checks_in_area=checks_in_area, location_info=location_info,
@@ -954,57 +953,37 @@ if "Timespinner" in network_data_package["games"]:
             "Lab Glasses":         "https://timespinnerwiki.com/mediawiki/images/4/4a/Lab_Glasses.png",
             "Eye Orb":             "https://timespinnerwiki.com/mediawiki/images/a/a4/Eye_Orb.png",
             "Lab Coat":            "https://timespinnerwiki.com/mediawiki/images/5/51/Lab_Coat.png", 
-            "Demon":               "https://timespinnerwiki.com/mediawiki/images/f/f8/Familiar_Demon.png", 
+            "Demon":               "https://timespinnerwiki.com/mediawiki/images/f/f8/Familiar_Demon.png",
+            "Cube of Bodie":       "https://timespinnerwiki.com/mediawiki/images/1/14/Menu_Icon_Stats.png"
         }
 
         timespinner_location_ids = {
-            "Present":         [
-                1337000, 1337001, 1337002, 1337003, 1337004, 1337005, 1337006, 1337007, 1337008, 1337009,
-                1337010, 1337011, 1337012, 1337013, 1337014, 1337015, 1337016, 1337017, 1337018, 1337019,
-                1337020, 1337021, 1337022, 1337023, 1337024, 1337025, 1337026, 1337027, 1337028, 1337029,
-                1337030, 1337031, 1337032, 1337033, 1337034, 1337035, 1337036, 1337037, 1337038, 1337039,
-                1337040, 1337041, 1337042, 1337043, 1337044, 1337045, 1337046, 1337047, 1337048, 1337049,
-                1337050, 1337051, 1337052, 1337053, 1337054, 1337055, 1337056, 1337057, 1337058, 1337059,
-                1337060, 1337061, 1337062, 1337063, 1337064, 1337065, 1337066, 1337067, 1337068, 1337069,
-                1337070, 1337071, 1337072, 1337073, 1337074, 1337075, 1337076, 1337077, 1337078, 1337079,
-                1337080, 1337081, 1337082, 1337083, 1337084, 1337085],
-            "Past":            [
-                1337086, 1337087, 1337088, 1337089,
-                1337090, 1337091, 1337092, 1337093, 1337094, 1337095, 1337096, 1337097, 1337098, 1337099,
-                1337100, 1337101, 1337102, 1337103, 1337104, 1337105, 1337106, 1337107, 1337108, 1337109,
-                1337110, 1337111, 1337112, 1337113, 1337114, 1337115, 1337116, 1337117, 1337118, 1337119,
-                1337120, 1337121, 1337122, 1337123, 1337124, 1337125, 1337126, 1337127, 1337128, 1337129,
-                1337130, 1337131, 1337132, 1337133, 1337134, 1337135, 1337136, 1337137, 1337138, 1337139,
-                1337140, 1337141, 1337142, 1337143, 1337144, 1337145, 1337146, 1337147, 1337148, 1337149,
-                1337150, 1337151, 1337152, 1337153, 1337154, 1337155,
-                1337171, 1337172, 1337173, 1337174, 1337175],
+            "Present": list(range(1337000, 1337085)),
+            "Past": list(range(1337086, 1337157)) + list(range(1337159, 1337175)),
             "Ancient Pyramid": [
                 1337236,
                 1337246, 1337247, 1337248, 1337249]
         }
 
-        slot_data = tracker_data.get_slot_data(team, player)
+        slot_data = tracker_data.get_slot_data(player)
         if (slot_data["DownloadableItems"]):
-            timespinner_location_ids["Present"] += [
-                1337156, 1337157, 1337159,
-                1337160, 1337161, 1337162, 1337163, 1337164, 1337165, 1337166, 1337167, 1337168, 1337169,
-                1337170]
+            timespinner_location_ids["Present"] += [1337156, 1337157] + list(range(1337159, 1337170))
         if (slot_data["Cantoran"]):
             timespinner_location_ids["Past"].append(1337176)
         if (slot_data["LoreChecks"]):
-            timespinner_location_ids["Present"] += [
-                1337177, 1337178, 1337179,
-                1337180, 1337181, 1337182, 1337183, 1337184, 1337185, 1337186, 1337187]
-            timespinner_location_ids["Past"] += [
-                1337188, 1337189,
-                1337190, 1337191, 1337192, 1337193, 1337194, 1337195, 1337196, 1337197, 1337198]
+            timespinner_location_ids["Present"] += list(range(1337177, 1337187))
+            timespinner_location_ids["Past"] += list(range(1337188, 1337198))
         if (slot_data["GyreArchives"]):
-            timespinner_location_ids["Ancient Pyramid"] += [
-                1337237, 1337238, 1337239,
-                1337240, 1337241, 1337242, 1337243, 1337244, 1337245]
+            timespinner_location_ids["Ancient Pyramid"] += list(range(1337237, 1337245))
         if (slot_data["PyramidStart"]):
             timespinner_location_ids["Ancient Pyramid"] += [
                 1337233, 1337234, 1337235]
+        if (slot_data["PureTorcher"]):
+            timespinner_location_ids["Present"] += list(range(1337250, 1337352)) + list(range(1337422, 1337496)) + [1337506] + list(range(1337712, 1337779)) + [1337781, 1337782]
+            timespinner_location_ids["Past"] += list(range(1337497, 1337505)) + list(range(1337507, 1337711)) + [1337780]
+            timespinner_location_ids["Ancient Pyramid"] += list(range(1337369, 1337421))
+            if (slot_data["GyreArchives"]):
+                timespinner_location_ids["Ancient Pyramid"] += list(range(1337353, 1337368))
 
         display_data = {}
 
@@ -1035,7 +1014,7 @@ if "Timespinner" in network_data_package["games"]:
             player=player,
             team=team,
             room=tracker_data.room,
-            player_name=tracker_data.get_player_name(team, player),
+            player_name=tracker_data.get_player_name(player),
             checks_done=checks_done,
             checks_in_area=checks_in_area,
             location_info=location_info,
@@ -1144,7 +1123,7 @@ if "Super Metroid" in network_data_package["games"]:
             player=player,
             team=team,
             room=tracker_data.room,
-            player_name=tracker_data.get_player_name(team, player),
+            player_name=tracker_data.get_player_name(player),
             checks_done=checks_done,
             checks_in_area=checks_in_area,
             location_info=location_info,
@@ -1194,7 +1173,7 @@ if "ChecksFinder" in network_data_package["games"]:
 
         display_data = {}
         inventory = tracker_data.get_player_inventory_counts(team, player)
-        locations = tracker_data.get_player_locations(team, player)
+        locations = tracker_data.get_player_locations(player)
 
         # Multi-items
         multi_items = {
@@ -1236,7 +1215,7 @@ if "ChecksFinder" in network_data_package["games"]:
             player=player,
             team=team,
             room=tracker_data.room,
-            player_name=tracker_data.get_player_name(team, player),
+            player_name=tracker_data.get_player_name(player),
             checks_done=checks_done,
             checks_in_area=checks_in_area,
             location_info=location_info,
@@ -1249,7 +1228,7 @@ if "Starcraft 2" in network_data_package["games"]:
     def render_Starcraft2_tracker(tracker_data: TrackerData, team: int, player: int) -> str:
         SC2WOL_ITEM_ID_OFFSET = 1000
         SC2HOTS_ITEM_ID_OFFSET = 2000
-        SC2LOTV_ITEM_ID_OFFSET = 2000
+        SC2LOTV_ITEM_ID_OFFSET = 3000
         SC2_KEY_ITEM_ID_OFFSET = 4000
         NCO_LOCATION_ID_LOW = 20004500
         NCO_LOCATION_ID_HIGH = NCO_LOCATION_ID_LOW + 1000
@@ -1264,7 +1243,7 @@ if "Starcraft 2" in network_data_package["games"]:
         UPGRADE_RESEARCH_SPEED_ITEM_ID = 1807
         UPGRADE_RESEARCH_COST_ITEM_ID = 1808
         REDUCED_MAX_SUPPLY_ITEM_ID = 1850
-        slot_data = tracker_data.get_slot_data(team, player)
+        slot_data = tracker_data.get_slot_data(player)
         inventory: collections.Counter[int] = tracker_data.get_player_inventory_counts(team, player)
         item_id_to_name = tracker_data.item_id_to_name["Starcraft 2"]
         location_id_to_name = tracker_data.location_id_to_name["Starcraft 2"]
@@ -1280,10 +1259,10 @@ if "Starcraft 2" in network_data_package["games"]:
         display_data["shield_regen_count"] = inventory.get(SHIELD_REGENERATION_ITEM_ID, 0)
         display_data["upgrade_speed_count"] = inventory.get(UPGRADE_RESEARCH_SPEED_ITEM_ID, 0)
         display_data["research_cost_count"] = inventory.get(UPGRADE_RESEARCH_COST_ITEM_ID, 0)
-        
+
         # Locations
         have_nco_locations = False
-        locations = tracker_data.get_player_locations(team, player)
+        locations = tracker_data.get_player_locations(player)
         checked_locations = tracker_data.get_player_checked_locations(team, player)
         missions: dict[str, list[tuple[str, bool]]] = {}
         for location_id in locations:
@@ -1438,7 +1417,7 @@ if "Starcraft 2" in network_data_package["games"]:
                     # the maximum bundle contribution, not the sum
                     inventory[upgrade_id] = bundle_amount
 
-        
+
         # Victory condition
         game_state = tracker_data.get_player_client_status(team, player)
         display_data["game_finished"] = game_state == ClientStatus.CLIENT_GOAL
@@ -1456,7 +1435,7 @@ if "Starcraft 2" in network_data_package["games"]:
             player=player,
             team=team,
             room=tracker_data.room,
-            player_name=tracker_data.get_player_name(team, player),
+            player_name=tracker_data.get_player_name(player),
             missions=missions,
             locations=locations,
             checked_locations=checked_locations,

Zelda1Client.py

@@ -289,7 +289,7 @@ async def nes_sync_task(ctx: ZeldaContext):
                     if not ctx.auth:
                         ctx.auth = ''.join([chr(i) for i in data_decoded['playerName'] if i != 0])
                         if ctx.auth == '':
-                            logger.info("Invalid ROM detected. No player name built into the ROM. Please regenerate"
+                            logger.info("Invalid ROM detected. No player name built into the ROM. Please regenerate "
                                         "the ROM using the same link but adding your slot name")
                         if ctx.awaiting_rom:
                             await ctx.server_auth(False)

ci-requirements.txt

@@ -0,0 +1,2 @@
+pytest>=9.0.1,<10  # this includes subtests support
+pytest-xdist>=3.8.0

data/client.kv

@@ -224,6 +224,7 @@
     height: self.content.texture_size[1] + 80
 <ScrollBox>:
     layout: layout
+    box_height: dp(100)
     bar_width: "12dp"
     scroll_wheel_distance: 40
     do_scroll_x: False
@@ -234,4 +235,11 @@
         orientation: "vertical"
         spacing: 10
         size_hint_y: None
-        height: self.minimum_height
+        height: max(self.minimum_height, root.box_height)
+
+<MessageBoxLabel>:
+    valign: "middle"
+    halign: "center"
+    text_size: self.width, None
+    height: self.texture_size[1]
+

data/options.yaml

@@ -33,6 +33,10 @@ description: {{ yaml_dump("Default %s Template" % game) }}
 game: {{ yaml_dump(game) }}
 requires:
   version: {{ __version__ }} # Version of Archipelago required for this yaml to work as expected.
+  {%- if world_version != "0.0.0" %}
+  game:
+    {{ yaml_dump(game) }}: {{ world_version }} # Version of the world required for this yaml to work as expected.
+  {%- endif %}
 
 {%- macro range_option(option) %}
     # You can define additional values between the minimum and maximum values.

data/optionscreator.kv

@@ -0,0 +1,174 @@
+<VisualRange>:
+    id: this
+    spacing: 15
+    orientation: "horizontal"
+    slider: slider
+    tag: tag
+    MDLabel:
+        id: tag
+        text: str(this.option.default) if not isinstance(this.option.default, str) else str(this.option.range_start)
+    MDSlider:
+        id: slider
+        min: this.option.range_start
+        max: this.option.range_end
+        value: min(max(this.option.default, this.option.range_start), this.option.range_end) if not isinstance(this.option.default, str) else this.option.range_start
+        step: 1
+        step_point_size: 0
+        MDSliderHandle:
+
+        MDSliderValueLabel:
+
+<VisualChoice>:
+    id: this
+    text: text
+    MDButtonText:
+        id: text
+        text: this.option.get_option_name(this.option.default if not isinstance(this.option.default, str) else list(this.option.options.values())[0])
+        theme_text_color: "Primary"
+
+<VisualNamedRange>:
+    id: this
+    orientation: "horizontal"
+    spacing: "10dp"
+    padding: (0, 0, "10dp", 0)
+    choice: choice
+
+    MDButton:
+        id: choice
+        text: text
+        MDButtonText:
+            id: text
+            text: this.option.default.title() if this.option.default in this.option.special_range_names else "Custom"
+
+<VisualFreeText>:
+    multiline: False
+    font_size: "15sp"
+    text: self.option.default if isinstance(self.option.default, str) else ""
+    theme_height: "Custom"
+    height: "30dp"
+
+
+<VisualTextChoice>:
+    id: this
+    orientation: "horizontal"
+    spacing: "5dp"
+    padding: (0, 0, "10dp", 0)
+
+<VisualToggle>:
+    id: this
+    button: button
+    MDIconButton:
+        id: button
+        icon: "checkbox-outline" if this.option.default else "checkbox-blank-outline"
+
+<VisualListSetEntry@ResizableTextField>:
+    height: "20dp"
+
+<CounterItemValue>:
+    height: "30dp"
+
+<VisualListSetCounter>:
+    id: this
+    scrollbox: scrollbox
+    add: add
+    save: save
+    input: input
+    focus_behavior: False
+
+    MDDialogHeadlineText:
+        text: getattr(this.option, "display_name", this.name)
+
+    MDDialogSupportingText:
+        text: "Add or Remove Entries"
+
+    MDDialogContentContainer:
+        orientation: "vertical"
+        spacing: 10
+
+        MDBoxLayout:
+            orientation: "horizontal"
+            VisualListSetEntry:
+                id: input
+                height: "20dp"
+
+            MDIconButton:
+                id: add
+                icon: "plus"
+                theme_height: "Custom"
+                height: "20dp"
+                on_press: root.validate_add(input)
+
+        ScrollBox:
+            id: scrollbox
+            size_hint_y: None
+            adapt_minimum: False
+
+        MDButton:
+            id: save
+            MDButtonText:
+                text: "Save Changes"
+
+ContainerLayout:
+    md_bg_color: app.theme_cls.backgroundColor
+
+    MainLayout:
+        id: main
+        cols: 3
+        padding: 3, 5, 0, 3
+        spacing: "2dp"
+
+        ScrollBox:
+            id: scrollbox
+            size_hint_x: None
+            width: "150dp"
+
+        MDDivider:
+            orientation: "vertical"
+            width: "4dp"
+
+        MainLayout:
+            id: player_layout
+            rows: 2
+            spacing: "20dp"
+
+            MDBoxLayout:
+                id: player_options
+                orientation: "horizontal"
+                height: "75dp"
+                size_hint_y: None
+                padding: ["10dp", "30dp", "10dp", 0]
+                spacing: "10dp"
+
+                ResizableTextField:
+                    id: player_name
+                    multiline: False
+
+                    MDTextFieldHintText:
+                        text: "Player Name"
+
+                    MDTextFieldMaxLengthText:
+                        max_text_length: 16
+
+                MDBoxLayout:
+                    orientation: "vertical"
+                    spacing: "15dp"
+
+                    MDLabel:
+                        id: game
+                        text: "Game: None"
+                        pos_hint: {"center_x": 0.5, "center_y": 0.5}
+
+                    MDButton:
+                        pos_hint: {"center_x": 0.5, "center_y": 0.5}
+                        on_press: app.export_options(self)
+                        theme_width: "Custom"
+                        size_hint_y: 1
+                        size_hint_x: 1
+
+                        MDButtonText:
+                            pos_hint: {"center_x": 0.5, "center_y": 0.5}
+                            text: "Export Options"
+
+            MainLayout:
+                cols: 1
+                id: options

deploy/example_config.yaml

@@ -8,3 +8,7 @@ SELFLAUNCH: false
 # Host Address.  This is the address encoded into the patch that will be used for client auto-connect.
 # Set as your local IP (192.168.x.x) to serve over LAN.
 HOST_ADDRESS: localhost
+
+# Asset redistribution rights.  If true, the host affirms they have been given explicit permission to redistribute
+# the proprietary assets in WebHostLib
+#ASSET_RIGHTS: false

docs/CODEOWNERS

@@ -15,6 +15,10 @@
 # A Link to the Past
 /worlds/alttp/ @Berserker66
 
+# APQuest
+# NewSoupVi is acting maintainer, but world belongs to core with the exception of the music
+/worlds/apquest/ @NewSoupVi
+
 # Sudoku (APSudoku)
 /worlds/apsudoku/ @EmilyV99
 
@@ -72,6 +76,9 @@
 # Faxanadu
 /worlds/faxanadu/ @Daivuk
 
+# Final Fantasy (1)
+/worlds/ff1/ @Rosalie-A
+
 # Final Fantasy Mystic Quest
 /worlds/ffmq/ @Alchav @wildham0
 
@@ -241,9 +248,6 @@
 # compatibility, these worlds may be deleted. If you are interested in stepping up as maintainer for
 # any of these worlds, please review `/docs/world maintainer.md` documentation.
 
-# Final Fantasy (1)
-# /worlds/ff1/
-
 # Ocarina of Time
 # /worlds/oot/
 

docs/apworld specification.md

@@ -1,26 +1,83 @@
-# apworld Specification
+# APWorld Specification
 
 Archipelago depends on worlds to provide game-specific details like items, locations and output generation.
-Those are located in the `worlds/` folder (source) or `<install dir>/lib/worlds/` (when installed).
+These are called "APWorlds".
+They are located in the `worlds/` folder (source) or `<install dir>/lib/worlds/` (when installed).
 See [world api.md](world%20api.md) for details.
+APWorlds can either be a folder, or they can be packaged as an .apworld file.
 
-apworld provides a way to package and ship a world that is not part of the main distribution by placing a `*.apworld`
-file into the worlds folder.
+## .apworld File Format
 
-**Warning:** apworlds have to be all lower case, otherwise they raise a bogus Exception when trying to import in frozen python 3.10+!
+The `.apworld` file format provides a way to package and ship an APWorld that is not part of the main distribution
+by placing a `*.apworld` file into the worlds folder.
 
-
-## File Format
-
-apworld files are zip archives, all lower case, with the file ending `.apworld`.
+`.apworld` files are zip archives, all lower case, with the file ending `.apworld`.
 The zip has to contain a folder with the same name as the zip, case-sensitive, that contains what would normally be in
 the world's folder in `worlds/`. I.e. `worlds/ror2.apworld` containing `ror2/__init__.py`.
 
+**Warning:** `.apworld` files have to be all lower case,
+otherwise they raise a bogus Exception when trying to import in frozen python 3.10+!
 
 ## Metadata
 
-No metadata is specified yet.
+Metadata about the APWorld is defined in an `archipelago.json` file.
 
+If the APWorld is a folder, the only required field is "game":
+```json
+{
+  "game": "Game Name"
+}
+```
+
+There are also the following optional fields:
+* `minimum_ap_version` and `maximum_ap_version` - which if present will each be compared against the current
+  Archipelago version respectively to filter those files from being loaded.
+* `world_version` - an arbitrary version for that world in order to only load the newest valid world.
+  An APWorld without a world_version is always treated as older than one with a version
+  (**Must** use exactly the format `"major.minor.build"`, e.g. `1.0.0`)
+* `authors` - a list of authors, to eventually be displayed in various user-facing places such as WebHost and
+  package managers. Should always be a list of strings.
+
+If the APWorld is packaged as an `.apworld` zip file, it also needs to have `version` and `compatible_version`,
+which refer to the version of the APContainer packaging scheme defined in [Files.py](../worlds/Files.py).  
+These get automatically added to the `archipelago.json` of an .apworld if it is packaged using the 
+["Build apworlds" launcher component](#build-apworlds-launcher-component),
+which is the correct way to package your `.apworld` as a world developer. Do not write these fields yourself.
+
+### "Build APWorlds" Launcher Component
+
+In the Archipelago Launcher, there is a "Build APWorlds" component that will package all world folders to `.apworld`,
+and add `archipelago.json` manifest files to them.  
+These .apworld files will be output to `build/apworlds` (relative to the Archipelago root directory).  
+The `archipelago.json` file in each .apworld will automatically include the appropriate
+`version` and `compatible_version`.
+
+If a world folder has an `archipelago.json` in its root, any fields it contains will be carried over.  
+So, a world folder with an `archipelago.json` that looks like this:
+
+```json
+{
+    "game": "Game Name",
+    "minimum_ap_version": "0.6.4",
+    "world_version": "2.1.4",
+    "authors": ["NewSoupVi"]
+}
+```
+
+will be packaged into an `.apworld` with a manifest file inside of it that looks like this:
+
+```json
+{
+    "minimum_ap_version": "0.6.4", 
+    "world_version": "2.1.4",
+    "authors": ["NewSoupVi"],
+    "version": 7,
+    "compatible_version": 7,
+    "game": "Game Name"
+}
+```
+
+This is the recommended workflow for packaging your world to an `.apworld`.
 
 ## Extra Data
 
@@ -29,7 +86,7 @@ The zip can contain arbitrary files in addition what was specified above.
 
 ## Caveats
 
-Imports from other files inside the apworld have to use relative imports. e.g. `from .options import MyGameOptions`
+Imports from other files inside the APWorld have to use relative imports. e.g. `from .options import MyGameOptions`
 
 Imports from AP base have to use absolute imports, e.g. `from Options import Toggle` or
 `from worlds.AutoWorld import World`

docs/entrance randomization.md

@@ -352,14 +352,14 @@ direction_matching_group_lookup = {
 
 Terrain matching or dungeon shuffle:
 ```python
-def randomize_within_same_group(group: int) -> List[int]:
+def randomize_within_same_group(group: int) -> list[int]:
     return [group]
 identity_group_lookup = bake_target_group_lookup(world, randomize_within_same_group)
 ```
 
 Directional + area shuffle:
 ```python
-def get_target_groups(group: int) -> List[int]:
+def get_target_groups(group: int) -> list[int]:
     # example group: LEFT | CAVE
     # example result: [RIGHT | CAVE, DOOR | CAVE]
     direction = group & Groups.DIRECTION_MASK

docs/network protocol.md

@@ -79,7 +79,7 @@ Sent to clients when they connect to an Archipelago server.
 | generator_version     | [NetworkVersion](#NetworkVersion)             | Object denoting the version of Archipelago which generated the multiworld.                                                                                                                                                            |
 | tags                  | list\[str\]                                   | Denotes special features or capabilities that the sender is capable of. Example: `WebHost`                                                                                                                                            |
 | password              | bool                                          | Denoted whether a password is required to join this room.                                                                                                                                                                             |
-| permissions           | dict\[str, [Permission](#Permission)\[int\]\] | Mapping of permission name to [Permission](#Permission), keys are: "release", "collect" and "remaining".                                                                                                                              |
+| permissions           | dict\[str, [Permission](#Permission)\]        | Mapping of permission name to [Permission](#Permission), keys are: "release", "collect" and "remaining".                                                                                                                              |
 | hint_cost             | int                                           | The percentage of total locations that need to be checked to receive a hint from the server.                                                                                                                                          |
 | location_check_points | int                                           | The amount of hint points you receive per item/location check completed.                                                                                                                                                              |
 | games                 | list\[str\]                                   | List of games present in this multiworld.                                                                                                                                                                                             |
@@ -647,6 +647,16 @@ class Version(NamedTuple):
     build: int
 ```
 
+If constructing version information as a dict for a custom client rather than as a NamedTuple built into the CommonClient, you must add the `class` key to allow Archipelago to compare version support.
+```
+"version": {
+      "class": "Version",
+      "build": X,
+      "major": Y,
+      "minor": Z
+    }
+```
+
 ### SlotType
 An enum representing the nature of a slot.
 
@@ -662,13 +672,14 @@ class SlotType(enum.IntFlag):
 An object representing static information about a slot.
 
 ```python
-import typing
+from collections.abc import Sequence
+from typing import NamedTuple
 from NetUtils import SlotType
-class NetworkSlot(typing.NamedTuple):
+class NetworkSlot(NamedTuple):
    name: str
    game: str
    type: SlotType
-   group_members: typing.List[int] = []  # only populated if type == group
+   group_members: Sequence[int] = []  # only populated if type == group
 ```
 
 ### Permission
@@ -686,8 +697,8 @@ class Permission(enum.IntEnum):
 ### Hint
 An object representing a Hint.
 ```python
-import typing
-class Hint(typing.NamedTuple):
+from typing import NamedTuple
+class Hint(NamedTuple):
     receiving_player: int
     finding_player: int
     location: int

docs/options api.md

@@ -269,7 +269,8 @@ placed on them.
 
 ### PriorityLocations
 Marks locations given here as `LocationProgressType.Priority` forcing progression items on them if any are available in
-the pool.
+the pool. Progression items without a deprioritized flag will be used first when filling priority_locations. Progression items with
+a deprioritized flag will be used next.
 
 ### ItemLinks
 Allows users to share their item pool with other players. Currently item links are per game. A link of one game between

docs/settings api.md

@@ -28,7 +28,7 @@ if it does not exist.
 ## Global Settings
 
 All non-world-specific settings are defined directly in settings.py.
-Each value needs to have a default. If the default should be `None`, define it as `typing.Optional` and assign `None`.
+Each value needs to have a default. If the default should be `None`, annotate it using `T | None = None`.
 
 To access a "global" config value, with correct typing, use one of
 ```python

docs/style.md

@@ -15,8 +15,10 @@
 * Prefer [format string literals](https://peps.python.org/pep-0498/) over string concatenation,
   use single quotes inside them: `f"Like {dct['key']}"`
 * Use type annotations where possible for function signatures and class members.
-* Use type annotations where appropriate for local variables (e.g. `var: List[int] = []`, or when the
-  type is hard or impossible to deduce.) Clear annotations help developers look up and validate API calls.
+* Use type annotations where appropriate for local variables (e.g. `var: list[int] = []`, or when the
+  type is hard or impossible to deduce). Clear annotations help developers look up and validate API calls.
+* Prefer new style type annotations for new code (e.g. `var: dict[str, str | int]` over
+  `var: Dict[str, Union[str, int]]`).
 * If a line ends with an open bracket/brace/parentheses, the matching closing bracket should be at the
   beginning of a line at the same indentation as the beginning of the line with the open bracket.
   ```python
@@ -60,3 +62,9 @@
 * Indent `case` inside `switch ` with 2 spaces.
 * Use single quotes.
 * Semicolons are required after every statement.
+
+## KV
+
+* Style should be defined in `.kv` as much as possible, only Python when unavailable.
+* Should follow [our Python style](#python-code) where appropriate (quotation marks, indentation).
+* When escaping a line break, add a space between code and backslash.

docs/tests.md

@@ -82,10 +82,10 @@ overridden. For more information on what methods are available to your class, ch
 
 #### Alternatives to WorldTestBase
 
-Unit tests can also be created using [TestBase](/test/bases.py#L16) or
-[unittest.TestCase](https://docs.python.org/3/library/unittest.html#unittest.TestCase) depending on your use case. These
-may be useful for generating a multiworld under very specific constraints without using the generic world setup, or for
-testing portions of your code that can be tested without relying on a multiworld to be created first.
+Unit tests can also be created using
+[unittest.TestCase](https://docs.python.org/3/library/unittest.html#unittest.TestCase) directly. These may be useful
+for generating a multiworld under very specific constraints without using the generic world setup, or for testing
+portions of your code that can be tested without relying on a multiworld to be created first.
 
 #### Parametrization
 
@@ -102,8 +102,7 @@ for multiple inputs) the base test. Some important things to consider when attem
 
 * Classes inheriting from `WorldTestBase`, including those created by the helpers in `test.param`, will run all
   base tests by default, make sure the produced tests actually do what you aim for and do not waste a lot of
-  extra CPU time. Consider using `TestBase` or `unittest.TestCase` directly
-  or setting `WorldTestBase.run_default_tests` to False.
+  extra CPU time. Consider using `unittest.TestCase` directly or setting `WorldTestBase.run_default_tests` to False.
 
 #### Performance Considerations
 

docs/webhost api.md

@@ -18,6 +18,8 @@ Current endpoints:
     - [`/room_status/<suuid:room_id>`](#roomstatus)
 - Tracker API
     - [`/tracker/<suuid:tracker>`](#tracker)
+    - [`/static_tracker/<suuid:tracker>`](#statictracker)
+    - [`/slot_data_tracker/<suuid:tracker>`](#slotdatatracker)
 - User API
     - [`/get_rooms`](#getrooms)
     - [`/get_seeds`](#getseeds)
@@ -254,8 +256,6 @@ can either be viewed while on a room tracker page, or from the [room's endpoint]
 <a name=tracker></a>
 Will provide a dict of tracker data with the following keys:
 
-- item_link groups and their players (`groups`)
-- Each player's slot_data (`slot_data`)
 - Each player's current alias (`aliases`)
   - Will return the name if there is none
 - A list of items each player has received as a NetworkItem (`player_items_received`)
@@ -265,111 +265,55 @@ Will provide a dict of tracker data with the following keys:
 - The time of last activity of each player in RFC 1123 format (`activity_timers`)
 - The time of last active connection of each player in RFC 1123 format (`connection_timers`)
 - The current client status of each player (`player_status`)
-- The datapackage hash for each player (`datapackage`)
-  - This hash can then be sent to the datapackage API to receive the appropriate datapackage as necessary
-
 
 Example:
 ```json
 {
-  "groups": [
-    {
-      "team": 0,
-      "groups": [
-        {
-          "slot": 5,
-          "name": "testGroup",
-          "members": [
-            1,
-            2
-          ]
-        },
-        {
-          "slot": 6,
-          "name": "myCoolLink",
-          "members": [
-            3,
-            4
-          ]
-        }
-      ]
-    }
-  ],
-  "slot_data": [
-    {
-      "team": 0,
-      "players": [
-        {
-          "player": 1,
-          "slot_data": {
-            "example_option": 1,
-            "other_option": 3
-          }
-        },
-        {
-          "player": 2,
-          "slot_data": {
-            "example_option": 1,
-            "other_option": 2
-          }
-        }
-      ]
-    }
-  ],
   "aliases": [
     {
       "team": 0,
-      "players": [
-        {
-          "player": 1,
-          "alias": "Incompetence"
-        },
-        {
-          "player": 2,
-          "alias": "Slot_Name_2"
-        }
-      ]
+      "player": 1,
+      "alias": "Incompetence"
+    },
+    {
+      "team": 0,
+      "player": 2,
+      "alias": "Slot_Name_2"
     }
   ],
   "player_items_received": [
     {
       "team": 0,
-      "players": [
-        {
-          "player": 1,
-          "items": [
-            [1, 1, 1, 0],
-            [2, 2, 2, 1]
-          ]
-        },
-        {
-          "player": 2,
-          "items": [
-            [1, 1, 1, 2],
-            [2, 2, 2, 0]
-          ]
-        }
+      "player": 1,
+      "items": [
+        [1, 1, 1, 0],
+        [2, 2, 2, 1]
+      ]
+    },
+    {
+      "team": 0,
+      "player": 2,
+      "items": [
+        [1, 1, 1, 2],
+        [2, 2, 2, 0]
       ]
     }
   ],
   "player_checks_done": [
     {
       "team": 0,
-      "players": [
-        {
-          "player": 1,
-          "locations": [
-            1,
-            2
-          ]
-        },
-        {
-          "player": 2,
-          "locations": [
-            1,
-            2
-          ]
-        }
+      "player": 1,
+      "locations": [
+        1,
+        2
+      ]
+    },
+    {
+      "team": 0,
+      "player": 2,
+      "locations": [
+        1,
+        2
       ]
     }
   ],
@@ -382,76 +326,146 @@ Example:
   "hints": [
     {
       "team": 0,
-      "players": [
-        {
-          "player": 1,
-          "hints": [
-            [1, 2, 4, 6, 0, "", 4, 0]
-          ]
-        },
-        {
-          "player": 2,
-          "hints": []
-        }
+      "player": 1,
+      "hints": [
+        [1, 2, 4, 6, 0, "", 4, 0]
       ]
+    },
+    {
+      "team": 0,
+      "player": 2,
+      "hints": []
     }
   ],
   "activity_timers": [
     {
       "team": 0,
-      "players": [
-        {
-          "player": 1,
-          "time": "Fri, 18 Apr 2025 20:35:45 GMT"
-        },
-        {
-          "player": 2,
-          "time": "Fri, 18 Apr 2025 20:42:46 GMT"
-        }
-      ]
+      "player": 1,
+      "time": "Fri, 18 Apr 2025 20:35:45 GMT"
+    },
+    {
+      "team": 0,
+      "player": 2,
+      "time": "Fri, 18 Apr 2025 20:42:46 GMT"
     }
   ],
   "connection_timers": [
     {
       "team": 0,
-      "players": [
-        {
-          "player": 1,
-          "time": "Fri, 18 Apr 2025 20:38:25 GMT"
-        },
-        {
-          "player": 2,
-          "time": "Fri, 18 Apr 2025 21:03:00 GMT"
-        }
-      ]
+      "player": 1,
+      "time": "Fri, 18 Apr 2025 20:38:25 GMT"
+    },
+    {
+      "team": 0,
+      "player": 2,
+      "time": "Fri, 18 Apr 2025 21:03:00 GMT"
     }
   ],
   "player_status": [
     {
       "team": 0,
-      "players": [
-        {
-          "player": 1,
-          "status": 0
-        },
-        {
-          "player": 2,
-          "status": 0
-        }
+      "player": 1,
+      "status": 0
+    },
+    {
+      "team": 0,
+      "player": 2,
+      "status": 0
+    }
+  ]
+}
+```
+
+### `/static_tracker/<suuid:tracker>`
+<a name=statictracker></a>
+Will provide a dict of static tracker data with the following keys:
+
+- item_link groups and their players (`groups`)
+- The datapackage hash for each game (`datapackage`)
+  - This hash can then be sent to the datapackage API to receive the appropriate datapackage as necessary
+- The number of checks found vs. total checks available per player (`player_locations_total`)
+  - Same logic as the multitracker template: found = len(player_checks_done.locations) / total = player_locations_total.total_locations (all available checks).
+- The game each player is playing (`player_game`)
+  - Provided as a list of objects with `team`, `player`, and `game`.
+
+Example:
+```json
+{
+  "groups": [
+    {
+      "slot": 5,
+      "name": "testGroup",
+      "members": [
+        1,
+        2
+      ]
+    },
+    {
+      "slot": 6,
+      "name": "myCoolLink",
+      "members": [
+        3,
+        4
       ]
     }
   ],
   "datapackage": {
     "Archipelago": {
-      "checksum": "ac9141e9ad0318df2fa27da5f20c50a842afeecb",
-      "version": 0
+      "checksum": "ac9141e9ad0318df2fa27da5f20c50a842afeecb"
     },
     "The Messenger": {
-      "checksum": "6991cbcda7316b65bcb072667f3ee4c4cae71c0b",
-      "version": 0
+      "checksum": "6991cbcda7316b65bcb072667f3ee4c4cae71c0b"
+    }
+  },
+  "player_locations_total": [
+    {
+      "player": 1,
+      "team" : 0,
+      "total_locations": 10
+    },
+    {
+      "player": 2,
+      "team" : 0,
+      "total_locations": 20
+    }
+  ],
+  "player_game": [
+    {
+      "team": 0,
+      "player": 1,
+      "game": "Archipelago"
+    },
+    {
+      "team": 0,
+      "player": 2,
+      "game": "The Messenger"
+    }
+  ]
+}
+```
+
+### `/slot_data_tracker/<suuid:tracker>`
+<a name=slotdatatracker></a>
+Will provide a list of each player's slot_data.
+
+Example:
+```json
+[
+  {
+    "player": 1,
+    "slot_data": {
+      "example_option": 1,
+      "other_option": 3
+    }
+  },
+  {
+    "player": 2,
+    "slot_data": {
+      "example_option": 1,
+      "other_option": 2
     }
   }
-}
+]
 ```
 
 ## User Endpoints
@@ -554,4 +568,4 @@ Example:
         "seed_id": "a528e34c-3b4f-42a9-9f8f-00a4fd40bacb"
     }
 ]
-```
+```

docs/world api.md

@@ -76,8 +76,8 @@ webhost:
 * `game_info_languages` (optional) list of strings for defining the existing game info pages your game supports. The
   documents must be prefixed with the same string as defined here. Default already has 'en'.
 
-* `options_presets` (optional) `Dict[str, Dict[str, Any]]` where the keys are the names of the presets and the values
-  are the options to be set for that preset. The options are defined as a `Dict[str, Any]` where the keys are the names
+* `options_presets` (optional) `dict[str, dict[str, Any]]` where the keys are the names of the presets and the values
+  are the options to be set for that preset. The options are defined as a `dict[str, Any]` where the keys are the names
   of the options and the values are the values to be set for that option. These presets will be available for users to
   select from on the game's options page.
 
@@ -753,7 +753,7 @@ from BaseClasses import CollectionState, MultiWorld
 from worlds.AutoWorld import LogicMixin
 
 class MyGameState(LogicMixin):
-    mygame_defeatable_enemies: Dict[int, Set[str]]  # per player
+    mygame_defeatable_enemies: dict[int, set[str]]  # per player
 
     def init_mixin(self, multiworld: MultiWorld) -> None:
         # Initialize per player with the corresponding "nothing" value, such as 0 or an empty set.
@@ -882,11 +882,11 @@ item/location pairs is unnecessary since the AP server already retains and freel
 that request it. The most common usage of slot data is sending option results that the client needs to be aware of.
 
 ```python
-def fill_slot_data(self) -> Dict[str, Any]:
+def fill_slot_data(self) -> dict[str, Any]:
     # In order for our game client to handle the generated seed correctly we need to know what the user selected
     # for their difficulty and final boss HP.
     # A dictionary returned from this method gets set as the slot_data and will be sent to the client after connecting.
-    # The options dataclass has a method to return a `Dict[str, Any]` of each option name provided and the relevant
+    # The options dataclass has a method to return a `dict[str, Any]` of each option name provided and the relevant
     # option's value.
     return self.options.as_dict("difficulty", "final_boss_hp")
 ```

entrance_rando.py

@@ -525,7 +525,7 @@ def randomize_entrances(
 
     running_time = time.perf_counter() - start_time
     if running_time > 1.0:
-        logging.info(f"Took {running_time:.4f} seconds during entrance randomization for player {world.player},"
+        logging.info(f"Took {running_time:.4f} seconds during entrance randomization for player {world.player}, "
                      f"named {world.multiworld.player_name[world.player]}")
 
     return er_state

inno_setup.iss

@@ -180,8 +180,8 @@ Root: HKCR; Subkey: "{#MyAppName}mm2patch\shell\open\command";  ValueData: """{a
 
 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: "";
-Root: HKCR; Subkey: "{#MyAppName}ladxpatch\shell\open\command";  ValueData: """{app}\ArchipelagoLinksAwakeningClient.exe"" ""%1""";                  ValueType: string;  ValueName: "";
+Root: HKCR; Subkey: "{#MyAppName}ladxpatch\DefaultIcon";         ValueData: "{app}\ArchipelagoLauncher.exe,0";                           ValueType: string;  ValueName: "";
+Root: HKCR; Subkey: "{#MyAppName}ladxpatch\shell\open\command";  ValueData: """{app}\ArchipelagoLauncher.exe"" ""%1""";                  ValueType: string;  ValueName: "";
 
 Root: HKCR; Subkey: ".aptloz";                                   ValueData: "{#MyAppName}tlozpatch";        Flags: uninsdeletevalue; ValueType: string;  ValueName: "";
 Root: HKCR; Subkey: "{#MyAppName}tlozpatch";                     ValueData: "Archipelago The Legend of Zelda Patch"; Flags: uninsdeletekey;   ValueType: string;  ValueName: "";

kvui.py

@@ -34,6 +34,28 @@ from kivy.config import Config
 Config.set("input", "mouse", "mouse,disable_multitouch")
 Config.set("kivy", "exit_on_escape", "0")
 Config.set("graphics", "multisamples", "0")  # multisamples crash old intel drivers
+
+# Workaround for Kivy issue #9226.
+# caused by kivy by default using probesysfs,
+# which assumes all multi touch deviecs are touch screens. 
+# workaround provided by Snu of the kivy commmunity c:
+from kivy.utils import platform
+if platform == "linux":
+    options = Config.options("input")
+    for option in options:
+        if Config.get("input", option) == "probesysfs":
+            Config.remove_option("input", option)
+
+# Workaround for an issue where importing kivy.core.window before loading sounds
+# will hang the whole application on Linux once the first sound is loaded.
+# kivymd imports kivy.core.window, so we have to do this before the first kivymd import.
+# No longer necessary when we switch to kivy 3.0.0, which fixes this issue.
+from kivy.core.audio import SoundLoader
+for classobj in SoundLoader._classes:
+    # The least invasive way to force a SoundLoader class to load its audio engine seems to be calling
+    # .extensions(), which e.g. in audio_sdl2.pyx then calls a function called "mix_init()"
+    classobj.extensions()
+
 from kivymd.uix.divider import MDDivider
 from kivy.core.window import Window
 from kivy.core.clipboard import Clipboard
@@ -116,7 +138,7 @@ class ImageButton(MDIconButton):
             val = kwargs.pop(kwarg, "None")
             if val != "None":
                 image_args[kwarg.replace("image_", "")] = val
-        super().__init__()
+        super().__init__(**kwargs)
         self.image = ApAsyncImage(**image_args)
 
         def set_center(button, center):
@@ -132,6 +154,7 @@ class ImageButton(MDIconButton):
 
 class ScrollBox(MDScrollView):
     layout: MDBoxLayout = ObjectProperty(None)
+    box_height: int = NumericProperty(dp(100))
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
@@ -142,6 +165,7 @@ class ToggleButton(MDButton, ToggleButtonBehavior):
     def __init__(self, *args, **kwargs):
         super(ToggleButton, self).__init__(*args, **kwargs)
         self.bind(state=self._update_bg)
+        self._update_bg(self, self.state)
 
     def _update_bg(self, _, state: str):
         if self.disabled:
@@ -159,7 +183,7 @@ class ToggleButton(MDButton, ToggleButtonBehavior):
                 child.text_color = self.theme_cls.onPrimaryColor
                 child.icon_color = self.theme_cls.onPrimaryColor
         else:
-            self.md_bg_color = self.theme_cls.surfaceContainerLowestColor
+            self.md_bg_color = self.theme_cls.surfaceContainerLowColor
             for child in self.children:
                 if child.theme_text_color == "Primary":
                     child.theme_text_color = "Custom"
@@ -173,7 +197,6 @@ class ToggleButton(MDButton, ToggleButtonBehavior):
 class ResizableTextField(MDTextField):
     """
     Resizable MDTextField that manually overrides the builtin sizing.
-
     Note that in order to use this, the sizing must be specified from within a .kv rule.
     """
     def __init__(self, *args, **kwargs):
@@ -237,7 +260,7 @@ Factory.register("HoverBehavior", HoverBehavior)
 
 
 class ToolTip(MDTooltipPlain):
-    pass
+    markup = True
 
 
 class ServerToolTip(ToolTip):
@@ -272,6 +295,8 @@ class TooltipLabel(HovererableLabel, MDTooltip):
     def on_mouse_pos(self, window, pos):
         if not self.get_root_window():
             return  # Abort if not displayed
+        if self.disabled:
+            return
         super().on_mouse_pos(window, pos)
         if self.refs and self.hovered:
 
@@ -838,15 +863,15 @@ class GameManager(ThemedApp):
         self.log_panels: typing.Dict[str, Widget] = {}
 
         # keep track of last used command to autofill on click
-        self.last_autofillable_command = "hint"
-        autofillable_commands = ("hint_location", "hint", "getitem")
+        self.last_autofillable_command = "!hint"
+        autofillable_commands = ("!hint_location", "!hint", "!getitem")
         original_say = ctx.on_user_say
 
         def intercept_say(text):
             text = original_say(text)
             if text:
                 for command in autofillable_commands:
-                    if text.startswith("!" + command):
+                    if text.startswith(command):
                         self.last_autofillable_command = command
                         break
             return text
@@ -1099,10 +1124,6 @@ class GameManager(ThemedApp):
         hints = self.ctx.stored_data.get(f"_read_hints_{self.ctx.team}_{self.ctx.slot}", [])
         self.hint_log.refresh_hints(hints)
 
-    # default F1 keybind, opens a settings menu, that seems to break the layout engine once closed
-    def open_settings(self, *largs):
-        pass
-
 
 class LogtoUI(logging.Handler):
     def __init__(self, on_log):

requirements.txt

@@ -1,17 +1,17 @@
 colorama>=0.4.6
 websockets>=13.0.1,<14
-PyYAML>=6.0.2
-jellyfish>=1.1.3
+PyYAML>=6.0.3
+jellyfish>=1.2.1
 jinja2>=3.1.6
-schema>=0.7.7
+schema>=0.7.8
 kivy>=2.3.1
 bsdiff4>=1.2.6
-platformdirs>=4.3.6
-certifi>=2025.4.26
-cython>=3.0.12
-cymem>=2.0.11
-orjson>=3.10.15
-typing_extensions>=4.12.2
-pyshortcuts>=1.9.1
+platformdirs>=4.5.0
+certifi>=2025.11.12
+cython>=3.2.1
+cymem>=2.0.13
+orjson>=3.11.4
+typing_extensions>=4.15.0
+pyshortcuts>=1.9.6
 kivymd @ git+https://github.com/kivymd/KivyMD@5ff9d0d
 kivymd>=2.0.1.dev0

ruff.toml

@@ -0,0 +1,16 @@
+line-length = 120
+indent-width = 4
+target-version = "py311"
+
+[lint]
+select = ["B", "C", "E", "F", "W", "I", "N", "Q", "UP", "RET", "RSE", "RUF", "ISC", "PLC", "PLE", "PLW", "T20", "PERF"]
+ignore = [
+    "B011",  # In AP, the use of assert False is essential because we optimise out these statements for release builds.
+    "C901",  # Author disagrees with limiting branch complexity
+    "N818",  # Author agrees with this rule, but Core AP violates this and changing it would be a hassle.
+    "PLC0415",  # In AP, we consider local imports totally fine & necessary
+    "PLC1802",  # Author agrees with this rule, but it literally changes the functionality of the code, which is unsafe.
+    "PLC1901",  # This is just not equivalent
+    "PLE1141",  # Gives false positives when the dict keys are tuples, but does not mention this in the suggested fix.
+    "UP015",  # Explicit is better than implicit, so we'd prefer to keep "r" in open() calls.
+]

settings.py

@@ -579,6 +579,17 @@ class ServerOptions(Group):
         "goal" -> Client can ask for remaining items after goal completion
         """
 
+    class CountdownMode(str):
+        """
+        Countdown modes
+        Determines whether or not a player can initiate a countdown with !countdown
+        Note that /countdown is always available to the host.
+
+        "enabled" -> Client can always initiate a countdown with !countdown.
+        "disabled" -> Client can never initiate a countdown with !countdown.
+        "auto" -> !countdown will be available for any room with less than 30 slots.
+        """
+
     class AutoShutdown(int):
         """Automatically shut down the server after this many seconds without new location checks, 0 to keep running"""
 
@@ -613,6 +624,7 @@ class ServerOptions(Group):
     release_mode: ReleaseMode = ReleaseMode("auto")
     collect_mode: CollectMode = CollectMode("auto")
     remaining_mode: RemainingMode = RemainingMode("goal")
+    countdown_mode: CountdownMode = CountdownMode("auto")
     auto_shutdown: AutoShutdown = AutoShutdown(0)
     compatibility: Compatibility = Compatibility(2)
     log_network: LogNetwork = LogNetwork(0)

setup.py

@@ -22,7 +22,7 @@ SNI_VERSION = "v0.0.100"  # change back to "latest" once tray icon issues are fi
 
 
 # This is a bit jank. We need cx-Freeze to be able to run anything from this script, so install it
-requirement = 'cx-Freeze==8.0.0'
+requirement = 'cx-Freeze==8.4.0'
 try:
     import pkg_resources
     try:
@@ -146,7 +146,16 @@ def download_SNI() -> None:
 
 signtool: str | None = None
 try:
-    with urllib.request.urlopen('http://192.168.206.4:12345/connector/status') as response:
+    import socket
+
+    sign_host, sign_port = "192.168.206.4", 12345
+    # check if the sign_host is on a local network
+    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    s.connect((sign_host, sign_port))
+    if s.getsockname()[0].rsplit(".", 1)[0] != sign_host.rsplit(".", 1)[0]:
+        raise ConnectionError()  # would go through default route
+    # configure signtool
+    with urllib.request.urlopen(f"http://{sign_host}:{sign_port}/connector/status") as response:
         html = response.read()
     if b"status=OK\n" in html:
         signtool = (r'signtool sign /sha1 6df76fe776b82869a5693ddcb1b04589cffa6faf /fd sha256 /td sha256 '
@@ -371,6 +380,7 @@ class BuildExeCommand(cx_Freeze.command.build_exe.build_exe):
         os.makedirs(self.buildfolder / "Players" / "Templates", exist_ok=True)
         from Options import generate_yaml_templates
         from worlds.AutoWorld import AutoWorldRegister
+        from worlds.Files import APWorldContainer
         assert not non_apworlds - set(AutoWorldRegister.world_types), \
             f"Unknown world {non_apworlds - set(AutoWorldRegister.world_types)} designated for .apworld"
         folders_to_remove: list[str] = []
@@ -379,13 +389,36 @@ class BuildExeCommand(cx_Freeze.command.build_exe.build_exe):
             if worldname not in non_apworlds:
                 file_name = os.path.split(os.path.dirname(worldtype.__file__))[1]
                 world_directory = self.libfolder / "worlds" / file_name
+                if os.path.isfile(world_directory / "archipelago.json"):
+                    with open(os.path.join(world_directory, "archipelago.json"), mode="r", encoding="utf-8") as manifest_file:
+                        manifest = json.load(manifest_file)
+
+                    assert "game" in manifest, (
+                        f"World directory {world_directory} has an archipelago.json manifest file, but it "
+                        "does not define a \"game\"."
+                    )
+                    assert manifest["game"] == worldtype.game, (
+                        f"World directory {world_directory} has an archipelago.json manifest file, but value of the "
+                        f"\"game\" field ({manifest['game']} does not equal the World class's game ({worldtype.game})."
+                    )
+                else:
+                    manifest = {}
                 # this method creates an apworld that cannot be moved to a different OS or minor python version,
                 # which should be ok
-                with zipfile.ZipFile(self.libfolder / "worlds" / (file_name + ".apworld"), "x", zipfile.ZIP_DEFLATED,
+                zip_path = self.libfolder / "worlds" / (file_name + ".apworld")
+                apworld = APWorldContainer(str(zip_path))
+                apworld.minimum_ap_version = version_tuple
+                apworld.maximum_ap_version = version_tuple
+                apworld.game = worldtype.game
+                manifest.update(apworld.get_manifest())
+                apworld.manifest_path = f"{file_name}/archipelago.json"
+                with zipfile.ZipFile(zip_path, "x", zipfile.ZIP_DEFLATED,
                                      compresslevel=9) as zf:
                     for path in world_directory.rglob("*.*"):
                         relative_path = os.path.join(*path.parts[path.parts.index("worlds")+1:])
-                        zf.write(path, relative_path)
+                        if not relative_path.endswith("archipelago.json"):
+                            zf.write(path, relative_path)
+                    zf.writestr(apworld.manifest_path, json.dumps(manifest))
                     folders_to_remove.append(file_name)
                 shutil.rmtree(world_directory)
         shutil.copyfile("meta.yaml", self.buildfolder / "Players" / "Templates" / "meta.yaml")

test/bases.py

@@ -9,98 +9,7 @@ from test.general import gen_steps
 from worlds import AutoWorld
 from worlds.AutoWorld import World, call_all
 
-from BaseClasses import Location, MultiWorld, CollectionState, ItemClassification, Item
-from worlds.alttp.Items import item_factory
-
-
-class TestBase(unittest.TestCase):
-    multiworld: MultiWorld
-    _state_cache = {}
-
-    def get_state(self, items):
-        if (self.multiworld, tuple(items)) in self._state_cache:
-            return self._state_cache[self.multiworld, tuple(items)]
-        state = CollectionState(self.multiworld)
-        for item in items:
-            item.classification = ItemClassification.progression
-            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
-
-    def get_path(self, state, region):
-        def flist_to_iter(node):
-            while node:
-                value, node = node
-                yield value
-
-        from itertools import zip_longest
-        reversed_path_as_flist = state.path.get(region, (region, None))
-        string_path_flat = reversed(list(map(str, flist_to_iter(reversed_path_as_flist))))
-        # Now we combine the flat string list into (region, exit) pairs
-        pathsiter = iter(string_path_flat)
-        pathpairs = zip_longest(pathsiter, pathsiter)
-        return list(pathpairs)
-
-    def run_location_tests(self, access_pool):
-        for i, (location, access, *item_pool) in enumerate(access_pool):
-            items = item_pool[0]
-            all_except = item_pool[1] if len(item_pool) > 1 else None
-            state = self._get_items(item_pool, all_except)
-            path = self.get_path(state, self.multiworld.get_location(location, 1).parent_region)
-            with self.subTest(msg="Reach Location", location=location, access=access, items=items,
-                              all_except=all_except, path=path, entry=i):
-
-                self.assertEqual(self.multiworld.get_location(location, 1).can_reach(state), access,
-                                 f"failed {self.multiworld.get_location(location, 1)} with: {item_pool}")
-
-            # check for partial solution
-            if not all_except and access:  # we are not supposed to be able to reach location with partial inventory
-                for missing_item in item_pool[0]:
-                    with self.subTest(msg="Location reachable without required item", location=location,
-                                      items=item_pool[0], missing_item=missing_item, entry=i):
-                        state = self._get_items_partial(item_pool, missing_item)
-
-                        self.assertEqual(self.multiworld.get_location(location, 1).can_reach(state), False,
-                                         f"failed {self.multiworld.get_location(location, 1)}: succeeded with "
-                                         f"{missing_item} removed from: {item_pool}")
-
-    def run_entrance_tests(self, access_pool):
-        for i, (entrance, access, *item_pool) in enumerate(access_pool):
-            items = item_pool[0]
-            all_except = item_pool[1] if len(item_pool) > 1 else None
-            state = self._get_items(item_pool, all_except)
-            path = self.get_path(state, self.multiworld.get_entrance(entrance, 1).parent_region)
-            with self.subTest(msg="Reach Entrance", entrance=entrance, access=access, items=items,
-                              all_except=all_except, path=path, entry=i):
-
-                self.assertEqual(self.multiworld.get_entrance(entrance, 1).can_reach(state), access)
-
-            # check for partial solution
-            if not all_except and access:  # we are not supposed to be able to reach location with partial inventory
-                for missing_item in item_pool[0]:
-                    with self.subTest(msg="Entrance reachable without required item", entrance=entrance,
-                                      items=item_pool[0], missing_item=missing_item, entry=i):
-                        state = self._get_items_partial(item_pool, missing_item)
-                        self.assertEqual(self.multiworld.get_entrance(entrance, 1).can_reach(state), False,
-                                         f"failed {self.multiworld.get_entrance(entrance, 1)} with: {item_pool}")
-
-    def _get_items(self, item_pool, all_except):
-        if all_except and len(all_except) > 0:
-            items = self.multiworld.itempool[:]
-            items = [item for item in items if
-                     item.name not in all_except and not ("Bottle" in item.name and "AnyBottle" in all_except)]
-            items.extend(item_factory(item_pool[0], self.multiworld.worlds[1]))
-        else:
-            items = item_factory(item_pool[0], self.multiworld.worlds[1])
-        return self.get_state(items)
-
-    def _get_items_partial(self, item_pool, missing_item):
-        new_items = item_pool[0].copy()
-        new_items.remove(missing_item)
-        items = item_factory(new_items, self.multiworld.worlds[1])
-        return self.get_state(items)
+from BaseClasses import Location, MultiWorld, CollectionState, Item
 
 
 class WorldTestBase(unittest.TestCase):

test/benchmark/compression/benchmark.py

@@ -0,0 +1,227 @@
+#!/usr/bin/env python
+
+# based on python-websockets compression benchmark (c) Aymeric Augustin and contributors
+# https://github.com/python-websockets/websockets/blob/main/experiments/compression/benchmark.py
+
+import collections
+import time
+import zlib
+from typing import Iterable
+
+
+REPEAT = 10
+
+WB, ML = 12, 5  # defaults used as a reference
+WBITS = range(9, 16)
+MEMLEVELS = range(1, 10)
+
+
+def benchmark(data: Iterable[bytes]) -> None:
+    size: dict[int, dict[int, float]] = collections.defaultdict(dict)
+    duration: dict[int, dict[int, float]] = collections.defaultdict(dict)
+
+    for wbits in WBITS:
+        for memLevel in MEMLEVELS:
+            encoder = zlib.compressobj(wbits=-wbits, memLevel=memLevel)
+            encoded = []
+
+            print(f"Compressing {REPEAT} times with {wbits=} and {memLevel=}")
+
+            t0 = time.perf_counter()
+
+            for _ in range(REPEAT):
+                for item in data:
+                    # Taken from PerMessageDeflate.encode
+                    item = encoder.compress(item) + encoder.flush(zlib.Z_SYNC_FLUSH)
+                    if item.endswith(b"\x00\x00\xff\xff"):
+                        item = item[:-4]
+                    encoded.append(item)
+
+            t1 = time.perf_counter()
+
+            size[wbits][memLevel] = sum(len(item) for item in encoded) / REPEAT
+            duration[wbits][memLevel] = (t1 - t0) / REPEAT
+
+    raw_size = sum(len(item) for item in data)
+
+    print("=" * 79)
+    print("Compression ratio")
+    print("=" * 79)
+    print("\t".join(["wb \\ ml"] + [str(memLevel) for memLevel in MEMLEVELS]))
+    for wbits in WBITS:
+        print(
+            "\t".join(
+                [str(wbits)]
+                + [
+                    f"{100 * (1 - size[wbits][memLevel] / raw_size):.1f}%"
+                    for memLevel in MEMLEVELS
+                ]
+            )
+        )
+    print("=" * 79)
+    print()
+
+    print("=" * 79)
+    print("CPU time")
+    print("=" * 79)
+    print("\t".join(["wb \\ ml"] + [str(memLevel) for memLevel in MEMLEVELS]))
+    for wbits in WBITS:
+        print(
+            "\t".join(
+                [str(wbits)]
+                + [
+                    f"{1000 * duration[wbits][memLevel]:.1f}ms"
+                    for memLevel in MEMLEVELS
+                ]
+            )
+        )
+    print("=" * 79)
+    print()
+
+    print("=" * 79)
+    print(f"Size vs. {WB} \\ {ML}")
+    print("=" * 79)
+    print("\t".join(["wb \\ ml"] + [str(memLevel) for memLevel in MEMLEVELS]))
+    for wbits in WBITS:
+        print(
+            "\t".join(
+                [str(wbits)]
+                + [
+                    f"{100 * (size[wbits][memLevel] / size[WB][ML] - 1):.1f}%"
+                    for memLevel in MEMLEVELS
+                ]
+            )
+        )
+    print("=" * 79)
+    print()
+
+    print("=" * 79)
+    print(f"Time vs. {WB} \\ {ML}")
+    print("=" * 79)
+    print("\t".join(["wb \\ ml"] + [str(memLevel) for memLevel in MEMLEVELS]))
+    for wbits in WBITS:
+        print(
+            "\t".join(
+                [str(wbits)]
+                + [
+                    f"{100 * (duration[wbits][memLevel] / duration[WB][ML] - 1):.1f}%"
+                    for memLevel in MEMLEVELS
+                ]
+            )
+        )
+    print("=" * 79)
+    print()
+
+
+def generate_data_package_corpus() -> list[bytes]:
+    # compared to default 12, 5:
+    # 11, 4 saves 16K RAM, gives  +4.6% size,  -5.0% time .. +1.1% time
+    # 10, 4 saves 20K RAM, gives +10.2% size,  -3.8% time .. +0.6% time
+    # 11, 3 saves 20K RAM, gives  +6.5% size, +14.2% time
+    # 10, 3 saves 24K RAM, gives +12.8% size,  +0.5% time .. +6.9% time
+    # NOTE: time delta is highly unstable; time is ~100ms
+    import warnings
+
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore")
+
+        from NetUtils import encode
+        from worlds import network_data_package
+
+        return [encode(network_data_package).encode("utf-8")]
+
+
+def generate_solo_release_corpus() -> list[bytes]:
+    # compared to default 12, 5:
+    # 11, 4 saves 16K RAM, gives  +0.9% size,  +3.9% time
+    # 10, 4 saves 20K RAM, gives  +1.4% size,  +3.4% time
+    # 11, 3 saves 20K RAM, gives  +1.8% size, +13.9% time
+    # 10, 3 saves 24K RAM, gives  +2.1% size,  +4.8% time
+    # NOTE: time delta is highly unstable; time is ~0.4ms
+
+    from random import Random
+    from MultiServer import json_format_send_event
+    from NetUtils import encode, NetworkItem
+
+    r = Random()
+    r.seed(0)
+    solo_release = []
+    solo_release_locations = [r.randint(1000, 1999) for _ in range(200)]
+    solo_release_items = sorted([r.randint(1000, 1999) for _ in range(200)])  # currently sorted by item
+    solo_player = 1
+    for location, item in zip(solo_release_locations, solo_release_items):
+        flags = r.choice((0, 0, 0, 0, 0, 0, 0, 1, 2, 3))
+        network_item = NetworkItem(item, location, solo_player, flags)
+        solo_release.append(json_format_send_event(network_item, solo_player))
+    solo_release.append({
+        "cmd": "ReceivedItems",
+        "index": 0,
+        "items": solo_release_items,
+    })
+    solo_release.append({
+        "cmd": "RoomUpdate",
+        "hint_points": 200,
+        "checked_locations": solo_release_locations,
+    })
+    return [encode(solo_release).encode("utf-8")]
+
+
+def generate_gameplay_corpus() -> list[bytes]:
+    # compared to default 12, 5:
+    # 11, 4 saves 16K RAM, gives  +13.6% size,  +4.1% time
+    # 10, 4 saves 20K RAM, gives  +22.3% size,  +2.2% time
+    # 10, 3 saves 24K RAM, gives  +26.2% size,  +1.6% time
+    # NOTE: time delta is highly unstable; time is 4ms
+
+    from copy import copy
+    from random import Random
+    from MultiServer import json_format_send_event
+    from NetUtils import encode, NetworkItem
+
+    r = Random()
+    r.seed(0)
+    gameplay = []
+    observer = 1
+    hint_points = 0
+    index = 0
+    players = list(range(1, 10))
+    player_locations = {player: [r.randint(1000, 1999) for _ in range(200)] for player in players}
+    player_items = {player: [r.randint(1000, 1999) for _ in range(200)] for player in players}
+    player_receiver = {player: [r.randint(1, len(players)) for _ in range(200)] for player in players}
+    for i in range(0, len(player_locations[1])):
+        player_sequence = copy(players)
+        r.shuffle(player_sequence)
+        for finder in player_sequence:
+            flags = r.choice((0, 0, 0, 0, 0, 0, 0, 1, 2, 3))
+            receiver = player_receiver[finder][i]
+            item = player_items[finder][i]
+            location = player_locations[finder][i]
+            network_item = NetworkItem(item, location, receiver, flags)
+            gameplay.append(json_format_send_event(network_item, observer))
+            if finder == observer:
+                hint_points += 1
+                gameplay.append({
+                    "cmd": "RoomUpdate",
+                    "hint_points": hint_points,
+                    "checked_locations": [location],
+                })
+            if receiver == observer:
+                gameplay.append({
+                    "cmd": "ReceivedItems",
+                    "index": index,
+                    "items": [item],
+                })
+                index += 1
+    return [encode(gameplay).encode("utf-8")]
+
+
+def main() -> None:
+    #corpus = generate_data_package_corpus()
+    #corpus = generate_solo_release_corpus()
+    #corpus = generate_gameplay_corpus()
+    corpus = generate_data_package_corpus() + generate_solo_release_corpus() + generate_gameplay_corpus()
+    benchmark(corpus)
+    print(f"raw size: {sum(len(data) for data in corpus)}")
+
+if __name__ == "__main__":
+    main()

test/benchmark/locations.py

@@ -1,4 +1,12 @@
-def run_locations_benchmark():
+def run_locations_benchmark(freeze_gc: bool = True) -> None:
+    """
+    Run a benchmark of location access rule performance against an empty_state and an all_state.
+
+    :param freeze_gc: Whether to freeze gc before benchmarking and unfreeze gc afterward. Freezing gc moves all objects
+        tracked by the garbage collector to a permanent generation, ignoring them in all future collections. Freezing
+        greatly reduces the duration of running gc.collect() within benchmarks, which otherwise often takes much longer
+        than running all iterations for the location rule being benchmarked.
+    """
     import argparse
     import logging
     import gc
@@ -34,6 +42,8 @@ def run_locations_benchmark():
             return "\n".join(f"  {time:.4f} in {name}" for name, time in counter.most_common(top))
 
         def location_test(self, test_location: Location, state: CollectionState, state_name: str) -> float:
+            if freeze_gc:
+                gc.freeze()
             with TimeIt(f"{test_location.game} {self.rule_iterations} "
                         f"runs of {test_location}.access_rule({state_name})", logger) as t:
                 for _ in range(self.rule_iterations):
@@ -41,6 +51,8 @@ def run_locations_benchmark():
                 # if time is taken to disentangle complex ref chains,
                 # this time should be attributed to the rule.
                 gc.collect()
+            if freeze_gc:
+                gc.unfreeze()
             return t.dif
 
         def main(self):
@@ -64,9 +76,13 @@ def run_locations_benchmark():
 
                     gc.collect()
                     for step in self.gen_steps:
+                        if freeze_gc:
+                            gc.freeze()
                         with TimeIt(f"{game} step {step}", logger):
                             call_all(multiworld, step)
                             gc.collect()
+                        if freeze_gc:
+                            gc.unfreeze()
 
                     locations = sorted(multiworld.get_unfilled_locations())
                     if not locations:

test/general/__init__.py

@@ -1,5 +1,5 @@
 from argparse import Namespace
-from typing import List, Optional, Tuple, Type, Union
+from typing import Any, List, Optional, Tuple, Type
 
 from BaseClasses import CollectionState, Item, ItemClassification, Location, MultiWorld, Region
 from worlds import network_data_package
@@ -31,8 +31,8 @@ def setup_solo_multiworld(
     return setup_multiworld(world_type, steps, seed)
 
 
-def setup_multiworld(worlds: Union[List[Type[World]], Type[World]], steps: Tuple[str, ...] = gen_steps,
-                     seed: Optional[int] = None) -> MultiWorld:
+def setup_multiworld(worlds: list[type[World]] | type[World], steps: tuple[str, ...] = gen_steps,
+                     seed: int | None = None, options: dict[str, Any] | list[dict[str, Any]] = None) -> MultiWorld:
     """
     Creates a multiworld with a player for each provided world type, allowing duplicates, setting default options, and
     calling the provided gen steps.
@@ -40,20 +40,27 @@ def setup_multiworld(worlds: Union[List[Type[World]], Type[World]], steps: Tuple
     :param worlds: Type/s of worlds to generate a multiworld for
     :param steps: Gen steps that should be called before returning. Default calls through pre_fill
     :param seed: The seed to be used when creating this multiworld
+    :param options: Options to set on each world. If just one dict of options is passed, it will be used for all worlds.
     :return: The generated multiworld
     """
     if not isinstance(worlds, list):
         worlds = [worlds]
+
+    if options is None:
+        options = [{}] * len(worlds)
+    elif not isinstance(options, list):
+        options = [options] * len(worlds)
+
     players = len(worlds)
     multiworld = MultiWorld(players)
     multiworld.game = {player: world_type.game for player, world_type in enumerate(worlds, 1)}
     multiworld.player_name = {player: f"Tester{player}" for player in multiworld.player_ids}
     multiworld.set_seed(seed)
     args = Namespace()
-    for player, world_type in enumerate(worlds, 1):
+    for player, (world_type, option_overrides) in enumerate(zip(worlds, options), 1):
         for key, option in world_type.options_dataclass.type_hints.items():
             updated_options = getattr(args, key, {})
-            updated_options[player] = option.from_any(option.default)
+            updated_options[player] = option.from_any(option_overrides.get(key, option.default))
             setattr(args, key, updated_options)
     multiworld.set_options(args)
     multiworld.state = CollectionState(multiworld)

test/general/test_client_server_interaction.py

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

test/general/test_options.py

@@ -1,7 +1,7 @@
 import unittest
 
 from BaseClasses import PlandoOptions
-from Options import ItemLinks, Choice
+from Options import Choice, ItemLinks, PlandoConnections, PlandoItems, PlandoTexts
 from Utils import restricted_dumps
 from worlds.AutoWorld import AutoWorldRegister
 
@@ -44,19 +44,19 @@ class TestOptions(unittest.TestCase):
             }],
             [{
                 "name": "ItemLinkGroup",
-                "item_pool": ["Hammer", "Bow"],
+                "item_pool": ["Hammer", "Sword"],
                 "link_replacement": False,
                 "replacement_item": None,
             }]
         ]
         # we really need some sort of test world but generic doesn't have enough items for this
-        world = AutoWorldRegister.world_types["A Link to the Past"]
+        world = AutoWorldRegister.world_types["APQuest"]
         plando_options = PlandoOptions.from_option_string("bosses")
         item_links = [ItemLinks.from_any(item_link_groups[0]), ItemLinks.from_any(item_link_groups[1])]
         for link in item_links:
             link.verify(world, "tester", plando_options)
             self.assertIn("Hammer", link.value[0]["item_pool"])
-            self.assertIn("Bow", link.value[0]["item_pool"])
+            self.assertIn("Sword", link.value[0]["item_pool"])
         
         # TODO test that the group created using these options has the items
 
@@ -72,8 +72,8 @@ class TestOptions(unittest.TestCase):
         for link in item_links.values():
             self.assertEqual(link.value[0], item_link_group[0])
 
-    def test_pickle_dumps(self):
-        """Test options can be pickled into database for WebHost generation"""
+    def test_pickle_dumps_default(self):
+        """Test that default option values can be pickled into database for WebHost generation"""
         for gamename, world_type in AutoWorldRegister.world_types.items():
             if not world_type.hidden:
                 for option_key, option in world_type.options_dataclass.type_hints.items():
@@ -81,3 +81,23 @@ class TestOptions(unittest.TestCase):
                         restricted_dumps(option.from_any(option.default))
                         if issubclass(option, Choice) and option.default in option.name_lookup:
                             restricted_dumps(option.from_text(option.name_lookup[option.default]))
+    
+    def test_pickle_dumps_plando(self):
+        """Test that plando options using containers of a custom type can be pickled"""
+        # The base PlandoConnections class can't be instantiated directly, create a subclass and then cast it
+        class TestPlandoConnections(PlandoConnections):
+            entrances = {"An Entrance"}
+            exits = {"An Exit"}
+        plando_connection_value = PlandoConnections(
+            TestPlandoConnections.from_any([{"entrance": "An Entrance", "exit": "An Exit"}])
+        )
+
+        plando_values = {
+            "PlandoConnections": plando_connection_value,
+            "PlandoItems": PlandoItems.from_any([{"item": "Something", "location": "Somewhere"}]),
+            "PlandoTexts": PlandoTexts.from_any([{"text": "Some text.", "at": "text_box"}]),
+        }
+
+        for option_key, value in plando_values.items():
+            with self.subTest(option=option_key):
+                restricted_dumps(value)

test/general/test_player_options.py

@@ -37,3 +37,23 @@ class TestPlayerOptions(unittest.TestCase):
         self.assertEqual(new_weights["dict_2"]["option_g"], 50)
         self.assertEqual(len(new_weights["set_1"]), 2)
         self.assertIn("option_d", new_weights["set_1"])
+
+    def test_update_dict_supports_negatives_and_zeroes(self):
+        original_options = {
+            "dict_1": {"a": 1, "b": -1},
+            "dict_2": {"a": 1, "b": -1},
+        }
+        new_weights = Generate.update_weights(
+            original_options,
+            {
+                "+dict_1": {"a": -2, "b": 2},
+                "-dict_2": {"a": 1, "b": 2},
+            },
+            "Tested",
+            "",
+        )
+        self.assertEqual(new_weights["dict_1"]["a"], -1)
+        self.assertEqual(new_weights["dict_1"]["b"], 1)
+        self.assertEqual(new_weights["dict_2"]["a"], 0)
+        self.assertEqual(new_weights["dict_2"]["b"], -3)
+        self.assertIn("a", new_weights["dict_2"])

test/general/test_world_manifest.py

@@ -0,0 +1,102 @@
+"""Check world sources' manifest files"""
+
+import json
+import unittest
+from pathlib import Path
+from typing import Any, ClassVar
+
+import test
+from Utils import home_path, local_path
+from worlds.AutoWorld import AutoWorldRegister
+from ..param import classvar_matrix
+
+
+test_path = Path(test.__file__).parent
+worlds_paths = [
+    Path(local_path("worlds")),
+    Path(local_path("custom_worlds")),
+    Path(home_path("worlds")),
+    Path(home_path("custom_worlds")),
+]
+
+# Only check source folders for now. Zip validation should probably be in the loader and/or installer.
+source_world_names = [
+    k
+    for k, v in AutoWorldRegister.world_types.items()
+    if not v.zip_path and not Path(v.__file__).is_relative_to(test_path)
+]
+
+
+def get_source_world_manifest_path(game: str) -> Path | None:
+    """Get path of archipelago.json in the world's root folder from game name."""
+    # TODO: add a feature to AutoWorld that makes this less annoying
+    world_type = AutoWorldRegister.world_types[game]
+    world_type_path = Path(world_type.__file__)
+    for worlds_path in worlds_paths:
+        if world_type_path.is_relative_to(worlds_path):
+            world_root = worlds_path / world_type_path.relative_to(worlds_path).parents[0]
+            manifest_path = world_root / "archipelago.json"
+            return manifest_path if manifest_path.exists() else None
+    assert False, f"{world_type_path} not found in any worlds path"
+
+
+# TODO: remove the filter once manifests are mandatory.
+@classvar_matrix(game=filter(get_source_world_manifest_path, source_world_names))
+class TestWorldManifest(unittest.TestCase):
+    game: ClassVar[str]
+    manifest: ClassVar[dict[str, Any]]
+
+    @classmethod
+    def setUpClass(cls) -> None:
+        world_type = AutoWorldRegister.world_types[cls.game]
+        assert world_type.game == cls.game
+        manifest_path = get_source_world_manifest_path(cls.game)
+        assert manifest_path  # make mypy happy
+        with manifest_path.open("r", encoding="utf-8") as f:
+            cls.manifest = json.load(f)
+
+    def test_game(self) -> None:
+        """Test that 'game' will be correctly defined when generating APWorld manifest from source."""
+        self.assertIn(
+            "game",
+            self.manifest,
+            f"archipelago.json manifest exists for {self.game} but does not contain 'game'",
+        )
+        self.assertEqual(
+            self.manifest["game"],
+            self.game,
+            f"archipelago.json manifest for {self.game} specifies wrong game '{self.manifest['game']}'",
+        )
+
+    def test_world_version(self) -> None:
+        """Test that world_version matches the requirements in apworld specification.md""" 
+        if "world_version" in self.manifest:
+            world_version: str = self.manifest["world_version"]
+            self.assertIsInstance(
+                world_version,
+                str,
+                f"world_version in archipelago.json for '{self.game}' has to be string if provided.",
+            )
+            parts = world_version.split(".")
+            self.assertEqual(
+                len(parts),
+                3,
+                f"world_version in archipelago.json for '{self.game}' has to be in the form of 'major.minor.build'.",
+            )
+            for part in parts:
+                self.assertTrue(
+                    part.isdigit(),
+                    f"world_version in archipelago.json for '{self.game}' may only contain numbers.",
+                )
+
+    def test_no_container_version(self) -> None:
+        self.assertNotIn(
+            "version",
+            self.manifest,
+            f"archipelago.json for '{self.game}' must not define 'version', see apworld specification.md.",
+        )
+        self.assertNotIn(
+            "compatible_version",
+            self.manifest,
+            f"archipelago.json for '{self.game}' must not define 'compatible_version', see apworld specification.md.",
+        )

test/hosting/__main__.py

@@ -3,6 +3,7 @@
 # Run with `python test/hosting` instead,
 import logging
 import traceback
+from pathlib import Path
 from tempfile import TemporaryDirectory
 from time import sleep
 from typing import Any
@@ -11,7 +12,7 @@ from test.hosting.client import Client
 from test.hosting.generate import generate_local
 from test.hosting.serve import ServeGame, LocalServeGame, WebHostServeGame
 from test.hosting.webhost import (create_room, get_app, get_multidata_for_room, set_multidata_for_room, start_room,
-                                  stop_autohost, upload_multidata)
+                                  stop_autogen, stop_autohost, upload_multidata, generate_remote)
 from test.hosting.world import copy as copy_world, delete as delete_world
 
 failure = False
@@ -56,35 +57,62 @@ else:
 
 
 if __name__ == "__main__":
+    import sys
     import warnings
+
     warnings.simplefilter("ignore", ResourceWarning)
     warnings.simplefilter("ignore", UserWarning)
+    warnings.simplefilter("ignore", DeprecationWarning)
 
     spacer = '=' * 80
 
     with TemporaryDirectory() as tempdir:
-        multis = [["VVVVVV"], ["Temp World"], ["VVVVVV", "Temp World"]]
-        p1_games = []
-        data_paths = []
-        rooms = []
+        empty_file = str(Path(tempdir) / "empty")
+        open(empty_file, "w").close()
+        sys.argv += ["--config_override", empty_file]  # tests #5541
+        multis = [["APQuest"], ["Temp World"], ["APQuest", "Temp World"]]
+        p1_games: list[str] = []
+        data_paths: list[Path | None] = []
+        rooms: list[str] = []
+        multidata: Path | None
 
-        copy_world("VVVVVV", "Temp World")
+        copy_world("APQuest", "Temp World")
         try:
             for n, games in enumerate(multis, 1):
-                print(f"Generating [{n}] {', '.join(games)}")
+                print(f"Generating [{n}] {', '.join(games)} offline")
                 multidata = generate_local(games, tempdir)
                 print(f"Generated [{n}] {', '.join(games)} as {multidata}\n")
-                p1_games.append(games[0])
                 data_paths.append(multidata)
+                p1_games.append(games[0])
         finally:
             delete_world("Temp World")
 
         webapp = get_app(tempdir)
         webhost_client = webapp.test_client()
+
         for n, multidata in enumerate(data_paths, 1):
+            assert multidata
             seed = upload_multidata(webhost_client, multidata)
+            print(f"Uploaded [{n}] {multidata} as {seed}\n")
             room = create_room(webhost_client, seed)
-            print(f"Uploaded [{n}] {multidata} as {room}\n")
+            print(f"Started [{n}] {seed} as {room}\n")
+            rooms.append(room)
+
+        # Generate 1 extra game on WebHost
+        from WebHostLib.autolauncher import autogen
+        for n, games in enumerate(multis[:1], len(multis) + 1):
+            multis.append(games)
+            try:
+                print(f"Generating [{n}] {', '.join(games)} online")
+                autogen(webapp.config)
+                sleep(5)  # until we have lazy loading of worlds, wait here for the process to start up
+                seed = generate_remote(webhost_client, games)
+                print(f"Generated [{n}] {', '.join(games)} as {seed}\n")
+            finally:
+                stop_autogen()
+            data_paths.append(None)  # WebHost-only
+            room = create_room(webhost_client, seed)
+            print(f"Started [{n}] {seed} as {room}\n")
             rooms.append(room)
 
         print("Starting autohost")
@@ -96,31 +124,10 @@ if __name__ == "__main__":
             for n, (multidata, room, game, multi_games) in enumerate(zip(data_paths, rooms, p1_games, multis), 1):
                 involved_games = {"Archipelago"} | set(multi_games)
                 for collected_items in range(3):
-                    print(f"\nTesting [{n}] {game} in {multidata} on MultiServer with {collected_items} items collected")
-                    with LocalServeGame(multidata) as host:
-                        with Client(host.address, game, "Player1") as client:
-                            local_data_packages = client.games_packages
-                            local_collected_items = len(client.checked_locations)
-                            if collected_items < 2:  # Don't collect anything on the last iteration
-                                client.collect_any()
-                            # TODO: Ctrl+C test here as well
-
-                    for game_name in sorted(involved_games):
-                        expect_true(game_name in local_data_packages,
-                                    f"{game_name} missing from MultiServer datap ackage")
-                        expect_true("item_name_groups" not in local_data_packages.get(game_name, {}),
-                                    f"item_name_groups are not supposed to be in MultiServer data for {game_name}")
-                        expect_true("location_name_groups" not in local_data_packages.get(game_name, {}),
-                                    f"location_name_groups are not supposed to be in MultiServer data for {game_name}")
-                    for game_name in local_data_packages:
-                        expect_true(game_name in involved_games,
-                                    f"Received unexpected extra data package for {game_name} from MultiServer")
-                    assert_equal(local_collected_items, collected_items,
-                                 "MultiServer did not load or save correctly")
-
                     print(f"\nTesting [{n}] {game} in {multidata} on customserver with {collected_items} items collected")
                     prev_host_adr: str
                     with WebHostServeGame(webhost_client, room) as host:
+                        sleep(.1)  # wait for the server to fully start before doing anything
                         prev_host_adr = host.address
                         with Client(host.address, game, "Player1") as client:
                             web_data_packages = client.games_packages
@@ -134,6 +141,7 @@ if __name__ == "__main__":
                                 autohost(webapp.config)  # this will spin the room right up again
                                 sleep(1)  # make log less annoying
                                 # if saving failed, the next iteration will fail below
+                        sleep(2)  # work around issue #5571
 
                     # verify server shut down
                     try:
@@ -156,6 +164,31 @@ if __name__ == "__main__":
                                  "customserver did not load or save correctly during/after "
                                  + ("Ctrl+C" if collected_items == 2 else "/exit"))
 
+                    if not multidata:
+                        continue  # games rolled on WebHost can not be tested against MultiServer
+
+                    print(f"\nTesting [{n}] {game} in {multidata} on MultiServer with {collected_items} items collected")
+                    with LocalServeGame(multidata) as host:
+                        with Client(host.address, game, "Player1") as client:
+                            local_data_packages = client.games_packages
+                            local_collected_items = len(client.checked_locations)
+                            if collected_items < 2:  # Don't collect anything on the last iteration
+                                client.collect_any()
+                            # TODO: Ctrl+C test here as well
+
+                    for game_name in sorted(involved_games):
+                        expect_true(game_name in local_data_packages,
+                                    f"{game_name} missing from MultiServer datapackage")
+                        expect_true("item_name_groups" not in local_data_packages.get(game_name, {}),
+                                    f"item_name_groups are not supposed to be in MultiServer data for {game_name}")
+                        expect_true("location_name_groups" not in local_data_packages.get(game_name, {}),
+                                    f"location_name_groups are not supposed to be in MultiServer data for {game_name}")
+                    for game_name in local_data_packages:
+                        expect_true(game_name in involved_games,
+                                    f"Received unexpected extra data package for {game_name} from MultiServer")
+                    assert_equal(local_collected_items, collected_items,
+                                 "MultiServer did not load or save correctly")
+
                     # compare customserver to MultiServer
                     expect_equal(local_data_packages, web_data_packages,
                                  "customserver datapackage differs from MultiServer")
@@ -176,10 +209,12 @@ if __name__ == "__main__":
             print(f"Restoring multidata for {room}")
             set_multidata_for_room(webhost_client, room, old_data)
             with WebHostServeGame(webhost_client, room) as host:
+                sleep(.1)  # wait for the server to fully start before doing anything
                 with Client(host.address, game, "Player1") as client:
                     assert_equal(len(client.checked_locations), 2,
                                  "Save was destroyed during exception in customserver")
                     print("Save file is not busted 🥳")
+                sleep(2)  # work around issue #5571
 
         finally:
             print("Stopping autohost")

test/hosting/webhost.py

@@ -1,6 +1,10 @@
+import io
+import json
 import re
+import time
+import zipfile
 from pathlib import Path
-from typing import TYPE_CHECKING, Optional, cast
+from typing import TYPE_CHECKING, Iterable, Optional, cast
 
 from WebHostLib import to_python
 
@@ -10,6 +14,7 @@ if TYPE_CHECKING:
 
 __all__ = [
     "get_app",
+    "generate_remote",
     "upload_multidata",
     "create_room",
     "start_room",
@@ -17,6 +22,7 @@ __all__ = [
     "set_room_timeout",
     "get_multidata_for_room",
     "set_multidata_for_room",
+    "stop_autogen",
     "stop_autohost",
 ]
 
@@ -33,10 +39,43 @@ def get_app(tempdir: str) -> "Flask":
         "TESTING": True,
         "HOST_ADDRESS": "localhost",
         "HOSTERS": 1,
+        "GENERATORS": 1,
+        "JOB_THRESHOLD": 1,
     })
     return get_app()
 
 
+def generate_remote(app_client: "FlaskClient", games: Iterable[str]) -> str:
+    data = io.BytesIO()
+    with zipfile.ZipFile(data, "a", zipfile.ZIP_DEFLATED, False) as zip_file:
+        for n, game in enumerate(games, 1):
+            name = f"{n}.yaml"
+            zip_file.writestr(name, json.dumps({
+                "name": f"Player{n}",
+                "game": game,
+                game: {},
+                "description": f"generate_remote slot {n} ('Player{n}'): {game}",
+            }))
+    data.seek(0)
+    response = app_client.post("/generate", content_type="multipart/form-data", data={
+        "file": (data, "yamls.zip"),
+    })
+    assert response.status_code < 400, f"Starting gen failed: status {response.status_code}"
+    assert "Location" in response.headers, f"Starting gen failed: no redirect"
+    location = response.headers["Location"]
+    assert isinstance(location, str)
+    assert location.startswith("/wait/"), f"Starting WebHost gen failed: unexpected redirect to {location}"
+    for attempt in range(10):
+        response = app_client.get(location)
+        if "Location" in response.headers:
+            location = response.headers["Location"]
+            assert isinstance(location, str)
+            assert location.startswith("/seed/"), f"Finishing WebHost gen failed: unexpected redirect to {location}"
+            return location[6:]
+        time.sleep(1)
+    raise TimeoutError("WebHost gen did not finish")
+
+
 def upload_multidata(app_client: "FlaskClient", multidata: Path) -> str:
     response = app_client.post("/uploads", data={
         "file": multidata.open("rb"),
@@ -188,7 +227,7 @@ def set_multidata_for_room(webhost_client: "FlaskClient", room_id: str, data: by
         room.seed.multidata = data
 
 
-def stop_autohost(graceful: bool = True) -> None:
+def _stop_webhost_mp(name_filter: str, graceful: bool = True) -> None:
     import os
     import signal
 
@@ -198,13 +237,30 @@ def stop_autohost(graceful: bool = True) -> None:
 
     stop()
     proc: multiprocessing.process.BaseProcess
-    for proc in filter(lambda child: child.name.startswith("MultiHoster"), multiprocessing.active_children()):
+    for proc in filter(lambda child: child.name.startswith(name_filter), multiprocessing.active_children()):
+        # FIXME: graceful currently does not work on Windows because the signals are not properly emulated
+        #        and ungraceful may not save the game
+        if proc.pid == os.getpid():
+            continue
         if graceful and proc.pid:
             os.kill(proc.pid, getattr(signal, "CTRL_C_EVENT", signal.SIGINT))
         else:
             proc.kill()
         try:
-            proc.join(30)
+            try:
+                proc.join(30)
+            except TimeoutError:
+                raise
+            except KeyboardInterrupt:
+                # on Windows, the MP exception may be forwarded to the host, so ignore once and retry
+                proc.join(30)
         except TimeoutError:
             proc.kill()
             proc.join()
+
+def stop_autogen(graceful: bool = True) -> None:
+    # FIXME: this name filter is jank, but there seems to be no way to add a custom prefix for a Pool
+    _stop_webhost_mp("SpawnPoolWorker-", graceful)
+
+def stop_autohost(graceful: bool = True) -> None:
+    _stop_webhost_mp("MultiHoster", graceful)

test/hosting/world.py

@@ -11,7 +11,7 @@ _new_worlds: dict[str, str] = {}
 
 def copy(src: str, dst: str) -> None:
     from Utils import get_file_safe_name
-    from worlds import AutoWorldRegister
+    from worlds.AutoWorld import AutoWorldRegister
 
     assert dst not in _new_worlds, "World already created"
     if '"' in dst or "\\" in dst:  # easier to reject than to escape
@@ -20,7 +20,7 @@ def copy(src: str, dst: str) -> None:
     src_cls = AutoWorldRegister.world_types[src]
     src_folder = Path(src_cls.__file__).parent
     worlds_folder = src_folder.parent
-    if (not src_cls.__file__.endswith("__init__.py") or not src_folder.is_dir()
+    if (not src_cls.__file__.endswith(("__init__.py", "world.py")) or not src_folder.is_dir()
             or not (worlds_folder / "generic").is_dir()):
         raise ValueError(f"Unsupported layout for copy_world from {src}")
     dst_folder = worlds_folder / dst_folder_name
@@ -28,11 +28,14 @@ def copy(src: str, dst: str) -> None:
         raise ValueError(f"Destination {dst_folder} already exists")
     shutil.copytree(src_folder, dst_folder)
     _new_worlds[dst] = str(dst_folder)
-    with open(dst_folder / "__init__.py", "r", encoding="utf-8-sig") as f:
-        contents = f.read()
-    contents = re.sub(r'game\s*(:\s*[a-zA-Z\[\]]+)?\s*=\s*[\'"]' + re.escape(src) + r'[\'"]', f'game = "{dst}"', contents)
-    with open(dst_folder / "__init__.py", "w", encoding="utf-8") as f:
-        f.write(contents)
+
+    for potential_world_class_file in ("__init__.py", "world.py"):
+        with open(dst_folder / potential_world_class_file, "r", encoding="utf-8-sig") as f:
+            contents = f.read()
+        r_src = re.escape(src)
+        contents = re.sub(r'game\s*(:\s*[a-zA-Z\[\]]+)?\s*=\s*[\'"]' + r_src + r'[\'"]', f'game = "{dst}"', contents)
+        with open(dst_folder / "__init__.py", "w", encoding="utf-8") as f:
+            f.write(contents)
 
 
 def delete(name: str) -> None:

test/programs/data/one_player/test.yaml

@@ -2,8 +2,8 @@ description: Almost blank test yaml
 name: Player{NUMBER}
 
 game:
-  Timespinner: 1  # what else
+  APQuest: 1  # what else
 requires:
   version: 0.2.6
-Timespinner: {}
+APQuest: {}
 

test/utils/test_daemon_thread_pool.py

@@ -0,0 +1,14 @@
+import unittest
+
+from Utils import DaemonThreadPoolExecutor
+
+
+class DaemonThreadPoolExecutorTest(unittest.TestCase):
+    def test_is_daemon(self) -> None:
+        def run() -> None:
+            pass
+
+        with DaemonThreadPoolExecutor(1) as executor:
+            executor.submit(run)
+
+            self.assertTrue(next(iter(executor._threads)).daemon)

test/webhost/test_markdown.py

@@ -0,0 +1,78 @@
+import os
+import unittest
+from tempfile import NamedTemporaryFile
+
+from mistune import HTMLRenderer, Markdown
+
+from WebHostLib.markdown import ImgUrlRewriteInlineParser, render_markdown
+
+
+class ImgUrlRewriteTest(unittest.TestCase):
+    markdown: Markdown
+    base_url = "/static/generated/docs/some_game"
+
+    def setUp(self) -> None:
+        self.markdown = Markdown(
+            renderer=HTMLRenderer(escape=False),
+            inline=ImgUrlRewriteInlineParser(self.base_url),
+        )
+
+    def test_relative_img_rewrite(self) -> None:
+        html = self.markdown("![Image](image.png)")
+        self.assertIn(f'src="{self.base_url}/image.png"', html)
+
+    def test_absolute_img_no_rewrite(self) -> None:
+        html = self.markdown("![Image](/image.png)")
+        self.assertIn(f'src="/image.png"', html)
+        self.assertNotIn(self.base_url, html)
+
+    def test_remote_img_no_rewrite(self) -> None:
+        html = self.markdown("![Image](https://example.com/image.png)")
+        self.assertIn(f'src="https://example.com/image.png"', html)
+        self.assertNotIn(self.base_url, html)
+
+    def test_relative_link_no_rewrite(self) -> None:
+        # The parser is only supposed to update images, not links.
+        html = self.markdown("[Link](image.png)")
+        self.assertIn(f'href="image.png"', html)
+        self.assertNotIn(self.base_url, html)
+
+    def test_absolute_link_no_rewrite(self) -> None:
+        html = self.markdown("[Link](/image.png)")
+        self.assertIn(f'href="/image.png"', html)
+        self.assertNotIn(self.base_url, html)
+
+    def test_auto_link_no_rewrite(self) -> None:
+        html = self.markdown("<https://example.com/image.png>")
+        self.assertIn(f'href="https://example.com/image.png"', html)
+        self.assertNotIn(self.base_url, html)
+
+    def test_relative_img_to_other_game(self) -> None:
+        html = self.markdown("![Image](../../generic/docs/image.png)")
+        self.assertIn(f'src="{self.base_url}/../Archipelago/image.png"', html)
+
+
+class RenderMarkdownTest(unittest.TestCase):
+    """Tests that render_markdown does the right thing."""
+    base_url = "/static/generated/docs/some_game"
+
+    def test_relative_img_rewrite(self) -> None:
+        f = NamedTemporaryFile(delete=False)
+        try:
+            f.write("![Image](image.png)".encode("utf-8"))
+            f.close()
+            html = render_markdown(f.name, self.base_url)
+            self.assertIn(f'src="{self.base_url}/image.png"', html)
+        finally:
+            os.unlink(f.name)
+
+    def test_no_img_rewrite(self) -> None:
+        f = NamedTemporaryFile(delete=False)
+        try:
+            f.write("![Image](image.png)".encode("utf-8"))
+            f.close()
+            html = render_markdown(f.name)
+            self.assertIn(f'src="image.png"', html)
+            self.assertNotIn(self.base_url, html)
+        finally:
+            os.unlink(f.name)

test/webhost/test_option_presets.py

@@ -2,7 +2,7 @@ import unittest
 
 from BaseClasses import PlandoOptions
 from worlds import AutoWorldRegister
-from Options import OptionCounter, NamedRange, NumericOption, OptionList, OptionSet
+from Options import OptionCounter, NamedRange, NumericOption, OptionList, OptionSet, Visibility
 
 
 class TestOptionPresets(unittest.TestCase):
@@ -19,6 +19,9 @@ class TestOptionPresets(unittest.TestCase):
                             # pass in all plando options in case a preset wants to require certain plando options
                             # for some reason
                             option.verify(world_type, "Test Player", PlandoOptions(sum(PlandoOptions)))
+                            if not (Visibility.complex_ui in option.visibility or Visibility.simple_ui in option.visibility):
+                                self.fail(f"'{option_name}' in preset '{preset_name}' for game '{game_name}' is not "
+                                          f"visible in any supported UI.")
                             supported_types = [NumericOption, OptionSet, OptionList, OptionCounter]
                             if not any([issubclass(option.__class__, t) for t in supported_types]):
                                 self.fail(f"'{option_name}' in preset '{preset_name}' for game '{game_name}' "

test/webhost/test_tracker.py

@@ -93,3 +93,13 @@ class TestTracker(TestBase):
                 headers={"If-Modified-Since": "Wed, 21 Oct 2015 07:28:00"},  # missing timezone
             )
             self.assertEqual(response.status_code, 400)
+
+    def test_tracker_api(self) -> None:
+        """Verify that tracker api gives a reply for the room."""
+        with self.app.test_request_context():
+            with self.client.open(url_for("api.tracker_data", tracker=self.tracker_uuid)) as response:
+                self.assertEqual(response.status_code, 200)
+            with self.client.open(url_for("api.static_tracker_data", tracker=self.tracker_uuid)) as response:
+                self.assertEqual(response.status_code, 200)
+            with self.client.open(url_for("api.tracker_slot_data", tracker=self.tracker_uuid)) as response:
+                self.assertEqual(response.status_code, 200)

worlds/AutoSNIClient.py

@@ -1,14 +1,26 @@
 
 from __future__ import annotations
 import abc
+from bisect import bisect_right
+from dataclasses import dataclass
+import enum
 import logging
-from typing import TYPE_CHECKING, ClassVar, Dict, Iterable, Tuple, Any, Optional, Union, TypeGuard
+from typing import (TYPE_CHECKING, Any, ClassVar, Dict, Generic, Iterable,
+                    Optional, Sequence, Tuple, TypeGuard, TypeVar, Union)
+
 
 from worlds.LauncherComponents import Component, SuffixIdentifier, Type, components
 
 if TYPE_CHECKING:
     from SNIClient import SNIContext
 
+SNES_READ_CHUNK_SIZE = 2048
+"""
+note: SNI v0.0.101 currently has a bug where reads from
+RetroArch >2048 bytes will only return the last ~2048 bytes read.
+https://github.com/alttpo/sni/issues/51
+"""
+
 component = Component('SNI Client', 'SNIClient', component_type=Type.CLIENT, file_identifier=SuffixIdentifier(".apsoe"),
                       description="A client for connecting to SNES consoles via Super Nintendo Interface.")
 components.append(component)
@@ -91,3 +103,119 @@ class SNIClient(abc.ABC, metaclass=AutoSNIClientRegister):
     def on_package(self, ctx: SNIContext, cmd: str, args: Dict[str, Any]) -> None:
         """ override this with code to handle packages from the server """
         pass
+
+
+@dataclass(frozen=True, slots=True, order=True)
+class Read:
+    """ snes memory read - address and size in bytes """
+    address: int
+    size: int
+
+
+@dataclass(frozen=True, slots=True)
+class _MemRead:
+    location: Read
+    data: bytes
+
+
+_T_Enum = TypeVar("_T_Enum", bound=enum.Enum)
+
+
+class SnesData(Generic[_T_Enum]):
+    _ranges: Sequence[_MemRead]
+    """ sorted by address """
+
+    def __init__(self, ranges: Sequence[tuple[Read, bytes]]) -> None:
+        self._ranges = [_MemRead(r, d) for r, d in ranges]
+
+    def get(self, read: _T_Enum) -> bytes:
+        assert isinstance(read.value, Read), read.value
+        address = read.value.address
+        index = bisect_right(self._ranges, address, key=lambda r: r.location.address) - 1
+        assert index >= 0, (self._ranges, read.value)
+        mem_read = self._ranges[index]
+        sub_index = address - mem_read.location.address
+        return mem_read.data[sub_index:sub_index + read.value.size]
+
+
+class SnesReader(Generic[_T_Enum]):
+    """
+    how to use:
+    ```
+    from enum import Enum
+    from worlds.AutoSNIClient import Read, SNIClient, SnesReader
+
+    class MyGameMemory(Enum):
+        game_mode = Read(WRAM_START + 0x0998, 1)
+        send_queue = Read(SEND_QUEUE_START, 8 * 127)
+        ...
+
+    snes_reader = SnesReader(MyGameMemory)
+
+    snes_data = await snes_reader.read(ctx)
+    if snes_data is None:
+        snes_logger.info("error reading from snes")
+        return
+
+    game_mode = snes_data.get(MyGameMemory.game_mode)
+    ```
+    """
+    _ranges: Sequence[Read]
+    """ sorted by address """
+
+    def __init__(self, reads: type[_T_Enum]) -> None:
+        self._ranges = self._make_ranges(reads)
+
+    @staticmethod
+    def _make_ranges(reads: type[enum.Enum]) -> Sequence[Read]:
+
+        unprocessed_reads: list[Read] = []
+        for e in reads:
+            assert isinstance(e.value, Read), (reads.__name__, e, e.value)
+            unprocessed_reads.append(e.value)
+        unprocessed_reads.sort()
+
+        ranges: list[Read] = []
+        for read in unprocessed_reads:
+            #                                      v  end of the previous range
+            if len(ranges) == 0 or read.address - (ranges[-1].address + ranges[-1].size) > 255:
+                ranges.append(read)
+            else:  # combine with previous range
+                chunk_address = ranges[-1].address
+                assert read.address >= chunk_address, "sort() didn't work? or something"
+                original_chunk_size = ranges[-1].size
+                new_size = max((read.address + read.size) - chunk_address,
+                               original_chunk_size)
+                ranges[-1] = Read(chunk_address, new_size)
+        logging.debug(f"{len(ranges)=} {max(r.size for r in ranges)=}")
+        return ranges
+
+    async def read(self, ctx: "SNIContext") -> SnesData[_T_Enum] | None:
+        """
+        returns `None` if reading fails,
+        otherwise returns the data for the registered `Enum`
+        """
+        from SNIClient import snes_read
+
+        reads: list[tuple[Read, bytes]] = []
+        for r in self._ranges:
+            if r.size < SNES_READ_CHUNK_SIZE:  # most common
+                response = await snes_read(ctx, r.address, r.size)
+                if response is None:
+                    return None
+                reads.append((r, response))
+            else:  # big read
+                # Problems were reported with big reads,
+                # so we chunk it into smaller pieces.
+                read_so_far = 0
+                collection: list[bytes] = []
+                while read_so_far < r.size:
+                    remaining_size = r.size - read_so_far
+                    chunk_size = min(SNES_READ_CHUNK_SIZE, remaining_size)
+                    response = await snes_read(ctx, r.address + read_so_far, chunk_size)
+                    if response is None:
+                        return None
+                    collection.append(response)
+                    read_so_far += chunk_size
+                reads.append((r, b"".join(collection)))
+        return SnesData(reads)

worlds/AutoWorld.py

@@ -12,7 +12,7 @@ from typing import (Any, Callable, ClassVar, Dict, FrozenSet, Iterable, List, Ma
 
 from Options import item_and_loc_options, ItemsAccessibility, OptionGroup, PerGameCommonOptions
 from BaseClasses import CollectionState
-from Utils import deprecate
+from Utils import Version
 
 if TYPE_CHECKING:
     from BaseClasses import MultiWorld, Item, Location, Tutorial, Region, Entrance
@@ -75,6 +75,10 @@ class AutoWorldRegister(type):
                 if "required_client_version" in base.__dict__:
                     dct["required_client_version"] = max(dct["required_client_version"],
                                                          base.__dict__["required_client_version"])
+        if "world_version" in dct:
+            if dct["world_version"] != Version(0, 0, 0):
+                raise RuntimeError(f"{name} is attempting to set 'world_version' from within the class. world_version "
+                                   f"can only be set from manifest.")
 
         # construct class
         new_class = super().__new__(mcs, name, bases, dct)
@@ -220,7 +224,7 @@ class WebWorld(metaclass=WebWorldRegister):
     tutorials: List["Tutorial"]
     """docs folder will also be scanned for tutorial guides. Each Tutorial class is to be used for one guide."""
 
-    theme = "grass"
+    theme: str = "grass"
     """Choose a theme for you /game/* pages.
     Available: dirt, grass, grassFlowers, ice, jungle, ocean, partyTime, stone"""
 
@@ -337,6 +341,8 @@ class World(metaclass=AutoWorldRegister):
     """If loaded from a .apworld, this is the Path to it."""
     __file__: ClassVar[str]
     """path it was loaded from"""
+    world_version: ClassVar[Version] = Version(0, 0, 0)
+    """Optional world version loaded from archipelago.json"""
 
     def __init__(self, multiworld: "MultiWorld", player: int):
         assert multiworld is not None

worlds/Files.py

@@ -8,7 +8,8 @@ import os
 import threading
 from io import BytesIO
 
-from typing import ClassVar, Dict, List, Literal, Tuple, Any, Optional, Union, BinaryIO, overload, Sequence
+from typing import (ClassVar, Dict, List, Literal, Tuple, Any, Optional, Union, BinaryIO, overload, Sequence,
+                    TYPE_CHECKING)
 
 import bsdiff4
 
@@ -16,6 +17,13 @@ semaphore = threading.Semaphore(os.cpu_count() or 4)
 
 del threading
 
+if TYPE_CHECKING:
+    from Utils import Version
+
+
+class ImproperlyConfiguredAutoPatchError(Exception):
+    pass
+
 
 class AutoPatchRegister(abc.ABCMeta):
     patch_types: ClassVar[Dict[str, AutoPatchRegister]] = {}
@@ -26,8 +34,28 @@ class AutoPatchRegister(abc.ABCMeta):
         new_class = super().__new__(mcs, name, bases, dct)
         if "game" in dct:
             AutoPatchRegister.patch_types[dct["game"]] = new_class
-            if not dct["patch_file_ending"]:
-                raise Exception(f"Need an expected file ending for {name}")
+
+            if not callable(getattr(new_class, "patch", None)):
+                raise ImproperlyConfiguredAutoPatchError(
+                    f"Container {new_class} uses metaclass AutoPatchRegister, but does not have a patch method defined."
+                )
+
+            patch_file_ending = dct.get("patch_file_ending")
+            if patch_file_ending == ".zip":
+                raise ImproperlyConfiguredAutoPatchError(
+                    f'Auto patch container {new_class} uses file ending ".zip", which is not allowed.'
+                )
+            if patch_file_ending is None:
+                raise ImproperlyConfiguredAutoPatchError(
+                    f"Need an expected file ending for auto patch container {new_class}"
+                )
+
+            existing_handler = AutoPatchRegister.file_endings.get(patch_file_ending)
+            if existing_handler:
+                raise ImproperlyConfiguredAutoPatchError(
+                    f"Two auto patch containers are using the same file extension: {new_class}, {existing_handler}"
+                )
+
             AutoPatchRegister.file_endings[dct["patch_file_ending"]] = new_class
         return new_class
 
@@ -65,7 +93,7 @@ class AutoPatchExtensionRegister(abc.ABCMeta):
             return handler
 
 
-container_version: int = 6
+container_version: int = 7
 
 
 def is_ap_player_container(game: str, data: bytes, player: int):
@@ -92,7 +120,7 @@ class APContainer:
     version: ClassVar[int] = container_version
     compression_level: ClassVar[int] = 9
     compression_method: ClassVar[int] = zipfile.ZIP_DEFLATED
-
+    manifest_path: str = "archipelago.json"
     path: Optional[str]
 
     def __init__(self, path: Optional[str] = None):
@@ -116,7 +144,7 @@ class APContainer:
         except Exception as e:
             raise Exception(f"Manifest {manifest} did not convert to json.") from e
         else:
-            opened_zipfile.writestr("archipelago.json", manifest_str)
+            opened_zipfile.writestr(self.manifest_path, manifest_str)
 
     def read(self, file: Optional[Union[str, BinaryIO]] = None) -> None:
         """Read data into patch object. file can be file-like, such as an outer zip file's stream."""
@@ -137,7 +165,18 @@ class APContainer:
                 raise InvalidDataError(f"{message}This might be the incorrect world version for this file") from e
 
     def read_contents(self, opened_zipfile: zipfile.ZipFile) -> Dict[str, Any]:
-        with opened_zipfile.open("archipelago.json", "r") as f:
+        try:
+            assert self.manifest_path.endswith("archipelago.json"), "Filename should be archipelago.json"
+            manifest_info = opened_zipfile.getinfo(self.manifest_path)
+        except KeyError as e:
+            for info in opened_zipfile.infolist():
+                if info.filename.endswith("archipelago.json"):
+                    manifest_info = info
+                    self.manifest_path = info.filename
+                    break
+            else:
+                raise e
+        with opened_zipfile.open(manifest_info, "r") as f:
             manifest = json.load(f)
         if manifest["compatible_version"] > self.version:
             raise Exception(f"File (version: {manifest['compatible_version']}) too new "
@@ -152,6 +191,33 @@ class APContainer:
         }
 
 
+class APWorldContainer(APContainer):
+    """A zipfile containing a world implementation."""
+    game: str | None = None
+    world_version: "Version | None" = None
+    minimum_ap_version: "Version | None" = None
+    maximum_ap_version: "Version | None" = None
+
+    def read_contents(self, opened_zipfile: zipfile.ZipFile) -> Dict[str, Any]:
+        from Utils import tuplize_version
+        manifest = super().read_contents(opened_zipfile)
+        self.game = manifest["game"]
+        for version_key in ("world_version", "minimum_ap_version", "maximum_ap_version"):
+            if version_key in manifest:
+                setattr(self, version_key, tuplize_version(manifest[version_key]))
+        return manifest
+
+    def get_manifest(self) -> Dict[str, Any]:
+        manifest = super().get_manifest()
+        manifest["game"] = self.game
+        manifest["compatible_version"] = 7
+        for version_key in ("world_version", "minimum_ap_version", "maximum_ap_version"):
+            version = getattr(self, version_key)
+            if version:
+                manifest[version_key] = version.as_simple_string()
+        return manifest
+
+
 class APPlayerContainer(APContainer):
     """A zipfile containing at least archipelago.json meant for a player"""
     game: ClassVar[Optional[str]] = None
@@ -248,10 +314,8 @@ class APProcedurePatch(APAutoPatchInterface):
             manifest["compatible_version"] = 5
         return manifest
 
-    def read_contents(self, opened_zipfile: zipfile.ZipFile) -> None:
-        super(APProcedurePatch, self).read_contents(opened_zipfile)
-        with opened_zipfile.open("archipelago.json", "r") as f:
-            manifest = json.load(f)
+    def read_contents(self, opened_zipfile: zipfile.ZipFile) -> Dict[str, Any]:
+        manifest = super(APProcedurePatch, self).read_contents(opened_zipfile)
         if "procedure" not in manifest:
             # support patching files made before moving to procedures
             self.procedure = [("apply_bsdiff4", ["delta.bsdiff4"])]
@@ -260,6 +324,7 @@ class APProcedurePatch(APAutoPatchInterface):
         for file in opened_zipfile.namelist():
             if file not in ["archipelago.json"]:
                 self.files[file] = opened_zipfile.read(file)
+        return manifest
 
     def write_contents(self, opened_zipfile: zipfile.ZipFile) -> None:
         super(APProcedurePatch, self).write_contents(opened_zipfile)

worlds/LauncherComponents.py

@@ -5,7 +5,7 @@ import weakref
 from enum import Enum, auto
 from typing import Optional, Callable, List, Iterable, Tuple
 
-from Utils import local_path, open_filename
+from Utils import local_path, open_filename, is_frozen, is_kivy_running, open_file, user_path
 
 
 class Type(Enum):
@@ -177,11 +177,10 @@ def _install_apworld(apworld_src: str = "") -> Optional[Tuple[pathlib.Path, path
         if module_name == loaded_name:
             found_already_loaded = True
             break
-    if found_already_loaded:
-        raise Exception(f"Installed APWorld successfully, but '{module_name}' is already loaded,\n"
-                        "so a Launcher restart is required to use the new installation.\n"
-                        "If the Launcher is not open, no action needs to be taken.")
-    world_source = worlds.WorldSource(str(target), is_zip=True)
+    if found_already_loaded and is_kivy_running():
+        raise Exception(f"Installed APWorld successfully, but '{module_name}' is already loaded, "
+                        "so a Launcher restart is required to use the new installation.")
+    world_source = worlds.WorldSource(str(target), is_zip=True, relative=False)
     bisect.insort(worlds.world_sources, world_source)
     world_source.load()
 
@@ -197,7 +196,7 @@ def install_apworld(apworld_path: str = "") -> None:
         source, target = res
     except Exception as e:
         import Utils
-        Utils.messagebox(e.__class__.__name__, str(e), error=True)
+        Utils.messagebox("Notice", str(e), error=True)
         logging.exception(e)
     else:
         import Utils
@@ -205,6 +204,18 @@ def install_apworld(apworld_path: str = "") -> None:
         Utils.messagebox("Install complete.", f"Installed APWorld from {source}.")
 
 
+def export_datapackage() -> None:
+    import json
+
+    from worlds import network_data_package
+
+    path = user_path("datapackage_export.json")
+    with open(path, "w") as f:
+        json.dump(network_data_package, f, indent=4)
+
+    open_file(path)
+
+
 components: List[Component] = [
     # Launcher
     Component('Launcher', 'Launcher', component_type=Type.HIDDEN),
@@ -214,12 +225,12 @@ components: List[Component] = [
               description="Host a generated multiworld on your computer."),
     Component('Generate', 'Generate', cli=True,
               description="Generate a multiworld with the YAMLs in the players folder."),
+    Component("Options Creator", "OptionsCreator", "ArchipelagoOptionsCreator", component_type=Type.TOOL,
+              description="Visual creator for Archipelago option files."),
     Component("Install APWorld", func=install_apworld, file_identifier=SuffixIdentifier(".apworld"),
               description="Install an APWorld to play games not included with Archipelago by default."),
     Component('Text Client', 'CommonClient', 'ArchipelagoTextClient', func=launch_textclient,
               description="Connect to a multiworld using the text client."),
-    Component('Links Awakening DX Client', 'LinksAwakeningClient',
-              file_identifier=SuffixIdentifier('.apladx')),
     Component('LttP Adjuster', 'LttPAdjuster'),
     # Ocarina of Time
     Component('OoT Client', 'OoTClient',
@@ -233,8 +244,10 @@ components: List[Component] = [
     Component('Zillion Client', 'ZillionClient',
               file_identifier=SuffixIdentifier('.apzl')),
 
-    #MegaMan Battle Network 3
-    Component('MMBN3 Client', 'MMBN3Client', file_identifier=SuffixIdentifier('.apbn3'))
+    # MegaMan Battle Network 3
+    Component('MMBN3 Client', 'MMBN3Client', file_identifier=SuffixIdentifier('.apbn3')),
+
+    Component("Export Datapackage", func=export_datapackage, component_type=Type.TOOL),
 ]
 
 
@@ -243,3 +256,67 @@ icon_paths = {
     'icon': local_path('data', 'icon.png'),
     'discord': local_path('data', 'discord-mark-blue.png'),
 }
+
+if not is_frozen():
+    def _build_apworlds(*launch_args: str):
+        import json
+        import os
+        import zipfile
+
+        from worlds import AutoWorldRegister
+        from worlds.Files import APWorldContainer
+        from Launcher import open_folder
+
+        import argparse
+        parser = argparse.ArgumentParser("Build script for APWorlds")
+        parser.add_argument("worlds", type=str, default=(), nargs="*", help="Names of APWorlds to build.")
+        args = parser.parse_args(launch_args)
+
+        if args.worlds:
+            games = [(game, AutoWorldRegister.world_types.get(game, None)) for game in args.worlds]
+        else:
+            games = [(worldname, worldtype) for worldname, worldtype in AutoWorldRegister.world_types.items()
+                     if not worldtype.zip_path]
+
+        apworlds_folder = os.path.join("build", "apworlds")
+        os.makedirs(apworlds_folder, exist_ok=True)
+        for worldname, worldtype in games:
+            if not worldtype:
+                logging.error(f"Requested APWorld \"{worldname}\" does not exist.")
+                continue
+            file_name = os.path.split(os.path.dirname(worldtype.__file__))[1]
+            world_directory = os.path.join("worlds", file_name)
+            if os.path.isfile(os.path.join(world_directory, "archipelago.json")):
+                with open(os.path.join(world_directory, "archipelago.json"), mode="r", encoding="utf-8") as manifest_file:
+                    manifest = json.load(manifest_file)
+
+                assert "game" in manifest, (
+                    f"World directory {world_directory} has an archipelago.json manifest file, but it "
+                    "does not define a \"game\"."
+                )
+                assert manifest["game"] == worldtype.game, (
+                    f"World directory {world_directory} has an archipelago.json manifest file, but value of the "
+                    f"\"game\" field ({manifest['game']} does not equal the World class's game ({worldtype.game})."
+                )
+            else:
+                manifest = {}
+
+            zip_path = os.path.join(apworlds_folder, file_name + ".apworld")
+            apworld = APWorldContainer(str(zip_path))
+            apworld.game = worldtype.game
+            manifest.update(apworld.get_manifest())
+            apworld.manifest_path = f"{file_name}/archipelago.json"
+            with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED,
+                                 compresslevel=9) as zf:
+                for path in pathlib.Path(world_directory).rglob("*"):
+                    relative_path = os.path.join(*path.parts[path.parts.index("worlds") + 1:])
+                    if "__MACOSX" in relative_path or ".DS_STORE" in relative_path or "__pycache__" in relative_path:
+                        continue
+                    if not relative_path.endswith("archipelago.json"):
+                        zf.write(path, relative_path)
+                zf.writestr(apworld.manifest_path, json.dumps(manifest))
+        open_folder(apworlds_folder)
+
+
+    components.append(Component("Build APWorlds", func=_build_apworlds, cli=True,
+                                description="Build APWorlds from loose-file world folders."))

worlds/__init__.py

@@ -7,10 +7,11 @@ import warnings
 import zipimport
 import time
 import dataclasses
+import json
 from typing import List
 
 from NetUtils import DataPackage
-from Utils import local_path, user_path
+from Utils import local_path, user_path, Version, version_tuple, tuplize_version
 
 local_folder = os.path.dirname(__file__)
 user_folder = user_path("worlds") if user_path() != local_path() else user_path("custom_worlds")
@@ -38,6 +39,7 @@ class WorldSource:
     is_zip: bool = False
     relative: bool = True  # relative to regular world import folder
     time_taken: float = -1.0
+    version: Version = Version(0, 0, 0)
 
     def __repr__(self) -> str:
         return f"{self.__class__.__name__}({self.path}, is_zip={self.is_zip}, relative={self.relative})"
@@ -102,12 +104,94 @@ for folder in (folder for folder in (user_folder, local_folder) if folder):
 
 # import all submodules to trigger AutoWorldRegister
 world_sources.sort()
+apworlds: list[WorldSource] = []
 for world_source in world_sources:
-    world_source.load()
+    # load all loose files first:
+    if world_source.is_zip:
+        apworlds.append(world_source)
+    else:
+        world_source.load()
+
 
-# Build the data package for each game.
 from .AutoWorld import AutoWorldRegister
 
+for world_source in world_sources:
+    if not world_source.is_zip:
+        # look for manifest
+        manifest = {}
+        for dirpath, dirnames, filenames in os.walk(world_source.resolved_path):
+            for file in filenames:
+                if file.endswith("archipelago.json"):
+                    with open(os.path.join(dirpath, file), mode="r", encoding="utf-8") as manifest_file:
+                        manifest = json.load(manifest_file)
+                    break
+            if manifest:
+                break
+        game = manifest.get("game")
+        if game in AutoWorldRegister.world_types:
+            AutoWorldRegister.world_types[game].world_version = tuplize_version(manifest.get("world_version", "0.0.0"))
+
+if apworlds:
+    # encapsulation for namespace / gc purposes
+    def load_apworlds() -> None:
+        global apworlds
+        from .Files import APWorldContainer, InvalidDataError
+        core_compatible: list[tuple[WorldSource, APWorldContainer]] = []
+
+        def fail_world(game_name: str, reason: str, add_as_failed_to_load: bool = True) -> None:
+            if add_as_failed_to_load:
+                failed_world_loads.append(game_name)
+            logging.warning(reason)
+
+        for apworld_source in apworlds:
+            apworld: APWorldContainer = APWorldContainer(apworld_source.resolved_path)
+            # populate metadata
+            try:
+                apworld.read()
+            except InvalidDataError as e:
+                if version_tuple < (0, 7, 0):
+                    logging.error(
+                        f"Invalid or missing manifest file for {apworld_source.resolved_path}. "
+                        "This apworld will stop working with Archipelago 0.7.0."
+                    )
+                    logging.error(e)
+                else:
+                    raise e
+
+            if apworld.minimum_ap_version and apworld.minimum_ap_version > version_tuple:
+                fail_world(apworld.game,
+                           f"Did not load {apworld_source.path} "
+                           f"as its minimum core version {apworld.minimum_ap_version} "
+                           f"is higher than current core version {version_tuple}.")
+            elif apworld.maximum_ap_version and apworld.maximum_ap_version < version_tuple:
+                fail_world(apworld.game,
+                           f"Did not load {apworld_source.path} "
+                           f"as its maximum core version {apworld.maximum_ap_version} "
+                           f"is lower than current core version {version_tuple}.")
+            else:
+                core_compatible.append((apworld_source, apworld))
+        # load highest version first
+        core_compatible.sort(
+            key=lambda element: element[1].world_version if element[1].world_version else Version(0, 0, 0),
+            reverse=True)
+        for apworld_source, apworld in core_compatible:
+            if apworld.game and apworld.game in AutoWorldRegister.world_types:
+                fail_world(apworld.game,
+                           f"Did not load {apworld_source.path} "
+                           f"as its game {apworld.game} is already loaded.",
+                           add_as_failed_to_load=False)
+            else:
+                apworld_source.load()
+                if apworld.game in AutoWorldRegister.world_types:
+                    # world could fail to load at this point
+                    if apworld.world_version:
+                        AutoWorldRegister.world_types[apworld.game].world_version = apworld.world_version
+    load_apworlds()
+    del load_apworlds
+
+del apworlds
+
+# Build the data package for each game.
 network_data_package: DataPackage = {
     "games": {world_name: world.get_data_package_data() for world_name, world in AutoWorldRegister.world_types.items()},
 }

worlds/_sc2common/bot/bot_ai_internal.py

@@ -9,7 +9,7 @@ from collections import Counter
 from typing import TYPE_CHECKING, Any
 from typing import Dict, Generator, Iterable, List, Set, Tuple, Union, final
 
-from s2clientprotocol import sc2api_pb2 as sc_pb
+from .proto import sc2api_pb2 as sc_pb
 
 from .constants import (
     IS_PLACEHOLDER,

worlds/_sc2common/bot/client.py

@@ -4,11 +4,11 @@ from typing import Dict, Iterable, List, Optional, Set, Tuple, Union
 
 from worlds._sc2common.bot import logger
 
-from s2clientprotocol import debug_pb2 as debug_pb
-from s2clientprotocol import query_pb2 as query_pb
-from s2clientprotocol import raw_pb2 as raw_pb
-from s2clientprotocol import sc2api_pb2 as sc_pb
-from s2clientprotocol import spatial_pb2 as spatial_pb
+from .proto import debug_pb2 as debug_pb
+from .proto import query_pb2 as query_pb
+from .proto import raw_pb2 as raw_pb
+from .proto import sc2api_pb2 as sc_pb
+from .proto import spatial_pb2 as spatial_pb
 
 from .data import ActionResult, ChatChannel, Race, Result, Status
 from .game_data import AbilityData, GameData

worlds/_sc2common/bot/controller.py

@@ -2,7 +2,7 @@ import platform
 from pathlib import Path
 
 from worlds._sc2common.bot import logger
-from s2clientprotocol import sc2api_pb2 as sc_pb
+from .proto import sc2api_pb2 as sc_pb
 
 from .player import Computer
 from .protocol import Protocol

worlds/_sc2common/bot/data.py

@@ -7,11 +7,11 @@ https://github.com/Blizzard/s2client-api/blob/d9ba0a33d6ce9d233c2a4ee988360c188f
 """
 import enum
 
-from s2clientprotocol import common_pb2 as common_pb
-from s2clientprotocol import data_pb2 as data_pb
-from s2clientprotocol import error_pb2 as error_pb
-from s2clientprotocol import raw_pb2 as raw_pb
-from s2clientprotocol import sc2api_pb2 as sc_pb
+from .proto import common_pb2 as common_pb
+from .proto import data_pb2 as data_pb
+from .proto import error_pb2 as error_pb
+from .proto import raw_pb2 as raw_pb
+from .proto import sc2api_pb2 as sc_pb
 
 CreateGameError = enum.Enum("CreateGameError", sc_pb.ResponseCreateGame.Error.items())
 

worlds/_sc2common/bot/main.py

@@ -15,7 +15,7 @@ import mpyq
 import portpicker
 from aiohttp import ClientSession, ClientWebSocketResponse
 from worlds._sc2common.bot import logger
-from s2clientprotocol import sc2api_pb2 as sc_pb
+from .proto import sc2api_pb2 as sc_pb
 
 from .bot_ai import BotAI
 from .client import Client

worlds/_sc2common/bot/position.py

@@ -5,7 +5,7 @@ import math
 import random
 from typing import TYPE_CHECKING, Iterable, List, Set, Tuple, Union
 
-from s2clientprotocol import common_pb2 as common_pb
+from .proto import common_pb2 as common_pb
 
 if TYPE_CHECKING:
     from .unit import Unit

worlds/_sc2common/bot/proto/common_pb2.py

@@ -0,0 +1,50 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# NO CHECKED-IN PROTOBUF GENCODE
+# source: s2clientprotocol/common.proto
+# Protobuf Python Version: 6.31.1
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import runtime_version as _runtime_version
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+_runtime_version.ValidateProtobufRuntimeVersion(
+    _runtime_version.Domain.PUBLIC,
+    6,
+    31,
+    1,
+    '',
+    's2clientprotocol/common.proto'
+)
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1ds2clientprotocol/common.proto\x12\x0eSC2APIProtocol\">\n\x10\x41vailableAbility\x12\x12\n\nability_id\x18\x01 \x01(\x05\x12\x16\n\x0erequires_point\x18\x02 \x01(\x08\"X\n\tImageData\x12\x16\n\x0e\x62its_per_pixel\x18\x01 \x01(\x05\x12%\n\x04size\x18\x02 \x01(\x0b\x32\x17.SC2APIProtocol.Size2DI\x12\x0c\n\x04\x64\x61ta\x18\x03 \x01(\x0c\"\x1e\n\x06PointI\x12\t\n\x01x\x18\x01 \x01(\x05\x12\t\n\x01y\x18\x02 \x01(\x05\"T\n\nRectangleI\x12\"\n\x02p0\x18\x01 \x01(\x0b\x32\x16.SC2APIProtocol.PointI\x12\"\n\x02p1\x18\x02 \x01(\x0b\x32\x16.SC2APIProtocol.PointI\"\x1f\n\x07Point2D\x12\t\n\x01x\x18\x01 \x01(\x02\x12\t\n\x01y\x18\x02 \x01(\x02\"(\n\x05Point\x12\t\n\x01x\x18\x01 \x01(\x02\x12\t\n\x01y\x18\x02 \x01(\x02\x12\t\n\x01z\x18\x03 \x01(\x02\"\x1f\n\x07Size2DI\x12\t\n\x01x\x18\x01 \x01(\x05\x12\t\n\x01y\x18\x02 \x01(\x05*A\n\x04Race\x12\n\n\x06NoRace\x10\x00\x12\n\n\x06Terran\x10\x01\x12\x08\n\x04Zerg\x10\x02\x12\x0b\n\x07Protoss\x10\x03\x12\n\n\x06Random\x10\x04')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 's2clientprotocol.common_pb2', _globals)
+if not _descriptor._USE_C_DESCRIPTORS:
+  DESCRIPTOR._loaded_options = None
+  _globals['_RACE']._serialized_start=429
+  _globals['_RACE']._serialized_end=494
+  _globals['_AVAILABLEABILITY']._serialized_start=49
+  _globals['_AVAILABLEABILITY']._serialized_end=111
+  _globals['_IMAGEDATA']._serialized_start=113
+  _globals['_IMAGEDATA']._serialized_end=201
+  _globals['_POINTI']._serialized_start=203
+  _globals['_POINTI']._serialized_end=233
+  _globals['_RECTANGLEI']._serialized_start=235
+  _globals['_RECTANGLEI']._serialized_end=319
+  _globals['_POINT2D']._serialized_start=321
+  _globals['_POINT2D']._serialized_end=352
+  _globals['_POINT']._serialized_start=354
+  _globals['_POINT']._serialized_end=394
+  _globals['_SIZE2DI']._serialized_start=396
+  _globals['_SIZE2DI']._serialized_end=427
+# @@protoc_insertion_point(module_scope)

worlds/_sc2common/bot/proto/data_pb2.py

@@ -0,0 +1,55 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# NO CHECKED-IN PROTOBUF GENCODE
+# source: s2clientprotocol/data.proto
+# Protobuf Python Version: 6.31.1
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import runtime_version as _runtime_version
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+_runtime_version.ValidateProtobufRuntimeVersion(
+    _runtime_version.Domain.PUBLIC,
+    6,
+    31,
+    1,
+    '',
+    's2clientprotocol/data.proto'
+)
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+from . import common_pb2 as s2clientprotocol_dot_common__pb2
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1bs2clientprotocol/data.proto\x12\x0eSC2APIProtocol\x1a\x1ds2clientprotocol/common.proto\"\xc4\x03\n\x0b\x41\x62ilityData\x12\x12\n\nability_id\x18\x01 \x01(\r\x12\x11\n\tlink_name\x18\x02 \x01(\t\x12\x12\n\nlink_index\x18\x03 \x01(\r\x12\x13\n\x0b\x62utton_name\x18\x04 \x01(\t\x12\x15\n\rfriendly_name\x18\x05 \x01(\t\x12\x0e\n\x06hotkey\x18\x06 \x01(\t\x12\x1c\n\x14remaps_to_ability_id\x18\x07 \x01(\r\x12\x11\n\tavailable\x18\x08 \x01(\x08\x12\x32\n\x06target\x18\t \x01(\x0e\x32\".SC2APIProtocol.AbilityData.Target\x12\x15\n\rallow_minimap\x18\n \x01(\x08\x12\x16\n\x0e\x61llow_autocast\x18\x0b \x01(\x08\x12\x13\n\x0bis_building\x18\x0c \x01(\x08\x12\x18\n\x10\x66ootprint_radius\x18\r \x01(\x02\x12\x1c\n\x14is_instant_placement\x18\x0e \x01(\x08\x12\x12\n\ncast_range\x18\x0f \x01(\x02\"I\n\x06Target\x12\x08\n\x04None\x10\x01\x12\t\n\x05Point\x10\x02\x12\x08\n\x04Unit\x10\x03\x12\x0f\n\x0bPointOrUnit\x10\x04\x12\x0f\n\x0bPointOrNone\x10\x05\"J\n\x0b\x44\x61mageBonus\x12,\n\tattribute\x18\x01 \x01(\x0e\x32\x19.SC2APIProtocol.Attribute\x12\r\n\x05\x62onus\x18\x02 \x01(\x02\"\xd7\x01\n\x06Weapon\x12/\n\x04type\x18\x01 \x01(\x0e\x32!.SC2APIProtocol.Weapon.TargetType\x12\x0e\n\x06\x64\x61mage\x18\x02 \x01(\x02\x12\x31\n\x0c\x64\x61mage_bonus\x18\x03 \x03(\x0b\x32\x1b.SC2APIProtocol.DamageBonus\x12\x0f\n\x07\x61ttacks\x18\x04 \x01(\r\x12\r\n\x05range\x18\x05 \x01(\x02\x12\r\n\x05speed\x18\x06 \x01(\x02\"*\n\nTargetType\x12\n\n\x06Ground\x10\x01\x12\x07\n\x03\x41ir\x10\x02\x12\x07\n\x03\x41ny\x10\x03\"\x95\x04\n\x0cUnitTypeData\x12\x0f\n\x07unit_id\x18\x01 \x01(\r\x12\x0c\n\x04name\x18\x02 \x01(\t\x12\x11\n\tavailable\x18\x03 \x01(\x08\x12\x12\n\ncargo_size\x18\x04 \x01(\r\x12\x14\n\x0cmineral_cost\x18\x0c \x01(\r\x12\x14\n\x0cvespene_cost\x18\r \x01(\r\x12\x15\n\rfood_required\x18\x0e \x01(\x02\x12\x15\n\rfood_provided\x18\x12 \x01(\x02\x12\x12\n\nability_id\x18\x0f \x01(\r\x12\"\n\x04race\x18\x10 \x01(\x0e\x32\x14.SC2APIProtocol.Race\x12\x12\n\nbuild_time\x18\x11 \x01(\x02\x12\x13\n\x0bhas_vespene\x18\x13 \x01(\x08\x12\x14\n\x0chas_minerals\x18\x14 \x01(\x08\x12\x13\n\x0bsight_range\x18\x19 \x01(\x02\x12\x12\n\ntech_alias\x18\x15 \x03(\r\x12\x12\n\nunit_alias\x18\x16 \x01(\r\x12\x18\n\x10tech_requirement\x18\x17 \x01(\r\x12\x18\n\x10require_attached\x18\x18 \x01(\x08\x12-\n\nattributes\x18\x08 \x03(\x0e\x32\x19.SC2APIProtocol.Attribute\x12\x16\n\x0emovement_speed\x18\t \x01(\x02\x12\r\n\x05\x61rmor\x18\n \x01(\x02\x12\'\n\x07weapons\x18\x0b \x03(\x0b\x32\x16.SC2APIProtocol.Weapon\"\x86\x01\n\x0bUpgradeData\x12\x12\n\nupgrade_id\x18\x01 \x01(\r\x12\x0c\n\x04name\x18\x02 \x01(\t\x12\x14\n\x0cmineral_cost\x18\x03 \x01(\r\x12\x14\n\x0cvespene_cost\x18\x04 \x01(\r\x12\x15\n\rresearch_time\x18\x05 \x01(\x02\x12\x12\n\nability_id\x18\x06 \x01(\r\")\n\x08\x42uffData\x12\x0f\n\x07\x62uff_id\x18\x01 \x01(\r\x12\x0c\n\x04name\x18\x02 \x01(\t\"T\n\nEffectData\x12\x11\n\teffect_id\x18\x01 \x01(\r\x12\x0c\n\x04name\x18\x02 \x01(\t\x12\x15\n\rfriendly_name\x18\x03 \x01(\t\x12\x0e\n\x06radius\x18\x04 \x01(\x02*\x9e\x01\n\tAttribute\x12\t\n\x05Light\x10\x01\x12\x0b\n\x07\x41rmored\x10\x02\x12\x0e\n\nBiological\x10\x03\x12\x0e\n\nMechanical\x10\x04\x12\x0b\n\x07Robotic\x10\x05\x12\x0b\n\x07Psionic\x10\x06\x12\x0b\n\x07Massive\x10\x07\x12\r\n\tStructure\x10\x08\x12\t\n\x05Hover\x10\t\x12\n\n\x06Heroic\x10\n\x12\x0c\n\x08Summoned\x10\x0b')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 's2clientprotocol.data_pb2', _globals)
+if not _descriptor._USE_C_DESCRIPTORS:
+  DESCRIPTOR._loaded_options = None
+  _globals['_ATTRIBUTE']._serialized_start=1630
+  _globals['_ATTRIBUTE']._serialized_end=1788
+  _globals['_ABILITYDATA']._serialized_start=79
+  _globals['_ABILITYDATA']._serialized_end=531
+  _globals['_ABILITYDATA_TARGET']._serialized_start=458
+  _globals['_ABILITYDATA_TARGET']._serialized_end=531
+  _globals['_DAMAGEBONUS']._serialized_start=533
+  _globals['_DAMAGEBONUS']._serialized_end=607
+  _globals['_WEAPON']._serialized_start=610
+  _globals['_WEAPON']._serialized_end=825
+  _globals['_WEAPON_TARGETTYPE']._serialized_start=783
+  _globals['_WEAPON_TARGETTYPE']._serialized_end=825
+  _globals['_UNITTYPEDATA']._serialized_start=828
+  _globals['_UNITTYPEDATA']._serialized_end=1361
+  _globals['_UPGRADEDATA']._serialized_start=1364
+  _globals['_UPGRADEDATA']._serialized_end=1498
+  _globals['_BUFFDATA']._serialized_start=1500
+  _globals['_BUFFDATA']._serialized_end=1541
+  _globals['_EFFECTDATA']._serialized_start=1543
+  _globals['_EFFECTDATA']._serialized_end=1627
+# @@protoc_insertion_point(module_scope)

worlds/_sc2common/bot/proto/debug_pb2.py

@@ -0,0 +1,71 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# NO CHECKED-IN PROTOBUF GENCODE
+# source: s2clientprotocol/debug.proto
+# Protobuf Python Version: 6.31.1
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import runtime_version as _runtime_version
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+_runtime_version.ValidateProtobufRuntimeVersion(
+    _runtime_version.Domain.PUBLIC,
+    6,
+    31,
+    1,
+    '',
+    's2clientprotocol/debug.proto'
+)
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+from . import common_pb2 as s2clientprotocol_dot_common__pb2
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1cs2clientprotocol/debug.proto\x12\x0eSC2APIProtocol\x1a\x1ds2clientprotocol/common.proto\"\xbb\x03\n\x0c\x44\x65\x62ugCommand\x12)\n\x04\x64raw\x18\x01 \x01(\x0b\x32\x19.SC2APIProtocol.DebugDrawH\x00\x12\x34\n\ngame_state\x18\x02 \x01(\x0e\x32\x1e.SC2APIProtocol.DebugGameStateH\x00\x12\x36\n\x0b\x63reate_unit\x18\x03 \x01(\x0b\x32\x1f.SC2APIProtocol.DebugCreateUnitH\x00\x12\x32\n\tkill_unit\x18\x04 \x01(\x0b\x32\x1d.SC2APIProtocol.DebugKillUnitH\x00\x12\x38\n\x0ctest_process\x18\x05 \x01(\x0b\x32 .SC2APIProtocol.DebugTestProcessH\x00\x12.\n\x05score\x18\x06 \x01(\x0b\x32\x1d.SC2APIProtocol.DebugSetScoreH\x00\x12\x30\n\x08\x65nd_game\x18\x07 \x01(\x0b\x32\x1c.SC2APIProtocol.DebugEndGameH\x00\x12\x37\n\nunit_value\x18\x08 \x01(\x0b\x32!.SC2APIProtocol.DebugSetUnitValueH\x00\x42\t\n\x07\x63ommand\"\xb5\x01\n\tDebugDraw\x12\'\n\x04text\x18\x01 \x03(\x0b\x32\x19.SC2APIProtocol.DebugText\x12(\n\x05lines\x18\x02 \x03(\x0b\x32\x19.SC2APIProtocol.DebugLine\x12\'\n\x05\x62oxes\x18\x03 \x03(\x0b\x32\x18.SC2APIProtocol.DebugBox\x12,\n\x07spheres\x18\x04 \x03(\x0b\x32\x1b.SC2APIProtocol.DebugSphere\"L\n\x04Line\x12!\n\x02p0\x18\x01 \x01(\x0b\x32\x15.SC2APIProtocol.Point\x12!\n\x02p1\x18\x02 \x01(\x0b\x32\x15.SC2APIProtocol.Point\"(\n\x05\x43olor\x12\t\n\x01r\x18\x01 \x01(\r\x12\t\n\x01g\x18\x02 \x01(\r\x12\t\n\x01\x62\x18\x03 \x01(\r\"\xa3\x01\n\tDebugText\x12$\n\x05\x63olor\x18\x01 \x01(\x0b\x32\x15.SC2APIProtocol.Color\x12\x0c\n\x04text\x18\x02 \x01(\t\x12*\n\x0bvirtual_pos\x18\x03 \x01(\x0b\x32\x15.SC2APIProtocol.Point\x12(\n\tworld_pos\x18\x04 \x01(\x0b\x32\x15.SC2APIProtocol.Point\x12\x0c\n\x04size\x18\x05 \x01(\r\"U\n\tDebugLine\x12$\n\x05\x63olor\x18\x01 \x01(\x0b\x32\x15.SC2APIProtocol.Color\x12\"\n\x04line\x18\x02 \x01(\x0b\x32\x14.SC2APIProtocol.Line\"x\n\x08\x44\x65\x62ugBox\x12$\n\x05\x63olor\x18\x01 \x01(\x0b\x32\x15.SC2APIProtocol.Color\x12\"\n\x03min\x18\x02 \x01(\x0b\x32\x15.SC2APIProtocol.Point\x12\"\n\x03max\x18\x03 \x01(\x0b\x32\x15.SC2APIProtocol.Point\"`\n\x0b\x44\x65\x62ugSphere\x12$\n\x05\x63olor\x18\x01 \x01(\x0b\x32\x15.SC2APIProtocol.Color\x12 \n\x01p\x18\x02 \x01(\x0b\x32\x15.SC2APIProtocol.Point\x12\t\n\x01r\x18\x03 \x01(\x02\"k\n\x0f\x44\x65\x62ugCreateUnit\x12\x11\n\tunit_type\x18\x01 \x01(\r\x12\r\n\x05owner\x18\x02 \x01(\x05\x12$\n\x03pos\x18\x03 \x01(\x0b\x32\x17.SC2APIProtocol.Point2D\x12\x10\n\x08quantity\x18\x04 \x01(\r\"\x1c\n\rDebugKillUnit\x12\x0b\n\x03tag\x18\x01 \x03(\x04\"\x80\x01\n\x10\x44\x65\x62ugTestProcess\x12\x33\n\x04test\x18\x01 \x01(\x0e\x32%.SC2APIProtocol.DebugTestProcess.Test\x12\x10\n\x08\x64\x65lay_ms\x18\x02 \x01(\x05\"%\n\x04Test\x12\x08\n\x04hang\x10\x01\x12\t\n\x05\x63rash\x10\x02\x12\x08\n\x04\x65xit\x10\x03\"\x1e\n\rDebugSetScore\x12\r\n\x05score\x18\x01 \x01(\x02\"z\n\x0c\x44\x65\x62ugEndGame\x12:\n\nend_result\x18\x01 \x01(\x0e\x32&.SC2APIProtocol.DebugEndGame.EndResult\".\n\tEndResult\x12\r\n\tSurrender\x10\x01\x12\x12\n\x0e\x44\x65\x63lareVictory\x10\x02\"\xa5\x01\n\x11\x44\x65\x62ugSetUnitValue\x12?\n\nunit_value\x18\x01 \x01(\x0e\x32+.SC2APIProtocol.DebugSetUnitValue.UnitValue\x12\r\n\x05value\x18\x02 \x01(\x02\x12\x10\n\x08unit_tag\x18\x03 \x01(\x04\".\n\tUnitValue\x12\n\n\x06\x45nergy\x10\x01\x12\x08\n\x04Life\x10\x02\x12\x0b\n\x07Shields\x10\x03*\xb2\x01\n\x0e\x44\x65\x62ugGameState\x12\x0c\n\x08show_map\x10\x01\x12\x11\n\rcontrol_enemy\x10\x02\x12\x08\n\x04\x66ood\x10\x03\x12\x08\n\x04\x66ree\x10\x04\x12\x11\n\rall_resources\x10\x05\x12\x07\n\x03god\x10\x06\x12\x0c\n\x08minerals\x10\x07\x12\x07\n\x03gas\x10\x08\x12\x0c\n\x08\x63ooldown\x10\t\x12\r\n\ttech_tree\x10\n\x12\x0b\n\x07upgrade\x10\x0b\x12\x0e\n\nfast_build\x10\x0c')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 's2clientprotocol.debug_pb2', _globals)
+if not _descriptor._USE_C_DESCRIPTORS:
+  DESCRIPTOR._loaded_options = None
+  _globals['_DEBUGGAMESTATE']._serialized_start=1897
+  _globals['_DEBUGGAMESTATE']._serialized_end=2075
+  _globals['_DEBUGCOMMAND']._serialized_start=80
+  _globals['_DEBUGCOMMAND']._serialized_end=523
+  _globals['_DEBUGDRAW']._serialized_start=526
+  _globals['_DEBUGDRAW']._serialized_end=707
+  _globals['_LINE']._serialized_start=709
+  _globals['_LINE']._serialized_end=785
+  _globals['_COLOR']._serialized_start=787
+  _globals['_COLOR']._serialized_end=827
+  _globals['_DEBUGTEXT']._serialized_start=830
+  _globals['_DEBUGTEXT']._serialized_end=993
+  _globals['_DEBUGLINE']._serialized_start=995
+  _globals['_DEBUGLINE']._serialized_end=1080
+  _globals['_DEBUGBOX']._serialized_start=1082
+  _globals['_DEBUGBOX']._serialized_end=1202
+  _globals['_DEBUGSPHERE']._serialized_start=1204
+  _globals['_DEBUGSPHERE']._serialized_end=1300
+  _globals['_DEBUGCREATEUNIT']._serialized_start=1302
+  _globals['_DEBUGCREATEUNIT']._serialized_end=1409
+  _globals['_DEBUGKILLUNIT']._serialized_start=1411
+  _globals['_DEBUGKILLUNIT']._serialized_end=1439
+  _globals['_DEBUGTESTPROCESS']._serialized_start=1442
+  _globals['_DEBUGTESTPROCESS']._serialized_end=1570
+  _globals['_DEBUGTESTPROCESS_TEST']._serialized_start=1533
+  _globals['_DEBUGTESTPROCESS_TEST']._serialized_end=1570
+  _globals['_DEBUGSETSCORE']._serialized_start=1572
+  _globals['_DEBUGSETSCORE']._serialized_end=1602
+  _globals['_DEBUGENDGAME']._serialized_start=1604
+  _globals['_DEBUGENDGAME']._serialized_end=1726
+  _globals['_DEBUGENDGAME_ENDRESULT']._serialized_start=1680
+  _globals['_DEBUGENDGAME_ENDRESULT']._serialized_end=1726
+  _globals['_DEBUGSETUNITVALUE']._serialized_start=1729
+  _globals['_DEBUGSETUNITVALUE']._serialized_end=1894
+  _globals['_DEBUGSETUNITVALUE_UNITVALUE']._serialized_start=1848
+  _globals['_DEBUGSETUNITVALUE_UNITVALUE']._serialized_end=1894
+# @@protoc_insertion_point(module_scope)

worlds/_sc2common/bot/proto/query_pb2.py

@@ -0,0 +1,52 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# NO CHECKED-IN PROTOBUF GENCODE
+# source: s2clientprotocol/query.proto
+# Protobuf Python Version: 6.31.1
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import runtime_version as _runtime_version
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+_runtime_version.ValidateProtobufRuntimeVersion(
+    _runtime_version.Domain.PUBLIC,
+    6,
+    31,
+    1,
+    '',
+    's2clientprotocol/query.proto'
+)
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+from . import common_pb2 as s2clientprotocol_dot_common__pb2
+from . import error_pb2 as s2clientprotocol_dot_error__pb2
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1cs2clientprotocol/query.proto\x12\x0eSC2APIProtocol\x1a\x1ds2clientprotocol/common.proto\x1a\x1cs2clientprotocol/error.proto\"\xf0\x01\n\x0cRequestQuery\x12\x34\n\x07pathing\x18\x01 \x03(\x0b\x32#.SC2APIProtocol.RequestQueryPathing\x12\x41\n\tabilities\x18\x02 \x03(\x0b\x32..SC2APIProtocol.RequestQueryAvailableAbilities\x12\x41\n\nplacements\x18\x03 \x03(\x0b\x32-.SC2APIProtocol.RequestQueryBuildingPlacement\x12$\n\x1cignore_resource_requirements\x18\x04 \x01(\x08\"\xce\x01\n\rResponseQuery\x12\x35\n\x07pathing\x18\x01 \x03(\x0b\x32$.SC2APIProtocol.ResponseQueryPathing\x12\x42\n\tabilities\x18\x02 \x03(\x0b\x32/.SC2APIProtocol.ResponseQueryAvailableAbilities\x12\x42\n\nplacements\x18\x03 \x03(\x0b\x32..SC2APIProtocol.ResponseQueryBuildingPlacement\"\x8a\x01\n\x13RequestQueryPathing\x12,\n\tstart_pos\x18\x01 \x01(\x0b\x32\x17.SC2APIProtocol.Point2DH\x00\x12\x12\n\x08unit_tag\x18\x02 \x01(\x04H\x00\x12(\n\x07\x65nd_pos\x18\x03 \x01(\x0b\x32\x17.SC2APIProtocol.Point2DB\x07\n\x05start\"(\n\x14ResponseQueryPathing\x12\x10\n\x08\x64istance\x18\x01 \x01(\x02\"2\n\x1eRequestQueryAvailableAbilities\x12\x10\n\x08unit_tag\x18\x01 \x01(\x04\"~\n\x1fResponseQueryAvailableAbilities\x12\x33\n\tabilities\x18\x01 \x03(\x0b\x32 .SC2APIProtocol.AvailableAbility\x12\x10\n\x08unit_tag\x18\x02 \x01(\x04\x12\x14\n\x0cunit_type_id\x18\x03 \x01(\r\"z\n\x1dRequestQueryBuildingPlacement\x12\x12\n\nability_id\x18\x01 \x01(\x05\x12+\n\ntarget_pos\x18\x02 \x01(\x0b\x32\x17.SC2APIProtocol.Point2D\x12\x18\n\x10placing_unit_tag\x18\x03 \x01(\x04\"N\n\x1eResponseQueryBuildingPlacement\x12,\n\x06result\x18\x01 \x01(\x0e\x32\x1c.SC2APIProtocol.ActionResult')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 's2clientprotocol.query_pb2', _globals)
+if not _descriptor._USE_C_DESCRIPTORS:
+  DESCRIPTOR._loaded_options = None
+  _globals['_REQUESTQUERY']._serialized_start=110
+  _globals['_REQUESTQUERY']._serialized_end=350
+  _globals['_RESPONSEQUERY']._serialized_start=353
+  _globals['_RESPONSEQUERY']._serialized_end=559
+  _globals['_REQUESTQUERYPATHING']._serialized_start=562
+  _globals['_REQUESTQUERYPATHING']._serialized_end=700
+  _globals['_RESPONSEQUERYPATHING']._serialized_start=702
+  _globals['_RESPONSEQUERYPATHING']._serialized_end=742
+  _globals['_REQUESTQUERYAVAILABLEABILITIES']._serialized_start=744
+  _globals['_REQUESTQUERYAVAILABLEABILITIES']._serialized_end=794
+  _globals['_RESPONSEQUERYAVAILABLEABILITIES']._serialized_start=796
+  _globals['_RESPONSEQUERYAVAILABLEABILITIES']._serialized_end=922
+  _globals['_REQUESTQUERYBUILDINGPLACEMENT']._serialized_start=924
+  _globals['_REQUESTQUERYBUILDINGPLACEMENT']._serialized_end=1046
+  _globals['_RESPONSEQUERYBUILDINGPLACEMENT']._serialized_start=1048
+  _globals['_RESPONSEQUERYBUILDINGPLACEMENT']._serialized_end=1126
+# @@protoc_insertion_point(module_scope)