remove attestation from docker workflow

I don't know what this is or what value this adds, so removing it for now as it doesn't work on gitea

.github/pyright-config.json

@@ -2,11 +2,15 @@
   "include": [
     "../BizHawkClient.py",
     "../Patch.py",
+    "../rule_builder/cached_world.py",
+    "../rule_builder/options.py",
+    "../rule_builder/rules.py",
     "../test/param.py",
     "../test/general/test_groups.py",
     "../test/general/test_helpers.py",
     "../test/general/test_memory.py",
     "../test/general/test_names.py",
+    "../test/general/test_rule_builder.py",
     "../test/multiworld/__init__.py",
     "../test/multiworld/test_multiworlds.py",
     "../test/netutils/__init__.py",

.github/workflows/build.yml

@@ -1,4 +1,5 @@
-# This workflow will build a release-like distribution when manually dispatched
+# This workflow will build a release-like distribution when manually dispatched:
+# a Windows x64 7zip, a Windows x64 Installer, a Linux AppImage and a Linux binary .tar.gz.
 
 name: Build
 
@@ -24,10 +25,10 @@ env:
   # 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.
   APPIMAGE_FORK: 'PopTracker'
-  APPIMAGETOOL_VERSION: 'r-2025-10-19'
-  APPIMAGETOOL_X86_64_HASH: '9493a6b253a01f84acb9c624c38810ecfa11d99daa829b952b0bff43113080f9'
-  APPIMAGE_RUNTIME_VERSION: 'r-2025-08-11'
-  APPIMAGE_RUNTIME_X86_64_HASH: 'e70ffa9b69b211574d0917adc482dd66f25a0083427b5945783965d55b0b0a8b'
+  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'

.github/workflows/docker.yml

@@ -11,144 +11,43 @@ on:
       - "!.github/workflows/**"
       - ".github/workflows/docker.yml"
     branches:
-      - "main"
+      - "dock-dev"
     tags:
       - "v?[0-9]+.[0-9]+.[0-9]*"
   workflow_dispatch:
 
-env:
-  REGISTRY: ghcr.io
 
 jobs:
-  prepare:
+  push_to_registry:
+    name: Push Docker image to Docker Hub
     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
+      contents: read
+      attestations: write
+      id-token: write
     steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
+      - name: Check out the repo
+        uses: actions/checkout@v5
 
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-
-      - name: Log in to GitHub Container Registry
-        uses: docker/login-action@v3
+      - name: Log in to Docker Hub
+        uses: docker/login-action@f4ef78c080cd8ba55a85445d5b36e214a81df20a
         with:
-          registry: ${{ env.REGISTRY }}
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN }}
+          username: ${{ secrets.DOCKERHUB_USER }}
+          password: ${{ secrets.DOCKERHUB_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: Extract metadata (tags, labels) for Docker
+        id: meta
+        uses: docker/metadata-action@9ec57ed1fcdbf14dcef7dfbe97b2010124a938b7
+        with:
+          images: ubufugu/dockipelago
 
       - name: Build and push Docker image
-        uses: docker/build-push-action@v5
+        id: push
+        uses: docker/build-push-action@3b5e8027fcad23fda98b2e3ac259d8d67585f671
         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
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}

.github/workflows/release.yml

@@ -12,10 +12,10 @@ env:
   # 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.
   APPIMAGE_FORK: 'PopTracker'
-  APPIMAGETOOL_VERSION: 'r-2025-10-19'
-  APPIMAGETOOL_X86_64_HASH: '9493a6b253a01f84acb9c624c38810ecfa11d99daa829b952b0bff43113080f9'
-  APPIMAGE_RUNTIME_VERSION: 'r-2025-08-11'
-  APPIMAGE_RUNTIME_X86_64_HASH: 'e70ffa9b69b211574d0917adc482dd66f25a0083427b5945783965d55b0b0a8b'
+  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'

.gitignore

@@ -63,7 +63,10 @@ Output Logs/
 /installdelete.iss
 /data/user.kv
 /datapackage
+/datapackage_export.json
 /custom_worlds
+# stubgen output
+/out/
 
 # Byte-compiled / optimized / DLL files
 __pycache__/

.run/Build APWorlds.run.xml

@@ -1,5 +1,5 @@
 <component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="Build APWorld" type="PythonConfigurationType" factoryName="Python">
+  <configuration default="false" name="Build APWorlds" type="PythonConfigurationType" factoryName="Python">
     <module name="Archipelago" />
     <option name="ENV_FILES" value="" />
     <option name="INTERPRETER_OPTIONS" value="" />
@@ -12,8 +12,8 @@
     <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="$ContentRoot$/Launcher.py" />
-    <option name="PARAMETERS" value="\&quot;Build APWorlds\&quot;" />
+    <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" />

BaseClasses.py

@@ -8,10 +8,10 @@ import secrets
 import warnings
 from argparse import Namespace
 from collections import Counter, deque, defaultdict
-from collections.abc import Collection, MutableSequence
+from collections.abc import Callable, Collection, Iterable, Iterator, Mapping, MutableSequence, Set
 from enum import IntEnum, IntFlag
-from typing import (AbstractSet, Any, Callable, ClassVar, Dict, Iterable, Iterator, List, Literal, Mapping, NamedTuple,
-                    Optional, Protocol, Set, Tuple, Union, TYPE_CHECKING, Literal, overload)
+from typing import (AbstractSet, Any, ClassVar, Dict, List, Literal, NamedTuple,
+                    Optional, Protocol, Tuple, Union, TYPE_CHECKING, overload)
 import dataclasses
 
 from typing_extensions import NotRequired, TypedDict
@@ -22,6 +22,7 @@ import Utils
 
 if TYPE_CHECKING:
     from entrance_rando import ERPlacementState
+    from rule_builder.rules import Rule
     from worlds import AutoWorld
 
 
@@ -85,7 +86,7 @@ class MultiWorld():
     local_items: Dict[int, Options.LocalItems]
     non_local_items: Dict[int, Options.NonLocalItems]
     progression_balancing: Dict[int, Options.ProgressionBalancing]
-    completion_condition: Dict[int, Callable[[CollectionState], bool]]
+    completion_condition: Dict[int, CollectionRule]
     indirect_connections: Dict[Region, Set[Entrance]]
     exclude_locations: Dict[int, Options.ExcludeLocations]
     priority_locations: Dict[int, Options.PriorityLocations]
@@ -766,7 +767,7 @@ class CollectionState():
         else:
             self._update_reachable_regions_auto_indirect_conditions(player, queue)
 
-    def _update_reachable_regions_explicit_indirect_conditions(self, player: int, queue: deque):
+    def _update_reachable_regions_explicit_indirect_conditions(self, player: int, queue: deque[Entrance]):
         reachable_regions = self.reachable_regions[player]
         blocked_connections = self.blocked_connections[player]
         # run BFS on all connections, and keep track of those blocked by missing items
@@ -784,13 +785,16 @@ class CollectionState():
                 blocked_connections.update(new_region.exits)
                 queue.extend(new_region.exits)
                 self.path[new_region] = (new_region.name, self.path.get(connection, None))
+                self.multiworld.worlds[player].reached_region(self, new_region)
 
                 # Retry connections if the new region can unblock them
-                for new_entrance in self.multiworld.indirect_connections.get(new_region, set()):
-                    if new_entrance in blocked_connections and new_entrance not in queue:
-                        queue.append(new_entrance)
+                entrances = self.multiworld.indirect_connections.get(new_region)
+                if entrances is not None:
+                    relevant_entrances = entrances.intersection(blocked_connections)
+                    relevant_entrances.difference_update(queue)
+                    queue.extend(relevant_entrances)
 
-    def _update_reachable_regions_auto_indirect_conditions(self, player: int, queue: deque):
+    def _update_reachable_regions_auto_indirect_conditions(self, player: int, queue: deque[Entrance]):
         reachable_regions = self.reachable_regions[player]
         blocked_connections = self.blocked_connections[player]
         new_connection: bool = True
@@ -812,6 +816,7 @@ class CollectionState():
                     queue.extend(new_region.exits)
                     self.path[new_region] = (new_region.name, self.path.get(connection, None))
                     new_connection = True
+                    self.multiworld.worlds[player].reached_region(self, new_region)
             # sweep for indirect connections, mostly Entrance.can_reach(unrelated_Region)
             queue.extend(blocked_connections)
 
@@ -1169,13 +1174,17 @@ class CollectionState():
             self.prog_items[player][item] = count
 
 
+CollectionRule = Callable[[CollectionState], bool]
+DEFAULT_COLLECTION_RULE: CollectionRule = staticmethod(lambda state: True)
+
+
 class EntranceType(IntEnum):
     ONE_WAY = 1
     TWO_WAY = 2
 
 
 class Entrance:
-    access_rule: Callable[[CollectionState], bool] = staticmethod(lambda state: True)
+    access_rule: CollectionRule = DEFAULT_COLLECTION_RULE
     hide_path: bool = False
     player: int
     name: str
@@ -1362,7 +1371,7 @@ class Region:
         self,
         location_name: str,
         item_name: str | None = None,
-        rule: Callable[[CollectionState], bool] | None = None,
+        rule: CollectionRule | Rule[Any] | None = None,
         location_type: type[Location] | None = None,
         item_type: type[Item] | None = None,
         show_in_spoiler: bool = True,
@@ -1390,7 +1399,7 @@ class Region:
         event_location = location_type(self.player, location_name, None, self)
         event_location.show_in_spoiler = show_in_spoiler
         if rule is not None:
-            event_location.access_rule = rule
+            self.multiworld.worlds[self.player].set_rule(event_location, rule)
 
         event_item = item_type(item_name, ItemClassification.progression, None, self.player)
 
@@ -1401,7 +1410,7 @@ class Region:
         return event_item
 
     def connect(self, connecting_region: Region, name: Optional[str] = None,
-                rule: Optional[Callable[[CollectionState], bool]] = None) -> Entrance:
+                rule: Optional[CollectionRule | Rule[Any]] = None) -> Entrance:
         """
         Connects this Region to another Region, placing the provided rule on the connection.
 
@@ -1409,8 +1418,8 @@ class Region:
         :param name: name of the connection being created
         :param rule: callable to determine access of this connection to go from self to the exiting_region"""
         exit_ = self.create_exit(name if name else f"{self.name} -> {connecting_region.name}")
-        if rule:
-            exit_.access_rule = rule
+        if rule is not None:
+            self.multiworld.worlds[self.player].set_rule(exit_, rule)
         exit_.connect(connecting_region)
         return exit_
 
@@ -1435,7 +1444,7 @@ class Region:
         return entrance
 
     def add_exits(self, exits: Iterable[str] | Mapping[str, str | None],
-                  rules: Mapping[str, Callable[[CollectionState], bool]] | None = None) -> List[Entrance]:
+                  rules: Mapping[str, CollectionRule | Rule[Any]] | None = None) -> List[Entrance]:
         """
         Connects current region to regions in exit dictionary. Passed region names must exist first.
 
@@ -1474,7 +1483,7 @@ class Location:
     show_in_spoiler: bool = True
     progress_type: LocationProgressType = LocationProgressType.DEFAULT
     always_allow: Callable[[CollectionState, Item], bool] = staticmethod(lambda state, item: False)
-    access_rule: Callable[[CollectionState], bool] = staticmethod(lambda state: True)
+    access_rule: CollectionRule = DEFAULT_COLLECTION_RULE
     item_rule: Callable[[Item], bool] = staticmethod(lambda item: True)
     item: Optional[Item] = None
 
@@ -1551,7 +1560,7 @@ class ItemClassification(IntFlag):
     skip_balancing = 0b01000
     """ should technically never occur on its own
     Item that is logically relevant, but progression balancing should not touch.
-    
+
     Possible reasons for why an item should not be pulled ahead by progression balancing:
     1. This item is quite insignificant, so pulling it earlier doesn't help (currency/etc.)
     2. It is important for the player experience that this item is evenly distributed in the seed (e.g. goal items) """
@@ -1559,13 +1568,13 @@ class ItemClassification(IntFlag):
     deprioritized = 0b10000
     """ Should technically never occur on its own.
     Will not be considered for priority locations,
-    unless Priority Locations Fill runs out of regular progression items before filling all priority locations. 
-    
+    unless Priority Locations Fill runs out of regular progression items before filling all priority locations.
+
     Should be used for items that would feel bad for the player to find on a priority location.
     Usually, these are items that are plentiful or insignificant. """
 
     progression_deprioritized_skip_balancing = 0b11001
-    """ Since a common case of both skip_balancing and deprioritized is "insignificant progression", 
+    """ Since a common case of both skip_balancing and deprioritized is "insignificant progression",
     these items often want both flags. """
 
     progression_skip_balancing = 0b01001  # only progression gets balanced

CommonClient.py

@@ -24,7 +24,7 @@ if __name__ == "__main__":
 from MultiServer import CommandProcessor, mark_raw
 from NetUtils import (Endpoint, decode, NetworkItem, encode, JSONtoTextParser, ClientStatus, Permission, NetworkSlot,
                       RawJSONtoTextParser, add_json_text, add_json_location, add_json_item, JSONTypes, HintStatus, SlotType)
-from Utils import Version, stream_input, async_start
+from Utils import gui_enabled, Version, stream_input, async_start
 from worlds import network_data_package, AutoWorldRegister
 import os
 import ssl
@@ -35,9 +35,6 @@ if typing.TYPE_CHECKING:
 
 logger = logging.getLogger("Client")
 
-# without terminal, we have to use gui mode
-gui_enabled = not sys.stdout or "--nogui" not in sys.argv
-
 
 @Utils.cache_argsless
 def get_ssl_context():
@@ -65,6 +62,8 @@ class ClientCommandProcessor(CommandProcessor):
 
     def _cmd_exit(self) -> bool:
         """Close connections and client"""
+        if self.ctx.ui:
+            self.ctx.ui.stop()
         self.ctx.exit_event.set()
         return True
 
@@ -323,7 +322,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)"""
 

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(argv: list[str] | None = None):
+def mystery_argparse(argv: list[str] | None = None) -> argparse.Namespace:
     from settings import get_settings
     settings = get_settings()
     defaults = settings.generator
@@ -68,7 +68,7 @@ def mystery_argparse(argv: list[str] | None = None):
         args.weights_file_path = os.path.join(args.player_files_path, args.weights_file_path)
     if not os.path.isabs(args.meta_file_path):
         args.meta_file_path = os.path.join(args.player_files_path, args.meta_file_path)
-    args.plando: PlandoOptions = PlandoOptions.from_option_string(args.plando)
+    args.plando = PlandoOptions.from_option_string(args.plando)
 
     return args
 
@@ -119,9 +119,9 @@ def main(args=None) -> tuple[argparse.Namespace, int]:
     else:
         meta_weights = None
 
-
-    player_id = 1
-    player_files = {}
+    player_id: int = 1
+    player_files: dict[int, str] = {}
+    player_errors: list[str] = []
     for file in os.scandir(args.player_files_path):
         fname = file.name
         if file.is_file() and not fname.startswith(".") and not fname.lower().endswith(".ini") and \
@@ -135,9 +135,13 @@ def main(args=None) -> tuple[argparse.Namespace, int]:
                     else:
                         weights_for_file.append(yaml)
                 weights_cache[fname] = tuple(weights_for_file)
-                        
+
             except Exception as e:
-                raise ValueError(f"File {fname} is invalid. Please fix your yaml.") from e
+                logging.exception(f"Exception reading weights in file {fname}")
+                player_errors.append(
+                    f"{len(player_errors) + 1}. "
+                    f"File {fname} is invalid. Please fix your yaml.\n{Utils.get_all_causes(e)}"
+                )
 
     # sort dict for consistent results across platforms:
     weights_cache = {key: value for key, value in sorted(weights_cache.items(), key=lambda k: k[0].casefold())}
@@ -152,6 +156,10 @@ def main(args=None) -> tuple[argparse.Namespace, int]:
     args.multi = max(player_id - 1, args.multi)
 
     if args.multi == 0:
+        if player_errors:
+            errors = "\n\n".join(player_errors)
+            raise ValueError(f"Encountered {len(player_errors)} error(s) in player files. "
+                             f"See logs for full tracebacks.\n\n{errors}")
         raise ValueError(
             "No individual player files found and number of players is 0. "
             "Provide individual player files or specify the number of players via host.yaml or --multi."
@@ -161,6 +169,10 @@ def main(args=None) -> tuple[argparse.Namespace, int]:
                  f"{seed_name} Seed {seed} with plando: {args.plando}")
 
     if not weights_cache:
+        if player_errors:
+            errors = "\n\n".join(player_errors)
+            raise ValueError(f"Encountered {len(player_errors)} error(s) in player files. "
+                             f"See logs for full tracebacks.\n\n{errors}")
         raise Exception(f"No weights found. "
                         f"Provide a general weights file ({args.weights_file_path}) or individual player files. "
                         f"A mix is also permitted.")
@@ -171,10 +183,6 @@ def main(args=None) -> tuple[argparse.Namespace, int]:
     args.sprite_pool = dict.fromkeys(range(1, args.multi+1), None)
     args.name = {}
 
-    settings_cache: dict[str, tuple[argparse.Namespace, ...]] = \
-        {fname: (tuple(roll_settings(yaml, args.plando) for yaml in yamls) if args.sameoptions else None)
-         for fname, yamls in weights_cache.items()}
-
     if meta_weights:
         for category_name, category_dict in meta_weights.items():
             for key in category_dict:
@@ -197,47 +205,85 @@ def main(args=None) -> tuple[argparse.Namespace, int]:
                             else:
                                 yaml[category_name][key] = option
 
-    player_path_cache = {}
+    settings_cache: dict[str, tuple[argparse.Namespace, ...] | None] = {fname: None for fname in weights_cache}
+    if args.sameoptions:
+        for fname, yamls in weights_cache.items():
+            try:
+                settings_cache[fname] = tuple(roll_settings(yaml, args.plando) for yaml in yamls)
+            except Exception as e:
+                logging.exception(f"Exception reading settings in file {fname}")
+                player_errors.append(
+                    f"{len(player_errors) + 1}. "
+                    f"File {fname} is invalid. Please fix your yaml.\n{Utils.get_all_causes(e)}"
+                )
+        # Exit early here to avoid throwing the same errors again later
+        if player_errors:
+            errors = "\n\n".join(player_errors)
+            raise ValueError(f"Encountered {len(player_errors)} error(s) in player files. "
+                             f"See logs for full tracebacks.\n\n{errors}")
+
+    player_path_cache: dict[int, str] = {}
     for player in range(1, args.multi + 1):
         player_path_cache[player] = player_files.get(player, args.weights_file_path)
-    name_counter = Counter()
+    name_counter: Counter[str] = Counter()
     args.player_options = {}
 
     player = 1
     while player <= args.multi:
         path = player_path_cache[player]
-        if path:
+        if not path:
+            player_errors.append(f'No weights specified for player {player}')
+            player += 1
+            continue
+
+        for doc_index, yaml in enumerate(weights_cache[path]):
+            name = yaml.get("name")
             try:
-                settings: tuple[argparse.Namespace, ...] = settings_cache[path] if settings_cache[path] else \
-                    tuple(roll_settings(yaml, args.plando) for yaml in weights_cache[path])
-                for settingsObject in settings:
-                    for k, v in vars(settingsObject).items():
-                        if v is not None:
-                            try:
-                                getattr(args, k)[player] = v
-                            except AttributeError:
-                                setattr(args, k, {player: v})
-                            except Exception as e:
-                                raise Exception(f"Error setting {k} to {v} for player {player}") from e
+                # Use the cached settings object if it exists, otherwise roll settings within the try-catch
+                # Invariant: settings_cache[path] and weights_cache[path] have the same length
+                cached = settings_cache[path]
+                settings_object: argparse.Namespace = (cached[doc_index] if cached else roll_settings(yaml, args.plando))
 
-                    # name was not specified
-                    if player not in args.name:
-                        if path == args.weights_file_path:
-                            # weights file, so we need to make the name unique
-                            args.name[player] = f"Player{player}"
-                        else:
-                            # use the filename
-                            args.name[player] = os.path.splitext(os.path.split(path)[-1])[0]
-                    args.name[player] = handle_name(args.name[player], player, name_counter)
+                for k, v in vars(settings_object).items():
+                    if v is not None:
+                        try:
+                            getattr(args, k)[player] = v
+                        except AttributeError:
+                            setattr(args, k, {player: v})
+                        except Exception as e:
+                            raise Exception(f"Error setting {k} to {v} for player {player}") from e
+
+                # name was not specified
+                if player not in args.name:
+                    if path == args.weights_file_path:
+                        # weights file, so we need to make the name unique
+                        args.name[player] = f"Player{player}"
+                    else:
+                        # use the filename
+                        args.name[player] = os.path.splitext(os.path.split(path)[-1])[0]
+                args.name[player] = handle_name(args.name[player], player, name_counter)
 
-                    player += 1
             except Exception as e:
-                raise ValueError(f"File {path} is invalid. Please fix your yaml.") from e
-        else:
-            raise RuntimeError(f'No weights specified for player {player}')
+                logging.exception(f"Exception reading settings in file {path} document #{doc_index + 1} "
+                                  f"(name: {args.name.get(player, name)})")
+                player_errors.append(
+                    f"{len(player_errors) + 1}. "
+                    f"File {path} document #{doc_index + 1} (name: {args.name.get(player, name)}) is invalid. "
+                    f"Please fix your yaml.\n{Utils.get_all_causes(e)}")
+
+            # increment for each yaml document in the file
+            player += 1
 
     if len(set(name.lower() for name in args.name.values())) != len(args.name):
-        raise Exception(f"Names have to be unique. Names: {Counter(name.lower() for name in args.name.values())}")
+        player_errors.append(
+            f"{len(player_errors) + 1}. "
+            f"Names have to be unique. Names: {Counter(name.lower() for name in args.name.values())}"
+        )
+
+    if player_errors:
+        errors = "\n\n".join(player_errors)
+        raise ValueError(f"Encountered {len(player_errors)} error(s) in player files. "
+                         f"See logs for full tracebacks.\n\n{errors}")
 
     return args, seed
 
@@ -316,7 +362,7 @@ class SafeFormatter(string.Formatter):
             return kwargs.get(key, "{" + key + "}")
 
 
-def handle_name(name: str, player: int, name_counter: Counter):
+def handle_name(name: str, player: int, name_counter: Counter[str]):
     name_counter[name.lower()] += 1
     number = name_counter[name.lower()]
     new_name = "%".join([x.replace("%number%", "{number}").replace("%player%", "{player}") for x in name.split("%%")])
@@ -347,7 +393,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__}.")
@@ -361,7 +409,9 @@ 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__}.")
@@ -450,7 +500,7 @@ def roll_triggers(weights: dict, triggers: list, valid_keys: set) -> dict:
     return weights
 
 
-def handle_option(ret: argparse.Namespace, game_weights: dict, option_key: str, option: type(Options.Option), plando_options: PlandoOptions):
+def handle_option(ret: argparse.Namespace, game_weights: dict, option_key: str, option: type[Options.Option], plando_options: PlandoOptions):
     try:
         if option_key in game_weights:
             if not option.supports_weighting:

Launcher.py

@@ -31,6 +31,10 @@ import settings
 import Utils
 from Utils import (init_logging, is_frozen, is_linux, is_macos, is_windows, local_path, messagebox, open_filename,
                    user_path)
+
+if __name__ == "__main__":
+    init_logging('Launcher')
+
 from worlds.LauncherComponents import Component, components, icon_paths, SuffixIdentifier, Type
 
 
@@ -218,12 +222,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()
 
 
@@ -488,7 +497,6 @@ def main(args: argparse.Namespace | dict | None = None):
 
 
 if __name__ == '__main__':
-    init_logging('Launcher')
     multiprocessing.freeze_support()
     multiprocessing.set_start_method("spawn")  # if launched process uses kivy, fork won't work
     parser = argparse.ArgumentParser(

ModuleUpdate.py

@@ -5,15 +5,16 @@ import multiprocessing
 import warnings
 
 
-if sys.platform in ("win32", "darwin") and sys.version_info < (3, 11, 9):
+if sys.platform in ("win32", "darwin") and not (3, 11, 9) <= sys.version_info < (3, 14, 0):
     # Official micro version updates. This should match the number in docs/running from source.md.
-    raise RuntimeError(f"Incompatible Python Version found: {sys.version_info}. Official 3.11.9+ is supported.")
+    raise RuntimeError(f"Incompatible Python Version found: {sys.version_info}. "
+                       "Official 3.11.9 through 3.13.x is supported.")
 elif sys.platform in ("win32", "darwin") and sys.version_info < (3, 11, 13):
     # There are known security issues, but no easy way to install fixed versions on Windows for testing.
     warnings.warn(f"Python Version {sys.version_info} has security issues. Don't use in production.")
-elif sys.version_info < (3, 11, 0):
+elif not (3, 11, 0) <= sys.version_info < (3, 14, 0):
     # Other platforms may get security backports instead of micro updates, so the number is unreliable.
-    raise RuntimeError(f"Incompatible Python Version found: {sys.version_info}. 3.11.0+ is supported.")
+    raise RuntimeError(f"Incompatible Python Version found: {sys.version_info}. 3.11.0 through 3.13.x is supported.")
 
 # don't run update if environment is frozen/compiled or if not the parent process (skip in subprocess)
 _skip_update = bool(

MultiServer.py

@@ -69,6 +69,12 @@ def remove_from_list(container, value):
 
 
 def pop_from_container(container, value):
+    if isinstance(container, list) and isinstance(value, int) and len(container) <= value:
+        return container
+
+    if isinstance(container, dict) and value not in container:
+        return container
+
     try:
         container.pop(value)
     except ValueError:
@@ -493,7 +499,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", {})
@@ -911,12 +917,6 @@ async def server(websocket: "ServerConnection", path: str = "/", ctx: Context =
 
 
 async def on_client_connected(ctx: Context, client: Client):
-    players = []
-    for team, clients in ctx.clients.items():
-        for slot, connected_clients in clients.items():
-            if connected_clients:
-                name = ctx.player_names[team, slot]
-                players.append(NetworkPlayer(team, slot, ctx.name_aliases.get((team, slot), name), name))
     games = {ctx.games[x] for x in range(1, len(ctx.games) + 1)}
     games.add("Archipelago")
     await ctx.send_msgs(client, [{
@@ -1364,7 +1364,10 @@ class CommandProcessor(metaclass=CommandMeta):
                         argname += "=" + parameter.default
                 argtext += argname
                 argtext += " "
-            doctext = '\n    '.join(inspect.getdoc(method).split('\n'))
+            method_doc = inspect.getdoc(method)
+            if method_doc is None:
+                method_doc = "(missing help text)"
+            doctext = "\n    ".join(method_doc.split("\n"))
             s += f"{self.marker}{command} {argtext}\n    {doctext}\n"
         return s
 

Options.py

@@ -24,6 +24,39 @@ if typing.TYPE_CHECKING:
     import pathlib
 
 
+_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 triangular(lower: int, end: int, tri: float = 0.5) -> int:
+    """
+    Integer triangular distribution for `lower` inclusive to `end` inclusive.
+
+    Expects `lower <= end` and `0.0 <= tri <= 1.0`. The result of other inputs is undefined.
+    """
+    # Use the continuous range [lower, end + 1) to produce an integer result in [lower, end].
+    # random.triangular is actually [a, b] and not [a, b), so there is a very small chance of getting exactly b even
+    # when a != b, so ensure the result is never more than `end`.
+    return min(end, math.floor(random.triangular(0.0, 1.0, tri) * (end - lower + 1) + lower))
+  
+
+def random_weighted_range(text: str, range_start: int, range_end: int):
+    if text == "random-low":
+        return triangular(range_start, range_end, 0.0)
+    elif text == "random-high":
+        return triangular(range_start, range_end, 1.0)
+    elif text == "random-middle":
+        return triangular(range_start, range_end)
+    elif text == "random":
+        return random.randint(range_start, range_end)
+    else:
+            raise Exception(f"random text \"{text}\" did not resolve to a recognized pattern. "
+                            f"Acceptable values are: {', '.join(_RANDOM_OPTS)}.")
+
+        
 def roll_percentage(percentage: int | float) -> bool:
     """Roll a percentage chance.
     percentage is expected to be in range [0, 100]"""
@@ -417,10 +450,12 @@ class Toggle(NumericOption):
     def from_text(cls, text: str) -> Toggle:
         if text == "random":
             return cls(random.choice(list(cls.name_lookup)))
-        elif text.lower() in {"off", "0", "false", "none", "null", "no"}:
+        elif text.lower() in {"off", "0", "false", "none", "null", "no", "disabled"}:
             return cls(0)
-        else:
+        elif text.lower() in {"on", "1", "true", "yes", "enabled"}:
             return cls(1)
+        else:
+            raise OptionError(f"Option {cls.__name__} does not support a value of {text}")
 
     @classmethod
     def from_any(cls, data: typing.Any):
@@ -523,9 +558,9 @@ class Choice(NumericOption):
 
 class TextChoice(Choice):
     """Allows custom string input and offers choices. Choices will resolve to int and text will resolve to string"""
-    value: typing.Union[str, int]
+    value: str | int
 
-    def __init__(self, value: typing.Union[str, int]):
+    def __init__(self, value: str | int):
         assert isinstance(value, str) or isinstance(value, int), \
             f"'{value}' is not a valid option for '{self.__class__.__name__}'"
         self.value = value
@@ -546,7 +581,7 @@ class TextChoice(Choice):
         return cls(text)
 
     @classmethod
-    def get_option_name(cls, value: T) -> str:
+    def get_option_name(cls, value: str | int) -> str:
         if isinstance(value, str):
             return value
         return super().get_option_name(value)
@@ -688,12 +723,6 @@ 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__}")
@@ -742,25 +771,16 @@ class Range(NumericOption):
 
     @classmethod
     def weighted_range(cls, text) -> Range:
-        if text == "random-low":
-            return cls(cls.triangular(cls.range_start, cls.range_end, 0.0))
-        elif text == "random-high":
-            return cls(cls.triangular(cls.range_start, cls.range_end, 1.0))
-        elif text == "random-middle":
-            return cls(cls.triangular(cls.range_start, cls.range_end))
-        elif text.startswith("random-range-"):
+        if text.startswith("random-range-"):
             return cls.custom_range(text)
-        elif text == "random":
-            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: {', '.join(cls._RANDOM_OPTS)}.")
+            return cls(random_weighted_range(text, cls.range_start, cls.range_end))
 
     @classmethod
     def custom_range(cls, text) -> Range:
         textsplit = text.split("-")
         try:
-            random_range = [int(textsplit[len(textsplit) - 2]), int(textsplit[len(textsplit) - 1])]
+            random_range = [int(textsplit[-2]), int(textsplit[-1])]
         except ValueError:
             raise ValueError(f"Invalid random range {text} for option {cls.__name__}")
         random_range.sort()
@@ -768,14 +788,9 @@ class Range(NumericOption):
             raise Exception(
                 f"{random_range[0]}-{random_range[1]} is outside allowed range "
                 f"{cls.range_start}-{cls.range_end} for option {cls.__name__}")
-        if text.startswith("random-range-low"):
-            return cls(cls.triangular(random_range[0], random_range[1], 0.0))
-        elif text.startswith("random-range-middle"):
-            return cls(cls.triangular(random_range[0], random_range[1]))
-        elif text.startswith("random-range-high"):
-            return cls(cls.triangular(random_range[0], random_range[1], 1.0))
-        else:
-            return cls(random.randint(random_range[0], random_range[1]))
+        if textsplit[2] in ("low", "middle", "high"):
+            return cls(random_weighted_range(f"{textsplit[0]}-{textsplit[2]}", *random_range))
+        return cls(random_weighted_range("random", *random_range))
 
     @classmethod
     def from_any(cls, data: typing.Any) -> Range:
@@ -790,18 +805,6 @@ class Range(NumericOption):
     def __str__(self) -> str:
         return str(self.value)
 
-    @staticmethod
-    def triangular(lower: int, end: int, tri: float = 0.5) -> int:
-        """
-        Integer triangular distribution for `lower` inclusive to `end` inclusive.
-
-        Expects `lower <= end` and `0.0 <= tri <= 1.0`. The result of other inputs is undefined.
-        """
-        # Use the continuous range [lower, end + 1) to produce an integer result in [lower, end].
-        # random.triangular is actually [a, b] and not [a, b), so there is a very small chance of getting exactly b even
-        # when a != b, so ensure the result is never more than `end`.
-        return min(end, math.floor(random.triangular(0.0, 1.0, tri) * (end - lower + 1) + lower))
-
 
 class NamedRange(Range):
     special_range_names: typing.Dict[str, int] = {}
@@ -891,7 +894,7 @@ class VerifyKeys(metaclass=FreezeValidKeys):
     def __iter__(self) -> typing.Iterator[typing.Any]:
         return self.value.__iter__()
 
-    
+
 class OptionDict(Option[typing.Dict[str, typing.Any]], VerifyKeys, typing.Mapping[str, typing.Any]):
     default = {}
     supports_weighting = False
@@ -906,7 +909,8 @@ class OptionDict(Option[typing.Dict[str, typing.Any]], VerifyKeys, typing.Mappin
         else:
             raise NotImplementedError(f"Cannot Convert from non-dictionary, got {type(data)}")
 
-    def get_option_name(self, value):
+    @classmethod
+    def get_option_name(cls, value):
         return ", ".join(f"{key}: {v}" for key, v in value.items())
 
     def __getitem__(self, item: str) -> typing.Any:
@@ -986,7 +990,8 @@ class OptionList(Option[typing.List[typing.Any]], VerifyKeys):
             return cls(data)
         return cls.from_text(str(data))
 
-    def get_option_name(self, value):
+    @classmethod
+    def get_option_name(cls, value):
         return ", ".join(map(str, value))
 
     def __contains__(self, item):
@@ -996,13 +1001,19 @@ class OptionList(Option[typing.List[typing.Any]], VerifyKeys):
 class OptionSet(Option[typing.Set[str]], VerifyKeys):
     default = frozenset()
     supports_weighting = False
+    random_str: str | None
 
-    def __init__(self, value: typing.Iterable[str]):
+    def __init__(self, value: typing.Iterable[str], random_str: str | None = None):
         self.value = set(deepcopy(value))
+        self.random_str = random_str
         super(OptionSet, self).__init__()
 
     @classmethod
     def from_text(cls, text: str):
+        check_text = text.lower().split(",")
+        if ((cls.valid_keys or cls.verify_item_name or cls.verify_location_name)
+                and len(check_text) == 1 and check_text[0].startswith("random")):
+            return cls((), check_text[0])
         return cls([option.strip() for option in text.split(",")])
 
     @classmethod
@@ -1011,7 +1022,37 @@ class OptionSet(Option[typing.Set[str]], VerifyKeys):
             return cls(data)
         return cls.from_text(str(data))
 
-    def get_option_name(self, value):
+    def verify(self, world: typing.Type[World], player_name: str, plando_options: PlandoOptions) -> None:
+        if self.random_str and not self.value:
+            choice_list = sorted(self.valid_keys)
+            if self.verify_item_name:
+                choice_list.extend(sorted(world.item_names))
+            if self.verify_location_name:
+                choice_list.extend(sorted(world.location_names))
+            if self.random_str.startswith("random-range-"):
+                textsplit = self.random_str.split("-")
+                try:
+                    random_range = [int(textsplit[-2]), int(textsplit[-1])]
+                except ValueError:
+                    raise ValueError(f"Invalid random range {self.random_str} for option {self.__class__.__name__} "
+                                     f"for player {player_name}")
+                random_range.sort()
+                if random_range[0] < 0 or random_range[1] > len(choice_list):
+                    raise Exception(
+                        f"{random_range[0]}-{random_range[1]} is outside allowed range "
+                        f"0-{len(choice_list)} for option {self.__class__.__name__} for player {player_name}")
+                if textsplit[2] in ("low", "middle", "high"):
+                    choice_count = random_weighted_range(f"{textsplit[0]}-{textsplit[2]}",
+                                                         random_range[0], random_range[1])
+                else:
+                    choice_count = random_weighted_range("random", random_range[0], random_range[1])
+            else:
+                choice_count = random_weighted_range(self.random_str, 0, len(choice_list))
+            self.value = set(random.sample(choice_list, k=choice_count))
+        super(Option, self).verify(world, player_name, plando_options)
+
+    @classmethod
+    def get_option_name(cls, value):
         return ", ".join(sorted(value))
 
     def __contains__(self, item):
@@ -1545,6 +1586,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))
@@ -1655,7 +1697,7 @@ class PlandoItems(Option[typing.List[PlandoItem]]):
     def __len__(self) -> int:
         return len(self.value)
 
-        
+
 class Removed(FreeText):
     """This Option has been Removed."""
     rich_text_doc = True
@@ -1741,8 +1783,10 @@ def generate_yaml_templates(target_folder: typing.Union[str, "pathlib.Path"], ge
     from Utils import local_path, __version__
 
     full_path: str
+    preset_folder = os.path.join(target_folder, "Presets")
 
     os.makedirs(target_folder, exist_ok=True)
+    os.makedirs(preset_folder, exist_ok=True)
 
     # clean out old
     for file in os.listdir(target_folder):
@@ -1750,11 +1794,16 @@ def generate_yaml_templates(target_folder: typing.Union[str, "pathlib.Path"], ge
         if os.path.isfile(full_path) and full_path.endswith(".yaml"):
             os.unlink(full_path)
 
-    def dictify_range(option: Range):
-        data = {option.default: 50}
+    for file in os.listdir(preset_folder):
+        full_path = os.path.join(preset_folder, file)
+        if os.path.isfile(full_path) and full_path.endswith(".yaml"):
+            os.unlink(full_path)
+
+    def dictify_range(option: Range, option_val: int | str):
+        data = {option_val: 50}
         for sub_option in ["random", "random-low", "random-high",
                            f"random-range-{option.range_start}-{option.range_end}"]:
-            if sub_option != option.default:
+            if sub_option != option_val:
                 data[sub_option] = 0
         notes = {
             "random-low": "random value weighted towards lower values",
@@ -1767,6 +1816,8 @@ def generate_yaml_templates(target_folder: typing.Union[str, "pathlib.Path"], ge
             if number in data:
                 data[name] = data[number]
                 del data[number]
+            elif name in data:
+                pass
             else:
                 data[name] = 0
 
@@ -1782,20 +1833,27 @@ def generate_yaml_templates(target_folder: typing.Union[str, "pathlib.Path"], ge
 
     for game_name, world in AutoWorldRegister.world_types.items():
         if not world.hidden or generate_hidden:
+            presets = world.web.options_presets.copy()
+            presets.update({"": {}})
+
             option_groups = get_option_groups(world)
-
-            res = template.render(
-                option_groups=option_groups,
-                __version__=__version__,
-                game=game_name,
-                world_version=world.world_version.as_simple_string(),
-                yaml_dump=yaml_dump_scalar,
-                dictify_range=dictify_range,
-                cleandoc=cleandoc,
-            )
-
-            with open(os.path.join(target_folder, get_file_safe_name(game_name) + ".yaml"), "w", encoding="utf-8-sig") as f:
-                f.write(res)
+            for name, preset in presets.items():
+                res = template.render(
+                    option_groups=option_groups,
+                    __version__=__version__,
+                    game=game_name, 
+                    world_version=world.world_version.as_simple_string(),
+                    yaml_dump=yaml_dump_scalar,
+                    dictify_range=dictify_range,
+                    cleandoc=cleandoc,
+                    preset_name=name,
+                    preset=preset,
+                )
+                preset_name = f" - {name}" if name else ""
+                with open(os.path.join(preset_folder if name else target_folder,
+                                       get_file_safe_name(game_name + preset_name) + ".yaml"),
+                          "w", encoding="utf-8-sig") as f:
+                    f.write(res)
 
 
 def dump_player_options(multiworld: MultiWorld) -> None:

OptionsCreator.py

@@ -1,5 +1,12 @@
+if __name__ == "__main__":
+    import ModuleUpdate
+
+    ModuleUpdate.update()
+
+
 from kvui import (ThemedApp, ScrollBox, MainLayout, ContainerLayout, dp, Widget, MDBoxLayout, TooltipLabel, MDLabel,
                   ToggleButton, MarkupDropdown, ResizableTextField)
+from kivy.clock import Clock
 from kivy.uix.behaviors.button import ButtonBehavior
 from kivymd.uix.behaviors import RotateBehavior
 from kivymd.uix.anchorlayout import MDAnchorLayout
@@ -263,34 +270,53 @@ class OptionsCreator(ThemedApp):
         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"])],
+    @staticmethod
+    def show_result_snack(text: str) -> None:
+        MDSnackbar(MDSnackbarText(text=text), y=dp(24), pos_hint={"center_x": 0.5}, size_hint_x=0.5).open()
+
+    def on_export_result(self, text: str | None) -> None:
+        self.container.disabled = False
+        if text is not None:
+            Clock.schedule_once(lambda _: self.show_result_snack(text), 0)
+
+    def export_options_background(self, options: dict[str, typing.Any]) -> None:
+        try:
+            file_name = Utils.save_filename("Export Options File As...", [("YAML", [".yaml"])],
                                             Utils.get_file_safe_name(f"{self.name_input.text}.yaml"))
+        except Exception:
+            self.on_export_result("Could not open dialog. Already open?")
+            raise
+
+        if not file_name:
+            self.on_export_result(None)  # No file selected. No need to show a message for this.
+            return
+
+        try:
+            with open(file_name, 'w') as f:
+                f.write(Utils.dump(options, sort_keys=False))
+                f.close()
+                self.on_export_result("File saved successfully.")
+        except Exception:
+            self.on_export_result("Could not save file.")
+            raise
+
+    def export_options(self, button: Widget) -> None:
+        if 0 < len(self.name_input.text) < 17 and self.current_game:
+            import threading
             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()
+            threading.Thread(target=self.export_options_background, args=(options,), daemon=True).start()
+            self.container.disabled = True
         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()
+            self.show_result_snack("Name must not be empty.")
         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()
+            self.show_result_snack("You must select a game to play.")
         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()
+            self.show_result_snack("Name cannot be longer than 16 characters.")
 
     def create_range(self, option: typing.Type[Range], name: str):
         def update_text(range_box: VisualRange):
@@ -330,6 +356,11 @@ class OptionsCreator(ThemedApp):
             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 = [
             {
@@ -365,7 +396,7 @@ class OptionsCreator(ThemedApp):
             # for some reason this fixes an issue causing some to not open
             dropdown.open()
 
-        default_random = option.default == "random"
+        default_string = isinstance(option.default, str)
         main_button = VisualChoice(option=option, name=name)
         main_button.bind(on_release=open_dropdown)
 
@@ -377,7 +408,7 @@ class OptionsCreator(ThemedApp):
             for choice in option.name_lookup
         ]
         dropdown = MDDropdownMenu(caller=main_button, items=items)
-        self.options[name] = option.name_lookup[option.default] if not default_random else option.default
+        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):
@@ -498,8 +529,10 @@ class OptionsCreator(ThemedApp):
                     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])
+                    if self.options[name].isnumeric():
+                        self.options[name] = int(self.options[name])
+                    elif self.options[name] in ("True", "False"):
+                        self.options[name] = self.options[name] == "True"
 
                 base_object = instance.parent.parent
                 label_object = instance.parent
@@ -560,8 +593,11 @@ class OptionsCreator(ThemedApp):
                 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",
@@ -583,8 +619,7 @@ class OptionsCreator(ThemedApp):
                 group_box.layout.orientation = "vertical"
                 group_box.layout.spacing = dp(3)
                 for name, option in options:
-                    if name and option is not Removed and option.visibility & Visibility.simple_ui:
-                        group_content.add_widget(self.create_option(option, name, cls))
+                    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}"
@@ -619,7 +654,7 @@ class OptionsCreator(ThemedApp):
             self.create_options_panel(world_btn)
 
         for world, cls in sorted(AutoWorldRegister.world_types.items(), key=lambda x: x[0]):
-            if world == "Archipelago":
+            if cls.hidden:
                 continue
             world_text = MDButtonText(text=world, size_hint_y=None, width=dp(150),
                                       pos_hint={"x": 0.03, "center_y": 0.5})

README.md

@@ -83,6 +83,8 @@ Currently, the following games are supported:
 * Celeste (Open World)
 * Choo-Choo Charles
 * APQuest
+* Satisfactory
+* EarthBound
 
 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

Utils.py

@@ -22,6 +22,7 @@ from settings import Settings, get_settings
 from time import sleep
 from typing import BinaryIO, Coroutine, Optional, Set, Dict, Any, Union, TypeGuard
 from yaml import load, load_all, dump
+from pathspec import PathSpec, GitIgnoreSpec
 
 try:
     from yaml import CLoader as UnsafeLoader, CSafeLoader as SafeLoader, CDumper as Dumper
@@ -48,7 +49,7 @@ class Version(typing.NamedTuple):
         return ".".join(str(item) for item in self)
 
 
-__version__ = "0.6.5"
+__version__ = "0.6.7"
 version_tuple = tuplize_version(__version__)
 
 is_linux = sys.platform.startswith("linux")
@@ -387,6 +388,14 @@ def store_data_package_for_checksum(game: str, data: typing.Dict[str, Any]) -> N
             logging.debug(f"Could not store data package: {e}")
 
 
+def read_apignore(filename: str | pathlib.Path) -> PathSpec | None:
+    try:
+        with open(filename) as ignore_file:
+            return GitIgnoreSpec.from_lines(ignore_file)
+    except FileNotFoundError:
+        return None
+
+
 def get_default_adjuster_settings(game_name: str) -> Namespace:
     import LttPAdjuster
     adjuster_settings = Namespace()
@@ -802,29 +811,32 @@ def open_filename(title: str, filetypes: typing.Iterable[typing.Tuple[str, typin
         except tkinter.TclError:
             return None  # GUI not available. None is the same as a user clicking "cancel"
         root.withdraw()
-        return tkinter.filedialog.askopenfilename(title=title, filetypes=((t[0], ' '.join(t[1])) for t in filetypes),
-                                                  initialfile=suggest or None)
+        try:
+            return tkinter.filedialog.askopenfilename(
+                title=title,
+                filetypes=((t[0], ' '.join(t[1])) for t in filetypes),
+                initialfile=suggest or None,
+            )
+        finally:
+            root.destroy()
 
 
 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)
+            return _run_for_stdout(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)
+            return _run_for_stdout(zenity, f"--title={title}", "--file-selection", "--save", *z_filters, *selection)
 
     # fall back to tk
     try:
@@ -847,8 +859,14 @@ def save_filename(title: str, filetypes: typing.Iterable[typing.Tuple[str, typin
         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)
+        try:
+            return tkinter.filedialog.asksaveasfilename(
+                title=title,
+                filetypes=((t[0], ' '.join(t[1])) for t in filetypes),
+                initialfile=suggest or None,
+            )
+        finally:
+            root.destroy()
 
 
 def _mp_open_directory(res: "multiprocessing.Queue[typing.Optional[str]]", *args: Any) -> None:
@@ -896,6 +914,13 @@ def open_directory(title: str, suggest: str = "") -> typing.Optional[str]:
 
 
 def messagebox(title: str, text: str, error: bool = False) -> None:
+    if not gui_enabled:
+        if error:
+            logging.error(f"{title}: {text}")
+        else:
+            logging.info(f"{title}: {text}")
+        return
+
     if is_kivy_running():
         from kvui import MessageBox
         MessageBox(title, text, error).open()
@@ -931,6 +956,9 @@ def messagebox(title: str, text: str, error: bool = False) -> None:
         root.update()
 
 
+gui_enabled = not sys.stdout or "--nogui" not in sys.argv
+"""Checks if the user wanted no GUI mode and has a terminal to use it with."""
+
 def title_sorted(data: typing.Iterable, key=None, ignore: typing.AbstractSet[str] = frozenset(("a", "the"))):
     """Sorts a sequence of text ignoring typical articles like "a" or "the" in the beginning."""
     def sorter(element: Union[str, Dict[str, Any]]) -> str:
@@ -1050,9 +1078,18 @@ def freeze_support() -> None:
 _extend_freeze_support()
 
 
-def visualize_regions(root_region: Region, file_name: str, *,
-                      show_entrance_names: bool = False, show_locations: bool = True, show_other_regions: bool = True,
-                      linetype_ortho: bool = True, regions_to_highlight: set[Region] | None = None) -> None:
+def visualize_regions(
+        root_region: Region,
+        file_name: str,
+        *,
+        show_entrance_names: bool = False,
+        show_locations: bool = True,
+        show_other_regions: bool = True,
+        linetype_ortho: bool = True,
+        regions_to_highlight: set[Region] | None = None,
+        entrance_highlighting: dict[int, int] | None = None,
+        detail_other_regions: bool = False,
+        auto_assign_colors: bool = False) -> None:
     """Visualize the layout of a world as a PlantUML diagram.
 
     :param root_region: The region from which to start the diagram from. (Usually the "Menu" region of your world.)
@@ -1069,6 +1106,13 @@ def visualize_regions(root_region: Region, file_name: str, *,
     :param show_other_regions: (default True) If enabled, regions that can't be reached by traversing exits are shown.
     :param linetype_ortho: (default True) If enabled, orthogonal straight line parts will be used; otherwise polylines.
     :param regions_to_highlight: Regions that will be highlighted in green if they are reachable.
+    :param entrance_highlighting: a mapping from your world's entrance randomization groups to RGB values, used to color
+            your entrances
+    :param detail_other_regions: (default False) If enabled, will fully visualize regions that aren't reachable
+            from root_region.
+    :param auto_assign_colors: (default False) If enabled, will automatically assign random colors to entrances of the
+            same randomization group. Uses entrance_highlighting first, and only picks random colors for entrance groups
+            not found in the passed-in map
 
     Example usage in World code:
     from Utils import visualize_regions
@@ -1094,6 +1138,34 @@ def visualize_regions(root_region: Region, file_name: str, *,
     regions: typing.Deque[Region] = deque((root_region,))
     multiworld: MultiWorld = root_region.multiworld
 
+    colors_used: set[int] = set()
+    if entrance_highlighting:
+        for color in entrance_highlighting.values():
+            # filter the colors to their most-significant bits to avoid too similar colors
+            colors_used.add(color & 0xF0F0F0)
+    else:
+        # assign an empty dict to not crash later
+        # the parameter is optional for ease of use when you don't care about colors
+        entrance_highlighting = {}
+
+    def select_color(group: int) -> int:
+        # specifically spacing color indexes by three different prime numbers (3, 5, 7) for the RGB components to avoid
+        # obvious cyclical color patterns
+        COLOR_INDEX_SPACING: int = 0x357
+        new_color_index: int = (group * COLOR_INDEX_SPACING) % 0x1000
+        new_color = ((new_color_index & 0xF00) << 12) + \
+                    ((new_color_index & 0xF0) << 8) + \
+                    ((new_color_index & 0xF) << 4)
+        while new_color in colors_used:
+            # while this is technically unbounded, expected collisions are low. There are 4095 possible colors
+            # and worlds are unlikely to get to anywhere close to that many entrance groups
+            # intentionally not using multiworld.random to not affect output when debugging with this tool
+            new_color_index += COLOR_INDEX_SPACING
+            new_color = ((new_color_index & 0xF00) << 12) + \
+                        ((new_color_index & 0xF0) << 8) + \
+                        ((new_color_index & 0xF) << 4)
+        return new_color
+
     def fmt(obj: Union[Entrance, Item, Location, Region]) -> str:
         name = obj.name
         if isinstance(obj, Item):
@@ -1113,18 +1185,28 @@ def visualize_regions(root_region: Region, file_name: str, *,
 
     def visualize_exits(region: Region) -> None:
         for exit_ in region.exits:
+            color_code: str = ""
+            if exit_.randomization_group in entrance_highlighting:
+                color_code = f" #{entrance_highlighting[exit_.randomization_group]:0>6X}"
             if exit_.connected_region:
                 if show_entrance_names:
-                    uml.append(f"\"{fmt(region)}\" --> \"{fmt(exit_.connected_region)}\" : \"{fmt(exit_)}\"")
+                    uml.append(f"\"{fmt(region)}\" --> \"{fmt(exit_.connected_region)}\" : \"{fmt(exit_)}\"{color_code}")
                 else:
                     try:
-                        uml.remove(f"\"{fmt(exit_.connected_region)}\" --> \"{fmt(region)}\"")
-                        uml.append(f"\"{fmt(exit_.connected_region)}\" <--> \"{fmt(region)}\"")
+                        uml.remove(f"\"{fmt(exit_.connected_region)}\" --> \"{fmt(region)}\"{color_code}")
+                        uml.append(f"\"{fmt(exit_.connected_region)}\" <--> \"{fmt(region)}\"{color_code}")
                     except ValueError:
-                        uml.append(f"\"{fmt(region)}\" --> \"{fmt(exit_.connected_region)}\"")
+                        uml.append(f"\"{fmt(region)}\" --> \"{fmt(exit_.connected_region)}\"{color_code}")
             else:
-                uml.append(f"circle \"unconnected exit:\\n{fmt(exit_)}\"")
-                uml.append(f"\"{fmt(region)}\" --> \"unconnected exit:\\n{fmt(exit_)}\"")
+                uml.append(f"circle \"unconnected exit:\\n{fmt(exit_)}\" {color_code}")
+                uml.append(f"\"{fmt(region)}\" --> \"unconnected exit:\\n{fmt(exit_)}\"{color_code}")
+        for entrance in region.entrances:
+            color_code: str = ""
+            if entrance.randomization_group in entrance_highlighting:
+                color_code = f" #{entrance_highlighting[entrance.randomization_group]:0>6X}"
+            if not entrance.parent_region:
+                uml.append(f"circle \"unconnected entrance:\\n{fmt(entrance)}\"{color_code}")
+                uml.append(f"\"unconnected entrance:\\n{fmt(entrance)}\" --> \"{fmt(region)}\"{color_code}")
 
     def visualize_locations(region: Region) -> None:
         any_lock = any(location.locked for location in region.locations)
@@ -1145,9 +1227,27 @@ def visualize_regions(root_region: Region, file_name: str, *,
         if other_regions := [region for region in multiworld.get_regions(root_region.player) if region not in seen]:
             uml.append("package \"other regions\" <<Cloud>> {")
             for region in other_regions:
-                uml.append(f"class \"{fmt(region)}\"")
+                if detail_other_regions:
+                    visualize_region(region)
+                else:
+                    uml.append(f"class \"{fmt(region)}\"")
             uml.append("}")
 
+    if auto_assign_colors:
+        all_entrances: list[Entrance] = []
+        for region in multiworld.get_regions(root_region.player):
+            all_entrances.extend(region.entrances)
+            all_entrances.extend(region.exits)
+        all_groups: list[int] = sorted(set([entrance.randomization_group for entrance in all_entrances]))
+        for group in all_groups:
+            if group not in entrance_highlighting:
+                if len(colors_used) >= 0x1000:
+                    # on the off chance someone makes 4096 different entrance groups, don't cycle forever
+                    break
+                new_color: int = select_color(group)
+                entrance_highlighting[group] = new_color
+                colors_used.add(new_color)
+
     uml.append("@startuml")
     uml.append("hide circle")
     uml.append("hide empty members")
@@ -1158,7 +1258,7 @@ def visualize_regions(root_region: Region, file_name: str, *,
             seen.add(current_region)
             visualize_region(current_region)
             regions.extend(exit_.connected_region for exit_ in current_region.exits if exit_.connected_region)
-    if show_other_regions:
+    if show_other_regions or detail_other_regions:
         visualize_other_regions()
     uml.append("@enduml")
 
@@ -1222,3 +1322,35 @@ class DaemonThreadPoolExecutor(concurrent.futures.ThreadPoolExecutor):
             t.start()
             self._threads.add(t)
             # NOTE: don't add to _threads_queues so we don't block on shutdown
+
+
+def get_full_typename(t: type) -> str:
+    """Returns the full qualified name of a type, including its module (if not builtins)."""
+    module = t.__module__
+    if module and module != "builtins":
+        return f"{module}.{t.__qualname__}"
+    return t.__qualname__
+
+
+def get_all_causes(ex: Exception) -> str:
+    """Return a string describing the recursive causes of this exception.
+
+    :param ex: The exception to be described.
+    :return A multiline string starting with the initial exception on the first line and each resulting exception
+            on subsequent lines with progressive indentation.
+
+            For example:
+
+            ```
+            Exception: Invalid value 'bad'.
+             Which caused: Options.OptionError: Error generating option
+              Which caused: ValueError: File bad.yaml is invalid.
+            ```
+    """
+    cause = ex
+    causes = [f"{get_full_typename(type(ex))}: {ex}"]
+    while cause := cause.__cause__:
+        causes.append(f"{get_full_typename(type(cause))}: {cause}")
+    top = causes[-1]
+    others = "".join(f"\n{' ' * (i + 1)}Which caused: {c}" for i, c in enumerate(reversed(causes[:-1])))
+    return f"{top}{others}"

WebHost.py

@@ -20,7 +20,8 @@ if typing.TYPE_CHECKING:
 Utils.local_path.cached_path = os.path.dirname(__file__)
 settings.no_gui = True
 configpath = os.path.abspath("config.yaml")
-if not os.path.exists(configpath):  # fall back to config.yaml in home
+if not os.path.exists(configpath):
+    # fall back to config.yaml in user_path if config does not exist in cwd to match settings.py
     configpath = os.path.abspath(Utils.user_path('config.yaml'))
 
 

WebHostLib/README.md

@@ -1,46 +1,20 @@
 # WebHost
 
+## Asset License
+
+The image files used in the page design were specifically designed for archipelago.gg and are **not** covered by the top
+level LICENSE.
+See individual LICENSE files in `./static/static/**`.
+
+You are only allowed to use them for personal use, testing and development.
+If the site is reachable over the internet, have a robots.txt in place (see `ASSET_RIGHTS` in `config.yaml`)
+and do not promote it publicly. Alternatively replace or remove the assets.
+
 ## Contribution Guidelines
-**Thank you for your interest in contributing to the Archipelago website!**  
-Much of the content on the website is generated automatically, but there are some things
-that need a personal touch. For those things, we rely on contributions from both the core
-team and the community. The current primary maintainer of the website is Farrak Kilhn.
-He may be found on Discord as `Farrak Kilhn#0418`, or on GitHub as `LegendaryLinux`.
 
-### Small Changes
-Little changes like adding a button or a couple new select elements are perfectly fine.
-Tweaks to style specific to a PR's content are also probably not a problem. For example, if
-you build a new page which needs two side by side tables, and you need to write a CSS file
-specific to your page, that is perfectly reasonable.
+Pages should preferably be rendered on the server side with Jinja. Features should work with noscript if feasible.
+Design changes have to fit the overall design.
 
-### Content Additions
-Once you develop a new feature or add new content the website, make a pull request. It will
-be reviewed by the community and there will probably be some discussion around it. Depending
-on the size of the feature, and if new styles are required, there may be an additional step
-before the PR is accepted wherein Farrak works with the designer to implement styles.
+Introduction of JS dependencies should first be discussed on Discord or in a draft PR.
 
-### Restrictions on Style Changes
-A professional designer is paid to develop the styles and assets for the Archipelago website.
-In an effort to maintain a consistent look and feel, pull requests which *exclusively*
-change site styles are rejected. Please note this applies to code which changes the overall
-look and feel of the site, not to small tweaks to CSS for your custom page. The intention
-behind these restrictions is to maintain a curated feel for the design of the site. If
-any PR affects the overall feel of the site but includes additive changes, there will
-likely be a conversation about how to implement those changes without compromising the
-curated site style. It is therefore worth noting there are a couple files which, if
-changed in your pull request, will cause it to draw additional scrutiny.
-
-These closely guarded files are:
-- `globalStyles.css`
-- `islandFooter.css`
-- `landing.css`
-- `markdown.css`
-- `tooltip.css`
-
-### Site Themes
-There are several themes available for game pages. It is possible to request a new theme in
-the `#art-and-design` channel on Discord. Because themes are created by the designer, they
-are not free, and take some time to create. Farrak works closely with the designer to implement
-these themes, and pays for the assets out of pocket. Therefore, only a couple themes per year
-are added. If a proposed theme seems like a cool idea and the community likes it, there is a
-good chance it will become a reality.
+See also [docs/style.md](/docs/style.md) for the style guide.

WebHostLib/__init__.py

@@ -23,6 +23,17 @@ app.jinja_env.filters['any'] = any
 app.jinja_env.filters['all'] = all
 app.jinja_env.filters['get_file_safe_name'] = get_file_safe_name
 
+# overwrites of flask default config
+app.config["DEBUG"] = False
+app.config["PORT"] = 80
+app.config["UPLOAD_FOLDER"] = UPLOAD_FOLDER
+app.config["MAX_CONTENT_LENGTH"] = 64 * 1024 * 1024  # 64 megabyte limit
+# if you want to deploy, make sure you have a non-guessable secret key
+app.config["SECRET_KEY"] = bytes(socket.gethostname(), encoding="utf-8")
+app.config["SESSION_PERMANENT"] = True
+app.config["MAX_FORM_MEMORY_SIZE"] = 2 * 1024 * 1024  # 2 MB, needed for large option pages such as SC2
+
+# custom config
 app.config["SELFHOST"] = True  # application process is in charge of running the websites
 app.config["GENERATORS"] = 8  # maximum concurrent world gens
 app.config["HOSTERS"] = 8  # maximum concurrent room hosters
@@ -30,19 +41,12 @@ app.config["SELFLAUNCH"] = True  # application process is in charge of launching
 app.config["SELFLAUNCHCERT"] = None  # can point to a SSL Certificate to encrypt Room websocket connections
 app.config["SELFLAUNCHKEY"] = None  # can point to a SSL Certificate Key to encrypt Room websocket connections
 app.config["SELFGEN"] = True  # application process is in charge of scheduling Generations.
-app.config["DEBUG"] = False
-app.config["PORT"] = 80
-app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
-app.config['MAX_CONTENT_LENGTH'] = 64 * 1024 * 1024  # 64 megabyte limit
-# if you want to deploy, make sure you have a non-guessable secret key
-app.config["SECRET_KEY"] = bytes(socket.gethostname(), encoding="utf-8")
 # at what amount of worlds should scheduling be used, instead of rolling in the web-thread
 app.config["JOB_THRESHOLD"] = 1
 # after what time in seconds should generation be aborted, freeing the queue slot. Can be set to None to disable.
 app.config["JOB_TIME"] = 600
 # memory limit for generator processes in bytes
 app.config["GENERATOR_MEMORY_LIMIT"] = 4294967296
-app.config['SESSION_PERMANENT'] = True
 
 # waitress uses one thread for I/O, these are for processing of views that then get sent
 # archipelago.gg uses gunicorn + nginx; ignoring this option

WebHostLib/api/tracker.py

@@ -58,6 +58,12 @@ class PlayerLocationsTotal(TypedDict):
     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]:
@@ -80,7 +86,8 @@ def tracker_data(tracker: UUID) -> dict[str, Any]:
     """Slot aliases of all players."""
     for team, players in all_players.items():
         for player in players:
-            player_aliases.append({"team": team, "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)})
 
     player_items_received: list[PlayerItemsReceived] = []
     """Items received by each player."""
@@ -94,7 +101,8 @@ def tracker_data(tracker: UUID) -> dict[str, Any]:
     for team, players in all_players.items():
         for player in players:
             player_checks_done.append(
-                {"team": team, "player": player, "locations": sorted(tracker_data.get_player_checked_locations(team, player))})
+                {"team": team, "player": player,
+                 "locations": sorted(tracker_data.get_player_checked_locations(team, player))})
 
     total_checks_done: list[TeamTotalChecks] = [
         {"team": team, "checks_done": checks_done}
@@ -144,7 +152,8 @@ def tracker_data(tracker: UUID) -> dict[str, Any]:
     """The current client status for each player."""
     for team, players in all_players.items():
         for player in players:
-            player_status.append({"team": team, "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 {
         "aliases": player_aliases,
@@ -207,12 +216,20 @@ def static_tracker_data(tracker: UUID) -> dict[str, Any]:
             player_locations_total.append(
                 {"team": team, "player": player, "total_locations": len(tracker_data.get_player_locations(player))})
 
+    player_game: list[PlayerGame] = []
+    """The played game per player slot."""
+    for team, players in all_players.items():
+        for player in players:
+            player_game.append({"team": team, "player": player, "game": tracker_data.get_player_game(player)})
+
     return {
         "groups": groups,
         "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)

WebHostLib/customserver.py

@@ -89,19 +89,24 @@ class WebHostContext(Context):
             setattr(self, key, value)
         self.non_hintable_names = collections.defaultdict(frozenset, self.non_hintable_names)
 
-    def listen_to_db_commands(self):
+    async def listen_to_db_commands(self):
         cmdprocessor = DBCommandProcessor(self)
 
         while not self.exit_event.is_set():
-            with db_session:
-                commands = select(command for command in Command if command.room.id == self.room_id)
-                if commands:
-                    for command in commands:
-                        self.main_loop.call_soon_threadsafe(cmdprocessor, command.commandtext)
-                        command.delete()
-                    commit()
-            del commands
-            time.sleep(5)
+            await self.main_loop.run_in_executor(None, self._process_db_commands, cmdprocessor)
+            try:
+                await asyncio.wait_for(self.exit_event.wait(), 5)
+            except asyncio.TimeoutError:
+                pass
+
+    def _process_db_commands(self, cmdprocessor):
+        with db_session:
+            commands = select(command for command in Command if command.room.id == self.room_id)
+            if commands:
+                for command in commands:
+                    self.main_loop.call_soon_threadsafe(cmdprocessor, command.commandtext)
+                    command.delete()
+                commit()
 
     @db_session
     def load(self, room_id: int):
@@ -156,9 +161,9 @@ class WebHostContext(Context):
             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.set_save(restricted_loads(savegame_data))
             self._start_async_saving(atexit_save=False)
-        threading.Thread(target=self.listen_to_db_commands, daemon=True).start()
+        asyncio.create_task(self.listen_to_db_commands())
 
     @db_session
     def _save(self, exit_save: bool = False) -> bool:
@@ -229,6 +234,17 @@ def set_up_logging(room_id) -> logging.Logger:
     return logger
 
 
+def tear_down_logging(room_id):
+    """Close logging handling for a room."""
+    logger_name = f"RoomLogger {room_id}"
+    if logger_name in logging.Logger.manager.loggerDict:
+        logger = logging.getLogger(logger_name)
+        for handler in logger.handlers[:]:
+            logger.removeHandler(handler)
+            handler.close()
+        del logging.Logger.manager.loggerDict[logger_name]
+
+
 def run_server_process(name: str, ponyconfig: dict, static_server_data: dict,
                        cert_file: typing.Optional[str], cert_key_file: typing.Optional[str],
                        host: str, rooms_to_run: multiprocessing.Queue, rooms_shutting_down: multiprocessing.Queue):
@@ -325,7 +341,7 @@ def run_server_process(name: str, ponyconfig: dict, static_server_data: dict,
 
             except (KeyboardInterrupt, SystemExit):
                 if ctx.saving:
-                    ctx._save()
+                    ctx._save(True)
                     setattr(asyncio.current_task(), "save", None)
             except Exception as e:
                 with db_session:
@@ -336,19 +352,25 @@ def run_server_process(name: str, ponyconfig: dict, static_server_data: dict,
                 raise
             else:
                 if ctx.saving:
-                    ctx._save()
+                    ctx._save(True)
                     setattr(asyncio.current_task(), "save", None)
             finally:
                 try:
                     ctx.save_dirty = False  # make sure the saving thread does not write to DB after final wakeup
                     ctx.exit_event.set()  # make sure the saving thread stops at some point
                     # NOTE: async saving should probably be an async task and could be merged with shutdown_task
+
+                    if ctx.server and hasattr(ctx.server, "ws_server"):
+                        ctx.server.ws_server.close()
+                        await ctx.server.ws_server.wait_closed()
+
                     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
+                    tear_down_logging(room_id)
                     logging.info(f"Shutting down room {room_id} on {name}.")
                 finally:
                     await asyncio.sleep(5)

WebHostLib/misc.py

@@ -128,8 +128,13 @@ def tutorial_landing():
                 "authors": tutorial.authors,
                 "language": tutorial.language
             }
-    tutorials = {world_name: tutorials for world_name, tutorials in title_sorted(
-        tutorials.items(), key=lambda element: "\x00" if element[0] == "Archipelago" else worlds[element[0]].game)}
+
+    worlds = dict(
+        title_sorted(
+            worlds.items(), key=lambda element: "\x00" if element[0] == "Archipelago" else worlds[element[0]].game
+        )
+    )
+
     return render_template("tutorialLanding.html", worlds=worlds, tutorials=tutorials)
 
 

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?
 

WebHostLib/templates/playerOptions/macros.html

@@ -55,6 +55,9 @@
     {{ OptionTitle(option_name, option) }}
     <div class="named-range-container">
         <select id="{{ option_name }}-select" name="{{ option_name }}" data-option-name="{{ option_name }}" {{ "disabled" if option.default == "random" }}>
+            {% if option.default not in option.special_range_names.values() %}
+                <option value="{{ option.default }}" selected>Default ({{ option.default }})</option>
+            {% endif %}
             {% for key, val in option.special_range_names.items() %}
                 {% if option.default == val %}
                     <option value="{{ val }}" selected>{{ key|replace("_", " ")|title }} ({{ val }})</option>
@@ -94,6 +97,9 @@
     <div class="text-choice-container">
         <div class="text-choice-wrapper">
             <select id="{{ option_name }}" name="{{ option_name }}" {{ "disabled" if option.default == "random" }}>
+            {% if option.default not in option.options.values()  %}
+                <option value="{{ option.default }}" selected>Default ({{ option.default }})</option>
+            {% endif %}
             {% for id, name in option.name_lookup.items()|sort %}
                 {% if name != "random" %}
                     {% if option.default == id %}

WebHostLib/tracker.py

@@ -959,7 +959,7 @@ if "Timespinner" in network_data_package["games"]:
 
         timespinner_location_ids = {
             "Present": list(range(1337000, 1337085)),
-            "Past": list(range(1337086, 1337175)),
+            "Past": list(range(1337086, 1337157)) + list(range(1337159, 1337175)),
             "Ancient Pyramid": [
                 1337236,
                 1337246, 1337247, 1337248, 1337249]

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)

data/GLOBAL.apignore

@@ -0,0 +1,13 @@
+# This file specifies patterns that are ignored by default for any world built with the "Build APWorlds" component.
+# These patterns can be overriden by a world-specific .apignore using !-prefixed patterns for negation.
+
+# Auto-created folders
+__MACOSX
+.DS_Store
+__pycache__
+
+# Unneeded files
+/archipelago.json
+/.apignore
+/.git
+/.gitignore

data/options.yaml

@@ -28,7 +28,7 @@
 name: Player{number}
 
 # Used to describe your yaml. Useful if you have multiple files.
-description: {{ yaml_dump("Default %s Template" % game) }}
+description: {{ yaml_dump("%s Preset for %s" % (preset_name, game)) if preset_name else yaml_dump("Default %s Template" % game) }}
 
 game: {{ yaml_dump(game) }}
 requires:
@@ -38,11 +38,11 @@ requires:
     {{ yaml_dump(game) }}: {{ world_version }} # Version of the world required for this yaml to work as expected.
   {%- endif %}
 
-{%- macro range_option(option) %}
+{%- macro range_option(option, option_val) %}
     # You can define additional values between the minimum and maximum values.
     # Minimum value is {{ option.range_start }}
     # Maximum value is {{ option.range_end }}
-    {%- set data, notes = dictify_range(option) %}
+    {%- set data, notes = dictify_range(option, option_val) %}
     {%- for entry, default in data.items() %}
     {{ entry }}: {{ default }}{% if notes[entry] %} # {{ notes[entry] }}{% endif %}
     {%- endfor -%}
@@ -56,6 +56,10 @@ requires:
 
   {%- for option_key, option in group_options.items() %}
   {{ option_key }}:
+    {%- set option_val = option.default %}
+    {%- if option_key in preset %}
+      {%- set option_val = preset[option_key] %}
+    {%- endif -%}
     {%- if option.__doc__ %}
     # {{ cleandoc(option.__doc__)
         | trim
@@ -69,25 +73,25 @@ requires:
     {%- endif -%}
 
     {%- if option.range_start is defined and option.range_start is number %}
-    {{- range_option(option) -}}
+    {{- range_option(option, option_val) -}}
 
     {%- elif option.options -%}
     {%- for suboption_option_id, sub_option_name in option.name_lookup.items() %}
-    {{ yaml_dump(sub_option_name) }}: {% if suboption_option_id == option.default %}50{% else %}0{% endif %}
+    {{ yaml_dump(sub_option_name) }}: {% if suboption_option_id == option_val or sub_option_name == option_val %}50{% else %}0{% endif %}
     {%- endfor -%}
-
-    {%- if option.name_lookup[option.default] not in option.options %}
-    {{ yaml_dump(option.default) }}: 50
+  
+    {%- if option.name_lookup[option_val] not in option.options and option_val not in option.options %}
+    {{ yaml_dump(option_val) }}: 50
     {%- endif -%}
 
-    {%- elif option.default is string %}
-    {{ yaml_dump(option.default) }}: 50
+    {%- elif option_val is string %}
+    {{ yaml_dump(option_val) }}: 50
 
-    {%- elif option.default is iterable and option.default is not mapping %}
-    {{ option.default | list }}
+    {%- elif option_val is iterable and option_val is not mapping %}
+    {{ option_val | list }}
 
     {%- else %}
-    {{ yaml_dump(option.default) | indent(4, first=false) }}
+    {{ yaml_dump(option_val) | indent(4, first=false) }}
     {%- endif -%}
     {{ "\n" }}
   {%- endfor %}

data/optionscreator.kv

@@ -6,12 +6,12 @@
     tag: tag
     MDLabel:
         id: tag
-        text: str(this.option.default) if this.option.default != "random" else this.option.range_start
+        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 this.option.default != "random" else this.option.range_start
+        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:
@@ -23,7 +23,7 @@
     text: text
     MDButtonText:
         id: text
-        text: this.option.get_option_name(this.option.default if this.option.default != "random" else list(this.option.options.values())[0])
+        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>:
@@ -38,7 +38,7 @@
         text: text
         MDButtonText:
             id: text
-            text: this.option.special_range_names.get(list(this.option.special_range_names.values()).index(this.option.default)) if this.option.default in this.option.special_range_names else "Custom"
+            text: this.option.default.title() if this.option.default in this.option.special_range_names else "Custom"
 
 <VisualFreeText>:
     multiline: False

docs/CODEOWNERS

@@ -70,6 +70,9 @@
 # DOOM II
 /worlds/doom_ii/ @Daivuk @KScl
 
+# EarthBound
+/worlds/earthbound/ @PinkSwitch
+
 # Factorio
 /worlds/factorio/ @Berserker66
 
@@ -176,8 +179,12 @@
 # Sonic Adventure 2 Battle
 /worlds/sa2b/ @PoryGone @RaspberrySpace
 
+# Satisfactory
+/worlds/satisfactory/ @Jarno458 @budak7273
+
 # Starcraft 2
-/worlds/sc2/ @Ziktofel
+# Note: @Ziktofel acts as a mentor
+/worlds/sc2/ @MatthewMarinets @Snarkie @SirChuckOfTheChuckles
 
 # Super Metroid
 /worlds/sm/ @lordlou

docs/adding games.md

@@ -17,7 +17,8 @@ it will not be detailed here.
 The client is an intermediary program between the game and the Archipelago server. This can either be a direct
 modification to the game, an external program, or both. This can be implemented in nearly any modern language, but it
 must fulfill a few requirements in order to function as expected. Libraries for most modern languages and the spec for 
-various packets can be found in the [network protocol](/docs/network%20protocol.md) API reference document.
+various packets can be found in the [network protocol](/docs/network%20protocol.md) API reference document. Additional help with specific game
+engines and rom formats can be found in the #ap-modding-help channel in the [Discord](https://archipelago.gg/discord).
 
 ### Hard Requirements
 
@@ -139,8 +140,8 @@ if possible.
 
 * An implementation of
   [get_filler_item_name](https://github.com/ArchipelagoMW/Archipelago/blob/main/worlds/AutoWorld.py#L473)
-  * By default, this function chooses any item name from `item_name_to_id`, so you want to limit it to only the true
-    filler items.
+  * By default, this function chooses any item name from `item_name_to_id`, which may include items you consider
+  "non-repeatable".
 * An `options_dataclass` defining the options players have available to them
   * This should be accompanied by a type hint for `options` with the same class name
 * A [bug report page](https://github.com/ArchipelagoMW/Archipelago/blob/main/worlds/AutoWorld.py#L220)

docs/apworld specification.md

@@ -41,16 +41,18 @@ There are also the following optional fields:
 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),
+["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
+### "Build APWorlds" Launcher Component
 
-In the Archipelago Launcher, there is a "Build apworlds" component that will package all world folders to `.apworld`,
+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`.
+`version` and `compatible_version`.  
+The component can also be called from the command line to allow for specifying a certain list of worlds to build.
+For example, running `Launcher.py "Build APWorlds" -- "Game Name"` will build only the game called `Game Name`.
 
 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:
@@ -79,10 +81,26 @@ will be packaged into an `.apworld` with a manifest file inside of it that looks
 
 This is the recommended workflow for packaging your world to an `.apworld`.
 
-## Extra Data
+### .apignore Exclusions
 
-The zip can contain arbitrary files in addition what was specified above.
+By default, any additional files inside of the world folder will be packaged into the resulting `.apworld` archive and
+can then be read by the world. However, if there are any other files that aren't needed in the resulting `.apworld`, you
+can automatically prevent the build component from including them by specifying them in a file called `.apignore` inside
+the root of the world folder.
 
+The `.apignore` file selects files in the same way as the `.gitignore` format with patterns separated by line describing
+which files to ignore. For example, an `.apignore` like this:
+
+```gitignore
+*.iso
+scripts/
+!scripts/needed.py
+```
+
+would ignore any `.iso` files and anything in the scripts folder except for `scripts/needed.py`.
+
+Some exclusions are made by default for all worlds such as `__pycache__` folders. These are listed in the
+`GLOBAL.apignore` file inside of the `data` directory.
 
 ## Caveats
 

docs/apworld_dev_faq.md

@@ -6,6 +6,49 @@ including [Contributing](contributing.md), [Adding Games](<adding games.md>), an
 
 ---
 
+### I've never added a game to Archipelago before. Should I start with the APWorld or the game client?
+
+Strictly speaking, this is a false dichotomy: we do *not* recommend doing 100% of client work before the APWorld,
+or 100% of APWorld work before the client. It's important to iterate on both parts and test them together.
+However, the early iterations tend to be very similar for most games,
+so the typical recommendation for first-time AP developers is:
+
+- Start with a proof-of-concept for [the game client](adding%20games.md#client)
+  - Figure out how to interface with the game. Whether that means "modding" the game, or patching a ROM file,
+    or developing a separate client program that edits the game's memory, or some other technique.
+  - Figure out how to give items and detect locations in the actual game. Not every item and location,
+    just one of each major type (e.g. opening a chest vs completing a sidequest) to prove all the items and locations
+    you want can actually be implemented.
+  - Figure out how to make a websocket connection to an AP server, possibly using a client library (see [Network Protocol](<network%20protocol.md>).
+    To make absolutely sure this part works, you may want to test the connection by generating a multiworld
+    with a different game, then making your client temporarily pretend to be that other game.
+- Next, make a "trivial" APWorld, i.e. an APWorld that always generates the same items and locations
+  - If you've never done this before, likely the fastest approach is to copy-paste [APQuest](<../worlds/apquest>), and read the many
+    comments in there until you understand how to edit the items and locations.
+- Then you can do your first "end-to-end test": generate a multiworld using your APWorld, [run a local server](<running%20from%20source.md>)
+  to host it, connect to that local server from your game client, actually check a location in the game,
+  and finally make sure the client successfully sent that location check to the AP server
+  as well as received an item from it.
+
+That's about where general recommendations end. What you should do next will depend entirely on your game
+(e.g. implement more items, write down logic rules, add client features, prototype a tracker, etc).
+If you're not sure, then this would be a good time to re-read [Adding Games](<adding%20games.md>), and [World API](<world%20api.md>).
+
+There are a few assumptions in this recommendation worth stating explicitly, namely:
+
+- If something you want to do is infeasible, you want to find out that it's infeasible as soon as possible, before
+  you write a bunch of code assuming it could be done. That's why we recommend starting with the game client.
+  - Getting an APWorld to generate whatever items/locations you want is always feasible, since items/locations are
+    little more than id numbers and name strings during generation.
+- You generally want to get to an "end-to-end playable" prototype quickly. On top of all the technical challenges these
+  docs describe, it's also important to check that a randomizer is *fun to play*, and figure out what features would be
+  essential for a public release.
+- A first-time world developer may or may not be deeply familiar with Archipelago, but they're almost certainly familiar
+  with the game they want to randomize. So judging whether your game client is working correctly might be significantly
+  easier than judging if your APWorld is working.
+
+---
+
 ### My game has a restrictive start that leads to fill errors
 
 A "restrictive start" here means having a combination of very few sphere 1 locations and potentially requiring more
@@ -140,3 +183,58 @@ So when the game itself does not follow this assumption, the options are:
   - For connections, any logical regions will still need to be reachable through other, *repeatable* connections
   - For locations, this may require game changes to remove the vanilla item if it affects logic
 - Decide that resetting the save file is part of the game's logic, and warn players about that
+
+---
+
+### What are "local" vs "remote" items, and what are the pros and cons of each?
+
+First off, these terms can be misleading. Since the whole point of a multi-game multiworld randomizer is that some items
+are going to be placed in other slots (unless there's only one slot), the choice isn't really "local vs remote";
+it's "mixed local/remote vs all remote". You have to get "remote items" working to be an AP implementation at all, and
+it's often simpler to handle every item/location the same way, so you generally shouldn't worry about "local items"
+until you've finished more critical features.
+
+Next, "local" and "remote" items confusingly refer to multiple concepts, so it's important to clearly separate them:
+
+- Whether an item happens to get placed in the same slot it originates from, or a different slot. I'll call these
+  "locally placed" and "remotely placed" items.
+- Whether an AP client implements location checking for locally placed items by skipping the usual AP server roundtrip
+  (i.e. sending [LocationChecks](<network%20protocol.md#locationchecks>)
+  then receiving [ReceivedItems](<network%20protocol.md#receiveditems>)
+  ) and directly giving the item to the player, or by doing the AP server roundtrip regardless. I'll call these
+  "locally implemented" items and "remotely implemented" items.
+  - Locally implementing items requires the AP client to know what the locally placed items were without asking an AP
+    server (or else you'd effectively be doing remote items with extra steps). Typically, it gets that information from
+    a patch file, which is one reason why games that already need a patch file are more likely to choose local items.
+  - If items are remotely implemented, the AP client can use [location scouts](<network%20protocol.md#LocationScouts>)
+    to learn what items are placed on what locations. Features that require this information are sometimes mistakenly
+    assumed to require locally implemented items, but location scouts work just as well as patch file data.
+- [The `items_handling` bitflags in the Connect packet](<network%20protocol.md#items_handling-flags>).
+  AP clients with remotely implemented items will typically set all three flags, including "from your own world".
+  Clients with locally implemented items might set only the "from other worlds" flag.
+  - Whether a local items client sets the "starting inventory" flag likely depends on other details. For example, if a ROM
+    is being patched, and starting inventory can be added to that patch, then it makes sense to leave the flag unset.
+
+When people talk about "local vs remote items" as a choice that world devs have to make, they mean deciding whether
+your client will locally or remotely implement the items which happen to be locally placed (or make both
+implementations, or let the player choose an implementation).
+
+Theoretically, the biggest benefit of "local items" is that it allows a solo (single slot) multiworld to be played
+entirely offline, with no AP server, from start to finish. This is similar to a "standalone"/non-AP randomizer,
+except that you still get AP's player options, generation, etc. for free.
+For some games, there are also technical constraints that make certain items easier to implement locally,
+or less glitchy when implemented locally, as long as you're okay with never allowing these items to be placed remotely
+(or offering the player even more options).
+
+The main downside (besides more implementation work) is that "local items" can't support "same slot co-op".
+That's when two players on two different machines connect to the same slot and play together.
+This only works if both players receive all the items for that slot, including ones found by the other player,
+which requires those items to be implemented remotely so the AP server can send them to all of that slot's clients.
+
+So to recap:
+
+- (All) remote items is often the simplest choice, since you have to implement remote items anyway.
+- Remote items enable same slot co-op.
+- Local items enable solo offline play.
+- If you want to support both solo offline play and same slot co-op,
+  you might need to expose local vs remote items as an option to the player.

docs/contributing.md

@@ -20,7 +20,7 @@ game contributions:
   It is recommended that automated github actions are turned on in your fork to have github run unit tests after
   pushing.
   You can turn them on here:  
-  ![Github actions example](./img/github-actions-example.png)
+  ![Github actions example](/docs/img/github-actions-example.png)
 
 * **When reviewing PRs, please leave a message about what was done.**
   We don't have full test coverage, so manual testing can help.

docs/network protocol.md

@@ -225,7 +225,7 @@ Sent to clients after a client requested this message be sent to them, more info
 | games | list\[str\] | Optional. Game names this message is targeting |
 | slots | list\[int\] | Optional. Player slot IDs that this message is targeting |
 | tags | list\[str\] | Optional. Client [Tags](#Tags) this message is targeting |
-| data | dict | The data in the [Bounce](#Bounce) package copied |
+| data | dict | Optional. The data in the [Bounce](#Bounce) package copied |
 
 ### InvalidPacket
 Sent to clients if the server caught a problem with a packet. This only occurs for errors that are explicitly checked for.
@@ -425,7 +425,7 @@ the server will forward the message to all those targets to which any one requir
 | games | list\[str\] | Optional. Game names that should receive this message |
 | slots | list\[int\] | Optional. Player IDs that should receive this message |
 | tags | list\[str\] | Optional. Client tags that should receive this message |
-| data | dict | Any data you want to send |
+| data | dict | Optional. Any data you want to send |
 
 ### Get
 Used to request a single or multiple values from the server's data storage, see the [Set](#Set) package for how to write values to the data storage. A Get package will be answered with a [Retrieved](#Retrieved) package.

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/rule builder.md

@@ -0,0 +1,482 @@
+# Rule Builder
+
+This document describes the API provided for the rule builder. Using this API provides you with with a simple interface to define rules and the following advantages:
+
+- Rule classes that avoid all the common pitfalls
+- Logic optimization
+- Automatic result caching (opt-in)
+- Serialization/deserialization
+- Human-readable logic explanations for players
+
+## Overview
+
+The rule builder consists of 3 main parts:
+
+1. The rules, which are classes that inherit from `rule_builder.rules.Rule`. These are what you write for your logic. They can be combined and take into account your world's options. There are a number of default rules listed below, and you can create as many custom rules for your world as needed. When assigning the rules to a location or entrance they must be resolved.
+1. Resolved rules, which are classes that inherit from `rule_builder.rules.Rule.Resolved`. These are the optimized rules specific to one player that are set as a location or entrance's access rule. You generally shouldn't be directly creating these but they'll be created when assigning rules to locations or entrances. These are what power the human-readable logic explanations.
+1. The optional rule builder world subclass `CachedRuleBuilderWorld`, which is a class your world can inherit from instead of `World`. It adds a caching system to the rules that will lazy evaluate and cache the result.
+
+## Usage
+
+For the most part the only difference in usage is instead of writing lambdas for your logic, you write static Rule objects. You then must use `world.set_rule` to assign the rule to a location or entrance.
+
+```python
+# In your world's create_regions method
+location = MyWorldLocation(...)
+self.set_rule(location, Has("A Big Gun"))
+```
+
+The rule builder comes with a number of rules by default:
+
+- `True_`: Always returns true
+- `False_`: Always returns false
+- `And`: Checks that all child rules are true (also provided by `&` operator)
+- `Or`: Checks that at least one child rule is true (also provided by `|` operator)
+- `Has`: Checks that the player has the given item with the given count (default 1)
+- `HasAll`: Checks that the player has all given items
+- `HasAny`: Checks that the player has at least one of the given items
+- `HasAllCounts`: Checks that the player has all of the counts for the given items
+- `HasAnyCount`: Checks that the player has any of the counts for the given items
+- `HasFromList`: Checks that the player has some number of given items
+- `HasFromListUnique`: Checks that the player has some number of given items, ignoring duplicates of the same item
+- `HasGroup`: Checks that the player has some number of items from a given item group
+- `HasGroupUnique`: Checks that the player has some number of items from a given item group, ignoring duplicates of the same item
+- `CanReachLocation`: Checks that the player can logically reach the given location
+- `CanReachRegion`: Checks that the player can logically reach the given region
+- `CanReachEntrance`: Checks that the player can logically reach the given entrance
+
+You can combine these rules together to describe the logic required for something. For example, to check if a player either has `Movement ability` or they have both `Key 1` and `Key 2`, you can do:
+
+```python
+rule = Has("Movement ability") | HasAll("Key 1", "Key 2")
+```
+
+> ⚠️ Composing rules with the `and` and `or` keywords will not work. You must use the bitwise `&` and `|` operators. In order to catch mistakes, the rule builder will not let you do boolean operations. As a consequence, in order to check if a rule is defined you must use `if rule is not None`.
+
+### Assigning rules
+
+When assigning the rule you must use the `set_rule` helper to correctly resolve and register the rule.
+
+```python
+self.set_rule(location_or_entrance, rule)
+```
+
+There is also a `create_entrance` helper that will resolve the rule, check if it's `False`, and if not create the entrance and set the rule. This allows you to skip creating entrances that will never be valid. You can also specify `force_creation=True` if you would like to create the entrance even if the rule is `False`.
+
+```python
+self.create_entrance(from_region, to_region, rule)
+```
+
+> ⚠️ If you use a `CanReachLocation` rule on an entrance, you will either have to create the locations first, or specify the location's parent region name with the `parent_region_name` argument of `CanReachLocation`.
+
+You can also set a rule for your world's completion condition:
+
+```python
+self.set_completion_rule(rule)
+```
+
+### Restricting options
+
+Every rule allows you to specify which options it's applicable for. You can provide the argument `options` which is an iterable of `OptionFilter` instances. Rules that pass the options check will be resolved as normal, and those that fail will be resolved as `False`.
+
+If you want a comparison that isn't equals, you can specify with the `operator` argument. The following operators are allowed:
+
+- `eq`: `==`
+- `ne`: `!=`
+- `gt`: `>`
+- `lt`: `<`
+- `ge`: `>=`
+- `le`: `<=`
+- `contains`: `in`
+
+By default rules that are excluded by their options will default to `False`. If you want to default to `True` instead, you can specify `filtered_resolution=True` on your rule.
+
+To check if the player can reach a switch, or if they've received the switch item if switches are randomized:
+
+```python
+rule = (
+    Has("Red switch", options=[OptionFilter(SwitchRando, 1)])
+    | CanReachLocation("Red switch", options=[OptionFilter(SwitchRando, 0)])
+)
+```
+
+To add an extra logic requirement on the easiest difficulty which is ignored for other difficulties:
+
+```python
+rule = (
+    # ...the rest of the logic
+    & Has("QoL item", options=[OptionFilter(Difficulty, Difficulty.option_easy)], filtered_resolution=True)
+)
+```
+
+If you would like to provide option filters when reusing or composing rules, you can use the `Filtered` helper rule:
+
+```python
+common_rule = Has("A") | HasAny("B", "C")
+...
+rule = (
+    Filtered(common_rule, options=[OptionFilter(Opt, 0)]),
+    | Filtered(Has("X") | CanReachRegion("Y"), options=[OptionFilter(Opt, 1)]),
+)
+```
+
+You can also use the & and | operators to apply options to rules:
+
+```python
+common_rule = Has("A")
+easy_filter = [OptionFilter(Difficulty, Difficulty.option_easy)]
+common_rule_only_on_easy = common_rule & easy_filter
+common_rule_skipped_on_easy = common_rule | easy_filter
+```
+
+## Enabling caching
+
+The rule builder provides a `CachedRuleBuilderWorld` base class for your `World` class that enables caching on your rules.
+
+```python
+class MyWorld(CachedRuleBuilderWorld):
+    game = "My Game"
+```
+
+If your world's logic is very simple and you don't have many nested rules, the caching system may have more overhead cost than time it saves. You'll have to benchmark your own world to see if it should be enabled or not.
+
+### Item name mapping
+
+If you have multiple real items that map to a single logic item, add a `item_mapping` class dict to your world that maps actual item names to real item names so the cache system knows what to invalidate.
+
+For example, if you have multiple `Currency x<num>` items on locations, but your rules only check a singular logical `Currency` item, eg `Has("Currency", 1000)`, you'll want to map each numerical currency item to the single logical `Currency`.
+
+```python
+class MyWorld(CachedRuleBuilderWorld):
+    item_mapping = {
+        "Currency x10": "Currency",
+        "Currency x50": "Currency",
+        "Currency x100": "Currency",
+        "Currency x500": "Currency",
+    }
+```
+
+## Defining custom rules
+
+You can create a custom rule by creating a class that inherits from `Rule` or any of the default rules. You must provide the game name as an argument to the class. It's recommended to use the `@dataclass` decorator to reduce boilerplate, and to also provide your world as a type argument to add correct type checking to the `_instantiate` method.
+
+You must provide or inherit a `Resolved` child class that defines an `_evaluate` method. This class will automatically be converted into a frozen `dataclass`. If your world has caching enabled you may need to define one or more dependencies functions as outlined below.
+
+To add a rule that checks if the user has enough mcguffins to goal, with a randomized requirement:
+
+```python
+@dataclasses.dataclass()
+class CanGoal(Rule["MyWorld"], game="My Game"):
+    @override
+    def _instantiate(self, world: "MyWorld") -> Rule.Resolved:
+        # caching_enabled only needs to be passed in when your world inherits from CachedRuleBuilderWorld
+        return self.Resolved(world.required_mcguffins, player=world.player, caching_enabled=True)
+
+    class Resolved(Rule.Resolved):
+        goal: int
+
+        @override
+        def _evaluate(self, state: CollectionState) -> bool:
+            return state.has("McGuffin", self.player, count=self.goal)
+
+        @override
+        def item_dependencies(self) -> dict[str, set[int]]:
+            # this function is only required if you have caching enabled
+            return {"McGuffin": {id(self)}}
+
+        @override
+        def explain_json(self, state: CollectionState | None = None) -> list[JSONMessagePart]:
+            # this method can be overridden to display custom explanations
+            return [
+                {"type": "text", "text": "Goal with "},
+                {"type": "color", "color": "green" if state and self(state) else "salmon", "text": str(self.goal)},
+                {"type": "text", "text": " McGuffins"},
+            ]
+```
+
+Your custom rule can also resolve to builtin rules instead of needing to define your own:
+
+```python
+@dataclasses.dataclass()
+class ComplicatedFilter(Rule["MyWorld"], game="My Game"):
+    def _instantiate(self, world: "MyWorld") -> Rule.Resolved:
+        if world.some_precalculated_bool:
+            return Has("Item 1").resolve(world)
+        if world.options.some_option:
+            return CanReachRegion("Region 1").resolve(world)
+        return False_().resolve(world)
+```
+
+### Item dependencies
+
+If your world inherits from `CachedRuleBuilderWorld` and there are items that when collected will affect the result of your rule evaluation, it must define an `item_dependencies` function that returns a mapping of the item name to the id of your rule. These dependencies will be combined to inform the caching system. It may be worthwhile to define this function even when caching is disabled as more things may use it in the future.
+
+```python
+@dataclasses.dataclass()
+class MyRule(Rule["MyWorld"], game="My Game"):
+    class Resolved(Rule.Resolved):
+        item_name: str
+
+        @override
+        def item_dependencies(self) -> dict[str, set[int]]:
+            return {self.item_name: {id(self)}}
+```
+
+All of the default `Has*` rules define this function already.
+
+### Region dependencies
+
+If your custom rule references other regions, it must define a `region_dependencies` function that returns a mapping of region names to the id of your rule regardless of if your world inherits from `CachedRuleBuilderWorld`. These dependencies will be combined to register indirect connections when you set this rule on an entrance and inform the caching system if applicable.
+
+```python
+@dataclasses.dataclass()
+class MyRule(Rule["MyWorld"], game="My Game"):
+    class Resolved(Rule.Resolved):
+        region_name: str
+
+        @override
+        def region_dependencies(self) -> dict[str, set[int]]:
+            return {self.region_name: {id(self)}}
+```
+
+The default `CanReachLocation`, `CanReachRegion`, and `CanReachEntrance` rules define this function already.
+
+### Location dependencies
+
+If your custom rule references other locations, it must define a `location_dependencies` function that returns a mapping of the location name to the id of your rule regardless of if your world inherits from `CachedRuleBuilderWorld`. These dependencies will be combined to register indirect connections when you set this rule on an entrance and inform the caching system if applicable.
+
+```python
+@dataclasses.dataclass()
+class MyRule(Rule["MyWorld"], game="My Game"):
+    class Resolved(Rule.Resolved):
+        location_name: str
+
+        @override
+        def location_dependencies(self) -> dict[str, set[int]]:
+            return {self.location_name: {id(self)}}
+```
+
+The default `CanReachLocation` rule defines this function already.
+
+### Entrance dependencies
+
+If your custom rule references other entrances, it must define a `entrance_dependencies` function that returns a mapping of the entrance name to the id of your rule regardless of if your world inherits from `CachedRuleBuilderWorld`. These dependencies will be combined to register indirect connections when you set this rule on an entrance and inform the caching system if applicable.
+
+```python
+@dataclasses.dataclass()
+class MyRule(Rule["MyWorld"], game="My Game"):
+    class Resolved(Rule.Resolved):
+        entrance_name: str
+
+        @override
+        def entrance_dependencies(self) -> dict[str, set[int]]:
+            return {self.entrance_name: {id(self)}}
+```
+
+The default `CanReachEntrance` rule defines this function already.
+
+### Rule explanations
+
+Resolved rules have a default implementation for `explain_json` and `explain_str` functions. The former optionally accepts a `CollectionState` and returns a list of `JSONMessagePart` appropriate for `print_json` in a client. It will display a human-readable message that explains what the rule requires. The latter is similar but returns a string. It is useful when debugging. There is also a `__str__` method defined to check what a rule is without a state.
+
+To implement a custom message with a custom rule, override the `explain_json` and/or `explain_str` method on your `Resolved` class:
+
+```python
+class MyRule(Rule, game="My Game"):
+    class Resolved(Rule.Resolved):
+        @override
+        def explain_json(self, state: CollectionState | None = None) -> list[JSONMessagePart]:
+            has_item = state and state.has("growth spurt", self.player)
+            color = "yellow"
+            start = "You must be "
+            if has_item:
+                start = "You are "
+                color = "green"
+            elif state is not None:
+                start = "You are not "
+                color = "salmon"
+            return [
+                {"type": "text", "text": start},
+                {"type": "color", "color": color, "text": "THIS"},
+                {"type": "text", "text": " tall to beat the game"},
+            ]
+
+        @override
+        def explain_str(self, state: CollectionState | None = None) -> str:
+            if state is None:
+                return str(self)
+            if state.has("growth spurt", self.player):
+                return "You ARE this tall and can beat the game"
+            return "You are not THIS tall and cannot beat the game"
+
+        @override
+        def __str__(self) -> str:
+            return "You must be THIS tall to beat the game"
+```
+
+### Cache control
+
+By default your custom rule will work through the cache system as any other rule if caching is enabled. There are two class attributes on the `Resolved` class you can override to change this behavior.
+
+- `force_recalculate`: Setting this to `True` will cause your custom rule to skip going through the caching system and always recalculate when being evaluated. When a rule with this flag enabled is composed with `And` or `Or` it will cause any parent rules to always force recalculate as well. Use this flag when it's difficult to determine when your rule should be marked as stale.
+- `skip_cache`: Setting this to `True` will also cause your custom rule to skip going through the caching system when being evaluated. However, it will **not** affect any other rules when composed with `And` or `Or`, so it must still define its `*_dependencies` functions as required. Use this flag when the evaluation of this rule is trivial and the overhead of the caching system will slow it down.
+
+### Caveats
+
+- Ensure you are passing `caching_enabled=True` in your `_instantiate` function when creating resolved rule instances if your world has opted into caching.
+- Resolved rules are forced to be frozen dataclasses. They and all their attributes must be immutable and hashable.
+- If your rule creates child rules ensure they are being resolved through the world rather than creating `Resolved` instances directly.
+
+## Serialization
+
+The rule builder is intended to be written first in Python for optimization and type safety. To facilitate exporting the rules to a client or tracker, rules have a `to_dict` method that returns a JSON-compatible dict. Since the location and entrance logic structure varies greatly from world to world, the actual JSON dumping is left up to the world dev.
+
+The dict contains a `rule` key with the name of the rule, an `options` key with the rule's list of option filters, and an `args` key that contains any other arguments the individual rule has. For example, this is what a simple `Has` rule would look like:
+
+```python
+{
+    "rule": "Has",
+    "options": [],
+    "args": {
+        "item_name": "Some item",
+        "count": 1,
+    },
+}
+```
+
+For `And` and `Or` rules, instead of an `args` key, they have a `children` key containing a list of their child rules in the same serializable format:
+
+```python
+{
+    "rule": "And",
+    "options": [],
+    "children": [
+        ...,  # each serialized rule
+    ]
+}
+```
+
+A full example is as follows:
+
+```python
+rule = And(
+    Has("a", options=[OptionFilter(ToggleOption, 0)]),
+    Or(Has("b", count=2), CanReachRegion("c"), options=[OptionFilter(ToggleOption, 1)]),
+)
+assert rule.to_dict() == {
+    "rule": "And",
+    "options": [],
+    "children": [
+        {
+            "rule": "Has",
+            "options": [
+                {
+                    "option": "worlds.my_world.options.ToggleOption",
+                    "value": 0,
+                    "operator": "eq",
+                },
+            ],
+            "args": {
+                "item_name": "a",
+                "count": 1,
+            },
+        },
+        {
+            "rule": "Or",
+            "options": [
+                {
+                    "option": "worlds.my_world.options.ToggleOption",
+                    "value": 1,
+                    "operator": "eq",
+                },
+            ],
+            "children": [
+                {
+                    "rule": "Has",
+                    "options": [],
+                    "args": {
+                        "item_name": "b",
+                        "count": 2,
+                    },
+                },
+                {
+                    "rule": "CanReachRegion",
+                    "options": [],
+                    "args": {
+                        "region_name": "c",
+                    },
+                },
+            ],
+        },
+    ],
+}
+```
+
+### Custom serialization
+
+To define a different format for your custom rules, override the `to_dict` function:
+
+```python
+class BasicLogicRule(Rule, game="My Game"):
+    items = ("one", "two")
+
+    def to_dict(self) -> dict[str, Any]:
+        # Return whatever format works best for you
+        return {
+            "logic": "basic",
+            "items": self.items,
+        }
+```
+
+If your logic has been done in custom JSON first, you can define a `from_dict` class method on your rules to parse it correctly:
+
+```python
+class BasicLogicRule(Rule, game="My Game"):
+    @classmethod
+    def from_dict(cls, data: Mapping[str, Any], world_cls: type[World]) -> Self:
+        items = data.get("items", ())
+        return cls(*items)
+```
+
+## APIs
+
+This section is provided for reference, refer to the above sections for examples.
+
+### World API
+
+These are properties and helpers that are available to you in your world.
+
+#### Methods
+
+- `rule_from_dict(data)`: Create a rule instance from a deserialized dict representation
+- `register_rule_builder_dependencies()`: Register all rules that depend on location or entrance access with the inherited dependencies, gets called automatically after set_rules
+- `set_rule(spot: Location | Entrance, rule: Rule)`: Resolve a rule, register its dependencies, and set it on the given location or entrance
+- `set_completion_rule(rule: Rule)`: Sets the completion condition for this world
+- `create_entrance(from_region: Region, to_region: Region, rule: Rule | None, name: str | None = None, force_creation: bool = False)`: Attempt to create an entrance from `from_region` to `to_region`, skipping creation if `rule` is defined and evaluates to `False_()` unless force_creation is `True`
+
+#### CachedRuleBuilderWorld Properties
+
+The following property is only available when inheriting from `CachedRuleBuilderWorld`
+
+- `item_mapping: dict[str, str]`: A mapping of actual item name to logical item name
+
+### Rule API
+
+These are properties and helpers that you can use or override for custom rules.
+
+- `_instantiate(world: World)`: Create a new resolved rule instance, override for custom rules as required
+- `to_dict()`: Create a JSON-compatible dict representation of this rule, override if you want to customize your rule's serialization
+- `from_dict(data, world_cls: type[World])`: Return a new rule instance from a deserialized representation, override if you've overridden `to_dict`
+- `__str__()`: Basic string representation of a rule, useful for debugging
+
+#### Resolved rule API
+
+- `player: int`: The slot this rule is resolved for
+- `_evaluate(state: CollectionState)`: Evaluate this rule against the given state, override this to define the logic for this rule
+- `item_dependencies()`: A mapping of item name to set of ids, override this if your custom rule depends on item collection
+- `region_dependencies()`: A mapping of region name to set of ids, override this if your custom rule depends on reaching regions
+- `location_dependencies()`: A mapping of location name to set of ids, override this if your custom rule depends on reaching locations
+- `entrance_dependencies()`: A mapping of entrance name to set of ids, override this if your custom rule depends on reaching entrances
+- `explain_json(state: CollectionState | None = None)`: Return a list of printJSON messages describing this rule's logic (and if state is defined its evaluation) in a human readable way, override to explain custom rules
+- `explain_str(state: CollectionState | None = None)`: Return a string describing this rule's logic (and if state is defined its evaluation) in a human readable way, override to explain custom rules, more useful for debugging
+- `__str__()`: A string describing this rule's logic without its evaluation, override to explain custom rules

docs/running from source.md

@@ -7,10 +7,9 @@ use that version. These steps are for developers or platforms without compiled r
 ## General
 
 What you'll need:
- * [Python 3.11.9 or newer](https://www.python.org/downloads/), not the Windows Store version
+ * [Python 3.11.9 or newer but less than 3.14](https://www.python.org/downloads/), not the Windows Store version
    * On Windows, please consider only using the latest supported version in production environments since security
      updates for older versions are not easily available.
-   * Python 3.13.x is currently the newest supported version
  * pip: included in downloads from python.org, separate in many Linux distributions
  * Matching C compiler
    * possibly optional, read operating system specific sections
@@ -53,6 +52,32 @@ Recommended steps
 Refer to [Guide to Run Archipelago from Source Code on macOS](../worlds/generic/docs/mac_en.md).
 
 
+## Linux
+
+If your Linux distribution ships a compatible Python version (see [General](#general)) and pip, you can use that,
+otherwise you may need to install Python from a 3rd party. Refer to documentation of your Linux distribution.
+
+Installing a C compiler is usually optional. The package is typically named `gcc`, sometimes another package with the
+base build tools may be required, i.e. `build-essential` (Debian/Ubuntu) or `base-devel` (Arch).
+
+After getting the source code, it is strongly recommended to create a
+[venv](https://docs.python.org/3/tutorial/venv.html) (Virtual Environment)
+by hand or using an IDE, such as PyCharm, because Archipelago requires specific versions of Python packages.
+
+Run `python ModuleUpdate.py` in the project root to install packages, run `python Launcher.py` to run the Launcher.
+
+### Building
+
+Builds contain (almost) all dependencies to run Archipelago on any Linux distribution that is as new or newer than the
+one it was built on. Beware that currently only the oldest Ubuntu LTS available in GitHub actions is supported for that.
+This means the easiest way to generate a build is by running the `Build` action from GitHub actions instead of building
+locally. If you still want to, e.g. for local testing, you can by running
+
+`python setup.py build_exe` to generate a binary distribution of Archipelago in `build/`. Or to generate an AppImage
+first generate the binary distribution and then run `python setup.py bdist_appimage` to populate `dist/`. You need to
+put an `appimagetool` into the directory you run the command from, rename it to `appimagetool` and make it executable.
+
+
 ## Optional: A Link to the Past Enemizer
 
 Only required to generate seeds that include A Link to the Past with certain options enabled. You will receive an

docs/style.md

@@ -47,21 +47,27 @@
 
 ## HTML
 
-* Indent with 2 spaces for new code.
+* Indent with 4 spaces for new code.
 * kebab-case for ids and classes.
+* Avoid using on* attributes (onclick, etc.).
 
-## CSS
+## CSS / SCSS
 
-* Indent with 2 spaces for new code.
+* Indent with 4 spaces for new code.
 * `{` on the same line as the selector.
-* No space between selector and `{`.
+* Space between selector and `{`.
 
 ## JS
 
-* Indent with 2 spaces.
-* Indent `case` inside `switch ` with 2 spaces.
-* Use single quotes.
+* Indent with 4 spaces.
+* Indent `case` inside `switch ` with 4 spaces.
+* Prefer double quotation marks (`"`).
 * Semicolons are required after every statement.
+* Use [IIFEs](https://developer.mozilla.org/docs/Glossary/IIFE) to avoid polluting global scope.
+* Prefer to use [defer](https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/script#defer)
+  in script tags, which retains order of execution but does not block.
+* Avoid `<script async ...` in most cases, see [async and defer](https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/script#async_and_defer).
+* Use addEventListener.
 
 ## KV
 

docs/webhost api.md

@@ -4,7 +4,7 @@ Archipelago has a rudimentary API that can be queried by endpoints. The API is a
 
 The following API requests are formatted as: `https://<Archipelago URL>/api/<endpoint>`
 
-The returned data will be formated in a combination of JSON lists or dicts, with their keys or values being notated in `blocks` (if applicable)
+The returned data will be formatted in a combination of JSON lists or dicts, with their keys or values being notated in `blocks` (if applicable)
 
 Current endpoints:
 - Datapackage API
@@ -24,13 +24,21 @@ Current endpoints:
     - [`/get_rooms`](#getrooms)
     - [`/get_seeds`](#getseeds)
 
+## API Data Caching
+To reduce the strain on an Archipelago WebHost, many API endpoints will cache their data and only poll new data in timed intervals. Each endpoint has their own caching time related to the type of data being served. More dynamic data is refreshed more frequently, while static data is cached for longer.  
+Each API endpoint will have their "Cache timer" listed under their definition (if any).
+API calls to these endpoints should not be faster than the listed timer. This will result in wasted processing for your client and (more importantly) the Archipelago WebHost, as the data will not be refreshed by the WebHost until the internal timer has elapsed.
+
 
 ## Datapackage Endpoints
 These endpoints are used by applications to acquire a room's datapackage, and validate that they have the correct datapackage for use. Datapackages normally include, item IDs, location IDs, and name groupings, for a given room, and are essential for mapping IDs received from Archipelago to their correct items or locations.
 
 ### `/datapackage`
 <a name="datapackage"></a>
+
 Fetches the current datapackage from the WebHost.  
+**Cache timer: None**
+
 You'll receive a dict named `games` that contains a named dict of every game and its data currently supported by Archipelago.  
 Each game will have:
 - A checksum `checksum`
@@ -40,7 +48,7 @@ Each game will have:
 - Location name to AP ID dict `location_name_to_id`
 
 Example:
-```
+```json
 {
     "games": {
         ...
@@ -76,7 +84,10 @@ Example:
 
 ### `/datapackage/<string:checksum>`
 <a name="datapackagestringchecksum"></a>
-Fetches a single datapackage by checksum.
+
+Fetches a single datapackage by checksum.  
+**Cache timer: None**
+
 Returns a dict of the game's data with:
 - A checksum `checksum`
 - A dict of item groups `item_name_groups`
@@ -88,10 +99,13 @@ Its format will be identical to the whole-datapackage endpoint (`/datapackage`),
 
 ### `/datapackage_checksum`
 <a name="datapackagechecksum"></a>
-Fetches the checksums of the current static datapackages on the WebHost.
+
+Fetches the checksums of the current static datapackages on the WebHost.  
+**Cache timer: None**
+
 You'll receive a dict with `game:checksum` key-value pairs for all the current officially supported games.  
 Example:
-```
+```json
 {
 ...
 "Donkey Kong Country 3":"f90acedcd958213f483a6a4c238e2a3faf92165e",
@@ -108,6 +122,7 @@ These endpoints are used internally for the WebHost to generate games and valida
 <a name="generate"></a>
 Submits a game to the WebHost for generation.  
 **This endpoint only accepts a POST HTTP request.**  
+**Cache timer: None**
 
 There are two ways to submit data for generation: With a file and with JSON.
 
@@ -116,7 +131,7 @@ Have your ZIP of yaml(s) or a single yaml, and submit a POST request to the `/ge
 If the options are valid, you'll be returned a successful generation response. (see [Generation Response](#generation-response))
 
 Example using the python requests library:
-```
+```python
 file = {'file': open('Games.zip', 'rb')}
 req = requests.post("https://archipelago.gg/api/generate", files=file)
 ```
@@ -127,7 +142,7 @@ Finally, submit a POST request to the `/generate` endpoint.
 If the weighted options are valid, you'll be returned a successful generation response (see [Generation Response](#generation-response))
 
 Example using the python requests library:
-```
+```python
 data = {"Test":{"game": "Factorio","name": "Test","Factorio": {}},}
 weights={"weights": data}
 req = requests.post("https://archipelago.gg/api/generate", json=weights)
@@ -143,7 +158,7 @@ Upon successful generation, you'll be sent a JSON dict response detailing the ge
 - The API status page of the generation `wait_api_url` (see [Status Endpoint](#status))
 
 Example:
-```
+```json
 {
     "detail": "19878f16-5a58-4b76-aab7-d6bf38be9463",
     "encoded": "GYePFlpYS3aqt9a_OL6UYw",
@@ -167,12 +182,14 @@ If the generation detects a issue in generation, you'll be sent a dict with two
 - Detailed issue in `detail`
 
 In the event of an unhandled server exception, you'll be provided a dict with a single key `text`:
-- Exception, `Uncought Exception: <error>` with a 500 status code
+- Exception, `Uncaught Exception: <error>` with a 500 status code
 
 ### `/status/<suuid:seed>`
 <a name="status"></a>
 Retrieves the status of the seed's generation.  
-This endpoint will return a dict with a single key-vlaue pair. The key will always be `text`  
+**Cache timer: None**
+
+This endpoint will return a dict with a single key-value pair. The key will always be `text`  
 The value will tell you the status of the generation:
 - Generation was completed: `Generation done` with a 201 status code
 - Generation request was not found: `Generation not found` with a 404 status code
@@ -184,6 +201,8 @@ Endpoints to fetch information of the active WebHost room with the supplied room
 
 ### `/room_status/<suuid:room_id>`  
 <a name="roomstatus"></a>
+**Cache timer: None**
+
 Will provide a dict of room data with the following keys:
 - Tracker SUUID (`tracker`)
 - A list of players (`players`)
@@ -192,10 +211,10 @@ Will provide a dict of room data with the following keys:
 - Last activity timestamp (`last_activity`)
 - The room timeout counter (`timeout`)
 - A list of downloads for files required for gameplay (`downloads`)
-    - Each item is a dict containings the download URL and slot (`slot`, `download`)
+    - Each item is a dict containing the download URL and slot (`slot`, `download`)
 
 Example:
-```
+```json
 {
     "downloads": [
         {
@@ -244,7 +263,7 @@ Example:
         ]
     ],
     "timeout": 7200,
-    "tracker": "cf6989c0-4703-45d7-a317-2e5158431171"
+    "tracker": "2gVkMQgISGScA8wsvDZg5A"
 }
 ```
 
@@ -254,17 +273,27 @@ can either be viewed while on a room tracker page, or from the [room's endpoint]
 
 ### `/tracker/<suuid:tracker>`
 <a name=tracker></a>
+**Cache timer: 60 seconds**
+
 Will provide a dict of tracker data with the following keys:
 
-- 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`)
+- A list of players current alias data (`aliases`)
+  - Each item containing a dict with, their alias `alias`, their player number `player`, and their team `team`
+  - `alias` will return `null` if there is no alias set
+- A list of items each player has received as a [NetworkItem](network%20protocol.md#networkitem) (`player_items_received`)
+  - Each item containing a dict with, a list of NetworkItems `items`, their player number `player`, their team `team`
 - A list of checks done by each player as a list of the location id's (`player_checks_done`)
-- The total number of checks done by all players (`total_checks_done`)
-- Hints that players have used or received (`hints`)
-- 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`)
+  - Each item containing a dict with, a list of checked location id's `locations`, their player number `player`, and their team `team`
+- A list of the total number of checks done by all players (`total_checks_done`)
+  - Each item will contain a dict with, the total checks done `checks_done`, and the team `team`  
+- A list of [Hints](network%20protocol.md#hint) data that players have used or received (`hints`)
+  - Each item containing a dict containing, a list of hint data `hints`, the player number `player`, and their team `team`
+- A list containing the last activity time for each player, formatted in RFC 1123 format (`activity_timers`)
+  - Each item containing, last activity time `time`, their player number `player`, and their team `team`
+- A list containing the last connection time for each player, formatted in RFC 1123 format (`connection_timers`)
+  - Each item containing, the time of their last connection `time`, their player number `player`, and their team `team`
+- A list of the current [ClientStatus](network%20protocol.md#clientstatus) of each player (`player_status`)
+  - Each item will contain, their status `status`, their player number `player`, and their team `team`
 
 Example:
 ```json
@@ -279,7 +308,12 @@ Example:
       "team": 0,
       "player": 2,
       "alias": "Slot_Name_2"
-    }
+    },
+    {
+      "team": 0,
+      "player": 3,
+      "alias": null
+    },
   ],
   "player_items_received": [
     {
@@ -378,13 +412,21 @@ Example:
 
 ### `/static_tracker/<suuid:tracker>`
 <a name=statictracker></a>
+**Cache timer: 300 seconds**
+
 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`)
+- A list of item_link groups and their member players (`groups`)
+  - Each item containing a dict with, the slot registering the group `slot`, the item_link name `name`, and a list of members `members`
+- A dict of datapackage hashes for each game (`datapackage`)
+  - Each item is a named dict of the game's name.
+    - Each game contains two keys, the datapackage's checksum hash `checksum`, and the version `version`
   - 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`)
+- A list of number of checks found vs. total checks available per player (`player_locations_total`)
+  - Each list item contains a dict with three keys, the total locations for that slot `total_locations`, their player number `player`, and their team `team`
   - 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
@@ -409,10 +451,10 @@ Example:
   ],
   "datapackage": {
     "Archipelago": {
-      "checksum": "ac9141e9ad0318df2fa27da5f20c50a842afeecb",
+      "checksum": "ac9141e9ad0318df2fa27da5f20c50a842afeecb"
     },
     "The Messenger": {
-      "checksum": "6991cbcda7316b65bcb072667f3ee4c4cae71c0b",
+      "checksum": "6991cbcda7316b65bcb072667f3ee4c4cae71c0b"
     }
   },
   "player_locations_total": [
@@ -427,12 +469,29 @@ Example:
       "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.
+Will provide a list of each player's slot_data.  
+**Cache timer: 300 seconds**
+
+Each list item will contain a dict with the player's data:
+- player slot number `player`
+- A named dict `slot_data` containing any set slot data for that player
 
 Example:
 ```json
@@ -460,6 +519,8 @@ User endpoints can get room and seed details from the current session tokens (co
 ### `/get_rooms`  
 <a name="getrooms"></a>
 Retreives a list of all rooms currently owned by the session token.  
+**Cache timer: None**
+
 Each list item will contain a dict with the room's details:
 - Room SUUID (`room_id`)
 - Seed SUUID (`seed_id`)
@@ -470,25 +531,25 @@ Each list item will contain a dict with the room's details:
 - Room tracker SUUID (`tracker`)
 
 Example:
-```
+```json
 [
     {
         "creation_time": "Fri, 18 Apr 2025 19:46:53 GMT",
         "last_activity": "Fri, 18 Apr 2025 21:16:02 GMT",
         "last_port": 52122,
-        "room_id": "90ae5f9b-177c-4df8-ac53-9629fc3bff7a",
-        "seed_id": "efbd62c2-aaeb-4dda-88c3-f461c029cef6",
+        "room_id": "0D30FgQaRcWivFsw9o8qzw",
+        "seed_id": "TFjiarBgTsCj5-Jbe8u33A",
         "timeout": 7200,
-        "tracker": "cf6989c0-4703-45d7-a317-2e5158431171"
+        "tracker": "52BycvJhRe6knrYH8v4bag"
     },
     {
         "creation_time": "Fri, 18 Apr 2025 20:36:42 GMT",
         "last_activity": "Fri, 18 Apr 2025 20:36:46 GMT",
         "last_port": 56884,
-        "room_id": "14465c05-d08e-4d28-96bd-916f994609d8",
-        "seed_id": "a528e34c-3b4f-42a9-9f8f-00a4fd40bacb",
+        "room_id": "LMCFchESSNyuqcY3GxkhwA",
+        "seed_id": "CENtJMXCTGmkIYCzjB5Csg",
         "timeout": 7200,
-        "tracker": "4e624bd8-32b6-42e4-9178-aa407f72751c"
+        "tracker": "2gVkMQgISGScA8wsvDZg5A"
     }
 ]
 ```
@@ -496,6 +557,8 @@ Example:
 ### `/get_seeds`  
 <a name="getseeds"></a>
 Retreives a list of all seeds currently owned by the session token.  
+**Cache timer: None**
+
 Each item in the list will contain a dict with the seed's details:
 - Seed SUUID (`seed_id`)
 - Creation timestamp (`creation_time`)
@@ -503,7 +566,7 @@ Each item in the list will contain a dict with the seed's details:
     - Each item in the list will contain a list of the slot name and game
 
 Example:
-```
+```json
 [
     {
         "creation_time": "Fri, 18 Apr 2025 19:46:52 GMT",
@@ -529,7 +592,7 @@ Example:
                 "Ocarina of Time"
             ]
         ],
-        "seed_id": "efbd62c2-aaeb-4dda-88c3-f461c029cef6"
+        "seed_id": "CENtJMXCTGmkIYCzjB5Csg"
     },
     {
         "creation_time": "Fri, 18 Apr 2025 20:36:39 GMT",
@@ -551,7 +614,7 @@ Example:
                 "Archipelago"
             ]
         ],
-        "seed_id": "a528e34c-3b4f-42a9-9f8f-00a4fd40bacb"
+        "seed_id": "TFjiarBgTsCj5-Jbe8u33A"
     }
 ]
 ```

docs/world api.md

@@ -225,7 +225,10 @@ and has a classification. The name needs to be unique within each game and must
 letter or symbol). The ID needs to be unique across all locations within the game. 
 Locations and items can share IDs, and locations can share IDs with other games' locations.
 
-World-specific IDs must be in the range 1 to 2<sup>53</sup>-1; IDs ≤ 0 are global and reserved.
+World-specific IDs **must** be in the range 1 to 2<sup>53</sup>-1 (the largest integer that is "[safe](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER#description)"
+to store in a 64-bit float, and thus all popular programming languages can handle). IDs ≤ 0 are global and reserved.
+It's **recommended** to keep your IDs in the range 1 to 2<sup>31</sup>-1,
+so only 32-bit integers are needed to hold your IDs.
 
 Classification is one of `LocationProgressType.DEFAULT`, `PRIORITY` or `EXCLUDED`.
 The Fill algorithm will force progression items to be placed at priority locations, giving a higher chance of them being

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

@@ -208,6 +208,11 @@ Root: HKCR; Subkey: "{#MyAppName}apcivvipatch";                     ValueData: "
 Root: HKCR; Subkey: "{#MyAppName}apcivvipatch\DefaultIcon";         ValueData: "{app}\ArchipelagoLauncher.exe,0";                           ValueType: string;  ValueName: "";
 Root: HKCR; Subkey: "{#MyAppName}apcivvipatch\shell\open\command";  ValueData: """{app}\ArchipelagoLauncher.exe"" ""%1""";                  ValueType: string;  ValueName: "";
 
+Root: HKCR; Subkey: ".apeb";                                   ValueData: "{#MyAppName}ebpatch";        Flags: uninsdeletevalue; ValueType: string;  ValueName: "";
+Root: HKCR; Subkey: "{#MyAppName}ebpatch";                     ValueData: "Archipelago EarthBound Patch"; Flags: uninsdeletekey;   ValueType: string;  ValueName: "";
+Root: HKCR; Subkey: "{#MyAppName}ebpatch\DefaultIcon";         ValueData: "{app}\ArchipelagoSNIClient.exe,0";                           ValueType: string;  ValueName: "";
+Root: HKCR; Subkey: "{#MyAppName}ebpatch\shell\open\command";  ValueData: """{app}\ArchipelagoSNIClient.exe"" ""%1""";                  ValueType: string;  ValueName: "";
+
 Root: HKCR; Subkey: ".archipelago";                              ValueData: "{#MyAppName}multidata";        Flags: uninsdeletevalue; ValueType: string;  ValueName: "";
 Root: HKCR; Subkey: "{#MyAppName}multidata";                     ValueData: "Archipelago Server Data";      Flags: uninsdeletekey;   ValueType: string;  ValueName: "";
 Root: HKCR; Subkey: "{#MyAppName}multidata\DefaultIcon";         ValueData: "{app}\ArchipelagoServer.exe,0";                         ValueType: string;  ValueName: "";

kvui.py

@@ -19,6 +19,7 @@ os.environ["KIVY_NO_CONSOLELOG"] = "1"
 os.environ["KIVY_NO_FILELOG"] = "1"
 os.environ["KIVY_NO_ARGS"] = "1"
 os.environ["KIVY_LOG_ENABLE"] = "0"
+os.environ["SDL_MOUSE_FOCUS_CLICKTHROUGH"] = "1"
 
 import Utils
 
@@ -35,6 +36,17 @@ 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.

mypy.ini

@@ -0,0 +1,2 @@
+[mypy]
+mypy_path = typings

requirements.txt

@@ -1,17 +1,21 @@
 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
+pathspec>=0.12.1
 kivymd @ git+https://github.com/kivymd/KivyMD@5ff9d0d
 kivymd>=2.0.1.dev0
+
+# Legacy world dependencies that custom worlds rely on
+Pymem>=1.13.0

rule_builder/cached_world.py

@@ -0,0 +1,146 @@
+from collections import defaultdict
+from typing import ClassVar, cast
+
+from typing_extensions import override
+
+from BaseClasses import CollectionState, Item, MultiWorld, Region
+from worlds.AutoWorld import LogicMixin, World
+
+from .rules import Rule
+
+
+class CachedRuleBuilderWorld(World):
+    """A World subclass that provides helpers for interacting with the rule builder"""
+
+    rule_item_dependencies: dict[str, set[int]]
+    """A mapping of item name to set of rule ids"""
+
+    rule_region_dependencies: dict[str, set[int]]
+    """A mapping of region name to set of rule ids"""
+
+    rule_location_dependencies: dict[str, set[int]]
+    """A mapping of location name to set of rule ids"""
+
+    rule_entrance_dependencies: dict[str, set[int]]
+    """A mapping of entrance name to set of rule ids"""
+
+    item_mapping: ClassVar[dict[str, str]] = {}
+    """A mapping of actual item name to logical item name.
+    Useful when there are multiple versions of a collected item but the logic only uses one. For example:
+    item = Item("Currency x500"), rule = Has("Currency", count=1000), item_mapping = {"Currency x500": "Currency"}"""
+
+    rule_caching_enabled: ClassVar[bool] = True
+    """Flag to inform rules that the caching system for this world is enabled. It should not be overridden."""
+
+    def __init__(self, multiworld: MultiWorld, player: int) -> None:
+        super().__init__(multiworld, player)
+        self.rule_item_dependencies = defaultdict(set)
+        self.rule_region_dependencies = defaultdict(set)
+        self.rule_location_dependencies = defaultdict(set)
+        self.rule_entrance_dependencies = defaultdict(set)
+
+    @override
+    def register_rule_dependencies(self, resolved_rule: Rule.Resolved) -> None:
+        for item_name, rule_ids in resolved_rule.item_dependencies().items():
+            self.rule_item_dependencies[item_name] |= rule_ids
+        for region_name, rule_ids in resolved_rule.region_dependencies().items():
+            self.rule_region_dependencies[region_name] |= rule_ids
+        for location_name, rule_ids in resolved_rule.location_dependencies().items():
+            self.rule_location_dependencies[location_name] |= rule_ids
+        for entrance_name, rule_ids in resolved_rule.entrance_dependencies().items():
+            self.rule_entrance_dependencies[entrance_name] |= rule_ids
+
+    def register_rule_builder_dependencies(self) -> None:
+        """Register all rules that depend on locations or entrances with their dependencies"""
+        for location_name, rule_ids in self.rule_location_dependencies.items():
+            try:
+                location = self.get_location(location_name)
+            except KeyError:
+                continue
+            if not isinstance(location.access_rule, Rule.Resolved):
+                continue
+            for item_name in location.access_rule.item_dependencies():
+                self.rule_item_dependencies[item_name] |= rule_ids
+            for region_name in location.access_rule.region_dependencies():
+                self.rule_region_dependencies[region_name] |= rule_ids
+
+        for entrance_name, rule_ids in self.rule_entrance_dependencies.items():
+            try:
+                entrance = self.get_entrance(entrance_name)
+            except KeyError:
+                continue
+            if not isinstance(entrance.access_rule, Rule.Resolved):
+                continue
+            for item_name in entrance.access_rule.item_dependencies():
+                self.rule_item_dependencies[item_name] |= rule_ids
+            for region_name in entrance.access_rule.region_dependencies():
+                self.rule_region_dependencies[region_name] |= rule_ids
+
+    @override
+    def collect(self, state: CollectionState, item: Item) -> bool:
+        changed = super().collect(state, item)
+        if changed and self.rule_item_dependencies:
+            player_results = cast(dict[int, bool], state.rule_builder_cache[self.player])  # pyright: ignore[reportAttributeAccessIssue, reportUnknownMemberType]
+            mapped_name = self.item_mapping.get(item.name, "")
+            rule_ids = self.rule_item_dependencies[item.name] | self.rule_item_dependencies[mapped_name]
+            for rule_id in rule_ids:
+                if player_results.get(rule_id, None) is False:
+                    del player_results[rule_id]
+
+        return changed
+
+    @override
+    def remove(self, state: CollectionState, item: Item) -> bool:
+        changed = super().remove(state, item)
+        if not changed:
+            return changed
+
+        player_results = cast(dict[int, bool], state.rule_builder_cache[self.player])  # pyright: ignore[reportAttributeAccessIssue, reportUnknownMemberType]
+        if self.rule_item_dependencies:
+            mapped_name = self.item_mapping.get(item.name, "")
+            rule_ids = self.rule_item_dependencies[item.name] | self.rule_item_dependencies[mapped_name]
+            for rule_id in rule_ids:
+                player_results.pop(rule_id, None)
+
+        # clear all region dependent caches as none can be trusted
+        if self.rule_region_dependencies:
+            for rule_ids in self.rule_region_dependencies.values():
+                for rule_id in rule_ids:
+                    player_results.pop(rule_id, None)
+
+        # clear all location dependent caches as they may have lost region access
+        if self.rule_location_dependencies:
+            for rule_ids in self.rule_location_dependencies.values():
+                for rule_id in rule_ids:
+                    player_results.pop(rule_id, None)
+
+        # clear all entrance dependent caches as they may have lost region access
+        if self.rule_entrance_dependencies:
+            for rule_ids in self.rule_entrance_dependencies.values():
+                for rule_id in rule_ids:
+                    player_results.pop(rule_id, None)
+
+        return changed
+
+    @override
+    def reached_region(self, state: CollectionState, region: Region) -> None:
+        super().reached_region(state, region)
+        if self.rule_region_dependencies:
+            player_results = cast(dict[int, bool], state.rule_builder_cache[self.player])  # pyright: ignore[reportAttributeAccessIssue, reportUnknownMemberType]
+            for rule_id in self.rule_region_dependencies[region.name]:
+                player_results.pop(rule_id, None)
+
+
+class CachedRuleBuilderLogicMixin(LogicMixin):
+    multiworld: MultiWorld  # pyright: ignore[reportUninitializedInstanceVariable]
+    rule_builder_cache: dict[int, dict[int, bool]]  # pyright: ignore[reportUninitializedInstanceVariable]
+
+    def init_mixin(self, multiworld: "MultiWorld") -> None:
+        players = multiworld.get_all_ids()
+        self.rule_builder_cache = {player: {} for player in players}
+
+    def copy_mixin(self, new_state: "CachedRuleBuilderLogicMixin") -> "CachedRuleBuilderLogicMixin":
+        new_state.rule_builder_cache = {
+            player: player_results.copy() for player, player_results in self.rule_builder_cache.items()
+        }
+        return new_state

rule_builder/options.py

@@ -0,0 +1,91 @@
+import dataclasses
+import importlib
+import operator
+from collections.abc import Callable, Iterable
+from typing import Any, Final, Literal, Self, cast
+
+from typing_extensions import override
+
+from Options import CommonOptions, Option
+
+Operator = Literal["eq", "ne", "gt", "lt", "ge", "le", "contains", "in"]
+
+OPERATORS: Final[dict[Operator, Callable[..., bool]]] = {
+    "eq": operator.eq,
+    "ne": operator.ne,
+    "gt": operator.gt,
+    "lt": operator.lt,
+    "ge": operator.ge,
+    "le": operator.le,
+    "contains": operator.contains,
+    "in": operator.contains,
+}
+OPERATOR_STRINGS: Final[dict[Operator, str]] = {
+    "eq": "==",
+    "ne": "!=",
+    "gt": ">",
+    "lt": "<",
+    "ge": ">=",
+    "le": "<=",
+}
+REVERSE_OPERATORS: Final[tuple[Operator, ...]] = ("in",)
+
+
+@dataclasses.dataclass(frozen=True)
+class OptionFilter:
+    option: type[Option[Any]]
+    value: Any
+    operator: Operator = "eq"
+
+    def to_dict(self) -> dict[str, Any]:
+        """Returns a JSON compatible dict representation of this option filter"""
+        return {
+            "option": f"{self.option.__module__}.{self.option.__name__}",
+            "value": self.value,
+            "operator": self.operator,
+        }
+
+    def check(self, options: CommonOptions) -> bool:
+        """Tests the given options dataclass to see if it passes this option filter"""
+        option_name = next(
+            (name for name, cls in options.__class__.type_hints.items() if cls is self.option),
+            None,
+        )
+        if option_name is None:
+            raise ValueError(f"Cannot find option {self.option.__name__} in options class {options.__class__.__name__}")
+        opt = cast(Option[Any] | None, getattr(options, option_name, None))
+        if opt is None:
+            raise ValueError(f"Invalid option: {option_name}")
+
+        fn = OPERATORS[self.operator]
+        return fn(self.value, opt) if self.operator in REVERSE_OPERATORS else fn(opt, self.value)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> Self:
+        """Returns a new OptionFilter instance from a dict representation"""
+        if "option" not in data or "value" not in data:
+            raise ValueError("Missing required value and/or option")
+
+        option_path = data["option"]
+        try:
+            option_mod_name, option_cls_name = option_path.rsplit(".", 1)
+            option_module = importlib.import_module(option_mod_name)
+            option = getattr(option_module, option_cls_name, None)
+        except (ValueError, ImportError) as e:
+            raise ValueError(f"Cannot parse option '{option_path}'") from e
+        if option is None or not issubclass(option, Option):
+            raise ValueError(f"Invalid option '{option_path}' returns type '{option}' instead of Option subclass")
+
+        value = data["value"]
+        operator = data.get("operator", "eq")
+        return cls(option=cast(type[Option[Any]], option), value=value, operator=operator)
+
+    @classmethod
+    def multiple_from_dict(cls, data: Iterable[dict[str, Any]]) -> tuple[Self, ...]:
+        """Returns a tuple of OptionFilters instances from an iterable of dict representations"""
+        return tuple(cls.from_dict(o) for o in data)
+
+    @override
+    def __str__(self) -> str:
+        op = OPERATOR_STRINGS.get(self.operator, self.operator)
+        return f"{self.option.__name__} {op} {self.value}"

setup.py

@@ -394,11 +394,11 @@ class BuildExeCommand(cx_Freeze.command.build_exe.build_exe):
                         manifest = json.load(manifest_file)
 
                     assert "game" in manifest, (
-                        f"World directory {world_directory} has an archipelago.json manifest file, but it"
+                        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"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:

test/general/test_helpers.py

@@ -1,9 +1,11 @@
 import unittest
-from typing import Callable, Dict, Optional
+from typing import Any, Dict, Optional
 
 from typing_extensions import override
 
-from BaseClasses import CollectionState, MultiWorld, Region
+from BaseClasses import CollectionRule, MultiWorld, Region
+from rule_builder.rules import Has, Rule
+from test.general import TestWorld
 
 
 class TestHelpers(unittest.TestCase):
@@ -16,6 +18,7 @@ class TestHelpers(unittest.TestCase):
         self.multiworld.game[self.player] = "helper_test_game"
         self.multiworld.player_name = {1: "Tester"}
         self.multiworld.set_seed()
+        self.multiworld.worlds[self.player] = TestWorld(self.multiworld, self.player)
 
     def test_region_helpers(self) -> None:
         """Tests `Region.add_locations()` and `Region.add_exits()` have correct behavior"""
@@ -46,8 +49,9 @@ class TestHelpers(unittest.TestCase):
             "TestRegion1": {"TestRegion3"}
         }
 
-        exit_rules: Dict[str, Callable[[CollectionState], bool]] = {
-            "TestRegion1": lambda state: state.has("test_item", self.player)
+        exit_rules: Dict[str, CollectionRule | Rule[Any]] = {
+            "TestRegion1": lambda state: state.has("test_item", self.player),
+            "TestRegion2": Has("test_item2"),
         }
 
         self.multiworld.regions += [Region(region, self.player, self.multiworld, regions[region]) for region in regions]
@@ -74,13 +78,17 @@ class TestHelpers(unittest.TestCase):
                         self.assertTrue(f"{parent} -> {exit_reg}" in created_exit_names)
                     if exit_reg in exit_rules:
                         entrance_name = exit_name if exit_name else f"{parent} -> {exit_reg}"
-                        self.assertEqual(exit_rules[exit_reg],
-                                         self.multiworld.get_entrance(entrance_name, self.player).access_rule)
+                        rule = exit_rules[exit_reg]
+                        if isinstance(rule, Rule):
+                            self.assertEqual(rule.resolve(self.multiworld.worlds[self.player]),
+                                             self.multiworld.get_entrance(entrance_name, self.player).access_rule)
+                        else:
+                            self.assertEqual(rule, self.multiworld.get_entrance(entrance_name, self.player).access_rule)
 
-            for region in reg_exit_set:
+            for region, exit_set in reg_exit_set.items():
                 current_region = self.multiworld.get_region(region, self.player)
-                current_region.add_exits(reg_exit_set[region])
+                current_region.add_exits(exit_set)
                 exit_names = {_exit.name for _exit in current_region.exits}
-                for reg_exit in reg_exit_set[region]:
+                for reg_exit in exit_set:
                     self.assertTrue(f"{region} -> {reg_exit}" in exit_names,
                                     f"{region} -> {reg_exit} not in {exit_names}")

test/general/test_items.py

@@ -1,5 +1,6 @@
 import unittest
 from argparse import Namespace
+from collections import ChainMap
 from typing import Type
 
 from BaseClasses import CollectionState, MultiWorld
@@ -82,12 +83,13 @@ class TestBase(unittest.TestCase):
 
     def test_items_in_datapackage(self):
         """Test that any created items in the itempool are in the datapackage"""
+        archipelago = AutoWorldRegister.world_types["Archipelago"]
         for game_name, world_type in AutoWorldRegister.world_types.items():
             with self.subTest("Game", game=game_name):
                 multiworld = setup_solo_multiworld(world_type)
                 for item in multiworld.itempool:
-                    self.assertIn(item.name, world_type.item_name_to_id)
-    
+                    self.assertIn(item.name, ChainMap(world_type.item_name_to_id, archipelago.item_name_to_id))
+
     def test_item_links(self) -> None:
         """
         Tests item link creation by creating a multiworld of 2 worlds for every game and linking their items together.

test/general/test_options.py

@@ -1,8 +1,9 @@
 import unittest
 
 from BaseClasses import PlandoOptions
-from Options import Choice, ItemLinks, PlandoConnections, PlandoItems, PlandoTexts
+from Options import Choice, ItemLinks, OptionSet, PlandoConnections, PlandoItems, PlandoTexts
 from Utils import restricted_dumps
+
 from worlds.AutoWorld import AutoWorldRegister
 
 
@@ -81,6 +82,19 @@ 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_option_set_keys_random(self):
+        """Tests that option sets do not contain 'random' and its variants as valid keys"""
+        for game_name, world_type in AutoWorldRegister.world_types.items():
+            if game_name not in ("Archipelago", "Sudoku", "Super Metroid"):
+                for option_key, option in world_type.options_dataclass.type_hints.items():
+                    if issubclass(option, OptionSet):
+                        with self.subTest(game=game_name, option=option_key):
+                            self.assertFalse(any(random_key in option.valid_keys for random_key in ("random",
+                                                                                                    "random-high",
+                                                                                                    "random-low")))
+                            for key in option.valid_keys:
+                                self.assertFalse("random-range" in key)
     
     def test_pickle_dumps_plando(self):
         """Test that plando options using containers of a custom type can be pickled"""

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/hosting/__main__.py

@@ -70,13 +70,13 @@ if __name__ == "__main__":
         empty_file = str(Path(tempdir) / "empty")
         open(empty_file, "w").close()
         sys.argv += ["--config_override", empty_file]  # tests #5541
-        multis = [["VVVVVV"], ["Temp World"], ["VVVVVV", "Temp World"]]
+        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)} offline")

test/hosting/world.py

@@ -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/options/test_generate_templates.py

@@ -25,31 +25,41 @@ class TestGenerateYamlTemplates(unittest.TestCase):
         if "World: with colon" in worlds.AutoWorld.AutoWorldRegister.world_types:
             del worlds.AutoWorld.AutoWorldRegister.world_types["World: with colon"]
 
+
     def test_name_with_colon(self) -> None:
         from Options import generate_yaml_templates
         from worlds.AutoWorld import AutoWorldRegister
-        from worlds.AutoWorld import World
+        from worlds.AutoWorld import World, WebWorld
+
+        class WebWorldWithColon(WebWorld):
+            options_presets = {
+                "Generic": {
+                    "progression_balancing": "disabled",
+                    "accessibility": "minimal",
+                }
+            }
 
         class WorldWithColon(World):
             game = "World: with colon"
             item_name_to_id = {}
             location_name_to_id = {}
+            web = WebWorldWithColon()
 
         AutoWorldRegister.world_types = {WorldWithColon.game: WorldWithColon}
         with TemporaryDirectory(f"archipelago_{__name__}") as temp_dir:
             generate_yaml_templates(temp_dir)
             path: Path
-            for path in Path(temp_dir).iterdir():
-                self.assertTrue(path.is_file())
-                self.assertTrue(path.suffix == ".yaml")
-                with path.open(encoding="utf-8") as f:
-                    try:
-                        data = parse_yaml(f)
-                    except:
-                        f.seek(0)
-                        print(f"Error in {path.name}:\n{f.read()}")
-                        raise
-                    self.assertIn("game", data)
-                    self.assertIn(":", data["game"])
-                    self.assertIn(data["game"], data)
-                    self.assertIsInstance(data[data["game"]], dict)
+            for path in Path(temp_dir).rglob("*"):
+                if path.is_file():
+                    self.assertTrue(path.suffix == ".yaml")
+                    with path.open(encoding="utf-8") as f:
+                        try:
+                            data = parse_yaml(f)
+                        except:
+                            f.seek(0)
+                            print(f"Error in {path.name}:\n{f.read()}")
+                            raise
+                        self.assertIn("game", data)
+                        self.assertIn(":", data["game"])
+                        self.assertIn(data["game"], data)
+                        self.assertIsInstance(data[data["game"]], dict)

test/webhost/test_host_room.py

@@ -1,11 +1,22 @@
+import logging
 import os
 from uuid import UUID, uuid4, uuid5
 
 from flask import url_for
 
+from WebHostLib.customserver import set_up_logging, tear_down_logging
 from . import TestBase
 
 
+def _cleanup_logger(room_id: UUID) -> None:
+    from Utils import user_path
+    tear_down_logging(room_id)
+    try:
+        os.unlink(user_path("logs", f"{room_id}.txt"))
+    except OSError:
+        pass
+
+
 class TestHostFakeRoom(TestBase):
     room_id: UUID
     log_filename: str
@@ -39,7 +50,7 @@ class TestHostFakeRoom(TestBase):
 
         try:
             os.unlink(self.log_filename)
-        except FileNotFoundError:
+        except OSError:
             pass
 
     def test_display_log_missing_full(self) -> None:
@@ -191,3 +202,27 @@ class TestHostFakeRoom(TestBase):
         with db_session:
             commands = select(command for command in Command if command.room.id == self.room_id)  # type: ignore
             self.assertNotIn("/help", (command.commandtext for command in commands))
+
+    def test_logger_teardown(self) -> None:
+        """Verify that room loggers are removed from the global logging manager."""
+        from WebHostLib.customserver import tear_down_logging
+        room_id = uuid4()
+        self.addCleanup(_cleanup_logger, room_id)
+        set_up_logging(room_id)
+        self.assertIn(f"RoomLogger {room_id}", logging.Logger.manager.loggerDict)
+        tear_down_logging(room_id)
+        self.assertNotIn(f"RoomLogger {room_id}", logging.Logger.manager.loggerDict)
+
+    def test_handler_teardown(self) -> None:
+        """Verify that handlers for room loggers are closed by tear_down_logging."""
+        from WebHostLib.customserver import tear_down_logging
+        room_id = uuid4()
+        self.addCleanup(_cleanup_logger, room_id)
+        logger = set_up_logging(room_id)
+        handlers = logger.handlers[:]
+        self.assertGreater(len(handlers), 0)
+
+        tear_down_logging(room_id)
+        for handler in handlers:
+            if isinstance(handler, logging.FileHandler):
+                self.assertTrue(handler.stream is None or handler.stream.closed)

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}' "

typings/kivy/clock.pyi

@@ -0,0 +1,82 @@
+from _typeshed import Incomplete
+from kivy._clock import (
+    ClockEvent as ClockEvent,
+    ClockNotRunningError as ClockNotRunningError,
+    CyClockBase as CyClockBase,
+    CyClockBaseFree as CyClockBaseFree,
+    FreeClockEvent as FreeClockEvent,
+)
+
+__all__ = [
+    "Clock",
+    "ClockNotRunningError",
+    "ClockEvent",
+    "FreeClockEvent",
+    "CyClockBase",
+    "CyClockBaseFree",
+    "triggered",
+    "ClockBaseBehavior",
+    "ClockBaseInterruptBehavior",
+    "ClockBaseInterruptFreeBehavior",
+    "ClockBase",
+    "ClockBaseInterrupt",
+    "ClockBaseFreeInterruptAll",
+    "ClockBaseFreeInterruptOnly",
+    "mainthread",
+]
+
+class ClockBaseBehavior:
+    MIN_SLEEP: float
+    SLEEP_UNDERSHOOT: Incomplete
+    def __init__(self, async_lib: str = "asyncio", **kwargs) -> None: ...
+    def init_async_lib(self, lib) -> None: ...
+    @property
+    def frametime(self): ...
+    @property
+    def frames(self): ...
+    @property
+    def frames_displayed(self): ...
+    def usleep(self, microseconds) -> None: ...
+    def idle(self): ...
+    async def async_idle(self): ...
+    def tick(self) -> None: ...
+    async def async_tick(self) -> None: ...
+    def pre_idle(self) -> None: ...
+    def post_idle(self, ts, current): ...
+    def tick_draw(self) -> None: ...
+    def get_fps(self): ...
+    def get_rfps(self): ...
+    def get_time(self): ...
+    def get_boottime(self): ...
+    time: Incomplete
+    def handle_exception(self, e) -> None: ...
+
+class ClockBaseInterruptBehavior(ClockBaseBehavior):
+    interupt_next_only: bool
+    def __init__(self, interupt_next_only: bool = False, **kwargs) -> None: ...
+    def init_async_lib(self, lib) -> None: ...
+    def usleep(self, microseconds) -> None: ...
+    async def async_usleep(self, microseconds) -> None: ...
+    def on_schedule(self, event) -> None: ...
+    def idle(self): ...
+    async def async_idle(self): ...
+
+class ClockBaseInterruptFreeBehavior(ClockBaseInterruptBehavior):
+    def __init__(self, **kwargs) -> None: ...
+    def on_schedule(self, event): ...
+
+class ClockBase(ClockBaseBehavior, CyClockBase):
+    def __init__(self, **kwargs) -> None: ...
+    def usleep(self, microseconds) -> None: ...
+
+class ClockBaseInterrupt(ClockBaseInterruptBehavior, CyClockBase): ...
+class ClockBaseFreeInterruptAll(ClockBaseInterruptFreeBehavior, CyClockBaseFree): ...
+
+class ClockBaseFreeInterruptOnly(ClockBaseInterruptFreeBehavior, CyClockBaseFree):
+    def idle(self): ...
+    async def async_idle(self): ...
+
+def mainthread(func): ...
+def triggered(timeout: int = 0, interval: bool = False): ...
+
+Clock: ClockBase

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

@@ -5,17 +5,18 @@ import logging
 import pathlib
 import sys
 import time
+from collections.abc import Callable, Iterable, Mapping
 from random import Random
-from dataclasses import make_dataclass
-from typing import (Any, Callable, ClassVar, Dict, FrozenSet, Iterable, List, Mapping, Optional, Set, TextIO, Tuple,
+from typing import (Any, ClassVar, Dict, FrozenSet, List, Optional, Self, Set, TextIO, Tuple,
                     TYPE_CHECKING, Type, Union)
 
 from Options import item_and_loc_options, ItemsAccessibility, OptionGroup, PerGameCommonOptions
-from BaseClasses import CollectionState
+from BaseClasses import CollectionState, Entrance
+from rule_builder.rules import CustomRuleRegister, Rule
 from Utils import Version
 
 if TYPE_CHECKING:
-    from BaseClasses import MultiWorld, Item, Location, Tutorial, Region, Entrance
+    from BaseClasses import CollectionRule, Item, Location, MultiWorld, Region, Tutorial
     from NetUtils import GamesPackage, MultiData
     from settings import Group
 
@@ -47,27 +48,31 @@ class AutoWorldRegister(type):
     def __new__(mcs, name: str, bases: Tuple[type, ...], dct: Dict[str, Any]) -> AutoWorldRegister:
         if "web" in dct:
             assert isinstance(dct["web"], WebWorld), "WebWorld has to be instantiated."
-        # filter out any events
-        dct["item_name_to_id"] = {name: id for name, id in dct["item_name_to_id"].items() if id}
-        dct["location_name_to_id"] = {name: id for name, id in dct["location_name_to_id"].items() if id}
-        # build reverse lookups
-        dct["item_id_to_name"] = {code: name for name, code in dct["item_name_to_id"].items()}
-        dct["location_id_to_name"] = {code: name for name, code in dct["location_name_to_id"].items()}
 
-        # build rest
-        dct["item_names"] = frozenset(dct["item_name_to_id"])
-        dct["item_name_groups"] = {group_name: frozenset(group_set) for group_name, group_set
-                                   in dct.get("item_name_groups", {}).items()}
-        dct["item_name_groups"]["Everything"] = dct["item_names"]
-
-        dct["location_names"] = frozenset(dct["location_name_to_id"])
-        dct["location_name_groups"] = {group_name: frozenset(group_set) for group_name, group_set
-                                       in dct.get("location_name_groups", {}).items()}
-        dct["location_name_groups"]["Everywhere"] = dct["location_names"]
-        dct["all_item_and_group_names"] = frozenset(dct["item_names"] | set(dct.get("item_name_groups", {})))
-
-        # move away from get_required_client_version function
         if "game" in dct:
+            assert "item_name_to_id" in dct, f"{name}: item_name_to_id is required"
+            assert "location_name_to_id" in dct, f"{name}: location_name_to_id is required"
+
+            # filter out any events
+            dct["item_name_to_id"] = {name: id for name, id in dct["item_name_to_id"].items() if id}
+            dct["location_name_to_id"] = {name: id for name, id in dct["location_name_to_id"].items() if id}
+            # build reverse lookups
+            dct["item_id_to_name"] = {code: name for name, code in dct["item_name_to_id"].items()}
+            dct["location_id_to_name"] = {code: name for name, code in dct["location_name_to_id"].items()}
+
+            # build rest
+            dct["item_names"] = frozenset(dct["item_name_to_id"])
+            dct["item_name_groups"] = {group_name: frozenset(group_set) for group_name, group_set
+                                    in dct.get("item_name_groups", {}).items()}
+            dct["item_name_groups"]["Everything"] = dct["item_names"]
+
+            dct["location_names"] = frozenset(dct["location_name_to_id"])
+            dct["location_name_groups"] = {group_name: frozenset(group_set) for group_name, group_set
+                                        in dct.get("location_name_groups", {}).items()}
+            dct["location_name_groups"]["Everywhere"] = dct["location_names"]
+            dct["all_item_and_group_names"] = frozenset(dct["item_names"] | set(dct.get("item_name_groups", {})))
+
+            # move away from get_required_client_version function
             assert "get_required_client_version" not in dct, f"{name}: required_client_version is an attribute now"
         # set minimum required_client_version from bases
         if "required_client_version" in dct and bases:
@@ -173,7 +178,8 @@ def _timed_call(method: Callable[..., Any], *args: Any,
 
 
 def call_single(multiworld: "MultiWorld", method_name: str, player: int, *args: Any) -> Any:
-    method = getattr(multiworld.worlds[player], method_name)
+    world = multiworld.worlds[player]
+    method = getattr(world, method_name)
     try:
         ret = _timed_call(method, *args, multiworld=multiworld, player=player)
     except Exception as e:
@@ -184,6 +190,10 @@ def call_single(multiworld: "MultiWorld", method_name: str, player: int, *args:
             logging.error(message)
         raise e
     else:
+        # Convenience for CachedRuleBuilderWorld users: Ensure that caching setup function is called
+        # Can be removed once dependency system is improved
+        if method_name == "set_rules" and hasattr(world, "register_rule_builder_dependencies"):
+            call_single(multiworld, "register_rule_builder_dependencies", player)
         return ret
 
 
@@ -484,7 +494,14 @@ class World(metaclass=AutoWorldRegister):
         raise NotImplementedError
 
     def get_filler_item_name(self) -> str:
-        """Called when the item pool needs to be filled with additional items to match location count."""
+        """
+        Called when the item pool needs to be filled with additional items to match location count.
+
+        Any returned item name must be for a "repeatable" item, i.e. one that it's okay to generate arbitrarily many of.
+        For most worlds this will be one or more of your filler items, but the classification of these items
+        does not need to be ItemClassification.filler.
+        The item name returned can be for a trap, useful, and/or progression item as long as it's repeatable.
+        """
         logging.warning(f"World {self} is generating a filler item without custom filler pool.")
         return self.random.choice(tuple(self.item_name_to_id.keys()))
 
@@ -538,6 +555,10 @@ class World(metaclass=AutoWorldRegister):
             return True
         return False
 
+    def reached_region(self, state: "CollectionState", region: "Region") -> None:
+        """Called when a region is newly reachable by the state."""
+        pass
+
     # following methods should not need to be overridden.
     def create_filler(self) -> "Item":
         return self.create_item(self.get_filler_item_name())
@@ -586,6 +607,64 @@ class World(metaclass=AutoWorldRegister):
         res["checksum"] = data_package_checksum(res)
         return res
 
+    @classmethod
+    def get_rule_cls(cls, name: str) -> type[Rule[Self]]:
+        """Returns the world-registered or default rule with the given name"""
+        return CustomRuleRegister.get_rule_cls(cls.game, name)
+
+    @classmethod
+    def rule_from_dict(cls, data: Mapping[str, Any]) -> Rule[Self]:
+        """Create a rule instance from a serialized dict representation"""
+        name = data.get("rule", "")
+        rule_class = cls.get_rule_cls(name)
+        return rule_class.from_dict(data, cls)
+
+    def set_rule(self, spot: Location | Entrance, rule: CollectionRule | Rule[Any]) -> None:
+        """Sets an access rule for a location or entrance"""
+        if isinstance(rule, Rule):
+            rule = rule.resolve(self)
+            self.register_rule_dependencies(rule)
+            if isinstance(spot, Entrance):
+                self._register_rule_indirects(rule, spot)
+        spot.access_rule = rule
+
+    def set_completion_rule(self, rule: CollectionRule | Rule[Any]) -> None:
+        """Set the completion rule for this world"""
+        if isinstance(rule, Rule):
+            rule = rule.resolve(self)
+            self.register_rule_dependencies(rule)
+        self.multiworld.completion_condition[self.player] = rule
+
+    def create_entrance(
+        self,
+        from_region: Region,
+        to_region: Region,
+        rule: CollectionRule | Rule[Any] | None = None,
+        name: str | None = None,
+        force_creation: bool = False,
+    ) -> Entrance | None:
+        """Try to create an entrance between regions with the given rule,
+        skipping it if the rule resolves to False (unless force_creation is True)"""
+        if rule is not None and isinstance(rule, Rule):
+            rule = rule.resolve(self)
+            if rule.always_false and not force_creation:
+                return None
+            self.register_rule_dependencies(rule)
+
+        entrance = from_region.connect(to_region, name, rule=rule)
+        if rule and isinstance(rule, Rule.Resolved):
+            self._register_rule_indirects(rule, entrance)
+        return entrance
+
+    def register_rule_dependencies(self, resolved_rule: Rule.Resolved) -> None:
+        """Hook for registering dependencies when a rule is assigned for this world"""
+        pass
+
+    def _register_rule_indirects(self, resolved_rule: Rule.Resolved, entrance: Entrance) -> None:
+        if self.explicit_indirect_conditions:
+            for indirect_region in resolved_rule.region_dependencies().keys():
+                self.multiworld.register_indirect_condition(self.get_region(indirect_region), entrance)
+
 
 # any methods attached to this can be used as part of CollectionState,
 # please use a prefix as all of them get clobbered together

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, is_frozen, is_kivy_running, open_file, user_path
+from Utils import local_path, open_filename, is_frozen, is_kivy_running, open_file, user_path, read_apignore
 
 
 class Type(Enum):
@@ -247,7 +247,8 @@ components: List[Component] = [
     # MegaMan Battle Network 3
     Component('MMBN3 Client', 'MMBN3Client', file_identifier=SuffixIdentifier('.apbn3')),
 
-    Component("Export Datapackage", func=export_datapackage, component_type=Type.TOOL),
+    Component("Export Datapackage", func=export_datapackage, component_type=Type.TOOL,
+              description="Write item/location data for installed worlds to a file and open it."),
 ]
 
 
@@ -278,6 +279,10 @@ if not is_frozen():
             games = [(worldname, worldtype) for worldname, worldtype in AutoWorldRegister.world_types.items()
                      if not worldtype.zip_path]
 
+        global_apignores = read_apignore(local_path("data", "GLOBAL.apignore"))
+        if not global_apignores:
+            raise RuntimeError("Could not read global apignore file for build component")
+
         apworlds_folder = os.path.join("build", "apworlds")
         os.makedirs(apworlds_folder, exist_ok=True)
         for worldname, worldtype in games:
@@ -291,11 +296,11 @@ if not is_frozen():
                     manifest = json.load(manifest_file)
 
                 assert "game" in manifest, (
-                    f"World directory {world_directory} has an archipelago.json manifest file, but it"
+                    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"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:
@@ -305,18 +310,17 @@ if not is_frozen():
             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)
+            apworld.manifest_path = os.path.join(file_name, "archipelago.json")
+
+            local_ignores = read_apignore(pathlib.Path(world_directory, ".apignore"))
+            apignores = global_apignores + local_ignores if local_ignores else global_apignores
+
+            with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED, compresslevel=9) as zf:
+                for file in apignores.match_tree_files(world_directory, negate=True):
+                    zf.write(pathlib.Path(world_directory, file), pathlib.Path(file_name, file))
+
                 zf.writestr(apworld.manifest_path, json.dumps(manifest))
         open_folder(apworlds_folder)
 
-
-    components.append(Component('Build APWorlds', func=_build_apworlds, cli=True,
+    components.append(Component("Build APWorlds", func=_build_apworlds, cli=True,
                                 description="Build APWorlds from loose-file world folders."))

worlds/__init__.py

@@ -1,17 +1,20 @@
 import importlib
-import importlib.util
+import importlib.abc
+import importlib.machinery
 import logging
 import os
 import sys
-import warnings
 import zipimport
 import time
 import dataclasses
 import json
-from typing import List
+from pathlib import Path
+from types import ModuleType
+from typing import List, Sequence
+from zipfile import BadZipFile
 
 from NetUtils import DataPackage
-from Utils import local_path, user_path, Version, version_tuple, tuplize_version
+from Utils import local_path, user_path, Version, version_tuple, tuplize_version, messagebox
 
 local_folder = os.path.dirname(__file__)
 user_folder = user_path("worlds") if user_path() != local_path() else user_path("custom_worlds")
@@ -20,14 +23,14 @@ try:
 except OSError:  # can't access/write?
     user_folder = None
 
-__all__ = {
+__all__ = [
     "network_data_package",
     "AutoWorldRegister",
     "world_sources",
     "local_folder",
     "user_folder",
     "failed_world_loads",
-}
+]
 
 
 failed_world_loads: List[str] = []
@@ -53,21 +56,7 @@ class WorldSource:
     def load(self) -> bool:
         try:
             start = time.perf_counter()
-            if self.is_zip:
-                importer = zipimport.zipimporter(self.resolved_path)
-                spec = importer.find_spec(os.path.basename(self.path).rsplit(".", 1)[0])
-                assert spec, f"{self.path} is not a loadable module"
-                mod = importlib.util.module_from_spec(spec)
-
-                mod.__package__ = f"worlds.{mod.__package__}"
-
-                mod.__name__ = f"worlds.{mod.__name__}"
-                sys.modules[mod.__name__] = mod
-                with warnings.catch_warnings():
-                    warnings.filterwarnings("ignore", message="__package__ != __spec__.parent")
-                    importer.exec_module(mod)
-            else:
-                importlib.import_module(f".{self.path}", "worlds")
+            importlib.import_module(f".{Path(self.path).stem}", "worlds")
             self.time_taken = time.perf_counter()-start
             return True
 
@@ -112,7 +101,6 @@ for world_source in world_sources:
     else:
         world_source.load()
 
-
 from .AutoWorld import AutoWorldRegister
 
 for world_source in world_sources:
@@ -157,6 +145,15 @@ if apworlds:
                     logging.error(e)
                 else:
                     raise e
+            except BadZipFile as e:
+                err_message = (f"The world source {apworld_source.resolved_path} is not a valid zip. "
+                               "It is likely either corrupted, or was packaged incorrectly.")
+
+                if sys.stdout:
+                    raise RuntimeError(err_message) from e
+                else:
+                    messagebox("Couldn't load worlds", err_message, error=True)
+                    sys.exit(1)
 
             if apworld.minimum_ap_version and apworld.minimum_ap_version > version_tuple:
                 fail_world(apworld.game,
@@ -174,6 +171,16 @@ if apworlds:
         core_compatible.sort(
             key=lambda element: element[1].world_version if element[1].world_version else Version(0, 0, 0),
             reverse=True)
+
+        apworld_module_specs = {}
+        class APWorldModuleFinder(importlib.abc.MetaPathFinder):
+            def find_spec(
+                    self, fullname: str, _path: Sequence[str] | None, _target: ModuleType = None
+            ) -> importlib.machinery.ModuleSpec | None:
+                return apworld_module_specs.get(fullname)
+
+        sys.meta_path.insert(0, APWorldModuleFinder())
+
         for apworld_source, apworld in core_compatible:
             if apworld.game and apworld.game in AutoWorldRegister.world_types:
                 fail_world(apworld.game,
@@ -181,6 +188,12 @@ if apworlds:
                            f"as its game {apworld.game} is already loaded.",
                            add_as_failed_to_load=False)
             else:
+                importer = zipimport.zipimporter(apworld_source.resolved_path)
+                world_name = Path(apworld.path).stem
+
+                spec = importer.find_spec(f"worlds.{world_name}")
+                apworld_module_specs[f"worlds.{world_name}"] = spec
+
                 apworld_source.load()
                 if apworld.game in AutoWorldRegister.world_types:
                     # world could fail to load at this point

worlds/_sc2common/requirements.txt

@@ -2,4 +2,4 @@ mpyq>=0.2.5
 portpicker>=1.5.2
 aiohttp>=3.8.4
 loguru>=0.7.0
-protobuf==6.31.1
+protobuf==6.33.5

worlds/ahit/Locations.py

@@ -63,6 +63,9 @@ def is_location_valid(world: "HatInTimeWorld", location: str) -> bool:
     if not world.options.ShuffleStorybookPages and location in storybook_pages.keys():
         return False
 
+    if not world.options.ShuffleDirectorTokens and location in director_tokens.keys():
+        return False
+
     if not world.options.ShuffleActContracts and location in contract_locations.keys():
         return False
 
@@ -566,6 +569,34 @@ storybook_pages = {
     "Rumbi Factory - Page: Last Area": LocData(2000345883, "Time Rift - Rumbi Factory", dlc_flags=HatDLC.dlc2),
 }
 
+director_tokens = {
+    "Murder on the Owl Express - Conductor Token: Cafeteria": LocData(2001104767, "Murder on the Owl Express"),
+    "Murder on the Owl Express - Conductor Token: Recreational Room": LocData(2001104768, "Murder on the Owl Express"),
+    "Picture Perfect - DJ Grooves Token: Cardboard Puppy": LocData(2001203990, "Picture Perfect"),
+    "Picture Perfect - DJ Grooves Token: Card Guessing Game": LocData(2001203991, "Picture Perfect"),
+    "Picture Perfect - DJ Grooves Token: Back Alley": LocData(2001203992, "Picture Perfect"),
+    "Picture Perfect - DJ Grooves Token: Cooking Show": LocData(2001203993, "Picture Perfect"),
+    "Picture Perfect - DJ Grooves Token: Pon Cluster": LocData(2001203987, "Picture Perfect"),
+    "Train Rush - Time Bonus: 1st Room": LocData(2001305235, "Train Rush", hookshot=True),
+    "Train Rush - Time Bonus: Falling Platform": LocData(2001305189, "Train Rush", hookshot=True),
+    "Train Rush - Time Bonus: Acid Crates": LocData(2001305186, "Train Rush", hookshot=True),
+    "Train Rush - Time Bonus: Balloon": LocData(2001305239, "Train Rush", hookshot=True),
+    "Train Rush - Time Bonus: Ring of Fire": LocData(2001305237, "Train Rush", hookshot=True),
+    "Train Rush - Time Bonus: Blue Panels": LocData(2001305236, "Train Rush", hookshot=True),
+    "Train Rush - Time Bonus: Sinking Lava Platform": LocData(2001305234, "Train Rush", hookshot=True),
+    "Train Rush - Time Bonus: Lava Panels 1": LocData(2001305193, "Train Rush", hookshot=True),
+    "Train Rush - Time Bonus: Lava Panels 2": LocData(2001305190, "Train Rush", hookshot=True),
+    "Train Rush - Time Bonus: Lava Panels 3": LocData(2001305238, "Train Rush", hookshot=True),
+    "The Big Parade - DJ Grooves Token (1/8)": LocData(2001400000, "The Big Parade"),
+    "The Big Parade - DJ Grooves Token (2/8)": LocData(2001400001, "The Big Parade"),
+    "The Big Parade - DJ Grooves Token (3/8)": LocData(2001400002, "The Big Parade"),
+    "The Big Parade - DJ Grooves Token (4/8)": LocData(2001400003, "The Big Parade"),
+    "The Big Parade - DJ Grooves Token (5/8)": LocData(2001400004, "The Big Parade", hit_type=HitType.umbrella),
+    "The Big Parade - DJ Grooves Token (6/8)": LocData(2001400005, "The Big Parade", hit_type=HitType.umbrella),
+    "The Big Parade - DJ Grooves Token (7/8)": LocData(2001400006, "The Big Parade", hit_type=HitType.umbrella),
+    "The Big Parade - DJ Grooves Token (8/8)": LocData(2001400007, "The Big Parade", hit_type=HitType.umbrella),
+}
+
 shop_locations = {
     "Badge Seller - Item 1": LocData(2000301003, "Badge Seller"),
     "Badge Seller - Item 2": LocData(2000301004, "Badge Seller"),
@@ -1050,6 +1081,7 @@ location_table = {
     **ahit_locations,
     **act_completions,
     **storybook_pages,
+    **director_tokens,
     **contract_locations,
     **shop_locations,
 }

worlds/ahit/Options.py

@@ -72,6 +72,7 @@ def adjust_options(world: "HatInTimeWorld"):
         world.options.EndGoal.value = EndGoal.option_seal_the_deal
         world.options.ActRandomizer.value = 0
         world.options.ShuffleAlpineZiplines.value = 0
+        world.options.ShuffleDirectorTokens.value = 0
         world.options.ShuffleSubconPaintings.value = 0
         world.options.ShuffleStorybookPages.value = 0
         world.options.ShuffleActContracts.value = 0
@@ -219,6 +220,12 @@ class ShuffleStorybookPages(DefaultOnToggle):
     display_name = "Shuffle Storybook Pages"
 
 
+class ShuffleDirectorTokens(Toggle):
+    """If enabled, causes the Conductor/DJ Grooves tokens found in Chapter 2 levels to become item checks.
+    NOTE: This also includes the time bonus pickups from Train Rush, since the level doesn't have any tokens."""
+    display_name = "Shuffle Director Tokens"
+
+
 class ShuffleActContracts(DefaultOnToggle):
     """If enabled, shuffle Snatcher's act contracts into the pool as items"""
     display_name = "Shuffle Contracts"
@@ -658,6 +665,7 @@ class AHITOptions(PerGameCommonOptions):
     StartWithCompassBadge:    StartWithCompassBadge
     CompassBadgeMode:         CompassBadgeMode
     ShuffleStorybookPages:    ShuffleStorybookPages
+    ShuffleDirectorTokens:    ShuffleDirectorTokens
     ShuffleActContracts:      ShuffleActContracts
     ShuffleSubconPaintings:   ShuffleSubconPaintings
     NoPaintingSkips:          NoPaintingSkips
@@ -722,7 +730,8 @@ class AHITOptions(PerGameCommonOptions):
 
 
 ahit_option_groups: Dict[str, List[Any]] = {
-    "General Options": [EndGoal, ShuffleStorybookPages, ShuffleAlpineZiplines, ShuffleSubconPaintings,
+    "General Options": [EndGoal, ShuffleStorybookPages, ShuffleDirectorTokens,
+                        ShuffleAlpineZiplines, ShuffleSubconPaintings,
                         ShuffleActContracts, MinPonCost, MaxPonCost, BadgeSellerMinItems, BadgeSellerMaxItems,
                         LogicDifficulty, NoPaintingSkips, CTRLogic],
 
@@ -759,6 +768,7 @@ slot_data_options: List[str] = [
     "StartWithCompassBadge",
     "CompassBadgeMode",
     "ShuffleStorybookPages",
+    "ShuffleDirectorTokens",
     "ShuffleActContracts",
     "ShuffleSubconPaintings",
     "NoPaintingSkips",

worlds/ahit/Regions.py

@@ -1,7 +1,7 @@
 from BaseClasses import Region, Entrance, ItemClassification, Location, LocationProgressType
 from .Types import ChapterIndex, Difficulty, HatInTimeLocation, HatInTimeItem
 from .Locations import location_table, storybook_pages, event_locs, is_location_valid, \
-    shop_locations, TASKSANITY_START_ID, snatcher_coins, zero_jumps, zero_jumps_expert, zero_jumps_hard
+    shop_locations, TASKSANITY_START_ID, snatcher_coins, zero_jumps, zero_jumps_expert, zero_jumps_hard, director_tokens
 from typing import TYPE_CHECKING, List, Dict, Optional
 from .Rules import set_rift_rules, get_difficulty
 from .Options import ActRandomizer, EndGoal
@@ -859,6 +859,9 @@ def create_region(world: "HatInTimeWorld", name: str) -> Region:
             if key in storybook_pages.keys() and not world.options.ShuffleStorybookPages:
                 continue
 
+            if key in director_tokens.keys() and not world.options.ShuffleDirectorTokens:
+                continue
+
             location = HatInTimeLocation(world.player, key, data.id, reg)
             reg.locations.append(location)
             if location.name in shop_locations:

worlds/alttp/ItemPool.py

@@ -263,7 +263,6 @@ def generate_itempool(world):
         ('Frog', 'Get Frog'),
         ('Missing Smith', 'Return Smith'),
         ('Floodgate', 'Open Floodgate'),
-        ('Agahnim 1', 'Beat Agahnim 1'),
         ('Flute Activation Spot', 'Activated Flute'),
         ('Capacity Upgrade Shop', 'Capacity Upgrade Shop')
     ]

worlds/alttp/Rom.py

@@ -183,7 +183,7 @@ def check_enemizer(enemizercli):
     if getattr(check_enemizer, "done", None):
         return
     if not os.path.exists(enemizercli) and not os.path.exists(enemizercli + ".exe"):
-        raise Exception(f"Enemizer not found at {enemizercli}, please install it."
+        raise Exception(f"Enemizer not found at {enemizercli}, please install it. "
                         f"Such as https://github.com/Ijwu/Enemizer/releases")
 
     with check_lock:

worlds/apquest/archipelago.json

@@ -1,6 +1,6 @@
 {
 	"game": "APQuest",
 	"minimum_ap_version": "0.6.4",
-	"world_version": "1.0.0",
+	"world_version": "1.0.1",
 	"authors": ["NewSoupVi"]
 }

worlds/apquest/client/custom_views.py

@@ -2,7 +2,7 @@ from collections.abc import Callable
 from dataclasses import dataclass
 from math import sqrt
 from random import choice, random
-from typing import TYPE_CHECKING, Any
+from typing import Any
 
 from kivy.core.window import Keyboard, Window
 from kivy.graphics import Color, Triangle

worlds/apquest/client/graphics.py

@@ -2,9 +2,8 @@ import pkgutil
 from collections.abc import Buffer
 from enum import Enum
 from io import BytesIO
-from typing import Literal, NamedTuple, cast
+from typing import Literal, NamedTuple, Protocol, cast
 
-from bokeh.protocol import Protocol
 from kivy.uix.image import CoreImage
 
 from CommonClient import logger

worlds/apquest/client/utils.py

@@ -16,10 +16,6 @@ def make_data_directory(dir_name: str) -> Path:
     gitignore = specific_data_directory / ".gitignore"
 
     with open(gitignore, "w") as f:
-        f.write(
-            """*
-!.gitignore
-"""
-        )
+        f.write("*\n")
 
     return specific_data_directory

worlds/apquest/components.py

@@ -31,3 +31,21 @@ components.append(
         supports_uri=True,
     )
 )
+
+# There are two optional parameters that are worth drawing attention to here: "game_name" and "supports_uri".
+# As you might know, on a room page on WebHost, clicking a slot name opens your locally installed Launcher
+# and asks you if you want to open a Text Client.
+# If you have "game_name" set on your Component, your user also gets the option to open that instead.
+# Furthermore, if you have "supports_uri" set to True, your Component will be passed a uri as an arg.
+# This uri contains the room url + port, the slot name, and the password.
+# You can process this uri arg to automatically connect the user to their slot without having to type anything.
+
+# As you can see above, the APQuest client has both of these parameters set.
+# This means a user can click on the slot name of an APQuest slot on WebHost,
+# then click "APQuest Client" instead of "Text Client" in the Launcher popup, and after a few seconds,
+# they will be connected and playing the game without having to touch their keyboard once.
+
+# Since a Component is just Python code, this doesn't just work with CommonClient-derived clients.
+# You could forward this uri arg to your standalone C++/Java/.NET/whatever client as well,
+# meaning just about every client can support this "Click on slot name -> Everything happens automatically" action.
+# The author would like to see more clients be aware of this feature and try to support it.

worlds/apquest/docs/setup_de.md

@@ -2,7 +2,7 @@
 
 ## Benötigte Software
 
-- [Archipelago](github.com/ArchipelagoMW/Archipelago/releases/latest)
+- [Archipelago](https://github.com/ArchipelagoMW/Archipelago/releases/latest)
 - Die [APQuest-apworld](https://github.com/NewSoupVi/Archipelago/releases), 
   falls diese nicht mit deiner Version von Archipelago gebündelt ist.
 
@@ -11,16 +11,16 @@
 Zuerst brauchst du einen Raum, mit dem du dich verbinden kannst.
 Dafür musst du oder jemand den du kennst ein Spiel generieren.  
 Dieser Schritt wird hier nicht erklärt, aber du kannst den
-[Archipelago Setup Guide](https://archipelago.gg/tutorial/Archipelago/setup_en#generating-a-game) lesen.
+[Archipelago Setup Guide](/tutorial/Archipelago/setup_en#generating-a-game) lesen.
 
-Du musst außerdem [Archipelago](github.com/ArchipelagoMW/Archipelago/releases/latest) installiert haben
+Du musst außerdem [Archipelago](https://github.com/ArchipelagoMW/Archipelago/releases/latest) installiert haben
 und die [APQuest apworld](https://github.com/NewSoupVi/Archipelago/releases) darin installieren.
 
 Von hier ist es einfach, dich mit deinem Slot zu verbinden.
 
 ### Webhost-Raum
 
-Wenn dein Raum auf einem WebHost läuft (z.B. [archipelago.gg](archipelago.gg))
+Wenn dein Raum auf einem WebHost läuft (z.B. [archipelago.gg](https://archipelago.gg))
 kannst du einfach auf deinen Namen in der Spielerliste klicken.  
 Dies öffnet den Archipelago Launcher, welcher dich dann fragt,
 ob du den Text Client oder den APQuest Client öffnen willst.  

worlds/apquest/docs/setup_en.md

@@ -2,7 +2,7 @@
 
 ## Required Software
 
-- [Archipelago](github.com/ArchipelagoMW/Archipelago/releases/latest)
+- [Archipelago](https://github.com/ArchipelagoMW/Archipelago/releases/latest)
 - [The APQuest apworld](https://github.com/NewSoupVi/Archipelago/releases), 
   if not bundled with your version of Archipelago
 
@@ -10,16 +10,16 @@
 
 First, you need a room to connect to. For this, you or someone you know has to generate a game.  
 This will not be explained here,
-but you can check the [Archipelago Setup Guide](https://archipelago.gg/tutorial/Archipelago/setup_en#generating-a-game).
+but you can check the [Archipelago Setup Guide](/tutorial/Archipelago/setup_en#generating-a-game).
 
-You also need to have [Archipelago](github.com/ArchipelagoMW/Archipelago/releases/latest) installed
+You also need to have [Archipelago](https://github.com/ArchipelagoMW/Archipelago/releases/latest) installed
 and the [The APQuest apworld](https://github.com/NewSoupVi/Archipelago/releases) installed into Archipelago.
 
 From here, connecting to your APQuest slot is easy. There are two scenarios.
 
 ### Webhost Room
 
-If your room is hosted on a WebHost (e.g. [archipelago.gg](archipelago.gg)),
+If your room is hosted on a WebHost (e.g. [archipelago.gg](https://archipelago.gg)),
 you should be able to simply click on your name in the player list.  
 This will open the Archipelago Launcher
 and ask you whether you want to connect with the Text Client or the APQuest Client.  

worlds/apquest/game/game.py

@@ -158,11 +158,11 @@ class Game:
         if not self.gameboard.ready:
             return
 
-        if self.active_math_problem is not None:
-            if input_key in DIGIT_INPUTS_TO_DIGITS:
-                self.math_problem_input(DIGIT_INPUTS_TO_DIGITS[input_key])
-            if input_key == Input.BACKSPACE:
-                self.math_problem_delete()
+        if input_key in DIGIT_INPUTS_TO_DIGITS:
+            self.math_problem_input(DIGIT_INPUTS_TO_DIGITS[input_key])
+            return
+        if input_key == Input.BACKSPACE:
+            self.math_problem_delete()
             return
 
         if input_key == Input.LEFT:

worlds/apquest/game/player.py

@@ -1,6 +1,5 @@
 from collections import Counter
 from collections.abc import Callable
-from typing import TYPE_CHECKING
 
 from .events import Event, LocationClearedEvent, VictoryEvent
 from .gameboard import Gameboard

worlds/apquest/world.py

@@ -5,7 +5,8 @@ from typing import Any
 from worlds.AutoWorld import World
 
 # Imports of your world's files must be relative.
-from . import items, locations, options, regions, rules, web_world
+from . import items, locations, regions, rules, web_world
+from . import options as apquest_options  # rename due to a name conflict with World.options
 
 # APQuest will go through all the parts of the world api one step at a time,
 # with many examples and comments across multiple files.
@@ -36,8 +37,9 @@ class APQuestWorld(World):
     web = web_world.APQuestWebWorld()
 
     # This is how we associate the options defined in our options.py with our world.
-    options_dataclass = options.APQuestOptions
-    options: options.APQuestOptions  # Common mistake: This has to be a colon (:), not an equals sign (=).
+    # (Note: options.py has been imported as "apquest_options" at the top of this file to avoid a name conflict)
+    options_dataclass = apquest_options.APQuestOptions
+    options: apquest_options.APQuestOptions  # Common mistake: This has to be a colon (:), not an equals sign (=).
 
     # Our world class must have a static location_name_to_id and item_name_to_id defined.
     # We define these in regions.py and items.py respectively, so we just set them here.

worlds/apsudoku/docs/en_Sudoku.md

@@ -11,3 +11,5 @@ Play Sudoku puzzles of varying difficulties, earning a hint for each puzzle corr
 ## Where is the options page?
 
 There is no options page; this game cannot be used in your .yamls. Instead, the client can connect to any slot in a multiworld.
+
+By using the connected room's Admin Password on the Admin Panel tab, you can configure some settings at any time to affect the entire room. This allows disabling hints entirely, as well as altering the hint odds for each difficulty.

worlds/apsudoku/docs/setup_en.md

@@ -11,7 +11,11 @@ Does not need to be added at the start of a seed, as it does not create any slot
 
 ## Installation Procedures
 
-Go to the latest release from the [APSudoku Releases page](https://github.com/APSudoku/APSudoku/releases/latest). Download and extract the appropriate file for your platform.
+### Windows / Linux
+Go to the latest release from the [github APSudoku Releases page](https://github.com/APSudoku/APSudoku/releases/latest). Download and extract the appropriate file for your platform.
+
+### Web
+Go to the [github pages](apsudoku.github.io) or [itch.io](https://emilyv99.itch.io/apsudoku) site, and play in the browser.
 
 ## Joining a MultiWorld Game
 
@@ -35,6 +39,14 @@ Info:
 - You can also use the `Tracking` tab to view either a basic tracker or a valid [GodotAP tracker pack](https://github.com/EmilyV99/GodotAP/blob/main/tracker_packs/GET_PACKS.md)
 - While connected, the number of "unhinted" locations for your slot is shown in the upper-left of the the `Sudoku` tab. (If this reads 0, no further hints can be earned for this slot, as every locations is already hinted)
 - Click the various `?` buttons for information on controls/how to play
+
+## Admin Settings
+
+By using the connected room's Admin Password on the Admin Panel tab, you can configure some settings at any time to affect the entire room.
+
+- You can disable APSudoku for the entire room, preventing any hints from being granted.
+- You can customize the reward weights for each difficulty, making progression hints more or less likely, and/or adding a chance to get "no hint" after a solve.
+
 ## DeathLink Support
 
 If `DeathLink` is enabled when you click `Connect`:

worlds/aquaria/Items.py

@@ -29,6 +29,7 @@ class ItemGroup(Enum):
     UTILITY = 4
     SONG = 5
     TURTLE = 6
+    DOOR = 7
 
 
 class AquariaItem(Item):
@@ -211,6 +212,7 @@ class ItemNames:
     TRANSTURTLE_BODY = "Transturtle Final Boss"
     TRANSTURTLE_SIMON_SAYS = "Transturtle Simon Says"
     TRANSTURTLE_ARNASSI_RUINS = "Transturtle Arnassi Ruins"
+    DOOR_TO_CATHEDRAL = "Door to the Cathedral opened"
     # Events name
     BODY_TONGUE_CLEARED = "Body Tongue cleared"
     HAS_SUN_CRYSTAL = "Has Sun Crystal"
@@ -240,7 +242,7 @@ item_table = {
     ItemNames.BIG_SEED: ItemData(698002, 1, ItemType.JUNK, ItemGroup.COLLECTIBLE),  # collectible_big_seed
     ItemNames.GLOWING_SEED: ItemData(698003, 1, ItemType.JUNK, ItemGroup.COLLECTIBLE),  # collectible_bio_seed
     ItemNames.BLACK_PEARL: ItemData(698004, 1, ItemType.JUNK, ItemGroup.COLLECTIBLE),  # collectible_blackpearl
-    ItemNames.BABY_BLASTER: ItemData(698005, 1, ItemType.NORMAL, ItemGroup.UTILITY),  # collectible_blaster
+    ItemNames.BABY_BLASTER: ItemData(698005, 1, ItemType.PROGRESSION, ItemGroup.UTILITY),  # collectible_blaster
     ItemNames.CRAB_ARMOR: ItemData(698006, 1, ItemType.NORMAL, ItemGroup.UTILITY),  # collectible_crab_costume
     ItemNames.BABY_DUMBO: ItemData(698007, 1, ItemType.PROGRESSION, ItemGroup.UTILITY),  # collectible_dumbo
     ItemNames.TOOTH: ItemData(698008, 1, ItemType.JUNK, ItemGroup.COLLECTIBLE),  # collectible_energy_boss
@@ -256,8 +258,8 @@ item_table = {
     ItemNames.MITHALAS_BANNER: ItemData(698018, 1, ItemType.JUNK, ItemGroup.COLLECTIBLE),  # collectible_mithalas_banner
     ItemNames.MITHALAS_POT: ItemData(698019, 1, ItemType.JUNK, ItemGroup.COLLECTIBLE),  # collectible_mithalas_pot
     ItemNames.MUTANT_COSTUME: ItemData(698020, 1, ItemType.JUNK, ItemGroup.COLLECTIBLE),  # collectible_mutant_costume
-    ItemNames.BABY_NAUTILUS: ItemData(698021, 1, ItemType.NORMAL, ItemGroup.UTILITY),  # collectible_nautilus
-    ItemNames.BABY_PIRANHA: ItemData(698022, 1, ItemType.NORMAL, ItemGroup.UTILITY),  # collectible_piranha
+    ItemNames.BABY_NAUTILUS: ItemData(698021, 1, ItemType.PROGRESSION, ItemGroup.UTILITY),  # collectible_nautilus
+    ItemNames.BABY_PIRANHA: ItemData(698022, 1, ItemType.PROGRESSION, ItemGroup.UTILITY),  # collectible_piranha
     ItemNames.ARNASSI_ARMOR: ItemData(698023, 1, ItemType.PROGRESSION, ItemGroup.UTILITY),  # collectible_seahorse_costume
     ItemNames.SEED_BAG: ItemData(698024, 1, ItemType.JUNK, ItemGroup.COLLECTIBLE),  # collectible_seed_bag
     ItemNames.KING_S_SKULL: ItemData(698025, 1, ItemType.JUNK, ItemGroup.COLLECTIBLE),  # collectible_skull
@@ -371,4 +373,20 @@ item_table = {
     ItemNames.TRANSTURTLE_BODY: ItemData(698131, 1, ItemType.PROGRESSION, ItemGroup.TURTLE),  # transport_finalboss
     ItemNames.TRANSTURTLE_SIMON_SAYS: ItemData(698132, 1, ItemType.PROGRESSION, ItemGroup.TURTLE),  # transport_forest05
     ItemNames.TRANSTURTLE_ARNASSI_RUINS: ItemData(698133, 1, ItemType.PROGRESSION, ItemGroup.TURTLE),  # transport_seahorse
+    ItemNames.DOOR_TO_CATHEDRAL: ItemData(698134, 1, ItemType.PROGRESSION, ItemGroup.DOOR),  # door_to_cathedral
 }
+
+
+four_gods_excludes = [ItemNames.ANEMONE, ItemNames.ARNASSI_STATUE, ItemNames.BIG_SEED, ItemNames.GLOWING_SEED,
+                      ItemNames.BLACK_PEARL, ItemNames.TOOTH, ItemNames.ENERGY_STATUE, ItemNames.KROTITE_ARMOR,
+                      ItemNames.GOLDEN_STARFISH, ItemNames.GOLDEN_GEAR, ItemNames.JELLY_BEACON,
+                      ItemNames.JELLY_PLANT, ItemNames.MITHALAS_DOLL, ItemNames.MITHALAN_DRESS,
+                      ItemNames.MITHALAS_BANNER, ItemNames.MITHALAS_POT, ItemNames.MUTANT_COSTUME, ItemNames.SEED_BAG,
+                      ItemNames.KING_S_SKULL, ItemNames.SONG_PLANT_SPORE, ItemNames.STONE_HEAD, ItemNames.SUN_KEY,
+                      ItemNames.GIRL_COSTUME, ItemNames.ODD_CONTAINER, ItemNames.TRIDENT, ItemNames.TURTLE_EGG,
+                      ItemNames.JELLY_EGG, ItemNames.URCHIN_COSTUME, ItemNames.BABY_WALKER,
+                      ItemNames.RAINBOW_MUSHROOM, ItemNames.RAINBOW_MUSHROOM, ItemNames.RAINBOW_MUSHROOM,
+                      ItemNames.LEAF_POULTICE, ItemNames.LEAF_POULTICE, ItemNames.LEAF_POULTICE,
+                      ItemNames.LEECHING_POULTICE, ItemNames.LEECHING_POULTICE, ItemNames.ARCANE_POULTICE,
+                      ItemNames.ROTTEN_MEAT, ItemNames.ROTTEN_MEAT, ItemNames.ROTTEN_MEAT, ItemNames.ROTTEN_MEAT,
+                      ItemNames.SEA_LOAF_X_2, ItemNames.SMALL_EGG]

worlds/aquaria/Locations.py

@@ -233,7 +233,7 @@ class AquariaLocationNames:
     SUN_TEMPLE_BULB_AT_THE_TOP_OF_THE_HIGH_DARK_ROOM = "Sun Temple, bulb at the top of the high dark room"
     SUN_TEMPLE_GOLDEN_GEAR = "Sun Temple, Golden Gear"
     SUN_TEMPLE_FIRST_BULB_OF_THE_TEMPLE = "Sun Temple, first bulb of the temple"
-    SUN_TEMPLE_BULB_ON_THE_RIGHT_PART = "Sun Temple, bulb on the right part"
+    SUN_TEMPLE_BULB_ON_THE_RIGHT_PART = "Sun Temple, bulb in the right part"
     SUN_TEMPLE_BULB_IN_THE_HIDDEN_ROOM_OF_THE_RIGHT_PART = "Sun Temple, bulb in the hidden room of the right part"
     SUN_TEMPLE_SUN_KEY = "Sun Temple, Sun Key"
     SUN_TEMPLE_BOSS_PATH_FIRST_PATH_BULB = "Sun Temple boss path, first path bulb"
@@ -306,6 +306,7 @@ class AquariaLocationNames:
     BEATING_CRABBIUS_MAXIMUS = "Beating Crabbius Maximus"
     BEATING_MANTIS_SHRIMP_PRIME = "Beating Mantis Shrimp Prime"
     BEATING_KING_JELLYFISH_GOD_PRIME = "Beating King Jellyfish God Prime"
+    SITTING_ON_THRONE = "Mithalas City Castle, sitting on the sealed throne"
     FIRST_SECRET = "First Secret"
     SECOND_SECRET = "Second Secret"
     THIRD_SECRET = "Third Secret"
@@ -497,6 +498,7 @@ class AquariaLocations:
     locations_mithalas_castle = {
         AquariaLocationNames.MITHALAS_CITY_CASTLE_BULB_IN_THE_FLESH_HOLE: 698042,
         AquariaLocationNames.MITHALAS_CITY_CASTLE_BLUE_BANNER: 698165,
+        AquariaLocationNames.SITTING_ON_THRONE: 698218,
     }
 
     locations_mithalas_castle_urns = {
@@ -803,6 +805,10 @@ class AquariaLocations:
         AquariaLocationNames.FINAL_BOSS_AREA_TRANSTURTLE: 698215,
     }
 
+    locations_final_boss_tube_transturtle_only = {
+        AquariaLocationNames.FINAL_BOSS_AREA_TRANSTURTLE: 698215,
+    }
+
     locations_final_boss = {
         AquariaLocationNames.FINAL_BOSS_AREA_BULB_IN_THE_BOSS_THIRD_FORM_ROOM: 698106,
     }

worlds/aquaria/Options.py

@@ -11,9 +11,11 @@ from Options import Toggle, Choice, Range, PerGameCommonOptions, DefaultOnToggle
 class IngredientRandomizer(Choice):
     """
     Select if the simple ingredients (that do not have a recipe) should be randomized.
+
     If "Common Ingredients" is selected, the randomization will exclude the "Red Bulb", "Special Bulb" and "Rukh Egg".
     """
     display_name = "Randomize Ingredients"
+    rich_text_doc = True
     option_off = 0
     alias_false = 0
     option_common_ingredients = 1
@@ -26,11 +28,17 @@ class IngredientRandomizer(Choice):
 class DishRandomizer(Toggle):
     """Randomize the drop of Dishes (Ingredients with recipe)."""
     display_name = "Dish Randomizer"
+    rich_text_doc = True
 
 
 class TurtleRandomizer(Choice):
-    """Randomize the transportation turtle."""
+    """
+    Randomize the transportation turtle.
+
+    If the objective is "killing the four gods" or "Gods and Creator", the abyss and body turtle will not be randomized.
+    """
     display_name = "Turtle Randomizer"
+    rich_text_doc = True
     option_none = 0
     alias_off = 0
     alias_false = 0
@@ -47,6 +55,7 @@ class EarlyBindSong(Choice):
     selected).
     """
     display_name = "Early Bind song"
+    rich_text_doc = True
     option_off = 0
     alias_false = 0
     option_early = 1
@@ -62,6 +71,7 @@ class EarlyEnergyForm(Choice):
     selected).
     """
     display_name = "Early Energy form"
+    rich_text_doc = True
     option_off = 0
     alias_false = 0
     option_early = 1
@@ -74,14 +84,19 @@ class EarlyEnergyForm(Choice):
 class AquarianTranslation(Toggle):
     """Translate the Aquarian scripture in the game into English."""
     display_name = "Translate Aquarian"
+    rich_text_doc = True
 
 
 class BigBossesToBeat(Range):
     """
-    The number of big bosses to beat before having access to the creator (the final boss). The big bosses are
-    "Fallen God", "Mithalan God", "Drunian God", "Lumerean God" and "The Golem".
+    The number of big bosses to beat before having access to the creator (the final boss).
+
+    The big bosses are "Fallen God", "Mithalan God", "Drunian God", "Lumerean God" and "The Golem".
+
+    Has no effect if the objective is "killing the four gods" or "Gods and Creator".
     """
     display_name = "Big bosses to beat"
+    rich_text_doc = True
     range_start = 0
     range_end = 5
     default = 0
@@ -89,12 +104,18 @@ class BigBossesToBeat(Range):
 
 class MiniBossesToBeat(Range):
     """
-    The number of minibosses to beat before having access to the creator (the final boss). The minibosses are
-    "Nautilus Prime", "Blaster Peg Prime", "Mergog", "Mithalan priests", "Octopus Prime", "Crabbius Maximus",
-    "Mantis Shrimp Prime" and "King Jellyfish God Prime".
-    Note that the Energy Statue and Simon Says are not minibosses.
+    The number of minibosses to beat before having access to the goal.
+
+    The minibosses are "Nautilus Prime", "Blaster Peg Prime", "Mergog", "Mithalan priests", "Octopus Prime",
+    "Crabbius Maximus", "Mantis Shrimp Prime" and "King Jellyfish God Prime".
+
+    Note that the "Energy Statue" and "Simon Says" are not minibosses.
+
+    Also note that if the objective is "killing the four enemy gods" or "Gods and creator", it might be needed to go in the abyss and
+    bubble cave to kill "King Jellyfish God Prime" and "Mantis Shrimp Prime".
     """
     display_name = "Minibosses to beat"
+    rich_text_doc = True
     range_start = 0
     range_end = 8
     default = 0
@@ -102,38 +123,48 @@ class MiniBossesToBeat(Range):
 
 class Objective(Choice):
     """
-    The game objective can be to kill the creator or to kill the creator after obtaining all three secret memories.
+    **Kill the Creator:** Get to the final boss (the Creator) and beat all it's forms.
+
+    **Obtain secrets and kill the Creator:** like the "Kill the Creator", but need to find all three secret memories
+    before getting to the Creator.
+
+    **Killing the four gods:**, Beat all four enemy gods ("Fallen God", "Mithalan God", "Drunian God", "Lumerean God").
+
+    **Gods and Creator:** like "Killing the four gods" but you also have to beat the creator.
     """
     display_name = "Objective"
+    rich_text_doc = True
     option_kill_the_creator = 0
     option_obtain_secrets_and_kill_the_creator = 1
+    option_killing_the_four_gods = 2
+    option_gods_and_creator = 3
     default = 0
 
 
 class SkipFirstVision(Toggle):
     """
-    The first vision in the game, where Naija transforms into Energy Form and gets flooded by enemies, is quite cool but
-    can be quite long when you already know what is going on. This option can be used to skip this vision.
+    Skip the first vision in the game, where Naija transforms into Energy Form and gets flooded by enemies.
     """
     display_name = "Skip Naija's first vision"
+    rich_text_doc = True
 
 
-class NoProgressionHardOrHiddenLocation(Toggle):
-    """
-    Make sure that there are no progression items at hard-to-reach or hard-to-find locations.
-    Those locations are very High locations (that need beast form, soup and skill to get),
-    every location in the bubble cave, locations where need you to cross a false wall without any indication,
-    the Arnassi race, bosses and minibosses. Useful for those that want a more casual run.
-    """
-    display_name = "No progression in hard or hidden locations"
-
-
-class LightNeededToGetToDarkPlaces(DefaultOnToggle):
+class LightNeededToGetToDarkPlaces(Choice):
     """
     Make sure that the sun form or the dumbo pet can be acquired before getting to dark places.
+
     Be aware that navigating in dark places without light is extremely difficult.
+
+    You can also force the sun form to be accessible by using the "sun form" option.
     """
     display_name = "Light needed to get to dark places"
+    rich_text_doc = True
+    option_off = 0
+    alias_false = 0
+    option_on = 1
+    alias_true = 1
+    option_sun_form = 2
+    default = 1
 
 
 class BindSongNeededToGetUnderRockBulb(DefaultOnToggle):
@@ -141,23 +172,83 @@ class BindSongNeededToGetUnderRockBulb(DefaultOnToggle):
     Make sure that the bind song can be acquired before having to obtain sing bulbs under rocks.
     """
     display_name = "Bind song needed to get sing bulbs under rocks"
+    rich_text_doc = True
 
 
 class BlindGoal(Toggle):
     """
-    Hide the goal's requirements from the help page so that you have to go to the last boss door to know
-    what is needed to access the boss.
+    Hide the goal's requirements from the help page so that you don't know what is needed to goal.
+
+    Note that when you get to the final boss door (or you beat the last gods when the "Killing the four gods"
+    is selected) you can then see the requirements in the help page.
     """
     display_name = "Hide the goal's requirements"
+    rich_text_doc = True
+
+
+class InfiniteHotSoup(DefaultOnToggle):
+    """
+    As soon as a "hot soup" is received, the user will never run out of this dish.
+
+    This option is recommended if using Ingredient randomization since "hot soup" ingredients may become hard to get
+    and the "hot soup" is necessary to get to some locations.
+    """
+    display_name = "Infinite Hot Soup"
+    rich_text_doc = True
+
+
+class SaveHealing(DefaultOnToggle):
+    """
+    When you save, Naija is healed back to full health. If disabled, saving won't heal Naija.
+
+    Note that Naija can still heal by sleeping in some beds in the game (including in her home).
+    """
+    display_name = "Save heal Naija"
+    rich_text_doc = True
+
+
+class OpenBodyTongue(Toggle):
+    """
+    Remove the body tongue making the body accessible without going in the sunken city
+    """
+    display_name = "Open the body tongue"
+    rich_text_doc = True
+
+
+class SkipFinalBoss3rdForm(Toggle):
+    """
+    The Final boss third form (the hide and seek form) can be easy and quite long. So, this option can be used
+    to skip this form.
+
+    Note that you will still need to deliver the final blow to the 3rd form in order to activate the 4th form animation.
+    """
+    display_name = "Skip final boss third form"
+
+
+class MaximumIngredientAmount(Range):
+    """
+    The maximum number of the same ingredients that can be stacked on the ingredient inventory.
+    """
+    display_name = "Maximum ingredient amount"
+    rich_text_doc = True
+    range_start = 2
+    range_end = 20
+    default = 8
 
 
 class UnconfineHomeWater(Choice):
     """
     Open the way out of the Home Waters area so that Naija can go to open water and beyond without the bind song.
+
+    **Via energy door:** Open the energy door between the home waters and the open waters
+
+    **Via transturtle:** Remove the rock blocking the home water transturtle.
+
     Note that if you turn this option off, it is recommended to turn on the Early Energy form and Early Bind Song
     options.
     """
     display_name = "Unconfine Home Waters Area"
+    rich_text_doc = True
     option_off = 0
     alias_false = 0
     option_via_energy_door = 1
@@ -168,6 +259,134 @@ class UnconfineHomeWater(Choice):
     default = 0
 
 
+class ThroneAsLocation(Toggle):
+    """
+    If enabled, sitting on the Mithalas City Castle throne (with the seal on it) will be a location and opening the
+    door to the Mithalas Cathedral will be an item.
+    """
+    display_name = "Throne as a location"
+    rich_text_doc = True
+
+
+class NoProgressionHardOrHiddenLocation(Toggle):
+    """
+    Make sure that there are no progression items at hard-to-reach or hard-to-find locations.
+
+    Those locations are very High locations (that need beast form, soup and skill to get), every location in the
+    bubble cave, locations where need you to cross a false wall without any indication, the Arnassi race,
+    bosses and minibosses.
+
+    Useful for those that want a more casual run.
+    """
+    display_name = "No progression in hard or hidden locations"
+    rich_text_doc = True
+
+
+class NoProgressionSimonSays(Toggle):
+    """
+    Make sure that there are no progression items in the says area.
+    """
+    display_name = "No progression in Simon says area"
+    rich_text_doc = True
+
+
+class NoProgressionKelpForest(Toggle):
+    """
+    Make sure that there are no progression items in Kelp Forest (excluding Simon says area).
+
+    Can be useful to get smaller runs.
+    """
+    display_name = "No progression in Kelp Forest"
+
+
+class NoProgressionVeil(Toggle):
+    """
+    Make sure that there are no progression items in the Veil.
+
+    Can be useful to get smaller runs.
+    """
+    display_name = "No progression in the Veil"
+    rich_text_doc = True
+
+
+class NoProgressionMithalas(Toggle):
+    """
+    Make sure that there are no progression items in the Mithalas (city, castle and cathedral).
+
+    Can be useful to get smaller runs.
+    """
+    display_name = "No progression in Mithalas"
+    rich_text_doc = True
+
+
+class NoProgressionEnergyTemple(Toggle):
+    """
+    Make sure that there are no progression items in the Energy Temple.
+
+    Can be useful to get smaller runs.
+    """
+    display_name = "No progression in the Energy Temple"
+    rich_text_doc = True
+
+
+class NoProgressionArnassiRuins(Toggle):
+    """
+    Make sure that there are no progression items in the Arnassi Ruins.
+
+    Can be useful to get smaller runs.
+
+    Note that if the Transportation turtle are not randomize, this include Simon Says area.
+    """
+    display_name = "No progression in Arnassi Ruins"
+    rich_text_doc = True
+
+
+class NoProgressionFrozenVeil(Toggle):
+    """
+    Make sure that there are no progression items in the Frozen Veil (including Ice Cavern and Bubble Cave).
+
+    Can be useful to get smaller runs.
+    """
+    display_name = "No progression in the Frozen Veil"
+    rich_text_doc = True
+
+
+class NoProgressionAbyss(Toggle):
+    """
+    Make sure that there are no progression items in the Abyss.
+
+    Can be useful to get smaller runs.
+
+    Has no effect if the objective is "killing the four gods".
+    """
+    display_name = "No progression in the Abyss"
+    rich_text_doc = True
+
+
+class NoProgressionSunkenCity(Toggle):
+    """
+    Make sure that there are no progression items in the Sunken City.
+
+    Can be useful to get smaller runs.
+
+    Has no effect if the objective is "killing the four gods".
+    """
+    display_name = "No progression in the Sunken City"
+    rich_text_doc = True
+
+
+class NoProgressionBody(Toggle):
+    """
+    Make sure that there are no progression items in the Body (including the before-boss transturtle room
+    and the boss location).
+
+    Can be useful to get smaller runs.
+
+    Has no effect if the objective is "killing the four gods".
+    """
+    display_name = "No progression in the Body"
+    rich_text_doc = True
+
 @dataclass
 class AquariaOptions(PerGameCommonOptions):
     """
@@ -183,9 +402,25 @@ class AquariaOptions(PerGameCommonOptions):
     light_needed_to_get_to_dark_places: LightNeededToGetToDarkPlaces
     bind_song_needed_to_get_under_rock_bulb: BindSongNeededToGetUnderRockBulb
     unconfine_home_water: UnconfineHomeWater
-    no_progression_hard_or_hidden_locations: NoProgressionHardOrHiddenLocation
     ingredient_randomizer: IngredientRandomizer
     dish_randomizer: DishRandomizer
     aquarian_translation: AquarianTranslation
     skip_first_vision: SkipFirstVision
     blind_goal: BlindGoal
+    infinite_hot_soup: InfiniteHotSoup
+    open_body_tongue: OpenBodyTongue
+    maximum_ingredient_amount: MaximumIngredientAmount
+    skip_final_boss_3rd_form: SkipFinalBoss3rdForm
+    save_healing: SaveHealing
+    throne_as_location: ThroneAsLocation
+    no_progression_hard_or_hidden_locations: NoProgressionHardOrHiddenLocation
+    no_progression_simon_says: NoProgressionSimonSays
+    no_progression_kelp_forest: NoProgressionKelpForest
+    no_progression_veil: NoProgressionVeil
+    no_progression_mithalas: NoProgressionMithalas
+    no_progression_energy_temple: NoProgressionEnergyTemple
+    no_progression_arnassi_ruins: NoProgressionArnassiRuins
+    no_progression_frozen_veil: NoProgressionFrozenVeil
+    no_progression_abyss: NoProgressionAbyss
+    no_progression_sunken_city: NoProgressionSunkenCity
+    no_progression_body: NoProgressionBody

worlds/aquaria/Regions.py

@@ -8,7 +8,7 @@ from typing import Dict, Optional, Iterable
 from BaseClasses import MultiWorld, Region, Entrance, Item, ItemClassification, CollectionState
 from .Items import AquariaItem, ItemNames
 from .Locations import AquariaLocations, AquariaLocation, AquariaLocationNames
-from .Options import AquariaOptions, UnconfineHomeWater
+from .Options import AquariaOptions, UnconfineHomeWater, LightNeededToGetToDarkPlaces, Objective
 from worlds.generic.Rules import add_rule, set_rule
 
 
@@ -116,14 +116,27 @@ def _has_big_bosses(state: CollectionState, player: int) -> bool:
                           ItemNames.LUMEREAN_GOD_BEATED, ItemNames.THE_GOLEM_BEATED}, player)
 
 
-def _has_mini_bosses(state: CollectionState, player: int) -> bool:
+def _has_four_gods_beated(state: CollectionState, player: int) -> bool:
     """`player` in `state` has beated every big bosses"""
+    return state.has_all({ItemNames.FALLEN_GOD_BEATED, ItemNames.MITHALAN_GOD_BEATED, ItemNames.DRUNIAN_GOD_BEATED,
+                          ItemNames.LUMEREAN_GOD_BEATED}, player)
+
+
+def _has_mini_bosses(state: CollectionState, player: int) -> bool:
+    """`player` in `state` has beated every mini bosses"""
     return state.has_all({ItemNames.NAUTILUS_PRIME_BEATED, ItemNames.BLASTER_PEG_PRIME_BEATED, ItemNames.MERGOG_BEATED,
                           ItemNames.MITHALAN_PRIESTS_BEATED, ItemNames.OCTOPUS_PRIME_BEATED,
                           ItemNames.CRABBIUS_MAXIMUS_BEATED, ItemNames.MANTIS_SHRIMP_PRIME_BEATED,
                           ItemNames.KING_JELLYFISH_GOD_PRIME_BEATED}, player)
 
 
+def _has_mini_bosses_four_gods(state: CollectionState, player: int) -> bool:
+    """`player` in `state` has beated every mini bosses other than the ones in the abyss and in the bubble cave"""
+    return state.has_all({ItemNames.NAUTILUS_PRIME_BEATED, ItemNames.BLASTER_PEG_PRIME_BEATED, ItemNames.MERGOG_BEATED,
+                          ItemNames.MITHALAN_PRIESTS_BEATED, ItemNames.OCTOPUS_PRIME_BEATED,
+                          ItemNames.CRABBIUS_MAXIMUS_BEATED}, player)
+
+
 def _has_secrets(state: CollectionState, player: int) -> bool:
     """The secrets have been acquired in the `state` of the `player`"""
     return state.has_all({ItemNames.FIRST_SECRET_OBTAINED, ItemNames.SECOND_SECRET_OBTAINED,
@@ -133,6 +146,11 @@ def _item_not_advancement(item: Item):
     """The `item` is not an advancement item"""
     return not item.advancement
 
+def _is_cathedral_door_opened(state: CollectionState, player: int) -> bool:
+    """The door to Mithalas Cathedral has been opened in the `state` of the `player`"""
+    return state.has(ItemNames.DOOR_TO_CATHEDRAL, player)
+
+
 class AquariaRegions:
     """
     Class used to create regions of the Aquaria game
@@ -236,10 +254,11 @@ class AquariaRegions:
     body_rt: Region
     body_rb: Region
     body_b: Region
-    final_boss_loby: Region
+    final_boss_lobby: Region
     final_boss_tube: Region
     final_boss: Region
     final_boss_end: Region
+    four_gods_end: Region
     """
     Every Region of the game
     """
@@ -254,6 +273,11 @@ class AquariaRegions:
     The ID of the player
     """
 
+    is_four_gods: bool
+    """
+    True if the player has an objective that implies killing the four gods
+    """
+
     def __add_region(self, hint: str,
                      locations: Optional[Dict[str, int]]) -> Region:
         """
@@ -439,65 +463,82 @@ class AquariaRegions:
         self.sun_temple_boss = self.__add_region("Sun Temple boss area",
                                                  AquariaLocations.locations_sun_temple_boss)
 
-    def __create_abyss(self) -> None:
+    def __create_abyss(self, add_locations: bool) -> None:
         """
         Create the `abyss_*`, `ice_cave`, `king_jellyfish_cave` and `whale`
         regions
         """
         self.abyss_l = self.__add_region("Abyss left area",
-                                         AquariaLocations.locations_abyss_l)
-        self.abyss_lb = self.__add_region("Abyss left bottom area", AquariaLocations.locations_abyss_lb)
-        self.abyss_r = self.__add_region("Abyss right area", AquariaLocations.locations_abyss_r)
+                                         AquariaLocations.locations_abyss_l if add_locations else None)
+        self.abyss_lb = self.__add_region("Abyss left bottom area",
+                                          AquariaLocations.locations_abyss_lb if add_locations else None)
+        self.abyss_r = self.__add_region("Abyss right area",
+                                         AquariaLocations.locations_abyss_r if add_locations else None)
         self.abyss_r_transturtle = self.__add_region("Abyss right area, transturtle",
                                                      AquariaLocations.locations_abyss_r_transturtle)
         self.abyss_r_whale = self.__add_region("Abyss right area, outside the whale",
-                                               AquariaLocations.locations_abyss_r_whale)
-        self.ice_cave = self.__add_region("Ice Cavern", AquariaLocations.locations_ice_cave)
+                                               AquariaLocations.locations_abyss_r_whale if add_locations else None)
+        self.ice_cave = self.__add_region("Ice Cavern",
+                                          AquariaLocations.locations_ice_cave if add_locations else None)
         self.frozen_feil = self.__add_region("Frozen Veil", None)
-        self.bubble_cave = self.__add_region("Bubble Cave", AquariaLocations.locations_bubble_cave)
-        self.bubble_cave_boss = self.__add_region("Bubble Cave boss area", AquariaLocations.locations_bubble_cave_boss)
+        self.bubble_cave = self.__add_region("Bubble Cave",
+                                             AquariaLocations.locations_bubble_cave if add_locations else None)
+        self.bubble_cave_boss = self.__add_region("Bubble Cave boss area",
+                                                  AquariaLocations.locations_bubble_cave_boss
+                                                  if add_locations else None)
         self.king_jellyfish_cave = self.__add_region("Abyss left area, King jellyfish cave",
-                                                     AquariaLocations.locations_king_jellyfish_cave)
-        self.whale = self.__add_region("Inside the whale", AquariaLocations.locations_whale)
+                                                     AquariaLocations.locations_king_jellyfish_cave
+                                                     if add_locations else None)
+        self.whale = self.__add_region("Inside the whale",
+                                       AquariaLocations.locations_whale if add_locations else None)
+
         self.first_secret = self.__add_region("First Secret area", None)
 
-    def __create_sunken_city(self) -> None:
+    def __create_sunken_city(self, add_locations: bool) -> None:
         """
         Create the `sunken_city_*` regions
         """
         self.sunken_city_l = self.__add_region("Sunken City left area", None)
         self.sunken_city_l_crates = self.__add_region("Sunken City left area",
-                                                      AquariaLocations.locations_sunken_city_l)
+                                                      AquariaLocations.locations_sunken_city_l
+                                                      if add_locations else None)
         self.sunken_city_l_bedroom = self.__add_region("Sunken City left area, bedroom",
-                                                       AquariaLocations.locations_sunken_city_l_bedroom)
+                                                       AquariaLocations.locations_sunken_city_l_bedroom
+                                                       if add_locations else None)
         self.sunken_city_r = self.__add_region("Sunken City right area", None)
         self.sunken_city_r_crates = self.__add_region("Sunken City right area crates",
-                                                      AquariaLocations.locations_sunken_city_r)
+                                                      AquariaLocations.locations_sunken_city_r
+                                                      if add_locations else None)
         self.sunken_city_boss = self.__add_region("Sunken City boss area",
-                                                  AquariaLocations.locations_sunken_city_boss)
+                                                  AquariaLocations.locations_sunken_city_boss
+                                                  if add_locations else None)
 
-    def __create_body(self) -> None:
+    def __create_body(self, add_locations: bool) -> None:
         """
         Create the `body_*` and `final_boss* regions
         """
         self.body_c = self.__add_region("The Body center area",
-                                        AquariaLocations.locations_body_c)
+                                        AquariaLocations.locations_body_c if add_locations else None)
         self.body_l = self.__add_region("The Body left area",
-                                        AquariaLocations.locations_body_l)
+                                        AquariaLocations.locations_body_l if add_locations else None)
         self.body_rt = self.__add_region("The Body right area, top path",
-                                         AquariaLocations.locations_body_rt)
+                                         AquariaLocations.locations_body_rt if add_locations else None)
         self.body_rb = self.__add_region("The Body right area, bottom path",
-                                         AquariaLocations.locations_body_rb)
+                                         AquariaLocations.locations_body_rb if add_locations else None)
         self.body_b = self.__add_region("The Body bottom area",
-                                        AquariaLocations.locations_body_b)
-        self.final_boss_loby = self.__add_region("The Body, before final boss", None)
+                                        AquariaLocations.locations_body_b if add_locations else None)
+        self.final_boss_lobby = self.__add_region("The Body, before final boss", None)
         self.final_boss_tube = self.__add_region("The Body, final boss area turtle room",
-                                                 AquariaLocations.locations_final_boss_tube)
+                                                 AquariaLocations.locations_final_boss_tube
+                                                 if add_locations else
+                                                 AquariaLocations.locations_final_boss_tube_transturtle_only)
         self.final_boss = self.__add_region("The Body, final boss",
-                                            AquariaLocations.locations_final_boss)
+                                            AquariaLocations.locations_final_boss if add_locations else None)
         self.final_boss_end = self.__add_region("The Body, final boss area", None)
 
-    def get_entrance_name(self, from_region: Region, to_region: Region):
+    @staticmethod
+    def get_entrance_name(from_region: Region, to_region: Region):
+
         """
         Return the name of an entrance between `from_region` and `to_region`
         """
@@ -510,6 +551,7 @@ class AquariaRegions:
         entrance = Entrance(self.player, self.get_entrance_name(source_region, destination_region), source_region)
         source_region.exits.append(entrance)
         entrance.connect(destination_region)
+
         if rule is not None:
             set_rule(entrance, rule)
 
@@ -633,8 +675,8 @@ class AquariaRegions:
                                        lambda state: _has_beast_form(state, self.player))
         self.__connect_regions(self.mithalas_castle, self.cathedral_underground,
                                lambda state: _has_beast_form(state, self.player))
-        self.__connect_one_way_regions(self.mithalas_castle, self.cathedral_top_start,
-                                       lambda state: _has_bind_song(state, self.player))
+        self.__connect_regions(self.mithalas_castle, self.cathedral_top_start,
+                               lambda state: _is_cathedral_door_opened(state, self.player))
         self.__connect_one_way_regions(self.cathedral_top_start, self.cathedral_top_start_urns,
                                        lambda state: _has_damaging_item(state, self.player))
         self.__connect_regions(self.cathedral_top_start, self.cathedral_top_end,
@@ -708,16 +750,14 @@ class AquariaRegions:
         self.__connect_regions(self.veil_tl, self.turtle_cave)
         self.__connect_regions(self.turtle_cave, self.turtle_cave_bubble)
         self.__connect_regions(self.veil_tr_r, self.sun_temple_r)
-
         self.__connect_one_way_regions(self.sun_temple_r, self.sun_temple_l_entrance,
-                                       lambda state: _has_bind_song(state, self.player) or
+                                       lambda state: _has_sun_crystal(state, self.player) or
                                                      _has_light(state, self.player))
         self.__connect_one_way_regions(self.sun_temple_l_entrance, self.sun_temple_r,
                                        lambda state: _has_light(state, self.player))
         self.__connect_regions(self.sun_temple_l_entrance, self.veil_tr_l)
         self.__connect_regions(self.sun_temple_l, self.sun_temple_l_entrance)
-        self.__connect_one_way_regions(self.sun_temple_l, self.sun_temple_boss_path)
-        self.__connect_one_way_regions(self.sun_temple_boss_path, self.sun_temple_l)
+        self.__connect_regions(self.sun_temple_l, self.sun_temple_boss_path)
         self.__connect_regions(self.sun_temple_boss_path, self.sun_temple_boss,
                                lambda state: _has_energy_attack_item(state, self.player))
         self.__connect_one_way_regions(self.sun_temple_boss, self.veil_tr_l)
@@ -800,17 +840,31 @@ class AquariaRegions:
         self.__connect_one_way_regions(self.body_rb, self.body_c)
         self.__connect_regions(self.body_c, self.body_b,
                                lambda state: _has_dual_form(state, self.player))
-        self.__connect_regions(self.body_b, self.final_boss_loby,
+        self.__connect_regions(self.body_b, self.final_boss_lobby,
                                lambda state: _has_dual_form(state, self.player))
-        self.__connect_regions(self.final_boss_loby, self.final_boss_tube,
+        self.__connect_regions(self.final_boss_lobby, self.final_boss_tube,
                                lambda state: _has_nature_form(state, self.player))
-        self.__connect_one_way_regions(self.final_boss_loby, self.final_boss,
+        self.__connect_one_way_regions(self.final_boss_lobby, self.final_boss,
                                        lambda state: _has_energy_form(state, self.player) and
                                                      _has_dual_form(state, self.player) and
                                                      _has_sun_form(state, self.player) and
                                                      _has_bind_song(state, self.player))
         self.__connect_one_way_regions(self.final_boss, self.final_boss_end)
 
+    def __connect_four_gods_end(self, options: AquariaOptions) -> None:
+        """
+        Connect an entrance for the four gods objective ending
+        """
+        if options.mini_bosses_to_beat.value > 6:
+            victory_lambda = lambda state: (_has_four_gods_beated(state, self.player) and
+                                            _has_mini_bosses(state, self.player))
+        elif options.big_bosses_to_beat.value > 0:
+            victory_lambda = lambda state: (_has_four_gods_beated(state, self.player) and
+                                            _has_mini_bosses_four_gods(state, self.player))
+        else:
+            victory_lambda = lambda state: _has_four_gods_beated(state, self.player)
+        self.__connect_one_way_regions(self.menu, self.four_gods_end, victory_lambda)
+
     def __connect_transturtle(self, item_target: str, region_source: Region, region_target: Region) -> None:
         """Connect a single transturtle to another one"""
         if region_source != region_target:
@@ -824,10 +878,10 @@ class AquariaRegions:
         self.__connect_transturtle(ItemNames.TRANSTURTLE_OPEN_WATERS, region, self.openwater_tr_turtle)
         self.__connect_transturtle(ItemNames.TRANSTURTLE_KELP_FOREST, region, self.forest_bl)
         self.__connect_transturtle(ItemNames.TRANSTURTLE_HOME_WATERS, region, self.home_water_transturtle)
-        self.__connect_transturtle(ItemNames.TRANSTURTLE_ABYSS, region, self.abyss_r_transturtle)
-        self.__connect_transturtle(ItemNames.TRANSTURTLE_BODY, region, self.final_boss_tube)
         self.__connect_transturtle(ItemNames.TRANSTURTLE_SIMON_SAYS, region, self.simon)
         self.__connect_transturtle(ItemNames.TRANSTURTLE_ARNASSI_RUINS, region, self.arnassi_cave_transturtle)
+        self.__connect_transturtle(ItemNames.TRANSTURTLE_ABYSS, region, self.abyss_r_transturtle)
+        self.__connect_transturtle(ItemNames.TRANSTURTLE_BODY, region, self.final_boss_tube)
 
     def __connect_transturtles(self) -> None:
         """Connect every transturtle with others"""
@@ -836,12 +890,12 @@ class AquariaRegions:
         self._connect_transturtle_to_other(self.openwater_tr_turtle)
         self._connect_transturtle_to_other(self.forest_bl)
         self._connect_transturtle_to_other(self.home_water_transturtle)
-        self._connect_transturtle_to_other(self.abyss_r_transturtle)
-        self._connect_transturtle_to_other(self.final_boss_tube)
         self._connect_transturtle_to_other(self.simon)
         self._connect_transturtle_to_other(self.arnassi_cave_transturtle)
+        self._connect_transturtle_to_other(self.abyss_r_transturtle)
+        self._connect_transturtle_to_other(self.final_boss_tube)
 
-    def connect_regions(self) -> None:
+    def connect_regions(self, options: AquariaOptions) -> None:
         """
         Connect every region (entrances and exits)
         """
@@ -853,6 +907,8 @@ class AquariaRegions:
         self.__connect_abyss_regions()
         self.__connect_sunken_city_regions()
         self.__connect_body_regions()
+        if self.is_four_gods:
+            self.__connect_four_gods_end(options)
         self.__connect_transturtles()
 
     def __add_event_location(self, region: Region, name: str, event_name: str) -> None:
@@ -934,21 +990,25 @@ class AquariaRegions:
                                   AquariaLocationNames.THIRD_SECRET,
                                   ItemNames.THIRD_SECRET_OBTAINED)
 
-    def add_event_locations(self) -> None:
+    def add_event_locations(self, options: AquariaOptions) -> None:
         """
         Add every event (locations and items) to the `world`
         """
         self.__add_event_mini_bosses()
-        self.__add_event_big_bosses()
-        self.__add_event_secrets()
-        self.__add_event_location(self.sunken_city_boss,
-                                  AquariaLocationNames.SUNKEN_CITY_CLEARED,
-                                  ItemNames.BODY_TONGUE_CLEARED)
         self.__add_event_location(self.sun_temple_r,
                                   AquariaLocationNames.SUN_CRYSTAL,
                                   ItemNames.HAS_SUN_CRYSTAL)
-        self.__add_event_location(self.final_boss_end, AquariaLocationNames.OBJECTIVE_COMPLETE,
-                                  ItemNames.VICTORY)
+        self.__add_event_big_bosses()
+        self.__add_event_location(self.sunken_city_boss,
+                                  AquariaLocationNames.SUNKEN_CITY_CLEARED,
+                                  ItemNames.BODY_TONGUE_CLEARED)
+        if self.is_four_gods:
+            self.__add_event_location(self.four_gods_end, AquariaLocationNames.OBJECTIVE_COMPLETE,
+                                      ItemNames.VICTORY)
+        else:
+            self.__add_event_secrets()
+            self.__add_event_location(self.final_boss_end, AquariaLocationNames.OBJECTIVE_COMPLETE,
+                                      ItemNames.VICTORY)
 
     def __adjusting_soup_rules(self) -> None:
         """
@@ -958,16 +1018,16 @@ class AquariaRegions:
                  lambda state: _has_hot_soup(state, self.player))
         add_rule(self.multiworld.get_location(AquariaLocationNames.SUN_TEMPLE_BOSS_PATH_FIRST_CLIFF_BULB, self.player),
                  lambda state: _has_beast_and_soup_form(state, self.player) or
-                               state.has(ItemNames.LUMEREAN_GOD_BEATED, self.player), combine="or")
+                               state.has(ItemNames.LUMEREAN_GOD_BEATED, self.player))
         add_rule(self.multiworld.get_location(AquariaLocationNames.SUN_TEMPLE_BOSS_PATH_SECOND_CLIFF_BULB, self.player),
                  lambda state: _has_beast_and_soup_form(state, self.player) or
-                               state.has(ItemNames.LUMEREAN_GOD_BEATED, self.player), combine="or")
+                               state.has(ItemNames.LUMEREAN_GOD_BEATED, self.player))
         add_rule(
             self.multiworld.get_location(AquariaLocationNames.THE_VEIL_TOP_RIGHT_AREA_BULB_AT_THE_TOP_OF_THE_WATERFALL,
                                          self.player),
             lambda state: _has_beast_and_soup_form(state, self.player))
 
-    def __adjusting_under_rock_location(self) -> None:
+    def __adjusting_under_rock_location(self, options: AquariaOptions) -> None:
         """
         Modify rules implying bind song needed for bulb under rocks
         """
@@ -999,21 +1059,29 @@ class AquariaRegions:
         add_rule(self.multiworld.get_location(
             AquariaLocationNames.THE_VEIL_TOP_LEFT_AREA_BULB_UNDER_THE_ROCK_IN_THE_TOP_RIGHT_PATH,
             self.player), lambda state: _has_bind_song(state, self.player))
-        add_rule(
-            self.multiworld.get_location(AquariaLocationNames.ABYSS_RIGHT_AREA_BULB_BEHIND_THE_ROCK_IN_THE_WHALE_ROOM,
-                                         self.player), lambda state: _has_bind_song(state, self.player))
-        add_rule(self.multiworld.get_location(AquariaLocationNames.ABYSS_RIGHT_AREA_BULB_IN_THE_MIDDLE_PATH,
-                                              self.player), lambda state: _has_bind_song(state, self.player))
         add_rule(self.multiworld.get_location(
             AquariaLocationNames.THE_VEIL_TOP_LEFT_AREA_BULB_UNDER_THE_ROCK_IN_THE_TOP_RIGHT_PATH,
             self.player), lambda state: _has_bind_song(state, self.player))
+        if not self.is_four_gods:
+            add_rule(self.multiworld.get_location(
+                    AquariaLocationNames.ABYSS_RIGHT_AREA_BULB_BEHIND_THE_ROCK_IN_THE_WHALE_ROOM,
+                    self.player), lambda state: _has_bind_song(state, self.player))
+            add_rule(self.multiworld.get_location(AquariaLocationNames.ABYSS_RIGHT_AREA_BULB_IN_THE_MIDDLE_PATH,
+                                                  self.player), lambda state: _has_bind_song(state, self.player))
 
-    def __adjusting_light_in_dark_place_rules(self) -> None:
+    def __adjusting_light_in_dark_place_rules(self, light_option: LightNeededToGetToDarkPlaces) -> None:
+        """
+        Modify rules implying that the player needs a light to go in dark places
+        """
+        if light_option == LightNeededToGetToDarkPlaces.option_sun_form:
+            light_lambda = _has_sun_form
+        else:
+            light_lambda = _has_light
         add_rule(self.multiworld.get_location(AquariaLocationNames.KELP_FOREST_TOP_RIGHT_AREA_BLACK_PEARL, self.player),
-                 lambda state: _has_light(state, self.player))
+                 lambda state: light_lambda(state, self.player))
         add_rule(
             self.multiworld.get_location(AquariaLocationNames.KELP_FOREST_BOTTOM_RIGHT_AREA_ODD_CONTAINER, self.player),
-            lambda state: _has_light(state, self.player))
+            lambda state: light_lambda(state, self.player))
         add_rule(self.multiworld.get_entrance(self.get_entrance_name(self.sun_temple_l_entrance, self.sun_temple_l),
                                               self.player), lambda state: _has_light(state, self.player) or
                                                                           _has_sun_crystal(state, self.player))
@@ -1022,15 +1090,15 @@ class AquariaRegions:
                                                                           _has_sun_crystal(state, self.player))
         add_rule(self.multiworld.get_entrance(self.get_entrance_name(self.abyss_r_transturtle, self.abyss_r),
                                               self.player),
-                 lambda state: _has_light(state, self.player))
+                 lambda state: light_lambda(state, self.player))
         add_rule(self.multiworld.get_entrance(self.get_entrance_name(self.body_c, self.abyss_lb), self.player),
-                 lambda state: _has_light(state, self.player))
+                 lambda state: light_lambda(state, self.player))
         add_rule(self.multiworld.get_entrance(self.get_entrance_name(self.openwater_br, self.abyss_r), self.player),
-                 lambda state: _has_light(state, self.player))
+                 lambda state: light_lambda(state, self.player))
         add_rule(self.multiworld.get_entrance(self.get_entrance_name(self.openwater_bl, self.abyss_l), self.player),
-                 lambda state: _has_light(state, self.player))
+                 lambda state: light_lambda(state, self.player))
 
-    def __adjusting_manual_rules(self) -> None:
+    def __adjusting_manual_rules(self, options: AquariaOptions) -> None:
         add_rule(self.multiworld.get_location(AquariaLocationNames.MITHALAS_CATHEDRAL_MITHALAN_DRESS, self.player),
                  lambda state: _has_beast_form(state, self.player))
         add_rule(self.multiworld.get_location(
@@ -1045,9 +1113,6 @@ class AquariaRegions:
             lambda state: _has_bind_song(state, self.player))
         add_rule(self.multiworld.get_location(AquariaLocationNames.TURTLE_CAVE_TURTLE_EGG, self.player),
                  lambda state: _has_bind_song(state, self.player))
-        add_rule(self.multiworld.get_location(AquariaLocationNames.ABYSS_LEFT_AREA_BULB_IN_THE_BOTTOM_FISH_PASS,
-                                              self.player),
-                 lambda state: _has_fish_form(state, self.player))
         add_rule(self.multiworld.get_location(AquariaLocationNames.SONG_CAVE_ANEMONE_SEED, self.player),
                  lambda state: _has_nature_form(state, self.player))
         add_rule(self.multiworld.get_location(AquariaLocationNames.SONG_CAVE_VERSE_EGG, self.player),
@@ -1076,19 +1141,21 @@ class AquariaRegions:
         ), lambda state: _has_beast_form_or_arnassi_armor(state, self.player))
         add_rule(self.multiworld.get_location(AquariaLocationNames.KELP_FOREST_TOP_LEFT_AREA_JELLY_EGG, self.player),
                  lambda state: _has_beast_form(state, self.player))
-        add_rule(self.multiworld.get_location(AquariaLocationNames.SUN_TEMPLE_BOSS_PATH_FIRST_CLIFF_BULB, self.player),
-                 lambda state: state.has("Sun God beated", self.player))
-        add_rule(self.multiworld.get_location(AquariaLocationNames.SUN_TEMPLE_BOSS_PATH_SECOND_CLIFF_BULB, self.player),
-                 lambda state: state.has("Sun God beated", self.player))
-        add_rule(
-            self.multiworld.get_location(AquariaLocationNames.THE_BODY_CENTER_AREA_BREAKING_LI_S_CAGE, self.player),
-            lambda state: _has_tongue_cleared(state, self.player))
         add_rule(self.multiworld.get_location(
             AquariaLocationNames.OPEN_WATERS_TOP_RIGHT_AREA_BULB_IN_THE_SMALL_PATH_BEFORE_MITHALAS,
             self.player), lambda state: _has_bind_song(state, self.player)
         )
+        add_rule(self.multiworld.get_location(AquariaLocationNames.SITTING_ON_THRONE, self.player),
+                 lambda state: _has_bind_song(state, self.player))
+        if not self.is_four_gods:
+            add_rule(self.multiworld.get_location(AquariaLocationNames.ABYSS_LEFT_AREA_BULB_IN_THE_BOTTOM_FISH_PASS,
+                                                  self.player),
+                     lambda state: _has_fish_form(state, self.player))
+            add_rule(
+                self.multiworld.get_location(AquariaLocationNames.THE_BODY_CENTER_AREA_BREAKING_LI_S_CAGE, self.player),
+                lambda state: _has_tongue_cleared(state, self.player))
 
-    def __no_progression_hard_or_hidden_location(self) -> None:
+    def __no_progression_hard_or_hidden_location(self, options: AquariaOptions) -> None:
         self.multiworld.get_location(AquariaLocationNames.ENERGY_TEMPLE_BOSS_AREA_FALLEN_GOD_TOOTH,
                                      self.player).item_rule = _item_not_advancement
         self.multiworld.get_location(AquariaLocationNames.MITHALAS_BOSS_AREA_BEATING_MITHALAN_GOD,
@@ -1097,8 +1164,6 @@ class AquariaRegions:
                                      self.player).item_rule = _item_not_advancement
         self.multiworld.get_location(AquariaLocationNames.SUN_TEMPLE_BOSS_AREA_BEATING_LUMEREAN_GOD,
                                      self.player).item_rule = _item_not_advancement
-        self.multiworld.get_location(AquariaLocationNames.SUNKEN_CITY_BULB_ON_TOP_OF_THE_BOSS_AREA,
-                                     self.player).item_rule = _item_not_advancement
         self.multiworld.get_location(AquariaLocationNames.HOME_WATERS_NAUTILUS_EGG,
                                      self.player).item_rule = _item_not_advancement
         self.multiworld.get_location(AquariaLocationNames.ENERGY_TEMPLE_BLASTER_ROOM_BLASTER_EGG,
@@ -1109,25 +1174,12 @@ class AquariaRegions:
                                      self.player).item_rule = _item_not_advancement
         self.multiworld.get_location(AquariaLocationNames.OCTOPUS_CAVE_DUMBO_EGG,
                                      self.player).item_rule = _item_not_advancement
-        self.multiworld.get_location(AquariaLocationNames.KING_JELLYFISH_CAVE_BULB_IN_THE_RIGHT_PATH_FROM_KING_JELLY,
-                                     self.player).item_rule = _item_not_advancement
-        self.multiworld.get_location(AquariaLocationNames.KING_JELLYFISH_CAVE_JELLYFISH_COSTUME,
-                                     self.player).item_rule = _item_not_advancement
-        self.multiworld.get_location(AquariaLocationNames.FINAL_BOSS_AREA_BULB_IN_THE_BOSS_THIRD_FORM_ROOM,
-                                     self.player).item_rule = _item_not_advancement
         self.multiworld.get_location(AquariaLocationNames.SUN_TEMPLE_BOSS_PATH_FIRST_CLIFF_BULB,
                                      self.player).item_rule = _item_not_advancement
         self.multiworld.get_location(AquariaLocationNames.SUN_TEMPLE_BOSS_PATH_SECOND_CLIFF_BULB,
                                      self.player).item_rule = _item_not_advancement
         self.multiworld.get_location(AquariaLocationNames.THE_VEIL_TOP_RIGHT_AREA_BULB_AT_THE_TOP_OF_THE_WATERFALL,
                                      self.player).item_rule = _item_not_advancement
-        self.multiworld.get_location(AquariaLocationNames.BUBBLE_CAVE_BULB_IN_THE_LEFT_CAVE_WALL,
-                                     self.player).item_rule = _item_not_advancement
-        self.multiworld.get_location(
-            AquariaLocationNames.BUBBLE_CAVE_BULB_IN_THE_RIGHT_CAVE_WALL_BEHIND_THE_ICE_CRYSTAL,
-            self.player).item_rule = _item_not_advancement
-        self.multiworld.get_location(AquariaLocationNames.BUBBLE_CAVE_VERSE_EGG,
-                                     self.player).item_rule = _item_not_advancement
         self.multiworld.get_location(
             AquariaLocationNames.KELP_FOREST_BOTTOM_LEFT_AREA_BULB_CLOSE_TO_THE_SPIRIT_CRYSTALS,
             self.player).item_rule = _item_not_advancement
@@ -1135,33 +1187,183 @@ class AquariaRegions:
                                      self.player).item_rule = _item_not_advancement
         self.multiworld.get_location(AquariaLocationNames.SUN_TEMPLE_SUN_KEY,
                                      self.player).item_rule = _item_not_advancement
-        self.multiworld.get_location(AquariaLocationNames.THE_BODY_BOTTOM_AREA_MUTANT_COSTUME,
-                                     self.player).item_rule = _item_not_advancement
         self.multiworld.get_location(AquariaLocationNames.SUN_TEMPLE_BULB_IN_THE_HIDDEN_ROOM_OF_THE_RIGHT_PART,
                                      self.player).item_rule = _item_not_advancement
         self.multiworld.get_location(AquariaLocationNames.ARNASSI_RUINS_ARNASSI_ARMOR,
                                      self.player).item_rule = _item_not_advancement
+        if not self.is_four_gods:
+            self.multiworld.get_location(AquariaLocationNames.SUNKEN_CITY_BULB_ON_TOP_OF_THE_BOSS_AREA,
+                                         self.player).item_rule = _item_not_advancement
+            self.multiworld.get_location(AquariaLocationNames.THE_BODY_BOTTOM_AREA_MUTANT_COSTUME,
+                                         self.player).item_rule = _item_not_advancement
+            self.multiworld.get_location(AquariaLocationNames.FINAL_BOSS_AREA_BULB_IN_THE_BOSS_THIRD_FORM_ROOM,
+                                         self.player).item_rule = _item_not_advancement
+            self.multiworld.get_location(
+                AquariaLocationNames.KING_JELLYFISH_CAVE_BULB_IN_THE_RIGHT_PATH_FROM_KING_JELLY,
+                self.player).item_rule = _item_not_advancement
+            self.multiworld.get_location(AquariaLocationNames.KING_JELLYFISH_CAVE_JELLYFISH_COSTUME,
+                                         self.player).item_rule = _item_not_advancement
+            self.multiworld.get_location(AquariaLocationNames.BUBBLE_CAVE_BULB_IN_THE_LEFT_CAVE_WALL,
+                                         self.player).item_rule = _item_not_advancement
+            self.multiworld.get_location(
+                AquariaLocationNames.BUBBLE_CAVE_BULB_IN_THE_RIGHT_CAVE_WALL_BEHIND_THE_ICE_CRYSTAL,
+                self.player).item_rule = _item_not_advancement
+            self.multiworld.get_location(AquariaLocationNames.BUBBLE_CAVE_VERSE_EGG,
+                                         self.player).item_rule = _item_not_advancement
+
+    def __no_progression_area(self, area: dict) -> None:
+        """Be sure to not put any progression items in location of an `area`"""
+        for location in area:
+            self.multiworld.get_location(location, self.player).item_rule = _item_not_advancement
+
+    def __no_progression_kelp_forest(self) -> None:
+        """Be sure to not put any progression items in Kelp forest"""
+        self.__no_progression_area(AquariaLocations.locations_forest_tl)
+        self.__no_progression_area(AquariaLocations.locations_forest_tl_verse_egg_room)
+        self.__no_progression_area(AquariaLocations.locations_forest_tr)
+        self.__no_progression_area(AquariaLocations.locations_forest_tr_fp)
+        self.__no_progression_area(AquariaLocations.locations_forest_bl)
+        self.__no_progression_area(AquariaLocations.locations_forest_bl_sc)
+        self.__no_progression_area(AquariaLocations.locations_forest_br)
+        self.__no_progression_area(AquariaLocations.locations_forest_boss)
+        self.__no_progression_area(AquariaLocations.locations_forest_boss_entrance)
+        self.__no_progression_area(AquariaLocations.locations_forest_fish_cave)
+        self.__no_progression_area(AquariaLocations.locations_sprite_cave)
+        self.__no_progression_area(AquariaLocations.locations_sprite_cave_tube)
+        self.__no_progression_area(AquariaLocations.locations_mermog_cave)
+        self.__no_progression_area(AquariaLocations.locations_mermog_boss)
+
+    def __no_progression_veil(self) -> None:
+        """Be sure to not put any progression items in The Veil"""
+        self.__no_progression_area(AquariaLocations.locations_veil_tl)
+        self.__no_progression_area(AquariaLocations.locations_veil_tl_fp)
+        self.__no_progression_area(AquariaLocations.locations_turtle_cave)
+        self.__no_progression_area(AquariaLocations.locations_turtle_cave_bubble)
+        self.__no_progression_area(AquariaLocations.locations_veil_tr_r)
+        self.__no_progression_area(AquariaLocations.locations_veil_tr_l)
+        self.__no_progression_area(AquariaLocations.locations_veil_b)
+        self.__no_progression_area(AquariaLocations.locations_veil_b_sc)
+        self.__no_progression_area(AquariaLocations.locations_veil_b_fp)
+        self.__no_progression_area(AquariaLocations.locations_veil_br)
+        self.__no_progression_area(AquariaLocations.locations_octo_cave_t)
+        self.__no_progression_area(AquariaLocations.locations_octo_cave_b)
+        self.__no_progression_area(AquariaLocations.locations_sun_temple_l)
+        self.__no_progression_area(AquariaLocations.locations_sun_temple_r)
+        self.__no_progression_area(AquariaLocations.locations_sun_temple_boss_path)
+        self.__no_progression_area(AquariaLocations.locations_sun_temple_boss)
+
+    def __no_progression_mithalas(self) -> None:
+        """Be sure to not put any progression items in Mithalas"""
+        self.__no_progression_area(AquariaLocations.locations_mithalas_city)
+        self.__no_progression_area(AquariaLocations.locations_mithalas_city_urns)
+        self.__no_progression_area(AquariaLocations.locations_mithalas_city_top_path)
+        self.__no_progression_area(AquariaLocations.locations_mithalas_city_fishpass)
+        self.__no_progression_area(AquariaLocations.locations_mithalas_castle)
+        self.__no_progression_area(AquariaLocations.locations_mithalas_castle_urns)
+        self.__no_progression_area(AquariaLocations.locations_mithalas_castle_tube)
+        self.__no_progression_area(AquariaLocations.locations_mithalas_castle_sc)
+        self.__no_progression_area(AquariaLocations.locations_cathedral_top_start)
+        self.__no_progression_area(AquariaLocations.locations_cathedral_top_start_urns)
+        self.__no_progression_area(AquariaLocations.locations_cathedral_top_end)
+        self.__no_progression_area(AquariaLocations.locations_cathedral_underground)
+        self.__no_progression_area(AquariaLocations.locations_cathedral_boss)
+
+    def __no_progression_energy_temple(self) -> None:
+        """Be sure to not put any progression items in the Energy Temple"""
+        self.__no_progression_area(AquariaLocations.locations_energy_temple_1)
+        self.__no_progression_area(AquariaLocations.locations_energy_temple_idol)
+        self.__no_progression_area(AquariaLocations.locations_energy_temple_2)
+        self.__no_progression_area(AquariaLocations.locations_energy_temple_altar)
+        self.__no_progression_area(AquariaLocations.locations_energy_temple_3)
+        self.__no_progression_area(AquariaLocations.locations_energy_temple_boss)
+        self.__no_progression_area(AquariaLocations.locations_energy_temple_blaster_room)
+
+    def __no_progression_arnassi_ruins(self, options: AquariaOptions) -> None:
+        """Be sure to not put any progression items in the Arnassi ruins"""
+        self.__no_progression_area(AquariaLocations.locations_arnassi)
+        self.__no_progression_area(AquariaLocations.locations_arnassi_cave)
+        self.__no_progression_area(AquariaLocations.locations_arnassi_cave_transturtle)
+        self.__no_progression_area(AquariaLocations.locations_arnassi_crab_boss)
+        if options.turtle_randomizer == 0:
+            self.__no_progression_area(AquariaLocations.locations_simon)
+
+    def __no_progression_frozen_veil(self) -> None:
+        """Be sure to not put any progression items in the Frozen Veil"""
+        self.__no_progression_area(AquariaLocations.locations_ice_cave)
+        self.__no_progression_area(AquariaLocations.locations_bubble_cave)
+        self.__no_progression_area(AquariaLocations.locations_bubble_cave_boss)
+
+    def __no_progression_abyss(self) -> None:
+        """Be sure to not put any progression items in the Abyss"""
+        self.__no_progression_area(AquariaLocations.locations_abyss_l)
+        self.__no_progression_area(AquariaLocations.locations_abyss_lb)
+        self.__no_progression_area(AquariaLocations.locations_abyss_r)
+        self.__no_progression_area(AquariaLocations.locations_abyss_r_whale)
+        self.__no_progression_area(AquariaLocations.locations_abyss_r_transturtle)
+        self.__no_progression_area(AquariaLocations.locations_king_jellyfish_cave)
+
+    def __no_progression_sunken_city(self) -> None:
+        """Be sure to not put any progression items in the Sunken City"""
+        self.__no_progression_area(AquariaLocations.locations_sunken_city_r)
+        self.__no_progression_area(AquariaLocations.locations_sunken_city_l)
+        self.__no_progression_area(AquariaLocations.locations_sunken_city_l_bedroom)
+        self.__no_progression_area(AquariaLocations.locations_sunken_city_boss)
+
+    def __no_progression_body(self) -> None:
+        """Be sure to not put any progression items in the Body"""
+        self.__no_progression_area(AquariaLocations.locations_body_c)
+        self.__no_progression_area(AquariaLocations.locations_body_l)
+        self.__no_progression_area(AquariaLocations.locations_body_rt)
+        self.__no_progression_area(AquariaLocations.locations_body_rb)
+        self.__no_progression_area(AquariaLocations.locations_body_b)
+        self.__no_progression_area(AquariaLocations.locations_final_boss_tube)
+        self.__no_progression_area(AquariaLocations.locations_final_boss)
+
+    def __no_progression_areas(self, options: AquariaOptions) -> None:
+        """Manage options that remove progression items from areas around the Aquaria world"""
+        if options.no_progression_simon_says:
+            self.__no_progression_area(AquariaLocations.locations_simon)
+        if options.no_progression_kelp_forest:
+            self.__no_progression_kelp_forest()
+        if options.no_progression_veil:
+            self.__no_progression_veil()
+        if options.no_progression_mithalas:
+            self.__no_progression_mithalas()
+        if options.no_progression_energy_temple:
+            self.__no_progression_energy_temple()
+        if options.no_progression_arnassi_ruins:
+            self.__no_progression_arnassi_ruins(options)
+        if not self.is_four_gods:
+            if options.no_progression_frozen_veil:
+                self.__no_progression_frozen_veil()
+            if options.no_progression_abyss:
+                self.__no_progression_abyss()
+            if options.no_progression_sunken_city:
+                self.__no_progression_sunken_city()
+            if options.no_progression_body:
+                self.__no_progression_body()
 
     def adjusting_rules(self, options: AquariaOptions) -> None:
         """
         Modify rules for single location or optional rules
         """
-        self.__adjusting_manual_rules()
+        self.__adjusting_manual_rules(options)
         self.__adjusting_soup_rules()
-        if options.light_needed_to_get_to_dark_places:
-            self.__adjusting_light_in_dark_place_rules()
+        self.__no_progression_areas(options)
+        if options.light_needed_to_get_to_dark_places != LightNeededToGetToDarkPlaces.option_off:
+            self.__adjusting_light_in_dark_place_rules(options.light_needed_to_get_to_dark_places)
         if options.bind_song_needed_to_get_under_rock_bulb:
-            self.__adjusting_under_rock_location()
-
-        if options.mini_bosses_to_beat.value > 0:
-            add_rule(self.multiworld.get_entrance(self.get_entrance_name(self.final_boss_loby, self.final_boss),
-                                                  self.player), lambda state: _has_mini_bosses(state, self.player))
-        if options.big_bosses_to_beat.value > 0:
-            add_rule(self.multiworld.get_entrance(self.get_entrance_name(self.final_boss_loby, self.final_boss),
-                                                  self.player), lambda state: _has_big_bosses(state, self.player))
-        if options.objective.value == options.objective.option_obtain_secrets_and_kill_the_creator:
-            add_rule(self.multiworld.get_entrance(self.get_entrance_name(self.final_boss_loby, self.final_boss),
-                                                  self.player), lambda state: _has_secrets(state, self.player))
+            self.__adjusting_under_rock_location(options)
+        if not self.is_four_gods:
+            if options.mini_bosses_to_beat.value > 0:
+                add_rule(self.multiworld.get_entrance(self.get_entrance_name(self.final_boss_lobby, self.final_boss),
+                                                      self.player), lambda state: _has_mini_bosses(state, self.player))
+            if options.big_bosses_to_beat.value > 0:
+                add_rule(self.multiworld.get_entrance(self.get_entrance_name(self.final_boss_lobby, self.final_boss),
+                                                      self.player), lambda state: _has_big_bosses(state, self.player))
+            if options.objective.value == options.objective.option_obtain_secrets_and_kill_the_creator:
+                add_rule(self.multiworld.get_entrance(self.get_entrance_name(self.final_boss_lobby, self.final_boss),
+                                                      self.player), lambda state: _has_secrets(state, self.player))
         if (options.unconfine_home_water.value == UnconfineHomeWater.option_via_energy_door or
                 options.unconfine_home_water.value == UnconfineHomeWater.option_off):
             add_rule(self.multiworld.get_entrance(self.get_entrance_name(self.home_water, self.home_water_transturtle),
@@ -1173,7 +1375,7 @@ class AquariaRegions:
                      lambda state: _has_bind_song(state, self.player) and
                                    _has_energy_attack_item(state, self.player))
         if options.no_progression_hard_or_hidden_locations:
-            self.__no_progression_hard_or_hidden_location()
+            self.__no_progression_hard_or_hidden_location(options)
 
     def __add_home_water_regions_to_world(self) -> None:
         """
@@ -1298,12 +1500,12 @@ class AquariaRegions:
         self.multiworld.regions.append(self.body_rt)
         self.multiworld.regions.append(self.body_rb)
         self.multiworld.regions.append(self.body_b)
-        self.multiworld.regions.append(self.final_boss_loby)
+        self.multiworld.regions.append(self.final_boss_lobby)
         self.multiworld.regions.append(self.final_boss_tube)
         self.multiworld.regions.append(self.final_boss)
         self.multiworld.regions.append(self.final_boss_end)
 
-    def add_regions_to_world(self) -> None:
+    def add_regions_to_world(self, options: AquariaOptions) -> None:
         """
         Add every region to the `world`
         """
@@ -1314,13 +1516,17 @@ class AquariaRegions:
         self.__add_veil_regions_to_world()
         self.__add_abyss_regions_to_world()
         self.__add_body_regions_to_world()
+        if self.is_four_gods:
+            self.multiworld.regions.append(self.four_gods_end)
 
-    def __init__(self, multiworld: MultiWorld, player: int):
+    def __init__(self, multiworld: MultiWorld, player: int, options: AquariaOptions):
         """
         Initialisation of the regions
         """
         self.multiworld = multiworld
         self.player = player
+        self.is_four_gods = (options.objective.value == Objective.option_killing_the_four_gods or
+            options.objective.value == Objective.option_gods_and_creator)
         self.__create_home_water_area()
         self.__create_energy_temple()
         self.__create_openwater()
@@ -1328,6 +1534,8 @@ class AquariaRegions:
         self.__create_forest()
         self.__create_veil()
         self.__create_sun_temple()
-        self.__create_abyss()
-        self.__create_sunken_city()
-        self.__create_body()
+        self.__create_abyss(not self.is_four_gods)
+        self.__create_sunken_city(not self.is_four_gods)
+        self.__create_body(not self.is_four_gods)
+        if self.is_four_gods:
+            self.four_gods_end = self.__add_region("Four gods ending", None)

worlds/aquaria/__init__.py

@@ -7,12 +7,14 @@ Description: Main module for Aquaria game multiworld randomizer
 from typing import List, Dict, ClassVar, Any
 from worlds.AutoWorld import World, WebWorld
 from BaseClasses import Tutorial, MultiWorld, ItemClassification
-from .Items import item_table, AquariaItem, ItemType, ItemGroup, ItemNames
+from .Items import item_table, AquariaItem, ItemType, ItemGroup, ItemNames, four_gods_excludes
 from .Locations import location_table, AquariaLocationNames
 from .Options import (AquariaOptions, IngredientRandomizer, TurtleRandomizer, EarlyBindSong, EarlyEnergyForm,
                       UnconfineHomeWater, Objective)
 from .Regions import AquariaRegions
 
+CLIENT_MINIMAL_COMPATIBILITY = [1, 4, 1]
+
 
 class AquariaWeb(WebWorld):
     """
@@ -98,6 +100,7 @@ class AquariaWorld(World):
     "Used to manage Regions"
 
     exclude: List[str]
+    "The items that should not be added to the multiworld item pool"
 
     def __init__(self, multiworld: MultiWorld, player: int):
         """Initialisation of the Aquaria World"""
@@ -111,15 +114,15 @@ class AquariaWorld(World):
         Run before any general steps of the MultiWorld other than options. Useful for getting and adjusting option
         results and determining layouts for entrance rando etc. start inventory gets pushed after this step.
         """
-        self.regions = AquariaRegions(self.multiworld, self.player)
+        self.regions = AquariaRegions(self.multiworld, self.player, self.options)
 
     def create_regions(self) -> None:
         """
         Create every Region in `regions`
         """
-        self.regions.add_regions_to_world()
-        self.regions.connect_regions()
-        self.regions.add_event_locations()
+        self.regions.add_regions_to_world(self.options)
+        self.regions.connect_regions(self.options)
+        self.regions.add_event_locations(self.options)
 
     def create_item(self, name: str) -> AquariaItem:
         """
@@ -157,8 +160,17 @@ class AquariaWorld(World):
     def create_items(self) -> None:
         """Create every item in the world"""
         precollected = [item.name for item in self.multiworld.precollected_items[self.player]]
+        if (self.options.objective.value == Objective.option_killing_the_four_gods or
+                self.options.objective.value == Objective.option_gods_and_creator):
+            self.exclude.extend(four_gods_excludes)
+            self.__pre_fill_item(ItemNames.TRANSTURTLE_ABYSS, AquariaLocationNames.ABYSS_RIGHT_AREA_TRANSTURTLE,
+                                 precollected)
+            self.__pre_fill_item(ItemNames.TRANSTURTLE_BODY, AquariaLocationNames.FINAL_BOSS_AREA_TRANSTURTLE,
+                                 precollected)
         if self.options.turtle_randomizer.value != TurtleRandomizer.option_none:
-            if self.options.turtle_randomizer.value == TurtleRandomizer.option_all_except_final:
+            if (self.options.turtle_randomizer.value == TurtleRandomizer.option_all_except_final and
+                    self.options.objective.value != Objective.option_killing_the_four_gods and
+                    self.options.objective.value != Objective.option_gods_and_creator):
                 self.__pre_fill_item(ItemNames.TRANSTURTLE_BODY, AquariaLocationNames.FINAL_BOSS_AREA_TRANSTURTLE,
                                      precollected)
         else:
@@ -167,25 +179,29 @@ class AquariaWorld(World):
             self.__pre_fill_item(ItemNames.TRANSTURTLE_VEIL_TOP_RIGHT,
                                  AquariaLocationNames.THE_VEIL_TOP_RIGHT_AREA_TRANSTURTLE, precollected)
             self.__pre_fill_item(ItemNames.TRANSTURTLE_OPEN_WATERS,
-                                 AquariaLocationNames.OPEN_WATERS_TOP_RIGHT_AREA_TRANSTURTLE,
-                                 precollected)
+                                 AquariaLocationNames.OPEN_WATERS_TOP_RIGHT_AREA_TRANSTURTLE, precollected)
             self.__pre_fill_item(ItemNames.TRANSTURTLE_KELP_FOREST,
-                                 AquariaLocationNames.KELP_FOREST_BOTTOM_LEFT_AREA_TRANSTURTLE,
-                                 precollected)
-            self.__pre_fill_item(ItemNames.TRANSTURTLE_HOME_WATERS, AquariaLocationNames.HOME_WATERS_TRANSTURTLE,
-                                 precollected)
-            self.__pre_fill_item(ItemNames.TRANSTURTLE_ABYSS, AquariaLocationNames.ABYSS_RIGHT_AREA_TRANSTURTLE,
-                                 precollected)
-            self.__pre_fill_item(ItemNames.TRANSTURTLE_BODY, AquariaLocationNames.FINAL_BOSS_AREA_TRANSTURTLE,
-                                 precollected)
+                                 AquariaLocationNames.KELP_FOREST_BOTTOM_LEFT_AREA_TRANSTURTLE, precollected)
+            self.__pre_fill_item(ItemNames.TRANSTURTLE_HOME_WATERS, AquariaLocationNames.HOME_WATERS_TRANSTURTLE, precollected)
+            if (self.options.objective.value != Objective.option_killing_the_four_gods and
+                    self.options.objective.value != Objective.option_gods_and_creator):
+                self.__pre_fill_item(ItemNames.TRANSTURTLE_ABYSS, AquariaLocationNames.ABYSS_RIGHT_AREA_TRANSTURTLE,
+                                     precollected)
+                self.__pre_fill_item(ItemNames.TRANSTURTLE_BODY, AquariaLocationNames.FINAL_BOSS_AREA_TRANSTURTLE,
+                                     precollected)
             # The last two are inverted because in the original game, they are special turtle that communicate directly
             self.__pre_fill_item(ItemNames.TRANSTURTLE_SIMON_SAYS, AquariaLocationNames.ARNASSI_RUINS_TRANSTURTLE,
                                  precollected, ItemClassification.progression)
             self.__pre_fill_item(ItemNames.TRANSTURTLE_ARNASSI_RUINS, AquariaLocationNames.SIMON_SAYS_AREA_TRANSTURTLE,
                                  precollected)
+        if not self.options.throne_as_location:
+            self.__pre_fill_item(ItemNames.DOOR_TO_CATHEDRAL, AquariaLocationNames.SITTING_ON_THRONE,
+                                 precollected, ItemClassification.progression)
         for name, data in item_table.items():
-            if name not in self.exclude:
-                for i in range(data.count):
+            for i in range(data.count):
+                if name in self.exclude:
+                    self.exclude.remove(name)
+                else:
                     item = self.create_item(name)
                     self.multiworld.itempool.append(item)
 
@@ -227,22 +243,41 @@ class AquariaWorld(World):
         self.ingredients_substitution.extend(dishes_substitution)
 
     def fill_slot_data(self) -> Dict[str, Any]:
+        """
+        Send some useful information to the client.
+        """
         return {"ingredientReplacement": self.ingredients_substitution,
                 "aquarian_translate": bool(self.options.aquarian_translation.value),
                 "blind_goal": bool(self.options.blind_goal.value),
-                "secret_needed":
-                    self.options.objective.value == Objective.option_obtain_secrets_and_kill_the_creator,
+                "goal": self.options.objective.value,
                 "minibosses_to_kill": self.options.mini_bosses_to_beat.value,
                 "bigbosses_to_kill": self.options.big_bosses_to_beat.value,
                 "skip_first_vision": bool(self.options.skip_first_vision.value),
+                "skip_final_boss_3rd_form": bool(self.options.skip_final_boss_3rd_form.value),
+                "infinite_hot_soup": bool(self.options.infinite_hot_soup.value),
+                "open_body_tongue": bool(self.options.open_body_tongue.value),
                 "unconfine_home_water_energy_door":
                     self.options.unconfine_home_water.value == UnconfineHomeWater.option_via_energy_door
                     or self.options.unconfine_home_water.value == UnconfineHomeWater.option_via_both,
                 "unconfine_home_water_transturtle":
                     self.options.unconfine_home_water.value == UnconfineHomeWater.option_via_transturtle
                     or self.options.unconfine_home_water.value == UnconfineHomeWater.option_via_both,
+                "maximum_ingredient_amount": self.options.maximum_ingredient_amount.value,
                 "bind_song_needed_to_get_under_rock_bulb": bool(self.options.bind_song_needed_to_get_under_rock_bulb),
                 "no_progression_hard_or_hidden_locations": bool(self.options.no_progression_hard_or_hidden_locations),
                 "light_needed_to_get_to_dark_places": bool(self.options.light_needed_to_get_to_dark_places),
-                "turtle_randomizer": self.options.turtle_randomizer.value
+                "turtle_randomizer": self.options.turtle_randomizer.value,
+                "no_progression_simon_says": bool(self.options.no_progression_simon_says),
+                "no_progression_kelp_forest": bool(self.options.no_progression_kelp_forest),
+                "no_progression_veil": bool(self.options.no_progression_veil),
+                "no_progression_mithalas": bool(self.options.no_progression_mithalas),
+                "no_progression_energy_temple": bool(self.options.no_progression_energy_temple),
+                "no_progression_arnassi_ruins": bool(self.options.no_progression_arnassi_ruins),
+                "no_progression_frozen_veil": bool(self.options.no_progression_frozen_veil),
+                "no_progression_abyss": bool(self.options.no_progression_abyss),
+                "no_progression_sunken_city": bool(self.options.no_progression_sunken_city),
+                "no_progression_body": bool(self.options.no_progression_body),
+                "save_healing": bool(self.options.save_healing),
+                "throne_as_location": bool(self.options.throne_as_location),
+                "required_client_version": CLIENT_MINIMAL_COMPATIBILITY,
                 }

worlds/aquaria/test/test_access_four_gods.py

@@ -0,0 +1,185 @@
+"""
+Author: Louis M
+Date: Thu, 18 Apr 2024 18:45:56 +0000
+Description: Unit test used to test accessibility of locations with the goal four gods
+"""
+
+from . import AquariaTestBase
+from ..Items import ItemNames
+from ..Locations import AquariaLocationNames
+from ..Options import UnconfineHomeWater, Objective, BindSongNeededToGetUnderRockBulb
+
+
+class FourGodsAccessTest(AquariaTestBase):
+    """Unit test used to test accessibility of locations with the goal four gods"""
+    options = {
+        "objective": Objective.option_killing_the_four_gods,
+        "bind_song_needed_to_get_under_rock_bulb": BindSongNeededToGetUnderRockBulb.option_true
+    }
+
+
+    def test_locations(self) -> None:
+        """Test locations with the goal four gods"""
+        locations = [
+            AquariaLocationNames.VERSE_CAVE_RIGHT_AREA_BIG_SEED,
+            AquariaLocationNames.VERSE_CAVE_LEFT_AREA_BULB_UNDER_THE_ROCK_AT_THE_END_OF_THE_PATH,
+            AquariaLocationNames.HOME_WATERS_BULB_UNDER_THE_ROCK_IN_THE_LEFT_PATH_FROM_THE_VERSE_CAVE,
+            AquariaLocationNames.HOME_WATERS_BULB_IN_THE_PATH_BELOW_NAUTILUS_PRIME,
+            AquariaLocationNames.HOME_WATERS_BULB_IN_THE_BOTTOM_LEFT_ROOM,
+            AquariaLocationNames.HOME_WATERS_NAUTILUS_EGG,
+            AquariaLocationNames.HOME_WATERS_TRANSTURTLE,
+            AquariaLocationNames.NAIJA_S_HOME_BULB_AFTER_THE_ENERGY_DOOR,
+            AquariaLocationNames.NAIJA_S_HOME_BULB_UNDER_THE_ROCK_AT_THE_RIGHT_OF_THE_MAIN_PATH,
+            AquariaLocationNames.SONG_CAVE_BULB_UNDER_THE_ROCK_IN_THE_PATH_TO_THE_SINGING_STATUES,
+            AquariaLocationNames.SONG_CAVE_BULB_UNDER_THE_ROCK_CLOSE_TO_THE_SONG_DOOR,
+            AquariaLocationNames.SONG_CAVE_VERSE_EGG,
+            AquariaLocationNames.SONG_CAVE_ANEMONE_SEED,
+            AquariaLocationNames.ENERGY_TEMPLE_FIRST_AREA_BEATING_THE_ENERGY_STATUE,
+            AquariaLocationNames.ENERGY_TEMPLE_FIRST_AREA_BULB_IN_THE_BOTTOM_ROOM_BLOCKED_BY_A_ROCK,
+            AquariaLocationNames.ENERGY_TEMPLE_ENERGY_IDOL,
+            AquariaLocationNames.ENERGY_TEMPLE_SECOND_AREA_BULB_UNDER_THE_ROCK,
+            AquariaLocationNames.ENERGY_TEMPLE_BOTTOM_ENTRANCE_KROTITE_ARMOR,
+            AquariaLocationNames.ENERGY_TEMPLE_THIRD_AREA_BULB_IN_THE_BOTTOM_PATH,
+            AquariaLocationNames.ENERGY_TEMPLE_BOSS_AREA_FALLEN_GOD_TOOTH,
+            AquariaLocationNames.ENERGY_TEMPLE_BLASTER_ROOM_BLASTER_EGG,
+            AquariaLocationNames.OPEN_WATERS_TOP_LEFT_AREA_BULB_UNDER_THE_ROCK_IN_THE_RIGHT_PATH,
+            AquariaLocationNames.OPEN_WATERS_TOP_LEFT_AREA_BULB_UNDER_THE_ROCK_IN_THE_LEFT_PATH,
+            AquariaLocationNames.OPEN_WATERS_TOP_LEFT_AREA_BULB_TO_THE_RIGHT_OF_THE_SAVE_CRYSTAL,
+            AquariaLocationNames.OPEN_WATERS_TOP_RIGHT_AREA_BULB_IN_THE_SMALL_PATH_BEFORE_MITHALAS,
+            AquariaLocationNames.OPEN_WATERS_TOP_RIGHT_AREA_BULB_IN_THE_PATH_FROM_THE_LEFT_ENTRANCE,
+            AquariaLocationNames.OPEN_WATERS_TOP_RIGHT_AREA_BULB_IN_THE_CLEARING_CLOSE_TO_THE_BOTTOM_EXIT,
+            AquariaLocationNames.OPEN_WATERS_TOP_RIGHT_AREA_BULB_IN_THE_BIG_CLEARING_CLOSE_TO_THE_SAVE_CRYSTAL,
+            AquariaLocationNames.OPEN_WATERS_TOP_RIGHT_AREA_BULB_IN_THE_BIG_CLEARING_TO_THE_TOP_EXIT,
+            AquariaLocationNames.OPEN_WATERS_TOP_RIGHT_AREA_BULB_IN_THE_TURTLE_ROOM,
+            AquariaLocationNames.OPEN_WATERS_TOP_RIGHT_AREA_TRANSTURTLE,
+            AquariaLocationNames.OPEN_WATERS_TOP_RIGHT_AREA_FIRST_URN_IN_THE_MITHALAS_EXIT,
+            AquariaLocationNames.OPEN_WATERS_TOP_RIGHT_AREA_SECOND_URN_IN_THE_MITHALAS_EXIT,
+            AquariaLocationNames.OPEN_WATERS_TOP_RIGHT_AREA_THIRD_URN_IN_THE_MITHALAS_EXIT,
+            AquariaLocationNames.OPEN_WATERS_BOTTOM_LEFT_AREA_BULB_BEHIND_THE_CHOMPER_FISH,
+            AquariaLocationNames.OPEN_WATERS_BOTTOM_LEFT_AREA_BULB_INSIDE_THE_LOWEST_FISH_PASS,
+            AquariaLocationNames.OPEN_WATERS_SKELETON_PATH_BULB_CLOSE_TO_THE_RIGHT_EXIT,
+            AquariaLocationNames.OPEN_WATERS_SKELETON_PATH_BULB_BEHIND_THE_CHOMPER_FISH,
+            AquariaLocationNames.OPEN_WATERS_SKELETON_PATH_KING_SKULL,
+            AquariaLocationNames.ARNASSI_RUINS_BULB_IN_THE_RIGHT_PART,
+            AquariaLocationNames.ARNASSI_RUINS_BULB_IN_THE_LEFT_PART,
+            AquariaLocationNames.ARNASSI_RUINS_BULB_IN_THE_CENTER_PART,
+            AquariaLocationNames.ARNASSI_RUINS_SONG_PLANT_SPORE,
+            AquariaLocationNames.ARNASSI_RUINS_ARNASSI_ARMOR,
+            AquariaLocationNames.ARNASSI_RUINS_ARNASSI_STATUE,
+            AquariaLocationNames.ARNASSI_RUINS_TRANSTURTLE,
+            AquariaLocationNames.ARNASSI_RUINS_CRAB_ARMOR,
+            AquariaLocationNames.SIMON_SAYS_AREA_BEATING_SIMON_SAYS,
+            AquariaLocationNames.SIMON_SAYS_AREA_TRANSTURTLE,
+            AquariaLocationNames.MITHALAS_CITY_FIRST_BULB_IN_THE_LEFT_CITY_PART,
+            AquariaLocationNames.MITHALAS_CITY_SECOND_BULB_IN_THE_LEFT_CITY_PART,
+            AquariaLocationNames.MITHALAS_CITY_BULB_IN_THE_RIGHT_PART,
+            AquariaLocationNames.MITHALAS_CITY_BULB_AT_THE_TOP_OF_THE_CITY,
+            AquariaLocationNames.MITHALAS_CITY_FIRST_BULB_IN_A_BROKEN_HOME,
+            AquariaLocationNames.MITHALAS_CITY_SECOND_BULB_IN_A_BROKEN_HOME,
+            AquariaLocationNames.MITHALAS_CITY_BULB_IN_THE_BOTTOM_LEFT_PART,
+            AquariaLocationNames.MITHALAS_CITY_FIRST_BULB_IN_ONE_OF_THE_HOMES,
+            AquariaLocationNames.MITHALAS_CITY_SECOND_BULB_IN_ONE_OF_THE_HOMES,
+            AquariaLocationNames.MITHALAS_CITY_FIRST_URN_IN_ONE_OF_THE_HOMES,
+            AquariaLocationNames.MITHALAS_CITY_SECOND_URN_IN_ONE_OF_THE_HOMES,
+            AquariaLocationNames.MITHALAS_CITY_FIRST_URN_IN_THE_CITY_RESERVE,
+            AquariaLocationNames.MITHALAS_CITY_SECOND_URN_IN_THE_CITY_RESERVE,
+            AquariaLocationNames.MITHALAS_CITY_THIRD_URN_IN_THE_CITY_RESERVE,
+            AquariaLocationNames.MITHALAS_CITY_FIRST_BULB_AT_THE_END_OF_THE_TOP_PATH,
+            AquariaLocationNames.MITHALAS_CITY_SECOND_BULB_AT_THE_END_OF_THE_TOP_PATH,
+            AquariaLocationNames.MITHALAS_CITY_BULB_IN_THE_TOP_PATH,
+            AquariaLocationNames.MITHALAS_CITY_MITHALAS_POT,
+            AquariaLocationNames.MITHALAS_CITY_URN_IN_THE_CASTLE_FLOWER_TUBE_ENTRANCE,
+            AquariaLocationNames.MITHALAS_CITY_DOLL,
+            AquariaLocationNames.MITHALAS_CITY_URN_INSIDE_A_HOME_FISH_PASS,
+            AquariaLocationNames.MITHALAS_CITY_CASTLE_BULB_IN_THE_FLESH_HOLE,
+            AquariaLocationNames.MITHALAS_CITY_CASTLE_BLUE_BANNER,
+            AquariaLocationNames.MITHALAS_CITY_CASTLE_URN_IN_THE_BEDROOM,
+            AquariaLocationNames.MITHALAS_CITY_CASTLE_FIRST_URN_OF_THE_SINGLE_LAMP_PATH,
+            AquariaLocationNames.MITHALAS_CITY_CASTLE_SECOND_URN_OF_THE_SINGLE_LAMP_PATH,
+            AquariaLocationNames.MITHALAS_CITY_CASTLE_URN_IN_THE_BOTTOM_ROOM,
+            AquariaLocationNames.MITHALAS_CITY_CASTLE_FIRST_URN_ON_THE_ENTRANCE_PATH,
+            AquariaLocationNames.MITHALAS_CITY_CASTLE_SECOND_URN_ON_THE_ENTRANCE_PATH,
+            AquariaLocationNames.MITHALAS_CITY_CASTLE_BEATING_THE_PRIESTS,
+            AquariaLocationNames.MITHALAS_CITY_CASTLE_TRIDENT_HEAD,
+            AquariaLocationNames.MITHALAS_CATHEDRAL_BULB_IN_THE_FLESH_ROOM_WITH_FLEAS,
+            AquariaLocationNames.MITHALAS_CATHEDRAL_MITHALAN_DRESS,
+            AquariaLocationNames.MITHALAS_CATHEDRAL_FIRST_URN_IN_THE_TOP_RIGHT_ROOM,
+            AquariaLocationNames.MITHALAS_CATHEDRAL_SECOND_URN_IN_THE_TOP_RIGHT_ROOM,
+            AquariaLocationNames.MITHALAS_CATHEDRAL_THIRD_URN_IN_THE_TOP_RIGHT_ROOM,
+            AquariaLocationNames.MITHALAS_CATHEDRAL_URN_BEHIND_THE_FLESH_VEIN,
+            AquariaLocationNames.MITHALAS_CATHEDRAL_URN_IN_THE_TOP_LEFT_EYES_BOSS_ROOM,
+            AquariaLocationNames.MITHALAS_CATHEDRAL_FIRST_URN_IN_THE_PATH_BEHIND_THE_FLESH_VEIN,
+            AquariaLocationNames.MITHALAS_CATHEDRAL_SECOND_URN_IN_THE_PATH_BEHIND_THE_FLESH_VEIN,
+            AquariaLocationNames.MITHALAS_CATHEDRAL_THIRD_URN_IN_THE_PATH_BEHIND_THE_FLESH_VEIN,
+            AquariaLocationNames.MITHALAS_CATHEDRAL_FOURTH_URN_IN_THE_TOP_RIGHT_ROOM,
+            AquariaLocationNames.MITHALAS_CATHEDRAL_URN_BELOW_THE_LEFT_ENTRANCE,
+            AquariaLocationNames.MITHALAS_CATHEDRAL_FIRST_URN_IN_THE_BOTTOM_RIGHT_PATH,
+            AquariaLocationNames.MITHALAS_CATHEDRAL_SECOND_URN_IN_THE_BOTTOM_RIGHT_PATH,
+            AquariaLocationNames.CATHEDRAL_UNDERGROUND_BULB_IN_THE_CENTER_PART,
+            AquariaLocationNames.CATHEDRAL_UNDERGROUND_FIRST_BULB_IN_THE_TOP_LEFT_PART,
+            AquariaLocationNames.CATHEDRAL_UNDERGROUND_SECOND_BULB_IN_THE_TOP_LEFT_PART,
+            AquariaLocationNames.CATHEDRAL_UNDERGROUND_THIRD_BULB_IN_THE_TOP_LEFT_PART,
+            AquariaLocationNames.CATHEDRAL_UNDERGROUND_BULB_CLOSE_TO_THE_SAVE_CRYSTAL,
+            AquariaLocationNames.CATHEDRAL_UNDERGROUND_BULB_IN_THE_BOTTOM_RIGHT_PATH,
+            AquariaLocationNames.MITHALAS_BOSS_AREA_BEATING_MITHALAN_GOD,
+            AquariaLocationNames.KELP_FOREST_TOP_LEFT_AREA_BULB_IN_THE_BOTTOM_LEFT_CLEARING,
+            AquariaLocationNames.KELP_FOREST_TOP_LEFT_AREA_BULB_IN_THE_PATH_DOWN_FROM_THE_TOP_LEFT_CLEARING,
+            AquariaLocationNames.KELP_FOREST_TOP_LEFT_AREA_BULB_IN_THE_TOP_LEFT_CLEARING,
+            AquariaLocationNames.KELP_FOREST_TOP_LEFT_AREA_JELLY_EGG,
+            AquariaLocationNames.KELP_FOREST_TOP_LEFT_AREA_BULB_CLOSE_TO_THE_VERSE_EGG,
+            AquariaLocationNames.KELP_FOREST_TOP_LEFT_AREA_VERSE_EGG,
+            AquariaLocationNames.KELP_FOREST_TOP_RIGHT_AREA_BULB_UNDER_THE_ROCK_IN_THE_RIGHT_PATH,
+            AquariaLocationNames.KELP_FOREST_TOP_RIGHT_AREA_BULB_AT_THE_LEFT_OF_THE_CENTER_CLEARING,
+            AquariaLocationNames.KELP_FOREST_TOP_RIGHT_AREA_BULB_IN_THE_LEFT_PATH_S_BIG_ROOM,
+            AquariaLocationNames.KELP_FOREST_TOP_RIGHT_AREA_BULB_IN_THE_LEFT_PATH_S_SMALL_ROOM,
+            AquariaLocationNames.KELP_FOREST_TOP_RIGHT_AREA_BULB_AT_THE_TOP_OF_THE_CENTER_CLEARING,
+            AquariaLocationNames.KELP_FOREST_TOP_RIGHT_AREA_BLACK_PEARL,
+            AquariaLocationNames.KELP_FOREST_TOP_RIGHT_AREA_BULB_IN_THE_TOP_FISH_PASS,
+            AquariaLocationNames.KELP_FOREST_BOTTOM_LEFT_AREA_TRANSTURTLE,
+            AquariaLocationNames.KELP_FOREST_BOTTOM_LEFT_AREA_BULB_CLOSE_TO_THE_SPIRIT_CRYSTALS,
+            AquariaLocationNames.KELP_FOREST_BOTTOM_LEFT_AREA_WALKER_BABY,
+            AquariaLocationNames.KELP_FOREST_BOTTOM_LEFT_AREA_FISH_CAVE_PUZZLE,
+            AquariaLocationNames.KELP_FOREST_BOTTOM_RIGHT_AREA_ODD_CONTAINER,
+            AquariaLocationNames.KELP_FOREST_BOSS_AREA_BEATING_DRUNIAN_GOD,
+            AquariaLocationNames.KELP_FOREST_BOSS_ROOM_BULB_AT_THE_BOTTOM_OF_THE_AREA,
+            AquariaLocationNames.KELP_FOREST_SPRITE_CAVE_BULB_INSIDE_THE_FISH_PASS,
+            AquariaLocationNames.KELP_FOREST_SPRITE_CAVE_BULB_IN_THE_SECOND_ROOM,
+            AquariaLocationNames.KELP_FOREST_SPRITE_CAVE_SEED_BAG,
+            AquariaLocationNames.MERMOG_CAVE_BULB_IN_THE_LEFT_PART_OF_THE_CAVE,
+            AquariaLocationNames.MERMOG_CAVE_PIRANHA_EGG,
+            AquariaLocationNames.THE_VEIL_TOP_LEFT_AREA_IN_LI_S_CAVE,
+            AquariaLocationNames.THE_VEIL_TOP_LEFT_AREA_BULB_UNDER_THE_ROCK_IN_THE_TOP_RIGHT_PATH,
+            AquariaLocationNames.THE_VEIL_TOP_LEFT_AREA_BULB_HIDDEN_BEHIND_THE_BLOCKING_ROCK,
+            AquariaLocationNames.THE_VEIL_TOP_LEFT_AREA_TRANSTURTLE,
+            AquariaLocationNames.THE_VEIL_TOP_LEFT_AREA_BULB_INSIDE_THE_FISH_PASS,
+            AquariaLocationNames.TURTLE_CAVE_TURTLE_EGG,
+            AquariaLocationNames.TURTLE_CAVE_BULB_IN_BUBBLE_CLIFF,
+            AquariaLocationNames.TURTLE_CAVE_URCHIN_COSTUME,
+            AquariaLocationNames.THE_VEIL_TOP_RIGHT_AREA_BULB_IN_THE_MIDDLE_OF_THE_WALL_JUMP_CLIFF,
+            AquariaLocationNames.THE_VEIL_TOP_RIGHT_AREA_GOLDEN_STARFISH,
+            AquariaLocationNames.THE_VEIL_TOP_RIGHT_AREA_BULB_AT_THE_TOP_OF_THE_WATERFALL,
+            AquariaLocationNames.THE_VEIL_TOP_RIGHT_AREA_TRANSTURTLE,
+            AquariaLocationNames.THE_VEIL_BOTTOM_AREA_BULB_IN_THE_LEFT_PATH,
+            AquariaLocationNames.THE_VEIL_BOTTOM_AREA_BULB_IN_THE_SPIRIT_PATH,
+            AquariaLocationNames.THE_VEIL_BOTTOM_AREA_VERSE_EGG,
+            AquariaLocationNames.THE_VEIL_BOTTOM_AREA_STONE_HEAD,
+            AquariaLocationNames.OCTOPUS_CAVE_DUMBO_EGG,
+            AquariaLocationNames.OCTOPUS_CAVE_BULB_IN_THE_PATH_BELOW_THE_OCTOPUS_CAVE_PATH,
+            AquariaLocationNames.SUN_TEMPLE_BULB_IN_THE_TOP_LEFT_PART,
+            AquariaLocationNames.SUN_TEMPLE_BULB_IN_THE_TOP_RIGHT_PART,
+            AquariaLocationNames.SUN_TEMPLE_BULB_AT_THE_TOP_OF_THE_HIGH_DARK_ROOM,
+            AquariaLocationNames.SUN_TEMPLE_GOLDEN_GEAR,
+            AquariaLocationNames.SUN_TEMPLE_FIRST_BULB_OF_THE_TEMPLE,
+            AquariaLocationNames.SUN_TEMPLE_BULB_ON_THE_RIGHT_PART,
+            AquariaLocationNames.SUN_TEMPLE_BULB_IN_THE_HIDDEN_ROOM_OF_THE_RIGHT_PART,
+            AquariaLocationNames.SUN_TEMPLE_SUN_KEY,
+            AquariaLocationNames.SUN_TEMPLE_BOSS_PATH_FIRST_PATH_BULB,
+            AquariaLocationNames.SUN_TEMPLE_BOSS_PATH_SECOND_PATH_BULB,
+            AquariaLocationNames.SUN_TEMPLE_BOSS_PATH_FIRST_CLIFF_BULB,
+            AquariaLocationNames.SUN_TEMPLE_BOSS_PATH_SECOND_CLIFF_BULB,
+            AquariaLocationNames.SUN_TEMPLE_BOSS_AREA_BEATING_LUMEREAN_GOD,
+        ]
+        items = [[ItemNames.ENERGY_FORM, ItemNames.SUN_FORM, ItemNames.BEAST_FORM, ItemNames.SPIRIT_FORM,
+                  ItemNames.FISH_FORM, ItemNames.HOT_SOUP, ItemNames.BIND_SONG, ItemNames.NATURE_FORM,
+                  ItemNames.DUAL_FORM]]
+        self.assertAccessDependency(locations, items, True)

worlds/aquaria/test/test_beast_or_soup_access.py

@@ -0,0 +1,35 @@
+"""
+Author: Louis M
+Date: Thu, 18 Apr 2024 18:45:56 +0000
+Description: Unit test used to test accessibility of locations with and without the beast form or hot soup
+"""
+
+from . import AquariaTestBase
+from ..Locations import AquariaLocationNames
+from ..Items import ItemNames
+
+
+class BeastOrSoupAccessTest(AquariaTestBase):
+    """Unit test used to test accessibility of locations with and without the beast form or hot soup"""
+
+    def test_beast_or_soup_location(self) -> None:
+        """Test locations that require beast form or hot soup"""
+        locations = [
+            AquariaLocationNames.MERMOG_CAVE_PIRANHA_EGG,
+            AquariaLocationNames.MITHALAS_CATHEDRAL_MITHALAN_DRESS,
+            AquariaLocationNames.KELP_FOREST_TOP_LEFT_AREA_JELLY_EGG,
+            AquariaLocationNames.TURTLE_CAVE_URCHIN_COSTUME,
+            AquariaLocationNames.THE_VEIL_TOP_RIGHT_AREA_BULB_AT_THE_TOP_OF_THE_WATERFALL,
+            AquariaLocationNames.SUNKEN_CITY_BULB_ON_TOP_OF_THE_BOSS_AREA,
+            AquariaLocationNames.OCTOPUS_CAVE_DUMBO_EGG,
+            AquariaLocationNames.BUBBLE_CAVE_BULB_IN_THE_LEFT_CAVE_WALL,
+            AquariaLocationNames.BUBBLE_CAVE_BULB_IN_THE_RIGHT_CAVE_WALL_BEHIND_THE_ICE_CRYSTAL,
+            AquariaLocationNames.BUBBLE_CAVE_VERSE_EGG,
+            AquariaLocationNames.BEATING_MANTIS_SHRIMP_PRIME,
+            AquariaLocationNames.BEATING_THE_GOLEM,
+            AquariaLocationNames.BEATING_MERGOG,
+            AquariaLocationNames.BEATING_OCTOPUS_PRIME,
+            AquariaLocationNames.SUNKEN_CITY_CLEARED
+        ]
+        items = [[ItemNames.BEAST_FORM, ItemNames.HOT_SOUP, ItemNames.HOT_SOUP_X_2]]
+        self.assertAccessDependency(locations, items)

worlds/aquaria/test/test_bind_song_access.py

@@ -35,6 +35,7 @@ class BindSongAccessTest(AquariaTestBase):
             AquariaLocationNames.ENERGY_TEMPLE_THIRD_AREA_BULB_IN_THE_BOTTOM_PATH,
             AquariaLocationNames.ENERGY_TEMPLE_BOSS_AREA_FALLEN_GOD_TOOTH,
             AquariaLocationNames.ENERGY_TEMPLE_BLASTER_ROOM_BLASTER_EGG,
+            AquariaLocationNames.SITTING_ON_THRONE,
             *after_home_water_locations
         ]
         items = [[ItemNames.BIND_SONG]]

worlds/aquaria/test/test_bind_song_option_access.py

@@ -38,6 +38,7 @@ class BindSongOptionAccessTest(AquariaTestBase):
             AquariaLocationNames.ENERGY_TEMPLE_THIRD_AREA_BULB_IN_THE_BOTTOM_PATH,
             AquariaLocationNames.ENERGY_TEMPLE_BOSS_AREA_FALLEN_GOD_TOOTH,
             AquariaLocationNames.ENERGY_TEMPLE_BLASTER_ROOM_BLASTER_EGG,
+            AquariaLocationNames.SITTING_ON_THRONE,
             *after_home_water_locations
         ]
         items = [[ItemNames.BIND_SONG]]

worlds/aquaria/test/test_no_progression_arnassi_ruins.py

@@ -0,0 +1,44 @@
+"""
+Author: Louis M
+Date: Fri, 03 May 2024 14:07:35 +0000
+Description: Unit test used to test that no progression items can be put in Arnassi Ruins when option enabled
+"""
+
+from . import AquariaTestBase
+from BaseClasses import ItemClassification
+from ..Locations import AquariaLocationNames
+
+
+class NoProgressionArnassiRuinsTest(AquariaTestBase):
+    """Unit test used to test that no progression items can be put in Arnassi Ruins when option enabled"""
+    options = {
+        "no_progression_arnassi_ruins": True
+    }
+
+    unfillable_locations = [
+        AquariaLocationNames.ARNASSI_RUINS_BULB_IN_THE_RIGHT_PART,
+        AquariaLocationNames.ARNASSI_RUINS_BULB_IN_THE_LEFT_PART,
+        AquariaLocationNames.ARNASSI_RUINS_BULB_IN_THE_CENTER_PART,
+        AquariaLocationNames.ARNASSI_RUINS_SONG_PLANT_SPORE,
+        AquariaLocationNames.ARNASSI_RUINS_ARNASSI_ARMOR,
+        AquariaLocationNames.ARNASSI_RUINS_ARNASSI_STATUE,
+        AquariaLocationNames.ARNASSI_RUINS_TRANSTURTLE,
+        AquariaLocationNames.ARNASSI_RUINS_CRAB_ARMOR,
+    ]
+
+    def test_no_progression_arnassi_ruins(self) -> None:
+        """
+            Unit test used to test that no progression items can be put in Arnassi Ruins when option enabled
+        """
+        for location in self.unfillable_locations:
+            for item_name in self.world.item_names:
+                item = self.get_item_by_name(item_name)
+                if item.classification == ItemClassification.progression:
+                    self.assertFalse(
+                        self.world.get_location(location).can_fill(self.multiworld.state, item, False),
+                        "The location \"" + location + "\" can be filled with \"" + item_name + "\"")
+                else:
+                    self.assertTrue(
+                        self.world.get_location(location).can_fill(self.multiworld.state, item, False),
+                        "The location \"" + location + "\" cannot be filled with \"" + item_name + "\"")
+

worlds/aquaria/test/test_no_progression_energy_temple.py

@@ -0,0 +1,44 @@
+"""
+Author: Louis M
+Date: Fri, 03 May 2024 14:07:35 +0000
+Description: Unit test used to test that no progression items can be put in Energy Temple when option enabled
+"""
+
+from . import AquariaTestBase
+from BaseClasses import ItemClassification
+from ..Locations import AquariaLocationNames
+
+
+class NoProgressionEnergyTempleTest(AquariaTestBase):
+    """Unit test used to test that no progression items can be put in Energy Temple when option enabled"""
+    options = {
+        "no_progression_energy_temple": True
+    }
+
+    unfillable_locations = [
+        AquariaLocationNames.ENERGY_TEMPLE_FIRST_AREA_BEATING_THE_ENERGY_STATUE,
+        AquariaLocationNames.ENERGY_TEMPLE_FIRST_AREA_BULB_IN_THE_BOTTOM_ROOM_BLOCKED_BY_A_ROCK,
+        AquariaLocationNames.ENERGY_TEMPLE_ENERGY_IDOL,
+        AquariaLocationNames.ENERGY_TEMPLE_SECOND_AREA_BULB_UNDER_THE_ROCK,
+        AquariaLocationNames.ENERGY_TEMPLE_BOTTOM_ENTRANCE_KROTITE_ARMOR,
+        AquariaLocationNames.ENERGY_TEMPLE_THIRD_AREA_BULB_IN_THE_BOTTOM_PATH,
+        AquariaLocationNames.ENERGY_TEMPLE_BOSS_AREA_FALLEN_GOD_TOOTH,
+        AquariaLocationNames.ENERGY_TEMPLE_BLASTER_ROOM_BLASTER_EGG,
+    ]
+
+    def test_no_progression_energy_temple(self) -> None:
+        """
+            Unit test used to test that no progression items can be put in Energy Temple when option enabled
+        """
+        for location in self.unfillable_locations:
+            for item_name in self.world.item_names:
+                item = self.get_item_by_name(item_name)
+                if item.classification == ItemClassification.progression:
+                    self.assertFalse(
+                        self.world.get_location(location).can_fill(self.multiworld.state, item, False),
+                        "The location \"" + location + "\" can be filled with \"" + item_name + "\"")
+                else:
+                    self.assertTrue(
+                        self.world.get_location(location).can_fill(self.multiworld.state, item, False),
+                        "The location \"" + location + "\" cannot be filled with \"" + item_name + "\"")
+

worlds/aquaria/test/test_no_progression_frozen_veil.py

@@ -0,0 +1,44 @@
+"""
+Author: Louis M
+Date: Fri, 03 May 2024 14:07:35 +0000
+Description: Unit test used to test that no progression items can be put in Frozen Veil when option enabled
+"""
+
+from . import AquariaTestBase
+from BaseClasses import ItemClassification
+from ..Locations import AquariaLocationNames
+
+
+class NoProgressionFrozenVeilTest(AquariaTestBase):
+    """Unit test used to test that no progression items can be put in Frozen Veil when option enabled"""
+    options = {
+        "no_progression_frozen_veil": True
+    }
+
+    unfillable_locations = [
+        AquariaLocationNames.ICE_CAVERN_BULB_IN_THE_ROOM_TO_THE_RIGHT,
+        AquariaLocationNames.ICE_CAVERN_FIRST_BULB_IN_THE_TOP_EXIT_ROOM,
+        AquariaLocationNames.ICE_CAVERN_SECOND_BULB_IN_THE_TOP_EXIT_ROOM,
+        AquariaLocationNames.ICE_CAVERN_THIRD_BULB_IN_THE_TOP_EXIT_ROOM,
+        AquariaLocationNames.ICE_CAVERN_BULB_IN_THE_LEFT_ROOM,
+        AquariaLocationNames.BUBBLE_CAVE_BULB_IN_THE_LEFT_CAVE_WALL,
+        AquariaLocationNames.BUBBLE_CAVE_BULB_IN_THE_RIGHT_CAVE_WALL_BEHIND_THE_ICE_CRYSTAL,
+        AquariaLocationNames.BUBBLE_CAVE_VERSE_EGG,
+    ]
+
+    def test_no_progression_frozen_veil(self) -> None:
+        """
+            Unit test used to test that no progression items can be put in Frozen Veil when option enabled
+        """
+        for location in self.unfillable_locations:
+            for item_name in self.world.item_names:
+                item = self.get_item_by_name(item_name)
+                if item.classification == ItemClassification.progression:
+                    self.assertFalse(
+                        self.world.get_location(location).can_fill(self.multiworld.state, item, False),
+                        "The location \"" + location + "\" can be filled with \"" + item_name + "\"")
+                else:
+                    self.assertTrue(
+                        self.world.get_location(location).can_fill(self.multiworld.state, item, False),
+                        "The location \"" + location + "\" cannot be filled with \"" + item_name + "\"")
+

worlds/aquaria/test/test_no_progression_hard_hidden_locations.py

@@ -9,7 +9,7 @@ from BaseClasses import ItemClassification
 from ..Locations import AquariaLocationNames
 
 
-class UNoProgressionHardHiddenTest(AquariaTestBase):
+class NoProgressionHardHiddenTest(AquariaTestBase):
     """Unit test used to test that no progression items can be put in hard or hidden locations when option enabled"""
     options = {
         "no_progression_hard_or_hidden_locations": True
@@ -43,7 +43,7 @@ class UNoProgressionHardHiddenTest(AquariaTestBase):
         AquariaLocationNames.ARNASSI_RUINS_ARNASSI_ARMOR,
     ]
 
-    def test_unconfine_home_water_both_location_fillable(self) -> None:
+    def test_no_progression_hard_or_hidden(self) -> None:
         """
             Unit test used to test that no progression items can be put in hard or hidden locations when option enabled
         """

worlds/aquaria/test/test_no_progression_kelp_forest.py

@@ -0,0 +1,61 @@
+"""
+Author: Louis M
+Date: Fri, 03 May 2024 14:07:35 +0000
+Description: Unit test used to test that no progression items can be put in Kelp Forest when option enabled
+"""
+
+from . import AquariaTestBase
+from BaseClasses import ItemClassification
+from ..Locations import AquariaLocationNames
+
+
+class NoProgressionKelpForestTest(AquariaTestBase):
+    """Unit test used to test that no progression items can be put in Kelp Forest when option enabled"""
+    options = {
+        "no_progression_kelp_forest": True
+    }
+
+    unfillable_locations = [
+        AquariaLocationNames.KELP_FOREST_TOP_LEFT_AREA_BULB_IN_THE_BOTTOM_LEFT_CLEARING,
+        AquariaLocationNames.KELP_FOREST_TOP_LEFT_AREA_BULB_IN_THE_PATH_DOWN_FROM_THE_TOP_LEFT_CLEARING,
+        AquariaLocationNames.KELP_FOREST_TOP_LEFT_AREA_BULB_IN_THE_TOP_LEFT_CLEARING,
+        AquariaLocationNames.KELP_FOREST_TOP_LEFT_AREA_JELLY_EGG,
+        AquariaLocationNames.KELP_FOREST_TOP_LEFT_AREA_BULB_CLOSE_TO_THE_VERSE_EGG,
+        AquariaLocationNames.KELP_FOREST_TOP_LEFT_AREA_VERSE_EGG,
+        AquariaLocationNames.KELP_FOREST_TOP_RIGHT_AREA_BULB_UNDER_THE_ROCK_IN_THE_RIGHT_PATH,
+        AquariaLocationNames.KELP_FOREST_TOP_RIGHT_AREA_BULB_AT_THE_LEFT_OF_THE_CENTER_CLEARING,
+        AquariaLocationNames.KELP_FOREST_TOP_RIGHT_AREA_BULB_IN_THE_LEFT_PATH_S_BIG_ROOM,
+        AquariaLocationNames.KELP_FOREST_TOP_RIGHT_AREA_BULB_IN_THE_LEFT_PATH_S_SMALL_ROOM,
+        AquariaLocationNames.KELP_FOREST_TOP_RIGHT_AREA_BULB_AT_THE_TOP_OF_THE_CENTER_CLEARING,
+        AquariaLocationNames.KELP_FOREST_TOP_RIGHT_AREA_BLACK_PEARL,
+        AquariaLocationNames.KELP_FOREST_TOP_RIGHT_AREA_BULB_IN_THE_TOP_FISH_PASS,
+        AquariaLocationNames.KELP_FOREST_BOTTOM_LEFT_AREA_BULB_CLOSE_TO_THE_SPIRIT_CRYSTALS,
+        AquariaLocationNames.KELP_FOREST_BOTTOM_LEFT_AREA_WALKER_BABY,
+        AquariaLocationNames.KELP_FOREST_BOTTOM_LEFT_AREA_TRANSTURTLE,
+        AquariaLocationNames.KELP_FOREST_BOTTOM_RIGHT_AREA_ODD_CONTAINER,
+        AquariaLocationNames.KELP_FOREST_BOSS_AREA_BEATING_DRUNIAN_GOD,
+        AquariaLocationNames.KELP_FOREST_BOSS_ROOM_BULB_AT_THE_BOTTOM_OF_THE_AREA,
+        AquariaLocationNames.KELP_FOREST_BOTTOM_LEFT_AREA_FISH_CAVE_PUZZLE,
+        AquariaLocationNames.KELP_FOREST_SPRITE_CAVE_BULB_INSIDE_THE_FISH_PASS,
+        AquariaLocationNames.KELP_FOREST_SPRITE_CAVE_BULB_IN_THE_SECOND_ROOM,
+        AquariaLocationNames.KELP_FOREST_SPRITE_CAVE_SEED_BAG,
+        AquariaLocationNames.MERMOG_CAVE_BULB_IN_THE_LEFT_PART_OF_THE_CAVE,
+        AquariaLocationNames.MERMOG_CAVE_PIRANHA_EGG,
+    ]
+
+    def test_no_progression_kelp_forest(self) -> None:
+        """
+            Unit test used to test that no progression items can be put in Kelp Forest when option enabled
+        """
+        for location in self.unfillable_locations:
+            for item_name in self.world.item_names:
+                item = self.get_item_by_name(item_name)
+                if item.classification == ItemClassification.progression:
+                    self.assertFalse(
+                        self.world.get_location(location).can_fill(self.multiworld.state, item, False),
+                        "The location \"" + location + "\" can be filled with \"" + item_name + "\"")
+                else:
+                    self.assertTrue(
+                        self.world.get_location(location).can_fill(self.multiworld.state, item, False),
+                        "The location \"" + location + "\" cannot be filled with \"" + item_name + "\"")
+

worlds/aquaria/test/test_no_progression_mithalas.py

@@ -0,0 +1,88 @@
+"""
+Author: Louis M
+Date: Fri, 03 May 2024 14:07:35 +0000
+Description: Unit test used to test that no progression items can be put in Mithalas when option enabled
+"""
+
+from . import AquariaTestBase
+from BaseClasses import ItemClassification
+from ..Locations import AquariaLocationNames
+
+
+class NoProgressionMithalasTest(AquariaTestBase):
+    """Unit test used to test that no progression items can be put in Mithalas when option enabled"""
+    options = {
+        "no_progression_mithalas": True
+    }
+
+    unfillable_locations = [
+        AquariaLocationNames.MITHALAS_CITY_FIRST_BULB_IN_THE_LEFT_CITY_PART,
+        AquariaLocationNames.MITHALAS_CITY_SECOND_BULB_IN_THE_LEFT_CITY_PART,
+        AquariaLocationNames.MITHALAS_CITY_BULB_IN_THE_RIGHT_PART,
+        AquariaLocationNames.MITHALAS_CITY_BULB_AT_THE_TOP_OF_THE_CITY,
+        AquariaLocationNames.MITHALAS_CITY_FIRST_BULB_IN_A_BROKEN_HOME,
+        AquariaLocationNames.MITHALAS_CITY_SECOND_BULB_IN_A_BROKEN_HOME,
+        AquariaLocationNames.MITHALAS_CITY_BULB_IN_THE_BOTTOM_LEFT_PART,
+        AquariaLocationNames.MITHALAS_CITY_FIRST_BULB_IN_ONE_OF_THE_HOMES,
+        AquariaLocationNames.MITHALAS_CITY_SECOND_BULB_IN_ONE_OF_THE_HOMES,
+        AquariaLocationNames.MITHALAS_CITY_FIRST_URN_IN_ONE_OF_THE_HOMES,
+        AquariaLocationNames.MITHALAS_CITY_SECOND_URN_IN_ONE_OF_THE_HOMES,
+        AquariaLocationNames.MITHALAS_CITY_FIRST_URN_IN_THE_CITY_RESERVE,
+        AquariaLocationNames.MITHALAS_CITY_SECOND_URN_IN_THE_CITY_RESERVE,
+        AquariaLocationNames.MITHALAS_CITY_THIRD_URN_IN_THE_CITY_RESERVE,
+        AquariaLocationNames.MITHALAS_CITY_FIRST_BULB_AT_THE_END_OF_THE_TOP_PATH,
+        AquariaLocationNames.MITHALAS_CITY_SECOND_BULB_AT_THE_END_OF_THE_TOP_PATH,
+        AquariaLocationNames.MITHALAS_CITY_BULB_IN_THE_TOP_PATH,
+        AquariaLocationNames.MITHALAS_CITY_MITHALAS_POT,
+        AquariaLocationNames.MITHALAS_CITY_URN_IN_THE_CASTLE_FLOWER_TUBE_ENTRANCE,
+        AquariaLocationNames.MITHALAS_CITY_DOLL,
+        AquariaLocationNames.MITHALAS_CITY_URN_INSIDE_A_HOME_FISH_PASS,
+        AquariaLocationNames.MITHALAS_CITY_CASTLE_BULB_IN_THE_FLESH_HOLE,
+        AquariaLocationNames.MITHALAS_CITY_CASTLE_BLUE_BANNER,
+        AquariaLocationNames.MITHALAS_CITY_CASTLE_URN_IN_THE_BEDROOM,
+        AquariaLocationNames.MITHALAS_CITY_CASTLE_FIRST_URN_OF_THE_SINGLE_LAMP_PATH,
+        AquariaLocationNames.MITHALAS_CITY_CASTLE_SECOND_URN_OF_THE_SINGLE_LAMP_PATH,
+        AquariaLocationNames.MITHALAS_CITY_CASTLE_URN_IN_THE_BOTTOM_ROOM,
+        AquariaLocationNames.MITHALAS_CITY_CASTLE_FIRST_URN_ON_THE_ENTRANCE_PATH,
+        AquariaLocationNames.MITHALAS_CITY_CASTLE_SECOND_URN_ON_THE_ENTRANCE_PATH,
+        AquariaLocationNames.MITHALAS_CITY_CASTLE_BEATING_THE_PRIESTS,
+        AquariaLocationNames.MITHALAS_CITY_CASTLE_TRIDENT_HEAD,
+        AquariaLocationNames.MITHALAS_CATHEDRAL_FIRST_URN_IN_THE_TOP_RIGHT_ROOM,
+        AquariaLocationNames.MITHALAS_CATHEDRAL_SECOND_URN_IN_THE_TOP_RIGHT_ROOM,
+        AquariaLocationNames.MITHALAS_CATHEDRAL_THIRD_URN_IN_THE_TOP_RIGHT_ROOM,
+        AquariaLocationNames.MITHALAS_CATHEDRAL_BULB_IN_THE_FLESH_ROOM_WITH_FLEAS,
+        AquariaLocationNames.MITHALAS_CATHEDRAL_FIRST_URN_IN_THE_BOTTOM_RIGHT_PATH,
+        AquariaLocationNames.MITHALAS_CATHEDRAL_SECOND_URN_IN_THE_BOTTOM_RIGHT_PATH,
+        AquariaLocationNames.MITHALAS_CATHEDRAL_URN_BEHIND_THE_FLESH_VEIN,
+        AquariaLocationNames.MITHALAS_CATHEDRAL_URN_IN_THE_TOP_LEFT_EYES_BOSS_ROOM,
+        AquariaLocationNames.MITHALAS_CATHEDRAL_FIRST_URN_IN_THE_PATH_BEHIND_THE_FLESH_VEIN,
+        AquariaLocationNames.MITHALAS_CATHEDRAL_SECOND_URN_IN_THE_PATH_BEHIND_THE_FLESH_VEIN,
+        AquariaLocationNames.MITHALAS_CATHEDRAL_THIRD_URN_IN_THE_PATH_BEHIND_THE_FLESH_VEIN,
+        AquariaLocationNames.MITHALAS_CATHEDRAL_FOURTH_URN_IN_THE_TOP_RIGHT_ROOM,
+        AquariaLocationNames.MITHALAS_CATHEDRAL_MITHALAN_DRESS,
+        AquariaLocationNames.MITHALAS_CATHEDRAL_URN_BELOW_THE_LEFT_ENTRANCE,
+        AquariaLocationNames.CATHEDRAL_UNDERGROUND_BULB_IN_THE_CENTER_PART,
+        AquariaLocationNames.CATHEDRAL_UNDERGROUND_FIRST_BULB_IN_THE_TOP_LEFT_PART,
+        AquariaLocationNames.CATHEDRAL_UNDERGROUND_SECOND_BULB_IN_THE_TOP_LEFT_PART,
+        AquariaLocationNames.CATHEDRAL_UNDERGROUND_THIRD_BULB_IN_THE_TOP_LEFT_PART,
+        AquariaLocationNames.CATHEDRAL_UNDERGROUND_BULB_CLOSE_TO_THE_SAVE_CRYSTAL,
+        AquariaLocationNames.CATHEDRAL_UNDERGROUND_BULB_IN_THE_BOTTOM_RIGHT_PATH,
+        AquariaLocationNames.MITHALAS_BOSS_AREA_BEATING_MITHALAN_GOD,
+    ]
+
+    def test_no_progression_mithalas(self) -> None:
+        """
+            Unit test used to test that no progression items can be put in Mithalas when option enabled
+        """
+        for location in self.unfillable_locations:
+            for item_name in self.world.item_names:
+                item = self.get_item_by_name(item_name)
+                if item.classification == ItemClassification.progression:
+                    self.assertFalse(
+                        self.world.get_location(location).can_fill(self.multiworld.state, item, False),
+                        "The location \"" + location + "\" can be filled with \"" + item_name + "\"")
+                else:
+                    self.assertTrue(
+                        self.world.get_location(location).can_fill(self.multiworld.state, item, False),
+                        "The location \"" + location + "\" cannot be filled with \"" + item_name + "\"")
+

worlds/aquaria/test/test_no_progression_simon_says.py

@@ -0,0 +1,38 @@
+"""
+Author: Louis M
+Date: Fri, 03 May 2024 14:07:35 +0000
+Description: Unit test used to test that no progression items can be put in Simon says when option enabled
+"""
+
+from . import AquariaTestBase
+from BaseClasses import ItemClassification
+from ..Locations import AquariaLocationNames
+
+
+class NoProgressionSimonSaysTest(AquariaTestBase):
+    """Unit test used to test that no progression items can be put in Simon says when option enabled"""
+    options = {
+        "no_progression_simon_says": True
+    }
+
+    unfillable_locations = [
+        AquariaLocationNames.SIMON_SAYS_AREA_BEATING_SIMON_SAYS,
+        AquariaLocationNames.SIMON_SAYS_AREA_TRANSTURTLE,
+    ]
+
+    def test_no_progression_simon_says(self) -> None:
+        """
+            Unit test used to test that no progression items can be put in Simon says when option enabled
+        """
+        for location in self.unfillable_locations:
+            for item_name in self.world.item_names:
+                item = self.get_item_by_name(item_name)
+                if item.classification == ItemClassification.progression:
+                    self.assertFalse(
+                        self.world.get_location(location).can_fill(self.multiworld.state, item, False),
+                        "The location \"" + location + "\" can be filled with \"" + item_name + "\"")
+                else:
+                    self.assertTrue(
+                        self.world.get_location(location).can_fill(self.multiworld.state, item, False),
+                        "The location \"" + location + "\" cannot be filled with \"" + item_name + "\"")
+