MultiServer.py: Another Hint Priority + Item Links bug oh boy

Basically, the hint for an item linked item gets stored in two players' hints.

1. The player whose location it is
2. **Every individual player** participating in the item link

Crucially, it is *not* stored as a hint for the itemlink world.

This makes `replace_hint` not act correctly when a receiving player of an itemlink item tries to change the priority.

I'm not sure if this has other implications, it probably warrants some testing.

.github/labeler.yml

@@ -21,6 +21,7 @@
     - '!data/**'
     - '!.run/**'
     - '!.github/**'
+    - '!worlds_disabled/**'
     - '!worlds/**'
     - '!WebHost.py'
     - '!WebHostLib/**'

.github/workflows/build.yml

@@ -21,17 +21,12 @@ env:
   ENEMIZER_VERSION: 7.1
   APPIMAGETOOL_VERSION: 13
 
-permissions:  # permissions required for attestation
-  id-token: 'write'
-  attestations: 'write'
-
 jobs:
   # build-release-macos: # LF volunteer
 
-  build-win: # RCs and releases may still be built and signed by hand
+  build-win: # RCs will still be built and signed by hand
     runs-on: windows-latest
     steps:
-      # - copy code below to release.yml -
       - uses: actions/checkout@v4
       - name: Install python
         uses: actions/setup-python@v5
@@ -70,18 +65,6 @@ jobs:
           $contents = Get-ChildItem -Path setups/*.exe -Force -Recurse
           $SETUP_NAME=$contents[0].Name
           echo "SETUP_NAME=$SETUP_NAME" >> $Env:GITHUB_ENV
-      # - copy code above to release.yml -
-      - name: Attest Build
-        if: ${{ github.event_name == 'workflow_dispatch' }}
-        uses: actions/attest-build-provenance@v2
-        with:
-          subject-path: |
-            build/exe.*/ArchipelagoLauncher.exe
-            build/exe.*/ArchipelagoLauncherDebug.exe
-            build/exe.*/ArchipelagoGenerate.exe
-            build/exe.*/ArchipelagoServer.exe
-            dist/${{ env.ZIP_NAME }}
-            setups/${{ env.SETUP_NAME }}
       - name: Check build loads expected worlds
         shell: bash
         run: |
@@ -159,16 +142,6 @@ jobs:
           echo "APPIMAGE_NAME=$APPIMAGE_NAME" >> $GITHUB_ENV
           echo "TAR_NAME=$TAR_NAME" >> $GITHUB_ENV
       # - copy code above to release.yml -
-      - name: Attest Build
-        if: ${{ github.event_name == 'workflow_dispatch' }}
-        uses: actions/attest-build-provenance@v2
-        with:
-          subject-path: |
-            build/exe.*/ArchipelagoLauncher
-            build/exe.*/ArchipelagoGenerate
-            build/exe.*/ArchipelagoServer
-            dist/${{ env.APPIMAGE_NAME }}*
-            dist/${{ env.TAR_NAME }}
       - name: Build Again
         run: |
           source venv/bin/activate

.github/workflows/release.yml

@@ -11,11 +11,6 @@ env:
   ENEMIZER_VERSION: 7.1
   APPIMAGETOOL_VERSION: 13
 
-permissions:  # permissions required for attestation
-  id-token: 'write'
-  attestations: 'write'
-  contents: 'write'  # additionally required for release
-
 jobs:
   create-release:
     runs-on: ubuntu-latest
@@ -31,79 +26,11 @@ jobs:
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
+  # build-release-windows: # this is done by hand because of signing
   # build-release-macos: # LF volunteer
 
-  build-release-win:
-    runs-on: windows-latest
-    if: ${{ true }}  # change to false to skip if release is built by hand
-    needs: create-release
-    steps:
-      - name: Set env
-        shell: bash
-        run: echo "RELEASE_VERSION=${GITHUB_REF#refs/*/}" >> $GITHUB_ENV
-      # - code below copied from build.yml -
-      - uses: actions/checkout@v4
-      - name: Install python
-        uses: actions/setup-python@v5
-        with:
-          python-version: '~3.12.7'
-          check-latest: true
-      - name: Download run-time dependencies
-        run: |
-          Invoke-WebRequest -Uri https://github.com/Ijwu/Enemizer/releases/download/${Env:ENEMIZER_VERSION}/win-x64.zip -OutFile enemizer.zip
-          Expand-Archive -Path enemizer.zip -DestinationPath EnemizerCLI -Force
-          choco install innosetup --version=6.2.2 --allow-downgrade
-      - name: Build
-        run: |
-          python -m pip install --upgrade pip
-          python setup.py build_exe --yes
-          if ( $? -eq $false ) {
-            Write-Error "setup.py failed!"
-            exit 1
-          }
-          $NAME="$(ls build | Select-String -Pattern 'exe')".Split('.',2)[1]
-          $ZIP_NAME="Archipelago_$NAME.7z"
-          echo "$NAME -> $ZIP_NAME"
-          echo "ZIP_NAME=$ZIP_NAME" >> $Env:GITHUB_ENV
-          New-Item -Path dist -ItemType Directory -Force
-          cd build
-          Rename-Item "exe.$NAME" Archipelago
-          7z a -mx=9 -mhe=on -ms "../dist/$ZIP_NAME" Archipelago
-          Rename-Item Archipelago "exe.$NAME"  # inno_setup.iss expects the original name
-      - name: Build Setup
-        run: |
-          & "${env:ProgramFiles(x86)}\Inno Setup 6\iscc.exe" inno_setup.iss /DNO_SIGNTOOL
-          if ( $? -eq $false ) {
-            Write-Error "Building setup failed!"
-            exit 1
-          }
-          $contents = Get-ChildItem -Path setups/*.exe -Force -Recurse
-          $SETUP_NAME=$contents[0].Name
-          echo "SETUP_NAME=$SETUP_NAME" >> $Env:GITHUB_ENV
-      # - code above copied from build.yml -
-      - name: Attest Build
-        uses: actions/attest-build-provenance@v2
-        with:
-          subject-path: |
-            build/exe.*/ArchipelagoLauncher.exe
-            build/exe.*/ArchipelagoLauncherDebug.exe
-            build/exe.*/ArchipelagoGenerate.exe
-            build/exe.*/ArchipelagoServer.exe
-            setups/*
-      - name: Add to Release
-        uses: softprops/action-gh-release@975c1b265e11dd76618af1c374e7981f9a6ff44a
-        with:
-          draft: true  # see above
-          prerelease: false
-          name: Archipelago ${{ env.RELEASE_VERSION }}
-          files: |
-            setups/*
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
   build-release-ubuntu2204:
     runs-on: ubuntu-22.04
-    needs: create-release
     steps:
       - name: Set env
         run: echo "RELEASE_VERSION=${GITHUB_REF#refs/*/}" >> $GITHUB_ENV
@@ -147,14 +74,6 @@ jobs:
           echo "APPIMAGE_NAME=$APPIMAGE_NAME" >> $GITHUB_ENV
           echo "TAR_NAME=$TAR_NAME" >> $GITHUB_ENV
       # - code above copied from build.yml -
-      - name: Attest Build
-        uses: actions/attest-build-provenance@v2
-        with:
-          subject-path: |
-            build/exe.*/ArchipelagoLauncher
-            build/exe.*/ArchipelagoGenerate
-            build/exe.*/ArchipelagoServer
-            dist/*
       - name: Add to Release
         uses: softprops/action-gh-release@975c1b265e11dd76618af1c374e7981f9a6ff44a
         with:

AHITClient.py

@@ -1,4 +1,3 @@
-import sys
 from worlds.ahit.Client import launch
 import Utils
 import ModuleUpdate
@@ -6,4 +5,4 @@ ModuleUpdate.update()
 
 if __name__ == "__main__":
     Utils.init_logging("AHITClient", exception_logger="Client")
-    launch(*sys.argv[1:])
+    launch()

BaseClasses.py

@@ -9,9 +9,8 @@ from argparse import Namespace
 from collections import Counter, deque
 from collections.abc import Collection, MutableSequence
 from enum import IntEnum, IntFlag
-from typing import (AbstractSet, Any, Callable, ClassVar, Dict, Iterable, Iterator, List, Literal, Mapping, NamedTuple,
+from typing import (AbstractSet, Any, Callable, ClassVar, Dict, Iterable, Iterator, List, Mapping, NamedTuple,
                     Optional, Protocol, Set, Tuple, Union, TYPE_CHECKING)
-import dataclasses
 
 from typing_extensions import NotRequired, TypedDict
 
@@ -55,21 +54,12 @@ class HasNameAndPlayer(Protocol):
     player: int
 
 
-@dataclasses.dataclass
-class PlandoItemBlock:
-    player: int
-    from_pool: bool
-    force: bool | Literal["silent"]
-    worlds: set[int] = dataclasses.field(default_factory=set)
-    items: list[str] = dataclasses.field(default_factory=list)
-    locations: list[str] = dataclasses.field(default_factory=list)
-    resolved_locations: list[Location] = dataclasses.field(default_factory=list)
-    count: dict[str, int] = dataclasses.field(default_factory=dict)
-
-
 class MultiWorld():
     debug_types = False
     player_name: Dict[int, str]
+    plando_texts: List[Dict[str, str]]
+    plando_items: List[List[Dict[str, Any]]]
+    plando_connections: List
     worlds: Dict[int, "AutoWorld.World"]
     groups: Dict[int, Group]
     regions: RegionManager
@@ -93,8 +83,6 @@ class MultiWorld():
     start_location_hints: Dict[int, Options.StartLocationHints]
     item_links: Dict[int, Options.ItemLinks]
 
-    plando_item_blocks: Dict[int, List[PlandoItemBlock]]
-
     game: Dict[int, str]
 
     random: random.Random
@@ -172,12 +160,13 @@ class MultiWorld():
         self.local_early_items = {player: {} for player in self.player_ids}
         self.indirect_connections = {}
         self.start_inventory_from_pool: Dict[int, Options.StartInventoryPool] = {}
-        self.plando_item_blocks = {}
 
         for player in range(1, players + 1):
             def set_player_attr(attr: str, val) -> None:
                 self.__dict__.setdefault(attr, {})[player] = val
-            set_player_attr('plando_item_blocks', [])
+            set_player_attr('plando_items', [])
+            set_player_attr('plando_texts', {})
+            set_player_attr('plando_connections', [])
             set_player_attr('game', "Archipelago")
             set_player_attr('completion_condition', lambda state: True)
         self.worlds = {}
@@ -234,7 +223,7 @@ class MultiWorld():
                               AutoWorld.AutoWorldRegister.world_types[self.game[player]].options_dataclass.type_hints}
         for option_key in all_keys:
             option = Utils.DeprecateDict(f"Getting options from multiworld is now deprecated. "
-                                         f"Please use `self.options.{option_key}` instead.", True)
+                                         f"Please use `self.options.{option_key}` instead.")
             option.update(getattr(args, option_key, {}))
             setattr(self, option_key, option)
 
@@ -438,8 +427,7 @@ class MultiWorld():
     def get_location(self, location_name: str, player: int) -> Location:
         return self.regions.location_cache[player][location_name]
 
-    def get_all_state(self, use_cache: bool, allow_partial_entrances: bool = False,
-                      collect_pre_fill_items: bool = True, perform_sweep: bool = True) -> CollectionState:
+    def get_all_state(self, use_cache: bool, allow_partial_entrances: bool = False) -> CollectionState:
         cached = getattr(self, "_all_state", None)
         if use_cache and cached:
             return cached.copy()
@@ -448,13 +436,11 @@ class MultiWorld():
 
         for item in self.itempool:
             self.worlds[item.player].collect(ret, item)
-        if collect_pre_fill_items:
-            for player in self.player_ids:
-                subworld = self.worlds[player]
-                for item in subworld.get_pre_fill_items():
-                    subworld.collect(ret, item)
-        if perform_sweep:
-            ret.sweep_for_advancements()
+        for player in self.player_ids:
+            subworld = self.worlds[player]
+            for item in subworld.get_pre_fill_items():
+                subworld.collect(ret, item)
+        ret.sweep_for_advancements()
 
         if use_cache:
             self._all_state = ret
@@ -559,9 +545,7 @@ class MultiWorld():
         else:
             return all((self.has_beaten_game(state, p) for p in range(1, self.players + 1)))
 
-    def can_beat_game(self,
-                      starting_state: Optional[CollectionState] = None,
-                      locations: Optional[Iterable[Location]] = None) -> bool:
+    def can_beat_game(self, starting_state: Optional[CollectionState] = None) -> bool:
         if starting_state:
             if self.has_beaten_game(starting_state):
                 return True
@@ -570,9 +554,7 @@ class MultiWorld():
             state = CollectionState(self)
             if self.has_beaten_game(state):
                 return True
-
-        base_locations = self.get_locations() if locations is None else locations
-        prog_locations = {location for location in base_locations if location.item
+        prog_locations = {location for location in self.get_locations() if location.item
                           and location.item.advancement and location not in state.locations_checked}
 
         while prog_locations:
@@ -741,7 +723,6 @@ class CollectionState():
     additional_copy_functions: List[Callable[[CollectionState, CollectionState], CollectionState]] = []
 
     def __init__(self, parent: MultiWorld, allow_partial_entrances: bool = False):
-        assert parent.worlds, "CollectionState created without worlds initialized in parent"
         self.prog_items = {player: Counter() for player in parent.get_all_ids()}
         self.multiworld = parent
         self.reachable_regions = {player: set() for player in parent.get_all_ids()}
@@ -1018,17 +999,6 @@ class CollectionState():
 
         return changed
 
-    def add_item(self, item: str, player: int, count: int = 1) -> None:
-        """
-        Adds the item to state.
-
-        :param item: The item to be added.
-        :param player: The player the item is for.
-        :param count: How many of the item to add.
-        """
-        assert count > 0
-        self.prog_items[player][item] += count
-
     def remove(self, item: Item):
         changed = self.multiworld.worlds[item.player].remove(self, item)
         if changed:
@@ -1037,33 +1007,6 @@ class CollectionState():
             self.blocked_connections[item.player] = set()
             self.stale[item.player] = True
 
-    def remove_item(self, item: str, player: int, count: int = 1) -> None:
-        """
-        Removes the item from state.
-
-        :param item: The item to be removed.
-        :param player: The player the item is for.
-        :param count: How many of the item to remove.
-        """
-        assert count > 0
-        self.prog_items[player][item] -= count
-        if self.prog_items[player][item] < 1:
-            del (self.prog_items[player][item])
-
-    def set_item(self, item: str, player: int, count: int) -> None:
-        """
-        Sets the item in state equal to the provided count.
-
-        :param item: The item to modify.
-        :param player: The player the item is for.
-        :param count: How many of the item to now have.
-        """
-        assert count >= 0
-        if count == 0:
-            del (self.prog_items[player][item])
-        else:
-            self.prog_items[player][item] = count
-
 
 class EntranceType(IntEnum):
     ONE_WAY = 1
@@ -1079,6 +1022,9 @@ class Entrance:
     connected_region: Optional[Region] = None
     randomization_group: int
     randomization_type: EntranceType
+    # LttP specific, TODO: should make a LttPEntrance
+    addresses = None
+    target = None
 
     def __init__(self, player: int, name: str = "", parent: Optional[Region] = None,
                  randomization_group: int = 0, randomization_type: EntranceType = EntranceType.ONE_WAY) -> None:
@@ -1097,8 +1043,10 @@ class Entrance:
 
         return False
 
-    def connect(self, region: Region) -> None:
+    def connect(self, region: Region, addresses: Any = None, target: Any = None) -> None:
         self.connected_region = region
+        self.target = target
+        self.addresses = addresses
         region.entrances.append(self)
 
     def is_valid_source_transition(self, er_state: "ERPlacementState") -> bool:
@@ -1255,48 +1203,6 @@ class Region:
         for location, address in locations.items():
             self.locations.append(location_type(self.player, location, address, self))
 
-    def add_event(
-        self,
-        location_name: str,
-        item_name: str | None = None,
-        rule: Callable[[CollectionState], bool] | None = None,
-        location_type: type[Location] | None = None,
-        item_type: type[Item] | None = None,
-        show_in_spoiler: bool = True,
-    ) -> Item:
-        """
-        Adds an event location/item pair to the region.
-
-        :param location_name: Name for the event location.
-        :param item_name: Name for the event item. If not provided, defaults to location_name.
-        :param rule: Callable to determine access for this event location within its region.
-        :param location_type: Location class to create the event location with. Defaults to BaseClasses.Location.
-        :param item_type: Item class to create the event item with. Defaults to BaseClasses.Item.
-        :param show_in_spoiler: Will be passed along to the created event Location's show_in_spoiler attribute.
-        :return: The created Event Item
-        """
-        if location_type is None:
-            location_type = Location
-
-        if item_name is None:
-            item_name = location_name
-
-        if item_type is None:
-            item_type = Item
-
-        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
-
-        event_item = item_type(item_name, ItemClassification.progression, None, self.player)
-
-        event_location.place_locked_item(event_item)
-
-        self.locations.append(event_location)
-
-        return event_item
-
     def connect(self, connecting_region: Region, name: Optional[str] = None,
                 rule: Optional[Callable[[CollectionState], bool]] = None) -> Entrance:
         """
@@ -1607,19 +1513,21 @@ class Spoiler:
 
         # in the second phase, we cull each sphere such that the game is still beatable,
         # reducing each range of influence to the bare minimum required inside it
-        required_locations = {location for sphere in collection_spheres for location in sphere}
+        restore_later: Dict[Location, Item] = {}
         for num, sphere in reversed(tuple(enumerate(collection_spheres))):
             to_delete: Set[Location] = set()
             for location in sphere:
-                # we remove the location from required_locations to sweep from, and check if the game is still beatable
+                # we remove the item at location and check if game is still beatable
                 logging.debug('Checking if %s (Player %d) is required to beat the game.', location.item.name,
                               location.item.player)
-                required_locations.remove(location)
-                if multiworld.can_beat_game(state_cache[num], required_locations):
+                old_item = location.item
+                location.item = None
+                if multiworld.can_beat_game(state_cache[num]):
                     to_delete.add(location)
+                    restore_later[location] = old_item
                 else:
                     # still required, got to keep it around
-                    required_locations.add(location)
+                    location.item = old_item
 
             # cull entries in spheres for spoiler walkthrough at end
             sphere -= to_delete
@@ -1636,7 +1544,7 @@ class Spoiler:
                 logging.debug('Checking if %s (Player %d) is required to beat the game.', item.name, item.player)
                 precollected_items.remove(item)
                 multiworld.state.remove(item)
-                if not multiworld.can_beat_game(multiworld.state, required_locations):
+                if not multiworld.can_beat_game():
                     # Add the item back into `precollected_items` and collect it into `multiworld.state`.
                     multiworld.push_precollected(item)
                 else:
@@ -1678,6 +1586,9 @@ class Spoiler:
             self.create_paths(state, collection_spheres)
 
         # repair the multiworld again
+        for location, item in restore_later.items():
+            location.item = item
+
         for item in removed_precollected:
             multiworld.push_precollected(item)
 

CommonClient.py

@@ -196,11 +196,25 @@ class CommonContext:
             self.lookup_type: typing.Literal["item", "location"] = lookup_type
             self._unknown_item: typing.Callable[[int], str] = lambda key: f"Unknown {lookup_type} (ID: {key})"
             self._archipelago_lookup: typing.Dict[int, str] = {}
+            self._flat_store: typing.Dict[int, str] = Utils.KeyedDefaultDict(self._unknown_item)
             self._game_store: typing.Dict[str, typing.ChainMap[int, str]] = collections.defaultdict(
                 lambda: collections.ChainMap(self._archipelago_lookup, Utils.KeyedDefaultDict(self._unknown_item)))
+            self.warned: bool = False
 
         # noinspection PyTypeChecker
         def __getitem__(self, key: str) -> typing.Mapping[int, str]:
+            # TODO: In a future version (0.6.0?) this should be simplified by removing implicit id lookups support.
+            if isinstance(key, int):
+                if not self.warned:
+                    # Use warnings instead of logger to avoid deprecation message from appearing on user side.
+                    self.warned = True
+                    warnings.warn(f"Implicit name lookup by id only is deprecated and only supported to maintain "
+                                  f"backwards compatibility for now. If multiple games share the same id for a "
+                                  f"{self.lookup_type}, name could be incorrect. Please use "
+                                  f"`{self.lookup_type}_names.lookup_in_game()` or "
+                                  f"`{self.lookup_type}_names.lookup_in_slot()` instead.")
+                return self._flat_store[key]  # type: ignore
+
             return self._game_store[key]
 
         def __len__(self) -> int:
@@ -240,6 +254,7 @@ class CommonContext:
             id_to_name_lookup_table = Utils.KeyedDefaultDict(self._unknown_item)
             id_to_name_lookup_table.update({code: name for name, code in name_to_id_lookup_table.items()})
             self._game_store[game] = collections.ChainMap(self._archipelago_lookup, id_to_name_lookup_table)
+            self._flat_store.update(id_to_name_lookup_table)  # Only needed for legacy lookup method.
             if game == "Archipelago":
                 # Keep track of the Archipelago data package separately so if it gets updated in a custom datapackage,
                 # it updates in all chain maps automatically.
@@ -266,71 +281,38 @@ class CommonContext:
     last_death_link: float = time.time()  # last send/received death link on AP layer
 
     # remaining type info
-    slot_info: dict[int, NetworkSlot]
-    """Slot Info from the server for the current connection"""
-    server_address: str | None
-    """Autoconnect address provided by the ctx constructor"""
-    password: str | None
-    """Password used for Connecting, expected by server_auth"""
-    hint_cost: int | None
-    """Current Hint Cost per Hint from the server"""
-    hint_points: int | None
-    """Current avaliable Hint Points from the server"""
-    player_names: dict[int, str]
-    """Current lookup of slot number to player display name from server (includes aliases)"""
+    slot_info: typing.Dict[int, NetworkSlot]
+    server_address: typing.Optional[str]
+    password: typing.Optional[str]
+    hint_cost: typing.Optional[int]
+    hint_points: typing.Optional[int]
+    player_names: typing.Dict[int, str]
 
     finished_game: bool
-    """
-    Bool to signal that status should be updated to Goal after reconnecting
-    to be used to ensure that a StatusUpdate packet does not get lost when disconnected
-    """
     ready: bool
-    """Bool to keep track of state for the /ready command"""
-    team: int | None
-    """Team number of currently connected slot"""
-    slot: int | None
-    """Slot number of currently connected slot"""
-    auth: str | None
-    """Name used in Connect packet"""
-    seed_name: str | None
-    """Seed name that will be validated on opening a socket if present"""
+    team: typing.Optional[int]
+    slot: typing.Optional[int]
+    auth: typing.Optional[str]
+    seed_name: typing.Optional[str]
 
     # locations
-    locations_checked: set[int]
-    """
-    Local container of location ids checked to signal that LocationChecks should be resent after reconnecting
-    to be used to ensure that a LocationChecks packet does not get lost when disconnected
-    """
-    locations_scouted: set[int]
-    """
-    Local container of location ids scouted to signal that LocationScouts should be resent after reconnecting
-    to be used to ensure that a LocationScouts packet does not get lost when disconnected
-    """
-    items_received: list[NetworkItem]
-    """List of NetworkItems recieved from the server"""
-    missing_locations: set[int]
-    """Container of Locations that are unchecked per server state"""
-    checked_locations: set[int]
-    """Container of Locations that are checked per server state"""
-    server_locations: set[int]
-    """Container of Locations that exist per server state; a combination between missing and checked locations"""
-    locations_info: dict[int, NetworkItem]
-    """Dict of location id: NetworkItem info from LocationScouts request"""
+    locations_checked: typing.Set[int]  # local state
+    locations_scouted: typing.Set[int]
+    items_received: typing.List[NetworkItem]
+    missing_locations: typing.Set[int]  # server state
+    checked_locations: typing.Set[int]  # server state
+    server_locations: typing.Set[int]  # all locations the server knows of, missing_location | checked_locations
+    locations_info: typing.Dict[int, NetworkItem]
 
     # data storage
-    stored_data: dict[str, typing.Any]
-    """
-    Data Storage values by key that were retrieved from the server
-    any keys subscribed to with SetNotify will be kept up to date
-    """
-    stored_data_notification_keys: set[str]
-    """Current container of watched Data Storage keys, managed by ctx.set_notify"""
+    stored_data: typing.Dict[str, typing.Any]
+    stored_data_notification_keys: typing.Set[str]
 
     # internals
+    # current message box through kvui
     _messagebox: typing.Optional["kvui.MessageBox"] = None
-    """Current message box through kvui"""
+    # message box reporting a loss of connection
     _messagebox_connection_loss: typing.Optional["kvui.MessageBox"] = None
-    """Message box reporting a loss of connection"""
 
     def __init__(self, server_address: typing.Optional[str] = None, password: typing.Optional[str] = None) -> None:
         # server state
@@ -374,6 +356,7 @@ class CommonContext:
 
         self.item_names = self.NameLookupDict(self, "item")
         self.location_names = self.NameLookupDict(self, "location")
+        self.versions = {}
         self.checksums = {}
 
         self.jsontotextparser = JSONtoTextParser(self)
@@ -588,6 +571,7 @@ class CommonContext:
     
     # DataPackage
     async def prepare_data_package(self, relevant_games: typing.Set[str],
+                                   remote_date_package_versions: typing.Dict[str, int],
                                    remote_data_package_checksums: typing.Dict[str, str]):
         """Validate that all data is present for the current multiworld.
         Download, assimilate and cache missing data from the server."""
@@ -596,26 +580,33 @@ class CommonContext:
 
         needed_updates: typing.Set[str] = set()
         for game in relevant_games:
-            if game not in remote_data_package_checksums:
+            if game not in remote_date_package_versions and game not in remote_data_package_checksums:
                 continue
 
+            remote_version: int = remote_date_package_versions.get(game, 0)
             remote_checksum: typing.Optional[str] = remote_data_package_checksums.get(game)
 
-            if not remote_checksum:  # custom data package and no checksum for this game
+            if remote_version == 0 and not remote_checksum:  # custom data package and no checksum for this game
                 needed_updates.add(game)
                 continue
 
+            cached_version: int = self.versions.get(game, 0)
             cached_checksum: typing.Optional[str] = self.checksums.get(game)
             # no action required if cached version is new enough
-            if remote_checksum != cached_checksum:
+            if (not remote_checksum and (remote_version > cached_version or remote_version == 0)) \
+                    or remote_checksum != cached_checksum:
+                local_version: int = network_data_package["games"].get(game, {}).get("version", 0)
                 local_checksum: typing.Optional[str] = network_data_package["games"].get(game, {}).get("checksum")
-                if remote_checksum == local_checksum:
+                if ((remote_checksum or remote_version <= local_version and remote_version != 0)
+                        and remote_checksum == local_checksum):
                     self.update_game(network_data_package["games"][game], game)
                 else:
                     cached_game = Utils.load_data_package_for_checksum(game, remote_checksum)
+                    cache_version: int = cached_game.get("version", 0)
                     cache_checksum: typing.Optional[str] = cached_game.get("checksum")
                     # download remote version if cache is not new enough
-                    if remote_checksum != cache_checksum:
+                    if (not remote_checksum and (remote_version > cache_version or remote_version == 0)) \
+                            or remote_checksum != cache_checksum:
                         needed_updates.add(game)
                     else:
                         self.update_game(cached_game, game)
@@ -625,6 +616,7 @@ class CommonContext:
     def update_game(self, game_package: dict, game: str):
         self.item_names.update_game(game, game_package["item_name_to_id"])
         self.location_names.update_game(game, game_package["location_name_to_id"])
+        self.versions[game] = game_package.get("version", 0)
         self.checksums[game] = game_package.get("checksum")
 
     def update_data_package(self, data_package: dict):
@@ -895,8 +887,9 @@ async def process_server_cmd(ctx: CommonContext, args: dict):
                         logger.info('    %s (Player %d)' % (network_player.alias, network_player.slot))
 
             # update data package
+            data_package_versions = args.get("datapackage_versions", {})
             data_package_checksums = args.get("datapackage_checksums", {})
-            await ctx.prepare_data_package(set(args["games"]), data_package_checksums)
+            await ctx.prepare_data_package(set(args["games"]), data_package_versions, data_package_checksums)
 
             await ctx.server_auth(args['password'])
 

FF1Client.py

@@ -0,0 +1,267 @@
+import asyncio
+import copy
+import json
+import time
+from asyncio import StreamReader, StreamWriter
+from typing import List
+
+
+import Utils
+from Utils import async_start
+from CommonClient import CommonContext, server_loop, gui_enabled, ClientCommandProcessor, logger, \
+    get_base_parser
+
+SYSTEM_MESSAGE_ID = 0
+
+CONNECTION_TIMING_OUT_STATUS = "Connection timing out. Please restart your emulator, then restart connector_ff1.lua"
+CONNECTION_REFUSED_STATUS = "Connection Refused. Please start your emulator and make sure connector_ff1.lua is running"
+CONNECTION_RESET_STATUS = "Connection was reset. Please restart your emulator, then restart connector_ff1.lua"
+CONNECTION_TENTATIVE_STATUS = "Initial Connection Made"
+CONNECTION_CONNECTED_STATUS = "Connected"
+CONNECTION_INITIAL_STATUS = "Connection has not been initiated"
+
+DISPLAY_MSGS = True
+
+
+class FF1CommandProcessor(ClientCommandProcessor):
+    def __init__(self, ctx: CommonContext):
+        super().__init__(ctx)
+
+    def _cmd_nes(self):
+        """Check NES Connection State"""
+        if isinstance(self.ctx, FF1Context):
+            logger.info(f"NES Status: {self.ctx.nes_status}")
+
+    def _cmd_toggle_msgs(self):
+        """Toggle displaying messages in EmuHawk"""
+        global DISPLAY_MSGS
+        DISPLAY_MSGS = not DISPLAY_MSGS
+        logger.info(f"Messages are now {'enabled' if DISPLAY_MSGS  else 'disabled'}")
+
+
+class FF1Context(CommonContext):
+    command_processor = FF1CommandProcessor
+    game = 'Final Fantasy'
+    items_handling = 0b111  # full remote
+
+    def __init__(self, server_address, password):
+        super().__init__(server_address, password)
+        self.nes_streams: (StreamReader, StreamWriter) = None
+        self.nes_sync_task = None
+        self.messages = {}
+        self.locations_array = None
+        self.nes_status = CONNECTION_INITIAL_STATUS
+        self.awaiting_rom = False
+        self.display_msgs = True
+
+    async def server_auth(self, password_requested: bool = False):
+        if password_requested and not self.password:
+            await super(FF1Context, self).server_auth(password_requested)
+        if not self.auth:
+            self.awaiting_rom = True
+            logger.info('Awaiting connection to NES to get Player information')
+            return
+
+        await self.send_connect()
+
+    def _set_message(self, msg: str, msg_id: int):
+        if DISPLAY_MSGS:
+            self.messages[time.time(), msg_id] = msg
+
+    def on_package(self, cmd: str, args: dict):
+        if cmd == 'Connected':
+            async_start(parse_locations(self.locations_array, self, True))
+        elif cmd == 'Print':
+            msg = args['text']
+            if ': !' not in msg:
+                self._set_message(msg, SYSTEM_MESSAGE_ID)
+
+    def on_print_json(self, args: dict):
+        if self.ui:
+            self.ui.print_json(copy.deepcopy(args["data"]))
+        else:
+            text = self.jsontotextparser(copy.deepcopy(args["data"]))
+            logger.info(text)
+        relevant = args.get("type", None) in {"Hint", "ItemSend"}
+        if relevant:
+            item = args["item"]
+            # goes to this world
+            if self.slot_concerns_self(args["receiving"]):
+                relevant = True
+            # found in this world
+            elif self.slot_concerns_self(item.player):
+                relevant = True
+            # not related
+            else:
+                relevant = False
+            if relevant:
+                item = args["item"]
+                msg = self.raw_text_parser(copy.deepcopy(args["data"]))
+                self._set_message(msg, item.item)
+
+    def run_gui(self):
+        from kvui import GameManager
+
+        class FF1Manager(GameManager):
+            logging_pairs = [
+                ("Client", "Archipelago")
+            ]
+            base_title = "Archipelago Final Fantasy 1 Client"
+
+        self.ui = FF1Manager(self)
+        self.ui_task = asyncio.create_task(self.ui.async_run(), name="UI")
+
+
+def get_payload(ctx: FF1Context):
+    current_time = time.time()
+    return json.dumps(
+        {
+            "items": [item.item for item in ctx.items_received],
+            "messages": {f'{key[0]}:{key[1]}': value for key, value in ctx.messages.items()
+                         if key[0] > current_time - 10}
+        }
+    )
+
+
+async def parse_locations(locations_array: List[int], ctx: FF1Context, force: bool):
+    if locations_array == ctx.locations_array and not force:
+        return
+    else:
+        # print("New values")
+        ctx.locations_array = locations_array
+        locations_checked = []
+        if len(locations_array) > 0xFE and locations_array[0xFE] & 0x02 != 0 and not ctx.finished_game:
+            await ctx.send_msgs([
+                {"cmd": "StatusUpdate",
+                 "status": 30}
+            ])
+            ctx.finished_game = True
+        for location in ctx.missing_locations:
+            # index will be - 0x100 or 0x200
+            index = location
+            if location < 0x200:
+                # Location is a chest
+                index -= 0x100
+                flag = 0x04
+            else:
+                # Location is an NPC
+                index -= 0x200
+                flag = 0x02
+
+            # print(f"Location: {ctx.location_names[location]}")
+            # print(f"Index: {str(hex(index))}")
+            # print(f"value: {locations_array[index] & flag != 0}")
+            if locations_array[index] & flag != 0:
+                locations_checked.append(location)
+        if locations_checked:
+            # print([ctx.location_names[location] for location in locations_checked])
+            await ctx.send_msgs([
+                {"cmd": "LocationChecks",
+                 "locations": locations_checked}
+            ])
+
+
+async def nes_sync_task(ctx: FF1Context):
+    logger.info("Starting nes connector. Use /nes for status information")
+    while not ctx.exit_event.is_set():
+        error_status = None
+        if ctx.nes_streams:
+            (reader, writer) = ctx.nes_streams
+            msg = get_payload(ctx).encode()
+            writer.write(msg)
+            writer.write(b'\n')
+            try:
+                await asyncio.wait_for(writer.drain(), timeout=1.5)
+                try:
+                    # Data will return a dict with up to two fields:
+                    # 1. A keepalive response of the Players Name (always)
+                    # 2. An array representing the memory values of the locations area (if in game)
+                    data = await asyncio.wait_for(reader.readline(), timeout=5)
+                    data_decoded = json.loads(data.decode())
+                    # print(data_decoded)
+                    if ctx.game is not None and 'locations' in data_decoded:
+                        # Not just a keep alive ping, parse
+                        async_start(parse_locations(data_decoded['locations'], ctx, False))
+                    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"
+                                        "the ROM using the same link but adding your slot name")
+                        if ctx.awaiting_rom:
+                            await ctx.server_auth(False)
+                except asyncio.TimeoutError:
+                    logger.debug("Read Timed Out, Reconnecting")
+                    error_status = CONNECTION_TIMING_OUT_STATUS
+                    writer.close()
+                    ctx.nes_streams = None
+                except ConnectionResetError as e:
+                    logger.debug("Read failed due to Connection Lost, Reconnecting")
+                    error_status = CONNECTION_RESET_STATUS
+                    writer.close()
+                    ctx.nes_streams = None
+            except TimeoutError:
+                logger.debug("Connection Timed Out, Reconnecting")
+                error_status = CONNECTION_TIMING_OUT_STATUS
+                writer.close()
+                ctx.nes_streams = None
+            except ConnectionResetError:
+                logger.debug("Connection Lost, Reconnecting")
+                error_status = CONNECTION_RESET_STATUS
+                writer.close()
+                ctx.nes_streams = None
+            if ctx.nes_status == CONNECTION_TENTATIVE_STATUS:
+                if not error_status:
+                    logger.info("Successfully Connected to NES")
+                    ctx.nes_status = CONNECTION_CONNECTED_STATUS
+                else:
+                    ctx.nes_status = f"Was tentatively connected but error occured: {error_status}"
+            elif error_status:
+                ctx.nes_status = error_status
+                logger.info("Lost connection to nes and attempting to reconnect. Use /nes for status updates")
+        else:
+            try:
+                logger.debug("Attempting to connect to NES")
+                ctx.nes_streams = await asyncio.wait_for(asyncio.open_connection("localhost", 52980), timeout=10)
+                ctx.nes_status = CONNECTION_TENTATIVE_STATUS
+            except TimeoutError:
+                logger.debug("Connection Timed Out, Trying Again")
+                ctx.nes_status = CONNECTION_TIMING_OUT_STATUS
+                continue
+            except ConnectionRefusedError:
+                logger.debug("Connection Refused, Trying Again")
+                ctx.nes_status = CONNECTION_REFUSED_STATUS
+                continue
+
+
+if __name__ == '__main__':
+    # Text Mode to use !hint and such with games that have no text entry
+    Utils.init_logging("FF1Client")
+
+    options = Utils.get_options()
+    DISPLAY_MSGS = options["ffr_options"]["display_msgs"]
+
+    async def main(args):
+        ctx = FF1Context(args.connect, args.password)
+        ctx.server_task = asyncio.create_task(server_loop(ctx), name="ServerLoop")
+        if gui_enabled:
+            ctx.run_gui()
+        ctx.run_cli()
+        ctx.nes_sync_task = asyncio.create_task(nes_sync_task(ctx), name="NES Sync")
+
+        await ctx.exit_event.wait()
+        ctx.server_address = None
+
+        await ctx.shutdown()
+
+        if ctx.nes_sync_task:
+            await ctx.nes_sync_task
+
+
+    import colorama
+
+    parser = get_base_parser()
+    args = parser.parse_args()
+    colorama.just_fix_windows_console()
+
+    asyncio.run(main(args))
+    colorama.deinit()

FactorioClient.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+import ModuleUpdate
+ModuleUpdate.update()
+
+from worlds.factorio.Client import check_stdin, launch
+import Utils
+
+if __name__ == "__main__":
+    Utils.init_logging("FactorioClient", exception_logger="Client")
+    check_stdin()
+    launch()

Fill.py

@@ -4,7 +4,7 @@ import logging
 import typing
 from collections import Counter, deque
 
-from BaseClasses import CollectionState, Item, Location, LocationProgressType, MultiWorld, PlandoItemBlock
+from BaseClasses import CollectionState, Item, Location, LocationProgressType, MultiWorld
 from Options import Accessibility
 
 from worlds.AutoWorld import call_all
@@ -100,7 +100,7 @@ def fill_restrictive(multiworld: MultiWorld, base_state: CollectionState, locati
             # if minimal accessibility, only check whether location is reachable if game not beatable
             if multiworld.worlds[item_to_place.player].options.accessibility == Accessibility.option_minimal:
                 perform_access_check = not multiworld.has_beaten_game(maximum_exploration_state,
-                                                                      item_to_place.player) \
+                                                                 item_to_place.player) \
                     if single_player_placement else not has_beaten_game
             else:
                 perform_access_check = True
@@ -138,21 +138,32 @@ def fill_restrictive(multiworld: MultiWorld, base_state: CollectionState, locati
                         # to clean that up later, so there is a chance generation fails.
                         if (not single_player_placement or location.player == item_to_place.player) \
                                 and location.can_fill(swap_state, item_to_place, perform_access_check):
-                            # Add this item to the existing placement, and
-                            # add the old item to the back of the queue
-                            spot_to_fill = placements.pop(i)
 
-                            swap_count += 1
-                            swapped_items[placed_item.player, placed_item.name, unsafe] = swap_count
+                            # Verify placing this item won't reduce available locations, which would be a useless swap.
+                            prev_state = swap_state.copy()
+                            prev_loc_count = len(
+                                multiworld.get_reachable_locations(prev_state))
 
-                            reachable_items[placed_item.player].appendleft(
-                                placed_item)
-                            item_pool.append(placed_item)
+                            swap_state.collect(item_to_place, True)
+                            new_loc_count = len(
+                                multiworld.get_reachable_locations(swap_state))
 
-                            # cleanup at the end to hopefully get better errors
-                            cleanup_required = True
+                            if new_loc_count >= prev_loc_count:
+                                # Add this item to the existing placement, and
+                                # add the old item to the back of the queue
+                                spot_to_fill = placements.pop(i)
 
-                            break
+                                swap_count += 1
+                                swapped_items[placed_item.player, placed_item.name, unsafe] = swap_count
+
+                                reachable_items[placed_item.player].appendleft(
+                                    placed_item)
+                                item_pool.append(placed_item)
+
+                                # cleanup at the end to hopefully get better errors
+                                cleanup_required = True
+
+                                break
 
                         # Item can't be placed here, restore original item
                         location.item = placed_item
@@ -231,7 +242,7 @@ def remaining_fill(multiworld: MultiWorld,
     unplaced_items: typing.List[Item] = []
     placements: typing.List[Location] = []
     swapped_items: typing.Counter[typing.Tuple[int, str]] = Counter()
-    total = min(len(itempool), len(locations))
+    total = min(len(itempool),  len(locations))
     placed = 0
 
     # Optimisation: Decide whether to do full location.can_fill check (respect excluded), or only check the item rule
@@ -332,10 +343,8 @@ def fast_fill(multiworld: MultiWorld,
 
 def accessibility_corrections(multiworld: MultiWorld, state: CollectionState, locations, pool=[]):
     maximum_exploration_state = sweep_from_pool(state, pool)
-    minimal_players = {player for player in multiworld.player_ids if
-                       multiworld.worlds[player].options.accessibility == "minimal"}
-    unreachable_locations = [location for location in multiworld.get_locations() if
-                             location.player in minimal_players and
+    minimal_players = {player for player in multiworld.player_ids if multiworld.worlds[player].options.accessibility == "minimal"}
+    unreachable_locations = [location for location in multiworld.get_locations() if location.player in minimal_players and
                              not location.can_reach(maximum_exploration_state)]
     for location in unreachable_locations:
         if (location.item is not None and location.item.advancement and location.address is not None and not
@@ -356,7 +365,7 @@ def inaccessible_location_rules(multiworld: MultiWorld, state: CollectionState,
     unreachable_locations = [location for location in locations if not location.can_reach(maximum_exploration_state)]
     if unreachable_locations:
         def forbid_important_item_rule(item: Item):
-            return not ((item.classification & 0b0011) and multiworld.worlds[item.player].options.accessibility != "minimal")
+            return not ((item.classification & 0b0011) and multiworld.worlds[item.player].options.accessibility != 'minimal')
 
         for location in unreachable_locations:
             add_item_rule(location, forbid_important_item_rule)
@@ -668,9 +677,9 @@ def balance_multiworld_progression(multiworld: MultiWorld) -> None:
         if multiworld.worlds[player].options.progression_balancing > 0
     }
     if not balanceable_players:
-        logging.info("Skipping multiworld progression balancing.")
+        logging.info('Skipping multiworld progression balancing.')
     else:
-        logging.info(f"Balancing multiworld progression for {len(balanceable_players)} Players.")
+        logging.info(f'Balancing multiworld progression for {len(balanceable_players)} Players.')
         logging.debug(balanceable_players)
         state: CollectionState = CollectionState(multiworld)
         checked_locations: typing.Set[Location] = set()
@@ -768,7 +777,7 @@ def balance_multiworld_progression(multiworld: MultiWorld) -> None:
                                 if player in threshold_percentages):
                             break
                         elif not balancing_sphere:
-                            raise RuntimeError("Not all required items reachable. Something went terribly wrong here.")
+                            raise RuntimeError('Not all required items reachable. Something went terribly wrong here.')
                     # Gather a set of locations which we can swap items into
                     unlocked_locations: typing.Dict[int, typing.Set[Location]] = collections.defaultdict(set)
                     for l in unchecked_locations:
@@ -784,8 +793,8 @@ def balance_multiworld_progression(multiworld: MultiWorld) -> None:
                             testing = items_to_test.pop()
                             reducing_state = state.copy()
                             for location in itertools.chain((
-                                    l for l in items_to_replace
-                                    if l.item.player == player
+                                l for l in items_to_replace
+                                if l.item.player == player
                             ), items_to_test):
                                 reducing_state.collect(location.item, True, location)
 
@@ -858,30 +867,52 @@ def swap_location_item(location_1: Location, location_2: Location, check_locked:
     location_2.item.location = location_2
 
 
-def parse_planned_blocks(multiworld: MultiWorld) -> dict[int, list[PlandoItemBlock]]:
-    def warn(warning: str, force: bool | str) -> None:
-        if isinstance(force, bool):
-            logging.warning(f"{warning}")
+def distribute_planned(multiworld: MultiWorld) -> None:
+    def warn(warning: str, force: typing.Union[bool, str]) -> None:
+        if force in [True, 'fail', 'failure', 'none', False, 'warn', 'warning']:
+            logging.warning(f'{warning}')
         else:
-            logging.debug(f"{warning}")
+            logging.debug(f'{warning}')
 
-    def failed(warning: str, force: bool | str) -> None:
-        if force is True:
+    def failed(warning: str, force: typing.Union[bool, str]) -> None:
+        if force in [True, 'fail', 'failure']:
             raise Exception(warning)
         else:
             warn(warning, force)
 
+    swept_state = multiworld.state.copy()
+    swept_state.sweep_for_advancements()
+    reachable = frozenset(multiworld.get_reachable_locations(swept_state))
+    early_locations: typing.Dict[int, typing.List[str]] = collections.defaultdict(list)
+    non_early_locations: typing.Dict[int, typing.List[str]] = collections.defaultdict(list)
+    for loc in multiworld.get_unfilled_locations():
+        if loc in reachable:
+            early_locations[loc.player].append(loc.name)
+        else:  # not reachable with swept state
+            non_early_locations[loc.player].append(loc.name)
+
     world_name_lookup = multiworld.world_name_lookup
 
-    plando_blocks: dict[int, list[PlandoItemBlock]] = dict()
-    player_ids: set[int] = set(multiworld.player_ids)
+    block_value = typing.Union[typing.List[str], typing.Dict[str, typing.Any], str]
+    plando_blocks: typing.List[typing.Dict[str, typing.Any]] = []
+    player_ids = set(multiworld.player_ids)
     for player in player_ids:
-        plando_blocks[player] = []
-        for block in multiworld.worlds[player].options.plando_items:
-            new_block: PlandoItemBlock = PlandoItemBlock(player, block.from_pool, block.force)
-            target_world = block.world
+        for block in multiworld.plando_items[player]:
+            block['player'] = player
+            if 'force' not in block:
+                block['force'] = 'silent'
+            if 'from_pool' not in block:
+                block['from_pool'] = True
+            elif not isinstance(block['from_pool'], bool):
+                from_pool_type = type(block['from_pool'])
+                raise Exception(f'Plando "from_pool" has to be boolean, not {from_pool_type} for player {player}.')
+            if 'world' not in block:
+                target_world = False
+            else:
+                target_world = block['world']
+
             if target_world is False or multiworld.players == 1:  # target own world
-                worlds: set[int] = {player}
+                worlds: typing.Set[int] = {player}
             elif target_world is True:  # target any worlds besides own
                 worlds = set(multiworld.player_ids) - {player}
             elif target_world is None:  # target all worlds
@@ -891,197 +922,172 @@ def parse_planned_blocks(multiworld: MultiWorld) -> dict[int, list[PlandoItemBlo
                 for listed_world in target_world:
                     if listed_world not in world_name_lookup:
                         failed(f"Cannot place item to {target_world}'s world as that world does not exist.",
-                               block.force)
+                               block['force'])
                         continue
                     worlds.add(world_name_lookup[listed_world])
             elif type(target_world) == int:  # target world by slot number
                 if target_world not in range(1, multiworld.players + 1):
                     failed(
                         f"Cannot place item in world {target_world} as it is not in range of (1, {multiworld.players})",
-                        block.force)
+                        block['force'])
                     continue
                 worlds = {target_world}
             else:  # target world by slot name
                 if target_world not in world_name_lookup:
                     failed(f"Cannot place item to {target_world}'s world as that world does not exist.",
-                           block.force)
+                           block['force'])
                     continue
                 worlds = {world_name_lookup[target_world]}
-            new_block.worlds = worlds
+            block['world'] = worlds
 
-            items: list[str] | dict[str, typing.Any] = block.items
+            items: block_value = []
+            if "items" in block:
+                items = block["items"]
+                if 'count' not in block:
+                    block['count'] = False
+            elif "item" in block:
+                items = block["item"]
+                if 'count' not in block:
+                    block['count'] = 1
+            else:
+                failed("You must specify at least one item to place items with plando.", block['force'])
+                continue
             if isinstance(items, dict):
-                item_list: list[str] = []
+                item_list: typing.List[str] = []
                 for key, value in items.items():
                     if value is True:
                         value = multiworld.itempool.count(multiworld.worlds[player].create_item(key))
                     item_list += [key] * value
                 items = item_list
-            new_block.items = items
+            if isinstance(items, str):
+                items = [items]
+            block['items'] = items
 
-            locations: list[str] = block.locations
+            locations: block_value = []
+            if 'location' in block:
+                locations = block['location']  # just allow 'location' to keep old yamls compatible
+            elif 'locations' in block:
+                locations = block['locations']
             if isinstance(locations, str):
                 locations = [locations]
 
-            locations_from_groups: list[str] = []
-            resolved_locations: list[Location] = []
-            for target_player in worlds:
-                world_locations = multiworld.get_unfilled_locations(target_player)
-                for group in multiworld.worlds[target_player].location_name_groups:
-                    if group in locations:
-                        locations_from_groups.extend(multiworld.worlds[target_player].location_name_groups[group])
-                resolved_locations.extend(location for location in world_locations
-                                          if location.name in [*locations, *locations_from_groups])
-            new_block.locations = sorted(dict.fromkeys(locations))
-            new_block.resolved_locations = sorted(set(resolved_locations))
+            if isinstance(locations, dict):
+                location_list = []
+                for key, value in locations.items():
+                    location_list += [key] * value
+                locations = location_list
 
-            count = block.count
-            if not count:
-                count = len(new_block.items)
-            if isinstance(count, int):
-                count = {"min": count, "max": count}
-            if "min" not in count:
-                count["min"] = 0
-            if "max" not in count:
-                count["max"] = len(new_block.items)
-
-            new_block.count = count
-            plando_blocks[player].append(new_block)
-
-    return plando_blocks
-
-
-def resolve_early_locations_for_planned(multiworld: MultiWorld):
-    def warn(warning: str, force: bool | str) -> None:
-        if isinstance(force, bool):
-            logging.warning(f"{warning}")
-        else:
-            logging.debug(f"{warning}")
-
-    def failed(warning: str, force: bool | str) -> None:
-        if force is True:
-            raise Exception(warning)
-        else:
-            warn(warning, force)
-
-    swept_state = multiworld.state.copy()
-    swept_state.sweep_for_advancements()
-    reachable = frozenset(multiworld.get_reachable_locations(swept_state))
-    early_locations: dict[int, list[Location]] = collections.defaultdict(list)
-    non_early_locations: dict[int, list[Location]] = collections.defaultdict(list)
-    for loc in multiworld.get_unfilled_locations():
-        if loc in reachable:
-            early_locations[loc.player].append(loc)
-        else:  # not reachable with swept state
-            non_early_locations[loc.player].append(loc)
-
-    for player in multiworld.plando_item_blocks:
-        removed = []
-        for block in multiworld.plando_item_blocks[player]:
-            locations = block.locations
-            resolved_locations = block.resolved_locations
-            worlds = block.worlds
             if "early_locations" in locations:
+                locations.remove("early_locations")
                 for target_player in worlds:
-                    resolved_locations += early_locations[target_player]
+                    locations += early_locations[target_player]
             if "non_early_locations" in locations:
+                locations.remove("non_early_locations")
                 for target_player in worlds:
-                    resolved_locations += non_early_locations[target_player]
+                    locations += non_early_locations[target_player]
 
-            if block.count["max"] > len(block.items):
-                count = block.count["max"]
-                failed(f"Plando count {count} greater than items specified", block.force)
-                block.count["max"] = len(block.items)
-                if block.count["min"] > len(block.items):
-                    block.count["min"] = len(block.items)
-            if block.count["max"] > len(block.resolved_locations) > 0:
-                count = block.count["max"]
-                failed(f"Plando count {count} greater than locations specified", block.force)
-                block.count["max"] = len(block.resolved_locations)
-                if block.count["min"] > len(block.resolved_locations):
-                    block.count["min"] = len(block.resolved_locations)
-            block.count["target"] = multiworld.random.randint(block.count["min"],
-                                                                     block.count["max"])
+            block['locations'] = list(dict.fromkeys(locations))
 
-            if not block.count["target"]:
-                removed.append(block)
+            if not block['count']:
+                block['count'] = (min(len(block['items']), len(block['locations'])) if
+                                  len(block['locations']) > 0 else len(block['items']))
+            if isinstance(block['count'], int):
+                block['count'] = {'min': block['count'], 'max': block['count']}
+            if 'min' not in block['count']:
+                block['count']['min'] = 0
+            if 'max' not in block['count']:
+                block['count']['max'] = (min(len(block['items']), len(block['locations'])) if
+                                         len(block['locations']) > 0 else len(block['items']))
+            if block['count']['max'] > len(block['items']):
+                count = block['count']
+                failed(f"Plando count {count} greater than items specified", block['force'])
+                block['count'] = len(block['items'])
+            if block['count']['max'] > len(block['locations']) > 0:
+                count = block['count']
+                failed(f"Plando count {count} greater than locations specified", block['force'])
+                block['count'] = len(block['locations'])
+            block['count']['target'] = multiworld.random.randint(block['count']['min'], block['count']['max'])
 
-        for block in removed:
-            multiworld.plando_item_blocks[player].remove(block)
-
-
-def distribute_planned_blocks(multiworld: MultiWorld, plando_blocks: list[PlandoItemBlock]):
-    def warn(warning: str, force: bool | str) -> None:
-        if isinstance(force, bool):
-            logging.warning(f"{warning}")
-        else:
-            logging.debug(f"{warning}")
-
-    def failed(warning: str, force: bool | str) -> None:
-        if force is True:
-            raise Exception(warning)
-        else:
-            warn(warning, force)
+            if block['count']['target'] > 0:
+                plando_blocks.append(block)
 
     # shuffle, but then sort blocks by number of locations minus number of items,
     # so less-flexible blocks get priority
     multiworld.random.shuffle(plando_blocks)
-    plando_blocks.sort(key=lambda block: (len(block.resolved_locations) - block.count["target"]
-                                          if len(block.resolved_locations) > 0
-                                          else len(multiworld.get_unfilled_locations(block.player)) -
-                                          block.count["target"]))
+    plando_blocks.sort(key=lambda block: (len(block['locations']) - block['count']['target']
+                                          if len(block['locations']) > 0
+                                          else len(multiworld.get_unfilled_locations(player)) - block['count']['target']))
+
     for placement in plando_blocks:
-        player = placement.player
+        player = placement['player']
         try:
-            worlds = placement.worlds
-            locations = placement.resolved_locations
-            items = placement.items
-            maxcount = placement.count["target"]
-            from_pool = placement.from_pool
+            worlds = placement['world']
+            locations = placement['locations']
+            items = placement['items']
+            maxcount = placement['count']['target']
+            from_pool = placement['from_pool']
 
-            item_candidates = []
-            if from_pool:
-                instances = [item for item in multiworld.itempool if item.player == player and item.name in items]
-                for item in multiworld.random.sample(items, maxcount):
-                    candidate = next((i for i in instances if i.name == item), None)
-                    if candidate is None:
-                        warn(f"Could not remove {item} from pool for {multiworld.player_name[player]} as "
-                             f"it's already missing from it", placement.force)
-                        candidate = multiworld.worlds[player].create_item(item)
-                    else:
-                        multiworld.itempool.remove(candidate)
-                        instances.remove(candidate)
-                    item_candidates.append(candidate)
-            else:
-                item_candidates = [multiworld.worlds[player].create_item(item)
-                                   for item in multiworld.random.sample(items, maxcount)]
-            if any(item.code is None for item in item_candidates) \
-               and not all(item.code is None for item in item_candidates):
-                failed(f"Plando block for player {player} ({multiworld.player_name[player]}) contains both "
-                       f"event items and non-event items. "
-                       f"Event items: {[item for item in item_candidates if item.code is None]}, "
-                       f"Non-event items: {[item for item in item_candidates if item.code is not None]}",
-                       placement.force)
-                continue
-            else:
-                is_real = item_candidates[0].code is not None
-            candidates = [candidate for candidate in locations if candidate.item is None
-                          and bool(candidate.address) == is_real]
+            candidates = list(multiworld.get_unfilled_locations_for_players(locations, sorted(worlds)))
             multiworld.random.shuffle(candidates)
-            allstate = multiworld.get_all_state(False)
-            mincount = placement.count["min"]
-            allowed_margin = len(item_candidates) - mincount
-            fill_restrictive(multiworld, allstate, candidates, item_candidates, lock=True,
-                             allow_partial=True, name="Plando Main Fill")
+            multiworld.random.shuffle(items)
+            count = 0
+            err: typing.List[str] = []
+            successful_pairs: typing.List[typing.Tuple[int, Item, Location]] = []
+            claimed_indices: typing.Set[typing.Optional[int]] = set()
+            for item_name in items:
+                index_to_delete: typing.Optional[int] = None
+                if from_pool:
+                    try:
+                        # If from_pool, try to find an existing item with this name & player in the itempool and use it
+                        index_to_delete, item = next(
+                            (i, item) for i, item in enumerate(multiworld.itempool)
+                            if item.player == player and item.name == item_name and i not in claimed_indices
+                        )
+                    except StopIteration:
+                        warn(
+                        f"Could not remove {item_name} from pool for {multiworld.player_name[player]} as it's already missing from it.",
+                        placement['force'])
+                        item = multiworld.worlds[player].create_item(item_name)
+                else:
+                    item = multiworld.worlds[player].create_item(item_name)
+
+                for location in reversed(candidates):
+                    if (location.address is None) == (item.code is None):  # either both None or both not None
+                        if not location.item:
+                            if location.item_rule(item):
+                                if location.can_fill(multiworld.state, item, False):
+                                    successful_pairs.append((index_to_delete, item, location))
+                                    claimed_indices.add(index_to_delete)
+                                    candidates.remove(location)
+                                    count = count + 1
+                                    break
+                                else:
+                                    err.append(f"Can't place item at {location} due to fill condition not met.")
+                            else:
+                                err.append(f"{item_name} not allowed at {location}.")
+                        else:
+                            err.append(f"Cannot place {item_name} into already filled location {location}.")
+                    else:
+                        err.append(f"Mismatch between {item_name} and {location}, only one is an event.")
+
+                if count == maxcount:
+                    break
+            if count < placement['count']['min']:
+                m = placement['count']['min']
+                failed(
+                    f"Plando block failed to place {m - count} of {m} item(s) for {multiworld.player_name[player]}, error(s): {' '.join(err)}",
+                    placement['force'])
+
+            # Sort indices in reverse so we can remove them one by one
+            successful_pairs = sorted(successful_pairs, key=lambda successful_pair: successful_pair[0] or 0, reverse=True)
+
+            for (index, item, location) in successful_pairs:
+                multiworld.push_item(location, item, collect=False)
+                location.locked = True
+                logging.debug(f"Plando placed {item} at {location}")
+                if index is not None:  # If this item is from_pool and was found in the pool, remove it.
+                    multiworld.itempool.pop(index)
 
-            if len(item_candidates) > allowed_margin:
-                failed(f"Could not place {len(item_candidates)} "
-                       f"of {mincount + allowed_margin} item(s) "
-                       f"for {multiworld.player_name[player]}, "
-                       f"remaining items: {item_candidates}",
-                       placement.force)
-            if from_pool:
-                multiworld.itempool.extend([item for item in item_candidates if item.code is not None])
         except Exception as e:
             raise Exception(
                 f"Error running plando for player {player} ({multiworld.player_name[player]})") from e

Generate.py

@@ -10,8 +10,8 @@ import sys
 import urllib.parse
 import urllib.request
 from collections import Counter
+from typing import Any, Dict, Tuple, Union
 from itertools import chain
-from typing import Any
 
 import ModuleUpdate
 
@@ -77,7 +77,7 @@ def get_seed_name(random_source) -> str:
     return f"{random_source.randint(0, pow(10, seeddigits) - 1)}".zfill(seeddigits)
 
 
-def main(args=None) -> tuple[argparse.Namespace, int]:
+def main(args=None) -> Tuple[argparse.Namespace, int]:
     # __name__ == "__main__" check so unittests that already imported worlds don't trip this.
     if __name__ == "__main__" and "worlds" in sys.modules:
         raise Exception("Worlds system should not be loaded before logging init.")
@@ -95,7 +95,7 @@ def main(args=None) -> tuple[argparse.Namespace, int]:
         logging.info("Race mode enabled. Using non-deterministic random source.")
         random.seed()  # reset to time-based random source
 
-    weights_cache: dict[str, tuple[Any, ...]] = {}
+    weights_cache: Dict[str, Tuple[Any, ...]] = {}
     if args.weights_file_path and os.path.exists(args.weights_file_path):
         try:
             weights_cache[args.weights_file_path] = read_weights_yamls(args.weights_file_path)
@@ -180,7 +180,7 @@ def main(args=None) -> tuple[argparse.Namespace, int]:
     erargs.name = {}
     erargs.csv_output = args.csv_output
 
-    settings_cache: dict[str, tuple[argparse.Namespace, ...]] = \
+    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()}
 
@@ -212,7 +212,7 @@ def main(args=None) -> tuple[argparse.Namespace, int]:
         path = player_path_cache[player]
         if path:
             try:
-                settings: tuple[argparse.Namespace, ...] = settings_cache[path] if settings_cache[path] else \
+                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():
@@ -224,14 +224,10 @@ def main(args=None) -> tuple[argparse.Namespace, int]:
                             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 erargs.name:
-                        if path == args.weights_file_path:
-                            # weights file, so we need to make the name unique
-                            erargs.name[player] = f"Player{player}"
-                        else:
-                            # use the filename
-                            erargs.name[player] = os.path.splitext(os.path.split(path)[-1])[0]
+                    if path == args.weights_file_path:  # if name came from the weights file, just use base player name
+                        erargs.name[player] = f"Player{player}"
+                    elif player not in erargs.name:  # if name was not specified, generate it from filename
+                        erargs.name[player] = os.path.splitext(os.path.split(path)[-1])[0]
                     erargs.name[player] = handle_name(erargs.name[player], player, name_counter)
 
                     player += 1
@@ -246,7 +242,7 @@ def main(args=None) -> tuple[argparse.Namespace, int]:
     return erargs, seed
 
 
-def read_weights_yamls(path) -> tuple[Any, ...]:
+def read_weights_yamls(path) -> Tuple[Any, ...]:
     try:
         if urllib.parse.urlparse(path).scheme in ('https', 'file'):
             yaml = str(urllib.request.urlopen(path).read(), "utf-8-sig")
@@ -256,20 +252,7 @@ def read_weights_yamls(path) -> tuple[Any, ...]:
     except Exception as e:
         raise Exception(f"Failed to read weights ({path})") from e
 
-    from yaml.error import MarkedYAMLError
-    try:
-        return tuple(parse_yamls(yaml))
-    except MarkedYAMLError as ex:
-        if ex.problem_mark:
-            lines = yaml.splitlines()
-            if ex.context_mark:
-                relevant_lines = "\n".join(lines[ex.context_mark.line:ex.problem_mark.line+1])
-            else:
-                relevant_lines = lines[ex.problem_mark.line]
-            error_line = " " * ex.problem_mark.column + "^"
-            raise Exception(f"{ex.context} {ex.problem} on line {ex.problem_mark.line}:"
-                            f"\n{relevant_lines}\n{error_line}")
-        raise ex
+    return tuple(parse_yamls(yaml))
 
 
 def interpret_on_off(value) -> bool:
@@ -338,6 +321,12 @@ def handle_name(name: str, player: int, name_counter: Counter):
     return new_name
 
 
+def roll_percentage(percentage: Union[int, float]) -> bool:
+    """Roll a percentage chance.
+    percentage is expected to be in range [0, 100]"""
+    return random.random() < (float(percentage) / 100)
+
+
 def update_weights(weights: dict, new_weights: dict, update_type: str, name: str) -> dict:
     logging.debug(f'Applying {new_weights}')
     cleaned_weights = {}
@@ -382,7 +371,7 @@ def update_weights(weights: dict, new_weights: dict, update_type: str, name: str
     return weights
 
 
-def roll_meta_option(option_key, game: str, category_dict: dict) -> Any:
+def roll_meta_option(option_key, game: str, category_dict: Dict) -> Any:
     from worlds import AutoWorldRegister
 
     if not game:
@@ -403,7 +392,7 @@ def roll_linked_options(weights: dict) -> dict:
         if "name" not in option_set:
             raise ValueError("One of your linked options does not have a name.")
         try:
-            if Options.roll_percentage(option_set["percentage"]):
+            if roll_percentage(option_set["percentage"]):
                 logging.debug(f"Linked option {option_set['name']} triggered.")
                 new_options = option_set["options"]
                 for category_name, category_options in new_options.items():
@@ -436,7 +425,7 @@ def roll_triggers(weights: dict, triggers: list, valid_keys: set) -> dict:
             trigger_result = get_choice("option_result", option_set)
             result = get_choice(key, currently_targeted_weights)
             currently_targeted_weights[key] = result
-            if result == trigger_result and Options.roll_percentage(get_choice("percentage", option_set, 100)):
+            if result == trigger_result and roll_percentage(get_choice("percentage", option_set, 100)):
                 for category_name, category_options in option_set["options"].items():
                     currently_targeted_weights = weights
                     if category_name:
@@ -467,14 +456,6 @@ def handle_option(ret: argparse.Namespace, game_weights: dict, option_key: str,
 
 
 def roll_settings(weights: dict, plando_options: PlandoOptions = PlandoOptions.bosses):
-    """
-    Roll options from specified weights, usually originating from a .yaml options file.
-
-    Important note:
-    The same weights dict is shared between all slots using the same yaml (e.g. generic weights file for filler slots).
-    This means it should never be modified without making a deepcopy first.
-    """
-
     from worlds import AutoWorldRegister
 
     if "linked_options" in weights:
@@ -540,6 +521,10 @@ def roll_settings(weights: dict, plando_options: PlandoOptions = PlandoOptions.b
         handle_option(ret, game_weights, option_key, option, plando_options)
         valid_keys.add(option_key)
 
+    # TODO remove plando_items after moving it to the options system
+    valid_keys.add("plando_items")
+    if PlandoOptions.items in plando_options:
+        ret.plando_items = copy.deepcopy(game_weights.get("plando_items", []))
     if ret.game == "A Link to the Past":
         # TODO there are still more LTTP options not on the options system
         valid_keys |= {"sprite_pool", "sprite", "random_sprite_on_event"}

Launcher.py

@@ -1,11 +1,11 @@
 """
 Archipelago Launcher
 
-* If run with a patch file as argument, launch corresponding client with the patch file as an argument.
-* If run with component name as argument, run it passing argv[2:] as arguments.
-* If run without arguments or unknown arguments, open launcher GUI.
+* if run with APBP as argument, launch corresponding client.
+* if run with executable as argument, run it passing argv[2:] as arguments
+* if run without arguments, open launcher GUI
 
-Additional components can be added to worlds.LauncherComponents.components.
+Scroll down to components= to add components to the launcher as well as setup.py
 """
 
 import argparse
@@ -16,10 +16,9 @@ import subprocess
 import sys
 import urllib.parse
 import webbrowser
-from collections.abc import Callable, Sequence
 from os.path import isfile
 from shutil import which
-from typing import Any
+from typing import Callable, Optional, Sequence, Tuple, Union, Any
 
 if __name__ == "__main__":
     import ModuleUpdate
@@ -85,16 +84,12 @@ def browse_files():
 def open_folder(folder_path):
     if is_linux:
         exe = which('xdg-open') or which('gnome-open') or which('kde-open')
+        subprocess.Popen([exe, folder_path])
     elif is_macos:
         exe = which("open")
-    else:
-        webbrowser.open(folder_path)
-        return
-
-    if exe:
         subprocess.Popen([exe, folder_path])
     else:
-        logging.warning(f"No file browser available to open {folder_path}")
+        webbrowser.open(folder_path)
 
 
 def update_settings():
@@ -115,33 +110,55 @@ components.extend([
 ])
 
 
-def handle_uri(path: str) -> tuple[list[Component], Component]:
+def handle_uri(path: str, launch_args: Tuple[str, ...]) -> None:
     url = urllib.parse.urlparse(path)
     queries = urllib.parse.parse_qs(url.query)
-    client_components = []
+    launch_args = (path, *launch_args)
+    client_component = []
     text_client_component = None
-    game = queries["game"][0]
+    if "game" in queries:
+        game = queries["game"][0]
+    else:  # TODO around 0.6.0 - this is for pre this change webhost uri's
+        game = "Archipelago"
     for component in components:
         if component.supports_uri and component.game_name == game:
-            client_components.append(component)
+            client_component.append(component)
         elif component.display_name == "Text Client":
             text_client_component = component
-    return client_components, text_client_component
+
+    from kvui import MDButton, MDButtonText
+    from kivymd.uix.dialog import MDDialog, MDDialogHeadlineText, MDDialogContentContainer, MDDialogSupportingText
+    from kivymd.uix.divider import MDDivider
+
+    if not client_component:
+        run_component(text_client_component, *launch_args)
+        return
+    else:
+        popup_text = MDDialogSupportingText(text="Select client to open and connect with.")
+        component_buttons = [MDDivider()]
+        for component in [text_client_component, *client_component]:
+            component_buttons.append(MDButton(
+                MDButtonText(text=component.display_name),
+                on_release=lambda *args, comp=component: run_component(comp, *launch_args),
+                style="text"
+            ))
+        component_buttons.append(MDDivider())
+
+    MDDialog(
+        # Headline
+        MDDialogHeadlineText(text="Connect to Multiworld"),
+        # Text
+        popup_text,
+        # Content
+        MDDialogContentContainer(
+            *component_buttons,
+            orientation="vertical"
+        ),
+
+    ).open()
 
 
-def build_uri_popup(component_list: list[Component], launch_args: tuple[str, ...]) -> None:
-    from kvui import ButtonsPrompt
-    component_options = {
-        component.display_name: component for component in component_list
-    }
-    popup = ButtonsPrompt("Connect to Multiworld",
-                          "Select client to open and connect with.",
-                          lambda component_name: run_component(component_options[component_name], *launch_args),
-                          *component_options.keys())
-    popup.open()
-
-
-def identify(path: None | str) -> tuple[None | str, None | Component]:
+def identify(path: Union[None, str]) -> Tuple[Union[None, str], Union[None, Component]]:
     if path is None:
         return None, None
     for component in components:
@@ -152,7 +169,7 @@ def identify(path: None | str) -> tuple[None | str, None | Component]:
     return None, None
 
 
-def get_exe(component: str | Component) -> Sequence[str] | None:
+def get_exe(component: Union[str, Component]) -> Optional[Sequence[str]]:
     if isinstance(component, str):
         name = component
         component = None
@@ -205,19 +222,18 @@ def create_shortcut(button: Any, component: Component) -> None:
     button.menu.dismiss()
 
 
-refresh_components: Callable[[], None] | None = None
+refresh_components: Optional[Callable[[], None]] = None
 
 
-def run_gui(launch_components: list[Component], args: Any) -> None:
+def run_gui(path: str, args: Any) -> None:
     from kvui import (ThemedApp, MDFloatLayout, MDGridLayout, ScrollBox)
     from kivy.properties import ObjectProperty
     from kivy.core.window import Window
     from kivy.metrics import dp
-    from kivymd.uix.button import MDIconButton, MDButton
+    from kivymd.uix.button import MDIconButton
     from kivymd.uix.card import MDCard
     from kivymd.uix.menu import MDDropdownMenu
     from kivymd.uix.snackbar import MDSnackbar, MDSnackbarText
-    from kivymd.uix.textfield import MDTextField
 
     from kivy.lang.builder import Builder
 
@@ -237,16 +253,15 @@ def run_gui(launch_components: list[Component], args: Any) -> None:
         navigation: MDGridLayout = ObjectProperty(None)
         grid: MDGridLayout = ObjectProperty(None)
         button_layout: ScrollBox = ObjectProperty(None)
-        search_box: MDTextField = ObjectProperty(None)
         cards: list[LauncherCard]
         current_filter: Sequence[str | Type] | None
 
-        def __init__(self, ctx=None, components=None, args=None):
+        def __init__(self, ctx=None, path=None, args=None):
             self.title = self.base_title + " " + Utils.__version__
             self.ctx = ctx
             self.icon = r"data/icon.png"
             self.favorites = []
-            self.launch_components = components
+            self.launch_uri = path
             self.launch_args = args
             self.cards = []
             self.current_filter = (Type.CLIENT, Type.TOOL, Type.ADJUSTER, Type.MISC)
@@ -323,29 +338,14 @@ def run_gui(launch_components: list[Component], args: Any) -> None:
             scroll_percent = self.button_layout.convert_distance_to_scroll(0, top)
             self.button_layout.scroll_y = max(0, min(1, scroll_percent[1]))
 
-        def filter_clients_by_type(self, caller: MDButton):
+        def filter_clients(self, caller):
             self._refresh_components(caller.type)
-            self.search_box.text = ""
-
-        def filter_clients_by_name(self, caller: MDTextField, name: str) -> None:
-            if len(name) == 0:
-                self._refresh_components(self.current_filter)
-                return
-
-            sub_matches = [
-                card for card in self.cards
-                if name.lower() in card.component.display_name.lower() and card.component.type != Type.HIDDEN
-            ]
-            self.button_layout.layout.clear_widgets()
-            for card in sub_matches:
-                self.button_layout.layout.add_widget(card)
 
         def build(self):
             self.top_screen = Builder.load_file(Utils.local_path("data/launcher.kv"))
             self.grid = self.top_screen.ids.grid
             self.navigation = self.top_screen.ids.navigation
             self.button_layout = self.top_screen.ids.button_layout
-            self.search_box = self.top_screen.ids.search_box
             self.set_colors()
             self.top_screen.md_bg_color = self.theme_cls.backgroundColor
 
@@ -353,24 +353,18 @@ def run_gui(launch_components: list[Component], args: Any) -> None:
             refresh_components = self._refresh_components
 
             Window.bind(on_drop_file=self._on_drop_file)
-            Window.bind(on_keyboard=self._on_keyboard)
 
             for component in components:
                 self.cards.append(self.build_card(component))
 
             self._refresh_components(self.current_filter)
 
-            # Uncomment to re-enable the Kivy console/live editor
-            # Ctrl-E to enable it, make sure numlock/capslock is disabled
-            # from kivy.modules.console import create_console
-            # create_console(Window, self.top_screen)
-
             return self.top_screen
 
         def on_start(self):
-            if self.launch_components:
-                build_uri_popup(self.launch_components, self.launch_args)
-                self.launch_components = None
+            if self.launch_uri:
+                handle_uri(self.launch_uri, self.launch_args)
+                self.launch_uri = None
                 self.launch_args = None
 
         @staticmethod
@@ -388,16 +382,7 @@ def run_gui(launch_components: list[Component], args: Any) -> None:
             if file and component:
                 run_component(component, file)
             else:
-                logging.warning(f"unable to identify component for {filename}")
-
-        def _on_keyboard(self, window: Window, key: int, scancode: int, codepoint: str, modifier: list[str]):
-            # Activate search as soon as we start typing, no matter if we are focused on the search box or not.
-            # Focus first, then capture the first character we type, otherwise it gets swallowed and lost.
-            # Limit text input to ASCII non-control characters (space bar to tilde).
-            if not self.search_box.focus:
-                self.search_box.focus = True
-                if key in range(32, 126):
-                    self.search_box.text += codepoint
+                logging.warning(f"unable to identify component for {file}")
 
         def _stop(self, *largs):
             # ran into what appears to be https://groups.google.com/g/kivy-users/c/saWDLoYCSZ4 with PyCharm.
@@ -411,7 +396,7 @@ def run_gui(launch_components: list[Component], args: Any) -> None:
                                                                    for filter in self.current_filter))
             super().on_stop()
 
-    Launcher(components=launch_components, args=args).run()
+    Launcher(path=path, args=args).run()
 
     # avoiding Launcher reference leak
     # and don't try to do something with widgets after window closed
@@ -430,7 +415,7 @@ def run_component(component: Component, *args):
         logging.warning(f"Component {component} does not appear to be executable.")
 
 
-def main(args: argparse.Namespace | dict | None = None):
+def main(args: Optional[Union[argparse.Namespace, dict]] = None):
     if isinstance(args, argparse.Namespace):
         args = {k: v for k, v in args._get_kwargs()}
     elif not args:
@@ -438,15 +423,7 @@ def main(args: argparse.Namespace | dict | None = None):
 
     path = args.get("Patch|Game|Component|url", None)
     if path is not None:
-        if path.startswith("archipelago://"):
-            args["args"] = (path, *args.get("args", ()))
-            # add the url arg to the passthrough args
-            components, text_client_component = handle_uri(path)
-            if not components:
-                args["component"] = text_client_component
-            else:
-                args['launch_components'] = [text_client_component, *components]
-        else:
+        if not path.startswith("archipelago://"):
             file, component = identify(path)
             if file:
                 args['file'] = file
@@ -462,7 +439,7 @@ def main(args: argparse.Namespace | dict | None = None):
     elif "component" in args:
         run_component(args["component"], *args["args"])
     elif not args["update_settings"]:
-        run_gui(args.get("launch_components", None), args.get("args", ()))
+        run_gui(path, args.get("args", ()))
 
 
 if __name__ == '__main__':

LinksAwakeningClient.py

@@ -33,7 +33,7 @@ from worlds.ladx.TrackerConsts import storage_key
 from worlds.ladx.ItemTracker import ItemTracker
 from worlds.ladx.LADXR.checkMetadata import checkMetadataTable
 from worlds.ladx.Locations import get_locations_to_id, meta_to_name
-from worlds.ladx.Tracker import LocationTracker, MagpieBridge, Check
+from worlds.ladx.Tracker import LocationTracker, MagpieBridge
 
 
 class GameboyException(Exception):
@@ -52,6 +52,22 @@ class BadRetroArchResponse(GameboyException):
     pass
 
 
+def magpie_logo():
+    from kivy.uix.image import CoreImage
+    binary_data = """
+iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAIAAACQkWg2AAAAAXN
+SR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA
+7DAcdvqGQAAADGSURBVDhPhVLBEcIwDHOYhjHCBuXHj2OTbAL8+
+MEGZIxOQ1CinOOk0Op0bmo7tlXXeR9FJMYDLOD9mwcLjQK7+hSZ
+wgcWMZJOAGeGKtChNHFL0j+FZD3jSCuo0w7l03wDrWdg00C4/aW
+eDEYNenuzPOfPspBnxf0kssE80vN0L8361j10P03DK4x6FHabuV
+ear8fHme+b17rwSjbAXeUMLb+EVTV2QHm46MWQanmnydA98KsVS
+XkV+qFpGQXrLhT/fqraQeQLuplpNH5g+WkAAAAASUVORK5CYII="""
+    binary_data = base64.b64decode(binary_data)
+    data = io.BytesIO(binary_data)
+    return CoreImage(data, ext="png").texture
+
+
 class LAClientConstants:
     # Connector version
     VERSION = 0x01
@@ -514,9 +530,7 @@ class LinksAwakeningContext(CommonContext):
 
     def run_gui(self) -> None:
         import webbrowser
-        from kvui import GameManager
-        from kivy.metrics import dp
-        from kivymd.uix.button import MDButton, MDButtonText
+        from kvui import GameManager, ImageButton
 
         class LADXManager(GameManager):
             logging_pairs = [
@@ -529,10 +543,8 @@ class LinksAwakeningContext(CommonContext):
                 b = super().build()
 
                 if self.ctx.magpie_enabled:
-                    button = MDButton(MDButtonText(text="Open Tracker"), style="filled", size=(dp(100), dp(70)), radius=5,
-                                      size_hint_x=None, size_hint_y=None, pos_hint={"center_y": 0.55},
-                                      on_press=lambda _: webbrowser.open('https://magpietracker.us/?enable_autotracker=1'))
-                    button.height = self.server_connect_bar.height
+                    button = ImageButton(texture=magpie_logo(), fit_mode="cover", image_size=(32, 32), size_hint_x=None,
+                                on_press=lambda _: webbrowser.open('https://magpietracker.us/?enable_autotracker=1'))
                     self.connect_layout.add_widget(button)
 
                 return b
@@ -626,11 +638,6 @@ class LinksAwakeningContext(CommonContext):
                 "password": self.password,
             })
 
-            # We can process linked items on already-checked checks now that we have slot_data
-            if self.client.tracker:
-                checked_checks = set(self.client.tracker.all_checks) - set(self.client.tracker.remaining_checks)
-                self.add_linked_items(checked_checks)
-
         # TODO - use watcher_event
         if cmd == "ReceivedItems":
             for index, item in enumerate(args["items"], start=args["index"]):
@@ -646,13 +653,6 @@ class LinksAwakeningContext(CommonContext):
         sync_msg = [{'cmd': 'Sync'}]
         await self.send_msgs(sync_msg)
 
-    def add_linked_items(self, checks: typing.List[Check]):
-        for check in checks:
-            if check.value and check.linkedItem:
-                linkedItem = check.linkedItem
-                if 'condition' not in linkedItem or (self.slot_data and linkedItem['condition'](self.slot_data)):
-                    self.client.item_tracker.setExtraItem(check.linkedItem['item'], check.linkedItem['qty'])
-
     item_id_lookup = get_locations_to_id()
 
     async def run_game_loop(self):
@@ -661,7 +661,11 @@ class LinksAwakeningContext(CommonContext):
                 checkMetadataTable[check.id])] for check in ladxr_checks]
             self.new_checks(checks, [check.id for check in ladxr_checks])
 
-            self.add_linked_items(ladxr_checks)
+            for check in ladxr_checks:
+                if check.value and check.linkedItem:
+                    linkedItem = check.linkedItem
+                    if 'condition' not in linkedItem or linkedItem['condition'](self.slot_data):
+                        self.client.item_tracker.setExtraItem(check.linkedItem['item'], check.linkedItem['qty'])
 
         async def victory():
             await self.send_victory()

Main.py

@@ -7,13 +7,14 @@ import tempfile
 import time
 import zipfile
 import zlib
+from typing import Dict, List, Optional, Set, Tuple, Union
 
 import worlds
-from BaseClasses import CollectionState, Item, Location, LocationProgressType, MultiWorld
-from Fill import FillError, balance_multiworld_progression, distribute_items_restrictive, flood_items, \
-    parse_planned_blocks, distribute_planned_blocks, resolve_early_locations_for_planned
+from BaseClasses import CollectionState, Item, Location, LocationProgressType, MultiWorld, Region
+from Fill import FillError, balance_multiworld_progression, distribute_items_restrictive, distribute_planned, \
+    flood_items
 from Options import StartInventoryPool
-from Utils import __version__, output_path, version_tuple
+from Utils import __version__, output_path, version_tuple, get_settings
 from settings import get_settings
 from worlds import AutoWorld
 from worlds.generic.Rules import exclusion_rules, locality_rules
@@ -21,7 +22,7 @@ from worlds.generic.Rules import exclusion_rules, locality_rules
 __all__ = ["main"]
 
 
-def main(args, seed=None, baked_server_options: dict[str, object] | None = None):
+def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = None):
     if not baked_server_options:
         baked_server_options = get_settings().server_options.as_dict()
     assert isinstance(baked_server_options, dict)
@@ -36,6 +37,9 @@ def main(args, seed=None, baked_server_options: dict[str, object] | None = None)
     logger = logging.getLogger()
     multiworld.set_seed(seed, args.race, str(args.outputname) if args.outputname else None)
     multiworld.plando_options = args.plando_options
+    multiworld.plando_items = args.plando_items.copy()
+    multiworld.plando_texts = args.plando_texts.copy()
+    multiworld.plando_connections = args.plando_connections.copy()
     multiworld.game = args.game.copy()
     multiworld.player_name = args.name.copy()
     multiworld.sprite = args.sprite.copy()
@@ -52,15 +56,29 @@ def main(args, seed=None, baked_server_options: dict[str, object] | None = None)
     logger.info(f"Found {len(AutoWorld.AutoWorldRegister.world_types)} World Types:")
     longest_name = max(len(text) for text in AutoWorld.AutoWorldRegister.world_types)
 
+    max_item = 0
+    max_location = 0
+    for cls in AutoWorld.AutoWorldRegister.world_types.values():
+        if cls.item_id_to_name:
+            max_item = max(max_item, max(cls.item_id_to_name))
+            max_location = max(max_location, max(cls.location_id_to_name))
+
+    item_digits = len(str(max_item))
+    location_digits = len(str(max_location))
     item_count = len(str(max(len(cls.item_names) for cls in AutoWorld.AutoWorldRegister.world_types.values())))
     location_count = len(str(max(len(cls.location_names) for cls in AutoWorld.AutoWorldRegister.world_types.values())))
+    del max_item, max_location
 
     for name, cls in AutoWorld.AutoWorldRegister.world_types.items():
         if not cls.hidden and len(cls.item_names) > 0:
-            logger.info(f" {name:{longest_name}}: Items: {len(cls.item_names):{item_count}} | "
-                        f"Locations: {len(cls.location_names):{location_count}}")
+            logger.info(f" {name:{longest_name}}: {len(cls.item_names):{item_count}} "
+                        f"Items (IDs: {min(cls.item_id_to_name):{item_digits}} - "
+                        f"{max(cls.item_id_to_name):{item_digits}}) | "
+                        f"{len(cls.location_names):{location_count}} "
+                        f"Locations (IDs: {min(cls.location_id_to_name):{location_digits}} - "
+                        f"{max(cls.location_id_to_name):{location_digits}})")
 
-    del item_count, location_count
+    del item_digits, location_digits, item_count, location_count
 
     # This assertion method should not be necessary to run if we are not outputting any multidata.
     if not args.skip_output and not args.spoiler_only:
@@ -131,15 +149,13 @@ def main(args, seed=None, baked_server_options: dict[str, object] | None = None)
         multiworld.worlds[1].options.non_local_items.value = set()
         multiworld.worlds[1].options.local_items.value = set()
 
-    multiworld.plando_item_blocks = parse_planned_blocks(multiworld)
-
     AutoWorld.call_all(multiworld, "connect_entrances")
     AutoWorld.call_all(multiworld, "generate_basic")
 
     # remove starting inventory from pool items.
     # Because some worlds don't actually create items during create_items this has to be as late as possible.
     fallback_inventory = StartInventoryPool({})
-    depletion_pool: dict[int, dict[str, int]] = {
+    depletion_pool: Dict[int, Dict[str, int]] = {
         player: getattr(multiworld.worlds[player].options, "start_inventory_from_pool", fallback_inventory).value.copy()
         for player in multiworld.player_ids
     }
@@ -148,7 +164,7 @@ def main(args, seed=None, baked_server_options: dict[str, object] | None = None)
     }
 
     if target_per_player:
-        new_itempool: list[Item] = []
+        new_itempool: List[Item] = []
 
         # Make new itempool with start_inventory_from_pool items removed
         for item in multiworld.itempool:
@@ -177,9 +193,8 @@ def main(args, seed=None, baked_server_options: dict[str, object] | None = None)
         multiworld._all_state = None
 
     logger.info("Running Item Plando.")
-    resolve_early_locations_for_planned(multiworld)
-    distribute_planned_blocks(multiworld, [x for player in multiworld.plando_item_blocks
-                                           for x in multiworld.plando_item_blocks[player]])
+
+    distribute_planned(multiworld)
 
     logger.info('Running Pre Main Fill.')
 
@@ -232,7 +247,7 @@ def main(args, seed=None, baked_server_options: dict[str, object] | None = None)
                     pool.submit(AutoWorld.call_single, multiworld, "generate_output", player, temp_dir))
 
             # collect ER hint info
-            er_hint_data: dict[int, dict[int, str]] = {}
+            er_hint_data: Dict[int, Dict[int, str]] = {}
             AutoWorld.call_all(multiworld, 'extend_hint_information', er_hint_data)
 
             def write_multidata():
@@ -273,7 +288,7 @@ def main(args, seed=None, baked_server_options: dict[str, object] | None = None)
                         for player in multiworld.groups[location.item.player]["players"]:
                             precollected_hints[player].add(hint)
 
-                locations_data: dict[int, dict[int, tuple[int, int, int]]] = {player: {} for player in multiworld.player_ids}
+                locations_data: Dict[int, Dict[int, Tuple[int, int, int]]] = {player: {} for player in multiworld.player_ids}
                 for location in multiworld.get_filled_locations():
                     if type(location.address) == int:
                         assert location.item.code is not None, "item code None should be event, " \
@@ -300,14 +315,13 @@ def main(args, seed=None, baked_server_options: dict[str, object] | None = None)
                     game_world.game: worlds.network_data_package["games"][game_world.game]
                     for game_world in multiworld.worlds.values()
                 }
-                data_package["Archipelago"] = worlds.network_data_package["games"]["Archipelago"]
 
-                checks_in_area: dict[int, dict[str, int | list[int]]] = {}
+                checks_in_area: Dict[int, Dict[str, Union[int, List[int]]]] = {}
 
                 # get spheres -> filter address==None -> skip empty
-                spheres: list[dict[int, set[int]]] = []
+                spheres: List[Dict[int, Set[int]]] = []
                 for sphere in multiworld.get_sendable_spheres():
-                    current_sphere: dict[int, set[int]] = collections.defaultdict(set)
+                    current_sphere: Dict[int, Set[int]] = collections.defaultdict(set)
                     for sphere_location in sphere:
                         current_sphere[sphere_location.player].add(sphere_location.address)
 

MinecraftClient.py

@@ -14,7 +14,6 @@ import requests
 
 import Utils
 from Utils import is_windows
-from settings import get_settings
 
 atexit.register(input, "Press enter to exit.")
 
@@ -148,11 +147,9 @@ def find_jdk(version: str) -> str:
         if os.path.isfile(jdk_exe):
             return jdk_exe
     else:
-        jdk_exe = shutil.which(options.java)
+        jdk_exe = shutil.which(options["minecraft_options"].get("java", "java"))
         if not jdk_exe:
-            jdk_exe = shutil.which("java") # try to fall back to system java
-            if not jdk_exe:
-                raise Exception("Could not find Java. Is Java installed on the system?")
+            raise Exception("Could not find Java. Is Java installed on the system?")
         return jdk_exe
 
 
@@ -288,8 +285,8 @@ if __name__ == '__main__':
     # Change to executable's working directory
     os.chdir(os.path.abspath(os.path.dirname(sys.argv[0])))
 
-    options = get_settings().minecraft_options
-    channel = args.channel or options.release_channel
+    options = Utils.get_options()
+    channel = args.channel or options["minecraft_options"]["release_channel"]
     apmc_data = None
     data_version = args.data_version or None
 
@@ -302,8 +299,8 @@ if __name__ == '__main__':
 
     versions = get_minecraft_versions(data_version, channel)
 
-    forge_dir = options.forge_directory
-    max_heap = options.max_heap_size
+    forge_dir = options["minecraft_options"]["forge_directory"]
+    max_heap = options["minecraft_options"]["max_heap_size"]
     forge_version = args.forge or versions["forge"]
     java_version = args.java or versions["java"]
     mod_url = versions["url"]

MultiServer.py

@@ -46,8 +46,7 @@ from NetUtils import Endpoint, ClientStatus, NetworkItem, decode, encode, Networ
     SlotType, LocationStore, Hint, HintStatus
 from BaseClasses import ItemClassification
 
-
-min_client_version = Version(0, 5, 0)
+min_client_version = Version(0, 1, 6)
 colorama.just_fix_windows_console()
 
 
@@ -458,12 +457,8 @@ class Context:
         self.generator_version = Version(*decoded_obj["version"])
         clients_ver = decoded_obj["minimum_versions"].get("clients", {})
         self.minimum_client_versions = {}
-        if self.generator_version < Version(0, 6, 2):
-            min_version = Version(0, 1, 6)
-        else:
-            min_version = min_client_version
         for player, version in clients_ver.items():
-            self.minimum_client_versions[player] = max(Version(*version), min_version)
+            self.minimum_client_versions[player] = max(Version(*version), min_client_version)
 
         self.slot_info = decoded_obj["slot_info"]
         self.games = {slot: slot_info.game for slot, slot_info in self.slot_info.items()}
@@ -797,9 +792,10 @@ class Context:
         return None
     
     def replace_hint(self, team: int, slot: int, old_hint: Hint, new_hint: Hint) -> None:
-        if old_hint in self.hints[team, slot]:
-            self.hints[team, slot].remove(old_hint)
-            self.hints[team, slot].add(new_hint)
+        for real_slot in self.slot_set(slot):
+            if old_hint in self.hints[team, real_slot]:
+                self.hints[team, real_slot].remove(old_hint)
+                self.hints[team, real_slot].add(new_hint)
     
     # "events"
 
@@ -1830,7 +1826,7 @@ async def process_client_cmd(ctx: Context, client: Client, args: dict):
             ctx.clients[team][slot].append(client)
             client.version = args['version']
             client.tags = args['tags']
-            client.no_locations = bool(client.tags & _non_game_messages.keys())
+            client.no_locations = "TextOnly" in client.tags or "Tracker" in client.tags
             # set NoText for old PopTracker clients that predate the tag to save traffic
             client.no_text = "NoText" in client.tags or ("PopTracker" in client.tags and client.version < (0, 5, 1))
             connected_packet = {
@@ -1904,7 +1900,7 @@ async def process_client_cmd(ctx: Context, client: Client, args: dict):
                 old_tags = client.tags
                 client.tags = args["tags"]
                 if set(old_tags) != set(client.tags):
-                    client.no_locations = bool(client.tags & _non_game_messages.keys())
+                    client.no_locations = 'TextOnly' in client.tags or 'Tracker' in client.tags
                     client.no_text = "NoText" in client.tags or (
                         "PopTracker" in client.tags and client.version < (0, 5, 1)
                     )
@@ -1987,21 +1983,14 @@ async def process_client_cmd(ctx: Context, client: Client, args: dict):
             new_hint = new_hint.re_prioritize(ctx, status)
             if hint == new_hint:
                 return
-
-            concerning_slots = ctx.slot_set(hint.receiving_player) | {hint.finding_player}
-            for slot in concerning_slots:
-                ctx.replace_hint(client.team, slot, hint, new_hint)
+            ctx.replace_hint(client.team, hint.finding_player, hint, new_hint)
+            ctx.replace_hint(client.team, hint.receiving_player, hint, new_hint)
             ctx.save()
-            for slot in concerning_slots:
-                ctx.on_changed_hints(client.team, slot)
-
+            ctx.on_changed_hints(client.team, hint.finding_player)
+            ctx.on_changed_hints(client.team, hint.receiving_player)
+        
         elif cmd == 'StatusUpdate':
-            if client.no_locations and args["status"] == ClientStatus.CLIENT_GOAL:
-                await ctx.send_msgs(client, [{'cmd': 'InvalidPacket', "type": "cmd",
-                                              "text": "Trackers can't register Goal Complete",
-                                              "original_cmd": cmd}])
-            else:
-                update_client_status(ctx, client, args["status"])
+            update_client_status(ctx, client, args["status"])
 
         elif cmd == 'Say':
             if "text" not in args or type(args["text"]) is not str or not args["text"].isprintable():
@@ -2428,10 +2417,8 @@ async def console(ctx: Context):
 
 
 def parse_args() -> argparse.Namespace:
-    from settings import get_settings
-
     parser = argparse.ArgumentParser()
-    defaults = get_settings().server_options.as_dict()
+    defaults = Utils.get_settings()["server_options"].as_dict()
     parser.add_argument('multidata', nargs="?", default=defaults["multidata"])
     parser.add_argument('--host', default=defaults["host"])
     parser.add_argument('--port', default=defaults["port"], type=int)

OoTClient.py

@@ -12,7 +12,6 @@ from CommonClient import CommonContext, server_loop, gui_enabled, \
 import Utils
 from Utils import async_start
 from worlds import network_data_package
-from worlds.oot import OOTWorld
 from worlds.oot.Rom import Rom, compress_rom_file
 from worlds.oot.N64Patch import apply_patch_file
 from worlds.oot.Utils import data_path
@@ -281,7 +280,7 @@ async def n64_sync_task(ctx: OoTContext):
 
 
 async def run_game(romfile):
-    auto_start = OOTWorld.settings.rom_start
+    auto_start = Utils.get_options()["oot_options"].get("rom_start", True)
     if auto_start is True:
         import webbrowser
         webbrowser.open(romfile)
@@ -296,7 +295,7 @@ async def patch_and_run_game(apz5_file):
     decomp_path = base_name + '-decomp.z64'
     comp_path = base_name + '.z64'
     # Load vanilla ROM, patch file, compress ROM
-    rom_file_name = OOTWorld.settings.rom_file
+    rom_file_name = Utils.get_options()["oot_options"]["rom_file"]
     rom = Rom(rom_file_name)
 
     sub_file = None

Options.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import abc
-import collections
 import functools
 import logging
 import math
@@ -24,12 +23,6 @@ if typing.TYPE_CHECKING:
     import pathlib
 
 
-def roll_percentage(percentage: int | float) -> bool:
-    """Roll a percentage chance.
-    percentage is expected to be in range [0, 100]"""
-    return random.random() < (float(percentage) / 100)
-
-
 class OptionError(ValueError):
     pass
 
@@ -873,49 +866,15 @@ class OptionDict(Option[typing.Dict[str, typing.Any]], VerifyKeys, typing.Mappin
     def __len__(self) -> int:
         return self.value.__len__()
 
-    # __getitem__ fallback fails for Counters, so we define this explicitly
-    def __contains__(self, item) -> bool:
-        return item in self.value
 
-
-class OptionCounter(OptionDict):
-    min: int | None = None
-    max: int | None = None
-
-    def __init__(self, value: dict[str, int]) -> None:
-        super(OptionCounter, self).__init__(collections.Counter(value))
-
-    def verify(self, world: type[World], player_name: str, plando_options: PlandoOptions) -> None:
-        super(OptionCounter, self).verify(world, player_name, plando_options)
-
-        range_errors = []
-
-        if self.max is not None:
-            range_errors += [
-                f"\"{key}: {value}\" is higher than maximum allowed value {self.max}."
-                for key, value in self.value.items() if value > self.max
-            ]
-
-        if self.min is not None:
-            range_errors += [
-                f"\"{key}: {value}\" is lower than minimum allowed value {self.min}."
-                for key, value in self.value.items() if value < self.min
-            ]
-
-        if range_errors:
-            range_errors = [f"For option {getattr(self, 'display_name', self)}:"] + range_errors
-            raise OptionError("\n".join(range_errors))
-
-
-class ItemDict(OptionCounter):
+class ItemDict(OptionDict):
     verify_item_name = True
 
-    min = 0
-
-    def __init__(self, value: dict[str, int]) -> None:
-        # Backwards compatibility: Cull 0s to make "in" checks behave the same as when this wasn't a OptionCounter
-        value = {item_name: amount for item_name, amount in value.items() if amount != 0}
-
+    def __init__(self, value: typing.Dict[str, int]):
+        if any(item_count is None for item_count in value.values()):
+            raise Exception("Items must have counts associated with them. Please provide positive integer values in the format \"item\": count .")
+        if any(item_count < 1 for item_count in value.values()):
+            raise Exception("Cannot have non-positive item counts.")
         super(ItemDict, self).__init__(value)
 
 
@@ -1025,7 +984,7 @@ class PlandoTexts(Option[typing.List[PlandoText]], VerifyKeys):
         if isinstance(data, typing.Iterable):
             for text in data:
                 if isinstance(text, typing.Mapping):
-                    if roll_percentage(text.get("percentage", 100)):
+                    if random.random() < float(text.get("percentage", 100)/100):
                         at = text.get("at", None)
                         if at is not None:
                             if isinstance(at, dict):
@@ -1051,7 +1010,7 @@ class PlandoTexts(Option[typing.List[PlandoText]], VerifyKeys):
                         else:
                             raise OptionError("\"at\" must be a valid string or weighted list of strings!")
                 elif isinstance(text, PlandoText):
-                    if roll_percentage(text.percentage):
+                    if random.random() < float(text.percentage/100):
                         texts.append(text)
                 else:
                     raise Exception(f"Cannot create plando text from non-dictionary type, got {type(text)}")
@@ -1175,7 +1134,7 @@ class PlandoConnections(Option[typing.List[PlandoConnection]], metaclass=Connect
         for connection in data:
             if isinstance(connection, typing.Mapping):
                 percentage = connection.get("percentage", 100)
-                if roll_percentage(percentage):
+                if random.random() < float(percentage / 100):
                     entrance = connection.get("entrance", None)
                     if is_iterable_except_str(entrance):
                         entrance = random.choice(sorted(entrance))
@@ -1193,7 +1152,7 @@ class PlandoConnections(Option[typing.List[PlandoConnection]], metaclass=Connect
                         percentage
                     ))
             elif isinstance(connection, PlandoConnection):
-                if roll_percentage(connection.percentage):
+                if random.random() < float(connection.percentage / 100):
                     value.append(connection)
             else:
                 raise Exception(f"Cannot create connection from non-Dict type, got {type(connection)}.")
@@ -1298,47 +1257,42 @@ class CommonOptions(metaclass=OptionsMetaProperty):
     progression_balancing: ProgressionBalancing
     accessibility: Accessibility
 
-    def as_dict(
-            self,
-            *option_names: str,
-            casing: typing.Literal["snake", "camel", "pascal", "kebab"] = "snake",
-            toggles_as_bools: bool = False,
-    ) -> dict[str, typing.Any]:
+    def as_dict(self,
+                *option_names: str,
+                casing: typing.Literal["snake", "camel", "pascal", "kebab"] = "snake",
+                toggles_as_bools: bool = False) -> typing.Dict[str, typing.Any]:
         """
         Returns a dictionary of [str, Option.value]
 
-        :param option_names: Names of the options to get the values of.
-        :param casing: Casing of the keys to return. Supports `snake`, `camel`, `pascal`, `kebab`.
-        :param toggles_as_bools: Whether toggle options should be returned as bools instead of ints.
-
-        :return: A dictionary of each option name to the value of its Option. If the option is an OptionSet, the value
-        will be returned as a sorted list.
+        :param option_names: names of the options to return
+        :param casing: case of the keys to return. Supports `snake`, `camel`, `pascal`, `kebab`
+        :param toggles_as_bools: whether toggle options should be output as bools instead of strings
         """
         assert option_names, "options.as_dict() was used without any option names."
         option_results = {}
         for option_name in option_names:
-            if option_name not in type(self).type_hints:
-                raise ValueError(f"{option_name} not found in {tuple(type(self).type_hints)}")
-
-            if casing == "snake":
-                display_name = option_name
-            elif casing == "camel":
-                split_name = [name.title() for name in option_name.split("_")]
-                split_name[0] = split_name[0].lower()
-                display_name = "".join(split_name)
-            elif casing == "pascal":
-                display_name = "".join([name.title() for name in option_name.split("_")])
-            elif casing == "kebab":
-                display_name = option_name.replace("_", "-")
+            if option_name in type(self).type_hints:
+                if casing == "snake":
+                    display_name = option_name
+                elif casing == "camel":
+                    split_name = [name.title() for name in option_name.split("_")]
+                    split_name[0] = split_name[0].lower()
+                    display_name = "".join(split_name)
+                elif casing == "pascal":
+                    display_name = "".join([name.title() for name in option_name.split("_")])
+                elif casing == "kebab":
+                    display_name = option_name.replace("_", "-")
+                else:
+                    raise ValueError(f"{casing} is invalid casing for as_dict. "
+                                     "Valid names are 'snake', 'camel', 'pascal', 'kebab'.")
+                value = getattr(self, option_name).value
+                if isinstance(value, set):
+                    value = sorted(value)
+                elif toggles_as_bools and issubclass(type(self).type_hints[option_name], Toggle):
+                    value = bool(value)
+                option_results[display_name] = value
             else:
-                raise ValueError(f"{casing} is invalid casing for as_dict. "
-                                 "Valid names are 'snake', 'camel', 'pascal', 'kebab'.")
-            value = getattr(self, option_name).value
-            if isinstance(value, set):
-                value = sorted(value)
-            elif toggles_as_bools and issubclass(type(self).type_hints[option_name], Toggle):
-                value = bool(value)
-            option_results[display_name] = value
+                raise ValueError(f"{option_name} not found in {tuple(type(self).type_hints)}")
         return option_results
 
 
@@ -1359,7 +1313,6 @@ class StartInventory(ItemDict):
     verify_item_name = True
     display_name = "Start Inventory"
     rich_text_doc = True
-    max = 10000
 
 
 class StartInventoryPool(StartInventory):
@@ -1475,133 +1428,6 @@ class ItemLinks(OptionList):
             link["item_pool"] = list(pool)
 
 
-@dataclass(frozen=True)
-class PlandoItem:
-    items: list[str] | dict[str, typing.Any]
-    locations: list[str]
-    world: int | str | bool | None | typing.Iterable[str] | set[int] = False
-    from_pool: bool = True
-    force: bool | typing.Literal["silent"] = "silent"
-    count: int | bool | dict[str, int] = False
-    percentage: int = 100
-
-
-class PlandoItems(Option[typing.List[PlandoItem]]):
-    """Generic items plando."""
-    default = ()
-    supports_weighting = False
-    display_name = "Plando Items"
-
-    def __init__(self, value: typing.Iterable[PlandoItem]) -> None:
-        self.value = list(deepcopy(value))
-        super().__init__()
-
-    @classmethod
-    def from_any(cls, data: typing.Any) -> Option[typing.List[PlandoItem]]:
-        if not isinstance(data, typing.Iterable):
-            raise OptionError(f"Cannot create plando items from non-Iterable type, got {type(data)}")
-
-        value: typing.List[PlandoItem] = []
-        for item in data:
-            if isinstance(item, typing.Mapping):
-                percentage = item.get("percentage", 100)
-                if not isinstance(percentage, int):
-                    raise OptionError(f"Plando `percentage` has to be int, not {type(percentage)}.")
-                if not (0 <= percentage <= 100):
-                    raise OptionError(f"Plando `percentage` has to be between 0 and 100 (inclusive) not {percentage}.")
-                if roll_percentage(percentage):
-                    count = item.get("count", False)
-                    items = item.get("items", [])
-                    if not items:
-                        items = item.get("item", None)  # explicitly throw an error here if not present
-                        if not items:
-                            raise OptionError("You must specify at least one item to place items with plando.")
-                        count = 1
-                    if isinstance(items, str):
-                        items = [items]
-                    elif not isinstance(items, (dict, list)):
-                        raise OptionError(f"Plando 'items' has to be string, list, or "
-                                          f"dictionary, not {type(items)}")
-                    locations = item.get("locations", [])
-                    if not locations:
-                        locations = item.get("location", [])
-                        if locations:
-                            count = 1
-                        else:
-                            locations = ["Everywhere"]
-                        if isinstance(locations, str):
-                            locations = [locations]
-                        if not isinstance(locations, list):
-                            raise OptionError(f"Plando `location` has to be string or list, not {type(locations)}")
-                    world = item.get("world", False)
-                    from_pool = item.get("from_pool", True)
-                    force = item.get("force", "silent")
-                    if not isinstance(from_pool, bool):
-                        raise OptionError(f"Plando 'from_pool' has to be true or false, not {from_pool!r}.")
-                    if not (isinstance(force, bool) or force == "silent"):
-                        raise OptionError(f"Plando `force` has to be true or false or `silent`, not {force!r}.")
-                    value.append(PlandoItem(items, locations, world, from_pool, force, count, percentage))
-            elif isinstance(item, PlandoItem):
-                if roll_percentage(item.percentage):
-                    value.append(item)
-            else:
-                raise OptionError(f"Cannot create plando item from non-Dict type, got {type(item)}.")
-        return cls(value)
-
-    def verify(self, world: typing.Type[World], player_name: str, plando_options: "PlandoOptions") -> None:
-        if not self.value:
-            return
-        from BaseClasses import PlandoOptions
-        if not (PlandoOptions.items & plando_options):
-            # plando is disabled but plando options were given so overwrite the options
-            self.value = []
-            logging.warning(f"The plando items module is turned off, "
-                            f"so items for {player_name} will be ignored.")
-        else:
-            # filter down item groups
-            for plando in self.value:
-                # confirm a valid count
-                if isinstance(plando.count, dict):
-                    if "min" in plando.count and "max" in plando.count:
-                        if plando.count["min"] > plando.count["max"]:
-                            raise OptionError("Plando cannot have count `min` greater than `max`.")
-                items_copy = plando.items.copy()
-                if isinstance(plando.items, dict):
-                    for item in items_copy:
-                        if item in world.item_name_groups:
-                            value = plando.items.pop(item)
-                            group = world.item_name_groups[item]
-                            filtered_items = sorted(group.difference(list(plando.items.keys())))
-                            if not filtered_items:
-                                raise OptionError(f"Plando `items` contains the group \"{item}\" "
-                                                  f"and every item in it. This is not allowed.")
-                            if value is True:
-                                for key in filtered_items:
-                                    plando.items[key] = True
-                            else:
-                                for key in random.choices(filtered_items, k=value):
-                                    plando.items[key] = plando.items.get(key, 0) + 1
-                else:
-                    assert isinstance(plando.items, list)  # pycharm can't figure out the hinting without the hint
-                    for item in items_copy:
-                        if item in world.item_name_groups:
-                            plando.items.remove(item)
-                            plando.items.extend(sorted(world.item_name_groups[item]))
-
-    @classmethod
-    def get_option_name(cls, value: list[PlandoItem]) -> str:
-        return ", ".join(["(%s: %s)" % (item.items, item.locations) for item in value])  #TODO: see what a better way to display would be
-
-    def __getitem__(self, index: typing.SupportsIndex) -> PlandoItem:
-        return self.value.__getitem__(index)
-
-    def __iter__(self) -> typing.Iterator[PlandoItem]:
-        yield from self.value
-
-    def __len__(self) -> int:
-        return len(self.value)
-
-        
 class Removed(FreeText):
     """This Option has been Removed."""
     rich_text_doc = True
@@ -1624,7 +1450,6 @@ class PerGameCommonOptions(CommonOptions):
     exclude_locations: ExcludeLocations
     priority_locations: PriorityLocations
     item_links: ItemLinks
-    plando_items: PlandoItems
 
 
 @dataclass
@@ -1678,7 +1503,6 @@ def get_option_groups(world: typing.Type[World], visibility_level: Visibility =
 
 def generate_yaml_templates(target_folder: typing.Union[str, "pathlib.Path"], generate_hidden: bool = True) -> None:
     import os
-    from inspect import cleandoc
 
     import yaml
     from jinja2 import Template
@@ -1717,21 +1541,19 @@ def generate_yaml_templates(target_folder: typing.Union[str, "pathlib.Path"], ge
         # yaml dump may add end of document marker and newlines.
         return yaml.dump(scalar).replace("...\n", "").strip()
 
-    with open(local_path("data", "options.yaml")) as f:
-        file_data = f.read()
-    template = Template(file_data)
-
     for game_name, world in AutoWorldRegister.world_types.items():
         if not world.hidden or generate_hidden:
             option_groups = get_option_groups(world)
-
-            res = template.render(
+            with open(local_path("data", "options.yaml")) as f:
+                file_data = f.read()
+            res = Template(file_data).render(
                 option_groups=option_groups,
                 __version__=__version__, game=game_name, yaml_dump=yaml_dump_scalar,
                 dictify_range=dictify_range,
-                cleandoc=cleandoc,
             )
 
+            del file_data
+
             with open(os.path.join(target_folder, get_file_safe_name(game_name) + ".yaml"), "w", encoding="utf-8-sig") as f:
                 f.write(res)
 

README.md

@@ -9,6 +9,7 @@ Currently, the following games are supported:
 * Factorio
 * Minecraft
 * Subnautica
+* Slay the Spire
 * Risk of Rain 2
 * The Legend of Zelda: Ocarina of Time
 * Timespinner
@@ -62,6 +63,7 @@ Currently, the following games are supported:
 * TUNIC
 * Kirby's Dream Land 3
 * Celeste 64
+* Zork Grand Inquisitor
 * Castlevania 64
 * A Short Hike
 * Yoshi's Island
@@ -80,9 +82,6 @@ Currently, the following games are supported:
 * Inscryption
 * Civilization VI
 * The Legend of Zelda: The Wind Waker
-* Jak and Daxter: The Precursor Legacy
-* Super Mario Land 2: 6 Golden Coins
-* shapez
 
 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

@@ -114,8 +114,6 @@ def cache_self1(function: typing.Callable[[S, T], RetType]) -> typing.Callable[[
             cache[arg] = res
             return res
 
-    wrap.__defaults__ = function.__defaults__
-
     return wrap
 
 
@@ -139,11 +137,8 @@ def local_path(*path: str) -> str:
             local_path.cached_path = os.path.dirname(os.path.abspath(sys.argv[0]))
     else:
         import __main__
-        if globals().get("__file__") and os.path.isfile(__file__):
+        if hasattr(__main__, "__file__") and os.path.isfile(__main__.__file__):
             # we are running in a normal Python environment
-            local_path.cached_path = os.path.dirname(os.path.abspath(__file__))
-        elif hasattr(__main__, "__file__") and os.path.isfile(__main__.__file__):
-            # we are running in a normal Python environment, but AP was imported weirdly
             local_path.cached_path = os.path.dirname(os.path.abspath(__main__.__file__))
         else:
             # pray
@@ -432,9 +427,6 @@ class RestrictedUnpickler(pickle.Unpickler):
     def find_class(self, module: str, name: str) -> type:
         if module == "builtins" and name in safe_builtins:
             return getattr(builtins, name)
-        # used by OptionCounter
-        if module == "collections" and name == "Counter":
-            return collections.Counter
         # used by MultiServer -> savegame/multidata
         if module == "NetUtils" and name in {"NetworkItem", "ClientStatus", "Hint",
                                              "SlotType", "NetworkSlot", "HintStatus"}:
@@ -540,8 +532,6 @@ def init_logging(name: str, loglevel: typing.Union[str, int] = logging.INFO,
         if add_timestamp:
             stream_handler.setFormatter(formatter)
         root_logger.addHandler(stream_handler)
-        if hasattr(sys.stdout, "reconfigure"):
-            sys.stdout.reconfigure(encoding="utf-8", errors="replace")
 
     # Relay unhandled exceptions to logger.
     if not getattr(sys.excepthook, "_wrapped", False):  # skip if already modified
@@ -640,8 +630,6 @@ def get_fuzzy_results(input_word: str, word_list: typing.Collection[str], limit:
     import jellyfish
 
     def get_fuzzy_ratio(word1: str, word2: str) -> float:
-        if word1 == word2:
-            return 1.01
         return (1 - jellyfish.damerau_levenshtein_distance(word1.lower(), word2.lower())
                 / max(len(word1), len(word2)))
 
@@ -662,10 +650,8 @@ def get_intended_text(input_text: str, possible_answers) -> typing.Tuple[str, bo
     picks = get_fuzzy_results(input_text, possible_answers, limit=2)
     if len(picks) > 1:
         dif = picks[0][1] - picks[1][1]
-        if picks[0][1] == 101:
+        if picks[0][1] == 100:
             return picks[0][0], True, "Perfect Match"
-        elif picks[0][1] == 100:
-            return picks[0][0], True, "Case Insensitive Perfect Match"
         elif picks[0][1] < 75:
             return picks[0][0], False, f"Didn't find something that closely matches '{input_text}', " \
                                        f"did you mean '{picks[0][0]}'? ({picks[0][1]}% sure)"

WargrooveClient.py

@@ -2,15 +2,14 @@ from __future__ import annotations
 
 import atexit
 import os
-import pkgutil
 import sys
 import asyncio
 import random
-import typing
+import shutil
 from typing import Tuple, List, Iterable, Dict
 
-from . import WargrooveWorld
-from .Items import item_table, faction_table, CommanderData, ItemData
+from worlds.wargroove import WargrooveWorld
+from worlds.wargroove.Items import item_table, faction_table, CommanderData, ItemData
 
 import ModuleUpdate
 ModuleUpdate.update()
@@ -22,7 +21,7 @@ import logging
 if __name__ == "__main__":
     Utils.init_logging("WargrooveClient", exception_logger="Client")
 
-from NetUtils import ClientStatus
+from NetUtils import NetworkItem, ClientStatus
 from CommonClient import gui_enabled, logger, get_base_parser, ClientCommandProcessor, \
     CommonContext, server_loop
 
@@ -30,34 +29,6 @@ wg_logger = logging.getLogger("WG")
 
 
 class WargrooveClientCommandProcessor(ClientCommandProcessor):
-    def _cmd_sacrifice_summon(self):
-        """Toggles sacrifices and summons On/Off"""
-        if isinstance(self.ctx, WargrooveContext):
-            self.ctx.has_sacrifice_summon = not self.ctx.has_sacrifice_summon
-            if self.ctx.has_sacrifice_summon:
-                self.output(f"Sacrifices and summons are enabled.")
-            else:
-                unit_summon_response_file = os.path.join(self.ctx.game_communication_path, "unitSummonResponse")
-                if os.path.exists(unit_summon_response_file):
-                    os.remove(unit_summon_response_file)
-                self.output(f"Sacrifices and summons are disabled.")
-
-    def _cmd_deathlink(self):
-        """Toggles deathlink On/Off"""
-        if isinstance(self.ctx, WargrooveContext):
-            self.ctx.has_death_link = not self.ctx.has_death_link
-            Utils.async_start(self.ctx.update_death_link(self.ctx.has_death_link), name="Update Deathlink")
-            if self.ctx.has_death_link:
-                death_link_send_file = os.path.join(self.ctx.game_communication_path, "deathLinkSend")
-                if os.path.exists(death_link_send_file):
-                    os.remove(death_link_send_file)
-                self.output(f"Deathlink enabled.")
-            else:
-                death_link_receive_file = os.path.join(self.ctx.game_communication_path, "deathLinkReceive")
-                if os.path.exists(death_link_receive_file):
-                    os.remove(death_link_receive_file)
-                self.output(f"Deathlink disabled.")
-
     def _cmd_resync(self):
         """Manually trigger a resync."""
         self.output(f"Syncing items.")
@@ -87,11 +58,6 @@ class WargrooveContext(CommonContext):
     commander_defense_boost_multiplier: int = 0
     income_boost_multiplier: int = 0
     starting_groove_multiplier: float
-    has_death_link: bool = False
-    has_sacrifice_summon: bool = True
-    player_stored_units_key: str = ""
-    ai_stored_units_key: str = ""
-    max_stored_units: int = 1000
     faction_item_ids = {
         'Starter': 0,
         'Cherrystone': 52025,
@@ -105,31 +71,6 @@ class WargrooveContext(CommonContext):
         'Income Boost': 52023,
         'Commander Defense Boost': 52024,
     }
-    unit_classes = {
-        "archer",
-        "ballista",
-        "balloon",
-        "dog",
-        "dragon",
-        "giant",
-        "harpoonship",
-        "harpy",
-        "knight",
-        "mage",
-        "merman",
-        "rifleman",
-        "soldier",
-        "spearman",
-        "thief",
-        "thief_with_gold",
-        "travelboat",
-        "trebuchet",
-        "turtle",
-        "villager",
-        "wagon",
-        "warship",
-        "witch",
-    }
 
     def __init__(self, server_address, password):
         super(WargrooveContext, self).__init__(server_address, password)
@@ -137,80 +78,31 @@ class WargrooveContext(CommonContext):
         self.syncing = False
         self.awaiting_bridge = False
         # self.game_communication_path: files go in this path to pass data between us and the actual game
-        game_options = WargrooveWorld.settings
-
-        # Validate the AppData directory with Wargroove save data.
-        # By default, Windows sets an environment variable we can leverage.
-        # However, other OSes don't usually have this value set, so we need to rely on a settings value instead.
-        appdata_wargroove = None
         if "appdata" in os.environ:
-            appdata_wargroove = os.environ['appdata']
-        else:
-            try:
-                appdata_wargroove = game_options.save_directory
-            except FileNotFoundError:
-                print_error_and_close("WargrooveClient couldn't detect a path to the AppData folder.\n"
-                                      "Unable to infer required game_communication_path.\n"
-                                      "Try setting the \"save_directory\" value in your local options file "
-                                      "to the AppData folder containing your Wargroove saves.")
-        appdata_wargroove = os.path.expandvars(os.path.join(appdata_wargroove, "Chucklefish", "Wargroove"))
-        if not os.path.isdir(appdata_wargroove):
-            print_error_and_close(f"WargrooveClient couldn't find Wargroove data in your AppData folder.\n"
-                                  f"Looked in \"{appdata_wargroove}\".\n"
-                                  f"If you haven't yet booted the game at least once, boot Wargroove "
-                                  f"and then close it to attempt to fix this error.\n"
-                                  f"If the AppData folder above seems wrong, try setting the "
-                                  f"\"save_directory\" value in your local options file "
-                                  f"to the AppData folder containing your Wargroove saves.")
-
-        # Check for the Wargroove game executable path.
-        # This should always be set regardless of the OS.
-        root_directory = game_options["root_directory"]
-        if not os.path.isfile(os.path.join(root_directory, "win64_bin", "wargroove64.exe")):
-            print_error_and_close(f"WargrooveClient couldn't find wargroove64.exe in "
-                                  f"\"{root_directory}/win64_bin/\".\n"
-                                  f"Unable to infer required game_communication_path.\n"
-                                  f"Please verify the \"root_directory\" value in your local "
-                                  f"options file is set correctly.")
-        self.game_communication_path = os.path.join(root_directory, "AP")
-        if not os.path.exists(self.game_communication_path):
-            os.makedirs(self.game_communication_path)
-        self.remove_communication_files()
-        atexit.register(self.remove_communication_files)
-        if not os.path.isdir(appdata_wargroove):
-            print_error_and_close("WargrooveClient couldn't find Wargoove in appdata!"
-                                  "Boot Wargroove and then close it to attempt to fix this error")
-        mods_directory = os.path.join(appdata_wargroove, "mods", "ArchipelagoMod")
-        save_directory = os.path.join(appdata_wargroove, "save")
-
-        # Wargroove doesn't always create the mods directory, so we have to do it
-        if not os.path.isdir(mods_directory):
-            os.makedirs(mods_directory)
-        resources = ["data/mods/ArchipelagoMod/maps.dat",
-                     "data/mods/ArchipelagoMod/mod.dat",
-                     "data/mods/ArchipelagoMod/modAssets.dat",
-                     "data/save/campaign-c40a6e5b0cdf86ddac03b276691c483d.cmp",
-                     "data/save/campaign-c40a6e5b0cdf86ddac03b276691c483d.cmp.bak"]
-        file_paths = [os.path.join(mods_directory, "maps.dat"),
-                      os.path.join(mods_directory, "mod.dat"),
-                      os.path.join(mods_directory, "modAssets.dat"),
-                      os.path.join(save_directory, "campaign-c40a6e5b0cdf86ddac03b276691c483d.cmp"),
-                      os.path.join(save_directory, "campaign-c40a6e5b0cdf86ddac03b276691c483d.cmp.bak")]
-        for resource, destination in zip(resources, file_paths):
-            file_data = pkgutil.get_data("worlds.wargroove", resource)
-            if file_data is None:
+            options = Utils.get_options()
+            root_directory = os.path.join(options["wargroove_options"]["root_directory"])
+            data_directory = os.path.join("lib", "worlds", "wargroove", "data")
+            dev_data_directory = os.path.join("worlds", "wargroove", "data")
+            appdata_wargroove = os.path.expandvars(os.path.join("%APPDATA%", "Chucklefish", "Wargroove"))
+            if not os.path.isfile(os.path.join(root_directory, "win64_bin", "wargroove64.exe")):
+                print_error_and_close("WargrooveClient couldn't find wargroove64.exe. "
+                                      "Unable to infer required game_communication_path")
+            self.game_communication_path = os.path.join(root_directory, "AP")
+            if not os.path.exists(self.game_communication_path):
+                os.makedirs(self.game_communication_path)
+            self.remove_communication_files()
+            atexit.register(self.remove_communication_files)
+            if not os.path.isdir(appdata_wargroove):
+                print_error_and_close("WargrooveClient couldn't find Wargoove in appdata!"
+                                      "Boot Wargroove and then close it to attempt to fix this error")
+            if not os.path.isdir(data_directory):
+                data_directory = dev_data_directory
+            if not os.path.isdir(data_directory):
                 print_error_and_close("WargrooveClient couldn't find Wargoove mod and save files in install!")
-            with open(destination, 'wb') as f:
-                f.write(file_data)
-
-    def on_deathlink(self, data: typing.Dict[str, typing.Any]) -> None:
-        with open(os.path.join(self.game_communication_path, "deathLinkReceive"), 'w+') as f:
-            text = data.get("cause", "")
-            if text:
-                f.write(f"DeathLink: {text}")
-            else:
-                f.write(f"DeathLink: Received from {data['source']}")
-        super(WargrooveContext, self).on_deathlink(data)
+            shutil.copytree(data_directory, appdata_wargroove, dirs_exist_ok=True)
+        else:
+            print_error_and_close("WargrooveClient couldn't detect system type. "
+                                  "Unable to infer required game_communication_path")
 
     async def server_auth(self, password_requested: bool = False):
         if password_requested and not self.password:
@@ -246,25 +138,20 @@ class WargrooveContext(CommonContext):
 
     def on_package(self, cmd: str, args: dict):
         if cmd in {"Connected"}:
-            slot_data = args["slot_data"]
-            self.has_death_link = slot_data.get("death_link", False)
             filename = f"AP_settings.json"
             with open(os.path.join(self.game_communication_path, filename), 'w') as f:
-                json.dump(slot_data, f)
+                slot_data = args["slot_data"]
+                json.dump(args["slot_data"], f)
                 self.can_choose_commander = slot_data["can_choose_commander"]
                 print('can choose commander:', self.can_choose_commander)
                 self.starting_groove_multiplier = slot_data["starting_groove_multiplier"]
                 self.income_boost_multiplier = slot_data["income_boost"]
                 self.commander_defense_boost_multiplier = slot_data["commander_defense_boost"]
+                f.close()
             for ss in self.checked_locations:
                 filename = f"send{ss}"
                 with open(os.path.join(self.game_communication_path, filename), 'w') as f:
-                    pass
-
-            self.player_stored_units_key = f"wargroove_player_units_{self.team}"
-            self.ai_stored_units_key = f"wargroove_ai_units_{self.team}"
-            self.set_notify(self.player_stored_units_key, self.ai_stored_units_key)
-
+                    f.close()
             self.update_commander_data()
             self.ui.update_tracker()
 
@@ -274,6 +161,7 @@ class WargrooveContext(CommonContext):
                 filename = f"seed{i}"
                 with open(os.path.join(self.game_communication_path, filename), 'w') as f:
                     f.write(str(random.randint(0, 4294967295)))
+                    f.close()
 
         if cmd in {"RoomInfo"}:
             self.seed_name = args["seed_name"]
@@ -301,6 +189,7 @@ class WargrooveContext(CommonContext):
                         f.write(f"{item_count * self.commander_defense_boost_multiplier}")
                     else:
                         f.write(f"{item_count}")
+                    f.close()
 
                 print_filename = f"AP_{str(network_item.item)}.item.print"
                 print_path = os.path.join(self.game_communication_path, print_filename)
@@ -311,6 +200,7 @@ class WargrooveContext(CommonContext):
                                 self.item_names.lookup_in_game(network_item.item) +
                                 " from " +
                                 self.player_names[network_item.player])
+                        f.close()
             self.update_commander_data()
             self.ui.update_tracker()
 
@@ -319,7 +209,7 @@ class WargrooveContext(CommonContext):
                 for ss in self.checked_locations:
                     filename = f"send{ss}"
                     with open(os.path.join(self.game_communication_path, filename), 'w') as f:
-                        pass
+                        f.close()
 
     def run_gui(self):
         """Import kivy UI system and start running it as self.ui_task."""
@@ -495,6 +385,7 @@ class WargrooveContext(CommonContext):
 
 
 async def game_watcher(ctx: WargrooveContext):
+    from worlds.wargroove.Locations import location_table
     while not ctx.exit_event.is_set():
         if ctx.syncing == True:
             sync_msg = [{'cmd': 'Sync'}]
@@ -506,12 +397,6 @@ async def game_watcher(ctx: WargrooveContext):
         victory = False
         for root, dirs, files in os.walk(ctx.game_communication_path):
             for file in files:
-                if file == "deathLinkSend" and ctx.has_death_link:
-                    with open(os.path.join(ctx.game_communication_path, file), 'r') as f:
-                        failed_mission = f.read()
-                        if ctx.slot is not None:
-                            await ctx.send_death(f"{ctx.player_names[ctx.slot]} failed {failed_mission}")
-                    os.remove(os.path.join(ctx.game_communication_path, file))
                 if file.find("send") > -1:
                     st = file.split("send", -1)[1]
                     sending = sending+[(int(st))]
@@ -519,40 +404,6 @@ async def game_watcher(ctx: WargrooveContext):
                 if file.find("victory") > -1:
                     victory = True
                     os.remove(os.path.join(ctx.game_communication_path, file))
-                if file == "unitSacrifice" or file == "unitSacrificeAI":
-                    if ctx.has_sacrifice_summon:
-                        stored_units_key = ctx.player_stored_units_key
-                        if file == "unitSacrificeAI":
-                            stored_units_key = ctx.ai_stored_units_key
-                        with open(os.path.join(ctx.game_communication_path, file), 'r') as f:
-                            unit_class = f.read()
-                            message = [{"cmd": 'Set', "key": stored_units_key,
-                                        "default": [],
-                                        "want_reply": True,
-                                        "operations": [{"operation": "add", "value": [unit_class[:64]]}]}]
-                            await ctx.send_msgs(message)
-                    os.remove(os.path.join(ctx.game_communication_path, file))
-                if file == "unitSummonRequestAI" or file == "unitSummonRequest":
-                    if ctx.has_sacrifice_summon:
-                        stored_units_key = ctx.player_stored_units_key
-                        if file == "unitSummonRequestAI":
-                            stored_units_key = ctx.ai_stored_units_key
-                        with open(os.path.join(ctx.game_communication_path, "unitSummonResponse"), 'w') as f:
-                            if stored_units_key in ctx.stored_data:
-                                stored_units = ctx.stored_data[stored_units_key]
-                                if stored_units is None:
-                                    stored_units = []
-                                wg1_stored_units = [unit for unit in stored_units if unit in ctx.unit_classes]
-                                if len(wg1_stored_units) != 0:
-                                    summoned_unit = random.choice(wg1_stored_units)
-                                    message = [{"cmd": 'Set', "key": stored_units_key,
-                                                "default": [],
-                                                "want_reply": True,
-                                                "operations": [{"operation": "remove", "value": summoned_unit[:64]}]}]
-                                    await ctx.send_msgs(message)
-                                    f.write(summoned_unit)
-                    os.remove(os.path.join(ctx.game_communication_path, file))
-
         ctx.locations_checked = sending
         message = [{"cmd": 'LocationChecks', "locations": sending}]
         await ctx.send_msgs(message)
@@ -567,9 +418,8 @@ def print_error_and_close(msg):
     Utils.messagebox("Error", msg, error=True)
     sys.exit(1)
 
-def launch(*launch_args: str):
-    async def main():
-        args = parser.parse_args(launch_args)
+if __name__ == '__main__':
+    async def main(args):
         ctx = WargrooveContext(args.connect, args.password)
         ctx.server_task = asyncio.create_task(server_loop(ctx), name="server loop")
         if gui_enabled:
@@ -589,6 +439,7 @@ def launch(*launch_args: str):
 
     parser = get_base_parser(description="Wargroove Client, for text interfacing.")
 
+    args, rest = parser.parse_known_args()
     colorama.just_fix_windows_console()
-    asyncio.run(main())
+    asyncio.run(main(args))
     colorama.deinit()

WebHostLib/__init__.py

@@ -80,8 +80,10 @@ def register():
     """Import submodules, triggering their registering on flask routing.
     Note: initializes worlds subsystem."""
     # has automatic patch integration
+    import worlds.AutoWorld
     import worlds.Files
-    app.jinja_env.filters['is_applayercontainer'] = worlds.Files.is_ap_player_container
+    app.jinja_env.filters['supports_apdeltapatch'] = lambda game_name: \
+        game_name in worlds.Files.AutoPatchRegister.patch_types
 
     from WebHostLib.customserver import run_server_process
     # to trigger app routing picking up on it

WebHostLib/api/user.py

@@ -28,6 +28,6 @@ def get_seeds():
         response.append({
             "seed_id": seed.id,
             "creation_time": seed.creation_time,
-            "players": get_players(seed),
+            "players": get_players(seed.slots),
         })
     return jsonify(response)

WebHostLib/options.py

@@ -108,7 +108,7 @@ def option_presets(game: str) -> Response:
                     f"Expected {option.special_range_names.keys()} or {option.range_start}-{option.range_end}."
 
                 presets[preset_name][preset_option_name] = option.value
-            elif isinstance(option, (Options.Range, Options.OptionSet, Options.OptionList, Options.OptionCounter)):
+            elif isinstance(option, (Options.Range, Options.OptionSet, Options.OptionList, Options.ItemDict)):
                 presets[preset_name][preset_option_name] = option.value
             elif isinstance(preset_option, str):
                 # Ensure the option value is valid for Choice and Toggle options
@@ -222,7 +222,7 @@ def generate_yaml(game: str):
 
         for key, val in options.copy().items():
             key_parts = key.rsplit("||", 2)
-            # Detect and build OptionCounter options from their name pattern
+            # Detect and build ItemDict options from their name pattern
             if key_parts[-1] == "qty":
                 if key_parts[0] not in options:
                     options[key_parts[0]] = {}

WebHostLib/templates/macros.html

@@ -29,15 +29,27 @@
                             {% if patch.game == "Minecraft" %}
                             <a href="{{ url_for("download_slot_file", room_id=room.id, player_id=patch.player_id) }}" download>
                                 Download APMC File...</a>
+                            {% elif patch.game == "Factorio" %}
+                            <a href="{{ url_for("download_slot_file", room_id=room.id, player_id=patch.player_id) }}" download>
+                                Download Factorio Mod...</a>
+                            {% elif patch.game == "Kingdom Hearts 2" %}
+                            <a href="{{ url_for("download_slot_file", room_id=room.id, player_id=patch.player_id) }}" download>
+                                Download Kingdom Hearts 2 Mod...</a>
+                            {% elif patch.game == "Ocarina of Time" %}
+                            <a href="{{ url_for("download_slot_file", room_id=room.id, player_id=patch.player_id) }}" download>
+                                Download APZ5 File...</a>
                             {% elif patch.game == "VVVVVV" and room.seed.slots|length == 1 %}
                             <a href="{{ url_for("download_slot_file", room_id=room.id, player_id=patch.player_id) }}" download>
                                 Download APV6 File...</a>
                             {% elif patch.game == "Super Mario 64" and room.seed.slots|length == 1 %}
                             <a href="{{ url_for("download_slot_file", room_id=room.id, player_id=patch.player_id) }}" download>
                                 Download APSM64EX File...</a>
-                            {% elif patch.game | is_applayercontainer(patch.data, patch.player_id) %}
+                            {% elif patch.game | supports_apdeltapatch %}
                             <a href="{{ url_for("download_patch", patch_id=patch.id, room_id=room.id) }}" download>
                                 Download Patch File...</a>
+                            {% elif patch.game == "Final Fantasy Mystic Quest" %}
+                            <a href="{{ url_for("download_slot_file", room_id=room.id, player_id=patch.player_id) }}" download>
+                                Download APMQ File...</a>
                             {% else %}
                                 No file to download for this game.
                             {% endif %}

WebHostLib/templates/playerOptions/macros.html

@@ -111,19 +111,10 @@
     </div>
 {% endmacro %}
 
-{% macro OptionCounter(option_name, option) %}
-    {% set relevant_keys = option.valid_keys %}
-    {% if not relevant_keys %}
-        {% if option.verify_item_name %}
-            {% set relevant_keys = world.item_names %}
-        {% elif option.verify_location_name %}
-            {% set relevant_keys = world.location_names %}
-        {% endif %}
-    {% endif %}
-
+{% macro ItemDict(option_name, option) %}
     {{ OptionTitle(option_name, option) }}
     <div class="option-container">
-        {% for item_name in (relevant_keys if relevant_keys is ordered else relevant_keys|sort) %}
+        {% for item_name in (option.valid_keys|sort if (option.valid_keys|length > 0) else world.item_names|sort) %}
             <div class="option-entry">
                 <label for="{{ option_name }}-{{ item_name }}-qty">{{ item_name }}</label>
                 <input type="number" id="{{ option_name }}-{{ item_name }}-qty" name="{{ option_name }}||{{ item_name }}||qty" value="{{ option.default[item_name]|default("0") }}" data-option-name="{{ option_name }}" data-item-name="{{ item_name }}" />

WebHostLib/templates/playerOptions/playerOptions.html

@@ -93,10 +93,8 @@
                                         {% elif issubclass(option, Options.FreeText) %}
                                             {{ inputs.FreeText(option_name, option) }}
 
-                                        {% elif issubclass(option, Options.OptionCounter) and (
-                                            option.valid_keys or option.verify_item_name or option.verify_location_name
-                                        ) %}
-                                            {{ inputs.OptionCounter(option_name, option) }}
+                                        {% elif issubclass(option, Options.ItemDict) and option.verify_item_name %}
+                                            {{ inputs.ItemDict(option_name, option) }}
 
                                         {% elif issubclass(option, Options.OptionList) and option.valid_keys %}
                                             {{ inputs.OptionList(option_name, option) }}
@@ -135,10 +133,8 @@
                                         {% elif issubclass(option, Options.FreeText) %}
                                             {{ inputs.FreeText(option_name, option) }}
 
-                                        {% elif issubclass(option, Options.OptionCounter) and (
-                                            option.valid_keys or option.verify_item_name or option.verify_location_name
-                                        ) %}
-                                            {{ inputs.OptionCounter(option_name, option) }}
+                                        {% elif issubclass(option, Options.ItemDict) and option.verify_item_name %}
+                                            {{ inputs.ItemDict(option_name, option) }}
 
                                         {% elif issubclass(option, Options.OptionList) and option.valid_keys %}
                                             {{ inputs.OptionList(option_name, option) }}

WebHostLib/templates/userContent.html

@@ -29,8 +29,7 @@
     <div id="user-content-wrapper" class="markdown">
         <div id="user-content" class="grass-island">
             <h1>User Content</h1>
-            Below is a list of all the content you have generated on this site. Rooms and seeds are listed separately.<br/>
-            Sessions can be saved or synced across devices using the <a href="{{url_for('show_session')}}">Sessions Page.</a>
+            Below is a list of all the content you have generated on this site. Rooms and seeds are listed separately.
 
             <h2>Your Rooms</h2>
             {% if rooms %}

WebHostLib/templates/weightedOptions/macros.html

@@ -113,18 +113,9 @@
     {{ TextChoice(option_name, option) }}
 {% endmacro %}
 
-{% macro OptionCounter(option_name, option, world) %}
-    {% set relevant_keys = option.valid_keys %}
-    {% if not relevant_keys %}
-        {% if option.verify_item_name %}
-            {% set relevant_keys = world.item_names %}
-        {% elif option.verify_location_name %}
-            {% set relevant_keys = world.location_names %}
-        {% endif %}
-    {% endif %}
-
+{% macro ItemDict(option_name, option, world) %}
     <div class="dict-container">
-        {% for item_name in (relevant_keys if relevant_keys is ordered else relevant_keys|sort) %}
+        {% for item_name in (option.valid_keys|sort if (option.valid_keys|length > 0) else world.item_names|sort) %}
             <div class="dict-entry">
                 <label for="{{ option_name }}-{{ item_name }}-qty">{{ item_name }}</label>
                 <input

WebHostLib/templates/weightedOptions/weightedOptions.html

@@ -83,10 +83,8 @@
                                 {% elif issubclass(option, Options.FreeText) %}
                                     {{ inputs.FreeText(option_name, option) }}
 
-                                {% elif issubclass(option, Options.OptionCounter) and (
-                                    option.valid_keys or option.verify_item_name or option.verify_location_name
-                                ) %}
-                                    {{ inputs.OptionCounter(option_name, option, world) }}
+                                {% elif issubclass(option, Options.ItemDict) and option.verify_item_name %}
+                                    {{ inputs.ItemDict(option_name, option, world) }}
 
                                 {% elif issubclass(option, Options.OptionList) and option.valid_keys %}
                                     {{ inputs.OptionList(option_name, option) }}

data/client.kv

@@ -16,30 +16,21 @@
     orange: "FF7700"  # Used for command echo
     # KivyMD theming parameters
     theme_style: "Dark" # Light/Dark
-    primary_palette: "Lightsteelblue" # Many options
-    dynamic_scheme_name: "VIBRANT"
+    primary_palette: "Green" # Many options
+    dynamic_scheme_name: "TONAL_SPOT"
     dynamic_scheme_contrast: 0.0
 <MDLabel>:
     color: self.theme_cls.primaryColor
-<BaseButton>:
-    ripple_color: app.theme_cls.primaryColor
-    ripple_duration_in_fast: 0.2
-<MDTabsItemBase>:
-    ripple_color: app.theme_cls.primaryColor
-    ripple_duration_in_fast: 0.2
 <TooltipLabel>:
     adaptive_height: True
-    theme_font_size: "Custom"
-    font_size: "20dp"
+    font_size: dp(20)
     markup: True
     halign: "left"
 <SelectableLabel>:
     size_hint: 1, None
-    theme_text_color: "Custom"
-    text_color: 1, 1, 1, 1
     canvas.before:
         Color:
-            rgba: (self.theme_cls.primaryColor[0], self.theme_cls.primaryColor[1], self.theme_cls.primaryColor[2], .3) if self.selected else self.theme_cls.surfaceContainerLowestColor
+            rgba: (.0, 0.9, .1, .3) if self.selected else self.theme_cls.surfaceContainerLowColor
         Rectangle:
             size: self.size
             pos: self.pos
@@ -163,12 +154,9 @@
 <ToolTip>:
     size: self.texture_size
     size_hint: None, None
-    theme_font_size: "Custom"
     font_size: dp(18)
     pos_hint: {'center_y': 0.5, 'center_x': 0.5}
     halign: "left"
-    theme_text_color: "Custom"
-    text_color: (1, 1, 1, 1)
     canvas.before:
         Color:
             rgba: 0.2, 0.2, 0.2, 1
@@ -187,28 +175,11 @@
             rectangle: self.x-2, self.y-2, self.width+4, self.height+4
 <ServerToolTip>:
     pos_hint: {'center_y': 0.5, 'center_x': 0.5}
-<AutocompleteHintInput>:
+<AutocompleteHintInput>
     size_hint_y: None
-    height: "30dp"
+    height: dp(30)
     multiline: False
     write_tab: False
-    pos_hint: {"center_x": 0.5, "center_y": 0.5}
-<ConnectBarTextInput>:
-    height: "30dp"
-    multiline: False
-    write_tab: False
-    role: "medium"
-    size_hint_y: None
-    pos_hint: {"center_x": 0.5, "center_y": 0.5}
-<CommandPromptTextInput>:
-    size_hint_y: None
-    height: "30dp"
-    multiline: False
-    write_tab: False
-    pos_hint: {"center_x": 0.5, "center_y": 0.5}
-<MessageBoxLabel>:
-    theme_text_color: "Custom"
-    text_color: 1, 1, 1, 1
 <ScrollBox>:
     layout: layout
     bar_width: "12dp"
@@ -222,8 +193,3 @@
         spacing: 10
         size_hint_y: None
         height: self.minimum_height
-<MessageBoxLabel>:
-    valign: "middle"
-    halign: "center"
-    text_size: self.width, None
-    height: self.texture_size[1]

data/launcher.kv

@@ -5,13 +5,12 @@
     size_hint: 1, None
     height: "75dp"
     context_button: context
-    focus_behavior: False
 
     MDRelativeLayout:
         ApAsyncImage:
             source: main.image
             size: (48, 48)
-            size_hint: None, None
+            size_hint_y: None
             pos_hint: {"center_x": 0.1, "center_y": 0.5}
 
         MDLabel:
@@ -38,7 +37,6 @@
             pos_hint:{"center_x": 0.85, "center_y": 0.8}
             theme_text_color: "Custom"
             text_color: app.theme_cls.primaryColor
-            detect_visible: False
             on_release: app.set_favorite(self)
 
         MDIconButton:
@@ -48,7 +46,6 @@
             pos_hint:{"center_x": 0.95, "center_y": 0.8}
             theme_text_color: "Custom"
             text_color: app.theme_cls.primaryColor
-            detect_visible: False
 
         MDButton:
             pos_hint:{"center_x": 0.9, "center_y": 0.25}
@@ -56,7 +53,7 @@
             height: "25dp"
             component: main.component
             on_release: app.component_action(self)
-            detect_visible: False
+
             MDButtonText:
                 text: "Open"
 
@@ -80,7 +77,7 @@ MDFloatLayout:
                 id: all
                 style: "text"
                 type: (Type.CLIENT, Type.TOOL, Type.ADJUSTER, Type.MISC)
-                on_release: app.filter_clients_by_type(self)
+                on_release: app.filter_clients(self)
 
                 MDButtonIcon:
                     icon: "asterisk"
@@ -90,7 +87,7 @@ MDFloatLayout:
                 id: client
                 style: "text"
                 type: (Type.CLIENT, )
-                on_release: app.filter_clients_by_type(self)
+                on_release: app.filter_clients(self)
 
                 MDButtonIcon:
                     icon: "controller"
@@ -100,7 +97,7 @@ MDFloatLayout:
                 id: Tool
                 style: "text"
                 type: (Type.TOOL, )
-                on_release: app.filter_clients_by_type(self)
+                on_release: app.filter_clients(self)
 
                 MDButtonIcon:
                     icon: "desktop-classic"
@@ -110,7 +107,7 @@ MDFloatLayout:
                 id: adjuster
                 style: "text"
                 type: (Type.ADJUSTER, )
-                on_release: app.filter_clients_by_type(self)
+                on_release: app.filter_clients(self)
 
                 MDButtonIcon:
                     icon: "wrench"
@@ -120,7 +117,7 @@ MDFloatLayout:
                 id: misc
                 style: "text"
                 type: (Type.MISC, )
-                on_release: app.filter_clients_by_type(self)
+                on_release: app.filter_clients(self)
 
                 MDButtonIcon:
                     icon: "dots-horizontal-circle-outline"
@@ -131,7 +128,7 @@ MDFloatLayout:
                 id: favorites
                 style: "text"
                 type: ("favorites", )
-                on_release: app.filter_clients_by_type(self)
+                on_release: app.filter_clients(self)
 
                 MDButtonIcon:
                     icon: "star"
@@ -141,21 +138,5 @@ MDFloatLayout:
             MDNavigationDrawerDivider:
 
 
-        MDGridLayout:
-            id: main_layout
-            cols: 1
-            spacing: "10dp"
-
-            MDTextField:
-                id: search_box
-                mode: "outlined"
-                set_text: app.filter_clients_by_name
-
-                MDTextFieldLeadingIcon:
-                    icon: "magnify"
-
-                MDTextFieldHintText:
-                    text: "Search"
-
-            ScrollBox:
-                id: button_layout
+        ScrollBox:
+            id: button_layout

data/lua/connector_bizhawk_generic.lua

@@ -365,14 +365,18 @@ request_handlers = {
     ["PREFERRED_CORES"] = function (req)
         local res = {}
         local preferred_cores = client.getconfig().PreferredCores
-        local systems_enumerator = preferred_cores.Keys:GetEnumerator()
 
         res["type"] = "PREFERRED_CORES_RESPONSE"
         res["value"] = {}
-
-        while systems_enumerator:MoveNext() do
-            res["value"][systems_enumerator.Current] = preferred_cores[systems_enumerator.Current]
-        end
+        res["value"]["NES"] = preferred_cores.NES
+        res["value"]["SNES"] = preferred_cores.SNES
+        res["value"]["GB"] = preferred_cores.GB
+        res["value"]["GBC"] = preferred_cores.GBC
+        res["value"]["DGB"] = preferred_cores.DGB
+        res["value"]["SGB"] = preferred_cores.SGB
+        res["value"]["PCE"] = preferred_cores.PCE
+        res["value"]["PCECD"] = preferred_cores.PCECD
+        res["value"]["SGX"] = preferred_cores.SGX
 
         return res
     end,

data/lua/connector_ff1.lua

@@ -0,0 +1,462 @@
+local socket = require("socket")
+local json = require('json')
+local math = require('math')
+require("common")
+
+local STATE_OK = "Ok"
+local STATE_TENTATIVELY_CONNECTED = "Tentatively Connected"
+local STATE_INITIAL_CONNECTION_MADE = "Initial Connection Made"
+local STATE_UNINITIALIZED = "Uninitialized"
+
+local ITEM_INDEX = 0x03
+local WEAPON_INDEX = 0x07
+local ARMOR_INDEX = 0x0B
+
+local goldLookup = {
+    [0x16C] = 10,
+    [0x16D] = 20,
+    [0x16E] = 25,
+    [0x16F] = 30,
+    [0x170] = 55,
+    [0x171] = 70,
+    [0x172] = 85,
+    [0x173] = 110,
+    [0x174] = 135,
+    [0x175] = 155,
+    [0x176] = 160,
+    [0x177] = 180,
+    [0x178] = 240,
+    [0x179] = 255,
+    [0x17A] = 260,
+    [0x17B] = 295,
+    [0x17C] = 300,
+    [0x17D] = 315,
+    [0x17E] = 330,
+    [0x17F] = 350,
+    [0x180] = 385,
+    [0x181] = 400,
+    [0x182] = 450,
+    [0x183] = 500,
+    [0x184] = 530,
+    [0x185] = 575,
+    [0x186] = 620,
+    [0x187] = 680,
+    [0x188] = 750,
+    [0x189] = 795,
+    [0x18A] = 880,
+    [0x18B] = 1020,
+    [0x18C] = 1250,
+    [0x18D] = 1455,
+    [0x18E] = 1520,
+    [0x18F] = 1760,
+    [0x190] = 1975,
+    [0x191] = 2000,
+    [0x192] = 2750,
+    [0x193] = 3400,
+    [0x194] = 4150,
+    [0x195] = 5000,
+    [0x196] = 5450,
+    [0x197] = 6400,
+    [0x198] = 6720,
+    [0x199] = 7340,
+    [0x19A] = 7690,
+    [0x19B] = 7900,
+    [0x19C] = 8135,
+    [0x19D] = 9000,
+    [0x19E] = 9300,
+    [0x19F] = 9500,
+    [0x1A0] = 9900,
+    [0x1A1] = 10000,
+    [0x1A2] = 12350,
+    [0x1A3] = 13000,
+    [0x1A4] = 13450,
+    [0x1A5] = 14050,
+    [0x1A6] = 14720,
+    [0x1A7] = 15000,
+    [0x1A8] = 17490,
+    [0x1A9] = 18010,
+    [0x1AA] = 19990,
+    [0x1AB] = 20000,
+    [0x1AC] = 20010,
+    [0x1AD] = 26000,
+    [0x1AE] = 45000,
+    [0x1AF] = 65000
+}
+
+local extensionConsumableLookup = {
+    [432] = 0x3C,
+    [436] = 0x3C,
+    [440] = 0x3C,
+    [433] = 0x3D,
+    [437] = 0x3D,
+    [441] = 0x3D,
+    [434] = 0x3E,
+    [438] = 0x3E,
+    [442] = 0x3E,
+    [435] = 0x3F,
+    [439] = 0x3F,
+    [443] = 0x3F
+}
+
+local noOverworldItemsLookup = {
+    [499] = 0x2B,
+    [500] = 0x12,
+}
+
+local consumableStacks = nil
+local prevstate = ""
+local curstate =  STATE_UNINITIALIZED
+local ff1Socket = nil
+local frame = 0
+
+local isNesHawk = false
+
+
+--Sets correct memory access functions based on whether NesHawk or QuickNES is loaded
+local function defineMemoryFunctions()
+	local memDomain = {}
+	local domains = memory.getmemorydomainlist()
+	if domains[1] == "System Bus" then
+		--NesHawk
+		isNesHawk = true
+		memDomain["systembus"] = function() memory.usememorydomain("System Bus") end
+		memDomain["saveram"]   = function() memory.usememorydomain("Battery RAM") end
+		memDomain["rom"]       = function() memory.usememorydomain("PRG ROM") end
+	elseif domains[1] == "WRAM" then
+		--QuickNES
+		memDomain["systembus"] = function() memory.usememorydomain("System Bus") end
+		memDomain["saveram"]   = function() memory.usememorydomain("WRAM") end
+		memDomain["rom"]       = function() memory.usememorydomain("PRG ROM") end
+	end
+	return memDomain
+end
+
+local memDomain = defineMemoryFunctions()
+
+local function StateOKForMainLoop()
+    memDomain.saveram()
+    local A = u8(0x102) -- Party Made
+    local B = u8(0x0FC)
+    local C = u8(0x0A3)
+    return A ~= 0x00 and not (A== 0xF2 and B == 0xF2 and C == 0xF2)
+end
+
+function generateLocationChecked()
+    memDomain.saveram()
+    data = uRange(0x01FF, 0x101)
+    data[0] = nil
+    return data
+end
+
+function setConsumableStacks()
+    memDomain.rom()
+    consumableStacks = {}
+    -- In order shards, tent, cabin, house, heal, pure, soft, ext1, ext2, ext3, ex4
+    consumableStacks[0x35] = 1
+    consumableStacks[0x36] = u8(0x47400) + 1
+    consumableStacks[0x37] = u8(0x47401) + 1
+    consumableStacks[0x38] = u8(0x47402) + 1
+    consumableStacks[0x39] = u8(0x47403) + 1
+    consumableStacks[0x3A] = u8(0x47404) + 1
+    consumableStacks[0x3B] = u8(0x47405) + 1
+    consumableStacks[0x3C] = u8(0x47406) + 1
+    consumableStacks[0x3D] = u8(0x47407) + 1
+    consumableStacks[0x3E] = u8(0x47408) + 1
+    consumableStacks[0x3F] = u8(0x47409) + 1
+end
+
+function getEmptyWeaponSlots()
+    memDomain.saveram()
+    ret = {}
+    count = 1
+    slot1 = uRange(0x118, 0x4)
+    slot2 = uRange(0x158, 0x4)
+    slot3 = uRange(0x198, 0x4)
+    slot4 = uRange(0x1D8, 0x4)
+    for i,v in pairs(slot1) do
+        if v == 0 then
+            ret[count] = 0x118 + i
+            count = count + 1
+        end
+    end
+    for i,v in pairs(slot2) do
+        if v == 0 then
+            ret[count] = 0x158 + i
+            count = count + 1
+        end
+    end
+    for i,v in pairs(slot3) do
+        if v == 0 then
+            ret[count] = 0x198 + i
+            count = count + 1
+        end
+    end
+    for i,v in pairs(slot4) do
+        if v == 0 then
+            ret[count] = 0x1D8 + i
+            count = count + 1
+        end
+    end
+    return ret
+end
+
+function getEmptyArmorSlots()
+    memDomain.saveram()
+    ret = {}
+    count = 1
+    slot1 = uRange(0x11C, 0x4)
+    slot2 = uRange(0x15C, 0x4)
+    slot3 = uRange(0x19C, 0x4)
+    slot4 = uRange(0x1DC, 0x4)
+    for i,v in pairs(slot1) do
+        if v == 0 then
+            ret[count] = 0x11C + i
+            count = count + 1
+        end
+    end
+    for i,v in pairs(slot2) do
+        if v == 0 then
+            ret[count] = 0x15C + i
+            count = count + 1
+        end
+    end
+    for i,v in pairs(slot3) do
+        if v == 0 then
+            ret[count] = 0x19C + i
+            count = count + 1
+        end
+    end
+    for i,v in pairs(slot4) do
+        if v == 0 then
+            ret[count] = 0x1DC + i
+            count = count + 1
+        end
+    end
+    return ret
+end
+local function slice (tbl, s, e)
+    local pos, new = 1, {}
+    for i = s + 1, e do
+        new[pos] = tbl[i]
+        pos = pos + 1
+    end
+    return new
+end
+function processBlock(block)
+    local msgBlock = block['messages']
+    if msgBlock ~= nil then
+        for i, v in pairs(msgBlock) do
+            if itemMessages[i] == nil then
+                local msg = {TTL=450, message=v, color=0xFFFF0000}
+                itemMessages[i] = msg
+            end
+        end
+    end
+    local itemsBlock = block["items"]
+    memDomain.saveram()
+    isInGame = u8(0x102)
+    if itemsBlock ~= nil and isInGame ~= 0x00 then
+        if consumableStacks == nil then
+            setConsumableStacks()
+        end
+        memDomain.saveram()
+--         print('ITEMBLOCK: ')
+--         print(itemsBlock)
+        itemIndex = u8(ITEM_INDEX)
+--         print('ITEMINDEX: '..itemIndex)
+        for i, v in pairs(slice(itemsBlock, itemIndex, #itemsBlock)) do
+            -- Minus the offset and add to the correct domain
+            local memoryLocation = v
+            if v >= 0x100 and v <= 0x114 then
+                -- This is a key item
+                memoryLocation = memoryLocation - 0x0E0
+                wU8(memoryLocation, 0x01)
+            elseif v >= 0x1E0 and v <= 0x1F2 then
+                -- This is a movement item
+                -- Minus Offset (0x100) - movement offset (0xE0)
+                memoryLocation = memoryLocation - 0x1E0
+                -- Canal is a flipped bit
+                if memoryLocation == 0x0C then
+                    wU8(memoryLocation, 0x00)
+                else
+                    wU8(memoryLocation, 0x01)
+                end
+            elseif v >= 0x1F3 and v <= 0x1F4 then
+                -- NoOverworld special items
+                memoryLocation = noOverworldItemsLookup[v]
+                wU8(memoryLocation, 0x01)
+            elseif v >= 0x16C and v <= 0x1AF then
+                -- This is a gold item
+                amountToAdd = goldLookup[v]
+                biggest = u8(0x01E)
+                medium = u8(0x01D)
+                smallest = u8(0x01C)
+                currentValue = 0x10000 * biggest + 0x100 * medium + smallest
+                newValue = currentValue + amountToAdd
+                newBiggest = math.floor(newValue / 0x10000)
+                newMedium = math.floor(math.fmod(newValue, 0x10000) / 0x100)
+                newSmallest = math.floor(math.fmod(newValue, 0x100))
+                wU8(0x01E, newBiggest)
+                wU8(0x01D, newMedium)
+                wU8(0x01C, newSmallest)
+            elseif v >= 0x115 and v <= 0x11B then
+                -- This is a regular consumable OR a shard
+                -- Minus Offset (0x100) + item offset (0x20)
+                memoryLocation = memoryLocation - 0x0E0
+                currentValue = u8(memoryLocation)
+                amountToAdd = consumableStacks[memoryLocation]
+                if currentValue < 99 then
+                    wU8(memoryLocation, currentValue + amountToAdd)
+                end
+            elseif v >= 0x1B0  and v <= 0x1BB then
+                -- This is an extension consumable
+                memoryLocation = extensionConsumableLookup[v]
+                currentValue = u8(memoryLocation)
+                amountToAdd = consumableStacks[memoryLocation]
+                if currentValue < 99 then
+                    value = currentValue + amountToAdd
+                    if value > 99 then
+                        value = 99
+                    end
+                    wU8(memoryLocation, value)
+                end
+            end
+        end
+        if #itemsBlock > itemIndex then
+            wU8(ITEM_INDEX, #itemsBlock)
+        end
+
+        memDomain.saveram()
+        weaponIndex = u8(WEAPON_INDEX)
+        emptyWeaponSlots = getEmptyWeaponSlots()
+        lastUsedWeaponIndex = weaponIndex
+--         print('WEAPON_INDEX: '.. weaponIndex)
+        memDomain.saveram()
+        for i, v in pairs(slice(itemsBlock, weaponIndex, #itemsBlock)) do
+            if v >= 0x11C and v <= 0x143 then
+                -- Minus the offset and add to the correct domain
+                local itemValue = v - 0x11B
+                if #emptyWeaponSlots > 0 then
+                    slot = table.remove(emptyWeaponSlots, 1)
+                    wU8(slot, itemValue)
+                    lastUsedWeaponIndex = weaponIndex + i
+                else
+                    break
+                end
+            end
+        end
+        if lastUsedWeaponIndex ~= weaponIndex then
+            wU8(WEAPON_INDEX, lastUsedWeaponIndex)
+        end
+        memDomain.saveram()
+        armorIndex = u8(ARMOR_INDEX)
+        emptyArmorSlots = getEmptyArmorSlots()
+        lastUsedArmorIndex = armorIndex
+--         print('ARMOR_INDEX: '.. armorIndex)
+        memDomain.saveram()
+        for i, v in pairs(slice(itemsBlock, armorIndex, #itemsBlock)) do
+            if v >= 0x144 and v <= 0x16B then
+                -- Minus the offset and add to the correct domain
+                local itemValue = v - 0x143
+                if #emptyArmorSlots > 0 then
+                    slot = table.remove(emptyArmorSlots, 1)
+                    wU8(slot, itemValue)
+                    lastUsedArmorIndex = armorIndex + i
+                else
+                    break
+                end
+            end
+        end
+        if lastUsedArmorIndex ~= armorIndex then
+            wU8(ARMOR_INDEX, lastUsedArmorIndex)
+        end
+    end
+end
+
+function receive()
+    l, e = ff1Socket:receive()
+    if e == 'closed' then
+        if curstate == STATE_OK then
+            print("Connection closed")
+        end
+        curstate = STATE_UNINITIALIZED
+        return
+    elseif e == 'timeout' then
+        print("timeout")
+        return
+    elseif e ~= nil then
+        print(e)
+        curstate = STATE_UNINITIALIZED
+        return
+    end
+    processBlock(json.decode(l))
+
+    -- Determine Message to send back
+    memDomain.rom()
+    local playerName = uRange(0x7BCBF, 0x41)
+    playerName[0] = nil
+    local retTable = {}
+    retTable["playerName"] = playerName
+    if StateOKForMainLoop() then
+        retTable["locations"] = generateLocationChecked()
+    end
+    msg = json.encode(retTable).."\n"
+    local ret, error = ff1Socket:send(msg)
+    if ret == nil then
+        print(error)
+    elseif curstate == STATE_INITIAL_CONNECTION_MADE then
+        curstate = STATE_TENTATIVELY_CONNECTED
+    elseif curstate == STATE_TENTATIVELY_CONNECTED then
+        print("Connected!")
+        itemMessages["(0,0)"] = {TTL=240, message="Connected", color="green"}
+        curstate = STATE_OK
+    end
+end
+
+function main()
+    if not checkBizHawkVersion() then
+        return
+    end
+    server, error = socket.bind('localhost', 52980)
+
+    while true do
+        gui.drawEllipse(248, 9, 6, 6, "Black", "Yellow")
+        frame = frame + 1
+        drawMessages()
+        if not (curstate == prevstate) then
+            -- console.log("Current state: "..curstate)
+            prevstate = curstate
+        end
+        if (curstate == STATE_OK) or (curstate == STATE_INITIAL_CONNECTION_MADE) or (curstate == STATE_TENTATIVELY_CONNECTED) then
+            if (frame % 60 == 0) then
+                gui.drawEllipse(248, 9, 6, 6, "Black", "Blue")
+                receive()
+            else
+                gui.drawEllipse(248, 9, 6, 6, "Black", "Green")
+            end
+        elseif (curstate == STATE_UNINITIALIZED) then
+            gui.drawEllipse(248, 9, 6, 6, "Black", "White")
+            if  (frame % 60 == 0) then
+                gui.drawEllipse(248, 9, 6, 6, "Black", "Yellow")
+
+                drawText(5, 8, "Waiting for client", 0xFFFF0000)
+                drawText(5, 32, "Please start FF1Client.exe", 0xFFFF0000)
+
+                -- Advance so the messages are drawn
+                emu.frameadvance()
+                server:settimeout(2)
+                print("Attempting to connect")
+                local client, timeout = server:accept()
+                if timeout == nil then
+                    -- print('Initial Connection Made')
+                    curstate = STATE_INITIAL_CONNECTION_MADE
+                    ff1Socket = client
+                    ff1Socket:settimeout(0)
+                end
+            end
+        end
+        emu.frameadvance()
+    end
+end
+
+main()

data/options.yaml

@@ -51,9 +51,10 @@ requires:
   {%- for option_key, option in group_options.items() %}
   {{ option_key }}:
     {%- if option.__doc__ %}
-    # {{ cleandoc(option.__doc__)
+    # {{ option.__doc__
         | trim
-        | replace('\n', '\n# ')
+        | replace('\n\n', '\n    \n')
+        | replace('\n    ', '\n# ')
         | indent(4, first=False)
       }}
     {%- endif -%}

docs/CODEOWNERS

@@ -87,9 +87,6 @@
 # Inscryption
 /worlds/inscryption/ @DrBibop @Glowbuzz
 
-# Jak and Daxter: The Precursor Legacy
-/worlds/jakanddaxter/ @massimilianodelliubaldini
-
 # Kirby's Dream Land 3
 /worlds/kdl3/ @Silvris
 
@@ -160,9 +157,6 @@
 # Saving Princess
 /worlds/saving_princess/ @LeonarthCG
 
-# shapez
-/worlds/shapez/ @BlastSlimey
-
 # Shivers
 /worlds/shivers/ @GodlFire @korydondzila
 
@@ -181,9 +175,6 @@
 # Super Mario 64
 /worlds/sm64ex/ @N00byKing
 
-# Super Mario Land 2: 6 Golden Coins
-/worlds/marioland2/ @Alchav
-
 # Super Mario World
 /worlds/smw/ @PoryGone
 
@@ -193,6 +184,9 @@
 # Secret of Evermore
 /worlds/soe/ @black-sliver
 
+# Slay the Spire
+/worlds/spire/ @KonoTyran
+
 # Stardew Valley
 /worlds/stardew_valley/ @agilbert1412
 
@@ -238,10 +232,14 @@
 # Zillion
 /worlds/zillion/ @beauxq
 
+# Zork Grand Inquisitor
+/worlds/zork_grand_inquisitor/ @nbrochu
+
+
 ## Active Unmaintained Worlds
 
 # The following worlds in this repo are currently unmaintained, but currently still work in core. If any update breaks
-# compatibility, these worlds may be deleted. If you are interested in stepping up as maintainer for
+# compatibility, these worlds may be moved to `worlds_disabled`. If you are interested in stepping up as maintainer for
 # any of these worlds, please review `/docs/world maintainer.md` documentation.
 
 # Final Fantasy (1)
@@ -250,6 +248,15 @@
 # Ocarina of Time
 # /worlds/oot/
 
+## Disabled Unmaintained Worlds
+
+# The following worlds in this repo are currently unmaintained and disabled as they do not work in core. If you are
+# interested in stepping up as maintainer for any of these worlds, please review `/docs/world maintainer.md`
+# documentation.
+
+# Ori and the Blind Forest
+# /worlds_disabled/oribf/
+
 ###################
 ## Documentation ##
 ###################

docs/apworld_dev_faq.md

@@ -8,11 +8,7 @@ including [Contributing](contributing.md), [Adding Games](<adding games.md>), an
 
 ### 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
-than one item to get a player to sphere 2.
-
-One way to fix this is to hint to the Generator that an item needs to be in sphere one with local_early_items. 
-Here, `1` represents the number of "Sword" items the Generator will attempt to place in sphere one.
+Hint to the Generator that an item needs to be in sphere one with local_early_items. Here, `1` represents the number of "Sword" items to attempt to place in sphere one.
 ```py
 early_item_name = "Sword"
 self.multiworld.local_early_items[self.player][early_item_name] = 1
@@ -22,19 +18,15 @@ Some alternative ways to try to fix this problem are:
 * Add more locations to sphere one of your world, potentially only when there would be a restrictive start
 * Pre-place items yourself, such as during `create_items`
 * Put items into the player's starting inventory using `push_precollected`
-* Raise an exception, such as an `OptionError` during `generate_early`, to disallow options that would lead to a
-  restrictive start
+* Raise an exception, such as an `OptionError` during `generate_early`, to disallow options that would lead to a restrictive start
 
 ---
 
-### I have multiple options that change the item/location pool counts and need to make sure I am not submitting more/fewer items than locations
+### I have multiple settings that change the item/location pool counts and need to balance them out
 
-In an ideal situation your system for producing locations and items wouldn't leave any opportunity for them to be
-unbalanced. But in real, complex situations, that might be unfeasible.
+In an ideal situation your system for producing locations and items wouldn't leave any opportunity for them to be unbalanced. But in real, complex situations, that might be unfeasible.
 
-If that's the case, you can create extra filler based on the difference between your unfilled locations and your
-itempool by comparing [get_unfilled_locations](https://github.com/ArchipelagoMW/Archipelago/blob/main/BaseClasses.py#:~:text=get_unfilled_locations)
-to your list of items to submit
+If that's the case, you can create extra filler based on the difference between your unfilled locations and your itempool by comparing [get_unfilled_locations](https://github.com/ArchipelagoMW/Archipelago/blob/main/BaseClasses.py#:~:text=get_unfilled_locations) to your list of items to submit
 
 Note: to use self.create_filler(), self.get_filler_item_name() should be defined to only return valid filler item names
 ```py
@@ -47,8 +39,7 @@ for _ in range(total_locations - len(item_pool)):
 self.multiworld.itempool += item_pool
 ```
 
-A faster alternative to the `for` loop would be to use a
-[list comprehension](https://docs.python.org/3/tutorial/datastructures.html#list-comprehensions):
+A faster alternative to the `for` loop would be to use a [list comprehension](https://docs.python.org/3/tutorial/datastructures.html#list-comprehensions):
 ```py
 item_pool += [self.create_filler() for _ in range(total_locations - len(item_pool))]
 ```
@@ -57,39 +48,24 @@ item_pool += [self.create_filler() for _ in range(total_locations - len(item_poo
 
 ### I learned about indirect conditions in the world API document, but I want to know more. What are they and why are they necessary?
 
-The world API document mentions how to use `multiworld.register_indirect_condition` to register indirect conditions and
-**when** you should use them, but not *how* they work and *why* they are necessary. This is because the explanation is
-quite complicated.
+The world API document mentions how to use `multiworld.register_indirect_condition` to register indirect conditions and **when** you should use them, but not *how* they work and *why* they are necessary. This is because the explanation is quite complicated.
 
-Region sweep (the algorithm that determines which regions are reachable) is a Breadth-First Search of the region graph.
-It starts from the origin region, checks entrances one by one, and adds newly reached regions and their entrances to
-the queue until there is nothing more to check.
+Region sweep (the algorithm that determines which regions are reachable) is a Breadth-First Search of the region graph. It starts from the origin region, checks entrances one by one, and adds newly reached regions and their entrances to the queue until there is nothing more to check.
 
-For performance reasons, AP only checks every entrance once. However, if an entrance's access_rule depends on region
-access, then the following may happen:
-1. The entrance is checked and determined to be nontraversable because the region in its access_rule hasn't been
-   reached yet during the graph search.
+For performance reasons, AP only checks every entrance once. However, if an entrance's access_rule depends on region access, then the following may happen:
+1. The entrance is checked and determined to be nontraversable because the region in its access_rule hasn't been reached yet during the graph search.
 2. Then, the region in its access_rule is determined to be reachable.
 
 This entrance *would* be in logic if it were rechecked, but it won't be rechecked this cycle.
-To account for this case, AP would have to recheck all entrances every time a new region is reached until no new
-regions are reached.
+To account for this case, AP would have to recheck all entrances every time a new region is reached until no new regions are reached.
 
-An indirect condition is how you can manually define that a specific entrance needs to be rechecked during region sweep
-if a specific region is reached during it.
-This keeps most of the performance upsides. Even in a game making heavy use of indirect conditions (ex: The Witness),
-using them is significantly faster than just "rechecking each entrance until nothing new is found".
-The reason entrance access rules using `location.can_reach` and `entrance.can_reach` are also affected is because they
-call `region.can_reach` on their respective parent/source region.
+An indirect condition is how you can manually define that a specific entrance needs to be rechecked during region sweep if a specific region is reached during it.
+This keeps most of the performance upsides. Even in a game making heavy use of indirect conditions (ex: The Witness), using them is significantly faster than just "rechecking each entrance until nothing new is found".
+The reason entrance access rules using `location.can_reach` and `entrance.can_reach` are also affected is because they call `region.can_reach` on their respective parent/source region.
 
-We recognize it can feel like a trap since it will not alert you when you are missing an indirect condition,
-and that some games have very complex access rules.
-As of [PR #3682 (Core: Region handling customization)](https://github.com/ArchipelagoMW/Archipelago/pull/3682)
-being merged, it is possible for a world to opt out of indirect conditions entirely, instead using the system of
-checking each entrance whenever a region has been reached, although this does come with a performance cost.
-Opting out of using indirect conditions should only be used by games that *really* need it. For most games, it should
-be reasonable to know all entrance &rarr; region dependencies, making indirect conditions preferred because they are
-much faster.
+We recognize it can feel like a trap since it will not alert you when you are missing an indirect condition, and that some games have very complex access rules.
+As of [PR #3682 (Core: Region handling customization)](https://github.com/ArchipelagoMW/Archipelago/pull/3682) being merged, it is possible for a world to opt out of indirect conditions entirely, instead using the system of checking each entrance whenever a region has been reached, although this does come with a performance cost.
+Opting out of using indirect conditions should only be used by games that *really* need it. For most games, it should be reasonable to know all entrance &rarr; region dependencies, making indirect conditions preferred because they are much faster.
 
 ---
 
@@ -109,34 +85,3 @@ Common situations where this can happen include:
   Also, consider using the `options.as_dict("option_name", "option_two")` helper.
 * Using enums as Location/Item names in the datapackage. When building out `location_name_to_id` and `item_name_to_id`,
   make sure that you are not using your enum class for either the names or ids in these mappings.
-
----
-
-### Some locations are technically possible to check with few or no items, but they'd be very tedious or frustrating. How do worlds deal with this?
-
-Sometimes the game can be modded to skip these locations or make them less tedious. But when this issue is due to a fundamental aspect of the game, then the general answer is "soft logic" (and its subtypes like "combat logic", "money logic", etc.). For example: you can logically require that a player have several helpful items before fighting the final boss, even if a skilled player technically needs no items to beat it. Randomizer logic should describe what's *fun* rather than what's technically possible.
-
-Concrete examples of soft logic include:
-- Defeating a boss might logically require health upgrades, damage upgrades, certain weapons, etc. that aren't strictly necessary.
-- Entering a high-level area might logically require access to enough other parts of the game that checking other locations should naturally get the player to the soft-required level.
-- Buying expensive shop items might logically require access to a place where you can quickly farm money, or logically require access to enough parts of the game that checking other locations should naturally generate enough money without grinding.
-
-Remember that all items referenced by logic (however hard or soft) must be `progression`. Since you typically don't want to turn a ton of `filler` items into `progression` just for this, it's common to e.g. write money logic using only the rare "$100" item, so the dozens of "$1" and "$10" items in your world can remain `filler`.
-
----
-
-### What if my game has "missable" or "one-time-only" locations or region connections?
-
-Archipelago logic assumes that once a region or location becomes reachable, it stays reachable forever, no matter what 
-the player does in-game. Slightly more formally: Receiving an AP item must never cause a region connection or location 
-to "go out of logic" (become unreachable when it was previously reachable), and receiving AP items is the only kind of 
-state change that AP logic acknowledges. No other actions or events can change reachability.
-
-So when the game itself does not follow this assumption, the options are:
-- Modify the game to make that location/connection repeatable
-- If there are both missable and repeatable ways to check the location/traverse the connection, then write logic for 
-  only the repeatable ways
-- Don't generate the missable location/connection at all
-  - 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

docs/network diagram/network diagram.md

@@ -117,6 +117,8 @@ flowchart LR
     %% Java Based Games
     subgraph Java
         JM[Mod with Archipelago.MultiClient.Java]
+        STS[Slay the Spire]
+        JM <-- Mod the Spire --> STS
         subgraph Minecraft
             MCS[Minecraft Forge Server]
             JMC[Any Java Minecraft Clients]

docs/network protocol.md

@@ -231,11 +231,11 @@ Sent to clients after a client requested this message be sent to them, more info
 Sent to clients if the server caught a problem with a packet. This only occurs for errors that are explicitly checked for.
 
 #### Arguments
-| Name | Type        | Notes |
-| ---- |-------------| ----- |
-| type | str         | The [PacketProblemType](#PacketProblemType) that was detected in the packet. |
-| original_cmd | str \| None | The `cmd` argument of the faulty packet, will be `None` if the `cmd` failed to be parsed. |
-| text | str         | A descriptive message of the problem at hand. |
+| Name | Type | Notes |
+| ---- | ---- | ----- |
+| type | str | The [PacketProblemType](#PacketProblemType) that was detected in the packet. |
+| original_cmd | Optional[str] | The `cmd` argument of the faulty packet, will be `None` if the `cmd` failed to be parsed. |
+| text | str | A descriptive message of the problem at hand. |
 
 ##### PacketProblemType
 `PacketProblemType` indicates the type of problem that was detected in the faulty packet, the known problem types are below but others may be added in the future.
@@ -551,14 +551,14 @@ In JSON this may look like:
 Message nodes sent along with [PrintJSON](#PrintJSON) packet to be reconstructed into a legible message. The nodes are intended to be read in the order they are listed in the packet.
 
 ```python
-from typing import TypedDict
+from typing import TypedDict, Optional
 class JSONMessagePart(TypedDict):
-    type: str | None
-    text: str | None
-    color: str | None # only available if type is a color
-    flags: int | None # only available if type is an item_id or item_name
-    player: int | None # only available if type is either item or location
-    hint_status: HintStatus | None # only available if type is hint_status
+    type: Optional[str]
+    text: Optional[str]
+    color: Optional[str] # only available if type is a color
+    flags: Optional[int] # only available if type is an item_id or item_name
+    player: Optional[int] # only available if type is either item or location
+    hint_status: Optional[HintStatus] # only available if type is hint_status
 ```
 
 `type` is used to denote the intent of the message part. This can be used to indicate special information which may be rendered differently depending on client. How these types are displayed in Archipelago's ALttP client is not the end-all be-all. Other clients may choose to interpret and display these messages differently.

docs/options api.md

@@ -333,7 +333,7 @@ within the world.
 ### TextChoice
 Like choice allows you to predetermine options and has all of the same comparison methods and handling. Also accepts any
 user defined string as a valid option, so will either need to be validated by adding a validation step to the option
-class or within world, if necessary. Value for this class is `str | int` so if you need the value at a specified
+class or within world, if necessary. Value for this class is `Union[str, int]` so if you need the value at a specified
 point, `self.options.my_option.current_key` will always return a string.
 
 ### PlandoBosses
@@ -352,15 +352,8 @@ template. If you set a [Schema](https://pypi.org/project/schema/) on the class w
 options system will automatically validate the user supplied data against the schema to ensure it's in the correct
 format.
 
-### OptionCounter
-This is a special case of OptionDict where the dictionary values can only be integers.  
-It returns a [collections.Counter](https://docs.python.org/3/library/collections.html#collections.Counter).
-This means that if you access a key that isn't present, its value will be 0.  
-The upside of using an OptionCounter (instead of an OptionDict with integer values) is that an OptionCounter can be
-displayed on the Options page on WebHost.
-
 ### ItemDict
-An OptionCounter that will verify that every key in the dictionary is a valid name for an item for your world.
+Like OptionDict, except this will verify that every key in the dictionary is a valid name for an item for your world.
 
 ### OptionList
 This option defines a List, where the user can add any number of strings to said list, allowing duplicate values. You

docs/settings api.md

@@ -102,16 +102,17 @@ In worlds, this should only be used for the top level to avoid issues when upgra
 
 ### Bool
 
-Since `bool` can not be subclassed, use the `settings.Bool` helper in a union to get a comment in host.yaml.
+Since `bool` can not be subclassed, use the `settings.Bool` helper in a `typing.Union` to get a comment in host.yaml.
 
 ```python
 import settings
+import typing
 
 class MySettings(settings.Group):
     class MyBool(settings.Bool):
         """Doc string"""
 
-    my_value: MyBool | bool = True
+    my_value: typing.Union[MyBool, bool] = True
 ```
 
 ### UserFilePath
@@ -133,15 +134,15 @@ Checks the file against [md5s](#md5s) by default.
 
 Resolves to an executable (varying file extension based on platform)
 
-#### description: str | None
+#### description: Optional\[str\]
 
 Human-readable name to use in file browser
 
-#### copy_to: str | None
+#### copy_to: Optional\[str\]
 
 Instead of storing the path, copy the file.
 
-#### md5s: list[str | bytes]
+#### md5s: List[Union[str, bytes]]
 
 Provide md5 hashes as hex digests or raw bytes for automatic validation.
 

docs/tests.md

@@ -11,13 +11,8 @@ found in the [general test directory](/test/general).
 ## Defining World Tests
 
 In order to run tests from your world, you will need to create a `test` package within your world package. This can be
-done by creating a `test` directory inside your world with an (empty) `__init__.py` inside it. By convention, a base
-for your world tests can be created in `bases.py` or any file that does not start with `test`, that you can then import
-into other modules. All tests should be defined in files named `test_*.py` (all lower case) and be member functions
-(named `test_*`) of classes (named `Test*` or `*Test`) that inherit from `unittest.TestCase` or a test base.
-
-Defining anything inside `test/__init__.py` is deprecated. Defining TestBase there was previously the norm; however,
-it complicates test discovery because some worlds also put actual tests into `__init__.py`.
+done by creating a `test` directory with a file named `__init__.py` inside it inside your world. By convention, a base
+for your world tests can be created in this file that you can then import into other modules.
 
 ### WorldTestBase
 
@@ -26,7 +21,7 @@ interactions in the world interact as expected, you will want to use the [WorldT
 comes with the basics for test setup as well as a few preloaded tests that most worlds might want to check on varying
 options combinations.
 
-Example `/worlds/<my_game>/test/bases.py`:
+Example `/worlds/<my_game>/test/__init__.py`:
 
 ```python
 from test.bases import WorldTestBase
@@ -54,7 +49,7 @@ with `test_`.
 Example `/worlds/<my_game>/test/test_chest_access.py`:
 
 ```python
-from .bases import MyGameTestBase
+from . import MyGameTestBase
 
 
 class TestChestAccess(MyGameTestBase):
@@ -124,12 +119,8 @@ variable to keep all the benefits of the test framework while not running the ma
 #### Using Pycharm
 
 In PyCharm, running all tests can be done by right-clicking the root test directory and selecting Run 'Archipelago Unittests'. 
-If you have never previously run ModuleUpdate.py, then you will need to do this once before the tests will run. 
-You can run ModuleUpdate.py by right-clicking ModuleUpdate.py and selecting `Run 'ModuleUpdate'`. 
-After running ModuleUpdate.py you may still get a `ModuleNotFoundError: No module named 'flask'` for the webhost tests. 
-If this happens, run WebHost.py by right-clicking it and selecting `Run 'WebHost'`. Make sure to press enter when prompted. 
-Unless you configured PyCharm to use pytest as a test runner, you may get import failures. To solve this, 
-edit the run configuration, and set the working directory to the Archipelago directory which contains all the project files. 
+Unless you configured PyCharm to use pytest as a test runner, you may get import failures. To solve this, edit the run configuration, 
+and set the working directory to the Archipelago directory which contains all the project files. 
 
 If you only want to run your world's defined tests, repeat the steps for the test directory within your world.
 Your working directory should be the directory of your world in the worlds directory and the script should be the 

docs/world api.md

@@ -561,7 +561,7 @@ from .items import is_progression  # this is just a dummy
 
 
 def create_item(self, item: str) -> MyGameItem:
-    # this is called when AP wants to create an item by name (for plando, start inventory, item links) or when you call it from your own code
+    # this is called when AP wants to create an item by name (for plando) or when you call it from your own code
     classification = ItemClassification.progression if is_progression(item) else ItemClassification.filler
     return MyGameItem(item, classification, self.item_name_to_id[item], self.player)
 

docs/world maintainer.md

@@ -65,5 +65,5 @@ date, voting members and final result in the commit message.
 
 ## Handling of Unmaintained Worlds
 
-As long as worlds are known to work for the most part, they can stay included. Once the world becomes broken, it shall 
-be deleted.
+As long as worlds are known to work for the most part, they can stay included. Once a world becomes broken it shall be
+moved from `worlds/` to `worlds_disabled/`.

inno_setup.iss

@@ -45,8 +45,7 @@ MinVersion={#min_windows}
 Name: "english"; MessagesFile: "compiler:Default.isl"
 
 [Tasks]
-Name: "desktopicon"; Description: "{cm:CreateDesktopIcon}";
-Name: "deletelib"; Description: "Clean existing /lib folder and subfolders including /worlds (leave checked if unsure)"; Check: ShouldShowDeleteLibTask
+Name: "desktopicon"; Description: "{cm:CreateDesktopIcon}"; GroupDescription: "{cm:AdditionalIcons}";
 
 [Types]
 Name: "full"; Description: "Full installation"
@@ -84,9 +83,18 @@ Filename: "{app}\ArchipelagoLauncher"; Description: "{cm:LaunchProgram,{#StringC
 Type: dirifempty; Name: "{app}"
 
 [InstallDelete]
-Type: files; Name: "{app}\*.exe"
+Type: files; Name: "{app}\lib\worlds\_bizhawk.apworld"
+Type: files; Name: "{app}\ArchipelagoLttPClient.exe"
+Type: files; Name: "{app}\ArchipelagoPokemonClient.exe"
 Type: files; Name: "{app}\data\lua\connector_pkmn_rb.lua"
-Type: files; Name: "{app}\data\lua\connector_ff1.lua"
+Type: filesandordirs; Name: "{app}\lib\worlds\rogue-legacy"
+Type: dirifempty; Name: "{app}\lib\worlds\rogue-legacy"
+Type: files; Name: "{app}\lib\worlds\sc2wol.apworld"
+Type: filesandordirs; Name: "{app}\lib\worlds\sc2wol"
+Type: dirifempty; Name: "{app}\lib\worlds\sc2wol"
+Type: filesandordirs; Name: "{app}\lib\worlds\bk_sudoku"
+Type: dirifempty; Name: "{app}\lib\worlds\bk_sudoku"
+Type: files; Name: "{app}\ArchipelagoLauncher(DEBUG).exe"
 Type: filesandordirs; Name: "{app}\SNI\lua*"
 Type: filesandordirs; Name: "{app}\EnemizerCLI*"
 #include "installdelete.iss"
@@ -253,17 +261,3 @@ begin
     Result := True;
   end;
 end;
-
-function ShouldShowDeleteLibTask: Boolean;
-begin
-  Result := DirExists(ExpandConstant('{app}\lib'));
-end;
-
-procedure CurStepChanged(CurStep: TSetupStep);
-begin
-  if CurStep = ssInstall then
-  begin
-    if WizardIsTaskSelected('deletelib') then
-      DelTree(ExpandConstant('{app}\lib'), True, True, True);
-  end;
-end;

kvui.py

@@ -6,6 +6,7 @@ import re
 import io
 import pkgutil
 from collections import deque
+
 assert "kivy" not in sys.modules, "kvui should be imported before kivy for frozen compatibility"
 
 if sys.platform == "win32":
@@ -42,8 +43,8 @@ from kivy.core.image import ImageLoader, ImageLoaderBase, ImageData
 from kivy.base import ExceptionHandler, ExceptionManager
 from kivy.clock import Clock
 from kivy.factory import Factory
-from kivy.properties import BooleanProperty, ObjectProperty, NumericProperty, StringProperty
-from kivy.metrics import dp, sp
+from kivy.properties import BooleanProperty, ObjectProperty, NumericProperty
+from kivy.metrics import dp
 from kivy.uix.widget import Widget
 from kivy.uix.layout import Layout
 from kivy.utils import escape_markup
@@ -56,11 +57,10 @@ from kivy.animation import Animation
 from kivy.uix.popup import Popup
 from kivy.uix.image import AsyncImage
 from kivymd.app import MDApp
-from kivymd.uix.dialog import MDDialog, MDDialogHeadlineText, MDDialogSupportingText, MDDialogButtonContainer
 from kivymd.uix.gridlayout import MDGridLayout
 from kivymd.uix.floatlayout import MDFloatLayout
 from kivymd.uix.boxlayout import MDBoxLayout
-from kivymd.uix.tab.tab import MDTabsSecondary, MDTabsItem, MDTabsItemText, MDTabsCarousel
+from kivymd.uix.tab.tab import MDTabsPrimary, MDTabsItem, MDTabsItemText, MDTabsCarousel
 from kivymd.uix.menu import MDDropdownMenu
 from kivymd.uix.menu.menu import MDDropdownTextItem
 from kivymd.uix.dropdownitem import MDDropDownItem, MDDropDownItemText
@@ -90,15 +90,15 @@ remove_between_brackets = re.compile(r"\[.*?]")
 class ThemedApp(MDApp):
     def set_colors(self):
         text_colors = KivyJSONtoTextParser.TextColors()
-        self.theme_cls.theme_style = text_colors.theme_style
-        self.theme_cls.primary_palette = text_colors.primary_palette
-        self.theme_cls.dynamic_scheme_name = text_colors.dynamic_scheme_name
-        self.theme_cls.dynamic_scheme_contrast = text_colors.dynamic_scheme_contrast
+        self.theme_cls.theme_style = getattr(text_colors, "theme_style", "Dark")
+        self.theme_cls.primary_palette = getattr(text_colors, "primary_palette", "Green")
+        self.theme_cls.dynamic_scheme_name = getattr(text_colors, "dynamic_scheme_name", "TONAL_SPOT")
+        self.theme_cls.dynamic_scheme_contrast = getattr(text_colors, "dynamic_scheme_contrast", 0.0)
 
 
 class ImageIcon(MDButtonIcon, AsyncImage):
     def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
+        super().__init__(args, kwargs)
         self.image = ApAsyncImage(**kwargs)
         self.add_widget(self.image)
 
@@ -166,34 +166,6 @@ class ToggleButton(MDButton, ToggleButtonBehavior):
                 child.icon_color = self.theme_cls.primaryColor
 
 
-# thanks kivymd
-class ResizableTextField(MDTextField):
-    """
-    Resizable MDTextField that manually overrides the builtin sizing.
-
-    Note that in order to use this, the sizing must be specified from within a .kv rule.
-    """
-    def __init__(self, *args, **kwargs):
-        # cursed rules override
-        rules = Builder.match(self)
-        textfield = next((rule for rule in rules if rule.name == f"<MDTextField>"), None)
-        if textfield:
-            subclasses = rules[rules.index(textfield) + 1:]
-            for subclass in subclasses:
-                height_rule = subclass.properties.get("height", None)
-                if height_rule:
-                    height_rule.ignore_prev = True
-        super().__init__(*args, **kwargs)
-
-
-def on_release(self: MDButton, *args):
-    super(MDButton, self).on_release(args)
-    self.on_leave()
-
-
-MDButton.on_release = on_release
-
-
 # I was surprised to find this didn't already exist in kivy :(
 class HoverBehavior(object):
     """originally from https://stackoverflow.com/a/605348110"""
@@ -294,15 +266,11 @@ class TooltipLabel(HovererableLabel, MDTooltip):
         self._tooltip = None
 
 
-class ServerLabel(HoverBehavior, MDTooltip, MDBoxLayout):
+class ServerLabel(HovererableLabel, MDTooltip):
     tooltip_display_delay = 0.1
-    text: str = StringProperty("Server:")
 
     def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.add_widget(MDIcon(icon="information", font_size=sp(15)))
-        self.add_widget(TooltipLabel(text=self.text, pos_hint={"center_x": 0.5, "center_y": 0.5},
-                                     font_size=sp(15)))
+        super(HovererableLabel, self).__init__(*args, **kwargs)
         self._tooltip = ServerToolTip(text="Test")
 
     def on_enter(self):
@@ -415,6 +383,7 @@ class MarkupDropdownTextItem(MDDropdownTextItem):
         for child in self.children:
             if child.__class__ == MDLabel:
                 child.markup = True
+        print(self.text)
     # Currently, this only lets us do markup on text that does not have any icons
     # Create new TextItems as needed
 
@@ -492,13 +461,14 @@ class MarkupDropdown(MDDropdownMenu):
             self.menu.data = self._items
 
 
-class AutocompleteHintInput(ResizableTextField):
+class AutocompleteHintInput(MDTextField):
     min_chars = NumericProperty(3)
 
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
 
-        self.dropdown = MarkupDropdown(caller=self, position="bottom", border_margin=dp(2), width=self.width)
+        self.dropdown = MarkupDropdown(caller=self, position="bottom", border_margin=dp(24), width=self.width)
+        self.dropdown.bind(on_select=lambda instance, x: setattr(self, 'text', x))
         self.bind(on_text_validate=self.on_message)
         self.bind(width=lambda instance, x: setattr(self.dropdown, "width", x))
 
@@ -515,11 +485,8 @@ class AutocompleteHintInput(ResizableTextField):
 
             def on_press(text):
                 split_text = MarkupLabel(text=text).markup
-                self.set_text(self, "".join(text_frag for text_frag in split_text
-                                            if not text_frag.startswith("[")))
-                self.dropdown.dismiss()
-                self.focus = True
-
+                return self.dropdown.select("".join(text_frag for text_frag in split_text
+                                                    if not text_frag.startswith("[")))
             lowered = value.lower()
             for item_name in item_names:
                 try:
@@ -531,7 +498,7 @@ class AutocompleteHintInput(ResizableTextField):
                     text = text[:index] + "[b]" + text[index:index+len(value)]+"[/b]"+text[index+len(value):]
                     self.dropdown.items.append({
                         "text": text,
-                        "on_release": lambda txt=text: on_press(txt),
+                        "on_release": lambda: on_press(text),
                         "markup": True
                     })
             if not self.dropdown.parent:
@@ -653,7 +620,7 @@ class HintLabel(RecycleDataViewBehavior, MDBoxLayout):
             self.selected = is_selected
 
 
-class ConnectBarTextInput(ResizableTextField):
+class ConnectBarTextInput(MDTextField):
     def insert_text(self, substring, from_undo=False):
         s = substring.replace("\n", "").replace("\r", "")
         return super(ConnectBarTextInput, self).insert_text(s, from_undo=from_undo)
@@ -663,14 +630,14 @@ def is_command_input(string: str) -> bool:
     return len(string) > 0 and string[0] in "/!"
 
 
-class CommandPromptTextInput(ResizableTextField):
+class CommandPromptTextInput(MDTextField):
     MAXIMUM_HISTORY_MESSAGES = 50
 
     def __init__(self, **kwargs) -> None:
         super().__init__(**kwargs)
         self._command_history_index = -1
         self._command_history: typing.Deque[str] = deque(maxlen=CommandPromptTextInput.MAXIMUM_HISTORY_MESSAGES)
-
+    
     def update_history(self, new_entry: str) -> None:
         self._command_history_index = -1
         if is_command_input(new_entry):
@@ -697,7 +664,7 @@ class CommandPromptTextInput(ResizableTextField):
             self._change_to_history_text_if_available(self._command_history_index - 1)
             return True
         return super().keyboard_on_key_down(window, keycode, text, modifiers)
-
+    
     def _change_to_history_text_if_available(self, new_index: int) -> None:
         if new_index < -1:
             return
@@ -710,108 +677,34 @@ class CommandPromptTextInput(ResizableTextField):
         self.text = self._command_history[self._command_history_index]
 
 
-class MessageBoxLabel(MDLabel):
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-        self._label.refresh()
-
-
 class MessageBox(Popup):
+    class MessageBoxLabel(MDLabel):
+        def __init__(self, **kwargs):
+            super().__init__(**kwargs)
+            self._label.refresh()
+            self.size = self._label.texture.size
+            if self.width + 50 > Window.width:
+                self.text_size[0] = Window.width - 50
+                self._label.refresh()
+                self.size = self._label.texture.size
 
     def __init__(self, title, text, error=False, **kwargs):
-        label = MessageBoxLabel(text=text)
+        label = MessageBox.MessageBoxLabel(text=text)
         separator_color = [217 / 255, 129 / 255, 122 / 255, 1.] if error else [47 / 255., 167 / 255., 212 / 255, 1.]
-        super().__init__(title=title, content=label, size_hint=(0.5, None), width=max(100, int(label.width) + 40),
+        super().__init__(title=title, content=label, size_hint=(None, None), width=max(100, int(label.width) + 40),
                          separator_color=separator_color, **kwargs)
         self.height += max(0, label.height - 18)
 
 
-class ButtonsPrompt(MDDialog):
-    def __init__(self, title: str, text: str, response: typing.Callable[[str], None],
-                 *prompts: str, **kwargs) -> None:
-        """
-        Customizable popup box that lets you create any number of buttons. The text of the pressed button is returned to
-        the callback.
-
-        :param title: The title of the popup.
-        :param text: The message prompt in the popup.
-        :param response: A callable that will get called when the user presses a button. The prompt will not close
-         itself so should be done here if you want to close it when certain buttons are pressed.
-        :param prompts: Any number of strings to be used for the buttons.
-        """
-        layout = MDBoxLayout(orientation="vertical")
-        label = MessageBoxLabel(text=text)
-        layout.add_widget(label)
-
-        def on_release(button: MDButton, *args) -> None:
-            response(button.text)
-
-        buttons = [MDDivider()]
-        for prompt in prompts:
-            button = MDButton(
-                MDButtonText(text=prompt, pos_hint={"center_x": 0.5, "center_y": 0.5}),
-                on_release=on_release,
-                style="text",
-                theme_width="Custom",
-                size_hint_x=1,
-            )
-            button.text = prompt
-            buttons.extend([button, MDDivider()])
-
-        super().__init__(
-            MDDialogHeadlineText(text=title),
-            MDDialogSupportingText(text=text),
-            MDDialogButtonContainer(*buttons, orientation="vertical"),
-            **kwargs,
-        )
-
-
-class ClientTabs(MDTabsSecondary):
+class ClientTabs(MDTabsPrimary):
     carousel: MDTabsCarousel
     lock_swiping = True
 
     def __init__(self, *args, **kwargs):
-        self.carousel = MDTabsCarousel(lock_swiping=True, anim_move_duration=0.2)
-        super().__init__(*args, MDDivider(size_hint_y=None, height=dp(1)), self.carousel, **kwargs)
+        self.carousel = MDTabsCarousel(lock_swiping=True)
+        super().__init__(*args, MDDivider(size_hint_y=None, height=dp(4)), self.carousel, **kwargs)
         self.size_hint_y = 1
 
-    def _check_panel_height(self, *args):
-        self.ids.tab_scroll.height = dp(38)
-
-    def update_indicator(
-        self, x: float = 0.0, w: float = 0.0, instance: MDTabsItem = None
-    ) -> None:
-        def update_indicator(*args):
-            indicator_pos = (0, 0)
-            indicator_size = (0, 0)
-
-            item_text_object = self._get_tab_item_text_icon_object()
-
-            if item_text_object:
-                indicator_pos = (
-                    instance.x + dp(12),
-                    self.indicator.pos[1]
-                    if not self._tabs_carousel
-                    else self._tabs_carousel.height,
-                )
-                indicator_size = (
-                    instance.width - dp(24),
-                    self.indicator_height,
-                )
-
-            Animation(
-                pos=indicator_pos,
-                size=indicator_size,
-                d=0 if not self.indicator_anim else self.indicator_duration,
-                t=self.indicator_transition,
-            ).start(self.indicator)
-
-        if not instance:
-            self.indicator.pos = (x, self.indicator.pos[1])
-            self.indicator.size = (w, self.indicator_height)
-        else:
-            Clock.schedule_once(update_indicator)
-
     def remove_tab(self, tab, content=None):
         if content is None:
             content = tab.content
@@ -820,21 +713,6 @@ class ClientTabs(MDTabsSecondary):
         self.on_size(self, self.size)
 
 
-class CommandButton(MDButton, MDTooltip):
-    def __init__(self, *args, manager: "GameManager", **kwargs):
-        super().__init__(*args, **kwargs)
-        self.manager = manager
-        self._tooltip = ToolTip(text="Test")
-
-    def on_enter(self):
-        self._tooltip.text = self.manager.commandprocessor.get_help_text()
-        self._tooltip.font_size = dp(20 - (len(self._tooltip.text) // 400))  # mostly guessing on the numbers here
-        self.display_tooltip()
-
-    def on_leave(self):
-        self.animation_tooltip_dismiss()
-
-
 class GameManager(ThemedApp):
     logging_pairs = [
         ("Client", "Archipelago"),
@@ -889,19 +767,19 @@ class GameManager(ThemedApp):
 
         self.grid = MainLayout()
         self.grid.cols = 1
-        self.connect_layout = MDBoxLayout(orientation="horizontal", size_hint_y=None, height=dp(40),
+        self.connect_layout = MDBoxLayout(orientation="horizontal", size_hint_y=None, height=dp(70),
                                           spacing=5, padding=(5, 10))
         # top part
-        server_label = ServerLabel(width=dp(75))
+        server_label = ServerLabel(halign="center")
         self.connect_layout.add_widget(server_label)
         self.server_connect_bar = ConnectBarTextInput(text=self.ctx.suggested_address or "archipelago.gg:",
-                                                      pos_hint={"center_x": 0.5, "center_y": 0.5})
+                                                      size_hint_y=None, role="medium",
+                                                      height=dp(70), multiline=False, write_tab=False)
 
         def connect_bar_validate(sender):
             if not self.ctx.server:
                 self.connect_button_action(sender)
 
-        self.server_connect_bar.height = dp(30)
         self.server_connect_bar.bind(on_text_validate=connect_bar_validate)
         self.connect_layout.add_widget(self.server_connect_bar)
         self.server_connect_button = MDButton(MDButtonText(text="Connect"), style="filled", size=(dp(100), dp(70)),
@@ -914,7 +792,7 @@ class GameManager(ThemedApp):
         self.grid.add_widget(self.progressbar)
 
         # middle part
-        self.tabs = ClientTabs(pos_hint={"center_x": 0.5, "center_y": 0.5})
+        self.tabs = ClientTabs()
         self.tabs.add_widget(MDTabsItem(MDTabsItemText(text="All" if len(self.logging_pairs) > 1 else "Archipelago")))
         self.log_panels["All"] = self.tabs.default_tab_content = UILog(*(logging.getLogger(logger_name)
                                                                              for logger_name, name in
@@ -942,13 +820,12 @@ class GameManager(ThemedApp):
         self.grid.add_widget(self.main_area_container)
 
         # bottom part
-        bottom_layout = MDBoxLayout(orientation="horizontal", size_hint_y=None, height=dp(40), spacing=5, padding=(5, 10))
-        info_button = CommandButton(MDButtonText(text="Command:", halign="left"), manager=self, radius=5,
-                                    style="filled", size=(dp(100), dp(70)), size_hint_x=None, size_hint_y=None,
-                                    pos_hint={"center_y": 0.575})
+        bottom_layout = MDBoxLayout(orientation="horizontal", size_hint_y=None, height=dp(70), spacing=5, padding=(5, 10))
+        info_button = MDButton(MDButtonText(text="Command:"), radius=5, style="filled", size=(dp(100), dp(70)),
+                               size_hint_x=None, size_hint_y=None, pos_hint={"center_y": 0.575})
         info_button.bind(on_release=self.command_button_action)
         bottom_layout.add_widget(info_button)
-        self.textinput = CommandPromptTextInput(size_hint_y=None, multiline=False, write_tab=False)
+        self.textinput = CommandPromptTextInput(size_hint_y=None, height=dp(30), multiline=False, write_tab=False)
         self.textinput.bind(on_text_validate=self.on_message)
         info_button.height = self.textinput.height
         self.textinput.text_validate_unfocus = False
@@ -966,27 +843,15 @@ class GameManager(ThemedApp):
         self.server_connect_bar.focus = True
         self.server_connect_bar.select_text(port_start if port_start > 0 else host_start, len(s))
 
-        # Uncomment to enable the kivy live editor console
-        # Press Ctrl-E (with numlock/capslock) disabled to open
-        # from kivy.core.window import Window
-        # from kivy.modules import console
-        # console.create_console(Window, self.container)
-
         return self.container
 
-    def add_client_tab(self, title: str, content: Widget, index: int = -1) -> Widget:
+    def add_client_tab(self, title: str, content: Widget) -> Widget:
         """Adds a new tab to the client window with a given title, and provides a given Widget as its content.
          Returns the new tab widget, with the provided content being placed on the tab as content."""
         new_tab = MDTabsItem(MDTabsItemText(text=title))
         new_tab.content = content
-        if -1 < index <= len(self.tabs.carousel.slides):
-            new_tab.bind(on_release=self.tabs.set_active_item)
-            new_tab._tabs = self.tabs
-            self.tabs.ids.container.add_widget(new_tab, index=index)
-            self.tabs.carousel.add_widget(new_tab.content, index=len(self.tabs.carousel.slides) - index)
-        else:
-            self.tabs.add_widget(new_tab)
-            self.tabs.carousel.add_widget(new_tab.content)
+        self.tabs.add_widget(new_tab)
+        self.tabs.carousel.add_widget(new_tab.content)
         return new_tab
 
     def update_texts(self, dt):
@@ -1136,9 +1001,8 @@ class HintLayout(MDBoxLayout):
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
-        boxlayout = MDBoxLayout(orientation="horizontal", size_hint_y=None, height=dp(40))
-        boxlayout.add_widget(MDLabel(text="New Hint:", size_hint_x=None, size_hint_y=None,
-                                     height=dp(40), width=dp(75), halign="center", valign="center"))
+        boxlayout = MDBoxLayout(orientation="horizontal", size_hint_y=None, height=dp(55))
+        boxlayout.add_widget(MDLabel(text="New Hint:", size_hint_x=None, size_hint_y=None, height=dp(55)))
         boxlayout.add_widget(AutocompleteHintInput())
         self.add_widget(boxlayout)
 
@@ -1148,7 +1012,7 @@ class HintLayout(MDBoxLayout):
             if fix_func:
                 fix_func()
 
-
+        
 status_names: typing.Dict[HintStatus, str] = {
     HintStatus.HINT_FOUND: "Found",
     HintStatus.HINT_UNSPECIFIED: "Unspecified",
@@ -1245,7 +1109,6 @@ class HintLog(MDRecycleView):
 
 
 class ApAsyncImage(AsyncImage):
-
     def is_uri(self, filename: str) -> bool:
         if filename.startswith("ap:"):
             return True
@@ -1291,23 +1154,7 @@ class E(ExceptionHandler):
 class KivyJSONtoTextParser(JSONtoTextParser):
     # dummy class to absorb kvlang definitions
     class TextColors(Widget):
-        white: str = StringProperty("FFFFFF")
-        black: str = StringProperty("000000")
-        red: str = StringProperty("EE0000")
-        green: str = StringProperty("00FF7F")
-        yellow: str = StringProperty("FAFAD2")
-        blue: str = StringProperty("6495ED")
-        magenta: str = StringProperty("EE00EE")
-        cyan: str = StringProperty("00EEEE")
-        slateblue: str = StringProperty("6D8BE8")
-        plum: str = StringProperty("AF99EF")
-        salmon: str = StringProperty("FA8072")
-        orange: str = StringProperty("FF7700")
-        # KivyMD parameters
-        theme_style: str = StringProperty("Dark")
-        primary_palette: str = StringProperty("Lightsteelblue")
-        dynamic_scheme_name: str = StringProperty("VIBRANT")
-        dynamic_scheme_contrast: int = NumericProperty(0)
+        pass
 
     def __init__(self, *args, **kwargs):
         # we grab the color definitions from the .kv file, then overwrite the JSONtoTextParser default entries

pytest.ini

@@ -1,5 +1,5 @@
 [pytest]
-python_files = test_*.py Test*.py __init__.py  # TODO: remove Test* once all worlds have been ported
+python_files = test_*.py Test*.py  # TODO: remove Test* once all worlds have been ported
 python_classes = Test
 python_functions = test
 testpaths =

requirements.txt

@@ -7,7 +7,7 @@ schema>=0.7.7
 kivy>=2.3.1
 bsdiff4>=1.2.6
 platformdirs>=4.3.6
-certifi>=2025.4.26
+certifi>=2025.1.31
 cython>=3.0.12
 cymem>=2.0.11
 orjson>=3.10.15

settings.py

@@ -10,10 +10,9 @@ import sys
 import types
 import typing
 import warnings
-from collections.abc import Iterator, Sequence
 from enum import IntEnum
 from threading import Lock
-from typing import cast, Any, BinaryIO, ClassVar, TextIO, TypeVar, Union
+from typing import cast, Any, BinaryIO, ClassVar, Dict, Iterator, List, Optional, TextIO, Tuple, Union, TypeVar
 
 __all__ = [
     "get_settings", "fmt_doc", "no_gui",
@@ -24,7 +23,7 @@ __all__ = [
 
 no_gui = False
 skip_autosave = False
-_world_settings_name_cache: dict[str, str] = {}  # TODO: cache on disk and update when worlds change
+_world_settings_name_cache: Dict[str, str] = {}  # TODO: cache on disk and update when worlds change
 _world_settings_name_cache_updated = False
 _lock = Lock()
 
@@ -54,7 +53,7 @@ def fmt_doc(cls: type, level: int) -> str:
 
 
 class Group:
-    _type_cache: ClassVar[dict[str, Any] | None] = None
+    _type_cache: ClassVar[Optional[Dict[str, Any]]] = None
     _dumping: bool = False
     _has_attr: bool = False
     _changed: bool = False
@@ -107,7 +106,7 @@ class Group:
                                         self.__dict__.values()))
 
     @classmethod
-    def get_type_hints(cls) -> dict[str, Any]:
+    def get_type_hints(cls) -> Dict[str, Any]:
         """Returns resolved type hints for the class"""
         if cls._type_cache is None:
             if not cls.__annotations__ or not isinstance(next(iter(cls.__annotations__.values())), str):
@@ -125,10 +124,10 @@ class Group:
             return self[key]
         return default
 
-    def items(self) -> list[tuple[str, Any]]:
+    def items(self) -> List[Tuple[str, Any]]:
         return [(key, getattr(self, key)) for key in self]
 
-    def update(self, dct: dict[str, Any]) -> None:
+    def update(self, dct: Dict[str, Any]) -> None:
         assert isinstance(dct, dict), f"{self.__class__.__name__}.update called with " \
                                       f"{dct.__class__.__name__} instead of dict."
 
@@ -197,7 +196,7 @@ class Group:
                         warnings.warn(f"{self.__class__.__name__}.{k} "
                                       f"assigned from incompatible type {type(v).__name__}")
 
-    def as_dict(self, *args: str, downcast: bool = True) -> dict[str, Any]:
+    def as_dict(self, *args: str, downcast: bool = True) -> Dict[str, Any]:
         return {
             name: _to_builtin(cast(object, getattr(self, name))) if downcast else getattr(self, name)
             for name in self if not args or name in args
@@ -212,7 +211,7 @@ class Group:
         f.write(f"{indent}{yaml_line}")
 
     @classmethod
-    def _dump_item(cls, name: str | None, attr: object, f: TextIO, level: int) -> None:
+    def _dump_item(cls, name: Optional[str], attr: object, f: TextIO, level: int) -> None:
         """Write a group, dict or sequence item to f, where attr can be a scalar or a collection"""
 
         # lazy construction of yaml Dumper to avoid loading Utils early
@@ -224,7 +223,7 @@ class Group:
                     def represent_mapping(self, tag: str, mapping: Any, flow_style: Any = None) -> MappingNode:
                         from yaml import ScalarNode
                         res: MappingNode = super().represent_mapping(tag, mapping, flow_style)
-                        pairs = cast(list[tuple[ScalarNode, Any]], res.value)
+                        pairs = cast(List[Tuple[ScalarNode, Any]], res.value)
                         for k, v in pairs:
                             k.style = None  # remove quotes from keys
                         return res
@@ -330,9 +329,9 @@ class Path(str):
     """Marks the file as required and opens a file browser when missing"""
     is_exe: bool = False
     """Special cross-platform handling for executables"""
-    description: str | None = None
+    description: Optional[str] = None
     """Title to display when browsing for the file"""
-    copy_to: str | None = None
+    copy_to: Optional[str] = None
     """If not None, copy to AP folder instead of linking it"""
 
     @classmethod
@@ -340,7 +339,7 @@ class Path(str):
         """Overload and raise to validate input files from browse"""
         pass
 
-    def browse(self: T, **kwargs: Any) -> T | None:
+    def browse(self: T, **kwargs: Any) -> Optional[T]:
         """Opens a file browser to search for the file"""
         raise NotImplementedError(f"Please use a subclass of Path for {self.__class__.__name__}")
 
@@ -370,12 +369,12 @@ class _LocalPath(str):
 class FilePath(Path):
     # path to a file
 
-    md5s: ClassVar[list[str | bytes]] = []
+    md5s: ClassVar[List[Union[str, bytes]]] = []
     """MD5 hashes for default validator."""
 
     def browse(self: T,
-               filetypes: Sequence[tuple[str, Sequence[str]]] | None = None, **kwargs: Any)\
-            -> T | None:
+               filetypes: Optional[typing.Sequence[typing.Tuple[str, typing.Sequence[str]]]] = None, **kwargs: Any)\
+            -> Optional[T]:
         from Utils import open_filename, is_windows
         if not filetypes:
             if self.is_exe:
@@ -440,7 +439,7 @@ class FilePath(Path):
 class FolderPath(Path):
     # path to a folder
 
-    def browse(self: T, **kwargs: Any) -> T | None:
+    def browse(self: T, **kwargs: Any) -> Optional[T]:
         from Utils import open_directory
         res = open_directory(f"Select {self.description or self.__class__.__name__}", self)
         if res:
@@ -598,16 +597,16 @@ class ServerOptions(Group):
         OFF = 0
         ON = 1
 
-    host: str | None = None
+    host: Optional[str] = None
     port: int = 38281
-    password: str | None = None
-    multidata: str | None = None
-    savefile: str | None = None
+    password: Optional[str] = None
+    multidata: Optional[str] = None
+    savefile: Optional[str] = None
     disable_save: bool = False
     loglevel: str = "info"
     logtime: bool = False
-    server_password: ServerPassword | None = None
-    disable_item_cheat: DisableItemCheat | bool = False
+    server_password: Optional[ServerPassword] = None
+    disable_item_cheat: Union[DisableItemCheat, bool] = False
     location_check_points: LocationCheckPoints = LocationCheckPoints(1)
     hint_cost: HintCost = HintCost(10)
     release_mode: ReleaseMode = ReleaseMode("auto")
@@ -703,7 +702,7 @@ does nothing if not found
         """
 
     sni_path: SNIPath = SNIPath("SNI")
-    snes_rom_start: SnesRomStart | bool = True
+    snes_rom_start: Union[SnesRomStart, bool] = True
 
 
 class BizHawkClientOptions(Group):
@@ -722,7 +721,7 @@ class BizHawkClientOptions(Group):
         """
 
     emuhawk_path: EmuHawkPath = EmuHawkPath(None)
-    rom_start: RomStart | bool = True
+    rom_start: Union[RomStart, bool] = True
 
 
 # Top-level group with lazy loading of worlds
@@ -734,7 +733,7 @@ class Settings(Group):
     sni_options: SNIOptions = SNIOptions()
     bizhawkclient_options: BizHawkClientOptions = BizHawkClientOptions()
 
-    _filename: str | None = None
+    _filename: Optional[str] = None
 
     def __getattribute__(self, key: str) -> Any:
         if key.startswith("_") or key in self.__class__.__dict__:
@@ -788,7 +787,7 @@ class Settings(Group):
 
         return super().__getattribute__(key)
 
-    def __init__(self, location: str | None):  # change to PathLike[str] once we drop 3.8?
+    def __init__(self, location: Optional[str]):  # change to PathLike[str] once we drop 3.8?
         super().__init__()
         if location:
             from Utils import parse_yaml
@@ -822,7 +821,7 @@ class Settings(Group):
             import atexit
             atexit.register(autosave)
 
-    def save(self, location: str | None = None) -> None:  # as above
+    def save(self, location: Optional[str] = None) -> None:  # as above
         from Utils import parse_yaml
         location = location or self._filename
         assert location, "No file specified"
@@ -855,7 +854,7 @@ class Settings(Group):
         super().dump(f, level)
 
     @property
-    def filename(self) -> str | None:
+    def filename(self) -> Optional[str]:
         return self._filename
 
 
@@ -868,7 +867,7 @@ def get_settings() -> Settings:
         if not res:
             from Utils import user_path, local_path
             filenames = ("options.yaml", "host.yaml")
-            locations: list[str] = []
+            locations: List[str] = []
             if os.path.join(os.getcwd()) != local_path():
                 locations += filenames  # use files from cwd only if it's not the local_path
             locations += [user_path(filename) for filename in filenames]

setup.py

@@ -1,20 +1,22 @@
 import base64
 import datetime
-import io
-import json
 import os
 import platform
 import shutil
-import subprocess
 import sys
 import sysconfig
-import threading
-import urllib.request
 import warnings
 import zipfile
-from collections.abc import Iterable, Sequence
+import urllib.request
+import io
+import json
+import threading
+import subprocess
+
 from hashlib import sha3_512
 from pathlib import Path
+from typing import Dict, Iterable, List, Optional, Sequence, Set, Tuple, Union
+
 
 # This is a bit jank. We need cx-Freeze to be able to run anything from this script, so install it
 requirement = 'cx-Freeze==8.0.0'
@@ -58,17 +60,19 @@ from Cython.Build import cythonize
 
 
 # On  Python < 3.10 LogicMixin is not currently supported.
-non_apworlds: set[str] = {
+non_apworlds: Set[str] = {
     "A Link to the Past",
     "Adventure",
     "ArchipIDLE",
     "Archipelago",
     "Clique",
+    "Final Fantasy",
     "Lufia II Ancient Cave",
     "Meritous",
     "Ocarina of Time",
     "Overcooked! 2",
     "Raft",
+    "Slay the Spire",
     "Sudoku",
     "Super Mario 64",
     "VVVVVV",
@@ -144,13 +148,13 @@ def download_SNI() -> None:
         print(f"No SNI found for system spec {platform_name} {machine_name}")
 
 
-signtool: str | None
+signtool: Optional[str]
 if os.path.exists("X:/pw.txt"):
     print("Using signtool")
     with open("X:/pw.txt", encoding="utf-8-sig") as f:
         pw = f.read()
     signtool = r'signtool sign /f X:/_SITS_Zertifikat_.pfx /p "' + pw + \
-               r'" /fd sha256 /td sha256 /tr http://timestamp.digicert.com/ '
+               r'" /fd sha256 /tr http://timestamp.digicert.com/ '
 else:
     signtool = None
 
@@ -202,7 +206,7 @@ def remove_sprites_from_folder(folder: Path) -> None:
             os.remove(folder / file)
 
 
-def _threaded_hash(filepath: str | Path) -> str:
+def _threaded_hash(filepath: Union[str, Path]) -> str:
     hasher = sha3_512()
     hasher.update(open(filepath, "rb").read())
     return base64.b85encode(hasher.digest()).decode()
@@ -252,7 +256,7 @@ class BuildExeCommand(cx_Freeze.command.build_exe.build_exe):
         self.libfolder = Path(self.buildfolder, "lib")
         self.library = Path(self.libfolder, "library.zip")
 
-    def installfile(self, path: Path, subpath: str | Path | None = None, keep_content: bool = False) -> None:
+    def installfile(self, path: Path, subpath: Optional[Union[str, Path]] = None, keep_content: bool = False) -> None:
         folder = self.buildfolder
         if subpath:
             folder /= subpath
@@ -371,7 +375,11 @@ class BuildExeCommand(cx_Freeze.command.build_exe.build_exe):
         from worlds.AutoWorld import AutoWorldRegister
         assert not non_apworlds - set(AutoWorldRegister.world_types), \
             f"Unknown world {non_apworlds - set(AutoWorldRegister.world_types)} designated for .apworld"
-        folders_to_remove: list[str] = []
+        folders_to_remove: List[str] = []
+        disabled_worlds_folder = "worlds_disabled"
+        for entry in os.listdir(disabled_worlds_folder):
+            if os.path.isdir(os.path.join(disabled_worlds_folder, entry)):
+                folders_to_remove.append(entry)
         generate_yaml_templates(self.buildfolder / "Players" / "Templates", False)
         for worldname, worldtype in AutoWorldRegister.world_types.items():
             if worldname not in non_apworlds:
@@ -439,12 +447,12 @@ class AppImageCommand(setuptools.Command):
         ("app-exec=", None, "The application to run inside the image."),
         ("yes", "y", 'Answer "yes" to all questions.'),
     ]
-    build_folder: Path | None
-    dist_file: Path | None
-    app_dir: Path | None
+    build_folder: Optional[Path]
+    dist_file: Optional[Path]
+    app_dir: Optional[Path]
     app_name: str
-    app_exec: Path | None
-    app_icon: Path | None  # source file
+    app_exec: Optional[Path]
+    app_icon: Optional[Path]  # source file
     app_id: str  # lower case name, used for icon and .desktop
     yes: bool
 
@@ -481,12 +489,12 @@ tmp="${{exe#*/}}"
 if [ ! "${{#tmp}}" -lt "${{#exe}}" ]; then
     exe="{default_exe.parent}/$exe"
 fi
-export LD_LIBRARY_PATH="${{LD_LIBRARY_PATH:+$LD_LIBRARY_PATH:}}$APPDIR/{default_exe.parent}/lib"
+export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:$APPDIR/{default_exe.parent}/lib"
 $APPDIR/$exe "$@"
 """)
         launcher_filename.chmod(0o755)
 
-    def install_icon(self, src: Path, name: str | None = None, symlink: Path | None = None) -> None:
+    def install_icon(self, src: Path, name: Optional[str] = None, symlink: Optional[Path] = None) -> None:
         assert self.app_dir, "Invalid app_dir"
         try:
             from PIL import Image
@@ -549,7 +557,7 @@ $APPDIR/$exe "$@"
         subprocess.call(f'ARCH={build_arch} ./appimagetool -n "{self.app_dir}" "{self.dist_file}"', shell=True)
 
 
-def find_libs(*args: str) -> Sequence[tuple[str, str]]:
+def find_libs(*args: str) -> Sequence[Tuple[str, str]]:
     """Try to find system libraries to be included."""
     if not args:
         return []
@@ -557,7 +565,7 @@ def find_libs(*args: str) -> Sequence[tuple[str, str]]:
     arch = build_arch.replace('_', '-')
     libc = 'libc6'  # we currently don't support musl
 
-    def parse(line: str) -> tuple[tuple[str, str, str], str]:
+    def parse(line: str) -> Tuple[Tuple[str, str, str], str]:
         lib, path = line.strip().split(' => ')
         lib, typ = lib.split(' ', 1)
         for test_arch in ('x86-64', 'i386', 'aarch64'):
@@ -582,8 +590,8 @@ def find_libs(*args: str) -> Sequence[tuple[str, str]]:
             k: v for k, v in (parse(line) for line in data if "=>" in line)
         }
 
-    def find_lib(lib: str, arch: str, libc: str) -> str | None:
-        cache: dict[tuple[str, str, str], str] = getattr(find_libs, "cache")
+    def find_lib(lib: str, arch: str, libc: str) -> Optional[str]:
+        cache: Dict[Tuple[str, str, str], str] = getattr(find_libs, "cache")
         for k, v in cache.items():
             if k == (lib, arch, libc):
                 return v
@@ -592,7 +600,7 @@ def find_libs(*args: str) -> Sequence[tuple[str, str]]:
                 return v
         return None
 
-    res: list[tuple[str, str]] = []
+    res: List[Tuple[str, str]] = []
     for arg in args:
         # try exact match, empty libc, empty arch, empty arch and libc
         file = find_lib(arg, arch, libc)

test/bases.py

@@ -159,6 +159,7 @@ class WorldTestBase(unittest.TestCase):
         self.multiworld.game[self.player] = self.game
         self.multiworld.player_name = {self.player: "Tester"}
         self.multiworld.set_seed(seed)
+        self.multiworld.state = CollectionState(self.multiworld)
         random.seed(self.multiworld.seed)
         self.multiworld.seed_name = get_seed_name(random)  # only called to get same RNG progression as Generate.py
         args = Namespace()
@@ -167,7 +168,6 @@ class WorldTestBase(unittest.TestCase):
                 1: option.from_any(self.options.get(name, option.default))
             })
         self.multiworld.set_options(args)
-        self.multiworld.state = CollectionState(self.multiworld)
         self.world = self.multiworld.worlds[self.player]
         for step in gen_steps:
             call_all(self.multiworld, step)

test/benchmark/locations.py

@@ -59,13 +59,13 @@ def run_locations_benchmark():
                     multiworld.game[1] = game
                     multiworld.player_name = {1: "Tester"}
                     multiworld.set_seed(0)
+                    multiworld.state = CollectionState(multiworld)
                     args = argparse.Namespace()
                     for name, option in AutoWorld.AutoWorldRegister.world_types[game].options_dataclass.type_hints.items():
                         setattr(args, name, {
                             1: option.from_any(getattr(option, "default"))
                         })
                     multiworld.set_options(args)
-                    multiworld.state = CollectionState(multiworld)
 
                     gc.collect()
                     for step in self.gen_steps:

test/general/__init__.py

@@ -49,6 +49,7 @@ def setup_multiworld(worlds: Union[List[Type[World]], Type[World]], steps: Tuple
     multiworld.game = {player: world_type.game for player, world_type in enumerate(worlds, 1)}
     multiworld.player_name = {player: f"Tester{player}" for player in multiworld.player_ids}
     multiworld.set_seed(seed)
+    multiworld.state = CollectionState(multiworld)
     args = Namespace()
     for player, world_type in enumerate(worlds, 1):
         for key, option in world_type.options_dataclass.type_hints.items():
@@ -56,7 +57,6 @@ def setup_multiworld(worlds: Union[List[Type[World]], Type[World]], steps: Tuple
             updated_options[player] = option.from_any(option.default)
             setattr(args, key, updated_options)
     multiworld.set_options(args)
-    multiworld.state = CollectionState(multiworld)
     for step in steps:
         call_all(multiworld, step)
     return multiworld

test/general/test_entrance_rando.py

@@ -1,4 +1,3 @@
-from typing import Callable
 import unittest
 from enum import IntEnum
 
@@ -35,7 +34,7 @@ def generate_entrance_pair(region: Region, name_suffix: str, group: int):
 
 
 def generate_disconnected_region_grid(multiworld: MultiWorld, grid_side_length: int, region_size: int = 0,
-                                      region_creator: Callable[[str, int, MultiWorld], Region] = Region):
+                                      region_type: type[Region] = Region):
     """
     Generates a grid-like region structure for ER testing, where menu is connected to the top-left region, and each
     region "in vanilla" has 2 2-way exits going either down or to the right, until reaching the goal region in the
@@ -45,7 +44,7 @@ def generate_disconnected_region_grid(multiworld: MultiWorld, grid_side_length:
         for col in range(grid_side_length):
             index = row * grid_side_length + col
             name = f"region{index}"
-            region = region_creator(name, 1, multiworld)
+            region = region_type(name, 1, multiworld)
             multiworld.regions.append(region)
             generate_locations(region_size, 1, region=region, tag=f"_{name}")
 
@@ -466,7 +465,7 @@ class TestRandomizeEntrances(unittest.TestCase):
             entrance_type = CustomEntrance
 
         multiworld = generate_test_multiworld()
-        generate_disconnected_region_grid(multiworld, 5, region_creator=CustomRegion)
+        generate_disconnected_region_grid(multiworld, 5, region_type=CustomRegion)
 
         self.assertRaises(EntranceRandomizationError, randomize_entrances, multiworld.worlds[1], False,
                           directionally_matched_group_lookup)

test/general/test_ids.py

@@ -47,39 +47,13 @@ class TestIDs(unittest.TestCase):
         """Test that a game doesn't have item id overlap within its own datapackage"""
         for gamename, world_type in AutoWorldRegister.world_types.items():
             with self.subTest(game=gamename):
-                len_item_id_to_name = len(world_type.item_id_to_name)
-                len_item_name_to_id = len(world_type.item_name_to_id)
-
-                if len_item_id_to_name != len_item_name_to_id:
-                    self.assertCountEqual(
-                        world_type.item_id_to_name.values(), 
-                        world_type.item_name_to_id.keys(),
-                        "\nThese items have overlapping ids with other items in its own world")
-                    self.assertCountEqual(
-                        world_type.item_id_to_name.keys(), 
-                        world_type.item_name_to_id.values(),
-                        "\nThese items have overlapping names with other items in its own world")
-                    
-                self.assertEqual(len_item_id_to_name, len_item_name_to_id)
+                self.assertEqual(len(world_type.item_id_to_name), len(world_type.item_name_to_id))
 
     def test_duplicate_location_ids(self):
         """Test that a game doesn't have location id overlap within its own datapackage"""
         for gamename, world_type in AutoWorldRegister.world_types.items():
             with self.subTest(game=gamename):
-                len_location_id_to_name = len(world_type.location_id_to_name)
-                len_location_name_to_id = len(world_type.location_name_to_id)
-
-                if len_location_id_to_name != len_location_name_to_id:
-                    self.assertCountEqual(
-                        world_type.location_id_to_name.values(), 
-                        world_type.location_name_to_id.keys(),
-                        "\nThese locations have overlapping ids with other locations in its own world")
-                    self.assertCountEqual(
-                        world_type.location_id_to_name.keys(), 
-                        world_type.location_name_to_id.values(),
-                        "\nThese locations have overlapping names with other locations in its own world")
-
-                self.assertEqual(len_location_id_to_name, len_location_name_to_id)
+                self.assertEqual(len(world_type.location_id_to_name), len(world_type.location_name_to_id))
 
     def test_postgen_datapackage(self):
         """Generates a solo multiworld and checks that the datapackage is still valid"""

test/general/test_implemented.py

@@ -53,22 +53,6 @@ class TestImplemented(unittest.TestCase):
         if failed_world_loads:
             self.fail(f"The following worlds failed to load: {failed_world_loads}")
 
-    def test_prefill_items(self):
-        """Test that every world can reach every location from allstate before pre_fill."""
-        for gamename, world_type in AutoWorldRegister.world_types.items():
-            if gamename not in ("Archipelago", "Sudoku", "Final Fantasy", "Test Game"):
-                with self.subTest(gamename):
-                    multiworld = setup_solo_multiworld(world_type, ("generate_early", "create_regions", "create_items",
-                                                                    "set_rules", "connect_entrances", "generate_basic"))
-                    allstate = multiworld.get_all_state(False)
-                    locations = multiworld.get_locations()
-                    reachable = multiworld.get_reachable_locations(allstate)
-                    unreachable = [location for location in locations if location not in reachable]
-
-                    self.assertTrue(not unreachable,
-                                    f"Locations were not reachable with all state before prefill: "
-                                    f"{unreachable}. Seed: {multiworld.seed}")
-                    
     def test_explicit_indirect_conditions_spheres(self):
         """Tests that worlds using explicit indirect conditions produce identical spheres as when using implicit
         indirect conditions"""

test/general/test_items.py

@@ -1,11 +1,7 @@
 import unittest
-from argparse import Namespace
-from typing import Type
 
-from BaseClasses import CollectionState, MultiWorld
-from Fill import distribute_items_restrictive
-from Options import ItemLinks
-from worlds.AutoWorld import AutoWorldRegister, World, call_all
+from BaseClasses import CollectionState
+from worlds.AutoWorld import AutoWorldRegister, call_all
 from . import setup_solo_multiworld
 
 
@@ -87,47 +83,6 @@ class TestBase(unittest.TestCase):
                 multiworld = setup_solo_multiworld(world_type)
                 for item in multiworld.itempool:
                     self.assertIn(item.name, world_type.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.
-        """
-        def setup_link_multiworld(world: Type[World], link_replace: bool) -> None:
-            multiworld = MultiWorld(2)
-            multiworld.game = {1: world.game, 2: world.game}
-            multiworld.player_name = {1: "Linker 1", 2: "Linker 2"}
-            multiworld.set_seed()
-            item_link_group = [{
-                "name": "ItemLinkTest",
-                "item_pool": ["Everything"],
-                "link_replacement": link_replace,
-                "replacement_item": None,
-            }]
-            args = Namespace()
-            for name, option in world.options_dataclass.type_hints.items():
-                setattr(args, name, {1: option.from_any(option.default), 2: option.from_any(option.default)})
-            setattr(args, "item_links",
-                    {1: ItemLinks.from_any(item_link_group), 2: ItemLinks.from_any(item_link_group)})
-            multiworld.set_options(args)
-            multiworld.set_item_links()
-            # groups get added to state during its constructor so this has to be after item links are set
-            multiworld.state = CollectionState(multiworld)
-            gen_steps = ("generate_early", "create_regions", "create_items", "set_rules", "connect_entrances", "generate_basic")
-            for step in gen_steps:
-                call_all(multiworld, step)
-            # link the items together and attempt to fill
-            multiworld.link_items()
-            multiworld._all_state = None
-            call_all(multiworld, "pre_fill")
-            distribute_items_restrictive(multiworld)
-            call_all(multiworld, "post_fill")
-            self.assertTrue(multiworld.can_beat_game(CollectionState(multiworld)), f"seed = {multiworld.seed}")
-
-        for game_name, world_type in AutoWorldRegister.world_types.items():
-            with self.subTest("Can generate with link replacement", game=game_name):
-                setup_link_multiworld(world_type, True)
-            with self.subTest("Can generate without link replacement", game=game_name):
-                setup_link_multiworld(world_type, False)
 
     def test_itempool_not_modified(self):
         """Test that worlds don't modify the itempool after `create_items`"""

test/general/test_state.py

@@ -26,4 +26,4 @@ class TestBase(unittest.TestCase):
                 for step in self.test_steps:
                     with self.subTest("Step", step=step):
                         call_all(multiworld, step)
-                        self.assertTrue(multiworld.get_all_state(False, allow_partial_entrances=True))
+                        self.assertTrue(multiworld.get_all_state(False, True))

test/hosting/client.py

@@ -80,8 +80,8 @@ class Client:
             "version": {
                 "class": "Version",
                 "major": 0,
-                "minor": 6,
-                "build": 0,
+                "minor": 4,
+                "build": 6,
             },
             "items_handling": 0,
             "tags": [],

test/hosting/world.py

@@ -1,12 +1,13 @@
 import re
 import shutil
 from pathlib import Path
+from typing import Dict
 
 
 __all__ = ["copy", "delete"]
 
 
-_new_worlds: dict[str, str] = {}
+_new_worlds: Dict[str, str] = {}
 
 
 def copy(src: str, dst: str) -> None:

test/programs/test_common_client.py

@@ -47,6 +47,17 @@ class TestCommonContext(unittest.IsolatedAsyncioTestCase):
         assert "Archipelago" in self.ctx.item_names, "Archipelago item names entry does not exist"
         assert "Archipelago" in self.ctx.location_names, "Archipelago location names entry does not exist"
 
+    async def test_implicit_name_lookups(self):
+        # Items
+        assert self.ctx.item_names[2**54 + 1] == "Test Item 1 - Safe"
+        assert self.ctx.item_names[2**54 + 3] == f"Unknown item (ID: {2**54+3})"
+        assert self.ctx.item_names[-1] == "Nothing"
+
+        # Locations
+        assert self.ctx.location_names[2**54 + 1] == "Test Location 1 - Safe"
+        assert self.ctx.location_names[2**54 + 3] == f"Unknown location (ID: {2**54+3})"
+        assert self.ctx.location_names[-1] == "Cheat Console"
+
     async def test_explicit_name_lookups(self):
         # Items
         assert self.ctx.item_names["__TestGame1"][2**54+1] == "Test Item 1 - Safe"

test/utils/test_caches.py

@@ -35,19 +35,6 @@ class TestCacheSelf1(unittest.TestCase):
         self.assertFalse(o1.func(1) is o1.func(2))
         self.assertFalse(o1.func(1) is o2.func(1))
 
-    def test_cache_default(self) -> None:
-        class Cls:
-            @cache_self1
-            def func(self, _: Any = 1) -> object:
-                return object()
-
-        o1 = Cls()
-        o2 = Cls()
-        self.assertIs(o1.func(), o1.func())
-        self.assertIs(o1.func(1), o1.func())
-        self.assertIsNot(o1.func(2), o1.func())
-        self.assertIsNot(o1.func(), o2.func())
-
     def test_gc(self) -> None:
         # verify that we don't keep a global reference
         import gc

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 ItemDict, NamedRange, NumericOption, OptionList, OptionSet
 
 
 class TestOptionPresets(unittest.TestCase):
@@ -19,7 +19,7 @@ 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)))
-                            supported_types = [NumericOption, OptionSet, OptionList, OptionCounter]
+                            supported_types = [NumericOption, OptionSet, OptionList, ItemDict]
                             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}' "
                                           f"is not a supported type for webhost. "

test/worlds/__init__.py

@@ -12,7 +12,7 @@ def load_tests(loader, standard_tests, pattern):
     all_tests = [
         test_case for folder in folders if os.path.exists(folder)
         for test_collection in loader.discover(folder, top_level_dir=file_path)
-        for test_suite in test_collection if isinstance(test_suite, unittest.suite.TestSuite)
+        for test_suite in test_collection
         for test_case in test_suite
     ]
 

worlds/AutoWorld.py

@@ -12,7 +12,6 @@ from typing import (Any, Callable, ClassVar, Dict, FrozenSet, Iterable, List, Ma
 
 from Options import item_and_loc_options, ItemsAccessibility, OptionGroup, PerGameCommonOptions
 from BaseClasses import CollectionState
-from Utils import deprecate
 
 if TYPE_CHECKING:
     from BaseClasses import MultiWorld, Item, Location, Tutorial, Region, Entrance
@@ -76,20 +75,19 @@ class AutoWorldRegister(type):
         # TODO - remove this once all worlds use options dataclasses
         if "options_dataclass" not in dct and "option_definitions" in dct:
             # TODO - switch to deprecate after a version
-            deprecate(f"{name} Assigned options through option_definitions which is now deprecated. "
-                      "Please use options_dataclass instead.")
+            if __debug__:
+                logging.warning(f"{name} Assigned options through option_definitions which is now deprecated. "
+                                "Please use options_dataclass instead.")
             dct["options_dataclass"] = make_dataclass(f"{name}Options", dct["option_definitions"].items(),
                                                       bases=(PerGameCommonOptions,))
 
         # construct class
         new_class = super().__new__(mcs, name, bases, dct)
-        new_class.__file__ = sys.modules[new_class.__module__].__file__
         if "game" in dct:
             if dct["game"] in AutoWorldRegister.world_types:
-                raise RuntimeError(f"""Game {dct["game"]} already registered in 
-                {AutoWorldRegister.world_types[dct["game"]].__file__} when attempting to register from
-                {new_class.__file__}.""")
+                raise RuntimeError(f"""Game {dct["game"]} already registered.""")
             AutoWorldRegister.world_types[dct["game"]] = new_class
+        new_class.__file__ = sys.modules[new_class.__module__].__file__
         if ".apworld" in new_class.__file__:
             new_class.zip_path = pathlib.Path(new_class.__file__).parents[1]
         if "settings_key" not in dct:
@@ -485,7 +483,7 @@ class World(metaclass=AutoWorldRegister):
     def get_filler_item_name(self) -> str:
         """Called when the item pool needs to be filled with additional items to match location count."""
         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()))
+        return self.multiworld.random.choice(tuple(self.item_name_to_id.keys()))
 
     @classmethod
     def create_group(cls, multiworld: "MultiWorld", new_player_id: int, players: Set[int]) -> World:
@@ -528,7 +526,7 @@ class World(metaclass=AutoWorldRegister):
         """Called when an item is collected in to state. Useful for things such as progressive items or currency."""
         name = self.collect_item(state, item)
         if name:
-            state.add_item(name, self.player)
+            state.prog_items[self.player][name] += 1
             return True
         return False
 
@@ -536,7 +534,9 @@ class World(metaclass=AutoWorldRegister):
         """Called when an item is removed from to state. Useful for things such as progressive items or currency."""
         name = self.collect_item(state, item, True)
         if name:
-            state.remove_item(name, self.player)
+            state.prog_items[self.player][name] -= 1
+            if state.prog_items[self.player][name] < 1:
+                del (state.prog_items[self.player][name])
             return True
         return False
 

worlds/Files.py

@@ -6,7 +6,6 @@ import zipfile
 from enum import IntEnum
 import os
 import threading
-from io import BytesIO
 
 from typing import ClassVar, Dict, List, Literal, Tuple, Any, Optional, Union, BinaryIO, overload, Sequence
 
@@ -71,18 +70,6 @@ class AutoPatchExtensionRegister(abc.ABCMeta):
 container_version: int = 6
 
 
-def is_ap_player_container(game: str, data: bytes, player: int):
-    if not zipfile.is_zipfile(BytesIO(data)):
-        return False
-    with zipfile.ZipFile(BytesIO(data), mode='r') as zf:
-        if "archipelago.json" in zf.namelist():
-            manifest = json.loads(zf.read("archipelago.json"))
-            if "game" in manifest and "player" in manifest:
-                if game == manifest["game"] and player == manifest["player"]:
-                    return True
-    return False
-
-
 class InvalidDataError(Exception):
     """
     Since games can override `read_contents` in APContainer,
@@ -91,15 +78,24 @@ class InvalidDataError(Exception):
 
 
 class APContainer:
-    """A zipfile containing at least archipelago.json, which contains a manifest json payload."""
-    version: ClassVar[int] = container_version
-    compression_level: ClassVar[int] = 9
-    compression_method: ClassVar[int] = zipfile.ZIP_DEFLATED
+    """A zipfile containing at least archipelago.json"""
+    version: int = container_version
+    compression_level: int = 9
+    compression_method: int = zipfile.ZIP_DEFLATED
+    game: Optional[str] = None
 
+    # instance attributes:
     path: Optional[str]
+    player: Optional[int]
+    player_name: str
+    server: str
 
-    def __init__(self, path: Optional[str] = None):
+    def __init__(self, path: Optional[str] = None, player: Optional[int] = None,
+                 player_name: str = "", server: str = ""):
         self.path = path
+        self.player = player
+        self.player_name = player_name
+        self.server = server
 
     def write(self, file: Optional[Union[str, BinaryIO]] = None) -> None:
         zip_file = file if file else self.path
@@ -139,58 +135,31 @@ class APContainer:
                         message = f"{arg0} - "
                 raise InvalidDataError(f"{message}This might be the incorrect world version for this file") from e
 
-    def read_contents(self, opened_zipfile: zipfile.ZipFile) -> Dict[str, Any]:
+    def read_contents(self, opened_zipfile: zipfile.ZipFile) -> None:
         with opened_zipfile.open("archipelago.json", "r") as f:
             manifest = json.load(f)
         if manifest["compatible_version"] > self.version:
             raise Exception(f"File (version: {manifest['compatible_version']}) too new "
                             f"for this handler (version: {self.version})")
-        return manifest
+        self.player = manifest["player"]
+        self.server = manifest["server"]
+        self.player_name = manifest["player_name"]
 
     def get_manifest(self) -> Dict[str, Any]:
         return {
+            "server": self.server,  # allow immediate connection to server in multiworld. Empty string otherwise
+            "player": self.player,
+            "player_name": self.player_name,
+            "game": self.game,
             # minimum version of patch system expected for patching to be successful
             "compatible_version": 5,
             "version": container_version,
         }
 
 
-class APPlayerContainer(APContainer):
-    """A zipfile containing at least archipelago.json meant for a player"""
-    game: ClassVar[Optional[str]] = None
-
-    player: Optional[int]
-    player_name: str
-    server: str
-
-    def __init__(self, path: Optional[str] = None, player: Optional[int] = None,
-                 player_name: str = "", server: str = ""):
-        super().__init__(path)
-        self.player = player
-        self.player_name = player_name
-        self.server = server
-
-    def read_contents(self, opened_zipfile: zipfile.ZipFile) -> Dict[str, Any]:
-        manifest = super().read_contents(opened_zipfile)
-        self.player = manifest["player"]
-        self.server = manifest["server"]
-        self.player_name = manifest["player_name"]
-        return manifest
-
-    def get_manifest(self) -> Dict[str, Any]:
-        manifest = super().get_manifest()
-        manifest.update({
-            "server": self.server,  # allow immediate connection to server in multiworld. Empty string otherwise
-            "player": self.player,
-            "player_name": self.player_name,
-            "game": self.game,
-        })
-        return manifest
-
-
-class APPatch(APPlayerContainer):
+class APPatch(APContainer):
     """
-    An `APPlayerContainer` that represents a patch file.
+    An `APContainer` that represents a patch file.
     It includes the `procedure` key in the manifest to indicate that it is a patch.
 
     Your implementation should inherit from this if your output file

worlds/LauncherComponents.py

@@ -224,12 +224,16 @@ components: List[Component] = [
     Component('OoT Client', 'OoTClient',
               file_identifier=SuffixIdentifier('.apz5')),
     Component('OoT Adjuster', 'OoTAdjuster'),
+    # FF1
+    Component('FF1 Client', 'FF1Client'),
     # TLoZ
     Component('Zelda 1 Client', 'Zelda1Client', file_identifier=SuffixIdentifier('.aptloz')),
     # ChecksFinder
     Component('ChecksFinder Client', 'ChecksFinderClient'),
     # Starcraft 2
     Component('Starcraft 2 Client', 'Starcraft2Client'),
+    # Wargroove
+    Component('Wargroove Client', 'WargrooveClient'),
     # Zillion
     Component('Zillion Client', 'ZillionClient',
               file_identifier=SuffixIdentifier('.apzl')),

worlds/adventure/Rom.py

@@ -182,11 +182,10 @@ class AdventureDeltaPatch(APPatch, metaclass=AutoPatchRegister):
                                     json.dumps(self.rom_deltas),
                                     compress_type=zipfile.ZIP_LZMA)
 
-    def read_contents(self, opened_zipfile: zipfile.ZipFile) -> dict[str, Any]:
-        manifest = super(AdventureDeltaPatch, self).read_contents(opened_zipfile)
+    def read_contents(self, opened_zipfile: zipfile.ZipFile):
+        super(AdventureDeltaPatch, self).read_contents(opened_zipfile)
         self.foreign_items = AdventureDeltaPatch.read_foreign_items(opened_zipfile)
         self.autocollect_items = AdventureDeltaPatch.read_autocollect_items(opened_zipfile)
-        return manifest
 
     @classmethod
     def get_source_data(cls) -> bytes:

worlds/ahit/Client.py

@@ -238,10 +238,10 @@ async def proxy_loop(ctx: AHITContext):
         logger.info("Aborting AHIT Proxy Client due to errors")
 
 
-def launch(*launch_args: str):
+def launch():
     async def main():
         parser = get_base_parser()
-        args = parser.parse_args(launch_args)
+        args = parser.parse_args()
 
         ctx = AHITContext(args.connect, args.password)
         logger.info("Starting A Hat in Time proxy server")

worlds/ahit/Locations.py

@@ -477,7 +477,7 @@ act_completions = {
     "Act Completion (Rush Hour)": LocData(2000311210, "Rush Hour",
                                           dlc_flags=HatDLC.dlc2,
                                           hookshot=True,
-                                          required_hats=[HatType.ICE, HatType.BREWING, HatType.DWELLER]),
+                                          required_hats=[HatType.ICE, HatType.BREWING]),
 
     "Act Completion (Time Rift - Rumbi Factory)": LocData(2000312736, "Time Rift - Rumbi Factory",
                                                           dlc_flags=HatDLC.dlc2),

worlds/ahit/Rules.py

@@ -455,7 +455,7 @@ def set_moderate_rules(world: "HatInTimeWorld"):
             if "Pink Paw Station Thug" in key and is_location_valid(world, key):
                 set_rule(world.multiworld.get_location(key, world.player), lambda state: True)
 
-        # Moderate: clear Rush Hour without Hookshot or Dweller Mask
+        # Moderate: clear Rush Hour without Hookshot
         set_rule(world.multiworld.get_location("Act Completion (Rush Hour)", world.player),
                  lambda state: state.has("Metro Ticket - Pink", world.player)
                  and state.has("Metro Ticket - Yellow", world.player)

worlds/ahit/__init__.py

@@ -16,9 +16,9 @@ from worlds.LauncherComponents import Component, components, icon_paths, launch
 from Utils import local_path
 
 
-def launch_client(*args: str):
+def launch_client():
     from .Client import launch
-    launch_component(launch, name="AHITClient", args=args)
+    launch_component(launch, name="AHITClient")
 
 
 components.append(Component("A Hat in Time Client", "AHITClient", func=launch_client,

worlds/alttp/Bosses.py

@@ -102,7 +102,7 @@ def KholdstareDefeatRule(state, player: int) -> bool:
                     state.has('Fire Rod', player) or
                     (
                             state.has('Bombos', player) and
-                            (has_sword(state, player) or state.multiworld.worlds[player].options.swordless)
+                            (has_sword(state, player) or state.multiworld.swordless[player])
                     )
             ) and
             (
@@ -111,7 +111,7 @@ def KholdstareDefeatRule(state, player: int) -> bool:
                     (
                             state.has('Fire Rod', player) and
                             state.has('Bombos', player) and
-                            state.multiworld.worlds[player].options.swordless and
+                            state.multiworld.swordless[player] and
                             can_extend_magic(state, player, 16)
                     )
             )
@@ -137,7 +137,7 @@ def AgahnimDefeatRule(state, player: int) -> bool:
 
 
 def GanonDefeatRule(state, player: int) -> bool:
-    if state.multiworld.worlds[player].options.swordless:
+    if state.multiworld.swordless[player]:
         return state.has('Hammer', player) and \
                has_fire_source(state, player) and \
                state.has('Silver Bow', player) and \
@@ -146,7 +146,7 @@ def GanonDefeatRule(state, player: int) -> bool:
     can_hurt = has_beam_sword(state, player)
     common = can_hurt and has_fire_source(state, player)
     # silverless ganon may be needed in anything higher than no glitches
-    if state.multiworld.worlds[player].options.glitches_required != 'no_glitches':
+    if state.multiworld.glitches_required[player] != 'no_glitches':
         # need to light torch a sufficient amount of times
         return common and (state.has('Tempered Sword', player) or state.has('Golden Sword', player) or (
                 state.has('Silver Bow', player) and can_shoot_arrows(state, player)) or
@@ -248,7 +248,7 @@ for location in boss_location_table:
 
 def place_boss(world: "ALTTPWorld", boss: str, location: str, level: Optional[str]) -> None:
     player = world.player
-    if location == 'Ganons Tower' and world.options.mode == 'inverted':
+    if location == 'Ganons Tower' and world.multiworld.mode[player] == 'inverted':
         location = 'Inverted Ganons Tower'
     logging.debug('Placing boss %s at %s', boss, location + (' (' + level + ')' if level else ''))
     world.dungeons[location].bosses[level] = BossFactory(boss, player)
@@ -260,8 +260,9 @@ def format_boss_location(location_name: str, level: str) -> str:
 
 def place_bosses(world: "ALTTPWorld") -> None:
     multiworld = world.multiworld
+    player = world.player
     # will either be an int or a lower case string with ';' between options
-    boss_shuffle: Union[str, int] = world.options.boss_shuffle.value
+    boss_shuffle: Union[str, int] = multiworld.boss_shuffle[player].value
     already_placed_bosses: List[str] = []
     remaining_locations: List[Tuple[str, str]] = []
     # handle plando

worlds/alttp/Dungeons.py

@@ -66,7 +66,7 @@ def create_dungeons(world: "ALTTPWorld"):
 
     def make_dungeon(name, default_boss, dungeon_regions, big_key, small_keys, dungeon_items):
         dungeon = Dungeon(name, dungeon_regions, big_key,
-                          [] if multiworld.worlds[player].options.small_key_shuffle == small_key_shuffle.option_universal else small_keys,
+                          [] if multiworld.small_key_shuffle[player] == small_key_shuffle.option_universal else small_keys,
                           dungeon_items, player)
         for item in dungeon.all_items:
             item.dungeon = dungeon
@@ -143,7 +143,7 @@ def create_dungeons(world: "ALTTPWorld"):
                       item_factory(['Small Key (Turtle Rock)'] * 6, world),
                       item_factory(['Map (Turtle Rock)', 'Compass (Turtle Rock)'], world))
 
-    if multiworld.worlds[player].options.mode != 'inverted':
+    if multiworld.mode[player] != 'inverted':
         AT = make_dungeon('Agahnims Tower', 'Agahnim', ['Agahnims Tower', 'Agahnim 1'], None,
                           item_factory(['Small Key (Agahnims Tower)'] * 4, world), [])
         GT = make_dungeon('Ganons Tower', 'Agahnim2',

worlds/alttp/EntranceRandomizer.py

@@ -54,13 +54,16 @@ def parse_arguments(argv, no_defaults=False):
     ret = parser.parse_args(argv)
 
     # cannot be set through CLI currently
+    ret.plando_items = []
+    ret.plando_texts = {}
+    ret.plando_connections = []
 
     if multiargs.multi:
         defaults = copy.deepcopy(ret)
         for player in range(1, multiargs.multi + 1):
             playerargs = parse_arguments(shlex.split(getattr(ret, f"p{player}")), True)
 
-            for name in ["game", "sprite", "sprite_pool"]:
+            for name in ["plando_items", "plando_texts", "plando_connections", "game", "sprite", "sprite_pool"]:
                 value = getattr(defaults, name) if getattr(playerargs, name) is None else getattr(playerargs, name)
                 if player == 1:
                     setattr(ret, name, {1: value})

worlds/alttp/EntranceShuffle.py

@@ -23,17 +23,17 @@ def link_entrances(world, player):
         connect_simple(world, exitname, regionname, player)
 
     # if we do not shuffle, set default connections
-    if world.worlds[player].options.entrance_shuffle == 'vanilla':
+    if world.entrance_shuffle[player] == 'vanilla':
         for exitname, regionname in default_connections:
             connect_simple(world, exitname, regionname, player)
         for exitname, regionname in default_dungeon_connections:
             connect_simple(world, exitname, regionname, player)
-    elif world.worlds[player].options.entrance_shuffle == 'dungeons_simple':
+    elif world.entrance_shuffle[player] == 'dungeons_simple':
         for exitname, regionname in default_connections:
             connect_simple(world, exitname, regionname, player)
 
         simple_shuffle_dungeons(world, player)
-    elif world.worlds[player].options.entrance_shuffle == 'dungeons_full':
+    elif world.entrance_shuffle[player] == 'dungeons_full':
         for exitname, regionname in default_connections:
             connect_simple(world, exitname, regionname, player)
 
@@ -43,7 +43,7 @@ def link_entrances(world, player):
         lw_entrances = list(LW_Dungeon_Entrances)
         dw_entrances = list(DW_Dungeon_Entrances)
 
-        if world.worlds[player].options.mode == 'standard':
+        if world.mode[player] == 'standard':
             # must connect front of hyrule castle to do escape
             connect_two_way(world, 'Hyrule Castle Entrance (South)', 'Hyrule Castle Exit (South)', player)
         else:
@@ -56,7 +56,7 @@ def link_entrances(world, player):
             dw_entrances.append('Ganons Tower')
             dungeon_exits.append('Ganons Tower Exit')
 
-        if world.worlds[player].options.mode == 'standard':
+        if world.mode[player] == 'standard':
             # rest of hyrule castle must be in light world, so it has to be the one connected to east exit of desert
             hyrule_castle_exits = [('Hyrule Castle Exit (West)', 'Hyrule Castle Exit (East)')]
             connect_mandatory_exits(world, lw_entrances, hyrule_castle_exits, list(LW_Dungeon_Entrances_Must_Exit), player)
@@ -65,9 +65,9 @@ def link_entrances(world, player):
             connect_mandatory_exits(world, lw_entrances, dungeon_exits, list(LW_Dungeon_Entrances_Must_Exit), player)
         connect_mandatory_exits(world, dw_entrances, dungeon_exits, list(DW_Dungeon_Entrances_Must_Exit), player)
         connect_caves(world, lw_entrances, dw_entrances, dungeon_exits, player)
-    elif world.worlds[player].options.entrance_shuffle == 'dungeons_crossed':
+    elif world.entrance_shuffle[player] == 'dungeons_crossed':
         crossed_shuffle_dungeons(world, player)
-    elif world.worlds[player].options.entrance_shuffle == 'simple':
+    elif world.entrance_shuffle[player] == 'simple':
         simple_shuffle_dungeons(world, player)
 
         old_man_entrances = list(Old_Man_Entrances)
@@ -138,7 +138,7 @@ def link_entrances(world, player):
 
         # place remaining doors
         connect_doors(world, single_doors, door_targets, player)
-    elif world.worlds[player].options.entrance_shuffle == 'restricted':
+    elif world.entrance_shuffle[player] == 'restricted':
         simple_shuffle_dungeons(world, player)
 
         lw_entrances = list(LW_Entrances + LW_Single_Cave_Doors + Old_Man_Entrances)
@@ -210,7 +210,7 @@ def link_entrances(world, player):
         # place remaining doors
         connect_doors(world, doors, door_targets, player)
 
-    elif world.worlds[player].options.entrance_shuffle == 'full':
+    elif world.entrance_shuffle[player] == 'full':
         skull_woods_shuffle(world, player)
 
         lw_entrances = list(LW_Entrances + LW_Dungeon_Entrances + LW_Single_Cave_Doors + Old_Man_Entrances)
@@ -227,7 +227,7 @@ def link_entrances(world, player):
         # tavern back door cannot be shuffled yet
         connect_doors(world, ['Tavern North'], ['Tavern'], player)
 
-        if world.worlds[player].options.mode == 'standard':
+        if world.mode[player] == 'standard':
             # must connect front of hyrule castle to do escape
             connect_two_way(world, 'Hyrule Castle Entrance (South)', 'Hyrule Castle Exit (South)', player)
         else:
@@ -264,7 +264,7 @@ def link_entrances(world, player):
                 pass
             else: #if the cave wasn't placed we get here
                 connect_caves(world, lw_entrances, [], old_man_house, player)
-        if world.worlds[player].options.mode == 'standard':
+        if world.mode[player] == 'standard':
             # rest of hyrule castle must be in light world
             connect_caves(world, lw_entrances, [], [('Hyrule Castle Exit (West)', 'Hyrule Castle Exit (East)')], player)
 
@@ -316,7 +316,7 @@ def link_entrances(world, player):
 
         # place remaining doors
         connect_doors(world, doors, door_targets, player)
-    elif world.worlds[player].options.entrance_shuffle == 'crossed':
+    elif world.entrance_shuffle[player] == 'crossed':
         skull_woods_shuffle(world, player)
 
         entrances = list(LW_Entrances + LW_Dungeon_Entrances + LW_Single_Cave_Doors + Old_Man_Entrances + DW_Entrances + DW_Dungeon_Entrances + DW_Single_Cave_Doors)
@@ -331,7 +331,7 @@ def link_entrances(world, player):
         # tavern back door cannot be shuffled yet
         connect_doors(world, ['Tavern North'], ['Tavern'], player)
 
-        if world.worlds[player].options.mode == 'standard':
+        if world.mode[player] == 'standard':
             # must connect front of hyrule castle to do escape
             connect_two_way(world, 'Hyrule Castle Entrance (South)', 'Hyrule Castle Exit (South)', player)
         else:
@@ -348,7 +348,7 @@ def link_entrances(world, player):
         #place must-exit caves 
         connect_mandatory_exits(world, entrances, caves, must_exits, player)
 
-        if world.worlds[player].options.mode == 'standard':
+        if world.mode[player] == 'standard':
             # rest of hyrule castle must be dealt with
             connect_caves(world, entrances, [], [('Hyrule Castle Exit (West)', 'Hyrule Castle Exit (East)')], player)
 
@@ -394,7 +394,7 @@ def link_entrances(world, player):
         # place remaining doors
         connect_doors(world, entrances, door_targets, player)
 
-    elif world.worlds[player].options.entrance_shuffle == 'insanity':
+    elif world.entrance_shuffle[player] == 'insanity':
         # beware ye who enter here
 
         entrances = LW_Entrances + LW_Dungeon_Entrances + DW_Entrances + DW_Dungeon_Entrances + Old_Man_Entrances + ['Skull Woods Second Section Door (East)', 'Skull Woods First Section Door', 'Kakariko Well Cave', 'Bat Cave Cave', 'North Fairy Cave', 'Sanctuary', 'Lost Woods Hideout Stump', 'Lumberjack Tree Cave']
@@ -431,7 +431,7 @@ def link_entrances(world, player):
         # tavern back door cannot be shuffled yet
         connect_doors(world, ['Tavern North'], ['Tavern'], player)
 
-        if world.worlds[player].options.mode == 'standard':
+        if world.mode[player] == 'standard':
             # cannot move uncle cave
             connect_entrance(world, 'Hyrule Castle Secret Entrance Drop', 'Hyrule Castle Secret Entrance', player)
             connect_exit(world, 'Hyrule Castle Secret Entrance Exit', 'Hyrule Castle Secret Entrance Stairs', player)
@@ -464,7 +464,7 @@ def link_entrances(world, player):
             connect_entrance(world, hole, hole_targets.pop(), player)
 
         # hyrule castle handling
-        if world.worlds[player].options.mode == 'standard':
+        if world.mode[player] == 'standard':
             # must connect front of hyrule castle to do escape
             connect_entrance(world, 'Hyrule Castle Entrance (South)', 'Hyrule Castle Exit (South)', player)
             connect_exit(world, 'Hyrule Castle Exit (South)', 'Hyrule Castle Entrance (South)', player)
@@ -544,12 +544,12 @@ def link_entrances(world, player):
 
     else:
         raise NotImplementedError(
-            f'{world.worlds[player].options.entrance_shuffle} Shuffling not supported yet. Player {world.get_player_name(player)}')
+            f'{world.entrance_shuffle[player]} Shuffling not supported yet. Player {world.get_player_name(player)}')
 
-    if world.worlds[player].options.glitches_required in ['overworld_glitches', 'hybrid_major_glitches', 'no_logic']:
+    if world.glitches_required[player] in ['overworld_glitches', 'hybrid_major_glitches', 'no_logic']:
         overworld_glitch_connections(world, player)
         # mandatory hybrid major glitches connections
-        if world.worlds[player].options.glitches_required in ['hybrid_major_glitches', 'no_logic']:
+        if world.glitches_required[player] in ['hybrid_major_glitches', 'no_logic']:
             underworld_glitch_connections(world, player)
 
     # check for swamp palace fix
@@ -584,17 +584,17 @@ def link_inverted_entrances(world, player):
         connect_simple(world, exitname, regionname, player)
 
     # if we do not shuffle, set default connections
-    if world.worlds[player].options.entrance_shuffle == 'vanilla':
+    if world.entrance_shuffle[player] == 'vanilla':
         for exitname, regionname in inverted_default_connections:
             connect_simple(world, exitname, regionname, player)
         for exitname, regionname in inverted_default_dungeon_connections:
             connect_simple(world, exitname, regionname, player)
-    elif world.worlds[player].options.entrance_shuffle == 'dungeons_simple':
+    elif world.entrance_shuffle[player] == 'dungeons_simple':
         for exitname, regionname in inverted_default_connections:
             connect_simple(world, exitname, regionname, player)
 
         simple_shuffle_dungeons(world, player)
-    elif world.worlds[player].options.entrance_shuffle == 'dungeons_full':
+    elif world.entrance_shuffle[player] == 'dungeons_full':
         for exitname, regionname in inverted_default_connections:
             connect_simple(world, exitname, regionname, player)
 
@@ -649,9 +649,9 @@ def link_inverted_entrances(world, player):
         connect_mandatory_exits(world, lw_entrances, dungeon_exits, lw_dungeon_entrances_must_exit, player)
 
         connect_caves(world, lw_entrances, dw_entrances, dungeon_exits, player)
-    elif world.worlds[player].options.entrance_shuffle == 'dungeons_crossed':
+    elif world.entrance_shuffle[player] == 'dungeons_crossed':
         inverted_crossed_shuffle_dungeons(world, player)
-    elif world.worlds[player].options.entrance_shuffle == 'simple':
+    elif world.entrance_shuffle[player] == 'simple':
         simple_shuffle_dungeons(world, player)
 
         old_man_entrances = list(Inverted_Old_Man_Entrances)
@@ -748,7 +748,7 @@ def link_inverted_entrances(world, player):
         # place remaining doors
         connect_doors(world, single_doors, door_targets, player)
     
-    elif world.worlds[player].options.entrance_shuffle == 'restricted':
+    elif world.entrance_shuffle[player] == 'restricted':
         simple_shuffle_dungeons(world, player)
 
         lw_entrances = list(Inverted_LW_Entrances + Inverted_LW_Single_Cave_Doors)
@@ -833,7 +833,7 @@ def link_inverted_entrances(world, player):
         doors = lw_entrances + dw_entrances
         # place remaining doors
         connect_doors(world, doors, door_targets, player)
-    elif world.worlds[player].options.entrance_shuffle == 'full':
+    elif world.entrance_shuffle[player] == 'full':
         skull_woods_shuffle(world, player)
 
         lw_entrances = list(Inverted_LW_Entrances + Inverted_LW_Dungeon_Entrances + Inverted_LW_Single_Cave_Doors)
@@ -984,7 +984,7 @@ def link_inverted_entrances(world, player):
 
         # place remaining doors
         connect_doors(world, doors, door_targets, player)
-    elif world.worlds[player].options.entrance_shuffle == 'crossed':
+    elif world.entrance_shuffle[player] == 'crossed':
         skull_woods_shuffle(world, player)
 
         entrances = list(Inverted_LW_Entrances + Inverted_LW_Dungeon_Entrances + Inverted_LW_Single_Cave_Doors + Inverted_Old_Man_Entrances + Inverted_DW_Entrances + Inverted_DW_Dungeon_Entrances + Inverted_DW_Single_Cave_Doors)
@@ -1095,7 +1095,7 @@ def link_inverted_entrances(world, player):
 
         # place remaining doors
         connect_doors(world, entrances, door_targets, player)
-    elif world.worlds[player].options.entrance_shuffle == 'insanity':
+    elif world.entrance_shuffle[player] == 'insanity':
         # beware ye who enter here
 
         entrances = Inverted_LW_Entrances + Inverted_LW_Dungeon_Entrances + Inverted_DW_Entrances + Inverted_DW_Dungeon_Entrances + Inverted_Old_Man_Entrances + Old_Man_Entrances + ['Skull Woods Second Section Door (East)', 'Skull Woods Second Section Door (West)', 'Skull Woods First Section Door', 'Kakariko Well Cave', 'Bat Cave Cave', 'North Fairy Cave', 'Sanctuary', 'Lost Woods Hideout Stump', 'Lumberjack Tree Cave', 'Hyrule Castle Entrance (South)']
@@ -1254,10 +1254,10 @@ def link_inverted_entrances(world, player):
     else:
         raise NotImplementedError('Shuffling not supported yet')
 
-    if world.worlds[player].options.glitches_required in ['overworld_glitches', 'hybrid_major_glitches', 'no_logic']:
+    if world.glitches_required[player] in ['overworld_glitches', 'hybrid_major_glitches', 'no_logic']:
         overworld_glitch_connections(world, player)
         # mandatory hybrid major glitches connections
-        if world.worlds[player].options.glitches_required in ['hybrid_major_glitches', 'no_logic']:
+        if world.glitches_required[player] in ['hybrid_major_glitches', 'no_logic']:
             underworld_glitch_connections(world, player)
 
     # patch swamp drain
@@ -1349,7 +1349,7 @@ def scramble_holes(world, player):
     else:
         hole_targets.append(('Pyramid Exit', 'Pyramid'))
 
-    if world.worlds[player].options.mode == 'standard':
+    if world.mode[player] == 'standard':
         # cannot move uncle cave
         connect_two_way(world, 'Hyrule Castle Secret Entrance Stairs', 'Hyrule Castle Secret Entrance Exit', player)
         connect_entrance(world, 'Hyrule Castle Secret Entrance Drop', 'Hyrule Castle Secret Entrance', player)
@@ -1358,14 +1358,14 @@ def scramble_holes(world, player):
         hole_targets.append(('Hyrule Castle Secret Entrance Exit', 'Hyrule Castle Secret Entrance'))
 
     # do not shuffle sanctuary into pyramid hole unless shuffle is crossed
-    if world.worlds[player].options.entrance_shuffle == 'crossed':
+    if world.entrance_shuffle[player] == 'crossed':
         hole_targets.append(('Sanctuary Exit', 'Sewer Drop'))
     if world.shuffle_ganon:
         world.random.shuffle(hole_targets)
         exit, target = hole_targets.pop()
         connect_two_way(world, 'Pyramid Entrance', exit, player)
         connect_entrance(world, 'Pyramid Hole', target, player)
-    if world.worlds[player].options.entrance_shuffle != 'crossed':
+    if world.entrance_shuffle[player] != 'crossed':
         hole_targets.append(('Sanctuary Exit', 'Sewer Drop'))
 
     world.random.shuffle(hole_targets)
@@ -1400,14 +1400,14 @@ def scramble_inverted_holes(world, player):
     hole_targets.append(('Hyrule Castle Secret Entrance Exit', 'Hyrule Castle Secret Entrance'))
 
     # do not shuffle sanctuary into pyramid hole unless shuffle is crossed
-    if world.worlds[player].options.entrance_shuffle == 'crossed':
+    if world.entrance_shuffle[player] == 'crossed':
         hole_targets.append(('Sanctuary Exit', 'Sewer Drop'))
     if world.shuffle_ganon:
         world.random.shuffle(hole_targets)
         exit, target = hole_targets.pop()
         connect_two_way(world, 'Inverted Pyramid Entrance', exit, player)
         connect_entrance(world, 'Inverted Pyramid Hole', target, player)
-    if world.worlds[player].options.entrance_shuffle != 'crossed':
+    if world.entrance_shuffle[player] != 'crossed':
         hole_targets.append(('Sanctuary Exit', 'Sewer Drop'))
 
     world.random.shuffle(hole_targets)
@@ -1430,15 +1430,15 @@ def connect_random(world, exitlist, targetlist, player, two_way=False):
 def connect_mandatory_exits(world, entrances, caves, must_be_exits, player):
 
     # Keeps track of entrances that cannot be used to access each exit / cave
-    if world.worlds[player].options.mode == 'inverted':
+    if world.mode[player] == 'inverted':
         invalid_connections = Inverted_Must_Exit_Invalid_Connections.copy()
     else:
         invalid_connections = Must_Exit_Invalid_Connections.copy()
     invalid_cave_connections = defaultdict(set)
 
-    if world.worlds[player].options.glitches_required in ['overworld_glitches', 'hybrid_major_glitches', 'no_logic']:
+    if world.glitches_required[player] in ['overworld_glitches', 'hybrid_major_glitches', 'no_logic']:
         from . import OverworldGlitchRules
-        for entrance in OverworldGlitchRules.get_non_mandatory_exits(world.worlds[player].options.mode == 'inverted'):
+        for entrance in OverworldGlitchRules.get_non_mandatory_exits(world.mode[player] == 'inverted'):
             invalid_connections[entrance] = set()
             if entrance in must_be_exits:
                 must_be_exits.remove(entrance)
@@ -1449,7 +1449,7 @@ def connect_mandatory_exits(world, entrances, caves, must_be_exits, player):
     world.random.shuffle(caves)
 
     # Handle inverted Aga Tower - if it depends on connections, then so does Hyrule Castle Ledge
-    if world.worlds[player].options.mode == 'inverted':
+    if world.mode[player] == 'inverted':
         for entrance in invalid_connections:
             if world.get_entrance(entrance, player).connected_region == world.get_region('Inverted Agahnims Tower',
                                                                                          player):
@@ -1490,7 +1490,7 @@ def connect_mandatory_exits(world, entrances, caves, must_be_exits, player):
                 entrance = next(e for e in entrances[::-1] if e not in invalid_connections[exit])
                 cave_entrances.append(entrance)
                 entrances.remove(entrance)
-                connect_two_way(world, entrance, cave_exit, player)
+                connect_two_way(world,entrance,cave_exit, player)
                 if entrance not in invalid_connections:
                     invalid_connections[exit] = set()
             if all(entrance in invalid_connections for entrance in cave_entrances):
@@ -1564,7 +1564,7 @@ def simple_shuffle_dungeons(world, player):
     dungeon_entrances = ['Eastern Palace', 'Tower of Hera', 'Thieves Town', 'Skull Woods Final Section', 'Palace of Darkness', 'Ice Palace', 'Misery Mire', 'Swamp Palace']
     dungeon_exits = ['Eastern Palace Exit', 'Tower of Hera Exit', 'Thieves Town Exit', 'Skull Woods Final Section Exit', 'Palace of Darkness Exit', 'Ice Palace Exit', 'Misery Mire Exit', 'Swamp Palace Exit']
 
-    if world.worlds[player].options.mode != 'inverted':
+    if world.mode[player] != 'inverted':
         if not world.shuffle_ganon:
             connect_two_way(world, 'Ganons Tower', 'Ganons Tower Exit', player)
         else:
@@ -1579,13 +1579,13 @@ def simple_shuffle_dungeons(world, player):
 
     # mix up 4 door dungeons
     multi_dungeons = ['Desert', 'Turtle Rock']
-    if world.worlds[player].options.mode == 'open' or (world.worlds[player].options.mode == 'inverted' and world.shuffle_ganon):
+    if world.mode[player] == 'open' or (world.mode[player] == 'inverted' and world.shuffle_ganon):
         multi_dungeons.append('Hyrule Castle')
     world.random.shuffle(multi_dungeons)
 
     dp_target = multi_dungeons[0]
     tr_target = multi_dungeons[1]
-    if world.worlds[player].options.mode not in ['open', 'inverted'] or (world.worlds[player].options.mode == 'inverted' and world.shuffle_ganon is False):
+    if world.mode[player] not in ['open', 'inverted'] or (world.mode[player] == 'inverted' and world.shuffle_ganon is False):
         # place hyrule castle as intended
         hc_target = 'Hyrule Castle'
     else:
@@ -1593,7 +1593,7 @@ def simple_shuffle_dungeons(world, player):
 
     # ToDo improve this?
 
-    if world.worlds[player].options.mode != 'inverted':
+    if world.mode[player] != 'inverted':
         if hc_target == 'Hyrule Castle':
             connect_two_way(world, 'Hyrule Castle Entrance (South)', 'Hyrule Castle Exit (South)', player)
             connect_two_way(world, 'Hyrule Castle Entrance (East)', 'Hyrule Castle Exit (East)', player)
@@ -1708,7 +1708,7 @@ def crossed_shuffle_dungeons(world, player: int):
         dungeon_entrances.append('Ganons Tower')
         dungeon_exits.append('Ganons Tower Exit')
 
-    if world.worlds[player].options.mode == 'standard':
+    if world.mode[player] == 'standard':
         # must connect front of hyrule castle to do escape
         connect_two_way(world, 'Hyrule Castle Entrance (South)', 'Hyrule Castle Exit (South)', player)
     else:
@@ -1718,7 +1718,7 @@ def crossed_shuffle_dungeons(world, player: int):
     connect_mandatory_exits(world, dungeon_entrances, dungeon_exits,
                             LW_Dungeon_Entrances_Must_Exit + DW_Dungeon_Entrances_Must_Exit, player)
 
-    if world.worlds[player].options.mode == 'standard':
+    if world.mode[player] == 'standard':
         connect_caves(world, dungeon_entrances, [], [('Hyrule Castle Exit (West)', 'Hyrule Castle Exit (East)')], player)
 
     connect_caves(world, dungeon_entrances, [], dungeon_exits, player)
@@ -1823,14 +1823,14 @@ lookup = {
 
 
 def plando_connect(world, player: int):
-    if world.worlds[player].options.plando_connections:
-        for connection in world.worlds[player].options.plando_connections:
+    if world.plando_connections[player]:
+        for connection in world.plando_connections[player]:
             func = lookup[connection.direction]
             try:
                 func(world, connection.entrance, connection.exit, player)
             except Exception as e:
                 raise Exception(f"Could not connect using {connection}") from e
-        if world.worlds[player].options.mode != 'inverted':
+        if world.mode[player] != 'inverted':
             mark_light_world_regions(world, player)
         else:
             mark_dark_world_regions(world, player)

worlds/alttp/ItemPool.py

@@ -226,25 +226,25 @@ def generate_itempool(world):
     player = world.player
     multiworld = world.multiworld
 
-    if world.options.item_pool.current_key not in difficulties:
-        raise NotImplementedError(f"Diffulty {world.options.item_pool}")
-    if world.options.goal not in ('ganon', 'pedestal', 'bosses', 'triforce_hunt', 'local_triforce_hunt',
-                                  'ganon_triforce_hunt', 'local_ganon_triforce_hunt', 'crystals',
-                                  'ganon_pedestal'):
-        raise NotImplementedError(f"Goal {world.options.goal} for player {player}")
-    if world.options.mode not in ('open', 'standard', 'inverted'):
-        raise NotImplementedError(f"Mode {world.options.mode} for player {player}")
-    if world.options.timer not in (False, 'display', 'timed', 'timed_ohko', 'ohko', 'timed_countdown'):
-        raise NotImplementedError(f"Timer {world.options.timer} for player {player}")
+    if multiworld.item_pool[player].current_key not in difficulties:
+        raise NotImplementedError(f"Diffulty {multiworld.item_pool[player]}")
+    if multiworld.goal[player] not in ('ganon', 'pedestal', 'bosses', 'triforce_hunt', 'local_triforce_hunt',
+                                       'ganon_triforce_hunt', 'local_ganon_triforce_hunt', 'crystals',
+                                       'ganon_pedestal'):
+        raise NotImplementedError(f"Goal {multiworld.goal[player]} for player {player}")
+    if multiworld.mode[player] not in ('open', 'standard', 'inverted'):
+        raise NotImplementedError(f"Mode {multiworld.mode[player]} for player {player}")
+    if multiworld.timer[player] not in (False, 'display', 'timed', 'timed_ohko', 'ohko', 'timed_countdown'):
+        raise NotImplementedError(f"Timer {multiworld.timer[player]} for player {player}")
 
-    if world.options.timer in ['ohko', 'timed_ohko']:
+    if multiworld.timer[player] in ['ohko', 'timed_ohko']:
         world.can_take_damage = False
-    if world.options.goal in ['pedestal', 'triforce_hunt', 'local_triforce_hunt']:
+    if multiworld.goal[player] in ['pedestal', 'triforce_hunt', 'local_triforce_hunt']:
         multiworld.push_item(multiworld.get_location('Ganon', player), item_factory('Nothing', world), False)
     else:
         multiworld.push_item(multiworld.get_location('Ganon', player), item_factory('Triforce', world), False)
 
-    if world.options.goal in ['triforce_hunt', 'local_triforce_hunt']:
+    if multiworld.goal[player] in ['triforce_hunt', 'local_triforce_hunt']:
         region = multiworld.get_region('Light World', player)
 
         loc = ALttPLocation(player, "Murahdahla", parent=region)
@@ -288,7 +288,7 @@ def generate_itempool(world):
     for item in precollected_items:
         multiworld.push_precollected(item_factory(item, world))
 
-    if world.options.mode == 'standard' and not has_melee_weapon(multiworld.state, player):
+    if multiworld.mode[player] == 'standard' and not has_melee_weapon(multiworld.state, player):
         if "Link's Uncle" not in placed_items:
             found_sword = False
             found_bow = False
@@ -304,10 +304,10 @@ def generate_itempool(world):
                 elif item in ['Hammer', 'Fire Rod', 'Cane of Somaria', 'Cane of Byrna']:
                     if item not in possible_weapons:
                         possible_weapons.append(item)
-                elif (item == 'Bombs (10)' and (not world.options.bombless_start) and item not in
+                elif (item == 'Bombs (10)' and (not multiworld.bombless_start[player]) and item not in
                         possible_weapons):
                     possible_weapons.append(item)
-                elif (item in ['Bomb Upgrade (+10)', 'Bomb Upgrade (50)'] and world.options.bombless_start and item
+                elif (item in ['Bomb Upgrade (+10)', 'Bomb Upgrade (50)'] and multiworld.bombless_start[player] and item
                         not in possible_weapons):
                     possible_weapons.append(item)
 
@@ -315,21 +315,21 @@ def generate_itempool(world):
             placed_items["Link's Uncle"] = starting_weapon
             pool.remove(starting_weapon)
         if (placed_items["Link's Uncle"] in ['Bow', 'Progressive Bow', 'Bombs (10)', 'Bomb Upgrade (+10)',
-                                            'Bomb Upgrade (50)', 'Cane of Somaria', 'Cane of Byrna'] and world.options.enemy_health not in ['default', 'easy']):
-            if world.options.bombless_start and "Bomb Upgrade" not in placed_items["Link's Uncle"]:
+                                            'Bomb Upgrade (50)', 'Cane of Somaria', 'Cane of Byrna'] and multiworld.enemy_health[player] not in ['default', 'easy']):
+            if multiworld.bombless_start[player] and "Bomb Upgrade" not in placed_items["Link's Uncle"]:
                 if 'Bow' in placed_items["Link's Uncle"]:
-                    world.escape_assist.append('arrows')
+                    multiworld.worlds[player].escape_assist.append('arrows')
                 elif 'Cane' in placed_items["Link's Uncle"]:
-                    world.escape_assist.append('magic')
+                    multiworld.worlds[player].escape_assist.append('magic')
             else:
-                world.escape_assist.append('bombs')
+                multiworld.worlds[player].escape_assist.append('bombs')
 
     for (location, item) in placed_items.items():
         multiworld.get_location(location, player).place_locked_item(item_factory(item, world))
 
     items = item_factory(pool, world)
     # convert one Progressive Bow into Progressive Bow (Alt), in ID only, for ganon silvers hint text
-    if world.has_progressive_bows:
+    if multiworld.worlds[player].has_progressive_bows:
         for item in items:
             if item.code == 0x64:  # Progressive Bow
                 item.code = 0x65  # Progressive Bow (Alt)
@@ -338,21 +338,21 @@ def generate_itempool(world):
     if clock_mode:
         world.clock_mode = clock_mode
 
-    world.treasure_hunt_required = treasure_hunt_required % 999
-    world.treasure_hunt_total = treasure_hunt_total
+    multiworld.worlds[player].treasure_hunt_required = treasure_hunt_required % 999
+    multiworld.worlds[player].treasure_hunt_total = treasure_hunt_total
 
     dungeon_items = [item for item in get_dungeon_item_pool_player(world)
-                     if item.name not in world.dungeon_local_item_names]
+                     if item.name not in multiworld.worlds[player].dungeon_local_item_names]
 
     for key_loc in key_drop_data:
         key_data = key_drop_data[key_loc]
         drop_item = item_factory(key_data[3], world)
-        if not world.options.key_drop_shuffle:
+        if not multiworld.key_drop_shuffle[player]:
             if drop_item in dungeon_items:
                 dungeon_items.remove(drop_item)
             else:
                 dungeon = drop_item.name.split("(")[1].split(")")[0]
-                if world.options.mode == 'inverted':
+                if multiworld.mode[player] == 'inverted':
                     if dungeon == "Agahnims Tower":
                         dungeon = "Inverted Agahnims Tower"
                     if dungeon == "Ganons Tower":
@@ -365,7 +365,7 @@ def generate_itempool(world):
             loc = multiworld.get_location(key_loc, player)
             loc.place_locked_item(drop_item)
             loc.address = None
-        elif "Small" in key_data[3] and world.options.small_key_shuffle == small_key_shuffle.option_universal:
+        elif "Small" in key_data[3] and multiworld.small_key_shuffle[player] == small_key_shuffle.option_universal:
             # key drop shuffle and universal keys are on. Add universal keys in place of key drop keys.
             multiworld.itempool.append(item_factory(GetBeemizerItem(multiworld, player, 'Small Key (Universal)'), world))
     dungeon_item_replacements = sum(difficulties[world.options.item_pool.current_key].extras, []) * 2
@@ -373,10 +373,10 @@ def generate_itempool(world):
 
     for x in range(len(dungeon_items)-1, -1, -1):
         item = dungeon_items[x]
-        if ((world.options.small_key_shuffle == small_key_shuffle.option_start_with and item.type == 'SmallKey')
-                or (world.options.big_key_shuffle == big_key_shuffle.option_start_with and item.type == 'BigKey')
-                or (world.options.compass_shuffle == compass_shuffle.option_start_with and item.type == 'Compass')
-                or (world.options.map_shuffle == map_shuffle.option_start_with and item.type == 'Map')):
+        if ((multiworld.small_key_shuffle[player] == small_key_shuffle.option_start_with and item.type == 'SmallKey')
+                or (multiworld.big_key_shuffle[player] == big_key_shuffle.option_start_with and item.type == 'BigKey')
+                or (multiworld.compass_shuffle[player] == compass_shuffle.option_start_with and item.type == 'Compass')
+                or (multiworld.map_shuffle[player] == map_shuffle.option_start_with and item.type == 'Map')):
             dungeon_items.pop(x)
             multiworld.push_precollected(item)
             multiworld.itempool.append(item_factory(dungeon_item_replacements.pop(), world))
@@ -384,7 +384,7 @@ def generate_itempool(world):
 
     set_up_shops(multiworld, player)
 
-    if world.options.retro_bow:
+    if multiworld.retro_bow[player]:
         shop_items = 0
         shop_locations = [location for shop_locations in (shop.region.locations for shop in multiworld.shops if
                           shop.type == ShopType.Shop and shop.region.player == player) for location in shop_locations if
@@ -395,12 +395,12 @@ def generate_itempool(world):
             else:
                 shop_items += 1
     else:
-        shop_items = min(world.options.shop_item_slots, 30 if world.options.include_witch_hut else 27)
+        shop_items = min(multiworld.shop_item_slots[player], 30 if multiworld.include_witch_hut[player] else 27)
 
-    if world.options.shuffle_capacity_upgrades:
+    if multiworld.shuffle_capacity_upgrades[player]:
         shop_items += 2
-    chance_100 = int(world.options.retro_bow) * 0.25 + int(
-        world.options.small_key_shuffle == small_key_shuffle.option_universal) * 0.5
+    chance_100 = int(multiworld.retro_bow[player]) * 0.25 + int(
+        multiworld.small_key_shuffle[player] == small_key_shuffle.option_universal) * 0.5
     for _ in range(shop_items):
         if multiworld.random.random() < chance_100:
             items.append(item_factory(GetBeemizerItem(multiworld, player, "Rupees (100)"), world))
@@ -410,19 +410,19 @@ def generate_itempool(world):
     multiworld.random.shuffle(items)
     pool_count = len(items)
     new_items = ["Triforce Piece" for _ in range(additional_triforce_pieces)]
-    if world.options.shuffle_capacity_upgrades or world.options.bombless_start:
-        progressive = world.options.progressive
+    if multiworld.shuffle_capacity_upgrades[player] or multiworld.bombless_start[player]:
+        progressive = multiworld.progressive[player]
         progressive = multiworld.random.choice([True, False]) if progressive == 'grouped_random' else progressive == 'on'
-        if world.options.shuffle_capacity_upgrades == "on_combined":
+        if multiworld.shuffle_capacity_upgrades[player] == "on_combined":
             new_items.append("Bomb Upgrade (50)")
-        elif world.options.shuffle_capacity_upgrades == "on":
+        elif multiworld.shuffle_capacity_upgrades[player] == "on":
             new_items += ["Bomb Upgrade (+5)"] * 6
             new_items.append("Bomb Upgrade (+5)" if progressive else "Bomb Upgrade (+10)")
-        if world.options.shuffle_capacity_upgrades != "on_combined" and world.options.bombless_start:
+        if multiworld.shuffle_capacity_upgrades[player] != "on_combined" and multiworld.bombless_start[player]:
             new_items.append("Bomb Upgrade (+5)" if progressive else "Bomb Upgrade (+10)")
 
-        if world.options.shuffle_capacity_upgrades and not world.options.retro_bow:
-            if world.options.shuffle_capacity_upgrades == "on_combined":
+        if multiworld.shuffle_capacity_upgrades[player] and not multiworld.retro_bow[player]:
+            if multiworld.shuffle_capacity_upgrades[player] == "on_combined":
                 new_items += ["Arrow Upgrade (70)"]
             else:
                 new_items += ["Arrow Upgrade (+5)"] * 6
@@ -481,7 +481,7 @@ def generate_itempool(world):
     if len(items) < pool_count:
         items += removed_filler[len(items) - pool_count:]
 
-    if world.options.randomize_cost_types:
+    if multiworld.randomize_cost_types[player]:
         # Heart and Arrow costs require all Heart Container/Pieces and Arrow Upgrades to be advancement items for logic
         for item in items:
             if item.name in ("Boss Heart Container", "Sanctuary Heart Container", "Piece of Heart"):
@@ -490,25 +490,21 @@ def generate_itempool(world):
         # Otherwise, logic has some branches where having 4 hearts is one possible requirement (of several alternatives)
         # rather than making all hearts/heart pieces progression items (which slows down generation considerably)
         # We mark one random heart container as an advancement item (or 4 heart pieces in expert mode)
-        try:
-            next(item for item in items if item.name == 'Boss Heart Container').classification \
-                |= ItemClassification.progression
-        except StopIteration:
+        if multiworld.item_pool[player] in ['easy', 'normal', 'hard'] and not (multiworld.custom and multiworld.customitemarray[30] == 0):
+            next(item for item in items if item.name == 'Boss Heart Container').classification = ItemClassification.progression
+        elif multiworld.item_pool[player] in ['expert'] and not (multiworld.custom and multiworld.customitemarray[29] < 4):
             adv_heart_pieces = (item for item in items if item.name == 'Piece of Heart')
             for i in range(4):
-                try:
-                    next(adv_heart_pieces).classification |= ItemClassification.progression
-                except StopIteration:
-                    break  # logically health tanking is an option, so rules should still resolve to something beatable
+                next(adv_heart_pieces).classification = ItemClassification.progression
 
-    world.required_medallions = (world.options.misery_mire_medallion.current_key.title(),
-                                 world.options.turtle_rock_medallion.current_key.title())
+    world.required_medallions = (multiworld.misery_mire_medallion[player].current_key.title(),
+                                 multiworld.turtle_rock_medallion[player].current_key.title())
 
     place_bosses(world)
 
     multiworld.itempool += items
 
-    if world.options.retro_caves:
+    if multiworld.retro_caves[player]:
         set_up_take_anys(multiworld, world, player)  # depends on world.itempool to be set
 
 
@@ -531,7 +527,7 @@ take_any_locations.sort()
 
 def set_up_take_anys(multiworld, world, player):
     # these are references, do not modify these lists in-place
-    if world.options.mode == 'inverted':
+    if multiworld.mode[player] == 'inverted':
         take_any_locs = take_any_locations_inverted
     else:
         take_any_locs = take_any_locations
@@ -582,14 +578,14 @@ def set_up_take_anys(multiworld, world, player):
 
 
 def get_pool_core(world, player: int):
-    shuffle = world.worlds[player].options.entrance_shuffle.current_key
-    difficulty = world.worlds[player].options.item_pool.current_key
-    timer = world.worlds[player].options.timer.current_key
-    goal = world.worlds[player].options.goal.current_key
-    mode = world.worlds[player].options.mode.current_key
-    swordless = world.worlds[player].options.swordless
-    retro_bow = world.worlds[player].options.retro_bow
-    logic = world.worlds[player].options.glitches_required
+    shuffle = world.entrance_shuffle[player].current_key
+    difficulty = world.item_pool[player].current_key
+    timer = world.timer[player].current_key
+    goal = world.goal[player].current_key
+    mode = world.mode[player].current_key
+    swordless = world.swordless[player]
+    retro_bow = world.retro_bow[player]
+    logic = world.glitches_required[player]
 
     pool = []
     placed_items = {}
@@ -606,11 +602,11 @@ def get_pool_core(world, player: int):
         placed_items[loc] = item
 
     # provide boots to major glitch dependent seeds
-    if logic.current_key in {'overworld_glitches', 'hybrid_major_glitches', 'no_logic'} and world.worlds[player].options.glitch_boots:
+    if logic.current_key in {'overworld_glitches', 'hybrid_major_glitches', 'no_logic'} and world.glitch_boots[player]:
         precollected_items.append('Pegasus Boots')
         pool.remove('Pegasus Boots')
         pool.append('Rupees (20)')
-    want_progressives = world.worlds[player].options.progressive.want_progressives
+    want_progressives = world.progressive[player].want_progressives
 
     if want_progressives(world.random):
         pool.extend(diff.progressiveglove)
@@ -684,22 +680,22 @@ def get_pool_core(world, player: int):
     additional_pieces_to_place = 0
     if 'triforce_hunt' in goal:
 
-        if world.worlds[player].options.triforce_pieces_mode.value == TriforcePiecesMode.option_extra:
-            treasure_hunt_total = (world.worlds[player].options.triforce_pieces_required.value
-                                   + world.worlds[player].options.triforce_pieces_extra.value)
-        elif world.worlds[player].options.triforce_pieces_mode.value == TriforcePiecesMode.option_percentage:
-            percentage = float(world.worlds[player].options.triforce_pieces_percentage.value) / 100
-            treasure_hunt_total = int(round(world.worlds[player].options.triforce_pieces_required.value * percentage, 0))
+        if world.triforce_pieces_mode[player].value == TriforcePiecesMode.option_extra:
+            treasure_hunt_total = (world.triforce_pieces_required[player].value
+                                   + world.triforce_pieces_extra[player].value)
+        elif world.triforce_pieces_mode[player].value == TriforcePiecesMode.option_percentage:
+            percentage = float(world.triforce_pieces_percentage[player].value) / 100
+            treasure_hunt_total = int(round(world.triforce_pieces_required[player].value * percentage, 0))
         else:  # available
-            treasure_hunt_total = world.worlds[player].options.triforce_pieces_available.value
+            treasure_hunt_total = world.triforce_pieces_available[player].value
 
-        triforce_pieces = min(90, max(treasure_hunt_total, world.worlds[player].options.triforce_pieces_required.value))
+        triforce_pieces = min(90, max(treasure_hunt_total, world.triforce_pieces_required[player].value))
 
         pieces_in_core = min(extraitems, triforce_pieces)
         additional_pieces_to_place = triforce_pieces - pieces_in_core
         pool.extend(["Triforce Piece"] * pieces_in_core)
         extraitems -= pieces_in_core
-        treasure_hunt_required = world.worlds[player].options.triforce_pieces_required.value
+        treasure_hunt_required = world.triforce_pieces_required[player].value
 
     for extra in diff.extras:
         if extraitems >= len(extra):
@@ -711,24 +707,17 @@ def get_pool_core(world, player: int):
         else:
             break
 
+    if goal == 'pedestal':
+        place_item('Master Sword Pedestal', 'Triforce')
+        pool.remove("Rupees (20)")
+
     if retro_bow:
         replace = {'Single Arrow', 'Arrows (10)', 'Arrow Upgrade (+5)', 'Arrow Upgrade (+10)', 'Arrow Upgrade (70)'}
         pool = ['Rupees (5)' if item in replace else item for item in pool]
-
-    if goal == 'pedestal':
-        place_item('Master Sword Pedestal', 'Triforce')
-        for rupee_name in ("Rupees (5)", "Rupees (20)", "Rupees (50)", "Rupees (100)", "Rupees (300)"):
-            try:
-                pool.remove(rupee_name)
-            except ValueError:
-                pass
-            else:
-                break
-
-    if world.worlds[player].options.small_key_shuffle == small_key_shuffle.option_universal:
+    if world.small_key_shuffle[player] == small_key_shuffle.option_universal:
         pool.extend(diff.universal_keys)
         if mode == 'standard':
-            if world.worlds[player].options.key_drop_shuffle:
+            if world.key_drop_shuffle[player]:
                 key_locations = ['Secret Passage', 'Hyrule Castle - Map Guard Key Drop']
                 key_location = world.random.choice(key_locations)
                 key_locations.remove(key_location)
@@ -752,11 +741,11 @@ def get_pool_core(world, player: int):
 
 
 def make_custom_item_pool(world, player):
-    shuffle = world.worlds[player].options.entrance_shuffle
-    difficulty = world.worlds[player].options.item_pool
-    timer = world.worlds[player].options.timer
-    goal = world.worlds[player].options.goal
-    mode = world.worlds[player].options.mode
+    shuffle = world.entrance_shuffle[player]
+    difficulty = world.item_pool[player]
+    timer = world.timer[player]
+    goal = world.goal[player]
+    mode = world.mode[player]
     customitemarray = world.customitemarray
 
     pool = []
@@ -856,10 +845,10 @@ def make_custom_item_pool(world, player):
             thisbottle = world.random.choice(diff.bottles)
         pool.append(thisbottle)
 
-    if "triforce" in world.worlds[player].options.goal:
-        pool.extend(["Triforce Piece"] * world.worlds[player].options.triforce_pieces_available)
-        itemtotal += world.worlds[player].options.triforce_pieces_available
-        treasure_hunt_required = world.worlds[player].options.triforce_pieces_required
+    if "triforce" in world.goal[player]:
+        pool.extend(["Triforce Piece"] * world.triforce_pieces_available[player])
+        itemtotal += world.triforce_pieces_available[player]
+        treasure_hunt_required = world.triforce_pieces_required[player]
 
     if timer in ['display', 'timed', 'timed_countdown']:
         clock_mode = 'countdown' if timer == 'timed_countdown' else 'stopwatch'
@@ -873,7 +862,7 @@ def make_custom_item_pool(world, player):
         itemtotal = itemtotal + 1
 
     if mode == 'standard':
-        if world.worlds[player].options.small_key_shuffle == small_key_shuffle.option_universal:
+        if world.small_key_shuffle[player] == small_key_shuffle.option_universal:
             key_location = world.random.choice(
                 ['Secret Passage', 'Hyrule Castle - Boomerang Chest', 'Hyrule Castle - Map Chest',
                  'Hyrule Castle - Zelda\'s Chest', 'Sewers - Dark Cross'])
@@ -896,9 +885,9 @@ def make_custom_item_pool(world, player):
         pool.extend(['Magic Mirror'] * customitemarray[22])
         pool.extend(['Moon Pearl'] * customitemarray[28])
 
-    if world.worlds[player].options.small_key_shuffle == small_key_shuffle.option_universal:
+    if world.small_key_shuffle[player] == small_key_shuffle.option_universal:
         itemtotal = itemtotal - 28  # Corrects for small keys not being in item pool in universal Mode
-        if world.worlds[player].options.key_drop_shuffle:
+        if world.key_drop_shuffle[player]:
             itemtotal = itemtotal - (len(key_drop_data) - 1)
     if itemtotal < total_items_to_place:
         pool.extend(['Nothing'] * (total_items_to_place - itemtotal))

worlds/alttp/Items.py

@@ -11,11 +11,11 @@ def GetBeemizerItem(world, player: int, item):
         return item
 
     # first roll - replaceable item should be replaced, within beemizer_total_chance
-    if not world.worlds[player].options.beemizer_total_chance or world.random.random() > (world.worlds[player].options.beemizer_total_chance / 100):
+    if not world.beemizer_total_chance[player] or world.random.random() > (world.beemizer_total_chance[player] / 100):
         return item
 
     # second roll - bee replacement should be trap, within beemizer_trap_chance
-    if not world.worlds[player].options.beemizer_trap_chance or world.random.random() > (world.worlds[player].options.beemizer_trap_chance / 100):
+    if not world.beemizer_trap_chance[player] or world.random.random() > (world.beemizer_trap_chance[player] / 100):
         return "Bee" if isinstance(item, str) else world.create_item("Bee", player)
     else:
         return "Bee Trap" if isinstance(item, str) else world.create_item("Bee Trap", player)

worlds/alttp/Options.py

@@ -156,10 +156,10 @@ class OpenPyramid(Choice):
 
     def to_bool(self, world: MultiWorld, player: int) -> bool:
         if self.value == self.option_goal:
-            return world.worlds[player].options.goal.current_key in {'crystals', 'ganon_triforce_hunt', 'local_ganon_triforce_hunt', 'ganon_pedestal'}
+            return world.goal[player].current_key in {'crystals', 'ganon_triforce_hunt', 'local_ganon_triforce_hunt', 'ganon_pedestal'}
         elif self.value == self.option_auto:
-            return world.worlds[player].options.goal.current_key in {'crystals', 'ganon_triforce_hunt', 'local_ganon_triforce_hunt', 'ganon_pedestal'} \
-            and (world.worlds[player].options.entrance_shuffle.current_key in {'vanilla', 'dungeons_simple', 'dungeons_full', 'dungeons_crossed'} or not
+            return world.goal[player].current_key in {'crystals', 'ganon_triforce_hunt', 'local_ganon_triforce_hunt', 'ganon_pedestal'} \
+            and (world.entrance_shuffle[player].current_key in {'vanilla', 'dungeons_simple', 'dungeons_full', 'dungeons_crossed'} or not
                  world.shuffle_ganon)
         elif self.value == self.option_open:
             return True

worlds/alttp/OverworldGlitchRules.py

@@ -2,6 +2,8 @@
 Helper functions to deliver entrance/exit/region sets to OWG rules.
 """
 
+from BaseClasses import Entrance
+
 from .StateHelpers import can_lift_heavy_rocks, can_boots_clip_lw, can_boots_clip_dw, can_get_glitched_speed_dw
 
 
@@ -220,14 +222,14 @@ def get_invalid_bunny_revival_dungeons():
 
 def overworld_glitch_connections(world, player):
     # Boots-accessible locations.
-    create_owg_connections(player, world, get_boots_clip_exits_lw(world.worlds[player].options.mode == 'inverted'))
-    create_owg_connections(player, world, get_boots_clip_exits_dw(world.worlds[player].options.mode == 'inverted', player))
+    create_owg_connections(player, world, get_boots_clip_exits_lw(world.mode[player] == 'inverted'))
+    create_owg_connections(player, world, get_boots_clip_exits_dw(world.mode[player] == 'inverted', player))
 
     # Glitched speed drops.
-    create_owg_connections(player, world, get_glitched_speed_drops_dw(world.worlds[player].options.mode == 'inverted'))
+    create_owg_connections(player, world, get_glitched_speed_drops_dw(world.mode[player] == 'inverted'))
 
     # Mirror clip spots.
-    if world.worlds[player].options.mode != 'inverted':
+    if world.mode[player] != 'inverted':
         create_owg_connections(player, world, get_mirror_clip_spots_dw())
         create_owg_connections(player, world, get_mirror_offset_spots_dw())
     else:
@@ -237,24 +239,24 @@ def overworld_glitch_connections(world, player):
 def overworld_glitches_rules(world, player):
 
     # Boots-accessible locations.
-    set_owg_connection_rules(player, world, get_boots_clip_exits_lw(world.worlds[player].options.mode == 'inverted'), lambda state: can_boots_clip_lw(state, player))
-    set_owg_connection_rules(player, world, get_boots_clip_exits_dw(world.worlds[player].options.mode == 'inverted', player), lambda state: can_boots_clip_dw(state, player))
+    set_owg_connection_rules(player, world, get_boots_clip_exits_lw(world.mode[player] == 'inverted'), lambda state: can_boots_clip_lw(state, player))
+    set_owg_connection_rules(player, world, get_boots_clip_exits_dw(world.mode[player] == 'inverted', player), lambda state: can_boots_clip_dw(state, player))
 
     # Glitched speed drops.
-    set_owg_connection_rules(player, world, get_glitched_speed_drops_dw(world.worlds[player].options.mode == 'inverted'), lambda state: can_get_glitched_speed_dw(state, player))
+    set_owg_connection_rules(player, world, get_glitched_speed_drops_dw(world.mode[player] == 'inverted'), lambda state: can_get_glitched_speed_dw(state, player))
     # Dark Death Mountain Ledge Clip Spot also accessible with mirror.
-    if world.worlds[player].options.mode != 'inverted':
+    if world.mode[player] != 'inverted':
         add_alternate_rule(world.get_entrance('Dark Death Mountain Ledge Clip Spot', player), lambda state: state.has('Magic Mirror', player))
 
     # Mirror clip spots.
-    if world.worlds[player].options.mode != 'inverted':
+    if world.mode[player] != 'inverted':
         set_owg_connection_rules(player, world, get_mirror_clip_spots_dw(), lambda state: state.has('Magic Mirror', player))
         set_owg_connection_rules(player, world, get_mirror_offset_spots_dw(), lambda state: state.has('Magic Mirror', player) and can_boots_clip_lw(state, player))
     else:
         set_owg_connection_rules(player, world, get_mirror_offset_spots_lw(player), lambda state: state.has('Magic Mirror', player) and can_boots_clip_dw(state, player))
 
     # Regions that require the boots and some other stuff.
-    if world.worlds[player].options.mode != 'inverted':
+    if world.mode[player] != 'inverted':
         world.get_entrance('Turtle Rock Teleporter', player).access_rule = lambda state: (can_boots_clip_lw(state, player) or can_lift_heavy_rocks(state, player)) and state.has('Hammer', player)
         add_alternate_rule(world.get_entrance('Waterfall of Wishing', player), lambda state: state.has('Moon Pearl', player) or state.has('Pegasus Boots', player))
     else:
@@ -277,14 +279,18 @@ def create_no_logic_connections(player, world, connections):
     for entrance, parent_region, target_region, *rule_override in connections:
         parent = world.get_region(parent_region, player)
         target = world.get_region(target_region, player)
-        parent.connect(target, entrance)
+        connection = Entrance(player, entrance, parent)
+        parent.exits.append(connection)
+        connection.connect(target)
 
 
 def create_owg_connections(player, world, connections):
     for entrance, parent_region, target_region, *rule_override in connections:
         parent = world.get_region(parent_region, player)
         target = world.get_region(target_region, player)
-        parent.connect(target, entrance)
+        connection = Entrance(player, entrance, parent)
+        parent.exits.append(connection)
+        connection.connect(target)
 
 
 def set_owg_connection_rules(player, world, connections, default_rule):

worlds/alttp/Regions.py

@@ -1,11 +1,11 @@
 import collections
 import typing
 
-from BaseClasses import MultiWorld
-from .SubClasses import LTTPEntrance, LTTPRegion, LTTPRegionType
+from BaseClasses import Entrance, MultiWorld
+from .SubClasses import LTTPRegion, LTTPRegionType
 
 
-def is_main_entrance(entrance: LTTPEntrance) -> bool:
+def is_main_entrance(entrance: Entrance) -> bool:
     return entrance.parent_region.type in {LTTPRegionType.DarkWorld, LTTPRegionType.LightWorld} if entrance.parent_region.type else True
 
 
@@ -410,7 +410,7 @@ def _create_region(world: MultiWorld, player: int, name: str, type: LTTPRegionTy
     ret = LTTPRegion(name, type, hint, player, world)
     if exits:
         for exit in exits:
-            ret.create_exit(exit)
+            ret.exits.append(Entrance(player, exit, ret))
     if locations:
         for location in locations:
             if location in key_drop_data:

worlds/alttp/Rom.py

@@ -92,7 +92,7 @@ class LocalRom:
             # cause crash to provide traceback
             import xxtea
 
-        local_random = world.worlds[player].random
+        local_random = world.per_slot_randoms[player]
         key = bytes(local_random.getrandbits(8 * 16).to_bytes(16, 'big'))
         self.write_bytes(0x1800B0, bytearray(key))
         self.write_int16(0x180087, 1)
@@ -281,6 +281,7 @@ def apply_random_sprite_on_event(rom: LocalRom, sprite, local_random, allow_rand
 
 def patch_enemizer(world, rom: LocalRom, enemizercli, output_directory):
     player = world.player
+    multiworld = world.multiworld
     check_enemizer(enemizercli)
     randopatch_path = os.path.abspath(os.path.join(output_directory, f'enemizer_randopatch_{player}.sfc'))
     options_path = os.path.abspath(os.path.join(output_directory, f'enemizer_options_{player}.json'))
@@ -288,18 +289,18 @@ def patch_enemizer(world, rom: LocalRom, enemizercli, output_directory):
 
     # write options file for enemizer
     options = {
-        'RandomizeEnemies': world.options.enemy_shuffle.value,
+        'RandomizeEnemies': multiworld.enemy_shuffle[player].value,
         'RandomizeEnemiesType': 3,
-        'RandomizeBushEnemyChance': world.options.bush_shuffle.value,
-        'RandomizeEnemyHealthRange': world.options.enemy_health != 'default',
+        'RandomizeBushEnemyChance': multiworld.bush_shuffle[player].value,
+        'RandomizeEnemyHealthRange': multiworld.enemy_health[player] != 'default',
         'RandomizeEnemyHealthType': {'default': 0, 'easy': 0, 'normal': 1, 'hard': 2, 'expert': 3}[
-            world.options.enemy_health.current_key],
+            multiworld.enemy_health[player].current_key],
         'OHKO': False,
-        'RandomizeEnemyDamage': world.options.enemy_damage != 'default',
+        'RandomizeEnemyDamage': multiworld.enemy_damage[player] != 'default',
         'AllowEnemyZeroDamage': True,
-        'ShuffleEnemyDamageGroups': world.options.enemy_damage != 'default',
-        'EnemyDamageChaosMode': world.options.enemy_damage == 'chaos',
-        'EasyModeEscape': world.options.mode == "standard",
+        'ShuffleEnemyDamageGroups': multiworld.enemy_damage[player] != 'default',
+        'EnemyDamageChaosMode': multiworld.enemy_damage[player] == 'chaos',
+        'EasyModeEscape': multiworld.mode[player] == "standard",
         'EnemiesAbsorbable': False,
         'AbsorbableSpawnRate': 10,
         'AbsorbableTypes': {
@@ -328,7 +329,7 @@ def patch_enemizer(world, rom: LocalRom, enemizercli, output_directory):
         'GrayscaleMode': False,
         'GenerateSpoilers': False,
         'RandomizeLinkSpritePalette': False,
-        'RandomizePots': world.options.pot_shuffle.value,
+        'RandomizePots': multiworld.pot_shuffle[player].value,
         'ShuffleMusic': False,
         'BootlegMagic': True,
         'CustomBosses': False,
@@ -341,7 +342,7 @@ def patch_enemizer(world, rom: LocalRom, enemizercli, output_directory):
         'BeesLevel': 0,
         'RandomizeTileTrapPattern': False,
         'RandomizeTileTrapFloorTile': False,
-        'AllowKillableThief': world.options.killable_thieves.value,
+        'AllowKillableThief': multiworld.killable_thieves[player].value,
         'RandomizeSpriteOnHit': False,
         'DebugMode': False,
         'DebugForceEnemy': False,
@@ -365,13 +366,13 @@ def patch_enemizer(world, rom: LocalRom, enemizercli, output_directory):
             'MiseryMire': world.dungeons["Misery Mire"].boss.enemizer_name,
             'TurtleRock': world.dungeons["Turtle Rock"].boss.enemizer_name,
             'GanonsTower1':
-                world.dungeons["Ganons Tower" if world.options.mode != 'inverted' else
+                world.dungeons["Ganons Tower" if multiworld.mode[player] != 'inverted' else
                                "Inverted Ganons Tower"].bosses['bottom'].enemizer_name,
             'GanonsTower2':
-                world.dungeons["Ganons Tower" if world.options.mode != 'inverted' else
+                world.dungeons["Ganons Tower" if multiworld.mode[player] != 'inverted' else
                                "Inverted Ganons Tower"].bosses['middle'].enemizer_name,
             'GanonsTower3':
-                world.dungeons["Ganons Tower" if world.options.mode != 'inverted' else
+                world.dungeons["Ganons Tower" if multiworld.mode[player] != 'inverted' else
                                "Inverted Ganons Tower"].bosses['top'].enemizer_name,
             'GanonsTower4': 'Agahnim2',
             'Ganon': 'Ganon',
@@ -385,7 +386,7 @@ def patch_enemizer(world, rom: LocalRom, enemizercli, output_directory):
 
     max_enemizer_tries = 5
     for i in range(max_enemizer_tries):
-        enemizer_seed = str(world.random.randint(0, 999999999))
+        enemizer_seed = str(multiworld.per_slot_randoms[player].randint(0, 999999999))
         enemizer_command = [os.path.abspath(enemizercli),
                             '--rom', randopatch_path,
                             '--seed', enemizer_seed,
@@ -415,7 +416,7 @@ def patch_enemizer(world, rom: LocalRom, enemizercli, output_directory):
             continue
 
         for j in range(i + 1, max_enemizer_tries):
-            world.random.randint(0, 999999999)
+            multiworld.per_slot_randoms[player].randint(0, 999999999)
             # Sacrifice all remaining random numbers that would have been used for unused enemizer tries.
             # This allows for future enemizer bug fixes to NOT affect the rest of the seed's randomness
         break
@@ -429,7 +430,7 @@ def patch_enemizer(world, rom: LocalRom, enemizercli, output_directory):
 
     # Moblins attached to "key drop" locations crash the game when dropping their item when Key Drop Shuffle is on.
     # Replace them with a Slime enemy if they are placed.
-    if world.options.key_drop_shuffle:
+    if multiworld.key_drop_shuffle[player]:
         key_drop_enemies = {
             0x4DA20, 0x4DA5C, 0x4DB7F, 0x4DD73, 0x4DDC3, 0x4DE07, 0x4E201,
             0x4E20A, 0x4E326, 0x4E4F7, 0x4E687, 0x4E70C, 0x4E7C8, 0x4E7FA
@@ -791,8 +792,8 @@ def get_nonnative_item_sprite(code: int) -> int:
 
 
 def patch_rom(world: MultiWorld, rom: LocalRom, player: int, enemized: bool):
-    local_random = world.worlds[player].random
     local_world = world.worlds[player]
+    local_random = local_world.random
 
     # patch items
 
@@ -839,20 +840,20 @@ def patch_rom(world: MultiWorld, rom: LocalRom, player: int, enemized: bool):
 
             # patch music
             music_addresses = dungeon_music_addresses[location.name]
-            if local_world.options.map_shuffle:
+            if world.map_shuffle[player]:
                 music = local_random.choice([0x11, 0x16])
             else:
                 music = 0x11 if 'Pendant' in location.item.name else 0x16
             for music_address in music_addresses:
                 rom.write_byte(music_address, music)
 
-    if local_world.options.map_shuffle:
+    if world.map_shuffle[player]:
         rom.write_byte(0x155C9, local_random.choice([0x11, 0x16]))  # Randomize GT music too with map shuffle
 
     # patch entrance/exits/holes
-    for region in world.get_regions(player):
+    for region in world.regions:
         for exit in region.exits:
-            if exit.target is not None:
+            if exit.target is not None and exit.player == player:
                 if isinstance(exit.addresses, tuple):
                     offset = exit.target
                     room_id, ow_area, vram_loc, scroll_y, scroll_x, link_y, link_x, camera_y, camera_x, unknown_1, unknown_2, door_1, door_2 = exit.addresses
@@ -867,15 +868,15 @@ def patch_rom(world: MultiWorld, rom: LocalRom, player: int, enemized: bool):
                     # Thanks to Zarby89 for originally finding these values
                     # todo fix screen scrolling
 
-                    if local_world.options.entrance_shuffle != 'insanity' and \
+                    if world.entrance_shuffle[player] != 'insanity' and \
                             exit.name in {'Eastern Palace Exit', 'Tower of Hera Exit', 'Thieves Town Exit',
                                           'Skull Woods Final Section Exit', 'Ice Palace Exit', 'Misery Mire Exit',
                                           'Palace of Darkness Exit', 'Swamp Palace Exit', 'Ganons Tower Exit',
                                           'Desert Palace Exit (North)', 'Agahnims Tower Exit', 'Spiral Cave Exit (Top)',
                                           'Superbunny Cave Exit (Bottom)', 'Turtle Rock Ledge Exit (East)'} and \
-                            (local_world.options.glitches_required not in ['hybrid_major_glitches', 'no_logic'] or
-                             exit.name not in {'Palace of Darkness Exit', 'Tower of Hera Exit', 'Swamp Palace Exit'}):
-                        # For exits that cannot be reached from another, no need to apply offset fixes.
+                            (world.glitches_required[player] not in ['hybrid_major_glitches', 'no_logic'] or
+                                exit.name not in {'Palace of Darkness Exit', 'Tower of Hera Exit', 'Swamp Palace Exit'}):
+                        # For exits that connot be reached from another, no need to apply offset fixes.
                         rom.write_int16(0x15DB5 + 2 * offset, link_y)  # same as final else
                     elif room_id == 0x0059 and local_world.fix_skullwoods_exit:
                         rom.write_int16(0x15DB5 + 2 * offset, 0x00F8)
@@ -902,7 +903,7 @@ def patch_rom(world: MultiWorld, rom: LocalRom, player: int, enemized: bool):
                 else:
                     # patch door table
                     rom.write_byte(0xDBB73 + exit.addresses, exit.target)
-    if local_world.options.mode == 'inverted':
+    if world.mode[player] == 'inverted':
         patch_shuffled_dark_sanc(world, rom, player)
 
     write_custom_shops(rom, world, player)
@@ -913,16 +914,16 @@ def patch_rom(world: MultiWorld, rom: LocalRom, player: int, enemized: bool):
         return 0x53 + int(num), 0x79 + int(num)
 
     credits_total = 216
-    if local_world.options.retro_caves:  # Old man cave and Take any caves will count towards collection rate.
+    if world.retro_caves[player]:  # Old man cave and Take any caves will count towards collection rate.
         credits_total += 5
-    if local_world.options.shop_item_slots:  # Potion shop only counts towards collection rate if included in the shuffle.
-        credits_total += 30 if local_world.options.include_witch_hut else 27
-    if local_world.options.shuffle_capacity_upgrades:
+    if world.shop_item_slots[player]:  # Potion shop only counts towards collection rate if included in the shuffle.
+        credits_total += 30 if world.include_witch_hut[player] else 27
+    if world.shuffle_capacity_upgrades[player]:
         credits_total += 2
 
     rom.write_byte(0x187010, credits_total)  # dynamic credits
 
-    if local_world.options.key_drop_shuffle:
+    if world.key_drop_shuffle[player]:
         rom.write_byte(0x140000, 1)  # enable key drop shuffle
         credits_total += len(key_drop_data)
         # update dungeon counters
@@ -976,11 +977,11 @@ def patch_rom(world: MultiWorld, rom: LocalRom, player: int, enemized: bool):
         rom.write_byte(0x51DE, 0x00)
 
     # set open mode:
-    if local_world.options.mode in ['open', 'inverted']:
+    if world.mode[player] in ['open', 'inverted']:
         rom.write_byte(0x180032, 0x01)  # open mode
-    if local_world.options.mode == 'inverted':
+    if world.mode[player] == 'inverted':
         set_inverted_mode(world, player, rom)
-    elif local_world.options.mode == 'standard':
+    elif world.mode[player] == 'standard':
         rom.write_byte(0x180032, 0x00)  # standard mode
 
     uncle_location = world.get_location('Link\'s Uncle', player)
@@ -1000,7 +1001,7 @@ def patch_rom(world: MultiWorld, rom: LocalRom, player: int, enemized: bool):
         rom.write_bytes(0x6D323, [0x00, 0x00, 0xe4, 0xff, 0x08, 0x0E])
 
     # set light cones
-    rom.write_byte(0x180038, 0x01 if local_world.options.mode == "standard" else 0x00)
+    rom.write_byte(0x180038, 0x01 if world.mode[player] == "standard" else 0x00)
     rom.write_byte(0x180039, 0x01 if world.light_world_light_cone else 0x00)
     rom.write_byte(0x18003A, 0x01 if world.dark_world_light_cone else 0x00)
 
@@ -1010,7 +1011,7 @@ def patch_rom(world: MultiWorld, rom: LocalRom, player: int, enemized: bool):
     rom.write_byte(0x18004F, 0x01)  # Byrna Invulnerability: on
 
     # handle item_functionality
-    if local_world.options.item_functionality == 'hard':
+    if world.item_functionality[player] == 'hard':
         rom.write_byte(0x180181, 0x01)  # Make silver arrows work only on ganon
         rom.write_byte(0x180182, 0x00)  # Don't auto equip silvers on pickup
         # Powdered Fairies Prize
@@ -1030,7 +1031,7 @@ def patch_rom(world: MultiWorld, rom: LocalRom, player: int, enemized: bool):
         rom.write_int16(0x180036, world.rupoor_cost)
         # Set stun items
         rom.write_byte(0x180180, 0x02)  # Hookshot only
-    elif local_world.options.item_functionality == 'expert':
+    elif world.item_functionality[player] == 'expert':
         rom.write_byte(0x180181, 0x01)  # Make silver arrows work only on ganon
         rom.write_byte(0x180182, 0x00)  # Don't auto equip silvers on pickup
         # Powdered Fairies Prize
@@ -1070,7 +1071,7 @@ def patch_rom(world: MultiWorld, rom: LocalRom, player: int, enemized: bool):
         # Set stun items
         rom.write_byte(0x180180, 0x03)  # All standard items
         # Set overflow items for progressive equipment
-        if local_world.options.timer in ['timed', 'timed_countdown', 'timed_ohko']:
+        if world.timer[player] in ['timed', 'timed_countdown', 'timed_ohko']:
             overflow_replacement = GREEN_CLOCK
         else:
             overflow_replacement = GREEN_TWENTY_RUPEES
@@ -1082,7 +1083,7 @@ def patch_rom(world: MultiWorld, rom: LocalRom, player: int, enemized: bool):
 
     # Set overflow items for progressive equipment
     rom.write_bytes(0x180090,
-                    [difficulty.progressive_sword_limit if not local_world.options.swordless else 0,
+                    [difficulty.progressive_sword_limit if not world.swordless[player] else 0,
                      item_table[difficulty.basicsword[-1]].item_code,
                      difficulty.progressive_shield_limit, item_table[difficulty.basicshield[-1]].item_code,
                      difficulty.progressive_armor_limit, item_table[difficulty.basicarmor[-1]].item_code,
@@ -1090,7 +1091,7 @@ def patch_rom(world: MultiWorld, rom: LocalRom, player: int, enemized: bool):
                      difficulty.progressive_bow_limit, item_table[difficulty.basicbow[-1]].item_code])
 
     if difficulty.progressive_bow_limit < 2 and (
-            local_world.options.swordless or local_world.options.glitches_required == 'no_glitches'):
+            world.swordless[player] or world.glitches_required[player] == 'no_glitches'):
         rom.write_bytes(0x180098, [2, item_table["Silver Bow"].item_code])
         rom.write_byte(0x180181, 0x01)  # Make silver arrows work only on ganon
         rom.write_byte(0x180182, 0x00)  # Don't auto equip silvers on pickup
@@ -1098,15 +1099,15 @@ def patch_rom(world: MultiWorld, rom: LocalRom, player: int, enemized: bool):
     # set up game internal RNG seed
     rom.write_bytes(0x178000, local_random.getrandbits(8 * 1024).to_bytes(1024, 'big'))
     prize_replacements = {}
-    if local_world.options.item_functionality in ['hard', 'expert']:
+    if world.item_functionality[player] in ['hard', 'expert']:
         prize_replacements[0xE0] = 0xDF  # Fairy -> heart
         prize_replacements[0xE3] = 0xD8  # Big magic -> small magic
 
-    if local_world.options.retro_bow:
+    if world.retro_bow[player]:
         prize_replacements[0xE1] = 0xDA  # 5 Arrows -> Blue Rupee
         prize_replacements[0xE2] = 0xDB  # 10 Arrows -> Red Rupee
 
-    if local_world.options.shuffle_prizes in ("general", "both"):
+    if world.shuffle_prizes[player] in ("general", "both"):
         # shuffle prize packs
         prizes = [0xD8, 0xD8, 0xD8, 0xD8, 0xD9, 0xD8, 0xD8, 0xD9, 0xDA, 0xD9, 0xDA, 0xDB, 0xDA, 0xD9, 0xDA, 0xDA, 0xE0,
                   0xDF, 0xDF, 0xDA, 0xE0, 0xDF, 0xD8, 0xDF,
@@ -1168,7 +1169,7 @@ def patch_rom(world: MultiWorld, rom: LocalRom, player: int, enemized: bool):
             byte = int(rom.read_byte(address))
             rom.write_byte(address, prize_replacements.get(byte, byte))
 
-    if local_world.options.shuffle_prizes in ("bonk", "both"):
+    if world.shuffle_prizes[player] in ("bonk", "both"):
         # set bonk prizes
         bonk_prizes = [0x79, 0xE3, 0x79, 0xAC, 0xAC, 0xE0, 0xDC, 0xAC, 0xE3, 0xE3, 0xDA, 0xE3, 0xDA, 0xD8, 0xAC,
                        0xAC, 0xE3, 0xD8, 0xE3, 0xE3, 0xE3, 0xE3, 0xE3, 0xE3, 0xDC, 0xDB, 0xE3, 0xDA, 0x79, 0x79,
@@ -1195,7 +1196,7 @@ def patch_rom(world: MultiWorld, rom: LocalRom, player: int, enemized: bool):
         0x12, 0x01, 0x35, 0xFF,  # lamp -> 5 rupees
         0x51, 0x06, 0x52, 0xFF,  # 6 +5 bomb upgrades -> +10 bomb upgrade
         0x53, 0x06, 0x54, 0xFF,  # 6 +5 arrow upgrades -> +10 arrow upgrade
-        0x58, 0x01, 0x36 if local_world.options.retro_bow else 0x43, 0xFF,  # silver arrows -> single arrow (red 20 in retro mode)
+        0x58, 0x01, 0x36 if world.retro_bow[player] else 0x43, 0xFF,  # silver arrows -> single arrow (red 20 in retro mode)
         0x3E, difficulty.boss_heart_container_limit, 0x47, 0xff,  # boss heart -> green 20
         0x17, difficulty.heart_piece_limit, 0x47, 0xff,  # piece of heart -> green 20
         0xFF, 0xFF, 0xFF, 0xFF,  # end of table sentinel
@@ -1237,13 +1238,13 @@ def patch_rom(world: MultiWorld, rom: LocalRom, player: int, enemized: bool):
     rom.write_byte(0x180029, 0x01)  # Smithy quick item give
 
     # set swordless mode settings
-    rom.write_byte(0x18003F, 0x01 if local_world.options.swordless else 0x00)  # hammer can harm ganon
-    rom.write_byte(0x180040, 0x01 if local_world.options.swordless else 0x00)  # open curtains
-    rom.write_byte(0x180041, 0x01 if local_world.options.swordless else 0x00)  # swordless medallions
-    rom.write_byte(0x180043, 0xFF if local_world.options.swordless else 0x00)  # starting sword for link
-    rom.write_byte(0x180044, 0x01 if local_world.options.swordless else 0x00)  # hammer activates tablets
+    rom.write_byte(0x18003F, 0x01 if world.swordless[player] else 0x00)  # hammer can harm ganon
+    rom.write_byte(0x180040, 0x01 if world.swordless[player] else 0x00)  # open curtains
+    rom.write_byte(0x180041, 0x01 if world.swordless[player] else 0x00)  # swordless medallions
+    rom.write_byte(0x180043, 0xFF if world.swordless[player] else 0x00)  # starting sword for link
+    rom.write_byte(0x180044, 0x01 if world.swordless[player] else 0x00)  # hammer activates tablets
 
-    if local_world.options.item_functionality == 'easy':
+    if world.item_functionality[player] == 'easy':
         rom.write_byte(0x18003F, 0x01)  # hammer can harm ganon
         rom.write_byte(0x180041, 0x02)  # Allow swordless medallion use EVERYWHERE.
         rom.write_byte(0x180044, 0x01)  # hammer activates tablets
@@ -1261,11 +1262,11 @@ def patch_rom(world: MultiWorld, rom: LocalRom, player: int, enemized: bool):
     # Set up requested clock settings
     if local_world.clock_mode in ['countdown-ohko', 'stopwatch', 'countdown']:
         rom.write_int32(0x180200,
-                        local_world.options.red_clock_time * 60 * 60)  # red clock adjustment time (in frames, sint32)
+                        world.red_clock_time[player] * 60 * 60)  # red clock adjustment time (in frames, sint32)
         rom.write_int32(0x180204,
-                        local_world.options.blue_clock_time * 60 * 60)  # blue clock adjustment time (in frames, sint32)
+                        world.blue_clock_time[player] * 60 * 60)  # blue clock adjustment time (in frames, sint32)
         rom.write_int32(0x180208,
-                        local_world.options.green_clock_time * 60 * 60)  # green clock adjustment time (in frames, sint32)
+                        world.green_clock_time[player] * 60 * 60)  # green clock adjustment time (in frames, sint32)
     else:
         rom.write_int32(0x180200, 0)  # red clock adjustment time (in frames, sint32)
         rom.write_int32(0x180204, 0)  # blue clock adjustment time (in frames, sint32)
@@ -1273,20 +1274,20 @@ def patch_rom(world: MultiWorld, rom: LocalRom, player: int, enemized: bool):
 
     # Set up requested start time for countdown modes
     if local_world.clock_mode in ['countdown-ohko', 'countdown']:
-        rom.write_int32(0x18020C, local_world.options.countdown_start_time * 60 * 60)  # starting time (in frames, sint32)
+        rom.write_int32(0x18020C, world.countdown_start_time[player] * 60 * 60)  # starting time (in frames, sint32)
     else:
         rom.write_int32(0x18020C, 0)  # starting time (in frames, sint32)
 
     # set up goals for treasure hunt
     rom.write_int16(0x180163, max(0, local_world.treasure_hunt_required -
-                                  sum(1 for item in world.precollected_items[player] if item.name == "Triforce Piece")))
+                    sum(1 for item in world.precollected_items[player] if item.name == "Triforce Piece")))
     rom.write_bytes(0x180165, [0x0E, 0x28])  #  Triforce Piece Sprite
     rom.write_byte(0x180194, 1)  # Must turn in triforced pieces (instant win not enabled)
 
     rom.write_bytes(0x180213, [0x00, 0x01])  # Not a Tournament Seed
 
     gametype = 0x04  # item
-    if local_world.options.entrance_shuffle != 'vanilla':
+    if world.entrance_shuffle[player] != 'vanilla':
         gametype |= 0x02  # entrance
     if enemized:
         gametype |= 0x01  # enemizer
@@ -1297,7 +1298,7 @@ def patch_rom(world: MultiWorld, rom: LocalRom, player: int, enemized: bool):
     rom.write_byte(0x1800A2, 0x01 if local_world.fix_fake_world else 0x00)
     # Lock or unlock aga tower door during escape sequence.
     rom.write_byte(0x180169, 0x00)
-    if local_world.options.mode == 'inverted':
+    if world.mode[player] == 'inverted':
         rom.write_byte(0x180169, 0x02)  # lock aga/ganon tower door with crystals in inverted
     rom.write_byte(0x180171,
                    0x01 if local_world.ganon_at_pyramid else 0x00)  # Enable respawning on pyramid after ganon death
@@ -1308,8 +1309,9 @@ def patch_rom(world: MultiWorld, rom: LocalRom, player: int, enemized: bool):
     rom.write_bytes(0x50563, [0x3F, 0x14])  # disable below ganon chest
     rom.write_byte(0x50599, 0x00)  # disable below ganon chest
     rom.write_bytes(0xE9A5, [0x7E, 0x00, 0x24])  # disable below ganon chest
-    rom.write_byte(0x18008B, 0x01 if local_world.options.open_pyramid.to_bool(world, player) else 0x00)  # pre-open Pyramid Hole
-    rom.write_byte(0x18008C, 0x01 if local_world.options.crystals_needed_for_gt == 0 else 0x00)  # GT pre-opened if crystal requirement is 0
+    rom.write_byte(0x18008B, 0x01 if world.open_pyramid[player].to_bool(world, player) else 0x00)  # pre-open Pyramid Hole
+    rom.write_byte(0x18008C, 0x01 if world.crystals_needed_for_gt[
+                                         player] == 0 else 0x00)  # GT pre-opened if crystal requirement is 0
     rom.write_byte(0xF5D73, 0xF0)  # bees are catchable
     rom.write_byte(0xF5F10, 0xF0)  # bees are catchable
     rom.write_byte(0x180086, 0x00 if world.aga_randomness else 0x01)  # set blue ball and ganon warp randomness
@@ -1323,7 +1325,7 @@ def patch_rom(world: MultiWorld, rom: LocalRom, player: int, enemized: bool):
     equip[0x36C] = 0x18
     equip[0x36D] = 0x18
     equip[0x379] = 0x68
-    starting_max_bombs = 0 if local_world.options.bombless_start else 10
+    starting_max_bombs = 0 if world.bombless_start[player] else 10
     starting_max_arrows = 30
 
     startingstate = CollectionState(world)
@@ -1331,12 +1333,12 @@ def patch_rom(world: MultiWorld, rom: LocalRom, player: int, enemized: bool):
     if startingstate.has('Silver Bow', player):
         equip[0x340] = 1
         equip[0x38E] |= 0x60
-        if not local_world.options.retro_bow:
+        if not world.retro_bow[player]:
             equip[0x38E] |= 0x80
     elif startingstate.has('Bow', player):
         equip[0x340] = 1
         equip[0x38E] |= 0x20  # progressive flag to get the correct hint in all cases
-        if not local_world.options.retro_bow:
+        if not world.retro_bow[player]:
             equip[0x38E] |= 0x80
     if startingstate.has('Silver Arrows', player):
         equip[0x38E] |= 0x40
@@ -1474,7 +1476,7 @@ def patch_rom(world: MultiWorld, rom: LocalRom, player: int, enemized: bool):
         elif item.name in bombs:
             equip[0x343] += bombs[item.name]
         elif item.name in arrows:
-            if local_world.options.retro_bow:
+            if world.retro_bow[player]:
                 equip[0x38E] |= 0x80
                 equip[0x377] = 1
             else:
@@ -1500,13 +1502,16 @@ def patch_rom(world: MultiWorld, rom: LocalRom, player: int, enemized: bool):
     rom.write_bytes(0x183000, equip[0x340:])
     rom.write_bytes(0x271A6, equip[0x340:0x340 + 60])
 
-    rom.write_byte(0x18004A, 0x00 if local_world.options.mode != 'inverted' else 0x01)  # Inverted mode
+    rom.write_byte(0x18004A, 0x00 if world.mode[player] != 'inverted' else 0x01)  # Inverted mode
     rom.write_byte(0x18005D, 0x00)  # Hammer always breaks barrier
-    rom.write_byte(0x2AF79, 0xD0 if local_world.options.mode != 'inverted' else 0xF0)  # vortexes: Normal  (D0=light to dark, F0=dark to light, 42 = both)
-    rom.write_byte(0x3A943, 0xD0 if local_world.options.mode != 'inverted' else 0xF0)  # Mirror: Normal  (D0=Dark to Light, F0=light to dark, 42 = both)
-    rom.write_byte(0x3A96D, 0xF0 if local_world.options.mode != 'inverted' else 0xD0)  # Residual Portal: Normal  (F0= Light Side, D0=Dark Side, 42 = both (Darth Vader))
+    rom.write_byte(0x2AF79, 0xD0 if world.mode[
+                                        player] != 'inverted' else 0xF0)  # vortexes: Normal  (D0=light to dark, F0=dark to light, 42 = both)
+    rom.write_byte(0x3A943, 0xD0 if world.mode[
+                                        player] != 'inverted' else 0xF0)  # Mirror: Normal  (D0=Dark to Light, F0=light to dark, 42 = both)
+    rom.write_byte(0x3A96D, 0xF0 if world.mode[
+                                        player] != 'inverted' else 0xD0)  # Residual Portal: Normal  (F0= Light Side, D0=Dark Side, 42 = both (Darth Vader))
     rom.write_byte(0x3A9A7, 0xD0)  # Residual Portal: Normal  (D0= Light Side, F0=Dark Side, 42 = both (Darth Vader))
-    if local_world.options.shuffle_capacity_upgrades:
+    if world.shuffle_capacity_upgrades[player]:
         rom.write_bytes(0x180080,
                         [5, 10, 5, 10])  # values to fill for Capacity Upgrades (Bomb5, Bomb10, Arrow5, Arrow10)
     else:
@@ -1517,21 +1522,21 @@ def patch_rom(world: MultiWorld, rom: LocalRom, player: int, enemized: bool):
                               (0x02 if 'bombs' in local_world.escape_assist else 0x00) |
                               (0x04 if 'magic' in local_world.escape_assist else 0x00)))  # Escape assist
 
-    if local_world.options.goal in ['pedestal', 'triforce_hunt', 'local_triforce_hunt']:
+    if world.goal[player] in ['pedestal', 'triforce_hunt', 'local_triforce_hunt']:
         rom.write_byte(0x18003E, 0x01)  # make ganon invincible
-    elif local_world.options.goal in ['ganon_triforce_hunt', 'local_ganon_triforce_hunt']:
+    elif world.goal[player] in ['ganon_triforce_hunt', 'local_ganon_triforce_hunt']:
         rom.write_byte(0x18003E, 0x05)  # make ganon invincible until enough triforce pieces are collected
-    elif local_world.options.goal in ['ganon_pedestal']:
+    elif world.goal[player] in ['ganon_pedestal']:
         rom.write_byte(0x18003E, 0x06)
-    elif local_world.options.goal in ['bosses']:
+    elif world.goal[player] in ['bosses']:
         rom.write_byte(0x18003E, 0x02)  # make ganon invincible until all bosses are beat
-    elif local_world.options.goal in ['crystals']:
+    elif world.goal[player] in ['crystals']:
         rom.write_byte(0x18003E, 0x04)  # make ganon invincible until all crystals
     else:
         rom.write_byte(0x18003E, 0x03)  # make ganon invincible until all crystals and aga 2 are collected
 
-    rom.write_byte(0x18005E, local_world.options.crystals_needed_for_gt)
-    rom.write_byte(0x18005F, local_world.options.crystals_needed_for_ganon)
+    rom.write_byte(0x18005E, world.crystals_needed_for_gt[player])
+    rom.write_byte(0x18005F, world.crystals_needed_for_ganon[player])
 
     # Bitfield - enable text box to show with free roaming items
     #
@@ -1542,20 +1547,21 @@ def patch_rom(world: MultiWorld, rom: LocalRom, player: int, enemized: bool):
     # c - enabled for inside compasses
     # s - enabled for inside small keys
     # block HC upstairs doors in rain state in standard mode
-    rom.write_byte(0x18008A, 0x01 if local_world.options.mode == "standard" and local_world.options.entrance_shuffle != 'vanilla' else 0x00)
+    rom.write_byte(0x18008A, 0x01 if world.mode[player] == "standard" and world.entrance_shuffle[player] != 'vanilla' else 0x00)
 
-    rom.write_byte(0x18016A, 0x10 | ((0x01 if local_world.options.small_key_shuffle else 0x00)
-                                     | (0x02 if local_world.options.compass_shuffle else 0x00)
-                                     | (0x04 if local_world.options.map_shuffle else 0x00)
-                                     | (0x08 if local_world.options.big_key_shuffle else 0x00)))  # free roaming item text boxes
-    rom.write_byte(0x18003B, 0x01 if local_world.options.map_shuffle else 0x00)  # maps showing crystals on overworld
+    rom.write_byte(0x18016A, 0x10 | ((0x01 if world.small_key_shuffle[player] else 0x00)
+                                     | (0x02 if world.compass_shuffle[player] else 0x00)
+                                     | (0x04 if world.map_shuffle[player] else 0x00)
+                                     | (0x08 if world.big_key_shuffle[
+                player] else 0x00)))  # free roaming item text boxes
+    rom.write_byte(0x18003B, 0x01 if world.map_shuffle[player] else 0x00)  # maps showing crystals on overworld
 
     # compasses showing dungeon count
-    if local_world.clock_mode or local_world.options.dungeon_counters == 'off':
+    if local_world.clock_mode or world.dungeon_counters[player] == 'off':
         rom.write_byte(0x18003C, 0x00)  # Currently must be off if timer is on, because they use same HUD location
-    elif local_world.options.dungeon_counters == 'on':
+    elif world.dungeon_counters[player] == 'on':
         rom.write_byte(0x18003C, 0x02)  # always on
-    elif local_world.options.compass_shuffle or local_world.options.dungeon_counters == 'pickup':
+    elif world.compass_shuffle[player] or world.dungeon_counters[player] == 'pickup':
         rom.write_byte(0x18003C, 0x01)  # show on pickup
     else:
         rom.write_byte(0x18003C, 0x00)
@@ -1568,11 +1574,11 @@ def patch_rom(world: MultiWorld, rom: LocalRom, player: int, enemized: bool):
     # b - Big Key
     # a - Small Key
     #
-    rom.write_byte(0x180045, ((0x00 if (local_world.options.small_key_shuffle == small_key_shuffle.option_original_dungeon or
-                                        local_world.options.small_key_shuffle == small_key_shuffle.option_universal) else 0x01)
-                              | (0x02 if local_world.options.big_key_shuffle else 0x00)
-                              | (0x04 if local_world.options.map_shuffle else 0x00)
-                              | (0x08 if local_world.options.compass_shuffle else 0x00)))  # free roaming items in menu
+    rom.write_byte(0x180045, ((0x00 if (world.small_key_shuffle[player] == small_key_shuffle.option_original_dungeon or
+                                        world.small_key_shuffle[player] == small_key_shuffle.option_universal) else 0x01)
+                              | (0x02 if world.big_key_shuffle[player] else 0x00)
+                              | (0x04 if world.map_shuffle[player] else 0x00)
+                              | (0x08 if world.compass_shuffle[player] else 0x00)))  # free roaming items in menu
 
     # Map reveals
     reveal_bytes = {
@@ -1598,25 +1604,31 @@ def patch_rom(world: MultiWorld, rom: LocalRom, player: int, enemized: bool):
         return 0x0000
 
     rom.write_int16(0x18017A,
-                    get_reveal_bytes('Green Pendant') if local_world.options.map_shuffle else 0x0000)  # Sahasrahla reveal
-    rom.write_int16(0x18017C, get_reveal_bytes('Crystal 5') | get_reveal_bytes('Crystal 6') if local_world.options.map_shuffle else 0x0000)  # Bomb Shop Reveal
+                    get_reveal_bytes('Green Pendant') if world.map_shuffle[player] else 0x0000)  # Sahasrahla reveal
+    rom.write_int16(0x18017C, get_reveal_bytes('Crystal 5') | get_reveal_bytes('Crystal 6') if world.map_shuffle[
+        player] else 0x0000)  # Bomb Shop Reveal
 
-    rom.write_byte(0x180172, 0x01 if local_world.options.small_key_shuffle == small_key_shuffle.option_universal else 0x00)  # universal keys
-    rom.write_byte(0x18637E, 0x01 if local_world.options.retro_bow else 0x00)  # Skip quiver in item shops once bought
-    rom.write_byte(0x180175, 0x01 if local_world.options.retro_bow else 0x00)  # rupee bow
-    rom.write_byte(0x180176, 0x0A if local_world.options.retro_bow else 0x00)  # wood arrow cost
-    rom.write_byte(0x180178, 0x32 if local_world.options.retro_bow else 0x00)  # silver arrow cost
-    rom.write_byte(0x301FC, 0xDA if local_world.options.retro_bow else 0xE1)  # rupees replace arrows under pots
-    rom.write_byte(0x30052, 0xDB if local_world.options.retro_bow else 0xE2)  # replace arrows in fish prize from bottle merchant
-    rom.write_bytes(0xECB4E, [0xA9, 0x00, 0xEA, 0xEA] if local_world.options.retro_bow else [0xAF, 0x77, 0xF3, 0x7E])  # Thief steals rupees instead of arrows
-    rom.write_bytes(0xF0D96, [0xA9, 0x00, 0xEA, 0xEA] if local_world.options.retro_bow else [0xAF, 0x77, 0xF3, 0x7E])  # Pikit steals rupees instead of arrows
-    rom.write_bytes(0xEDA5, [0x35, 0x41] if local_world.options.retro_bow else [0x43, 0x44])  # Chest game gives rupees instead of arrows
+    rom.write_byte(0x180172, 0x01 if world.small_key_shuffle[
+                                         player] == small_key_shuffle.option_universal else 0x00)  # universal keys
+    rom.write_byte(0x18637E, 0x01 if world.retro_bow[player] else 0x00)  # Skip quiver in item shops once bought
+    rom.write_byte(0x180175, 0x01 if world.retro_bow[player] else 0x00)  # rupee bow
+    rom.write_byte(0x180176, 0x0A if world.retro_bow[player] else 0x00)  # wood arrow cost
+    rom.write_byte(0x180178, 0x32 if world.retro_bow[player] else 0x00)  # silver arrow cost
+    rom.write_byte(0x301FC, 0xDA if world.retro_bow[player] else 0xE1)  # rupees replace arrows under pots
+    rom.write_byte(0x30052, 0xDB if world.retro_bow[player] else 0xE2)  # replace arrows in fish prize from bottle merchant
+    rom.write_bytes(0xECB4E, [0xA9, 0x00, 0xEA, 0xEA] if world.retro_bow[player] else [0xAF, 0x77, 0xF3,
+                                                                                   0x7E])  # Thief steals rupees instead of arrows
+    rom.write_bytes(0xF0D96, [0xA9, 0x00, 0xEA, 0xEA] if world.retro_bow[player] else [0xAF, 0x77, 0xF3,
+                                                                                   0x7E])  # Pikit steals rupees instead of arrows
+    rom.write_bytes(0xEDA5,
+                    [0x35, 0x41] if world.retro_bow[player] else [0x43, 0x44])  # Chest game gives rupees instead of arrows
     digging_game_rng = local_random.randint(1, 30)  # set rng for digging game
     rom.write_byte(0x180020, digging_game_rng)
     rom.write_byte(0xEFD95, digging_game_rng)
     rom.write_byte(0x1800A3, 0x01)  # enable correct world setting behaviour after agahnim kills
-    rom.write_byte(0x1800A4, 0x01 if local_world.options.glitches_required != 'no_logic' else 0x00)  # enable POD EG fix
-    rom.write_byte(0x186383, 0x01 if local_world.options.glitches_required == 'no_logic' else 0x00)  # disable glitching to Triforce from Ganons Room
+    rom.write_byte(0x1800A4, 0x01 if world.glitches_required[player] != 'no_logic' else 0x00)  # enable POD EG fix
+    rom.write_byte(0x186383, 0x01 if world.glitches_required[
+        player] == 'no_logic' else 0x00)  # disable glitching to Triforce from Ganons Room
     rom.write_byte(0x180042, 0x01 if world.save_and_quit_from_boss else 0x00)  # Allow Save and Quit after boss kill
 
     # remove shield from uncle
@@ -1633,7 +1645,7 @@ def patch_rom(world: MultiWorld, rom: LocalRom, player: int, enemized: bool):
     rom.write_bytes(0x180185, [0, 0, 0])  # Uncle respawn refills (magic, bombs, arrows)
     rom.write_bytes(0x180188, [0, 0, 0])  # Zelda respawn refills (magic, bombs, arrows)
     rom.write_bytes(0x18018B, [0, 0, 0])  # Mantle respawn refills (magic, bombs, arrows)
-    if local_world.options.mode == 'standard' and uncle_location.item and uncle_location.item.player == player:
+    if world.mode[player] == 'standard' and uncle_location.item and uncle_location.item.player == player:
         if uncle_location.item.name in {'Bow', 'Progressive Bow'}:
             rom.write_byte(0x18004E, 1)  # Escape Fill (arrows)
             rom.write_int16(0x180183, 300)  # Escape fill rupee bow
@@ -1661,8 +1673,8 @@ def patch_rom(world: MultiWorld, rom: LocalRom, player: int, enemized: bool):
                         0xAD, 0xBF, 0x0A, 0xF0, 0x4F])
 
     # allow smith into multi-entrance caves in appropriate shuffles
-    if local_world.options.entrance_shuffle in ['restricted', 'full', 'crossed', 'insanity'] or (
-            local_world.options.entrance_shuffle == 'simple' and local_world.options.mode == 'inverted'):
+    if world.entrance_shuffle[player] in ['restricted', 'full', 'crossed', 'insanity'] or (
+            world.entrance_shuffle[player] == 'simple' and world.mode[player] == 'inverted'):
         rom.write_byte(0x18004C, 0x01)
 
     # set correct flag for hera basement item
@@ -1682,8 +1694,8 @@ def patch_rom(world: MultiWorld, rom: LocalRom, player: int, enemized: bool):
         rom.write_byte(0xFED31, 0x2A)  # bombable exit
         rom.write_byte(0xFEE41, 0x2A)  # bombable exit
 
-    if local_world.options.tile_shuffle:
-        tile_set = TileSet.get_random_tile_set(world.worlds[player].random)
+    if world.tile_shuffle[player]:
+        tile_set = TileSet.get_random_tile_set(world.per_slot_randoms[player])
         rom.write_byte(0x4BA21, tile_set.get_speed())
         rom.write_byte(0x4BA1D, tile_set.get_len())
         rom.write_bytes(0x4BA2A, tile_set.get_bytes())
@@ -1758,9 +1770,9 @@ def write_custom_shops(rom, world, player):
             slot = 0 if shop.type == ShopType.TakeAny else index
             if item is None:
                 break
-            if world.worlds[player].options.shop_item_slots or shop.type == ShopType.TakeAny:
-                count_shop = (shop.region.name != 'Potion Shop' or world.worlds[player].options.include_witch_hut) and \
-                             (shop.region.name != 'Capacity Upgrade' or world.worlds[player].options.shuffle_capacity_upgrades)
+            if world.shop_item_slots[player] or shop.type == ShopType.TakeAny:
+                count_shop = (shop.region.name != 'Potion Shop' or world.include_witch_hut[player]) and \
+                             (shop.region.name != 'Capacity Upgrade' or world.shuffle_capacity_upgrades[player])
                 rom.write_byte(0x186560 + shop.sram_offset + slot, 1 if count_shop else 0)
             if item['item'] == 'Single Arrow' and item['player'] == 0:
                 arrow_mask |= 1 << index
@@ -1777,7 +1789,7 @@ def write_custom_shops(rom, world, player):
                 item_code = get_nonnative_item_sprite(world.worlds[item['player']].item_name_to_id[item['item']])
             else:
                 item_code = item_table[item["item"]].item_code
-                if item['item'] == 'Single Arrow' and item['player'] == 0 and world.worlds[player].options.retro_bow:
+                if item['item'] == 'Single Arrow' and item['player'] == 0 and world.retro_bow[player]:
                     rom.write_byte(0x186500 + shop.sram_offset + slot, arrow_mask)
 
             item_data = [shop_id, item_code] + price_data + \
@@ -1790,7 +1802,7 @@ def write_custom_shops(rom, world, player):
     items_data.extend([0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF])
     rom.write_bytes(0x184900, items_data)
 
-    if world.worlds[player].options.retro_bow:
+    if world.retro_bow[player]:
         retro_shop_slots.append(0xFF)
         rom.write_bytes(0x186540, retro_shop_slots)
 
@@ -2195,18 +2207,19 @@ def write_string_to_rom(rom, target, string):
 
 def write_strings(rom, world, player):
     from . import ALTTPWorld
-    local_random = world.worlds[player].random
+
     w: ALTTPWorld = world.worlds[player]
+    local_random = w.random
 
     tt = TextTable()
     tt.removeUnwantedText()
 
     # Let's keep this guy's text accurate to the shuffle setting.
-    if world.worlds[player].options.entrance_shuffle in ['vanilla', 'dungeons_full', 'dungeons_simple', 'dungeons_crossed']:
+    if world.entrance_shuffle[player] in ['vanilla', 'dungeons_full', 'dungeons_simple', 'dungeons_crossed']:
         tt['kakariko_flophouse_man_no_flippers'] = 'I really hate mowing my yard.\n{PAGEBREAK}\nI should move.'
         tt['kakariko_flophouse_man'] = 'I really hate mowing my yard.\n{PAGEBREAK}\nI should move.'
 
-    if world.worlds[player].options.mode == 'inverted':
+    if world.mode[player] == 'inverted':
         tt['sign_village_of_outcasts'] = 'attention\nferal ducks sighted\nhiding in statues\n\nflute players beware\n'
 
     def hint_text(dest, ped_hint=False):
@@ -2225,21 +2238,21 @@ def write_strings(rom, world, player):
                 hint += f" for {world.player_name[dest.player]}"
         return hint
 
-    if world.worlds[player].options.scams.gives_king_zora_hint:
+    if world.scams[player].gives_king_zora_hint:
         # Zora hint
         zora_location = world.get_location("King Zora", player)
         tt['zora_tells_cost'] = f"You got 500 rupees to buy {hint_text(zora_location.item)}" \
                                 f"\n  ≥ Duh\n    Oh carp\n{{CHOICE}}"
-    if world.worlds[player].options.scams.gives_bottle_merchant_hint:
+    if world.scams[player].gives_bottle_merchant_hint:
         # Bottle Vendor hint
         vendor_location = world.get_location("Bottle Merchant", player)
         tt['bottle_vendor_choice'] = f"I gots {hint_text(vendor_location.item)}\nYous gots 100 rupees?" \
                                      f"\n  ≥ I want\n    no way!\n{{CHOICE}}"
 
     # First we write hints about entrances, some from the inconvenient list others from all reasonable entrances.
-    if world.worlds[player].options.hints:
-        if world.worlds[player].options.hints.value >= 2:
-            if world.worlds[player].options.hints == "full":
+    if world.hints[player]:
+        if world.hints[player].value >= 2:
+            if world.hints[player] == "full":
                 tt['sign_north_of_links_house'] = '> Randomizer The telepathic tiles have hints!'
             else:
                 tt['sign_north_of_links_house'] = '> Randomizer The telepathic tiles can have hints!'
@@ -2252,11 +2265,11 @@ def write_strings(rom, world, player):
             entrances_to_hint = {}
             entrances_to_hint.update(InconvenientDungeonEntrances)
             if world.shuffle_ganon:
-                if world.worlds[player].options.mode == 'inverted':
+                if world.mode[player] == 'inverted':
                     entrances_to_hint.update({'Inverted Ganons Tower': 'The sealed castle door'})
                 else:
                     entrances_to_hint.update({'Ganons Tower': 'Ganon\'s Tower'})
-            if world.worlds[player].options.entrance_shuffle in ['simple', 'restricted']:
+            if world.entrance_shuffle[player] in ['simple', 'restricted']:
                 for entrance in all_entrances:
                     if entrance.name in entrances_to_hint:
                         this_hint = entrances_to_hint[entrance.name] + ' leads to ' + hint_text(
@@ -2266,9 +2279,9 @@ def write_strings(rom, world, player):
                         break
             # Now we write inconvenient locations for most shuffles and finish taking care of the less chaotic ones.
             entrances_to_hint.update(InconvenientOtherEntrances)
-            if world.worlds[player].options.entrance_shuffle in ['vanilla', 'dungeons_simple', 'dungeons_full', 'dungeons_crossed']:
+            if world.entrance_shuffle[player] in ['vanilla', 'dungeons_simple', 'dungeons_full', 'dungeons_crossed']:
                 hint_count = 0
-            elif world.worlds[player].options.entrance_shuffle in ['simple', 'restricted']:
+            elif world.entrance_shuffle[player] in ['simple', 'restricted']:
                 hint_count = 2
             else:
                 hint_count = 4
@@ -2285,31 +2298,31 @@ def write_strings(rom, world, player):
 
             # Next we handle hints for randomly selected other entrances,
             # curating the selection intelligently based on shuffle.
-            if world.worlds[player].options.entrance_shuffle not in ['simple', 'restricted']:
+            if world.entrance_shuffle[player] not in ['simple', 'restricted']:
                 entrances_to_hint.update(ConnectorEntrances)
                 entrances_to_hint.update(DungeonEntrances)
-                if world.worlds[player].options.mode == 'inverted':
+                if world.mode[player] == 'inverted':
                     entrances_to_hint.update({'Inverted Agahnims Tower': 'The dark mountain tower'})
                 else:
                     entrances_to_hint.update({'Agahnims Tower': 'The sealed castle door'})
-            elif world.worlds[player].options.entrance_shuffle == 'restricted':
+            elif world.entrance_shuffle[player] == 'restricted':
                 entrances_to_hint.update(ConnectorEntrances)
             entrances_to_hint.update(OtherEntrances)
-            if world.worlds[player].options.mode == 'inverted':
+            if world.mode[player] == 'inverted':
                 entrances_to_hint.update({'Inverted Dark Sanctuary': 'The dark sanctuary cave'})
                 entrances_to_hint.update({'Inverted Big Bomb Shop': 'The old hero\'s dark home'})
                 entrances_to_hint.update({'Inverted Links House': 'The old hero\'s light home'})
             else:
                 entrances_to_hint.update({'Dark Sanctuary Hint': 'The dark sanctuary cave'})
                 entrances_to_hint.update({'Big Bomb Shop': 'The old bomb shop'})
-            if world.worlds[player].options.entrance_shuffle != 'insanity':
+            if world.entrance_shuffle[player] != 'insanity':
                 entrances_to_hint.update(InsanityEntrances)
                 if world.shuffle_ganon:
-                    if world.worlds[player].options.mode == 'inverted':
+                    if world.mode[player] == 'inverted':
                         entrances_to_hint.update({'Inverted Pyramid Entrance': 'The extra castle passage'})
                     else:
                         entrances_to_hint.update({'Pyramid Ledge': 'The pyramid ledge'})
-            hint_count = 4 if world.worlds[player].options.entrance_shuffle not in ['vanilla', 'dungeons_simple', 'dungeons_full',
+            hint_count = 4 if world.entrance_shuffle[player] not in ['vanilla', 'dungeons_simple', 'dungeons_full',
                                                             'dungeons_crossed'] else 0
             for entrance in all_entrances:
                 if entrance.name in entrances_to_hint:
@@ -2324,10 +2337,10 @@ def write_strings(rom, world, player):
 
             # Next we write a few hints for specific inconvenient locations. We don't make many because in entrance this is highly unpredictable.
             locations_to_hint = InconvenientLocations.copy()
-            if world.worlds[player].options.entrance_shuffle in ['vanilla', 'dungeons_simple', 'dungeons_full', 'dungeons_crossed']:
+            if world.entrance_shuffle[player] in ['vanilla', 'dungeons_simple', 'dungeons_full', 'dungeons_crossed']:
                 locations_to_hint.extend(InconvenientVanillaLocations)
             local_random.shuffle(locations_to_hint)
-            hint_count = 3 if world.worlds[player].options.entrance_shuffle not in ['vanilla', 'dungeons_simple', 'dungeons_full',
+            hint_count = 3 if world.entrance_shuffle[player] not in ['vanilla', 'dungeons_simple', 'dungeons_full',
                                                             'dungeons_crossed'] else 5
             for location in locations_to_hint[:hint_count]:
                 if location == 'Swamp Left':
@@ -2382,15 +2395,15 @@ def write_strings(rom, world, player):
 
             # Lastly we write hints to show where certain interesting items are.
             items_to_hint = RelevantItems.copy()
-            if world.worlds[player].options.small_key_shuffle.hints_useful:
+            if world.small_key_shuffle[player].hints_useful:
                 items_to_hint |= item_name_groups["Small Keys"]
-            if world.worlds[player].options.big_key_shuffle.hints_useful:
+            if world.big_key_shuffle[player].hints_useful:
                 items_to_hint |= item_name_groups["Big Keys"]
 
-            if world.worlds[player].options.hints == "full":
+            if world.hints[player] == "full":
                 hint_count = len(hint_locations)  # fill all remaining hint locations with Item hints.
             else:
-                hint_count = 5 if world.worlds[player].options.entrance_shuffle not in ['vanilla', 'dungeons_simple', 'dungeons_full',
+                hint_count = 5 if world.entrance_shuffle[player] not in ['vanilla', 'dungeons_simple', 'dungeons_full',
                                                                 'dungeons_crossed'] else 8
             hint_count = min(hint_count, len(items_to_hint), len(hint_locations))
             if hint_count:
@@ -2421,7 +2434,7 @@ def write_strings(rom, world, player):
     tt['ganon_phase_3_no_silvers'] = 'Did you find the silver arrows%s' % silverarrow_hint
     tt['ganon_phase_3_no_silvers_alt'] = 'Did you find the silver arrows%s' % silverarrow_hint
     if world.worlds[player].has_progressive_bows and (w.difficulty_requirements.progressive_bow_limit >= 2 or (
-            world.worlds[player].options.swordless or world.worlds[player].options.glitches_required == 'no_glitches')):
+            world.swordless[player] or world.glitches_required[player] == 'no_glitches')):
         prog_bow_locs = world.find_item_locations('Progressive Bow', player, True)
         local_random.shuffle(prog_bow_locs)
         found_bow = False
@@ -2445,26 +2458,26 @@ def write_strings(rom, world, player):
     greenpendant = world.find_item('Green Pendant', player)
     tt['sahasrahla_bring_courage'] = 'I lost my family heirloom in %s' % greenpendant.hint_text
 
-    if world.worlds[player].options.crystals_needed_for_gt == 1:
+    if world.crystals_needed_for_gt[player] == 1:
         tt['sign_ganons_tower'] = 'You need a crystal to enter.'
     else:
-        tt['sign_ganons_tower'] = f'You need {world.worlds[player].options.crystals_needed_for_gt} crystals to enter.'
+        tt['sign_ganons_tower'] = f'You need {world.crystals_needed_for_gt[player]} crystals to enter.'
 
-    if world.worlds[player].options.goal == 'bosses':
+    if world.goal[player] == 'bosses':
         tt['sign_ganon'] = 'You need to kill all bosses, Ganon last.'
-    elif world.worlds[player].options.goal == 'ganon_pedestal':
+    elif world.goal[player] == 'ganon_pedestal':
         tt['sign_ganon'] = 'You need to pull the pedestal to defeat Ganon.'
-    elif world.worlds[player].options.goal == "ganon":
-        if world.worlds[player].options.crystals_needed_for_ganon == 1:
+    elif world.goal[player] == "ganon":
+        if world.crystals_needed_for_ganon[player] == 1:
             tt['sign_ganon'] = 'You need a crystal to beat Ganon and have beaten Agahnim atop Ganons Tower.'
         else:
-            tt['sign_ganon'] = f'You need {world.worlds[player].options.crystals_needed_for_ganon} crystals to beat Ganon and ' \
+            tt['sign_ganon'] = f'You need {world.crystals_needed_for_ganon[player]} crystals to beat Ganon and ' \
                                f'have beaten Agahnim atop Ganons Tower'
     else:
-        if world.worlds[player].options.crystals_needed_for_ganon == 1:
+        if world.crystals_needed_for_ganon[player] == 1:
             tt['sign_ganon'] = 'You need a crystal to beat Ganon.'
         else:
-            tt['sign_ganon'] = f'You need {world.worlds[player].options.crystals_needed_for_ganon} crystals to beat Ganon.'
+            tt['sign_ganon'] = f'You need {world.crystals_needed_for_ganon[player]} crystals to beat Ganon.'
 
     tt['uncle_leaving_text'] = Uncle_texts[local_random.randint(0, len(Uncle_texts) - 1)]
     tt['end_triforce'] = "{NOBORDER}\n" + Triforce_texts[local_random.randint(0, len(Triforce_texts) - 1)]
@@ -2477,10 +2490,10 @@ def write_strings(rom, world, player):
     triforce_pieces_required = max(0, w.treasure_hunt_required -
                                    sum(1 for item in world.precollected_items[player] if item.name == "Triforce Piece"))
 
-    if world.worlds[player].options.goal in ['triforce_hunt', 'local_triforce_hunt']:
+    if world.goal[player] in ['triforce_hunt', 'local_triforce_hunt']:
         tt['ganon_fall_in_alt'] = 'Why are you even here?\n You can\'t even hurt me! Get the Triforce Pieces.'
         tt['ganon_phase_3_alt'] = 'Seriously? Go Away, I will not Die.'
-        if world.worlds[player].options.goal == 'triforce_hunt' and world.players > 1:
+        if world.goal[player] == 'triforce_hunt' and world.players > 1:
             tt['sign_ganon'] = 'Go find the Triforce pieces with your friends... Ganon is invincible!'
         else:
             tt['sign_ganon'] = 'Go find the Triforce pieces... Ganon is invincible!'
@@ -2494,7 +2507,7 @@ def write_strings(rom, world, player):
                                "invisibility.\n\n\n\n… … …\n\nWait! you can see me? I knew I should have\n" \
                                "hidden in  a hollow tree. If you bring\n%d Triforce piece out of %d, I can reassemble it." % \
                                (triforce_pieces_required, w.treasure_hunt_total)
-    elif world.worlds[player].options.goal in ['pedestal']:
+    elif world.goal[player] in ['pedestal']:
         tt['ganon_fall_in_alt'] = 'Why are you even here?\n You can\'t even hurt me! Your goal is at the pedestal.'
         tt['ganon_phase_3_alt'] = 'Seriously? Go Away, I will not Die.'
         tt['sign_ganon'] = 'You need to get to the pedestal... Ganon is invincible!'
@@ -2503,17 +2516,17 @@ def write_strings(rom, world, player):
         tt['ganon_fall_in_alt'] = 'You cannot defeat me until you finish your goal!'
         tt['ganon_phase_3_alt'] = 'Got wax in\nyour ears?\nI can not die!'
         if triforce_pieces_required > 1:
-            if world.worlds[player].options.goal == 'ganon_triforce_hunt' and world.players > 1:
+            if world.goal[player] == 'ganon_triforce_hunt' and world.players > 1:
                 tt['sign_ganon'] = 'You need to find %d Triforce pieces out of %d with your friends to defeat Ganon.' % \
                                    (triforce_pieces_required, w.treasure_hunt_total)
-            elif world.worlds[player].options.goal in ['ganon_triforce_hunt', 'local_ganon_triforce_hunt']:
+            elif world.goal[player] in ['ganon_triforce_hunt', 'local_ganon_triforce_hunt']:
                 tt['sign_ganon'] = 'You need to find %d Triforce pieces out of %d to defeat Ganon.' % \
                                    (triforce_pieces_required, w.treasure_hunt_total)
         else:
-            if world.worlds[player].options.goal == 'ganon_triforce_hunt' and world.players > 1:
+            if world.goal[player] == 'ganon_triforce_hunt' and world.players > 1:
                 tt['sign_ganon'] = 'You need to find %d Triforce piece out of %d with your friends to defeat Ganon.' % \
                                    (triforce_pieces_required, w.treasure_hunt_total)
-            elif world.worlds[player].options.goal in ['ganon_triforce_hunt', 'local_ganon_triforce_hunt']:
+            elif world.goal[player] in ['ganon_triforce_hunt', 'local_ganon_triforce_hunt']:
                 tt['sign_ganon'] = 'You need to find %d Triforce piece out of %d to defeat Ganon.' % \
                                    (triforce_pieces_required, w.treasure_hunt_total)
 
@@ -2536,11 +2549,11 @@ def write_strings(rom, world, player):
     tt['tablet_bombos_book'] = bombos_text
 
     # inverted spawn menu changes
-    if world.worlds[player].options.mode == 'inverted':
+    if world.mode[player] == 'inverted':
         tt['menu_start_2'] = "{MENU}\n{SPEED0}\n≥@'s house\n Dark Chapel\n{CHOICE3}"
         tt['menu_start_3'] = "{MENU}\n{SPEED0}\n≥@'s house\n Dark Chapel\n Mountain Cave\n{CHOICE2}"
 
-    for at, text, _ in world.worlds[player].options.plando_texts:
+    for at, text, _ in world.plando_texts[player]:
 
         if at not in tt:
             raise Exception(f"No text target \"{at}\" found.")
@@ -2613,12 +2626,12 @@ def set_inverted_mode(world, player, rom):
     rom.write_byte(snes_to_pc(0x08D40C), 0xD0)  # morph proof
     # the following bytes should only be written in vanilla
     # or they'll overwrite the randomizer's shuffles
-    if world.worlds[player].options.entrance_shuffle == 'vanilla':
+    if world.entrance_shuffle[player] == 'vanilla':
         rom.write_byte(0xDBB73 + 0x23, 0x37)  # switch AT and GT
         rom.write_byte(0xDBB73 + 0x36, 0x24)
         rom.write_int16(0x15AEE + 2 * 0x38, 0x00E0)
         rom.write_int16(0x15AEE + 2 * 0x25, 0x000C)
-    if world.worlds[player].options.entrance_shuffle in ['vanilla', 'dungeons_simple', 'dungeons_full', 'dungeons_crossed']:
+    if world.entrance_shuffle[player] in ['vanilla', 'dungeons_simple', 'dungeons_full', 'dungeons_crossed']:
         rom.write_byte(0x15B8C, 0x6C)
         rom.write_byte(0xDBB73 + 0x00, 0x53)  # switch bomb shop and links house
         rom.write_byte(0xDBB73 + 0x52, 0x01)
@@ -2676,7 +2689,7 @@ def set_inverted_mode(world, player, rom):
     rom.write_int16(snes_to_pc(0x02D9A6), 0x005A)
     rom.write_byte(snes_to_pc(0x02D9B3), 0x12)
     # keep the old man spawn point at old man house unless shuffle is vanilla
-    if world.worlds[player].options.entrance_shuffle in ['vanilla', 'dungeons_full', 'dungeons_simple', 'dungeons_crossed']:
+    if world.entrance_shuffle[player] in ['vanilla', 'dungeons_full', 'dungeons_simple', 'dungeons_crossed']:
         rom.write_bytes(snes_to_pc(0x308350), [0x00, 0x00, 0x01])
         rom.write_int16(snes_to_pc(0x02D8DE), 0x00F1)
         rom.write_bytes(snes_to_pc(0x02D910), [0x1F, 0x1E, 0x1F, 0x1F, 0x03, 0x02, 0x03, 0x03])
@@ -2739,7 +2752,7 @@ def set_inverted_mode(world, player, rom):
     rom.write_int16s(snes_to_pc(0x1bb836), [0x001B, 0x001B, 0x001B])
     rom.write_int16(snes_to_pc(0x308300), 0x0140)  # new pyramid hole entrance
     rom.write_int16(snes_to_pc(0x308320), 0x001B)
-    if world.worlds[player].options.entrance_shuffle in ['vanilla', 'dungeons_simple', 'dungeons_full', 'dungeons_crossed']:
+    if world.entrance_shuffle[player] in ['vanilla', 'dungeons_simple', 'dungeons_full', 'dungeons_crossed']:
         rom.write_byte(snes_to_pc(0x308340), 0x7B)
     rom.write_int16(snes_to_pc(0x1af504), 0x148B)
     rom.write_int16(snes_to_pc(0x1af50c), 0x149B)
@@ -2776,10 +2789,10 @@ def set_inverted_mode(world, player, rom):
     rom.write_bytes(snes_to_pc(0x1BC85A), [0x50, 0x0F, 0x82])
     rom.write_int16(0xDB96F + 2 * 0x35, 0x001B)  # move pyramid exit door
     rom.write_int16(0xDBA71 + 2 * 0x35, 0x06A4)
-    if world.worlds[player].options.entrance_shuffle in ['vanilla', 'dungeons_simple', 'dungeons_full', 'dungeons_crossed']:
+    if world.entrance_shuffle[player] in ['vanilla', 'dungeons_simple', 'dungeons_full', 'dungeons_crossed']:
         rom.write_byte(0xDBB73 + 0x35, 0x36)
     rom.write_byte(snes_to_pc(0x09D436), 0xF3)  # remove castle gate warp
-    if world.worlds[player].options.entrance_shuffle in ['vanilla', 'dungeons_simple', 'dungeons_full', 'dungeons_crossed']:
+    if world.entrance_shuffle[player] in ['vanilla', 'dungeons_simple', 'dungeons_full', 'dungeons_crossed']:
         rom.write_int16(0x15AEE + 2 * 0x37, 0x0010)  # pyramid exit to new hc area
         rom.write_byte(0x15B8C + 0x37, 0x1B)
         rom.write_int16(0x15BDB + 2 * 0x37, 0x0418)

worlds/alttp/Rules.py

@@ -3,7 +3,7 @@ import logging
 from typing import Iterator, Set
 
 from Options import ItemsAccessibility
-from BaseClasses import MultiWorld
+from BaseClasses import Entrance, MultiWorld
 from worlds.generic.Rules import (add_item_rule, add_rule, forbid_item,
                                   item_name_in_location_names, location_item_name, set_rule, allow_self_locking_items)
 
@@ -27,9 +27,9 @@ from .UnderworldGlitchRules import underworld_glitches_rules
 def set_rules(world):
     player = world.player
     world = world.multiworld
-    if world.worlds[player].options.glitches_required == 'no_logic':
+    if world.glitches_required[player] == 'no_logic':
         if player == next(player_id for player_id in world.get_game_players("A Link to the Past")
-                          if world.worlds[player_id].options.glitches_required == 'no_logic'):  # only warn one time
+                          if world.glitches_required[player_id] == 'no_logic'):  # only warn one time
             logging.info(
                 'WARNING! Seeds generated under this logic often require major glitches and may be impossible!')
 
@@ -40,8 +40,8 @@ def set_rules(world):
         else:
             # Set access rules according to max glitches for multiworld progression.
             # Set accessibility to none, and shuffle assuming the no logic players can always win
-            world.worlds[player].options.accessibility.value = ItemsAccessibility.option_minimal
-            world.worlds[player].options.progression_balancing.value = 0
+            world.accessibility[player].value = ItemsAccessibility.option_minimal
+            world.progression_balancing[player].value = 0
 
     else:
         world.completion_condition[player] = lambda state: state.has('Triforce', player)
@@ -49,52 +49,52 @@ def set_rules(world):
     dungeon_boss_rules(world, player)
     global_rules(world, player)
 
-    if world.worlds[player].options.mode != 'inverted':
+    if world.mode[player] != 'inverted':
         default_rules(world, player)
 
-    if world.worlds[player].options.mode == 'open':
+    if world.mode[player] == 'open':
         open_rules(world, player)
-    elif world.worlds[player].options.mode == 'standard':
+    elif world.mode[player] == 'standard':
         standard_rules(world, player)
-    elif world.worlds[player].options.mode == 'inverted':
+    elif world.mode[player] == 'inverted':
         open_rules(world, player)
         inverted_rules(world, player)
     else:
-        raise NotImplementedError(f'World state {world.worlds[player].options.mode} is not implemented yet')
+        raise NotImplementedError(f'World state {world.mode[player]} is not implemented yet')
 
-    if world.worlds[player].options.glitches_required == 'no_glitches':
+    if world.glitches_required[player] == 'no_glitches':
         no_glitches_rules(world, player)
         forbid_bomb_jump_requirements(world, player)
-    elif world.worlds[player].options.glitches_required == 'overworld_glitches':
+    elif world.glitches_required[player] == 'overworld_glitches':
         # Initially setting no_glitches_rules to set the baseline rules for some
         # entrances. The overworld_glitches_rules set is primarily additive.
         no_glitches_rules(world, player)
         fake_flipper_rules(world, player)
         overworld_glitches_rules(world, player)
         forbid_bomb_jump_requirements(world, player)
-    elif world.worlds[player].options.glitches_required in ['hybrid_major_glitches', 'no_logic']:
+    elif world.glitches_required[player] in ['hybrid_major_glitches', 'no_logic']:
         no_glitches_rules(world, player)
         fake_flipper_rules(world, player)
         overworld_glitches_rules(world, player)
         underworld_glitches_rules(world, player)
         bomb_jump_requirements(world, player)
-    elif world.worlds[player].options.glitches_required == 'minor_glitches':
+    elif world.glitches_required[player] == 'minor_glitches':
         no_glitches_rules(world, player)
         fake_flipper_rules(world, player)
         forbid_bomb_jump_requirements(world, player)
     else:
-        raise NotImplementedError(f'Not implemented yet: Logic - {world.worlds[player].options.glitches_required}')
+        raise NotImplementedError(f'Not implemented yet: Logic - {world.glitches_required[player]}')
 
-    if world.worlds[player].options.goal == 'bosses':
+    if world.goal[player] == 'bosses':
         # require all bosses to beat ganon
         add_rule(world.get_location('Ganon', player), lambda state: state.can_reach('Master Sword Pedestal', 'Location', player) and state.has('Beat Agahnim 1', player) and state.has('Beat Agahnim 2', player) and has_crystals(state, 7, player))
-    elif world.worlds[player].options.goal == 'ganon':
+    elif world.goal[player] == 'ganon':
         # require aga2 to beat ganon
         add_rule(world.get_location('Ganon', player), lambda state: state.has('Beat Agahnim 2', player))
 
-    if world.worlds[player].options.mode != 'inverted':
+    if world.mode[player] != 'inverted':
         set_big_bomb_rules(world, player)
-        if world.worlds[player].options.glitches_required.current_key in {'overworld_glitches', 'hybrid_major_glitches', 'no_logic'} and world.worlds[player].options.entrance_shuffle.current_key not in {'insanity', 'insanity_legacy', 'madness'}:
+        if world.glitches_required[player].current_key in {'overworld_glitches', 'hybrid_major_glitches', 'no_logic'} and world.entrance_shuffle[player].current_key not in {'insanity', 'insanity_legacy', 'madness'}:
             path_to_courtyard = mirrorless_path_to_castle_courtyard(world, player)
             add_rule(world.get_entrance('Pyramid Fairy', player), lambda state: state.multiworld.get_entrance('Dark Death Mountain Offset Mirror', player).can_reach(state) and all(rule(state) for rule in path_to_courtyard), 'or')
     else:
@@ -102,24 +102,21 @@ def set_rules(world):
 
     # if swamp and dam have not been moved we require mirror for swamp palace
     # however there is mirrorless swamp in hybrid MG, so we don't necessarily want this. HMG handles this requirement itself. 
-    if not world.worlds[player].swamp_patch_required and world.worlds[player].options.glitches_required not in ['hybrid_major_glitches', 'no_logic']:
+    if not world.worlds[player].swamp_patch_required and world.glitches_required[player] not in ['hybrid_major_glitches', 'no_logic']:
         add_rule(world.get_entrance('Swamp Palace Moat', player), lambda state: state.has('Magic Mirror', player))
 
     # GT Entrance may be required for Turtle Rock for OWG and < 7 required
-    ganons_tower = world.get_entrance('Inverted Ganons Tower' if world.worlds[player].options.mode == 'inverted' else 'Ganons Tower', player)
-    if (world.worlds[player].options.crystals_needed_for_gt == 7
-            and not (world.worlds[player].options.glitches_required
-                     in ['overworld_glitches', 'hybrid_major_glitches', 'no_logic']
-                     and world.worlds[player].options.mode != 'inverted')):
+    ganons_tower = world.get_entrance('Inverted Ganons Tower' if world.mode[player] == 'inverted' else 'Ganons Tower', player)
+    if world.crystals_needed_for_gt[player] == 7 and not (world.glitches_required[player] in ['overworld_glitches', 'hybrid_major_glitches', 'no_logic'] and world.mode[player] != 'inverted'):
         set_rule(ganons_tower, lambda state: False)
 
     set_trock_key_rules(world, player)
 
-    set_rule(ganons_tower, lambda state: has_crystals(state, state.multiworld.worlds[player].options.crystals_needed_for_gt, player))
-    if world.worlds[player].options.mode != 'inverted' and world.worlds[player].options.glitches_required in ['overworld_glitches', 'hybrid_major_glitches', 'no_logic']:
+    set_rule(ganons_tower, lambda state: has_crystals(state, state.multiworld.crystals_needed_for_gt[player], player))
+    if world.mode[player] != 'inverted' and world.glitches_required[player] in ['overworld_glitches', 'hybrid_major_glitches', 'no_logic']:
         add_rule(world.get_entrance('Ganons Tower', player), lambda state: state.multiworld.get_entrance('Ganons Tower Ascent', player).can_reach(state), 'or')
 
-    set_bunny_rules(world, player, world.worlds[player].options.mode == 'inverted')
+    set_bunny_rules(world, player, world.mode[player] == 'inverted')
 
 
 def mirrorless_path_to_castle_courtyard(world, player):
@@ -153,17 +150,17 @@ def set_always_allow(spot, rule):
 
 
 def add_lamp_requirement(world: MultiWorld, spot, player: int, has_accessible_torch: bool = False):
-    if world.worlds[player].options.dark_room_logic == "lamp":
+    if world.dark_room_logic[player] == "lamp":
         add_rule(spot, lambda state: state.has('Lamp', player))
-    elif world.worlds[player].options.dark_room_logic == "torches":  # implicitly lamp as well
+    elif world.dark_room_logic[player] == "torches":  # implicitly lamp as well
         if has_accessible_torch:
             add_rule(spot, lambda state: state.has('Lamp', player) or state.has('Fire Rod', player))
         else:
             add_rule(spot, lambda state: state.has('Lamp', player))
-    elif world.worlds[player].options.dark_room_logic == "none":
+    elif world.dark_room_logic[player] == "none":
         pass
     else:
-        raise ValueError(f"Unknown Dark Room Logic: {world.worlds[player].options.dark_room_logic}")
+        raise ValueError(f"Unknown Dark Room Logic: {world.dark_room_logic[player]}")
 
 
 non_crossover_items = (item_name_groups["Small Keys"] | item_name_groups["Big Keys"] | progression_items) - {
@@ -230,13 +227,12 @@ def global_rules(multiworld: MultiWorld, player: int):
     set_rule(multiworld.get_location('Sick Kid', player), lambda state: state.has_group("Bottles", player))
     set_rule(multiworld.get_location('Library', player), lambda state: state.has('Pegasus Boots', player))
 
-    if world.options.enemy_shuffle:
+    if multiworld.enemy_shuffle[player]:
         set_rule(multiworld.get_location('Mimic Cave', player), lambda state: state.has('Hammer', player) and
                                                                               can_kill_most_things(state, player, 4))
     else:
         set_rule(multiworld.get_location('Mimic Cave', player), lambda state: state.has('Hammer', player)
-                                                                              and ((state.multiworld.worlds[player].options.enemy_health in ("easy", "default")
-                                                                                    and can_use_bombs(state, player, 4))
+                                                                              and ((state.multiworld.enemy_health[player] in ("easy", "default") and can_use_bombs(state, player, 4))
                       or can_shoot_arrows(state, player) or state.has("Cane of Somaria", player)
                       or has_beam_sword(state, player)))
 
@@ -303,7 +299,8 @@ def global_rules(multiworld: MultiWorld, player: int):
 
     set_rule(multiworld.get_entrance('Sewers Door', player),
              lambda state: state._lttp_has_key('Small Key (Hyrule Castle)', player, 4) or (
-                     world.options.small_key_shuffle == small_key_shuffle.option_universal and world.options.mode == 'standard'))  # standard universal small keys cannot access the shop
+                     multiworld.small_key_shuffle[player] == small_key_shuffle.option_universal and multiworld.mode[
+                     player] == 'standard'))  # standard universal small keys cannot access the shop
     set_rule(multiworld.get_entrance('Sewers Back Door', player),
              lambda state: state._lttp_has_key('Small Key (Hyrule Castle)', player, 4))
     set_rule(multiworld.get_entrance('Sewers Secret Room', player), lambda state: can_bomb_or_bonk(state, player))
@@ -342,12 +339,12 @@ def global_rules(multiworld: MultiWorld, player: int):
     add_rule(ep_prize, lambda state: state.has('Big Key (Eastern Palace)', player) and
                                      state._lttp_has_key('Small Key (Eastern Palace)', player, 2) and
                                      ep_prize.parent_region.dungeon.boss.can_defeat(state))
-    if not world.options.enemy_shuffle:
+    if not multiworld.enemy_shuffle[player]:
         add_rule(ep_boss, lambda state: can_shoot_arrows(state, player))
         add_rule(ep_prize, lambda state: can_shoot_arrows(state, player))
 
     # You can always kill the Stalfos' with the pots on easy/normal
-    if world.options.enemy_health in ("hard", "expert") or world.options.enemy_shuffle:
+    if multiworld.enemy_health[player] in ("hard", "expert") or multiworld.enemy_shuffle[player]:
         stalfos_rule = lambda state: can_kill_most_things(state, player, 4)
         for location in ['Eastern Palace - Compass Chest', 'Eastern Palace - Big Chest',
                          'Eastern Palace - Dark Square Pot Key', 'Eastern Palace - Dark Eyegore Key Drop',
@@ -365,14 +362,14 @@ def global_rules(multiworld: MultiWorld, player: int):
     add_rule(multiworld.get_location('Desert Palace - Boss', player), lambda state: state._lttp_has_key('Small Key (Desert Palace)', player, 4) and state.has('Big Key (Desert Palace)', player) and has_fire_source(state, player) and state.multiworld.get_location('Desert Palace - Boss', player).parent_region.dungeon.boss.can_defeat(state))
 
     # logic patch to prevent placing a crystal in Desert that's required to reach the required keys
-    if not (world.options.small_key_shuffle and world.options.big_key_shuffle):
+    if not (multiworld.small_key_shuffle[player] and multiworld.big_key_shuffle[player]):
         add_rule(multiworld.get_location('Desert Palace - Prize', player), lambda state: state.multiworld.get_region('Desert Palace Main (Outer)', player).can_reach(state))
 
     set_rule(multiworld.get_location('Tower of Hera - Basement Cage', player), lambda state: can_activate_crystal_switch(state, player))
     set_rule(multiworld.get_location('Tower of Hera - Map Chest', player), lambda state: can_activate_crystal_switch(state, player))
     set_rule(multiworld.get_entrance('Tower of Hera Small Key Door', player), lambda state: can_activate_crystal_switch(state, player) and (state._lttp_has_key('Small Key (Tower of Hera)', player) or location_item_name(state, 'Tower of Hera - Big Key Chest', player) == ('Small Key (Tower of Hera)', player)))
     set_rule(multiworld.get_entrance('Tower of Hera Big Key Door', player), lambda state: can_activate_crystal_switch(state, player) and state.has('Big Key (Tower of Hera)', player))
-    if world.options.enemy_shuffle:
+    if multiworld.enemy_shuffle[player]:
         add_rule(multiworld.get_entrance('Tower of Hera Big Key Door', player), lambda state: can_kill_most_things(state, player, 3))
     else:
         add_rule(multiworld.get_entrance('Tower of Hera Big Key Door', player),
@@ -381,7 +378,7 @@ def global_rules(multiworld: MultiWorld, player: int):
                                 or state.has("Cane of Somaria", player)))
     set_rule(multiworld.get_location('Tower of Hera - Big Chest', player), lambda state: state.has('Big Key (Tower of Hera)', player))
     set_rule(multiworld.get_location('Tower of Hera - Big Key Chest', player), lambda state: has_fire_source(state, player))
-    if world.options.accessibility != 'full':
+    if multiworld.accessibility[player] != 'full':
         set_always_allow(multiworld.get_location('Tower of Hera - Big Key Chest', player), lambda state, item: item.name == 'Small Key (Tower of Hera)' and item.player == player)
 
     set_rule(multiworld.get_entrance('Swamp Palace Moat', player), lambda state: state.has('Flippers', player) and state.has('Open Floodgate', player))
@@ -390,30 +387,32 @@ def global_rules(multiworld: MultiWorld, player: int):
     set_rule(multiworld.get_location('Swamp Palace - Trench 1 Pot Key', player), lambda state: state._lttp_has_key('Small Key (Swamp Palace)', player, 2))
     set_rule(multiworld.get_entrance('Swamp Palace (Center)', player), lambda state: state.has('Hammer', player) and state._lttp_has_key('Small Key (Swamp Palace)', player, 3))
     set_rule(multiworld.get_location('Swamp Palace - Hookshot Pot Key', player), lambda state: state.has('Hookshot', player))
-    if world.options.pot_shuffle:
+    if multiworld.pot_shuffle[player]:
         # it could move the key to the top right platform which can only be reached with bombs
         add_rule(multiworld.get_location('Swamp Palace - Hookshot Pot Key', player), lambda state: can_use_bombs(state, player))
-    set_rule(multiworld.get_entrance('Swamp Palace (West)', player), lambda state: state._lttp_has_key('Small Key (Swamp Palace)', player, 6))
+    set_rule(multiworld.get_entrance('Swamp Palace (West)', player), lambda state: state._lttp_has_key('Small Key (Swamp Palace)', player, 6)
+        if state.has('Hookshot', player)
+        else state._lttp_has_key('Small Key (Swamp Palace)', player, 4))
     set_rule(multiworld.get_location('Swamp Palace - Big Chest', player), lambda state: state.has('Big Key (Swamp Palace)', player))
-    if world.options.accessibility != 'full':
+    if multiworld.accessibility[player] != 'full':
         allow_self_locking_items(multiworld.get_location('Swamp Palace - Big Chest', player), 'Big Key (Swamp Palace)')
     set_rule(multiworld.get_entrance('Swamp Palace (North)', player), lambda state: state.has('Hookshot', player) and state._lttp_has_key('Small Key (Swamp Palace)', player, 5))
-    if not world.options.small_key_shuffle and world.options.glitches_required not in ['hybrid_major_glitches', 'no_logic']:
+    if not multiworld.small_key_shuffle[player] and multiworld.glitches_required[player] not in ['hybrid_major_glitches', 'no_logic']:
         forbid_item(multiworld.get_location('Swamp Palace - Entrance', player), 'Big Key (Swamp Palace)', player)
     add_rule(multiworld.get_location('Swamp Palace - Prize', player), lambda state: state._lttp_has_key('Small Key (Swamp Palace)', player, 6))
     add_rule(multiworld.get_location('Swamp Palace - Boss', player), lambda state: state._lttp_has_key('Small Key (Swamp Palace)', player, 6))
-    if world.options.pot_shuffle:
+    if multiworld.pot_shuffle[player]:
         # key can (and probably will) be moved behind bombable wall
         set_rule(multiworld.get_location('Swamp Palace - Waterway Pot Key', player), lambda state: can_use_bombs(state, player))
 
     set_rule(multiworld.get_entrance('Thieves Town Big Key Door', player), lambda state: state.has('Big Key (Thieves Town)', player))
-    if world.dungeons["Thieves Town"].boss.enemizer_name == "Blind":
+    if multiworld.worlds[player].dungeons["Thieves Town"].boss.enemizer_name == "Blind":
         set_rule(multiworld.get_entrance('Blind Fight', player), lambda state: state._lttp_has_key('Small Key (Thieves Town)', player, 3) and can_use_bombs(state, player))
     set_rule(multiworld.get_location('Thieves\' Town - Big Chest', player),
              lambda state: ((state._lttp_has_key('Small Key (Thieves Town)', player, 3)) or (location_item_name(state, 'Thieves\' Town - Big Chest', player) == ("Small Key (Thieves Town)", player)) and state._lttp_has_key('Small Key (Thieves Town)', player, 2)) and state.has('Hammer', player))
     set_rule(multiworld.get_location('Thieves\' Town - Blind\'s Cell', player),
              lambda state: state._lttp_has_key('Small Key (Thieves Town)', player))
-    if world.options.accessibility != 'full' and not world.options.key_drop_shuffle:
+    if multiworld.accessibility[player] != 'full' and not multiworld.key_drop_shuffle[player]:
         set_always_allow(multiworld.get_location('Thieves\' Town - Big Chest', player), lambda state, item: item.name == 'Small Key (Thieves Town)' and item.player == player)
     set_rule(multiworld.get_location('Thieves\' Town - Attic', player), lambda state: state._lttp_has_key('Small Key (Thieves Town)', player, 3))
     set_rule(multiworld.get_location('Thieves\' Town - Spike Switch Pot Key', player),
@@ -425,7 +424,7 @@ def global_rules(multiworld: MultiWorld, player: int):
     set_rule(multiworld.get_entrance('Skull Woods First Section West Door', player), lambda state: state._lttp_has_key('Small Key (Skull Woods)', player, 5))
     set_rule(multiworld.get_entrance('Skull Woods First Section (Left) Door to Exit', player), lambda state: state._lttp_has_key('Small Key (Skull Woods)', player, 5))
     set_rule(multiworld.get_location('Skull Woods - Big Chest', player), lambda state: state.has('Big Key (Skull Woods)', player) and can_use_bombs(state, player))
-    if world.options.accessibility != 'full':
+    if multiworld.accessibility[player] != 'full':
         allow_self_locking_items(multiworld.get_location('Skull Woods - Big Chest', player), 'Big Key (Skull Woods)')
     set_rule(multiworld.get_entrance('Skull Woods Torch Room', player), lambda state: state._lttp_has_key('Small Key (Skull Woods)', player, 4) and state.has('Fire Rod', player) and has_sword(state, player))  # sword required for curtain
     add_rule(multiworld.get_location('Skull Woods - Prize', player), lambda state: state._lttp_has_key('Small Key (Skull Woods)', player, 5))
@@ -502,13 +501,13 @@ def global_rules(multiworld: MultiWorld, player: int):
     set_rule(multiworld.get_entrance('Turtle Rock (Trinexx)', player), lambda state: state._lttp_has_key('Small Key (Turtle Rock)', player, 6) and state.has('Big Key (Turtle Rock)', player) and state.has('Cane of Somaria', player))
     set_rule(multiworld.get_entrance('Turtle Rock Second Section Bomb Wall', player), lambda state: can_kill_most_things(state, player, 10))
 
-    if not world.fix_trock_doors:
+    if not multiworld.worlds[player].fix_trock_doors:
         add_rule(multiworld.get_entrance('Turtle Rock Second Section Bomb Wall', player), lambda state: can_use_bombs(state, player))
         set_rule(multiworld.get_entrance('Turtle Rock Second Section from Bomb Wall', player), lambda state: can_use_bombs(state, player))
         set_rule(multiworld.get_entrance('Turtle Rock Eye Bridge from Bomb Wall', player), lambda state: can_use_bombs(state, player))
         set_rule(multiworld.get_entrance('Turtle Rock Eye Bridge Bomb Wall', player), lambda state: can_use_bombs(state, player))
 
-    if world.options.enemy_shuffle:
+    if multiworld.enemy_shuffle[player]:
         set_rule(multiworld.get_entrance('Palace of Darkness Bonk Wall', player), lambda state: can_bomb_or_bonk(state, player) and can_kill_most_things(state, player, 3))
     else:
         set_rule(multiworld.get_entrance('Palace of Darkness Bonk Wall', player), lambda state: can_bomb_or_bonk(state, player) and can_shoot_arrows(state, player))
@@ -518,18 +517,18 @@ def global_rules(multiworld: MultiWorld, player: int):
     set_rule(multiworld.get_entrance('Palace of Darkness (North)', player), lambda state: state._lttp_has_key('Small Key (Palace of Darkness)', player, 4))
     set_rule(multiworld.get_location('Palace of Darkness - Big Chest', player), lambda state: can_use_bombs(state, player) and state.has('Big Key (Palace of Darkness)', player))
     set_rule(multiworld.get_location('Palace of Darkness - The Arena - Ledge', player), lambda state: can_use_bombs(state, player))
-    if world.options.pot_shuffle:
+    if multiworld.pot_shuffle[player]:
         # chest switch may be up on ledge where bombs are required
         set_rule(multiworld.get_location('Palace of Darkness - Stalfos Basement', player), lambda state: can_use_bombs(state, player))
 
     set_rule(multiworld.get_entrance('Palace of Darkness Big Key Chest Staircase', player), lambda state: can_use_bombs(state, player) and (state._lttp_has_key('Small Key (Palace of Darkness)', player, 6) or (
             location_item_name(state, 'Palace of Darkness - Big Key Chest', player) in [('Small Key (Palace of Darkness)', player)] and state._lttp_has_key('Small Key (Palace of Darkness)', player, 3))))
-    if world.options.accessibility != 'full':
+    if multiworld.accessibility[player] != 'full':
         set_always_allow(multiworld.get_location('Palace of Darkness - Big Key Chest', player), lambda state, item: item.name == 'Small Key (Palace of Darkness)' and item.player == player and state._lttp_has_key('Small Key (Palace of Darkness)', player, 5))
 
     set_rule(multiworld.get_entrance('Palace of Darkness Spike Statue Room Door', player), lambda state: state._lttp_has_key('Small Key (Palace of Darkness)', player, 6) or (
             location_item_name(state, 'Palace of Darkness - Harmless Hellway', player) in [('Small Key (Palace of Darkness)', player)] and state._lttp_has_key('Small Key (Palace of Darkness)', player, 4)))
-    if world.options.accessibility != 'full':
+    if multiworld.accessibility[player] != 'full':
         set_always_allow(multiworld.get_location('Palace of Darkness - Harmless Hellway', player), lambda state, item: item.name == 'Small Key (Palace of Darkness)' and item.player == player and state._lttp_has_key('Small Key (Palace of Darkness)', player, 5))
 
     set_rule(multiworld.get_entrance('Palace of Darkness Maze Door', player), lambda state: state._lttp_has_key('Small Key (Palace of Darkness)', player, 6))
@@ -542,13 +541,13 @@ def global_rules(multiworld: MultiWorld, player: int):
     set_rule(multiworld.get_location('Ganons Tower - Bob\'s Torch', player), lambda state: state.has('Pegasus Boots', player))
     set_rule(multiworld.get_entrance('Ganons Tower (Tile Room)', player), lambda state: state.has('Cane of Somaria', player))
     set_rule(multiworld.get_entrance('Ganons Tower (Hookshot Room)', player), lambda state: state.has('Hammer', player) and (state.has('Hookshot', player) or state.has('Pegasus Boots', player)))
-    if world.options.pot_shuffle:
+    if multiworld.pot_shuffle[player]:
         set_rule(multiworld.get_location('Ganons Tower - Conveyor Cross Pot Key', player), lambda state: state.has('Hammer', player) and (state.has('Hookshot', player) or state.has('Pegasus Boots', player)))
     set_rule(multiworld.get_entrance('Ganons Tower (Map Room)', player), lambda state: state._lttp_has_key('Small Key (Ganons Tower)', player, 8) or (
                 location_item_name(state, 'Ganons Tower - Map Chest', player) in [('Big Key (Ganons Tower)', player)] and state._lttp_has_key('Small Key (Ganons Tower)', player, 6)))
 
     # this seemed to be causing generation failure, disable for now
-    # if world.worlds[player].options.accessibility != 'full':
+    # if world.accessibility[player] != 'full':
     #     set_always_allow(world.get_location('Ganons Tower - Map Chest', player), lambda state, item: item.name == 'Small Key (Ganons Tower)' and item.player == player and state._lttp_has_key('Small Key (Ganons Tower)', player, 7) and state.can_reach('Ganons Tower (Hookshot Room)', 'region', player))
 
     # It is possible to need more than 6 keys to get through this entrance if you spend keys elsewhere. We reflect this in the chest requirements.
@@ -583,7 +582,7 @@ def global_rules(multiworld: MultiWorld, player: int):
              lambda state: can_use_bombs(state, player) and state.multiworld.get_location('Ganons Tower - Big Key Chest', player).parent_region.dungeon.bosses['bottom'].can_defeat(state))
     set_rule(multiworld.get_location('Ganons Tower - Big Key Room - Right', player),
              lambda state: can_use_bombs(state, player) and state.multiworld.get_location('Ganons Tower - Big Key Room - Right', player).parent_region.dungeon.bosses['bottom'].can_defeat(state))
-    if world.options.enemy_shuffle:
+    if multiworld.enemy_shuffle[player]:
         set_rule(multiworld.get_entrance('Ganons Tower Big Key Door', player),
                  lambda state: state.has('Big Key (Ganons Tower)', player))
     else:
@@ -601,12 +600,12 @@ def global_rules(multiworld: MultiWorld, player: int):
     set_defeat_dungeon_boss_rule(multiworld.get_location('Agahnim 2', player))
     ganon = multiworld.get_location('Ganon', player)
     set_rule(ganon, lambda state: GanonDefeatRule(state, player))
-    if world.options.goal in ['ganon_triforce_hunt', 'local_ganon_triforce_hunt']:
+    if multiworld.goal[player] in ['ganon_triforce_hunt', 'local_ganon_triforce_hunt']:
         add_rule(ganon, lambda state: has_triforce_pieces(state, player))
-    elif world.options.goal == 'ganon_pedestal':
+    elif multiworld.goal[player] == 'ganon_pedestal':
         add_rule(multiworld.get_location('Ganon', player), lambda state: state.can_reach('Master Sword Pedestal', 'Location', player))
     else:
-        add_rule(ganon, lambda state: has_crystals(state, state.multiworld.worlds[player].options.crystals_needed_for_ganon, player))
+        add_rule(ganon, lambda state: has_crystals(state, state.multiworld.crystals_needed_for_ganon[player], player))
     set_rule(multiworld.get_entrance('Ganon Drop', player), lambda state: has_beam_sword(state, player))  # need to damage ganon to get tiles to drop
 
     set_rule(multiworld.get_location('Flute Activation Spot', player), lambda state: state.has('Flute', player))
@@ -723,9 +722,9 @@ def default_rules(world, player):
     set_rule(world.get_entrance('Floating Island Mirror Spot', player), lambda state: state.has('Magic Mirror', player))
     set_rule(world.get_entrance('Turtle Rock', player), lambda state: state.has('Moon Pearl', player) and has_sword(state, player) and has_turtle_rock_medallion(state, player) and state.can_reach('Turtle Rock (Top)', 'Region', player))  # sword required to cast magic (!)
 
-    set_rule(world.get_entrance('Pyramid Hole', player), lambda state: state.has('Beat Agahnim 2', player) or world.worlds[player].options.open_pyramid.to_bool(world, player))
+    set_rule(world.get_entrance('Pyramid Hole', player), lambda state: state.has('Beat Agahnim 2', player) or world.open_pyramid[player].to_bool(world, player))
 
-    if world.worlds[player].options.swordless:
+    if world.swordless[player]:
         swordless_rules(world, player)
 
 
@@ -880,14 +879,14 @@ def inverted_rules(world, player):
     set_rule(world.get_entrance('Dark Grassy Lawn Flute', player), lambda state: state.has('Activated Flute', player))
     set_rule(world.get_entrance('Hammer Peg Area Flute', player), lambda state: state.has('Activated Flute', player))
 
-    set_rule(world.get_entrance('Inverted Pyramid Hole', player), lambda state: state.has('Beat Agahnim 2', player) or world.worlds[player].options.open_pyramid)
+    set_rule(world.get_entrance('Inverted Pyramid Hole', player), lambda state: state.has('Beat Agahnim 2', player) or world.open_pyramid[player])
 
-    if world.worlds[player].options.swordless:
+    if world.swordless[player]:
         swordless_rules(world, player)
 
 def no_glitches_rules(world, player):
     """"""
-    if world.worlds[player].options.mode == 'inverted':
+    if world.mode[player] == 'inverted':
         set_rule(world.get_entrance('Zoras River', player), lambda state: state.has('Moon Pearl', player) and (state.has('Flippers', player) or can_lift_rocks(state, player)))
         set_rule(world.get_entrance('Lake Hylia Central Island Pier', player), lambda state: state.has('Moon Pearl', player) and state.has('Flippers', player))  # can be fake flippered to
         set_rule(world.get_entrance('Lake Hylia Island Pier', player), lambda state: state.has('Moon Pearl', player) and state.has('Flippers', player))  # can be fake flippered to
@@ -911,7 +910,7 @@ def no_glitches_rules(world, player):
     add_conditional_lamps(world, player)
 
 def fake_flipper_rules(world, player):
-    if world.worlds[player].options.mode == 'inverted':
+    if world.mode[player] == 'inverted':
         set_rule(world.get_entrance('Zoras River', player), lambda state: state.has('Moon Pearl', player))
         set_rule(world.get_entrance('Lake Hylia Central Island Pier', player), lambda state: state.has('Moon Pearl', player))
         set_rule(world.get_entrance('Lake Hylia Island Pier', player), lambda state: state.has('Moon Pearl', player))
@@ -997,7 +996,7 @@ def add_conditional_lamps(world, player):
                          'Location', True)
     add_conditional_lamp('Palace of Darkness - Dark Basement - Right', 'Palace of Darkness (Entrance)',
                          'Location', True)
-    if world.worlds[player].options.mode != 'inverted':
+    if world.mode[player] != 'inverted':
         add_conditional_lamp('Agahnim 1', 'Agahnims Tower', 'Entrance')
         add_conditional_lamp('Castle Tower - Dark Maze', 'Agahnims Tower')
         add_conditional_lamp('Castle Tower - Dark Archer Key Drop', 'Agahnims Tower')
@@ -1019,7 +1018,7 @@ def add_conditional_lamps(world, player):
     add_conditional_lamp('Eastern Palace - Boss', 'Eastern Palace', 'Location', True)
     add_conditional_lamp('Eastern Palace - Prize', 'Eastern Palace', 'Location', True)
 
-    if not world.worlds[player].options.mode == "standard":
+    if not world.mode[player] == "standard":
         add_lamp_requirement(world, world.get_location('Sewers - Dark Cross', player), player)
         add_lamp_requirement(world, world.get_entrance('Sewers Back Door', player), player)
         add_lamp_requirement(world, world.get_entrance('Throne Room', player), player)
@@ -1045,7 +1044,7 @@ def open_rules(world, player):
     set_rule(world.get_location('Hyrule Castle - Zelda\'s Chest', player),
              lambda state: state._lttp_has_key('Small Key (Hyrule Castle)', player, 4)
                            and state.has('Big Key (Hyrule Castle)', player)
-                           and (world.worlds[player].options.enemy_health in ("easy", "default")
+                           and (world.enemy_health[player] in ("easy", "default")
                                 or can_kill_most_things(state, player, 1)))
 
 
@@ -1059,7 +1058,7 @@ def swordless_rules(world, player):
 
     set_rule(world.get_entrance('Ganon Drop', player), lambda state: state.has('Hammer', player))  # need to damage ganon to get tiles to drop
 
-    if world.worlds[player].options.mode != 'inverted':
+    if world.mode[player] != 'inverted':
         set_rule(world.get_entrance('Agahnims Tower', player), lambda state: state.has('Cape', player) or state.has('Hammer', player) or state.has('Beat Agahnim 1', player))  # barrier gets removed after killing agahnim, relevant for entrance shuffle
         set_rule(world.get_entrance('Turtle Rock', player), lambda state: state.has('Moon Pearl', player) and has_turtle_rock_medallion(state, player) and state.can_reach('Turtle Rock (Top)', 'Region', player))   # sword not required to use medallion for opening in swordless (!)
         set_rule(world.get_entrance('Misery Mire', player), lambda state: state.has('Moon Pearl', player) and has_misery_mire_medallion(state, player))  # sword not required to use medallion for opening in swordless (!)
@@ -1072,8 +1071,9 @@ def swordless_rules(world, player):
 def add_connection(parent_name, target_name, entrance_name, world, player):
     parent = world.get_region(parent_name, player)
     target = world.get_region(target_name, player)
-    parent.connect(target, entrance_name)
-
+    connection = Entrance(player, entrance_name, parent)
+    parent.exits.append(connection)
+    connection.connect(target)
 
 
 def standard_rules(world, player):
@@ -1085,7 +1085,7 @@ def standard_rules(world, player):
     set_rule(world.get_entrance('Links House S&Q', player), lambda state: state.can_reach('Sanctuary', 'Region', player))
     set_rule(world.get_entrance('Sanctuary S&Q', player), lambda state: state.can_reach('Sanctuary', 'Region', player))
 
-    if world.worlds[player].options.small_key_shuffle != small_key_shuffle.option_universal:
+    if world.small_key_shuffle[player] != small_key_shuffle.option_universal:
         set_rule(world.get_location('Hyrule Castle - Boomerang Guard Key Drop', player),
                  lambda state: state._lttp_has_key('Small Key (Hyrule Castle)', player, 1)
                                and can_kill_most_things(state, player, 2))
@@ -1098,7 +1098,7 @@ def standard_rules(world, player):
         set_rule(world.get_location('Hyrule Castle - Zelda\'s Chest', player),
                  lambda state: state._lttp_has_key('Small Key (Hyrule Castle)', player, 2)
                                and state.has('Big Key (Hyrule Castle)', player)
-                               and (world.worlds[player].options.enemy_health in ("easy", "default")
+                               and (world.enemy_health[player] in ("easy", "default")
                                     or can_kill_most_things(state, player, 1)))
 
         set_rule(world.get_location('Sewers - Key Rat Key Drop', player),
@@ -1108,7 +1108,6 @@ def standard_rules(world, player):
         set_rule(world.get_location('Hyrule Castle - Zelda\'s Chest', player),
                  lambda state: state.has('Big Key (Hyrule Castle)', player))
 
-
 def toss_junk_item(world, player):
     items = ['Rupees (20)', 'Bombs (3)', 'Arrows (10)', 'Rupees (5)', 'Rupee (1)', 'Bombs (10)',
              'Single Arrow', 'Rupees (50)', 'Rupees (100)', 'Single Bomb', 'Bee', 'Bee Trap',
@@ -1196,15 +1195,15 @@ def set_trock_key_rules(multiworld, player):
             return 6
 
         # If TR is only accessible from the middle, the big key must be further restricted to prevent softlock potential
-        if not can_reach_front and not multiworld.worlds[player].options.small_key_shuffle:
+        if not can_reach_front and not multiworld.small_key_shuffle[player]:
             # Must not go in the Big Key Chest - only 1 other chest available and 2+ keys required for all other chests
             forbid_item(multiworld.get_location('Turtle Rock - Big Key Chest', player), 'Big Key (Turtle Rock)', player)
             if not can_reach_big_chest:
                 # Must not go in the Chain Chomps chest - only 2 other chests available and 3+ keys required for all other chests
                 forbid_item(multiworld.get_location('Turtle Rock - Chain Chomps', player), 'Big Key (Turtle Rock)', player)
                 forbid_item(multiworld.get_location('Turtle Rock - Pokey 2 Key Drop', player), 'Big Key (Turtle Rock)', player)
-            if multiworld.worlds[player].options.accessibility == 'full':
-                if multiworld.worlds[player].options.big_key_shuffle and can_reach_big_chest:
+            if multiworld.accessibility[player] == 'full':
+                if multiworld.big_key_shuffle[player] and can_reach_big_chest:
                     # Must not go in the dungeon - all 3 available chests (Chomps, Big Chest, Crystaroller) must be keys to access laser bridge, and the big key is required first
                     for location in ['Turtle Rock - Chain Chomps', 'Turtle Rock - Compass Chest',
                                      'Turtle Rock - Pokey 1 Key Drop', 'Turtle Rock - Pokey 2 Key Drop',
@@ -1217,9 +1216,9 @@ def set_trock_key_rules(multiworld, player):
                     location.place_locked_item(item)
                     toss_junk_item(multiworld, player)
 
-    if multiworld.worlds[player].options.accessibility != 'full':
+    if multiworld.accessibility[player] != 'full':
         set_always_allow(multiworld.get_location('Turtle Rock - Big Key Chest', player), lambda state, item: item.name == 'Small Key (Turtle Rock)' and item.player == player
-                and state.can_reach(state.multiworld.get_region('Turtle Rock (Second Section)', player)))
+                                                                                                             and state.can_reach(state.multiworld.get_region('Turtle Rock (Second Section)', player)))
 
 
 def set_big_bomb_rules(world, player):
@@ -1684,7 +1683,7 @@ def set_bunny_rules(world: MultiWorld, player: int, inverted: bool):
     def get_rule_to_add(region, location = None, connecting_entrance = None):
         # In OWG, a location can potentially be superbunny-mirror accessible or
         # bunny revival accessible.
-        if world.worlds[player].options.glitches_required in ['minor_glitches', 'overworld_glitches', 'hybrid_major_glitches', 'no_logic']:
+        if world.glitches_required[player] in ['minor_glitches', 'overworld_glitches', 'hybrid_major_glitches', 'no_logic']:
             if region.name == 'Swamp Palace (Entrance)':  # Need to 0hp revive - not in logic
                 return lambda state: state.has('Moon Pearl', player)
             if region.name == 'Tower of Hera (Bottom)':  # Need to hit the crystal switch
@@ -1724,7 +1723,7 @@ def set_bunny_rules(world: MultiWorld, player: int, inverted: bool):
                 seen.add(new_region)
                 if not is_link(new_region):
                     # For glitch rulesets, establish superbunny and revival rules.
-                    if world.worlds[player].options.glitches_required in ['minor_glitches', 'overworld_glitches', 'hybrid_major_glitches', 'no_logic'] and entrance.name not in OverworldGlitchRules.get_invalid_bunny_revival_dungeons():
+                    if world.glitches_required[player] in ['minor_glitches', 'overworld_glitches', 'hybrid_major_glitches', 'no_logic'] and entrance.name not in OverworldGlitchRules.get_invalid_bunny_revival_dungeons():
                         if region.name in OverworldGlitchRules.get_sword_required_superbunny_mirror_regions():
                             possible_options.append(lambda state: path_to_access_rule(new_path, entrance) and state.has('Magic Mirror', player) and has_sword(state, player))
                         elif (region.name in OverworldGlitchRules.get_boots_required_superbunny_mirror_regions()
@@ -1761,7 +1760,7 @@ def set_bunny_rules(world: MultiWorld, player: int, inverted: bool):
     # Add requirements for all locations that are actually in the dark world, except those available to the bunny, including dungeon revival
     for entrance in world.get_entrances(player):
         if is_bunny(entrance.connected_region):
-            if world.worlds[player].options.glitches_required in ['minor_glitches', 'overworld_glitches', 'hybrid_major_glitches', 'no_logic'] :
+            if world.glitches_required[player] in ['minor_glitches', 'overworld_glitches', 'hybrid_major_glitches', 'no_logic'] :
                 if entrance.connected_region.type == LTTPRegionType.Dungeon:
                     if entrance.parent_region.type != LTTPRegionType.Dungeon and entrance.connected_region.name in OverworldGlitchRules.get_invalid_bunny_revival_dungeons():
                         add_rule(entrance, get_rule_to_add(entrance.connected_region, None, entrance))
@@ -1769,7 +1768,7 @@ def set_bunny_rules(world: MultiWorld, player: int, inverted: bool):
                 if entrance.connected_region.name == 'Turtle Rock (Entrance)':
                     add_rule(world.get_entrance('Turtle Rock Entrance Gap', player), get_rule_to_add(entrance.connected_region, None, entrance))
             for location in entrance.connected_region.locations:
-                if world.worlds[player].options.glitches_required in ['minor_glitches', 'overworld_glitches', 'hybrid_major_glitches', 'no_logic'] and entrance.name in OverworldGlitchRules.get_invalid_mirror_bunny_entrances():
+                if world.glitches_required[player] in ['minor_glitches', 'overworld_glitches', 'hybrid_major_glitches', 'no_logic'] and entrance.name in OverworldGlitchRules.get_invalid_mirror_bunny_entrances():
                     continue
                 if location.name in bunny_accessible_locations:
                     continue

worlds/alttp/Shops.py

@@ -168,7 +168,7 @@ def push_shop_inventories(multiworld):
     for location in shop_slots:
         item_name = location.item.name
         # Retro Bow arrows will already have been pushed
-        if (not multiworld.worlds[location.player].options.retro_bow) or ((item_name, location.item.player)
+        if (not multiworld.retro_bow[location.player]) or ((item_name, location.item.player)
                                                            != ("Single Arrow", location.player)):
             location.shop.push_inventory(location.shop_slot, item_name,
                                          round(location.shop_price * get_price_modifier(location.item)),
@@ -185,36 +185,36 @@ def push_shop_inventories(multiworld):
 def create_shops(multiworld, player: int):
     from .Options import RandomizeShopInventories
     player_shop_table = shop_table.copy()
-    if multiworld.worlds[player].options.include_witch_hut:
+    if multiworld.include_witch_hut[player]:
         player_shop_table["Potion Shop"] = player_shop_table["Potion Shop"]._replace(locked=False)
         dynamic_shop_slots = total_dynamic_shop_slots + 3
     else:
         dynamic_shop_slots = total_dynamic_shop_slots
-    if multiworld.worlds[player].options.shuffle_capacity_upgrades:
+    if multiworld.shuffle_capacity_upgrades[player]:
         player_shop_table["Capacity Upgrade"] = player_shop_table["Capacity Upgrade"]._replace(locked=False)
 
-    num_slots = min(dynamic_shop_slots, multiworld.worlds[player].options.shop_item_slots)
+    num_slots = min(dynamic_shop_slots, multiworld.shop_item_slots[player])
     single_purchase_slots: List[bool] = [True] * num_slots + [False] * (dynamic_shop_slots - num_slots)
     multiworld.random.shuffle(single_purchase_slots)
 
-    if multiworld.worlds[player].options.randomize_shop_inventories:
+    if multiworld.randomize_shop_inventories[player]:
         default_shop_table = [i for l in
                               [shop_generation_types[x] for x in ['arrows', 'bombs', 'potions', 'shields', 'bottle'] if
-                               not multiworld.worlds[player].options.retro_bow or x != 'arrows'] for i in l]
+                               not multiworld.retro_bow[player] or x != 'arrows'] for i in l]
         new_basic_shop = multiworld.random.sample(default_shop_table, k=3)
         new_dark_shop = multiworld.random.sample(default_shop_table, k=3)
         for name, shop in player_shop_table.items():
             typ, shop_id, keeper, custom, locked, items, sram_offset = shop
             if not locked:
                 new_items = multiworld.random.sample(default_shop_table, k=len(items))
-                if multiworld.worlds[player].options.randomize_shop_inventories == RandomizeShopInventories.option_randomize_by_shop_type:
+                if multiworld.randomize_shop_inventories[player] == RandomizeShopInventories.option_randomize_by_shop_type:
                     if items == _basic_shop_defaults:
                         new_items = new_basic_shop
                     elif items == _dark_world_shop_defaults:
                         new_items = new_dark_shop
                 keeper = multiworld.random.choice([0xA0, 0xC1, 0xFF])
                 player_shop_table[name] = ShopData(typ, shop_id, keeper, custom, locked, new_items, sram_offset)
-    if multiworld.worlds[player].options.mode == "inverted":
+    if multiworld.mode[player] == "inverted":
         # make sure that blue potion is available in inverted, special case locked = None; lock when done.
         player_shop_table["Dark Lake Hylia Shop"] = \
             player_shop_table["Dark Lake Hylia Shop"]._replace(items=_inverted_hylia_shop_defaults, locked=None)
@@ -237,7 +237,7 @@ def create_shops(multiworld, player: int):
                 add_rule(loc, lambda state, spot=loc: shop_price_rules(state, player, spot))
                 loc.shop = shop
                 loc.shop_slot = index
-                if ((not (multiworld.worlds[player].options.shuffle_capacity_upgrades and type == ShopType.UpgradeShop))
+                if ((not (multiworld.shuffle_capacity_upgrades[player] and type == ShopType.UpgradeShop))
                         and not single_purchase_slots.pop()):
                     loc.shop_slot_disabled = True
                     loc.locked = True
@@ -309,18 +309,18 @@ def set_up_shops(multiworld, player: int):
     from .Options import small_key_shuffle
     # TODO: move hard+ mode changes for shields here, utilizing the new shops
 
-    if multiworld.worlds[player].options.retro_bow:
+    if multiworld.retro_bow[player]:
         rss = multiworld.get_region('Red Shield Shop', player).shop
         replacement_items = [['Red Potion', 150], ['Green Potion', 75], ['Blue Potion', 200], ['Bombs (10)', 50],
                              ['Blue Shield', 50], ['Small Heart',
                                                    10]]  # Can't just replace the single arrow with 10 arrows as retro doesn't need them.
-        if multiworld.worlds[player].options.small_key_shuffle == small_key_shuffle.option_universal:
+        if multiworld.small_key_shuffle[player] == small_key_shuffle.option_universal:
             replacement_items.append(['Small Key (Universal)', 100])
         replacement_item = multiworld.random.choice(replacement_items)
         rss.add_inventory(2, 'Single Arrow', 80, 1, replacement_item[0], replacement_item[1])
         rss.locked = True
 
-    if multiworld.worlds[player].options.small_key_shuffle == small_key_shuffle.option_universal or multiworld.worlds[player].options.retro_bow:
+    if multiworld.small_key_shuffle[player] == small_key_shuffle.option_universal or multiworld.retro_bow[player]:
         for shop in multiworld.random.sample([s for s in multiworld.shops if
                                               s.custom and not s.locked and s.type == ShopType.Shop
                                               and s.region.player == player], 5):
@@ -328,19 +328,19 @@ def set_up_shops(multiworld, player: int):
             slots = [0, 1, 2]
             multiworld.random.shuffle(slots)
             slots = iter(slots)
-            if multiworld.worlds[player].options.small_key_shuffle == small_key_shuffle.option_universal:
+            if multiworld.small_key_shuffle[player] == small_key_shuffle.option_universal:
                 shop.add_inventory(next(slots), 'Small Key (Universal)', 100)
-            if multiworld.worlds[player].options.retro_bow:
+            if multiworld.retro_bow[player]:
                 shop.push_inventory(next(slots), 'Single Arrow', 80)
 
-    if multiworld.worlds[player].options.shuffle_capacity_upgrades:
+    if multiworld.shuffle_capacity_upgrades[player]:
         for shop in multiworld.shops:
             if shop.type == ShopType.UpgradeShop and shop.region.player == player and \
                     shop.region.name == "Capacity Upgrade":
                 shop.clear_inventory()
 
-    if (multiworld.worlds[player].options.shuffle_shop_inventories or multiworld.worlds[player].options.randomize_shop_prices
-            or multiworld.worlds[player].options.randomize_cost_types):
+    if (multiworld.shuffle_shop_inventories[player] or multiworld.randomize_shop_prices[player]
+            or multiworld.randomize_cost_types[player]):
         shops = []
         total_inventory = []
         for shop in multiworld.shops:
@@ -352,7 +352,7 @@ def set_up_shops(multiworld, player: int):
         for item in total_inventory:
             item["price_type"], item["price"] = get_price(multiworld, item, player)
 
-        if multiworld.worlds[player].options.shuffle_shop_inventories:
+        if multiworld.shuffle_shop_inventories[player]:
             multiworld.random.shuffle(total_inventory)
 
             i = 0
@@ -434,39 +434,39 @@ def get_price(multiworld, item, player: int, price_type=None):
         price_types = [price_type]
     else:
         price_types = [ShopPriceType.Rupees]  # included as a chance to not change price
-        if multiworld.worlds[player].options.randomize_cost_types:
+        if multiworld.randomize_cost_types[player]:
             price_types += [
                 ShopPriceType.Hearts,
                 ShopPriceType.Bombs,
                 ShopPriceType.Magic,
             ]
-            if multiworld.worlds[player].options.small_key_shuffle == small_key_shuffle.option_universal:
+            if multiworld.small_key_shuffle[player] == small_key_shuffle.option_universal:
                 if item and item["item"] == "Small Key (Universal)":
                     price_types = [ShopPriceType.Rupees, ShopPriceType.Magic]  # no logical requirements for repeatable keys
                 else:
                     price_types.append(ShopPriceType.Keys)
-            if multiworld.worlds[player].options.retro_bow:
+            if multiworld.retro_bow[player]:
                 if item and item["item"] == "Single Arrow":
                     price_types = [ShopPriceType.Rupees, ShopPriceType.Magic]  # no logical requirements for arrows
             else:
                 price_types.append(ShopPriceType.Arrows)
-    diff = multiworld.worlds[player].options.item_pool.value
+    diff = multiworld.item_pool[player].value
     if item:
         # This is for a shop's regular inventory, the item is already determined, and we will decide the price here
         price = item["price"]
-        if multiworld.worlds[player].options.randomize_shop_prices:
+        if multiworld.randomize_shop_prices[player]:
             adjust = 2 if price < 100 else 5
-            price = int((price / adjust) * (0.5 + multiworld.worlds[player].random.random() * 1.5)) * adjust
-        multiworld.worlds[player].random.shuffle(price_types)
+            price = int((price / adjust) * (0.5 + multiworld.per_slot_randoms[player].random() * 1.5)) * adjust
+        multiworld.per_slot_randoms[player].shuffle(price_types)
         for p_type in price_types:
             if any(x in item['item'] for x in price_blacklist[p_type]):
                 continue
             return p_type, price_chart[p_type](price, diff)
     else:
         # This is an AP location and the price will be adjusted after an item is shuffled into it
-        p_type = multiworld.worlds[player].random.choice(price_types)
-        return p_type, price_chart[p_type](min(int(multiworld.worlds[player].random.randint(8, 56)
-                                           * multiworld.worlds[player].options.shop_price_modifier / 100) * 5, 9999), diff)
+        p_type = multiworld.per_slot_randoms[player].choice(price_types)
+        return p_type, price_chart[p_type](min(int(multiworld.per_slot_randoms[player].randint(8, 56)
+                                           * multiworld.shop_price_modifier[player] / 100) * 5, 9999), diff)
 
 
 def shop_price_rules(state: CollectionState, player: int, location: ALttPLocation):

worlds/alttp/StateHelpers.py

@@ -6,7 +6,7 @@ def is_not_bunny(state: CollectionState, region: LTTPRegion, player: int) -> boo
     if state.has('Moon Pearl', player):
         return True
 
-    return region.is_light_world if state.multiworld.worlds[player].options.mode != 'inverted' else region.is_dark_world
+    return region.is_light_world if state.multiworld.mode[player] != 'inverted' else region.is_dark_world
 
 
 def can_bomb_clip(state: CollectionState, region: LTTPRegion, player: int) -> bool:
@@ -24,7 +24,7 @@ def can_buy(state: CollectionState, item: str, player: int) -> bool:
 
 
 def can_shoot_arrows(state: CollectionState, player: int, count: int = 0) -> bool:
-    if state.multiworld.worlds[player].options.retro_bow:
+    if state.multiworld.retro_bow[player]:
         return (state.has('Bow', player) or state.has('Silver Bow', player)) and can_buy(state, 'Single Arrow', player)
     return (state.has('Bow', player) or state.has('Silver Bow', player)) and can_hold_arrows(state, player, count)
 
@@ -74,9 +74,9 @@ def can_extend_magic(state: CollectionState, player: int, smallmagic: int = 16,
     elif state.has('Magic Upgrade (1/2)', player):
         basemagic = 16
     if can_buy_unlimited(state, 'Green Potion', player) or can_buy_unlimited(state, 'Blue Potion', player):
-        if state.multiworld.worlds[player].options.item_functionality == 'hard' and not fullrefill:
+        if state.multiworld.item_functionality[player] == 'hard' and not fullrefill:
             basemagic = basemagic + int(basemagic * 0.5 * bottle_count(state, player))
-        elif state.multiworld.worlds[player].options.item_functionality == 'expert' and not fullrefill:
+        elif state.multiworld.item_functionality[player] == 'expert' and not fullrefill:
             basemagic = basemagic + int(basemagic * 0.25 * bottle_count(state, player))
         else:
             basemagic = basemagic + basemagic * bottle_count(state, player)
@@ -99,12 +99,12 @@ def can_hold_arrows(state: CollectionState, player: int, quantity: int):
 
 
 def can_use_bombs(state: CollectionState, player: int, quantity: int = 1) -> bool:
-    bombs = 0 if state.multiworld.worlds[player].options.bombless_start else 10
+    bombs = 0 if state.multiworld.bombless_start[player] else 10
     bombs += ((state.count("Bomb Upgrade (+5)", player) * 5) + (state.count("Bomb Upgrade (+10)", player) * 10)
               + (state.count("Bomb Upgrade (50)", player) * 50))
     # Bomb Upgrade (+5) beyond the 6th gives +10
     bombs += max(0, ((state.count("Bomb Upgrade (+5)", player) - 6) * 10))
-    if (not state.multiworld.worlds[player].options.shuffle_capacity_upgrades) and state.has("Capacity Upgrade Shop", player):
+    if (not state.multiworld.shuffle_capacity_upgrades[player]) and state.has("Capacity Upgrade Shop", player):
         bombs += 40
     return bombs >= min(quantity, 50)
 
@@ -120,7 +120,7 @@ def can_activate_crystal_switch(state: CollectionState, player: int) -> bool:
 
 
 def can_kill_most_things(state: CollectionState, player: int, enemies: int = 5) -> bool:
-    if state.multiworld.worlds[player].options.enemy_shuffle:
+    if state.multiworld.enemy_shuffle[player]:
         # I don't fully understand Enemizer's logic for placing enemies in spots where they need to be killable, if any.
         # Just go with maximal requirements for now.
         return (has_melee_weapon(state, player)
@@ -135,7 +135,7 @@ def can_kill_most_things(state: CollectionState, player: int, enemies: int = 5)
                 or (state.has('Cane of Byrna', player) and (enemies < 6 or can_extend_magic(state, player)))
                 or can_shoot_arrows(state, player)
                 or state.has('Fire Rod', player)
-                or (state.multiworld.worlds[player].options.enemy_health in ("easy", "default")
+                or (state.multiworld.enemy_health[player] in ("easy", "default")
                     and can_use_bombs(state, player, enemies * 4)))
 
 
@@ -152,7 +152,7 @@ def can_get_good_bee(state: CollectionState, player: int) -> bool:
 
 def can_retrieve_tablet(state: CollectionState, player: int) -> bool:
     return state.has('Book of Mudora', player) and (has_beam_sword(state, player) or
-                                                    (state.multiworld.worlds[player].options.swordless and
+                                                    (state.multiworld.swordless[player] and
                                                      state.has("Hammer", player)))
 
 
@@ -179,7 +179,7 @@ def has_fire_source(state: CollectionState, player: int) -> bool:
 def can_melt_things(state: CollectionState, player: int) -> bool:
     return state.has('Fire Rod', player) or \
         (state.has('Bombos', player) and
-         (state.multiworld.worlds[player].options.swordless or
+         (state.multiworld.swordless[player] or
           has_sword(state, player)))
 
 
@@ -192,19 +192,19 @@ def has_turtle_rock_medallion(state: CollectionState, player: int) -> bool:
 
 
 def can_boots_clip_lw(state: CollectionState, player: int) -> bool:
-    if state.multiworld.worlds[player].options.mode == 'inverted':
+    if state.multiworld.mode[player] == 'inverted':
         return state.has('Pegasus Boots', player) and state.has('Moon Pearl', player)
     return state.has('Pegasus Boots', player)
 
 
 def can_boots_clip_dw(state: CollectionState, player: int) -> bool:
-    if state.multiworld.worlds[player].options.mode != 'inverted':
+    if state.multiworld.mode[player] != 'inverted':
         return state.has('Pegasus Boots', player) and state.has('Moon Pearl', player)
     return state.has('Pegasus Boots', player)
 
 
 def can_get_glitched_speed_dw(state: CollectionState, player: int) -> bool:
     rules = [state.has('Pegasus Boots', player), any([state.has('Hookshot', player), has_sword(state, player)])]
-    if state.multiworld.worlds[player].options.mode != 'inverted':
+    if state.multiworld.mode[player] != 'inverted':
         rules.append(state.has('Moon Pearl', player))
     return all(rules)

worlds/alttp/SubClasses.py

@@ -2,10 +2,11 @@
 from typing import Optional, TYPE_CHECKING
 from enum import IntEnum
 
-from BaseClasses import Entrance, Location, Item, ItemClassification, Region, MultiWorld
+from BaseClasses import Location, Item, ItemClassification, Region, MultiWorld
 
 if TYPE_CHECKING:
     from .Dungeons import Dungeon
+    from .Regions import LTTPRegion
 
 
 class ALttPLocation(Location):
@@ -76,19 +77,6 @@ class ALttPItem(Item):
             return self.type
 
 
-Addresses = int | list[int] | tuple[int, int, int, int, int, int, int, int, int, int, int, int, int]
-
-
-class LTTPEntrance(Entrance):
-    addresses: Addresses | None = None
-    target: int | None = None
-
-    def connect(self, region: Region, addresses: Addresses | None = None, target: int | None = None) -> None:
-        super().connect(region)
-        self.addresses = addresses
-        self.target = target
-
-
 class LTTPRegionType(IntEnum):
     LightWorld = 1
     DarkWorld = 2
@@ -102,7 +90,6 @@ class LTTPRegionType(IntEnum):
 
 
 class LTTPRegion(Region):
-    entrance_type = LTTPEntrance
     type: LTTPRegionType
 
     # will be set after making connections.

worlds/alttp/UnderworldGlitchRules.py

@@ -1,6 +1,6 @@
+from BaseClasses import Entrance
 from worlds.generic.Rules import set_rule, add_rule
 from .StateHelpers import can_bomb_clip, has_sword, has_beam_sword, has_fire_source, can_melt_things, has_misery_mire_medallion
-from .SubClasses import LTTPEntrance
 
 
 # We actually need the logic to properly "mark" these regions as Light or Dark world. 
@@ -9,15 +9,17 @@ def underworld_glitch_connections(world, player):
     specrock = world.get_region('Spectacle Rock Cave (Bottom)', player)
     mire = world.get_region('Misery Mire (West)', player)
 
-    kikiskip = specrock.create_exit('Kiki Skip')
-    mire_to_hera = mire.create_exit('Mire to Hera Clip')
-    mire_to_swamp = mire.create_exit('Hera to Swamp Clip')
+    kikiskip = Entrance(player, 'Kiki Skip', specrock)
+    mire_to_hera = Entrance(player, 'Mire to Hera Clip', mire)
+    mire_to_swamp = Entrance(player, 'Hera to Swamp Clip', mire)
+    specrock.exits.append(kikiskip)
+    mire.exits.extend([mire_to_hera, mire_to_swamp])
 
     if world.worlds[player].fix_fake_world:
         kikiskip.connect(world.get_entrance('Palace of Darkness Exit', player).connected_region)
         mire_to_hera.connect(world.get_entrance('Tower of Hera Exit', player).connected_region)
         mire_to_swamp.connect(world.get_entrance('Swamp Palace Exit', player).connected_region)
-    else:
+    else: 
         kikiskip.connect(world.get_region('Palace of Darkness (Entrance)', player))
         mire_to_hera.connect(world.get_region('Tower of Hera (Bottom)', player))
         mire_to_swamp.connect(world.get_region('Swamp Palace (Entrance)', player))
@@ -35,7 +37,7 @@ def fake_pearl_state(state, player):
 
 # Sets the rules on where we can actually go using this clip.
 # Behavior differs based on what type of ER shuffle we're playing. 
-def dungeon_reentry_rules(world, player, clip: LTTPEntrance, dungeon_region: str, dungeon_exit: str): 
+def dungeon_reentry_rules(world, player, clip: Entrance, dungeon_region: str, dungeon_exit: str): 
     fix_dungeon_exits = world.worlds[player].fix_palaceofdarkness_exit
     fix_fake_worlds = world.worlds[player].fix_fake_world
 
@@ -59,7 +61,7 @@ def dungeon_reentry_rules(world, player, clip: LTTPEntrance, dungeon_region: str
     # since the clip links directly to the exterior region. 
 
 
-def underworld_glitches_rules(world, player):
+def underworld_glitches_rules(world, player): 
     # Ice Palace Entrance Clip
     # This is the easiest one since it's a simple internal clip.
     # Need to also add melting to freezor chest since it's otherwise assumed.
@@ -88,12 +90,12 @@ def underworld_glitches_rules(world, player):
     # We need to be able to s+q to old man, then go to either Mire or Hera at either Hera or GT. 
     # First we require a certain type of entrance shuffle, then build the rule from its pieces. 
     if not world.worlds[player].swamp_patch_required:
-        if world.worlds[player].options.entrance_shuffle in ['vanilla', 'dungeons_simple', 'dungeons_full', 'dungeons_crossed']:
+        if world.entrance_shuffle[player] in ['vanilla', 'dungeons_simple', 'dungeons_full', 'dungeons_crossed']:
             rule_map = {
                 'Misery Mire (Entrance)': (lambda state: True),
                 'Tower of Hera (Bottom)': (lambda state: state.can_reach('Tower of Hera Big Key Door', 'Entrance', player))
             }
-            inverted = world.worlds[player].options.mode == 'inverted'
+            inverted = world.mode[player] == 'inverted'
             hera_rule = lambda state: (state.has('Moon Pearl', player) or not inverted) and \
                                       rule_map.get(world.get_entrance('Tower of Hera', player).connected_region.name, lambda state: False)(state)
             gt_rule = lambda state: (state.has('Moon Pearl', player) or inverted) and \

worlds/alttp/__init__.py

@@ -141,7 +141,7 @@ class ALTTPWorld(World):
     item_name_groups = item_name_groups
     location_name_groups = {
         "Blind's Hideout": {"Blind's Hideout - Top", "Blind's Hideout - Left", "Blind's Hideout - Right",
-                            "Blind's Hideout - Far Left", "Blind's Hideout - Far Right"},
+                           "Blind's Hideout - Far Left", "Blind's Hideout - Far Right"},
         "Kakariko Well": {"Kakariko Well - Top", "Kakariko Well - Left", "Kakariko Well - Middle",
                           "Kakariko Well - Right", "Kakariko Well - Bottom"},
         "Mini Moldorm Cave": {"Mini Moldorm Cave - Far Left", "Mini Moldorm Cave - Left", "Mini Moldorm Cave - Right",
@@ -154,23 +154,15 @@ class ALTTPWorld(World):
         "Hookshot Cave": {"Hookshot Cave - Top Right", "Hookshot Cave - Top Left", "Hookshot Cave - Bottom Right",
                           "Hookshot Cave - Bottom Left"},
         "Hyrule Castle": {"Hyrule Castle - Boomerang Chest", "Hyrule Castle - Map Chest",
-                          "Hyrule Castle - Zelda's Chest", "Hyrule Castle - Big Key Drop",
-                          "Hyrule Castle - Boomerang Guard Key Drop", "Hyrule Castle - Map Guard Key Drop",
-                          "Sewers - Dark Cross", "Sewers - Secret Room - Left",
-                          "Sewers - Secret Room - Middle", "Sewers - Secret Room - Right",
-                          "Sewers - Key Rat Key Drop"},
+                          "Hyrule Castle - Zelda's Chest", "Sewers - Dark Cross", "Sewers - Secret Room - Left",
+                          "Sewers - Secret Room - Middle", "Sewers - Secret Room - Right"},
         "Eastern Palace": {"Eastern Palace - Compass Chest", "Eastern Palace - Big Chest",
                            "Eastern Palace - Cannonball Chest", "Eastern Palace - Big Key Chest",
-                           "Eastern Palace - Dark Eyegore Key Drop", "Eastern Palace - Dark Square Pot Key",
                            "Eastern Palace - Map Chest", "Eastern Palace - Boss"},
         "Desert Palace": {"Desert Palace - Big Chest", "Desert Palace - Torch", "Desert Palace - Map Chest",
-                          "Desert Palace - Beamos Hall Pot Key", "Desert Palace - Desert Tiles 1 Pot Key",
-                          "Desert Palace - Desert Tiles 2 Pot Key", "Desert Palace - Compass Chest",
-                          "Desert Palace - Big Key Chest", "Desert Palace - Boss"},
+                          "Desert Palace - Compass Chest", "Desert Palace - Big Key Chest", "Desert Palace - Boss"},
         "Tower of Hera": {"Tower of Hera - Basement Cage", "Tower of Hera - Map Chest", "Tower of Hera - Big Key Chest",
                           "Tower of Hera - Compass Chest", "Tower of Hera - Big Chest", "Tower of Hera - Boss"},
-        "Castle Tower": {"Castle Tower - Room 03", "Castle Tower - Dark Maze",
-                         "Castle Tower - Dark Archer Key Drop", "Castle Tower - Circle of Pots Key Drop"},
         "Palace of Darkness": {"Palace of Darkness - Shooter Room", "Palace of Darkness - The Arena - Bridge",
                                "Palace of Darkness - Stalfos Basement", "Palace of Darkness - Big Key Chest",
                                "Palace of Darkness - The Arena - Ledge", "Palace of Darkness - Map Chest",
@@ -181,33 +173,25 @@ class ALTTPWorld(World):
         "Swamp Palace": {"Swamp Palace - Entrance", "Swamp Palace - Map Chest", "Swamp Palace - Big Chest",
                          "Swamp Palace - Compass Chest", "Swamp Palace - Big Key Chest", "Swamp Palace - West Chest",
                          "Swamp Palace - Flooded Room - Left", "Swamp Palace - Flooded Room - Right",
-                         "Swamp Palace - Hookshot Pot Key", "Swamp Palace - Pot Row Pot Key",
-                         "Swamp Palace - Trench 1 Pot Key", "Swamp Palace - Trench 2 Pot Key",
-                         "Swamp Palace - Waterway Pot Key", "Swamp Palace - Waterfall Room", "Swamp Palace - Boss"},
+                         "Swamp Palace - Waterfall Room", "Swamp Palace - Boss"},
         "Thieves' Town": {"Thieves' Town - Big Key Chest", "Thieves' Town - Map Chest", "Thieves' Town - Compass Chest",
                           "Thieves' Town - Ambush Chest", "Thieves' Town - Attic", "Thieves' Town - Big Chest",
-                          "Thieves' Town - Hallway Pot Key", "Thieves' Town - Spike Switch Pot Key",
                           "Thieves' Town - Blind's Cell", "Thieves' Town - Boss"},
         "Skull Woods": {"Skull Woods - Map Chest", "Skull Woods - Pinball Room", "Skull Woods - Compass Chest",
                         "Skull Woods - Pot Prison", "Skull Woods - Big Chest", "Skull Woods - Big Key Chest",
-                        "Skull Woods - Spike Corner Key Drop", "Skull Woods - West Lobby Pot Key",
                         "Skull Woods - Bridge Room", "Skull Woods - Boss"},
         "Ice Palace": {"Ice Palace - Compass Chest", "Ice Palace - Freezor Chest", "Ice Palace - Big Chest",
                        "Ice Palace - Freezor Chest", "Ice Palace - Big Chest", "Ice Palace - Iced T Room",
                        "Ice Palace - Spike Room", "Ice Palace - Big Key Chest", "Ice Palace - Map Chest",
-                       "Ice Palace - Conveyor Key Drop", "Ice Palace - Hammer Block Key Drop",
-                       "Ice Palace - Jelly Key Drop", "Ice Palace - Many Pots Pot Key",
                        "Ice Palace - Boss"},
         "Misery Mire": {"Misery Mire - Big Chest", "Misery Mire - Map Chest", "Misery Mire - Main Lobby",
                         "Misery Mire - Bridge Chest", "Misery Mire - Spike Chest", "Misery Mire - Compass Chest",
-                        "Misery Mire - Conveyor Crystal Key Drop", "Misery Mire - Fishbone Pot Key",
-                        "Misery Mire - Spikes Pot Key", "Misery Mire - Big Key Chest", "Misery Mire - Boss"},
+                        "Misery Mire - Big Key Chest", "Misery Mire - Boss"},
         "Turtle Rock": {"Turtle Rock - Compass Chest", "Turtle Rock - Roller Room - Left",
                         "Turtle Rock - Roller Room - Right", "Turtle Rock - Chain Chomps", "Turtle Rock - Big Key Chest",
                         "Turtle Rock - Big Chest", "Turtle Rock - Crystaroller Room",
                         "Turtle Rock - Eye Bridge - Bottom Left", "Turtle Rock - Eye Bridge - Bottom Right",
                         "Turtle Rock - Eye Bridge - Top Left", "Turtle Rock - Eye Bridge - Top Right",
-                        "Turtle Rock - Pokey 1 Key Drop", "Turtle Rock - Pokey 2 Key Drop",
                         "Turtle Rock - Boss"},
         "Ganons Tower": {"Ganons Tower - Bob's Torch", "Ganons Tower - Hope Room - Left",
                          "Ganons Tower - Hope Room - Right", "Ganons Tower - Tile Room",
@@ -220,13 +204,10 @@ class ALTTPWorld(World):
                          "Ganons Tower - Randomizer Room - Bottom Left", "Ganons Tower - Randomizer Room - Bottom Right",
                          "Ganons Tower - Bob's Chest", "Ganons Tower - Big Chest", "Ganons Tower - Big Key Room - Left",
                          "Ganons Tower - Big Key Room - Right", "Ganons Tower - Big Key Chest",
-                         "Ganons Tower - Conveyor Cross Pot Key", "Ganons Tower - Conveyor Star Pits Pot Key",
-                         "Ganons Tower - Double Switch Pot Key", "Ganons Tower - Mini Helmasaur Room - Left",
-                         "Ganons Tower - Mini Helmasaur Room - Right", "Ganons Tower - Pre-Moldorm Chest",
-                         "Ganons Tower - Mini Helmasaur Key Drop", "Ganons Tower - Validation Chest"},
+                         "Ganons Tower - Mini Helmasaur Room - Left", "Ganons Tower - Mini Helmasaur Room - Right",
+                         "Ganons Tower - Pre-Moldorm Chest", "Ganons Tower - Validation Chest"},
         "Ganons Tower Climb": {"Ganons Tower - Mini Helmasaur Room - Left", "Ganons Tower - Mini Helmasaur Room - Right",
-                               "Ganons Tower - Mini Helmasaur Key Drop", "Ganons Tower - Pre-Moldorm Chest",
-                               "Ganons Tower - Validation Chest"},
+                               "Ganons Tower - Pre-Moldorm Chest", "Ganons Tower - Validation Chest"},
     }
     hint_blacklist = {"Triforce"}
 
@@ -313,62 +294,74 @@ class ALTTPWorld(World):
                 break
 
     def generate_early(self):
+        # write old options
+        import dataclasses
+        is_first = self.player == min(self.multiworld.get_game_players(self.game))
+
+        for field in dataclasses.fields(self.options_dataclass):
+            if is_first:
+                setattr(self.multiworld, field.name, {})
+            getattr(self.multiworld, field.name)[self.player] = getattr(self.options, field.name)
+        # end of old options re-establisher
+
+        player = self.player
         multiworld = self.multiworld
 
-        self.fix_trock_doors = (self.options.entrance_shuffle != 'vanilla' or self.options.mode == 'inverted')
-        self.fix_skullwoods_exit = self.options.entrance_shuffle not in ['vanilla', 'simple', 'restricted', 'dungeons_simple']
-        self.fix_palaceofdarkness_exit = self.options.entrance_shuffle not in ['dungeons_simple', 'vanilla', 'simple', 'restricted']
-        self.fix_trock_exit = self.options.entrance_shuffle not in ['vanilla', 'simple', 'restricted', 'dungeons_simple']
+        self.fix_trock_doors = (multiworld.entrance_shuffle[player] != 'vanilla'
+                                or multiworld.mode[player] == 'inverted')
+        self.fix_skullwoods_exit = multiworld.entrance_shuffle[player] not in ['vanilla', 'simple', 'restricted',
+                                                                               'dungeons_simple']
+        self.fix_palaceofdarkness_exit = multiworld.entrance_shuffle[player] not in ['dungeons_simple', 'vanilla',
+                                                                                     'simple', 'restricted']
+        self.fix_trock_exit = multiworld.entrance_shuffle[player] not in ['vanilla', 'simple', 'restricted',
+                                                                          'dungeons_simple']
 
         # fairy bottle fills
         bottle_options = [
             "Bottle (Red Potion)", "Bottle (Green Potion)", "Bottle (Blue Potion)",
             "Bottle (Bee)", "Bottle (Good Bee)"
         ]
-        if self.options.item_pool not in ["hard", "expert"]:
+        if multiworld.item_pool[player] not in ["hard", "expert"]:
             bottle_options.append("Bottle (Fairy)")
         self.waterfall_fairy_bottle_fill = self.random.choice(bottle_options)
         self.pyramid_fairy_bottle_fill = self.random.choice(bottle_options)
 
-        if self.options.mode == 'standard':
-            if self.options.small_key_shuffle:
-                if (self.options.small_key_shuffle not in
-                        (small_key_shuffle.option_universal, small_key_shuffle.option_own_dungeons,
-                         small_key_shuffle.option_start_with)):
+        if multiworld.mode[player] == 'standard':
+            if multiworld.small_key_shuffle[player]:
+                if (multiworld.small_key_shuffle[player] not in
+                   (small_key_shuffle.option_universal, small_key_shuffle.option_own_dungeons,
+                    small_key_shuffle.option_start_with)):
                     self.multiworld.local_early_items[self.player]["Small Key (Hyrule Castle)"] = 1
-                self.options.local_items.value.add("Small Key (Hyrule Castle)")
-                self.options.non_local_items.value.discard("Small Key (Hyrule Castle)")
-            if self.options.big_key_shuffle:
-                self.options.local_items.value.add("Big Key (Hyrule Castle)")
-                self.options.non_local_items.value.discard("Big Key (Hyrule Castle)")
+                self.multiworld.local_items[self.player].value.add("Small Key (Hyrule Castle)")
+                self.multiworld.non_local_items[self.player].value.discard("Small Key (Hyrule Castle)")
+            if multiworld.big_key_shuffle[player]:
+                self.multiworld.local_items[self.player].value.add("Big Key (Hyrule Castle)")
+                self.multiworld.non_local_items[self.player].value.discard("Big Key (Hyrule Castle)")
 
         # system for sharing ER layouts
         self.er_seed = str(multiworld.random.randint(0, 2 ** 64))
 
-        if self.options.entrance_shuffle != "vanilla" and self.options.entrance_shuffle_seed != "random":
-            shuffle = self.options.entrance_shuffle.current_key
+        if multiworld.entrance_shuffle[player] != "vanilla" and multiworld.entrance_shuffle_seed[player] != "random":
+            shuffle = multiworld.entrance_shuffle[player].current_key
             if shuffle == "vanilla":
                 self.er_seed = "vanilla"
-            elif (not self.options.entrance_shuffle_seed.value.isdigit()) or multiworld.is_race:
+            elif (not multiworld.entrance_shuffle_seed[player].value.isdigit()) or multiworld.is_race:
                 self.er_seed = get_same_seed(multiworld, (
-                    shuffle, self.options.entrance_shuffle_seed.value,
-                    self.options.retro_caves,
-                    self.options.mode,
-                    self.options.glitches_required
-                ))
+                    shuffle, multiworld.entrance_shuffle_seed[player].value, multiworld.retro_caves[player], multiworld.mode[player],
+                    multiworld.glitches_required[player]))
             else:  # not a race or group seed, use set seed as is.
-                self.er_seed = int(self.options.entrance_shuffle_seed.value)
-        elif self.options.entrance_shuffle == "vanilla":
+                self.er_seed = int(multiworld.entrance_shuffle_seed[player].value)
+        elif multiworld.entrance_shuffle[player] == "vanilla":
             self.er_seed = "vanilla"
 
         for dungeon_item in ["small_key_shuffle", "big_key_shuffle", "compass_shuffle", "map_shuffle"]:
-            option = getattr(self.options, dungeon_item)
+            option = getattr(multiworld, dungeon_item)[player]
             if option == "own_world":
-                self.options.local_items.value |= self.item_name_groups[option.item_name_group]
+                multiworld.local_items[player].value |= self.item_name_groups[option.item_name_group]
             elif option == "different_world":
-                self.options.non_local_items.value |= self.item_name_groups[option.item_name_group]
-                if self.options.mode == "standard":
-                    self.options.non_local_items.value -= {"Small Key (Hyrule Castle)"}
+                multiworld.non_local_items[player].value |= self.item_name_groups[option.item_name_group]
+                if multiworld.mode[player] == "standard":
+                    multiworld.non_local_items[player].value -= {"Small Key (Hyrule Castle)"}
             elif option.in_dungeon:
                 self.dungeon_local_item_names |= self.item_name_groups[option.item_name_group]
                 if option == "original_dungeon":
@@ -376,15 +369,15 @@ class ALTTPWorld(World):
                 else:
                     self.options.local_items.value |= self.dungeon_local_item_names
 
-        self.difficulty_requirements = difficulties[self.options.item_pool.current_key]
+        self.difficulty_requirements = difficulties[multiworld.item_pool[player].current_key]
 
         # enforce pre-defined local items.
-        if self.options.goal in ["local_triforce_hunt", "local_ganon_triforce_hunt"]:
-            self.options.local_items.value.add('Triforce Piece')
+        if multiworld.goal[player] in ["local_triforce_hunt", "local_ganon_triforce_hunt"]:
+            multiworld.local_items[player].value.add('Triforce Piece')
 
         # Not possible to place crystals outside boss prizes yet (might as well make it consistent with pendants too).
-        self.options.non_local_items.value -= item_name_groups['Pendants']
-        self.options.non_local_items.value -= item_name_groups['Crystals']
+        multiworld.non_local_items[player].value -= item_name_groups['Pendants']
+        multiworld.non_local_items[player].value -= item_name_groups['Crystals']
 
     create_dungeons = create_dungeons
 
@@ -392,15 +385,15 @@ class ALTTPWorld(World):
         player = self.player
         multiworld = self.multiworld
 
-        if self.options.mode != 'inverted':
+        if multiworld.mode[player] != 'inverted':
             create_regions(multiworld, player)
         else:
             create_inverted_regions(multiworld, player)
         create_shops(multiworld, player)
         self.create_dungeons()
 
-        if (self.options.glitches_required not in ["no_glitches", "minor_glitches"] and
-                self.options.entrance_shuffle in [
+        if (multiworld.glitches_required[player] not in ["no_glitches", "minor_glitches"] and
+                multiworld.entrance_shuffle[player] in [
                     "vanilla", "dungeons_simple", "dungeons_full", "simple", "restricted", "full"]):
             self.fix_fake_world = False
 
@@ -408,7 +401,7 @@ class ALTTPWorld(World):
         old_random = multiworld.random
         multiworld.random = random.Random(self.er_seed)
 
-        if self.options.mode != 'inverted':
+        if multiworld.mode[player] != 'inverted':
             link_entrances(multiworld, player)
             mark_light_world_regions(multiworld, player)
         else:
@@ -493,9 +486,8 @@ class ALTTPWorld(World):
                     if state.has('Silver Bow', item.player):
                         return
                     elif state.has('Bow', item.player) and (self.difficulty_requirements.progressive_bow_limit >= 2
-                                                            or self.options.glitches_required == 'no_glitches'
-                                                            or self.options.swordless):
-                        # modes where silver bow is always required for ganon
+                                                            or self.multiworld.glitches_required[self.player] == 'no_glitches'
+                                                            or self.multiworld.swordless[self.player]):  # modes where silver bow is always required for ganon
                         return 'Silver Bow'
                     elif self.difficulty_requirements.progressive_bow_limit >= 1:
                         return 'Bow'
@@ -505,20 +497,20 @@ class ALTTPWorld(World):
     def pre_fill(self):
         from Fill import fill_restrictive, FillError
         attempts = 5
-        all_state = self.multiworld.get_all_state(use_cache=False)
+        world = self.multiworld
+        player = self.player
+        all_state = world.get_all_state(use_cache=True)
         crystals = [self.create_item(name) for name in ['Red Pendant', 'Blue Pendant', 'Green Pendant', 'Crystal 1', 'Crystal 2', 'Crystal 3', 'Crystal 4', 'Crystal 7', 'Crystal 5', 'Crystal 6']]
-        for crystal in crystals:
-            all_state.remove(crystal)
-        crystal_locations = [self.get_location('Turtle Rock - Prize'),
-                             self.get_location('Eastern Palace - Prize'),
-                             self.get_location('Desert Palace - Prize'),
-                             self.get_location('Tower of Hera - Prize'),
-                             self.get_location('Palace of Darkness - Prize'),
-                             self.get_location('Thieves\' Town - Prize'),
-                             self.get_location('Skull Woods - Prize'),
-                             self.get_location('Swamp Palace - Prize'),
-                             self.get_location('Ice Palace - Prize'),
-                             self.get_location('Misery Mire - Prize')]
+        crystal_locations = [world.get_location('Turtle Rock - Prize', player),
+                             world.get_location('Eastern Palace - Prize', player),
+                             world.get_location('Desert Palace - Prize', player),
+                             world.get_location('Tower of Hera - Prize', player),
+                             world.get_location('Palace of Darkness - Prize', player),
+                             world.get_location('Thieves\' Town - Prize', player),
+                             world.get_location('Skull Woods - Prize', player),
+                             world.get_location('Swamp Palace - Prize', player),
+                             world.get_location('Ice Palace - Prize', player),
+                             world.get_location('Misery Mire - Prize', player)]
         placed_prizes = {loc.item.name for loc in crystal_locations if loc.item}
         unplaced_prizes = [crystal for crystal in crystals if crystal.name not in placed_prizes]
         empty_crystal_locations = [loc for loc in crystal_locations if not loc.item]
@@ -526,8 +518,8 @@ class ALTTPWorld(World):
             try:
                 prizepool = unplaced_prizes.copy()
                 prize_locs = empty_crystal_locations.copy()
-                self.multiworld.random.shuffle(prize_locs)
-                fill_restrictive(self.multiworld, all_state, prize_locs, prizepool, True, lock=True,
+                world.random.shuffle(prize_locs)
+                fill_restrictive(world, all_state, prize_locs, prizepool, True, lock=True,
                                  name="LttP Dungeon Prizes")
             except FillError as e:
                 lttp_logger.exception("Failed to place dungeon prizes (%s). Will retry %s more times", e,
@@ -538,10 +530,10 @@ class ALTTPWorld(World):
             break
         else:
             raise FillError('Unable to place dungeon prizes')
-        if self.options.mode == 'standard' and self.options.small_key_shuffle \
-                and self.options.small_key_shuffle != small_key_shuffle.option_universal and \
-                self.options.small_key_shuffle != small_key_shuffle.option_own_dungeons:
-            self.multiworld.local_early_items[self.player]["Small Key (Hyrule Castle)"] = 1
+        if world.mode[player] == 'standard' and world.small_key_shuffle[player] \
+                and world.small_key_shuffle[player] != small_key_shuffle.option_universal and \
+                world.small_key_shuffle[player] != small_key_shuffle.option_own_dungeons:
+            world.local_early_items[player]["Small Key (Hyrule Castle)"] = 1
 
     @classmethod
     def stage_pre_fill(cls, world):
@@ -581,27 +573,27 @@ class ALTTPWorld(World):
             multiworld.spoiler.hashes[player] = get_hash_string(rom.hash)
 
             palettes_options = {
-                'dungeon': self.options.uw_palettes,
-                'overworld': self.options.ow_palettes,
-                'hud': self.options.hud_palettes,
-                'sword': self.options.sword_palettes,
-                'shield': self.options.shield_palettes,
+                'dungeon': multiworld.uw_palettes[player],
+                'overworld': multiworld.ow_palettes[player],
+                'hud': multiworld.hud_palettes[player],
+                'sword': multiworld.sword_palettes[player],
+                'shield': multiworld.shield_palettes[player],
                 # 'link': world.link_palettes[player]
             }
             palettes_options = {key: option.current_key for key, option in palettes_options.items()}
 
-            apply_rom_settings(rom, self.options.heartbeep.current_key,
-                               self.options.heartcolor.current_key,
-                               self.options.quickswap,
-                               self.options.menuspeed.current_key,
-                               self.options.music,
+            apply_rom_settings(rom, multiworld.heartbeep[player].current_key,
+                               multiworld.heartcolor[player].current_key,
+                               multiworld.quickswap[player],
+                               multiworld.menuspeed[player].current_key,
+                               multiworld.music[player],
                                multiworld.sprite[player],
                                None,
                                palettes_options, multiworld, player, True,
-                               reduceflashing=self.options.reduceflashing or multiworld.is_race,
-                               triforcehud=self.options.triforcehud.current_key,
-                               deathlink=self.options.death_link,
-                               allowcollect=self.options.allow_collect)
+                               reduceflashing=multiworld.reduceflashing[player] or multiworld.is_race,
+                               triforcehud=multiworld.triforcehud[player].current_key,
+                               deathlink=multiworld.death_link[player],
+                               allowcollect=multiworld.allow_collect[player])
 
             rompath = os.path.join(output_directory, f"{self.multiworld.get_out_file_name_base(self.player)}.sfc")
             rom.write_to_file(rompath)
@@ -618,7 +610,7 @@ class ALTTPWorld(World):
     @classmethod
     def stage_extend_hint_information(cls, world, hint_data: typing.Dict[int, typing.Dict[int, str]]):
         er_hint_data = {player: {} for player in world.get_game_players("A Link to the Past") if
-                        world.worlds[player].options.entrance_shuffle != "vanilla" or world.worlds[player].options.retro_caves}
+                        world.entrance_shuffle[player] != "vanilla" or world.retro_caves[player]}
 
         for region in world.regions:
             if region.player in er_hint_data and region.locations:
@@ -734,7 +726,7 @@ class ALTTPWorld(World):
                              f" {self.pyramid_fairy_bottle_fill}")
         spoiler_handle.write(f"\nWaterfall Fairy ({player_name}):"
                              f" {self.waterfall_fairy_bottle_fill}")
-        if self.options.boss_shuffle != "none":
+        if self.multiworld.boss_shuffle[self.player] != "none":
             def create_boss_map() -> typing.Dict:
                 boss_map = {
                     "Eastern Palace": self.dungeons["Eastern Palace"].boss.name,
@@ -751,7 +743,7 @@ class ALTTPWorld(World):
                     "Ganons Tower": "Agahnim 2",
                     "Ganon": "Ganon"
                 }
-                if self.options.mode != 'inverted':
+                if self.multiworld.mode[self.player] != 'inverted':
                     boss_map.update({
                         "Ganons Tower Basement":
                             self.dungeons["Ganons Tower"].bosses["bottom"].name,
@@ -811,15 +803,12 @@ class ALTTPWorld(World):
         return GetBeemizerItem(self.multiworld, self.player, item)
 
     def get_pre_fill_items(self):
-        res = [self.create_item(name) for name in ('Red Pendant', 'Blue Pendant', 'Green Pendant', 'Crystal 1',
-                                                   'Crystal 2', 'Crystal 3', 'Crystal 4', 'Crystal 7', 'Crystal 5',
-                                                   'Crystal 6')]
+        res = []
         if self.dungeon_local_item_names:
             for dungeon in self.dungeons.values():
                 for item in dungeon.all_items:
                     if item.name in self.dungeon_local_item_names:
                         res.append(item)
-
         return res
 
     def fill_slot_data(self):
@@ -839,7 +828,7 @@ class ALTTPWorld(World):
                             "triforce_pieces_available", "triforce_pieces_extra",
             ]
 
-            slot_data = {option_name: getattr(self.options, option_name).value for option_name in slot_options}
+            slot_data = {option_name: getattr(self.multiworld, option_name)[self.player].value for option_name in slot_options}
 
             slot_data.update({
                 'mm_medalion': self.required_medallions[0],
@@ -860,8 +849,8 @@ def get_same_seed(world, seed_def: tuple) -> str:
 
 class ALttPLogic(LogicMixin):
     def _lttp_has_key(self, item, player, count: int = 1):
-        if self.multiworld.worlds[player].options.glitches_required == 'no_logic':
+        if self.multiworld.glitches_required[player] == 'no_logic':
             return True
-        if self.multiworld.worlds[player].options.small_key_shuffle == small_key_shuffle.option_universal:
+        if self.multiworld.small_key_shuffle[player] == small_key_shuffle.option_universal:
             return can_buy_unlimited(self, 'Small Key (Universal)', player)
         return self.prog_items[player][item] >= count

worlds/alttp/test/__init__.py

@@ -10,12 +10,12 @@ class LTTPTestBase(unittest.TestCase):
         from worlds.alttp.Options import Medallion
         self.multiworld = MultiWorld(1)
         self.multiworld.game[1] = "A Link to the Past"
+        self.multiworld.state = CollectionState(self.multiworld)
         self.multiworld.set_seed(None)
         args = Namespace()
         for name, option in AutoWorldRegister.world_types["A Link to the Past"].options_dataclass.type_hints.items():
             setattr(args, name, {1: option.from_any(getattr(option, "default"))})
         self.multiworld.set_options(args)
-        self.multiworld.state = CollectionState(self.multiworld)
         self.world = self.multiworld.worlds[1]
         # by default medallion access is randomized, for unittests we set it to vanilla
         self.world.options.misery_mire_medallion.value = Medallion.option_ether

worlds/alttp/test/dungeons/TestDungeon.py

@@ -14,8 +14,8 @@ class TestDungeon(LTTPTestBase):
         self.starting_regions = []  # Where to start exploring
         self.remove_exits = []      # Block dungeon exits
         self.multiworld.worlds[1].difficulty_requirements = difficulties['normal']
-        self.multiworld.worlds[1].options.bombless_start.value = True
-        self.multiworld.worlds[1].options.shuffle_capacity_upgrades.value = 2
+        self.multiworld.bombless_start[1].value = True
+        self.multiworld.shuffle_capacity_upgrades[1].value = 2
         create_regions(self.multiworld, 1)
         self.multiworld.worlds[1].create_dungeons()
         create_shops(self.multiworld, 1)

worlds/alttp/test/dungeons/TestSwampPalace.py

@@ -24,7 +24,7 @@ class TestSwampPalace(TestDungeon):
             ["Swamp Palace - Big Key Chest", False, [], ['Open Floodgate']],
             ["Swamp Palace - Big Key Chest", False, [], ['Hammer']],
             ["Swamp Palace - Big Key Chest", False, [], ['Small Key (Swamp Palace)']],
-            ["Swamp Palace - Big Key Chest", True, ['Open Floodgate', 'Small Key (Swamp Palace)', 'Small Key (Swamp Palace)', 'Small Key (Swamp Palace)', 'Small Key (Swamp Palace)', 'Small Key (Swamp Palace)', 'Small Key (Swamp Palace)', 'Flippers', 'Hammer']],
+            ["Swamp Palace - Big Key Chest", True, ['Open Floodgate', 'Small Key (Swamp Palace)', 'Small Key (Swamp Palace)', 'Small Key (Swamp Palace)', 'Small Key (Swamp Palace)', 'Flippers', 'Hammer']],
 
             ["Swamp Palace - Map Chest", False, []],
             ["Swamp Palace - Map Chest", False, [], ['Flippers']],
@@ -38,7 +38,7 @@ class TestSwampPalace(TestDungeon):
             ["Swamp Palace - West Chest", False, [], ['Open Floodgate']],
             ["Swamp Palace - West Chest", False, [], ['Hammer']],
             ["Swamp Palace - West Chest", False, [], ['Small Key (Swamp Palace)']],
-            ["Swamp Palace - West Chest", True, ['Open Floodgate', 'Small Key (Swamp Palace)', 'Small Key (Swamp Palace)', 'Small Key (Swamp Palace)', 'Small Key (Swamp Palace)', 'Small Key (Swamp Palace)', 'Small Key (Swamp Palace)', 'Flippers', 'Hammer']],
+            ["Swamp Palace - West Chest", True, ['Open Floodgate', 'Small Key (Swamp Palace)', 'Small Key (Swamp Palace)', 'Small Key (Swamp Palace)', 'Small Key (Swamp Palace)', 'Flippers', 'Hammer']],
 
             ["Swamp Palace - Compass Chest", False, []],
             ["Swamp Palace - Compass Chest", False, [], ['Flippers']],

worlds/alttp/test/inverted/TestInverted.py

@@ -14,9 +14,9 @@ class TestInverted(TestBase, LTTPTestBase):
     def setUp(self):
         self.world_setup()
         self.multiworld.worlds[1].difficulty_requirements = difficulties['normal']
-        self.multiworld.worlds[1].options.mode.value = 2
-        self.multiworld.worlds[1].options.bombless_start.value = True
-        self.multiworld.worlds[1].options.shuffle_capacity_upgrades.value = 2
+        self.multiworld.mode[1].value = 2
+        self.multiworld.bombless_start[1].value = True
+        self.multiworld.shuffle_capacity_upgrades[1].value = 2
         create_inverted_regions(self.multiworld, 1)
         self.world.create_dungeons()
         create_shops(self.multiworld, 1)

worlds/alttp/test/inverted/TestInvertedBombRules.py

@@ -12,7 +12,7 @@ class TestInvertedBombRules(LTTPTestBase):
     def setUp(self):
         self.world_setup()
         self.multiworld.worlds[1].difficulty_requirements = difficulties['normal']
-        self.multiworld.worlds[1].options.mode.value = 2
+        self.multiworld.mode[1].value = 2
         create_inverted_regions(self.multiworld, 1)
         self.multiworld.worlds[1].create_dungeons()
 

worlds/alttp/test/inverted_minor_glitches/TestInvertedMinor.py

@@ -14,10 +14,10 @@ from worlds.alttp.test import LTTPTestBase
 class TestInvertedMinor(TestBase, LTTPTestBase):
     def setUp(self):
         self.world_setup()
-        self.multiworld.worlds[1].options.mode.value = 2
-        self.multiworld.worlds[1].options.glitches_required = GlitchesRequired.from_any("minor_glitches")
-        self.multiworld.worlds[1].options.bombless_start.value = True
-        self.multiworld.worlds[1].options.shuffle_capacity_upgrades.value = 2
+        self.multiworld.mode[1].value = 2
+        self.multiworld.glitches_required[1] = GlitchesRequired.from_any("minor_glitches")
+        self.multiworld.bombless_start[1].value = True
+        self.multiworld.shuffle_capacity_upgrades[1].value = 2
         self.multiworld.worlds[1].difficulty_requirements = difficulties['normal']
         create_inverted_regions(self.multiworld, 1)
         self.world.create_dungeons()

worlds/alttp/test/inverted_owg/TestInvertedOWG.py

@@ -14,10 +14,10 @@ from worlds.alttp.test import LTTPTestBase
 class TestInvertedOWG(TestBase, LTTPTestBase):
     def setUp(self):
         self.world_setup()
-        self.multiworld.worlds[1].options.glitches_required = GlitchesRequired.from_any("overworld_glitches")
-        self.multiworld.worlds[1].options.mode.value = 2
-        self.multiworld.worlds[1].options.bombless_start.value = True
-        self.multiworld.worlds[1].options.shuffle_capacity_upgrades.value = 2
+        self.multiworld.glitches_required[1] = GlitchesRequired.from_any("overworld_glitches")
+        self.multiworld.mode[1].value = 2
+        self.multiworld.bombless_start[1].value = True
+        self.multiworld.shuffle_capacity_upgrades[1].value = 2
         self.multiworld.worlds[1].difficulty_requirements = difficulties['normal']
         create_inverted_regions(self.multiworld, 1)
         self.world.create_dungeons()