ALttP: Re-mark light/dark world regions after applying plando connections (#2964)

* The Messenger: update docs formatting and fix outdated info

* address review feedback

* 120 chars

.coveragerc

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

.github/labeler.yml

@@ -0,0 +1,31 @@
+'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/workflows/analyze-modified-files.yml

@@ -0,0 +1,80 @@
+name: Analyze modified files
+
+on:
+  pull_request:
+    paths:
+      - "**.py"
+  push:
+    paths:
+      - "**.py"
+
+env:
+  BASE: ${{ github.event.pull_request.base.sha }}
+  HEAD: ${{ github.event.pull_request.head.sha }}
+  BEFORE: ${{ github.event.before }}
+  AFTER: ${{ github.event.after }}
+
+jobs:
+  flake8-or-mypy:
+    strategy:
+      fail-fast: false
+      matrix:
+        task: [flake8, mypy]
+
+    name: ${{ matrix.task }}
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: "Determine modified files (pull_request)"
+        if: github.event_name == 'pull_request'
+        run: |
+          git fetch origin $BASE $HEAD
+          DIFF=$(git diff --diff-filter=d --name-only $BASE...$HEAD -- "*.py")
+          echo "modified files:"
+          echo "$DIFF"
+          echo "diff=${DIFF//$'\n'/$' '}" >> $GITHUB_ENV
+
+      - name: "Determine modified files (push)"
+        if: github.event_name == 'push' && github.event.before != '0000000000000000000000000000000000000000'
+        run: |
+          git fetch origin $BEFORE $AFTER
+          DIFF=$(git diff --diff-filter=d --name-only $BEFORE..$AFTER -- "*.py")
+          echo "modified files:"
+          echo "$DIFF"
+          echo "diff=${DIFF//$'\n'/$' '}" >> $GITHUB_ENV
+
+      - name: "Treat all files as modified (new branch)"
+        if: github.event_name == 'push' && github.event.before == '0000000000000000000000000000000000000000'
+        run: |
+          echo "diff=." >> $GITHUB_ENV
+
+      - uses: actions/setup-python@v5
+        if: env.diff != ''
+        with:
+          python-version: 3.8
+
+      - name: "Install dependencies"
+        if: env.diff != ''
+        run: |
+          python -m pip install --upgrade pip ${{ matrix.task }}
+          python ModuleUpdate.py --append "WebHostLib/requirements.txt" --force --yes
+
+      - name: "flake8: Stop the build if there are Python syntax errors or undefined names"
+        continue-on-error: false
+        if: env.diff != '' && matrix.task == 'flake8'
+        run: |
+          flake8 --count --select=E9,F63,F7,F82 --show-source --statistics ${{ env.diff }}
+
+      - name: "flake8: Lint modified files"
+        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 }}
+
+      - name: "mypy: Type check modified files"
+        continue-on-error: true
+        if: env.diff != '' && matrix.task == 'mypy'
+        run: |
+          mypy --follow-imports=silent --install-types --non-interactive --strict ${{ env.diff }}

.github/workflows/build.yml

@@ -8,11 +8,13 @@ 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:
@@ -25,9 +27,9 @@ jobs:
   build-win-py38: # RCs will still be built and signed by hand
     runs-on: windows-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - name: Install python
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v5
         with:
           python-version: '3.8'
       - name: Download run-time dependencies
@@ -38,37 +40,55 @@ jobs:
         run: |
           python -m pip install --upgrade pip
           python setup.py build_exe --yes
-          $NAME="$(ls build)".Split('.',2)[1]
+          $NAME="$(ls build | Select-String -Pattern 'exe')".Split('.',2)[1]
           $ZIP_NAME="Archipelago_$NAME.7z"
+          echo "$NAME -> $ZIP_NAME"
           echo "ZIP_NAME=$ZIP_NAME" >> $Env:GITHUB_ENV
           New-Item -Path dist -ItemType Directory -Force
           cd build
-          Rename-Item exe.$NAME Archipelago
+          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@v3
+        uses: actions/upload-artifact@v4
         with:
           name: ${{ env.ZIP_NAME }}
           path: dist/${{ env.ZIP_NAME }}
           retention-days: 7  # keep for 7 days, should be enough
+      - name: Build Setup
+        run: |
+          & "${env:ProgramFiles(x86)}\Inno Setup 6\iscc.exe" inno_setup.iss /DNO_SIGNTOOL
+          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-ubuntu1804:
-    runs-on: ubuntu-18.04
+  build-ubuntu2004:
+    runs-on: ubuntu-20.04
     steps:
       # - copy code below to release.yml -
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - 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@v4
+        uses: actions/setup-python@v5
         with:
-          python-version: '3.9'
+          python-version: '3.11'
       - name: Install build-time dependencies
         run: |
-          echo "PYTHON=python3.9" >> $GITHUB_ENV
+          echo "PYTHON=python3.11" >> $GITHUB_ENV
           wget -nv https://github.com/AppImage/AppImageKit/releases/download/$APPIMAGETOOL_VERSION/appimagetool-x86_64.AppImage
           chmod a+rx appimagetool-x86_64.AppImage
           ./appimagetool-x86_64.AppImage --appimage-extract
@@ -99,13 +119,13 @@ jobs:
           source venv/bin/activate
           python setup.py build_exe --yes
       - name: Store AppImage
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
           name: ${{ env.APPIMAGE_NAME }}
           path: dist/${{ env.APPIMAGE_NAME }}
           retention-days: 7
       - name: Store .tar.gz
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         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@v3
+      uses: actions/checkout@v4
 
     # Initializes the CodeQL tools for scanning.
     - name: Initialize CodeQL

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

@@ -0,0 +1,46 @@
+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/lint.yml

@@ -1,35 +0,0 @@
-# This workflow will install Python dependencies, run tests and lint with a single version of Python
-# For more information see: https://help.github.com/actions/language-and-framework-guides/using-python-with-github-actions
-
-name: lint
-
-on:
-  push:
-    paths:
-      - '**.py'
-  pull_request:
-    paths:
-      - '**.py'
-
-jobs:
-  flake8:
-
-    runs-on: ubuntu-latest
-
-    steps:
-    - uses: actions/checkout@v3
-    - name: Set up Python 3.9
-      uses: actions/setup-python@v4
-      with:
-        python-version: 3.9
-    - name: Install dependencies
-      run: |
-        python -m pip install --upgrade pip wheel
-        pip install flake8
-        if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
-    - name: Lint with flake8
-      run: |
-        # stop the build if there are Python syntax errors or undefined names
-        flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
-        # exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide
-        flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics

.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@b7e450da2a4b4cb4bfbae528f788167786cfcedf
+        uses: softprops/action-gh-release@975c1b265e11dd76618af1c374e7981f9a6ff44a
         with:
           draft: true  # don't publish right away, especially since windows build is added by hand
           prerelease: false
@@ -29,25 +29,25 @@ jobs:
   # build-release-windows: # this is done by hand because of signing
   # build-release-macos: # LF volunteer
 
-  build-release-ubuntu1804:
-    runs-on: ubuntu-18.04
+  build-release-ubuntu2004:
+    runs-on: ubuntu-20.04
     steps:
       - name: Set env
         run: echo "RELEASE_VERSION=${GITHUB_REF#refs/*/}" >> $GITHUB_ENV
       # - code below copied from build.yml -
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - 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@v4
+        uses: actions/setup-python@v5
         with:
-          python-version: '3.9'
+          python-version: '3.11'
       - name: Install build-time dependencies
         run: |
-          echo "PYTHON=python3.9" >> $GITHUB_ENV
+          echo "PYTHON=python3.11" >> $GITHUB_ENV
           wget -nv https://github.com/AppImage/AppImageKit/releases/download/$APPIMAGETOOL_VERSION/appimagetool-x86_64.AppImage
           chmod a+rx appimagetool-x86_64.AppImage
           ./appimagetool-x86_64.AppImage --appimage-extract
@@ -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@b7e450da2a4b4cb4bfbae528f788167786cfcedf
+        uses: softprops/action-gh-release@975c1b265e11dd76618af1c374e7981f9a6ff44a
         with:
           draft: true  # see above
           prerelease: false

.github/workflows/scan-build.yml

@@ -0,0 +1,65 @@
+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/unittests.yml

@@ -36,25 +36,27 @@ jobs:
           - {version: '3.8'}
           - {version: '3.9'}
           - {version: '3.10'}
+          - {version: '3.11'}
         include:
           - python: {version: '3.8'}  # win7 compat
             os: windows-latest
-          - python: {version: '3.10'}  # current
+          - python: {version: '3.11'}  # current
             os: windows-latest
-          - python: {version: '3.10'}  # current
+          - python: {version: '3.11'}  # current
             os: macos-latest
 
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
     - name: Set up Python ${{ matrix.python.version }}
-      uses: actions/setup-python@v4
+      uses: actions/setup-python@v5
       with:
         python-version: ${{ matrix.python.version }}
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip
-        pip install pytest pytest-subtests
+        pip install pytest pytest-subtests pytest-xdist
         python ModuleUpdate.py --yes --force --append "WebHostLib/requirements.txt"
+        python Launcher.py --update_settings  # make sure host.yaml exists for tests
     - name: Unittests
       run: |
-        pytest
+        pytest -n auto

.gitignore

@@ -9,12 +9,14 @@
 *.apmc
 *.apz5
 *.aptloz
+*.apemerald
 *.pyc
 *.pyd
 *.sfc
 *.z64
 *.n64
 *.nes
+*.smc
 *.sms
 *.gb
 *.gbc
@@ -27,15 +29,21 @@
 *.archipelago
 *.apsave
 *.BIN
+*.puml
 
+setups
 build
 bundle/components.wxs
 dist
+/prof/
 README.html
 .vs/
 EnemizerCLI/
 /Players/
 /SNI/
+/sni-*/
+/appimagetool*
+/host.yaml
 /options.yaml
 /config.yaml
 /logs/
@@ -137,6 +145,7 @@ ipython_config.py
 .venv*
 env/
 venv/
+/venv*/
 ENV/
 env.bak/
 venv.bak/
@@ -167,6 +176,10 @@ dmypy.json
 # Cython debug symbols
 cython_debug/
 
+# Cython intermediates
+_speedups.cpp
+_speedups.html
+
 # minecraft server stuff
 jdk*/
 minecraft*/
@@ -176,6 +189,9 @@ minecraft_versions.json
 # pyenv
 .python-version
 
+#undertale stuff
+/Undertale/
+
 # OS General Files
 .DS_Store
 .AppleDouble

.run/Archipelago Unittests.run.xml

@@ -0,0 +1,18 @@
+<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>

AdventureClient.py

@@ -25,11 +25,11 @@ from worlds.adventure.Offsets import static_item_element_size, connector_port_of
 SYSTEM_MESSAGE_ID = 0
 
 CONNECTION_TIMING_OUT_STATUS = \
-    "Connection timing out. Please restart your emulator, then restart adventure_connector.lua"
+    "Connection timing out. Please restart your emulator, then restart connector_adventure.lua"
 CONNECTION_REFUSED_STATUS = \
-    "Connection Refused. Please start your emulator and make sure adventure_connector.lua is running"
+    "Connection Refused. Please start your emulator and make sure connector_adventure.lua is running"
 CONNECTION_RESET_STATUS = \
-    "Connection was reset. Please restart your emulator, then restart adventure_connector.lua"
+    "Connection was reset. Please restart your emulator, then restart connector_adventure.lua"
 CONNECTION_TENTATIVE_STATUS = "Initial Connection Made"
 CONNECTION_CONNECTED_STATUS = "Connected"
 CONNECTION_INITIAL_STATUS = "Connection has not been initiated"
@@ -115,11 +115,12 @@ class AdventureContext(CommonContext):
             msg = f"Received {', '.join([self.item_names[item.item] for item in args['items']])}"
             self._set_message(msg, SYSTEM_MESSAGE_ID)
         elif cmd == "Retrieved":
-            self.freeincarnates_used = args["keys"][f"adventure_{self.auth}_freeincarnates_used"]
-            if self.freeincarnates_used is None:
-                self.freeincarnates_used = 0
-            self.freeincarnates_used += self.freeincarnate_pending
-            self.send_pending_freeincarnates()
+            if f"adventure_{self.auth}_freeincarnates_used" in args["keys"]:
+                self.freeincarnates_used = args["keys"][f"adventure_{self.auth}_freeincarnates_used"]
+                if self.freeincarnates_used is None:
+                    self.freeincarnates_used = 0
+                self.freeincarnates_used += self.freeincarnate_pending
+                self.send_pending_freeincarnates()
         elif cmd == "SetReply":
             if args["key"] == f"adventure_{self.auth}_freeincarnates_used":
                 self.freeincarnates_used = args["value"]
@@ -396,7 +397,7 @@ async def atari_sync_task(ctx: AdventureContext):
                     ctx.atari_streams = await asyncio.wait_for(
                         asyncio.open_connection("localhost",
                                                 port),
-                                                timeout=10)
+                        timeout=10)
                     ctx.atari_status = CONNECTION_TENTATIVE_STATUS
                 except TimeoutError:
                     logger.debug("Connection Timed Out, Trying Again")
@@ -436,7 +437,7 @@ async def patch_and_run_game(patch_file, ctx):
         logger.info(msg, extra={'compact_gui': True})
         ctx.gui_error('Error', msg)
 
-    with open(Utils.user_path("data", "adventure_basepatch.bsdiff4"), "rb") as file:
+    with open(Utils.local_path("data", "adventure_basepatch.bsdiff4"), "rb") as file:
         basepatch = bytes(file.read())
 
     base_patched_rom_data = bsdiff4.patch(base_rom, basepatch)

BizHawkClient.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+import ModuleUpdate
+ModuleUpdate.update()
+
+from worlds._bizhawk.context import launch
+
+if __name__ == "__main__":
+    launch()

CommonClient.py

@@ -1,4 +1,6 @@
 from __future__ import annotations
+
+import copy
 import logging
 import asyncio
 import urllib.parse
@@ -18,11 +20,12 @@ 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
+from NetUtils import (Endpoint, decode, NetworkItem, encode, JSONtoTextParser, ClientStatus, Permission, NetworkSlot,
+                      RawJSONtoTextParser, add_json_text, add_json_location, add_json_item, JSONTypes)
 from Utils import Version, stream_input, async_start
 from worlds import network_data_package, AutoWorldRegister
 import os
+import ssl
 
 if typing.TYPE_CHECKING:
     import kvui
@@ -33,6 +36,12 @@ logger = logging.getLogger("Client")
 gui_enabled = not sys.stdout or "--nogui" not in sys.argv
 
 
+@Utils.cache_argsless
+def get_ssl_context():
+    import certifi
+    return ssl.create_default_context(ssl.Purpose.SERVER_AUTH, cafile=certifi.where())
+
+
 class ClientCommandProcessor(CommandProcessor):
     def __init__(self, ctx: CommonContext):
         self.ctx = ctx
@@ -63,19 +72,29 @@ class ClientCommandProcessor(CommandProcessor):
 
     def _cmd_received(self) -> bool:
         """List all received items"""
-        self.output(f'{len(self.ctx.items_received)} received items:')
+        item: NetworkItem
+        self.output(f'{len(self.ctx.items_received)} received items, sorted by time:')
         for index, item in enumerate(self.ctx.items_received, 1):
-            self.output(f"{self.ctx.item_names[item.item]} from {self.ctx.player_names[item.player]}")
+            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"})
         return True
 
-    def _cmd_missing(self) -> bool:
-        """List all missing location checks, from your local game state"""
+    def _cmd_missing(self, filter_text = "") -> bool:
+        """List all missing location checks, from your local game state.
+        Can be given text, which will be used as filter."""
         if not self.ctx.game:
             self.output("No game set, cannot determine missing checks.")
             return False
         count = 0
         checked_count = 0
         for location, location_id in AutoWorldRegister.world_types[self.ctx.game].location_name_to_id.items():
+            if filter_text and filter_text not in location:
+                continue
             if location_id < 0:
                 continue
             if location_id not in self.ctx.locations_checked:
@@ -103,6 +122,15 @@ 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:
@@ -112,6 +140,15 @@ 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
@@ -154,6 +191,7 @@ class CommonContext:
     disconnected_intentionally: bool = False
     server: typing.Optional[Endpoint] = None
     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
 
     last_death_link: float = time.time()  # last send/received death link on AP layer
@@ -163,6 +201,7 @@ class CommonContext:
     server_address: typing.Optional[str]
     password: typing.Optional[str]
     hint_cost: typing.Optional[int]
+    hint_points: typing.Optional[int]
     player_names: typing.Dict[int, str]
 
     finished_game: bool
@@ -179,6 +218,10 @@ class CommonContext:
     server_locations: typing.Set[int]  # all locations the server knows of, missing_location | checked_locations
     locations_info: typing.Dict[int, NetworkItem]
 
+    # data storage
+    stored_data: typing.Dict[str, typing.Any]
+    stored_data_notification_keys: typing.Set[str]
+
     # internals
     # current message box through kvui
     _messagebox: typing.Optional["kvui.MessageBox"] = None
@@ -214,6 +257,9 @@ class CommonContext:
         self.server_locations = set()  # all locations the server knows of, missing_location | checked_locations
         self.locations_info = {}
 
+        self.stored_data = {}
+        self.stored_data_notification_keys = set()
+
         self.input_queue = asyncio.Queue()
         self.input_requests = 0
 
@@ -223,6 +269,7 @@ class CommonContext:
         self.watcher_event = asyncio.Event()
 
         self.jsontotextparser = JSONtoTextParser(self)
+        self.rawjsontotextparser = RawJSONtoTextParser(self)
         self.update_data_package(network_data_package)
 
         # execution
@@ -256,6 +303,7 @@ class CommonContext:
         self.items_received = []
         self.locations_info = {}
         self.server_version = Version(0, 0, 0)
+        self.generator_version = Version(0, 0, 0)
         self.server = None
         self.server_task = None
         self.hint_cost = None
@@ -357,10 +405,13 @@ class CommonContext:
 
     def on_print_json(self, args: dict):
         if self.ui:
-            self.ui.print_json(args["data"])
-        else:
-            text = self.jsontotextparser(args["data"])
-            logger.info(text)
+            # send copy to UI
+            self.ui.print_json(copy.deepcopy(args["data"]))
+
+        logging.getLogger("FileLog").info(self.rawjsontotextparser(copy.deepcopy(args["data"])),
+                                          extra={"NoStream": True})
+        logging.getLogger("StreamLog").info(self.jsontotextparser(copy.deepcopy(args["data"])),
+                                            extra={"NoFile": True})
 
     def on_package(self, cmd: str, args: dict):
         """For custom package handling in subclasses."""
@@ -434,7 +485,7 @@ class CommonContext:
                 else:
                     self.update_game(cached_game)
         if needed_updates:
-            await self.send_msgs([{"cmd": "GetDataPackage", "games": list(needed_updates)}])
+            await self.send_msgs([{"cmd": "GetDataPackage", "games": [game_name]} for game_name in needed_updates])
 
     def update_game(self, game_package: dict):
         for item_name, item_id in game_package["item_name_to_id"].items():
@@ -451,9 +502,25 @@ 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)
 
+    # data storage
+
+    def set_notify(self, *keys: str) -> None:
+        """Subscribe to be notified of changes to selected data storage keys.
+
+        The values can be accessed via the "stored_data" attribute of this context, which is a dictionary mapping the
+        names of the data storage keys to the latest values received from the server.
+        """
+        if new_keys := (set(keys) - self.stored_data_notification_keys):
+            self.stored_data_notification_keys.update(new_keys)
+            async_start(self.send_msgs([{"cmd": "Get",
+                                         "keys": list(new_keys)},
+                                        {"cmd": "SetNotify",
+                                         "keys": list(new_keys)}]))
+
     # DeathLink hooks
 
     def on_deathlink(self, data: typing.Dict[str, typing.Any]) -> None:
@@ -576,14 +643,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:
-        socket = await websockets.connect(address, port=port, ping_timeout=None, ping_interval=None)
+        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)
         if ctx.ui is not None:
             ctx.ui.update_address_bar(server_url.netloc)
         ctx.server = Endpoint(socket)
@@ -598,6 +666,7 @@ async def server_loop(ctx: CommonContext, address: typing.Optional[str] = None)
     except websockets.InvalidMessage:
         # probably encrypted
         if address.startswith("ws://"):
+            # try wss
             await server_loop(ctx, "ws" + address[1:])
         else:
             ctx.handle_connection_loss(f"Lost connection to the multiworld server due to InvalidMessage"
@@ -642,11 +711,16 @@ async def process_server_cmd(ctx: CommonContext, args: dict):
             logger.info('Room Information:')
             logger.info('--------------------------------')
             version = args["version"]
-            ctx.server_version = tuple(version)
-            version = ".".join(str(item) for item in version)
+            ctx.server_version = Version(*version)
 
-            logger.info(f'Server protocol version: {version}')
-            logger.info("Server protocol tags: " + ", ".join(args["tags"]))
+            if "generator_version" in args:
+                ctx.generator_version = Version(*args["generator_version"])
+                logger.info(f'Server protocol version: {ctx.server_version.as_simple_string()}, '
+                            f'generator version: {ctx.generator_version.as_simple_string()}, '
+                            f'tags: {", ".join(args["tags"])}')
+            else:
+                logger.info(f'Server protocol version: {ctx.server_version.as_simple_string()}, '
+                            f'tags: {", ".join(args["tags"])}')
             if args['password']:
                 logger.info('Password required')
             ctx.update_permissions(args.get("permissions", {}))
@@ -679,17 +753,19 @@ 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')
+            raise Exception('Server reported your client version as incompatible. '
+                            'This probably means you have to update.')
         elif 'InvalidItemsHandling' in errors:
             raise Exception('The item handling flags requested by the client are not supported')
         # last to check, recoverable problem
@@ -708,7 +784,9 @@ async def process_server_cmd(ctx: CommonContext, args: dict):
         ctx.slot = args["slot"]
         # int keys get lost in JSON transfer
         ctx.slot_info = {int(pid): data for pid, data in args["slot_info"].items()}
+        ctx.hint_points = args.get("hint_points", 0)
         ctx.consume_players_package(args["players"])
+        ctx.stored_data_notification_keys.add(f"_read_hints_{ctx.team}_{ctx.slot}")
         msgs = []
         if ctx.locations_checked:
             msgs.append({"cmd": "LocationChecks",
@@ -716,6 +794,11 @@ async def process_server_cmd(ctx: CommonContext, args: dict):
         if ctx.locations_scouted:
             msgs.append({"cmd": "LocationScouts",
                          "locations": list(ctx.locations_scouted)})
+        if ctx.stored_data_notification_keys:
+            msgs.append({"cmd": "Get",
+                         "keys": list(ctx.stored_data_notification_keys)})
+            msgs.append({"cmd": "SetNotify",
+                         "keys": list(ctx.stored_data_notification_keys)})
         if msgs:
             await ctx.send_msgs(msgs)
         if ctx.finished_game:
@@ -779,8 +862,17 @@ async def process_server_cmd(ctx: CommonContext, args: dict):
         # we can skip checking "DeathLink" in ctx.tags, as otherwise we wouldn't have been send this
         if "DeathLink" in tags and ctx.last_death_link != args["data"]["time"]:
             ctx.on_deathlink(args["data"])
+
+    elif cmd == "Retrieved":
+        ctx.stored_data.update(args["keys"])
+        if ctx.ui and f"_read_hints_{ctx.team}_{ctx.slot}" in args["keys"]:
+            ctx.ui.update_hints()
+
     elif cmd == "SetReply":
-        if args["key"] == "EnergyLink":
+        ctx.stored_data[args["key"]] = args["value"]
+        if ctx.ui and f"_read_hints_{ctx.team}_{ctx.slot}" == args["key"]:
+            ctx.ui.update_hints()
+        elif args["key"].startswith("EnergyLink"):
             ctx.current_energy_link_value = args["value"]
             if ctx.ui:
                 ctx.ui.set_new_energy_link_value()
@@ -820,11 +912,10 @@ def get_base_parser(description: typing.Optional[str] = None):
     return parser
 
 
-if __name__ == '__main__':
-    # Text Mode to use !hint and such with games that have no text entry
-
+def run_as_textclient():
     class TextContext(CommonContext):
-        tags = {"AP", "TextOnly"}
+        # Text Mode to use !hint and such with games that have no text entry
+        tags = CommonContext.tags | {"TextOnly"}
         game = ""  # empty matches any game since 0.3.2
         items_handling = 0b111  # receive all items for /received
         want_slot_data = False  # Can't use game specific slot_data
@@ -838,12 +929,11 @@ if __name__ == '__main__':
         def on_package(self, cmd: str, args: dict):
             if cmd == "Connected":
                 self.game = self.slot_info[self.slot].game
-        
+
         async def disconnect(self, allow_autoreconnect: bool = False):
             self.game = ""
             await super().disconnect(allow_autoreconnect)
 
-
     async def main(args):
         ctx = TextContext(args.connect, args.password)
         ctx.auth = args.name
@@ -856,7 +946,6 @@ if __name__ == '__main__':
         await ctx.exit_event.wait()
         await ctx.shutdown()
 
-
     import colorama
 
     parser = get_base_parser(description="Gameless Archipelago Client, for text interfacing.")
@@ -876,3 +965,8 @@ if __name__ == '__main__':
 
     asyncio.run(main(args))
     colorama.deinit()
+
+
+if __name__ == '__main__':
+    logging.getLogger().setLevel(logging.INFO)  # force log-level to work around log level resetting to WARNING
+    run_as_textclient()

FF1Client.py

@@ -13,9 +13,9 @@ from CommonClient import CommonContext, server_loop, gui_enabled, ClientCommandP
 
 SYSTEM_MESSAGE_ID = 0
 
-CONNECTION_TIMING_OUT_STATUS = "Connection timing out. Please restart your emulator, then restart ff1_connector.lua"
-CONNECTION_REFUSED_STATUS = "Connection Refused. Please start your emulator and make sure ff1_connector.lua is running"
-CONNECTION_RESET_STATUS = "Connection was reset. Please restart your emulator, then restart ff1_connector.lua"
+CONNECTION_TIMING_OUT_STATUS = "Connection timing out. Please restart your emulator, then restart connector_ff1.lua"
+CONNECTION_REFUSED_STATUS = "Connection Refused. Please start your emulator and make sure connector_ff1.lua is running"
+CONNECTION_RESET_STATUS = "Connection was reset. Please restart your emulator, then restart connector_ff1.lua"
 CONNECTION_TENTATIVE_STATUS = "Initial Connection Made"
 CONNECTION_CONNECTED_STATUS = "Connected"
 CONNECTION_INITIAL_STATUS = "Connection has not been initiated"
@@ -33,7 +33,7 @@ class FF1CommandProcessor(ClientCommandProcessor):
             logger.info(f"NES Status: {self.ctx.nes_status}")
 
     def _cmd_toggle_msgs(self):
-        """Toggle displaying messages in bizhawk"""
+        """Toggle displaying messages in EmuHawk"""
         global DISPLAY_MSGS
         DISPLAY_MSGS = not DISPLAY_MSGS
         logger.info(f"Messages are now {'enabled' if DISPLAY_MSGS  else 'disabled'}")

FactorioClient.py

@@ -1,553 +1,12 @@
 from __future__ import annotations
-import os
-import logging
-import json
-import string
-import copy
-import re
-import subprocess
-import sys
-import time
-import random
-import typing
 
 import ModuleUpdate
 ModuleUpdate.update()
 
-import factorio_rcon
-import colorama
-import asyncio
-from queue import Queue
+from worlds.factorio.Client import check_stdin, launch
 import Utils
 
-def check_stdin() -> None:
-    if Utils.is_windows and sys.stdin:
-        print("WARNING: Console input is not routed reliably on Windows, use the GUI instead.")
-
 if __name__ == "__main__":
     Utils.init_logging("FactorioClient", exception_logger="Client")
     check_stdin()
-
-from CommonClient import CommonContext, server_loop, ClientCommandProcessor, logger, gui_enabled, get_base_parser
-from MultiServer import mark_raw
-from NetUtils import NetworkItem, ClientStatus, JSONtoTextParser, JSONMessagePart
-from Utils import async_start
-
-from worlds.factorio import Factorio
-
-
-class FactorioCommandProcessor(ClientCommandProcessor):
-    ctx: FactorioContext
-
-    def _cmd_energy_link(self):
-        """Print the status of the energy link."""
-        self.output(f"Energy Link: {self.ctx.energy_link_status}")
-
-    @mark_raw
-    def _cmd_factorio(self, text: str) -> bool:
-        """Send the following command to the bound Factorio Server."""
-        if self.ctx.rcon_client:
-            # TODO: Print the command non-silently only for race seeds, or otherwise block anything but /factorio /save in race seeds.
-            self.ctx.print_to_game(f"/factorio {text}")
-            result = self.ctx.rcon_client.send_command(text)
-            if result:
-                self.output(result)
-            return True
-        return False
-
-    def _cmd_resync(self):
-        """Manually trigger a resync."""
-        self.ctx.awaiting_bridge = True
-
-    def _cmd_toggle_send_filter(self):
-        """Toggle filtering of item sends that get displayed in-game to only those that involve you."""
-        self.ctx.toggle_filter_item_sends()
-
-    def _cmd_toggle_chat(self):
-        """Toggle sending of chat messages from players on the Factorio server to Archipelago."""
-        self.ctx.toggle_bridge_chat_out()
-
-class FactorioContext(CommonContext):
-    command_processor = FactorioCommandProcessor
-    game = "Factorio"
-    items_handling = 0b111  # full remote
-
-    # updated by spinup server
-    mod_version: Utils.Version = Utils.Version(0, 0, 0)
-
-    def __init__(self, server_address, password):
-        super(FactorioContext, self).__init__(server_address, password)
-        self.send_index: int = 0
-        self.rcon_client = None
-        self.awaiting_bridge = False
-        self.write_data_path = None
-        self.death_link_tick: int = 0  # last send death link on Factorio layer
-        self.factorio_json_text_parser = FactorioJSONtoTextParser(self)
-        self.energy_link_increment = 0
-        self.last_deplete = 0
-        self.filter_item_sends: bool = False
-        self.multiplayer: bool = False  # whether multiple different players have connected
-        self.bridge_chat_out: bool = True
-
-    async def server_auth(self, password_requested: bool = False):
-        if password_requested and not self.password:
-            await super(FactorioContext, self).server_auth(password_requested)
-
-        if self.rcon_client:
-            await get_info(self, self.rcon_client)  # retrieve current auth code
-        else:
-            raise Exception("Cannot connect to a server with unknown own identity, "
-                            "bridge to Factorio first.")
-
-        await self.send_connect()
-
-    def on_print(self, args: dict):
-        super(FactorioContext, self).on_print(args)
-        if self.rcon_client:
-            if not args['text'].startswith(self.player_names[self.slot] + ":"):
-                self.print_to_game(args['text'])
-
-    def on_print_json(self, args: dict):
-        if self.rcon_client:
-            if (not self.filter_item_sends or not self.is_uninteresting_item_send(args)) \
-                    and not self.is_echoed_chat(args):
-                text = self.factorio_json_text_parser(copy.deepcopy(args["data"]))
-                if not text.startswith(self.player_names[self.slot] + ":"): # TODO: Remove string heuristic in the future.
-                    self.print_to_game(text)
-        super(FactorioContext, self).on_print_json(args)
-
-    @property
-    def savegame_name(self) -> str:
-        return f"AP_{self.seed_name}_{self.auth}_Save.zip"
-
-    def print_to_game(self, text):
-        self.rcon_client.send_command(f"/ap-print [font=default-large-bold]Archipelago:[/font] "
-                                      f"{text}")
-
-    @property
-    def energy_link_status(self) -> str:
-        if not self.energy_link_increment:
-            return "Disabled"
-        elif self.current_energy_link_value is None:
-            return "Standby"
-        else:
-            return f"{Utils.format_SI_prefix(self.current_energy_link_value)}J"
-
-    def on_deathlink(self, data: dict):
-        if self.rcon_client:
-            self.rcon_client.send_command(f"/ap-deathlink {data['source']}")
-        super(FactorioContext, self).on_deathlink(data)
-
-    def on_package(self, cmd: str, args: dict):
-        if cmd in {"Connected", "RoomUpdate"}:
-            # catch up sync anything that is already cleared.
-            if "checked_locations" in args and args["checked_locations"]:
-                self.rcon_client.send_commands({item_name: f'/ap-get-technology ap-{item_name}-\t-1' for
-                                                item_name in args["checked_locations"]})
-            if cmd == "Connected" and self.energy_link_increment:
-                async_start(self.send_msgs([{
-                    "cmd": "SetNotify", "keys": ["EnergyLink"]
-                }]))
-        elif cmd == "SetReply":
-            if args["key"] == "EnergyLink":
-                if self.energy_link_increment and args.get("last_deplete", -1) == self.last_deplete:
-                    # it's our deplete request
-                    gained = int(args["original_value"] - args["value"])
-                    gained_text = Utils.format_SI_prefix(gained) + "J"
-                    if gained:
-                        logger.debug(f"EnergyLink: Received {gained_text}. "
-                                     f"{Utils.format_SI_prefix(args['value'])}J remaining.")
-                        self.rcon_client.send_command(f"/ap-energylink {gained}")
-
-    def on_user_say(self, text: str) -> typing.Optional[str]:
-        # Mirror chat sent from the UI to the Factorio server.
-        self.print_to_game(f"{self.player_names[self.slot]}: {text}")
-        return text
-
-    async def chat_from_factorio(self, user: str, message: str) -> None:
-        if not self.bridge_chat_out:
-            return
-
-        # Pass through commands
-        if message.startswith("!"):
-            await self.send_msgs([{"cmd": "Say", "text": message}])
-            return
-
-        # Omit messages that contain local coordinates
-        if "[gps=" in message:
-            return
-
-        prefix = f"({user}) " if self.multiplayer else ""
-        await self.send_msgs([{"cmd": "Say", "text": f"{prefix}{message}"}])
-
-    def toggle_filter_item_sends(self) -> None:
-        self.filter_item_sends = not self.filter_item_sends
-        if self.filter_item_sends:
-            announcement = "Item sends are now filtered."
-        else:
-            announcement = "Item sends are no longer filtered."
-        logger.info(announcement)
-        self.print_to_game(announcement)
-
-    def toggle_bridge_chat_out(self) -> None:
-        self.bridge_chat_out = not self.bridge_chat_out
-        if self.bridge_chat_out:
-            announcement = "Chat is now bridged to Archipelago."
-        else:
-            announcement = "Chat is no longer bridged to Archipelago."
-        logger.info(announcement)
-        self.print_to_game(announcement)
-
-    def run_gui(self):
-        from kvui import GameManager
-
-        class FactorioManager(GameManager):
-            logging_pairs = [
-                ("Client", "Archipelago"),
-                ("FactorioServer", "Factorio Server Log"),
-                ("FactorioWatcher", "Bridge Data Log"),
-            ]
-            base_title = "Archipelago Factorio Client"
-
-        self.ui = FactorioManager(self)
-        self.ui_task = asyncio.create_task(self.ui.async_run(), name="UI")
-
-
-async def game_watcher(ctx: FactorioContext):
-    bridge_logger = logging.getLogger("FactorioWatcher")
-    next_bridge = time.perf_counter() + 1
-    try:
-        while not ctx.exit_event.is_set():
-            # TODO: restore on-demand refresh
-            if ctx.rcon_client and time.perf_counter() > next_bridge:
-                next_bridge = time.perf_counter() + 1
-                ctx.awaiting_bridge = False
-                data = json.loads(ctx.rcon_client.send_command("/ap-sync"))
-                if not ctx.auth:
-                    pass  # auth failed, wait for new attempt
-                elif data["slot_name"] != ctx.auth:
-                    bridge_logger.warning(f"Connected World is not the expected one {data['slot_name']} != {ctx.auth}")
-                elif data["seed_name"] != ctx.seed_name:
-                    bridge_logger.warning(
-                        f"Connected Multiworld is not the expected one {data['seed_name']} != {ctx.seed_name}")
-                else:
-                    data = data["info"]
-                    research_data = data["research_done"]
-                    research_data = {int(tech_name.split("-")[1]) for tech_name in research_data}
-                    victory = data["victory"]
-                    await ctx.update_death_link(data["death_link"])
-                    ctx.multiplayer = data.get("multiplayer", False)
-
-                    if not ctx.finished_game and victory:
-                        await ctx.send_msgs([{"cmd": "StatusUpdate", "status": ClientStatus.CLIENT_GOAL}])
-                        ctx.finished_game = True
-
-                    if ctx.locations_checked != research_data:
-                        bridge_logger.debug(
-                            f"New researches done: "
-                            f"{[ctx.location_names[rid] for rid in research_data - ctx.locations_checked]}")
-                        ctx.locations_checked = research_data
-                        await ctx.send_msgs([{"cmd": 'LocationChecks', "locations": tuple(research_data)}])
-                    death_link_tick = data.get("death_link_tick", 0)
-                    if death_link_tick != ctx.death_link_tick:
-                        ctx.death_link_tick = death_link_tick
-                        if "DeathLink" in ctx.tags:
-                            async_start(ctx.send_death())
-                    if ctx.energy_link_increment:
-                        in_world_bridges = data["energy_bridges"]
-                        if in_world_bridges:
-                            in_world_energy = data["energy"]
-                            if in_world_energy < (ctx.energy_link_increment * in_world_bridges):
-                                # attempt to refill
-                                ctx.last_deplete = time.time()
-                                async_start(ctx.send_msgs([{
-                                    "cmd": "Set", "key": "EnergyLink", "operations":
-                                        [{"operation": "add", "value": -ctx.energy_link_increment * in_world_bridges},
-                                         {"operation": "max", "value": 0}],
-                                    "last_deplete": ctx.last_deplete
-                                }]))
-                            # Above Capacity - (len(Bridges) * ENERGY_INCREMENT)
-                            elif in_world_energy > (in_world_bridges * ctx.energy_link_increment * 5) - \
-                                ctx.energy_link_increment*in_world_bridges:
-                                value = ctx.energy_link_increment * in_world_bridges
-                                async_start(ctx.send_msgs([{
-                                    "cmd": "Set", "key": "EnergyLink", "operations":
-                                        [{"operation": "add", "value": value}]
-                                }]))
-                                ctx.rcon_client.send_command(
-                                    f"/ap-energylink -{value}")
-                                logger.debug(f"EnergyLink: Sent {Utils.format_SI_prefix(value)}J")
-
-            await asyncio.sleep(0.1)
-
-    except Exception as e:
-        logging.exception(e)
-        logging.error("Aborted Factorio Server Bridge")
-
-
-def stream_factorio_output(pipe, queue, process):
-    pipe.reconfigure(errors="replace")
-
-    def queuer():
-        while process.poll() is None:
-            text = pipe.readline().strip()
-            if text:
-                queue.put_nowait(text)
-
-    from threading import Thread
-
-    thread = Thread(target=queuer, name="Factorio Output Queue", daemon=True)
-    thread.start()
-    return thread
-
-
-async def factorio_server_watcher(ctx: FactorioContext):
-    savegame_name = os.path.abspath(ctx.savegame_name)
-    if not os.path.exists(savegame_name):
-        logger.info(f"Creating savegame {savegame_name}")
-        subprocess.run((
-            executable, "--create", savegame_name, "--preset", "archipelago"
-        ))
-    factorio_process = subprocess.Popen((executable, "--start-server", ctx.savegame_name,
-                                         *(str(elem) for elem in server_args)),
-                                        stderr=subprocess.PIPE,
-                                        stdout=subprocess.PIPE,
-                                        stdin=subprocess.DEVNULL,
-                                        encoding="utf-8")
-    factorio_server_logger.info("Started Factorio Server")
-    factorio_queue = Queue()
-    stream_factorio_output(factorio_process.stdout, factorio_queue, factorio_process)
-    stream_factorio_output(factorio_process.stderr, factorio_queue, factorio_process)
-    try:
-        while not ctx.exit_event.is_set():
-            if factorio_process.poll() is not None:
-                factorio_server_logger.info("Factorio server has exited.")
-                ctx.exit_event.set()
-
-            while not factorio_queue.empty():
-                msg = factorio_queue.get()
-                factorio_queue.task_done()
-
-                if not ctx.rcon_client and "Starting RCON interface at IP ADDR:" in msg:
-                    ctx.rcon_client = factorio_rcon.RCONClient("localhost", rcon_port, rcon_password)
-                    if not ctx.server:
-                        logger.info("Established bridge to Factorio Server. "
-                                    "Ready to connect to Archipelago via /connect")
-                        check_stdin()
-
-                if not ctx.awaiting_bridge and "Archipelago Bridge Data available for game tick " in msg:
-                    ctx.awaiting_bridge = True
-                    factorio_server_logger.debug(msg)
-                elif re.match(r"^[0-9.]+ Script @[^ ]+\.lua:\d+: Player command energy-link$", msg):
-                    factorio_server_logger.debug(msg)
-                    ctx.print_to_game(f"Energy Link: {ctx.energy_link_status}")
-                elif re.match(r"^[0-9.]+ Script @[^ ]+\.lua:\d+: Player command toggle-ap-send-filter$", msg):
-                    factorio_server_logger.debug(msg)
-                    ctx.toggle_filter_item_sends()
-                elif re.match(r"^[0-9.]+ Script @[^ ]+\.lua:\d+: Player command toggle-ap-chat$", msg):
-                    factorio_server_logger.debug(msg)
-                    ctx.toggle_bridge_chat_out()
-                else:
-                    factorio_server_logger.info(msg)
-                    match = re.match(r"^\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d \[CHAT\] ([^:]+): (.*)$", msg)
-                    if match:
-                        await ctx.chat_from_factorio(match.group(1), match.group(2))
-            if ctx.rcon_client:
-                commands = {}
-                while ctx.send_index < len(ctx.items_received):
-                    transfer_item: NetworkItem = ctx.items_received[ctx.send_index]
-                    item_id = transfer_item.item
-                    player_name = ctx.player_names[transfer_item.player]
-                    if item_id not in Factorio.item_id_to_name:
-                        factorio_server_logger.error(f"Cannot send unknown item ID: {item_id}")
-                    else:
-                        item_name = Factorio.item_id_to_name[item_id]
-                        factorio_server_logger.info(f"Sending {item_name} to Nauvis from {player_name}.")
-                        commands[ctx.send_index] = f'/ap-get-technology {item_name}\t{ctx.send_index}\t{player_name}'
-                    ctx.send_index += 1
-                if commands:
-                    ctx.rcon_client.send_commands(commands)
-            await asyncio.sleep(0.1)
-
-    except Exception as e:
-        logging.exception(e)
-        logging.error("Aborted Factorio Server Bridge")
-        ctx.exit_event.set()
-
-    finally:
-        if factorio_process.poll() is not None:
-            if ctx.rcon_client:
-                ctx.rcon_client.close()
-                ctx.rcon_client = None
-            return
-
-        sent_quit = False
-        if ctx.rcon_client:
-            # Attempt clean quit through RCON.
-            try:
-                ctx.rcon_client.send_command("/quit")
-            except factorio_rcon.RCONNetworkError:
-                pass
-            else:
-                sent_quit = True
-            ctx.rcon_client.close()
-            ctx.rcon_client = None
-        if not sent_quit:
-            # Attempt clean quit using SIGTERM. (Note that on Windows this kills the process instead.)
-            factorio_process.terminate()
-
-        try:
-            factorio_process.wait(10)
-        except subprocess.TimeoutExpired:
-            factorio_process.kill()
-
-
-async def get_info(ctx: FactorioContext, rcon_client: factorio_rcon.RCONClient):
-    info = json.loads(rcon_client.send_command("/ap-rcon-info"))
-    ctx.auth = info["slot_name"]
-    ctx.seed_name = info["seed_name"]
-    # 0.2.0 addition, not present earlier
-    death_link = bool(info.get("death_link", False))
-    ctx.energy_link_increment = info.get("energy_link", 0)
-    logger.debug(f"Energy Link Increment: {ctx.energy_link_increment}")
-    if ctx.energy_link_increment and ctx.ui:
-        ctx.ui.enable_energy_link()
-    await ctx.update_death_link(death_link)
-
-
-async def factorio_spinup_server(ctx: FactorioContext) -> bool:
-    savegame_name = os.path.abspath("Archipelago.zip")
-    if not os.path.exists(savegame_name):
-        logger.info(f"Creating savegame {savegame_name}")
-        subprocess.run((
-            executable, "--create", savegame_name
-        ))
-    factorio_process = subprocess.Popen(
-        (executable, "--start-server", savegame_name, *(str(elem) for elem in server_args)),
-        stderr=subprocess.PIPE,
-        stdout=subprocess.PIPE,
-        stdin=subprocess.DEVNULL,
-        encoding="utf-8")
-    factorio_server_logger.info("Started Information Exchange Factorio Server")
-    factorio_queue = Queue()
-    stream_factorio_output(factorio_process.stdout, factorio_queue, factorio_process)
-    stream_factorio_output(factorio_process.stderr, factorio_queue, factorio_process)
-    rcon_client = None
-    try:
-        while not ctx.auth:
-            while not factorio_queue.empty():
-                msg = factorio_queue.get()
-                factorio_server_logger.info(msg)
-                if "Loading mod AP-" in msg and msg.endswith("(data.lua)"):
-                    parts = msg.split()
-                    ctx.mod_version = Utils.Version(*(int(number) for number in parts[-2].split(".")))
-                elif "Write data path: " in msg:
-                    ctx.write_data_path = Utils.get_text_between(msg, "Write data path: ", " [")
-                    if "AppData" in ctx.write_data_path:
-                        logger.warning("It appears your mods are loaded from Appdata, "
-                                       "this can lead to problems with multiple Factorio instances. "
-                                       "If this is the case, you will get a file locked error running Factorio.")
-                if not rcon_client and "Starting RCON interface at IP ADDR:" in msg:
-                    rcon_client = factorio_rcon.RCONClient("localhost", rcon_port, rcon_password)
-                    if ctx.mod_version == ctx.__class__.mod_version:
-                        raise Exception("No Archipelago mod was loaded. Aborting.")
-                    await get_info(ctx, rcon_client)
-            await asyncio.sleep(0.01)
-
-    except Exception as e:
-        logger.exception(e, extra={"compact_gui": True})
-        msg = "Aborted Factorio Server Bridge"
-        logger.error(msg)
-        ctx.gui_error(msg, e)
-        ctx.exit_event.set()
-
-    else:
-        logger.info(
-            f"Got World Information from AP Mod {tuple(ctx.mod_version)} for seed {ctx.seed_name} in slot {ctx.auth}")
-        return True
-    finally:
-        factorio_process.terminate()
-        factorio_process.wait(5)
-    return False
-
-
-async def main(args):
-    ctx = FactorioContext(args.connect, args.password)
-    ctx.filter_item_sends = initial_filter_item_sends
-    ctx.bridge_chat_out = initial_bridge_chat_out
-    ctx.server_task = asyncio.create_task(server_loop(ctx), name="ServerLoop")
-
-    if gui_enabled:
-        ctx.run_gui()
-    ctx.run_cli()
-
-    factorio_server_task = asyncio.create_task(factorio_spinup_server(ctx), name="FactorioSpinupServer")
-    successful_launch = await factorio_server_task
-    if successful_launch:
-        factorio_server_task = asyncio.create_task(factorio_server_watcher(ctx), name="FactorioServer")
-        progression_watcher = asyncio.create_task(
-            game_watcher(ctx), name="FactorioProgressionWatcher")
-
-        await ctx.exit_event.wait()
-        ctx.server_address = None
-
-        await progression_watcher
-        await factorio_server_task
-
-    await ctx.shutdown()
-
-
-class FactorioJSONtoTextParser(JSONtoTextParser):
-    def _handle_color(self, node: JSONMessagePart):
-        colors = node["color"].split(";")
-        for color in colors:
-            if color in self.color_codes:
-                node["text"] = f"[color=#{self.color_codes[color]}]{node['text']}[/color]"
-            return self._handle_text(node)
-        return self._handle_text(node)
-
-
-if __name__ == '__main__':
-    parser = get_base_parser(description="Optional arguments to FactorioClient follow. "
-                                         "Remaining arguments get passed into bound Factorio instance."
-                                         "Refer to Factorio --help for those.")
-    parser.add_argument('--rcon-port', default='24242', type=int, help='Port to use to communicate with Factorio')
-    parser.add_argument('--rcon-password', help='Password to authenticate with RCON.')
-    parser.add_argument('--server-settings', help='Factorio server settings configuration file.')
-
-    args, rest = parser.parse_known_args()
-    colorama.init()
-    rcon_port = args.rcon_port
-    rcon_password = args.rcon_password if args.rcon_password else ''.join(
-        random.choice(string.ascii_letters) for x in range(32))
-
-    factorio_server_logger = logging.getLogger("FactorioServer")
-    options = Utils.get_options()
-    executable = options["factorio_options"]["executable"]
-    server_settings = args.server_settings if args.server_settings else options["factorio_options"].get("server_settings", None)
-    if server_settings:
-        server_settings = os.path.abspath(server_settings)
-    if not isinstance(options["factorio_options"]["filter_item_sends"], bool):
-        logging.warning(f"Warning: Option filter_item_sends should be a bool.")
-    initial_filter_item_sends = bool(options["factorio_options"]["filter_item_sends"])
-    if not isinstance(options["factorio_options"]["bridge_chat_out"], bool):
-        logging.warning(f"Warning: Option bridge_chat_out should be a bool.")
-    initial_bridge_chat_out = bool(options["factorio_options"]["bridge_chat_out"])
-
-    if not os.path.exists(os.path.dirname(executable)):
-        raise FileNotFoundError(f"Path {os.path.dirname(executable)} does not exist or could not be accessed.")
-    if os.path.isdir(executable):  # user entered a path to a directory, let's find the executable therein
-        executable = os.path.join(executable, "factorio")
-    if not os.path.isfile(executable):
-        if os.path.isfile(executable + ".exe"):
-            executable = executable + ".exe"
-        else:
-            raise FileNotFoundError(f"Path {executable} is not an executable file.")
-
-    if server_settings and os.path.isfile(server_settings):
-        server_args = ("--rcon-port", rcon_port, "--rcon-password", rcon_password, "--server-settings", server_settings, *rest)
-    else:
-        server_args = ("--rcon-port", rcon_port, "--rcon-password", rcon_password, *rest)
-
-    asyncio.run(main(args))
-    colorama.deinit()
+    launch()

Fill.py

@@ -1,10 +1,11 @@
-import logging
-import typing
 import collections
 import itertools
+import logging
+import typing
 from collections import Counter, deque
 
-from BaseClasses import CollectionState, Location, LocationProgressType, MultiWorld, Item, ItemClassification
+from BaseClasses import CollectionState, Item, Location, LocationProgressType, MultiWorld
+from Options import Accessibility
 
 from worlds.AutoWorld import call_all
 from worlds.generic.Rules import add_item_rule
@@ -14,6 +15,10 @@ class FillError(RuntimeError):
     pass
 
 
+def _log_fill_progress(name: str, placed: int, total_items: int) -> None:
+    logging.info(f"Current fill step ({name}) at {placed}/{total_items} items placed.")
+
+
 def sweep_from_pool(base_state: CollectionState, itempool: typing.Sequence[Item] = tuple()) -> CollectionState:
     new_state = base_state.copy()
     for item in itempool:
@@ -22,12 +27,12 @@ def sweep_from_pool(base_state: CollectionState, itempool: typing.Sequence[Item]
     return new_state
 
 
-def fill_restrictive(world: MultiWorld, base_state: CollectionState, locations: typing.List[Location],
+def fill_restrictive(multiworld: 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) -> None:
+                     allow_partial: bool = False, allow_excluded: bool = False, name: str = "Unknown") -> None:
     """
-    :param world: Multiworld to be filled.
+    :param multiworld: 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
@@ -37,25 +42,33 @@ def fill_restrictive(world: MultiWorld, base_state: CollectionState, locations:
     :param on_place: callback that is called when a placement happens
     :param allow_partial: only place what is possible. Remaining items will be in the item_pool list.
     :param allow_excluded: if true and placement fails, it is re-attempted while ignoring excluded on Locations
+    :param name: name of this fill step for progress logging purposes
     """
     unplaced_items: typing.List[Item] = []
     placements: typing.List[Location] = []
-
-    swapped_items: typing.Counter[typing.Tuple[int, str]] = Counter()
+    cleanup_required = False
+    swapped_items: typing.Counter[typing.Tuple[int, str, bool]] = Counter()
     reachable_items: typing.Dict[int, typing.Deque[Item]] = {}
     for item in item_pool:
         reachable_items.setdefault(item.player, deque()).append(item)
 
+    # for progress logging
+    total = min(len(item_pool), len(locations))
+    placed = 0
+
     while any(reachable_items.values()) and locations:
         # grab one item per player
         items_to_place = [items.pop()
                           for items in reachable_items.values() if items]
         for item in items_to_place:
-            item_pool.remove(item)
+            for p, pool_item in enumerate(item_pool):
+                if pool_item is item:
+                    item_pool.pop(p)
+                    break
         maximum_exploration_state = sweep_from_pool(
             base_state, item_pool + unplaced_items)
 
-        has_beaten_game = world.has_beaten_game(maximum_exploration_state)
+        has_beaten_game = multiworld.has_beaten_game(maximum_exploration_state)
 
         while items_to_place:
             # if we have run out of locations to fill,break out of this loop
@@ -67,8 +80,8 @@ def fill_restrictive(world: MultiWorld, base_state: CollectionState, locations:
             spot_to_fill: typing.Optional[Location] = None
 
             # if minimal accessibility, only check whether location is reachable if game not beatable
-            if world.accessibility[item_to_place.player] == 'minimal':
-                perform_access_check = not world.has_beaten_game(maximum_exploration_state,
+            if multiworld.worlds[item_to_place.player].options.accessibility == Accessibility.option_minimal:
+                perform_access_check = not multiworld.has_beaten_game(maximum_exploration_state,
                                                                  item_to_place.player) \
                     if single_player_placement else not has_beaten_game
             else:
@@ -85,32 +98,35 @@ def fill_restrictive(world: MultiWorld, base_state: CollectionState, locations:
             else:
                 # we filled all reachable spots.
                 if swap:
-                    # try swapping this item with previously placed items
-                    for (i, location) in enumerate(placements):
+                    # try swapping this item with previously placed items in a safe way then in an unsafe way
+                    swap_attempts = ((i, location, unsafe)
+                                     for unsafe in (False, True)
+                                     for i, location in enumerate(placements))
+                    for (i, location, unsafe) in swap_attempts:
                         placed_item = location.item
                         # Unplaceable items can sometimes be swapped infinitely. Limit the
                         # number of times we will swap an individual item to prevent this
-                        swap_count = swapped_items[placed_item.player,
-                                                   placed_item.name]
+                        swap_count = swapped_items[placed_item.player, placed_item.name, unsafe]
                         if swap_count > 1:
                             continue
 
                         location.item = None
                         placed_item.location = None
-                        swap_state = sweep_from_pool(base_state, [placed_item])
-                        # swap_state assumes we can collect placed item before item_to_place
+                        swap_state = sweep_from_pool(base_state, [placed_item, *item_pool] if unsafe else item_pool)
+                        # unsafe means swap_state assumes we can somehow collect placed_item before item_to_place
+                        # by continuing to swap, which is not guaranteed. This is unsafe because there is no mechanic
+                        # to clean that up later, so there is a chance generation fails.
                         if (not single_player_placement or location.player == item_to_place.player) \
                                 and location.can_fill(swap_state, item_to_place, perform_access_check):
 
-                            # Verify that placing this item won't reduce available locations, which could happen with rules
-                            # that want to not have both items. Left in until removal is proven useful.
+                            # Verify placing this item won't reduce available locations, which would be a useless swap.
                             prev_state = swap_state.copy()
                             prev_loc_count = len(
-                                world.get_reachable_locations(prev_state))
+                                multiworld.get_reachable_locations(prev_state))
 
                             swap_state.collect(item_to_place, True)
                             new_loc_count = len(
-                                world.get_reachable_locations(swap_state))
+                                multiworld.get_reachable_locations(swap_state))
 
                             if new_loc_count >= prev_loc_count:
                                 # Add this item to the existing placement, and
@@ -118,13 +134,15 @@ def fill_restrictive(world: MultiWorld, base_state: CollectionState, locations:
                                 spot_to_fill = placements.pop(i)
 
                                 swap_count += 1
-                                swapped_items[placed_item.player,
-                                              placed_item.name] = swap_count
+                                swapped_items[placed_item.player, placed_item.name, unsafe] = swap_count
 
                                 reachable_items[placed_item.player].appendleft(
                                     placed_item)
                                 item_pool.append(placed_item)
 
+                                # cleanup at the end to hopefully get better errors
+                                cleanup_required = True
+
                                 break
 
                         # Item can't be placed here, restore original item
@@ -138,13 +156,29 @@ def fill_restrictive(world: MultiWorld, base_state: CollectionState, locations:
                 else:
                     unplaced_items.append(item_to_place)
                     continue
-            world.push_item(spot_to_fill, item_to_place, False)
+            multiworld.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)
             if on_place:
                 on_place(spot_to_fill)
 
+    if total > 1000:
+        _log_fill_progress(name, placed, total)
+
+    if cleanup_required:
+        # 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):
+                placement.item.location = None
+                unplaced_items.append(placement.item)
+                placement.item = None
+                locations.append(placement)
+
     if allow_excluded:
         # check if partial fill is the result of excluded locations, in which case retry
         excluded_locations = [
@@ -154,7 +188,7 @@ def fill_restrictive(world: MultiWorld, base_state: CollectionState, locations:
         if excluded_locations:
             for location in excluded_locations:
                 location.progress_type = location.progress_type.DEFAULT
-            fill_restrictive(world, base_state, excluded_locations, unplaced_items, single_player_placement, lock,
+            fill_restrictive(multiworld, 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:
@@ -162,22 +196,31 @@ def fill_restrictive(world: MultiWorld, base_state: CollectionState, locations:
 
     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 world.can_beat_game():
+        if multiworld.can_beat_game():
             logging.warning(
-                f'Not all items placed. Game beatable anyway. (Could not place {unplaced_items})')
+                f"Not all items placed. Game beatable anyway.\nCould not place:\n"
+                f"{', '.join(str(item) for item in unplaced_items)}")
         else:
-            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)}')
+            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)}")
 
     item_pool.extend(unplaced_items)
 
 
-def remaining_fill(world: MultiWorld,
+def remaining_fill(multiworld: MultiWorld,
                    locations: typing.List[Location],
-                   itempool: typing.List[Item]) -> None:
+                   itempool: typing.List[Item],
+                   name: str = "Remaining") -> None:
     unplaced_items: typing.List[Item] = []
     placements: typing.List[Location] = []
     swapped_items: typing.Counter[typing.Tuple[int, str]] = Counter()
+    total = min(len(itempool),  len(locations))
+    placed = 0
     while locations and itempool:
         item_to_place = itempool.pop()
         spot_to_fill: typing.Optional[Location] = None
@@ -225,30 +268,41 @@ def remaining_fill(world: MultiWorld,
                 unplaced_items.append(item_to_place)
                 continue
 
-        world.push_item(spot_to_fill, item_to_place, False)
+        multiworld.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)
+
+    if total > 1000:
+        _log_fill_progress(name, 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 {unplaced_items}, locations {locations} are invalid. '
-                        f'Already placed {len(placements)}: {", ".join(str(place) for place in placements)}')
+        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)}")
 
     itempool.extend(unplaced_items)
 
 
-def fast_fill(world: MultiWorld,
+def fast_fill(multiworld: 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):
-        world.push_item(location, item, False)
+        multiworld.push_item(location, item, False)
     return item_pool[placing:], fill_locations[placing:]
 
 
-def accessibility_corrections(world: MultiWorld, state: CollectionState, locations, pool=[]):
+def accessibility_corrections(multiworld: MultiWorld, state: CollectionState, locations, pool=[]):
     maximum_exploration_state = sweep_from_pool(state, pool)
-    minimal_players = {player for player in world.player_ids if world.accessibility[player] == "minimal"}
-    unreachable_locations = [location for location in world.get_locations() if location.player in minimal_players and
+    minimal_players = {player for player in multiworld.player_ids if multiworld.worlds[player].options.accessibility == "minimal"}
+    unreachable_locations = [location for location in multiworld.get_locations() if location.player in minimal_players and
                              not location.can_reach(maximum_exploration_state)]
     for location in unreachable_locations:
         if (location.item is not None and location.item.advancement and location.address is not None and not
@@ -262,36 +316,36 @@ def accessibility_corrections(world: MultiWorld, state: CollectionState, locatio
             locations.append(location)
     if pool and locations:
         locations.sort(key=lambda loc: loc.progress_type != LocationProgressType.PRIORITY)
-        fill_restrictive(world, state, locations, pool)
+        fill_restrictive(multiworld, state, locations, pool, name="Accessibility Corrections")
 
 
-def inaccessible_location_rules(world: MultiWorld, state: CollectionState, locations):
+def inaccessible_location_rules(multiworld: 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 world.accessibility[item.player] != 'minimal')
+            return not ((item.classification & 0b0011) and multiworld.worlds[item.player].options.accessibility != 'minimal')
 
         for location in unreachable_locations:
             add_item_rule(location, forbid_important_item_rule)
 
 
-def distribute_early_items(world: MultiWorld,
+def distribute_early_items(multiworld: 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 world.player_ids:
-        items = itertools.chain(world.early_items[player], world.local_early_items[player])
+    for player in multiworld.player_ids:
+        items = itertools.chain(multiworld.early_items[player], multiworld.local_early_items[player])
         for item in items:
-            early_items_count[item, player] = [world.early_items[player].get(item, 0),
-                                               world.local_early_items[player].get(item, 0)]
+            early_items_count[item, player] = [multiworld.early_items[player].get(item, 0),
+                                               multiworld.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 = world.state.copy()
-        base_state.sweep_for_events(locations=(loc for loc in world.get_filled_locations() if loc.address is None))
+        base_state = multiworld.state.copy()
+        base_state.sweep_for_events(locations=(loc for loc in multiworld.get_filled_locations() if loc.address is None))
         for i, loc in enumerate(fill_locations):
             if loc.can_reach(base_state):
                 if loc.progress_type == LocationProgressType.PRIORITY:
@@ -303,8 +357,8 @@ def distribute_early_items(world: 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 world.player_ids}
-        early_local_rest_items: typing.Dict[int, typing.List[Item]] = {player: [] for player in world.player_ids}
+        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}
         item_indexes_to_remove: typing.Set[int] = set()
         for i, item in enumerate(itempool):
             if (item.name, item.player) in early_items_count:
@@ -328,27 +382,29 @@ def distribute_early_items(world: 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 world.player_ids:
+        for player in multiworld.player_ids:
             player_local = early_local_rest_items[player]
-            fill_restrictive(world, base_state,
+            fill_restrictive(multiworld, base_state,
                              [loc for loc in early_locations if loc.player == player],
-                             player_local, lock=True, allow_partial=True)
+                             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(world, base_state, early_locations, early_rest_items, lock=True, allow_partial=True)
+        fill_restrictive(multiworld, base_state, early_locations, early_rest_items, lock=True, allow_partial=True,
+                         name="Early Items")
         early_locations += early_priority_locations
-        for player in world.player_ids:
+        for player in multiworld.player_ids:
             player_local = early_local_prog_items[player]
-            fill_restrictive(world, base_state,
+            fill_restrictive(multiworld, base_state,
                              [loc for loc in early_locations if loc.player == player],
-                             player_local, lock=True, allow_partial=True)
+                             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(world, base_state, early_locations, early_prog_items, lock=True, allow_partial=True)
+        fill_restrictive(multiworld, 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:
             logging.warning("Ran out of early locations for early items. Failed to place "
@@ -356,18 +412,18 @@ def distribute_early_items(world: MultiWorld,
             itempool += unplaced_early_items
 
         fill_locations.extend(early_locations)
-        world.random.shuffle(fill_locations)
+        multiworld.random.shuffle(fill_locations)
     return fill_locations, itempool
 
 
-def distribute_items_restrictive(world: MultiWorld) -> None:
-    fill_locations = sorted(world.get_unfilled_locations())
-    world.random.shuffle(fill_locations)
+def distribute_items_restrictive(multiworld: MultiWorld) -> None:
+    fill_locations = sorted(multiworld.get_unfilled_locations())
+    multiworld.random.shuffle(fill_locations)
     # get items to distribute
-    itempool = sorted(world.itempool)
-    world.random.shuffle(itempool)
+    itempool = sorted(multiworld.itempool)
+    multiworld.random.shuffle(itempool)
 
-    fill_locations, itempool = distribute_early_items(world, fill_locations, itempool)
+    fill_locations, itempool = distribute_early_items(multiworld, fill_locations, itempool)
 
     progitempool: typing.List[Item] = []
     usefulitempool: typing.List[Item] = []
@@ -381,7 +437,7 @@ def distribute_items_restrictive(world: MultiWorld) -> None:
         else:
             filleritempool.append(item)
 
-    call_all(world, "fill_hook", progitempool, usefulitempool, filleritempool, fill_locations)
+    call_all(multiworld, "fill_hook", progitempool, usefulitempool, filleritempool, fill_locations)
 
     locations: typing.Dict[LocationProgressType, typing.List[Location]] = {
         loc_type: [] for loc_type in LocationProgressType}
@@ -402,74 +458,79 @@ def distribute_items_restrictive(world: MultiWorld) -> None:
 
     if prioritylocations:
         # "priority fill"
-        fill_restrictive(world, world.state, prioritylocations, progitempool, swap=False, on_place=mark_for_locking)
-        accessibility_corrections(world, world.state, prioritylocations, progitempool)
+        fill_restrictive(multiworld, multiworld.state, prioritylocations, progitempool, swap=False, on_place=mark_for_locking,
+                         name="Priority")
+        accessibility_corrections(multiworld, multiworld.state, prioritylocations, progitempool)
         defaultlocations = prioritylocations + defaultlocations
 
     if progitempool:
-        # "progression fill"
-        fill_restrictive(world, world.state, defaultlocations, progitempool)
+        # "advancement/progression fill"
+        fill_restrictive(multiworld, multiworld.state, defaultlocations, progitempool, name="Progression")
         if progitempool:
             raise FillError(
-                f'Not enough locations for progress items. There are {len(progitempool)} more items than locations')
-        accessibility_corrections(world, world.state, defaultlocations)
+                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)
 
     for location in lock_later:
         if location.item:
             location.locked = True
     del mark_for_locking, lock_later
 
-    inaccessible_location_rules(world, world.state, defaultlocations)
+    inaccessible_location_rules(multiworld, multiworld.state, defaultlocations)
 
-    remaining_fill(world, excludedlocations, filleritempool)
+    remaining_fill(multiworld, excludedlocations, filleritempool, "Remaining Excluded")
     if excludedlocations:
         raise FillError(
-            f"Not enough filler items for excluded locations. There are {len(excludedlocations)} more locations than items")
+            f"Not enough filler items for excluded locations. "
+            f"There are {len(excludedlocations)} more excluded locations than filler or trap items."
+        )
 
-    restitempool = usefulitempool + filleritempool
+    restitempool = filleritempool + usefulitempool
 
-    remaining_fill(world, defaultlocations, restitempool)
+    remaining_fill(multiworld, 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 world.get_locations() if location.item)
-        locations_counter = Counter(location.player for location in world.get_locations())
+            f"Unplaced items({len(unplaced)}): {unplaced} - Unfilled Locations({len(unfilled)}): {unfilled}")
+        items_counter = Counter(location.item.player for location in multiworld.get_locations() if location.item)
+        locations_counter = Counter(location.player for location in multiworld.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(world: MultiWorld) -> None:
+def flood_items(multiworld: MultiWorld) -> None:
     # get items to distribute
-    world.random.shuffle(world.itempool)
-    itempool = world.itempool
+    multiworld.random.shuffle(multiworld.itempool)
+    itempool = multiworld.itempool
     progress_done = False
 
     # sweep once to pick up preplaced items
-    world.state.sweep_for_events()
+    multiworld.state.sweep_for_events()
 
-    # fill world from top of itempool while we can
+    # fill multiworld from top of itempool while we can
     while not progress_done:
-        location_list = world.get_unfilled_locations()
-        world.random.shuffle(location_list)
+        location_list = multiworld.get_unfilled_locations()
+        multiworld.random.shuffle(location_list)
         spot_to_fill = None
         for location in location_list:
-            if location.can_fill(world.state, itempool[0]):
+            if location.can_fill(multiworld.state, itempool[0]):
                 spot_to_fill = location
                 break
 
         if spot_to_fill:
             item = itempool.pop(0)
-            world.push_item(spot_to_fill, item, True)
+            multiworld.push_item(spot_to_fill, item, True)
             continue
 
         # ran out of spots, check if we need to step in and correct things
-        if len(world.get_reachable_locations()) == len(world.get_locations()):
+        if len(multiworld.get_reachable_locations()) == len(multiworld.get_locations()):
             progress_done = True
             continue
 
@@ -479,7 +540,7 @@ def flood_items(world: MultiWorld) -> None:
         for item in itempool:
             if item.advancement:
                 candidate_item_to_place = item
-                if world.unlocks_new_location(item):
+                if multiworld.unlocks_new_location(item):
                     item_to_place = item
                     break
 
@@ -492,20 +553,20 @@ def flood_items(world: MultiWorld) -> None:
                 raise FillError('No more progress items left to place.')
 
         # find item to replace with progress item
-        location_list = world.get_reachable_locations()
-        world.random.shuffle(location_list)
+        location_list = multiworld.get_reachable_locations()
+        multiworld.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)
-                world.push_item(location, item_to_place, True)
+                multiworld.push_item(location, item_to_place, True)
                 itempool.remove(item_to_place)
                 break
 
 
-def balance_multiworld_progression(world: MultiWorld) -> None:
+def balance_multiworld_progression(multiworld: MultiWorld) -> None:
     # A system to reduce situations where players have no checks remaining, popularly known as "BK mode."
     # Overall progression balancing algorithm:
     # Gather up all locations in a sphere.
@@ -513,29 +574,29 @@ def balance_multiworld_progression(world: MultiWorld) -> None:
     # If other players are below the threshold value, swap progression in this sphere into earlier spheres,
     #   which gives more locations available by this sphere.
     balanceable_players: typing.Dict[int, float] = {
-        player: world.progression_balancing[player] / 100
-        for player in world.player_ids
-        if world.progression_balancing[player] > 0
+        player: multiworld.worlds[player].options.progression_balancing / 100
+        for player in multiworld.player_ids
+        if multiworld.worlds[player].options.progression_balancing > 0
     }
     if not balanceable_players:
         logging.info('Skipping multiworld progression balancing.')
     else:
         logging.info(f'Balancing multiworld progression for {len(balanceable_players)} Players.')
         logging.debug(balanceable_players)
-        state: CollectionState = CollectionState(world)
+        state: CollectionState = CollectionState(multiworld)
         checked_locations: typing.Set[Location] = set()
-        unchecked_locations: typing.Set[Location] = set(world.get_locations())
+        unchecked_locations: typing.Set[Location] = set(multiworld.get_locations())
 
-        reachable_locations_count: typing.Dict[int, int] = {
-            player: 0
-            for player in world.player_ids
-            if len(world.get_filled_locations(player)) != 0
-        }
         total_locations_count: typing.Counter[int] = Counter(
             location.player
-            for location in world.get_locations()
+            for location in multiworld.get_locations()
             if not location.locked
         )
+        reachable_locations_count: typing.Dict[int, int] = {
+            player: 0
+            for player in multiworld.player_ids
+            if total_locations_count[player] and len(multiworld.get_filled_locations(player)) != 0
+        }
         balanceable_players = {
             player: balanceable_players[player]
             for player in balanceable_players
@@ -552,6 +613,10 @@ def balance_multiworld_progression(world: MultiWorld) -> None:
         def item_percentage(player: int, num: int) -> float:
             return num / total_locations_count[player]
 
+        # If there are no locations that aren't locked, there's no point in attempting to balance progression.
+        if len(total_locations_count) == 0:
+            return
+
         while True:
             # Gather non-locked locations.
             # This ensures that only shuffled locations get counted for progression balancing,
@@ -609,7 +674,7 @@ def balance_multiworld_progression(world: MultiWorld) -> None:
                             balancing_unchecked_locations.remove(location)
                             if not location.locked:
                                 balancing_reachables[location.player] += 1
-                        if world.has_beaten_game(balancing_state) or all(
+                        if multiworld.has_beaten_game(balancing_state) or all(
                                 item_percentage(player, reachables) >= threshold_percentages[player]
                                 for player, reachables in balancing_reachables.items()
                                 if player in threshold_percentages):
@@ -626,7 +691,7 @@ def balance_multiworld_progression(world: MultiWorld) -> None:
                         locations_to_test = unlocked_locations[player]
                         items_to_test = list(candidate_items[player])
                         items_to_test.sort()
-                        world.random.shuffle(items_to_test)
+                        multiworld.random.shuffle(items_to_test)
                         while items_to_test:
                             testing = items_to_test.pop()
                             reducing_state = state.copy()
@@ -638,8 +703,8 @@ def balance_multiworld_progression(world: MultiWorld) -> None:
 
                             reducing_state.sweep_for_events(locations=locations_to_test)
 
-                            if world.has_beaten_game(balancing_state):
-                                if not world.has_beaten_game(reducing_state):
+                            if multiworld.has_beaten_game(balancing_state):
+                                if not multiworld.has_beaten_game(reducing_state):
                                     items_to_replace.append(testing)
                             else:
                                 reduced_sphere = get_sphere_locations(reducing_state, locations_to_test)
@@ -647,33 +712,32 @@ def balance_multiworld_progression(world: MultiWorld) -> None:
                                 if p < threshold_percentages[player]:
                                     items_to_replace.append(testing)
 
-                    replaced_items = False
+                    old_moved_item_count = moved_item_count
 
                     # 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.event and not l.locked)
-                    world.random.shuffle(replacement_locations)
+                    multiworld.random.shuffle(replacement_locations)
                     items_to_replace.sort()
-                    world.random.shuffle(items_to_replace)
+                    multiworld.random.shuffle(items_to_replace)
 
                     # Start swapping items. Since we swap into earlier spheres, no need for accessibility checks. 
                     while replacement_locations and items_to_replace:
                         old_location = items_to_replace.pop()
-                        for new_location in replacement_locations:
+                        for i, new_location in enumerate(replacement_locations):
                             if new_location.can_fill(state, old_location.item, False) and \
                                     old_location.can_fill(state, new_location.item, False):
-                                replacement_locations.remove(new_location)
+                                replacement_locations.pop(i)
                                 swap_location_item(old_location, new_location)
                                 logging.debug(f"Progression balancing moved {new_location.item} to {new_location}, "
                                               f"displacing {old_location.item} into {old_location}")
                                 moved_item_count += 1
                                 state.collect(new_location.item, True, new_location)
-                                replaced_items = True
                                 break
                         else:
                             logging.warning(f"Could not Progression Balance {old_location.item}")
 
-                    if replaced_items:
+                    if old_moved_item_count < moved_item_count:
                         logging.debug(f"Moved {moved_item_count} items so far\n")
                         unlocked = {fresh for player in balancing_players for fresh in unlocked_locations[player]}
                         for location in get_sphere_locations(state, unlocked):
@@ -687,7 +751,7 @@ def balance_multiworld_progression(world: MultiWorld) -> None:
                     state.collect(location.item, True, location)
             checked_locations |= sphere_locations
 
-            if world.has_beaten_game(state):
+            if multiworld.has_beaten_game(state):
                 break
             elif not sphere_locations:
                 logging.warning("Progression Balancing ran out of paths.")
@@ -707,7 +771,7 @@ def swap_location_item(location_1: Location, location_2: Location, check_locked:
     location_1.event, location_2.event = location_2.event, location_1.event
 
 
-def distribute_planned(world: MultiWorld) -> None:
+def distribute_planned(multiworld: MultiWorld) -> None:
     def warn(warning: str, force: typing.Union[bool, str]) -> None:
         if force in [True, 'fail', 'failure', 'none', False, 'warn', 'warning']:
             logging.warning(f'{warning}')
@@ -720,42 +784,43 @@ def distribute_planned(world: MultiWorld) -> None:
         else:
             warn(warning, force)
 
-    swept_state = world.state.copy()
+    swept_state = multiworld.state.copy()
     swept_state.sweep_for_events()
-    reachable = frozenset(world.get_reachable_locations(swept_state))
+    reachable = frozenset(multiworld.get_reachable_locations(swept_state))
     early_locations: typing.Dict[int, typing.List[str]] = collections.defaultdict(list)
     non_early_locations: typing.Dict[int, typing.List[str]] = collections.defaultdict(list)
-    for loc in world.get_unfilled_locations():
+    for loc in multiworld.get_unfilled_locations():
         if loc in reachable:
             early_locations[loc.player].append(loc.name)
         else:  # not reachable with swept state
             non_early_locations[loc.player].append(loc.name)
 
-    # TODO: remove. Preferably by implementing key drop
-    from worlds.alttp.Regions import key_drop_data
-    world_name_lookup = world.world_name_lookup
+    world_name_lookup = multiworld.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(world.player_ids)
+    player_ids = set(multiworld.player_ids)
     for player in player_ids:
-        for block in world.plando_items[player]:
+        for block in multiworld.plando_items[player]:
             block['player'] = player
             if 'force' not in block:
                 block['force'] = 'silent'
             if 'from_pool' not in block:
                 block['from_pool'] = True
+            elif not isinstance(block['from_pool'], bool):
+                from_pool_type = type(block['from_pool'])
+                raise Exception(f'Plando "from_pool" has to be boolean, not {from_pool_type} for player {player}.')
             if 'world' not in block:
                 target_world = False
             else:
                 target_world = block['world']
 
-            if target_world is False or world.players == 1:  # target own world
+            if target_world is False or multiworld.players == 1:  # target own world
                 worlds: typing.Set[int] = {player}
             elif target_world is True:  # target any worlds besides own
-                worlds = set(world.player_ids) - {player}
+                worlds = set(multiworld.player_ids) - {player}
             elif target_world is None:  # target all worlds
-                worlds = set(world.player_ids)
+                worlds = set(multiworld.player_ids)
             elif type(target_world) == list:  # list of target worlds
                 worlds = set()
                 for listed_world in target_world:
@@ -765,9 +830,9 @@ def distribute_planned(world: 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, world.players + 1):
+                if target_world not in range(1, multiworld.players + 1):
                     failed(
-                        f"Cannot place item in world {target_world} as it is not in range of (1, {world.players})",
+                        f"Cannot place item in world {target_world} as it is not in range of (1, {multiworld.players})",
                         block['force'])
                     continue
                 worlds = {target_world}
@@ -795,7 +860,7 @@ def distribute_planned(world: MultiWorld) -> None:
                 item_list: typing.List[str] = []
                 for key, value in items.items():
                     if value is True:
-                        value = world.itempool.count(world.worlds[player].create_item(key))
+                        value = multiworld.itempool.count(multiworld.worlds[player].create_item(key))
                     item_list += [key] * value
                 items = item_list
             if isinstance(items, str):
@@ -818,15 +883,14 @@ def distribute_planned(world: MultiWorld) -> None:
 
             if "early_locations" in locations:
                 locations.remove("early_locations")
-                for player in worlds:
-                    locations += early_locations[player]
+                for target_player in worlds:
+                    locations += early_locations[target_player]
             if "non_early_locations" in locations:
                 locations.remove("non_early_locations")
-                for player in worlds:
-                    locations += non_early_locations[player]
+                for target_player in worlds:
+                    locations += non_early_locations[target_player]
 
-
-            block['locations'] = locations
+            block['locations'] = list(dict.fromkeys(locations))
 
             if not block['count']:
                 block['count'] = (min(len(block['items']), len(block['locations'])) if
@@ -846,17 +910,17 @@ def distribute_planned(world: MultiWorld) -> None:
                 count = block['count']
                 failed(f"Plando count {count} greater than locations specified", block['force'])
                 block['count'] = len(block['locations'])
-            block['count']['target'] = world.random.randint(block['count']['min'], block['count']['max'])
+            block['count']['target'] = multiworld.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
-    world.random.shuffle(plando_blocks)
+    multiworld.random.shuffle(plando_blocks)
     plando_blocks.sort(key=lambda block: (len(block['locations']) - block['count']['target']
                                           if len(block['locations']) > 0
-                                          else len(world.get_unfilled_locations(player)) - block['count']['target']))
+                                          else len(multiworld.get_unfilled_locations(player)) - block['count']['target']))
 
     for placement in plando_blocks:
         player = placement['player']
@@ -867,52 +931,51 @@ def distribute_planned(world: MultiWorld) -> None:
             maxcount = placement['count']['target']
             from_pool = placement['from_pool']
 
-            candidates = list(world.get_unfilled_locations_for_players(locations, sorted(worlds)))
-            world.random.shuffle(candidates)
-            world.random.shuffle(items)
+            candidates = list(multiworld.get_unfilled_locations_for_players(locations, sorted(worlds)))
+            multiworld.random.shuffle(candidates)
+            multiworld.random.shuffle(items)
             count = 0
             err: typing.List[str] = []
             successful_pairs: typing.List[typing.Tuple[Item, Location]] = []
             for item_name in items:
-                item = world.worlds[player].create_item(item_name)
+                item = multiworld.worlds[player].create_item(item_name)
                 for location in reversed(candidates):
-                    if location in key_drop_data:
-                        warn(
-                            f"Can't place '{item_name}' at '{placement.location}', as key drop shuffle locations are not supported yet.")
-                        continue
-                    if not location.item:
-                        if location.item_rule(item):
-                            if location.can_fill(world.state, item, False):
-                                successful_pairs.append((item, location))
-                                candidates.remove(location)
-                                count = count + 1
-                                break
+                    if (location.address is None) == (item.code is None):  # either both None or both not None
+                        if not location.item:
+                            if location.item_rule(item):
+                                if location.can_fill(multiworld.state, item, False):
+                                    successful_pairs.append((item, location))
+                                    candidates.remove(location)
+                                    count = count + 1
+                                    break
+                                else:
+                                    err.append(f"Can't place item at {location} due to fill condition not met.")
                             else:
-                                err.append(f"Can't place item at {location} due to fill condition not met.")
+                                err.append(f"{item_name} not allowed at {location}.")
                         else:
-                            err.append(f"{item_name} not allowed at {location}.")
+                            err.append(f"Cannot place {item_name} into already filled location {location}.")
                     else:
-                        err.append(f"Cannot place {item_name} into already filled location {location}.")
+                        err.append(f"Mismatch between {item_name} and {location}, only one is an event.")
                 if count == maxcount:
                     break
             if count < placement['count']['min']:
                 m = placement['count']['min']
                 failed(
-                    f"Plando block failed to place {m - count} of {m} item(s) for {world.player_name[player]}, error(s): {' '.join(err)}",
+                    f"Plando block failed to place {m - count} of {m} item(s) for {multiworld.player_name[player]}, error(s): {' '.join(err)}",
                     placement['force'])
             for (item, location) in successful_pairs:
-                world.push_item(location, item, collect=False)
+                multiworld.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:
-                        world.itempool.remove(item)
+                        multiworld.itempool.remove(item)
                     except ValueError:
                         warn(
-                            f"Could not remove {item} from pool for {world.player_name[player]} as it's already missing from it.",
+                            f"Could not remove {item} from pool for {multiworld.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} ({world.player_name[player]})") from e
+                f"Error running plando for player {player} ({multiworld.player_name[player]})") from e

Generate.py

@@ -7,55 +7,56 @@ import random
 import string
 import urllib.parse
 import urllib.request
-from collections import Counter, ChainMap
-from typing import Dict, Tuple, Callable, Any, Union
+from collections import Counter
+from typing import Any, Dict, Tuple, Union
 
 import ModuleUpdate
 
 ModuleUpdate.update()
 
+import copy
 import Utils
-from worlds.alttp import Options as LttPOptions
-from worlds.generic import PlandoConnection
-from Utils import parse_yamls, version_tuple, __version__, tuplize_version, get_options, user_path
-from worlds.alttp.EntranceRandomizer import parse_arguments
-from Main import main as ERmain
-from BaseClasses import seeddigits, get_seed, PlandoOptions
 import Options
+from BaseClasses import seeddigits, get_seed, PlandoOptions
+from Main import main as ERmain
+from settings import get_settings
+from Utils import parse_yamls, version_tuple, __version__, tuplize_version
+from worlds.alttp import Options as LttPOptions
+from worlds.alttp.EntranceRandomizer import parse_arguments
 from worlds.alttp.Text import TextTable
 from worlds.AutoWorld import AutoWorldRegister
-import copy
-
-
-
+from worlds.generic import PlandoConnection
+from worlds import failed_world_loads
 
 
 def mystery_argparse():
-    options = get_options()
-    defaults = options["generator"]
-
-    def resolve_path(path: str, resolver: Callable[[str], str]) -> str:
-        return path if os.path.isabs(path) else resolver(path)
+    options = get_settings()
+    defaults = options.generator
 
     parser = argparse.ArgumentParser(description="CMD Generation Interface, defaults come from host.yaml.")
-    parser.add_argument('--weights_file_path', default=defaults["weights_file_path"],
+    parser.add_argument('--weights_file_path', default=defaults.weights_file_path,
                         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=resolve_path(defaults["player_files_path"], user_path),
+    parser.add_argument('--player_files_path', default=defaults.player_files_path,
                         help="Input directory for player files.")
     parser.add_argument('--seed', help='Define seed number to generate.', type=int)
-    parser.add_argument('--multi', default=defaults["players"], type=lambda value: max(int(value), 1))
-    parser.add_argument('--spoiler', type=int, default=defaults["spoiler"])
-    parser.add_argument('--outputpath', default=resolve_path(options["general_options"]["output_path"], user_path),
+    parser.add_argument('--multi', default=defaults.players, type=lambda value: max(int(value), 1))
+    parser.add_argument('--spoiler', type=int, default=defaults.spoiler)
+    parser.add_argument('--outputpath', default=options.general_options.output_path,
                         help="Path to output folder. Absolute or relative to cwd.")  # absolute or relative to cwd
-    parser.add_argument('--race', action='store_true', default=defaults["race"])
-    parser.add_argument('--meta_file_path', default=defaults["meta_file_path"])
+    parser.add_argument('--race', action='store_true', default=defaults.race)
+    parser.add_argument('--meta_file_path', default=defaults.meta_file_path)
     parser.add_argument('--log_level', default='info', help='Sets log level')
     parser.add_argument('--yaml_output', default=0, type=lambda value: max(int(value), 0),
                         help='Output rolled mystery results to yaml up to specified number (made for async multiworld)')
-    parser.add_argument('--plando', default=defaults["plando_options"],
+    parser.add_argument('--plando', default=defaults.plando_options,
                         help='List of options that can be set manually. Can be combined, for example "bosses, items"')
+    parser.add_argument("--skip_prog_balancing", action="store_true",
+                        help="Skip progression balancing step during generation.")
+    parser.add_argument("--skip_output", action="store_true",
+                        help="Skips generation assertion and output stages and skips multidata and spoiler output. "
+                             "Intended for debugging and testing purposes.")
     args = parser.parse_args()
     if not os.path.isabs(args.weights_file_path):
         args.weights_file_path = os.path.join(args.player_files_path, args.weights_file_path)
@@ -72,12 +73,16 @@ def get_seed_name(random_source) -> str:
 def main(args=None, callback=ERmain):
     if not args:
         args, options = mystery_argparse()
+    else:
+        options = get_settings()
 
     seed = get_seed(args.seed)
+    Utils.init_logging(f"Generate_{seed}", loglevel=args.log_level)
     random.seed(seed)
     seed_name = get_seed_name(random)
 
     if args.race:
+        logging.info("Race mode enabled. Using non-deterministic random source.")
         random.seed()  # reset to time-based random source
 
     weights_cache: Dict[str, Tuple[Any, ...]] = {}
@@ -85,16 +90,16 @@ def main(args=None, callback=ERmain):
         try:
             weights_cache[args.weights_file_path] = read_weights_yamls(args.weights_file_path)
         except Exception as e:
-            raise ValueError(f"File {args.weights_file_path} is destroyed. Please fix your yaml.") from e
-        print(f"Weights: {args.weights_file_path} >> "
-              f"{get_choice('description', weights_cache[args.weights_file_path][-1], 'No description specified')}")
+            raise ValueError(f"File {args.weights_file_path} is invalid. Please fix your yaml.") from e
+        logging.info(f"Weights: {args.weights_file_path} >> "
+                     f"{get_choice('description', weights_cache[args.weights_file_path][-1], 'No description specified')}")
 
     if args.meta_file_path and os.path.exists(args.meta_file_path):
         try:
             meta_weights = read_weights_yamls(args.meta_file_path)[-1]
         except Exception as e:
-            raise ValueError(f"File {args.meta_file_path} is destroyed. Please fix your yaml.") from e
-        print(f"Meta: {args.meta_file_path} >> {get_choice('meta_description', meta_weights)}")
+            raise ValueError(f"File {args.meta_file_path} is invalid. Please fix your yaml.") from e
+        logging.info(f"Meta: {args.meta_file_path} >> {get_choice('meta_description', meta_weights)}")
         try:  # meta description allows us to verify that the file named meta.yaml is intentionally a meta file
             del(meta_weights["meta_description"])
         except Exception as e:
@@ -113,35 +118,43 @@ def main(args=None, callback=ERmain):
             try:
                 weights_cache[fname] = read_weights_yamls(path)
             except Exception as e:
-                raise ValueError(f"File {fname} is destroyed. Please fix your yaml.") from e
+                raise ValueError(f"File {fname} is invalid. Please fix your yaml.") from e
 
     # sort dict for consistent results across platforms:
     weights_cache = {key: value for key, value in sorted(weights_cache.items())}
     for filename, yaml_data in weights_cache.items():
         if filename not in {args.meta_file_path, args.weights_file_path}:
             for yaml in yaml_data:
-                print(f"P{player_id} Weights: {filename} >> "
-                      f"{get_choice('description', yaml, 'No description specified')}")
+                logging.info(f"P{player_id} Weights: {filename} >> "
+                             f"{get_choice('description', yaml, 'No description specified')}")
                 player_files[player_id] = filename
                 player_id += 1
 
     args.multi = max(player_id - 1, args.multi)
-    print(f"Generating for {args.multi} player{'s' if args.multi > 1 else ''}, {seed_name} Seed {seed} with plando: "
-          f"{args.plando}")
+
+    if args.multi == 0:
+        raise ValueError(
+            "No individual player files found and number of players is 0. "
+            "Provide individual player files or specify the number of players via host.yaml or --multi."
+        )
+
+    logging.info(f"Generating for {args.multi} player{'s' if args.multi > 1 else ''}, "
+                 f"{seed_name} Seed {seed} with plando: {args.plando}")
 
     if not weights_cache:
-        raise Exception(f"No weights found. Provide a general weights file ({args.weights_file_path}) or individual player files. "
+        raise Exception(f"No weights found. "
+                        f"Provide a general weights file ({args.weights_file_path}) or individual player files. "
                         f"A mix is also permitted.")
     erargs = parse_arguments(['--multi', str(args.multi)])
     erargs.seed = seed
     erargs.plando_options = args.plando
-    erargs.glitch_triforce = options["generator"]["glitch_triforce_room"]
+    erargs.glitch_triforce = options.generator.glitch_triforce_room
     erargs.spoiler = args.spoiler
     erargs.race = args.race
     erargs.outputname = seed_name
     erargs.outputpath = args.outputpath
-
-    Utils.init_logging(f"Generate_{seed}", loglevel=args.log_level)
+    erargs.skip_prog_balancing = args.skip_prog_balancing
+    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.samesettings else None)
@@ -156,7 +169,8 @@ def main(args=None, callback=ERmain):
                         for yaml in weights_cache[path]:
                             if category_name is None:
                                 for category in yaml:
-                                    if category in AutoWorldRegister.world_types and key in Options.common_options:
+                                    if category in AutoWorldRegister.world_types and \
+                                            key in Options.CommonOptions.type_hints:
                                         yaml[category][key] = option
                             elif category_name not in yaml:
                                 logging.warning(f"Meta: Category {category_name} is not present in {path}.")
@@ -167,7 +181,7 @@ def main(args=None, callback=ERmain):
     for player in range(1, args.multi + 1):
         player_path_cache[player] = player_files.get(player, args.weights_file_path)
     name_counter = Counter()
-    erargs.player_settings = {}
+    erargs.player_options = {}
 
     player = 1
     while player <= args.multi:
@@ -194,7 +208,7 @@ def main(args=None, callback=ERmain):
 
                     player += 1
             except Exception as e:
-                raise ValueError(f"File {path} is destroyed. Please fix your yaml.") from e
+                raise ValueError(f"File {path} is invalid. Please fix your yaml.") from e
         else:
             raise RuntimeError(f'No weights specified for player {player}')
 
@@ -223,7 +237,7 @@ def main(args=None, callback=ERmain):
         with open(os.path.join(args.outputpath if args.outputpath else ".", f"generate_{seed_name}.yaml"), "wt") as f:
             yaml.dump(important, f)
 
-    callback(erargs, seed)
+    return callback(erargs, seed)
 
 
 def read_weights_yamls(path) -> Tuple[Any, ...]:
@@ -289,7 +303,9 @@ def handle_name(name: str, player: int, name_counter: Counter):
                                                                  NUMBER=(number if number > 1 else ''),
                                                                  player=player,
                                                                  PLAYER=(player if player > 1 else '')))
-    new_name = new_name.strip()[:16]
+    # 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()
     if new_name == "Archipelago":
         raise Exception(f"You cannot name yourself \"{new_name}\"")
     return new_name
@@ -302,33 +318,35 @@ def prefer_int(input_data: str) -> Union[str, int]:
         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, type: str, name: str) -> dict:
+def update_weights(weights: dict, new_weights: dict, update_type: str, name: str) -> dict:
     logging.debug(f'Applying {new_weights}')
-    new_options = set(new_weights) - set(weights)
-    weights.update(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)
     if new_options:
         for new_option in new_options:
-            logging.warning(f'{type} Suboption "{new_option}" of "{name}" did not '
+            logging.warning(f'{update_type} Suboption "{new_option}" of "{name}" did not '
                             f'overwrite a root option. '
                             f'This is probably in error.')
     return weights
@@ -339,20 +357,11 @@ def roll_meta_option(option_key, game: str, category_dict: Dict) -> Any:
         return get_choice(option_key, category_dict)
     if game in AutoWorldRegister.world_types:
         game_world = AutoWorldRegister.world_types[game]
-        options = ChainMap(game_world.option_definitions, Options.per_game_common_options)
+        options = game_world.options_dataclass.type_hints
         if option_key in options:
             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}.")
 
 
@@ -373,7 +382,7 @@ def roll_linked_options(weights: dict) -> dict:
             else:
                 logging.debug(f"linked option {option_set['name']} skipped.")
         except Exception as e:
-            raise ValueError(f"Linked option {option_set['name']} is destroyed. "
+            raise ValueError(f"Linked option {option_set['name']} is invalid. "
                              f"Please fix your linked option.") from e
     return weights
 
@@ -403,7 +412,7 @@ def roll_triggers(weights: dict, triggers: list) -> dict:
                     update_weights(currently_targeted_weights, category_options, "Triggered", option_set["option_name"])
 
         except Exception as e:
-            raise ValueError(f"Your trigger number {i + 1} is destroyed. "
+            raise ValueError(f"Your trigger number {i + 1} is invalid. "
                              f"Please fix your triggers.") from e
     return weights
 
@@ -444,151 +453,59 @@ def roll_settings(weights: dict, plando_options: PlandoOptions = PlandoOptions.b
                                 f"which is not enabled.")
 
     ret = argparse.Namespace()
-    for option_key in Options.per_game_common_options:
-        if option_key in weights and option_key not in Options.common_options:
+    for option_key in Options.PerGameCommonOptions.type_hints:
+        if option_key in weights and option_key not in Options.CommonOptions.type_hints:
             raise Exception(f"Option {option_key} has to be in a game's section, not on its own.")
 
     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.")
+        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.")
+
     if ret.game not in weights:
         raise Exception(f"No game options for selected game \"{ret.game}\" found.")
 
     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]
 
     ret.name = get_choice('name', weights)
-    for option_key, option in Options.common_options.items():
+    for option_key, option in Options.CommonOptions.type_hints.items():
         setattr(ret, option_key, option.from_any(get_choice(option_key, weights, option.default)))
 
-    if ret.game in AutoWorldRegister.world_types:
-        for option_key, option in world_type.option_definitions.items():
-            handle_option(ret, game_weights, option_key, option, plando_options)
-        for option_key, option in Options.per_game_common_options.items():
-            # skip setting this option if already set from common_options, defaulting to root option
-            if option_key not in world_type.option_definitions and \
-                    (option_key not in Options.common_options or option_key in game_weights):
-                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 == "Minecraft" or ret.game == "Ocarina of Time":
-            # bad hardcoded behavior to make this work for now
-            ret.plando_connections = []
-            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)
-    else:
-        raise Exception(f"Unsupported game {ret.game}")
+    for option_key, option in world_type.options_dataclass.type_hints.items():
+        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:
+        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")
+                ))
 
     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:
@@ -602,17 +519,6 @@ 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:
@@ -640,6 +546,15 @@ def roll_alttp_settings(ret: argparse.Namespace, weights, plando_options):
 if __name__ == '__main__':
     import atexit
     confirmation = atexit.register(input, "Press enter to close.")
-    main()
+    multiworld = main()
+    if __debug__:
+        import gc
+        import sys
+        import weakref
+        weak = weakref.ref(multiworld)
+        del multiworld
+        gc.collect()  # need to collect to deref all hard references
+        assert not weak(), f"MultiWorld object was not de-allocated, it's referenced {sys.getrefcount(weak())} times." \
+                           " This would be a memory leak."
     # in case of error-free exit should not need confirmation
     atexit.unregister(confirmation)

KH2Client.py

@@ -1,906 +1,8 @@
-import os
-import asyncio
 import ModuleUpdate
-import json
 import Utils
-from pymem import pymem
-from worlds.kh2.Items import exclusionItem_table, CheckDupingItems
-from worlds.kh2 import all_locations, item_dictionary_table, exclusion_table
-
-from worlds.kh2.WorldLocations import *
-
-from worlds import network_data_package
-
-if __name__ == "__main__":
-    Utils.init_logging("KH2Client", exception_logger="Client")
-
-from NetUtils import ClientStatus
-from CommonClient import gui_enabled, logger, get_base_parser, ClientCommandProcessor, \
-    CommonContext, server_loop
-
+from worlds.kh2.Client import launch
 ModuleUpdate.update()
 
-kh2_loc_name_to_id = network_data_package["games"]["Kingdom Hearts 2"]["location_name_to_id"]
-
-
-# class KH2CommandProcessor(ClientCommandProcessor):
-
-
-class KH2Context(CommonContext):
-    # command_processor: int = KH2CommandProcessor
-    game = "Kingdom Hearts 2"
-    items_handling = 0b101  # Indicates you get items sent from other worlds.
-
-    def __init__(self, server_address, password):
-        super(KH2Context, self).__init__(server_address, password)
-        self.kh2LocalItems = None
-        self.ability = None
-        self.growthlevel = None
-        self.KH2_sync_task = None
-        self.syncing = False
-        self.kh2connected = False
-        self.serverconneced = False
-        self.item_name_to_data = {name: data for name, data, in item_dictionary_table.items()}
-        self.location_name_to_data = {name: data for name, data, in all_locations.items()}
-        self.lookup_id_to_item: typing.Dict[int, str] = {data.code: item_name for item_name, data in
-                                                         item_dictionary_table.items() if data.code}
-        self.lookup_id_to_Location: typing.Dict[int, str] = {data.code: item_name for item_name, data in
-                                                             all_locations.items() if data.code}
-        self.location_name_to_worlddata = {name: data for name, data, in all_world_locations.items()}
-
-        self.location_table = {}
-        self.collectible_table = {}
-        self.collectible_override_flags_address = 0
-        self.collectible_offsets = {}
-        self.sending = []
-        # flag for if the player has gotten their starting inventory from the server
-        self.hasStartingInvo = False
-        # list used to keep track of locations+items player has. Used for disoneccting
-        self.kh2seedsave = {"checked_locations":  {"0": []},
-                            "starting_inventory": self.hasStartingInvo,
-
-                            #  Character: [back of invo, front of invo]
-                            "SoraInvo":           [0x25CC, 0x2546],
-                            "DonaldInvo":         [0x2678, 0x2658],
-                            "GoofyInvo":          [0x278E, 0x276C],
-                            "AmountInvo":         {
-                                "ServerItems": {
-                                    "Ability":      {},
-                                    "Amount":       {},
-                                    "Growth":       {"High Jump": 0, "Quick Run": 0, "Dodge Roll": 0, "Aerial Dodge": 0,
-                                                     "Glide":     0},
-                                    "Bitmask":      [],
-                                    "Weapon":       {"Sora": [], "Donald": [], "Goofy": []},
-                                    "Equipment":    [],
-                                    "Magic":        {},
-                                    "StatIncrease": {},
-                                    "Boost":        {},
-                                },
-                                "LocalItems":  {
-                                    "Ability":      {},
-                                    "Amount":       {},
-                                    "Growth":       {"High Jump":    0, "Quick Run": 0, "Dodge Roll": 0,
-                                                     "Aerial Dodge": 0, "Glide": 0},
-                                    "Bitmask":      [],
-                                    "Weapon":       {"Sora": [], "Donald": [], "Goofy": []},
-                                    "Equipment":    [],
-                                    "Magic":        {},
-                                    "StatIncrease": {},
-                                    "Boost":        {},
-                                }},
-                            #  1,3,255 are in this list in case the player gets locations in those "worlds" and I need to still have them checked
-                            "worldIdChecks":      {
-                                "1":   [],  # world of darkness (story cutscenes)
-                                "2":   [],
-                                "3":   [],  # destiny island doesn't have checks to ima put tt checks here
-                                "4":   [],
-                                "5":   [],
-                                "6":   [],
-                                "7":   [],
-                                "8":   [],
-                                "9":   [],
-                                "10":  [],
-                                "11":  [],
-                                # atlantica isn't a supported world. if you go in atlantica it will check dc
-                                "12":  [],
-                                "13":  [],
-                                "14":  [],
-                                "15":  [],
-                                # world map, but you only go to the world map while on the way to goa so checking hb
-                                "16":  [],
-                                "17":  [],
-                                "18":  [],
-                                "255": [],  # starting screen
-                            },
-                            "Levels":             {
-                                "SoraLevel":   0,
-                                "ValorLevel":  0,
-                                "WisdomLevel": 0,
-                                "LimitLevel":  0,
-                                "MasterLevel": 0,
-                                "FinalLevel":  0,
-                            },
-                            "SoldEquipment":      [],
-                            "SoldBoosts":         {"Power Boost":   0,
-                                                   "Magic Boost":   0,
-                                                   "Defense Boost": 0,
-                                                   "AP Boost":      0}
-                            }
-        self.slotDataProgressionNames = {}
-        self.kh2seedname = None
-        self.kh2slotdata = None
-        self.itemamount = {}
-        # sora equipped, valor equipped, master equipped, final equipped
-        self.keybladeAnchorList = (0x24F0, 0x32F4, 0x339C, 0x33D4)
-        if "localappdata" in os.environ:
-            self.game_communication_path = os.path.expandvars(r"%localappdata%\KH2AP")
-        self.amountOfPieces = 0
-        # hooked object
-        self.kh2 = None
-        self.ItemIsSafe = False
-        self.game_connected = False
-        self.finalxemnas = False
-        self.worldid = {
-            #  1:   {},  # world of darkness (story cutscenes)
-            2:  TT_Checks,
-            #  3:   {},  # destiny island doesn't have checks to ima put tt checks here
-            4:  HB_Checks,
-            5:  BC_Checks,
-            6:  Oc_Checks,
-            7:  AG_Checks,
-            8:  LoD_Checks,
-            9:  HundredAcreChecks,
-            10: PL_Checks,
-            11: DC_Checks,  # atlantica isn't a supported world. if you go in atlantica it will check dc
-            12: DC_Checks,
-            13: TR_Checks,
-            14: HT_Checks,
-            15: HB_Checks,  # world map, but you only go to the world map while on the way to goa so checking hb
-            16: PR_Checks,
-            17: SP_Checks,
-            18: TWTNW_Checks,
-            #  255: {},  # starting screen
-        }
-        # 0x2A09C00+0x40 is the sve anchor. +1 is the last saved room
-        self.sveroom = 0x2A09C00 + 0x41
-        # 0 not in battle 1 in yellow battle 2 red battle #short
-        self.inBattle = 0x2A0EAC4 + 0x40
-        self.onDeath = 0xAB9078
-        # PC Address anchors
-        self.Now = 0x0714DB8
-        self.Save = 0x09A70B0
-        self.Sys3 = 0x2A59DF0
-        self.Bt10 = 0x2A74880
-        self.BtlEnd = 0x2A0D3E0
-        self.Slot1 = 0x2A20C98
-
-        self.chest_set = set(exclusion_table["Chests"])
-
-        self.keyblade_set = set(CheckDupingItems["Weapons"]["Keyblades"])
-        self.staff_set = set(CheckDupingItems["Weapons"]["Staffs"])
-        self.shield_set = set(CheckDupingItems["Weapons"]["Shields"])
-
-        self.all_weapons = self.keyblade_set.union(self.staff_set).union(self.shield_set)
-
-        self.equipment_categories = CheckDupingItems["Equipment"]
-        self.armor_set = set(self.equipment_categories["Armor"])
-        self.accessories_set = set(self.equipment_categories["Accessories"])
-        self.all_equipment = self.armor_set.union(self.accessories_set)
-
-        self.Equipment_Anchor_Dict = {
-            "Armor":       [0x2504, 0x2506, 0x2508, 0x250A],
-            "Accessories": [0x2514, 0x2516, 0x2518, 0x251A]}
-
-        self.AbilityQuantityDict = {}
-        self.ability_categories = CheckDupingItems["Abilities"]
-
-        self.sora_ability_set = set(self.ability_categories["Sora"])
-        self.donald_ability_set = set(self.ability_categories["Donald"])
-        self.goofy_ability_set = set(self.ability_categories["Goofy"])
-
-        self.all_abilities = self.sora_ability_set.union(self.donald_ability_set).union(self.goofy_ability_set)
-
-        self.boost_set = set(CheckDupingItems["Boosts"])
-        self.stat_increase_set = set(CheckDupingItems["Stat Increases"])
-
-        self.AbilityQuantityDict = {item: self.item_name_to_data[item].quantity for item in self.all_abilities}
-        #  Growth:[level 1,level 4,slot]
-        self.growth_values_dict = {"High Jump":    [0x05E, 0x061, 0x25CE],
-                                   "Quick Run":    [0x62, 0x65, 0x25D0],
-                                   "Dodge Roll":   [0x234, 0x237, 0x25D2],
-                                   "Aerial Dodge": [0x066, 0x069, 0x25D4],
-                                   "Glide":        [0x6A, 0x6D, 0x25D6]}
-        self.boost_to_anchor_dict = {
-            "Power Boost":   0x24F9,
-            "Magic Boost":   0x24FA,
-            "Defense Boost": 0x24FB,
-            "AP Boost":      0x24F8}
-
-        self.AbilityCodeList = [self.item_name_to_data[item].code for item in exclusionItem_table["Ability"]]
-        self.master_growth = {"High Jump", "Quick Run", "Dodge Roll", "Aerial Dodge", "Glide"}
-
-        self.bitmask_item_code = [
-            0x130000, 0x130001, 0x130002, 0x130003, 0x130004, 0x130005, 0x130006, 0x130007
-            , 0x130008, 0x130009, 0x13000A, 0x13000B, 0x13000C
-            , 0x13001F, 0x130020, 0x130021, 0x130022, 0x130023
-            , 0x13002A, 0x13002B, 0x13002C, 0x13002D]
-
-    async def server_auth(self, password_requested: bool = False):
-        if password_requested and not self.password:
-            await super(KH2Context, self).server_auth(password_requested)
-        await self.get_username()
-        await self.send_connect()
-
-    async def connection_closed(self):
-        self.kh2connected = False
-        self.serverconneced = False
-        if self.kh2seedname is not None and self.auth is not None:
-            with open(os.path.join(self.game_communication_path, f"kh2save{self.kh2seedname}{self.auth}.json"),
-                      'w') as f:
-                f.write(json.dumps(self.kh2seedsave, indent=4))
-        await super(KH2Context, self).connection_closed()
-
-    async def disconnect(self, allow_autoreconnect: bool = False):
-        self.kh2connected = False
-        self.serverconneced = False
-        if self.kh2seedname not in {None} and self.auth not in {None}:
-            with open(os.path.join(self.game_communication_path, f"kh2save{self.kh2seedname}{self.auth}.json"),
-                      'w') as f:
-                f.write(json.dumps(self.kh2seedsave, indent=4))
-        await super(KH2Context, self).disconnect()
-
-    @property
-    def endpoints(self):
-        if self.server:
-            return [self.server]
-        else:
-            return []
-
-    async def shutdown(self):
-        if self.kh2seedname not in {None} and self.auth not in {None}:
-            with open(os.path.join(self.game_communication_path, f"kh2save{self.kh2seedname}{self.auth}.json"),
-                      'w') as f:
-                f.write(json.dumps(self.kh2seedsave, indent=4))
-        await super(KH2Context, self).shutdown()
-
-    def on_package(self, cmd: str, args: dict):
-        if cmd in {"RoomInfo"}:
-            self.kh2seedname = args['seed_name']
-            if not os.path.exists(self.game_communication_path):
-                os.makedirs(self.game_communication_path)
-            if not os.path.exists(self.game_communication_path + f"\kh2save{self.kh2seedname}{self.auth}.json"):
-                with open(os.path.join(self.game_communication_path, f"kh2save{self.kh2seedname}{self.auth}.json"),
-                          'wt') as f:
-                    pass
-            elif os.path.exists(self.game_communication_path + f"\kh2save{self.kh2seedname}{self.auth}.json"):
-                with open(self.game_communication_path + f"\kh2save{self.kh2seedname}{self.auth}.json", 'r') as f:
-                    self.kh2seedsave = json.load(f)
-
-        if cmd in {"Connected"}:
-            for player in args['players']:
-                if str(player.slot) not in self.kh2seedsave["checked_locations"]:
-                    self.kh2seedsave["checked_locations"].update({str(player.slot): []})
-            self.kh2slotdata = args['slot_data']
-            self.serverconneced = True
-            self.kh2LocalItems = {int(location): item for location, item in self.kh2slotdata["LocalItems"].items()}
-            try:
-                self.kh2 = pymem.Pymem(process_name="KINGDOM HEARTS II FINAL MIX")
-                logger.info("You are now auto-tracking")
-                self.kh2connected = True
-            except Exception as e:
-                logger.info("Line 247")
-                if self.kh2connected:
-                    logger.info("Connection Lost")
-                    self.kh2connected = False
-                logger.info(e)
-
-        if cmd in {"ReceivedItems"}:
-            start_index = args["index"]
-            if start_index != len(self.items_received):
-                for item in args['items']:
-                    # starting invo from server
-                    if item.location in {-2}:
-                        if not self.kh2seedsave["starting_inventory"]:
-                            asyncio.create_task(self.give_item(item.item))
-                    # if location is not already given or is !getitem
-                    elif item.location not in self.kh2seedsave["checked_locations"][str(item.player)] \
-                            or item.location in {-1}:
-                        asyncio.create_task(self.give_item(item.item))
-                        if item.location not in self.kh2seedsave["checked_locations"][str(item.player)] \
-                                and item.location not in {-1, -2}:
-                            self.kh2seedsave["checked_locations"][str(item.player)].append(item.location)
-                if not self.kh2seedsave["starting_inventory"]:
-                    self.kh2seedsave["starting_inventory"] = True
-
-        if cmd in {"RoomUpdate"}:
-            if "checked_locations" in args:
-                new_locations = set(args["checked_locations"])
-                # TODO: make this take locations from other players on the same slot so proper coop happens
-                #  items_to_give = [self.kh2slotdata["LocalItems"][str(location_id)] for location_id in new_locations if
-                #                 location_id in self.kh2LocalItems.keys()]
-                self.checked_locations |= new_locations
-
-    async def checkWorldLocations(self):
-        try:
-            currentworldint = int.from_bytes(self.kh2.read_bytes(self.kh2.base_address + 0x0714DB8, 1), "big")
-            if currentworldint in self.worldid:
-                curworldid = self.worldid[currentworldint]
-                for location, data in curworldid.items():
-                    if location not in self.locations_checked \
-                            and (int.from_bytes(
-                            self.kh2.read_bytes(self.kh2.base_address + self.Save + data.addrObtained, 1),
-                            "big") & 0x1 << data.bitIndex) > 0:
-                        self.locations_checked.add(location)
-                        self.sending = self.sending + [(int(kh2_loc_name_to_id[location]))]
-        except Exception as e:
-            logger.info("Line 285")
-            if self.kh2connected:
-                logger.info("Connection Lost.")
-                self.kh2connected = False
-            logger.info(e)
-
-    async def checkLevels(self):
-        try:
-            for location, data in SoraLevels.items():
-                currentLevel = int.from_bytes(
-                        self.kh2.read_bytes(self.kh2.base_address + self.Save + 0x24FF, 1), "big")
-                if location not in self.locations_checked \
-                        and currentLevel >= data.bitIndex:
-                    if self.kh2seedsave["Levels"]["SoraLevel"] < currentLevel:
-                        self.kh2seedsave["Levels"]["SoraLevel"] = currentLevel
-                    self.locations_checked.add(location)
-                    self.sending = self.sending + [(int(kh2_loc_name_to_id[location]))]
-            formDict = {
-                0: ["ValorLevel", ValorLevels], 1: ["WisdomLevel", WisdomLevels], 2: ["LimitLevel", LimitLevels],
-                3: ["MasterLevel", MasterLevels], 4: ["FinalLevel", FinalLevels]}
-            for i in range(5):
-                for location, data in formDict[i][1].items():
-                    formlevel = int.from_bytes(
-                            self.kh2.read_bytes(self.kh2.base_address + self.Save + data.addrObtained, 1), "big")
-                    if location not in self.locations_checked \
-                            and formlevel >= data.bitIndex:
-                        if formlevel > self.kh2seedsave["Levels"][formDict[i][0]]:
-                            self.kh2seedsave["Levels"][formDict[i][0]] = formlevel
-                        self.locations_checked.add(location)
-                        self.sending = self.sending + [(int(kh2_loc_name_to_id[location]))]
-        except Exception as e:
-            logger.info("Line 312")
-            if self.kh2connected:
-                logger.info("Connection Lost.")
-                self.kh2connected = False
-            logger.info(e)
-
-    async def checkSlots(self):
-        try:
-            for location, data in weaponSlots.items():
-                if location not in self.locations_checked:
-                    if int.from_bytes(self.kh2.read_bytes(self.kh2.base_address + self.Save + data.addrObtained, 1),
-                                      "big") > 0:
-                        self.locations_checked.add(location)
-                        self.sending = self.sending + [(int(kh2_loc_name_to_id[location]))]
-
-            for location, data in formSlots.items():
-                if location not in self.locations_checked:
-                    if int.from_bytes(self.kh2.read_bytes(self.kh2.base_address + self.Save + data.addrObtained, 1),
-                                      "big") & 0x1 << data.bitIndex > 0:
-                        self.locations_checked.add(location)
-                        self.sending = self.sending + [(int(kh2_loc_name_to_id[location]))]
-        except Exception as e:
-            if self.kh2connected:
-                logger.info("Line 333")
-                logger.info("Connection Lost.")
-                self.kh2connected = False
-            logger.info(e)
-
-    async def verifyChests(self):
-        try:
-            currentworld = str(int.from_bytes(self.kh2.read_bytes(self.kh2.base_address + 0x0714DB8, 1), "big"))
-            for location in self.kh2seedsave["worldIdChecks"][currentworld]:
-                locationName = self.lookup_id_to_Location[location]
-                if locationName in self.chest_set:
-                    if locationName in self.location_name_to_worlddata.keys():
-                        locationData = self.location_name_to_worlddata[locationName]
-                        if int.from_bytes(
-                                self.kh2.read_bytes(self.kh2.base_address + self.Save + locationData.addrObtained, 1),
-                                "big") & 0x1 << locationData.bitIndex == 0:
-                            roomData = int.from_bytes(
-                                    self.kh2.read_bytes(self.kh2.base_address + self.Save + locationData.addrObtained,
-                                                        1), "big")
-                            self.kh2.write_bytes(self.kh2.base_address + self.Save + locationData.addrObtained,
-                                                 (roomData | 0x01 << locationData.bitIndex).to_bytes(1, 'big'), 1)
-
-        except Exception as e:
-            if self.kh2connected:
-                logger.info("Line 350")
-                logger.info("Connection Lost.")
-                self.kh2connected = False
-            logger.info(e)
-
-    async def verifyLevel(self):
-        for leveltype, anchor in {"SoraLevel":   0x24FF,
-                                  "ValorLevel":  0x32F6,
-                                  "WisdomLevel": 0x332E,
-                                  "LimitLevel":  0x3366,
-                                  "MasterLevel": 0x339E,
-                                  "FinalLevel":  0x33D6}.items():
-            if int.from_bytes(self.kh2.read_bytes(self.kh2.base_address + self.Save + anchor, 1), "big") < \
-                    self.kh2seedsave["Levels"][leveltype]:
-                self.kh2.write_bytes(self.kh2.base_address + self.Save + anchor,
-                                     (self.kh2seedsave["Levels"][leveltype]).to_bytes(1, 'big'), 1)
-
-    def verifyLocation(self, location):
-        locationData = self.location_name_to_worlddata[location]
-        locationName = self.lookup_id_to_Location[location]
-        isChecked = True
-
-        if locationName not in levels_locations:
-            if (int.from_bytes(self.kh2.read_bytes(self.kh2.base_address + self.Save + locationData.addrObtained, 1),
-                               "big") & 0x1 << locationData.bitIndex) == 0:
-                isChecked = False
-        elif locationName in SoraLevels:
-            if int.from_bytes(self.kh2.read_bytes(self.kh2.base_address + self.Save + 0x24FF, 1),
-                              "big") < locationData.bitIndex:
-                isChecked = False
-        elif int.from_bytes(self.kh2.read_bytes(self.kh2.base_address + self.Save + locationData.addrObtained, 1),
-                            "big") < locationData.bitIndex:
-            isChecked = False
-        return isChecked
-
-    async def give_item(self, item, ItemType="ServerItems"):
-        try:
-            itemname = self.lookup_id_to_item[item]
-            itemcode = self.item_name_to_data[itemname]
-            if itemcode.ability:
-                abilityInvoType = 0
-                TwilightZone = 2
-                if ItemType == "LocalItems":
-                    abilityInvoType = 1
-                    TwilightZone = -2
-                if itemname in {"High Jump", "Quick Run", "Dodge Roll", "Aerial Dodge", "Glide"}:
-                    self.kh2seedsave["AmountInvo"][ItemType]["Growth"][itemname] += 1
-                    return
-
-                if itemname not in self.kh2seedsave["AmountInvo"][ItemType]["Ability"]:
-                    self.kh2seedsave["AmountInvo"][ItemType]["Ability"][itemname] = []
-                    #  appending the slot that the ability should be in
-
-                if len(self.kh2seedsave["AmountInvo"][ItemType]["Ability"][itemname]) < \
-                        self.AbilityQuantityDict[itemname]:
-                    if itemname in self.sora_ability_set:
-                        self.kh2seedsave["AmountInvo"][ItemType]["Ability"][itemname].append(
-                                self.kh2seedsave["SoraInvo"][abilityInvoType])
-                        self.kh2seedsave["SoraInvo"][abilityInvoType] -= TwilightZone
-                    elif itemname in self.donald_ability_set:
-                        self.kh2seedsave["AmountInvo"][ItemType]["Ability"][itemname].append(
-                                self.kh2seedsave["DonaldInvo"][abilityInvoType])
-                        self.kh2seedsave["DonaldInvo"][abilityInvoType] -= TwilightZone
-                    else:
-                        self.kh2seedsave["AmountInvo"][ItemType]["Ability"][itemname].append(
-                                self.kh2seedsave["GoofyInvo"][abilityInvoType])
-                        self.kh2seedsave["GoofyInvo"][abilityInvoType] -= TwilightZone
-
-            elif itemcode.code in self.bitmask_item_code:
-
-                if itemname not in self.kh2seedsave["AmountInvo"][ItemType]["Bitmask"]:
-                    self.kh2seedsave["AmountInvo"][ItemType]["Bitmask"].append(itemname)
-
-            elif itemcode.memaddr in {0x3594, 0x3595, 0x3596, 0x3597, 0x35CF, 0x35D0}:
-
-                if itemname in self.kh2seedsave["AmountInvo"][ItemType]["Magic"]:
-                    self.kh2seedsave["AmountInvo"][ItemType]["Magic"][itemname] += 1
-                else:
-                    self.kh2seedsave["AmountInvo"][ItemType]["Magic"][itemname] = 1
-            elif itemname in self.all_equipment:
-
-                self.kh2seedsave["AmountInvo"][ItemType]["Equipment"].append(itemname)
-
-            elif itemname in self.all_weapons:
-                if itemname in self.keyblade_set:
-                    self.kh2seedsave["AmountInvo"][ItemType]["Weapon"]["Sora"].append(itemname)
-                elif itemname in self.staff_set:
-                    self.kh2seedsave["AmountInvo"][ItemType]["Weapon"]["Donald"].append(itemname)
-                else:
-                    self.kh2seedsave["AmountInvo"][ItemType]["Weapon"]["Goofy"].append(itemname)
-
-            elif itemname in self.boost_set:
-                if itemname in self.kh2seedsave["AmountInvo"][ItemType]["Boost"]:
-                    self.kh2seedsave["AmountInvo"][ItemType]["Boost"][itemname] += 1
-                else:
-                    self.kh2seedsave["AmountInvo"][ItemType]["Boost"][itemname] = 1
-
-            elif itemname in self.stat_increase_set:
-
-                if itemname in self.kh2seedsave["AmountInvo"][ItemType]["StatIncrease"]:
-                    self.kh2seedsave["AmountInvo"][ItemType]["StatIncrease"][itemname] += 1
-                else:
-                    self.kh2seedsave["AmountInvo"][ItemType]["StatIncrease"][itemname] = 1
-
-            else:
-                if itemname in self.kh2seedsave["AmountInvo"][ItemType]["Amount"]:
-                    self.kh2seedsave["AmountInvo"][ItemType]["Amount"][itemname] += 1
-                else:
-                    self.kh2seedsave["AmountInvo"][ItemType]["Amount"][itemname] = 1
-
-        except Exception as e:
-            if self.kh2connected:
-                logger.info("Line 398")
-                logger.info("Connection Lost.")
-                self.kh2connected = False
-            logger.info(e)
-
-    def run_gui(self):
-        """Import kivy UI system and start running it as self.ui_task."""
-        from kvui import GameManager
-
-        class KH2Manager(GameManager):
-            logging_pairs = [
-                ("Client", "Archipelago")
-            ]
-            base_title = "Archipelago KH2 Client"
-
-        self.ui = KH2Manager(self)
-        self.ui_task = asyncio.create_task(self.ui.async_run(), name="UI")
-
-    async def IsInShop(self, sellable, master_boost):
-        # journal = 0x741230 shop = 0x741320
-        # if journal=-1 and shop = 5 then in shop
-        # if journam !=-1 and shop = 10 then journal
-        journal = self.kh2.read_short(self.kh2.base_address + 0x741230)
-        shop = self.kh2.read_short(self.kh2.base_address + 0x741320)
-        if (journal == -1 and shop == 5) or (journal != -1 and shop == 10):
-            # print("your in the shop")
-            sellable_dict = {}
-            for itemName in sellable:
-                itemdata = self.item_name_to_data[itemName]
-                amount = int.from_bytes(
-                        self.kh2.read_bytes(self.kh2.base_address + self.Save + itemdata.memaddr, 1), "big")
-                sellable_dict[itemName] = amount
-            while (journal == -1 and shop == 5) or (journal != -1 and shop == 10):
-                journal = self.kh2.read_short(self.kh2.base_address + 0x741230)
-                shop = self.kh2.read_short(self.kh2.base_address + 0x741320)
-                await asyncio.sleep(0.5)
-            for item, amount in sellable_dict.items():
-                itemdata = self.item_name_to_data[item]
-                afterShop = int.from_bytes(
-                        self.kh2.read_bytes(self.kh2.base_address + self.Save + itemdata.memaddr, 1), "big")
-                if afterShop < amount:
-                    if item in master_boost:
-                        self.kh2seedsave["SoldBoosts"][item] += (amount - afterShop)
-                    else:
-                        self.kh2seedsave["SoldEquipment"].append(item)
-
-    async def verifyItems(self):
-        try:
-            local_amount = set(self.kh2seedsave["AmountInvo"]["LocalItems"]["Amount"].keys())
-            server_amount = set(self.kh2seedsave["AmountInvo"]["ServerItems"]["Amount"].keys())
-            master_amount = local_amount | server_amount
-
-            local_ability = set(self.kh2seedsave["AmountInvo"]["LocalItems"]["Ability"].keys())
-            server_ability = set(self.kh2seedsave["AmountInvo"]["ServerItems"]["Ability"].keys())
-            master_ability = local_ability | server_ability
-
-            local_bitmask = set(self.kh2seedsave["AmountInvo"]["LocalItems"]["Bitmask"])
-            server_bitmask = set(self.kh2seedsave["AmountInvo"]["ServerItems"]["Bitmask"])
-            master_bitmask = local_bitmask | server_bitmask
-
-            local_keyblade = set(self.kh2seedsave["AmountInvo"]["LocalItems"]["Weapon"]["Sora"])
-            local_staff = set(self.kh2seedsave["AmountInvo"]["LocalItems"]["Weapon"]["Donald"])
-            local_shield = set(self.kh2seedsave["AmountInvo"]["LocalItems"]["Weapon"]["Goofy"])
-
-            server_keyblade = set(self.kh2seedsave["AmountInvo"]["ServerItems"]["Weapon"]["Sora"])
-            server_staff = set(self.kh2seedsave["AmountInvo"]["ServerItems"]["Weapon"]["Donald"])
-            server_shield = set(self.kh2seedsave["AmountInvo"]["ServerItems"]["Weapon"]["Goofy"])
-
-            master_keyblade = local_keyblade | server_keyblade
-            master_staff = local_staff | server_staff
-            master_shield = local_shield | server_shield
-
-            local_equipment = set(self.kh2seedsave["AmountInvo"]["LocalItems"]["Equipment"])
-            server_equipment = set(self.kh2seedsave["AmountInvo"]["ServerItems"]["Equipment"])
-            master_equipment = local_equipment | server_equipment
-
-            local_magic = set(self.kh2seedsave["AmountInvo"]["LocalItems"]["Magic"].keys())
-            server_magic = set(self.kh2seedsave["AmountInvo"]["ServerItems"]["Magic"].keys())
-            master_magic = local_magic | server_magic
-
-            local_stat = set(self.kh2seedsave["AmountInvo"]["LocalItems"]["StatIncrease"].keys())
-            server_stat = set(self.kh2seedsave["AmountInvo"]["ServerItems"]["StatIncrease"].keys())
-            master_stat = local_stat | server_stat
-
-            local_boost = set(self.kh2seedsave["AmountInvo"]["LocalItems"]["Boost"].keys())
-            server_boost = set(self.kh2seedsave["AmountInvo"]["ServerItems"]["Boost"].keys())
-            master_boost = local_boost | server_boost
-
-            master_sell = master_equipment | master_staff | master_shield | master_boost
-            await asyncio.create_task(self.IsInShop(master_sell, master_boost))
-            for itemName in master_amount:
-                itemData = self.item_name_to_data[itemName]
-                amountOfItems = 0
-                if itemName in local_amount:
-                    amountOfItems += self.kh2seedsave["AmountInvo"]["LocalItems"]["Amount"][itemName]
-                if itemName in server_amount:
-                    amountOfItems += self.kh2seedsave["AmountInvo"]["ServerItems"]["Amount"][itemName]
-
-                if itemName == "Torn Page":
-                    # Torn Pages are handled differently because they can be consumed.
-                    # Will check the progression in 100 acre and - the amount of visits
-                    # amountofitems-amount of visits done
-                    for location, data in tornPageLocks.items():
-                        if int.from_bytes(self.kh2.read_bytes(self.kh2.base_address + self.Save + data.addrObtained, 1),
-                                          "big") & 0x1 << data.bitIndex > 0:
-                            amountOfItems -= 1
-                if int.from_bytes(self.kh2.read_bytes(self.kh2.base_address + self.Save + itemData.memaddr, 1),
-                                  "big") != amountOfItems and amountOfItems >= 0:
-                    self.kh2.write_bytes(self.kh2.base_address + self.Save + itemData.memaddr,
-                                         amountOfItems.to_bytes(1, 'big'), 1)
-
-            for itemName in master_keyblade:
-                itemData = self.item_name_to_data[itemName]
-                # if the inventory slot for that keyblade is less than the amount they should have
-                if int.from_bytes(self.kh2.read_bytes(self.kh2.base_address + self.Save + itemData.memaddr, 1),
-                                  "big") != 1 and int.from_bytes(self.kh2.read_bytes(self.kh2.base_address + 0x1CFF, 1),
-                                                                 "big") != 13:
-                    # Checking form anchors for the keyblade
-                    if self.kh2.read_short(self.kh2.base_address + self.Save + 0x24F0) == itemData.kh2id \
-                            or self.kh2.read_short(self.kh2.base_address + self.Save + 0x32F4) == itemData.kh2id \
-                            or self.kh2.read_short(self.kh2.base_address + self.Save + 0x339C) == itemData.kh2id \
-                            or self.kh2.read_short(self.kh2.base_address + self.Save + 0x33D4) == itemData.kh2id:
-                        self.kh2.write_bytes(self.kh2.base_address + self.Save + itemData.memaddr,
-                                             (0).to_bytes(1, 'big'), 1)
-                    else:
-                        self.kh2.write_bytes(self.kh2.base_address + self.Save + itemData.memaddr,
-                                             (1).to_bytes(1, 'big'), 1)
-            for itemName in master_staff:
-                itemData = self.item_name_to_data[itemName]
-                if int.from_bytes(self.kh2.read_bytes(self.kh2.base_address + self.Save + itemData.memaddr, 1),
-                                  "big") != 1 \
-                        and self.kh2.read_short(self.kh2.base_address + self.Save + 0x2604) != itemData.kh2id \
-                        and itemName not in self.kh2seedsave["SoldEquipment"]:
-                    self.kh2.write_bytes(self.kh2.base_address + self.Save + itemData.memaddr,
-                                         (1).to_bytes(1, 'big'), 1)
-
-            for itemName in master_shield:
-                itemData = self.item_name_to_data[itemName]
-                if int.from_bytes(self.kh2.read_bytes(self.kh2.base_address + self.Save + itemData.memaddr, 1),
-                                  "big") != 1 \
-                        and self.kh2.read_short(self.kh2.base_address + self.Save + 0x2718) != itemData.kh2id \
-                        and itemName not in self.kh2seedsave["SoldEquipment"]:
-                    self.kh2.write_bytes(self.kh2.base_address + self.Save + itemData.memaddr,
-                                         (1).to_bytes(1, 'big'), 1)
-
-            for itemName in master_ability:
-                itemData = self.item_name_to_data[itemName]
-                ability_slot = []
-                if itemName in local_ability:
-                    ability_slot += self.kh2seedsave["AmountInvo"]["LocalItems"]["Ability"][itemName]
-                if itemName in server_ability:
-                    ability_slot += self.kh2seedsave["AmountInvo"]["ServerItems"]["Ability"][itemName]
-                for slot in ability_slot:
-                    current = self.kh2.read_short(self.kh2.base_address + self.Save + slot)
-                    ability = current & 0x0FFF
-                    if ability | 0x8000 != (0x8000 + itemData.memaddr):
-                        self.kh2.write_short(self.kh2.base_address + self.Save + slot, itemData.memaddr)
-
-            for itemName in self.master_growth:
-                growthLevel = self.kh2seedsave["AmountInvo"]["ServerItems"]["Growth"][itemName] \
-                              + self.kh2seedsave["AmountInvo"]["LocalItems"]["Growth"][itemName]
-                if growthLevel > 0:
-                    slot = self.growth_values_dict[itemName][2]
-                    min_growth = self.growth_values_dict[itemName][0]
-                    max_growth = self.growth_values_dict[itemName][1]
-                    if growthLevel > 4:
-                        growthLevel = 4
-                    current_growth_level = self.kh2.read_short(self.kh2.base_address + self.Save + slot)
-                    ability = current_growth_level & 0x0FFF
-                    # if the player should be getting a growth ability
-                    if ability | 0x8000 != 0x8000 + min_growth - 1 + growthLevel:
-                        # if it should be level one of that growth
-                        if 0x8000 + min_growth - 1 + growthLevel <= 0x8000 + min_growth or ability < min_growth:
-                            self.kh2.write_short(self.kh2.base_address + self.Save + slot, min_growth)
-                        # if it is already in the inventory
-                        elif ability | 0x8000 < (0x8000 + max_growth):
-                            self.kh2.write_short(self.kh2.base_address + self.Save + slot, current_growth_level + 1)
-
-            for itemName in master_bitmask:
-                itemData = self.item_name_to_data[itemName]
-                itemMemory = int.from_bytes(
-                        self.kh2.read_bytes(self.kh2.base_address + self.Save + itemData.memaddr, 1), "big")
-                if (int.from_bytes(self.kh2.read_bytes(self.kh2.base_address + self.Save + itemData.memaddr, 1),
-                                   "big") & 0x1 << itemData.bitmask) == 0:
-                    self.kh2.write_bytes(self.kh2.base_address + self.Save + itemData.memaddr,
-                                         (itemMemory | 0x01 << itemData.bitmask).to_bytes(1, 'big'), 1)
-
-            for itemName in master_equipment:
-                itemData = self.item_name_to_data[itemName]
-                isThere = False
-                if itemName in self.accessories_set:
-                    Equipment_Anchor_List = self.Equipment_Anchor_Dict["Accessories"]
-                else:
-                    Equipment_Anchor_List = self.Equipment_Anchor_Dict["Armor"]
-                    # Checking form anchors for the equipment
-                for slot in Equipment_Anchor_List:
-                    if self.kh2.read_short(self.kh2.base_address + self.Save + slot) == itemData.kh2id:
-                        isThere = True
-                        if int.from_bytes(self.kh2.read_bytes(self.kh2.base_address + self.Save + itemData.memaddr, 1),
-                                          "big") != 0:
-                            self.kh2.write_bytes(self.kh2.base_address + self.Save + itemData.memaddr,
-                                                 (0).to_bytes(1, 'big'), 1)
-                        break
-                if not isThere and itemName not in self.kh2seedsave["SoldEquipment"]:
-                    if int.from_bytes(self.kh2.read_bytes(self.kh2.base_address + self.Save + itemData.memaddr, 1),
-                                      "big") != 1:
-                        self.kh2.write_bytes(self.kh2.base_address + self.Save + itemData.memaddr,
-                                             (1).to_bytes(1, 'big'), 1)
-
-            for itemName in master_magic:
-                itemData = self.item_name_to_data[itemName]
-                amountOfItems = 0
-                if itemName in local_magic:
-                    amountOfItems += self.kh2seedsave["AmountInvo"]["LocalItems"]["Magic"][itemName]
-                if itemName in server_magic:
-                    amountOfItems += self.kh2seedsave["AmountInvo"]["ServerItems"]["Magic"][itemName]
-                if int.from_bytes(self.kh2.read_bytes(self.kh2.base_address + self.Save + itemData.memaddr, 1),
-                                  "big") != amountOfItems \
-                        and int.from_bytes(self.kh2.read_bytes(self.kh2.base_address + 0x741320, 1), "big") in {10, 8}:
-                    self.kh2.write_bytes(self.kh2.base_address + self.Save + itemData.memaddr,
-                                         amountOfItems.to_bytes(1, 'big'), 1)
-
-            for itemName in master_stat:
-                itemData = self.item_name_to_data[itemName]
-                amountOfItems = 0
-                if itemName in local_stat:
-                    amountOfItems += self.kh2seedsave["AmountInvo"]["LocalItems"]["StatIncrease"][itemName]
-                if itemName in server_stat:
-                    amountOfItems += self.kh2seedsave["AmountInvo"]["ServerItems"]["StatIncrease"][itemName]
-
-                if int.from_bytes(self.kh2.read_bytes(self.kh2.base_address + self.Save + itemData.memaddr, 1),
-                                  "big") != amountOfItems \
-                        and int.from_bytes(self.kh2.read_bytes(self.kh2.base_address + self.Slot1 + 0x1B2, 1),
-                                           "big") >= 5:
-                    self.kh2.write_bytes(self.kh2.base_address + self.Save + itemData.memaddr,
-                                         amountOfItems.to_bytes(1, 'big'), 1)
-
-            for itemName in master_boost:
-                itemData = self.item_name_to_data[itemName]
-                amountOfItems = 0
-                if itemName in local_boost:
-                    amountOfItems += self.kh2seedsave["AmountInvo"]["LocalItems"]["Boost"][itemName]
-                if itemName in server_boost:
-                    amountOfItems += self.kh2seedsave["AmountInvo"]["ServerItems"]["Boost"][itemName]
-                amountOfBoostsInInvo = int.from_bytes(
-                        self.kh2.read_bytes(self.kh2.base_address + self.Save + itemData.memaddr, 1),
-                        "big")
-                amountOfUsedBoosts = int.from_bytes(
-                        self.kh2.read_bytes(self.kh2.base_address + self.Save + self.boost_to_anchor_dict[itemName], 1),
-                        "big")
-                # Ap Boots start at +50 for some reason
-                if itemName == "AP Boost":
-                    amountOfUsedBoosts -= 50
-                totalBoosts = (amountOfBoostsInInvo + amountOfUsedBoosts)
-                if totalBoosts <= amountOfItems - self.kh2seedsave["SoldBoosts"][itemName] and amountOfBoostsInInvo < 255:
-                    self.kh2.write_bytes(self.kh2.base_address + self.Save + itemData.memaddr,
-                                         (amountOfBoostsInInvo + 1).to_bytes(1, 'big'), 1)
-
-        except Exception as e:
-            logger.info("Line 573")
-            if self.kh2connected:
-                logger.info("Connection Lost.")
-                self.kh2connected = False
-            logger.info(e)
-
-
-def finishedGame(ctx: KH2Context, message):
-    if ctx.kh2slotdata['FinalXemnas'] == 1:
-        if 0x1301ED in message[0]["locations"]:
-            ctx.finalxemnas = True
-    # three proofs
-    if ctx.kh2slotdata['Goal'] == 0:
-        if int.from_bytes(ctx.kh2.read_bytes(ctx.kh2.base_address + ctx.Save + 0x36B2, 1), "big") > 0 \
-                and int.from_bytes(ctx.kh2.read_bytes(ctx.kh2.base_address + ctx.Save + 0x36B3, 1), "big") > 0 \
-                and int.from_bytes(ctx.kh2.read_bytes(ctx.kh2.base_address + ctx.Save + 0x36B4, 1), "big") > 0:
-            if ctx.kh2slotdata['FinalXemnas'] == 1:
-                if ctx.finalxemnas:
-                    return True
-                else:
-                    return False
-            else:
-                return True
-        else:
-            return False
-    elif ctx.kh2slotdata['Goal'] == 1:
-        if int.from_bytes(ctx.kh2.read_bytes(ctx.kh2.base_address + ctx.Save + 0x3641, 1), "big") >= \
-                ctx.kh2slotdata['LuckyEmblemsRequired']:
-            ctx.kh2.write_bytes(ctx.kh2.base_address + ctx.Save + 0x36B2, (1).to_bytes(1, 'big'), 1)
-            ctx.kh2.write_bytes(ctx.kh2.base_address + ctx.Save + 0x36B3, (1).to_bytes(1, 'big'), 1)
-            ctx.kh2.write_bytes(ctx.kh2.base_address + ctx.Save + 0x36B4, (1).to_bytes(1, 'big'), 1)
-            if ctx.kh2slotdata['FinalXemnas'] == 1:
-                if ctx.finalxemnas:
-                    return True
-                else:
-                    return False
-            else:
-                return True
-        else:
-            return False
-    elif ctx.kh2slotdata['Goal'] == 2:
-        for boss in ctx.kh2slotdata["hitlist"]:
-            if boss in message[0]["locations"]:
-                ctx.amountOfPieces += 1
-        if ctx.amountOfPieces >= ctx.kh2slotdata["BountyRequired"]:
-            ctx.kh2.write_bytes(ctx.kh2.base_address + ctx.Save + 0x36B2, (1).to_bytes(1, 'big'), 1)
-            ctx.kh2.write_bytes(ctx.kh2.base_address + ctx.Save + 0x36B3, (1).to_bytes(1, 'big'), 1)
-            ctx.kh2.write_bytes(ctx.kh2.base_address + ctx.Save + 0x36B4, (1).to_bytes(1, 'big'), 1)
-            if ctx.kh2slotdata['FinalXemnas'] == 1:
-                if ctx.finalxemnas:
-                    return True
-                else:
-                    return False
-            else:
-                return True
-        else:
-            return False
-
-
-async def kh2_watcher(ctx: KH2Context):
-    while not ctx.exit_event.is_set():
-        try:
-            if ctx.kh2connected and ctx.serverconneced:
-                ctx.sending = []
-                await asyncio.create_task(ctx.checkWorldLocations())
-                await asyncio.create_task(ctx.checkLevels())
-                await asyncio.create_task(ctx.checkSlots())
-                await asyncio.create_task(ctx.verifyChests())
-                await asyncio.create_task(ctx.verifyItems())
-                await asyncio.create_task(ctx.verifyLevel())
-                message = [{"cmd": 'LocationChecks', "locations": ctx.sending}]
-                if finishedGame(ctx, message):
-                    await ctx.send_msgs([{"cmd": "StatusUpdate", "status": ClientStatus.CLIENT_GOAL}])
-                    ctx.finished_game = True
-                location_ids = []
-                location_ids = [location for location in message[0]["locations"] if location not in location_ids]
-                for location in location_ids:
-                    currentWorld = int.from_bytes(ctx.kh2.read_bytes(ctx.kh2.base_address + 0x0714DB8, 1), "big")
-                    if location not in ctx.kh2seedsave["worldIdChecks"][str(currentWorld)]:
-                        ctx.kh2seedsave["worldIdChecks"][str(currentWorld)].append(location)
-                        if location in ctx.kh2LocalItems:
-                            item = ctx.kh2slotdata["LocalItems"][str(location)]
-                            await asyncio.create_task(ctx.give_item(item, "LocalItems"))
-                await ctx.send_msgs(message)
-            elif not ctx.kh2connected and ctx.serverconneced:
-                logger.info("Game is not open. Disconnecting from Server.")
-                await ctx.disconnect()
-        except Exception as e:
-            logger.info("Line 661")
-            if ctx.kh2connected:
-                logger.info("Connection Lost.")
-                ctx.kh2connected = False
-            logger.info(e)
-        await asyncio.sleep(0.5)
-
-
 if __name__ == '__main__':
-    async def main(args):
-        ctx = KH2Context(args.connect, args.password)
-        ctx.server_task = asyncio.create_task(server_loop(ctx), name="server loop")
-        if gui_enabled:
-            ctx.run_gui()
-        ctx.run_cli()
-        progression_watcher = asyncio.create_task(
-                kh2_watcher(ctx), name="KH2ProgressionWatcher")
-
-        await ctx.exit_event.wait()
-        ctx.server_address = None
-
-        await progression_watcher
-
-        await ctx.shutdown()
-
-
-    import colorama
-
-    parser = get_base_parser(description="KH2 Client, for text interfacing.")
-
-    args, rest = parser.parse_known_args()
-    colorama.init()
-    asyncio.run(main(args))
-    colorama.deinit()
+    Utils.init_logging("KH2Client", exception_logger="Client")
+    launch()

Launcher.py

@@ -11,14 +11,19 @@ Scroll down to components= to add components to the launcher as well as setup.py
 
 import argparse
 import itertools
+import logging
+import multiprocessing
 import shlex
 import subprocess
 import sys
+import webbrowser
 from os.path import isfile
 from shutil import which
 from typing import Sequence, Union, Optional
 
-from worlds.LauncherComponents import Component, components, Type, SuffixIdentifier
+import Utils
+import settings
+from worlds.LauncherComponents import Component, components, Type, SuffixIdentifier, icon_paths
 
 if __name__ == "__main__":
     import ModuleUpdate
@@ -29,7 +34,8 @@ from Utils import is_frozen, user_path, local_path, init_logging, open_filename,
 
 
 def open_host_yaml():
-    file = user_path('host.yaml')
+    file = settings.get_settings().filename
+    assert file, "host.yaml missing"
     if is_linux:
         exe = which('sensible-editor') or which('gedit') or \
               which('xdg-open') or which('gnome-open') or which('kde-open')
@@ -38,79 +44,103 @@ def open_host_yaml():
         exe = which("open")
         subprocess.Popen([exe, file])
     else:
-        import webbrowser
         webbrowser.open(file)
 
 
 def open_patch():
     suffixes = []
     for c in components:
-        if isfile(get_exe(c)[-1]):
-            suffixes += c.file_identifier.suffixes if c.type == Type.CLIENT and \
-                                                      isinstance(c.file_identifier, SuffixIdentifier) else []
+        if c.type == Type.CLIENT and \
+                isinstance(c.file_identifier, SuffixIdentifier) and \
+                (c.script_name is None or isfile(get_exe(c)[-1])):
+            suffixes += c.file_identifier.suffixes
     try:
-        filename = open_filename('Select patch', (('Patches', suffixes),))
+        filename = open_filename("Select patch", (("Patches", suffixes),))
     except Exception as e:
-        messagebox('Error', str(e), error=True)
+        messagebox("Error", str(e), error=True)
     else:
-        file, _, component = identify(filename)
+        file, component = identify(filename)
         if file and component:
-            launch([*get_exe(component), file], component.cli)
+            exe = get_exe(component)
+            if exe is None or not isfile(exe[-1]):
+                exe = get_exe("Launcher")
+
+            launch([*exe, file], component.cli)
+
+
+def generate_yamls():
+    from Options import generate_yaml_templates
+
+    target = Utils.user_path("Players", "Templates")
+    generate_yaml_templates(target, False)
+    open_folder(target)
 
 
 def browse_files():
-    file = user_path()
+    open_folder(user_path())
+
+
+def open_folder(folder_path):
     if is_linux:
         exe = which('xdg-open') or which('gnome-open') or which('kde-open')
-        subprocess.Popen([exe, file])
+        subprocess.Popen([exe, folder_path])
     elif is_macos:
         exe = which("open")
-        subprocess.Popen([exe, file])
+        subprocess.Popen([exe, folder_path])
     else:
-        import webbrowser
-        webbrowser.open(file)
+        webbrowser.open(folder_path)
+
+
+def update_settings():
+    from settings import get_settings
+    get_settings().save()
 
 
 components.extend([
     # Functions
-    Component('Open host.yaml', func=open_host_yaml),
-    Component('Open Patch', func=open_patch),
-    Component('Browse Files', func=browse_files),
+    Component("Open host.yaml", func=open_host_yaml),
+    Component("Open Patch", func=open_patch),
+    Component("Generate Template Options", func=generate_yamls),
+    Component("Discord Server", icon="discord", func=lambda: webbrowser.open("https://discord.gg/8Z65BR2")),
+    Component("18+ Discord Server", icon="discord", func=lambda: webbrowser.open("https://discord.gg/fqvNCCRsu4")),
+    Component("Browse Files", func=browse_files),
 ])
 
 
 def identify(path: Union[None, str]):
     if path is None:
-        return None, None, None
+        return None, None
     for component in components:
         if component.handles_file(path):
-            return path, component.script_name, component
-    return (None, None, None) if '/' in path or '\\' in path else (None, path, None)
+            return path, component
+        elif path == component.display_name or path == component.script_name:
+            return None, component
+    return None, None
 
 
 def get_exe(component: Union[str, Component]) -> Optional[Sequence[str]]:
     if isinstance(component, str):
         name = component
         component = None
-        if name.startswith('Archipelago'):
+        if name.startswith("Archipelago"):
             name = name[11:]
-        if name.endswith('.exe'):
+        if name.endswith(".exe"):
             name = name[:-4]
-        if name.endswith('.py'):
+        if name.endswith(".py"):
             name = name[:-3]
         if not name:
             return None
         for c in components:
-            if c.script_name == name or c.frozen_name == f'Archipelago{name}':
+            if c.script_name == name or c.frozen_name == f"Archipelago{name}":
                 component = c
                 break
         if not component:
             return None
     if is_frozen():
-        suffix = '.exe' if is_windows else ''
-        return [local_path(f'{component.frozen_name}{suffix}')]
+        suffix = ".exe" if is_windows else ""
+        return [local_path(f"{component.frozen_name}{suffix}")] if component.frozen_name else None
     else:
-        return [sys.executable, local_path(f'{component.script_name}.py')]
+        return [sys.executable, local_path(f"{component.script_name}.py")] if component.script_name else None
 
 
 def launch(exe, in_terminal=False):
@@ -131,17 +161,19 @@ def launch(exe, in_terminal=False):
 
 
 def run_gui():
-    from kvui import App, ContainerLayout, GridLayout, Button, Label
+    from kvui import App, ContainerLayout, GridLayout, Button, Label, ScrollBox, Widget
+    from kivy.uix.image import AsyncImage
+    from kivy.uix.relativelayout import RelativeLayout
 
     class Launcher(App):
         base_title: str = "Archipelago Launcher"
         container: ContainerLayout
         grid: GridLayout
 
-        _tools = {c.display_name: c for c in components if c.type == Type.TOOL and isfile(get_exe(c)[-1])}
-        _clients = {c.display_name: c for c in components if c.type == Type.CLIENT and isfile(get_exe(c)[-1])}
-        _adjusters = {c.display_name: c for c in components if c.type == Type.ADJUSTER and isfile(get_exe(c)[-1])}
-        _funcs = {c.display_name: c for c in components if c.type == Type.FUNC}
+        _tools = {c.display_name: c for c in components if c.type == Type.TOOL}
+        _clients = {c.display_name: c for c in components if c.type == Type.CLIENT}
+        _adjusters = {c.display_name: c for c in components if c.type == Type.ADJUSTER}
+        _miscs = {c.display_name: c for c in components if c.type == Type.MISC}
 
         def __init__(self, ctx=None):
             self.title = self.base_title
@@ -153,39 +185,74 @@ 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)
+
+            def build_button(component: Component) -> Widget:
+                """
+                Builds a button widget for a given component.
+
+                Args:
+                    component (Component): The component associated with the button.
+
+                Returns:
+                    None. The button is added to the parent grid layout.
+
+                """
+                button = Button(text=component.display_name, size_hint_y=None, height=40)
+                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.add_widget(button)
+                    box_layout.add_widget(image)
+                    return box_layout
+                return button
 
-            button_layout = self.grid  # make buttons fill the window
             for (tool, client) in itertools.zip_longest(itertools.chain(
-                    self._tools.items(), self._funcs.items(), self._adjusters.items()), self._clients.items()):
+                    self._tools.items(), self._miscs.items(), self._adjusters.items()), self._clients.items()):
                 # column 1
                 if tool:
-                    button = Button(text=tool[0])
-                    button.component = tool[1]
-                    button.bind(on_release=self.component_action)
-                    button_layout.add_widget(button)
-                else:
-                    button_layout.add_widget(Label())
+                    tool_layout.layout.add_widget(build_button(tool[1]))
                 # column 2
                 if client:
-                    button = Button(text=client[0])
-                    button.component = client[1]
-                    button.bind(on_press=self.component_action)
-                    button_layout.add_widget(button)
-                else:
-                    button_layout.add_widget(Label())
+                    client_layout.layout.add_widget(build_button(client[1]))
 
             return self.container
 
         @staticmethod
         def component_action(button):
-            if button.component.type == Type.FUNC:
+            if button.component.func:
                 button.component.func()
             else:
                 launch(get_exe(button.component), button.component.cli)
 
+        def _stop(self, *largs):
+            # ran into what appears to be https://groups.google.com/g/kivy-users/c/saWDLoYCSZ4 with PyCharm.
+            # Closing the window explicitly cleans it up.
+            self.root_window.close()
+            super()._stop(*largs)
+
     Launcher().run()
 
 
+def run_component(component: Component, *args):
+    if component.func:
+        component.func(*args)
+    elif component.script_name:
+        subprocess.run([*get_exe(component.script_name), *args])
+    else:
+        logging.warning(f"Component {component} does not appear to be executable.")
+
+
 def main(args: Optional[Union[argparse.Namespace, dict]] = None):
     if isinstance(args, argparse.Namespace):
         args = {k: v for k, v in args._get_kwargs()}
@@ -193,24 +260,40 @@ def main(args: Optional[Union[argparse.Namespace, dict]] = None):
         args = {}
 
     if "Patch|Game|Component" in args:
-        file, component, _ = identify(args["Patch|Game|Component"])
+        file, component = identify(args["Patch|Game|Component"])
         if file:
             args['file'] = file
         if component:
             args['component'] = component
+        if not component:
+            logging.warning(f"Could not identify Component responsible for {args['Patch|Game|Component']}")
 
+    if args["update_settings"]:
+        update_settings()
     if 'file' in args:
-        subprocess.run([*get_exe(args['component']), args['file'], *args['args']])
+        run_component(args["component"], args["file"], *args["args"])
     elif 'component' in args:
-        subprocess.run([*get_exe(args['component']), *args['args']])
-    else:
+        run_component(args["component"], *args["args"])
+    elif not args["update_settings"]:
         run_gui()
 
 
 if __name__ == '__main__':
     init_logging('Launcher')
+    Utils.freeze_support()
+    multiprocessing.set_start_method("spawn")  # if launched process uses kivy, fork won't work
     parser = argparse.ArgumentParser(description='Archipelago Launcher')
-    parser.add_argument('Patch|Game|Component', type=str, nargs='?',
-                        help="Pass either a patch file, a generated game or the name of a component to run.")
-    parser.add_argument('args', nargs="*", help="Arguments to pass to component.")
+    run_group = parser.add_argument_group("Run")
+    run_group.add_argument("--update_settings", action="store_true",
+                           help="Update host.yaml and exit.")
+    run_group.add_argument("Patch|Game|Component", type=str, nargs="?",
+                           help="Pass either a patch file, a generated game or the name of a component to run.")
+    run_group.add_argument("args", nargs="*",
+                           help="Arguments to pass to component.")
     main(parser.parse_args())
+
+    from worlds.LauncherComponents import processes
+    for process in processes:
+        # we await all child processes to close before we tear down the process host
+        # this makes it feel like each one is its own program, as the Launcher is closed now
+        process.join()

LinksAwakeningClient.py

@@ -9,15 +9,18 @@ if __name__ == "__main__":
 import asyncio
 import base64
 import binascii
+import colorama
 import io
-import logging
+import os
+import re
 import select
+import shlex
 import socket
+import struct
+import sys
+import subprocess
 import time
 import typing
-import urllib
-
-import colorama
 
 
 from CommonClient import (CommonContext, get_base_parser, gui_enabled, logger,
@@ -30,6 +33,7 @@ from worlds.ladx.LADXR.checkMetadata import checkMetadataTable
 from worlds.ladx.Locations import get_locations_to_id, meta_to_name
 from worlds.ladx.Tracker import LocationTracker, MagpieBridge
 
+
 class GameboyException(Exception):
     pass
 
@@ -91,7 +95,7 @@ class LAClientConstants:
     # wLinkSendShopTarget = 0xDDFF
 
 
-    wRecvIndex = 0xDDFE  # 0xDB58
+    wRecvIndex = 0xDDFD # Two bytes
     wCheckAddress = 0xC0FF - 0x4
     WRamCheckSize = 0x4
     WRamSafetyValue = bytearray([0]*WRamCheckSize)
@@ -115,17 +119,17 @@ class RAGameboy():
         assert (self.socket)
         self.socket.setblocking(False)
 
-    def get_retroarch_version(self):
-        self.send(b'VERSION\n')
-        select.select([self.socket], [], [])
-        response_str, addr = self.socket.recvfrom(16)
+    async def send_command(self, command, timeout=1.0):
+        self.send(f'{command}\n')
+        response_str = await self.async_recv()
+        self.check_command_response(command, response_str)
         return response_str.rstrip()
 
-    def get_retroarch_status(self, timeout):
-        self.send(b'GET_STATUS\n')
-        select.select([self.socket], [], [], timeout)
-        response_str, addr = self.socket.recvfrom(1000, )
-        return response_str.rstrip()
+    async def get_retroarch_version(self):
+        return await self.send_command("VERSION")
+
+    async def get_retroarch_status(self):
+        return await self.send_command("GET_STATUS")
 
     def set_cache_limits(self, cache_start, cache_size):
         self.cache_start = cache_start
@@ -141,8 +145,8 @@ class RAGameboy():
         response, _ = self.socket.recvfrom(4096)
         return response
 
-    async def async_recv(self):
-        response = await asyncio.get_event_loop().sock_recv(self.socket, 4096)
+    async def async_recv(self, timeout=1.0):
+        response = await asyncio.wait_for(asyncio.get_event_loop().sock_recv(self.socket, 4096), timeout)
         return response
 
     async def check_safe_gameplay(self, throw=True):
@@ -169,6 +173,8 @@ class RAGameboy():
                 raise InvalidEmulatorStateError()
             return False
         if not await check_wram():
+            if throw:
+                raise InvalidEmulatorStateError()
             return False
         return True
 
@@ -227,20 +233,30 @@ class RAGameboy():
 
         return r
 
+    def check_command_response(self, command: str, response: bytes):
+        if command == "VERSION":
+            ok = re.match("\d+\.\d+\.\d+", response.decode('ascii')) is not None
+        else:
+            ok = response.startswith(command.encode())
+        if not ok:
+            logger.warning(f"Bad response to command {command} - {response}")
+            raise BadRetroArchResponse()
+
     def read_memory(self, address, size=1):
         command = "READ_CORE_MEMORY"
 
         self.send(f'{command} {hex(address)} {size}\n')
         response = self.recv()
 
+        self.check_command_response(command, response)
+
         splits = response.decode().split(" ", 2)
-
-        assert (splits[0] == command)
         # Ignore the address for now
-
-        # TODO: transform to bytes
-        if splits[2][:2] == "-1" or splits[0] != "READ_CORE_MEMORY":
+        if splits[2][:2] == "-1":
             raise BadRetroArchResponse()
+
+        # TODO: check response address, check hex behavior between RA and BH
+
         return bytearray.fromhex(splits[2])
 
     async def async_read_memory(self, address, size=1):
@@ -248,14 +264,21 @@ class RAGameboy():
 
         self.send(f'{command} {hex(address)} {size}\n')
         response = await self.async_recv()
+        self.check_command_response(command, response)
         response = response[:-1]
         splits = response.decode().split(" ", 2)
+        try:
+            response_addr = int(splits[1], 16)
+        except ValueError:
+            raise BadRetroArchResponse()
 
-        assert (splits[0] == command)
-        # Ignore the address for now
+        if response_addr != address:
+            raise BadRetroArchResponse()
 
-        # TODO: transform to bytes
-        return bytearray.fromhex(splits[2])
+        ret = bytearray.fromhex(splits[2])
+        if len(ret) > size:
+            raise BadRetroArchResponse()
+        return ret
 
     def write_memory(self, address, bytes):
         command = "WRITE_CORE_MEMORY"
@@ -263,7 +286,7 @@ class RAGameboy():
         self.send(f'{command} {hex(address)} {" ".join(hex(b) for b in bytes)}')
         select.select([self.socket], [], [])
         response, _ = self.socket.recvfrom(4096)
-
+        self.check_command_response(command, response)
         splits = response.decode().split(" ", 3)
 
         assert (splits[0] == command)
@@ -281,6 +304,9 @@ class LinksAwakeningClient():
     pending_deathlink = False
     deathlink_debounce = True
     recvd_checks = {}
+    retroarch_address = None
+    retroarch_port = None
+    gameboy = None
 
     def msg(self, m):
         logger.info(m)
@@ -288,50 +314,49 @@ class LinksAwakeningClient():
         self.gameboy.send(s)
 
     def __init__(self, retroarch_address="127.0.0.1", retroarch_port=55355):
-        self.gameboy = RAGameboy(retroarch_address, retroarch_port)
+        self.retroarch_address = retroarch_address
+        self.retroarch_port = retroarch_port
+        pass
 
+    stop_bizhawk_spam = False
     async def wait_for_retroarch_connection(self):
-        logger.info("Waiting on connection to Retroarch...")
+        if not self.stop_bizhawk_spam:
+            logger.info("Waiting on connection to Retroarch...")
+            self.stop_bizhawk_spam = True
+        self.gameboy = RAGameboy(self.retroarch_address, self.retroarch_port)
+
         while True:
             try:
-                version = self.gameboy.get_retroarch_version()
+                version = await self.gameboy.get_retroarch_version()
                 NO_CONTENT = b"GET_STATUS CONTENTLESS"
                 status = NO_CONTENT
                 core_type = None
                 GAME_BOY = b"game_boy"
                 while status == NO_CONTENT or core_type != GAME_BOY:
-                    try:
-                        status = self.gameboy.get_retroarch_status(0.1)
-                        if status.count(b" ") < 2:
-                            await asyncio.sleep(1.0)
-                            continue
-                        
-                        GET_STATUS, PLAYING, info = status.split(b" ", 2)
-                        if status.count(b",") < 2:
-                            await asyncio.sleep(1.0)
-                            continue
-                        core_type, rom_name, self.game_crc = info.split(b",", 2)
-                        if core_type != GAME_BOY:
-                            logger.info(
-                                f"Core type should be '{GAME_BOY}', found {core_type} instead - wrong type of ROM?")
-                            await asyncio.sleep(1.0)
-                            continue
-                    except (BlockingIOError, TimeoutError) as e:
-                        await asyncio.sleep(0.1)
-                        pass
-                logger.info(f"Connected to Retroarch {version} {info}")
-                self.gameboy.read_memory(0x1000)
+                    status = await self.gameboy.get_retroarch_status()
+                    if status.count(b" ") < 2:
+                        await asyncio.sleep(1.0)
+                        continue
+                    GET_STATUS, PLAYING, info = status.split(b" ", 2)
+                    if status.count(b",") < 2:
+                        await asyncio.sleep(1.0)
+                        continue
+                    core_type, rom_name, self.game_crc = info.split(b",", 2)
+                    if core_type != GAME_BOY:
+                        logger.info(
+                            f"Core type should be '{GAME_BOY}', found {core_type} instead - wrong type of ROM?")
+                        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')}")
                 return
-            except ConnectionResetError:
+            except (BlockingIOError, TimeoutError, ConnectionResetError):
                 await asyncio.sleep(1.0)
                 pass
 
-    def reset_auth(self):
-        auth = binascii.hexlify(self.gameboy.read_memory(0x0134, 12)).decode()
-
-        if self.auth:
-            assert (auth == self.auth)
-
+    async def reset_auth(self):
+        auth = binascii.hexlify(await self.gameboy.async_read_memory(0x0134, 12)).decode()
         self.auth = auth
 
     async def wait_and_init_tracker(self):
@@ -365,14 +390,16 @@ class LinksAwakeningClient():
                                   item_id, from_player])
         status |= 1
         status = self.gameboy.write_memory(LAClientConstants.wLinkStatusBits, [status])
-        self.gameboy.write_memory(LAClientConstants.wRecvIndex, [next_index])
+        self.gameboy.write_memory(LAClientConstants.wRecvIndex, struct.pack(">H", next_index))
 
+    should_reset_auth = False
     async def wait_for_game_ready(self):
         logger.info("Waiting on game to be in valid state...")
         while not await self.gameboy.check_safe_gameplay(throw=False):
-            pass
-        logger.info("Ready!")
-    last_index = 0
+            if self.should_reset_auth:
+                self.should_reset_auth = False
+                raise GameboyException("Resetting due to wrong archipelago server")
+        logger.info("Game connection ready!")
 
     async def is_victory(self):
         return (await self.gameboy.read_memory_cache([LAClientConstants.wGameplayType]))[LAClientConstants.wGameplayType] == 1
@@ -382,11 +409,6 @@ class LinksAwakeningClient():
         await self.item_tracker.readItems()
         await self.gps_tracker.read_location()
 
-        next_index = self.gameboy.read_memory(LAClientConstants.wRecvIndex)[0]
-        if next_index != self.last_index:
-            self.last_index = next_index
-            # logger.info(f"Got new index {next_index}")
-
         current_health = (await self.gameboy.read_memory_cache([LAClientConstants.wLinkHealth]))[LAClientConstants.wLinkHealth]
         if self.deathlink_debounce and current_health != 0:
             self.deathlink_debounce = False
@@ -404,7 +426,7 @@ class LinksAwakeningClient():
         if await self.is_victory():
             await win_cb()
 
-        recv_index = (await self.gameboy.async_read_memory_safe(LAClientConstants.wRecvIndex))[0]
+        recv_index = struct.unpack(">H", await self.gameboy.async_read_memory(LAClientConstants.wRecvIndex, 2))[0]
 
         # Play back one at a time
         if recv_index in self.recvd_checks:
@@ -438,12 +460,16 @@ class LinksAwakeningContext(CommonContext):
     found_checks = []
     last_resend = time.time()
 
-    magpie = MagpieBridge()
+    magpie_enabled = False
+    magpie = None
     magpie_task = None
     won = False
 
-    def __init__(self, server_address: typing.Optional[str], password: typing.Optional[str]) -> None:
+    def __init__(self, server_address: typing.Optional[str], password: typing.Optional[str], magpie: typing.Optional[bool]) -> None:
         self.client = LinksAwakeningClient()
+        if magpie:
+            self.magpie_enabled = True
+            self.magpie = MagpieBridge()
         super().__init__(server_address, password)
 
     def run_gui(self) -> None:
@@ -462,16 +488,17 @@ class LinksAwakeningContext(CommonContext):
             def build(self):
                 b = super().build()
 
-                button = Button(text="", size=(30, 30), size_hint_x=None,
-                                on_press=lambda _: webbrowser.open('https://magpietracker.us/?enable_autotracker=1'))
-                image = Image(size=(16, 16), texture=magpie_logo())
-                button.add_widget(image)
+                if self.ctx.magpie_enabled:
+                    button = Button(text="", size=(30, 30), size_hint_x=None,
+                                    on_press=lambda _: webbrowser.open('https://magpietracker.us/?enable_autotracker=1'))
+                    image = Image(size=(16, 16), texture=magpie_logo())
+                    button.add_widget(image)
 
-                def set_center(_, center):
-                    image.center = center
-                button.bind(center=set_center)
+                    def set_center(_, center):
+                        image.center = center
+                    button.bind(center=set_center)
 
-                self.connect_layout.add_widget(button)
+                    self.connect_layout.add_widget(button)
                 return b
 
         self.ui = LADXManager(self)
@@ -481,6 +508,15 @@ class LinksAwakeningContext(CommonContext):
         message = [{"cmd": 'LocationChecks', "locations": self.found_checks}]
         await self.send_msgs(message)
 
+    had_invalid_slot_data = None
+    def event_invalid_slot(self):
+        # The next time we try to connect, reset the game loop for new auth
+        self.had_invalid_slot_data = True
+        self.auth = None
+        # Don't try to autoreconnect, it will just fail
+        self.disconnected_intentionally = True
+        CommonContext.event_invalid_slot(self)
+
     ENABLE_DEATHLINK = False
     async def send_deathlink(self):
         if self.ENABLE_DEATHLINK:
@@ -506,13 +542,23 @@ class LinksAwakeningContext(CommonContext):
     def new_checks(self, item_ids, ladxr_ids):
         self.found_checks += item_ids
         create_task_log_exception(self.send_checks())
-        create_task_log_exception(self.magpie.send_new_checks(ladxr_ids))
+        if self.magpie_enabled:
+            create_task_log_exception(self.magpie.send_new_checks(ladxr_ids))
 
     async def server_auth(self, password_requested: bool = False):
         if password_requested and not self.password:
             await super(LinksAwakeningContext, self).server_auth(password_requested)
+
+        if self.had_invalid_slot_data:
+            # We are connecting when previously we had the wrong ROM or server - just in case
+            # re-read the ROM so that if the user had the correct address but wrong ROM, we
+            # allow a successful reconnect
+            self.client.should_reset_auth = True
+            self.had_invalid_slot_data = False
+
+        while self.client.auth == None:
+            await asyncio.sleep(0.1)
         self.auth = self.client.auth
-        await self.get_username()
         await self.send_connect()
 
     def on_package(self, cmd: str, args: dict):
@@ -520,9 +566,13 @@ class LinksAwakeningContext(CommonContext):
             self.game = self.slot_info[self.slot].game
         # TODO - use watcher_event
         if cmd == "ReceivedItems":
-            for index, item in enumerate(args["items"], args["index"]):
+            for index, item in enumerate(args["items"], start=args["index"]):
                 self.client.recvd_checks[index] = item
 
+    async def sync(self):
+        sync_msg = [{'cmd': 'Sync'}]
+        await self.send_msgs(sync_msg)
+
     item_id_lookup = get_locations_to_id()
 
     async def run_game_loop(self):
@@ -537,18 +587,33 @@ class LinksAwakeningContext(CommonContext):
         async def deathlink():
             await self.send_deathlink()
 
-        self.magpie_task = asyncio.create_task(self.magpie.serve())
-        
+        if self.magpie_enabled:
+            self.magpie_task = asyncio.create_task(self.magpie.serve())
+
         # yield to allow UI to start
         await asyncio.sleep(0)
 
         while True:
             try:
                 # TODO: cancel all client tasks
-                logger.info("(Re)Starting game loop")
+                if not self.client.stop_bizhawk_spam:
+                    logger.info("(Re)Starting game loop")
                 self.found_checks.clear()
+                # On restart of game loop, clear all checks, just in case we swapped ROMs
+                # this isn't totally neccessary, but is extra safety against cross-ROM contamination
+                self.client.recvd_checks.clear()
                 await self.client.wait_for_retroarch_connection()
-                self.client.reset_auth()
+                await self.client.reset_auth()
+                # If we find ourselves with new auth after the reset, reconnect
+                if self.auth and self.client.auth != self.auth:
+                    # It would be neat to reconnect here, but connection needs this loop to be running
+                    logger.info("Detected new ROM, disconnecting...")
+                    await self.disconnect()
+                    continue
+
+                if not self.client.recvd_checks:
+                    await self.sync()
+
                 await self.client.wait_and_init_tracker()
 
                 while True:
@@ -558,39 +623,62 @@ class LinksAwakeningContext(CommonContext):
                     if self.last_resend + 5.0 < now:
                         self.last_resend = now
                         await self.send_checks()
-                    self.magpie.set_checks(self.client.tracker.all_checks)
-                    await self.magpie.set_item_tracker(self.client.item_tracker)
-                    await self.magpie.send_gps(self.client.gps_tracker)
+                    if self.magpie_enabled:
+                        try:
+                            self.magpie.set_checks(self.client.tracker.all_checks)
+                            await self.magpie.set_item_tracker(self.client.item_tracker)
+                            await self.magpie.send_gps(self.client.gps_tracker)
+                        except Exception:
+                            # Don't let magpie errors take out the client
+                            pass
+                    if self.client.should_reset_auth:
+                        self.client.should_reset_auth = False
+                        raise GameboyException("Resetting due to wrong archipelago server")
+            except (GameboyException, asyncio.TimeoutError, TimeoutError, ConnectionResetError):
+                await asyncio.sleep(1.0)
 
-            except GameboyException:
-                time.sleep(1.0)
-                pass
+def run_game(romfile: str) -> None:
+    auto_start = typing.cast(typing.Union[bool, str],
+                            Utils.get_options()["ladx_options"].get("rom_start", True))
+    if auto_start is True:
+        import webbrowser
+        webbrowser.open(romfile)
+    elif isinstance(auto_start, str):
+        args = shlex.split(auto_start)
+        # Specify full path to ROM as we are going to cd in popen
+        full_rom_path = os.path.realpath(romfile)
+        args.append(full_rom_path)
+        try:
+            # set cwd so that paths to lua scripts are always relative to our client
+            if getattr(sys, 'frozen', False):
+                # The application is frozen
+                script_dir = os.path.dirname(sys.executable)
+            else:
+                script_dir = os.path.dirname(os.path.realpath(__file__))
 
+            subprocess.Popen(args, stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, cwd=script_dir)
+        except FileNotFoundError:
+            logger.error(f"Couldn't launch ROM, {args[0]} is missing")
 
 async def main():
     parser = get_base_parser(description="Link's Awakening Client.")
     parser.add_argument("--url", help="Archipelago connection url")
-
+    parser.add_argument("--no-magpie", dest='magpie', default=True, action='store_false', help="Disable magpie bridge")
     parser.add_argument('diff_file', default="", type=str, nargs="?",
                         help='Path to a .apladx Archipelago Binary Patch file')
+
     args = parser.parse_args()
-    logger.info(args)
 
     if args.diff_file:
         import Patch
         logger.info("patch file was supplied - creating rom...")
         meta, rom_file = Patch.create_rom_file(args.diff_file)
-        if "server" in meta:
-            args.url = meta["server"]
+        if "server" in meta and not args.connect:
+            args.connect = meta["server"]
         logger.info(f"wrote rom file to {rom_file}")
 
-    if args.url:
-        url = urllib.parse.urlparse(args.url)
-        args.connect = url.netloc
-        if url.password:
-            args.password = urllib.parse.unquote(url.password)
 
-    ctx = LinksAwakeningContext(args.connect, args.password)
+    ctx = LinksAwakeningContext(args.connect, args.password, args.magpie)
 
     ctx.server_task = asyncio.create_task(server_loop(ctx), name="server loop")
 
@@ -600,6 +688,10 @@ async def main():
         ctx.run_gui()
     ctx.run_cli()
 
+    # Down below run_gui so that we get errors out of the process
+    if args.diff_file:
+        run_game(rom_file)
+
     await ctx.exit_event.wait()
     await ctx.shutdown()
 

LttPAdjuster.py

@@ -25,7 +25,7 @@ ModuleUpdate.update()
 
 from worlds.alttp.Rom import Sprite, LocalRom, apply_rom_settings, get_base_rom_bytes
 from Utils import output_path, local_path, user_path, open_file, get_cert_none_ssl_context, persistent_store, \
-    get_adjuster_settings, tkinter_center_window, init_logging
+    get_adjuster_settings, get_adjuster_settings_no_defaults, tkinter_center_window, init_logging
 
 
 GAME_ALTTP = "A Link to the Past"
@@ -43,8 +43,49 @@ class ArgumentDefaultsHelpFormatter(argparse.RawTextHelpFormatter):
     def _get_help_string(self, action):
         return textwrap.dedent(action.help)
 
+# See argparse.BooleanOptionalAction
+class BooleanOptionalActionWithDisable(argparse.Action):
+    def __init__(self,
+                 option_strings,
+                 dest,
+                 default=None,
+                 type=None,
+                 choices=None,
+                 required=False,
+                 help=None,
+                 metavar=None):
 
-def main():
+        _option_strings = []
+        for option_string in option_strings:
+            _option_strings.append(option_string)
+
+            if option_string.startswith('--'):
+                option_string = '--disable' + option_string[2:]
+                _option_strings.append(option_string)
+
+        if help is not None and default is not None:
+            help += " (default: %(default)s)"
+
+        super().__init__(
+            option_strings=_option_strings,
+            dest=dest,
+            nargs=0,
+            default=default,
+            type=type,
+            choices=choices,
+            required=required,
+            help=help,
+            metavar=metavar)
+
+    def __call__(self, parser, namespace, values, option_string=None):
+        if option_string in self.option_strings:
+            setattr(namespace, self.dest, not option_string.startswith('--disable'))
+
+    def format_usage(self):
+        return ' | '.join(self.option_strings)
+
+
+def get_argparser() -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(formatter_class=ArgumentDefaultsHelpFormatter)
 
     parser.add_argument('rom', nargs="?", default='AP_LttP.sfc', help='Path to an ALttP rom to adjust.')
@@ -52,6 +93,8 @@ def main():
                         help='Path to an ALttP Japan(1.0) rom to use as a base.')
     parser.add_argument('--loglevel', default='info', const='info', nargs='?',
                         choices=['error', 'info', 'warning', 'debug'], help='Select level of logging for output.')
+    parser.add_argument('--auto_apply', default='ask',
+                        choices=['ask', 'always', 'never'], help='Whether or not to apply settings automatically in the future.')
     parser.add_argument('--menuspeed', default='normal', const='normal', nargs='?',
                         choices=['normal', 'instant', 'double', 'triple', 'quadruple', 'half'],
                         help='''\
@@ -61,7 +104,7 @@ def main():
     parser.add_argument('--quickswap', help='Enable quick item swapping with L and R.', action='store_true')
     parser.add_argument('--deathlink', help='Enable DeathLink system.', action='store_true')
     parser.add_argument('--allowcollect', help='Allow collection of other player items', action='store_true')
-    parser.add_argument('--disablemusic', help='Disables game music.', action='store_true')
+    parser.add_argument('--music', default=True, help='Enables/Disables game music.', action=BooleanOptionalActionWithDisable)
     parser.add_argument('--triforcehud', default='hide_goal', const='hide_goal', nargs='?',
                         choices=['normal', 'hide_goal', 'hide_required', 'hide_both'],
                         help='''\
@@ -85,9 +128,6 @@ def main():
     parser.add_argument('--ow_palettes', default='default',
                         choices=['default', 'random', 'blackout', 'puke', 'classic', 'grayscale', 'negative', 'dizzy',
                                  'sick'])
-    # parser.add_argument('--link_palettes', default='default',
-    #                     choices=['default', 'random', 'blackout', 'puke', 'classic', 'grayscale', 'negative', 'dizzy',
-    #                              'sick'])
     parser.add_argument('--shield_palettes', default='default',
                         choices=['default', 'random', 'blackout', 'puke', 'classic', 'grayscale', 'negative', 'dizzy',
                                  'sick'])
@@ -107,10 +147,23 @@ def main():
                              Alternatively, can be a ALttP Rom patched with a Link
                              sprite that will be extracted.
                              ''')
-    parser.add_argument('--names', default='', type=str)
+    parser.add_argument('--sprite_pool', nargs='+', default=[], help='''
+                             A list of sprites to pull from.
+                        ''')
+    parser.add_argument('--oof', help='''\
+                             Path to a sound effect to replace Link's "oof" sound.
+                             Needs to be in a .brr format and have a length of no
+                             more than 2673 bytes, created from a 16-bit signed PCM
+                             .wav at 12khz. https://github.com/boldowa/snesbrr
+                             ''')
     parser.add_argument('--update_sprites', action='store_true', help='Update Sprite Database, then exit.')
-    args = parser.parse_args()
-    args.music = not args.disablemusic
+    return parser
+
+
+def main():
+    parser = get_argparser()
+    args = parser.parse_args(namespace=get_adjuster_settings_no_defaults(GAME_ALTTP))
+    
     # set up logger
     loglevel = {'error': logging.ERROR, 'info': logging.INFO, 'warning': logging.WARNING, 'debug': logging.DEBUG}[
         args.loglevel]
@@ -126,6 +179,13 @@ def main():
         if args.sprite is not None and not os.path.isfile(args.sprite) and not Sprite.get_sprite_from_name(args.sprite):
             input('Could not find link sprite sheet at given location. \nPress Enter to exit.')
             sys.exit(1)
+        if args.oof is not None and not os.path.isfile(args.oof):
+            input('Could not find oof sound effect at given location. \nPress Enter to exit.')
+            sys.exit(1)
+        if args.oof is not None and os.path.getsize(args.oof) > 2673:
+            input('"oof" sound effect cannot exceed 2673 bytes. \nPress Enter to exit.')
+            sys.exit(1)
+            
 
         args, path = adjust(args=args)
         if isinstance(args.sprite, Sprite):
@@ -165,7 +225,7 @@ def adjust(args):
         world = getattr(args, "world")
 
     apply_rom_settings(rom, args.heartbeep, args.heartcolor, args.quickswap, args.menuspeed, args.music,
-                       args.sprite, palettes_options, reduceflashing=args.reduceflashing or racerom, world=world,
+                       args.sprite, args.oof, palettes_options, reduceflashing=args.reduceflashing or racerom, world=world,
                        deathlink=args.deathlink, allowcollect=args.allowcollect)
     path = output_path(f'{os.path.basename(args.rom)[:-4]}_adjusted.sfc')
     rom.write_to_file(path)
@@ -180,7 +240,7 @@ def adjustGUI():
     from tkinter import Tk, LEFT, BOTTOM, TOP, \
         StringVar, Frame, Label, X, Entry, Button, filedialog, messagebox, ttk
     from argparse import Namespace
-    from Main import __version__ as MWVersion
+    from Utils import __version__ as MWVersion
     adjustWindow = Tk()
     adjustWindow.wm_title("Archipelago %s LttP Adjuster" % MWVersion)
     set_icon(adjustWindow)
@@ -227,6 +287,7 @@ def adjustGUI():
         guiargs.sprite = rom_vars.sprite
         if rom_vars.sprite_pool:
             guiargs.world = AdjusterWorld(rom_vars.sprite_pool)
+        guiargs.oof = rom_vars.oof
 
         try:
             guiargs, path = adjust(args=guiargs)
@@ -265,6 +326,7 @@ def adjustGUI():
         else:
             guiargs.sprite = rom_vars.sprite
         guiargs.sprite_pool = rom_vars.sprite_pool
+        guiargs.oof = rom_vars.oof
         persistent_store("adjuster", GAME_ALTTP, guiargs)
         messagebox.showinfo(title="Success", message="Settings saved to persistent storage")
 
@@ -481,11 +543,38 @@ class BackgroundTaskProgressNullWindow(BackgroundTask):
         self.stop()
 
 
+class AttachTooltip(object):
+
+    def __init__(self, parent, text):
+        self._parent = parent
+        self._text = text
+        self._window = None
+        parent.bind('<Enter>', lambda event : self.show())
+        parent.bind('<Leave>', lambda event : self.hide())
+
+    def show(self):
+        if self._window or not self._text:
+            return
+        self._window = Toplevel(self._parent)
+        #remove window bar controls
+        self._window.wm_overrideredirect(1)
+        #adjust positioning
+        x, y, *_ = self._parent.bbox("insert")
+        x = x + self._parent.winfo_rootx() + 20
+        y = y + self._parent.winfo_rooty() + 20
+        self._window.wm_geometry("+{0}+{1}".format(x,y))
+        #show text
+        label = Label(self._window, text=self._text, justify=LEFT)
+        label.pack(ipadx=1)
+
+    def hide(self):
+        if self._window:
+            self._window.destroy()
+            self._window = None
+
+
 def get_rom_frame(parent=None):
     adjuster_settings = get_adjuster_settings(GAME_ALTTP)
-    if not adjuster_settings:
-        adjuster_settings = Namespace()
-        adjuster_settings.baserom = "Zelda no Densetsu - Kamigami no Triforce (Japan).sfc"
 
     romFrame = Frame(parent)
     baseRomLabel = Label(romFrame, text='LttP Base Rom: ')
@@ -513,32 +602,8 @@ def get_rom_frame(parent=None):
 
     return romFrame, romVar
 
-
 def get_rom_options_frame(parent=None):
     adjuster_settings = get_adjuster_settings(GAME_ALTTP)
-    defaults = {
-        "auto_apply": 'ask',
-        "music": True,
-        "reduceflashing": True,
-        "deathlink": False,
-        "sprite": None,
-        "quickswap": True,
-        "menuspeed": 'normal',
-        "heartcolor": 'red',
-        "heartbeep": 'normal',
-        "ow_palettes": 'default',
-        "uw_palettes": 'default',
-        "hud_palettes": 'default',
-        "sword_palettes": 'default',
-        "shield_palettes": 'default',
-        "sprite_pool": [],
-        "allowcollect": False,
-    }
-    if not adjuster_settings:
-        adjuster_settings = Namespace()
-    for key, defaultvalue in defaults.items():
-        if not hasattr(adjuster_settings, key):
-            setattr(adjuster_settings, key, defaultvalue)
 
     romOptionsFrame = LabelFrame(parent, text="Rom options")
     romOptionsFrame.columnconfigure(0, weight=1)
@@ -598,12 +663,50 @@ def get_rom_options_frame(parent=None):
     spriteEntry.pack(side=LEFT)
     spriteSelectButton.pack(side=LEFT)
 
+    oofDialogFrame = Frame(romOptionsFrame)
+    oofDialogFrame.grid(row=1, column=1)
+    baseOofLabel = Label(oofDialogFrame, text='"OOF" Sound:')
+
+    vars.oofNameVar = StringVar()
+    vars.oof = adjuster_settings.oof
+
+    def set_oof(oof_param):
+        nonlocal vars
+        if isinstance(oof_param, str) and os.path.isfile(oof_param) and os.path.getsize(oof_param) <= 2673:
+            vars.oof = oof_param
+            vars.oofNameVar.set(oof_param.rsplit('/',1)[-1])
+        else:
+            vars.oof = None
+            vars.oofNameVar.set('(unchanged)')
+
+    set_oof(adjuster_settings.oof)
+    oofEntry = Label(oofDialogFrame, textvariable=vars.oofNameVar)
+
+    def OofSelect():
+        nonlocal vars
+        oof_file = filedialog.askopenfilename(
+            filetypes=[("BRR files", ".brr"),
+                       ("All Files", "*")])
+        try:
+            set_oof(oof_file)
+        except Exception:
+            set_oof(None)
+
+    oofSelectButton = Button(oofDialogFrame, text='...', command=OofSelect)
+    AttachTooltip(oofSelectButton,
+                  text="Select a .brr file no more than 2673 bytes.\n" + \
+                  "This can be created from a <=0.394s 16-bit signed PCM .wav file at 12khz using snesbrr.")
+
+    baseOofLabel.pack(side=LEFT)
+    oofEntry.pack(side=LEFT)
+    oofSelectButton.pack(side=LEFT)
+
     vars.quickSwapVar = IntVar(value=adjuster_settings.quickswap)
     quickSwapCheckbutton = Checkbutton(romOptionsFrame, text="L/R Quickswapping", variable=vars.quickSwapVar)
     quickSwapCheckbutton.grid(row=1, column=0, sticky=E)
 
     menuspeedFrame = Frame(romOptionsFrame)
-    menuspeedFrame.grid(row=1, column=1, sticky=E)
+    menuspeedFrame.grid(row=6, column=1, sticky=E)
     menuspeedLabel = Label(menuspeedFrame, text='Menu speed')
     menuspeedLabel.pack(side=LEFT)
     vars.menuspeedVar = StringVar()
@@ -901,6 +1004,7 @@ class SpriteSelector():
                 self.add_to_sprite_pool(sprite)
 
     def icon_section(self, frame_label, path, no_results_label):
+        os.makedirs(path, exist_ok=True)
         frame = LabelFrame(self.window, labelwidget=frame_label, padx=5, pady=5)
         frame.pack(side=TOP, fill=X)
 
@@ -1056,7 +1160,6 @@ class SpriteSelector():
     def custom_sprite_dir(self):
         return user_path("data", "sprites", "custom")
 
-
 def get_image_for_sprite(sprite, gif_only: bool = False):
     if not sprite.valid:
         return None

MMBN3Client.py

@@ -0,0 +1,376 @@
+import asyncio
+import hashlib
+import json
+import os
+import multiprocessing
+import subprocess
+import zipfile
+
+from asyncio import StreamReader, StreamWriter
+
+import bsdiff4
+
+from CommonClient import CommonContext, server_loop, gui_enabled, \
+    ClientCommandProcessor, logger, get_base_parser
+import Utils
+from NetUtils import ClientStatus
+from worlds.mmbn3.Items import items_by_id
+from worlds.mmbn3.Rom import get_base_rom_path
+from worlds.mmbn3.Locations import all_locations, scoutable_locations
+
+SYSTEM_MESSAGE_ID = 0
+
+CONNECTION_TIMING_OUT_STATUS = "Connection timing out. Please restart your emulator, then restart connector_mmbn3.lua"
+CONNECTION_REFUSED_STATUS = \
+    "Connection refused. Please start your emulator and make sure connector_mmbn3.lua is running"
+CONNECTION_RESET_STATUS = "Connection was reset. Please restart your emulator, then restart connector_mmbn3.lua"
+CONNECTION_TENTATIVE_STATUS = "Initial Connection Made"
+CONNECTION_CONNECTED_STATUS = "Connected"
+CONNECTION_INITIAL_STATUS = "Connection has not been initiated"
+CONNECTION_INCORRECT_ROM = "Supplied Base Rom does not match US GBA Blue Version. Please provide the correct ROM version"
+
+script_version: int = 2
+
+debugEnabled = False
+locations_checked = []
+items_sent = []
+itemIndex = 1
+
+CHECKSUM_BLUE = "6fe31df0144759b34ad666badaacc442"
+
+
+class MMBN3CommandProcessor(ClientCommandProcessor):
+    def __init__(self, ctx):
+        super().__init__(ctx)
+
+    def _cmd_gba(self):
+        """Check GBA Connection State"""
+        if isinstance(self.ctx, MMBN3Context):
+            logger.info(f"GBA Status: {self.ctx.gba_status}")
+
+    def _cmd_debug(self):
+        """Toggle the Debug Text overlay in ROM"""
+        global debugEnabled
+        debugEnabled = not debugEnabled
+        logger.info("Debug Overlay Enabled" if debugEnabled else "Debug Overlay Disabled")
+
+
+class MMBN3Context(CommonContext):
+    command_processor = MMBN3CommandProcessor
+    game = "MegaMan Battle Network 3"
+    items_handling = 0b101  # full local except starting items
+
+    def __init__(self, server_address, password):
+        super().__init__(server_address, password)
+        self.gba_streams: (StreamReader, StreamWriter) = None
+        self.gba_sync_task = None
+        self.gba_status = CONNECTION_INITIAL_STATUS
+        self.awaiting_rom = False
+        self.location_table = {}
+        self.version_warning = False
+        self.auth_name = None
+        self.slot_data = dict()
+        self.patching_error = False
+        self.sent_hints = []
+
+    async def server_auth(self, password_requested: bool = False):
+        if password_requested and not self.password:
+            await super(MMBN3Context, self).server_auth(password_requested)
+
+        if self.auth_name is None:
+            self.awaiting_rom = True
+            logger.info("No ROM detected, awaiting conection to Bizhawk to authenticate to the multiworld server")
+            return
+
+        logger.info("Attempting to decode from ROM... ")
+        self.awaiting_rom = False
+        self.auth = self.auth_name.decode("utf8").replace('\x00', '')
+        logger.info("Connecting as "+self.auth)
+        await self.send_connect(name=self.auth)
+
+    def run_gui(self):
+        from kvui import GameManager
+
+        class MMBN3Manager(GameManager):
+            logging_pairs = [
+                ("Client", "Archipelago")
+            ]
+            base_title = "Archipelago MegaMan Battle Network 3 Client"
+
+        self.ui = MMBN3Manager(self)
+        self.ui_task = asyncio.create_task(self.ui.async_run(), name="UI")
+
+    def on_package(self, cmd: str, args: dict):
+        if cmd == 'Connected':
+            self.slot_data = args.get("slot_data", {})
+            print(self.slot_data)
+
+class ItemInfo:
+    id = 0x00
+    sender = ""
+    type = ""
+    count = 1
+    itemName = "Unknown"
+    itemID = 0x00  # Item ID, Chip ID, etc.
+    subItemID = 0x00  # Code for chips, color for programs
+    itemIndex = 1
+
+    def __init__(self, id, sender, type):
+        self.id = id
+        self.sender = sender
+        self.type = type
+
+    def get_json(self):
+        json_data = {
+            "id": self.id,
+            "sender": self.sender,
+            "type": self.type,
+            "itemName": self.itemName,
+            "itemID": self.itemID,
+            "subItemID": self.subItemID,
+            "count": self.count,
+            "itemIndex": self.itemIndex
+        }
+        return json_data
+
+
+def get_payload(ctx: MMBN3Context):
+    global debugEnabled
+
+    items_sent = []
+    for i, item in enumerate(ctx.items_received):
+        item_data = items_by_id[item.item]
+        new_item = ItemInfo(i, ctx.player_names[item.player], item_data.type)
+        new_item.itemIndex = i+1
+        new_item.itemName = item_data.itemName
+        new_item.type = item_data.type
+        new_item.itemID = item_data.itemID
+        new_item.subItemID = item_data.subItemID
+        new_item.count = item_data.count
+        items_sent.append(new_item)
+
+    return json.dumps({
+        "items": [item.get_json() for item in items_sent],
+        "debug": debugEnabled
+        })
+
+
+async def parse_payload(payload: dict, ctx: MMBN3Context, force: bool):
+    # Game completion handling
+    if payload["gameComplete"] and not ctx.finished_game:
+        await ctx.send_msgs([{
+            "cmd": "StatusUpdate",
+            "status": ClientStatus.CLIENT_GOAL
+        }])
+        ctx.finished_game = True
+
+    # Locations handling
+    if ctx.location_table != payload["locations"]:
+        ctx.location_table = payload["locations"]
+        locs = [loc.id for loc in all_locations
+                if check_location_packet(loc, ctx.location_table)]
+        await ctx.send_msgs([{
+            "cmd": "LocationChecks",
+            "locations": locs
+        }])
+
+    # If trade hinting is enabled, send scout checks
+    if ctx.slot_data.get("trade_quest_hinting", 0) == 2:
+        trade_bits = [loc.id for loc in scoutable_locations
+                        if check_location_scouted(loc, payload["locations"])]
+        scouted_locs = [loc for loc in trade_bits if loc not in ctx.sent_hints]
+        if len(scouted_locs) > 0:
+            ctx.sent_hints.extend(scouted_locs)
+            await ctx.send_msgs([{
+                "cmd": "LocationScouts",
+                "locations": scouted_locs,
+                "create_as_hint": 2
+            }])
+
+
+def check_location_packet(location, memory):
+    if len(memory) == 0:
+        return False
+    # Our keys have to be strings to come through the JSON lua plugin so we have to turn our memory address into a string as well
+    location_key = hex(location.flag_byte)[2:]
+    byte = memory.get(location_key)
+    if byte is not None:
+        return byte & location.flag_mask
+
+
+def check_location_scouted(location, memory):
+    if len(memory) == 0:
+        return False
+    location_key = hex(location.hint_flag)[2:]
+    byte = memory.get(location_key)
+    if byte is not None:
+        return byte & location.hint_flag_mask
+
+
+async def gba_sync_task(ctx: MMBN3Context):
+    logger.info("Starting GBA connector. Use /gba for status information.")
+    if ctx.patching_error:
+        logger.error('Unable to Patch ROM. No ROM provided or ROM does not match US GBA Blue Version.')
+    while not ctx.exit_event.is_set():
+        error_status = None
+        if ctx.gba_streams:
+            (reader, writer) = ctx.gba_streams
+            msg = get_payload(ctx).encode()
+            writer.write(msg)
+            writer.write(b'\n')
+            try:
+                await asyncio.wait_for(writer.drain(), timeout=1.5)
+                try:
+                    # Data will return a dict with up to four fields
+                    # 1. str: player name (always)
+                    # 2. int: script version (always)
+                    # 3. dict[str, byte]: value of location's memory byte
+                    # 4. bool: whether the game currently registers as complete
+                    data = await asyncio.wait_for(reader.readline(), timeout=10)
+                    data_decoded = json.loads(data.decode())
+                    reported_version = data_decoded.get("scriptVersion", 0)
+                    if reported_version >= script_version:
+                        if ctx.game is not None and "locations" in data_decoded:
+                            # Not just a keep alive ping, parse
+                            asyncio.create_task((parse_payload(data_decoded, ctx, False)))
+                        if not ctx.auth:
+                            ctx.auth_name = bytes(data_decoded["playerName"])
+
+                            if ctx.awaiting_rom:
+                                logger.info("Awaiting data from ROM...")
+                                await ctx.server_auth(False)
+                    else:
+                        if not ctx.version_warning:
+                            logger.warning(f"Your Lua script is version {reported_version}, expected {script_version}."
+                                           "Please update to the latest version."
+                                           "Your connection to the Archipelago server will not be accepted.")
+                            ctx.version_warning = True
+                except asyncio.TimeoutError:
+                    logger.debug("Read Timed Out, Reconnecting")
+                    error_status = CONNECTION_TIMING_OUT_STATUS
+                    writer.close()
+                    ctx.gba_streams = None
+                except ConnectionResetError:
+                    logger.debug("Read failed due to Connection Lost, Reconnecting")
+                    error_status = CONNECTION_RESET_STATUS
+                    writer.close()
+                    ctx.gba_streams = None
+            except TimeoutError:
+                logger.debug("Connection Timed Out, Reconnecting")
+                error_status = CONNECTION_TIMING_OUT_STATUS
+                writer.close()
+                ctx.gba_streams = None
+            except ConnectionResetError:
+                logger.debug("Connection Lost, Reconnecting")
+                error_status = CONNECTION_RESET_STATUS
+                writer.close()
+                ctx.gba_streams = None
+            if ctx.gba_status == CONNECTION_TENTATIVE_STATUS:
+                if not error_status:
+                    logger.info("Successfully Connected to GBA")
+                    ctx.gba_status = CONNECTION_CONNECTED_STATUS
+                else:
+                    ctx.gba_status = f"Was tentatively connected but error occurred: {error_status}"
+            elif error_status:
+                ctx.gba_status = error_status
+                logger.info("Lost connection to GBA and attempting to reconnect. Use /gba for status updates")
+        else:
+            try:
+                logger.debug("Attempting to connect to GBA")
+                ctx.gba_streams = await asyncio.wait_for(asyncio.open_connection("localhost", 28922), timeout=10)
+                ctx.gba_status = CONNECTION_TENTATIVE_STATUS
+            except TimeoutError:
+                logger.debug("Connection Timed Out, Trying Again")
+                ctx.gba_status = CONNECTION_TIMING_OUT_STATUS
+                continue
+            except ConnectionRefusedError:
+                logger.debug("Connection Refused, Trying Again")
+                ctx.gba_status = CONNECTION_REFUSED_STATUS
+                continue
+
+
+async def run_game(romfile):
+    options = Utils.get_options().get("mmbn3_options", None)
+    if options is None:
+        auto_start = True
+    else:
+        auto_start = options.get("rom_start", True)
+    if auto_start:
+        import webbrowser
+        webbrowser.open(romfile)
+    elif os.path.isfile(auto_start):
+        subprocess.Popen([auto_start, romfile],
+                         stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+
+
+async def patch_and_run_game(apmmbn3_file):
+    base_name = os.path.splitext(apmmbn3_file)[0]
+
+    with zipfile.ZipFile(apmmbn3_file, 'r') as patch_archive:
+        try:
+            with patch_archive.open("delta.bsdiff4", 'r') as stream:
+                patch_data = stream.read()
+        except KeyError:
+            raise FileNotFoundError("Patch file missing from archive.")
+    rom_file = get_base_rom_path()
+
+    with open(rom_file, 'rb') as rom:
+        rom_bytes = rom.read()
+
+    patched_bytes = bsdiff4.patch(rom_bytes, patch_data)
+    patched_rom_file = base_name+".gba"
+    with open(patched_rom_file, 'wb') as patched_rom:
+        patched_rom.write(patched_bytes)
+
+    asyncio.create_task(run_game(patched_rom_file))
+
+
+def confirm_checksum():
+    rom_file = get_base_rom_path()
+    if not os.path.exists(rom_file):
+        return False
+
+    with open(rom_file, 'rb') as rom:
+        rom_bytes = rom.read()
+
+    basemd5 = hashlib.md5()
+    basemd5.update(rom_bytes)
+    return CHECKSUM_BLUE == basemd5.hexdigest()
+
+
+if __name__ == "__main__":
+    Utils.init_logging("MMBN3Client")
+
+    async def main():
+        multiprocessing.freeze_support()
+        parser = get_base_parser()
+        parser.add_argument("patch_file", default="", type=str, nargs="?",
+                            help="Path to an APMMBN3 file")
+        args = parser.parse_args()
+        checksum_matches = confirm_checksum()
+        if checksum_matches:
+            if args.patch_file:
+                asyncio.create_task(patch_and_run_game(args.patch_file))
+
+        ctx = MMBN3Context(args.connect, args.password)
+        if not checksum_matches:
+            ctx.patching_error = True
+        ctx.server_task = asyncio.create_task(server_loop(ctx), name="Server Loop")
+        if gui_enabled:
+            ctx.run_gui()
+        ctx.run_cli()
+
+        ctx.gba_sync_task = asyncio.create_task(gba_sync_task(ctx), name="GBA Sync")
+        await ctx.exit_event.wait()
+        ctx.server_address = None
+        await ctx.shutdown()
+
+        if ctx.gba_sync_task:
+            await ctx.gba_sync_task
+
+    import colorama
+
+    colorama.init()
+
+    asyncio.run(main())
+    colorama.deinit()

Main.py

@@ -1,82 +1,78 @@
 import collections
+import concurrent.futures
 import logging
 import os
-import time
-import zlib
-import concurrent.futures
 import pickle
 import tempfile
+import time
 import zipfile
-from typing import Dict, List, Tuple, Optional, Set
+import zlib
+from typing import Dict, List, Optional, Set, Tuple, Union
 
-from BaseClasses import Item, MultiWorld, CollectionState, Region, LocationProgressType, Location
 import worlds
-from worlds.alttp.SubClasses import LTTPRegionType
-from worlds.alttp.Regions import is_main_entrance
-from Fill import distribute_items_restrictive, flood_items, balance_multiworld_progression, distribute_planned
-from worlds.alttp.Shops import FillDisabledShopSlots
-from Utils import output_path, get_options, __version__, version_tuple
-from worlds.generic.Rules import locality_rules, exclusion_rules
+from BaseClasses import CollectionState, Item, Location, LocationProgressType, MultiWorld, Region
+from Fill import balance_multiworld_progression, distribute_items_restrictive, distribute_planned, flood_items
+from Options import StartInventoryPool
+from Utils import __version__, output_path, version_tuple
+from settings import get_settings
 from worlds import AutoWorld
+from worlds.generic.Rules import exclusion_rules, locality_rules
 
-ordered_areas = (
-    'Light World', 'Dark World', 'Hyrule Castle', 'Agahnims Tower', 'Eastern Palace', 'Desert Palace',
-    'Tower of Hera', 'Palace of Darkness', 'Swamp Palace', 'Skull Woods', 'Thieves Town', 'Ice Palace',
-    'Misery Mire', 'Turtle Rock', 'Ganons Tower', "Total"
-)
+__all__ = ["main"]
 
 
 def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = None):
     if not baked_server_options:
-        baked_server_options = get_options()["server_options"]
+        baked_server_options = get_settings().server_options.as_dict()
+    assert isinstance(baked_server_options, dict)
     if args.outputpath:
         os.makedirs(args.outputpath, exist_ok=True)
         output_path.cached_path = args.outputpath
 
     start = time.perf_counter()
-    # initialize the world
-    world = MultiWorld(args.multi)
+    # initialize the multiworld
+    multiworld = MultiWorld(args.multi)
 
     logger = logging.getLogger()
-    world.set_seed(seed, args.race, str(args.outputname) if args.outputname else None)
-    world.plando_options = args.plando_options
+    multiworld.set_seed(seed, args.race, str(args.outputname) if args.outputname else None)
+    multiworld.plando_options = args.plando_options
 
-    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.
+    multiworld.shuffle = args.shuffle.copy()
+    multiworld.logic = args.logic.copy()
+    multiworld.mode = args.mode.copy()
+    multiworld.difficulty = args.difficulty.copy()
+    multiworld.item_functionality = args.item_functionality.copy()
+    multiworld.timer = args.timer.copy()
+    multiworld.goal = args.goal.copy()
+    multiworld.boss_shuffle = args.shufflebosses.copy()
+    multiworld.enemy_health = args.enemy_health.copy()
+    multiworld.enemy_damage = args.enemy_damage.copy()
+    multiworld.beemizer_total_chance = args.beemizer_total_chance.copy()
+    multiworld.beemizer_trap_chance = args.beemizer_trap_chance.copy()
+    multiworld.countdown_start_time = args.countdown_start_time.copy()
+    multiworld.red_clock_time = args.red_clock_time.copy()
+    multiworld.blue_clock_time = args.blue_clock_time.copy()
+    multiworld.green_clock_time = args.green_clock_time.copy()
+    multiworld.dungeon_counters = args.dungeon_counters.copy()
+    multiworld.triforce_pieces_available = args.triforce_pieces_available.copy()
+    multiworld.triforce_pieces_required = args.triforce_pieces_required.copy()
+    multiworld.shop_shuffle = args.shop_shuffle.copy()
+    multiworld.shuffle_prizes = args.shuffle_prizes.copy()
+    multiworld.sprite_pool = args.sprite_pool.copy()
+    multiworld.dark_room_logic = args.dark_room_logic.copy()
+    multiworld.plando_items = args.plando_items.copy()
+    multiworld.plando_texts = args.plando_texts.copy()
+    multiworld.plando_connections = args.plando_connections.copy()
+    multiworld.required_medallions = args.required_medallions.copy()
+    multiworld.game = args.game.copy()
+    multiworld.player_name = args.name.copy()
+    multiworld.sprite = args.sprite.copy()
+    multiworld.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)
+    multiworld.set_options(args)
+    multiworld.set_item_links()
+    multiworld.state = CollectionState(multiworld)
+    logger.info('Archipelago Version %s  -  Seed: %s\n', __version__, multiworld.seed)
 
     logger.info(f"Found {len(AutoWorld.AutoWorldRegister.world_types)} World Types:")
     longest_name = max(len(text) for text in AutoWorld.AutoWorldRegister.world_types)
@@ -105,58 +101,117 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
 
     del item_digits, location_digits, item_count, location_count
 
-    AutoWorld.call_stage(world, "assert_generate")
+    # 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_all(world, "generate_early")
+    AutoWorld.call_all(multiworld, "generate_early")
 
     logger.info('')
 
-    for player in world.player_ids:
-        for item_name, count in world.start_inventory[player].value.items():
+    for player in multiworld.player_ids:
+        for item_name, count in multiworld.worlds[player].options.start_inventory.value.items():
             for _ in range(count):
-                world.push_precollected(world.create_item(item_name, player))
+                multiworld.push_precollected(multiworld.create_item(item_name, player))
 
-    logger.info('Creating World.')
-    AutoWorld.call_all(world, "create_regions")
+        for item_name, count in getattr(multiworld.worlds[player].options,
+                                        "start_inventory_from_pool",
+                                        StartInventoryPool({})).value.items():
+            for _ in range(count):
+                multiworld.push_precollected(multiworld.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)
+            if early:
+                multiworld.early_items[player][item_name] = max(0, early-count)
+                remaining_count = count-early
+                if remaining_count > 0:
+                    local_early = multiworld.early_local_items[player].get(item_name, 0)
+                    if local_early:
+                        multiworld.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 Items.')
-    AutoWorld.call_all(world, "create_items")
-
-    # All worlds should have finished creating all regions, locations, and entrances.
-    # Recache to ensure that they are all visible for locality rules.
-    world._recache()
+    AutoWorld.call_all(multiworld, "create_items")
 
     logger.info('Calculating Access Rules.')
 
-    for player in world.player_ids:
+    for player in multiworld.player_ids:
         # items can't be both local and non-local, prefer local
-        world.non_local_items[player].value -= world.local_items[player].value
-        world.non_local_items[player].value -= set(world.local_early_items[player])
+        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])
 
-    if world.players > 1:
-        locality_rules(world)
+    AutoWorld.call_all(multiworld, "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:
+            try:
+                location = multiworld.get_location(location_name, player)
+            except KeyError as e:  # failed to find the given location. Check if it's a legitimate location
+                if location_name not in multiworld.worlds[player].location_name_to_id:
+                    raise Exception(f"Unable to prioritize location {location_name} in player {player}'s world.") from e
+            else:
+                location.progress_type = LocationProgressType.PRIORITY
+
+    # Set local and non-local item rules.
+    if multiworld.players > 1:
+        locality_rules(multiworld)
     else:
-        world.non_local_items[1].value = set()
-        world.local_items[1].value = set()
+        multiworld.worlds[1].options.non_local_items.value = set()
+        multiworld.worlds[1].options.local_items.value = set()
+    
+    AutoWorld.call_all(multiworld, "generate_basic")
 
-    AutoWorld.call_all(world, "set_rules")
+    # 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):
+        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
+        }
+        for player, items in depletion_pool.items():
+            player_world: AutoWorld.World = multiworld.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):
+            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:])
+                    break
+            else:
+                new_items.append(item)
 
-    for player in world.player_ids:
-        exclusion_rules(world, player, world.exclude_locations[player].value)
-        world.priority_locations[player].value -= world.exclude_locations[player].value
-        for location_name in world.priority_locations[player].value:
-            world.get_location(location_name, player).progress_type = LocationProgressType.PRIORITY
-
-    AutoWorld.call_all(world, "generate_basic")
+        # leftovers?
+        if target:
+            for player, remaining_items in depletion_pool.items():
+                remaining_items = {name: count for name, count in remaining_items.items() if count}
+                if remaining_items:
+                    raise Exception(f"{multiworld.get_player_name(player)}"
+                                    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
 
     # temporary home for item links, should be moved out of Main
-    for group_id, group in world.groups.items():
+    for group_id, group in multiworld.groups.items():
         def find_common_pool(players: Set[int], shared_pool: Set[str]) -> Tuple[
             Optional[Dict[int, Dict[str, int]]], Optional[Dict[str, int]]
         ]:
             classifications: Dict[str, int] = collections.defaultdict(int)
             counters = {player: {name: 0 for name in shared_pool} for player in players}
-            for item in world.itempool:
+            for item in multiworld.itempool:
                 if item.player in counters and item.name in shared_pool:
                     counters[item.player][item.name] += 1
                     classifications[item.name] |= item.classification
@@ -191,13 +246,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, world, "ItemLink")
-        world.regions.append(region)
-        locations = region.locations = []
-        for item in world.itempool:
+        region = Region("Menu", group_id, multiworld, "ItemLink")
+        multiworld.regions.append(region)
+        locations = region.locations
+        for item in multiworld.itempool:
             count = common_item_count.get(item.player, {}).get(item.name, 0)
             if count:
-                loc = Location(group_id, f"Item Link: {item.name} -> {world.player_name[item.player]} {count}",
+                loc = Location(group_id, f"Item Link: {item.name} -> {multiworld.player_name[item.player]} {count}",
                                None, region)
                 loc.access_rule = lambda state, item_name = item.name, group_id_ = group_id, count_ = count: \
                     state.has(item_name, group_id_, count_)
@@ -208,10 +263,10 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
             else:
                 new_itempool.append(item)
 
-        itemcount = len(world.itempool)
-        world.itempool = new_itempool
+        itemcount = len(multiworld.itempool)
+        multiworld.itempool = new_itempool
 
-        while itemcount > len(world.itempool):
+        while itemcount > len(multiworld.itempool):
             items_to_add = []
             for player in group["players"]:
                 if group["link_replacement"]:
@@ -219,88 +274,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(world, "create_item", item_player,
+                    items_to_add.append(AutoWorld.call_single(multiworld, "create_item", item_player,
                                                                 group["replacement_items"][player]))
                 else:
-                    items_to_add.append(AutoWorld.call_single(world, "create_filler", item_player))
-            world.random.shuffle(items_to_add)
-            world.itempool.extend(items_to_add[:itemcount - len(world.itempool)])
+                    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)])
 
-    if any(world.item_links.values()):
-        world._recache()
-        world._all_state = None
+    if any(multiworld.item_links.values()):
+        multiworld._all_state = None
 
-    logger.info("Running Item Plando")
+    logger.info("Running Item Plando.")
 
-    distribute_planned(world)
+    distribute_planned(multiworld)
 
     logger.info('Running Pre Main Fill.')
 
-    AutoWorld.call_all(world, "pre_fill")
+    AutoWorld.call_all(multiworld, "pre_fill")
 
-    logger.info(f'Filling the world with {len(world.itempool)} items.')
+    logger.info(f'Filling the multiworld with {len(multiworld.itempool)} items.')
 
-    if world.algorithm == 'flood':
-        flood_items(world)  # different algo, biased towards early game progress items
-    elif world.algorithm == 'balanced':
-        distribute_items_restrictive(world)
+    if multiworld.algorithm == 'flood':
+        flood_items(multiworld)  # different algo, biased towards early game progress items
+    elif multiworld.algorithm == 'balanced':
+        distribute_items_restrictive(multiworld)
 
-    AutoWorld.call_all(world, 'post_fill')
+    AutoWorld.call_all(multiworld, 'post_fill')
 
-    if world.players > 1:
-        balance_multiworld_progression(world)
-
-    logger.info(f'Beginning output...')
+    if multiworld.players > 1 and not args.skip_prog_balancing:
+        balance_multiworld_progression(multiworld)
+    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
-    world.random.passthrough = False
+    multiworld.random.passthrough = False
 
-    outfilebase = 'AP_' + world.seed_name
+    if args.skip_output:
+        logger.info('Done. Skipped output/spoiler generation. Total Time: %s', time.perf_counter() - start)
+        return multiworld
+
+    logger.info(f'Beginning output...')
+    outfilebase = 'AP_' + multiworld.seed_name
 
     output = tempfile.TemporaryDirectory()
     with output as temp_dir:
-        with concurrent.futures.ThreadPoolExecutor(world.players + 2) as pool:
-            check_accessibility_task = pool.submit(world.fulfills_accessibility)
+        output_players = [player for player in multiworld.player_ids if AutoWorld.World.generate_output.__code__
+                          is not multiworld.worlds[player].generate_output.__code__]
+        with concurrent.futures.ThreadPoolExecutor(len(output_players) + 2) as pool:
+            check_accessibility_task = pool.submit(multiworld.fulfills_accessibility)
 
-            output_file_futures = [pool.submit(AutoWorld.call_stage, world, "generate_output", temp_dir)]
-            for player in world.player_ids:
+            output_file_futures = [pool.submit(AutoWorld.call_stage, multiworld, "generate_output", temp_dir)]
+            for player in output_players:
                 # skip starting a thread for methods that say "pass".
-                if AutoWorld.World.generate_output.__code__ is not world.worlds[player].generate_output.__code__:
-                    output_file_futures.append(
-                        pool.submit(AutoWorld.call_single, world, "generate_output", player, temp_dir))
+                output_file_futures.append(
+                    pool.submit(AutoWorld.call_single, multiworld, "generate_output", player, temp_dir))
 
             # collect ER hint info
             er_hint_data: Dict[int, Dict[int, str]] = {}
-            AutoWorld.call_all(world, 'extend_hint_information', er_hint_data)
-
-            checks_in_area = {player: {area: list() for area in ordered_areas}
-                              for player in range(1, world.players + 1)}
-
-            for player in range(1, world.players + 1):
-                checks_in_area[player]["Total"] = 0
-
-            for location in world.get_filled_locations():
-                if type(location.address) is int:
-                    if location.game != "A Link to the Past":
-                        checks_in_area[location.player]["Light World"].append(location.address)
-                    else:
-                        main_entrance = location.parent_region.get_connecting_entrance(is_main_entrance)
-                        if location.parent_region.dungeon:
-                            dungeonname = {'Inverted Agahnims Tower': 'Agahnims Tower',
-                                           'Inverted Ganons Tower': 'Ganons Tower'} \
-                                .get(location.parent_region.dungeon.name, location.parent_region.dungeon.name)
-                            checks_in_area[location.player][dungeonname].append(location.address)
-                        elif location.parent_region.type == LTTPRegionType.LightWorld:
-                            checks_in_area[location.player]["Light World"].append(location.address)
-                        elif location.parent_region.type == LTTPRegionType.DarkWorld:
-                            checks_in_area[location.player]["Dark World"].append(location.address)
-                        elif main_entrance.parent_region.type == LTTPRegionType.LightWorld:
-                            checks_in_area[location.player]["Light World"].append(location.address)
-                        elif main_entrance.parent_region.type == LTTPRegionType.DarkWorld:
-                            checks_in_area[location.player]["Dark World"].append(location.address)
-                    checks_in_area[location.player]["Total"] += 1
-
-            FillDisabledShopSlots(world)
+            AutoWorld.call_all(multiworld, 'extend_hint_information', er_hint_data)
 
             def write_multidata():
                 import NetUtils
@@ -309,63 +340,67 @@ 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(world.player_name.items())]]
-                for slot in world.player_ids:
-                    player_world: AutoWorld.World = world.worlds[slot]
+                names = [[name for player, name in sorted(multiworld.player_name.items())]]
+                for slot in multiworld.player_ids:
+                    player_world: AutoWorld.World = multiworld.worlds[slot]
                     minimum_versions["server"] = max(minimum_versions["server"], player_world.required_server_version)
                     client_versions[slot] = player_world.required_client_version
-                    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],
+                    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],
                                                            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 world.precollected_items.items()}
-                precollected_hints = {player: set() for player in range(1, world.players + 1 + len(world.groups))}
+                                      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 slot in world.player_ids:
-                    slot_data[slot] = world.worlds[slot].fill_slot_data()
+                for slot in multiworld.player_ids:
+                    slot_data[slot] = multiworld.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 world.groups:
+                    if location.item.player not in multiworld.groups:
                         precollected_hints[location.item.player].add(hint)
                     else:
-                        for player in world.groups[location.item.player]["players"]:
+                        for player in multiworld.groups[location.item.player]["players"]:
                             precollected_hints[player].add(hint)
 
-                locations_data: Dict[int, Dict[int, Tuple[int, int, int]]] = {player: {} for player in world.player_ids}
-                for location in world.get_filled_locations():
+                locations_data: Dict[int, Dict[int, Tuple[int, int, int]]] = {player: {} for player in multiworld.player_ids}
+                for location in multiworld.get_filled_locations():
                     if type(location.address) == int:
                         assert location.item.code is not None, "item code None should be event, " \
                                                                "location.address should then also be None. Location: " \
                                                                f" {location}"
+                        assert location.address not in locations_data[location.player], (
+                            f"Locations with duplicate address. {location} and "
+                            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 world.start_location_hints[location.player]:
+                        if location.name in multiworld.worlds[location.player].options.start_location_hints:
                             precollect_hint(location)
-                        elif location.item.name in world.start_hints[location.item.player]:
+                        elif location.item.name in multiworld.worlds[location.item.player].options.start_hints:
                             precollect_hint(location)
-                        elif any([location.item.name in world.start_hints[player]
-                                  for player in world.groups.get(location.item.player, {}).get("players", [])]):
+                        elif any([location.item.name in multiworld.worlds[player].options.start_hints
+                                  for player in multiworld.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 world.worlds.values()
+                    for game_world in multiworld.worlds.values()
                 }
 
+                checks_in_area: Dict[int, Dict[str, Union[int, List[int]]]] = {}
+
                 multidata = {
                     "slot_data": slot_data,
                     "slot_info": slot_info,
-                    "names": names,  # TODO: remove after 0.3.9
-                    "connect_names": {name: (0, player) for player, name in world.player_name.items()},
+                    "connect_names": {name: (0, player) for player, name in multiworld.player_name.items()},
                     "locations": locations_data,
                     "checks_in_area": checks_in_area,
                     "server_options": baked_server_options,
@@ -375,10 +410,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": world.seed_name,
+                    "seed_name": multiworld.seed_name,
                     "datapackage": data_package,
                 }
-                AutoWorld.call_all(world, "modify_multidata", multidata)
+                AutoWorld.call_all(multiworld, "modify_multidata", multidata)
 
                 multidata = zlib.compress(pickle.dumps(multidata), 9)
 
@@ -386,15 +421,14 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
                     f.write(bytes([3]))  # version of format
                     f.write(multidata)
 
-            multidata_task = pool.submit(write_multidata)
+            output_file_futures.append(pool.submit(write_multidata))
             if not check_accessibility_task.result():
-                if not world.can_beat_game():
+                if not multiworld.can_beat_game():
                     raise Exception("Game appears as unbeatable. Aborting.")
                 else:
                     logger.warning("Location Accessibility requirements not fulfilled.")
 
             # retrieve exceptions via .result() if they occurred.
-            multidata_task.result()
             for i, future in enumerate(concurrent.futures.as_completed(output_file_futures), start=1):
                 if i % 10 == 0 or i == len(output_file_futures):
                     logger.info(f'Generating output files ({i}/{len(output_file_futures)}).')
@@ -402,12 +436,12 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
 
         if args.spoiler > 1:
             logger.info('Calculating playthrough.')
-            world.spoiler.create_playthrough(create_paths=args.spoiler > 2)
+            multiworld.spoiler.create_playthrough(create_paths=args.spoiler > 2)
 
         if args.spoiler:
-            world.spoiler.to_file(os.path.join(temp_dir, '%s_Spoiler.txt' % outfilebase))
+            multiworld.spoiler.to_file(os.path.join(temp_dir, '%s_Spoiler.txt' % outfilebase))
 
-        zipfilename = output_path(f"AP_{world.seed_name}.zip")
+        zipfilename = output_path(f"AP_{multiworld.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:
@@ -415,4 +449,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 world
+    return multiworld

MinecraftClient.py

@@ -299,7 +299,7 @@ if __name__ == '__main__':
 
     versions = get_minecraft_versions(data_version, channel)
 
-    forge_dir = Utils.user_path(options["minecraft_options"]["forge_directory"])
+    forge_dir = options["minecraft_options"]["forge_directory"]
     max_heap = options["minecraft_options"]["max_heap_size"]
     forge_version = args.forge or versions["forge"]
     java_version = args.java or versions["java"]

ModuleUpdate.py

@@ -1,15 +1,32 @@
 import os
 import sys
 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.")
 
-update_ran = getattr(sys, "frozen", False)  # don't run update if environment is frozen/compiled
+# 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'),))
 
 if not update_ran:
     for entry in os.scandir(os.path.join(local_dir, "worlds")):
@@ -65,14 +82,23 @@ def update(yes=False, force=False):
         install_pkg_resources(yes=yes)
         import pkg_resources
 
+        prev = ""  # if a line ends in \ we store here and merge later
         for req_file in requirements_files:
             path = os.path.join(os.path.dirname(sys.argv[0]), req_file)
             if not os.path.exists(path):
                 path = os.path.join(os.path.dirname(__file__), req_file)
             with open(path) as requirementsfile:
                 for line in requirementsfile:
-                    if not line or line[0] == "#":
-                        continue  # ignore comments
+                    if not line or line.lstrip(" \t")[0] == "#":
+                        if not prev:
+                            continue  # ignore comments
+                        line = ""
+                    elif line.rstrip("\r\n").endswith("\\"):
+                        prev = prev + line.rstrip("\r\n")[:-1] + " "  # continue on next line
+                        continue
+                    line = prev + line
+                    line = line.split("--hash=")[0]  # remove hashes from requirement for version checking
+                    prev = ""
                     if line.startswith(("https://", "git+https://")):
                         # extract name and version for url
                         rest = line.split('/')[-1]

MultiServer.py

@@ -2,17 +2,15 @@ from __future__ import annotations
 
 import argparse
 import asyncio
-import copy
-import functools
-import logging
-import zlib
 import collections
+import copy
 import datetime
 import functools
 import hashlib
 import inspect
 import itertools
 import logging
+import math
 import operator
 import pickle
 import random
@@ -41,7 +39,7 @@ import NetUtils
 import Utils
 from Utils import version_tuple, restricted_loads, Version, async_start
 from NetUtils import Endpoint, ClientStatus, NetworkItem, decode, encode, NetworkPlayer, Permission, NetworkSlot, \
-    SlotType
+    SlotType, LocationStore
 
 min_client_version = Version(0, 1, 6)
 colorama.init()
@@ -70,21 +68,25 @@ def update_dict(dictionary, entries):
 
 # functions callable on storable data on the server by clients
 modify_functions = {
-    "add": operator.add,  # add together two objects, using python's "+" operator (works on strings and lists as append)
-    "mul": operator.mul,
-    "mod": operator.mod,
-    "max": max,
-    "min": min,
+    # generic:
     "replace": lambda old, new: new,
     "default": lambda old, new: old,
+    # numeric:
+    "add": operator.add,  # add together two objects, using python's "+" operator (works on strings and lists as append)
+    "mul": operator.mul,
     "pow": operator.pow,
+    "mod": operator.mod,
+    "floor": lambda value, _: math.floor(value),
+    "ceil": lambda value, _: math.ceil(value),
+    "max": max,
+    "min": min,
     # bitwise:
     "xor": operator.xor,
     "or": operator.or_,
     "and": operator.and_,
     "left_shift": operator.lshift,
     "right_shift": operator.rshift,
-    # lists/dicts
+    # lists/dicts:
     "remove": remove_from_list,
     "pop": pop_from_container,
     "update": update_dict,
@@ -155,14 +157,16 @@ class Context:
                       "compatibility": int}
     # team -> slot id -> list of clients authenticated to slot.
     clients: typing.Dict[int, typing.Dict[int, typing.List[Client]]]
-    locations: typing.Dict[int, typing.Dict[int, typing.Tuple[int, int, int]]]
+    locations: LocationStore  # typing.Dict[int, typing.Dict[int, typing.Tuple[int, int, int]]]
+    location_checks: typing.Dict[typing.Tuple[int, int], typing.Set[int]]
+    hints_used: typing.Dict[typing.Tuple[int, int], int]
     groups: typing.Dict[int, typing.Set[int]]
     save_version = 2
     stored_data: typing.Dict[str, object]
     read_data: typing.Dict[str, object]
     stored_data_notification_clients: typing.Dict[str, typing.Set[Client]]
     slot_info: typing.Dict[int, NetworkSlot]
-
+    generator_version = Version(0, 0, 0)
     checksums: typing.Dict[str, str]
     item_names: typing.Dict[int, str] = Utils.KeyedDefaultDict(lambda code: f'Unknown item (ID:{code})')
     item_name_groups: typing.Dict[str, typing.Dict[str, typing.Set[str]]]
@@ -190,8 +194,6 @@ class Context:
         self.player_name_lookup: typing.Dict[str, team_slot] = {}
         self.connect_names = {}  # names of slots clients can connect to
         self.allow_releases = {}
-        #                          player          location_id     item_id  target_player_id
-        self.locations = {}
         self.host = host
         self.port = port
         self.server_password = server_password
@@ -226,7 +228,7 @@ class Context:
         self.save_dirty = False
         self.tags = ['AP']
         self.games: typing.Dict[int, str] = {}
-        self.minimum_client_versions: typing.Dict[int, Utils.Version] = {}
+        self.minimum_client_versions: typing.Dict[int, Version] = {}
         self.seed_name = ""
         self.groups = {}
         self.group_collected: typing.Dict[int, typing.Set[int]] = {}
@@ -260,7 +262,8 @@ class Context:
 
     def _init_game_data(self):
         for game_name, game_package in self.gamespackage.items():
-            self.checksums[game_name] = game_package["checksum"]
+            if "checksum" in game_package:
+                self.checksums[game_name] = game_package["checksum"]
             for item_name, item_id in game_package["item_name_to_id"].items():
                 self.item_names[item_id] = item_name
             for location_name, location_id in game_package["location_name_to_id"].items():
@@ -268,7 +271,7 @@ class Context:
             self.all_item_and_group_names[game_name] = \
                 set(game_package["item_name_to_id"]) | set(self.item_name_groups[game_name])
             self.all_location_and_group_names[game_name] = \
-                set(game_package["location_name_to_id"]) | set(self.location_name_groups[game_name])
+                set(game_package["location_name_to_id"]) | set(self.location_name_groups.get(game_name, []))
 
     def item_names_for_game(self, game: str) -> typing.Optional[typing.Dict[str, int]]:
         return self.gamespackage[game]["item_name_to_id"] if game in self.gamespackage else None
@@ -286,6 +289,7 @@ class Context:
         except websockets.ConnectionClosed:
             logging.exception(f"Exception during send_msgs, could not send {msg}")
             await self.disconnect(endpoint)
+            return False
         else:
             if self.log_network:
                 logging.info(f"Outgoing message: {msg}")
@@ -299,6 +303,7 @@ class Context:
         except websockets.ConnectionClosed:
             logging.exception("Exception during send_encoded_msgs")
             await self.disconnect(endpoint)
+            return False
         else:
             if self.log_network:
                 logging.info(f"Outgoing message: {msg}")
@@ -313,6 +318,7 @@ class Context:
             websockets.broadcast(sockets, msg)
         except RuntimeError:
             logging.exception("Exception during broadcast_send_encoded_msgs")
+            return False
         else:
             if self.log_network:
                 logging.info(f"Outgoing broadcast: {msg}")
@@ -356,9 +362,7 @@ class Context:
                                    [{"cmd": "PrintJSON", "data": [{ "text": text }], **additional_arguments}
                                     for text in texts]))
 
-
     # loading
-
     def load(self, multidatapath: str, use_embedded_server_options: bool = False):
         if multidatapath.lower().endswith(".zip"):
             import zipfile
@@ -385,15 +389,17 @@ class Context:
 
     def _load(self, decoded_obj: dict, game_data_packages: typing.Dict[str, typing.Any],
               use_embedded_server_options: bool):
+
         self.read_data = {}
         mdata_ver = decoded_obj["minimum_versions"]["server"]
-        if mdata_ver > Utils.version_tuple:
+        if mdata_ver > version_tuple:
             raise RuntimeError(f"Supplied Multidata (.archipelago) requires a server of at least version {mdata_ver},"
-                               f"however this server is of version {Utils.version_tuple}")
+                               f"however this server is of version {version_tuple}")
+        self.generator_version = Version(*decoded_obj["version"])
         clients_ver = decoded_obj["minimum_versions"].get("clients", {})
         self.minimum_client_versions = {}
         for player, version in clients_ver.items():
-            self.minimum_client_versions[player] = max(Utils.Version(*version), min_client_version)
+            self.minimum_client_versions[player] = max(Version(*version), min_client_version)
 
         self.slot_info = decoded_obj["slot_info"]
         self.games = {slot: slot_info.game for slot, slot_info in self.slot_info.items()}
@@ -411,11 +417,13 @@ class Context:
             self.player_name_lookup[slot_info.name] = 0, slot_id
             self.read_data[f"hints_{0}_{slot_id}"] = lambda local_team=0, local_player=slot_id: \
                 list(self.get_rechecked_hints(local_team, local_player))
+            self.read_data[f"client_status_{0}_{slot_id}"] = lambda local_team=0, local_player=slot_id: \
+                self.client_game_state[local_team, local_player]
 
         self.seed_name = decoded_obj["seed_name"]
         self.random.seed(self.seed_name)
         self.connect_names = decoded_obj['connect_names']
-        self.locations = decoded_obj['locations']
+        self.locations = LocationStore(decoded_obj.pop("locations"))  # pre-emptively free memory
         self.slot_data = decoded_obj['slot_data']
         for slot, data in self.slot_data.items():
             self.read_data[f"slot_data_{slot}"] = lambda data=data: data
@@ -446,9 +454,10 @@ class Context:
             logging.info(f"Loading embedded data package for game {game_name}")
             self.gamespackage[game_name] = data
             self.item_name_groups[game_name] = data["item_name_groups"]
-            self.location_name_groups[game_name] = data["location_name_groups"]
+            if "location_name_groups" in data:
+                self.location_name_groups[game_name] = data["location_name_groups"]
+                del data["location_name_groups"]
             del data["item_name_groups"]  # remove from data package, but keep in self.item_name_groups
-            del data["location_name_groups"]
         self._init_game_data()
         for game_name, data in self.item_name_groups.items():
             self.read_data[f"item_name_groups_{game_name}"] = lambda lgame=game_name: self.item_name_groups[lgame]
@@ -544,7 +553,7 @@ class Context:
             "stored_data": self.stored_data,
             "game_options": {"hint_cost": self.hint_cost, "location_check_points": self.location_check_points,
                              "server_password": self.server_password, "password": self.password,
-                             "forfeit_mode": self.release_mode, "release_mode": self.release_mode,  # TODO remove forfeit_mode around 0.4
+                             "release_mode": self.release_mode,
                              "remaining_mode": self.remaining_mode, "collect_mode": self.collect_mode,
                              "item_cheat": self.item_cheat, "compatibility": self.compatibility}
 
@@ -647,7 +656,8 @@ class Context:
         else:
             return self.player_names[team, slot]
 
-    def notify_hints(self, team: int, hints: typing.List[NetUtils.Hint], only_new: bool = False):
+    def notify_hints(self, team: int, hints: typing.List[NetUtils.Hint], only_new: bool = False,
+                     recipients: typing.Sequence[int] = None):
         """Send and remember hints."""
         if only_new:
             hints = [hint for hint in hints if hint not in self.hints[team, hint.finding_player]]
@@ -676,12 +686,13 @@ class Context:
         for slot in new_hint_events:
             self.on_new_hint(team, slot)
         for slot, hint_data in concerns.items():
-            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))
+            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))
 
     # "events"
 
@@ -696,11 +707,24 @@ 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]}])
 
+    def on_client_status_change(self, team: int, slot: int):
+        key: str = f"_read_client_status_{team}_{slot}"
+        targets: typing.Set[Client] = set(self.stored_data_notification_clients[key])
+        if targets:
+            self.broadcast(targets, [{"cmd": "SetReply", "key": key, "value": self.client_game_state[team, slot]}])
+
 
 def update_aliases(ctx: Context, team: int):
     cmd = ctx.dumper([{"cmd": "RoomUpdate",
@@ -754,14 +778,15 @@ async def on_client_connected(ctx: Context, client: Client):
         # tags are for additional features in the communication.
         # Name them by feature or fork, as you feel is appropriate.
         'tags': ctx.tags,
-        'version': Utils.version_tuple,
+        'version': version_tuple,
+        'generator_version': ctx.generator_version,
         'permissions': get_permissions(ctx),
         'hint_cost': ctx.hint_cost,
         'location_check_points': ctx.location_check_points,
         'datapackage_versions': {game: game_data["version"] for game, game_data
                                  in ctx.gamespackage.items() if game in games},
         'datapackage_checksums': {game: game_data["checksum"] for game, game_data
-                                  in ctx.gamespackage.items() if game in games},
+                                  in ctx.gamespackage.items() if game in games and "checksum" in game_data},
         'seed_name': ctx.seed_name,
         'time': time.time(),
     }])
@@ -769,7 +794,6 @@ async def on_client_connected(ctx: Context, client: Client):
 
 def get_permissions(ctx) -> typing.Dict[str, Permission]:
     return {
-        "forfeit": Permission.from_text(ctx.release_mode),  # TODO remove around 0.4
         "release": Permission.from_text(ctx.release_mode),
         "remaining": Permission.from_text(ctx.remaining_mode),
         "collect": Permission.from_text(ctx.collect_mode)
@@ -789,7 +813,7 @@ async def on_client_joined(ctx: Context, client: Client):
     ctx.broadcast_text_all(
         f"{ctx.get_aliased_name(client.team, client.slot)} (Team #{client.team + 1}) "
         f"{verb} {ctx.games[client.slot]} has joined. "
-        f"Client({version_str}), {client.tags}).",
+        f"Client({version_str}), {client.tags}.",
         {"type": "Join", "team": client.team, "slot": client.slot, "tags": client.tags})
     ctx.notify_client(client, "Now that you are connected, "
                               "you can use !help to list commands to run via the server. "
@@ -899,11 +923,7 @@ def release_player(ctx: Context, team: int, slot: int):
 
 def collect_player(ctx: Context, team: int, slot: int, is_group: bool = False):
     """register any locations that are in the multidata, pointing towards this player"""
-    all_locations = collections.defaultdict(set)
-    for source_slot, location_data in ctx.locations.items():
-        for location_id, values in location_data.items():
-            if values[1] == slot:
-                all_locations[source_slot].add(location_id)
+    all_locations = ctx.locations.get_for_player(slot)
 
     ctx.broadcast_text_all("%s (Team #%d) has collected their items from other worlds."
                            % (ctx.player_names[(team, slot)], team + 1),
@@ -922,11 +942,7 @@ def collect_player(ctx: Context, team: int, slot: int, is_group: bool = False):
 
 
 def get_remaining(ctx: Context, team: int, slot: int) -> typing.List[int]:
-    items = []
-    for location_id in ctx.locations[slot]:
-        if location_id not in ctx.location_checks[team, slot]:
-            items.append(ctx.locations[slot][location_id][0])  # item ID
-    return sorted(items)
+    return ctx.locations.get_remaining(ctx.location_checks, team, slot)
 
 
 def send_items_to(ctx: Context, team: int, target_slot: int, *items: NetworkItem):
@@ -962,7 +978,10 @@ 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()
 
 
@@ -974,13 +993,12 @@ def collect_hints(ctx: Context, team: int, slot: int, item: typing.Union[int, st
             slots.add(group_id)
 
     seeked_item_id = item if isinstance(item, int) else ctx.item_names_for_game(ctx.games[slot])[item]
-    for finding_player, check_data in ctx.locations.items():
-        for location_id, (item_id, receiving_player, item_flags) in check_data.items():
-            if receiving_player in slots and item_id == seeked_item_id:
-                found = location_id in ctx.location_checks[team, finding_player]
-                entrance = ctx.er_hint_data.get(finding_player, {}).get(location_id, "")
-                hints.append(NetUtils.Hint(receiving_player, finding_player, location_id, item_id, found, entrance,
-                                           item_flags))
+    for finding_player, location_id, item_id, receiving_player, item_flags \
+            in ctx.locations.find_item(slots, seeked_item_id):
+        found = location_id in ctx.location_checks[team, finding_player]
+        entrance = ctx.er_hint_data.get(finding_player, {}).get(location_id, "")
+        hints.append(NetUtils.Hint(receiving_player, finding_player, location_id, item_id, found, entrance,
+                                   item_flags))
 
     return hints
 
@@ -1040,17 +1058,19 @@ 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, " \
-                                       f"did you mean {picks[0][0]}? ({picks[0][1]}% sure)"
+            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)"
         elif dif > 5:
             return picks[0][0], True, "Close Match"
         else:
-            return picks[0][0], False, f"Too many close matches, did you mean {picks[0][0]}? ({picks[0][1]}% sure)"
+            return picks[0][0], False, f"Too many close matches for '{input_text}', " \
+                                       f"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"Did you mean {picks[0][0]}? ({picks[0][1]}% sure)"
+            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)"
 
 
 class CommandMeta(type):
@@ -1327,27 +1347,41 @@ class ClientMessageProcessor(CommonCommandProcessor):
                     "Sorry, !remaining requires you to have beaten the game on this server")
                 return False
 
-    def _cmd_missing(self) -> bool:
-        """List all missing location checks from the server's perspective"""
+    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."""
 
         locations = get_missing_checks(self.ctx, self.client.team, self.client.slot)
 
         if locations:
-            texts = [f'Missing: {self.ctx.location_names[location]}' for location in locations]
-            texts.append(f"Found {len(locations)} missing location checks")
+            names = [self.ctx.location_names[location] for location in locations]
+            if filter_text:
+                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.")
+            else:
+                texts.append(f"Found {len(locations)} missing location checks")
             self.output_multiple(texts)
         else:
             self.output("No missing location checks found.")
         return True
 
-    def _cmd_checked(self) -> bool:
-        """List all done location checks from the server's perspective"""
+    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."""
 
         locations = get_checked_checks(self.ctx, self.client.team, self.client.slot)
 
         if locations:
-            texts = [f'Checked: {self.ctx.location_names[location]}' for location in locations]
-            texts.append(f"Found {len(locations)} done location checks")
+            names = [self.ctx.location_names[location] for location in locations]
+            if filter_text:
+                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.")
+            else:
+                texts.append(f"Found {len(locations)} done location checks")
             self.output_multiple(texts)
         else:
             self.output("No done location checks found.")
@@ -1405,9 +1439,13 @@ 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))
+            self.ctx.notify_hints(self.client.team, list(hints), recipients=(self.client.slot,))
             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():
@@ -1538,15 +1576,11 @@ class ClientMessageProcessor(CommonCommandProcessor):
 
 
 def get_checked_checks(ctx: Context, team: int, slot: int) -> typing.List[int]:
-    return [location_id for
-            location_id in ctx.locations[slot] if
-            location_id in ctx.location_checks[team, slot]]
+    return ctx.locations.get_checked(ctx.location_checks, team, slot)
 
 
 def get_missing_checks(ctx: Context, team: int, slot: int) -> typing.List[int]:
-    return [location_id for
-            location_id in ctx.locations[slot] if
-            location_id not in ctx.location_checks[team, slot]]
+    return ctx.locations.get_missing(ctx.location_checks, team, slot)
 
 
 def get_client_points(ctx: Context, client: Client) -> int:
@@ -1626,7 +1660,8 @@ async def process_client_cmd(ctx: Context, client: Client, args: dict):
                 "players": ctx.get_players_package(),
                 "missing_locations": get_missing_checks(ctx, team, slot),
                 "checked_locations": get_checked_checks(ctx, team, slot),
-                "slot_info": ctx.slot_info
+                "slot_info": ctx.slot_info,
+                "hint_points": get_slot_points(ctx, team, slot),
             }
             reply = [connected_packet]
             start_inventory = get_start_inventory(ctx, slot, client.remote_start_inventory)
@@ -1728,6 +1763,8 @@ async def process_client_cmd(ctx: Context, client: Client, args: dict):
                     hints.extend(collect_hint_location_id(ctx, client.team, client.slot, location))
                 locs.append(NetworkItem(target_item, location, target_player, flags))
             ctx.notify_hints(client.team, hints, only_new=create_as_hint == 2)
+            if locs and create_as_hint:
+                ctx.save()
             await ctx.send_msgs(client, [{'cmd': 'LocationInfo', 'locations': locs}])
 
         elif cmd == 'StatusUpdate':
@@ -1786,6 +1823,7 @@ async def process_client_cmd(ctx: Context, client: Client, args: dict):
                 targets.add(client)
             if targets:
                 ctx.broadcast(targets, [args])
+            ctx.save()
 
         elif cmd == "SetNotify":
             if "keys" not in args or type(args["keys"]) != list:
@@ -1803,6 +1841,8 @@ def update_client_status(ctx: Context, client: Client, new_status: ClientStatus)
             ctx.on_goal_achieved(client)
 
         ctx.client_game_state[client.team, client.slot] = new_status
+        ctx.on_client_status_change(client.team, client.slot)
+        ctx.save()
 
 
 class ServerCommandProcessor(CommonCommandProcessor):
@@ -1843,7 +1883,7 @@ class ServerCommandProcessor(CommonCommandProcessor):
 
     def _cmd_exit(self) -> bool:
         """Shutdown the server"""
-        async_start(self.ctx.server.ws_server._close())
+        self.ctx.server.ws_server.close()
         if self.ctx.shutdown_task:
             self.ctx.shutdown_task.cancel()
         self.ctx.exit_event.set()
@@ -1932,7 +1972,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
@@ -2106,13 +2146,15 @@ class ServerCommandProcessor(CommonCommandProcessor):
 async def console(ctx: Context):
     import sys
     queue = asyncio.Queue()
-    Utils.stream_input(sys.stdin, queue)
+    worker = Utils.stream_input(sys.stdin, queue)
     while not ctx.exit_event.is_set():
         try:
             # I don't get why this while loop is needed. Works fine without it on clients,
             # but the queue.get() for server never fulfills if the queue is empty when entering the await.
             while queue.qsize() == 0:
                 await asyncio.sleep(0.05)
+                if not worker.is_alive():
+                    return
             input_text = await queue.get()
             queue.task_done()
             ctx.commandprocessor(input_text)
@@ -2123,7 +2165,7 @@ async def console(ctx: Context):
 
 def parse_args() -> argparse.Namespace:
     parser = argparse.ArgumentParser()
-    defaults = Utils.get_options()["server_options"]
+    defaults = Utils.get_options()["server_options"].as_dict()
     parser.add_argument('multidata', nargs="?", default=defaults["multidata"])
     parser.add_argument('--host', default=defaults["host"])
     parser.add_argument('--port', default=defaults["port"], type=int)
@@ -2182,25 +2224,24 @@ 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():
-            async_start(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.")
+            inactivity_shutdown()
         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:
-                async_start(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.")
+                inactivity_shutdown()
             else:
                 await asyncio.sleep(seconds)
 
@@ -2232,12 +2273,15 @@ async def main(args: argparse.Namespace):
                 if not isinstance(e, ImportError):
                     logging.error(f"Failed to load tkinter ({e})")
                 logging.info("Pass a multidata filename on command line to run headless.")
-                exit(1)
+                # when cx_Freeze'd the built-in exit is not available, so we import sys.exit instead
+                import sys
+                sys.exit(1)
             raise
 
         if not data_filename:
             logging.info("No file selected. Exiting.")
-            exit(1)
+            import sys
+            sys.exit(1)
 
     try:
         ctx.load(data_filename, args.use_embedded_options)
@@ -2250,8 +2294,7 @@ async def main(args: argparse.Namespace):
 
     ssl_context = load_server_cert(args.cert, args.cert_key) if args.cert else None
 
-    ctx.server = websockets.serve(functools.partial(server, ctx=ctx), host=ctx.host, port=ctx.port, ping_timeout=None,
-                                  ping_interval=None, ssl=ssl_context)
+    ctx.server = websockets.serve(functools.partial(server, ctx=ctx), host=ctx.host, port=ctx.port, ssl=ssl_context)
     ip = args.host if args.host else Utils.get_public_ipv4()
     logging.info('Hosting game at %s:%d (%s)' % (ip, ctx.port,
                                                  'No password' if not ctx.password else 'Password: %s' % ctx.password))

NetUtils.py

@@ -2,11 +2,12 @@ from __future__ import annotations
 
 import typing
 import enum
+import warnings
 from json import JSONEncoder, JSONDecoder
 
 import websockets
 
-from Utils import Version
+from Utils import ByValue, Version
 
 
 class JSONMessagePart(typing.TypedDict, total=False):
@@ -20,7 +21,7 @@ class JSONMessagePart(typing.TypedDict, total=False):
     flags: int
 
 
-class ClientStatus(enum.IntEnum):
+class ClientStatus(ByValue, enum.IntEnum):
     CLIENT_UNKNOWN = 0
     CLIENT_CONNECTED = 5
     CLIENT_READY = 10
@@ -28,7 +29,7 @@ class ClientStatus(enum.IntEnum):
     CLIENT_GOAL = 30
 
 
-class SlotType(enum.IntFlag):
+class SlotType(ByValue, enum.IntFlag):
     spectator = 0b00
     player = 0b01
     group = 0b10
@@ -39,7 +40,7 @@ class SlotType(enum.IntFlag):
         return self.value != 0b01
 
 
-class Permission(enum.IntFlag):
+class Permission(ByValue, enum.IntFlag):
     disabled = 0b000  # 0, completely disables access
     enabled = 0b001  # 1, allows manual use
     goal = 0b010  # 2, allows manual use after goal completion
@@ -289,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, item_id: int, player: int = 0, **kwargs) -> None:
-    parts.append({"text": str(item_id), "player": player, "type": JSONTypes.location_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})
 
 
 class Hint(typing.NamedTuple):
@@ -343,3 +344,85 @@ class Hint(typing.NamedTuple):
     @property
     def local(self):
         return self.receiving_player == self.finding_player
+
+
+class _LocationStore(dict, typing.MutableMapping[int, typing.Dict[int, typing.Tuple[int, int, int]]]):
+    def __init__(self, values: typing.MutableMapping[int, typing.Dict[int, typing.Tuple[int, int, int]]]):
+        super().__init__(values)
+
+        if not self:
+            raise ValueError(f"Rejecting game with 0 players")
+
+        if len(self) != max(self):
+            raise ValueError("Player IDs not continuous")
+
+        if len(self.get(0, {})):
+            raise ValueError("Invalid player id 0 for location")
+
+    def find_item(self, slots: typing.Set[int], seeked_item_id: int
+                  ) -> typing.Generator[typing.Tuple[int, int, int, int, int], None, None]:
+        for finding_player, check_data in self.items():
+            for location_id, (item_id, receiving_player, item_flags) in check_data.items():
+                if receiving_player in slots and item_id == seeked_item_id:
+                    yield finding_player, location_id, item_id, receiving_player, item_flags
+
+    def get_for_player(self, slot: int) -> typing.Dict[int, typing.Set[int]]:
+        import collections
+        all_locations: typing.Dict[int, typing.Set[int]] = collections.defaultdict(set)
+        for source_slot, location_data in self.items():
+            for location_id, values in location_data.items():
+                if values[1] == slot:
+                    all_locations[source_slot].add(location_id)
+        return all_locations
+
+    def get_checked(self, state: typing.Dict[typing.Tuple[int, int], typing.Set[int]], team: int, slot: int
+                    ) -> typing.List[int]:
+        checked = state[team, slot]
+        if not checked:
+            # This optimizes the case where everyone connects to a fresh game at the same time.
+            return []
+        return [location_id for
+                location_id in self[slot] if
+                location_id in checked]
+
+    def get_missing(self, state: typing.Dict[typing.Tuple[int, int], typing.Set[int]], team: int, slot: int
+                    ) -> typing.List[int]:
+        checked = state[team, slot]
+        if not checked:
+            # This optimizes the case where everyone connects to a fresh game at the same time.
+            return list(self[slot])
+        return [location_id for
+                location_id in self[slot] if
+                location_id not in checked]
+
+    def get_remaining(self, state: typing.Dict[typing.Tuple[int, int], typing.Set[int]], team: int, slot: int
+                      ) -> typing.List[int]:
+        checked = state[team, slot]
+        player_locations = self[slot]
+        return sorted([player_locations[location_id][0] for
+                       location_id in player_locations if
+                       location_id not in checked])
+
+
+if typing.TYPE_CHECKING:  # type-check with pure python implementation until we have a typing stub
+    LocationStore = _LocationStore
+else:
+    try:
+        from _speedups import LocationStore
+        import _speedups
+        import os.path
+        if os.path.isfile("_speedups.pyx") and os.path.getctime(_speedups.__file__) < os.path.getctime("_speedups.pyx"):
+            warnings.warn(f"{_speedups.__file__} outdated! "
+                          f"Please rebuild with `cythonize -b -i _speedups.pyx` or delete it!")
+    except ImportError:
+        try:
+            import pyximport
+            pyximport.install()
+        except ImportError:
+            pyximport = None
+        try:
+            from _speedups import LocationStore
+        except ImportError:
+            warnings.warn("_speedups not available. Falling back to pure python LocationStore. "
+                          "Install a matching C++ compiler for your platform to compile _speedups.")
+            LocationStore = _LocationStore

OoTAdjuster.py

@@ -44,7 +44,7 @@ def adjustGUI():
         StringVar, IntVar, Checkbutton, Frame, Label, X, Entry, Button, \
         OptionMenu, filedialog, messagebox, ttk
     from argparse import Namespace
-    from Main import __version__ as MWVersion
+    from Utils import __version__ as MWVersion
 
     window = tk.Tk()
     window.wm_title(f"Archipelago {MWVersion} OoT Adjuster")
@@ -195,10 +195,10 @@ def set_icon(window):
     window.tk.call('wm', 'iconphoto', window._w, logo)
 
 def adjust(args):
-    # Create a fake world and OOTWorld to use as a base
-    world = MultiWorld(1)
-    world.per_slot_randoms = {1: random}
-    ootworld = OOTWorld(world, 1)
+    # Create a fake multiworld and OOTWorld to use as a base
+    multiworld = MultiWorld(1)
+    multiworld.per_slot_randoms = {1: random}
+    ootworld = OOTWorld(multiworld, 1)
     # Set options in the fake OOTWorld
     for name, option in chain(cosmetic_options.items(), sfx_options.items()):
         result = getattr(args, name, None)

OoTClient.py

@@ -17,9 +17,9 @@ from worlds.oot.N64Patch import apply_patch_file
 from worlds.oot.Utils import data_path
 
 
-CONNECTION_TIMING_OUT_STATUS = "Connection timing out. Please restart your emulator, then restart oot_connector.lua"
-CONNECTION_REFUSED_STATUS = "Connection refused. Please start your emulator and make sure oot_connector.lua is running"
-CONNECTION_RESET_STATUS = "Connection was reset. Please restart your emulator, then restart oot_connector.lua"
+CONNECTION_TIMING_OUT_STATUS = "Connection timing out. Please restart your emulator, then restart connector_oot.lua"
+CONNECTION_REFUSED_STATUS = "Connection refused. Please start your emulator and make sure connector_oot.lua is running"
+CONNECTION_RESET_STATUS = "Connection was reset. Please restart your emulator, then restart connector_oot.lua"
 CONNECTION_TENTATIVE_STATUS = "Initial Connection Made"
 CONNECTION_CONNECTED_STATUS = "Connected"
 CONNECTION_INITIAL_STATUS = "Connection has not been initiated"
@@ -100,7 +100,7 @@ class OoTContext(CommonContext):
             await super(OoTContext, self).server_auth(password_requested)
         if not self.auth:
             self.awaiting_rom = True
-            logger.info('Awaiting connection to Bizhawk to get player information')
+            logger.info('Awaiting connection to EmuHawk to get player information')
             return
 
         await self.send_connect()
@@ -179,6 +179,12 @@ async def parse_payload(payload: dict, ctx: OoTContext, force: bool):
     locations = payload['locations']
     collectibles = payload['collectibles']
 
+    # The Lua JSON library serializes an empty table into a list instead of a dict. Verify types for safety:
+    if isinstance(locations, list):
+        locations = {}
+    if isinstance(collectibles, list):
+        collectibles = {}
+
     if ctx.location_table != locations or ctx.collectible_table != collectibles:
         ctx.location_table = locations
         ctx.collectible_table = collectibles
@@ -290,13 +296,16 @@ async def patch_and_run_game(apz5_file):
     comp_path = base_name + '.z64'
     # Load vanilla ROM, patch file, compress ROM
     rom_file_name = Utils.get_options()["oot_options"]["rom_file"]
-    if not os.path.exists(rom_file_name):
-        rom_file_name = Utils.user_path(rom_file_name)
     rom = Rom(rom_file_name)
-    apply_patch_file(rom, apz5_file,
-        sub_file=(os.path.basename(base_name) + '.zpf'
-            if zipfile.is_zipfile(apz5_file)
-            else None))
+
+    sub_file = None
+    if zipfile.is_zipfile(apz5_file):
+        for name in zipfile.ZipFile(apz5_file).namelist():
+            if name.endswith('.zpf'):
+                sub_file = name
+                break
+
+    apply_patch_file(rom, apz5_file, sub_file=sub_file)
     rom.write_to_file(decomp_path)
     os.chdir(data_path("Compress"))
     compress_rom_file(decomp_path, comp_path)

Options.py

@@ -1,18 +1,23 @@
 from __future__ import annotations
+
 import abc
+import functools
 import logging
-from copy import deepcopy
 import math
 import numbers
-import typing
 import random
+import typing
+from copy import deepcopy
+from dataclasses import dataclass
 
-from schema import Schema, And, Or, Optional
-from Utils import get_fuzzy_results
+from schema import And, Optional, Or, Schema
+
+from Utils import get_fuzzy_results, is_iterable_except_str
 
 if typing.TYPE_CHECKING:
     from BaseClasses import PlandoOptions
     from worlds.AutoWorld import World
+    import pathlib
 
 
 class AssembleOptions(abc.ABCMeta):
@@ -36,6 +41,11 @@ 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
@@ -53,6 +63,7 @@ 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"
@@ -90,7 +101,7 @@ T = typing.TypeVar('T')
 
 class Option(typing.Generic[T], metaclass=AssembleOptions):
     value: T
-    default = 0
+    default: typing.ClassVar[typing.Any]  # something that __init__ will be able to convert to the correct type
 
     # convert option_name_long into Name Long as display_name, otherwise name_long is the result.
     # Handled in get_option_name()
@@ -100,8 +111,9 @@ class Option(typing.Generic[T], metaclass=AssembleOptions):
     supports_weighting = True
 
     # filled by AssembleOptions:
-    name_lookup: typing.Dict[T, str]
-    options: typing.Dict[str, int]
+    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]]
 
     def __repr__(self) -> str:
         return f"{self.__class__.__name__}({self.current_option_name})"
@@ -154,6 +166,8 @@ 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
@@ -174,9 +188,18 @@ 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)
@@ -208,6 +231,12 @@ class NumericOption(Option[int], numbers.Integral, abc.ABC):
         else:
             return self.value > other
 
+    def __ge__(self, other: typing.Union[int, NumericOption]) -> bool:
+        if isinstance(other, NumericOption):
+            return self.value >= other.value
+        else:
+            return self.value >= other
+
     def __bool__(self) -> bool:
         return bool(self.value)
 
@@ -586,7 +615,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]
@@ -684,11 +713,19 @@ class Range(NumericOption):
         return int(round(random.triangular(lower, end, tri), 0))
 
 
-class SpecialRange(Range):
-    special_range_cutoff = 0
+class NamedRange(Range):
     special_range_names: typing.Dict[str, int] = {}
     """Special Range names have to be all lowercase as matching is done with text.lower()"""
 
+    def __init__(self, value: int) -> None:
+        if value < self.range_start and value not in self.special_range_names.values():
+            raise Exception(f"{value} is lower than minimum {self.range_start} for option {self.__class__.__name__} " +
+                            f"and is also not one of the supported named special values: {self.special_range_names}")
+        elif value > self.range_end and value not in self.special_range_names.values():
+            raise Exception(f"{value} is higher than maximum {self.range_end} for option {self.__class__.__name__} " +
+                            f"and is also not one of the supported named special values: {self.special_range_names}")
+        self.value = value
+
     @classmethod
     def from_text(cls, text: str) -> Range:
         text = text.lower()
@@ -696,6 +733,19 @@ class SpecialRange(Range):
             return cls(cls.special_range_names[text])
         return super().from_text(text)
 
+
+class SpecialRange(NamedRange):
+    special_range_cutoff = 0
+
+    # TODO: remove class SpecialRange, earliest 3 releases after 0.4.3
+    def __new__(cls, value: int) -> SpecialRange:
+        from Utils import deprecate
+        deprecate(f"Option type {cls.__name__} is a subclass of SpecialRange, which is deprecated and pending removal. "
+                  "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)
+
     @classmethod
     def weighted_range(cls, text) -> Range:
         if text == "random-low":
@@ -715,8 +765,16 @@ class SpecialRange(Range):
                             f"random-range-high-<min>-<max>, or random-range-<min>-<max>.")
 
 
-class VerifyKeys:
-    valid_keys = frozenset()
+class FreezeValidKeys(AssembleOptions):
+    def __new__(mcs, name, bases, attrs):
+        if "valid_keys" in attrs:
+            attrs["_valid_keys"] = frozenset(attrs["valid_keys"])
+        return super(FreezeValidKeys, mcs).__new__(mcs, name, bases, attrs)
+
+
+class VerifyKeys(metaclass=FreezeValidKeys):
+    valid_keys: typing.Iterable = []
+    _valid_keys: frozenset  # gets created by AssembleOptions from valid_keys
     valid_keys_casefold: bool = False
     convert_name_groups: bool = False
     verify_item_name: bool = False
@@ -724,14 +782,14 @@ class VerifyKeys:
     value: typing.Any
 
     @classmethod
-    def verify_keys(cls, data: typing.List[str]):
+    def verify_keys(cls, data: typing.Iterable[str]) -> None:
         if cls.valid_keys:
             data = set(data)
             dataset = set(word.casefold() for word in data) if cls.valid_keys_casefold else set(data)
-            extra = dataset - cls.valid_keys
+            extra = dataset - cls._valid_keys
             if extra:
                 raise Exception(f"Found unexpected key {', '.join(extra)} in {cls}. "
-                                f"Allowed keys: {cls.valid_keys}.")
+                                f"Allowed keys: {cls._valid_keys}.")
 
     def verify(self, world: typing.Type[World], player_name: str, plando_options: "PlandoOptions") -> None:
         if self.convert_name_groups and self.verify_item_name:
@@ -760,8 +818,8 @@ class VerifyKeys:
                                     f"Did you mean '{picks[0][0]}' ({picks[0][1]}% sure)")
 
 
-class OptionDict(Option[typing.Dict[str, typing.Any]], VerifyKeys):
-    default: typing.Dict[str, typing.Any] = {}
+class OptionDict(Option[typing.Dict[str, typing.Any]], VerifyKeys, typing.Mapping[str, typing.Any]):
+    default = {}
     supports_weighting = False
 
     def __init__(self, value: typing.Dict[str, typing.Any]):
@@ -778,8 +836,14 @@ class OptionDict(Option[typing.Dict[str, typing.Any]], VerifyKeys):
     def get_option_name(self, value):
         return ", ".join(f"{key}: {v}" for key, v in value.items())
 
-    def __contains__(self, item):
-        return item in self.value
+    def __getitem__(self, item: str) -> typing.Any:
+        return self.value.__getitem__(item)
+
+    def __iter__(self) -> typing.Iterator[str]:
+        return self.value.__iter__()
+
+    def __len__(self) -> int:
+        return self.value.__len__()
 
 
 class ItemDict(OptionDict):
@@ -792,11 +856,15 @@ class ItemDict(OptionDict):
 
 
 class OptionList(Option[typing.List[typing.Any]], VerifyKeys):
-    default: typing.List[typing.Any] = []
+    # Supports duplicate entries and ordering.
+    # 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 = ()
     supports_weighting = False
 
-    def __init__(self, value: typing.List[typing.Any]):
-        self.value = deepcopy(value)
+    def __init__(self, value: typing.Iterable[typing.Any]):
+        self.value = list(deepcopy(value))
         super(OptionList, self).__init__()
 
     @classmethod
@@ -805,7 +873,7 @@ class OptionList(Option[typing.List[typing.Any]], VerifyKeys):
 
     @classmethod
     def from_any(cls, data: typing.Any):
-        if type(data) == list:
+        if is_iterable_except_str(data):
             cls.verify_keys(data)
             return cls(data)
         return cls.from_text(str(data))
@@ -818,7 +886,7 @@ class OptionList(Option[typing.List[typing.Any]], VerifyKeys):
 
 
 class OptionSet(Option[typing.Set[str]], VerifyKeys):
-    default: typing.Union[typing.Set[str], typing.FrozenSet[str]] = frozenset()
+    default = frozenset()
     supports_weighting = False
 
     def __init__(self, value: typing.Iterable[str]):
@@ -831,7 +899,7 @@ class OptionSet(Option[typing.Set[str]], VerifyKeys):
 
     @classmethod
     def from_any(cls, data: typing.Any):
-        if isinstance(data, (list, set, frozenset)):
+        if is_iterable_except_str(data):
             cls.verify_keys(data)
             return cls(data)
         return cls.from_text(str(data))
@@ -861,7 +929,7 @@ class Accessibility(Choice):
     default = 1
 
 
-class ProgressionBalancing(SpecialRange):
+class ProgressionBalancing(NamedRange):
     """A system that can move progression earlier, to try and prevent the player from getting stuck and bored early.
     A lower setting means more getting stuck. A higher setting means less getting stuck."""
     default = 50
@@ -875,10 +943,58 @@ class ProgressionBalancing(SpecialRange):
     }
 
 
-common_options = {
-    "progression_balancing": ProgressionBalancing,
-    "accessibility": Accessibility
-}
+class OptionsMetaProperty(type):
+    def __new__(mcs,
+                name: str,
+                bases: typing.Tuple[type, ...],
+                attrs: typing.Dict[str, typing.Any]) -> "OptionsMetaProperty":
+        for attr_type in attrs.values():
+            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)
+
+    @property
+    @functools.lru_cache(maxsize=None)
+    def type_hints(cls) -> typing.Dict[str, typing.Type[Option[typing.Any]]]:
+        """Returns type hints of the class as a dictionary."""
+        return typing.get_type_hints(cls)
+
+
+@dataclass
+class CommonOptions(metaclass=OptionsMetaProperty):
+    progression_balancing: ProgressionBalancing
+    accessibility: Accessibility
+
+    def as_dict(self, *option_names: str, casing: str = "snake") -> typing.Dict[str, typing.Any]:
+        """
+        Returns a dictionary of [str, Option.value]
+        
+        :param option_names: names of the options to return
+        :param casing: case of the keys to return. Supports `snake`, `camel`, `pascal`, `kebab`
+        """
+        option_results = {}
+        for option_name in option_names:
+            if option_name in type(self).type_hints:
+                if casing == "snake":
+                    display_name = option_name
+                elif casing == "camel":
+                    split_name = [name.title() for name in option_name.split("_")]
+                    split_name[0] = split_name[0].lower()
+                    display_name = "".join(split_name)
+                elif casing == "pascal":
+                    display_name = "".join([name.title() for name in option_name.split("_")])
+                elif casing == "kebab":
+                    display_name = option_name.replace("_", "-")
+                else:
+                    raise ValueError(f"{casing} is invalid casing for as_dict. "
+                                     "Valid names are 'snake', 'camel', 'pascal', 'kebab'.")
+                value = getattr(self, option_name).value
+                if isinstance(value, set):
+                    value = sorted(value)
+                option_results[display_name] = value
+            else:
+                raise ValueError(f"{option_name} not found in {tuple(type(self).type_hints)}")
+        return option_results
 
 
 class LocalItems(ItemSet):
@@ -897,6 +1013,13 @@ class StartInventory(ItemDict):
     display_name = "Start Inventory"
 
 
+class StartInventoryPool(StartInventory):
+    """Start with these items and don't place them in the world.
+    The game decides what the replacement items will be."""
+    verify_item_name = True
+    display_name = "Start Inventory from Pool"
+
+
 class StartHints(ItemSet):
     """Start with these item's locations prefilled into the !hint command."""
     display_name = "Start Hints"
@@ -904,6 +1027,7 @@ class StartHints(ItemSet):
 
 class LocationSet(OptionSet):
     verify_location_name = True
+    convert_name_groups = True
 
 
 class StartLocationHints(LocationSet):
@@ -928,6 +1052,7 @@ class DeathLink(Toggle):
 
 class ItemLinks(OptionList):
     """Share part of your item pool with other players."""
+    display_name = "Item Links"
     default = []
     schema = Schema([
         {
@@ -990,17 +1115,76 @@ class ItemLinks(OptionList):
             link.setdefault("link_replacement", None)
 
 
-per_game_common_options = {
-    **common_options,  # can be overwritten per-game
-    "local_items": LocalItems,
-    "non_local_items": NonLocalItems,
-    "start_inventory": StartInventory,
-    "start_hints": StartHints,
-    "start_location_hints": StartLocationHints,
-    "exclude_locations": ExcludeLocations,
-    "priority_locations": PriorityLocations,
-    "item_links": ItemLinks
-}
+@dataclass
+class PerGameCommonOptions(CommonOptions):
+    local_items: LocalItems
+    non_local_items: NonLocalItems
+    start_inventory: StartInventory
+    start_hints: StartHints
+    start_location_hints: StartLocationHints
+    exclude_locations: ExcludeLocations
+    priority_locations: PriorityLocations
+    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
+
+    import yaml
+    from jinja2 import Template
+
+    from worlds import AutoWorldRegister
+    from Utils import local_path, __version__
+
+    full_path: str
+
+    os.makedirs(target_folder, exist_ok=True)
+
+    # clean out old
+    for file in os.listdir(target_folder):
+        full_path = os.path.join(target_folder, file)
+        if os.path.isfile(full_path) and full_path.endswith(".yaml"):
+            os.unlink(full_path)
+
+    def dictify_range(option: Range):
+        data = {option.default: 50}
+        for sub_option in ["random", "random-low", "random-high"]:
+            if sub_option != option.default:
+                data[sub_option] = 0
+
+        notes = {}
+        for name, number in getattr(option, "special_range_names", {}).items():
+            notes[name] = f"equivalent to {number}"
+            if number in data:
+                data[name] = data[number]
+                del data[number]
+            else:
+                data[name] = 0
+
+        return data, notes
+
+    for game_name, world in AutoWorldRegister.world_types.items():
+        if not world.hidden or generate_hidden:
+            all_options: typing.Dict[str, AssembleOptions] = world.options_dataclass.type_hints
+
+            with open(local_path("data", "options.yaml")) as f:
+                file_data = f.read()
+            res = Template(file_data).render(
+                options=all_options,
+                __version__=__version__, game=game_name, yaml_dump=yaml.dump,
+                dictify_range=dictify_range,
+            )
+
+            del file_data
+
+            with open(os.path.join(target_folder, game_name + ".yaml"), "w", encoding="utf-8-sig") as f:
+                f.write(res)
+
 
 if __name__ == "__main__":
 

Patch.py

@@ -8,7 +8,7 @@ if __name__ == "__main__":
     import ModuleUpdate
     ModuleUpdate.update()
 
-from worlds.Files import AutoPatchRegister, APDeltaPatch
+from worlds.Files import AutoPatchRegister, APAutoPatchInterface
 
 
 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: APDeltaPatch = auto_handler(patch_file)
+        handler: APAutoPatchInterface = auto_handler(patch_file)
         target = os.path.splitext(patch_file)[0]+handler.result_file_ending
         handler.patch(target)
         return {"server": handler.server,

PokemonClient.py

@@ -1,351 +0,0 @@
-import asyncio
-import json
-import time
-import os
-import bsdiff4
-import subprocess
-import zipfile
-from asyncio import StreamReader, StreamWriter
-from typing import List
-
-
-import Utils
-from Utils import async_start
-from CommonClient import CommonContext, server_loop, gui_enabled, ClientCommandProcessor, logger, \
-    get_base_parser
-
-from worlds.pokemon_rb.locations import location_data
-from worlds.pokemon_rb.rom import RedDeltaPatch, BlueDeltaPatch
-
-location_map = {"Rod": {}, "EventFlag": {}, "Missable": {}, "Hidden": {}, "list": {}, "DexSanityFlag": {}}
-location_bytes_bits = {}
-for location in location_data:
-    if location.ram_address is not None:
-        if type(location.ram_address) == list:
-            location_map[type(location.ram_address).__name__][(location.ram_address[0].flag, location.ram_address[1].flag)] = location.address
-            location_bytes_bits[location.address] = [{'byte': location.ram_address[0].byte, 'bit': location.ram_address[0].bit},
-                                                     {'byte': location.ram_address[1].byte, 'bit': location.ram_address[1].bit}]
-        else:
-            location_map[type(location.ram_address).__name__][location.ram_address.flag] = location.address
-            location_bytes_bits[location.address] = {'byte': location.ram_address.byte, 'bit': location.ram_address.bit}
-
-SYSTEM_MESSAGE_ID = 0
-
-CONNECTION_TIMING_OUT_STATUS = "Connection timing out. Please restart your emulator, then restart pkmn_rb.lua"
-CONNECTION_REFUSED_STATUS = "Connection Refused. Please start your emulator and make sure pkmn_rb.lua is running"
-CONNECTION_RESET_STATUS = "Connection was reset. Please restart your emulator, then restart pkmn_rb.lua"
-CONNECTION_TENTATIVE_STATUS = "Initial Connection Made"
-CONNECTION_CONNECTED_STATUS = "Connected"
-CONNECTION_INITIAL_STATUS = "Connection has not been initiated"
-
-DISPLAY_MSGS = True
-
-SCRIPT_VERSION = 3
-
-
-class GBCommandProcessor(ClientCommandProcessor):
-    def __init__(self, ctx: CommonContext):
-        super().__init__(ctx)
-
-    def _cmd_gb(self):
-        """Check Gameboy Connection State"""
-        if isinstance(self.ctx, GBContext):
-            logger.info(f"Gameboy Status: {self.ctx.gb_status}")
-
-
-class GBContext(CommonContext):
-    command_processor = GBCommandProcessor
-    game = 'Pokemon Red and Blue'
-
-    def __init__(self, server_address, password):
-        super().__init__(server_address, password)
-        self.gb_streams: (StreamReader, StreamWriter) = None
-        self.gb_sync_task = None
-        self.messages = {}
-        self.locations_array = None
-        self.gb_status = CONNECTION_INITIAL_STATUS
-        self.awaiting_rom = False
-        self.display_msgs = True
-        self.deathlink_pending = False
-        self.set_deathlink = False
-        self.client_compatibility_mode = 0
-        self.items_handling = 0b001
-        self.sent_release = False
-        self.sent_collect = False
-
-    async def server_auth(self, password_requested: bool = False):
-        if password_requested and not self.password:
-            await super(GBContext, self).server_auth(password_requested)
-        if not self.auth:
-            self.awaiting_rom = True
-            logger.info('Awaiting connection to Bizhawk to get Player information')
-            return
-
-        await self.send_connect()
-
-    def _set_message(self, msg: str, msg_id: int):
-        if DISPLAY_MSGS:
-            self.messages[(time.time(), msg_id)] = msg
-
-    def on_package(self, cmd: str, args: dict):
-        if cmd == 'Connected':
-            self.locations_array = None
-            if 'death_link' in args['slot_data'] and args['slot_data']['death_link']:
-                self.set_deathlink = True
-        elif cmd == "RoomInfo":
-            self.seed_name = args['seed_name']
-        elif cmd == 'Print':
-            msg = args['text']
-            if ': !' not in msg:
-                self._set_message(msg, SYSTEM_MESSAGE_ID)
-        elif cmd == "ReceivedItems":
-            msg = f"Received {', '.join([self.item_names[item.item] for item in args['items']])}"
-            self._set_message(msg, SYSTEM_MESSAGE_ID)
-
-    def on_deathlink(self, data: dict):
-        self.deathlink_pending = True
-        super().on_deathlink(data)
-
-    def run_gui(self):
-        from kvui import GameManager
-
-        class GBManager(GameManager):
-            logging_pairs = [
-                ("Client", "Archipelago")
-            ]
-            base_title = "Archipelago Pokémon Client"
-
-        self.ui = GBManager(self)
-        self.ui_task = asyncio.create_task(self.ui.async_run(), name="UI")
-
-
-def get_payload(ctx: GBContext):
-    current_time = time.time()
-    ret = json.dumps(
-        {
-            "items": [item.item for item in ctx.items_received],
-            "messages": {f'{key[0]}:{key[1]}': value for key, value in ctx.messages.items()
-                         if key[0] > current_time - 10},
-            "deathlink": ctx.deathlink_pending,
-            "options": ((ctx.permissions['release'] in ('goal', 'enabled')) * 2) + (ctx.permissions['collect'] in ('goal', 'enabled'))
-        }
-    )
-    ctx.deathlink_pending = False
-    return ret
-
-
-async def parse_locations(data: List, ctx: GBContext):
-    locations = []
-    flags = {"EventFlag": data[:0x140], "Missable": data[0x140:0x140 + 0x20],
-             "Hidden": data[0x140 + 0x20: 0x140 + 0x20 + 0x0E],
-             "Rod": data[0x140 + 0x20 + 0x0E:0x140 + 0x20 + 0x0E + 0x01]}
-
-    if len(data) > 0x140 + 0x20 + 0x0E + 0x01:
-        flags["DexSanityFlag"] = data[0x140 + 0x20 + 0x0E + 0x01:]
-    else:
-        flags["DexSanityFlag"] = [0] * 19
-
-    for flag_type, loc_map in location_map.items():
-        for flag, loc_id in loc_map.items():
-            if flag_type == "list":
-                if (flags["EventFlag"][location_bytes_bits[loc_id][0]['byte']] & 1 << location_bytes_bits[loc_id][0]['bit']
-                        and flags["Missable"][location_bytes_bits[loc_id][1]['byte']] & 1 << location_bytes_bits[loc_id][1]['bit']):
-                    locations.append(loc_id)
-            elif flags[flag_type][location_bytes_bits[loc_id]['byte']] & 1 << location_bytes_bits[loc_id]['bit']:
-                locations.append(loc_id)
-    if flags["EventFlag"][280] & 1 and not ctx.finished_game:
-        await ctx.send_msgs([
-                    {"cmd": "StatusUpdate",
-                     "status": 30}
-                ])
-        ctx.finished_game = True
-    if locations == ctx.locations_array:
-        return
-    ctx.locations_array = locations
-    if locations is not None:
-        await ctx.send_msgs([{"cmd": "LocationChecks", "locations": locations}])
-
-
-async def gb_sync_task(ctx: GBContext):
-    logger.info("Starting GB connector. Use /gb for status information")
-    while not ctx.exit_event.is_set():
-        error_status = None
-        if ctx.gb_streams:
-            (reader, writer) = ctx.gb_streams
-            msg = get_payload(ctx).encode()
-            writer.write(msg)
-            writer.write(b'\n')
-            try:
-                await asyncio.wait_for(writer.drain(), timeout=1.5)
-                try:
-                    # Data will return a dict with up to two fields:
-                    # 1. A keepalive response of the Players Name (always)
-                    # 2. An array representing the memory values of the locations area (if in game)
-                    data = await asyncio.wait_for(reader.readline(), timeout=5)
-                    data_decoded = json.loads(data.decode())
-                    if 'scriptVersion' not in data_decoded or data_decoded['scriptVersion'] != SCRIPT_VERSION:
-                        msg = "You are connecting with an incompatible Lua script version. Ensure your connector Lua " \
-                            "and PokemonClient are from the same Archipelago installation."
-                        logger.info(msg, extra={'compact_gui': True})
-                        ctx.gui_error('Error', msg)
-                        error_status = CONNECTION_RESET_STATUS
-                    ctx.client_compatibility_mode = data_decoded['clientCompatibilityVersion']
-                    if ctx.client_compatibility_mode == 0:
-                        ctx.items_handling = 0b101  # old patches will not have local start inventory, must be requested
-                    if ctx.seed_name and ctx.seed_name != ''.join([chr(i) for i in data_decoded['seedName'] if i != 0]):
-                        msg = "The server is running a different multiworld than your client is. (invalid seed_name)"
-                        logger.info(msg, extra={'compact_gui': True})
-                        ctx.gui_error('Error', msg)
-                        error_status = CONNECTION_RESET_STATUS
-                    ctx.seed_name = ''.join([chr(i) for i in data_decoded['seedName'] if i != 0])
-                    if not ctx.auth:
-                        ctx.auth = ''.join([chr(i) for i in data_decoded['playerName'] if i != 0])
-                        if ctx.auth == '':
-                            msg = "Invalid ROM detected. No player name built into the ROM."
-                            logger.info(msg, extra={'compact_gui': True})
-                            ctx.gui_error('Error', msg)
-                            error_status = CONNECTION_RESET_STATUS
-                        if ctx.awaiting_rom:
-                            await ctx.server_auth(False)
-                    if 'locations' in data_decoded and ctx.game and ctx.gb_status == CONNECTION_CONNECTED_STATUS \
-                            and not error_status and ctx.auth:
-                        # Not just a keep alive ping, parse
-                        async_start(parse_locations(data_decoded['locations'], ctx))
-                    if 'deathLink' in data_decoded and data_decoded['deathLink'] and 'DeathLink' in ctx.tags:
-                        await ctx.send_death(ctx.auth + " is out of usable Pokémon! " + ctx.auth + " blacked out!")
-                    if 'options' in data_decoded:
-                        msgs = []
-                        if data_decoded['options'] & 4 and not ctx.sent_release:
-                            ctx.sent_release = True
-                            msgs.append({"cmd": "Say", "text": "!release"})
-                        if data_decoded['options'] & 8 and not ctx.sent_collect:
-                            ctx.sent_collect = True
-                            msgs.append({"cmd": "Say", "text": "!collect"})
-                        if msgs:
-                            await ctx.send_msgs(msgs)
-                    if ctx.set_deathlink:
-                        await ctx.update_death_link(True)
-                except asyncio.TimeoutError:
-                    logger.debug("Read Timed Out, Reconnecting")
-                    error_status = CONNECTION_TIMING_OUT_STATUS
-                    writer.close()
-                    ctx.gb_streams = None
-                except ConnectionResetError as e:
-                    logger.debug("Read failed due to Connection Lost, Reconnecting")
-                    error_status = CONNECTION_RESET_STATUS
-                    writer.close()
-                    ctx.gb_streams = None
-            except TimeoutError:
-                logger.debug("Connection Timed Out, Reconnecting")
-                error_status = CONNECTION_TIMING_OUT_STATUS
-                writer.close()
-                ctx.gb_streams = None
-            except ConnectionResetError:
-                logger.debug("Connection Lost, Reconnecting")
-                error_status = CONNECTION_RESET_STATUS
-                writer.close()
-                ctx.gb_streams = None
-            if ctx.gb_status == CONNECTION_TENTATIVE_STATUS:
-                if not error_status:
-                    logger.info("Successfully Connected to Gameboy")
-                    ctx.gb_status = CONNECTION_CONNECTED_STATUS
-                else:
-                    ctx.gb_status = f"Was tentatively connected but error occured: {error_status}"
-            elif error_status:
-                ctx.gb_status = error_status
-                logger.info("Lost connection to Gameboy and attempting to reconnect. Use /gb for status updates")
-        else:
-            try:
-                logger.debug("Attempting to connect to Gameboy")
-                ctx.gb_streams = await asyncio.wait_for(asyncio.open_connection("localhost", 17242), timeout=10)
-                ctx.gb_status = CONNECTION_TENTATIVE_STATUS
-            except TimeoutError:
-                logger.debug("Connection Timed Out, Trying Again")
-                ctx.gb_status = CONNECTION_TIMING_OUT_STATUS
-                continue
-            except ConnectionRefusedError:
-                logger.debug("Connection Refused, Trying Again")
-                ctx.gb_status = CONNECTION_REFUSED_STATUS
-                continue
-
-
-async def run_game(romfile):
-    auto_start = Utils.get_options()["pokemon_rb_options"].get("rom_start", True)
-    if auto_start is True:
-        import webbrowser
-        webbrowser.open(romfile)
-    elif os.path.isfile(auto_start):
-        subprocess.Popen([auto_start, romfile],
-                         stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
-
-
-async def patch_and_run_game(game_version, patch_file, ctx):
-    base_name = os.path.splitext(patch_file)[0]
-    comp_path = base_name + '.gb'
-    if game_version == "blue":
-        delta_patch = BlueDeltaPatch
-    else:
-        delta_patch = RedDeltaPatch
-
-    try:
-        base_rom = delta_patch.get_source_data()
-    except Exception as msg:
-        logger.info(msg, extra={'compact_gui': True})
-        ctx.gui_error('Error', msg)
-
-    with zipfile.ZipFile(patch_file, 'r') as patch_archive:
-        with patch_archive.open('delta.bsdiff4', 'r') as stream:
-            patch = stream.read()
-    patched_rom_data = bsdiff4.patch(base_rom, patch)
-
-    with open(comp_path, "wb") as patched_rom_file:
-        patched_rom_file.write(patched_rom_data)
-
-    async_start(run_game(comp_path))
-
-
-if __name__ == '__main__':
-
-    Utils.init_logging("PokemonClient")
-
-    options = Utils.get_options()
-
-    async def main():
-        parser = get_base_parser()
-        parser.add_argument('patch_file', default="", type=str, nargs="?",
-                            help='Path to an APRED or APBLUE patch file')
-        args = parser.parse_args()
-
-        ctx = GBContext(args.connect, args.password)
-        ctx.server_task = asyncio.create_task(server_loop(ctx), name="ServerLoop")
-        if gui_enabled:
-            ctx.run_gui()
-        ctx.run_cli()
-        ctx.gb_sync_task = asyncio.create_task(gb_sync_task(ctx), name="GB Sync")
-
-        if args.patch_file:
-            ext = args.patch_file.split(".")[len(args.patch_file.split(".")) - 1].lower()
-            if ext == "apred":
-                logger.info("APRED file supplied, beginning patching process...")
-                async_start(patch_and_run_game("red", args.patch_file, ctx))
-            elif ext == "apblue":
-                logger.info("APBLUE file supplied, beginning patching process...")
-                async_start(patch_and_run_game("blue", args.patch_file, ctx))
-            else:
-                logger.warning(f"Unknown patch file extension {ext}")
-
-        await ctx.exit_event.wait()
-        ctx.server_address = None
-
-        await ctx.shutdown()
-
-        if ctx.gb_sync_task:
-            await ctx.gb_sync_task
-
-
-    import colorama
-
-    colorama.init()
-
-    asyncio.run(main())
-    colorama.deinit()

README.md

@@ -25,7 +25,7 @@ Currently, the following games are supported:
 * Hollow Knight
 * The Witness
 * Sonic Adventure 2: Battle
-* Starcraft 2: Wings of Liberty
+* Starcraft 2
 * Donkey Kong Country 3
 * Dark Souls 3
 * Super Mario World
@@ -43,6 +43,28 @@ Currently, the following games are supported:
 * The Legend of Zelda: Link's Awakening DX
 * Clique
 * Adventure
+* DLC Quest
+* Noita
+* Undertale
+* Bumper Stickers
+* Mega Man Battle Network 3: Blue Version
+* Muse Dash
+* DOOM 1993
+* Terraria
+* Lingo
+* Pokémon Emerald
+* DOOM II
+* Shivers
+* 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
@@ -64,9 +86,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. The installers function on Windows only.
+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.
 
-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).
+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).
 
 ## 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

@@ -68,12 +68,11 @@ class SNIClientCommandProcessor(ClientCommandProcessor):
         options = snes_options.split()
         num_options = len(options)
 
-        if num_options > 0:
-            snes_device_number = int(options[0])
-
         if num_options > 1:
             snes_address = options[0]
             snes_device_number = int(options[1])
+        elif num_options > 0:
+            snes_device_number = int(options[0])
 
         self.ctx.snes_reconnect_address = None
         if self.ctx.snes_connect_task:
@@ -208,12 +207,12 @@ class SNIContext(CommonContext):
             self.killing_player_task = asyncio.create_task(deathlink_kill_player(self))
         super(SNIContext, self).on_deathlink(data)
 
-    async def handle_deathlink_state(self, currently_dead: bool) -> None:
+    async def handle_deathlink_state(self, currently_dead: bool, death_text: str = "") -> None:
         # in this state we only care about triggering a death send
         if self.death_state == DeathState.alive:
             if currently_dead:
                 self.death_state = DeathState.dead
-                await self.send_death()
+                await self.send_death(death_text)
         # in this state we care about confirming a kill, to move state to dead
         elif self.death_state == DeathState.killing_player:
             # this is being handled in deathlink_kill_player(ctx) already
@@ -315,7 +314,7 @@ def launch_sni() -> None:
             f"please start it yourself if it is not running")
 
 
-async def _snes_connect(ctx: SNIContext, address: str) -> WebSocketClientProtocol:
+async def _snes_connect(ctx: SNIContext, address: str, retry: bool = True) -> WebSocketClientProtocol:
     address = f"ws://{address}" if "://" not in address else address
     snes_logger.info("Connecting to SNI at %s ..." % address)
     seen_problems: typing.Set[str] = set()
@@ -336,6 +335,8 @@ async def _snes_connect(ctx: SNIContext, address: str) -> WebSocketClientProtoco
             await asyncio.sleep(1)
         else:
             return snes_socket
+        if not retry:
+            break
 
 
 class SNESRequest(typing.TypedDict):
@@ -563,14 +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(len(data))[2:]]
-                # REVIEW: above: `if snes_socket is None: return False`
-                # Does it need to be checked again?
-                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
 
@@ -684,6 +687,8 @@ async def main() -> None:
         logging.info(f"Wrote rom file to {romfile}")
         if args.diff_file.endswith(".apsoe"):
             import webbrowser
+            async_start(run_game(romfile))
+            await _snes_connect(SNIContext(args.snes, args.connect, args.password), args.snes, False)
             webbrowser.open(f"http://www.evermizer.com/apclient/#server={meta['server']}")
             logging.info("Starting Evermizer Client in your Browser...")
             import time

UndertaleClient.py

@@ -0,0 +1,512 @@
+from __future__ import annotations
+import os
+import sys
+import asyncio
+import typing
+import bsdiff4
+import shutil
+
+import Utils
+
+from NetUtils import NetworkItem, ClientStatus
+from worlds import undertale
+from MultiServer import mark_raw
+from CommonClient import CommonContext, server_loop, \
+    gui_enabled, ClientCommandProcessor, logger, get_base_parser
+from Utils import async_start
+
+
+class UndertaleCommandProcessor(ClientCommandProcessor):
+    def __init__(self, ctx):
+        super().__init__(ctx)
+
+    def _cmd_resync(self):
+        """Manually trigger a resync."""
+        if isinstance(self.ctx, UndertaleContext):
+            self.output(f"Syncing items.")
+            self.ctx.syncing = True
+
+    def _cmd_patch(self):
+        """Patch the game. Only use this command if /auto_patch fails."""
+        if isinstance(self.ctx, UndertaleContext):
+            os.makedirs(name=os.path.join(os.getcwd(), "Undertale"), exist_ok=True)
+            self.ctx.patch_game()
+            self.output("Patched.")
+
+    def _cmd_savepath(self, directory: str):
+        """Redirect to proper save data folder. This is necessary for Linux users to use before connecting."""
+        if isinstance(self.ctx, UndertaleContext):
+            self.ctx.save_game_folder = directory
+            self.output("Changed to the following directory: " + self.ctx.save_game_folder)
+
+    @mark_raw
+    def _cmd_auto_patch(self, steaminstall: typing.Optional[str] = None):
+        """Patch the game automatically."""
+        if isinstance(self.ctx, UndertaleContext):
+            os.makedirs(name=os.path.join(os.getcwd(), "Undertale"), exist_ok=True)
+            tempInstall = steaminstall
+            if not os.path.isfile(os.path.join(tempInstall, "data.win")):
+                tempInstall = None
+            if tempInstall is None:
+                tempInstall = "C:\\Program Files (x86)\\Steam\\steamapps\\common\\Undertale"
+                if not os.path.exists(tempInstall):
+                    tempInstall = "C:\\Program Files\\Steam\\steamapps\\common\\Undertale"
+            elif not os.path.exists(tempInstall):
+                tempInstall = "C:\\Program Files (x86)\\Steam\\steamapps\\common\\Undertale"
+                if not os.path.exists(tempInstall):
+                    tempInstall = "C:\\Program Files\\Steam\\steamapps\\common\\Undertale"
+            if not os.path.exists(tempInstall) or not os.path.exists(tempInstall) or not os.path.isfile(os.path.join(tempInstall, "data.win")):
+                self.output("ERROR: Cannot find Undertale. Please rerun the command with the correct folder."
+                            " command. \"/auto_patch (Steam directory)\".")
+            else:
+                for file_name in os.listdir(tempInstall):
+                    if file_name != "steam_api.dll":
+                        shutil.copy(os.path.join(tempInstall, file_name),
+                               os.path.join(os.getcwd(), "Undertale", file_name))
+                self.ctx.patch_game()
+                self.output("Patching successful!")
+
+    def _cmd_online(self):
+        """Toggles seeing other Undertale players."""
+        if isinstance(self.ctx, UndertaleContext):
+            self.ctx.update_online_mode(not ("Online" in self.ctx.tags))
+            if "Online" in self.ctx.tags:
+                self.output(f"Now online.")
+            else:
+                self.output(f"Now offline.")
+
+    def _cmd_deathlink(self):
+        """Toggles deathlink"""
+        if isinstance(self.ctx, UndertaleContext):
+            self.ctx.deathlink_status = not self.ctx.deathlink_status
+            if self.ctx.deathlink_status:
+                self.output(f"Deathlink enabled.")
+            else:
+                self.output(f"Deathlink disabled.")
+
+
+class UndertaleContext(CommonContext):
+    tags = {"AP", "Online"}
+    game = "Undertale"
+    command_processor = UndertaleCommandProcessor
+    items_handling = 0b111
+    route = None
+    pieces_needed = None
+    completed_routes = None
+    completed_count = 0
+    save_game_folder = os.path.expandvars(r"%localappdata%/UNDERTALE")
+
+    def __init__(self, server_address, password):
+        super().__init__(server_address, password)
+        self.pieces_needed = 0
+        self.finished_game = False
+        self.game = "Undertale"
+        self.got_deathlink = False
+        self.syncing = False
+        self.deathlink_status = False
+        self.tem_armor = False
+        self.completed_count = 0
+        self.completed_routes = {"pacifist": 0, "genocide": 0, "neutral": 0}
+        # self.save_game_folder: files go in this path to pass data between us and the actual game
+        self.save_game_folder = os.path.expandvars(r"%localappdata%/UNDERTALE")
+
+    def patch_game(self):
+        with open(os.path.join(os.getcwd(), "Undertale", "data.win"), "rb") as f:
+            patchedFile = bsdiff4.patch(f.read(), undertale.data_path("patch.bsdiff"))
+        with open(os.path.join(os.getcwd(), "Undertale", "data.win"), "wb") as f:
+            f.write(patchedFile)
+        os.makedirs(name=os.path.join(os.getcwd(), "Undertale", "Custom Sprites"), exist_ok=True)
+        with open(os.path.expandvars(os.path.join(os.getcwd(), "Undertale", "Custom Sprites",
+                                     "Which Character.txt")), "w") as f:
+            f.writelines(["// Put the folder name of the sprites you want to play as, make sure it is the only "
+                          "line other than this one.\n", "frisk"])
+            f.close()
+
+    async def server_auth(self, password_requested: bool = False):
+        if password_requested and not self.password:
+            await super().server_auth(password_requested)
+        await self.get_username()
+        await self.send_connect()
+
+    def clear_undertale_files(self):
+        path = self.save_game_folder
+        self.finished_game = False
+        for root, dirs, files in os.walk(path):
+            for file in files:
+                if "check.spot" == file or "scout" == file:
+                    os.remove(os.path.join(root, file))
+                elif file.endswith((".item", ".victory", ".route", ".playerspot", ".mad", 
+                                            ".youDied", ".LV", ".mine", ".flag", ".hint")):
+                    os.remove(os.path.join(root, file))
+
+    async def connect(self, address: typing.Optional[str] = None):
+        self.clear_undertale_files()
+        await super().connect(address)
+
+    async def disconnect(self, allow_autoreconnect: bool = False):
+        self.clear_undertale_files()
+        await super().disconnect(allow_autoreconnect)
+
+    async def connection_closed(self):
+        self.clear_undertale_files()
+        await super().connection_closed()
+
+    async def shutdown(self):
+        self.clear_undertale_files()
+        await super().shutdown()
+
+    def update_online_mode(self, online):
+        old_tags = self.tags.copy()
+        if online:
+            self.tags.add("Online")
+        else:
+            self.tags -= {"Online"}
+        if old_tags != self.tags and self.server and not self.server.socket.closed:
+            async_start(self.send_msgs([{"cmd": "ConnectUpdate", "tags": self.tags}]))
+
+    def on_package(self, cmd: str, args: dict):
+        if cmd == "Connected":
+            self.game = self.slot_info[self.slot].game
+        async_start(process_undertale_cmd(self, cmd, args))
+
+    def run_gui(self):
+        from kvui import GameManager
+
+        class UTManager(GameManager):
+            logging_pairs = [
+                ("Client", "Archipelago")
+            ]
+            base_title = "Archipelago Undertale Client"
+
+        self.ui = UTManager(self)
+        self.ui_task = asyncio.create_task(self.ui.async_run(), name="UI")
+
+    def on_deathlink(self, data: typing.Dict[str, typing.Any]):
+        self.got_deathlink = True
+        super().on_deathlink(data)
+
+
+def to_room_name(place_name: str):
+    if place_name == "Old Home Exit":
+        return "room_ruinsexit"
+    elif place_name == "Snowdin Forest":
+        return "room_tundra1"
+    elif place_name == "Snowdin Town Exit":
+        return "room_fogroom"
+    elif place_name == "Waterfall":
+        return "room_water1"
+    elif place_name == "Waterfall Exit":
+        return "room_fire2"
+    elif place_name == "Hotland":
+        return "room_fire_prelab"
+    elif place_name == "Hotland Exit":
+        return "room_fire_precore"
+    elif place_name == "Core":
+        return "room_fire_core1"
+
+
+async def process_undertale_cmd(ctx: UndertaleContext, cmd: str, args: dict):
+    if cmd == "Connected":
+        if not os.path.exists(ctx.save_game_folder):
+            os.mkdir(ctx.save_game_folder)
+        ctx.route = args["slot_data"]["route"]
+        ctx.pieces_needed = args["slot_data"]["key_pieces"]
+        ctx.tem_armor = args["slot_data"]["temy_armor_include"]
+
+        await ctx.send_msgs([{"cmd": "Get", "keys": [str(ctx.slot)+" RoutesDone neutral",
+                                                     str(ctx.slot)+" RoutesDone pacifist",
+                                                     str(ctx.slot)+" RoutesDone genocide"]}])
+        await ctx.send_msgs([{"cmd": "SetNotify", "keys": [str(ctx.slot)+" RoutesDone neutral",
+                                                           str(ctx.slot)+" RoutesDone pacifist",
+                                                           str(ctx.slot)+" RoutesDone genocide"]}])
+        if args["slot_data"]["only_flakes"]:
+            with open(os.path.join(ctx.save_game_folder, "GenoNoChest.flag"), "w") as f:
+                f.close()
+        if not args["slot_data"]["key_hunt"]:
+            ctx.pieces_needed = 0
+        if args["slot_data"]["rando_love"]:
+            filename = f"LOVErando.LV"
+            with open(os.path.join(ctx.save_game_folder, filename), "w") as f:
+                f.close()
+        if args["slot_data"]["rando_stats"]:
+            filename = f"STATrando.LV"
+            with open(os.path.join(ctx.save_game_folder, filename), "w") as f:
+                f.close()
+        filename = f"{ctx.route}.route"
+        with open(os.path.join(ctx.save_game_folder, filename), "w") as f:
+            f.close()
+        filename = f"check.spot"
+        with open(os.path.join(ctx.save_game_folder, filename), "a") as f:
+            for ss in set(args["checked_locations"]):
+                f.write(str(ss-12000)+"\n")
+            f.close()
+    elif cmd == "LocationInfo":
+        for l in args["locations"]:
+            locationid = l.location
+            filename = f"{str(locationid-12000)}.hint"
+            with open(os.path.join(ctx.save_game_folder, filename), "w") as f:
+                toDraw = ""
+                for i in range(20):
+                    if i < len(str(ctx.item_names[l.item])):
+                        toDraw += str(ctx.item_names[l.item])[i]
+                    else:
+                        break
+                f.write(toDraw)
+                f.close()
+    elif cmd == "Retrieved":
+        if str(ctx.slot)+" RoutesDone neutral" in args["keys"]:
+            if args["keys"][str(ctx.slot)+" RoutesDone neutral"] is not None:
+                ctx.completed_routes["neutral"] = args["keys"][str(ctx.slot)+" RoutesDone neutral"]
+        if str(ctx.slot)+" RoutesDone genocide" in args["keys"]:
+            if args["keys"][str(ctx.slot)+" RoutesDone genocide"] is not None:
+                ctx.completed_routes["genocide"] = args["keys"][str(ctx.slot)+" RoutesDone genocide"]
+        if str(ctx.slot)+" RoutesDone pacifist" in args["keys"]:
+            if args["keys"][str(ctx.slot) + " RoutesDone pacifist"] is not None:
+                ctx.completed_routes["pacifist"] = args["keys"][str(ctx.slot)+" RoutesDone pacifist"]
+    elif cmd == "SetReply":
+        if args["value"] is not None:
+            if str(ctx.slot)+" RoutesDone pacifist" == args["key"]:
+                ctx.completed_routes["pacifist"] = args["value"]
+            elif str(ctx.slot)+" RoutesDone genocide" == args["key"]:
+                ctx.completed_routes["genocide"] = args["value"]
+            elif str(ctx.slot)+" RoutesDone neutral" == args["key"]:
+                ctx.completed_routes["neutral"] = args["value"]
+    elif cmd == "ReceivedItems":
+        start_index = args["index"]
+
+        if start_index == 0:
+            ctx.items_received = []
+        elif start_index != len(ctx.items_received):
+            sync_msg = [{"cmd": "Sync"}]
+            if ctx.locations_checked:
+                sync_msg.append({"cmd": "LocationChecks",
+                                 "locations": list(ctx.locations_checked)})
+            await ctx.send_msgs(sync_msg)
+        if start_index == len(ctx.items_received):
+            counter = -1
+            placedWeapon = 0
+            placedArmor = 0
+            for item in args["items"]:
+                id = NetworkItem(*item).location
+                while NetworkItem(*item).location < 0 and \
+                        counter <= id:
+                    id -= 1
+                if NetworkItem(*item).location < 0:
+                    counter -= 1
+                filename = f"{str(id)}PLR{str(NetworkItem(*item).player)}.item"
+                with open(os.path.join(ctx.save_game_folder, filename), "w") as f:
+                    if NetworkItem(*item).item == 77701:
+                        if placedWeapon == 0:
+                            f.write(str(77013-11000))
+                        elif placedWeapon == 1:
+                            f.write(str(77014-11000))
+                        elif placedWeapon == 2:
+                            f.write(str(77025-11000))
+                        elif placedWeapon == 3:
+                            f.write(str(77045-11000))
+                        elif placedWeapon == 4:
+                            f.write(str(77049-11000))
+                        elif placedWeapon == 5:
+                            f.write(str(77047-11000))
+                        elif placedWeapon == 6:
+                            if str(ctx.route) == "genocide" or str(ctx.route) == "all_routes":
+                                f.write(str(77052-11000))
+                            else:
+                                f.write(str(77051-11000))
+                        else:
+                            f.write(str(77003-11000))
+                        placedWeapon += 1
+                    elif NetworkItem(*item).item == 77702:
+                        if placedArmor == 0:
+                            f.write(str(77012-11000))
+                        elif placedArmor == 1:
+                            f.write(str(77015-11000))
+                        elif placedArmor == 2:
+                            f.write(str(77024-11000))
+                        elif placedArmor == 3:
+                            f.write(str(77044-11000))
+                        elif placedArmor == 4:
+                            f.write(str(77048-11000))
+                        elif placedArmor == 5:
+                            if str(ctx.route) == "genocide":
+                                f.write(str(77053-11000))
+                            else:
+                                f.write(str(77046-11000))
+                        elif placedArmor == 6 and ((not str(ctx.route) == "genocide") or ctx.tem_armor):
+                            if str(ctx.route) == "all_routes":
+                                f.write(str(77053-11000))
+                            elif str(ctx.route) == "genocide":
+                                f.write(str(77064-11000))
+                            else:
+                                f.write(str(77050-11000))
+                        elif placedArmor == 7 and ctx.tem_armor and not str(ctx.route) == "genocide":
+                            f.write(str(77064-11000))
+                        else:
+                            f.write(str(77004-11000))
+                        placedArmor += 1
+                    else:
+                        f.write(str(NetworkItem(*item).item-11000))
+                    f.close()
+                ctx.items_received.append(NetworkItem(*item))
+                if [item.item for item in ctx.items_received].count(77000) >= ctx.pieces_needed > 0:
+                    filename = f"{str(-99999)}PLR{str(0)}.item"
+                    with open(os.path.join(ctx.save_game_folder, filename), "w") as f:
+                        f.write(str(77787 - 11000))
+                        f.close()
+                    filename = f"{str(-99998)}PLR{str(0)}.item"
+                    with open(os.path.join(ctx.save_game_folder, filename), "w") as f:
+                        f.write(str(77789 - 11000))
+                        f.close()
+        ctx.watcher_event.set()
+
+    elif cmd == "RoomUpdate":
+        if "checked_locations" in args:
+            filename = f"check.spot"
+            with open(os.path.join(ctx.save_game_folder, filename), "a") as f:
+                for ss in set(args["checked_locations"]):
+                    f.write(str(ss-12000)+"\n")
+                f.close()
+
+    elif cmd == "Bounced":
+        tags = args.get("tags", [])
+        if "Online" in tags:
+            data = args.get("data", {})
+            if data["player"] != ctx.slot and data["player"] is not None:
+                filename = f"FRISK" + str(data["player"]) + ".playerspot"
+                with open(os.path.join(ctx.save_game_folder, filename), "w") as f:
+                    f.write(str(data["x"]) + str(data["y"]) + str(data["room"]) + str(
+                        data["spr"]) + str(data["frm"]))
+                    f.close()
+
+
+async def multi_watcher(ctx: UndertaleContext):
+    while not ctx.exit_event.is_set():
+        path = ctx.save_game_folder
+        for root, dirs, files in os.walk(path):
+            for file in files:
+                if "spots.mine" in file and "Online" in ctx.tags:
+                    with open(os.path.join(root, file), "r") as mine:
+                        this_x = mine.readline()
+                        this_y = mine.readline()
+                        this_room = mine.readline()
+                        this_sprite = mine.readline()
+                        this_frame = mine.readline()
+                        mine.close()
+                    message = [{"cmd": "Bounce", "tags": ["Online"],
+                                "data": {"player": ctx.slot, "x": this_x, "y": this_y, "room": this_room,
+                                         "spr": this_sprite, "frm": this_frame}}]
+                    await ctx.send_msgs(message)
+
+        await asyncio.sleep(0.1)
+
+
+async def game_watcher(ctx: UndertaleContext):
+    while not ctx.exit_event.is_set():
+        await ctx.update_death_link(ctx.deathlink_status)
+        path = ctx.save_game_folder
+        if ctx.syncing:
+            for root, dirs, files in os.walk(path):
+                for file in files:
+                    if ".item" in file:
+                        os.remove(os.path.join(root, file))
+            sync_msg = [{"cmd": "Sync"}]
+            if ctx.locations_checked:
+                sync_msg.append({"cmd": "LocationChecks", "locations": list(ctx.locations_checked)})
+            await ctx.send_msgs(sync_msg)
+            ctx.syncing = False
+        if ctx.got_deathlink:
+            ctx.got_deathlink = False
+            with open(os.path.join(ctx.save_game_folder, "WelcomeToTheDead.youDied"), "w") as f:
+                f.close()
+        sending = []
+        victory = False
+        found_routes = 0
+        for root, dirs, files in os.walk(path):
+            for file in files:
+                if "DontBeMad.mad" in file:
+                    os.remove(os.path.join(root, file))
+                    if "DeathLink" in ctx.tags:
+                        await ctx.send_death()
+                if "scout" == file:
+                    sending = []
+                    try:
+                        with open(os.path.join(root, file), "r") as f:
+                            lines = f.readlines()
+                        for l in lines:
+                            if ctx.server_locations.__contains__(int(l)+12000):
+                                sending = sending + [int(l.rstrip('\n'))+12000]
+                    finally:
+                        await ctx.send_msgs([{"cmd": "LocationScouts", "locations": sending,
+                                                          "create_as_hint": int(2)}])
+                        os.remove(os.path.join(root, file))
+                if "check.spot" in file:
+                    sending = []
+                    try:
+                        with open(os.path.join(root, file), "r") as f:
+                            lines = f.readlines()
+                        for l in lines:
+                            sending = sending+[(int(l.rstrip('\n')))+12000]
+                    finally:
+                        await ctx.send_msgs([{"cmd": "LocationChecks", "locations": sending}])
+                if "victory" in file and str(ctx.route) in file:
+                    victory = True
+                if ".playerspot" in file and "Online" not in ctx.tags:
+                    os.remove(os.path.join(root, file))
+                if "victory" in file:
+                    if str(ctx.route) == "all_routes":
+                        if "neutral" in file and ctx.completed_routes["neutral"] != 1:
+                            await ctx.send_msgs([{"cmd": "Set", "key": str(ctx.slot)+" RoutesDone neutral",
+                                                  "default": 0, "want_reply": True, "operations": [{"operation": "max",
+                                                                                                    "value": 1}]}])
+                        elif "pacifist" in file and ctx.completed_routes["pacifist"] != 1:
+                            await ctx.send_msgs([{"cmd": "Set", "key": str(ctx.slot)+" RoutesDone pacifist",
+                                                  "default": 0, "want_reply": True, "operations": [{"operation": "max",
+                                                                                                    "value": 1}]}])
+                        elif "genocide" in file and ctx.completed_routes["genocide"] != 1:
+                            await ctx.send_msgs([{"cmd": "Set", "key": str(ctx.slot)+" RoutesDone genocide",
+                                                  "default": 0, "want_reply": True, "operations": [{"operation": "max",
+                                                                                                    "value": 1}]}])
+        if str(ctx.route) == "all_routes":
+            found_routes += ctx.completed_routes["neutral"]
+            found_routes += ctx.completed_routes["pacifist"]
+            found_routes += ctx.completed_routes["genocide"]
+        if str(ctx.route) == "all_routes" and found_routes >= 3:
+            victory = True
+        ctx.locations_checked = sending
+        if (not ctx.finished_game) and victory:
+            await ctx.send_msgs([{"cmd": "StatusUpdate", "status": ClientStatus.CLIENT_GOAL}])
+            ctx.finished_game = True
+        await asyncio.sleep(0.1)
+
+
+def main():
+    Utils.init_logging("UndertaleClient", exception_logger="Client")
+
+    async def _main():
+        ctx = UndertaleContext(None, None)
+        ctx.server_task = asyncio.create_task(server_loop(ctx), name="server loop")
+        asyncio.create_task(
+            game_watcher(ctx), name="UndertaleProgressionWatcher")
+
+        asyncio.create_task(
+            multi_watcher(ctx), name="UndertaleMultiplayerWatcher")
+
+        if gui_enabled:
+            ctx.run_gui()
+        ctx.run_cli()
+
+        await ctx.exit_event.wait()
+        await ctx.shutdown()
+
+    import colorama
+
+    colorama.init()
+
+    asyncio.run(_main())
+    colorama.deinit()
+
+
+if __name__ == "__main__":
+    parser = get_base_parser(description="Undertale Client, for text interfacing.")
+    args = parser.parse_args()
+    main()

Utils.py

@@ -5,6 +5,7 @@ import json
 import typing
 import builtins
 import os
+import itertools
 import subprocess
 import sys
 import pickle
@@ -13,20 +14,23 @@ import io
 import collections
 import importlib
 import logging
-from typing import BinaryIO, Coroutine, Optional, Set, Dict, Any, Union
+import warnings
 
-from yaml import load, load_all, dump, SafeLoader
+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
 
 try:
-    from yaml import CLoader as UnsafeLoader
-    from yaml import CDumper as Dumper
+    from yaml import CLoader as UnsafeLoader, CSafeLoader as SafeLoader, CDumper as Dumper
 except ImportError:
-    from yaml import Loader as UnsafeLoader
-    from yaml import Dumper
+    from yaml import Loader as UnsafeLoader, SafeLoader, Dumper
 
 if typing.TYPE_CHECKING:
     import tkinter
     import pathlib
+    from BaseClasses import Region
 
 
 def tuplize_version(version: str) -> Version:
@@ -38,8 +42,11 @@ class Version(typing.NamedTuple):
     minor: int
     build: int
 
+    def as_simple_string(self) -> str:
+        return ".".join(str(item) for item in self)
 
-__version__ = "0.4.0"
+
+__version__ = "0.4.5"
 version_tuple = tuplize_version(__version__)
 
 is_linux = sys.platform.startswith("linux")
@@ -66,6 +73,8 @@ def snes_to_pc(value: int) -> int:
 
 
 RetType = typing.TypeVar("RetType")
+S = typing.TypeVar("S")
+T = typing.TypeVar("T")
 
 
 def cache_argsless(function: typing.Callable[[], RetType]) -> typing.Callable[[], RetType]:
@@ -83,6 +92,31 @@ def cache_argsless(function: typing.Callable[[], RetType]) -> typing.Callable[[]
     return _wrap
 
 
+def cache_self1(function: typing.Callable[[S, T], RetType]) -> typing.Callable[[S, T], RetType]:
+    """Specialized cache for self + 1 arg. Does not keep global ref to self and skips building a dict key tuple."""
+
+    assert function.__code__.co_argcount == 2, "Can only cache 2 argument functions with this cache."
+
+    cache_name = f"__cache_{function.__name__}__"
+
+    @functools.wraps(function)
+    def wrap(self: S, arg: T) -> RetType:
+        cache: Optional[Dict[T, RetType]] = typing.cast(Optional[Dict[T, RetType]],
+                                                        getattr(self, cache_name, None))
+        if cache is None:
+            res = function(self, arg)
+            setattr(self, cache_name, {arg: res})
+            return res
+        try:
+            return cache[arg]
+        except KeyError:
+            res = function(self, arg)
+            cache[arg] = res
+            return res
+
+    return wrap
+
+
 def is_frozen() -> bool:
     return typing.cast(bool, getattr(sys, 'frozen', False))
 
@@ -135,13 +169,20 @@ def user_path(*path: str) -> str:
         user_path.cached_path = local_path()
     else:
         user_path.cached_path = home_path()
-        # populate home from local - TODO: upgrade feature
-        if user_path.cached_path != local_path() and not os.path.exists(user_path("host.yaml")):
-            import shutil
-            for dn in ("Players", "data/sprites"):
-                shutil.copytree(local_path(dn), user_path(dn), dirs_exist_ok=True)
-            for fn in ("manifest.json", "host.yaml"):
-                shutil.copy2(local_path(fn), user_path(fn))
+        # populate home from local
+        if user_path.cached_path != local_path():
+            import filecmp
+            if not os.path.exists(user_path("manifest.json")) or \
+                    not os.path.exists(local_path("manifest.json")) or \
+                    not filecmp.cmp(local_path("manifest.json"), user_path("manifest.json"), shallow=True):
+                import shutil
+                for dn in ("Players", "data/sprites", "data/lua"):
+                    shutil.copytree(local_path(dn), user_path(dn), dirs_exist_ok=True)
+                if not os.path.exists(local_path("manifest.json")):
+                    warnings.warn(f"Upgrading {user_path()} from something that is not a proper install")
+                else:
+                    shutil.copy2(local_path("manifest.json"), user_path("manifest.json"))
+            os.makedirs(user_path("worlds"), exist_ok=True)
 
     return os.path.join(user_path.cached_path, *path)
 
@@ -184,6 +225,9 @@ 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)
 
@@ -207,7 +251,13 @@ def get_cert_none_ssl_context():
 def get_public_ipv4() -> str:
     import socket
     import urllib.request
-    ip = socket.gethostbyname(socket.gethostname())
+    try:
+        ip = socket.gethostbyname(socket.gethostname())
+    except socket.gaierror:
+        # if hostname or resolvconf is not set up properly, this may fail
+        warnings.warn("Could not resolve own hostname, falling back to 127.0.0.1")
+        ip = "127.0.0.1"
+
     ctx = get_cert_none_ssl_context()
     try:
         ip = urllib.request.urlopen("https://checkip.amazonaws.com/", context=ctx, timeout=10).read().decode("utf8").strip()
@@ -225,7 +275,13 @@ def get_public_ipv4() -> str:
 def get_public_ipv6() -> str:
     import socket
     import urllib.request
-    ip = socket.gethostbyname(socket.gethostname())
+    try:
+        ip = socket.gethostbyname(socket.gethostname())
+    except socket.gaierror:
+        # if hostname or resolvconf is not set up properly, this may fail
+        warnings.warn("Could not resolve own hostname, falling back to ::1")
+        ip = "::1"
+
     ctx = get_cert_none_ssl_context()
     try:
         ip = urllib.request.urlopen("https://v6.ident.me", context=ctx, timeout=10).read().decode("utf8").strip()
@@ -235,151 +291,13 @@ def get_public_ipv6() -> str:
     return ip
 
 
-OptionsType = typing.Dict[str, typing.Dict[str, typing.Any]]
+OptionsType = Settings  # TODO: remove when removing get_options
 
 
-@cache_argsless
-def get_default_options() -> OptionsType:
-    # Refer to host.yaml for comments as to what all these options mean.
-    options = {
-        "general_options": {
-            "output_path": "output",
-        },
-        "factorio_options": {
-            "executable": os.path.join("factorio", "bin", "x64", "factorio"),
-            "filter_item_sends": False,
-            "bridge_chat_out": True,
-        },
-        "sni_options": {
-            "sni_path": "SNI",
-            "snes_rom_start": True,
-        },
-        "sm_options": {
-            "rom_file": "Super Metroid (JU).sfc",
-        },
-        "soe_options": {
-            "rom_file": "Secret of Evermore (USA).sfc",
-        },
-        "lttp_options": {
-            "rom_file": "Zelda no Densetsu - Kamigami no Triforce (Japan).sfc",
-        },
-        "ladx_options": {
-            "rom_file": "Legend of Zelda, The - Link's Awakening DX (USA, Europe) (SGB Enhanced).gbc",
-        },
-        "server_options": {
-            "host": None,
-            "port": 38281,
-            "password": None,
-            "multidata": None,
-            "savefile": None,
-            "disable_save": False,
-            "loglevel": "info",
-            "server_password": None,
-            "disable_item_cheat": False,
-            "location_check_points": 1,
-            "hint_cost": 10,
-            "release_mode": "goal",
-            "collect_mode": "disabled",
-            "remaining_mode": "goal",
-            "auto_shutdown": 0,
-            "compatibility": 2,
-            "log_network": 0
-        },
-        "generator": {
-            "enemizer_path": os.path.join("EnemizerCLI", "EnemizerCLI.Core"),
-            "player_files_path": "Players",
-            "players": 0,
-            "weights_file_path": "weights.yaml",
-            "meta_file_path": "meta.yaml",
-            "spoiler": 3,
-            "glitch_triforce_room": 1,
-            "race": 0,
-            "plando_options": "bosses",
-        },
-        "minecraft_options": {
-            "forge_directory": "Minecraft Forge server",
-            "max_heap_size": "2G",
-            "release_channel": "release"
-        },
-        "oot_options": {
-            "rom_file": "The Legend of Zelda - Ocarina of Time.z64",
-            "rom_start": True
-        },
-        "dkc3_options": {
-            "rom_file": "Donkey Kong Country 3 - Dixie Kong's Double Trouble! (USA) (En,Fr).sfc",
-        },
-        "smw_options": {
-            "rom_file": "Super Mario World (USA).sfc",
-        },
-        "zillion_options": {
-            "rom_file": "Zillion (UE) [!].sms",
-            # RetroArch doesn't make it easy to launch a game from the command line.
-            # You have to know the path to the emulator core library on the user's computer.
-            "rom_start": "retroarch",
-        },
-        "pokemon_rb_options": {
-            "red_rom_file": "Pokemon Red (UE) [S][!].gb",
-            "blue_rom_file": "Pokemon Blue (UE) [S][!].gb",
-            "rom_start": True
-        },
-        "ffr_options": {
-            "display_msgs": True,
-        },
-        "lufia2ac_options": {
-            "rom_file": "Lufia II - Rise of the Sinistrals (USA).sfc",
-        },
-        "tloz_options": {
-            "rom_file": "Legend of Zelda, The (U) (PRG0) [!].nes",
-            "rom_start": True,
-            "display_msgs": True,
-        },
-        "wargroove_options": {
-            "root_directory": "C:/Program Files (x86)/Steam/steamapps/common/Wargroove"
-        },
-        "adventure_options": {
-            "rom_file": "ADVNTURE.BIN",
-            "display_msgs": True,
-            "rom_start": True,
-            "rom_args": ""
-        },
-    }
-    return options
-
-
-def update_options(src: dict, dest: dict, filename: str, keys: list) -> OptionsType:
-    for key, value in src.items():
-        new_keys = keys.copy()
-        new_keys.append(key)
-        option_name = '.'.join(new_keys)
-        if key not in dest:
-            dest[key] = value
-            if filename.endswith("options.yaml"):
-                logging.info(f"Warning: {filename} is missing {option_name}")
-        elif isinstance(value, dict):
-            if not isinstance(dest.get(key, None), dict):
-                if filename.endswith("options.yaml"):
-                    logging.info(f"Warning: {filename} has {option_name}, but it is not a dictionary. overwriting.")
-                dest[key] = value
-            else:
-                dest[key] = update_options(value, dest[key], filename, new_keys)
-    return dest
-
-
-@cache_argsless
-def get_options() -> OptionsType:
-    filenames = ("options.yaml", "host.yaml")
-    locations: typing.List[str] = []
-    if os.path.join(os.getcwd()) != local_path():
-        locations += filenames  # use files from cwd only if it's not the local_path
-    locations += [user_path(filename) for filename in filenames]
-
-    for location in locations:
-        if os.path.exists(location):
-            with open(location) as f:
-                options = parse_yaml(f.read())
-            return update_options(get_default_options(), options, location, list())
-
-    raise FileNotFoundError(f"Could not find {filenames[1]} to load options.")
+def get_options() -> Settings:
+    # TODO: switch to Utils.deprecate after 0.4.4
+    warnings.warn("Utils.get_options() is deprecated. Use the settings API instead.", DeprecationWarning)
+    return get_settings()
 
 
 def persistent_store(category: str, key: typing.Any, value: typing.Any):
@@ -447,12 +365,27 @@ def store_data_package_for_checksum(game: str, data: typing.Dict[str, Any]) -> N
         except Exception as e:
             logging.debug(f"Could not store data package: {e}")
 
+def get_default_adjuster_settings(game_name: str) -> Namespace:
+    import LttPAdjuster
+    adjuster_settings = Namespace()
+    if game_name == LttPAdjuster.GAME_ALTTP:
+        return LttPAdjuster.get_argparser().parse_known_args(args=[])[0]
 
-def get_adjuster_settings(game_name: str) -> typing.Dict[str, typing.Any]:
-    adjuster_settings = persistent_load().get("adjuster", {}).get(game_name, {})
     return adjuster_settings
 
 
+def get_adjuster_settings_no_defaults(game_name: str) -> Namespace:
+    return persistent_load().get("adjuster", {}).get(game_name, Namespace())
+
+
+def get_adjuster_settings(game_name: str) -> Namespace:
+    adjuster_settings = get_adjuster_settings_no_defaults(game_name)
+    default_settings = get_default_adjuster_settings(game_name)
+
+    # Fill in any arguments from the argparser that we haven't seen before
+    return Namespace(**vars(adjuster_settings), **{k:v for k,v in vars(default_settings).items() if k not in vars(adjuster_settings)})
+
+
 @cache_argsless
 def get_unique_identifier():
     uuid = persistent_load().get("client", {}).get("uuid", None)
@@ -472,11 +405,13 @@ safe_builtins = frozenset((
 
 
 class RestrictedUnpickler(pickle.Unpickler):
+    generic_properties_module: Optional[object]
+
     def __init__(self, *args, **kwargs):
         super(RestrictedUnpickler, self).__init__(*args, **kwargs)
         self.options_module = importlib.import_module("Options")
         self.net_utils_module = importlib.import_module("NetUtils")
-        self.generic_properties_module = importlib.import_module("worlds.generic")
+        self.generic_properties_module = None
 
     def find_class(self, module, name):
         if module == "builtins" and name in safe_builtins:
@@ -486,6 +421,8 @@ class RestrictedUnpickler(pickle.Unpickler):
             return getattr(self.net_utils_module, name)
         # Options and Plando are unpickled by WebHost -> Generate
         if module == "worlds.generic" and name in {"PlandoItem", "PlandoConnection"}:
+            if not self.generic_properties_module:
+                self.generic_properties_module = importlib.import_module("worlds.generic")
             return getattr(self.generic_properties_module, name)
         # pep 8 specifies that modules should have "all-lowercase names" (options, not Options)
         if module.lower().endswith("options"):
@@ -505,6 +442,15 @@ def restricted_loads(s):
     return RestrictedUnpickler(io.BytesIO(s)).load()
 
 
+class ByValue:
+    """
+    Mixin for enums to pickle value instead of name (restores pre-3.11 behavior). Use as left-most parent.
+    See https://github.com/python/cpython/pull/26658 for why this exists.
+    """
+    def __reduce_ex__(self, prot):
+        return self.__class__, (self._value_, )
+
+
 class KeyedDefaultDict(collections.defaultdict):
     """defaultdict variant that uses the missing key as argument to default_factory"""
     default_factory: typing.Callable[[typing.Any], typing.Any]
@@ -537,6 +483,7 @@ def init_logging(name: str, loglevel: typing.Union[str, int] = logging.INFO, wri
         root_logger.removeHandler(handler)
         handler.close()
     root_logger.setLevel(loglevel)
+    logging.getLogger("websockets").setLevel(loglevel)  # make sure level is applied for websockets
     if "a" not in write_mode:
         name += f"_{datetime.datetime.now().strftime('%Y_%m_%d_%H_%M_%S')}"
     file_handler = logging.FileHandler(
@@ -544,11 +491,21 @@ def init_logging(name: str, loglevel: typing.Union[str, int] = logging.INFO, wri
         write_mode,
         encoding="utf-8-sig")
     file_handler.setFormatter(logging.Formatter(log_format))
+
+    class Filter(logging.Filter):
+        def __init__(self, filter_name, condition):
+            super().__init__(filter_name)
+            self.condition = condition
+
+        def filter(self, record: logging.LogRecord) -> bool:
+            return self.condition(record)
+
+    file_handler.addFilter(Filter("NoStream", lambda record: not getattr(record,  "NoFile", False)))
     root_logger.addHandler(file_handler)
     if sys.stdout:
-        root_logger.addHandler(
-            logging.StreamHandler(sys.stdout)
-        )
+        stream_handler = logging.StreamHandler(sys.stdout)
+        stream_handler.addFilter(Filter("NoFile", lambda record: not getattr(record, "NoStream", False)))
+        root_logger.addHandler(stream_handler)
 
     # Relay unhandled exceptions to logger.
     if not getattr(sys.excepthook, "_wrapped", False):  # skip if already modified
@@ -660,7 +617,7 @@ 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]]]) \
+def open_filename(title: str, filetypes: typing.Sequence[typing.Tuple[str, typing.Sequence[str]]], suggest: str = "") \
         -> typing.Optional[str]:
     def run(*args: str):
         return subprocess.run(args, capture_output=True, text=True).stdout.split("\n", 1)[0] or None
@@ -671,11 +628,12 @@ def open_filename(title: str, filetypes: typing.Sequence[typing.Tuple[str, typin
         kdialog = which("kdialog")
         if kdialog:
             k_filters = '|'.join((f'{text} (*{" *".join(ext)})' for (text, ext) in filetypes))
-            return run(kdialog, f"--title={title}", "--getopenfilename", ".", k_filters)
+            return run(kdialog, f"--title={title}", "--getopenfilename", suggest or ".", k_filters)
         zenity = which("zenity")
         if zenity:
             z_filters = (f'--file-filter={text} ({", ".join(ext)}) | *{" *".join(ext)}' for (text, ext) in filetypes)
-            return run(zenity, f"--title={title}", "--file-selection", *z_filters)
+            selection = (f"--filename={suggest}",) if suggest else ()
+            return run(zenity, f"--title={title}", "--file-selection", *z_filters, *selection)
 
     # fall back to tk
     try:
@@ -686,9 +644,47 @@ def open_filename(title: str, filetypes: typing.Sequence[typing.Tuple[str, typin
                       f'This attempt was made because open_filename was used for "{title}".')
         raise e
     else:
-        root = tkinter.Tk()
+        try:
+            root = tkinter.Tk()
+        except tkinter.TclError:
+            return None  # GUI not available. None is the same as a user clicking "cancel"
         root.withdraw()
-        return tkinter.filedialog.askopenfilename(title=title, filetypes=((t[0], ' '.join(t[1])) for t in filetypes))
+        return tkinter.filedialog.askopenfilename(title=title, filetypes=((t[0], ' '.join(t[1])) for t in filetypes),
+                                                  initialfile=suggest or None)
+
+
+def open_directory(title: str, suggest: str = "") -> typing.Optional[str]:
+    def run(*args: str):
+        return subprocess.run(args, capture_output=True, text=True).stdout.split("\n", 1)[0] or None
+
+    if is_linux:
+        # prefer native dialog
+        from shutil import which
+        kdialog = which("kdialog")
+        if kdialog:
+            return run(kdialog, f"--title={title}", "--getexistingdirectory",
+                       os.path.abspath(suggest) if suggest else ".")
+        zenity = which("zenity")
+        if zenity:
+            z_filters = ("--directory",)
+            selection = (f"--filename={os.path.abspath(suggest)}/",) if suggest else ()
+            return run(zenity, f"--title={title}", "--file-selection", *z_filters, *selection)
+
+    # fall back to tk
+    try:
+        import tkinter
+        import tkinter.filedialog
+    except Exception as e:
+        logging.error('Could not load tkinter, which is likely not installed. '
+                      f'This attempt was made because open_filename was used for "{title}".')
+        raise e
+    else:
+        try:
+            root = tkinter.Tk()
+        except tkinter.TclError:
+            return None  # GUI not available. None is the same as a user clicking "cancel"
+        root.withdraw()
+        return tkinter.filedialog.askdirectory(title=title, mustexist=True, initialdir=suggest or None)
 
 
 def messagebox(title: str, text: str, error: bool = False) -> None:
@@ -716,6 +712,11 @@ def messagebox(title: str, text: str, error: bool = False) -> None:
         if zenity:
             return run(zenity, f"--title={title}", f"--text={text}", "--error" if error else "--info")
 
+    elif is_windows:
+        import ctypes
+        style = 0x10 if error else 0x0
+        return ctypes.windll.user32.MessageBoxW(0, text, title, style)
+
     # fall back to tk
     try:
         import tkinter
@@ -753,10 +754,10 @@ def read_snes_rom(stream: BinaryIO, strip_header: bool = True) -> bytearray:
     return buffer
 
 
-_faf_tasks: "Set[asyncio.Task[None]]" = set()
+_faf_tasks: "Set[asyncio.Task[typing.Any]]" = set()
 
 
-def async_start(co: Coroutine[typing.Any, typing.Any, bool], name: Optional[str] = None) -> None:
+def async_start(co: Coroutine[None, None, typing.Any], name: Optional[str] = None) -> None:
     """
     Use this to start a task when you don't keep a reference to it or immediately await it,
     to prevent early garbage collection. "fire-and-forget"
@@ -769,6 +770,210 @@ def async_start(co: Coroutine[typing.Any, typing.Any, bool], name: Optional[str]
     # ```
     # This implementation follows the pattern given in that documentation.
 
-    task = asyncio.create_task(co, name=name)
+    task: asyncio.Task[typing.Any] = asyncio.create_task(co, name=name)
     _faf_tasks.add(task)
     task.add_done_callback(_faf_tasks.discard)
+
+
+def deprecate(message: str):
+    if __debug__:
+        raise Exception(message)
+    import warnings
+    warnings.warn(message)
+
+
+class DeprecateDict(dict):
+    log_message: str
+    should_error: bool
+
+    def __init__(self, message, error: bool = False) -> None:
+        self.log_message = message
+        self.should_error = error
+        super().__init__()
+
+    def __getitem__(self, item: Any) -> Any:
+        if self.should_error:
+            deprecate(self.log_message)
+        elif __debug__:
+            import warnings
+            warnings.warn(self.log_message)
+        return super().__getitem__(item)
+
+
+def _extend_freeze_support() -> None:
+    """Extend multiprocessing.freeze_support() to also work on Non-Windows for spawn."""
+    # upstream issue: https://github.com/python/cpython/issues/76327
+    # code based on https://github.com/pyinstaller/pyinstaller/blob/develop/PyInstaller/hooks/rthooks/pyi_rth_multiprocessing.py#L26
+    import multiprocessing
+    import multiprocessing.spawn
+
+    def _freeze_support() -> None:
+        """Minimal freeze_support. Only apply this if frozen."""
+        from subprocess import _args_from_interpreter_flags
+
+        # Prevent `spawn` from trying to read `__main__` in from the main script
+        multiprocessing.process.ORIGINAL_DIR = None
+
+        # Handle the first process that MP will create
+        if (
+            len(sys.argv) >= 2 and sys.argv[-2] == '-c' and sys.argv[-1].startswith((
+                'from multiprocessing.semaphore_tracker import main',  # Py<3.8
+                'from multiprocessing.resource_tracker import main',  # Py>=3.8
+                'from multiprocessing.forkserver import main'
+            )) and set(sys.argv[1:-2]) == set(_args_from_interpreter_flags())
+        ):
+            exec(sys.argv[-1])
+            sys.exit()
+
+        # Handle the second process that MP will create
+        if multiprocessing.spawn.is_forking(sys.argv):
+            kwargs = {}
+            for arg in sys.argv[2:]:
+                name, value = arg.split('=')
+                if value == 'None':
+                    kwargs[name] = None
+                else:
+                    kwargs[name] = int(value)
+            multiprocessing.spawn.spawn_main(**kwargs)
+            sys.exit()
+
+    if not is_windows and is_frozen():
+        multiprocessing.freeze_support = multiprocessing.spawn.freeze_support = _freeze_support
+
+
+def freeze_support() -> None:
+    """This behaves like multiprocessing.freeze_support but also works on Non-Windows."""
+    import multiprocessing
+    _extend_freeze_support()
+    multiprocessing.freeze_support()
+
+
+def visualize_regions(root_region: Region, file_name: str, *,
+                      show_entrance_names: bool = False, show_locations: bool = True, show_other_regions: bool = True,
+                      linetype_ortho: bool = True) -> None:
+    """Visualize the layout of a world as a PlantUML diagram.
+
+    :param root_region: The region from which to start the diagram from. (Usually the "Menu" region of your world.)
+    :param file_name: The name of the destination .puml file.
+    :param show_entrance_names: (default False) If enabled, the name of the entrance will be shown near each connection.
+    :param show_locations: (default True) If enabled, the locations will be listed inside each region.
+            Priority locations will be shown in bold.
+            Excluded locations will be stricken out.
+            Locations without ID will be shown in italics.
+            Locked locations will be shown with a padlock icon.
+            For filled locations, the item name will be shown after the location name.
+            Progression items will be shown in bold.
+            Items without ID will be shown in italics.
+    :param show_other_regions: (default True) If enabled, regions that can't be reached by traversing exits are shown.
+    :param linetype_ortho: (default True) If enabled, orthogonal straight line parts will be used; otherwise polylines.
+
+    Example usage in World code:
+    from Utils import visualize_regions
+    visualize_regions(self.multiworld.get_region("Menu", self.player), "my_world.puml")
+
+    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")
+    """
+    assert root_region.multiworld, "The multiworld attribute of root_region has to be filled"
+    from BaseClasses import Entrance, Item, Location, LocationProgressType, MultiWorld, Region
+    from collections import deque
+    import re
+
+    uml: typing.List[str] = list()
+    seen: typing.Set[Region] = set()
+    regions: typing.Deque[Region] = deque((root_region,))
+    multiworld: MultiWorld = root_region.multiworld
+
+    def fmt(obj: Union[Entrance, Item, Location, Region]) -> str:
+        name = obj.name
+        if isinstance(obj, Item):
+            name = multiworld.get_name_string_for_object(obj)
+            if obj.advancement:
+                name = f"**{name}**"
+            if obj.code is None:
+                name = f"//{name}//"
+        if isinstance(obj, Location):
+            if obj.progress_type == LocationProgressType.PRIORITY:
+                name = f"**{name}**"
+            elif obj.progress_type == LocationProgressType.EXCLUDED:
+                name = f"--{name}--"
+            if obj.address is None:
+                name = f"//{name}//"
+        return re.sub("[\".:]", "", name)
+
+    def visualize_exits(region: Region) -> None:
+        for exit_ in region.exits:
+            if exit_.connected_region:
+                if show_entrance_names:
+                    uml.append(f"\"{fmt(region)}\" --> \"{fmt(exit_.connected_region)}\" : \"{fmt(exit_)}\"")
+                else:
+                    try:
+                        uml.remove(f"\"{fmt(exit_.connected_region)}\" --> \"{fmt(region)}\"")
+                        uml.append(f"\"{fmt(exit_.connected_region)}\" <--> \"{fmt(region)}\"")
+                    except ValueError:
+                        uml.append(f"\"{fmt(region)}\" --> \"{fmt(exit_.connected_region)}\"")
+            else:
+                uml.append(f"circle \"unconnected exit:\\n{fmt(exit_)}\"")
+                uml.append(f"\"{fmt(region)}\" --> \"unconnected exit:\\n{fmt(exit_)}\"")
+
+    def visualize_locations(region: Region) -> None:
+        any_lock = any(location.locked for location in region.locations)
+        for location in region.locations:
+            lock = "<&lock-locked> " if location.locked else "<&lock-unlocked,color=transparent> " if any_lock else ""
+            if location.item:
+                uml.append(f"\"{fmt(region)}\" : {{method}} {lock}{fmt(location)}: {fmt(location.item)}")
+            else:
+                uml.append(f"\"{fmt(region)}\" : {{field}} {lock}{fmt(location)}")
+
+    def visualize_region(region: Region) -> None:
+        uml.append(f"class \"{fmt(region)}\"")
+        if show_locations:
+            visualize_locations(region)
+        visualize_exits(region)
+
+    def visualize_other_regions() -> None:
+        if other_regions := [region for region in multiworld.get_regions(root_region.player) if region not in seen]:
+            uml.append("package \"other regions\" <<Cloud>> {")
+            for region in other_regions:
+                uml.append(f"class \"{fmt(region)}\"")
+            uml.append("}")
+
+    uml.append("@startuml")
+    uml.append("hide circle")
+    uml.append("hide empty members")
+    if linetype_ortho:
+        uml.append("skinparam linetype ortho")
+    while regions:
+        if (current_region := regions.popleft()) not in seen:
+            seen.add(current_region)
+            visualize_region(current_region)
+            regions.extend(exit_.connected_region for exit_ in current_region.exits if exit_.connected_region)
+    if show_other_regions:
+        visualize_other_regions()
+    uml.append("@enduml")
+
+    with open(file_name, "wt", encoding="utf-8") as f:
+        f.write("\n".join(uml))
+
+
+class RepeatableChain:
+    def __init__(self, iterable: typing.Iterable):
+        self.iterable = iterable
+
+    def __iter__(self):
+        return itertools.chain.from_iterable(self.iterable)
+
+    def __bool__(self):
+        return any(sub_iterable for sub_iterable in self.iterable)
+
+    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)

WargrooveClient.py

@@ -113,6 +113,9 @@ class WargrooveContext(CommonContext):
     async def connection_closed(self):
         await super(WargrooveContext, self).connection_closed()
         self.remove_communication_files()
+        self.checked_locations.clear()
+        self.server_locations.clear()
+        self.finished_game = False
 
     @property
     def endpoints(self):
@@ -124,6 +127,9 @@ class WargrooveContext(CommonContext):
     async def shutdown(self):
         await super(WargrooveContext, self).shutdown()
         self.remove_communication_files()
+        self.checked_locations.clear()
+        self.server_locations.clear()
+        self.finished_game = False
 
     def remove_communication_files(self):
         for root, dirs, files in os.walk(self.game_communication_path):
@@ -402,8 +408,10 @@ async def game_watcher(ctx: WargrooveContext):
                 if file.find("send") > -1:
                     st = file.split("send", -1)[1]
                     sending = sending+[(int(st))]
+                    os.remove(os.path.join(ctx.game_communication_path, file))
                 if file.find("victory") > -1:
                     victory = True
+                    os.remove(os.path.join(ctx.game_communication_path, file))
         ctx.locations_checked = sending
         message = [{"cmd": 'LocationChecks', "locations": sending}]
         await ctx.send_msgs(message)

WebHost.py

@@ -10,23 +10,19 @@ ModuleUpdate.update()
 
 # in case app gets imported by something like gunicorn
 import Utils
+import settings
 
 Utils.local_path.cached_path = os.path.dirname(__file__) or "."  # py3.8 is not abs. remove "." when dropping 3.8
-
-from WebHostLib import register, app as raw_app
-from waitress import serve
-
-from WebHostLib.models import db
-from WebHostLib.autolauncher import autohost, autogen
-from WebHostLib.lttpsprites import update_sprites_lttp
-from WebHostLib.options import create as create_options_files
-
+settings.no_gui = True
 configpath = os.path.abspath("config.yaml")
 if not os.path.exists(configpath):  # fall back to config.yaml in home
     configpath = os.path.abspath(Utils.user_path('config.yaml'))
 
 
 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"]:
@@ -38,6 +34,7 @@ def get_app():
         app.config["HOST_ADDRESS"] = Utils.get_public_ipv4()
         logging.info(f"HOST_ADDRESS was set to {app.config['HOST_ADDRESS']}")
 
+    cache.init_app(app)
     db.bind(**app.config["PONY"])
     db.generate_mapping(create_tables=True)
     return app
@@ -72,6 +69,7 @@ def create_ordered_tutorials_file() -> typing.List[typing.Dict[str, typing.Any]]
             with zipfile.ZipFile(zipfile_path) as zf:
                 for zfile in zf.infolist():
                     if not zfile.is_dir() and "/docs/" in zfile.filename:
+                        zfile.filename = os.path.basename(zfile.filename)
                         zf.extract(zfile, target_path)
         else:
             source_path = Utils.local_path(os.path.dirname(world.__file__), "docs")
@@ -117,6 +115,11 @@ if __name__ == "__main__":
     multiprocessing.freeze_support()
     multiprocessing.set_start_method('spawn')
     logging.basicConfig(format='[%(asctime)s] %(message)s', level=logging.INFO)
+
+    from WebHostLib.lttpsprites import update_sprites_lttp
+    from WebHostLib.autolauncher import autohost, autogen
+    from WebHostLib.options import create as create_options_files
+
     try:
         update_sprites_lttp()
     except Exception as e:
@@ -133,4 +136,5 @@ if __name__ == "__main__":
         if app.config["DEBUG"]:
             app.run(debug=True, port=app.config["PORT"])
         else:
+            from waitress import serve
             serve(app, port=app.config["PORT"], threads=app.config["WAITRESS_THREADS"])

WebHostLib/__init__.py

@@ -34,7 +34,7 @@ app.config['MAX_CONTENT_LENGTH'] = 64 * 1024 * 1024  # 64 megabyte limit
 # if you want to deploy, make sure you have a non-guessable secret key
 app.config["SECRET_KEY"] = bytes(socket.gethostname(), encoding="utf-8")
 # at what amount of worlds should scheduling be used, instead of rolling in the web-thread
-app.config["JOB_THRESHOLD"] = 2
+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
@@ -49,11 +49,10 @@ app.config["PONY"] = {
     'create_db': True
 }
 app.config["MAX_ROLL"] = 20
-app.config["CACHE_TYPE"] = "flask_caching.backends.SimpleCache"
-app.config["JSON_AS_ASCII"] = False
+app.config["CACHE_TYPE"] = "SimpleCache"
 app.config["HOST_ADDRESS"] = ""
 
-cache = Cache(app)
+cache = Cache()
 Compress(app)
 
 

WebHostLib/api/generate.py

@@ -2,7 +2,8 @@ import json
 import pickle
 from uuid import UUID
 
-from flask import request, session, url_for, Markup
+from flask import request, session, url_for
+from markupsafe import Markup
 from pony.orm import commit
 
 from WebHostLib import app
@@ -19,8 +20,8 @@ def generate_api():
         race = False
         meta_options_source = {}
         if 'file' in request.files:
-            file = request.files['file']
-            options = get_yaml_data(file)
+            files = request.files.getlist('file')
+            options = get_yaml_data(files)
             if isinstance(options, Markup):
                 return {"text": options.striptags()}, 400
             if isinstance(options, str):
@@ -48,9 +49,8 @@ def generate_api():
         if len(options) > app.config["MAX_ROLL"]:
             return {"text": "Max size of multiworld exceeded",
                     "detail": app.config["MAX_ROLL"]}, 409
-        meta = get_meta(meta_options_source)
-        meta["race"] = race
-        results, gen_options = roll_options(options, meta["plando_options"])
+        meta = get_meta(meta_options_source, race)
+        results, gen_options = roll_options(options, set(meta["plando_options"]))
         if any(type(result) == str for result in results.values()):
             return {"text": str(results),
                     "detail": results}, 400

WebHostLib/autolauncher.py

@@ -3,8 +3,6 @@ from __future__ import annotations
 import json
 import logging
 import multiprocessing
-import os
-import sys
 import threading
 import time
 import typing
@@ -13,55 +11,7 @@ from datetime import timedelta, datetime
 from pony.orm import db_session, select, commit
 
 from Utils import restricted_loads
-
-
-class CommonLocker():
-    """Uses a file lock to signal that something is already running"""
-    lock_folder = "file_locks"
-
-    def __init__(self, lockname: str, folder=None):
-        if folder:
-            self.lock_folder = folder
-        os.makedirs(self.lock_folder, exist_ok=True)
-        self.lockname = lockname
-        self.lockfile = os.path.join(self.lock_folder, f"{self.lockname}.lck")
-
-
-class AlreadyRunningException(Exception):
-    pass
-
-
-if sys.platform == 'win32':
-    class Locker(CommonLocker):
-        def __enter__(self):
-            try:
-                if os.path.exists(self.lockfile):
-                    os.unlink(self.lockfile)
-                self.fp = os.open(
-                    self.lockfile, os.O_CREAT | os.O_EXCL | os.O_RDWR)
-            except OSError as e:
-                raise AlreadyRunningException() from e
-
-        def __exit__(self, _type, value, tb):
-            fp = getattr(self, "fp", None)
-            if fp:
-                os.close(self.fp)
-                os.unlink(self.lockfile)
-else:  # unix
-    import fcntl
-
-
-    class Locker(CommonLocker):
-        def __enter__(self):
-            try:
-                self.fp = open(self.lockfile, "wb")
-                fcntl.flock(self.fp.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
-            except OSError as e:
-                raise AlreadyRunningException() from e
-
-        def __exit__(self, _type, value, tb):
-            fcntl.flock(self.fp.fileno(), fcntl.LOCK_UN)
-            self.fp.close()
+from .locker import Locker, AlreadyRunningException
 
 
 def launch_room(room: Room, config: dict):
@@ -135,7 +85,7 @@ def autogen(config: dict):
             with Locker("autogen"):
 
                 with multiprocessing.Pool(config["GENERATORS"], initializer=init_db,
-                                          initargs=(config["PONY"],)) as generator_pool:
+                                          initargs=(config["PONY"],), maxtasksperchild=10) as generator_pool:
                     with db_session:
                         to_start = select(generation for generation in Generation if generation.state == STATE_STARTED)
 

WebHostLib/check.py

@@ -1,16 +1,13 @@
+import os
 import zipfile
-from typing import *
+import base64
+from typing import Union, Dict, Set, Tuple
 
-from flask import request, flash, redirect, url_for, render_template, Markup
+from flask import request, flash, redirect, url_for, render_template
+from markupsafe import Markup
 
 from WebHostLib import app
-
-banned_zip_contents = (".sfc",)
-
-
-def allowed_file(filename):
-    return filename.endswith(('.txt', ".yaml", ".zip"))
-
+from WebHostLib.upload import allowed_options, allowed_options_extensions, banned_file
 
 from Generate import roll_settings, PlandoOptions
 from Utils import parse_yamls
@@ -23,13 +20,21 @@ def check():
         if 'file' not in request.files:
             flash('No file part')
         else:
-            file = request.files['file']
-            options = get_yaml_data(file)
+            files = request.files.getlist('file')
+            options = get_yaml_data(files)
             if isinstance(options, str):
                 flash(options)
             else:
                 results, _ = roll_options(options)
-                return render_template("checkResult.html", results=results)
+                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')}"
+                                                 for file_name, file_content in options.items())
+                    combined_yaml = base64.b64encode(combined_yaml.encode("utf-8-sig")).decode()
+                else:
+                    combined_yaml = ""
+                return render_template("checkResult.html",
+                                       results=results, combined_yaml=combined_yaml)
     return render_template("check.html")
 
 
@@ -38,31 +43,44 @@ def mysterycheck():
     return redirect(url_for("check"), 301)
 
 
-def get_yaml_data(file) -> Union[Dict[str, str], str, Markup]:
+def get_yaml_data(files) -> Union[Dict[str, str], str, Markup]:
     options = {}
-    # if user does not select file, browser also
-    # submit an empty part without filename
-    if file.filename == '':
-        return 'No selected file'
-    elif file and allowed_file(file.filename):
-        if file.filename.endswith(".zip"):
+    for uploaded_file in files:
+        if banned_file(uploaded_file.filename):
+            return ("Uploaded data contained a rom file, which is likely to contain copyrighted material. "
+                    "Your file was deleted.")
+        # If the user does not select file, the browser will still submit an empty string without a file name.
+        elif uploaded_file.filename == "":
+            return "No selected file."
+        elif uploaded_file.filename in options:
+            return f"Conflicting files named {uploaded_file.filename} submitted."
+        elif uploaded_file and allowed_options(uploaded_file.filename):
+            if uploaded_file.filename.endswith(".zip"):
+                if not zipfile.is_zipfile(uploaded_file):
+                    return f"Uploaded file {uploaded_file.filename} is not a valid .zip file and cannot be opened."
 
-            with zipfile.ZipFile(file, 'r') as zfile:
-                infolist = zfile.infolist()
+                uploaded_file.seek(0)  # offset from is_zipfile check
+                with zipfile.ZipFile(uploaded_file, "r") as zfile:
+                    for file in zfile.infolist():
+                        # Remove folder pathing from str (e.g. "__MACOSX/" folder paths from archives created by macOS).
+                        base_filename = os.path.basename(file.filename)
 
-                if any(file.filename.endswith(".archipelago") for file in infolist):
-                    return Markup("Error: Your .zip file contains an .archipelago file. "
-                                 'Did you mean to <a href="/uploads">host a game</a>?')
+                        if base_filename.endswith(".archipelago"):
+                            return Markup("Error: Your .zip file contains an .archipelago file. "
+                                          'Did you mean to <a href="/uploads">host a game</a>?')
+                        elif base_filename.endswith(".zip"):
+                            return "Nested .zip files inside a .zip are not supported."
+                        elif banned_file(base_filename):
+                            return ("Uploaded data contained a rom file, which is likely to contain copyrighted "
+                                    "material. Your file was deleted.")
+                        # Ignore dot-files.
+                        elif not base_filename.startswith(".") and allowed_options(base_filename):
+                            options[file.filename] = zfile.open(file, "r").read()
+            else:
+                options[uploaded_file.filename] = uploaded_file.read()
 
-                for file in infolist:
-                    if file.filename.endswith(banned_zip_contents):
-                        return "Uploaded data contained a rom file, which is likely to contain copyrighted material. Your file was deleted."
-                    elif file.filename.endswith((".yaml", ".json", ".yml", ".txt")):
-                        options[file.filename] = zfile.open(file, "r").read()
-        else:
-            options = {file.filename: file.read()}
     if not options:
-        return "Did not find a .yaml file to process."
+        return f"Did not find any valid files to process. Accepted formats: {allowed_options_extensions}"
     return options
 
 
@@ -90,7 +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:
-                results[filename] = f"Failed to generate mystery in {filename}: {e}"
+                results[filename] = f"Failed to generate options in {filename}: {e}"
             else:
                 results[filename] = True
     return results, rolled_results

WebHostLib/customserver.py

@@ -11,6 +11,7 @@ import socket
 import threading
 import time
 import typing
+import sys
 
 import websockets
 from pony.orm import commit, db_session, select
@@ -18,15 +19,18 @@ from pony.orm import commit, db_session, select
 import Utils
 
 from MultiServer import Context, server, auto_shutdown, ServerCommandProcessor, ClientMessageProcessor, load_server_cert
-from Utils import get_public_ipv4, get_public_ipv6, restricted_loads, cache_argsless
+from Utils import restricted_loads, cache_argsless
+from .locker import Locker
 from .models import Command, GameDataPackage, Room, db
 
 
 class CustomClientMessageProcessor(ClientMessageProcessor):
     ctx: WebHostContext
 
-    def _cmd_video(self, platform, user):
-        """Set a link for your name in the WebHostLib tracker pointing to a video stream"""
+    def _cmd_video(self, platform: str, user: str):
+        """Set a link for your name in the WebHostLib tracker pointing to a video stream.
+        Currently, only YouTube and Twitch platforms are supported.
+        """
         if platform.lower().startswith("t"):  # twitch
             self.ctx.video[self.client.team, self.client.slot] = "Twitch", user
             self.ctx.save()
@@ -94,7 +98,7 @@ class WebHostContext(Context):
 
         multidata = self.decompress(room.seed.multidata)
         game_data_packages = {}
-        for game in list(multidata["datapackage"]):
+        for game in list(multidata.get("datapackage", {})):
             game_data = multidata["datapackage"][game]
             if "checksum" in game_data:
                 if self.gamespackage.get(game, {}).get("checksum") == game_data["checksum"]:
@@ -102,8 +106,9 @@ class WebHostContext(Context):
                     # games package could be dropped from static data once all rooms embed data package
                     del multidata["datapackage"][game]
                 else:
-                    data = Utils.restricted_loads(GameDataPackage.get(checksum=game_data["checksum"]).data)
-                    game_data_packages[game] = data
+                    row = GameDataPackage.get(checksum=game_data["checksum"])
+                    if row:  # None if rolled on >= 0.3.9 but uploaded to <= 0.3.8. multidata should be complete
+                        game_data_packages[game] = Utils.restricted_loads(row.data)
 
         return self._load(multidata, game_data_packages, True)
 
@@ -162,19 +167,22 @@ def run_server_process(room_id, ponyconfig: dict, static_server_data: dict,
     db.generate_mapping(check_tables=False)
 
     async def main():
+        if "worlds" in sys.modules:
+            raise Exception("Worlds system should not be loaded in the custom server.")
+
+        import gc
         Utils.init_logging(str(room_id), write_mode="a")
         ctx = WebHostContext(static_server_data)
         ctx.load(room_id)
         ctx.init_save()
         ssl_context = load_server_cert(cert_file, cert_key_file) if cert_file else None
+        gc.collect()  # free intermediate objects used during setup
         try:
-            ctx.server = websockets.serve(functools.partial(server, ctx=ctx), ctx.host, ctx.port, ping_timeout=None,
-                                          ping_interval=None, ssl=ssl_context)
+            ctx.server = websockets.serve(functools.partial(server, ctx=ctx), ctx.host, ctx.port, ssl=ssl_context)
 
             await ctx.server
-        except Exception:  # likely port in use - in windows this is OSError, but I didn't check the others
-            ctx.server = websockets.serve(functools.partial(server, ctx=ctx), ctx.host, 0, ping_timeout=None,
-                                          ping_interval=None, ssl=ssl_context)
+        except OSError:  # likely port in use
+            ctx.server = websockets.serve(functools.partial(server, ctx=ctx), ctx.host, 0, ssl=ssl_context)
 
             await ctx.server
         port = 0
@@ -197,18 +205,23 @@ def run_server_process(room_id, ponyconfig: dict, static_server_data: dict,
             ctx.auto_shutdown = Room.get(id=room_id).timeout
         ctx.shutdown_task = asyncio.create_task(auto_shutdown(ctx, []))
         await ctx.shutdown_task
+
+        # ensure auto launch is on the same page in regard to room activity.
+        with db_session:
+            room: Room = Room.get(id=ctx.room_id)
+            room.last_activity = datetime.datetime.utcnow() - datetime.timedelta(seconds=room.timeout + 60)
+
         logging.info("Shutting down")
 
-    from .autolauncher import Locker
     with Locker(room_id):
         try:
             asyncio.run(main())
-        except KeyboardInterrupt:
+        except (KeyboardInterrupt, SystemExit):
             with db_session:
                 room = Room.get(id=room_id)
                 # ensure the Room does not spin up again on its own, minute of safety buffer
                 room.last_activity = datetime.datetime.utcnow() - datetime.timedelta(minutes=1, seconds=room.timeout)
-        except:
+        except Exception:
             with db_session:
                 room = Room.get(id=room_id)
                 room.last_port = -1

WebHostLib/downloads.py

@@ -90,6 +90,8 @@ def download_slot_file(room_id, player_id: int):
             fname = f"AP_{app.jinja_env.filters['suuid'](room_id)}.json"
         elif slot_data.game == "Kingdom Hearts 2":
             fname = f"AP_{app.jinja_env.filters['suuid'](room_id)}_P{slot_data.player_id}_{slot_data.player_name}.zip"
+        elif slot_data.game == "Final Fantasy Mystic Quest":
+            fname = f"AP+{app.jinja_env.filters['suuid'](room_id)}_P{slot_data.player_id}_{slot_data.player_name}.apmq"
         else:
             return "Game download not supported."
         return send_file(io.BytesIO(slot_data.data), as_attachment=True, download_name=fname)

WebHostLib/generate.py

@@ -1,18 +1,18 @@
+import concurrent.futures
 import json
 import os
 import pickle
 import random
 import tempfile
 import zipfile
-import concurrent.futures
 from collections import Counter
-from typing import Dict, Optional, Any
+from typing import Any, Dict, List, Optional, Union
 
-from flask import request, flash, redirect, url_for, session, render_template
+from flask import flash, redirect, render_template, request, session, url_for
 from pony.orm import commit, db_session
 
-from BaseClasses import seeddigits, get_seed
-from Generate import handle_name, PlandoOptions
+from BaseClasses import get_seed, seeddigits
+from Generate import PlandoOptions, handle_name
 from Main import main as ERmain
 from Utils import __version__
 from WebHostLib import app
@@ -22,7 +22,7 @@ from .models import Generation, STATE_ERROR, STATE_QUEUED, Seed, UUID
 from .upload import upload_zip_to_db
 
 
-def get_meta(options_source: dict) -> dict:
+def get_meta(options_source: dict, race: bool = False) -> Dict[str, Union[List[str], Dict[str, Any]]]:
     plando_options = {
         options_source.get("plando_bosses", ""),
         options_source.get("plando_items", ""),
@@ -39,7 +39,21 @@ def get_meta(options_source: dict) -> dict:
         "item_cheat": bool(int(options_source.get("item_cheat", 1))),
         "server_password": options_source.get("server_password", None),
     }
-    return {"server_options": server_options, "plando_options": list(plando_options)}
+    generator_options = {
+        "spoiler": int(options_source.get("spoiler", 0)),
+        "race": race
+    }
+
+    if race:
+        server_options["item_cheat"] = False
+        server_options["remaining_mode"] = "disabled"
+        generator_options["spoiler"] = 0
+
+    return {
+        "server_options": server_options,
+        "plando_options": list(plando_options),
+        "generator_options": generator_options,
+    }
 
 
 @app.route('/generate', methods=['GET', 'POST'])
@@ -50,18 +64,13 @@ def generate(race=False):
         if 'file' not in request.files:
             flash('No file part')
         else:
-            file = request.files['file']
-            options = get_yaml_data(file)
+            files = request.files.getlist('file')
+            options = get_yaml_data(files)
             if isinstance(options, str):
                 flash(options)
             else:
-                meta = get_meta(request.form)
-                meta["race"] = race
-                results, gen_options = roll_options(options, meta["plando_options"])
-
-                if race:
-                    meta["server_options"]["item_cheat"] = False
-                    meta["server_options"]["remaining_mode"] = "disabled"
+                meta = get_meta(request.form, race)
+                results, gen_options = roll_options(options, set(meta["plando_options"]))
 
                 if any(type(result) == str for result in results.values()):
                     return render_template("checkResult.html", results=results)
@@ -97,7 +106,7 @@ def gen_game(gen_options: dict, meta: Optional[Dict[str, Any]] = None, owner=Non
         meta: Dict[str, Any] = {}
 
     meta.setdefault("server_options", {}).setdefault("hint_cost", 10)
-    race = meta.setdefault("race", False)
+    race = meta.setdefault("generator_options", {}).setdefault("race", False)
 
     def task():
         target = tempfile.TemporaryDirectory()
@@ -114,13 +123,15 @@ def gen_game(gen_options: dict, meta: Optional[Dict[str, Any]] = None, owner=Non
         erargs = parse_arguments(['--multi', str(playercount)])
         erargs.seed = seed
         erargs.name = {x: "" for x in range(1, playercount + 1)}  # only so it can be overwritten in mystery
-        erargs.spoiler = 0 if race else 3
+        erargs.spoiler = meta["generator_options"].get("spoiler", 0)
         erargs.race = race
         erargs.outputname = seedname
         erargs.outputpath = target.name
         erargs.teams = 1
         erargs.plando_options = PlandoOptions.from_set(meta.setdefault("plando_options",
-                                                                        {"bosses", "items", "connections", "texts"}))
+                                                                       {"bosses", "items", "connections", "texts"}))
+        erargs.skip_prog_balancing = False
+        erargs.skip_output = False
 
         name_counter = Counter()
         for player, (playerfile, settings) in enumerate(gen_options.items(), 1):

WebHostLib/locker.py

@@ -0,0 +1,51 @@
+import os
+import sys
+
+
+class CommonLocker:
+    """Uses a file lock to signal that something is already running"""
+    lock_folder = "file_locks"
+
+    def __init__(self, lockname: str, folder=None):
+        if folder:
+            self.lock_folder = folder
+        os.makedirs(self.lock_folder, exist_ok=True)
+        self.lockname = lockname
+        self.lockfile = os.path.join(self.lock_folder, f"{self.lockname}.lck")
+
+
+class AlreadyRunningException(Exception):
+    pass
+
+
+if sys.platform == 'win32':
+    class Locker(CommonLocker):
+        def __enter__(self):
+            try:
+                if os.path.exists(self.lockfile):
+                    os.unlink(self.lockfile)
+                self.fp = os.open(
+                    self.lockfile, os.O_CREAT | os.O_EXCL | os.O_RDWR)
+            except OSError as e:
+                raise AlreadyRunningException() from e
+
+        def __exit__(self, _type, value, tb):
+            fp = getattr(self, "fp", None)
+            if fp:
+                os.close(self.fp)
+                os.unlink(self.lockfile)
+else:  # unix
+    import fcntl
+
+
+    class Locker(CommonLocker):
+        def __enter__(self):
+            try:
+                self.fp = open(self.lockfile, "wb")
+                fcntl.flock(self.fp.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
+            except OSError as e:
+                raise AlreadyRunningException() from e
+
+        def __exit__(self, _type, value, tb):
+            fcntl.flock(self.fp.fileno(), fcntl.LOCK_UN)
+            self.fp.close()

WebHostLib/misc.py

@@ -32,29 +32,46 @@ def page_not_found(err):
 
 # Start Playing Page
 @app.route('/start-playing')
+@cache.cached()
 def start_playing():
     return render_template(f"startPlaying.html")
 
 
-@app.route('/weighted-settings')
+# TODO for back compat. remove around 0.4.5
+@app.route("/weighted-settings")
 def weighted_settings():
-    return render_template(f"weighted-settings.html")
+    return redirect("weighted-options", 301)
 
 
-# Player settings pages
-@app.route('/games/<string:game>/player-settings')
-def player_settings(game):
-    return render_template(f"player-settings.html", game=game, theme=get_world_theme(game))
+@app.route("/weighted-options")
+@cache.cached()
+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()
+def player_options(game: str):
+    return render_template("player-options.html", game=game, theme=get_world_theme(game))
 
 
 # Game Info Pages
 @app.route('/games/<string:game>/info/<string:lang>')
+@cache.cached()
 def game_info(game, lang):
     return render_template('gameInfo.html', game=game, lang=lang, theme=get_world_theme(game))
 
 
 # List of supported games
 @app.route('/games')
+@cache.cached()
 def games():
     worlds = {}
     for game, world in AutoWorldRegister.world_types.items():
@@ -64,21 +81,25 @@ def games():
 
 
 @app.route('/tutorial/<string:game>/<string:file>/<string:lang>')
+@cache.cached()
 def tutorial(game, file, lang):
     return render_template("tutorial.html", game=game, file=file, lang=lang, theme=get_world_theme(game))
 
 
 @app.route('/tutorial/')
+@cache.cached()
 def tutorial_landing():
     return render_template("tutorialLanding.html")
 
 
 @app.route('/faq/<string:lang>/')
+@cache.cached()
 def faq(lang):
     return render_template("faq.html", lang=lang)
 
 
 @app.route('/glossary/<string:lang>/')
+@cache.cached()
 def terms(lang):
     return render_template("glossary.html", lang=lang)
 
@@ -116,7 +137,11 @@ def display_log(room: UUID):
     if room is None:
         return abort(404)
     if room.owner == session["_id"]:
-        return Response(_read_log(os.path.join("logs", str(room.id) + ".txt")), mimetype="text/plain;charset=UTF-8")
+        file_path = os.path.join("logs", str(room.id) + ".txt")
+        if os.path.exists(file_path):
+            return Response(_read_log(file_path), mimetype="text/plain;charset=UTF-8")
+        return "Log File does not exist."
+
     return "Access Denied", 403
 
 
@@ -143,7 +168,7 @@ def host_room(room: UUID):
 
 @app.route('/favicon.ico')
 def favicon():
-    return send_from_directory(os.path.join(app.root_path, 'static/static'),
+    return send_from_directory(os.path.join(app.root_path, "static", "static"),
                                'favicon.ico', mimetype='image/vnd.microsoft.icon')
 
 
@@ -163,10 +188,11 @@ def get_datapackage():
 
 @app.route('/index')
 @app.route('/sitemap')
+@cache.cached()
 def get_sitemap():
     available_games: List[Dict[str, Union[str, bool]]] = []
     for game, world in AutoWorldRegister.world_types.items():
         if not world.hidden:
-            has_settings: bool = isinstance(world.web.settings_page, bool) and world.web.settings_page
+            has_settings: bool = isinstance(world.web.options_page, bool) and world.web.options_page
             available_games.append({ 'title': game, 'has_settings': has_settings })
     return render_template("siteMap.html", games=available_games)

WebHostLib/models.py

@@ -21,7 +21,7 @@ class Slot(db.Entity):
 class Room(db.Entity):
     id = PrimaryKey(UUID, default=uuid4)
     last_activity = Required(datetime, default=lambda: datetime.utcnow(), index=True)
-    creation_time = Required(datetime, default=lambda: datetime.utcnow())
+    creation_time = Required(datetime, default=lambda: datetime.utcnow(), index=True)  # index used by landing page
     owner = Required(UUID, index=True)
     commands = Set('Command')
     seed = Required('Seed', index=True)
@@ -38,7 +38,7 @@ class Seed(db.Entity):
     rooms = Set(Room)
     multidata = Required(bytes, lazy=True)
     owner = Required(UUID, index=True)
-    creation_time = Required(datetime, default=lambda: datetime.utcnow())
+    creation_time = Required(datetime, default=lambda: datetime.utcnow(), index=True)  # index used by landing page
     slots = Set(Slot)
     spoiler = Optional(LongStr, lazy=True)
     meta = Required(LongStr, default=lambda: "{\"race\": false}")  # additional meta information/tags

WebHostLib/options.py

@@ -3,11 +3,8 @@ import logging
 import os
 import typing
 
-import yaml
-from jinja2 import Template
-
 import Options
-from Utils import __version__, local_path
+from Utils import local_path
 from worlds.AutoWorld import AutoWorldRegister
 
 handled_in_js = {"start_inventory", "local_items", "non_local_items", "start_hints", "start_location_hints",
@@ -17,39 +14,18 @@ handled_in_js = {"start_inventory", "local_items", "non_local_items", "start_hin
 def create():
     target_folder = local_path("WebHostLib", "static", "generated")
     yaml_folder = os.path.join(target_folder, "configs")
-    os.makedirs(yaml_folder, exist_ok=True)
 
-    for file in os.listdir(yaml_folder):
-        full_path: str = os.path.join(yaml_folder, file)
-        if os.path.isfile(full_path):
-            os.unlink(full_path)
-
-    def dictify_range(option: typing.Union[Options.Range, Options.SpecialRange]):
-        data = {option.default: 50}
-        for sub_option in ["random", "random-low", "random-high"]:
-            if sub_option != option.default:
-                data[sub_option] = 0
-
-        notes = {}
-        for name, number in getattr(option, "special_range_names", {}).items():
-            notes[name] = f"equivalent to {number}"
-            if number in data:
-                data[name] = data[number]
-                del data[number]
-            else:
-                data[name] = 0
-
-        return data, notes
+    Options.generate_yaml_templates(yaml_folder)
 
     def get_html_doc(option_type: type(Options.Option)) -> str:
         if not option_type.__doc__:
             return "Please document me!"
         return "\n".join(line.strip() for line in option_type.__doc__.split("\n")).strip()
 
-    weighted_settings = {
+    weighted_options = {
         "baseOptions": {
             "description": "Generated by https://archipelago.gg/",
-            "name": "Player",
+            "name": "",
             "game": {},
         },
         "games": {},
@@ -57,29 +33,14 @@ def create():
 
     for game_name, world in AutoWorldRegister.world_types.items():
 
-        all_options: typing.Dict[str, Options.AssembleOptions] = {
-            **Options.per_game_common_options,
-            **world.option_definitions
-        }
-        with open(local_path("WebHostLib", "templates", "options.yaml")) as f:
-            file_data = f.read()
-        res = Template(file_data).render(
-            options=all_options,
-            __version__=__version__, game=game_name, yaml_dump=yaml.dump,
-            dictify_range=dictify_range,
-        )
+        all_options: typing.Dict[str, Options.AssembleOptions] = world.options_dataclass.type_hints
 
-        del file_data
-
-        with open(os.path.join(target_folder, "configs", game_name + ".yaml"), "w", encoding="utf-8") as f:
-            f.write(res)
-
-        # Generate JSON files for player-settings pages
-        player_settings = {
+        # Generate JSON files for player-options pages
+        player_options = {
             "baseOptions": {
-                "description": "Generated by https://archipelago.gg/",
+                "description": f"Generated by https://archipelago.gg/ for {game_name}",
                 "game": game_name,
-                "name": "Player",
+                "name": "",
             },
         }
 
@@ -120,8 +81,8 @@ def create():
                     "max": option.range_end,
                 }
 
-                if issubclass(option, Options.SpecialRange):
-                    game_options[option_name]["type"] = 'special_range'
+                if issubclass(option, Options.NamedRange):
+                    game_options[option_name]["type"] = 'named_range'
                     game_options[option_name]["value_names"] = {}
                     for key, val in option.special_range_names.items():
                         game_options[option_name]["value_names"][key] = val
@@ -131,6 +92,7 @@ def create():
                     "type": "items-list",
                     "displayName": option.display_name if hasattr(option, "display_name") else option_name,
                     "description": get_html_doc(option),
+                    "defaultValue": list(option.default)
                 }
 
             elif issubclass(option, Options.LocationSet):
@@ -138,29 +100,67 @@ def create():
                     "type": "locations-list",
                     "displayName": option.display_name if hasattr(option, "display_name") else option_name,
                     "description": get_html_doc(option),
+                    "defaultValue": list(option.default)
                 }
 
-            elif issubclass(option, Options.VerifyKeys):
+            elif issubclass(option, Options.VerifyKeys) and not issubclass(option, Options.OptionDict):
                 if option.valid_keys:
                     game_options[option_name] = {
                         "type": "custom-list",
                         "displayName": option.display_name if hasattr(option, "display_name") else option_name,
                         "description": get_html_doc(option),
                         "options": list(option.valid_keys),
+                        "defaultValue": list(option.default) if hasattr(option, "default") else []
                     }
 
             else:
-                logging.debug(f"{option} not exported to Web Settings.")
+                logging.debug(f"{option} not exported to Web Options.")
 
-        player_settings["gameOptions"] = game_options
+        player_options["gameOptions"] = game_options
 
-        os.makedirs(os.path.join(target_folder, 'player-settings'), exist_ok=True)
+        player_options["presetOptions"] = {}
+        for preset_name, preset in world.web.options_presets.items():
+            player_options["presetOptions"][preset_name] = {}
+            for option_name, option_value in preset.items():
+                # Random range type settings are not valid.
+                assert (not str(option_value).startswith("random-")), \
+                    f"Invalid preset value '{option_value}' for '{option_name}' in '{preset_name}'. Special random " \
+                    f"values are not supported for presets."
 
-        with open(os.path.join(target_folder, 'player-settings', game_name + ".json"), "w") as f:
-            json.dump(player_settings, f, indent=2, separators=(',', ': '))
+                # Normal random is supported, but needs to be handled explicitly.
+                if option_value == "random":
+                    player_options["presetOptions"][preset_name][option_name] = option_value
+                    continue
 
-        if not world.hidden and world.web.settings_page is True:
-            # Add the random option to Choice, TextChoice, and Toggle settings
+                option = world.options_dataclass.type_hints[option_name].from_any(option_value)
+                if isinstance(option, Options.NamedRange) and isinstance(option_value, str):
+                    assert option_value in option.special_range_names, \
+                        f"Invalid preset value '{option_value}' for '{option_name}' in '{preset_name}'. " \
+                        f"Expected {option.special_range_names.keys()} or {option.range_start}-{option.range_end}."
+
+                    # Still use the true value for the option, not the name.
+                    player_options["presetOptions"][preset_name][option_name] = option.value
+                elif isinstance(option, Options.Range):
+                    player_options["presetOptions"][preset_name][option_name] = option.value
+                elif isinstance(option_value, str):
+                    # For Choice and Toggle options, the value should be the name of the option. This is to prevent
+                    # setting a preset for an option with an overridden from_text method that would normally be okay,
+                    # but would not be okay for the webhost's current implementation of player options UI.
+                    assert option.name_lookup[option.value] == option_value, \
+                        f"Invalid option value '{option_value}' for '{option_name}' in preset '{preset_name}'. " \
+                        f"Values must not be resolved to a different option via option.from_text (or an alias)."
+                    player_options["presetOptions"][preset_name][option_name] = option.current_key
+                else:
+                    # int and bool values are fine, just resolve them to the current key for webhost.
+                    player_options["presetOptions"][preset_name][option_name] = option.current_key
+
+        os.makedirs(os.path.join(target_folder, 'player-options'), exist_ok=True)
+
+        with open(os.path.join(target_folder, 'player-options', game_name + ".json"), "w") as f:
+            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 game_options.values():
                 if option["type"] == "select":
                     option["options"].append({"name": "Random", "value": "random"})
@@ -168,11 +168,21 @@ def create():
                     if not option["defaultValue"]:
                         option["defaultValue"] = "random"
 
-            weighted_settings["baseOptions"]["game"][game_name] = 0
-            weighted_settings["games"][game_name] = {}
-            weighted_settings["games"][game_name]["gameSettings"] = game_options
-            weighted_settings["games"][game_name]["gameItems"] = tuple(world.item_names)
-            weighted_settings["games"][game_name]["gameLocations"] = tuple(world.location_names)
+            weighted_options["baseOptions"]["game"][game_name] = 0
+            weighted_options["games"][game_name] = {
+                "gameSettings": game_options,
+                "gameItems": tuple(world.item_names),
+                "gameItemGroups": [
+                    group for group in world.item_name_groups.keys() if group != "Everything"
+                ],
+                "gameItemDescriptions": world.item_descriptions,
+                "gameLocations": tuple(world.location_names),
+                "gameLocationGroups": [
+                    group for group in world.location_name_groups.keys() if group != "Everywhere"
+                ],
+                "gameLocationDescriptions": world.location_descriptions,
+            }
+
+    with open(os.path.join(target_folder, 'weighted-options.json'), "w") as f:
+        json.dump(weighted_options, f, indent=2, separators=(',', ': '))
 
-    with open(os.path.join(target_folder, 'weighted-settings.json'), "w") as f:
-        json.dump(weighted_settings, f, indent=2, separators=(',', ': '))

WebHostLib/requirements.txt

@@ -1,7 +1,9 @@
-flask>=2.2.3
-pony>=0.7.16
+flask>=3.0.0
+pony>=0.7.17
 waitress>=2.1.2
-Flask-Caching>=2.0.2
-Flask-Compress>=1.13
-Flask-Limiter>=3.3.0
-bokeh>=3.1.0
+Flask-Caching>=2.1.0
+Flask-Compress>=1.14
+Flask-Limiter>=3.5.0
+bokeh>=3.1.1; python_version <= '3.8'
+bokeh>=3.3.2; python_version >= '3.9'
+markupsafe>=2.1.3

WebHostLib/static/assets/faq/faq_en.md

@@ -2,13 +2,62 @@
 
 ## What is a randomizer?
 
-A randomizer is a modification of a video game which reorganizes the items required to progress through the game. A
-normal play-through of a game might require you to use item A to unlock item B, then C, and so forth. In a randomized
+A randomizer is a modification of a game which reorganizes the items required to progress through that game. A
+normal play-through might require you to use item A to unlock item B, then C, and so forth. In a randomized
 game, you might first find item C, then A, then B.
 
-This transforms games from a linear experience into a puzzle, presenting players with a new challenge each time they
-play a randomized game. Putting items in non-standard locations can require the player to think about the game world and
-the items they encounter in new and interesting ways.
+This transforms the game from a linear experience into a puzzle, presenting players with a new challenge each time they
+play. Putting items in non-standard locations can require the player to think about the game world and the items they
+encounter in new and interesting ways.
+
+## What is a multiworld?
+
+While a randomizer shuffles a game, a multiworld randomizer shuffles that game for multiple players. For example, in a
+two player multiworld, players A and B each get their own randomized version of a game, called a world. In each
+player's game, they may find items which belong to the other player. If player A finds an item which belongs to
+player B, the item will be sent to player B's world over the internet. This creates a cooperative experience, requiring
+players to rely upon each other to complete their game.
+
+## What does multi-game mean?
+
+While a multiworld game traditionally requires all players to be playing the same game, a multi-game multiworld allows
+players to randomize any of the supported games, and send items between them. This allows players of different
+games to interact with one another in a single multiplayer environment.  Archipelago supports multi-game multiworld.
+Here is a list of our [Supported Games](https://archipelago.gg/games).
+
+## Can I generate a single-player game with Archipelago?
+
+Yes. All of our supported games can be generated as single-player experiences both on the website and by installing 
+the Archipelago generator software. The fastest way to do this is on the website. Find the Supported Game you wish to
+play, open the Settings Page, pick your settings, and click Generate Game.
+
+## How do I get started?
+
+We have a [Getting Started](https://archipelago.gg/tutorial/Archipelago/setup/en) guide that will help you get the
+software set up. You can use that guide to learn how to generate multiworlds. There are also basic instructions for
+including multiple games, and hosting multiworlds on the website for ease and convenience.
+
+If you are ready to start randomizing games, or want to start playing your favorite randomizer with others, please join
+our discord server at the [Archipelago Discord](https://discord.gg/8Z65BR2). There are always people ready to answer
+any questions you might have.
+
+## What are some common terms I should know?
+
+As randomizers and multiworld randomizers have been around for a while now, there are quite a few common terms used
+by the communities surrounding them. A list of Archipelago jargon and terms commonly used by the community can be
+found in the [Glossary](/glossary/en).
+
+## Does everyone need to be connected at the same time?
+
+There are two different play-styles that are common for Archipelago multiworld sessions. These sessions can either
+be considered synchronous (or "sync"), where everyone connects and plays at the same time, or asynchronous (or "async"),
+where players connect and play at their own pace. The setup for both is identical. The difference in play-style is how
+you and your friends choose to organize and play your multiworld. Most groups decide on the format before creating
+their multiworld.
+
+If a player must leave early, they can use Archipelago's release system. When a player releases their game, all items
+in that game belonging to other players are sent out automatically. This allows other players to continue to play
+uninterrupted. Here is a list of all of our [Server Commands](https://archipelago.gg/tutorial/Archipelago/commands/en).
 
 ## What happens if an item is placed somewhere it is impossible to get?
 
@@ -17,53 +66,15 @@ is to ensure items necessary to complete the game will be accessible to the play
 rules allowing certain items to be placed in normally unreachable locations, provided the player has indicated they are
 comfortable exploiting certain glitches in the game.
 
-## What is a multi-world?
-
-While a randomizer shuffles a game, a multi-world randomizer shuffles that game for multiple players. For example, in a
-two player multi-world, players A and B each get their own randomized version of a game, called a world. In each player's
-game, they may find items which belong to the other player. If player A finds an item which belongs to player B, the
-item will be sent to player B's world over the internet.
-
-This creates a cooperative experience during multi-world games, requiring players to rely upon each other to complete
-their game.
-
-## What happens if a person has to leave early?
-
-If a player must leave early, they can use Archipelago's release system. When a player releases their game, all the
-items in that game which belong to other players are sent out automatically, so other players can continue to play.
-
-## What does multi-game mean?
-
-While a multi-world game traditionally requires all players to be playing the same game, a multi-game multi-world allows
-players to randomize any of a number of supported games, and send items between them. This allows players of different
-games to interact with one another in a single multiplayer environment.
-
-## Can I generate a single-player game with Archipelago?
-
-Yes. All our supported games can be generated as single-player experiences, and so long as you download the software,
-the website is not required to generate them.
-
-## How do I get started?
-
-If you are ready to start randomizing games, or want to start playing your favorite randomizer with others, please join
-our discord server at the [Archipelago Discord](https://discord.gg/8Z65BR2). There are always people ready to answer
-any questions you might have.
-
-## What are some common terms I should know?
-
-As randomizers and multiworld randomizers have been around for a while now there are quite a lot of common terms
-and jargon that is used in conjunction by the communities surrounding them. For a lot of the terms that are more common
-to Archipelago and its specific systems please see the [Glossary](/glossary/en).
-
 ## I want to add a game to the Archipelago randomizer. How do I do that?
 
-The best way to get started is to take a look at our code on GitHub
-at [Archipelago GitHub Page](https://github.com/ArchipelagoMW/Archipelago).
+The best way to get started is to take a look at our code on GitHub:  
+[Archipelago GitHub Page](https://github.com/ArchipelagoMW/Archipelago).
 
-There you will find examples of games in the worlds folder
-at [/worlds Folder in Archipelago Code](https://github.com/ArchipelagoMW/Archipelago/tree/main/worlds).
+There, you will find examples of games in the `worlds` folder:  
+[/worlds Folder in Archipelago Code](https://github.com/ArchipelagoMW/Archipelago/tree/main/worlds).
 
-You may also find developer documentation in the docs folder
-at [/docs Folder in Archipelago Code](https://github.com/ArchipelagoMW/Archipelago/tree/main/docs).
+You may also find developer documentation in the `docs` folder:  
+[/docs Folder in Archipelago Code](https://github.com/ArchipelagoMW/Archipelago/tree/main/docs).
 
 If you have more questions, feel free to ask in the **#archipelago-dev** channel on our Discord.

WebHostLib/static/assets/player-options.js

@@ -0,0 +1,523 @@
+let gameName = null;
+
+window.addEventListener('load', () => {
+  gameName = document.getElementById('player-options').getAttribute('data-game');
+
+  // Update game name on page
+  document.getElementById('game-name').innerText = gameName;
+
+  fetchOptionData().then((results) => {
+    let optionHash = localStorage.getItem(`${gameName}-hash`);
+    if (!optionHash) {
+      // If no hash data has been set before, set it now
+      optionHash = md5(JSON.stringify(results));
+      localStorage.setItem(`${gameName}-hash`, optionHash);
+      localStorage.removeItem(gameName);
+    }
+
+    if (optionHash !== md5(JSON.stringify(results))) {
+      showUserMessage(
+          'Your options are out of date! Click here to update them! Be aware this will reset them all to default.'
+      );
+      document.getElementById('user-message').addEventListener('click', resetOptions);
+    }
+
+    // Page setup
+    createDefaultOptions(results);
+    buildUI(results);
+    adjustHeaderWidth();
+
+    // Event listeners
+    document.getElementById('export-options').addEventListener('click', () => exportOptions());
+    document.getElementById('generate-race').addEventListener('click', () => generateGame(true));
+    document.getElementById('generate-game').addEventListener('click', () => generateGame());
+
+    // Name input field
+    const playerOptions = JSON.parse(localStorage.getItem(gameName));
+    const nameInput = document.getElementById('player-name');
+    nameInput.addEventListener('keyup', (event) => updateBaseOption(event));
+    nameInput.value = playerOptions.name;
+
+    // Presets
+    const presetSelect = document.getElementById('game-options-preset');
+    presetSelect.addEventListener('change', (event) => setPresets(results, event.target.value));
+    for (const preset in results['presetOptions']) {
+      const presetOption = document.createElement('option');
+      presetOption.innerText = preset;
+      presetSelect.appendChild(presetOption);
+    }
+    presetSelect.value = localStorage.getItem(`${gameName}-preset`);
+    results['presetOptions']['__default'] = {};
+  }).catch((e) => {
+    console.error(e);
+    const url = new URL(window.location.href);
+    window.location.replace(`${url.protocol}//${url.hostname}/page-not-found`);
+  })
+});
+
+const resetOptions = () => {
+  localStorage.removeItem(gameName);
+  localStorage.removeItem(`${gameName}-hash`);
+  localStorage.removeItem(`${gameName}-preset`);
+  window.location.reload();
+};
+
+const fetchOptionData = () => new Promise((resolve, reject) => {
+  const ajax = new XMLHttpRequest();
+  ajax.onreadystatechange = () => {
+    if (ajax.readyState !== 4) { return; }
+    if (ajax.status !== 200) {
+      reject(ajax.responseText);
+      return;
+    }
+    try{ resolve(JSON.parse(ajax.responseText)); }
+    catch(error){ reject(error); }
+  };
+  ajax.open('GET', `${window.location.origin}/static/generated/player-options/${gameName}.json`, true);
+  ajax.send();
+});
+
+const createDefaultOptions = (optionData) => {
+  if (!localStorage.getItem(gameName)) {
+    const newOptions = {
+      [gameName]: {},
+    };
+    for (let baseOption of Object.keys(optionData.baseOptions)){
+      newOptions[baseOption] = optionData.baseOptions[baseOption];
+    }
+    for (let gameOption of Object.keys(optionData.gameOptions)){
+      newOptions[gameName][gameOption] = optionData.gameOptions[gameOption].defaultValue;
+    }
+    localStorage.setItem(gameName, JSON.stringify(newOptions));
+  }
+
+  if (!localStorage.getItem(`${gameName}-preset`)) {
+    localStorage.setItem(`${gameName}-preset`, '__default');
+  }
+};
+
+const buildUI = (optionData) => {
+  // Game Options
+  const leftGameOpts = {};
+  const rightGameOpts = {};
+  Object.keys(optionData.gameOptions).forEach((key, index) => {
+    if (index < Object.keys(optionData.gameOptions).length / 2) {
+      leftGameOpts[key] = optionData.gameOptions[key];
+    } else {
+      rightGameOpts[key] = optionData.gameOptions[key];
+    }
+  });
+  document.getElementById('game-options-left').appendChild(buildOptionsTable(leftGameOpts));
+  document.getElementById('game-options-right').appendChild(buildOptionsTable(rightGameOpts));
+};
+
+const buildOptionsTable = (options, romOpts = false) => {
+  const currentOptions = JSON.parse(localStorage.getItem(gameName));
+  const table = document.createElement('table');
+  const tbody = document.createElement('tbody');
+
+  Object.keys(options).forEach((option) => {
+    const tr = document.createElement('tr');
+
+    // td Left
+    const tdl = document.createElement('td');
+    const label = document.createElement('label');
+    label.textContent = `${options[option].displayName}: `;
+    label.setAttribute('for', option);
+
+    const questionSpan = document.createElement('span');
+    questionSpan.classList.add('interactive');
+    questionSpan.setAttribute('data-tooltip', options[option].description);
+    questionSpan.innerText = '(?)';
+
+    label.appendChild(questionSpan);
+    tdl.appendChild(label);
+    tr.appendChild(tdl);
+
+    // td Right
+    const tdr = document.createElement('td');
+    let element = null;
+
+    const randomButton = document.createElement('button');
+
+    switch(options[option].type) {
+      case 'select':
+        element = document.createElement('div');
+        element.classList.add('select-container');
+        let select = document.createElement('select');
+        select.setAttribute('id', option);
+        select.setAttribute('data-key', option);
+        if (romOpts) { select.setAttribute('data-romOpt', '1'); }
+        options[option].options.forEach((opt) => {
+          const optionElement = document.createElement('option');
+          optionElement.setAttribute('value', opt.value);
+          optionElement.innerText = opt.name;
+
+          if ((isNaN(currentOptions[gameName][option]) &&
+            (parseInt(opt.value, 10) === parseInt(currentOptions[gameName][option]))) ||
+            (opt.value === currentOptions[gameName][option]))
+          {
+            optionElement.selected = true;
+          }
+          select.appendChild(optionElement);
+        });
+        select.addEventListener('change', (event) => updateGameOption(event.target));
+        element.appendChild(select);
+
+        // Randomize button
+        randomButton.innerText = '🎲';
+        randomButton.classList.add('randomize-button');
+        randomButton.setAttribute('data-key', option);
+        randomButton.setAttribute('data-tooltip', 'Toggle randomization for this option!');
+        randomButton.addEventListener('click', (event) => toggleRandomize(event, select));
+        if (currentOptions[gameName][option] === 'random') {
+          randomButton.classList.add('active');
+          select.disabled = true;
+        }
+
+        element.appendChild(randomButton);
+        break;
+
+      case 'range':
+        element = document.createElement('div');
+        element.classList.add('range-container');
+
+        let range = document.createElement('input');
+        range.setAttribute('id', option);
+        range.setAttribute('type', 'range');
+        range.setAttribute('data-key', option);
+        range.setAttribute('min', options[option].min);
+        range.setAttribute('max', options[option].max);
+        range.value = currentOptions[gameName][option];
+        range.addEventListener('change', (event) => {
+          document.getElementById(`${option}-value`).innerText = event.target.value;
+          updateGameOption(event.target);
+        });
+        element.appendChild(range);
+
+        let rangeVal = document.createElement('span');
+        rangeVal.classList.add('range-value');
+        rangeVal.setAttribute('id', `${option}-value`);
+        rangeVal.innerText = currentOptions[gameName][option] !== 'random' ?
+          currentOptions[gameName][option] : options[option].defaultValue;
+        element.appendChild(rangeVal);
+
+        // Randomize button
+        randomButton.innerText = '🎲';
+        randomButton.classList.add('randomize-button');
+        randomButton.setAttribute('data-key', option);
+        randomButton.setAttribute('data-tooltip', 'Toggle randomization for this option!');
+        randomButton.addEventListener('click', (event) => toggleRandomize(event, range));
+        if (currentOptions[gameName][option] === 'random') {
+          randomButton.classList.add('active');
+          range.disabled = true;
+        }
+
+        element.appendChild(randomButton);
+        break;
+
+      case 'named_range':
+        element = document.createElement('div');
+        element.classList.add('named-range-container');
+
+        // Build the select element
+        let namedRangeSelect = document.createElement('select');
+        namedRangeSelect.setAttribute('data-key', option);
+        Object.keys(options[option].value_names).forEach((presetName) => {
+          let presetOption = document.createElement('option');
+          presetOption.innerText = presetName;
+          presetOption.value = options[option].value_names[presetName];
+          const words = presetOption.innerText.split('_');
+          for (let i = 0; i < words.length; i++) {
+            words[i] = words[i][0].toUpperCase() + words[i].substring(1);
+          }
+          presetOption.innerText = words.join(' ');
+          namedRangeSelect.appendChild(presetOption);
+        });
+        let customOption = document.createElement('option');
+        customOption.innerText = 'Custom';
+        customOption.value = 'custom';
+        customOption.selected = true;
+        namedRangeSelect.appendChild(customOption);
+        if (Object.values(options[option].value_names).includes(Number(currentOptions[gameName][option]))) {
+          namedRangeSelect.value = Number(currentOptions[gameName][option]);
+        }
+
+        // Build range element
+        let namedRangeWrapper = document.createElement('div');
+        namedRangeWrapper.classList.add('named-range-wrapper');
+        let namedRange = document.createElement('input');
+        namedRange.setAttribute('type', 'range');
+        namedRange.setAttribute('data-key', option);
+        namedRange.setAttribute('min', options[option].min);
+        namedRange.setAttribute('max', options[option].max);
+        namedRange.value = currentOptions[gameName][option];
+
+        // Build rage value element
+        let namedRangeVal = document.createElement('span');
+        namedRangeVal.classList.add('range-value');
+        namedRangeVal.setAttribute('id', `${option}-value`);
+        namedRangeVal.innerText = currentOptions[gameName][option] !== 'random' ?
+          currentOptions[gameName][option] : options[option].defaultValue;
+
+        // Configure select event listener
+        namedRangeSelect.addEventListener('change', (event) => {
+          if (event.target.value === 'custom') { return; }
+
+          // Update range slider
+          namedRange.value = event.target.value;
+          document.getElementById(`${option}-value`).innerText = event.target.value;
+          updateGameOption(event.target);
+        });
+
+        // Configure range event handler
+        namedRange.addEventListener('change', (event) => {
+          // Update select element
+          namedRangeSelect.value =
+            (Object.values(options[option].value_names).includes(parseInt(event.target.value))) ?
+            parseInt(event.target.value) : 'custom';
+          document.getElementById(`${option}-value`).innerText = event.target.value;
+          updateGameOption(event.target);
+        });
+
+        element.appendChild(namedRangeSelect);
+        namedRangeWrapper.appendChild(namedRange);
+        namedRangeWrapper.appendChild(namedRangeVal);
+        element.appendChild(namedRangeWrapper);
+
+        // Randomize button
+        randomButton.innerText = '🎲';
+        randomButton.classList.add('randomize-button');
+        randomButton.setAttribute('data-key', option);
+        randomButton.setAttribute('data-tooltip', 'Toggle randomization for this option!');
+        randomButton.addEventListener('click', (event) => toggleRandomize(
+            event, namedRange, namedRangeSelect)
+        );
+        if (currentOptions[gameName][option] === 'random') {
+          randomButton.classList.add('active');
+          namedRange.disabled = true;
+          namedRangeSelect.disabled = true;
+        }
+
+        namedRangeWrapper.appendChild(randomButton);
+        break;
+
+      default:
+        console.error(`Ignoring unknown option type: ${options[option].type} with name ${option}`);
+        return;
+    }
+
+    tdr.appendChild(element);
+    tr.appendChild(tdr);
+    tbody.appendChild(tr);
+  });
+
+  table.appendChild(tbody);
+  return table;
+};
+
+const setPresets = (optionsData, presetName) => {
+  const defaults = optionsData['gameOptions'];
+  const preset = optionsData['presetOptions'][presetName];
+
+  localStorage.setItem(`${gameName}-preset`, presetName);
+
+  if (!preset) {
+    console.error(`No presets defined for preset name: '${presetName}'`);
+    return;
+  }
+
+  const updateOptionElement = (option, presetValue) => {
+    const optionElement = document.querySelector(`#${option}[data-key='${option}']`);
+    const randomElement = document.querySelector(`.randomize-button[data-key='${option}']`);
+
+    if (presetValue === 'random') {
+      randomElement.classList.add('active');
+      optionElement.disabled = true;
+      updateGameOption(randomElement, false);
+    } else {
+      optionElement.value = presetValue;
+      randomElement.classList.remove('active');
+      optionElement.disabled = undefined;
+      updateGameOption(optionElement, false);
+    }
+  };
+
+  for (const option in defaults) {
+    let presetValue = preset[option];
+    if (presetValue === undefined) {
+      // Using the default value if not set in presets.
+      presetValue = defaults[option]['defaultValue'];
+    }
+
+    switch (defaults[option].type) {
+      case 'range':
+        const numberElement = document.querySelector(`#${option}-value`);
+        if (presetValue === 'random') {
+          numberElement.innerText = defaults[option]['defaultValue'] === 'random'
+              ? defaults[option]['min'] // A fallback so we don't print 'random' in the UI.
+              : defaults[option]['defaultValue'];
+        } else {
+          numberElement.innerText = presetValue;
+        }
+
+        updateOptionElement(option, presetValue);
+        break;
+
+      case 'select': {
+        updateOptionElement(option, presetValue);
+        break;
+      }
+
+      case 'named_range': {
+        const selectElement = document.querySelector(`select[data-key='${option}']`);
+        const rangeElement = document.querySelector(`input[data-key='${option}']`);
+        const randomElement = document.querySelector(`.randomize-button[data-key='${option}']`);
+
+        if (presetValue === 'random') {
+          randomElement.classList.add('active');
+          selectElement.disabled = true;
+          rangeElement.disabled = true;
+          updateGameOption(randomElement, false);
+        } else {
+          rangeElement.value = presetValue;
+          selectElement.value = Object.values(defaults[option]['value_names']).includes(parseInt(presetValue)) ?
+              parseInt(presetValue) : 'custom';
+          document.getElementById(`${option}-value`).innerText = presetValue;
+
+          randomElement.classList.remove('active');
+          selectElement.disabled = undefined;
+          rangeElement.disabled = undefined;
+          updateGameOption(rangeElement, false);
+        }
+        break;
+      }
+
+      default:
+        console.warn(`Ignoring preset value for unknown option type: ${defaults[option].type} with name ${option}`);
+        break;
+    }
+  }
+};
+
+const toggleRandomize = (event, inputElement, optionalSelectElement = null) => {
+  const active = event.target.classList.contains('active');
+  const randomButton = event.target;
+
+  if (active) {
+    randomButton.classList.remove('active');
+    inputElement.disabled = undefined;
+    if (optionalSelectElement) {
+      optionalSelectElement.disabled = undefined;
+    }
+  } else {
+    randomButton.classList.add('active');
+    inputElement.disabled = true;
+    if (optionalSelectElement) {
+      optionalSelectElement.disabled = true;
+    }
+  }
+    updateGameOption(active ? inputElement : randomButton);
+};
+
+const updateBaseOption = (event) => {
+  const options = JSON.parse(localStorage.getItem(gameName));
+  options[event.target.getAttribute('data-key')] = isNaN(event.target.value) ?
+    event.target.value : parseInt(event.target.value);
+  localStorage.setItem(gameName, JSON.stringify(options));
+};
+
+const updateGameOption = (optionElement, toggleCustomPreset = true) => {
+  const options = JSON.parse(localStorage.getItem(gameName));
+
+  if (toggleCustomPreset) {
+    localStorage.setItem(`${gameName}-preset`, '__custom');
+    const presetElement = document.getElementById('game-options-preset');
+    presetElement.value = '__custom';
+  }
+
+  if (optionElement.classList.contains('randomize-button')) {
+    // If the event passed in is the randomize button, then we know what we must do.
+    options[gameName][optionElement.getAttribute('data-key')] = 'random';
+  } else {
+    options[gameName][optionElement.getAttribute('data-key')] = isNaN(optionElement.value) ?
+      optionElement.value : parseInt(optionElement.value, 10);
+  }
+
+  localStorage.setItem(gameName, JSON.stringify(options));
+};
+
+const exportOptions = () => {
+  const options = JSON.parse(localStorage.getItem(gameName));
+  const preset = localStorage.getItem(`${gameName}-preset`);
+  switch (preset) {
+    case '__default':
+      options['description'] = `Generated by https://archipelago.gg with the default preset.`;
+      break;
+
+    case '__custom':
+      options['description'] = `Generated by https://archipelago.gg.`;
+      break;
+
+    default:
+      options['description'] = `Generated by https://archipelago.gg with the ${preset} preset.`;
+  }
+
+  if (!options.name || options.name.toString().trim().length === 0) {
+    return showUserMessage('You must enter a player name!');
+  }
+  const yamlText = jsyaml.safeDump(options, { noCompatMode: true }).replaceAll(/'(\d+)':/g, (x, y) => `${y}:`);
+  download(`${document.getElementById('player-name').value}.yaml`, yamlText);
+};
+
+/** Create an anchor and trigger a download of a text file. */
+const download = (filename, text) => {
+  const downloadLink = document.createElement('a');
+  downloadLink.setAttribute('href','data:text/yaml;charset=utf-8,'+ encodeURIComponent(text))
+  downloadLink.setAttribute('download', filename);
+  downloadLink.style.display = 'none';
+  document.body.appendChild(downloadLink);
+  downloadLink.click();
+  document.body.removeChild(downloadLink);
+};
+
+const generateGame = (raceMode = false) => {
+  const options = JSON.parse(localStorage.getItem(gameName));
+  if (!options.name || options.name.toLowerCase() === 'player' || options.name.trim().length === 0) {
+    return showUserMessage('You must enter a player name!');
+  }
+
+  axios.post('/api/generate', {
+    weights: { player: options },
+    presetData: { player: options },
+    playerCount: 1,
+    spoiler: 3,
+    race: raceMode ? '1' : '0',
+  }).then((response) => {
+    window.location.href = response.data.url;
+  }).catch((error) => {
+    let userMessage = 'Something went wrong and your game could not be generated.';
+    if (error.response.data.text) {
+      userMessage += ' ' + error.response.data.text;
+    }
+    showUserMessage(userMessage);
+    console.error(error);
+  });
+};
+
+const showUserMessage = (message) => {
+  const userMessage = document.getElementById('user-message');
+    userMessage.innerText = message;
+    userMessage.classList.add('visible');
+    window.scrollTo(0, 0);
+    userMessage.addEventListener('click', () => {
+      userMessage.classList.remove('visible');
+      userMessage.addEventListener('click', hideUserMessage);
+    });
+};
+
+const hideUserMessage = () => {
+  const userMessage = document.getElementById('user-message');
+  userMessage.classList.remove('visible');
+  userMessage.removeEventListener('click', hideUserMessage);
+};

WebHostLib/static/assets/player-settings.js

@@ -1,395 +0,0 @@
-let gameName = null;
-
-window.addEventListener('load', () => {
-  gameName = document.getElementById('player-settings').getAttribute('data-game');
-
-  // Update game name on page
-  document.getElementById('game-name').innerText = gameName;
-
-  fetchSettingData().then((results) => {
-    let settingHash = localStorage.getItem(`${gameName}-hash`);
-    if (!settingHash) {
-      // If no hash data has been set before, set it now
-      settingHash = md5(JSON.stringify(results));
-      localStorage.setItem(`${gameName}-hash`, settingHash);
-      localStorage.removeItem(gameName);
-    }
-
-    if (settingHash !== md5(JSON.stringify(results))) {
-      showUserMessage("Your settings are out of date! Click here to update them! Be aware this will reset " +
-        "them all to default.");
-      document.getElementById('user-message').addEventListener('click', resetSettings);
-    }
-
-    // Page setup
-    createDefaultSettings(results);
-    buildUI(results);
-    adjustHeaderWidth();
-
-    // Event listeners
-    document.getElementById('export-settings').addEventListener('click', () => exportSettings());
-    document.getElementById('generate-race').addEventListener('click', () => generateGame(true));
-    document.getElementById('generate-game').addEventListener('click', () => generateGame());
-
-    // Name input field
-    const playerSettings = JSON.parse(localStorage.getItem(gameName));
-    const nameInput = document.getElementById('player-name');
-    nameInput.addEventListener('keyup', (event) => updateBaseSetting(event));
-    nameInput.value = playerSettings.name;
-  }).catch((e) => {
-    console.error(e);
-    const url = new URL(window.location.href);
-    window.location.replace(`${url.protocol}//${url.hostname}/page-not-found`);
-  })
-});
-
-const resetSettings = () => {
-  localStorage.removeItem(gameName);
-  localStorage.removeItem(`${gameName}-hash`)
-  window.location.reload();
-};
-
-const fetchSettingData = () => new Promise((resolve, reject) => {
-  const ajax = new XMLHttpRequest();
-  ajax.onreadystatechange = () => {
-    if (ajax.readyState !== 4) { return; }
-    if (ajax.status !== 200) {
-      reject(ajax.responseText);
-      return;
-    }
-    try{ resolve(JSON.parse(ajax.responseText)); }
-    catch(error){ reject(error); }
-  };
-  ajax.open('GET', `${window.location.origin}/static/generated/player-settings/${gameName}.json`, true);
-  ajax.send();
-});
-
-const createDefaultSettings = (settingData) => {
-  if (!localStorage.getItem(gameName)) {
-    const newSettings = {
-      [gameName]: {},
-    };
-    for (let baseOption of Object.keys(settingData.baseOptions)){
-      newSettings[baseOption] = settingData.baseOptions[baseOption];
-    }
-    for (let gameOption of Object.keys(settingData.gameOptions)){
-      newSettings[gameName][gameOption] = settingData.gameOptions[gameOption].defaultValue;
-    }
-    localStorage.setItem(gameName, JSON.stringify(newSettings));
-  }
-};
-
-const buildUI = (settingData) => {
-  // Game Options
-  const leftGameOpts = {};
-  const rightGameOpts = {};
-  Object.keys(settingData.gameOptions).forEach((key, index) => {
-    if (index < Object.keys(settingData.gameOptions).length / 2) { leftGameOpts[key] = settingData.gameOptions[key]; }
-    else { rightGameOpts[key] = settingData.gameOptions[key]; }
-  });
-  document.getElementById('game-options-left').appendChild(buildOptionsTable(leftGameOpts));
-  document.getElementById('game-options-right').appendChild(buildOptionsTable(rightGameOpts));
-};
-
-const buildOptionsTable = (settings, romOpts = false) => {
-  const currentSettings = JSON.parse(localStorage.getItem(gameName));
-  const table = document.createElement('table');
-  const tbody = document.createElement('tbody');
-
-  Object.keys(settings).forEach((setting) => {
-    const tr = document.createElement('tr');
-
-    // td Left
-    const tdl = document.createElement('td');
-    const label = document.createElement('label');
-    label.textContent = `${settings[setting].displayName}: `;
-    label.setAttribute('for', setting);
-
-    const questionSpan = document.createElement('span');
-    questionSpan.classList.add('interactive');
-    questionSpan.setAttribute('data-tooltip', settings[setting].description);
-    questionSpan.innerText = '(?)';
-
-    label.appendChild(questionSpan);
-    tdl.appendChild(label);
-    tr.appendChild(tdl);
-
-    // td Right
-    const tdr = document.createElement('td');
-    let element = null;
-
-    const randomButton = document.createElement('button');
-
-    switch(settings[setting].type){
-      case 'select':
-        element = document.createElement('div');
-        element.classList.add('select-container');
-        let select = document.createElement('select');
-        select.setAttribute('id', setting);
-        select.setAttribute('data-key', setting);
-        if (romOpts) { select.setAttribute('data-romOpt', '1'); }
-        settings[setting].options.forEach((opt) => {
-          const option = document.createElement('option');
-          option.setAttribute('value', opt.value);
-          option.innerText = opt.name;
-          if ((isNaN(currentSettings[gameName][setting]) &&
-            (parseInt(opt.value, 10) === parseInt(currentSettings[gameName][setting]))) ||
-            (opt.value === currentSettings[gameName][setting]))
-          {
-            option.selected = true;
-          }
-          select.appendChild(option);
-        });
-        select.addEventListener('change', (event) => updateGameSetting(event.target));
-        element.appendChild(select);
-
-        // Randomize button
-        randomButton.innerText = '🎲';
-        randomButton.classList.add('randomize-button');
-        randomButton.setAttribute('data-key', setting);
-        randomButton.setAttribute('data-tooltip', 'Toggle randomization for this option!');
-        randomButton.addEventListener('click', (event) => toggleRandomize(event, [select]));
-        if (currentSettings[gameName][setting] === 'random') {
-          randomButton.classList.add('active');
-          select.disabled = true;
-        }
-
-        element.appendChild(randomButton);
-        break;
-
-      case 'range':
-        element = document.createElement('div');
-        element.classList.add('range-container');
-
-        let range = document.createElement('input');
-        range.setAttribute('type', 'range');
-        range.setAttribute('data-key', setting);
-        range.setAttribute('min', settings[setting].min);
-        range.setAttribute('max', settings[setting].max);
-        range.value = currentSettings[gameName][setting];
-        range.addEventListener('change', (event) => {
-          document.getElementById(`${setting}-value`).innerText = event.target.value;
-          updateGameSetting(event.target);
-        });
-        element.appendChild(range);
-
-        let rangeVal = document.createElement('span');
-        rangeVal.classList.add('range-value');
-        rangeVal.setAttribute('id', `${setting}-value`);
-        rangeVal.innerText = currentSettings[gameName][setting] !== 'random' ?
-          currentSettings[gameName][setting] : settings[setting].defaultValue;
-        element.appendChild(rangeVal);
-
-        // Randomize button
-        randomButton.innerText = '🎲';
-        randomButton.classList.add('randomize-button');
-        randomButton.setAttribute('data-key', setting);
-        randomButton.setAttribute('data-tooltip', 'Toggle randomization for this option!');
-        randomButton.addEventListener('click', (event) => toggleRandomize(event, [range]));
-        if (currentSettings[gameName][setting] === 'random') {
-          randomButton.classList.add('active');
-          range.disabled = true;
-        }
-
-        element.appendChild(randomButton);
-        break;
-
-      case 'special_range':
-        element = document.createElement('div');
-        element.classList.add('special-range-container');
-
-        // Build the select element
-        let specialRangeSelect = document.createElement('select');
-        specialRangeSelect.setAttribute('data-key', setting);
-        Object.keys(settings[setting].value_names).forEach((presetName) => {
-          let presetOption = document.createElement('option');
-          presetOption.innerText = presetName;
-          presetOption.value = settings[setting].value_names[presetName];
-          const words = presetOption.innerText.split("_");
-          for (let i = 0; i < words.length; i++) {
-            words[i] = words[i][0].toUpperCase() + words[i].substring(1);
-          }
-          presetOption.innerText = words.join(" ");
-          specialRangeSelect.appendChild(presetOption);
-        });
-        let customOption = document.createElement('option');
-        customOption.innerText = 'Custom';
-        customOption.value = 'custom';
-        customOption.selected = true;
-        specialRangeSelect.appendChild(customOption);
-        if (Object.values(settings[setting].value_names).includes(Number(currentSettings[gameName][setting]))) {
-          specialRangeSelect.value = Number(currentSettings[gameName][setting]);
-        }
-
-        // Build range element
-        let specialRangeWrapper = document.createElement('div');
-        specialRangeWrapper.classList.add('special-range-wrapper');
-        let specialRange = document.createElement('input');
-        specialRange.setAttribute('type', 'range');
-        specialRange.setAttribute('data-key', setting);
-        specialRange.setAttribute('min', settings[setting].min);
-        specialRange.setAttribute('max', settings[setting].max);
-        specialRange.value = currentSettings[gameName][setting];
-
-        // Build rage value element
-        let specialRangeVal = document.createElement('span');
-        specialRangeVal.classList.add('range-value');
-        specialRangeVal.setAttribute('id', `${setting}-value`);
-        specialRangeVal.innerText = currentSettings[gameName][setting] !== 'random' ?
-          currentSettings[gameName][setting] : settings[setting].defaultValue;
-
-        // Configure select event listener
-        specialRangeSelect.addEventListener('change', (event) => {
-          if (event.target.value === 'custom') { return; }
-
-          // Update range slider
-          specialRange.value = event.target.value;
-          document.getElementById(`${setting}-value`).innerText = event.target.value;
-          updateGameSetting(event.target);
-        });
-
-        // Configure range event handler
-        specialRange.addEventListener('change', (event) => {
-          // Update select element
-          specialRangeSelect.value =
-            (Object.values(settings[setting].value_names).includes(parseInt(event.target.value))) ?
-            parseInt(event.target.value) : 'custom';
-          document.getElementById(`${setting}-value`).innerText = event.target.value;
-          updateGameSetting(event.target);
-        });
-
-        element.appendChild(specialRangeSelect);
-        specialRangeWrapper.appendChild(specialRange);
-        specialRangeWrapper.appendChild(specialRangeVal);
-        element.appendChild(specialRangeWrapper);
-
-        // Randomize button
-        randomButton.innerText = '🎲';
-        randomButton.classList.add('randomize-button');
-        randomButton.setAttribute('data-key', setting);
-        randomButton.setAttribute('data-tooltip', 'Toggle randomization for this option!');
-        randomButton.addEventListener('click', (event) => toggleRandomize(
-            event, [specialRange, specialRangeSelect])
-        );
-        if (currentSettings[gameName][setting] === 'random') {
-          randomButton.classList.add('active');
-          specialRange.disabled = true;
-          specialRangeSelect.disabled = true;
-        }
-
-        specialRangeWrapper.appendChild(randomButton);
-        break;
-
-      default:
-        console.error(`Ignoring unknown setting type: ${settings[setting].type} with name ${setting}`);
-        return;
-    }
-
-    tdr.appendChild(element);
-    tr.appendChild(tdr);
-    tbody.appendChild(tr);
-  });
-
-  table.appendChild(tbody);
-  return table;
-};
-
-const toggleRandomize = (event, inputElements) => {
-  const active = event.target.classList.contains('active');
-  const randomButton = event.target;
-
-  if (active) {
-    randomButton.classList.remove('active');
-    for (const element of inputElements) {
-      element.disabled = undefined;
-      updateGameSetting(element);
-    }
-  } else {
-    randomButton.classList.add('active');
-    for (const element of inputElements) {
-      element.disabled = true;
-      updateGameSetting(randomButton);
-    }
-  }
-};
-
-const updateBaseSetting = (event) => {
-  const options = JSON.parse(localStorage.getItem(gameName));
-  options[event.target.getAttribute('data-key')] = isNaN(event.target.value) ?
-    event.target.value : parseInt(event.target.value);
-  localStorage.setItem(gameName, JSON.stringify(options));
-};
-
-const updateGameSetting = (settingElement) => {
-  const options = JSON.parse(localStorage.getItem(gameName));
-
-  if (settingElement.classList.contains('randomize-button')) {
-    // If the event passed in is the randomize button, then we know what we must do.
-    options[gameName][settingElement.getAttribute('data-key')] = 'random';
-  } else {
-    options[gameName][settingElement.getAttribute('data-key')] = isNaN(settingElement.value) ?
-      settingElement.value : parseInt(settingElement.value, 10);
-  }
-
-  localStorage.setItem(gameName, JSON.stringify(options));
-};
-
-const exportSettings = () => {
-  const settings = JSON.parse(localStorage.getItem(gameName));
-  if (!settings.name || settings.name.toLowerCase() === 'player' || settings.name.trim().length === 0) {
-    return showUserMessage('You must enter a player name!');
-  }
-  const yamlText = jsyaml.safeDump(settings, { noCompatMode: true }).replaceAll(/'(\d+)':/g, (x, y) => `${y}:`);
-  download(`${document.getElementById('player-name').value}.yaml`, yamlText);
-};
-
-/** Create an anchor and trigger a download of a text file. */
-const download = (filename, text) => {
-  const downloadLink = document.createElement('a');
-  downloadLink.setAttribute('href','data:text/yaml;charset=utf-8,'+ encodeURIComponent(text))
-  downloadLink.setAttribute('download', filename);
-  downloadLink.style.display = 'none';
-  document.body.appendChild(downloadLink);
-  downloadLink.click();
-  document.body.removeChild(downloadLink);
-};
-
-const generateGame = (raceMode = false) => {
-  const settings = JSON.parse(localStorage.getItem(gameName));
-  if (!settings.name || settings.name.toLowerCase() === 'player' || settings.name.trim().length === 0) {
-    return showUserMessage('You must enter a player name!');
-  }
-
-  axios.post('/api/generate', {
-    weights: { player: settings },
-    presetData: { player: settings },
-    playerCount: 1,
-    race: raceMode ? '1' : '0',
-  }).then((response) => {
-    window.location.href = response.data.url;
-  }).catch((error) => {
-    let userMessage = 'Something went wrong and your game could not be generated.';
-    if (error.response.data.text) {
-      userMessage += ' ' + error.response.data.text;
-    }
-    showUserMessage(userMessage);
-    console.error(error);
-  });
-};
-
-const showUserMessage = (message) => {
-  const userMessage = document.getElementById('user-message');
-    userMessage.innerText = message;
-    userMessage.classList.add('visible');
-    window.scrollTo(0, 0);
-    userMessage.addEventListener('click', () => {
-      userMessage.classList.remove('visible');
-      userMessage.addEventListener('click', hideUserMessage);
-    });
-};
-
-const hideUserMessage = () => {
-  const userMessage = document.getElementById('user-message');
-  userMessage.classList.remove('visible');
-  userMessage.removeEventListener('click', hideUserMessage);
-};

WebHostLib/static/assets/sc2Tracker.js

@@ -25,16 +25,16 @@ window.addEventListener('load', () => {
 
   // Collapsible advancement sections
   const categories = document.getElementsByClassName("location-category");
-  for (let i = 0; i < categories.length; i++) {
-    let hide_id = categories[i].id.split('-')[0];
-    if (hide_id == 'Total') {
+  for (let category of categories) {
+    let hide_id = category.id.split('_')[0];
+    if (hide_id === 'Total') {
       continue;
     }
-    categories[i].addEventListener('click', function() {
+    category.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/assets/supportedGames.js

@@ -0,0 +1,64 @@
+window.addEventListener('load', () => {
+  // Add toggle listener to all elements with .collapse-toggle
+  const toggleButtons = document.querySelectorAll('.collapse-toggle');
+  toggleButtons.forEach((e) => e.addEventListener('click', toggleCollapse));
+
+  // Handle game filter input
+  const gameSearch = document.getElementById('game-search');
+  gameSearch.value = '';
+  gameSearch.addEventListener('input', (evt) => {
+    if (!evt.target.value.trim()) {
+      // If input is empty, display all collapsed games
+      return toggleButtons.forEach((header) => {
+        header.style.display = null;
+        header.firstElementChild.innerText = '▶';
+        header.nextElementSibling.classList.add('collapsed');
+      });
+    }
+
+    // Loop over all the games
+    toggleButtons.forEach((header) => {
+      // If the game name includes the search string, display the game. If not, hide it
+      if (header.getAttribute('data-game').toLowerCase().includes(evt.target.value.toLowerCase())) {
+        header.style.display = null;
+        header.firstElementChild.innerText = '▼';
+        header.nextElementSibling.classList.remove('collapsed');
+      } else {
+        header.style.display = 'none';
+        header.firstElementChild.innerText = '▶';
+        header.nextElementSibling.classList.add('collapsed');
+      }
+    });
+  });
+
+  document.getElementById('expand-all').addEventListener('click', expandAll);
+  document.getElementById('collapse-all').addEventListener('click', collapseAll);
+});
+
+const toggleCollapse = (evt) => {
+  const gameArrow = evt.target.firstElementChild;
+  const gameInfo = evt.target.nextElementSibling;
+  if (gameInfo.classList.contains('collapsed')) {
+    gameArrow.innerText = '▼';
+    gameInfo.classList.remove('collapsed');
+  } else {
+    gameArrow.innerText = '▶';
+    gameInfo.classList.add('collapsed');
+  }
+};
+
+const expandAll = () => {
+  document.querySelectorAll('.collapse-toggle').forEach((header) => {
+    if (header.style.display === 'none') { return; }
+    header.firstElementChild.innerText = '▼';
+    header.nextElementSibling.classList.remove('collapsed');
+  });
+};
+
+const collapseAll = () => {
+  document.querySelectorAll('.collapse-toggle').forEach((header) => {
+    if (header.style.display === 'none') { return; }
+    header.firstElementChild.innerText = '▶';
+    header.nextElementSibling.classList.add('collapsed');
+  });
+};

WebHostLib/static/assets/trackerCommon.js

@@ -4,16 +4,34 @@ const adjustTableHeight = () => {
         return;
     const upperDistance = tablesContainer.getBoundingClientRect().top;
 
-    const containerHeight = window.innerHeight - upperDistance;
-    tablesContainer.style.maxHeight = `calc(${containerHeight}px - 1rem)`;
-
     const tableWrappers = document.getElementsByClassName('table-wrapper');
-    for(let i=0; i < tableWrappers.length; i++){
-        const maxHeight = (window.innerHeight - upperDistance) / 2;
-        tableWrappers[i].style.maxHeight = `calc(${maxHeight}px - 1rem)`;
+    for (let i = 0; i < tableWrappers.length; i++) {
+        // Ensure we are starting from maximum size prior to calculation.
+        tableWrappers[i].style.height = null;
+        tableWrappers[i].style.maxHeight = null;
+
+        // Set as a reasonable height, but still allows the user to resize element if they desire.
+        const currentHeight = tableWrappers[i].offsetHeight;
+        const maxHeight = (window.innerHeight - upperDistance) / Math.min(tableWrappers.length, 4);
+        if (currentHeight > maxHeight) {
+            tableWrappers[i].style.height = `calc(${maxHeight}px - 1rem)`;
+        }
+
+        tableWrappers[i].style.maxHeight = `${currentHeight}px`;
     }
 };
 
+/**
+ * Convert an integer number of seconds into a human readable HH:MM format
+ * @param {Number} seconds
+ * @returns {string}
+ */
+const secondsToHours = (seconds) => {
+    let hours   = Math.floor(seconds / 3600);
+    let minutes = Math.floor((seconds - (hours * 3600)) / 60).toString().padStart(2, '0');
+    return `${hours}:${minutes}`;
+};
+
 window.addEventListener('load', () => {
     const tables = $(".table").DataTable({
         paging: false,
@@ -27,24 +45,31 @@ window.addEventListener('load', () => {
         stateLoadCallback: function(settings) {
             return JSON.parse(localStorage.getItem(`DataTables_${settings.sInstance}_/tracker`));
         },
+        footerCallback: function(tfoot, data, start, end, display) {
+            if (tfoot) {
+                const activityData = this.api().column('lastActivity:name').data().toArray().filter(x => !isNaN(x));
+                Array.from(tfoot?.children).find(td => td.classList.contains('last-activity')).innerText =
+                  (activityData.length) ? secondsToHours(Math.min(...activityData)) : 'None';
+            }
+        },
         columnDefs: [
+            {
+                targets: 'last-activity',
+                name: 'lastActivity'
+            },
             {
                 targets: 'hours',
                 render: function (data, type, row) {
                     if (type === "sort" || type === 'type') {
                         if (data === "None")
-                            return -1;
+                            return Number.MAX_VALUE;
 
                         return parseInt(data);
                     }
                     if (data === "None")
                         return data;
 
-                    let hours   = Math.floor(data / 3600);
-                    let minutes = Math.floor((data - (hours * 3600)) / 60);
-
-                    if (minutes < 10) {minutes = "0"+minutes;}
-                    return hours+':'+minutes;
+                    return secondsToHours(data);
                 }
             },
             {
@@ -114,11 +139,16 @@ window.addEventListener('load', () => {
             if (status === "success") {
                 target.find(".table").each(function (i, new_table) {
                     const new_trs = $(new_table).find("tbody>tr");
+                    const footer_tr = $(new_table).find("tfoot>tr");
                     const old_table = tables.eq(i);
                     const topscroll = $(old_table.settings()[0].nScrollBody).scrollTop();
                     const leftscroll = $(old_table.settings()[0].nScrollBody).scrollLeft();
                     old_table.clear();
-                    old_table.rows.add(new_trs).draw();
+                    if (footer_tr.length) {
+                        $(old_table.table).find("tfoot").html(footer_tr);
+                    }
+                    old_table.rows.add(new_trs);
+                    old_table.draw();
                     $(old_table.settings()[0].nScrollBody).scrollTop(topscroll);
                     $(old_table.settings()[0].nScrollBody).scrollLeft(leftscroll);
                 });

WebHostLib/static/styles/landing.css

@@ -235,9 +235,6 @@ html{
     line-height: 30px;
 }
 
-#landing .variable{
-    color: #ffff00;
-}
 
 .landing-deco{
     position: absolute;

WebHostLib/static/styles/player-options.css

@@ -4,8 +4,9 @@ html{
     background-size: 650px 650px;
 }
 
-#player-settings{
-    max-width: 1000px;
+#player-options{
+    box-sizing: border-box;
+    max-width: 1024px;
     margin-left: auto;
     margin-right: auto;
     background-color: rgba(0, 0, 0, 0.15);
@@ -14,14 +15,14 @@ html{
     color: #eeffeb;
 }
 
-#player-settings #player-settings-button-row{
+#player-options #player-options-button-row{
     display: flex;
     flex-direction: row;
     justify-content: space-between;
     margin-top: 15px;
 }
 
-#player-settings code{
+#player-options code{
     background-color: #d9cd8e;
     border-radius: 4px;
     padding-left: 0.25rem;
@@ -29,7 +30,7 @@ html{
     color: #000000;
 }
 
-#player-settings #user-message{
+#player-options #user-message{
     display: none;
     width: calc(100% - 8px);
     background-color: #ffe86b;
@@ -39,12 +40,12 @@ html{
     text-align: center;
 }
 
-#player-settings #user-message.visible{
+#player-options #user-message.visible{
     display: block;
     cursor: pointer;
 }
 
-#player-settings h1{
+#player-options h1{
     font-size: 2.5rem;
     font-weight: normal;
     width: 100%;
@@ -52,7 +53,7 @@ html{
     text-shadow: 1px 1px 4px #000000;
 }
 
-#player-settings h2{
+#player-options h2{
     font-size: 40px;
     font-weight: normal;
     width: 100%;
@@ -61,22 +62,22 @@ html{
     text-shadow: 1px 1px 2px #000000;
 }
 
-#player-settings h3, #player-settings h4, #player-settings h5, #player-settings h6{
+#player-options h3, #player-options h4, #player-options h5, #player-options h6{
     text-shadow: 1px 1px 1px rgba(0, 0, 0, 0.5);
 }
 
-#player-settings input:not([type]){
+#player-options input:not([type]){
     border: 1px solid #000000;
     padding: 3px;
     border-radius: 3px;
     min-width: 150px;
 }
 
-#player-settings input:not([type]):focus{
+#player-options input:not([type]):focus{
     border: 1px solid #ffffff;
 }
 
-#player-settings select{
+#player-options select{
     border: 1px solid #000000;
     padding: 3px;
     border-radius: 3px;
@@ -84,72 +85,97 @@ html{
     background-color: #ffffff;
 }
 
-#player-settings #game-options, #player-settings #rom-options{
+#player-options #game-options, #player-options #rom-options{
     display: flex;
     flex-direction: row;
 }
 
-#player-settings .left, #player-settings .right{
+#player-options #meta-options {
+    display: flex;
+    justify-content: space-between;
+    gap: 20px;
+    padding: 3px;
+}
+
+#player-options div {
+    display: flex;
     flex-grow: 1;
 }
 
-#player-settings .left{
+#player-options #meta-options label {
+    display: inline-block;
+    min-width: 180px;
+    flex-grow: 1;
+}
+
+#player-options #meta-options input,
+#player-options #meta-options select {
+    box-sizing: border-box;
+    min-width: 150px;
+    width: 50%;
+}
+
+#player-options .left, #player-options .right{
+    flex-grow: 1;
+}
+
+#player-options .left{
     margin-right: 10px;
 }
 
-#player-settings .right{
+#player-options .right{
     margin-left: 10px;
 }
 
-#player-settings table{
+#player-options table{
     margin-bottom: 30px;
     width: 100%;
 }
 
-#player-settings table .select-container{
+#player-options table .select-container{
     display: flex;
     flex-direction: row;
 }
 
-#player-settings table .select-container select{
+#player-options table .select-container select{
     min-width: 200px;
     flex-grow: 1;
 }
 
-#player-settings table select:disabled{
+#player-options table select:disabled{
     background-color: lightgray;
 }
 
-#player-settings table .range-container{
+#player-options table .range-container{
     display: flex;
     flex-direction: row;
 }
 
-#player-settings table .range-container input[type=range]{
+#player-options table .range-container input[type=range]{
     flex-grow: 1;
 }
 
-#player-settings table .range-value{
+#player-options table .range-value{
     min-width: 20px;
     margin-left: 0.25rem;
 }
 
-#player-settings table .special-range-container{
+#player-options table .named-range-container{
     display: flex;
     flex-direction: column;
 }
 
-#player-settings table .special-range-wrapper{
+#player-options table .named-range-wrapper{
     display: flex;
     flex-direction: row;
     margin-top: 0.25rem;
 }
 
-#player-settings table .special-range-wrapper input[type=range]{
+#player-options table .named-range-wrapper input[type=range]{
     flex-grow: 1;
 }
 
-#player-settings table .randomize-button {
+#player-options table .randomize-button {
     max-height: 24px;
     line-height: 16px;
     padding: 2px 8px;
@@ -159,36 +185,60 @@ html{
     border-radius: 3px;
 }
 
-#player-settings table .randomize-button.active {
+#player-options table .randomize-button.active {
     background-color: #ffef00; /* Same as .interactive in globalStyles.css */
 }
 
-#player-settings table label{
+#player-options table .randomize-button[data-tooltip]::after {
+    left: unset;
+    right: 0;
+}
+
+#player-options table label{
     display: block;
     min-width: 200px;
     margin-right: 4px;
     cursor: default;
 }
 
-#player-settings th, #player-settings td{
+#player-options th, #player-options td{
     border: none;
     padding: 3px;
     font-size: 17px;
     vertical-align: top;
 }
 
-@media all and (max-width: 1000px), all and (orientation: portrait){
-    #player-settings #game-options{
+@media all and (max-width: 1024px) {
+    #player-options {
+        border-radius: 0;
+    }
+
+    #player-options #meta-options {
+        flex-direction: column;
+        justify-content: flex-start;
+        gap: 6px;
+    }
+
+    #player-options #game-options{
         justify-content: flex-start;
         flex-wrap: wrap;
     }
 
-    #player-settings .left, #player-settings .right{
-        flex-grow: unset;
+    #player-options .left,
+    #player-options .right {
+        margin: 0;
+    }
+
+    #game-options table {
+        margin-bottom: 0;
     }
 
     #game-options table label{
         display: block;
         min-width: 200px;
     }
+
+    #game-options table tr td {
+        width: 50%;
+    }
 }

WebHostLib/static/styles/sc2Tracker.css

@@ -0,0 +1,160 @@
+#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

@@ -1,110 +0,0 @@
-#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: 500px;
-    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%);
-}
-
-#inventory-table img.acquired{
-    filter: none;
-}
-
-#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: 500px;
-    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/supportedGames.css

@@ -18,6 +18,22 @@
     margin-bottom: 2px;
 }
 
+#games .collapse-toggle{
+    cursor: pointer;
+}
+
+#games h2 .collapse-arrow{
+    font-size: 20px;
+    display: inline-block; /* make vertical-align work */
+    padding-bottom: 9px;
+    vertical-align: middle;
+    padding-right: 8px;
+}
+
+#games p.collapsed{
+    display: none;
+}
+
 #games a{
     font-size: 16px;
 }
@@ -31,3 +47,13 @@
     line-height: 25px;
     margin-bottom: 7px;
 }
+
+#games .page-controls{
+    display: flex;
+    flex-direction: row;
+    margin-top: 0.25rem;
+}
+
+#games .page-controls button{
+    margin-left: 0.5rem;
+}

WebHostLib/static/styles/tracker.css

@@ -7,134 +7,55 @@
     width: calc(100% - 1rem);
 }
 
-#tracker-wrapper a{
+#tracker-wrapper a {
     color: #234ae4;
     text-decoration: none;
     cursor: pointer;
 }
 
-.table-wrapper{
-    overflow-y: auto;
-    overflow-x: auto;
-    margin-bottom: 1rem;
-}
-
-#tracker-header-bar{
+#tracker-header-bar {
     display: flex;
     flex-direction: row;
     justify-content: flex-start;
+    align-content: center;
     line-height: 20px;
+    gap: 0.5rem;
+    margin-bottom: 1rem;
 }
 
-#tracker-header-bar .info{
+#tracker-header-bar .info {
     color: #ffffff;
-}
-
-#search{
-    border: 1px solid #000000;
-    border-radius: 3px;
-    padding: 3px;
-    width: 200px;
-    margin-bottom: 0.5rem;
-    margin-right: 1rem;
-}
-
-#multi-stream-link{
-    margin-right: 1rem;
-}
-
-div.dataTables_wrapper.no-footer .dataTables_scrollBody{
-    border: none;
-}
-
-table.dataTable{
-    color: #000000;
-}
-
-table.dataTable thead{
-    font-family: LexendDeca-Regular, sans-serif;
-}
-
-table.dataTable tbody{
-    background-color: #dce2bd;
-    font-family: LexendDeca-Light, sans-serif;
-}
-
-table.dataTable tbody tr:hover{
-    background-color: #e2eabb;
-}
-
-table.dataTable tbody td{
-    padding: 4px 6px;
-}
-
-table.dataTable, table.dataTable.no-footer{
-    border-left: 1px solid #bba967;
-    width: calc(100% - 2px) !important;
-    font-size: 1rem;
-}
-
-table.dataTable thead th{
-    position: -webkit-sticky;
-    position: sticky;
-    background-color: #b0a77d;
-    top: 0;
-}
-
-table.dataTable thead th.upper-row{
-    position: -webkit-sticky;
-    position: sticky;
-    background-color: #b0a77d;
-    height: 36px;
-    top: 0;
-}
-
-table.dataTable thead th.lower-row{
-    position: -webkit-sticky;
-    position: sticky;
-    background-color: #b0a77d;
-    height: 22px;
-    top: 46px;
-}
-
-table.dataTable tbody td{
-    border: 1px solid #bba967;
-}
-
-div.dataTables_scrollBody{
-    background-color: inherit !important;
-}
-
-table.dataTable .center-column{
-    text-align: center;
-}
-
-img.alttp-sprite {
-    height: auto;
-    max-height: 32px;
-    min-height: 14px;
-}
-
-.item-acquired{
-    background-color: #d3c97d;
+    padding: 2px;
+    flex-grow: 1;
+    align-self: center;
+    text-align: justify;
 }
 
 #tracker-navigation {
-    display: inline-flex;
+    display: flex;
+    flex-wrap: wrap;
+    margin: 0 0.5rem 0.5rem 0.5rem;
+    user-select: none;
+    height: 2rem;
+}
+
+.tracker-navigation-bar {
+    display: flex;
     background-color: #b0a77d;
-    margin: 0.5rem;
     border-radius: 4px;
 }
 
 .tracker-navigation-button {
-    display: block;
+    display: flex;
+    justify-content: center;
+    align-items: center;
     margin: 4px;
     padding-left: 12px;
     padding-right: 12px;
     border-radius: 4px;
     text-align: center;
     font-size: 14px;
-    color: #000;
+    color: black !important;
     font-weight: lighter;
 }
 
@@ -146,6 +67,100 @@ img.alttp-sprite {
     background-color: rgb(220, 226, 189);
 }
 
+.table-wrapper {
+    overflow-y: auto;
+    overflow-x: auto;
+    margin-bottom: 1rem;
+    resize: vertical;
+}
+
+#search {
+    border: 1px solid #000000;
+    border-radius: 3px;
+    padding: 3px;
+    width: 200px;
+}
+
+div.dataTables_wrapper.no-footer .dataTables_scrollBody {
+    border: none;
+}
+
+table.dataTable {
+    color: #000000;
+}
+
+table.dataTable thead {
+    font-family: LexendDeca-Regular, sans-serif;
+}
+
+table.dataTable tbody, table.dataTable tfoot {
+    background-color: #dce2bd;
+    font-family: LexendDeca-Light, sans-serif;
+}
+
+table.dataTable tbody tr:hover, table.dataTable tfoot tr:hover {
+    background-color: #e2eabb;
+}
+
+table.dataTable tbody td, table.dataTable tfoot td {
+    padding: 4px 6px;
+}
+
+table.dataTable, table.dataTable.no-footer {
+    border-left: 1px solid #bba967;
+    width: calc(100% - 2px) !important;
+    font-size: 1rem;
+}
+
+table.dataTable thead th {
+    position: -webkit-sticky;
+    position: sticky;
+    background-color: #b0a77d;
+    top: 0;
+}
+
+table.dataTable thead th.upper-row {
+    position: -webkit-sticky;
+    position: sticky;
+    background-color: #b0a77d;
+    height: 36px;
+    top: 0;
+}
+
+table.dataTable thead th.lower-row {
+    position: -webkit-sticky;
+    position: sticky;
+    background-color: #b0a77d;
+    height: 22px;
+    top: 46px;
+}
+
+table.dataTable tbody td, table.dataTable tfoot td {
+    border: 1px solid #bba967;
+}
+
+table.dataTable tfoot td {
+    font-weight: bold;
+}
+
+div.dataTables_scrollBody {
+    background-color: inherit !important;
+}
+
+table.dataTable .center-column {
+    text-align: center;
+}
+
+img.icon-sprite {
+    height: auto;
+    max-height: 32px;
+    min-height: 14px;
+}
+
+.item-acquired {
+    background-color: #d3c97d;
+}
+
 @media all and (max-width: 1700px) {
     table.dataTable thead th.upper-row{
         position: -webkit-sticky;
@@ -155,7 +170,7 @@ img.alttp-sprite {
         top: 0;
     }
 
-    table.dataTable thead th.lower-row{
+    table.dataTable thead th.lower-row {
         position: -webkit-sticky;
         position: sticky;
         background-color: #b0a77d;
@@ -163,11 +178,11 @@ img.alttp-sprite {
         top: 37px;
     }
 
-    table.dataTable, table.dataTable.no-footer{
+    table.dataTable, table.dataTable.no-footer {
         font-size: 0.8rem;
     }
 
-    img.alttp-sprite {
+    img.icon-sprite {
         height: auto;
         max-height: 24px;
         min-height: 10px;
@@ -183,7 +198,7 @@ img.alttp-sprite {
         top: 0;
     }
 
-    table.dataTable thead th.lower-row{
+    table.dataTable thead th.lower-row {
         position: -webkit-sticky;
         position: sticky;
         background-color: #b0a77d;
@@ -191,11 +206,11 @@ img.alttp-sprite {
         top: 32px;
     }
 
-    table.dataTable, table.dataTable.no-footer{
+    table.dataTable, table.dataTable.no-footer {
         font-size: 0.6rem;
     }
 
-    img.alttp-sprite {
+    img.icon-sprite {
         height: auto;
         max-height: 20px;
         min-height: 10px;

WebHostLib/static/styles/weighted-options.css

@@ -292,6 +292,12 @@ html{
     margin-right: 0.5rem;
 }
 
+#weighted-settings .simple-list hr{
+    width: calc(100% - 2px);
+    margin: 2px auto;
+    border-bottom: 1px solid rgb(255 255 255 / 0.6);
+}
+
 #weighted-settings .invisible{
     display: none;
 }

WebHostLib/templates/check.html

@@ -17,9 +17,9 @@
             </p>
             <div id="check-form-wrapper">
                 <form id="check-form" method="post" enctype="multipart/form-data">
-                    <input id="file-input" type="file" name="file">
+                    <input id="file-input" type="file" name="file" multiple>
                 </form>
-                <button id="check-button">Upload</button>
+                <button id="check-button">Upload File(s)</button>
             </div>
         </div>
     </div>

WebHostLib/templates/checkResult.html

@@ -28,6 +28,10 @@
                     {% endfor %}
                 </tbody>
             </table>
+        {% if combined_yaml %}
+            <h1>Combined File Download</h1>
+            <p><a href="data:text/yaml;base64,{{ combined_yaml }}" download="combined.yaml">Download</a></p>
+        {% endif %}
         </div>
     </div>
 {% endblock %}

WebHostLib/templates/generate.html

@@ -69,8 +69,8 @@
                                     </td>
                                     <td>
                                         <select name="collect_mode" id="collect_mode">
-                                            <option value="goal">Allow !collect after goal completion</option>
                                             <option value="auto">Automatic on goal completion</option>
+                                            <option value="goal">Allow !collect after 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>
@@ -119,6 +119,28 @@
                                         </select>
                                     </td>
                                 </tr>
+                                <tr>
+                                    <td>
+                                        <label for="spoiler">Spoiler Log:
+                                            <span class="interactive" data-tooltip="Generates a text listing all randomized elements.
+Warning: playthrough can take a significant amount of time for larger multiworlds.">
+                                                (?)
+                                            </span>
+                                        </label>
+                                    </td>
+                                    <td>
+                                        <select name="spoiler" id="spoiler">
+                                            {% if race -%}
+                                                <option value="0">Disabled in Race mode</option>
+                                            {%- else -%}
+                                                <option value="3">Enabled with playthrough and traversal</option>
+                                                <option value="2">Enabled with playthrough</option>
+                                                <option value="1">Enabled</option>
+                                                <option value="0">Disabled</option>
+                                            {%- endif -%}
+                                        </select>
+                                    </td>
+                                </tr>
                             </tbody>
                         </table>
                         </div>
@@ -163,12 +185,12 @@
                                             </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>
 
@@ -181,10 +203,10 @@
                         </div>
                     </div>
                     <div id="generate-form-button-row">
-                        <input id="file-input" type="file" name="file">
+                        <input id="file-input" type="file" name="file" multiple>
                     </div>
                 </form>
-                <button id="generate-game-button">Upload File</button>
+                <button id="generate-game-button">Upload File(s)</button>
             </div>
         </div>
     </div>

WebHostLib/templates/genericTracker.html

@@ -1,36 +1,57 @@
-{% extends 'tablepage.html' %}
+{% extends "tablepage.html" %}
 {% block head %}
     {{ super() }}
     <title>{{ player_name }}&apos;s Tracker</title>
-    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename="styles/tracker.css") }}"/>
-    <script type="application/ecmascript" src="{{ url_for('static', filename="assets/jquery.scrollsync.js") }}"></script>
-    <script type="application/ecmascript" src="{{ url_for('static', filename="assets/trackerCommon.js") }}"></script>
+    <link rel="stylesheet" type="text/css" href="{{ url_for("static", filename="styles/tracker.css") }}"/>
+    <script type="application/ecmascript" src="{{ url_for("static", filename="assets/jquery.scrollsync.js") }}"></script>
+    <script type="application/ecmascript" src="{{ url_for("static", filename="assets/trackerCommon.js") }}"></script>
 {% endblock %}
 
 {% block body %}
-    {% include 'header/dirtHeader.html' %}
-    <div id="tracker-wrapper" data-tracker="{{ room.tracker|suuid }}/{{ team }}/{{ player }}" data-second="{{ saving_second }}">
-        <div id="tracker-header-bar">
-            <input placeholder="Search" id="search"/>
-            <span class="info">This tracker will automatically update itself periodically.</span>
+    {% include "header/dirtHeader.html" %}
+
+    <div id="tracker-navigation">
+        <div class="tracker-navigation-bar">
+            <a
+                class="tracker-navigation-button"
+                href="{{ url_for("get_multiworld_tracker", tracker=room.tracker) }}"
+            >
+                 🡸 Return to Multiworld Tracker
+            </a>
+            {% if game_specific_tracker %}
+            <a
+                class="tracker-navigation-button"
+                href="{{ url_for("get_player_tracker", tracker=room.tracker, tracked_team=team, tracked_player=player) }}"
+            >
+                Game-Specific Tracker
+            </a>
+            {% endif %}
         </div>
+    </div>
+
+    <div id="tracker-wrapper" data-tracker="{{ room.tracker | suuid }}/{{ team }}/{{ player }}" data-second="{{ saving_second }}">
+        <div id="tracker-header-bar">
+            <input placeholder="Search" id="search" />
+            <div class="info">This tracker will automatically update itself periodically.</div>
+        </div>
+        <div id="tables-container">
             <div class="table-wrapper">
                 <table id="received-table" class="table non-unique-item-table">
                     <thead>
                         <tr>
                             <th>Item</th>
                             <th>Amount</th>
-                            <th>Order Received</th>
+                            <th>Last Order Received</th>
                         </tr>
                     </thead>
                     <tbody>
 
-                    {% for id, count in inventory.items() %}
-                    <tr>
-                        <td>{{ id | item_name }}</td>
-                        <td>{{ count }}</td>
-                        <td>{{received_items[id]}}</td>
-                    </tr>
+                    {% for id, count in inventory.items() if count > 0 %}
+                        <tr>
+                            <td>{{ item_id_to_name[game][id] }}</td>
+                            <td>{{ count }}</td>
+                            <td>{{ received_items[id] }}</td>
+                        </tr>
                     {%- endfor -%}
 
                     </tbody>
@@ -39,24 +60,62 @@
             <div class="table-wrapper">
                 <table id="locations-table" class="table non-unique-item-table">
                     <thead>
-                    <tr>
-                        <th>Location</th>
-                        <th>Checked</th>
-                    </tr>
+                        <tr>
+                            <th>Location</th>
+                            <th class="center-column">Checked</th>
+                        </tr>
                     </thead>
                     <tbody>
-                        {% for name in checked_locations %}
+
+                    {%- for location in locations -%}
                         <tr>
-                            <td>{{ name | location_name}}</td>
-                            <td>✔</td>
+                            <td>{{ location_id_to_name[game][location] }}</td>
+                            <td class="center-column">
+                                {% if location in checked_locations %}✔{% endif %}
+                            </td>
                         </tr>
-                        {%- endfor -%}
-                        {% for name in not_checked_locations %}
+                    {%- endfor -%}
+
+                    </tbody>
+                </table>
+            </div>
+            <div class="table-wrapper">
+                <table id="hints-table" class="table non-unique-item-table">
+                    <thead>
                         <tr>
-                            <td>{{ name | location_name}}</td>
-                            <td></td>
+                            <th>Finder</th>
+                            <th>Receiver</th>
+                            <th>Item</th>
+                            <th>Location</th>
+                            <th>Game</th>
+                            <th>Entrance</th>
+                            <th class="center-column">Found</th>
                         </tr>
-                        {%- endfor -%}
+                    </thead>
+                    <tbody>
+                    {%- for hint in hints -%}
+                        <tr>
+                            <td>
+                                {% if hint.finding_player == player %}
+                                    <b>{{ player_names_with_alias[(team, hint.finding_player)] }}</b>
+                                {% else %}
+                                    {{ player_names_with_alias[(team, hint.finding_player)] }}
+                                {% endif %}
+                            </td>
+                            <td>
+                                {% if hint.receiving_player == player %}
+                                    <b>{{ player_names_with_alias[(team, hint.receiving_player)] }}</b>
+                                {% else %}
+                                    {{ player_names_with_alias[(team, hint.receiving_player)] }}
+                                {% endif %}
+                            </td>
+                            <td>{{ item_id_to_name[games[(team, hint.receiving_player)]][hint.item] }}</td>
+                            <td>{{ location_id_to_name[games[(team, hint.finding_player)]][hint.location] }}</td>
+                            <td>{{ games[(team, hint.finding_player)] }}</td>
+                            <td>{% if hint.entrance %}{{ hint.entrance }}{% else %}Vanilla{% endif %}</td>
+                            <td class="center-column">{% if hint.found %}✔{% endif %}</td>
+                        </tr>
+                    {%- endfor -%}
                     </tbody>
                 </table>
             </div>

WebHostLib/templates/header/baseHeader.html

@@ -30,14 +30,14 @@
                 <img src="/static/static/button-images/hamburger-menu-icon.png" alt="Menu" />
             </a>
         </div>
+        <div id="base-header-mobile-menu">
+            <a href="/games">supported games</a>
+            <a href="/tutorial">setup guides</a>
+            <a href="/faq/en">f.a.q.</a>
+            <a href="/generate">generate game</a>
+            <a href="/uploads">host game</a>
+            <a href="/user-content">user content</a>
+            <a href="https://discord.gg/8Z65BR2" target="_blank">discord</a>
+        </div>
     </header>
-    <div id="base-header-mobile-menu">
-        <a href="/games">supported games</a>
-        <a href="/tutorial">setup guides</a>
-        <a href="/faq/en">f.a.q.</a>
-        <a href="/generate">generate game</a>
-        <a href="/uploads">host game</a>
-        <a href="/user-content">user content</a>
-        <a href="https://discord.gg/8Z65BR2" target="_blank">discord</a>
-    </div>
 {% endblock %}

WebHostLib/templates/hostRoom.html

@@ -3,6 +3,16 @@
 {% block head %}
     <title>Multiworld {{ room.id|suuid }}</title>
     {% if should_refresh %}<meta http-equiv="refresh" content="2">{% endif %}
+    <meta name="og:site_name" content="Archipelago">
+    <meta property="og:title" content="Multiworld {{ room.id|suuid }}">
+    <meta property="og:type" content="website" />
+    {% if room.seed.slots|length < 2 %}
+    <meta property="og:description" content="{{ room.seed.slots|length }} Player World
+    {% if room.last_port != -1 %}running on {{ config['HOST_ADDRESS'] }} with port {{ room.last_port }}{% endif %}">
+    {% else %}
+    <meta property="og:description" content="{{ room.seed.slots|length }} Players Multiworld
+    {% if room.last_port != -1 %}running on {{ config['HOST_ADDRESS'] }} with port {{ room.last_port }}{% endif %}">
+    {% endif %}
     <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename="styles/hostRoom.css") }}"/>
 {% endblock %}
 
@@ -32,13 +42,18 @@
         {% endif %}
         {{ macros.list_patches_room(room) }}
         {% if room.owner == session["_id"] %}
-            <form method=post>
-                <div class="form-group">
-                    <label for="cmd"></label>
-                    <input class="form-control" type="text" id="cmd" name="cmd"
-                           placeholder="Server Command. /help to list them, list gets appended to log.">
-                </div>
-            </form>
+            <div style="display: flex; align-items: center;">
+                <form method=post style="flex-grow: 1; margin-right: 1em;">
+                    <div class="form-group">
+                        <label for="cmd"></label>
+                        <input class="form-control" type="text" id="cmd" name="cmd"
+                               placeholder="Server Command. /help to list them, list gets appended to log.">
+                    </div>
+                </form>
+                <a href="{{ url_for("display_log", room=room.id) }}">
+                    Open Log File...
+                </a>
+            </div>
         <div id="logger"></div>
         <script type="application/ecmascript">
             let xmlhttp = new XMLHttpRequest();

WebHostLib/templates/islandFooter.html

@@ -1,6 +1,6 @@
 {% block footer %}
     <footer id="island-footer">
-        <div id="copyright-notice">Copyright 2022 Archipelago</div>
+        <div id="copyright-notice">Copyright 2024 Archipelago</div>
         <div id="links">
             <a href="/sitemap">Site Map</a>
             -

WebHostLib/templates/landing.html

@@ -49,9 +49,9 @@
                     our crazy idea into a reality.
                 </p>
                 <p>
-                    <span class="variable">{{ seeds }}</span>
+                    <a href="{{ url_for("stats") }}">{{ seeds }}</a>
                     games were generated and
-                    <span class="variable">{{ rooms }}</span>
+                    <a href="{{ url_for("stats") }}">{{ rooms }}</a>
                     were hosted in the last 7 days.
                 </p>
             </div>

WebHostLib/templates/lttpMultiTracker.html

@@ -1,188 +0,0 @@
-{% extends 'tablepage.html' %}
-{% block head %}
-    {{ super() }}
-    <title>ALttP Multiworld Tracker</title>
-    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename="styles/tracker.css") }}"/>
-    <script type="application/ecmascript" src="{{ url_for('static', filename="assets/jquery.scrollsync.js") }}"></script>
-    <script type="application/ecmascript" src="{{ url_for('static', filename="assets/lttpMultiTracker.js") }}"></script>
-    <script type="application/ecmascript" src="{{ url_for('static', filename="assets/trackerCommon.js") }}"></script>
-{% endblock %}
-
-{% block body %}
-    {% include 'header/dirtHeader.html' %}
-    {% include 'multiTrackerNavigation.html' %}
-    <div id="tracker-wrapper" data-tracker="{{ room.tracker|suuid }}">
-        <div id="tracker-header-bar">
-            <input placeholder="Search" id="search"/>
-            <span{% if not video %} hidden{% endif %} id="multi-stream-link">
-                <a target="_blank" href="https://multistream.me/
-                    {%- for platform, link in video.values()|unique(False, 1)-%}
-                        {%- if platform == "Twitch" -%}t{%- else -%}yt{%- endif -%}:{{- link -}}/
-                    {%- endfor -%}">
-                    Multistream
-                </a>
-            </span>
-            <span class="info">Clicking on a slot's number will bring up a slot-specific auto-tracker. This tracker will automatically update itself periodically.</span>
-        </div>
-        <div id="tables-container">
-            {% for team, players in inventory.items() %}
-                <div class="table-wrapper">
-                    <table id="inventory-table" class="table unique-item-table">
-                        <thead>
-                        <tr>
-                            <th>#</th>
-                            <th>Name</th>
-                            {%- for name in tracking_names -%}
-                                {%- if name in icons -%}
-                                    <th class="center-column">
-                                            <img class="alttp-sprite" src="{{ icons[name] }}" alt="{{ name|e }}">
-                                        </th>
-                                {%- else -%}
-                                    <th class="center-column">{{ name|e }}</th>
-                                {%- endif -%}
-                            {%- endfor -%}
-                            </tr>
-                        </thead>
-                        <tbody>
-                            {%- for player, items in players.items() -%}
-                                <tr>
-                                    <td><a href="{{ url_for("get_player_tracker", tracker=room.tracker,
-                                    tracked_team=team, tracked_player=player)}}">{{ loop.index }}</a></td>
-                                    {%- if (team, loop.index) in video -%}
-                                        {%- if video[(team, loop.index)][0] == "Twitch" -%}
-                                        <td>
-                                            <a target="_blank" href="https://www.twitch.tv/{{ video[(team, loop.index)][1] }}">
-                                                {{ player_names[(team, loop.index)] }}
-                                                ▶️</a></td>
-                                        {%- elif video[(team, loop.index)][0] == "Youtube" -%}
-                                        <td>
-                                            <a target="_blank" href="youtube.com/c/{{ video[(team, loop.index)][1] }}/live">
-                                                {{ player_names[(team, loop.index)] }}
-                                                ▶️</a></td>
-                                        {%- endif -%}
-                                    {%- else -%}
-                                        <td>{{ player_names[(team, loop.index)] }}</td>
-                                    {%- endif -%}
-                                    {%- for id in tracking_ids -%}
-                                        {%- if items[id] -%}
-                                            <td class="center-column item-acquired">
-                                                {% if id in multi_items %}{{ items[id] }}{% else %}✔️{% endif %}</td>
-                                        {%- else -%}
-                                            <td></td>
-                                        {%- endif -%}
-                                    {% endfor %}
-                                </tr>
-                            {%- endfor -%}
-                        </tbody>
-                    </table>
-                </div>
-            {% endfor %}
-
-            {% for team, players in checks_done.items() %}
-                <div class="table-wrapper">
-                    <table id="checks-table" class="table non-unique-item-table">
-                        <thead>
-                            <tr>
-                                <th rowspan="2">#</th>
-                                <th rowspan="2">Name</th>
-                                {% for area in ordered_areas %}
-                                    {% set colspan = 1 %}
-                                    {% if area in key_locations %}
-                                    {% set colspan = colspan + 1 %}
-                                    {% endif %}
-                                    {% if area in big_key_locations %}
-                                    {% set colspan = colspan + 1 %}
-                                    {% endif %}
-                                    {% if area in icons %}
-                                        <th colspan="{{ colspan }}" class="center-column upper-row">
-                                            <img class="alttp-sprite" src="{{ icons[area] }}" alt="{{ area }}"></th>
-                                    {%- else -%}
-                                        <th colspan="{{ colspan }}" class="center-column">{{ area }}</th>
-                                    {%- endif -%}
-                                {%- endfor -%}
-                                <th rowspan="2" class="center-column">&percnt;</th>
-                                <th rowspan="2" class="center-column hours">Last<br>Activity</th>
-                            </tr>
-                            <tr>
-                                {% for area in ordered_areas %}
-                                    <th class="center-column lower-row fraction">
-                                        <img class="alttp-sprite" src="{{ icons["Chest"] }}" alt="Checks">
-                                    </th>
-                                    {% if area in key_locations %}
-                                        <th class="center-column lower-row number">
-                                            <img class="alttp-sprite" src="{{ icons["Small Key"] }}" alt="Small Key">
-                                        </th>
-                                    {% endif %}
-                                    {% if area in big_key_locations %}
-                                        <th class="center-column lower-row number">
-                                            <img class="alttp-sprite" src="{{ icons["Big Key"] }}" alt="Big Key">
-                                        </th>
-                                    {%- endif -%}
-                                {%- endfor -%}
-                            </tr>
-                        </thead>
-                        <tbody>
-                            {%- for player, checks in players.items() -%}
-                                <tr>
-                                    <td><a href="{{ url_for("get_player_tracker", tracker=room.tracker,
-                                    tracked_team=team, tracked_player=player)}}">{{ loop.index }}</a></td>
-                                    <td>{{ player_names[(team, loop.index)]|e }}</td>
-                                    {%- for area in ordered_areas -%}
-                                        {%- set checks_done = checks[area] -%}
-                                        {%- set checks_total = checks_in_area[player][area] -%}
-                                        {%- if checks_done == checks_total -%}
-                                            <td class="item-acquired center-column">
-                                                {{ checks_done }}/{{ checks_total }}</td>
-                                        {%- else -%}
-                                            <td class="center-column">{{ checks_done }}/{{ checks_total }}</td>
-                                        {%- endif -%}
-                                        {%- if area in key_locations -%}
-                                            <td class="center-column">{{ inventory[team][player][small_key_ids[area]] }}</td>
-                                        {%- endif -%}
-                                        {%- if area in big_key_locations -%}
-                                            <td class="center-column">{% if inventory[team][player][big_key_ids[area]] %}✔️{% endif %}</td>
-                                        {%- endif -%}
-                                    {%- endfor -%}
-                                    <td class="center-column">{{ percent_total_checks_done[team][player] }}</td>
-                                    {%- if activity_timers[(team, player)] -%}
-                                        <td class="center-column">{{ activity_timers[(team, player)].total_seconds() }}</td>
-                                    {%- else -%}
-                                        <td class="center-column">None</td>
-                                    {%- endif -%}
-                                </tr>
-                            {%- endfor -%}
-                        </tbody>
-                    </table>
-                </div>
-            {% endfor %}
-            {% for team, hints in hints.items() %}
-                <div class="table-wrapper">
-                    <table id="hints-table" class="table non-unique-item-table" data-order='[[5, "asc"], [0, "asc"]]'>
-                        <thead>
-                        <tr>
-                            <th>Finder</th>
-                            <th>Receiver</th>
-                            <th>Item</th>
-                            <th>Location</th>
-                            <th>Entrance</th>
-                            <th>Found</th>
-                        </tr>
-                        </thead>
-                        <tbody>
-                        {%- for hint in hints -%}
-                            <tr>
-                                <td>{{ long_player_names[team, hint.finding_player] }}</td>
-                                <td>{{ long_player_names[team, hint.receiving_player] }}</td>
-                                <td>{{ hint.item|item_name }}</td>
-                                <td>{{ hint.location|location_name }}</td>
-                                <td>{% if hint.entrance %}{{ hint.entrance }}{% else %}Vanilla{% endif %}</td>
-                                <td>{% if hint.found %}✔{% endif %}</td>
-                            </tr>
-                        {%- endfor -%}
-                        </tbody>
-                    </table>
-                </div>
-            {% endfor %}
-        </div>
-    </div>
-{% endblock %}

WebHostLib/templates/macros.html

@@ -22,33 +22,40 @@
             {% for patch in room.seed.slots|list|sort(attribute="player_id") %}
                 <tr>
                     <td>{{ patch.player_id }}</td>
-                    <td data-tooltip="Connect via TextClient"><a href="archipelago://{{ patch.player_name | e}}:@{{ config['HOST_ADDRESS'] }}:{{ room.last_port }}">{{ patch.player_name }}</a></td>
+                    <td data-tooltip="Connect via TextClient"><a href="archipelago://{{ patch.player_name | e}}:None@{{ config['HOST_ADDRESS'] }}:{{ room.last_port }}">{{ patch.player_name }}</a></td>
                     <td>{{ patch.game }}</td>
                     <td>
-                        {% if patch.game == "Minecraft" %}
-                        <a href="{{ url_for("download_slot_file", room_id=room.id, player_id=patch.player_id) }}" download>
-                            Download APMC File...</a>
-                        {% elif patch.game == "Factorio" %}
-                        <a href="{{ url_for("download_slot_file", room_id=room.id, player_id=patch.player_id) }}" download>
-                            Download Factorio Mod...</a>
-                        {% elif patch.game == "Kingdom Hearts 2" %}
-                        <a href="{{ url_for("download_slot_file", room_id=room.id, player_id=patch.player_id) }}" download>
-                            Download Kingdom Hearts 2 Mod...</a>
-                        {% elif patch.game == "Ocarina of Time" %}
-                        <a href="{{ url_for("download_slot_file", room_id=room.id, player_id=patch.player_id) }}" download>
-                            Download APZ5 File...</a>
-                        {% elif patch.game == "VVVVVV" and room.seed.slots|length == 1 %}
-                        <a href="{{ url_for("download_slot_file", room_id=room.id, player_id=patch.player_id) }}" download>
-                            Download APV6 File...</a>
-                        {% elif patch.game == "Super Mario 64" and room.seed.slots|length == 1 %}
-                        <a href="{{ url_for("download_slot_file", room_id=room.id, player_id=patch.player_id) }}" download>
-                            Download APSM64EX File...</a>
-                        {% elif patch.game | supports_apdeltapatch %}
-                        <a href="{{ url_for("download_patch", patch_id=patch.id, room_id=room.id) }}" download>
-                            Download Patch File...</a>
-                        {% elif patch.game == "Dark Souls III" and patch.data %}
-                        <a href="{{ url_for("download_slot_file", room_id=room.id, player_id=patch.player_id) }}" download>
-                            Download JSON File...</a>
+                        {% if patch.data %}
+                            {% if patch.game == "Minecraft" %}
+                            <a href="{{ url_for("download_slot_file", room_id=room.id, player_id=patch.player_id) }}" download>
+                                Download APMC File...</a>
+                            {% elif patch.game == "Factorio" %}
+                            <a href="{{ url_for("download_slot_file", room_id=room.id, player_id=patch.player_id) }}" download>
+                                Download Factorio Mod...</a>
+                            {% elif patch.game == "Kingdom Hearts 2" %}
+                            <a href="{{ url_for("download_slot_file", room_id=room.id, player_id=patch.player_id) }}" download>
+                                Download Kingdom Hearts 2 Mod...</a>
+                            {% elif patch.game == "Ocarina of Time" %}
+                            <a href="{{ url_for("download_slot_file", room_id=room.id, player_id=patch.player_id) }}" download>
+                                Download APZ5 File...</a>
+                            {% elif patch.game == "VVVVVV" and room.seed.slots|length == 1 %}
+                            <a href="{{ url_for("download_slot_file", room_id=room.id, player_id=patch.player_id) }}" download>
+                                Download APV6 File...</a>
+                            {% elif patch.game == "Super Mario 64" and room.seed.slots|length == 1 %}
+                            <a href="{{ url_for("download_slot_file", room_id=room.id, player_id=patch.player_id) }}" download>
+                                Download APSM64EX File...</a>
+                            {% elif patch.game | supports_apdeltapatch %}
+                            <a href="{{ url_for("download_patch", patch_id=patch.id, room_id=room.id) }}" download>
+                                Download Patch File...</a>
+                            {% elif patch.game == "Dark Souls III" %}
+                            <a href="{{ url_for("download_slot_file", room_id=room.id, player_id=patch.player_id) }}" download>
+                                Download JSON File...</a>
+                            {% elif patch.game == "Final Fantasy Mystic Quest" %}
+                            <a href="{{ url_for("download_slot_file", room_id=room.id, player_id=patch.player_id) }}" download>
+                                Download APMQ File...</a>
+                            {% else %}
+                                No file to download for this game.
+                            {% endif %}
                         {% else %}
                             No file to download for this game.
                         {% endif %}

WebHostLib/templates/multiFactorioTracker.html

@@ -1,44 +0,0 @@
-{% extends "multiTracker.html" %}
-{% block custom_table_headers %}
-<th class="center-column">
-    <img src="https://wiki.factorio.com/images/thumb/Logistic_science_pack.png/32px-Logistic_science_pack.png"
-         alt="Logistic Science Pack">
-</th>
-<th class="center-column">
-    <img src="https://wiki.factorio.com/images/thumb/Military_science_pack.png/32px-Military_science_pack.png"
-         alt="Military Science Pack">
-</th>
-<th class="center-column">
-    <img src="https://wiki.factorio.com/images/thumb/Chemical_science_pack.png/32px-Chemical_science_pack.png"
-         alt="Chemical Science Pack">
-</th>
-<th class="center-column">
-    <img src="https://wiki.factorio.com/images/thumb/Production_science_pack.png/32px-Production_science_pack.png"
-         alt="Production Science Pack">
-</th>
-<th class="center-column">
-    <img src="https://wiki.factorio.com/images/thumb/Utility_science_pack.png/32px-Utility_science_pack.png"
-         alt="Utility Science Pack">
-</th>
-<th class="center-column">
-    <img src="https://wiki.factorio.com/images/thumb/Space_science_pack.png/32px-Space_science_pack.png"
-         alt="Space Science Pack">
-</th>
-{% endblock %}
-{% block custom_table_row scoped  %}
-{% if games[player] == "Factorio" %}
-<td class="center-column">{% if inventory[team][player][131161] or inventory[team][player][131281] %}✔{% endif %}</td>
-<td class="center-column">{% if inventory[team][player][131172] or inventory[team][player][131281] > 1%}✔{% endif %}</td>
-<td class="center-column">{% if inventory[team][player][131195] or inventory[team][player][131281] > 2%}✔{% endif %}</td>
-<td class="center-column">{% if inventory[team][player][131240] or inventory[team][player][131281] > 3%}✔{% endif %}</td>
-<td class="center-column">{% if inventory[team][player][131240] or inventory[team][player][131281] > 4%}✔{% endif %}</td>
-<td class="center-column">{% if inventory[team][player][131220] or inventory[team][player][131281] > 5%}✔{% endif %}</td>
-{% else %}
-<td class="center-column">❌</td>
-<td class="center-column">❌</td>
-<td class="center-column">❌</td>
-<td class="center-column">❌</td>
-<td class="center-column">❌</td>
-<td class="center-column">❌</td>
-{% endif %}
-{% endblock%}

WebHostLib/templates/multiTracker.html

@@ -1,98 +0,0 @@
-{% extends 'tablepage.html' %}
-{% block head %}
-    {{ super() }}
-    <title>Multiworld Tracker</title>
-    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename="styles/tracker.css") }}"/>
-    <script type="application/ecmascript" src="{{ url_for('static', filename="assets/trackerCommon.js") }}"></script>
-{% endblock %}
-
-{% block body %}
-    {% include 'header/dirtHeader.html' %}
-    {% include 'multiTrackerNavigation.html' %}
-    <div id="tracker-wrapper" data-tracker="{{ room.tracker|suuid }}">
-        <div id="tracker-header-bar">
-            <input placeholder="Search" id="search"/>
-            <span{% if not video %} hidden{% endif %} id="multi-stream-link">
-                <a target="_blank" href="https://multistream.me/
-                    {%- for platform, link in video.values()|unique(False, 1)-%}
-                        {%- if platform == "Twitch" -%}t{%- else -%}yt{%- endif -%}:{{- link -}}/
-                    {%- endfor -%}">
-                    Multistream
-                </a>
-            </span>
-            <span class="info">Clicking on a slot's number will bring up a slot-specific auto-tracker. This tracker will automatically update itself periodically.</span>
-        </div>
-        <div id="tables-container">
-            {% for team, players in checks_done.items() %}
-                <div class="table-wrapper">
-                    <table id="checks-table" class="table non-unique-item-table">
-                        <thead>
-                            <tr>
-                                <th>#</th>
-                                <th>Name</th>
-                                <th>Game</th>
-                                {% block custom_table_headers %}
-                                {# implement this block in game-specific multi trackers #}
-                                {% endblock %}
-                                <th class="center-column">Checks</th>
-                                <th class="center-column">&percnt;</th>
-                                <th class="center-column">Status</th>
-                                <th class="center-column hours">Last<br>Activity</th>
-                            </tr>
-                        </thead>
-                        <tbody>
-                            {%- for player, checks in players.items() -%}
-                                <tr>
-                                    <td><a href="{{ url_for("get_player_tracker", tracker=room.tracker,
-                                    tracked_team=team, tracked_player=player)}}">{{ loop.index }}</a></td>
-                                    <td>{{ player_names[(team, loop.index)]|e }}</td>
-                                    <td>{{ games[player] }}</td>
-                                    {% block custom_table_row scoped %}
-                                    {# implement this block in game-specific multi trackers #}
-                                    {% endblock %}
-                                    <td class="center-column">{{ checks["Total"] }}/{{ checks_in_area[player]["Total"] }}</td>
-                                    <td class="center-column">{{ percent_total_checks_done[team][player] }}</td>
-                                    <td>{{ {0: "Disconnected", 5: "Connected", 10: "Ready", 20: "Playing",
-                                            30: "Goal Completed"}.get(states[team, player], "Unknown State") }}</td>
-                                    {%- if activity_timers[team, player] -%}
-                                        <td class="center-column">{{ activity_timers[team, player].total_seconds() }}</td>
-                                    {%- else -%}
-                                        <td class="center-column">None</td>
-                                    {%- endif -%}
-                                </tr>
-                            {%- endfor -%}
-                        </tbody>
-                    </table>
-                </div>
-            {% endfor %}
-            {% for team, hints in hints.items() %}
-                <div class="table-wrapper">
-                    <table id="hints-table" class="table non-unique-item-table" data-order='[[5, "asc"], [0, "asc"]]'>
-                        <thead>
-                        <tr>
-                            <th>Finder</th>
-                            <th>Receiver</th>
-                            <th>Item</th>
-                            <th>Location</th>
-                            <th>Entrance</th>
-                            <th>Found</th>
-                        </tr>
-                        </thead>
-                        <tbody>
-                        {%- for hint in hints -%}
-                            <tr>
-                                <td>{{ long_player_names[team, hint.finding_player] }}</td>
-                                <td>{{ long_player_names[team, hint.receiving_player] }}</td>
-                                <td>{{ hint.item|item_name }}</td>
-                                <td>{{ hint.location|location_name }}</td>
-                                <td>{% if hint.entrance %}{{ hint.entrance }}{% else %}Vanilla{% endif %}</td>
-                                <td>{% if hint.found %}✔{% endif %}</td>
-                            </tr>
-                        {%- endfor -%}
-                        </tbody>
-                    </table>
-                </div>
-            {% endfor %}
-        </div>
-    </div>
-{% endblock %}

WebHostLib/templates/multiTrackerNavigation.html

@@ -1,9 +0,0 @@
-{%- if enabled_multiworld_trackers|length > 1 -%}
-    <div id="tracker-navigation">
-        {% for enabled_tracker in enabled_multiworld_trackers %}
-            {% set tracker_url = url_for(enabled_tracker.endpoint, tracker=room.tracker) %}
-            <a class="tracker-navigation-button{%- if enabled_tracker.current -%} selected{% endif %}"
-               href="{{ tracker_url }}">{{ enabled_tracker.name }}</a>
-        {% endfor %}
-    </div>
-{%- endif -%}

WebHostLib/templates/multitracker.html

@@ -0,0 +1,144 @@
+{% extends "tablepage.html" %}
+{% block head %}
+    {{ super() }}
+    <title>Multiworld Tracker</title>
+    <link rel="stylesheet" type="text/css" href="{{ url_for("static", filename="styles/tracker.css") }}" />
+    <script type="application/ecmascript" src="{{ url_for("static", filename="assets/trackerCommon.js") }}"></script>
+{% endblock %}
+
+{% block body %}
+    {% include "header/dirtHeader.html" %}
+    {% include "multitrackerNavigation.html" %}
+
+    <div id="tracker-wrapper" data-tracker="{{ room.tracker | suuid }}">
+        <div id="tracker-header-bar">
+            <input placeholder="Search" id="search" />
+
+            <div
+                id="multi-stream-link"
+                class="tracker-navigation-bar"
+                {% if not videos %}style="display: none"{% endif %}
+            >
+
+                <a
+                    class="tracker-navigation-button"
+                    href="https://multistream.me/
+                        {%- for platform, link in videos.values() | unique(False, 1) -%}
+                            {%- if platform == "Twitch" -%}t{%- else -%}yt{%- endif -%}:{{- link -}}/
+                        {%- endfor -%}"
+                    target="_blank"
+                >
+                    ► Multistream
+                </a>
+            </div>
+
+            <div class="info">
+                Clicking on a slot&apos;s number will bring up the slot-specific tracker.
+                This tracker will automatically update itself periodically.
+            </div>
+        </div>
+
+        <div id="tables-container">
+        {%- for team, players in room_players.items() -%}
+            <div class="table-wrapper">
+                <table id="checks-table" class="table non-unique-item-table">
+                    <thead>
+                        <tr>
+                            <th>#</th>
+                            <th>Name</th>
+                            {% if current_tracker == "Generic" %}<th>Game</th>{% endif %}
+                            <th>Status</th>
+                            {% block custom_table_headers %}
+                            {# Implement this block in game-specific multi-trackers. #}
+                            {% endblock %}
+                            <th class="center-column">Checks</th>
+                            <th class="center-column">&percnt;</th>
+                            <th class="center-column hours last-activity">Last<br>Activity</th>
+                        </tr>
+                    </thead>
+                    <tbody>
+                    {%- for player in players -%}
+                        {%- if current_tracker == "Generic" or games[(team, player)] == current_tracker -%}
+                            <tr>
+                                <td>
+                                    <a href="{{ url_for("get_player_tracker", tracker=room.tracker, tracked_team=team, tracked_player=player) }}">
+                                        {{ player }}
+                                    </a>
+                                </td>
+                                <td>{{ player_names_with_alias[(team, player)] | e }}</td>
+                                {%- if current_tracker == "Generic" -%}
+                                    <td>{{ games[(team, player)] }}</td>
+                                {%- endif -%}
+                                <td>
+                                    {{
+                                        {
+                                            0: "Disconnected",
+                                            5: "Connected",
+                                            10: "Ready",
+                                            20: "Playing",
+                                            30: "Goal Completed"
+                                        }.get(states[(team, player)], "Unknown State")
+                                    }}
+                                </td>
+
+                                {% block custom_table_row scoped %}
+                                {# Implement this block in game-specific multi-trackers. #}
+                                {% endblock %}
+
+                                {% set location_count = locations[(team, player)] | length %}
+                                <td class="center-column" data-sort="{{ locations_complete[(team, player)] }}">
+                                    {{ locations_complete[(team, player)] }}/{{ location_count }}
+                                </td>
+
+                                <td class="center-column">
+                                {%- if locations[(team, player)] | length > 0 -%}
+                                    {% set percentage_of_completion = locations_complete[(team, player)] / location_count * 100 %}
+                                    {{ "{0:.2f}".format(percentage_of_completion) }}
+                                {%- else -%}
+                                    100.00
+                                {%- endif -%}
+                                </td>
+
+                                {%- if activity_timers[(team, player)] -%}
+                                    <td class="center-column">{{ activity_timers[(team, player)].total_seconds() }}</td>
+                                {%- else -%}
+                                    <td class="center-column">None</td>
+                                {%- endif -%}
+                            </tr>
+                        {%- endif -%}
+                    {%- endfor -%}
+                    </tbody>
+
+                    {%- if not self.custom_table_headers() | trim -%}
+                        <tfoot>
+                            <tr>
+                                <td colspan="2" style="text-align: right">Total</td>
+                                <td>All Games</td>
+                                <td>{{ completed_worlds[team] }}/{{ players | length }} Complete</td>
+                                <td class="center-column">
+                                    {{ total_team_locations_complete[team] }}/{{ total_team_locations[team] }}
+                                </td>
+                                <td class="center-column">
+                                    {%- if total_team_locations[team] == 0 -%}
+                                        100
+                                    {%- else -%}
+                                        {{ "{0:.2f}".format(total_team_locations_complete[team] / total_team_locations[team] * 100) }}
+                                    {%- endif -%}
+                                </td>
+                                <td class="center-column last-activity"></td>
+                            </tr>
+                        </tfoot>
+                    {%- endif -%}
+                </table>
+            </div>
+
+        {%- endfor -%}
+
+        {% block custom_tables %}
+        {# Implement this block to create custom tables in game-specific multi-trackers. #}
+        {% endblock %}
+
+        {% include "multitrackerHintTable.html" with context %}
+        </div>
+    </div>
+{% endblock %}

WebHostLib/templates/multitrackerHintTable.html

@@ -0,0 +1,37 @@
+{% for team, hints in hints.items() %}
+    <div class="table-wrapper">
+        <table id="hints-table" class="table non-unique-item-table" data-order='[[5, "asc"], [0, "asc"]]'>
+            <thead>
+            <tr>
+                <th>Finder</th>
+                <th>Receiver</th>
+                <th>Item</th>
+                <th>Location</th>
+                <th>Game</th>
+                <th>Entrance</th>
+                <th class="center-column">Found</th>
+            </tr>
+            </thead>
+            <tbody>
+            {%- for hint in hints -%}
+                {%-
+                    if current_tracker == "Generic" or (
+                        games[(team, hint.finding_player)] == current_tracker or
+                        games[(team, hint.receiving_player)] == current_tracker
+                    )
+                -%}
+                    <tr>
+                        <td>{{ player_names_with_alias[(team, hint.finding_player)] }}</td>
+                        <td>{{ player_names_with_alias[(team, hint.receiving_player)] }}</td>
+                        <td>{{ item_id_to_name[games[(team, hint.receiving_player)]][hint.item] }}</td>
+                        <td>{{ location_id_to_name[games[(team, hint.finding_player)]][hint.location] }}</td>
+                        <td>{{ games[(team, hint.finding_player)] }}</td>
+                        <td>{% if hint.entrance %}{{ hint.entrance }}{% else %}Vanilla{% endif %}</td>
+                        <td class="center-column">{% if hint.found %}✔{% endif %}</td>
+                    </tr>
+                {% endif %}
+            {%- endfor -%}
+            </tbody>
+        </table>
+    </div>
+{% endfor %}

WebHostLib/templates/multitrackerNavigation.html

@@ -0,0 +1,16 @@
+{% if enabled_trackers | length > 1 %}
+<div id="tracker-navigation">
+    {# Multitracker game navigation. #}
+    <div class="tracker-navigation-bar">
+    {%- for game_tracker in enabled_trackers -%}
+        {%- set tracker_url = url_for("get_multiworld_tracker", tracker=room.tracker, game=game_tracker) -%}
+        <a
+            class="tracker-navigation-button{% if current_tracker == game_tracker %} selected{% endif %}"
+            href="{{ tracker_url }}"
+        >
+            {{ game_tracker }}
+        </a>
+    {%- endfor -%}
+    </div>
+</div>
+{% endif %}

WebHostLib/templates/multitracker__ALinkToThePast.html

@@ -0,0 +1,205 @@
+{% extends "multitracker.html" %}
+{% block head %}
+    {{ super() }}
+    <script type="application/ecmascript" src="{{ url_for("static", filename="assets/jquery.scrollsync.js") }}"></script>
+    <script type="application/ecmascript" src="{{ url_for("static", filename="assets/lttpMultiTracker.js") }}"></script>
+{% endblock %}
+
+{# List all tracker-relevant icons. Format: (Name, Image URL) #}
+{%- set icons = {
+    "Blue Shield": "https://www.zeldadungeon.net/wiki/images/8/85/Fighters-Shield.png",
+    "Red Shield": "https://www.zeldadungeon.net/wiki/images/5/55/Fire-Shield.png",
+    "Mirror Shield": "https://www.zeldadungeon.net/wiki/images/8/84/Mirror-Shield.png",
+    "Fighter Sword": "https://oyster.ignimgs.com/mediawiki/apis.ign.com/the-legend-of-zelda-a-link-to-the-past/4/40/SFighterSword.png?width=1920",
+    "Master Sword": "https://oyster.ignimgs.com/mediawiki/apis.ign.com/the-legend-of-zelda-a-link-to-the-past/6/65/SMasterSword.png?width=1920",
+    "Tempered Sword": "https://oyster.ignimgs.com/mediawiki/apis.ign.com/the-legend-of-zelda-a-link-to-the-past/9/92/STemperedSword.png?width=1920",
+    "Golden Sword": "https://oyster.ignimgs.com/mediawiki/apis.ign.com/the-legend-of-zelda-a-link-to-the-past/2/28/SGoldenSword.png?width=1920",
+    "Bow": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/b/bc/ALttP_Bow_%26_Arrows_Sprite.png?version=5f85a70e6366bf473544ef93b274f74c",
+    "Silver Bow": "https://oyster.ignimgs.com/mediawiki/apis.ign.com/the-legend-of-zelda-a-link-to-the-past/6/65/Bow.png?width=1920",
+    "Green Mail": "https://oyster.ignimgs.com/mediawiki/apis.ign.com/the-legend-of-zelda-a-link-to-the-past/c/c9/SGreenTunic.png?width=1920",
+    "Blue Mail": "https://oyster.ignimgs.com/mediawiki/apis.ign.com/the-legend-of-zelda-a-link-to-the-past/9/98/SBlueTunic.png?width=1920",
+    "Red Mail": "https://oyster.ignimgs.com/mediawiki/apis.ign.com/the-legend-of-zelda-a-link-to-the-past/7/74/SRedTunic.png?width=1920",
+    "Power Glove": "https://oyster.ignimgs.com/mediawiki/apis.ign.com/the-legend-of-zelda-a-link-to-the-past/f/f5/SPowerGlove.png?width=1920",
+    "Titan Mitts": "https://oyster.ignimgs.com/mediawiki/apis.ign.com/the-legend-of-zelda-a-link-to-the-past/c/c1/STitanMitt.png?width=1920",
+    "Progressive Sword": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/c/cc/ALttP_Master_Sword_Sprite.png?version=55869db2a20e157cd3b5c8f556097725",
+    "Pegasus Boots": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/e/ed/ALttP_Pegasus_Shoes_Sprite.png?version=405f42f97240c9dcd2b71ffc4bebc7f9",
+    "Progressive Glove": "https://oyster.ignimgs.com/mediawiki/apis.ign.com/the-legend-of-zelda-a-link-to-the-past/c/c1/STitanMitt.png?width=1920",
+    "Flippers": "https://oyster.ignimgs.com/mediawiki/apis.ign.com/the-legend-of-zelda-a-link-to-the-past/4/4c/ZoraFlippers.png?width=1920",
+    "Moon Pearl": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/6/63/ALttP_Moon_Pearl_Sprite.png?version=d601542d5abcc3e006ee163254bea77e",
+    "Progressive Bow": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/b/bc/ALttP_Bow_%26_Arrows_Sprite.png?version=cfb7648b3714cccc80e2b17b2adf00ed",
+    "Blue Boomerang": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/c/c3/ALttP_Boomerang_Sprite.png?version=96127d163759395eb510b81a556d500e",
+    "Red Boomerang": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/b/b9/ALttP_Magical_Boomerang_Sprite.png?version=47cddce7a07bc3e4c2c10727b491f400",
+    "Hookshot": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/2/24/Hookshot.png?version=c90bc8e07a52e8090377bd6ef854c18b",
+    "Mushroom": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/3/35/ALttP_Mushroom_Sprite.png?version=1f1acb30d71bd96b60a3491e54bbfe59",
+    "Magic Powder": "https://www.zeldadungeon.net/wiki/images/thumb/6/62/MagicPowder-ALttP-Sprite.png/86px-MagicPowder-ALttP-Sprite.png",
+    "Fire Rod": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/d/d6/FireRod.png?version=6eabc9f24d25697e2c4cd43ddc8207c0",
+    "Ice Rod": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/d/d7/ALttP_Ice_Rod_Sprite.png?version=1f944148223d91cfc6a615c92286c3bc",
+    "Bombos": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/8/8c/ALttP_Bombos_Medallion_Sprite.png?version=f4d6aba47fb69375e090178f0fc33b26",
+    "Ether": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/3/3c/Ether.png?version=34027651a5565fcc5a83189178ab17b5",
+    "Quake": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/5/56/ALttP_Quake_Medallion_Sprite.png?version=efd64d451b1831bd59f7b7d6b61b5879",
+    "Lamp": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/6/63/ALttP_Lantern_Sprite.png?version=e76eaa1ec509c9a5efb2916698d5a4ce",
+    "Hammer": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/d/d1/ALttP_Hammer_Sprite.png?version=e0adec227193818dcaedf587eba34500",
+    "Shovel": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/c/c4/ALttP_Shovel_Sprite.png?version=e73d1ce0115c2c70eaca15b014bd6f05",
+    "Flute": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/d/db/Flute.png?version=ec4982b31c56da2c0c010905c5c60390",
+    "Bug Catching Net": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/5/54/Bug-CatchingNet.png?version=4d40e0ee015b687ff75b333b968d8be6",
+    "Book of Mudora": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/2/22/ALttP_Book_of_Mudora_Sprite.png?version=11e4632bba54f6b9bf921df06ac93744",
+    "Bottle": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/e/ef/ALttP_Magic_Bottle_Sprite.png?version=fd98ab04db775270cbe79fce0235777b",
+    "Cane of Somaria": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/e/e1/ALttP_Cane_of_Somaria_Sprite.png?version=8cc1900dfd887890badffc903bb87943",
+    "Cane of Byrna": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/b/bc/ALttP_Cane_of_Byrna_Sprite.png?version=758b607c8cbe2cf1900d42a0b3d0fb54",
+    "Cape": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/1/1c/ALttP_Magic_Cape_Sprite.png?version=6b77f0d609aab0c751307fc124736832",
+    "Magic Mirror": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/e/e5/ALttP_Magic_Mirror_Sprite.png?version=e035dbc9cbe2a3bd44aa6d047762b0cc",
+    "Triforce": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/4/4e/TriforceALttPTitle.png?version=dc398e1293177581c16303e4f9d12a48",
+    "Triforce Piece": "https://www.zeldadungeon.net/wiki/images/thumb/5/54/Triforce_Fragment_-_BS_Zelda.png/62px-Triforce_Fragment_-_BS_Zelda.png",
+    "Small Key": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/f/f1/ALttP_Small_Key_Sprite.png?version=4f35d92842f0de39d969181eea03774e",
+    "Big Key": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/3/33/ALttP_Big_Key_Sprite.png?version=136dfa418ba76c8b4e270f466fc12f4d",
+    "Chest": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/7/73/ALttP_Treasure_Chest_Sprite.png?version=5f530ecd98dcb22251e146e8049c0dda",
+    "Light World": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/e/e7/ALttP_Soldier_Green_Sprite.png?version=d650d417934cd707a47e496489c268a6",
+    "Dark World": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/9/94/ALttP_Moblin_Sprite.png?version=ebf50e33f4657c377d1606bcc0886ddc",
+    "Hyrule Castle": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/d/d3/ALttP_Ball_and_Chain_Trooper_Sprite.png?version=1768a87c06d29cc8e7ddd80b9fa516be",
+    "Agahnims Tower": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/1/1e/ALttP_Agahnim_Sprite.png?version=365956e61b0c2191eae4eddbe591dab5",
+    "Desert Palace": "https://www.zeldadungeon.net/wiki/images/2/25/Lanmola-ALTTP-Sprite.png",
+    "Eastern Palace": "https://www.zeldadungeon.net/wiki/images/d/dc/RedArmosKnight.png",
+    "Tower of Hera": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/3/3c/ALttP_Moldorm_Sprite.png?version=c588257bdc2543468e008a6b30f262a7",
+    "Palace of Darkness": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/e/ed/ALttP_Helmasaur_King_Sprite.png?version=ab8a4a1cfd91d4fc43466c56cba30022",
+    "Swamp Palace": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/7/73/ALttP_Arrghus_Sprite.png?version=b098be3122e53f751b74f4a5ef9184b5",
+    "Skull Woods": "https://alttp-wiki.net/images/6/6a/Mothula.png",
+    "Thieves Town": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/8/86/ALttP_Blind_the_Thief_Sprite.png?version=3833021bfcd112be54e7390679047222",
+    "Ice Palace": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/3/33/ALttP_Kholdstare_Sprite.png?version=e5a1b0e8b2298e550d85f90bf97045c0",
+    "Misery Mire": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/8/85/ALttP_Vitreous_Sprite.png?version=92b2e9cb0aa63f831760f08041d8d8d8",
+    "Turtle Rock": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/9/91/ALttP_Trinexx_Sprite.png?version=0cc867d513952aa03edd155597a0c0be",
+    "Ganons Tower": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/b/b9/ALttP_Ganon_Sprite.png?version=956f51f054954dfff53c1a9d4f929c74",
+} -%}
+
+{%- block custom_table_headers %}
+{#- macro that creates a table header with display name and image -#}
+{%- macro make_header(name, img_src) %}
+    <th class="center-column">
+        <img height="24" src="{{ img_src }}" title="{{ name }}" alt="{{ name }}" />
+    </th>
+{% endmacro -%}
+
+{#- call the macro to build the table header -#}
+{%- for name in tracking_names %}
+    {%- if name in icons -%}
+        <th class="center-column">
+            <img class="icon-sprite" src="{{ icons[name] }}" alt="{{ name | e }}" title="{{ name | e }}" />
+        </th>
+    {%- endif %}
+{% endfor -%}
+{% endblock %}
+
+{# build each row of custom entries #}
+{% block custom_table_row scoped %}
+    {%- for id in tracking_ids -%}
+{#        {{ checks }}#}
+        {%- if inventories[(team, player)][id] -%}
+            <td class="center-column item-acquired">
+                {% if id in multi_items %}{{ inventories[(team, player)][id] }}{% else %}✔️{% endif %}
+            </td>
+        {%- else -%}
+            <td></td>
+        {%- endif -%}
+    {% endfor %}
+{% endblock %}
+
+{% block custom_tables %}
+
+{% for team, _ in total_team_locations.items() %}
+<div class="table-wrapper">
+    <table id="area-table" class="table non-unique-item-table">
+        <thead>
+            <tr>
+                <th rowspan="2">#</th>
+                <th rowspan="2">Name</th>
+                {% for area in ordered_areas %}
+                    {% set colspan = 1 %}
+                    {% if area in key_locations %}
+                    {% set colspan = colspan + 1 %}
+                    {% endif %}
+                    {% if area in big_key_locations %}
+                    {% set colspan = colspan + 1 %}
+                    {% endif %}
+                    {% if area in icons %}
+                        <th colspan="{{ colspan }}" class="center-column upper-row">
+                            <img class="icon-sprite" src="{{ icons[area] }}" alt="{{ area }}" title="{{ area }}"></th>
+                    {%- else -%}
+                        <th colspan="{{ colspan }}" class="center-column">{{ area }}</th>
+                    {%- endif -%}
+                {%- endfor -%}
+                <th rowspan="2" class="center-column">&percnt;</th>
+                <th rowspan="2" class="center-column hours">Last<br>Activity</th>
+            </tr>
+            <tr>
+                {% for area in ordered_areas %}
+                    <th class="center-column lower-row fraction">
+                        <img class="icon-sprite" src="{{ icons["Chest"] }}" alt="Checks" title="Checks Complete">
+                    </th>
+                    {% if area in key_locations %}
+                        <th class="center-column lower-row number">
+                            <img class="icon-sprite" src="{{ icons["Small Key"] }}" alt="Small Key" title="Small Keys">
+                        </th>
+                    {% endif %}
+                    {% if area in big_key_locations %}
+                        <th class="center-column lower-row number">
+                            <img class="icon-sprite" src="{{ icons["Big Key"] }}" alt="Big Key" title="Big Keys">
+                        </th>
+                    {%- endif -%}
+                {%- endfor -%}
+            </tr>
+        </thead>
+        <tbody>
+        {%- for (checks_team, player), area_checks in checks_done.items() if games[(team, player)] == current_tracker and team == checks_team -%}
+            <tr>
+                <td><a href="{{ url_for("get_player_tracker", tracker=room.tracker,
+                tracked_team=team, tracked_player=player)}}">{{ player }}</a></td>
+                <td>{{ player_names_with_alias[(team, player)] | e }}</td>
+                {%- for area in ordered_areas -%}
+                    {% if (team, player) in checks_in_area and area in checks_in_area[(team, player)] %}
+                        {%- set checks_done = area_checks[area] -%}
+                        {%- set checks_total = checks_in_area[(team, player)][area] -%}
+                        {%- if checks_done == checks_total -%}
+                            <td class="item-acquired center-column">
+                                {{ checks_done }}/{{ checks_total }}</td>
+                        {%- else -%}
+                            <td class="center-column">{{ checks_done }}/{{ checks_total }}</td>
+                        {%- endif -%}
+                        {%- if area in key_locations -%}
+                            <td class="center-column">{{ inventories[(team, player)][small_key_ids[area]] }}</td>
+                        {%- endif -%}
+                        {%- if area in big_key_locations -%}
+                            <td class="center-column">{% if inventories[(team, player)][big_key_ids[area]] %}✔️{% endif %}</td>
+                        {%- endif -%}
+                    {% else %}
+                        <td class="center-column"></td>
+                        {%- if area in key_locations -%}
+                            <td class="center-column"></td>
+                        {%- endif -%}
+                        {%- if area in big_key_locations -%}
+                            <td class="center-column"></td>
+                        {%- endif -%}
+                    {% endif %}
+                {%- endfor -%}
+
+                <td class="center-column">
+                {% set location_count = locations[(team, player)] | length %}
+                {%- if locations[(team, player)] | length > 0 -%}
+                    {% set percentage_of_completion = locations_complete[(team, player)] / location_count * 100 %}
+                    {{ "{0:.2f}".format(percentage_of_completion) }}
+                {%- else -%}
+                    100.00
+                {%- endif -%}
+                </td>
+
+                {%- if activity_timers[(team, player)] -%}
+                    <td class="center-column">{{ activity_timers[(team, player)].total_seconds() }}</td>
+                {%- else -%}
+                    <td class="center-column">None</td>
+                {%- endif -%}
+            </tr>
+        {%- endfor -%}
+        </tbody>
+    </table>
+</div>
+{% endfor %}
+
+{% endblock %}

WebHostLib/templates/multitracker__Factorio.html

@@ -0,0 +1,41 @@
+{% extends "multitracker.html" %}
+{# establish the to be tracked data. Display Name, factorio/AP internal name, display image #}
+{%- set science_packs = [
+    ("Logistic Science Pack", "logistic-science-pack",
+    "https://wiki.factorio.com/images/thumb/Logistic_science_pack.png/32px-Logistic_science_pack.png"),
+    ("Military Science Pack", "military-science-pack",
+    "https://wiki.factorio.com/images/thumb/Military_science_pack.png/32px-Military_science_pack.png"),
+    ("Chemical Science Pack", "chemical-science-pack",
+    "https://wiki.factorio.com/images/thumb/Chemical_science_pack.png/32px-Chemical_science_pack.png"),
+    ("Production Science Pack", "production-science-pack",
+    "https://wiki.factorio.com/images/thumb/Production_science_pack.png/32px-Production_science_pack.png"),
+    ("Utility Science Pack", "utility-science-pack",
+    "https://wiki.factorio.com/images/thumb/Utility_science_pack.png/32px-Utility_science_pack.png"),
+    ("Space Science Pack", "space-science-pack",
+    "https://wiki.factorio.com/images/thumb/Space_science_pack.png/32px-Space_science_pack.png"),
+] -%}
+
+{%- block custom_table_headers %}
+{#- macro that creates a table header with display name and image -#}
+{%- macro make_header(name, img_src) %}
+<th class="center-column">
+    <img class="icon-sprite" src="{{ img_src }}" alt="{{ name }}" title="{{ name }}" />
+</th>
+{% endmacro -%}
+{#- call the macro to build the table header -#}
+{%- for name, internal_name, img_src in science_packs %}
+    {{ make_header(name, img_src) }}
+{% endfor -%}
+{% endblock %}
+
+{% block custom_table_row scoped  %}
+    {%- set player_inventory = inventories[(team, player)] -%}
+    {%- set prog_science = player_inventory["progressive-science-pack"] -%}
+    {%- for name, internal_name, img_src in science_packs %}
+        {% if player_inventory[internal_name] or prog_science > loop.index0 %}
+            <td class="center-column item-acquired">✔️</td>
+        {% else %}
+            <td class="center-column"></td>
+        {% endif %}
+    {% endfor -%}
+{% endblock%}

WebHostLib/templates/pageWrapper.html

@@ -16,7 +16,7 @@
 {% with messages = get_flashed_messages() %}
     {% if messages %}
         <div>
-            {% for message in messages %}
+            {% for message in messages | unique %}
                 <div class="user-message">{{ message }}</div>
             {% endfor %}
         </div>

WebHostLib/templates/player-options.html

@@ -1,26 +1,26 @@
 {% extends 'pageWrapper.html' %}
 
 {% block head %}
-    <title>{{ game }} Settings</title>
+    <title>{{ game }} Options</title>
     <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename="styles/markdown.css") }}" />
-    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename="styles/player-settings.css") }}" />
+    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename="styles/player-options.css") }}" />
     <script type="application/ecmascript" src="https://cdn.jsdelivr.net/npm/axios/dist/axios.min.js"></script>
     <script type="application/ecmascript" src="{{ url_for('static', filename="assets/md5.min.js") }}"></script>
     <script type="application/ecmascript" src="{{ url_for('static', filename="assets/js-yaml.min.js") }}"></script>
-    <script type="application/ecmascript" src="{{ url_for('static', filename="assets/player-settings.js") }}"></script>
+    <script type="application/ecmascript" src="{{ url_for('static', filename="assets/player-options.js") }}"></script>
 {% endblock %}
 
 {% block body %}
     {% include 'header/'+theme+'Header.html' %}
-    <div id="player-settings" class="markdown" data-game="{{ game }}">
+    <div id="player-options" class="markdown" data-game="{{ game }}">
         <div id="user-message"></div>
-        <h1><span id="game-name">Player</span> Settings</h1>
+        <h1><span id="game-name">Player</span> Options</h1>
         <p>Choose the options you would like to play with! You may generate a single-player game from this page,
-            or download a settings file you can use to participate in a MultiWorld.</p>
+            or download an options file you can use to participate in a MultiWorld.</p>
 
         <p>
-            A more advanced settings configuration for all games can be found on the
-            <a href="/weighted-settings">Weighted Settings</a> page.
+            A more advanced options configuration for all games can be found on the
+            <a href="/weighted-options">Weighted options</a> page.
             <br />
             A list of all games you have generated can be found on the <a href="/user-content">User Content Page</a>.
             <br />
@@ -28,10 +28,24 @@
             <a href="/static/generated/configs/{{ game }}.yaml">template file for this game</a>.
         </p>
 
-        <p><label for="player-name">Please enter your player name. This will appear in-game as you send and receive
-            items if you are playing in a MultiWorld.</label><br />
-            <input id="player-name" placeholder="Player Name" data-key="name" maxlength="16" />
-        </p>
+        <div id="meta-options">
+            <div>
+                <label for="player-name">
+                    Player Name: <span class="interactive" data-tooltip="This is the name you use to connect with your game. This is also known as your 'slot name'.">(?)</span>
+                </label>
+                <input id="player-name" placeholder="Player" data-key="name" maxlength="16" />
+            </div>
+            <div>
+                <label for="game-options-preset">
+                    Options Preset: <span class="interactive" data-tooltip="Select from a list of developer-curated presets (if any) or reset all options to their defaults.">(?)</span>
+                </label>
+                <select id="game-options-preset">
+                    <option value="__default">Defaults</option>
+                    <option value="__custom" hidden>Custom</option>
+                </select>
+            </div>
+
+        </div>
 
         <h2>Game Options</h2>
         <div id="game-options">
@@ -39,8 +53,8 @@
             <div id="game-options-right" class="right"></div>
         </div>
 
-        <div id="player-settings-button-row">
-            <button id="export-settings">Export Settings</button>
+        <div id="player-options-button-row">
+            <button id="export-options">Export Options</button>
             <button id="generate-game">Generate Game</button>
             <button id="generate-race">Generate Race</button>
         </div>

WebHostLib/templates/sc2wolTracker.html

@@ -1,233 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <title>{{ player_name }}&apos;s Tracker</title>
-    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename='styles/sc2wolTracker.css') }}"/>
-    <script type="application/ecmascript" src="{{ url_for('static', filename='assets/sc2wolTracker.js') }}"></script>
-    <link rel="stylesheet" media="screen" href="https://fontlibrary.org//face/jura" type="text/css"/>
-</head>
-
-<body>
-    <div id="player-tracker-wrapper" data-tracker="{{ room.tracker|suuid }}">
-        <table id="inventory-table">
-            <tr>
-                <td colspan="10" class="title">
-                    Starting Resources
-                </td>
-            </tr>
-            <tr>
-                <td><img src="{{ icons['Starting Minerals'] }}" class="{{ 'acquired' if '+15 Starting Minerals' in acquired_items }}" title="Starting Minerals" /></td>
-                <td colspan="2"><div class="item-count">+{{ minerals_count }}</div></td>
-                <td><img src="{{ icons['Starting Vespene'] }}" class="{{ 'acquired' if '+15 Starting Vespene' in acquired_items }}" title="Starting Vespene" /></td>
-                <td colspan="2"><div class="item-count">+{{ vespene_count }}</div></td>
-                <!--
-                <td><img src="{{ icons['Starting Supply'] }}" class="{{ 'acquired' if '+2 Starting Supply' in acquired_items }}" title="Starting Supply" /></td>
-                <td colspan="2"><div class="item-count">+{{ supply_count }}</div></td>
-                -->
-            </tr>
-            <tr>
-                <td colspan="10" class="title">
-                    Weapon & Armor Upgrades
-                </td>
-            </tr>
-            <tr>
-                <td><img src="{{ infantry_weapon_url }}" class="{{ 'acquired' if 'Progressive Infantry Weapon' in acquired_items }}" title="Progressive Infantry Weapons{% if infantry_weapon_level > 0 %} (Level {{ infantry_weapon_level }}){% endif %}" /></td>
-                <td><img src="{{ infantry_armor_url }}" class="{{ 'acquired' if 'Progressive Infantry Armor' in acquired_items }}" title="Progressive Infantry Armor{% if infantry_armor_level > 0 %} (Level {{ infantry_armor_level }}){% endif %}" /></td>
-                <td><img src="{{ vehicle_weapon_url }}" class="{{ 'acquired' if 'Progressive Vehicle Weapon' in acquired_items }}" title="Progressive Vehicle Weapons{% if vehicle_weapon_level > 0 %} (Level {{ vehicle_weapon_level }}){% endif %}" /></td>
-                <td><img src="{{ vehicle_armor_url }}" class="{{ 'acquired' if 'Progressive Vehicle Armor' in acquired_items }}" title="Progressive Vehicle Armor{% if vehicle_armor_level > 0 %} (Level {{ vehicle_armor_level }}){% endif %}" /></td>
-                <td><img src="{{ ship_weapon_url }}" class="{{ 'acquired' if 'Progressive Ship Weapon' in acquired_items }}" title="Progressive Ship Weapons{% if ship_weapon_level > 0 %} (Level {{ ship_weapon_level }}){% endif %}" /></td>
-                <td><img src="{{ ship_armor_url }}" class="{{ 'acquired' if 'Progressive Ship Armor' in acquired_items }}" title="Progressive Ship Armor{% if ship_armor_level > 0 %} (Level {{ ship_armor_level }}){% endif %}" /></td>
-            </tr>
-            <tr>
-                <td colspan="10" class="title">
-                    Base
-                </td>
-            </tr>
-            <tr>
-                <td colspan="2"><img src="{{ icons['Bunker'] }}" class="{{ 'acquired' if 'Bunker' in acquired_items }}" title="Bunker" /></td>
-                <td colspan="2"><img src="{{ icons['Missile Turret'] }}" class="{{ 'acquired' if 'Missile Turret' in acquired_items }}" title="Missile Turret" /></td>
-                <td colspan="2"><img src="{{ icons['Sensor Tower'] }}" class="{{ 'acquired' if 'Sensor Tower' in acquired_items }}" title="Sensor Tower" /></td>
-            </tr>
-            <tr>
-                <td><img src="{{ icons['Projectile Accelerator (Bunker)'] }}" class="{{ 'acquired' if 'Projectile Accelerator (Bunker)' in acquired_items }}" title="Projectile Accelerator (Bunker)" /></td>
-                <td><img src="{{ icons['Neosteel Bunker (Bunker)'] }}" class="{{ 'acquired' if 'Neosteel Bunker (Bunker)' in acquired_items }}" title="Neosteel Bunker (Bunker)" /></td>
-                <td><img src="{{ icons['Titanium Housing (Missile Turret)'] }}" class="{{ 'acquired' if 'Titanium Housing (Missile Turret)' in acquired_items }}" title="Titanium Housing (Missile Turret)" /></td>
-                <td><img src="{{ icons['Hellstorm Batteries (Missile Turret)'] }}" class="{{ 'acquired' if 'Hellstorm Batteries (Missile Turret)' in acquired_items }}" title="Hellstorm Batteries (Missile Turret)" /></td>
-                <td colspan="2">&nbsp;</td>
-                <td><img src="{{ icons['Advanced Construction (SCV)'] }}" class="{{ 'acquired' if 'Advanced Construction (SCV)' in acquired_items }}" title="Advanced Construction (SCV)" /></td>
-                <td><img src="{{ icons['Dual-Fusion Welders (SCV)'] }}" class="{{ 'acquired' if 'Dual-Fusion Welders (SCV)' in acquired_items }}" title="Dual-Fusion Welders (SCV)" /></td>
-                <td><img src="{{ icons['Fire-Suppression System (Building)'] }}" class="{{ 'acquired' if 'Fire-Suppression System (Building)' in acquired_items }}" title="Fire-Suppression System (Building)" /></td>
-                <td><img src="{{ icons['Orbital Command (Building)'] }}" class="{{ 'acquired' if 'Orbital Command (Building)' in acquired_items }}" title="Orbital Command (Building)" /></td>
-            </tr>
-            <tr>
-                <td colspan="10" class="title">
-                    Infantry
-                </td>
-            </tr>
-            <tr>
-                <td colspan="2"><img src="{{ icons['Marine'] }}" class="{{ 'acquired' if 'Marine' in acquired_items }}" title="Marine" /></td>
-                <td colspan="2"><img src="{{ icons['Medic'] }}" class="{{ 'acquired' if 'Medic' in acquired_items }}" title="Medic" /></td>
-                <td colspan="2"><img src="{{ icons['Firebat'] }}" class="{{ 'acquired' if 'Firebat' in acquired_items }}" title="Firebat" /></td>
-                <td colspan="2"><img src="{{ icons['Marauder'] }}" class="{{ 'acquired' if 'Marauder' in acquired_items }}" title="Marauder" /></td>
-                <td colspan="2"><img src="{{ icons['Reaper'] }}" class="{{ 'acquired' if 'Reaper' in acquired_items }}" title="Reaper" /></td>
-            </tr>
-            <tr>
-                <td><img src="{{ icons['Stimpack (Marine)'] }}" class="{{ 'acquired' if 'Stimpack (Marine)' in acquired_items }}" title="Stimpack (Marine)" /></td>
-                <td><img src="{{ icons['Combat Shield (Marine)'] }}" class="{{ 'acquired' if 'Combat Shield (Marine)' in acquired_items }}" title="Combat Shield (Marine)" /></td>
-                <td><img src="{{ icons['Advanced Medic Facilities (Medic)'] }}" class="{{ 'acquired' if 'Advanced Medic Facilities (Medic)' in acquired_items }}" title="Advanced Medic Facilities (Medic)" /></td>
-                <td><img src="{{ icons['Stabilizer Medpacks (Medic)'] }}" class="{{ 'acquired' if 'Stabilizer Medpacks (Medic)' in acquired_items }}" title="Stabilizer Medpacks (Medic)" /></td>
-                <td><img src="{{ icons['Incinerator Gauntlets (Firebat)'] }}" class="{{ 'acquired' if 'Incinerator Gauntlets (Firebat)' in acquired_items }}" title="Incinerator Gauntlets (Firebat)" /></td>
-                <td><img src="{{ icons['Juggernaut Plating (Firebat)'] }}" class="{{ 'acquired' if 'Juggernaut Plating (Firebat)' in acquired_items }}" title="Juggernaut Plating (Firebat)" /></td>
-                <td><img src="{{ icons['Concussive Shells (Marauder)'] }}" class="{{ 'acquired' if 'Concussive Shells (Marauder)' in acquired_items }}" title="Concussive Shells (Marauder)" /></td>
-                <td><img src="{{ icons['Kinetic Foam (Marauder)'] }}" class="{{ 'acquired' if 'Kinetic Foam (Marauder)' in acquired_items }}" title="Kinetic Foam (Marauder)" /></td>
-                <td><img src="{{ icons['U-238 Rounds (Reaper)'] }}" class="{{ 'acquired' if 'U-238 Rounds (Reaper)' in acquired_items }}" title="U-238 Rounds (Reaper)" /></td>
-                <td><img src="{{ icons['G-4 Clusterbomb (Reaper)'] }}" class="{{ 'acquired' if 'G-4 Clusterbomb (Reaper)' in acquired_items }}" title="G-4 Clusterbomb (Reaper)" /></td>
-            </tr>
-            <tr>
-                <td colspan="10" class="title">
-                    Vehicles
-                </td>
-            </tr>
-            <tr>
-                <td colspan="2"><img src="{{ icons['Hellion'] }}" class="{{ 'acquired' if 'Hellion' in acquired_items }}" title="Hellion" /></td>
-                <td colspan="2"><img src="{{ icons['Vulture'] }}" class="{{ 'acquired' if 'Vulture' in acquired_items }}" title="Vulture" /></td>
-                <td colspan="2"><img src="{{ icons['Goliath'] }}" class="{{ 'acquired' if 'Goliath' in acquired_items }}" title="Goliath" /></td>
-                <td colspan="2"><img src="{{ icons['Diamondback'] }}" class="{{ 'acquired' if 'Diamondback' in acquired_items }}" title="Diamondback" /></td>
-                <td colspan="2"><img src="{{ icons['Siege Tank'] }}" class="{{ 'acquired' if 'Siege Tank' in acquired_items }}" title="Siege Tank" /></td>
-            </tr>
-            <tr>
-                <td><img src="{{ icons['Twin-Linked Flamethrower (Hellion)'] }}" class="{{ 'acquired' if 'Twin-Linked Flamethrower (Hellion)' in acquired_items }}" title="Twin-Linked Flamethrower (Hellion)" /></td>
-                <td><img src="{{ icons['Thermite Filaments (Hellion)'] }}" class="{{ 'acquired' if 'Thermite Filaments (Hellion)' in acquired_items }}" title="Thermite Filaments (Hellion)" /></td>
-                <td><img src="{{ icons['Cerberus Mine (Vulture)'] }}" class="{{ 'acquired' if 'Cerberus Mine (Vulture)' in acquired_items }}" title="Cerberus Mine (Vulture)" /></td>
-                <td><img src="{{ icons['Replenishable Magazine (Vulture)'] }}" class="{{ 'acquired' if 'Replenishable Magazine (Vulture)' in acquired_items }}" title="Replenishable Magazine (Vulture)" /></td>
-                <td><img src="{{ icons['Multi-Lock Weapons System (Goliath)'] }}" class="{{ 'acquired' if 'Multi-Lock Weapons System (Goliath)' in acquired_items }}" title="Multi-Lock Weapons System (Goliath)" /></td>
-                <td><img src="{{ icons['Ares-Class Targeting System (Goliath)'] }}" class="{{ 'acquired' if 'Ares-Class Targeting System (Goliath)' in acquired_items }}" title="Ares-Class Targeting System (Goliath)" /></td>
-                <td><img src="{{ icons['Tri-Lithium Power Cell (Diamondback)'] }}" class="{{ 'acquired' if 'Tri-Lithium Power Cell (Diamondback)' in acquired_items }}" title="Tri-Lithium Power Cell (Diamondback)" /></td>
-                <td><img src="{{ icons['Shaped Hull (Diamondback)'] }}" class="{{ 'acquired' if 'Shaped Hull (Diamondback)' in acquired_items }}" title="Shaped Hull (Diamondback)" /></td>
-                <td><img src="{{ icons['Maelstrom Rounds (Siege Tank)'] }}" class="{{ 'acquired' if 'Maelstrom Rounds (Siege Tank)' in acquired_items }}" title="Maelstrom Rounds (Siege Tank)" /></td>
-                <td><img src="{{ icons['Shaped Blast (Siege Tank)'] }}" class="{{ 'acquired' if 'Shaped Blast (Siege Tank)' in acquired_items }}" title="Shaped Blast (Siege Tank)" /></td>
-            </tr>
-            <tr>
-                <td colspan="10" class="title">
-                    Starships
-                </td>
-            </tr>
-            <tr>
-                <td colspan="2"><img src="{{ icons['Medivac'] }}" class="{{ 'acquired' if 'Medivac' in acquired_items }}" title="Medivac" /></td>
-                <td colspan="2"><img src="{{ icons['Wraith'] }}" class="{{ 'acquired' if 'Wraith' in acquired_items }}" title="Wraith" /></td>
-                <td colspan="2"><img src="{{ icons['Viking'] }}" class="{{ 'acquired' if 'Viking' in acquired_items }}" title="Viking" /></td>
-                <td colspan="2"><img src="{{ icons['Banshee'] }}" class="{{ 'acquired' if 'Banshee' in acquired_items }}" title="Banshee" /></td>
-                <td colspan="2"><img src="{{ icons['Battlecruiser'] }}" class="{{ 'acquired' if 'Battlecruiser' in acquired_items }}" title="Battlecruiser" /></td>
-            </tr>
-            <tr>
-                <td><img src="{{ icons['Rapid Deployment Tube (Medivac)'] }}" class="{{ 'acquired' if 'Rapid Deployment Tube (Medivac)' in acquired_items }}" title="Rapid Deployment Tube (Medivac)" /></td>
-                <td><img src="{{ icons['Advanced Healing AI (Medivac)'] }}" class="{{ 'acquired' if 'Advanced Healing AI (Medivac)' in acquired_items }}" title="Advanced Healing AI (Medivac)" /></td>
-                <td><img src="{{ icons['Tomahawk Power Cells (Wraith)'] }}" class="{{ 'acquired' if 'Tomahawk Power Cells (Wraith)' in acquired_items }}" title="Tomahawk Power Cells (Wraith)" /></td>
-                <td><img src="{{ icons['Displacement Field (Wraith)'] }}" class="{{ 'acquired' if 'Displacement Field (Wraith)' in acquired_items }}" title="Displacement Field (Wraith)" /></td>
-                <td><img src="{{ icons['Ripwave Missiles (Viking)'] }}" class="{{ 'acquired' if 'Ripwave Missiles (Viking)' in acquired_items }}" title="Ripwave Missiles (Viking)" /></td>
-                <td><img src="{{ icons['Phobos-Class Weapons System (Viking)'] }}" class="{{ 'acquired' if 'Phobos-Class Weapons System (Viking)' in acquired_items }}" title="Phobos-Class Weapons System (Viking)" /></td>
-                <td><img src="{{ icons['Cross-Spectrum Dampeners (Banshee)'] }}" class="{{ 'acquired' if 'Cross-Spectrum Dampeners (Banshee)' in acquired_items }}" title="Cross-Spectrum Dampeners (Banshee)" /></td>
-                <td><img src="{{ icons['Shockwave Missile Battery (Banshee)'] }}" class="{{ 'acquired' if 'Shockwave Missile Battery (Banshee)' in acquired_items }}" title="Shockwave Missile Battery (Banshee)" /></td>
-                <td><img src="{{ icons['Missile Pods (Battlecruiser)'] }}" class="{{ 'acquired' if 'Missile Pods (Battlecruiser)' in acquired_items }}" title="Missile Pods (Battlecruiser)" /></td>
-                <td><img src="{{ icons['Defensive Matrix (Battlecruiser)'] }}" class="{{ 'acquired' if 'Defensive Matrix (Battlecruiser)' in acquired_items }}" title="Defensive Matrix (Battlecruiser)" /></td>
-            </tr>
-            <tr>
-                <td colspan="10" class="title">
-                    Dominion
-                </td>
-            </tr>
-            <tr>
-                <td colspan="2"><img src="{{ icons['Ghost'] }}" class="{{ 'acquired' if 'Ghost' in acquired_items }}" title="Ghost" /></td>
-                <td colspan="2"><img src="{{ icons['Spectre'] }}" class="{{ 'acquired' if 'Spectre' in acquired_items }}" title="Spectre" /></td>
-                <td colspan="2"><img src="{{ icons['Thor'] }}" class="{{ 'acquired' if 'Thor' in acquired_items }}" title="Thor" /></td>
-            </tr>
-            <tr>
-                <td><img src="{{ icons['Ocular Implants (Ghost)'] }}" class="{{ 'acquired' if 'Ocular Implants (Ghost)' in acquired_items }}" title="Ocular Implants (Ghost)" /></td>
-                <td><img src="{{ icons['Crius Suit (Ghost)'] }}" class="{{ 'acquired' if 'Crius Suit (Ghost)' in acquired_items }}" title="Crius Suit (Ghost)" /></td>
-                <td><img src="{{ icons['Psionic Lash (Spectre)'] }}" class="{{ 'acquired' if 'Psionic Lash (Spectre)' in acquired_items }}" title="Psionic Lash (Spectre)" /></td>
-                <td><img src="{{ icons['Nyx-Class Cloaking Module (Spectre)'] }}" class="{{ 'acquired' if 'Nyx-Class Cloaking Module (Spectre)' in acquired_items }}" title="Nyx-Class Cloaking Module (Spectre)" /></td>
-                <td><img src="{{ icons['330mm Barrage Cannon (Thor)'] }}" class="{{ 'acquired' if '330mm Barrage Cannon (Thor)' in acquired_items }}" title="330mm Barrage Cannon (Thor)" /></td>
-                <td><img src="{{ icons['Immortality Protocol (Thor)'] }}" class="{{ 'acquired' if 'Immortality Protocol (Thor)' in acquired_items }}" title="Immortality Protocol (Thor)" /></td>
-            </tr>
-            <tr>
-                <td colspan="10" class="title">
-                    Mercenaries
-                </td>
-            </tr>
-            <tr>
-                <td><img src="{{ icons['War Pigs'] }}" class="{{ 'acquired' if 'War Pigs' in acquired_items }}" title="War Pigs" /></td>
-                <td><img src="{{ icons['Devil Dogs'] }}" class="{{ 'acquired' if 'Devil Dogs' in acquired_items }}" title="Devil Dogs" /></td>
-                <td><img src="{{ icons['Hammer Securities'] }}" class="{{ 'acquired' if 'Hammer Securities' in acquired_items }}" title="Hammer Securities" /></td>
-                <td><img src="{{ icons['Spartan Company'] }}" class="{{ 'acquired' if 'Spartan Company' in acquired_items }}" title="Spartan Company" /></td>
-                <td><img src="{{ icons['Siege Breakers'] }}" class="{{ 'acquired' if 'Siege Breakers' in acquired_items }}" title="Siege Breakers" /></td>
-                <td><img src="{{ icons['Hel\'s Angel'] }}" class="{{ 'acquired' if 'Hel\'s Angel' in acquired_items }}" title="Hel's Angel" /></td>
-                <td><img src="{{ icons['Dusk Wings'] }}" class="{{ 'acquired' if 'Dusk Wings' in acquired_items }}" title="Dusk Wings" /></td>
-                <td><img src="{{ icons['Jackson\'s Revenge'] }}" class="{{ 'acquired' if 'Jackson\'s Revenge' in acquired_items }}" title="Jackson's Revenge" /></td>
-            </tr>
-            <tr>
-                <td colspan="10" class="title">
-                    Lab Upgrades
-                </td>
-            </tr>
-            <tr>
-                <td><img src="{{ icons['Ultra-Capacitors'] }}" class="{{ 'acquired' if 'Ultra-Capacitors' in acquired_items }}" title="Ultra-Capacitors" /></td>
-                <td><img src="{{ icons['Vanadium Plating'] }}" class="{{ 'acquired' if 'Vanadium Plating' in acquired_items }}" title="Vanadium Plating" /></td>
-                <td><img src="{{ icons['Orbital Depots'] }}" class="{{ 'acquired' if 'Orbital Depots' in acquired_items }}" title="Orbital Depots" /></td>
-                <td><img src="{{ icons['Micro-Filtering'] }}" class="{{ 'acquired' if 'Micro-Filtering' in acquired_items }}" title="Micro-Filtering" /></td>
-                <td><img src="{{ icons['Automated Refinery'] }}" class="{{ 'acquired' if 'Automated Refinery' in acquired_items }}" title="Automated Refinery" /></td>
-                <td><img src="{{ icons['Command Center Reactor'] }}" class="{{ 'acquired' if 'Command Center Reactor' in acquired_items }}" title="Command Center Reactor" /></td>
-                <td><img src="{{ icons['Raven'] }}" class="{{ 'acquired' if 'Raven' in acquired_items }}" title="Raven" /></td>
-                <td><img src="{{ icons['Science Vessel'] }}" class="{{ 'acquired' if 'Science Vessel' in acquired_items }}" title="Science Vessel" /></td>
-                <td><img src="{{ icons['Tech Reactor'] }}" class="{{ 'acquired' if 'Tech Reactor' in acquired_items }}" title="Tech Reactor" /></td>
-                <td><img src="{{ icons['Orbital Strike'] }}" class="{{ 'acquired' if 'Orbital Strike' in acquired_items }}" title="Orbital Strike" /></td>
-            </tr>
-            <tr>
-                <td><img src="{{ icons['Shrike Turret'] }}" class="{{ 'acquired' if 'Shrike Turret' in acquired_items }}" title="Shrike Turret" /></td>
-                <td><img src="{{ icons['Fortified Bunker'] }}" class="{{ 'acquired' if 'Fortified Bunker' in acquired_items }}" title="Fortified Bunker" /></td>
-                <td><img src="{{ icons['Planetary Fortress'] }}" class="{{ 'acquired' if 'Planetary Fortress' in acquired_items }}" title="Planetary Fortress" /></td>
-                <td><img src="{{ icons['Perdition Turret'] }}" class="{{ 'acquired' if 'Perdition Turret' in acquired_items }}" title="Perdition Turret" /></td>
-                <td><img src="{{ icons['Predator'] }}" class="{{ 'acquired' if 'Predator' in acquired_items }}" title="Predator" /></td>
-                <td><img src="{{ icons['Hercules'] }}" class="{{ 'acquired' if 'Hercules' in acquired_items }}" title="Hercules" /></td>
-                <td><img src="{{ icons['Cellular Reactor'] }}" class="{{ 'acquired' if 'Cellular Reactor' in acquired_items }}" title="Cellular Reactor" /></td>
-                <td><img src="{{ icons['Regenerative Bio-Steel'] }}" class="{{ 'acquired' if 'Regenerative Bio-Steel' in acquired_items }}" title="Regenerative Bio-Steel" /></td>
-                <td><img src="{{ icons['Hive Mind Emulator'] }}" class="{{ 'acquired' if 'Hive Mind Emulator' in acquired_items }}" title="Hive Mind Emulator" /></td>
-                <td><img src="{{ icons['Psi Disrupter'] }}" class="{{ 'acquired' if 'Psi Disrupter' in acquired_items }}" title="Psi Disrupter" /></td>
-            </tr>
-            <tr>
-                <td colspan="10" class="title">
-                    Protoss Units
-                </td>
-            </tr>
-            <tr>
-                <td><img src="{{ icons['Zealot'] }}" class="{{ 'acquired' if 'Zealot' in acquired_items }}" title="Zealot" /></td>
-                <td><img src="{{ icons['Stalker'] }}" class="{{ 'acquired' if 'Stalker' in acquired_items }}" title="Stalker" /></td>
-                <td><img src="{{ icons['High Templar'] }}" class="{{ 'acquired' if 'High Templar' in acquired_items }}" title="High Templar" /></td>
-                <td><img src="{{ icons['Dark Templar'] }}" class="{{ 'acquired' if 'Dark Templar' in acquired_items }}" title="Dark Templar" /></td>
-                <td><img src="{{ icons['Immortal'] }}" class="{{ 'acquired' if 'Immortal' in acquired_items }}" title="Immortal" /></td>
-                <td><img src="{{ icons['Colossus'] }}" class="{{ 'acquired' if 'Colossus' in acquired_items }}" title="Colossus" /></td>
-                <td><img src="{{ icons['Phoenix'] }}" class="{{ 'acquired' if 'Phoenix' in acquired_items }}" title="Phoenix" /></td>
-                <td><img src="{{ icons['Void Ray'] }}" class="{{ 'acquired' if 'Void Ray' in acquired_items }}" title="Void Ray" /></td>
-                <td><img src="{{ icons['Carrier'] }}" class="{{ 'acquired' if 'Carrier' in acquired_items }}" title="Carrier" /></td>
-            </tr>
-        </table>
-        <table id="location-table">
-            {% for area in checks_in_area %}
-            {% if checks_in_area[area] > 0 %}
-            <tr class="location-category" id="{{area}}-header">
-                <td>{{ area }} {{'▼' if area != 'Total'}}</td>
-                <td class="counter">{{ checks_done[area] }} / {{ checks_in_area[area] }}</td>
-            </tr>
-            <tbody class="locations hide" id="{{area}}">
-                {% for location in location_info[area] %}
-                <tr>
-                    <td class="location-name">{{ location }}</td>
-                    <td class="counter">{{ '✔' if location_info[area][location] else '' }}</td>
-                </tr>
-                {% endfor %}
-            </tbody>
-            {% endif %}
-            {% endfor %}
-        </table>
-    </div>
-</body>
-</html>

WebHostLib/templates/siteMap.html

@@ -24,7 +24,7 @@
             <li><a href="/games">Supported Games Page</a></li>
             <li><a href="/tutorial">Tutorials Page</a></li>
             <li><a href="/user-content">User Content</a></li>
-            <li><a href="/weighted-settings">Weighted Settings Page</a></li>
+            <li><a href="/weighted-options">Weighted Options Page</a></li>
             <li><a href="{{url_for('stats')}}">Game Statistics</a></li>
             <li><a href="/glossary/en">Glossary</a></li>
         </ul>
@@ -32,7 +32,6 @@
         <h2>Tutorials</h2>
         <ul>
             <li><a href="/tutorial/Archipelago/setup/en">Multiworld Setup Tutorial</a></li>
-            <li><a href="/tutorial/Archipelago/using_website/en">Website User Guide</a></li>
             <li><a href="/tutorial/Archipelago/mac/en">Setup Guide for Mac</a></li>
             <li><a href="/tutorial/Archipelago/commands/en">Server and Client Commands</a></li>
             <li><a href="/tutorial/Archipelago/advanced_settings/en">Advanced YAML Guide</a></li>
@@ -47,11 +46,11 @@
             {% endfor %}
         </ul>
 
-        <h2>Game Settings Pages</h2>
+        <h2>Game Options Pages</h2>
         <ul>
             {% for game in games | title_sorted %}
                 {% if game['has_settings'] %}
-                    <li><a href="{{ url_for('player_settings', game=game['title']) }}">{{ game['title'] }}</a></li>
+                    <li><a href="{{ url_for('player_options', game=game['title']) }}">{{ game['title'] }}</a></li>
                 {% endif %} 
             {% endfor %}
         </ul>

WebHostLib/templates/supportedGames.html

@@ -4,28 +4,59 @@
     <title>Supported Games</title>
     <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename="styles/markdown.css") }}" />
     <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename="styles/supportedGames.css") }}" />
+    <script type="application/ecmascript" src="{{ url_for('static', filename="assets/supportedGames.js") }}"></script>
+    <noscript>
+    <style>
+        /* always un-collapse all and hide arrow and search bar */
+        .js-only{
+          display: none;
+        }
+
+        #games p.collapsed{
+          display: block;
+        }
+
+        #games h2 .collapse-arrow{
+          display: none;
+        }
+
+        #games .collapse-toggle{
+          cursor: unset;
+        }
+    </style>
+    </noscript>
 {% endblock %}
 
 {% block body %}
     {% include 'header/oceanHeader.html' %}
     <div id="games" class="markdown">
         <h1>Currently Supported Games</h1>
+        <div class="js-only">
+            <label for="game-search">Search for your game below!</label><br />
+            <div class="page-controls">
+                <input id="game-search" placeholder="Search by title..." autofocus />
+                <button id="expand-all">Expand All</button>
+                <button id="collapse-all">Collapse All</button>
+            </div>
+        </div>
         {% for game_name in worlds | title_sorted %}
         {% set world = worlds[game_name] %}
-        <h2>{{ game_name }}</h2>
-        <p>
+        <h2 class="collapse-toggle" data-game="{{ game_name }}">
+            <span class="collapse-arrow">▶</span>{{ game_name }}
+        </h2>
+        <p class="collapsed">
             {{ world.__doc__ | default("No description provided.", true) }}<br />
             <a href="{{ url_for("game_info", game=game_name, lang="en") }}">Game Page</a>
             {% if world.web.tutorials %}
             <span class="link-spacer">|</span>
             <a href="{{ url_for("tutorial_landing") }}#{{ game_name }}">Setup Guides</a>
             {% endif %}
-            {% if world.web.settings_page is string %}
+            {% if world.web.options_page is string %}
             <span class="link-spacer">|</span>
-            <a href="{{ world.web.settings_page }}">Settings Page</a>
-            {% elif world.web.settings_page %}
+            <a href="{{ world.web.options_page }}">Options Page</a>
+            {% elif world.web.options_page %}
             <span class="link-spacer">|</span>
-            <a href="{{ url_for("player_settings", game=game_name) }}">Settings Page</a>
+            <a href="{{ url_for("player_options", game=game_name) }}">Options Page</a>
             {% endif %}
             {% if world.web.bug_report_page %}
             <span class="link-spacer">|</span>

WebHostLib/templates/tracker__ALinkToThePast.html

@@ -0,0 +1,154 @@
+{%- set icons = {
+    "Blue Shield": "https://www.zeldadungeon.net/wiki/images/8/85/Fighters-Shield.png",
+    "Red Shield": "https://www.zeldadungeon.net/wiki/images/5/55/Fire-Shield.png",
+    "Mirror Shield": "https://www.zeldadungeon.net/wiki/images/8/84/Mirror-Shield.png",
+    "Fighter Sword": "https://oyster.ignimgs.com/mediawiki/apis.ign.com/the-legend-of-zelda-a-link-to-the-past/4/40/SFighterSword.png?width=1920",
+    "Master Sword": "https://oyster.ignimgs.com/mediawiki/apis.ign.com/the-legend-of-zelda-a-link-to-the-past/6/65/SMasterSword.png?width=1920",
+    "Tempered Sword": "https://oyster.ignimgs.com/mediawiki/apis.ign.com/the-legend-of-zelda-a-link-to-the-past/9/92/STemperedSword.png?width=1920",
+    "Golden Sword": "https://oyster.ignimgs.com/mediawiki/apis.ign.com/the-legend-of-zelda-a-link-to-the-past/2/28/SGoldenSword.png?width=1920",
+    "Bow": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/b/bc/ALttP_Bow_%26_Arrows_Sprite.png?version=5f85a70e6366bf473544ef93b274f74c",
+    "Silver Bow": "https://oyster.ignimgs.com/mediawiki/apis.ign.com/the-legend-of-zelda-a-link-to-the-past/6/65/Bow.png?width=1920",
+    "Green Mail": "https://oyster.ignimgs.com/mediawiki/apis.ign.com/the-legend-of-zelda-a-link-to-the-past/c/c9/SGreenTunic.png?width=1920",
+    "Blue Mail": "https://oyster.ignimgs.com/mediawiki/apis.ign.com/the-legend-of-zelda-a-link-to-the-past/9/98/SBlueTunic.png?width=1920",
+    "Red Mail": "https://oyster.ignimgs.com/mediawiki/apis.ign.com/the-legend-of-zelda-a-link-to-the-past/7/74/SRedTunic.png?width=1920",
+    "Power Glove": "https://oyster.ignimgs.com/mediawiki/apis.ign.com/the-legend-of-zelda-a-link-to-the-past/f/f5/SPowerGlove.png?width=1920",
+    "Titan Mitts": "https://oyster.ignimgs.com/mediawiki/apis.ign.com/the-legend-of-zelda-a-link-to-the-past/c/c1/STitanMitt.png?width=1920",
+    "Progressive Sword": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/c/cc/ALttP_Master_Sword_Sprite.png?version=55869db2a20e157cd3b5c8f556097725",
+    "Pegasus Boots": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/e/ed/ALttP_Pegasus_Shoes_Sprite.png?version=405f42f97240c9dcd2b71ffc4bebc7f9",
+    "Progressive Glove": "https://oyster.ignimgs.com/mediawiki/apis.ign.com/the-legend-of-zelda-a-link-to-the-past/c/c1/STitanMitt.png?width=1920",
+    "Flippers": "https://oyster.ignimgs.com/mediawiki/apis.ign.com/the-legend-of-zelda-a-link-to-the-past/4/4c/ZoraFlippers.png?width=1920",
+    "Moon Pearl": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/6/63/ALttP_Moon_Pearl_Sprite.png?version=d601542d5abcc3e006ee163254bea77e",
+    "Progressive Bow": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/b/bc/ALttP_Bow_%26_Arrows_Sprite.png?version=cfb7648b3714cccc80e2b17b2adf00ed",
+    "Blue Boomerang": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/c/c3/ALttP_Boomerang_Sprite.png?version=96127d163759395eb510b81a556d500e",
+    "Red Boomerang": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/b/b9/ALttP_Magical_Boomerang_Sprite.png?version=47cddce7a07bc3e4c2c10727b491f400",
+    "Hookshot": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/2/24/Hookshot.png?version=c90bc8e07a52e8090377bd6ef854c18b",
+    "Mushroom": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/3/35/ALttP_Mushroom_Sprite.png?version=1f1acb30d71bd96b60a3491e54bbfe59",
+    "Magic Powder": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/e/e5/ALttP_Magic_Powder_Sprite.png?version=c24e38effbd4f80496d35830ce8ff4ec",
+    "Fire Rod": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/d/d6/FireRod.png?version=6eabc9f24d25697e2c4cd43ddc8207c0",
+    "Ice Rod": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/d/d7/ALttP_Ice_Rod_Sprite.png?version=1f944148223d91cfc6a615c92286c3bc",
+    "Bombos": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/8/8c/ALttP_Bombos_Medallion_Sprite.png?version=f4d6aba47fb69375e090178f0fc33b26",
+    "Ether": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/3/3c/Ether.png?version=34027651a5565fcc5a83189178ab17b5",
+    "Quake": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/5/56/ALttP_Quake_Medallion_Sprite.png?version=efd64d451b1831bd59f7b7d6b61b5879",
+    "Lamp": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/6/63/ALttP_Lantern_Sprite.png?version=e76eaa1ec509c9a5efb2916698d5a4ce",
+    "Hammer": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/d/d1/ALttP_Hammer_Sprite.png?version=e0adec227193818dcaedf587eba34500",
+    "Shovel": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/c/c4/ALttP_Shovel_Sprite.png?version=e73d1ce0115c2c70eaca15b014bd6f05",
+    "Flute": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/d/db/Flute.png?version=ec4982b31c56da2c0c010905c5c60390",
+    "Bug Catching Net": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/5/54/Bug-CatchingNet.png?version=4d40e0ee015b687ff75b333b968d8be6",
+    "Book of Mudora": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/2/22/ALttP_Book_of_Mudora_Sprite.png?version=11e4632bba54f6b9bf921df06ac93744",
+    "Bottle": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/e/ef/ALttP_Magic_Bottle_Sprite.png?version=fd98ab04db775270cbe79fce0235777b",
+    "Cane of Somaria": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/e/e1/ALttP_Cane_of_Somaria_Sprite.png?version=8cc1900dfd887890badffc903bb87943",
+    "Cane of Byrna": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/b/bc/ALttP_Cane_of_Byrna_Sprite.png?version=758b607c8cbe2cf1900d42a0b3d0fb54",
+    "Cape": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/1/1c/ALttP_Magic_Cape_Sprite.png?version=6b77f0d609aab0c751307fc124736832",
+    "Magic Mirror": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/e/e5/ALttP_Magic_Mirror_Sprite.png?version=e035dbc9cbe2a3bd44aa6d047762b0cc",
+    "Triforce": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/4/4e/TriforceALttPTitle.png?version=dc398e1293177581c16303e4f9d12a48",
+    "Triforce Piece": "https://www.zeldadungeon.net/wiki/images/thumb/5/54/Triforce_Fragment_-_BS_Zelda.png/62px-Triforce_Fragment_-_BS_Zelda.png",
+    "Small Key": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/f/f1/ALttP_Small_Key_Sprite.png?version=4f35d92842f0de39d969181eea03774e",
+    "Big Key": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/3/33/ALttP_Big_Key_Sprite.png?version=136dfa418ba76c8b4e270f466fc12f4d",
+    "Chest": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/7/73/ALttP_Treasure_Chest_Sprite.png?version=5f530ecd98dcb22251e146e8049c0dda",
+    "Light World": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/e/e7/ALttP_Soldier_Green_Sprite.png?version=d650d417934cd707a47e496489c268a6",
+    "Dark World": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/9/94/ALttP_Moblin_Sprite.png?version=ebf50e33f4657c377d1606bcc0886ddc",
+    "Hyrule Castle": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/d/d3/ALttP_Ball_and_Chain_Trooper_Sprite.png?version=1768a87c06d29cc8e7ddd80b9fa516be",
+    "Agahnims Tower": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/1/1e/ALttP_Agahnim_Sprite.png?version=365956e61b0c2191eae4eddbe591dab5",
+    "Desert Palace": "https://www.zeldadungeon.net/wiki/images/2/25/Lanmola-ALTTP-Sprite.png",
+    "Eastern Palace": "https://www.zeldadungeon.net/wiki/images/d/dc/RedArmosKnight.png",
+    "Tower of Hera": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/3/3c/ALttP_Moldorm_Sprite.png?version=c588257bdc2543468e008a6b30f262a7",
+    "Palace of Darkness": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/e/ed/ALttP_Helmasaur_King_Sprite.png?version=ab8a4a1cfd91d4fc43466c56cba30022",
+    "Swamp Palace": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/7/73/ALttP_Arrghus_Sprite.png?version=b098be3122e53f751b74f4a5ef9184b5",
+    "Skull Woods": "https://alttp-wiki.net/images/6/6a/Mothula.png",
+    "Thieves Town": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/8/86/ALttP_Blind_the_Thief_Sprite.png?version=3833021bfcd112be54e7390679047222",
+    "Ice Palace": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/3/33/ALttP_Kholdstare_Sprite.png?version=e5a1b0e8b2298e550d85f90bf97045c0",
+    "Misery Mire": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/8/85/ALttP_Vitreous_Sprite.png?version=92b2e9cb0aa63f831760f08041d8d8d8",
+    "Turtle Rock": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/9/91/ALttP_Trinexx_Sprite.png?version=0cc867d513952aa03edd155597a0c0be",
+    "Ganons Tower": "https://gamepedia.cursecdn.com/zelda_gamepedia_en/b/b9/ALttP_Ganon_Sprite.png?version=956f51f054954dfff53c1a9d4f929c74",
+} -%}
+
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <title>{{ player_name }}&apos;s Tracker</title>
+    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename="styles/lttp-tracker.css") }}"/>
+    <script type="application/ecmascript" src="{{ url_for('static', filename="assets/lttp-tracker.js") }}"></script>
+</head>
+
+<body>
+    {# TODO: Replace this with a proper wrapper for each tracker when developing TrackerAPI. #}
+    <div style="margin-bottom: 0.5rem">
+        <a href="{{ url_for("get_generic_game_tracker", tracker=room.tracker, tracked_team=team, tracked_player=player) }}">Switch To Generic Tracker</a>
+    </div>
+
+    <div id="player-tracker-wrapper" data-tracker="{{ room.tracker|suuid }}">
+        <table id="inventory-table">
+            <tr>
+                <td><img src="{{ icons[bow_icon] }}" class="{{ 'acquired' if bow_acquired }}" /></td>
+                <td><img src="{{ icons["Blue Boomerang"] }}" class="{{ 'acquired' if 'Blue Boomerang' in acquired_items }}" /></td>
+                <td><img src="{{ icons["Red Boomerang"] }}" class="{{ 'acquired' if 'Red Boomerang' in acquired_items }}" /></td>
+                <td><img src="{{ icons["Hookshot"] }}" class="{{ 'acquired' if 'Hookshot' in acquired_items }}" /></td>
+                <td><img src="{{ icons["Magic Powder"] }}" class="powder-fix {{ 'acquired' if 'Magic Powder' in acquired_items }}" /></td>
+            </tr>
+            <tr>
+                <td><img src="{{ icons["Fire Rod"] }}" class="{{ 'acquired' if "Fire Rod" in acquired_items }}" /></td>
+                <td><img src="{{ icons["Ice Rod"] }}" class="{{ 'acquired' if "Ice Rod" in acquired_items }}" /></td>
+                <td><img src="{{ icons["Bombos"] }}" class="{{ 'acquired' if "Bombos" in acquired_items }}" /></td>
+                <td><img src="{{ icons["Ether"] }}" class="{{ 'acquired' if "Ether" in acquired_items }}" /></td>
+                <td><img src="{{ icons["Quake"] }}" class="{{ 'acquired' if "Quake" in acquired_items }}" /></td>
+            </tr>
+            <tr>
+                <td><img src="{{ icons["Lamp"] }}" class="{{ 'acquired' if "Lamp" in acquired_items }}" /></td>
+                <td><img src="{{ icons["Hammer"] }}" class="{{ 'acquired' if "Hammer" in acquired_items }}" /></td>
+                <td><img src="{{ icons["Flute"] }}" class="{{ 'acquired' if "Flute" in acquired_items }}" /></td>
+                <td><img src="{{ icons["Bug Catching Net"] }}" class="{{ 'acquired' if "Bug Catching Net" in acquired_items }}" /></td>
+                <td><img src="{{ icons["Book of Mudora"] }}" class="{{ 'acquired' if "Book of Mudora" in acquired_items }}" /></td>
+            </tr>
+            <tr>
+                <td><img src="{{ icons["Bottle"] }}" class="{{ 'acquired' if "Bottle" in acquired_items }}" /></td>
+                <td><img src="{{ icons["Cane of Somaria"] }}" class="{{ 'acquired' if "Cane of Somaria" in acquired_items }}" /></td>
+                <td><img src="{{ icons["Cane of Byrna"] }}" class="{{ 'acquired' if "Cane of Byrna" in acquired_items }}" /></td>
+                <td><img src="{{ icons["Cape"] }}" class="{{ 'acquired' if "Cape" in acquired_items }}" /></td>
+                <td><img src="{{ icons["Magic Mirror"] }}" class="{{ 'acquired' if "Magic Mirror" in acquired_items }}" /></td>
+            </tr>
+            <tr>
+                <td><img src="{{ icons["Pegasus Boots"] }}" class="{{ 'acquired' if "Pegasus Boots" in acquired_items }}" /></td>
+                <td><img src="{{ icons[glove_icon] }}" class="{{ 'acquired' if glove_acquired }}" /></td>
+                <td><img src="{{ icons["Flippers"] }}" class="{{ 'acquired' if "Flippers" in acquired_items }}" /></td>
+                <td><img src="{{ icons["Moon Pearl"] }}" class="{{ 'acquired' if "Moon Pearl" in acquired_items }}" /></td>
+                <td><img src="{{ icons["Mushroom"] }}" class="{{ 'acquired' if "Mushroom" in acquired_items }}" /></td>
+            </tr>
+            <tr>
+                <td><img src="{{ icons[sword_icon] }}" class="{{ 'acquired' if sword_acquired }}" /></td>
+                <td><img src="{{ icons[shield_icon] }}" class="{{ 'acquired' if shield_acquired }}" /></td>
+                <td><img src="{{ icons[mail_icon] }}" class="acquired" /></td>
+                <td><img src="{{ icons["Shovel"] }}" class="{{ 'acquired' if "Shovel" in acquired_items }}" /></td>
+                <td><img src="{{ icons["Triforce"] }}" class="{{ 'acquired' if "Triforce" in acquired_items }}" /></td>
+            </tr>
+        </table>
+        <table id="location-table">
+            <tr>
+                <th></th>
+                <th class="counter"><img src="{{ icons["Chest"] }}" /></th>
+                {% if key_locations and "Universal" not in key_locations %}
+                    <th class="counter"><img src="{{ icons["Small Key"] }}" /></th>
+                {% endif %}
+                {% if big_key_locations %}
+                    <th><img src="{{ icons["Big Key"] }}" /></th>
+                {% endif %}
+            </tr>
+            {% for area in sp_areas %}
+                <tr>
+                    <td>{{ area }}</td>
+                    <td class="counter">{{ checks_done[area] }} / {{ checks_in_area[area] }}</td>
+                    {% if key_locations and "Universal" not in key_locations %}
+                        <td class="counter">
+                            {{ inventory[small_key_ids[area]] if area in key_locations else '—' }}
+                        </td>
+                    {% endif %}
+                    {% if big_key_locations %}
+                        <td>
+                            {{ '✔' if area in big_key_locations and inventory[big_key_ids[area]] else ('—' if area not in big_key_locations else '') }}
+                        </td>
+                    {% endif %}
+                </tr>
+            {% endfor %}
+        </table>
+    </div>
+</body>
+</html>

WebHostLib/templates/tracker__ChecksFinder.html

@@ -7,6 +7,11 @@
 </head>
 
 <body>
+    {# TODO: Replace this with a proper wrapper for each tracker when developing TrackerAPI. #}
+    <div style="margin-bottom: 0.5rem">
+        <a href="{{ url_for("get_generic_game_tracker", tracker=room.tracker, tracked_team=team, tracked_player=player) }}">Switch To Generic Tracker</a>
+    </div>
+
     <div id="player-tracker-wrapper" data-tracker="{{ room.tracker|suuid }}">
         <table id="inventory-table">
             <tr class="column-headers">

WebHostLib/templates/tracker__Minecraft.html

@@ -8,13 +8,18 @@
 </head>
 
 <body>
+    {# TODO: Replace this with a proper wrapper for each tracker when developing TrackerAPI. #}
+    <div style="margin-bottom: 0.5rem">
+        <a href="{{ url_for("get_generic_game_tracker", tracker=room.tracker, tracked_team=team, tracked_player=player) }}">Switch To Generic Tracker</a>
+    </div>
+
     <div id="player-tracker-wrapper" data-tracker="{{ room.tracker|suuid }}">
         <table id="inventory-table">
             <tr>
                 <td><img src="{{ tools_url }}" class="{{ 'acquired' }}" title="Progressive Tools" /></td>
                 <td><img src="{{ weapons_url }}" class="{{ 'acquired' }}" title="Progressive Weapons" /></td>
                 <td><img src="{{ armor_url }}" class="{{ 'acquired' }}" title="Progressive Armor" /></td>
-                <td><img src="{{ resource_crafting_url }}" class="{{ 'acquired' if 'Progressive Resource Crafting' in acquired_items }}" 
+                <td><img src="{{ resource_crafting_url }}" class="{{ 'acquired' if 'Progressive Resource Crafting' in acquired_items }}"
                     title="Progressive Resource Crafting" /></td>
                 <td><img src="{{ icons['Brewing Stand'] }}" class="{{ 'acquired' if 'Brewing' in acquired_items }}" title="Brewing" /></td>
                 <td>

WebHostLib/templates/tracker__OcarinaOfTime.html

@@ -0,0 +1,185 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <title>{{ player_name }}&apos;s Tracker</title>
+    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename='styles/ootTracker.css') }}"/>
+    <script type="application/ecmascript" src="{{ url_for('static', filename='assets/ootTracker.js') }}"></script>
+</head>
+
+<body>
+    {# TODO: Replace this with a proper wrapper for each tracker when developing TrackerAPI. #}
+    <div style="margin-bottom: 0.5rem">
+        <a href="{{ url_for("get_generic_game_tracker", tracker=room.tracker, tracked_team=team, tracked_player=player) }}">Switch To Generic Tracker</a>
+    </div>
+
+    <div id="player-tracker-wrapper" data-tracker="{{ room.tracker|suuid }}">
+        <table id="inventory-table">
+            <tr>
+                <td><img src="{{ ocarina_url }}" class="{{ 'acquired' if 'Ocarina' in acquired_items }}" title="Ocarina" /></td>
+                <td><img src="{{ icons['Bombs'] }}" class="{{ 'acquired' if 'Bomb Bag' in acquired_items }}" title="Bombs" /></td>
+                <td><img src="{{ icons['Bow'] }}" class="{{ 'acquired' if 'Bow' in acquired_items }}" title="Fairy Bow" /></td>
+                <td><img src="{{ icons['Fire Arrows'] }}" class="{{ 'acquired' if 'Fire Arrows' in acquired_items }}" title="Fire Arrows" /></td>
+                <td><img src="{{ icons['Kokiri Sword'] }}" class="{{ 'acquired' if 'Kokiri Sword' in acquired_items }}" title="Kokiri Sword" /></td>
+                <td><img src="{{ icons['Biggoron Sword'] }}" class="{{ 'acquired' if 'Biggoron Sword' in acquired_items }}" title="Biggoron's Sword" /></td>
+                <td><img src="{{ icons['Mirror Shield'] }}" class="{{ 'acquired' if 'Mirror Shield' in acquired_items }}" title="Mirror Shield" /></td>
+            </tr>
+            <tr>
+                <td><img src="{{ icons['Slingshot'] }}" class="{{ 'acquired' if 'Slingshot' in acquired_items }}" title="Slingshot" /></td>
+                <td><img src="{{ icons['Bombchus'] }}" class="{{ 'acquired' if has_bombchus }}" title="Bombchus" /></td>
+                <td>
+                    <div class="counted-item">
+                        <img src="{{ hookshot_url }}" class="{{ 'acquired' if 'Progressive Hookshot' in acquired_items }}" title="Progressive Hookshot" />
+                        <div class="item-count">{{ hookshot_length }}</div>
+                    </div>
+                </td>
+                <td><img src="{{ icons['Ice Arrows'] }}" class="{{ 'acquired' if 'Ice Arrows' in acquired_items }}" title="Ice Arrows" /></td>
+                <td><img src="{{ strength_upgrade_url }}" class="{{ 'acquired' if 'Progressive Strength Upgrade' in acquired_items }}" title="Progressive Strength Upgrade" /></td>
+                <td><img src="{{ icons['Goron Tunic'] }}" class="{{ 'acquired' if 'Goron Tunic' in acquired_items }}" title="Goron Tunic" /></td>
+                <td><img src="{{ icons['Zora Tunic'] }}" class="{{ 'acquired' if 'Zora Tunic' in acquired_items }}" title="Zora Tunic" /></td>
+            </tr>
+            <tr>
+                <td><img src="{{ icons['Boomerang'] }}" class="{{ 'acquired' if 'Boomerang' in acquired_items }}" title="Boomerang" /></td>
+                <td><img src="{{ icons['Lens of Truth'] }}" class="{{ 'acquired' if 'Lens of Truth' in acquired_items }}" title="Lens of Truth" /></td>
+                <td><img src="{{ icons['Megaton Hammer'] }}" class="{{ 'acquired' if 'Megaton Hammer' in acquired_items }}" title="Megaton Hammer" /></td>
+                <td><img src="{{ icons['Light Arrows'] }}" class="{{ 'acquired' if 'Light Arrows' in acquired_items }}" title="Light Arrows" /></td>
+                <td><img src="{{ scale_url }}" class="{{ 'acquired' if 'Progressive Scale' in acquired_items }}" title="Progressive Scale" /></td>
+                <td><img src="{{ icons['Iron Boots'] }}" class="{{ 'acquired' if 'Iron Boots' in acquired_items }}" title="Iron Boots" /></td>
+                <td><img src="{{ icons['Hover Boots'] }}" class="{{ 'acquired' if 'Hover Boots' in acquired_items }}" title="Hover Boots" /></td>
+            </tr>
+            <tr>
+                <td>
+                    <div class="counted-item">
+                        <img src="{{ bottle_url }}" class="{{ 'acquired' if bottle_count > 0 }}" title="Bottles" />
+                        <div class="item-count">{{ bottle_count if bottle_count > 0 else '' }}</div>
+                    </div>
+                </td>
+                <td><img src="{{ icons['Dins Fire'] }}" class="{{ 'acquired' if 'Dins Fire' in acquired_items }}" title="Din's Fire" /></td>
+                <td><img src="{{ icons['Farores Wind'] }}" class="{{ 'acquired' if 'Farores Wind' in acquired_items }}" title="Farore's Wind" /></td>
+                <td><img src="{{ icons['Nayrus Love'] }}" class="{{ 'acquired' if 'Nayrus Love' in acquired_items }}" title="Nayru's Love" /></td>
+                <td>
+                    <div class="counted-item">
+                        <img src="{{ wallet_url }}" class="{{ 'acquired' if 'Progressive Wallet' in acquired_items }}" title="Progressive Wallet" />
+                        <div class="item-count">{{ wallet_size }}</div>
+                    </div>
+                </td>
+                <td><img src="{{ magic_meter_url }}" class="{{ 'acquired' if 'Magic Meter' in acquired_items }}" title="Magic Meter" /></td>
+                <td><img src="{{ icons['Gerudo Membership Card'] }}" class="{{ 'acquired' if 'Gerudo Membership Card' in acquired_items }}" title="Gerudo Membership Card" /></td>
+            </tr>
+            <tr>
+                <td>
+                    <div class="counted-item">
+                        <img src="{{ icons['Zeldas Lullaby'] }}" class="{{ 'acquired' if 'Zeldas Lullaby' in acquired_items }}" title="Zelda's Lullaby" id="lullaby"/>
+                        <div class="item-count">Zelda</div>
+                    </div>
+                </td>
+                <td>
+                    <div class="counted-item">
+                        <img src="{{ icons['Eponas Song'] }}" class="{{ 'acquired' if 'Eponas Song' in acquired_items }}" title="Epona's Song" id="epona" />
+                        <div class="item-count">Epona</div>
+                    </div>
+                </td>
+                <td>
+                    <div class="counted-item">
+                        <img src="{{ icons['Sarias Song'] }}" class="{{ 'acquired' if 'Sarias Song' in acquired_items }}" title="Saria's Song" id="saria"/>
+                        <div class="item-count">Saria</div>
+                    </div>
+                </td>
+                <td>
+                    <div class="counted-item">
+                        <img src="{{ icons['Suns Song'] }}" class="{{ 'acquired' if 'Suns Song' in acquired_items }}" title="Sun's Song" id="sun"/>
+                        <div class="item-count">Sun</div>
+                    </div>
+                </td>
+                <td>
+                    <div class="counted-item">
+                        <img src="{{ icons['Song of Time'] }}" class="{{ 'acquired' if 'Song of Time' in acquired_items }}" title="Song of Time" id="time"/>
+                        <div class="item-count">Time</div>
+                    </div>
+                </td>
+                <td>
+                    <div class="counted-item">
+                        <img src="{{ icons['Song of Storms'] }}" class="{{ 'acquired' if 'Song of Storms' in acquired_items }}" title="Song of Storms" />
+                        <div class="item-count">Storms</div>
+                    </div>
+                </td>
+                <td>
+                    <div class="counted-item">
+                        <img src="{{ icons['Gold Skulltula Token'] }}" class="{{ 'acquired' if token_count > 0 }}" title="Gold Skulltula Tokens" />
+                        <div class="item-count">{{ token_count }}</div>
+                    </div>
+                </td>
+            </tr>
+            <tr>
+                <td>
+                    <div class="counted-item">
+                        <img src="{{ icons['Minuet of Forest'] }}" class="{{ 'acquired' if 'Minuet of Forest' in acquired_items }}" title="Minuet of Forest" />
+                        <div class="item-count">Min</div>
+                    </div>
+                </td>
+                <td>
+                    <div class="counted-item">
+                        <img src="{{ icons['Bolero of Fire'] }}" class="{{ 'acquired' if 'Bolero of Fire' in acquired_items }}" title="Bolero of Fire" />
+                        <div class="item-count">Bol</div>
+                    </div>
+                </td>
+                <td>
+                    <div class="counted-item">
+                        <img src="{{ icons['Serenade of Water'] }}" class="{{ 'acquired' if 'Serenade of Water' in acquired_items }}" title="Serenade of Water" />
+                        <div class="item-count">Ser</div>
+                    </div>
+                </td>
+                <td>
+                    <div class="counted-item">
+                        <img src="{{ icons['Requiem of Spirit'] }}" class="{{ 'acquired' if 'Requiem of Spirit' in acquired_items }}" title="Requiem of Spirit" />
+                        <div class="item-count">Req</div>
+                    </div>
+                </td>
+                <td>
+                    <div class="counted-item">
+                        <img src="{{ icons['Nocturne of Shadow'] }}" class="{{ 'acquired' if 'Nocturne of Shadow' in acquired_items }}" title="Nocturne of Shadow" />
+                        <div class="item-count">Noc</div>
+                    </div>
+                </td>
+                <td>
+                    <div class="counted-item">
+                        <img src="{{ icons['Prelude of Light'] }}" class="{{ 'acquired' if 'Prelude of Light' in acquired_items }}" title="Prelude of Light" />
+                        <div class="item-count">Pre</div>
+                    </div>
+                </td>
+                <td>
+                    <div class="counted-item">
+                        <img src="{{ icons['Triforce'] if game_finished else icons['Triforce Piece'] }}" class="{{ 'acquired' if game_finished or piece_count > 0 }}" title="{{ 'Triforce' if game_finished else 'Triforce Pieces' }}" id=triforce />
+                        <div class="item-count">{{ piece_count if piece_count > 0 else '' }}</div>
+                    </div>
+                </td>
+            </tr>
+        </table>
+        <table id="location-table">
+            <tr>
+                <td></td>
+                <td><img src="{{ icons['Small Key'] }}" title="Small Keys" /></td>
+                <td><img src="{{ icons['Boss Key'] }}" title="Boss Key" /></td>
+                <td class="right-align">Items</td>
+            </tr>
+            {% for area in checks_done %}
+            <tr class="location-category" id="{{area}}-header">
+                <td>{{ area }} {{'▼' if area != 'Total'}}</td>
+                <td class="smallkeys">{{ small_key_counts.get(area, '-') }}</td>
+                <td class="bosskeys">{{ boss_key_counts.get(area, '-') }}</td>
+                <td class="counter">{{ checks_done[area] }} / {{ checks_in_area[area] }}</td>
+            </tr>
+            <tbody class="locations hide" id="{{area}}">
+                {% for location in location_info[area] %}
+                <tr>
+                    <td class="location-name">{{ location }}</td>
+                    <td></td>
+                    <td></td>
+                    <td class="counter">{{ '✔' if location_info[area][location] else '' }}</td>
+                </tr>
+                {% endfor %}
+            </tbody>
+            {% endfor %}
+        </table>
+    </div>
+</body>
+</html>

WebHostLib/templates/tracker__SuperMetroid.html

@@ -7,6 +7,11 @@
 </head>
 
 <body>
+    {# TODO: Replace this with a proper wrapper for each tracker when developing TrackerAPI. #}
+    <div style="margin-bottom: 0.5rem">
+        <a href="{{ url_for("get_generic_game_tracker", tracker=room.tracker, tracked_team=team, tracked_player=player) }}">Switch To Generic Tracker</a>
+    </div>
+
     <div id="player-tracker-wrapper" data-tracker="{{ room.tracker|suuid }}">
         <table id="inventory-table">
             <tr>

WebHostLib/templates/tracker__Timespinner.html

@@ -7,6 +7,11 @@
 </head>
 
 <body>
+    {# TODO: Replace this with a proper wrapper for each tracker when developing TrackerAPI. #}
+    <div style="margin-bottom: 0.5rem">
+        <a href="{{ url_for("get_generic_game_tracker", tracker=room.tracker, tracked_team=team, tracked_player=player) }}">Switch To Generic Tracker</a>
+    </div>
+
     <div id="player-tracker-wrapper" data-tracker="{{ room.tracker|suuid }}">
         <div id="inventory-table">
             <div class="table-row">
@@ -51,16 +56,16 @@
                 <div class="C4"><img src="{{ icons['Security Keycard D'] }}" class="{{ 'acquired' if 'Security Keycard D' in acquired_items }}" title="Security Keycard D" /></div>
             {% if 'DownloadableItems' in options %}
                 <div class="C5"><img src="{{ icons['Library Keycard V'] }}" class="{{ 'acquired' if 'Library Keycard V' in acquired_items }}" title="Library Keycard V" /></div>
-            {% endif %}   
+            {% endif %}
             </div>
             <div class="table-row">
             {% if 'DownloadableItems' in options %}
                 <div class="C1"><img src="{{ icons['Tablet'] }}" class="{{ 'acquired' if 'Tablet' in acquired_items }}" title="Tablet" /></div>
-            {% endif %}    
+            {% endif %}
                 <div class="C2"><img src="{{ icons['Elevator Keycard'] }}" class="{{ 'acquired' if 'Elevator Keycard' in acquired_items }}" title="Elevator Keycard" /></div>
             {% if 'EyeSpy' in options %}
                 <div class="C3"><img src="{{ icons['Oculus Ring'] }}" class="{{ 'acquired' if 'Oculus Ring' in acquired_items }}" title="Oculus Ring" /></div>
-            {% endif %}   
+            {% endif %}
                 <div class="C4"><img src="{{ icons['Water Mask'] }}" class="{{ 'acquired' if 'Water Mask' in acquired_items }}" title="Water Mask" /></div>
                 <div class="C5"><img src="{{ icons['Gas Mask'] }}" class="{{ 'acquired' if 'Gas Mask' in acquired_items }}" title="Gas Mask" /></div>
             </div>

WebHostLib/templates/viewSeed.html

@@ -34,7 +34,7 @@
                 {% endif %}
                 <tr>
                     <td>Rooms:&nbsp;</td>
-                <td>
+                    <td>
                         {% call macros.list_rooms(seed.rooms | selectattr("owner", "eq", session["_id"])) %}
                             <li>
                                 <a href="{{ url_for("new_room", seed=seed.id) }}">Create New Room</a>