Dark Souls 3: Use options_dataclass

.coveragerc

@@ -1,5 +0,0 @@
-[report]
-exclude_lines = 
-    pragma: no cover
-    if TYPE_CHECKING:
-    if typing.TYPE_CHECKING:

.github/labeler.yml

@@ -1,31 +0,0 @@
-'is: documentation':
-- changed-files:
-  - all-globs-to-all-files: '{**/docs/**,**/README.md}'
-
-'affects: webhost':
-- changed-files:
-  - all-globs-to-any-file: 'WebHost.py'
-  - all-globs-to-any-file: 'WebHostLib/**/*'
-
-'affects: core':
-- changed-files:
-  - all-globs-to-any-file:
-    - '!*Client.py'
-    - '!README.md'
-    - '!LICENSE'
-    - '!*.yml'
-    - '!.gitignore'
-    - '!**/docs/**'
-    - '!typings/kivy/**'
-    - '!test/**'
-    - '!data/**'
-    - '!.run/**'
-    - '!.github/**'
-    - '!worlds_disabled/**'
-    - '!worlds/**'
-    - '!WebHost.py'
-    - '!WebHostLib/**'
-  - any-glob-to-any-file: # exceptions to the above rules of "stuff that isn't core"
-    - 'worlds/generic/**/*.py'
-    - 'worlds/*.py'
-    - 'CommonClient.py'

.github/pyright-config.json

@@ -1,27 +0,0 @@
-{
-  "include": [
-    "type_check.py",
-    "../worlds/AutoSNIClient.py",
-    "../Patch.py"
-  ],
-
-  "exclude": [
-    "**/__pycache__"
-  ],
-
-  "stubPath": "../typings",
-
-  "typeCheckingMode": "strict",
-  "reportImplicitOverride": "error",
-  "reportMissingImports": true,
-  "reportMissingTypeStubs": true,
-
-  "pythonVersion": "3.8",
-  "pythonPlatform": "Windows",
-
-  "executionEnvironments": [
-    {
-      "root": ".."
-    }
-  ]
-}

.github/type_check.py

@@ -1,15 +0,0 @@
-from pathlib import Path
-import subprocess
-
-config = Path(__file__).parent / "pyright-config.json"
-
-command = ("pyright", "-p", str(config))
-print(" ".join(command))
-
-try:
-    result = subprocess.run(command)
-except FileNotFoundError as e:
-    print(f"{e} - Is pyright installed?")
-    exit(1)
-
-exit(result.returncode)

.github/workflows/analyze-modified-files.yml

@@ -25,7 +25,7 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
 
       - name: "Determine modified files (pull_request)"
         if: github.event_name == 'pull_request'
@@ -50,7 +50,7 @@ jobs:
         run: |
           echo "diff=." >> $GITHUB_ENV
 
-      - uses: actions/setup-python@v5
+      - uses: actions/setup-python@v4
         if: env.diff != ''
         with:
           python-version: 3.8
@@ -71,7 +71,7 @@ jobs:
         continue-on-error: true
         if: env.diff != '' && matrix.task == 'flake8'
         run: |
-          flake8 --count --max-complexity=14 --max-doc-length=120 --max-line-length=120 --statistics ${{ env.diff }}
+          flake8 --count --max-complexity=10 --max-doc-length=120 --max-line-length=120 --statistics ${{ env.diff }}
 
       - name: "mypy: Type check modified files"
         continue-on-error: true

.github/workflows/build.yml

@@ -8,13 +8,11 @@ on:
       - '.github/workflows/build.yml'
       - 'setup.py'
       - 'requirements.txt'
-      - '*.iss'
   pull_request:
     paths:
       - '.github/workflows/build.yml'
       - 'setup.py'
       - 'requirements.txt'
-      - '*.iss'
   workflow_dispatch:
 
 env:
@@ -27,9 +25,9 @@ jobs:
   build-win-py38: # RCs will still be built and signed by hand
     runs-on: windows-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
       - name: Install python
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v4
         with:
           python-version: '3.8'
       - name: Download run-time dependencies
@@ -48,42 +46,25 @@ jobs:
           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: Store 7z
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
         with:
           name: ${{ env.ZIP_NAME }}
           path: dist/${{ env.ZIP_NAME }}
           retention-days: 7  # keep for 7 days, should be enough
-      - name: Build Setup
-        run: |
-          & "${env:ProgramFiles(x86)}\Inno Setup 6\iscc.exe" inno_setup.iss /DNO_SIGNTOOL
-          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
-      - name: Store Setup
-        uses: actions/upload-artifact@v4
-        with:
-          name: ${{ env.SETUP_NAME }}
-          path: setups/${{ env.SETUP_NAME }}
-          retention-days: 7  # keep for 7 days, should be enough
 
   build-ubuntu2004:
     runs-on: ubuntu-20.04
     steps:
       # - copy code below to release.yml -
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
       - name: Install base dependencies
         run: |
           sudo apt update
           sudo apt -y install build-essential p7zip xz-utils wget libglib2.0-0
           sudo apt -y install python3-gi libgirepository1.0-dev  # should pull dependencies for gi installation below
       - name: Get a recent python
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v4
         with:
           python-version: '3.11'
       - name: Install build-time dependencies
@@ -119,13 +100,13 @@ jobs:
           source venv/bin/activate
           python setup.py build_exe --yes
       - name: Store AppImage
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
         with:
           name: ${{ env.APPIMAGE_NAME }}
           path: dist/${{ env.APPIMAGE_NAME }}
           retention-days: 7
       - name: Store .tar.gz
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
         with:
           name: ${{ env.TAR_NAME }}
           path: dist/${{ env.TAR_NAME }}

.github/workflows/codeql-analysis.yml

@@ -43,7 +43,7 @@ jobs:
 
     steps:
     - name: Checkout repository
-      uses: actions/checkout@v4
+      uses: actions/checkout@v3
 
     # Initializes the CodeQL tools for scanning.
     - name: Initialize CodeQL

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

@@ -1,46 +0,0 @@
-name: Label Pull Request
-on:
-  pull_request_target:
-    types: ['opened', 'reopened', 'synchronize', 'ready_for_review', 'converted_to_draft', 'closed']
-    branches: ['main']
-permissions:
-  contents: read
-  pull-requests: write
-
-jobs:
-  labeler:
-    name: 'Apply content-based labels'
-    if: github.event.action == 'opened' || github.event.action == 'reopened' || github.event.action == 'synchronize'
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/labeler@v5
-        with:
-          sync-labels: false
-  peer_review:
-    name: 'Apply peer review label'
-    needs: labeler
-    if: >-
-      (github.event.action == 'opened' || github.event.action == 'reopened' || 
-      github.event.action == 'ready_for_review') && !github.event.pull_request.draft
-    runs-on: ubuntu-latest
-    steps:
-      - name: 'Add label'
-        run: "gh pr edit \"$PR_URL\" --add-label 'waiting-on: peer-review'"
-        env:
-          PR_URL: ${{ github.event.pull_request.html_url }}
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-  unblock_draft_prs:
-    name: 'Remove waiting-on labels'
-    needs: labeler
-    if: github.event.action == 'converted_to_draft' || github.event.action == 'closed'
-    runs-on: ubuntu-latest
-    steps:
-      - name: 'Remove labels'
-        run: |-
-          gh pr edit "$PR_URL" --remove-label 'waiting-on: peer-review' \
-            --remove-label 'waiting-on: core-review' \
-            --remove-label 'waiting-on: world-maintainer' \
-            --remove-label 'waiting-on: author'
-        env:
-          PR_URL: ${{ github.event.pull_request.html_url }}
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/release.yml

@@ -18,7 +18,7 @@ jobs:
       - name: Set env
         run: echo "RELEASE_VERSION=${GITHUB_REF#refs/*/}" >> $GITHUB_ENV  # tag x.y.z will become "Archipelago x.y.z"
       - name: Create Release
-        uses: softprops/action-gh-release@975c1b265e11dd76618af1c374e7981f9a6ff44a
+        uses: softprops/action-gh-release@b7e450da2a4b4cb4bfbae528f788167786cfcedf
         with:
           draft: true  # don't publish right away, especially since windows build is added by hand
           prerelease: false
@@ -35,14 +35,14 @@ jobs:
       - name: Set env
         run: echo "RELEASE_VERSION=${GITHUB_REF#refs/*/}" >> $GITHUB_ENV
       # - code below copied from build.yml -
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
       - name: Install base dependencies
         run: |
           sudo apt update
           sudo apt -y install build-essential p7zip xz-utils wget libglib2.0-0
           sudo apt -y install python3-gi libgirepository1.0-dev  # should pull dependencies for gi installation below
       - name: Get a recent python
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v4
         with:
           python-version: '3.11'
       - name: Install build-time dependencies
@@ -74,7 +74,7 @@ jobs:
           echo "TAR_NAME=$TAR_NAME" >> $GITHUB_ENV
       # - code above copied from build.yml -
       - name: Add to Release
-        uses: softprops/action-gh-release@975c1b265e11dd76618af1c374e7981f9a6ff44a
+        uses: softprops/action-gh-release@b7e450da2a4b4cb4bfbae528f788167786cfcedf
         with:
           draft: true  # see above
           prerelease: false

.github/workflows/scan-build.yml

@@ -1,65 +0,0 @@
-name: Native Code Static Analysis
-
-on:
-  push:
-    paths:
-      - '**.c'
-      - '**.cc'
-      - '**.cpp'
-      - '**.cxx'
-      - '**.h'
-      - '**.hh'
-      - '**.hpp'
-      - '**.pyx'
-      - 'setup.py'
-      - 'requirements.txt'
-      - '.github/workflows/scan-build.yml'
-  pull_request:
-    paths:
-      - '**.c'
-      - '**.cc'
-      - '**.cpp'
-      - '**.cxx'
-      - '**.h'
-      - '**.hh'
-      - '**.hpp'
-      - '**.pyx'
-      - 'setup.py'
-      - 'requirements.txt'
-      - '.github/workflows/scan-build.yml'
-
-jobs:
-  scan-build:
-    runs-on: ubuntu-latest
-
-    steps:
-    - uses: actions/checkout@v4
-      with:
-        submodules: recursive
-    - name: Install newer Clang
-      run: |
-        wget https://apt.llvm.org/llvm.sh
-        chmod +x ./llvm.sh
-        sudo ./llvm.sh 17
-    - name: Install scan-build command
-      run: |
-        sudo apt install clang-tools-17
-    - name: Get a recent python
-      uses: actions/setup-python@v5
-      with:
-        python-version: '3.11'
-    - name: Install dependencies
-      run: |
-        python -m venv venv
-        source venv/bin/activate
-        python -m pip install --upgrade pip -r requirements.txt
-    - name: scan-build
-      run: |
-        source venv/bin/activate
-        scan-build-17 --status-bugs -o scan-build-reports -disable-checker deadcode.DeadStores python setup.py build -y
-    - name: Store report
-      if: failure()
-      uses: actions/upload-artifact@v4
-      with:
-        name: scan-build-reports
-        path: scan-build-reports

.github/workflows/strict-type-check.yml

@@ -1,33 +0,0 @@
-name: type check
-
-on:
-  pull_request:
-    paths:
-      - "**.py"
-      - ".github/pyright-config.json"
-      - ".github/workflows/strict-type-check.yml"
-      - "**.pyi"
-  push:
-    paths:
-      - "**.py"
-      - ".github/pyright-config.json"
-      - ".github/workflows/strict-type-check.yml"
-      - "**.pyi"
-
-jobs:
-  pyright:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: actions/setup-python@v5
-        with:
-          python-version: "3.11"
-
-      - name: "Install dependencies"
-        run: |
-          python -m pip install --upgrade pip pyright==1.1.358
-          python ModuleUpdate.py --append "WebHostLib/requirements.txt" --force --yes
-
-      - name: "pyright: strict check on specific files"
-        run: python .github/type_check.py

.github/workflows/unittests.yml

@@ -46,9 +46,9 @@ jobs:
             os: macos-latest
 
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v3
     - name: Set up Python ${{ matrix.python.version }}
-      uses: actions/setup-python@v5
+      uses: actions/setup-python@v4
       with:
         python-version: ${{ matrix.python.version }}
     - name: Install dependencies

.run/Archipelago Unittests.run.xml

@@ -1,18 +0,0 @@
-<component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="Archipelago Unittests" type="tests" factoryName="Unittests">
-    <module name="Archipelago" />
-    <option name="INTERPRETER_OPTIONS" value="" />
-    <option name="PARENT_ENVS" value="true" />
-    <option name="SDK_HOME" value="" />
-    <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$" />
-    <option name="IS_MODULE_SDK" value="true" />
-    <option name="ADD_CONTENT_ROOTS" value="true" />
-    <option name="ADD_SOURCE_ROOTS" value="true" />
-    <EXTENSION ID="PythonCoverageRunConfigurationExtension" runner="coverage.py" />
-    <option name="_new_pattern" value="&quot;&quot;" />
-    <option name="_new_additionalArguments" value="&quot;&quot;" />
-    <option name="_new_target" value="&quot;$PROJECT_DIR$/test&quot;" />
-    <option name="_new_targetType" value="&quot;PATH&quot;" />
-    <method v="2" />
-  </configuration>
-</component>

BaseClasses.py

@@ -18,14 +18,11 @@ import NetUtils
 import Options
 import Utils
 
-if typing.TYPE_CHECKING:
-    from worlds import AutoWorld
-
 
 class Group(TypedDict, total=False):
     name: str
     game: str
-    world: "AutoWorld.World"
+    world: auto_world
     players: Set[int]
     item_pool: Set[str]
     replacement_items: Dict[int, Optional[str]]
@@ -51,10 +48,14 @@ class ThreadBarrierProxy:
 class MultiWorld():
     debug_types = False
     player_name: Dict[int, str]
+    difficulty_requirements: dict
+    required_medallions: dict
+    dark_room_logic: Dict[int, str]
+    restrict_dungeon_item_on_boss: Dict[int, bool]
     plando_texts: List[Dict[str, str]]
     plando_items: List[List[Dict[str, Any]]]
     plando_connections: List
-    worlds: Dict[int, "AutoWorld.World"]
+    worlds: Dict[int, auto_world]
     groups: Dict[int, Group]
     regions: RegionManager
     itempool: List[Item]
@@ -81,7 +82,7 @@ class MultiWorld():
     game: Dict[int, str]
 
     random: random.Random
-    per_slot_randoms: Utils.DeprecateDict[int, random.Random]
+    per_slot_randoms: Dict[int, random.Random]
     """Deprecated. Please use `self.random` instead."""
 
     class AttributeProxy():
@@ -106,14 +107,10 @@ class MultiWorld():
             return self
 
         def append(self, region: Region):
-            assert region.name not in self.region_cache[region.player], \
-                f"{region.name} already exists in region cache."
             self.region_cache[region.player][region.name] = region
 
         def extend(self, regions: Iterable[Region]):
             for region in regions:
-                assert region.name not in self.region_cache[region.player], \
-                    f"{region.name} already exists in region cache."
                 self.region_cache[region.player][region.name] = region
 
         def add_group(self, new_id: int):
@@ -133,6 +130,7 @@ class MultiWorld():
         self.random = ThreadBarrierProxy(random.Random())
         self.players = players
         self.player_types = {player: NetUtils.SlotType.player for player in self.player_ids}
+        self.glitch_triforce = False
         self.algorithm = 'balanced'
         self.groups = {}
         self.regions = self.RegionManager(players)
@@ -155,18 +153,64 @@ 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.fix_trock_doors = self.AttributeProxy(
+            lambda player: self.shuffle[player] != 'vanilla' or self.mode[player] == 'inverted')
+        self.fix_skullwoods_exit = self.AttributeProxy(
+            lambda player: self.shuffle[player] not in ['vanilla', 'simple', 'restricted', 'dungeonssimple'])
+        self.fix_palaceofdarkness_exit = self.AttributeProxy(
+            lambda player: self.shuffle[player] not in ['vanilla', 'simple', 'restricted', 'dungeonssimple'])
+        self.fix_trock_exit = self.AttributeProxy(
+            lambda player: self.shuffle[player] not in ['vanilla', 'simple', 'restricted', 'dungeonssimple'])
 
         for player in range(1, players + 1):
             def set_player_attr(attr, val):
                 self.__dict__.setdefault(attr, {})[player] = val
+
+            set_player_attr('shuffle', "vanilla")
+            set_player_attr('logic', "noglitches")
+            set_player_attr('mode', 'open')
+            set_player_attr('difficulty', 'normal')
+            set_player_attr('item_functionality', 'normal')
+            set_player_attr('timer', False)
+            set_player_attr('goal', 'ganon')
+            set_player_attr('required_medallions', ['Ether', 'Quake'])
+            set_player_attr('swamp_patch_required', False)
+            set_player_attr('powder_patch_required', False)
+            set_player_attr('ganon_at_pyramid', True)
+            set_player_attr('ganonstower_vanilla', True)
+            set_player_attr('can_access_trock_eyebridge', None)
+            set_player_attr('can_access_trock_front', None)
+            set_player_attr('can_access_trock_big_chest', None)
+            set_player_attr('can_access_trock_middle', None)
+            set_player_attr('fix_fake_world', True)
+            set_player_attr('difficulty_requirements', None)
+            set_player_attr('boss_shuffle', 'none')
+            set_player_attr('enemy_health', 'default')
+            set_player_attr('enemy_damage', 'default')
+            set_player_attr('beemizer_total_chance', 0)
+            set_player_attr('beemizer_trap_chance', 0)
+            set_player_attr('escape_assist', [])
+            set_player_attr('treasure_hunt_icon', 'Triforce Piece')
+            set_player_attr('treasure_hunt_count', 0)
+            set_player_attr('clock_mode', False)
+            set_player_attr('countdown_start_time', 10)
+            set_player_attr('red_clock_time', -2)
+            set_player_attr('blue_clock_time', 2)
+            set_player_attr('green_clock_time', 4)
+            set_player_attr('can_take_damage', True)
+            set_player_attr('triforce_pieces_available', 30)
+            set_player_attr('triforce_pieces_required', 20)
+            set_player_attr('shop_shuffle', 'off')
+            set_player_attr('shuffle_prizes', "g")
+            set_player_attr('sprite_pool', [])
+            set_player_attr('dark_room_logic', "lamp")
             set_player_attr('plando_items', [])
             set_player_attr('plando_texts', {})
             set_player_attr('plando_connections', [])
-            set_player_attr('game', "Archipelago")
+            set_player_attr('game', "A Link to the Past")
             set_player_attr('completion_condition', lambda state: True)
         self.worlds = {}
-        self.per_slot_randoms = Utils.DeprecateDict("Using per_slot_randoms is now deprecated. Please use the "
-                                                      "world's random object instead (usually self.random)")
+        self.per_slot_randoms = {}
         self.plando_options = PlandoOptions.none
 
     def get_all_ids(self) -> Tuple[int, ...]:
@@ -175,8 +219,6 @@ class MultiWorld():
     def add_group(self, name: str, game: str, players: Set[int] = frozenset()) -> Tuple[int, Group]:
         """Create a group with name and return the assigned player ID and group.
         If a group of this name already exists, the set of players is extended instead of creating a new one."""
-        from worlds import AutoWorld
-
         for group_id, group in self.groups.items():
             if group["name"] == name:
                 group["players"] |= players
@@ -200,18 +242,17 @@ class MultiWorld():
         return {group_id for group_id, group in self.groups.items() if player in group["players"]}
 
     def set_seed(self, seed: Optional[int] = None, secure: bool = False, name: Optional[str] = None):
-        assert not self.worlds, "seed needs to be initialized before Worlds"
         self.seed = get_seed(seed)
         if secure:
             self.secure()
         else:
             self.random.seed(self.seed)
         self.seed_name = name if name else str(self.seed)
+        self.per_slot_randoms = {player: random.Random(self.random.getrandbits(64)) for player in
+                                 range(1, self.players + 1)}
 
     def set_options(self, args: Namespace) -> None:
         # TODO - remove this section once all worlds use options dataclasses
-        from worlds import AutoWorld
-
         all_keys: Set[str] = {key for player in self.player_ids for key in
                               AutoWorld.AutoWorldRegister.world_types[self.game[player]].options_dataclass.type_hints}
         for option_key in all_keys:
@@ -223,13 +264,12 @@ class MultiWorld():
         for player in self.player_ids:
             world_type = AutoWorld.AutoWorldRegister.world_types[self.game[player]]
             self.worlds[player] = world_type(self, player)
+            self.worlds[player].random = self.per_slot_randoms[player]
             options_dataclass: typing.Type[Options.PerGameCommonOptions] = world_type.options_dataclass
             self.worlds[player].options = options_dataclass(**{option_key: getattr(args, option_key)[player]
                                                                for option_key in options_dataclass.type_hints})
 
     def set_item_links(self):
-        from worlds import AutoWorld
-
         item_links = {}
         replacement_prio = [False, True, None]
         for player in self.player_ids:
@@ -393,7 +433,7 @@ class MultiWorld():
         location.item = item
         item.location = location
         if collect:
-            self.state.collect(item, location.advancement, location)
+            self.state.collect(item, location.event, location)
 
         logging.debug('Placed %s at %s', item, location)
 
@@ -532,15 +572,15 @@ class MultiWorld():
 
         def location_condition(location: Location):
             """Determine if this location has to be accessible, location is already filtered by location_relevant"""
-            if location.player in players["locations"] or (location.item and location.item.player not in
-                                                           players["minimal"]):
-                return True
-            return False
+            if location.player in players["minimal"]:
+                return False
+            return True
 
         def location_relevant(location: Location):
             """Determine if this location is relevant to sweep."""
             if location.progress_type != LocationProgressType.EXCLUDED \
-               and (location.player in players["locations"] or location.advancement):
+                and (location.player in players["locations"] or location.event
+                     or (location.item and location.item.advancement)):
                 return True
             return False
 
@@ -663,29 +703,20 @@ class CollectionState():
             assert isinstance(player, int), "can_reach: player is required if spot is str"
             # try to resolve a name
             if resolution_hint == 'Location':
-                return self.can_reach_location(spot, player)
+                spot = self.multiworld.get_location(spot, player)
             elif resolution_hint == 'Entrance':
-                return self.can_reach_entrance(spot, player)
+                spot = self.multiworld.get_entrance(spot, player)
             else:
                 # default to Region
-                return self.can_reach_region(spot, player)
+                spot = self.multiworld.get_region(spot, player)
         return spot.can_reach(self)
 
-    def can_reach_location(self, spot: str, player: int) -> bool:
-        return self.multiworld.get_location(spot, player).can_reach(self)
-
-    def can_reach_entrance(self, spot: str, player: int) -> bool:
-        return self.multiworld.get_entrance(spot, player).can_reach(self)
-
-    def can_reach_region(self, spot: str, player: int) -> bool:
-        return self.multiworld.get_region(spot, player).can_reach(self)
-
     def sweep_for_events(self, key_only: bool = False, locations: Optional[Iterable[Location]] = None) -> None:
         if locations is None:
             locations = self.multiworld.get_filled_locations()
         reachable_events = True
         # since the loop has a good chance to run more than once, only filter the events once
-        locations = {location for location in locations if location.advancement and location not in self.events and
+        locations = {location for location in locations if location.event and location not in self.events and
                      not key_only or getattr(location.item, "locked_dungeon_item", False)}
         while reachable_events:
             reachable_events = {location for location in locations if location.can_reach(self)}
@@ -792,8 +823,8 @@ class Entrance:
         return self.__str__()
 
     def __str__(self):
-        multiworld = self.parent_region.multiworld if self.parent_region else None
-        return multiworld.get_name_string_for_object(self) if multiworld else f'{self.name} (Player {self.player})'
+        world = self.parent_region.multiworld if self.parent_region else None
+        return world.get_name_string_for_object(self) if world else f'{self.name} (Player {self.player})'
 
 
 class Region:
@@ -836,8 +867,6 @@ class Region:
             del(self.region_manager.location_cache[location.player][location.name])
 
         def insert(self, index: int, value: Location) -> None:
-            assert value.name not in self.region_manager.location_cache[value.player], \
-                f"{value.name} already exists in the location cache."
             self._list.insert(index, value)
             self.region_manager.location_cache[value.player][value.name] = value
 
@@ -848,8 +877,6 @@ class Region:
             del(self.region_manager.entrance_cache[entrance.player][entrance.name])
 
         def insert(self, index: int, value: Entrance) -> None:
-            assert value.name not in self.region_manager.entrance_cache[value.player], \
-                f"{value.name} already exists in the entrance cache."
             self._list.insert(index, value)
             self.region_manager.entrance_cache[value.player][value.name] = value
 
@@ -975,10 +1002,11 @@ class Location:
     name: str
     address: Optional[int]
     parent_region: Optional[Region]
+    event: bool = False
     locked: bool = False
     show_in_spoiler: bool = True
     progress_type: LocationProgressType = LocationProgressType.DEFAULT
-    always_allow = staticmethod(lambda state, item: False)
+    always_allow = staticmethod(lambda item, state: False)
     access_rule: Callable[[CollectionState], bool] = staticmethod(lambda state: True)
     item_rule = staticmethod(lambda item: True)
     item: Optional[Item] = None
@@ -1005,14 +1033,15 @@ class Location:
             raise Exception(f"Location {self} already filled.")
         self.item = item
         item.location = self
+        self.event = item.advancement
         self.locked = True
 
     def __repr__(self):
         return self.__str__()
 
     def __str__(self):
-        multiworld = self.parent_region.multiworld if self.parent_region and self.parent_region.multiworld else None
-        return multiworld.get_name_string_for_object(self) if multiworld else f'{self.name} (Player {self.player})'
+        world = self.parent_region.multiworld if self.parent_region and self.parent_region.multiworld else None
+        return world.get_name_string_for_object(self) if world else f'{self.name} (Player {self.player})'
 
     def __hash__(self):
         return hash((self.name, self.player))
@@ -1020,15 +1049,6 @@ class Location:
     def __lt__(self, other: Location):
         return (self.player, self.name) < (other.player, other.name)
 
-    @property
-    def advancement(self) -> bool:
-        return self.item is not None and self.item.advancement
-
-    @property
-    def is_event(self) -> bool:
-        """Returns True if the address of this location is None, denoting it is an Event Location."""
-        return self.address is None
-
     @property
     def native_item(self) -> bool:
         """Returns True if the item in this location matches game."""
@@ -1036,6 +1056,9 @@ class Location:
 
     @property
     def hint_text(self) -> str:
+        hint_text = getattr(self, "_hint_text", None)
+        if hint_text:
+            return hint_text
         return "at " + self.name.replace("_", " ").replace("-", " ")
 
 
@@ -1155,7 +1178,7 @@ class Spoiler:
                 {"player": player, "entrance": entrance, "exit": exit_, "direction": direction}
 
     def create_playthrough(self, create_paths: bool = True) -> None:
-        """Destructive to the multiworld while it is run, damage gets repaired afterwards."""
+        """Destructive to the world while it is run, damage gets repaired afterwards."""
         from itertools import chain
         # get locations containing progress items
         multiworld = self.multiworld
@@ -1242,12 +1265,12 @@ class Spoiler:
             for location in sphere:
                 state.collect(location.item, True, location)
 
+            required_locations -= sphere
+
             collection_spheres.append(sphere)
 
             logging.debug('Calculated final sphere %i, containing %i of %i progress items.', len(collection_spheres),
                           len(sphere), len(required_locations))
-
-            required_locations -= sphere
             if not sphere:
                 raise RuntimeError(f'Not all required items reachable. Unreachable locations: {required_locations}')
 
@@ -1306,15 +1329,10 @@ class Spoiler:
                             get_path(state, multiworld.get_region('Inverted Big Bomb Shop', player))
 
     def to_file(self, filename: str) -> None:
-        from itertools import chain
-        from worlds import AutoWorld
-        from Options import Visibility
-
         def write_option(option_key: str, option_obj: Options.AssembleOptions) -> None:
             res = getattr(self.multiworld.worlds[player].options, option_key)
-            if res.visibility & Visibility.spoiler:
-                display_name = getattr(option_obj, "display_name", option_key)
-                outfile.write(f"{display_name + ':':33}{res.current_option_name}\n")
+            display_name = getattr(option_obj, "display_name", option_key)
+            outfile.write(f"{display_name + ':':33}{res.current_option_name}\n")
 
         with open(filename, 'w', encoding="utf-8-sig") as outfile:
             outfile.write(
@@ -1345,14 +1363,6 @@ class Spoiler:
 
             AutoWorld.call_all(self.multiworld, "write_spoiler", outfile)
 
-            precollected_items = [f"{item.name} ({self.multiworld.get_player_name(item.player)})"
-                                  if self.multiworld.players > 1
-                                  else item.name
-                                  for item in chain.from_iterable(self.multiworld.precollected_items.values())]
-            if precollected_items:
-                outfile.write("\n\nStarting Items:\n\n")
-                outfile.write("\n".join([item for item in precollected_items]))
-
             locations = [(str(location), str(location.item) if location.item is not None else "Nothing")
                          for location in self.multiworld.get_locations() if location.show_in_spoiler]
             outfile.write('\n\nLocations:\n\n')
@@ -1442,3 +1452,8 @@ def get_seed(seed: Optional[int] = None) -> int:
         random.seed(None)
         return random.randint(0, pow(10, seeddigits) - 1)
     return seed
+
+
+from worlds import AutoWorld
+
+auto_world = AutoWorld.World

CommonClient.py

@@ -20,8 +20,8 @@ if __name__ == "__main__":
     Utils.init_logging("TextClient", exception_logger="Client")
 
 from MultiServer import CommandProcessor
-from NetUtils import (Endpoint, decode, NetworkItem, encode, JSONtoTextParser, ClientStatus, Permission, NetworkSlot,
-                      RawJSONtoTextParser, add_json_text, add_json_location, add_json_item, JSONTypes)
+from NetUtils import Endpoint, decode, NetworkItem, encode, JSONtoTextParser, \
+    ClientStatus, Permission, NetworkSlot, RawJSONtoTextParser
 from Utils import Version, stream_input, async_start
 from worlds import network_data_package, AutoWorldRegister
 import os
@@ -72,16 +72,9 @@ class ClientCommandProcessor(CommandProcessor):
 
     def _cmd_received(self) -> bool:
         """List all received items"""
-        item: NetworkItem
-        self.output(f'{len(self.ctx.items_received)} received items, sorted by time:')
+        self.output(f'{len(self.ctx.items_received)} received items:')
         for index, item in enumerate(self.ctx.items_received, 1):
-            parts = []
-            add_json_item(parts, item.item, self.ctx.slot, item.flags)
-            add_json_text(parts, " from ")
-            add_json_location(parts, item.location, item.player)
-            add_json_text(parts, " by ")
-            add_json_text(parts, item.player, type=JSONTypes.player_id)
-            self.ctx.on_print_json({"data": parts, "cmd": "PrintJSON"})
+            self.output(f"{self.ctx.item_names[item.item]} from {self.ctx.player_names[item.player]}")
         return True
 
     def _cmd_missing(self, filter_text = "") -> bool:
@@ -122,15 +115,6 @@ class ClientCommandProcessor(CommandProcessor):
         for item_name in AutoWorldRegister.world_types[self.ctx.game].item_name_to_id:
             self.output(item_name)
 
-    def _cmd_item_groups(self):
-        """List all item group names for the currently running game."""
-        if not self.ctx.game:
-            self.output("No game set, cannot determine existing item groups.")
-            return False
-        self.output(f"Item Group Names for {self.ctx.game}")
-        for group_name in AutoWorldRegister.world_types[self.ctx.game].item_name_groups:
-            self.output(group_name)
-
     def _cmd_locations(self):
         """List all location names for the currently running game."""
         if not self.ctx.game:
@@ -140,15 +124,6 @@ class ClientCommandProcessor(CommandProcessor):
         for location_name in AutoWorldRegister.world_types[self.ctx.game].location_name_to_id:
             self.output(location_name)
 
-    def _cmd_location_groups(self):
-        """List all location group names for the currently running game."""
-        if not self.ctx.game:
-            self.output("No game set, cannot determine existing location groups.")
-            return False
-        self.output(f"Location Group Names for {self.ctx.game}")
-        for group_name in AutoWorldRegister.world_types[self.ctx.game].location_name_groups:
-            self.output(group_name)
-
     def _cmd_ready(self):
         """Send ready status to server."""
         self.ctx.ready = not self.ctx.ready
@@ -193,7 +168,6 @@ class CommonContext:
     server_version: Version = Version(0, 0, 0)
     generator_version: Version = Version(0, 0, 0)
     current_energy_link_value: typing.Optional[int] = None  # to display in UI, gets set by server
-    max_size: int = 16*1024*1024  # 16 MB of max incoming packet size
 
     last_death_link: float = time.time()  # last send/received death link on AP layer
 
@@ -486,7 +460,7 @@ class CommonContext:
                 else:
                     self.update_game(cached_game)
         if needed_updates:
-            await self.send_msgs([{"cmd": "GetDataPackage", "games": [game_name]} for game_name in needed_updates])
+            await self.send_msgs([{"cmd": "GetDataPackage", "games": list(needed_updates)}])
 
     def update_game(self, game_package: dict):
         for item_name, item_id in game_package["item_name_to_id"].items():
@@ -503,7 +477,6 @@ class CommonContext:
         current_cache = Utils.persistent_load().get("datapackage", {}).get("games", {})
         current_cache.update(data_package["games"])
         Utils.persistent_store("datapackage", "games", current_cache)
-        logger.info(f"Got new ID/Name DataPackage for {', '.join(data_package['games'])}")
         for game, game_data in data_package["games"].items():
             Utils.store_data_package_for_checksum(game, game_data)
 
@@ -644,16 +617,15 @@ async def server_loop(ctx: CommonContext, address: typing.Optional[str] = None)
         ctx.username = server_url.username
     if server_url.password:
         ctx.password = server_url.password
+    port = server_url.port or 38281
 
     def reconnect_hint() -> str:
         return ", type /connect to reconnect" if ctx.server_address else ""
 
     logger.info(f'Connecting to Archipelago server at {address}')
     try:
-        port = server_url.port or 38281  # raises ValueError if invalid
         socket = await websockets.connect(address, port=port, ping_timeout=None, ping_interval=None,
-                                          ssl=get_ssl_context() if address.startswith("wss://") else None,
-                                          max_size=ctx.max_size)
+                                          ssl=get_ssl_context() if address.startswith("wss://") else None)
         if ctx.ui is not None:
             ctx.ui.update_address_bar(server_url.netloc)
         ctx.server = Endpoint(socket)
@@ -755,15 +727,14 @@ async def process_server_cmd(ctx: CommonContext, args: dict):
             await ctx.server_auth(args['password'])
 
     elif cmd == 'DataPackage':
+        logger.info("Got new ID/Name DataPackage")
         ctx.consume_network_data_package(args['data'])
 
     elif cmd == 'ConnectionRefused':
         errors = args["errors"]
         if 'InvalidSlot' in errors:
-            ctx.disconnected_intentionally = True
             ctx.event_invalid_slot()
         elif 'InvalidGame' in errors:
-            ctx.disconnected_intentionally = True
             ctx.event_invalid_game()
         elif 'IncompatibleVersion' in errors:
             raise Exception('Server reported your client version as incompatible. '
@@ -970,5 +941,4 @@ def run_as_textclient():
 
 
 if __name__ == '__main__':
-    logging.getLogger().setLevel(logging.INFO)  # force log-level to work around log level resetting to WARNING
     run_as_textclient()

Fill.py

@@ -27,12 +27,12 @@ def sweep_from_pool(base_state: CollectionState, itempool: typing.Sequence[Item]
     return new_state
 
 
-def fill_restrictive(multiworld: MultiWorld, base_state: CollectionState, locations: typing.List[Location],
+def fill_restrictive(world: MultiWorld, base_state: CollectionState, locations: typing.List[Location],
                      item_pool: typing.List[Item], single_player_placement: bool = False, lock: bool = False,
                      swap: bool = True, on_place: typing.Optional[typing.Callable[[Location], None]] = None,
                      allow_partial: bool = False, allow_excluded: bool = False, name: str = "Unknown") -> None:
     """
-    :param multiworld: Multiworld to be filled.
+    :param world: Multiworld to be filled.
     :param base_state: State assumed before fill.
     :param locations: Locations to be filled with item_pool
     :param item_pool: Items to fill into the locations
@@ -68,7 +68,7 @@ def fill_restrictive(multiworld: MultiWorld, base_state: CollectionState, locati
         maximum_exploration_state = sweep_from_pool(
             base_state, item_pool + unplaced_items)
 
-        has_beaten_game = multiworld.has_beaten_game(maximum_exploration_state)
+        has_beaten_game = world.has_beaten_game(maximum_exploration_state)
 
         while items_to_place:
             # if we have run out of locations to fill,break out of this loop
@@ -80,8 +80,8 @@ def fill_restrictive(multiworld: MultiWorld, base_state: CollectionState, locati
             spot_to_fill: typing.Optional[Location] = None
 
             # 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,
+            if world.worlds[item_to_place.player].options.accessibility == Accessibility.option_minimal:
+                perform_access_check = not world.has_beaten_game(maximum_exploration_state,
                                                                  item_to_place.player) \
                     if single_player_placement else not has_beaten_game
             else:
@@ -122,11 +122,11 @@ def fill_restrictive(multiworld: MultiWorld, base_state: CollectionState, locati
                             # 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))
+                                world.get_reachable_locations(prev_state))
 
                             swap_state.collect(item_to_place, True)
                             new_loc_count = len(
-                                multiworld.get_reachable_locations(swap_state))
+                                world.get_reachable_locations(swap_state))
 
                             if new_loc_count >= prev_loc_count:
                                 # Add this item to the existing placement, and
@@ -156,9 +156,10 @@ def fill_restrictive(multiworld: MultiWorld, base_state: CollectionState, locati
                 else:
                     unplaced_items.append(item_to_place)
                     continue
-            multiworld.push_item(spot_to_fill, item_to_place, False)
+            world.push_item(spot_to_fill, item_to_place, False)
             spot_to_fill.locked = lock
             placements.append(spot_to_fill)
+            spot_to_fill.event = item_to_place.advancement
             placed += 1
             if not placed % 1000:
                 _log_fill_progress(name, placed, total)
@@ -172,7 +173,7 @@ def fill_restrictive(multiworld: MultiWorld, base_state: CollectionState, locati
         # validate all placements and remove invalid ones
         state = sweep_from_pool(base_state, [])
         for placement in placements:
-            if multiworld.worlds[placement.item.player].options.accessibility != "minimal" and not placement.can_reach(state):
+            if world.accessibility[placement.item.player] != "minimal" and not placement.can_reach(state):
                 placement.item.location = None
                 unplaced_items.append(placement.item)
                 placement.item = None
@@ -187,7 +188,7 @@ def fill_restrictive(multiworld: MultiWorld, base_state: CollectionState, locati
         if excluded_locations:
             for location in excluded_locations:
                 location.progress_type = location.progress_type.DEFAULT
-            fill_restrictive(multiworld, base_state, excluded_locations, unplaced_items, single_player_placement, lock,
+            fill_restrictive(world, base_state, excluded_locations, unplaced_items, single_player_placement, lock,
                              swap, on_place, allow_partial, False)
             for location in excluded_locations:
                 if not location.item:
@@ -195,26 +196,19 @@ def fill_restrictive(multiworld: MultiWorld, base_state: CollectionState, locati
 
     if not allow_partial and len(unplaced_items) > 0 and len(locations) > 0:
         # There are leftover unplaceable items and locations that won't accept them
-        if multiworld.can_beat_game():
+        if world.can_beat_game():
             logging.warning(
-                f"Not all items placed. Game beatable anyway.\nCould not place:\n"
-                f"{', '.join(str(item) for item in unplaced_items)}")
+                f'Not all items placed. Game beatable anyway. (Could not place {unplaced_items})')
         else:
-            raise FillError(f"No more spots to place {len(unplaced_items)} items. Remaining locations are invalid.\n"
-                            f"Unplaced items:\n"
-                            f"{', '.join(str(item) for item in unplaced_items)}\n"
-                            f"Unfilled locations:\n"
-                            f"{', '.join(str(location) for location in locations)}\n"
-                            f"Already placed {len(placements)}:\n"
-                            f"{', '.join(str(place) for place in placements)}")
+            raise FillError(f'No more spots to place {unplaced_items}, locations {locations} are invalid. '
+                            f'Already placed {len(placements)}: {", ".join(str(place) for place in placements)}')
 
     item_pool.extend(unplaced_items)
 
 
-def remaining_fill(multiworld: MultiWorld,
+def remaining_fill(world: MultiWorld,
                    locations: typing.List[Location],
-                   itempool: typing.List[Item],
-                   name: str = "Remaining") -> None:
+                   itempool: typing.List[Item]) -> None:
     unplaced_items: typing.List[Item] = []
     placements: typing.List[Location] = []
     swapped_items: typing.Counter[typing.Tuple[int, str]] = Counter()
@@ -267,41 +261,36 @@ def remaining_fill(multiworld: MultiWorld,
                 unplaced_items.append(item_to_place)
                 continue
 
-        multiworld.push_item(spot_to_fill, item_to_place, False)
+        world.push_item(spot_to_fill, item_to_place, False)
         placements.append(spot_to_fill)
         placed += 1
         if not placed % 1000:
-            _log_fill_progress(name, placed, total)
+            _log_fill_progress("Remaining", placed, total)
 
     if total > 1000:
-        _log_fill_progress(name, placed, total)
+        _log_fill_progress("Remaining", placed, total)
 
     if unplaced_items and locations:
         # There are leftover unplaceable items and locations that won't accept them
-        raise FillError(f"No more spots to place {len(unplaced_items)} items. Remaining locations are invalid.\n"
-                        f"Unplaced items:\n"
-                        f"{', '.join(str(item) for item in unplaced_items)}\n"
-                        f"Unfilled locations:\n"
-                        f"{', '.join(str(location) for location in locations)}\n"
-                        f"Already placed {len(placements)}:\n"
-                        f"{', '.join(str(place) for place in placements)}")
+        raise FillError(f'No more spots to place {unplaced_items}, locations {locations} are invalid. '
+                        f'Already placed {len(placements)}: {", ".join(str(place) for place in placements)}')
 
     itempool.extend(unplaced_items)
 
 
-def fast_fill(multiworld: MultiWorld,
+def fast_fill(world: MultiWorld,
               item_pool: typing.List[Item],
               fill_locations: typing.List[Location]) -> typing.Tuple[typing.List[Item], typing.List[Location]]:
     placing = min(len(item_pool), len(fill_locations))
     for item, location in zip(item_pool, fill_locations):
-        multiworld.push_item(location, item, False)
+        world.push_item(location, item, False)
     return item_pool[placing:], fill_locations[placing:]
 
 
-def accessibility_corrections(multiworld: MultiWorld, state: CollectionState, locations, pool=[]):
+def accessibility_corrections(world: 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 world.player_ids if world.worlds[player].options.accessibility == "minimal"}
+    unreachable_locations = [location for location in world.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
@@ -309,41 +298,42 @@ def accessibility_corrections(multiworld: MultiWorld, state: CollectionState, lo
             pool.append(location.item)
             state.remove(location.item)
             location.item = None
+            location.event = False
             if location in state.events:
                 state.events.remove(location)
             locations.append(location)
     if pool and locations:
         locations.sort(key=lambda loc: loc.progress_type != LocationProgressType.PRIORITY)
-        fill_restrictive(multiworld, state, locations, pool, name="Accessibility Corrections")
+        fill_restrictive(world, state, locations, pool, name="Accessibility Corrections")
 
 
-def inaccessible_location_rules(multiworld: MultiWorld, state: CollectionState, locations):
+def inaccessible_location_rules(world: MultiWorld, state: CollectionState, locations):
     maximum_exploration_state = sweep_from_pool(state)
     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 world.worlds[item.player].options.accessibility != 'minimal')
 
         for location in unreachable_locations:
             add_item_rule(location, forbid_important_item_rule)
 
 
-def distribute_early_items(multiworld: MultiWorld,
+def distribute_early_items(world: MultiWorld,
                            fill_locations: typing.List[Location],
                            itempool: typing.List[Item]) -> typing.Tuple[typing.List[Location], typing.List[Item]]:
     """ returns new fill_locations and itempool """
     early_items_count: typing.Dict[typing.Tuple[str, int], typing.List[int]] = {}
-    for player in multiworld.player_ids:
-        items = itertools.chain(multiworld.early_items[player], multiworld.local_early_items[player])
+    for player in world.player_ids:
+        items = itertools.chain(world.early_items[player], world.local_early_items[player])
         for item in items:
-            early_items_count[item, player] = [multiworld.early_items[player].get(item, 0),
-                                               multiworld.local_early_items[player].get(item, 0)]
+            early_items_count[item, player] = [world.early_items[player].get(item, 0),
+                                               world.local_early_items[player].get(item, 0)]
     if early_items_count:
         early_locations: typing.List[Location] = []
         early_priority_locations: typing.List[Location] = []
         loc_indexes_to_remove: typing.Set[int] = set()
-        base_state = multiworld.state.copy()
-        base_state.sweep_for_events(locations=(loc for loc in multiworld.get_filled_locations() if loc.address is None))
+        base_state = world.state.copy()
+        base_state.sweep_for_events(locations=(loc for loc in world.get_filled_locations() if loc.address is None))
         for i, loc in enumerate(fill_locations):
             if loc.can_reach(base_state):
                 if loc.progress_type == LocationProgressType.PRIORITY:
@@ -355,8 +345,8 @@ def distribute_early_items(multiworld: MultiWorld,
 
         early_prog_items: typing.List[Item] = []
         early_rest_items: typing.List[Item] = []
-        early_local_prog_items: typing.Dict[int, typing.List[Item]] = {player: [] for player in multiworld.player_ids}
-        early_local_rest_items: typing.Dict[int, typing.List[Item]] = {player: [] for player in multiworld.player_ids}
+        early_local_prog_items: typing.Dict[int, typing.List[Item]] = {player: [] for player in world.player_ids}
+        early_local_rest_items: typing.Dict[int, typing.List[Item]] = {player: [] for player in world.player_ids}
         item_indexes_to_remove: typing.Set[int] = set()
         for i, item in enumerate(itempool):
             if (item.name, item.player) in early_items_count:
@@ -380,28 +370,28 @@ def distribute_early_items(multiworld: MultiWorld,
                     if len(early_items_count) == 0:
                         break
         itempool = [item for i, item in enumerate(itempool) if i not in item_indexes_to_remove]
-        for player in multiworld.player_ids:
+        for player in world.player_ids:
             player_local = early_local_rest_items[player]
-            fill_restrictive(multiworld, base_state,
+            fill_restrictive(world, base_state,
                              [loc for loc in early_locations if loc.player == player],
                              player_local, lock=True, allow_partial=True, name=f"Local Early Items P{player}")
             if player_local:
                 logging.warning(f"Could not fulfill rules of early items: {player_local}")
                 early_rest_items.extend(early_local_rest_items[player])
         early_locations = [loc for loc in early_locations if not loc.item]
-        fill_restrictive(multiworld, base_state, early_locations, early_rest_items, lock=True, allow_partial=True,
+        fill_restrictive(world, base_state, early_locations, early_rest_items, lock=True, allow_partial=True,
                          name="Early Items")
         early_locations += early_priority_locations
-        for player in multiworld.player_ids:
+        for player in world.player_ids:
             player_local = early_local_prog_items[player]
-            fill_restrictive(multiworld, base_state,
+            fill_restrictive(world, base_state,
                              [loc for loc in early_locations if loc.player == player],
                              player_local, lock=True, allow_partial=True, name=f"Local Early Progression P{player}")
             if player_local:
                 logging.warning(f"Could not fulfill rules of early items: {player_local}")
                 early_prog_items.extend(player_local)
         early_locations = [loc for loc in early_locations if not loc.item]
-        fill_restrictive(multiworld, base_state, early_locations, early_prog_items, lock=True, allow_partial=True,
+        fill_restrictive(world, base_state, early_locations, early_prog_items, lock=True, allow_partial=True,
                          name="Early Progression")
         unplaced_early_items = early_rest_items + early_prog_items
         if unplaced_early_items:
@@ -410,18 +400,18 @@ def distribute_early_items(multiworld: MultiWorld,
             itempool += unplaced_early_items
 
         fill_locations.extend(early_locations)
-        multiworld.random.shuffle(fill_locations)
+        world.random.shuffle(fill_locations)
     return fill_locations, itempool
 
 
-def distribute_items_restrictive(multiworld: MultiWorld) -> None:
-    fill_locations = sorted(multiworld.get_unfilled_locations())
-    multiworld.random.shuffle(fill_locations)
+def distribute_items_restrictive(world: MultiWorld) -> None:
+    fill_locations = sorted(world.get_unfilled_locations())
+    world.random.shuffle(fill_locations)
     # get items to distribute
-    itempool = sorted(multiworld.itempool)
-    multiworld.random.shuffle(itempool)
+    itempool = sorted(world.itempool)
+    world.random.shuffle(itempool)
 
-    fill_locations, itempool = distribute_early_items(multiworld, fill_locations, itempool)
+    fill_locations, itempool = distribute_early_items(world, fill_locations, itempool)
 
     progitempool: typing.List[Item] = []
     usefulitempool: typing.List[Item] = []
@@ -435,7 +425,7 @@ def distribute_items_restrictive(multiworld: MultiWorld) -> None:
         else:
             filleritempool.append(item)
 
-    call_all(multiworld, "fill_hook", progitempool, usefulitempool, filleritempool, fill_locations)
+    call_all(world, "fill_hook", progitempool, usefulitempool, filleritempool, fill_locations)
 
     locations: typing.Dict[LocationProgressType, typing.List[Location]] = {
         loc_type: [] for loc_type in LocationProgressType}
@@ -456,78 +446,75 @@ def distribute_items_restrictive(multiworld: MultiWorld) -> None:
 
     if prioritylocations:
         # "priority fill"
-        fill_restrictive(multiworld, multiworld.state, prioritylocations, progitempool, swap=False, on_place=mark_for_locking,
+        fill_restrictive(world, world.state, prioritylocations, progitempool, swap=False, on_place=mark_for_locking,
                          name="Priority")
-        accessibility_corrections(multiworld, multiworld.state, prioritylocations, progitempool)
+        accessibility_corrections(world, world.state, prioritylocations, progitempool)
         defaultlocations = prioritylocations + defaultlocations
 
     if progitempool:
         # "advancement/progression fill"
-        fill_restrictive(multiworld, multiworld.state, defaultlocations, progitempool, name="Progression")
+        fill_restrictive(world, world.state, defaultlocations, progitempool, name="Progression")
         if progitempool:
             raise FillError(
-                f"Not enough locations for progression items. "
-                f"There are {len(progitempool)} more progression items than there are available locations."
-            )
-        accessibility_corrections(multiworld, multiworld.state, defaultlocations)
+                f'Not enough locations for progress items. There are {len(progitempool)} more items than locations')
+        accessibility_corrections(world, world.state, defaultlocations)
 
     for location in lock_later:
         if location.item:
             location.locked = True
     del mark_for_locking, lock_later
 
-    inaccessible_location_rules(multiworld, multiworld.state, defaultlocations)
+    inaccessible_location_rules(world, world.state, defaultlocations)
 
-    remaining_fill(multiworld, excludedlocations, filleritempool, "Remaining Excluded")
+    remaining_fill(world, excludedlocations, filleritempool)
     if excludedlocations:
         raise FillError(
-            f"Not enough filler items for excluded locations. "
-            f"There are {len(excludedlocations)} more excluded locations than filler or trap items."
-        )
+            f"Not enough filler items for excluded locations. There are {len(excludedlocations)} more locations than items")
 
     restitempool = filleritempool + usefulitempool
 
-    remaining_fill(multiworld, defaultlocations, restitempool)
+    remaining_fill(world, defaultlocations, restitempool)
 
     unplaced = restitempool
     unfilled = defaultlocations
 
     if unplaced or unfilled:
         logging.warning(
-            f"Unplaced items({len(unplaced)}): {unplaced} - Unfilled Locations({len(unfilled)}): {unfilled}")
-        items_counter = Counter(location.item.player for location in multiworld.get_filled_locations())
-        locations_counter = Counter(location.player for location in multiworld.get_locations())
+            f'Unplaced items({len(unplaced)}): {unplaced} - Unfilled Locations({len(unfilled)}): {unfilled}')
+        items_counter = Counter(location.item.player for location in world.get_locations() if location.item)
+        locations_counter = Counter(location.player for location in world.get_locations())
         items_counter.update(item.player for item in unplaced)
+        locations_counter.update(location.player for location in unfilled)
         print_data = {"items": items_counter, "locations": locations_counter}
-        logging.info(f"Per-Player counts: {print_data})")
+        logging.info(f'Per-Player counts: {print_data})')
 
 
-def flood_items(multiworld: MultiWorld) -> None:
+def flood_items(world: MultiWorld) -> None:
     # get items to distribute
-    multiworld.random.shuffle(multiworld.itempool)
-    itempool = multiworld.itempool
+    world.random.shuffle(world.itempool)
+    itempool = world.itempool
     progress_done = False
 
     # sweep once to pick up preplaced items
-    multiworld.state.sweep_for_events()
+    world.state.sweep_for_events()
 
-    # fill multiworld from top of itempool while we can
+    # fill world from top of itempool while we can
     while not progress_done:
-        location_list = multiworld.get_unfilled_locations()
-        multiworld.random.shuffle(location_list)
+        location_list = world.get_unfilled_locations()
+        world.random.shuffle(location_list)
         spot_to_fill = None
         for location in location_list:
-            if location.can_fill(multiworld.state, itempool[0]):
+            if location.can_fill(world.state, itempool[0]):
                 spot_to_fill = location
                 break
 
         if spot_to_fill:
             item = itempool.pop(0)
-            multiworld.push_item(spot_to_fill, item, True)
+            world.push_item(spot_to_fill, item, True)
             continue
 
         # ran out of spots, check if we need to step in and correct things
-        if len(multiworld.get_reachable_locations()) == len(multiworld.get_locations()):
+        if len(world.get_reachable_locations()) == len(world.get_locations()):
             progress_done = True
             continue
 
@@ -537,7 +524,7 @@ def flood_items(multiworld: MultiWorld) -> None:
         for item in itempool:
             if item.advancement:
                 candidate_item_to_place = item
-                if multiworld.unlocks_new_location(item):
+                if world.unlocks_new_location(item):
                     item_to_place = item
                     break
 
@@ -550,15 +537,15 @@ def flood_items(multiworld: MultiWorld) -> None:
                 raise FillError('No more progress items left to place.')
 
         # find item to replace with progress item
-        location_list = multiworld.get_reachable_locations()
-        multiworld.random.shuffle(location_list)
+        location_list = world.get_reachable_locations()
+        world.random.shuffle(location_list)
         for location in location_list:
             if location.item is not None and not location.item.advancement:
                 # safe to replace
                 replace_item = location.item
                 replace_item.location = None
                 itempool.append(replace_item)
-                multiworld.push_item(location, item_to_place, True)
+                world.push_item(location, item_to_place, True)
                 itempool.remove(item_to_place)
                 break
 
@@ -656,7 +643,7 @@ def balance_multiworld_progression(multiworld: MultiWorld) -> None:
                     while True:
                         # Check locations in the current sphere and gather progression items to swap earlier
                         for location in balancing_sphere:
-                            if location.advancement:
+                            if location.event:
                                 balancing_state.collect(location.item, True, location)
                                 player = location.item.player
                                 # only replace items that end up in another player's world
@@ -713,7 +700,7 @@ def balance_multiworld_progression(multiworld: MultiWorld) -> None:
 
                     # sort then shuffle to maintain deterministic behaviour,
                     # while allowing use of set for better algorithm growth behaviour elsewhere
-                    replacement_locations = sorted(l for l in checked_locations if not l.advancement and not l.locked)
+                    replacement_locations = sorted(l for l in checked_locations if not l.event and not l.locked)
                     multiworld.random.shuffle(replacement_locations)
                     items_to_replace.sort()
                     multiworld.random.shuffle(items_to_replace)
@@ -744,7 +731,7 @@ def balance_multiworld_progression(multiworld: MultiWorld) -> None:
                             sphere_locations.add(location)
 
             for location in sphere_locations:
-                if location.advancement:
+                if location.event:
                     state.collect(location.item, True, location)
             checked_locations |= sphere_locations
 
@@ -765,9 +752,10 @@ def swap_location_item(location_1: Location, location_2: Location, check_locked:
     location_2.item, location_1.item = location_1.item, location_2.item
     location_1.item.location = location_1
     location_2.item.location = location_2
+    location_1.event, location_2.event = location_2.event, location_1.event
 
 
-def distribute_planned(multiworld: MultiWorld) -> None:
+def distribute_planned(world: 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}')
@@ -780,24 +768,24 @@ def distribute_planned(multiworld: MultiWorld) -> None:
         else:
             warn(warning, force)
 
-    swept_state = multiworld.state.copy()
+    swept_state = world.state.copy()
     swept_state.sweep_for_events()
-    reachable = frozenset(multiworld.get_reachable_locations(swept_state))
+    reachable = frozenset(world.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():
+    for loc in world.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
+    world_name_lookup = world.world_name_lookup
 
     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)
+    player_ids = set(world.player_ids)
     for player in player_ids:
-        for block in multiworld.plando_items[player]:
+        for block in world.plando_items[player]:
             block['player'] = player
             if 'force' not in block:
                 block['force'] = 'silent'
@@ -811,12 +799,12 @@ def distribute_planned(multiworld: MultiWorld) -> None:
             else:
                 target_world = block['world']
 
-            if target_world is False or multiworld.players == 1:  # target own world
+            if target_world is False or world.players == 1:  # target own world
                 worlds: typing.Set[int] = {player}
             elif target_world is True:  # target any worlds besides own
-                worlds = set(multiworld.player_ids) - {player}
+                worlds = set(world.player_ids) - {player}
             elif target_world is None:  # target all worlds
-                worlds = set(multiworld.player_ids)
+                worlds = set(world.player_ids)
             elif type(target_world) == list:  # list of target worlds
                 worlds = set()
                 for listed_world in target_world:
@@ -826,9 +814,9 @@ def distribute_planned(multiworld: MultiWorld) -> None:
                         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):
+                if target_world not in range(1, world.players + 1):
                     failed(
-                        f"Cannot place item in world {target_world} as it is not in range of (1, {multiworld.players})",
+                        f"Cannot place item in world {target_world} as it is not in range of (1, {world.players})",
                         block['force'])
                     continue
                 worlds = {target_world}
@@ -856,7 +844,7 @@ def distribute_planned(multiworld: MultiWorld) -> None:
                 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))
+                        value = world.itempool.count(world.worlds[player].create_item(key))
                     item_list += [key] * value
                 items = item_list
             if isinstance(items, str):
@@ -906,17 +894,17 @@ def distribute_planned(multiworld: MultiWorld) -> None:
                 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'])
+            block['count']['target'] = world.random.randint(block['count']['min'], block['count']['max'])
 
             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)
+    world.random.shuffle(plando_blocks)
     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']))
+                                          else len(world.get_unfilled_locations(player)) - block['count']['target']))
 
     for placement in plando_blocks:
         player = placement['player']
@@ -927,19 +915,19 @@ def distribute_planned(multiworld: MultiWorld) -> None:
             maxcount = placement['count']['target']
             from_pool = placement['from_pool']
 
-            candidates = list(multiworld.get_unfilled_locations_for_players(locations, sorted(worlds)))
-            multiworld.random.shuffle(candidates)
-            multiworld.random.shuffle(items)
+            candidates = list(world.get_unfilled_locations_for_players(locations, sorted(worlds)))
+            world.random.shuffle(candidates)
+            world.random.shuffle(items)
             count = 0
             err: typing.List[str] = []
             successful_pairs: typing.List[typing.Tuple[Item, Location]] = []
             for item_name in items:
-                item = multiworld.worlds[player].create_item(item_name)
+                item = world.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):
+                                if location.can_fill(world.state, item, False):
                                     successful_pairs.append((item, location))
                                     candidates.remove(location)
                                     count = count + 1
@@ -957,20 +945,21 @@ def distribute_planned(multiworld: MultiWorld) -> None:
             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)}",
+                    f"Plando block failed to place {m - count} of {m} item(s) for {world.player_name[player]}, error(s): {' '.join(err)}",
                     placement['force'])
             for (item, location) in successful_pairs:
-                multiworld.push_item(location, item, collect=False)
+                world.push_item(location, item, collect=False)
+                location.event = True  # flag location to be checked during fill
                 location.locked = True
                 logging.debug(f"Plando placed {item} at {location}")
                 if from_pool:
                     try:
-                        multiworld.itempool.remove(item)
+                        world.itempool.remove(item)
                     except ValueError:
                         warn(
-                            f"Could not remove {item} from pool for {multiworld.player_name[player]} as it's already missing from it.",
+                            f"Could not remove {item} from pool for {world.player_name[player]} as it's already missing from it.",
                             placement['force'])
 
         except Exception as e:
             raise Exception(
-                f"Error running plando for player {player} ({multiworld.player_name[player]})") from e
+                f"Error running plando for player {player} ({world.player_name[player]})") from e

Generate.py

@@ -21,11 +21,11 @@ from BaseClasses import seeddigits, get_seed, PlandoOptions
 from Main import main as ERmain
 from settings import get_settings
 from Utils import parse_yamls, version_tuple, __version__, tuplize_version
+from worlds.alttp import Options as LttPOptions
 from worlds.alttp.EntranceRandomizer import parse_arguments
 from worlds.alttp.Text import TextTable
 from worlds.AutoWorld import AutoWorldRegister
 from worlds.generic import PlandoConnection
-from worlds import failed_world_loads
 
 
 def mystery_argparse():
@@ -34,8 +34,8 @@ def mystery_argparse():
 
     parser = argparse.ArgumentParser(description="CMD Generation Interface, defaults come from host.yaml.")
     parser.add_argument('--weights_file_path', default=defaults.weights_file_path,
-                        help='Path to the weights file to use for rolling game options, urls are also valid')
-    parser.add_argument('--sameoptions', help='Rolls options per weights file rather than per player',
+                        help='Path to the weights file to use for rolling game settings, urls are also valid')
+    parser.add_argument('--samesettings', help='Rolls settings per weights file rather than per player',
                         action='store_true')
     parser.add_argument('--player_files_path', default=defaults.player_files_path,
                         help="Input directory for player files.")
@@ -103,8 +103,8 @@ def main(args=None, callback=ERmain):
             del(meta_weights["meta_description"])
         except Exception as e:
             raise ValueError("No meta description found for meta.yaml. Unable to verify.") from e
-        if args.sameoptions:
-            raise Exception("Cannot mix --sameoptions with --meta")
+        if args.samesettings:
+            raise Exception("Cannot mix --samesettings with --meta")
     else:
         meta_weights = None
     player_id = 1
@@ -147,6 +147,7 @@ def main(args=None, callback=ERmain):
     erargs = parse_arguments(['--multi', str(args.multi)])
     erargs.seed = seed
     erargs.plando_options = args.plando
+    erargs.glitch_triforce = options.generator.glitch_triforce_room
     erargs.spoiler = args.spoiler
     erargs.race = args.race
     erargs.outputname = seed_name
@@ -155,7 +156,7 @@ def main(args=None, callback=ERmain):
     erargs.skip_output = args.skip_output
 
     settings_cache: Dict[str, Tuple[argparse.Namespace, ...]] = \
-        {fname: (tuple(roll_settings(yaml, args.plando) for yaml in yamls) if args.sameoptions else None)
+        {fname: (tuple(roll_settings(yaml, args.plando) for yaml in yamls) if args.samesettings else None)
          for fname, yamls in weights_cache.items()}
 
     if meta_weights:
@@ -301,43 +302,46 @@ def handle_name(name: str, player: int, name_counter: Counter):
                                                                  NUMBER=(number if number > 1 else ''),
                                                                  player=player,
                                                                  PLAYER=(player if player > 1 else '')))
-    # Run .strip twice for edge case where after the initial .slice new_name has a leading whitespace.
-    # Could cause issues for some clients that cannot handle the additional whitespace.
-    new_name = new_name.strip()[:16].strip()
+    new_name = new_name.strip()[:16]
     if new_name == "Archipelago":
         raise Exception(f"You cannot name yourself \"{new_name}\"")
     return new_name
 
 
+def prefer_int(input_data: str) -> Union[str, int]:
+    try:
+        return int(input_data)
+    except:
+        return input_data
+
+
+goals = {
+    'ganon': 'ganon',
+    'crystals': 'crystals',
+    'bosses': 'bosses',
+    'pedestal': 'pedestal',
+    'ganon_pedestal': 'ganonpedestal',
+    'triforce_hunt': 'triforcehunt',
+    'local_triforce_hunt': 'localtriforcehunt',
+    'ganon_triforce_hunt': 'ganontriforcehunt',
+    'local_ganon_triforce_hunt': 'localganontriforcehunt',
+    'ice_rod_hunt': 'icerodhunt',
+}
+
+
 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:
+def update_weights(weights: dict, new_weights: dict, type: str, name: str) -> dict:
     logging.debug(f'Applying {new_weights}')
-    cleaned_weights = {}
-    for option in new_weights:
-        option_name = option.lstrip("+")
-        if option.startswith("+") and option_name in weights:
-            cleaned_value = weights[option_name]
-            new_value = new_weights[option]
-            if isinstance(new_value, (set, dict)):
-                cleaned_value.update(new_value)
-            elif isinstance(new_value, list):
-                cleaned_value.extend(new_value)
-            else:
-                raise Exception(f"Cannot apply merge to non-dict, set, or list type {option_name},"
-                                f" received {type(new_value).__name__}.")
-            cleaned_weights[option_name] = cleaned_value
-        else:
-            cleaned_weights[option_name] = new_weights[option]
-    new_options = set(cleaned_weights) - set(weights)
-    weights.update(cleaned_weights)
+    new_options = set(new_weights) - set(weights)
+    weights.update(new_weights)
     if new_options:
         for new_option in new_options:
-            logging.warning(f'{update_type} Suboption "{new_option}" of "{name}" did not '
+            logging.warning(f'{type} Suboption "{new_option}" of "{name}" did not '
                             f'overwrite a root option. '
                             f'This is probably in error.')
     return weights
@@ -353,6 +357,15 @@ def roll_meta_option(option_key, game: str, category_dict: Dict) -> Any:
             if options[option_key].supports_weighting:
                 return get_choice(option_key, category_dict)
             return category_dict[option_key]
+    if game == "A Link to the Past":  # TODO wow i hate this
+        if option_key in {"glitches_required", "dark_room_logic", "entrance_shuffle", "goals", "triforce_pieces_mode",
+                          "triforce_pieces_percentage", "triforce_pieces_available", "triforce_pieces_extra",
+                          "triforce_pieces_required", "shop_shuffle", "mode", "item_pool", "item_functionality",
+                          "boss_shuffle", "enemy_damage", "enemy_health", "timer", "countdown_start_time",
+                          "red_clock_time", "blue_clock_time", "green_clock_time", "dungeon_counters", "shuffle_prizes",
+                          "misery_mire_medallion", "turtle_rock_medallion", "sprite_pool", "sprite",
+                          "random_sprite_on_event"}:
+            return get_choice(option_key, category_dict)
     raise Exception(f"Error generating meta option {option_key} for {game}.")
 
 
@@ -450,11 +463,7 @@ def roll_settings(weights: dict, plando_options: PlandoOptions = PlandoOptions.b
 
     ret.game = get_choice("game", weights)
     if ret.game not in AutoWorldRegister.world_types:
-        picks = Utils.get_fuzzy_results(ret.game, list(AutoWorldRegister.world_types) + failed_world_loads, limit=1)[0]
-        if picks[0] in failed_world_loads:
-            raise Exception(f"No functional world found to handle game {ret.game}. "
-                            f"Did you mean '{picks[0]}' ({picks[1]}% sure)? "
-                            f"If so, it appears the world failed to initialize correctly.")
+        picks = Utils.get_fuzzy_results(ret.game, AutoWorldRegister.world_types, limit=1)[0]
         raise Exception(f"No world found to handle game {ret.game}. Did you mean '{picks[0]}' ({picks[1]}% sure)? "
                         f"Check your spelling or installation of that world.")
 
@@ -464,10 +473,6 @@ def roll_settings(weights: dict, plando_options: PlandoOptions = PlandoOptions.b
     world_type = AutoWorldRegister.world_types[ret.game]
     game_weights = weights[ret.game]
 
-    if any(weight.startswith("+") for weight in game_weights) or \
-       any(weight.startswith("+") for weight in weights):
-        raise Exception(f"Merge tag cannot be used outside of trigger contexts.")
-
     if "triggers" in game_weights:
         weights = roll_triggers(weights, game_weights["triggers"])
         game_weights = weights[ret.game]
@@ -480,23 +485,120 @@ def roll_settings(weights: dict, plando_options: PlandoOptions = PlandoOptions.b
         handle_option(ret, game_weights, option_key, option, plando_options)
     if PlandoOptions.items in plando_options:
         ret.plando_items = game_weights.get("plando_items", [])
-    if ret.game == "A Link to the Past":
-        roll_alttp_settings(ret, game_weights, plando_options)
-    if PlandoOptions.connections in plando_options:
+    if ret.game == "Minecraft" or ret.game == "Ocarina of Time":
+        # bad hardcoded behavior to make this work for now
         ret.plando_connections = []
-        options = game_weights.get("plando_connections", [])
-        for placement in options:
-            if roll_percentage(get_choice("percentage", placement, 100)):
-                ret.plando_connections.append(PlandoConnection(
-                    get_choice("entrance", placement),
-                    get_choice("exit", placement),
-                    get_choice("direction", placement, "both")
-                ))
+        if PlandoOptions.connections in plando_options:
+            options = game_weights.get("plando_connections", [])
+            for placement in options:
+                if roll_percentage(get_choice("percentage", placement, 100)):
+                    ret.plando_connections.append(PlandoConnection(
+                        get_choice("entrance", placement),
+                        get_choice("exit", placement),
+                        get_choice("direction", placement)
+                    ))
+    elif ret.game == "A Link to the Past":
+        roll_alttp_settings(ret, game_weights, plando_options)
 
     return ret
 
 
 def roll_alttp_settings(ret: argparse.Namespace, weights, plando_options):
+    if "dungeon_items" in weights and get_choice_legacy('dungeon_items', weights, "none") != "none":
+        raise Exception(f"dungeon_items key in A Link to the Past was removed, but is present in these weights as {get_choice_legacy('dungeon_items', weights, False)}.")
+    glitches_required = get_choice_legacy('glitches_required', weights)
+    if glitches_required not in [None, 'none', 'no_logic', 'overworld_glitches', 'hybrid_major_glitches', 'minor_glitches']:
+        logging.warning("Only NMG, OWG, HMG and No Logic supported")
+        glitches_required = 'none'
+    ret.logic = {None: 'noglitches', 'none': 'noglitches', 'no_logic': 'nologic', 'overworld_glitches': 'owglitches',
+                 'minor_glitches': 'minorglitches', 'hybrid_major_glitches': 'hybridglitches'}[
+        glitches_required]
+
+    ret.dark_room_logic = get_choice_legacy("dark_room_logic", weights, "lamp")
+    if not ret.dark_room_logic:  # None/False
+        ret.dark_room_logic = "none"
+    if ret.dark_room_logic == "sconces":
+        ret.dark_room_logic = "torches"
+    if ret.dark_room_logic not in {"lamp", "torches", "none"}:
+        raise ValueError(f"Unknown Dark Room Logic: \"{ret.dark_room_logic}\"")
+
+    entrance_shuffle = get_choice_legacy('entrance_shuffle', weights, 'vanilla')
+    if entrance_shuffle.startswith('none-'):
+        ret.shuffle = 'vanilla'
+    else:
+        ret.shuffle = entrance_shuffle if entrance_shuffle != 'none' else 'vanilla'
+
+    goal = get_choice_legacy('goals', weights, 'ganon')
+
+    ret.goal = goals[goal]
+
+
+    extra_pieces = get_choice_legacy('triforce_pieces_mode', weights, 'available')
+
+    ret.triforce_pieces_required = LttPOptions.TriforcePieces.from_any(get_choice_legacy('triforce_pieces_required', weights, 20))
+
+    # sum a percentage to required
+    if extra_pieces == 'percentage':
+        percentage = max(100, float(get_choice_legacy('triforce_pieces_percentage', weights, 150))) / 100
+        ret.triforce_pieces_available = int(round(ret.triforce_pieces_required * percentage, 0))
+    # vanilla mode (specify how many pieces are)
+    elif extra_pieces == 'available':
+        ret.triforce_pieces_available = LttPOptions.TriforcePieces.from_any(
+            get_choice_legacy('triforce_pieces_available', weights, 30))
+    # required pieces + fixed extra
+    elif extra_pieces == 'extra':
+        extra_pieces = max(0, int(get_choice_legacy('triforce_pieces_extra', weights, 10)))
+        ret.triforce_pieces_available = ret.triforce_pieces_required + extra_pieces
+
+    # change minimum to required pieces to avoid problems
+    ret.triforce_pieces_available = min(max(ret.triforce_pieces_required, int(ret.triforce_pieces_available)), 90)
+
+    ret.shop_shuffle = get_choice_legacy('shop_shuffle', weights, '')
+    if not ret.shop_shuffle:
+        ret.shop_shuffle = ''
+
+    ret.mode = get_choice_legacy("mode", weights)
+
+    ret.difficulty = get_choice_legacy('item_pool', weights)
+
+    ret.item_functionality = get_choice_legacy('item_functionality', weights)
+
+
+    ret.enemy_damage = {None: 'default',
+                        'default': 'default',
+                        'shuffled': 'shuffled',
+                        'random': 'chaos', # to be removed
+                        'chaos': 'chaos',
+                        }[get_choice_legacy('enemy_damage', weights)]
+
+    ret.enemy_health = get_choice_legacy('enemy_health', weights)
+
+    ret.timer = {'none': False,
+                 None: False,
+                 False: False,
+                 'timed': 'timed',
+                 'timed_ohko': 'timed-ohko',
+                 'ohko': 'ohko',
+                 'timed_countdown': 'timed-countdown',
+                 'display': 'display'}[get_choice_legacy('timer', weights, False)]
+
+    ret.countdown_start_time = int(get_choice_legacy('countdown_start_time', weights, 10))
+    ret.red_clock_time = int(get_choice_legacy('red_clock_time', weights, -2))
+    ret.blue_clock_time = int(get_choice_legacy('blue_clock_time', weights, 2))
+    ret.green_clock_time = int(get_choice_legacy('green_clock_time', weights, 4))
+
+    ret.dungeon_counters = get_choice_legacy('dungeon_counters', weights, 'default')
+
+    ret.shuffle_prizes = get_choice_legacy('shuffle_prizes', weights, "g")
+
+    ret.required_medallions = [get_choice_legacy("misery_mire_medallion", weights, "random"),
+                               get_choice_legacy("turtle_rock_medallion", weights, "random")]
+
+    for index, medallion in enumerate(ret.required_medallions):
+        ret.required_medallions[index] = {"ether": "Ether", "quake": "Quake", "bombos": "Bombos", "random": "random"} \
+            .get(medallion.lower(), None)
+        if not ret.required_medallions[index]:
+            raise Exception(f"unknown Medallion {medallion} for {'misery mire' if index == 0 else 'turtle rock'}")
 
     ret.plando_texts = {}
     if PlandoOptions.texts in plando_options:
@@ -510,6 +612,17 @@ def roll_alttp_settings(ret: argparse.Namespace, weights, plando_options):
                     raise Exception(f"No text target \"{at}\" found.")
                 ret.plando_texts[at] = str(get_choice_legacy("text", placement))
 
+    ret.plando_connections = []
+    if PlandoOptions.connections in plando_options:
+        options = weights.get("plando_connections", [])
+        for placement in options:
+            if roll_percentage(get_choice_legacy("percentage", placement, 100)):
+                ret.plando_connections.append(PlandoConnection(
+                    get_choice_legacy("entrance", placement),
+                    get_choice_legacy("exit", placement),
+                    get_choice_legacy("direction", placement, "both")
+                ))
+
     ret.sprite_pool = weights.get('sprite_pool', [])
     ret.sprite = get_choice_legacy('sprite', weights, "Link")
     if 'random_sprite_on_event' in weights:

Launcher.py

@@ -100,9 +100,9 @@ components.extend([
     # Functions
     Component("Open host.yaml", func=open_host_yaml),
     Component("Open Patch", func=open_patch),
-    Component("Generate Template Options", func=generate_yamls),
+    Component("Generate Template Settings", func=generate_yamls),
     Component("Discord Server", icon="discord", func=lambda: webbrowser.open("https://discord.gg/8Z65BR2")),
-    Component("Unrated/18+ Discord Server", icon="discord", func=lambda: webbrowser.open("https://discord.gg/fqvNCCRsu4")),
+    Component("18+ Discord Server", icon="discord", func=lambda: webbrowser.open("https://discord.gg/fqvNCCRsu4")),
     Component("Browse Files", func=browse_files),
 ])
 
@@ -161,7 +161,7 @@ def launch(exe, in_terminal=False):
 
 
 def run_gui():
-    from kvui import App, ContainerLayout, GridLayout, Button, Label, ScrollBox, Widget
+    from kvui import App, ContainerLayout, GridLayout, Button, Label
     from kivy.uix.image import AsyncImage
     from kivy.uix.relativelayout import RelativeLayout
 
@@ -185,16 +185,11 @@ def run_gui():
             self.container = ContainerLayout()
             self.grid = GridLayout(cols=2)
             self.container.add_widget(self.grid)
-            self.grid.add_widget(Label(text="General", size_hint_y=None, height=40))
-            self.grid.add_widget(Label(text="Clients", size_hint_y=None, height=40))
-            tool_layout = ScrollBox()
-            tool_layout.layout.orientation = "vertical"
-            self.grid.add_widget(tool_layout)
-            client_layout = ScrollBox()
-            client_layout.layout.orientation = "vertical"
-            self.grid.add_widget(client_layout)
+            self.grid.add_widget(Label(text="General"))
+            self.grid.add_widget(Label(text="Clients"))
+            button_layout = self.grid  # make buttons fill the window
 
-            def build_button(component: Component) -> Widget:
+            def build_button(component: Component):
                 """
                 Builds a button widget for a given component.
 
@@ -205,26 +200,31 @@ def run_gui():
                     None. The button is added to the parent grid layout.
 
                 """
-                button = Button(text=component.display_name, size_hint_y=None, height=40)
+                button = Button(text=component.display_name)
                 button.component = component
                 button.bind(on_release=self.component_action)
                 if component.icon != "icon":
                     image = AsyncImage(source=icon_paths[component.icon],
                                        size=(38, 38), size_hint=(None, 1), pos=(5, 0))
-                    box_layout = RelativeLayout(size_hint_y=None, height=40)
+                    box_layout = RelativeLayout()
                     box_layout.add_widget(button)
                     box_layout.add_widget(image)
-                    return box_layout
-                return button
+                    button_layout.add_widget(box_layout)
+                else:
+                    button_layout.add_widget(button)
 
             for (tool, client) in itertools.zip_longest(itertools.chain(
                     self._tools.items(), self._miscs.items(), self._adjusters.items()), self._clients.items()):
                 # column 1
                 if tool:
-                    tool_layout.layout.add_widget(build_button(tool[1]))
+                    build_button(tool[1])
+                else:
+                    button_layout.add_widget(Label())
                 # column 2
                 if client:
-                    client_layout.layout.add_widget(build_button(client[1]))
+                    build_button(client[1])
+                else:
+                    button_layout.add_widget(Label())
 
             return self.container
 

LinksAwakeningClient.py

@@ -348,8 +348,7 @@ class LinksAwakeningClient():
                         await asyncio.sleep(1.0)
                         continue
                 self.stop_bizhawk_spam = False
-                logger.info(f"Connected to Retroarch {version.decode('ascii', errors='replace')} "
-                            f"running {rom_name.decode('ascii', errors='replace')}")
+                logger.info(f"Connected to Retroarch {version.decode('ascii')} running {rom_name.decode('ascii')}")
                 return
             except (BlockingIOError, TimeoutError, ConnectionResetError):
                 await asyncio.sleep(1.0)

Main.py

@@ -30,24 +30,49 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
         output_path.cached_path = args.outputpath
 
     start = time.perf_counter()
-    # initialize the multiworld
-    multiworld = MultiWorld(args.multi)
+    # initialize the world
+    world = MultiWorld(args.multi)
 
     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()
-    multiworld.sprite_pool = args.sprite_pool.copy()
+    world.set_seed(seed, args.race, str(args.outputname) if args.outputname else None)
+    world.plando_options = args.plando_options
 
-    multiworld.set_options(args)
-    multiworld.set_item_links()
-    multiworld.state = CollectionState(multiworld)
-    logger.info('Archipelago Version %s  -  Seed: %s\n', __version__, multiworld.seed)
+    world.shuffle = args.shuffle.copy()
+    world.logic = args.logic.copy()
+    world.mode = args.mode.copy()
+    world.difficulty = args.difficulty.copy()
+    world.item_functionality = args.item_functionality.copy()
+    world.timer = args.timer.copy()
+    world.goal = args.goal.copy()
+    world.boss_shuffle = args.shufflebosses.copy()
+    world.enemy_health = args.enemy_health.copy()
+    world.enemy_damage = args.enemy_damage.copy()
+    world.beemizer_total_chance = args.beemizer_total_chance.copy()
+    world.beemizer_trap_chance = args.beemizer_trap_chance.copy()
+    world.countdown_start_time = args.countdown_start_time.copy()
+    world.red_clock_time = args.red_clock_time.copy()
+    world.blue_clock_time = args.blue_clock_time.copy()
+    world.green_clock_time = args.green_clock_time.copy()
+    world.dungeon_counters = args.dungeon_counters.copy()
+    world.triforce_pieces_available = args.triforce_pieces_available.copy()
+    world.triforce_pieces_required = args.triforce_pieces_required.copy()
+    world.shop_shuffle = args.shop_shuffle.copy()
+    world.shuffle_prizes = args.shuffle_prizes.copy()
+    world.sprite_pool = args.sprite_pool.copy()
+    world.dark_room_logic = args.dark_room_logic.copy()
+    world.plando_items = args.plando_items.copy()
+    world.plando_texts = args.plando_texts.copy()
+    world.plando_connections = args.plando_connections.copy()
+    world.required_medallions = args.required_medallions.copy()
+    world.game = args.game.copy()
+    world.player_name = args.name.copy()
+    world.sprite = args.sprite.copy()
+    world.glitch_triforce = args.glitch_triforce  # This is enabled/disabled globally, no per player option.
+
+    world.set_options(args)
+    world.set_item_links()
+    world.state = CollectionState(world)
+    logger.info('Archipelago Version %s  -  Seed: %s\n', __version__, world.seed)
 
     logger.info(f"Found {len(AutoWorld.AutoWorldRegister.world_types)} World Types:")
     longest_name = max(len(text) for text in AutoWorld.AutoWorldRegister.world_types)
@@ -78,93 +103,88 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
 
     # This assertion method should not be necessary to run if we are not outputting any multidata.
     if not args.skip_output:
-        AutoWorld.call_stage(multiworld, "assert_generate")
+        AutoWorld.call_stage(world, "assert_generate")
 
-    AutoWorld.call_all(multiworld, "generate_early")
+    AutoWorld.call_all(world, "generate_early")
 
     logger.info('')
 
-    for player in multiworld.player_ids:
-        for item_name, count in multiworld.worlds[player].options.start_inventory.value.items():
+    for player in world.player_ids:
+        for item_name, count in world.worlds[player].options.start_inventory.value.items():
             for _ in range(count):
-                multiworld.push_precollected(multiworld.create_item(item_name, player))
+                world.push_precollected(world.create_item(item_name, player))
 
-        for item_name, count in getattr(multiworld.worlds[player].options,
-                                        "start_inventory_from_pool",
-                                        StartInventoryPool({})).value.items():
+        for item_name, count in world.start_inventory_from_pool.setdefault(player, StartInventoryPool({})).value.items():
             for _ in range(count):
-                multiworld.push_precollected(multiworld.create_item(item_name, player))
+                world.push_precollected(world.create_item(item_name, player))
             # remove from_pool items also from early items handling, as starting is plenty early.
-            early = multiworld.early_items[player].get(item_name, 0)
+            early = world.early_items[player].get(item_name, 0)
             if early:
-                multiworld.early_items[player][item_name] = max(0, early-count)
+                world.early_items[player][item_name] = max(0, early-count)
                 remaining_count = count-early
                 if remaining_count > 0:
-                    local_early = multiworld.early_local_items[player].get(item_name, 0)
+                    local_early = world.early_local_items[player].get(item_name, 0)
                     if local_early:
-                        multiworld.early_items[player][item_name] = max(0, local_early - remaining_count)
+                        world.early_items[player][item_name] = max(0, local_early - remaining_count)
                     del local_early
             del early
 
-    logger.info('Creating MultiWorld.')
-    AutoWorld.call_all(multiworld, "create_regions")
+    logger.info('Creating World.')
+    AutoWorld.call_all(world, "create_regions")
 
     logger.info('Creating Items.')
-    AutoWorld.call_all(multiworld, "create_items")
+    AutoWorld.call_all(world, "create_items")
 
     logger.info('Calculating Access Rules.')
 
-    for player in multiworld.player_ids:
+    for player in world.player_ids:
         # items can't be both local and non-local, prefer local
-        multiworld.worlds[player].options.non_local_items.value -= multiworld.worlds[player].options.local_items.value
-        multiworld.worlds[player].options.non_local_items.value -= set(multiworld.local_early_items[player])
+        world.worlds[player].options.non_local_items.value -= world.worlds[player].options.local_items.value
+        world.worlds[player].options.non_local_items.value -= set(world.local_early_items[player])
 
-    AutoWorld.call_all(multiworld, "set_rules")
+    AutoWorld.call_all(world, "set_rules")
 
-    for player in multiworld.player_ids:
-        exclusion_rules(multiworld, player, multiworld.worlds[player].options.exclude_locations.value)
-        multiworld.worlds[player].options.priority_locations.value -= multiworld.worlds[player].options.exclude_locations.value
-        for location_name in multiworld.worlds[player].options.priority_locations.value:
+    for player in world.player_ids:
+        exclusion_rules(world, player, world.worlds[player].options.exclude_locations.value)
+        world.worlds[player].options.priority_locations.value -= world.worlds[player].options.exclude_locations.value
+        for location_name in world.worlds[player].options.priority_locations.value:
             try:
-                location = multiworld.get_location(location_name, player)
+                location = world.get_location(location_name, player)
             except KeyError as e:  # failed to find the given location. Check if it's a legitimate location
-                if location_name not in multiworld.worlds[player].location_name_to_id:
+                if location_name not in world.worlds[player].location_name_to_id:
                     raise Exception(f"Unable to prioritize location {location_name} in player {player}'s world.") from e
             else:
                 location.progress_type = LocationProgressType.PRIORITY
 
     # Set local and non-local item rules.
-    if multiworld.players > 1:
-        locality_rules(multiworld)
+    if world.players > 1:
+        locality_rules(world)
     else:
-        multiworld.worlds[1].options.non_local_items.value = set()
-        multiworld.worlds[1].options.local_items.value = set()
+        world.worlds[1].options.non_local_items.value = set()
+        world.worlds[1].options.local_items.value = set()
     
-    AutoWorld.call_all(multiworld, "generate_basic")
+    AutoWorld.call_all(world, "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.
-    if any(getattr(multiworld.worlds[player].options, "start_inventory_from_pool", None) for player in multiworld.player_ids):
+    if any(getattr(world.worlds[player].options, "start_inventory_from_pool", StartInventoryPool({})).value for player in world.player_ids):
         new_items: List[Item] = []
         depletion_pool: Dict[int, Dict[str, int]] = {
-            player: getattr(multiworld.worlds[player].options,
-                            "start_inventory_from_pool",
-                            StartInventoryPool({})).value.copy()
-            for player in multiworld.player_ids
-        }
+            player: getattr(world.worlds[player].options, "start_inventory_from_pool", StartInventoryPool({})).value.copy()
+            for player in world.player_ids}
         for player, items in depletion_pool.items():
-            player_world: AutoWorld.World = multiworld.worlds[player]
+            player_world: AutoWorld.World = world.worlds[player]
             for count in items.values():
                 for _ in range(count):
                     new_items.append(player_world.create_filler())
         target: int = sum(sum(items.values()) for items in depletion_pool.values())
-        for i, item in enumerate(multiworld.itempool):
+        for i, item in enumerate(world.itempool):
             if depletion_pool[item.player].get(item.name, 0):
                 target -= 1
                 depletion_pool[item.player][item.name] -= 1
                 # quick abort if we have found all items
                 if not target:
-                    new_items.extend(multiworld.itempool[i+1:])
+                    new_items.extend(world.itempool[i+1:])
                     break
             else:
                 new_items.append(item)
@@ -174,19 +194,19 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
             for player, remaining_items in depletion_pool.items():
                 remaining_items = {name: count for name, count in remaining_items.items() if count}
                 if remaining_items:
-                    raise Exception(f"{multiworld.get_player_name(player)}"
+                    raise Exception(f"{world.get_player_name(player)}"
                                     f" is trying to remove items from their pool that don't exist: {remaining_items}")
-        assert len(multiworld.itempool) == len(new_items), "Item Pool amounts should not change."
-        multiworld.itempool[:] = new_items
+        assert len(world.itempool) == len(new_items), "Item Pool amounts should not change."
+        world.itempool[:] = new_items
 
     # temporary home for item links, should be moved out of Main
-    for group_id, group in multiworld.groups.items():
+    for group_id, group in world.groups.items():
         def find_common_pool(players: Set[int], shared_pool: Set[str]) -> Tuple[
             Optional[Dict[int, Dict[str, int]]], Optional[Dict[str, int]]
         ]:
             classifications: Dict[str, int] = collections.defaultdict(int)
             counters = {player: {name: 0 for name in shared_pool} for player in players}
-            for item in multiworld.itempool:
+            for item in world.itempool:
                 if item.player in counters and item.name in shared_pool:
                     counters[item.player][item.name] += 1
                     classifications[item.name] |= item.classification
@@ -221,13 +241,13 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
                 new_item.classification |= classifications[item_name]
                 new_itempool.append(new_item)
 
-        region = Region("Menu", group_id, multiworld, "ItemLink")
-        multiworld.regions.append(region)
+        region = Region("Menu", group_id, world, "ItemLink")
+        world.regions.append(region)
         locations = region.locations
-        for item in multiworld.itempool:
+        for item in world.itempool:
             count = common_item_count.get(item.player, {}).get(item.name, 0)
             if count:
-                loc = Location(group_id, f"Item Link: {item.name} -> {multiworld.player_name[item.player]} {count}",
+                loc = Location(group_id, f"Item Link: {item.name} -> {world.player_name[item.player]} {count}",
                                None, region)
                 loc.access_rule = lambda state, item_name = item.name, group_id_ = group_id, count_ = count: \
                     state.has(item_name, group_id_, count_)
@@ -238,10 +258,10 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
             else:
                 new_itempool.append(item)
 
-        itemcount = len(multiworld.itempool)
-        multiworld.itempool = new_itempool
+        itemcount = len(world.itempool)
+        world.itempool = new_itempool
 
-        while itemcount > len(multiworld.itempool):
+        while itemcount > len(world.itempool):
             items_to_add = []
             for player in group["players"]:
                 if group["link_replacement"]:
@@ -249,64 +269,64 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
                 else:
                     item_player = player
                 if group["replacement_items"][player]:
-                    items_to_add.append(AutoWorld.call_single(multiworld, "create_item", item_player,
+                    items_to_add.append(AutoWorld.call_single(world, "create_item", item_player,
                                                                 group["replacement_items"][player]))
                 else:
-                    items_to_add.append(AutoWorld.call_single(multiworld, "create_filler", item_player))
-            multiworld.random.shuffle(items_to_add)
-            multiworld.itempool.extend(items_to_add[:itemcount - len(multiworld.itempool)])
+                    items_to_add.append(AutoWorld.call_single(world, "create_filler", item_player))
+            world.random.shuffle(items_to_add)
+            world.itempool.extend(items_to_add[:itemcount - len(world.itempool)])
 
-    if any(multiworld.item_links.values()):
-        multiworld._all_state = None
+    if any(world.item_links.values()):
+        world._all_state = None
 
     logger.info("Running Item Plando.")
 
-    distribute_planned(multiworld)
+    distribute_planned(world)
 
     logger.info('Running Pre Main Fill.')
 
-    AutoWorld.call_all(multiworld, "pre_fill")
+    AutoWorld.call_all(world, "pre_fill")
 
-    logger.info(f'Filling the multiworld with {len(multiworld.itempool)} items.')
+    logger.info(f'Filling the world with {len(world.itempool)} items.')
 
-    if multiworld.algorithm == 'flood':
-        flood_items(multiworld)  # different algo, biased towards early game progress items
-    elif multiworld.algorithm == 'balanced':
-        distribute_items_restrictive(multiworld)
+    if world.algorithm == 'flood':
+        flood_items(world)  # different algo, biased towards early game progress items
+    elif world.algorithm == 'balanced':
+        distribute_items_restrictive(world)
 
-    AutoWorld.call_all(multiworld, 'post_fill')
+    AutoWorld.call_all(world, 'post_fill')
 
-    if multiworld.players > 1 and not args.skip_prog_balancing:
-        balance_multiworld_progression(multiworld)
+    if world.players > 1 and not args.skip_prog_balancing:
+        balance_multiworld_progression(world)
     else:
         logger.info("Progression balancing skipped.")
 
     # we're about to output using multithreading, so we're removing the global random state to prevent accidental use
-    multiworld.random.passthrough = False
+    world.random.passthrough = False
 
     if args.skip_output:
         logger.info('Done. Skipped output/spoiler generation. Total Time: %s', time.perf_counter() - start)
-        return multiworld
+        return world
 
     logger.info(f'Beginning output...')
-    outfilebase = 'AP_' + multiworld.seed_name
+    outfilebase = 'AP_' + world.seed_name
 
     output = tempfile.TemporaryDirectory()
     with output as temp_dir:
-        output_players = [player for player in multiworld.player_ids if AutoWorld.World.generate_output.__code__
-                          is not multiworld.worlds[player].generate_output.__code__]
+        output_players = [player for player in world.player_ids if AutoWorld.World.generate_output.__code__
+                          is not world.worlds[player].generate_output.__code__]
         with concurrent.futures.ThreadPoolExecutor(len(output_players) + 2) as pool:
-            check_accessibility_task = pool.submit(multiworld.fulfills_accessibility)
+            check_accessibility_task = pool.submit(world.fulfills_accessibility)
 
-            output_file_futures = [pool.submit(AutoWorld.call_stage, multiworld, "generate_output", temp_dir)]
+            output_file_futures = [pool.submit(AutoWorld.call_stage, world, "generate_output", temp_dir)]
             for player in output_players:
                 # skip starting a thread for methods that say "pass".
                 output_file_futures.append(
-                    pool.submit(AutoWorld.call_single, multiworld, "generate_output", player, temp_dir))
+                    pool.submit(AutoWorld.call_single, world, "generate_output", player, temp_dir))
 
             # collect ER hint info
             er_hint_data: Dict[int, Dict[int, str]] = {}
-            AutoWorld.call_all(multiworld, 'extend_hint_information', er_hint_data)
+            AutoWorld.call_all(world, 'extend_hint_information', er_hint_data)
 
             def write_multidata():
                 import NetUtils
@@ -315,38 +335,38 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
                 games = {}
                 minimum_versions = {"server": AutoWorld.World.required_server_version, "clients": client_versions}
                 slot_info = {}
-                names = [[name for player, name in sorted(multiworld.player_name.items())]]
-                for slot in multiworld.player_ids:
-                    player_world: AutoWorld.World = multiworld.worlds[slot]
+                names = [[name for player, name in sorted(world.player_name.items())]]
+                for slot in world.player_ids:
+                    player_world: AutoWorld.World = world.worlds[slot]
                     minimum_versions["server"] = max(minimum_versions["server"], player_world.required_server_version)
                     client_versions[slot] = player_world.required_client_version
-                    games[slot] = multiworld.game[slot]
-                    slot_info[slot] = NetUtils.NetworkSlot(names[0][slot - 1], multiworld.game[slot],
-                                                           multiworld.player_types[slot])
-                for slot, group in multiworld.groups.items():
-                    games[slot] = multiworld.game[slot]
-                    slot_info[slot] = NetUtils.NetworkSlot(group["name"], multiworld.game[slot], multiworld.player_types[slot],
+                    games[slot] = world.game[slot]
+                    slot_info[slot] = NetUtils.NetworkSlot(names[0][slot - 1], world.game[slot],
+                                                           world.player_types[slot])
+                for slot, group in world.groups.items():
+                    games[slot] = world.game[slot]
+                    slot_info[slot] = NetUtils.NetworkSlot(group["name"], world.game[slot], world.player_types[slot],
                                                            group_members=sorted(group["players"]))
                 precollected_items = {player: [item.code for item in world_precollected if type(item.code) == int]
-                                      for player, world_precollected in multiworld.precollected_items.items()}
-                precollected_hints = {player: set() for player in range(1, multiworld.players + 1 + len(multiworld.groups))}
+                                      for player, world_precollected in world.precollected_items.items()}
+                precollected_hints = {player: set() for player in range(1, world.players + 1 + len(world.groups))}
 
-                for slot in multiworld.player_ids:
-                    slot_data[slot] = multiworld.worlds[slot].fill_slot_data()
+                for slot in world.player_ids:
+                    slot_data[slot] = world.worlds[slot].fill_slot_data()
 
                 def precollect_hint(location):
                     entrance = er_hint_data.get(location.player, {}).get(location.address, "")
                     hint = NetUtils.Hint(location.item.player, location.player, location.address,
                                          location.item.code, False, entrance, location.item.flags)
                     precollected_hints[location.player].add(hint)
-                    if location.item.player not in multiworld.groups:
+                    if location.item.player not in world.groups:
                         precollected_hints[location.item.player].add(hint)
                     else:
-                        for player in multiworld.groups[location.item.player]["players"]:
+                        for player in world.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}
-                for location in multiworld.get_filled_locations():
+                locations_data: Dict[int, Dict[int, Tuple[int, int, int]]] = {player: {} for player in world.player_ids}
+                for location in world.get_filled_locations():
                     if type(location.address) == int:
                         assert location.item.code is not None, "item code None should be event, " \
                                                                "location.address should then also be None. Location: " \
@@ -356,18 +376,18 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
                             f"{locations_data[location.player][location.address]}")
                         locations_data[location.player][location.address] = \
                             location.item.code, location.item.player, location.item.flags
-                        if location.name in multiworld.worlds[location.player].options.start_location_hints:
+                        if location.name in world.worlds[location.player].options.start_location_hints:
                             precollect_hint(location)
-                        elif location.item.name in multiworld.worlds[location.item.player].options.start_hints:
+                        elif location.item.name in world.worlds[location.item.player].options.start_hints:
                             precollect_hint(location)
-                        elif any([location.item.name in multiworld.worlds[player].options.start_hints
-                                  for player in multiworld.groups.get(location.item.player, {}).get("players", [])]):
+                        elif any([location.item.name in world.worlds[player].options.start_hints
+                                  for player in world.groups.get(location.item.player, {}).get("players", [])]):
                             precollect_hint(location)
 
                 # embedded data package
                 data_package = {
                     game_world.game: worlds.network_data_package["games"][game_world.game]
-                    for game_world in multiworld.worlds.values()
+                    for game_world in world.worlds.values()
                 }
 
                 checks_in_area: Dict[int, Dict[str, Union[int, List[int]]]] = {}
@@ -375,7 +395,7 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
                 multidata = {
                     "slot_data": slot_data,
                     "slot_info": slot_info,
-                    "connect_names": {name: (0, player) for player, name in multiworld.player_name.items()},
+                    "connect_names": {name: (0, player) for player, name in world.player_name.items()},
                     "locations": locations_data,
                     "checks_in_area": checks_in_area,
                     "server_options": baked_server_options,
@@ -385,10 +405,10 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
                     "version": tuple(version_tuple),
                     "tags": ["AP"],
                     "minimum_versions": minimum_versions,
-                    "seed_name": multiworld.seed_name,
+                    "seed_name": world.seed_name,
                     "datapackage": data_package,
                 }
-                AutoWorld.call_all(multiworld, "modify_multidata", multidata)
+                AutoWorld.call_all(world, "modify_multidata", multidata)
 
                 multidata = zlib.compress(pickle.dumps(multidata), 9)
 
@@ -398,7 +418,7 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
 
             output_file_futures.append(pool.submit(write_multidata))
             if not check_accessibility_task.result():
-                if not multiworld.can_beat_game():
+                if not world.can_beat_game():
                     raise Exception("Game appears as unbeatable. Aborting.")
                 else:
                     logger.warning("Location Accessibility requirements not fulfilled.")
@@ -411,12 +431,12 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
 
         if args.spoiler > 1:
             logger.info('Calculating playthrough.')
-            multiworld.spoiler.create_playthrough(create_paths=args.spoiler > 2)
+            world.spoiler.create_playthrough(create_paths=args.spoiler > 2)
 
         if args.spoiler:
-            multiworld.spoiler.to_file(os.path.join(temp_dir, '%s_Spoiler.txt' % outfilebase))
+            world.spoiler.to_file(os.path.join(temp_dir, '%s_Spoiler.txt' % outfilebase))
 
-        zipfilename = output_path(f"AP_{multiworld.seed_name}.zip")
+        zipfilename = output_path(f"AP_{world.seed_name}.zip")
         logger.info(f"Creating final archive at {zipfilename}")
         with zipfile.ZipFile(zipfilename, mode="w", compression=zipfile.ZIP_DEFLATED,
                              compresslevel=9) as zf:
@@ -424,4 +444,4 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
                 zf.write(file.path, arcname=file.name)
 
     logger.info('Done. Enjoy. Total Time: %s', time.perf_counter() - start)
-    return multiworld
+    return world

ModuleUpdate.py

@@ -4,29 +4,14 @@ import subprocess
 import multiprocessing
 import warnings
 
+local_dir = os.path.dirname(__file__)
+requirements_files = {os.path.join(local_dir, 'requirements.txt')}
 
 if sys.version_info < (3, 8, 6):
     raise RuntimeError("Incompatible Python Version. 3.8.7+ is supported.")
 
 # don't run update if environment is frozen/compiled or if not the parent process (skip in subprocess)
-_skip_update = bool(getattr(sys, "frozen", False) or multiprocessing.parent_process())
-update_ran = _skip_update
-
-
-class RequirementsSet(set):
-    def add(self, e):
-        global update_ran
-        update_ran &= _skip_update
-        super().add(e)
-
-    def update(self, *s):
-        global update_ran
-        update_ran &= _skip_update
-        super().update(*s)
-
-
-local_dir = os.path.dirname(__file__)
-requirements_files = RequirementsSet((os.path.join(local_dir, 'requirements.txt'),))
+update_ran = getattr(sys, "frozen", False) or multiprocessing.parent_process()
 
 if not update_ran:
     for entry in os.scandir(os.path.join(local_dir, "worlds")):
@@ -70,7 +55,7 @@ def install_pkg_resources(yes=False):
         subprocess.call([sys.executable, "-m", "pip", "install", "--upgrade", "setuptools"])
 
 
-def update(yes: bool = False, force: bool = False) -> None:
+def update(yes=False, force=False):
     global update_ran
     if not update_ran:
         update_ran = True

MultiServer.py

@@ -586,7 +586,7 @@ class Context:
             self.location_check_points = savedata["game_options"]["location_check_points"]
             self.server_password = savedata["game_options"]["server_password"]
             self.password = savedata["game_options"]["password"]
-            self.release_mode = savedata["game_options"]["release_mode"]
+            self.release_mode = savedata["game_options"].get("release_mode", savedata["game_options"].get("forfeit_mode", "goal"))
             self.remaining_mode = savedata["game_options"]["remaining_mode"]
             self.collect_mode = savedata["game_options"]["collect_mode"]
             self.item_cheat = savedata["game_options"]["item_cheat"]
@@ -631,6 +631,8 @@ class Context:
 
     def _set_options(self, server_options: dict):
         for key, value in server_options.items():
+            if key == "forfeit_mode":
+                key = "release_mode"
             data_type = self.simple_options.get(key, None)
             if data_type is not None:
                 if value not in {False, True, None}:  # some can be boolean OR text, such as password
@@ -654,8 +656,7 @@ class Context:
         else:
             return self.player_names[team, slot]
 
-    def notify_hints(self, team: int, hints: typing.List[NetUtils.Hint], only_new: bool = False,
-                     recipients: typing.Sequence[int] = None):
+    def notify_hints(self, team: int, hints: typing.List[NetUtils.Hint], only_new: bool = False):
         """Send and remember hints."""
         if only_new:
             hints = [hint for hint in hints if hint not in self.hints[team, hint.finding_player]]
@@ -684,13 +685,12 @@ class Context:
         for slot in new_hint_events:
             self.on_new_hint(team, slot)
         for slot, hint_data in concerns.items():
-            if recipients is None or slot in recipients:
-                clients = self.clients[team].get(slot)
-                if not clients:
-                    continue
-                client_hints = [datum[1] for datum in sorted(hint_data, key=lambda x: x[0].finding_player == slot)]
-                for client in clients:
-                    async_start(self.send_msgs(client, client_hints))
+            clients = self.clients[team].get(slot)
+            if not clients:
+                continue
+            client_hints = [datum[1] for datum in sorted(hint_data, key=lambda x: x[0].finding_player == slot)]
+            for client in clients:
+                async_start(self.send_msgs(client, client_hints))
 
     # "events"
 
@@ -705,17 +705,14 @@ class Context:
         self.save()  # save goal completion flag
 
     def on_new_hint(self, team: int, slot: int):
-        self.on_changed_hints(team, slot)
-        self.broadcast(self.clients[team][slot], [{
-            "cmd": "RoomUpdate",
-            "hint_points": get_slot_points(self, team, slot)
-        }])
-
-    def on_changed_hints(self, team: int, slot: int):
         key: str = f"_read_hints_{team}_{slot}"
         targets: typing.Set[Client] = set(self.stored_data_notification_clients[key])
         if targets:
             self.broadcast(targets, [{"cmd": "SetReply", "key": key, "value": self.hints[team, slot]}])
+        self.broadcast(self.clients[team][slot], [{
+            "cmd": "RoomUpdate",
+            "hint_points": get_slot_points(self, team, slot)
+        }])
 
     def on_client_status_change(self, team: int, slot: int):
         key: str = f"_read_client_status_{team}_{slot}"
@@ -976,10 +973,7 @@ def register_location_checks(ctx: Context, team: int, slot: int, locations: typi
             "hint_points": get_slot_points(ctx, team, slot),
             "checked_locations": new_locations,  # send back new checks only
         }])
-        old_hints = ctx.hints[team, slot].copy()
-        ctx.recheck_hints(team, slot)
-        if old_hints != ctx.hints[team, slot]:
-            ctx.on_changed_hints(team, slot)
+
         ctx.save()
 
 
@@ -1056,19 +1050,17 @@ def get_intended_text(input_text: str, possible_answers) -> typing.Tuple[str, bo
         if picks[0][1] == 100:
             return picks[0][0], True, "Perfect Match"
         elif picks[0][1] < 75:
-            return picks[0][0], False, f"Didn't find something that closely matches '{input_text}', " \
-                                       f"did you mean '{picks[0][0]}'? ({picks[0][1]}% sure)"
+            return picks[0][0], False, f"Didn't find something that closely matches, " \
+                                       f"did you mean {picks[0][0]}? ({picks[0][1]}% sure)"
         elif dif > 5:
             return picks[0][0], True, "Close Match"
         else:
-            return picks[0][0], False, f"Too many close matches for '{input_text}', " \
-                                       f"did you mean '{picks[0][0]}'? ({picks[0][1]}% sure)"
+            return picks[0][0], False, f"Too many close matches, did you mean {picks[0][0]}? ({picks[0][1]}% sure)"
     else:
         if picks[0][1] > 90:
             return picks[0][0], True, "Only Option Match"
         else:
-            return picks[0][0], False, f"Didn't find something that closely matches '{input_text}', " \
-                                       f"did you mean '{picks[0][0]}'? ({picks[0][1]}% sure)"
+            return picks[0][0], False, f"Did you mean {picks[0][0]}? ({picks[0][1]}% sure)"
 
 
 class CommandMeta(type):
@@ -1345,7 +1337,6 @@ class ClientMessageProcessor(CommonCommandProcessor):
                     "Sorry, !remaining requires you to have beaten the game on this server")
                 return False
 
-    @mark_raw
     def _cmd_missing(self, filter_text="") -> bool:
         """List all missing location checks from the server's perspective.
         Can be given text, which will be used as filter."""
@@ -1355,11 +1346,7 @@ class ClientMessageProcessor(CommonCommandProcessor):
         if locations:
             names = [self.ctx.location_names[location] for location in locations]
             if filter_text:
-                location_groups = self.ctx.location_name_groups[self.ctx.games[self.client.slot]]
-                if filter_text in location_groups:  # location group name
-                    names = [name for name in names if name in location_groups[filter_text]]
-                else:
-                    names = [name for name in names if filter_text in name]
+                names = [name for name in names if filter_text in name]
             texts = [f'Missing: {name}' for name in names]
             if filter_text:
                 texts.append(f"Found {len(locations)} missing location checks, displaying {len(names)} of them.")
@@ -1370,7 +1357,6 @@ class ClientMessageProcessor(CommonCommandProcessor):
             self.output("No missing location checks found.")
         return True
 
-    @mark_raw
     def _cmd_checked(self, filter_text="") -> bool:
         """List all done location checks from the server's perspective.
         Can be given text, which will be used as filter."""
@@ -1380,11 +1366,7 @@ class ClientMessageProcessor(CommonCommandProcessor):
         if locations:
             names = [self.ctx.location_names[location] for location in locations]
             if filter_text:
-                location_groups = self.ctx.location_name_groups[self.ctx.games[self.client.slot]]
-                if filter_text in location_groups:  # location group name
-                    names = [name for name in names if name in location_groups[filter_text]]
-                else:
-                    names = [name for name in names if filter_text in name]
+                names = [name for name in names if filter_text in name]
             texts = [f'Checked: {name}' for name in names]
             if filter_text:
                 texts.append(f"Found {len(locations)} done location checks, displaying {len(names)} of them.")
@@ -1447,13 +1429,9 @@ class ClientMessageProcessor(CommonCommandProcessor):
             hints = {hint.re_check(self.ctx, self.client.team) for hint in
                      self.ctx.hints[self.client.team, self.client.slot]}
             self.ctx.hints[self.client.team, self.client.slot] = hints
-            self.ctx.notify_hints(self.client.team, list(hints), recipients=(self.client.slot,))
+            self.ctx.notify_hints(self.client.team, list(hints))
             self.output(f"A hint costs {self.ctx.get_hint_cost(self.client.slot)} points. "
                         f"You have {points_available} points.")
-            if hints and Utils.version_tuple < (0, 5, 0):
-                self.output("It was recently changed, so that the above hints are only shown to you. "
-                            "If you meant to alert another player of an above hint, "
-                            "please let them know of the content or to run !hint themselves.")
             return True
 
         elif input_text.isnumeric():
@@ -1847,11 +1825,6 @@ def update_client_status(ctx: Context, client: Client, new_status: ClientStatus)
     if current != ClientStatus.CLIENT_GOAL:  # can't undo goal completion
         if new_status == ClientStatus.CLIENT_GOAL:
             ctx.on_goal_achieved(client)
-            # if player has yet to ever connect to the server, they will not be in client_game_state
-            if all(player in ctx.client_game_state and ctx.client_game_state[player] == ClientStatus.CLIENT_GOAL
-                   for player in ctx.player_names
-                   if player[0] == client.team and player[1] != client.slot):
-                ctx.broadcast_text_all(f"Team #{client.team + 1} has completed all of their games! Congratulations!")
 
         ctx.client_game_state[client.team, client.slot] = new_status
         ctx.on_client_status_change(client.team, client.slot)
@@ -1905,7 +1878,7 @@ class ServerCommandProcessor(CommonCommandProcessor):
     @mark_raw
     def _cmd_alias(self, player_name_then_alias_name):
         """Set a player's alias, by listing their base name and then their intended alias."""
-        player_name, _, alias_name = player_name_then_alias_name.partition(" ")
+        player_name, alias_name = player_name_then_alias_name.split(" ", 1)
         player_name, usable, response = get_intended_text(player_name, self.ctx.player_names.values())
         if usable:
             for (team, slot), name in self.ctx.player_names.items():
@@ -1985,7 +1958,7 @@ class ServerCommandProcessor(CommonCommandProcessor):
 
     @mark_raw
     def _cmd_forbid_release(self, player_name: str) -> bool:
-        """Disallow the specified player from using the !release command."""
+        """"Disallow the specified player from using the !release command."""
         player = self.resolve_player(player_name)
         if player:
             team, slot, name = player
@@ -2105,8 +2078,8 @@ class ServerCommandProcessor(CommonCommandProcessor):
 
             if full_name.isnumeric():
                 location, usable, response = int(full_name), True, None
-            elif game in self.ctx.all_location_and_group_names:
-                location, usable, response = get_intended_text(full_name, self.ctx.all_location_and_group_names[game])
+            elif self.ctx.location_names_for_game(game) is not None:
+                location, usable, response = get_intended_text(full_name, self.ctx.location_names_for_game(game))
             else:
                 self.output("Can't look up location for unknown game. Hint for ID instead.")
                 return False
@@ -2114,11 +2087,6 @@ class ServerCommandProcessor(CommonCommandProcessor):
             if usable:
                 if isinstance(location, int):
                     hints = collect_hint_location_id(self.ctx, team, slot, location)
-                elif game in self.ctx.location_name_groups and location in self.ctx.location_name_groups[game]:
-                    hints = []
-                    for loc_name_from_group in self.ctx.location_name_groups[game][location]:
-                        if loc_name_from_group in self.ctx.location_names_for_game(game):
-                            hints.extend(collect_hint_location_name(self.ctx, team, slot, loc_name_from_group))
                 else:
                     hints = collect_hint_location_name(self.ctx, team, slot, location)
                 if hints:
@@ -2134,47 +2102,32 @@ class ServerCommandProcessor(CommonCommandProcessor):
             self.output(response)
             return False
 
-    def _cmd_option(self, option_name: str, option_value: str):
-        """Set an option for the server."""
-        value_type = self.ctx.simple_options.get(option_name, None)
-        if not value_type:
-            known_options = (f"{option}: {option_type}" for option, option_type in self.ctx.simple_options.items())
-            self.output(f"Unrecognized option '{option_name}', known: {', '.join(known_options)}")
+    def _cmd_option(self, option_name: str, option: str):
+        """Set options for the server."""
+
+        attrtype = self.ctx.simple_options.get(option_name, None)
+        if attrtype:
+            if attrtype == bool:
+                def attrtype(input_text: str):
+                    return input_text.lower() not in {"off", "0", "false", "none", "null", "no"}
+            elif attrtype == str and option_name.endswith("password"):
+                def attrtype(input_text: str):
+                    if input_text.lower() in {"null", "none", '""', "''"}:
+                        return None
+                    return input_text
+            setattr(self.ctx, option_name, attrtype(option))
+            self.output(f"Set option {option_name} to {getattr(self.ctx, option_name)}")
+            if option_name in {"release_mode", "remaining_mode", "collect_mode"}:
+                self.ctx.broadcast_all([{"cmd": "RoomUpdate", 'permissions': get_permissions(self.ctx)}])
+            elif option_name in {"hint_cost", "location_check_points"}:
+                self.ctx.broadcast_all([{"cmd": "RoomUpdate", option_name: getattr(self.ctx, option_name)}])
+            return True
+        else:
+            known = (f"{option}:{otype}" for option, otype in self.ctx.simple_options.items())
+            self.output(f"Unrecognized Option {option_name}, known: "
+                        f"{', '.join(known)}")
             return False
 
-        if value_type == bool:
-            def value_type(input_text: str):
-                return input_text.lower() not in {"off", "0", "false", "none", "null", "no"}
-        elif value_type == str and option_name.endswith("password"):
-            def value_type(input_text: str):
-                return None if input_text.lower() in {"null", "none", '""', "''"} else input_text
-        elif value_type == str and option_name.endswith("mode"):
-            valid_values = {"goal", "enabled", "disabled"}
-            valid_values.update(("auto", "auto_enabled") if option_name != "remaining_mode" else [])
-            if option_value.lower() not in valid_values:
-                self.output(f"Unrecognized {option_name} value '{option_value}', known: {', '.join(valid_values)}")
-                return False
-
-        setattr(self.ctx, option_name, value_type(option_value))
-        self.output(f"Set option {option_name} to {getattr(self.ctx, option_name)}")
-        if option_name in {"release_mode", "remaining_mode", "collect_mode"}:
-            self.ctx.broadcast_all([{"cmd": "RoomUpdate", 'permissions': get_permissions(self.ctx)}])
-        elif option_name in {"hint_cost", "location_check_points"}:
-            self.ctx.broadcast_all([{"cmd": "RoomUpdate", option_name: getattr(self.ctx, option_name)}])
-        return True
-
-    def _cmd_datastore(self):
-        """Debug Tool: list writable datastorage keys and approximate the size of their values with pickle."""
-        total: int = 0
-        texts = []
-        for key, value in self.ctx.stored_data.items():
-            size = len(pickle.dumps(value))
-            total += size
-            texts.append(f"Key: {key} | Size: {size}B")
-        texts.insert(0, f"Found {len(self.ctx.stored_data)} keys, "
-                        f"approximately totaling {Utils.format_SI_prefix(total, power=1024)}B")
-        self.output("\n".join(texts))
-
 
 async def console(ctx: Context):
     import sys
@@ -2257,24 +2210,25 @@ def parse_args() -> argparse.Namespace:
 
 async def auto_shutdown(ctx, to_cancel=None):
     await asyncio.sleep(ctx.auto_shutdown)
-
-    def inactivity_shutdown():
-        ctx.server.ws_server.close()
-        ctx.exit_event.set()
-        if to_cancel:
-            for task in to_cancel:
-                task.cancel()
-        logging.info("Shutting down due to inactivity.")
-
     while not ctx.exit_event.is_set():
         if not ctx.client_activity_timers.values():
-            inactivity_shutdown()
+            ctx.server.ws_server.close()
+            ctx.exit_event.set()
+            if to_cancel:
+                for task in to_cancel:
+                    task.cancel()
+            logging.info("Shutting down due to inactivity.")
         else:
             newest_activity = max(ctx.client_activity_timers.values())
             delta = datetime.datetime.now(datetime.timezone.utc) - newest_activity
             seconds = ctx.auto_shutdown - delta.total_seconds()
             if seconds < 0:
-                inactivity_shutdown()
+                ctx.server.ws_server.close()
+                ctx.exit_event.set()
+                if to_cancel:
+                    for task in to_cancel:
+                        task.cancel()
+                logging.info("Shutting down due to inactivity.")
             else:
                 await asyncio.sleep(seconds)
 

NetUtils.py

@@ -290,8 +290,8 @@ def add_json_item(parts: list, item_id: int, player: int = 0, item_flags: int =
     parts.append({"text": str(item_id), "player": player, "flags": item_flags, "type": JSONTypes.item_id, **kwargs})
 
 
-def add_json_location(parts: list, location_id: int, player: int = 0, **kwargs) -> None:
-    parts.append({"text": str(location_id), "player": player, "type": JSONTypes.location_id, **kwargs})
+def add_json_location(parts: list, item_id: int, player: int = 0, **kwargs) -> None:
+    parts.append({"text": str(item_id), "player": player, "type": JSONTypes.location_id, **kwargs})
 
 
 class Hint(typing.NamedTuple):

OoTAdjuster.py

@@ -195,10 +195,10 @@ def set_icon(window):
     window.tk.call('wm', 'iconphoto', window._w, logo)
 
 def adjust(args):
-    # Create a fake multiworld and OOTWorld to use as a base
-    multiworld = MultiWorld(1)
-    multiworld.per_slot_randoms = {1: random}
-    ootworld = OOTWorld(multiworld, 1)
+    # Create a fake world and OOTWorld to use as a base
+    world = MultiWorld(1)
+    world.per_slot_randoms = {1: random}
+    ootworld = OOTWorld(world, 1)
     # Set options in the fake OOTWorld
     for name, option in chain(cosmetic_options.items(), sfx_options.items()):
         result = getattr(args, name, None)

Options.py

@@ -1,19 +1,19 @@
 from __future__ import annotations
 
 import abc
-import functools
 import logging
+from copy import deepcopy
+from dataclasses import dataclass
+import functools
 import math
 import numbers
 import random
 import typing
-import enum
 from copy import deepcopy
-from dataclasses import dataclass
 
 from schema import And, Optional, Or, Schema
 
-from Utils import get_fuzzy_results, is_iterable_except_str
+from Utils import get_fuzzy_results
 
 if typing.TYPE_CHECKING:
     from BaseClasses import PlandoOptions
@@ -21,15 +21,6 @@ if typing.TYPE_CHECKING:
     import pathlib
 
 
-class Visibility(enum.IntFlag):
-    none = 0b0000
-    template = 0b0001
-    simple_ui = 0b0010  # show option in simple menus, such as player-options
-    complex_ui = 0b0100  # show option in complex menus, such as weighted-options
-    spoiler = 0b1000
-    all = 0b1111
-
-
 class AssembleOptions(abc.ABCMeta):
     def __new__(mcs, name, bases, attrs):
         options = attrs["options"] = {}
@@ -51,11 +42,6 @@ class AssembleOptions(abc.ABCMeta):
         aliases = {name[6:].lower(): option_id for name, option_id in attrs.items() if
                    name.startswith("alias_")}
 
-        assert (
-            name in {"Option", "VerifyKeys"} or  # base abstract classes don't need default
-            "default" in attrs or
-            any(hasattr(base, "default") for base in bases)
-        ), f"Option class {name} needs default value"
         assert "random" not in aliases, "Choice option 'random' cannot be manually assigned."
 
         # auto-alias Off and On being parsed as True and False
@@ -73,7 +59,6 @@ class AssembleOptions(abc.ABCMeta):
                 def verify(self, *args, **kwargs) -> None:
                     for f in verifiers:
                         f(self, *args, **kwargs)
-
                 attrs["verify"] = verify
             else:
                 assert verifiers, "class Option is supposed to implement def verify"
@@ -111,8 +96,7 @@ T = typing.TypeVar('T')
 
 class Option(typing.Generic[T], metaclass=AssembleOptions):
     value: T
-    default: typing.ClassVar[typing.Any]  # something that __init__ will be able to convert to the correct type
-    visibility = Visibility.all
+    default = 0
 
     # convert option_name_long into Name Long as display_name, otherwise name_long is the result.
     # Handled in get_option_name()
@@ -122,9 +106,8 @@ class Option(typing.Generic[T], metaclass=AssembleOptions):
     supports_weighting = True
 
     # filled by AssembleOptions:
-    name_lookup: typing.ClassVar[typing.Dict[T, str]]  # type: ignore
-    # https://github.com/python/typing/discussions/1460 the reason for this type: ignore
-    options: typing.ClassVar[typing.Dict[str, int]]
+    name_lookup: typing.Dict[T, str]
+    options: typing.Dict[str, int]
 
     def __repr__(self) -> str:
         return f"{self.__class__.__name__}({self.current_option_name})"
@@ -177,8 +160,6 @@ class FreeText(Option[str]):
     """Text option that allows users to enter strings.
     Needs to be validated by the world or option definition."""
 
-    default = ""
-
     def __init__(self, value: str):
         assert isinstance(value, str), "value of FreeText must be a string"
         self.value = value
@@ -199,18 +180,9 @@ class FreeText(Option[str]):
     def get_option_name(cls, value: str) -> str:
         return value
 
-    def __eq__(self, other):
-        if isinstance(other, self.__class__):
-            return other.value == self.value
-        elif isinstance(other, str):
-            return other == self.value
-        else:
-            raise TypeError(f"Can't compare {self.__class__.__name__} with {other.__class__.__name__}")
-
 
 class NumericOption(Option[int], numbers.Integral, abc.ABC):
     default = 0
-
     # note: some of the `typing.Any`` here is a result of unresolved issue in python standards
     # `int` is not a `numbers.Integral` according to the official typestubs
     # (even though isinstance(5, numbers.Integral) == True)
@@ -384,8 +356,7 @@ class Toggle(NumericOption):
     default = 0
 
     def __init__(self, value: int):
-        # if user puts in an invalid value, make it valid
-        value = int(bool(value))
+        assert value == 0 or value == 1, "value of Toggle can only be 0 or 1"
         self.value = value
 
     @classmethod
@@ -627,7 +598,7 @@ class PlandoBosses(TextChoice, metaclass=BossMeta):
         if isinstance(self.value, int):
             return
         from BaseClasses import PlandoOptions
-        if not (PlandoOptions.bosses & plando_options):
+        if not(PlandoOptions.bosses & plando_options):
             # plando is disabled but plando options were given so pull the option and change it to an int
             option = self.value.split(";")[-1]
             self.value = self.options[option]
@@ -756,7 +727,7 @@ class SpecialRange(NamedRange):
                   "Consider switching to NamedRange, which supports all use-cases of SpecialRange, and more. In "
                   "NamedRange, range_start specifies the lower end of the regular range, while special values can be "
                   "placed anywhere (below, inside, or above the regular range).")
-        return super().__new__(cls)
+        return super().__new__(cls, value)
 
     @classmethod
     def weighted_range(cls, text) -> Range:
@@ -794,7 +765,7 @@ class VerifyKeys(metaclass=FreezeValidKeys):
     value: typing.Any
 
     @classmethod
-    def verify_keys(cls, data: typing.Iterable[str]) -> None:
+    def verify_keys(cls, data: typing.List[str]):
         if cls.valid_keys:
             data = set(data)
             dataset = set(word.casefold() for word in data) if cls.valid_keys_casefold else set(data)
@@ -831,7 +802,7 @@ class VerifyKeys(metaclass=FreezeValidKeys):
 
 
 class OptionDict(Option[typing.Dict[str, typing.Any]], VerifyKeys, typing.Mapping[str, typing.Any]):
-    default = {}
+    default: typing.Dict[str, typing.Any] = {}
     supports_weighting = False
 
     def __init__(self, value: typing.Dict[str, typing.Any]):
@@ -872,11 +843,11 @@ class OptionList(Option[typing.List[typing.Any]], VerifyKeys):
     # If only unique entries are needed and input order of elements does not matter, OptionSet should be used instead.
     # Not a docstring so it doesn't get grabbed by the options system.
 
-    default = ()
+    default: typing.List[typing.Any] = []
     supports_weighting = False
 
-    def __init__(self, value: typing.Iterable[typing.Any]):
-        self.value = list(deepcopy(value))
+    def __init__(self, value: typing.List[typing.Any]):
+        self.value = deepcopy(value)
         super(OptionList, self).__init__()
 
     @classmethod
@@ -885,7 +856,7 @@ class OptionList(Option[typing.List[typing.Any]], VerifyKeys):
 
     @classmethod
     def from_any(cls, data: typing.Any):
-        if is_iterable_except_str(data):
+        if type(data) == list:
             cls.verify_keys(data)
             return cls(data)
         return cls.from_text(str(data))
@@ -898,7 +869,7 @@ class OptionList(Option[typing.List[typing.Any]], VerifyKeys):
 
 
 class OptionSet(Option[typing.Set[str]], VerifyKeys):
-    default = frozenset()
+    default: typing.Union[typing.Set[str], typing.FrozenSet[str]] = frozenset()
     supports_weighting = False
 
     def __init__(self, value: typing.Iterable[str]):
@@ -911,7 +882,7 @@ class OptionSet(Option[typing.Set[str]], VerifyKeys):
 
     @classmethod
     def from_any(cls, data: typing.Any):
-        if is_iterable_except_str(data):
+        if isinstance(data, (list, set, frozenset)):
             cls.verify_keys(data)
             return cls(data)
         return cls.from_text(str(data))
@@ -961,7 +932,7 @@ class OptionsMetaProperty(type):
                 bases: typing.Tuple[type, ...],
                 attrs: typing.Dict[str, typing.Any]) -> "OptionsMetaProperty":
         for attr_type in attrs.values():
-            assert not isinstance(attr_type, AssembleOptions), \
+            assert not isinstance(attr_type, AssembleOptions),\
                 f"Options for {name} should be type hinted on the class, not assigned"
         return super().__new__(mcs, name, bases, attrs)
 
@@ -1125,18 +1096,6 @@ class ItemLinks(OptionList):
                 raise Exception(f"item_link {link['name']} has {intersection} "
                                 f"items in both its local_items and non_local_items pool.")
             link.setdefault("link_replacement", None)
-            link["item_pool"] = list(pool)
-
-
-class Removed(FreeText):
-    """This Option has been Removed."""
-    default = ""
-    visibility = Visibility.none
-
-    def __init__(self, value: str):
-        if value:
-            raise Exception("Option removed, please update your options file.")
-        super().__init__(value)
 
 
 @dataclass
@@ -1151,11 +1110,6 @@ class PerGameCommonOptions(CommonOptions):
     item_links: ItemLinks
 
 
-@dataclass
-class DeathLinkMixin:
-    death_link: DeathLink
-
-
 def generate_yaml_templates(target_folder: typing.Union[str, "pathlib.Path"], generate_hidden: bool = True):
     import os
 
@@ -1194,10 +1148,7 @@ def generate_yaml_templates(target_folder: typing.Union[str, "pathlib.Path"], ge
 
     for game_name, world in AutoWorldRegister.world_types.items():
         if not world.hidden or generate_hidden:
-            all_options: typing.Dict[str, AssembleOptions] = {
-                option_name: option for option_name, option in world.options_dataclass.type_hints.items()
-                if option.visibility & Visibility.template
-            }
+            all_options: typing.Dict[str, AssembleOptions] = world.options_dataclass.type_hints
 
             with open(local_path("data", "options.yaml")) as f:
                 file_data = f.read()

Patch.py

@@ -8,7 +8,7 @@ if __name__ == "__main__":
     import ModuleUpdate
     ModuleUpdate.update()
 
-from worlds.Files import AutoPatchRegister, APAutoPatchInterface
+from worlds.Files import AutoPatchRegister, APDeltaPatch
 
 
 class RomMeta(TypedDict):
@@ -20,7 +20,7 @@ class RomMeta(TypedDict):
 def create_rom_file(patch_file: str) -> Tuple[RomMeta, str]:
     auto_handler = AutoPatchRegister.get_handler(patch_file)
     if auto_handler:
-        handler: APAutoPatchInterface = auto_handler(patch_file)
+        handler: APDeltaPatch = auto_handler(patch_file)
         target = os.path.splitext(patch_file)[0]+handler.result_file_ending
         handler.patch(target)
         return {"server": handler.server,

README.md

@@ -25,7 +25,7 @@ Currently, the following games are supported:
 * Hollow Knight
 * The Witness
 * Sonic Adventure 2: Battle
-* Starcraft 2
+* Starcraft 2: Wings of Liberty
 * Donkey Kong Country 3
 * Dark Souls 3
 * Super Mario World
@@ -58,13 +58,6 @@ Currently, the following games are supported:
 * Heretic
 * Landstalker: The Treasures of King Nole
 * Final Fantasy Mystic Quest
-* TUNIC
-* Kirby's Dream Land 3
-* Celeste 64
-* Zork Grand Inquisitor
-* Castlevania 64
-* A Short Hike
-* Yoshi's Island
 
 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
@@ -86,9 +79,9 @@ We recognize that there is a strong community of incredibly smart people that ha
 Archipelago was directly forked from bonta0's `multiworld_31` branch of ALttPEntranceRandomizer (this project has a long legacy of its own, please check it out linked above) on January 12, 2020. The repository was then named to _MultiWorld-Utilities_ to better encompass its intended function. As Archipelago matured, then known as "Berserker's MultiWorld" by some, we found it necessary to transform our repository into a root level repository (as opposed to a 'forked repo') and change the name (which came later) to better reflect our project.
 
 ## Running Archipelago
-For most people, all you need to do is head over to the [releases](https://github.com/ArchipelagoMW/Archipelago/releases) page then download and run the appropriate installer, or AppImage for Linux-based systems.
+For most people all you need to do is head over to the [releases](https://github.com/ArchipelagoMW/Archipelago/releases) page then download and run the appropriate installer. The installers function on Windows only.
 
-If you are a developer or are running on a platform with no compiled releases available, please see our doc on [running Archipelago from source](docs/running%20from%20source.md).
+If you are running Archipelago from a non-Windows system then the likely scenario is that you are comfortable running source code directly. Please see our doc on [running Archipelago from source](docs/running%20from%20source.md).
 
 ## Related Repositories
 This project makes use of multiple other projects. We wouldn't be here without these other repositories and the contributions of their developers, past and present.

SNIClient.py

@@ -85,7 +85,6 @@ class SNIClientCommandProcessor(ClientCommandProcessor):
         """Close connection to a currently connected snes"""
         self.ctx.snes_reconnect_address = None
         self.ctx.cancel_snes_autoreconnect()
-        self.ctx.snes_state = SNESState.SNES_DISCONNECTED
         if self.ctx.snes_socket and not self.ctx.snes_socket.closed:
             async_start(self.ctx.snes_socket.close())
             return True
@@ -565,12 +564,16 @@ async def snes_write(ctx: SNIContext, write_list: typing.List[typing.Tuple[int,
         PutAddress_Request: SNESRequest = {"Opcode": "PutAddress", "Operands": [], 'Space': 'SNES'}
         try:
             for address, data in write_list:
-                PutAddress_Request['Operands'] = [hex(address)[2:], hex(min(len(data), 256))[2:]]
-                if ctx.snes_socket is not None:
-                    await ctx.snes_socket.send(dumps(PutAddress_Request))
-                    await ctx.snes_socket.send(data)
-                else:
-                    snes_logger.warning(f"Could not send data to SNES: {data}")
+                while data:
+                    # Divide the write into packets of 256 bytes.
+                    PutAddress_Request['Operands'] = [hex(address)[2:], hex(min(len(data), 256))[2:]]
+                    if ctx.snes_socket is not None:
+                        await ctx.snes_socket.send(dumps(PutAddress_Request))
+                        await ctx.snes_socket.send(data[:256])
+                        address += 256
+                        data = data[256:]
+                    else:
+                        snes_logger.warning(f"Could not send data to SNES: {data}")
         except ConnectionClosed:
             return False
 

Starcraft2Client.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import ModuleUpdate
 ModuleUpdate.update()
 
-from worlds.sc2.Client import launch
+from worlds.sc2wol.Client import launch
 import Utils
 
 if __name__ == "__main__":

Utils.py

@@ -19,13 +19,14 @@ import warnings
 from argparse import Namespace
 from settings import Settings, get_settings
 from typing import BinaryIO, Coroutine, Optional, Set, Dict, Any, Union
-from typing_extensions import TypeGuard
-from yaml import load, load_all, dump
+from yaml import load, load_all, dump, SafeLoader
 
 try:
-    from yaml import CLoader as UnsafeLoader, CSafeLoader as SafeLoader, CDumper as Dumper
+    from yaml import CLoader as UnsafeLoader
+    from yaml import CDumper as Dumper
 except ImportError:
-    from yaml import Loader as UnsafeLoader, SafeLoader, Dumper
+    from yaml import Loader as UnsafeLoader
+    from yaml import Dumper
 
 if typing.TYPE_CHECKING:
     import tkinter
@@ -46,7 +47,7 @@ class Version(typing.NamedTuple):
         return ".".join(str(item) for item in self)
 
 
-__version__ = "0.4.6"
+__version__ = "0.4.4"
 version_tuple = tuplize_version(__version__)
 
 is_linux = sys.platform.startswith("linux")
@@ -225,9 +226,6 @@ class UniqueKeyLoader(SafeLoader):
             if key in mapping:
                 logging.error(f"YAML duplicates sanity check failed{key_node.start_mark}")
                 raise KeyError(f"Duplicate key {key} found in YAML. Already found keys: {mapping}.")
-            if (str(key).startswith("+") and (str(key)[1:] in mapping)) or (f"+{key}" in mapping):
-                logging.error(f"YAML merge duplicates sanity check failed{key_node.start_mark}")
-                raise KeyError(f"Equivalent key {key} found in YAML. Already found keys: {mapping}.")
             mapping.add(key)
         return super().construct_mapping(node, deep)
 
@@ -619,8 +617,6 @@ def get_fuzzy_results(input_word: str, wordlist: typing.Sequence[str], limit: ty
 
 def open_filename(title: str, filetypes: typing.Sequence[typing.Tuple[str, typing.Sequence[str]]], suggest: str = "") \
         -> typing.Optional[str]:
-    logging.info(f"Opening file input dialog for {title}.")
-
     def run(*args: str):
         return subprocess.run(args, capture_output=True, text=True).stdout.split("\n", 1)[0] or None
 
@@ -718,7 +714,7 @@ def messagebox(title: str, text: str, error: bool = False) -> None:
         import ctypes
         style = 0x10 if error else 0x0
         return ctypes.windll.user32.MessageBoxW(0, text, title, style)
-
+    
     # fall back to tk
     try:
         import tkinter
@@ -875,8 +871,8 @@ def visualize_regions(root_region: Region, file_name: str, *,
 
     Example usage in Main code:
     from Utils import visualize_regions
-    for player in multiworld.player_ids:
-        visualize_regions(multiworld.get_region("Menu", player), f"{multiworld.get_out_file_name_base(player)}.puml")
+    for player in world.player_ids:
+        visualize_regions(world.get_region("Menu", player), f"{world.get_out_file_name_base(player)}.puml")
     """
     assert root_region.multiworld, "The multiworld attribute of root_region has to be filled"
     from BaseClasses import Entrance, Item, Location, LocationProgressType, MultiWorld, Region
@@ -972,10 +968,3 @@ class RepeatableChain:
 
     def __len__(self):
         return sum(len(iterable) for iterable in self.iterable)
-
-
-def is_iterable_except_str(obj: object) -> TypeGuard[typing.Iterable[typing.Any]]:
-    """ `str` is `Iterable`, but that's not what we want """
-    if isinstance(obj, str):
-        return False
-    return isinstance(obj, typing.Iterable)

WebHost.py

@@ -23,6 +23,7 @@ def get_app():
     from WebHostLib import register, cache, app as raw_app
     from WebHostLib.models import db
 
+    register()
     app = raw_app
     if os.path.exists(configpath) and not app.config["TESTING"]:
         import yaml
@@ -33,7 +34,6 @@ def get_app():
         app.config["HOST_ADDRESS"] = Utils.get_public_ipv4()
         logging.info(f"HOST_ADDRESS was set to {app.config['HOST_ADDRESS']}")
 
-    register()
     cache.init_app(app)
     db.bind(**app.config["PONY"])
     db.generate_mapping(create_tables=True)

WebHostLib/__init__.py

@@ -38,7 +38,6 @@ app.config["JOB_THRESHOLD"] = 1
 # after what time in seconds should generation be aborted, freeing the queue slot. Can be set to None to disable.
 app.config["JOB_TIME"] = 600
 app.config['SESSION_PERMANENT'] = True
-app.config["CHECK_DATA_PACKAGE_CHECKSUM_ON_STARTUP"] = False
 
 # waitress uses one thread for I/O, these are for processing of views that then get sent
 # archipelago.gg uses gunicorn + nginx; ignoring this option
@@ -52,7 +51,6 @@ app.config["PONY"] = {
 app.config["MAX_ROLL"] = 20
 app.config["CACHE_TYPE"] = "SimpleCache"
 app.config["HOST_ADDRESS"] = ""
-app.config["ASSET_RIGHTS"] = False
 
 cache = Cache()
 Compress(app)
@@ -84,6 +82,6 @@ def register():
 
     from WebHostLib.customserver import run_server_process
     # to trigger app routing picking up on it
-    from . import tracker, upload, landing, check, generate, downloads, api, stats, misc, robots
+    from . import tracker, upload, landing, check, generate, downloads, api, stats, misc
 
     app.register_blueprint(api.api_endpoints)

WebHostLib/api/__init__.py

@@ -2,9 +2,8 @@
 from typing import List, Tuple
 from uuid import UUID
 
-from flask import Blueprint, abort, url_for
+from flask import Blueprint, abort
 
-import worlds.Files
 from .. import cache
 from ..models import Room, Seed
 
@@ -22,30 +21,12 @@ def room_info(room: UUID):
     room = Room.get(id=room)
     if room is None:
         return abort(404)
-    
-    def supports_apdeltapatch(game: str):
-        return game in worlds.Files.AutoPatchRegister.patch_types
-    downloads = []
-    for slot in sorted(room.seed.slots):
-        if slot.data and not supports_apdeltapatch(slot.game):
-            slot_download = {
-                "slot": slot.player_id,
-                "download": url_for("download_slot_file", room_id=room.id, player_id=slot.player_id)
-            }
-            downloads.append(slot_download)
-        elif slot.data:
-            slot_download = {
-                "slot": slot.player_id,
-                "download": url_for("download_patch", patch_id=slot.id, room_id=room.id)
-            }
-            downloads.append(slot_download)
     return {
         "tracker": room.tracker,
         "players": get_players(room.seed),
         "last_port": room.last_port,
         "last_activity": room.last_activity,
-        "timeout": room.timeout,
-        "downloads": downloads,
+        "timeout": room.timeout
     }
 
 

WebHostLib/api/generate.py

@@ -20,8 +20,8 @@ def generate_api():
         race = False
         meta_options_source = {}
         if 'file' in request.files:
-            files = request.files.getlist('file')
-            options = get_yaml_data(files)
+            file = request.files['file']
+            options = get_yaml_data(file)
             if isinstance(options, Markup):
                 return {"text": options.striptags()}, 400
             if isinstance(options, str):

WebHostLib/autolauncher.py

@@ -6,7 +6,6 @@ import multiprocessing
 import threading
 import time
 import typing
-from uuid import UUID
 from datetime import timedelta, datetime
 
 from pony.orm import db_session, select, commit
@@ -63,32 +62,7 @@ def autohost(config: dict):
     def keep_running():
         try:
             with Locker("autohost"):
-                # delete unowned user-content
-                with db_session:
-                    # >>> bool(uuid.UUID(int=0))
-                    # True
-                    rooms = Room.select(lambda room: room.owner == UUID(int=0)).delete(bulk=True)
-                    seeds = Seed.select(lambda seed: seed.owner == UUID(int=0) and not seed.rooms).delete(bulk=True)
-                    slots = Slot.select(lambda slot: not slot.seed).delete(bulk=True)
-                    # Command gets deleted by ponyorm Cascade Delete, as Room is Required
-                if rooms or seeds or slots:
-                    logging.info(f"{rooms} Rooms, {seeds} Seeds and {slots} Slots have been deleted.")
-                if config["CHECK_DATA_PACKAGE_CHECKSUM_ON_STARTUP"]:
-                    logging.info("Checking for Data Package Checksum integrity")
-                    from worlds.AutoWorld import data_package_checksum
-                    with db_session:
-                        for data_package in GameDataPackage.select():
-                            data = restricted_loads(data_package.data)
-                            if data["checksum"] != data_package.checksum:
-                                logging.warning(f"Deleting mismatching checksum datapackage {data_package.checksum}.")
-                                data_package.delete()
-                                continue
-                            del data["checksum"]
-                            if data_package.checksum != data_package_checksum(data):
-                                logging.warning(f"Deleting mismatching checksum datapackage {data_package.checksum}.")
-                                data_package.delete()
                 run_guardian()
-                logging.info("Starting Autohost.")
                 while 1:
                     time.sleep(0.1)
                     with db_session:
@@ -217,6 +191,6 @@ def run_guardian():
             guardian = threading.Thread(name="Guardian", target=guard)
 
 
-from .models import Room, Generation, STATE_QUEUED, STATE_STARTED, STATE_ERROR, db, Seed, Slot, GameDataPackage
+from .models import Room, Generation, STATE_QUEUED, STATE_STARTED, STATE_ERROR, db, Seed
 from .customserver import run_server_process, get_static_server_data
 from .generate import gen_game

WebHostLib/check.py

@@ -28,7 +28,7 @@ def check():
                 results, _ = roll_options(options)
                 if len(options) > 1:
                     # offer combined file back
-                    combined_yaml = "\n---\n".join(f"# original filename: {file_name}\n{file_content.decode('utf-8-sig')}"
+                    combined_yaml = "---\n".join(f"# original filename: {file_name}\n{file_content.decode('utf-8-sig')}"
                                                  for file_name, file_content in options.items())
                     combined_yaml = base64.b64encode(combined_yaml.encode("utf-8-sig")).decode()
                 else:
@@ -108,10 +108,7 @@ def roll_options(options: Dict[str, Union[dict, str]],
                         rolled_results[f"{filename}/{i + 1}"] = roll_settings(yaml_data,
                                                                               plando_options=plando_options)
             except Exception as e:
-                if e.__cause__:
-                    results[filename] = f"Failed to generate options in {filename}: {e} - {e.__cause__}"
-                else:
-                    results[filename] = f"Failed to generate options in {filename}: {e}"
+                results[filename] = f"Failed to generate options in {filename}: {e}"
             else:
                 results[filename] = True
     return results, rolled_results

WebHostLib/misc.py

@@ -49,6 +49,12 @@ def weighted_options():
     return render_template("weighted-options.html")
 
 
+# TODO for back compat. remove around 0.4.5
+@app.route("/games/<string:game>/player-settings")
+def player_settings(game: str):
+    return redirect(url_for("player_options", game=game), 301)
+
+
 # Player options pages
 @app.route("/games/<string:game>/player-options")
 @cache.cached()

WebHostLib/options.py

@@ -45,15 +45,7 @@ def create():
         }
 
         game_options = {}
-        visible: typing.Set[str] = set()
-        visible_weighted: typing.Set[str] = set()
-
         for option_name, option in all_options.items():
-            if option.visibility & Options.Visibility.simple_ui:
-                visible.add(option_name)
-            if option.visibility & Options.Visibility.complex_ui:
-                visible_weighted.add(option_name)
-
             if option_name in handled_in_js:
                 pass
 
@@ -124,6 +116,8 @@ def create():
             else:
                 logging.debug(f"{option} not exported to Web Options.")
 
+        player_options["gameOptions"] = game_options
+
         player_options["presetOptions"] = {}
         for preset_name, preset in world.web.options_presets.items():
             player_options["presetOptions"][preset_name] = {}
@@ -162,23 +156,12 @@ def create():
 
         os.makedirs(os.path.join(target_folder, 'player-options'), exist_ok=True)
 
-        filtered_player_options = player_options
-        filtered_player_options["gameOptions"] = {
-            option_name: option_data for option_name, option_data in game_options.items()
-            if option_name in visible
-        }
-
         with open(os.path.join(target_folder, 'player-options', game_name + ".json"), "w") as f:
-            json.dump(filtered_player_options, f, indent=2, separators=(',', ': '))
-
-        filtered_player_options["gameOptions"] = {
-            option_name: option_data for option_name, option_data in game_options.items()
-            if option_name in visible_weighted
-        }
+            json.dump(player_options, f, indent=2, separators=(',', ': '))
 
         if not world.hidden and world.web.options_page is True:
             # Add the random option to Choice, TextChoice, and Toggle options
-            for option in filtered_player_options["gameOptions"].values():
+            for option in game_options.values():
                 if option["type"] == "select":
                     option["options"].append({"name": "Random", "value": "random"})
 
@@ -187,7 +170,7 @@ def create():
 
             weighted_options["baseOptions"]["game"][game_name] = 0
             weighted_options["games"][game_name] = {
-                "gameSettings": filtered_player_options["gameOptions"],
+                "gameSettings": game_options,
                 "gameItems": tuple(world.item_names),
                 "gameItemGroups": [
                     group for group in world.item_name_groups.keys() if group != "Everything"

WebHostLib/robots.py

@@ -1,14 +0,0 @@
-from WebHostLib import app
-from flask import abort
-from . import cache
-
-
-@cache.cached()
-@app.route('/robots.txt')
-def robots():
-    # If this host is not official, do not allow search engine crawling
-    if not app.config["ASSET_RIGHTS"]:
-        return app.send_static_file('robots.txt')
-
-    # Send 404 if the host has affirmed this to be the official WebHost
-    abort(404)

WebHostLib/static/assets/lttp-tracker.js

@@ -0,0 +1,20 @@
+window.addEventListener('load', () => {
+  const url = window.location;
+  setInterval(() => {
+    const ajax = new XMLHttpRequest();
+    ajax.onreadystatechange = () => {
+      if (ajax.readyState !== 4) { return; }
+
+      // Create a fake DOM using the returned HTML
+      const domParser = new DOMParser();
+      const fakeDOM = domParser.parseFromString(ajax.responseText, 'text/html');
+
+      // Update item and location trackers
+      document.getElementById('inventory-table').innerHTML = fakeDOM.getElementById('inventory-table').innerHTML;
+      document.getElementById('location-table').innerHTML = fakeDOM.getElementById('location-table').innerHTML;
+
+    };
+    ajax.open('GET', url);
+    ajax.send();
+  }, 15000)
+});

WebHostLib/static/assets/sc2wolTracker.js

@@ -25,16 +25,16 @@ window.addEventListener('load', () => {
 
   // Collapsible advancement sections
   const categories = document.getElementsByClassName("location-category");
-  for (let category of categories) {
-    let hide_id = category.id.split('_')[0];
-    if (hide_id === 'Total') {
+  for (let i = 0; i < categories.length; i++) {
+    let hide_id = categories[i].id.split('-')[0];
+    if (hide_id == 'Total') {
       continue;
     }
-    category.addEventListener('click', function() {
+    categories[i].addEventListener('click', function() {
       // Toggle the advancement list
       document.getElementById(hide_id).classList.toggle("hide");
       // Change text of the header
-      const tab_header = document.getElementById(hide_id+'_header').children[0];
+      const tab_header = document.getElementById(hide_id+'-header').children[0];
       const orig_text = tab_header.innerHTML;
       let new_text;
       if (orig_text.includes("▼")) {

WebHostLib/static/robots.txt

@@ -1,20 +0,0 @@
-User-agent: Googlebot
-Disallow: /
-
-User-agent: APIs-Google
-Disallow: /
-
-User-agent: AdsBot-Google-Mobile
-Disallow: /
-
-User-agent: AdsBot-Google-Mobile
-Disallow: /
-
-User-agent: Mediapartners-Google
-Disallow: /
-
-User-agent: Google-Safety
-Disallow: /
-
-User-agent: *
-Disallow: /

WebHostLib/static/styles/lttp-tracker.css

@@ -0,0 +1,75 @@
+#player-tracker-wrapper{
+    margin: 0;
+    font-family: LexendDeca-Light, sans-serif;
+    color: white;
+    font-size: 14px;
+}
+
+#inventory-table{
+    border-top: 2px solid #000000;
+    border-left: 2px solid #000000;
+    border-right: 2px solid #000000;
+    border-top-left-radius: 4px;
+    border-top-right-radius: 4px;
+    padding: 3px 3px 10px;
+    width: 284px;
+    background-color: #42b149;
+}
+
+#inventory-table td{
+    width: 40px;
+    height: 40px;
+    text-align: center;
+    vertical-align: middle;
+}
+
+#inventory-table img{
+    height: 100%;
+    max-width: 40px;
+    max-height: 40px;
+    filter: grayscale(100%) contrast(75%) brightness(75%);
+}
+
+#inventory-table img.acquired{
+    filter: none;
+}
+
+#inventory-table img.powder-fix{
+    width: 35px;
+    height: 35px;
+}
+
+#location-table{
+    width: 284px;
+    border-left: 2px solid #000000;
+    border-right: 2px solid #000000;
+    border-bottom: 2px solid #000000;
+    border-bottom-left-radius: 4px;
+    border-bottom-right-radius: 4px;
+    background-color: #42b149;
+    padding: 0 3px 3px;
+}
+
+#location-table th{
+    vertical-align: middle;
+    text-align: center;
+    padding-right: 10px;
+}
+
+#location-table td{
+    padding-top: 2px;
+    padding-bottom: 2px;
+    padding-right: 5px;
+    line-height: 20px;
+}
+
+#location-table td.counter{
+    padding-right: 8px;
+    text-align: right;
+}
+
+#location-table img{
+    height: 100%;
+    max-width: 30px;
+    max-height: 30px;
+}

WebHostLib/static/styles/sc2Tracker.css

@@ -1,160 +0,0 @@
-#player-tracker-wrapper{
-    margin: 0;
-}
-
-#tracker-table td {
-    vertical-align: top;
-}
-
-.inventory-table-area{
-    border: 2px solid #000000;
-    border-radius: 4px;
-    padding: 3px 10px 3px 10px;
-}
-
-.inventory-table-area:has(.inventory-table-terran) {
-    width: 690px;
-    background-color: #525494;
-}
-
-.inventory-table-area:has(.inventory-table-zerg) {
-    width: 360px;
-    background-color: #9d60d2;
-}
-
-.inventory-table-area:has(.inventory-table-protoss) {
-    width: 400px;
-    background-color: #d2b260;
-}
-
-#tracker-table .inventory-table td{
-    width: 40px;
-    height: 40px;
-    text-align: center;
-    vertical-align: middle;
-}
-
-.inventory-table td.title{
-    padding-top: 10px;
-    height: 20px;
-    font-family: "JuraBook", monospace;
-    font-size: 16px;
-    font-weight: bold;
-}
-
-.inventory-table img{
-    height: 100%;
-    max-width: 40px;
-    max-height: 40px;
-    border: 1px solid #000000;
-    filter: grayscale(100%) contrast(75%) brightness(20%);
-    background-color: black;
-}
-
-.inventory-table img.acquired{
-    filter: none;
-    background-color: black;
-}
-
-.inventory-table .tint-terran img.acquired {
-    filter: sepia(100%) saturate(300%) brightness(130%) hue-rotate(120deg)
-}
-
-.inventory-table .tint-protoss img.acquired {
-    filter: sepia(100%) saturate(1000%) brightness(110%) hue-rotate(180deg)
-}
-
-.inventory-table .tint-level-1 img.acquired {
-    filter: sepia(100%) saturate(1000%) brightness(110%) hue-rotate(60deg)
-}
-
-.inventory-table .tint-level-2 img.acquired {
-    filter: sepia(100%) saturate(1000%) brightness(110%) hue-rotate(60deg) hue-rotate(120deg)
-}
-
-.inventory-table .tint-level-3 img.acquired {
-    filter: sepia(100%) saturate(1000%) brightness(110%) hue-rotate(60deg) hue-rotate(240deg)
-}
-
-.inventory-table div.counted-item {
-    position: relative;
-}
-
-.inventory-table div.item-count {
-    width: 160px;
-    text-align: left;
-    color: black;
-    font-family: "JuraBook", monospace;
-    font-weight: bold;
-}
-
-#location-table{
-    border: 2px solid #000000;
-    border-radius: 4px;
-    background-color: #87b678;
-    padding: 10px 3px 3px;
-    font-family: "JuraBook", monospace;
-    font-size: 16px;
-    font-weight: bold;
-    cursor: default;
-}
-
-#location-table table{
-    width: 100%;
-}
-
-#location-table th{
-    vertical-align: middle;
-    text-align: left;
-    padding-right: 10px;
-}
-
-#location-table td{
-    padding-top: 2px;
-    padding-bottom: 2px;
-    line-height: 20px;
-}
-
-#location-table td.counter {
-    text-align: right;
-    font-size: 14px;
-}
-
-#location-table td.toggle-arrow {
-    text-align: right;
-}
-
-#location-table tr#Total-header {
-    font-weight: bold;
-}
-
-#location-table img{
-    height: 100%;
-    max-width: 30px;
-    max-height: 30px;
-}
-
-#location-table tbody.locations {
-    font-size: 16px;
-}
-
-#location-table td.location-name {
-    padding-left: 16px;
-}
-
-#location-table td:has(.location-column) {
-    vertical-align: top;
-}
-
-#location-table .location-column {
-    width: 100%;
-    height: 100%;
-}
-
-#location-table .location-column .spacer {
-    min-height: 24px;
-}
-
-.hide {
-    display: none;
-}

WebHostLib/static/styles/sc2wolTracker.css

@@ -0,0 +1,112 @@
+#player-tracker-wrapper{
+    margin: 0;
+}
+
+#inventory-table{
+    border-top: 2px solid #000000;
+    border-left: 2px solid #000000;
+    border-right: 2px solid #000000;
+    border-top-left-radius: 4px;
+    border-top-right-radius: 4px;
+    padding: 3px 3px 10px;
+    width: 710px;
+    background-color: #525494;
+}
+
+#inventory-table td{
+    width: 40px;
+    height: 40px;
+    text-align: center;
+    vertical-align: middle;
+}
+
+#inventory-table td.title{
+    padding-top: 10px;
+    height: 20px;
+    font-family: "JuraBook", monospace;
+    font-size: 16px;
+    font-weight: bold;
+}
+
+#inventory-table img{
+    height: 100%;
+    max-width: 40px;
+    max-height: 40px;
+    border: 1px solid #000000;
+    filter: grayscale(100%) contrast(75%) brightness(20%);
+    background-color: black;
+}
+
+#inventory-table img.acquired{
+    filter: none;
+    background-color: black;
+}
+
+#inventory-table div.counted-item {
+    position: relative;
+}
+
+#inventory-table div.item-count {
+    text-align: left;
+    color: black;
+    font-family: "JuraBook", monospace;
+    font-weight: bold;
+}
+
+#location-table{
+    width: 710px;
+    border-left: 2px solid #000000;
+    border-right: 2px solid #000000;
+    border-bottom: 2px solid #000000;
+    border-bottom-left-radius: 4px;
+    border-bottom-right-radius: 4px;
+    background-color: #525494;
+    padding: 10px 3px 3px;
+    font-family: "JuraBook", monospace;
+    font-size: 16px;
+    font-weight: bold;
+    cursor: default;
+}
+
+#location-table th{
+    vertical-align: middle;
+    text-align: left;
+    padding-right: 10px;
+}
+
+#location-table td{
+    padding-top: 2px;
+    padding-bottom: 2px;
+    line-height: 20px;
+}
+
+#location-table td.counter {
+    text-align: right;
+    font-size: 14px;
+}
+
+#location-table td.toggle-arrow {
+    text-align: right;
+}
+
+#location-table tr#Total-header {
+    font-weight: bold;
+}
+
+#location-table img{
+    height: 100%;
+    max-width: 30px;
+    max-height: 30px;
+}
+
+#location-table tbody.locations {
+    font-size: 16px;
+}
+
+#location-table td.location-name {
+    padding-left: 16px;
+}
+
+.hide {
+    display: none;
+}

WebHostLib/static/styles/tracker__ALinkToThePast.css

@@ -1,142 +0,0 @@
-@import url('https://fonts.googleapis.com/css2?family=Lexend+Deca:wght@100..900&display=swap');
-
-.tracker-container {
-    width: 440px;
-    box-sizing: border-box;
-    font-family: "Lexend Deca", Arial, Helvetica, sans-serif;
-    border: 2px solid black;
-    border-radius: 4px;
-    resize: both;
-
-    background-color: #42b149;
-    color: white;
-}
-
-.hidden {
-    visibility: hidden;
-}
-
-/** Inventory Grid ****************************************************************************************************/
-.inventory-grid {
-    display: grid;
-    grid-template-columns: repeat(6, minmax(0, 1fr));
-    padding: 1rem;
-    gap: 1rem;
-}
-
-.inventory-grid .item {
-    position: relative;
-    display: flex;
-    justify-content: center;
-    height: 48px;
-}
-
-.inventory-grid .dual-item {
-    display: flex;
-    justify-content: center;
-}
-
-.inventory-grid .missing {
-    /* Missing items will be in full grayscale to signify "uncollected". */
-    filter: grayscale(100%) contrast(75%) brightness(75%);
-}
-
-.inventory-grid .item img,
-.inventory-grid .dual-item img {
-    display: flex;
-    align-items: center;
-    text-align: center;
-    font-size: 0.8rem;
-    text-shadow: 0 1px 2px black;
-    font-weight: bold;
-    image-rendering: crisp-edges;
-    background-size: contain;
-    background-repeat: no-repeat;
-}
-
-.inventory-grid .dual-item img {
-    height: 48px;
-    margin: 0 -4px;
-}
-
-.inventory-grid .dual-item img:first-child {
-    align-self: flex-end;
-}
-
-.inventory-grid .item .quantity {
-    position: absolute;
-    bottom: 0;
-    right: 0;
-    text-align: right;
-    font-weight: 600;
-    font-size: 1.75rem;
-    line-height: 1.75rem;
-    text-shadow:
-        -1px -1px 0 #000,
-         1px -1px 0 #000,
-        -1px 1px 0 #000,
-         1px 1px 0 #000;
-    user-select: none;
-}
-
-/** Regions List ******************************************************************************************************/
-.regions-list {
-    padding: 1rem;
-}
-
-.regions-list summary {
-    list-style: none;
-    display: flex;
-    gap: 0.5rem;
-    cursor: pointer;
-}
-
-.regions-list summary::before {
-    content: "⯈";
-    width: 1em;
-    flex-shrink: 0;
-}
-
-.regions-list details {
-    font-weight: 300;
-}
-
-.regions-list details[open] > summary::before {
-    content: "⯆";
-}
-
-.regions-list .region {
-    width: 100%;
-    display: grid;
-    grid-template-columns: 20fr 8fr 2fr 2fr;
-    align-items: center;
-    gap: 4px;
-    text-align: center;
-    font-weight: 300;
-    box-sizing: border-box;
-}
-
-.regions-list .region :first-child {
-    text-align: left;
-    font-weight: 500;
-}
-
-.regions-list .region.region-header {
-    margin-left: 24px;
-    width: calc(100% - 24px);
-    padding: 2px;
-}
-
-.regions-list .location-rows {
-    border-top: 1px solid white;
-    display: grid;
-    grid-template-columns: auto 32px;
-    font-weight: 300;
-    padding: 2px 8px;
-    margin-top: 4px;
-    font-size: 0.8rem;
-}
-
-.regions-list .location-rows :nth-child(even) {
-    text-align: right;
-}

WebHostLib/templates/generate.html

@@ -69,8 +69,8 @@
                                     </td>
                                     <td>
                                         <select name="collect_mode" id="collect_mode">
-                                            <option value="auto">Automatic on goal completion</option>
                                             <option value="goal">Allow !collect after goal completion</option>
+                                            <option value="auto">Automatic on goal completion</option>
                                             <option value="auto-enabled">
                                                 Automatic on goal completion and manual !collect
                                             </option>
@@ -93,9 +93,9 @@
                                             {% if race -%}
                                                 <option value="disabled">Disabled in Race mode</option>
                                             {%- else -%}
+                                                <option value="disabled">Disabled</option>
                                                 <option value="goal">Allow !remaining after goal completion</option>
                                                 <option value="enabled">Manual !remaining</option>
-                                                <option value="disabled">Disabled</option>
                                             {%- endif -%}
                                         </select>
                                     </td>
@@ -185,12 +185,12 @@ Warning: playthrough can take a significant amount of time for larger multiworld
                                             </span>
                                         </td>
                                         <td>
-                                            <input type="checkbox" id="plando_items" name="plando_items" value="items">
-                                            <label for="plando_items">Items</label><br>
-
                                             <input type="checkbox" id="plando_bosses" name="plando_bosses" value="bosses" checked>
                                             <label for="plando_bosses">Bosses</label><br>
 
+                                            <input type="checkbox" id="plando_items" name="plando_items" value="items" checked>
+                                            <label for="plando_items">Items</label><br>
+
                                             <input type="checkbox" id="plando_connections" name="plando_connections" value="connections" checked>
                                             <label for="plando_connections">Connections</label><br>