docstring updated to clarify impact on collecting player.

.coveragerc

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

.github/labeler.yml

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

.github/pyright-config.json

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

.github/type_check.py

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

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

@@ -1,80 +0,0 @@
-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,13 +8,11 @@ on:
       - '.github/workflows/build.yml'
       - 'setup.py'
       - 'requirements.txt'
-      - '*.iss'
   pull_request:
     paths:
       - '.github/workflows/build.yml'
       - 'setup.py'
       - 'requirements.txt'
-      - '*.iss'
   workflow_dispatch:
 
 env:
@@ -27,9 +25,9 @@ jobs:
   build-win-py38: # RCs will still be built and signed by hand
     runs-on: windows-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
       - name: Install python
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v4
         with:
           python-version: '3.8'
       - name: Download run-time dependencies
@@ -38,57 +36,40 @@ jobs:
           Expand-Archive -Path enemizer.zip -DestinationPath EnemizerCLI -Force
       - name: Build
         run: |
-          python -m pip install --upgrade pip
+          python -m pip install --upgrade pip setuptools
+          pip install -r requirements.txt
           python setup.py build_exe --yes
-          $NAME="$(ls build | Select-String -Pattern 'exe')".Split('.',2)[1]
+          $NAME="$(ls build)".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@v4
+        uses: actions/upload-artifact@v3
         with:
           name: ${{ env.ZIP_NAME }}
           path: dist/${{ env.ZIP_NAME }}
           retention-days: 7  # keep for 7 days, should be enough
-      - name: Build Setup
-        run: |
-          & "${env:ProgramFiles(x86)}\Inno Setup 6\iscc.exe" inno_setup.iss /DNO_SIGNTOOL
-          if ( $? -eq $false ) {
-            Write-Error "Building setup failed!"
-            exit 1
-          }
-          $contents = Get-ChildItem -Path setups/*.exe -Force -Recurse
-          $SETUP_NAME=$contents[0].Name
-          echo "SETUP_NAME=$SETUP_NAME" >> $Env:GITHUB_ENV
-      - name: Store Setup
-        uses: actions/upload-artifact@v4
-        with:
-          name: ${{ env.SETUP_NAME }}
-          path: setups/${{ env.SETUP_NAME }}
-          retention-days: 7  # keep for 7 days, should be enough
 
-  build-ubuntu2004:
-    runs-on: ubuntu-20.04
+  build-ubuntu1804:
+    runs-on: ubuntu-18.04
     steps:
       # - copy code below to release.yml -
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
       - name: Install base dependencies
         run: |
           sudo apt update
           sudo apt -y install build-essential p7zip xz-utils wget libglib2.0-0
           sudo apt -y install python3-gi libgirepository1.0-dev  # should pull dependencies for gi installation below
       - name: Get a recent python
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v4
         with:
-          python-version: '3.11'
+          python-version: '3.9'
       - name: Install build-time dependencies
         run: |
-          echo "PYTHON=python3.11" >> $GITHUB_ENV
+          echo "PYTHON=python3.9" >> $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
@@ -104,7 +85,8 @@ jobs:
           # charset-normalizer was somehow incomplete in the github runner
           "${{ env.PYTHON }}" -m venv venv
           source venv/bin/activate
-          "${{ env.PYTHON }}" -m pip install --upgrade pip PyGObject charset-normalizer
+          "${{ env.PYTHON }}" -m pip install --upgrade pip PyGObject setuptools charset-normalizer
+          pip install -r requirements.txt
           python setup.py build_exe --yes bdist_appimage --yes
           echo -e "setup.py build output:\n `ls build`"
           echo -e "setup.py dist output:\n `ls dist`"
@@ -114,18 +96,14 @@ jobs:
           echo "APPIMAGE_NAME=$APPIMAGE_NAME" >> $GITHUB_ENV
           echo "TAR_NAME=$TAR_NAME" >> $GITHUB_ENV
       # - copy code above to release.yml -
-      - name: Build Again
-        run: |
-          source venv/bin/activate
-          python setup.py build_exe --yes
       - name: Store AppImage
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
         with:
           name: ${{ env.APPIMAGE_NAME }}
           path: dist/${{ env.APPIMAGE_NAME }}
           retention-days: 7
       - name: Store .tar.gz
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
         with:
           name: ${{ env.TAR_NAME }}
           path: dist/${{ env.TAR_NAME }}

.github/workflows/codeql-analysis.yml

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

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

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

.github/workflows/lint.yml

@@ -0,0 +1,35 @@
+# 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:
+  build:
+
+    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 pytest pytest-subtests
+        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@975c1b265e11dd76618af1c374e7981f9a6ff44a
+        uses: softprops/action-gh-release@b7e450da2a4b4cb4bfbae528f788167786cfcedf
         with:
           draft: true  # don't publish right away, especially since windows build is added by hand
           prerelease: false
@@ -29,25 +29,25 @@ jobs:
   # build-release-windows: # this is done by hand because of signing
   # build-release-macos: # LF volunteer
 
-  build-release-ubuntu2004:
-    runs-on: ubuntu-20.04
+  build-release-ubuntu1804:
+    runs-on: ubuntu-18.04
     steps:
       - name: Set env
         run: echo "RELEASE_VERSION=${GITHUB_REF#refs/*/}" >> $GITHUB_ENV
       # - code below copied from build.yml -
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
       - name: Install base dependencies
         run: |
           sudo apt update
           sudo apt -y install build-essential p7zip xz-utils wget libglib2.0-0
           sudo apt -y install python3-gi libgirepository1.0-dev  # should pull dependencies for gi installation below
       - name: Get a recent python
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v4
         with:
-          python-version: '3.11'
+          python-version: '3.9'
       - name: Install build-time dependencies
         run: |
-          echo "PYTHON=python3.11" >> $GITHUB_ENV
+          echo "PYTHON=python3.9" >> $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
@@ -63,8 +63,9 @@ jobs:
           # charset-normalizer was somehow incomplete in the github runner
           "${{ env.PYTHON }}" -m venv venv
           source venv/bin/activate
-          "${{ env.PYTHON }}" -m pip install --upgrade pip PyGObject charset-normalizer
-          python setup.py build_exe --yes bdist_appimage --yes
+          "${{ env.PYTHON }}" -m pip install --upgrade pip PyGObject setuptools charset-normalizer
+          pip install -r requirements.txt
+          python setup.py build --yes bdist_appimage --yes
           echo -e "setup.py build output:\n `ls build`"
           echo -e "setup.py dist output:\n `ls dist`"
           cd dist && export APPIMAGE_NAME="`ls *.AppImage`" && cd ..
@@ -74,7 +75,7 @@ jobs:
           echo "TAR_NAME=$TAR_NAME" >> $GITHUB_ENV
       # - code above copied from build.yml -
       - name: Add to Release
-        uses: softprops/action-gh-release@975c1b265e11dd76618af1c374e7981f9a6ff44a
+        uses: softprops/action-gh-release@b7e450da2a4b4cb4bfbae528f788167786cfcedf
         with:
           draft: true  # see above
           prerelease: false

.github/workflows/scan-build.yml

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

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

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

.github/workflows/unittests.yml

@@ -36,27 +36,25 @@ 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.11'}  # current
+          - python: {version: '3.10'}  # current
             os: windows-latest
-          - python: {version: '3.11'}  # current
+          - python: {version: '3.10'}  # current
             os: macos-latest
 
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v3
     - name: Set up Python ${{ matrix.python.version }}
-      uses: actions/setup-python@v5
+      uses: actions/setup-python@v4
       with:
         python-version: ${{ matrix.python.version }}
     - name: Install dependencies
       run: |
-        python -m pip install --upgrade pip
-        pip install pytest pytest-subtests pytest-xdist
+        python -m pip install --upgrade pip wheel
+        pip install flake8 pytest pytest-subtests
         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 -n auto
+        pytest

.gitignore

@@ -9,14 +9,12 @@
 *.apmc
 *.apz5
 *.aptloz
-*.apemerald
 *.pyc
 *.pyd
 *.sfc
 *.z64
 *.n64
 *.nes
-*.smc
 *.sms
 *.gb
 *.gbc
@@ -28,22 +26,15 @@
 *multisave
 *.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/
@@ -61,7 +52,6 @@ Output Logs/
 /setup.ini
 /installdelete.iss
 /data/user.kv
-/datapackage
 
 # Byte-compiled / optimized / DLL files
 __pycache__/
@@ -145,7 +135,6 @@ ipython_config.py
 .venv*
 env/
 venv/
-/venv*/
 ENV/
 env.bak/
 venv.bak/
@@ -176,10 +165,6 @@ dmypy.json
 # Cython debug symbols
 cython_debug/
 
-# Cython intermediates
-_speedups.cpp
-_speedups.html
-
 # minecraft server stuff
 jdk*/
 minecraft*/
@@ -189,9 +174,6 @@ minecraft_versions.json
 # pyenv
 .python-version
 
-#undertale stuff
-/Undertale/
-
 # OS General Files
 .DS_Store
 .AppleDouble

.run/Archipelago Unittests.run.xml

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

AdventureClient.py

@@ -1,517 +0,0 @@
-import asyncio
-import hashlib
-import json
-import time
-import os
-import bsdiff4
-import subprocess
-import zipfile
-from asyncio import StreamReader, StreamWriter, CancelledError
-from typing import List
-
-
-import Utils
-from NetUtils import ClientStatus
-from Utils import async_start
-from CommonClient import CommonContext, server_loop, gui_enabled, ClientCommandProcessor, logger, \
-    get_base_parser
-from worlds.adventure import AdventureDeltaPatch
-
-from worlds.adventure.Locations import base_location_id
-from worlds.adventure.Rom import AdventureForeignItemInfo, AdventureAutoCollectLocation, BatNoTouchLocation
-from worlds.adventure.Items import base_adventure_item_id, standard_item_max, item_table
-from worlds.adventure.Offsets import static_item_element_size, connector_port_offset
-
-SYSTEM_MESSAGE_ID = 0
-
-CONNECTION_TIMING_OUT_STATUS = \
-    "Connection timing out. Please restart your emulator, then restart connector_adventure.lua"
-CONNECTION_REFUSED_STATUS = \
-    "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 connector_adventure.lua"
-CONNECTION_TENTATIVE_STATUS = "Initial Connection Made"
-CONNECTION_CONNECTED_STATUS = "Connected"
-CONNECTION_INITIAL_STATUS = "Connection has not been initiated"
-
-SCRIPT_VERSION = 1
-
-
-class AdventureCommandProcessor(ClientCommandProcessor):
-    def __init__(self, ctx: CommonContext):
-        super().__init__(ctx)
-
-    def _cmd_2600(self):
-        """Check 2600 Connection State"""
-        if isinstance(self.ctx, AdventureContext):
-            logger.info(f"2600 Status: {self.ctx.atari_status}")
-
-    def _cmd_aconnect(self):
-        """Discard current atari 2600 connection state"""
-        if isinstance(self.ctx, AdventureContext):
-            self.ctx.atari_sync_task.cancel()
-
-
-class AdventureContext(CommonContext):
-    command_processor = AdventureCommandProcessor
-    game = 'Adventure'
-    lua_connector_port: int = 17242
-
-    def __init__(self, server_address, password):
-        super().__init__(server_address, password)
-        self.freeincarnates_used: int = -1
-        self.freeincarnate_pending: int = 0
-        self.foreign_items: [AdventureForeignItemInfo] = []
-        self.autocollect_items: [AdventureAutoCollectLocation] = []
-        self.atari_streams: (StreamReader, StreamWriter) = None
-        self.atari_sync_task = None
-        self.messages = {}
-        self.locations_array = None
-        self.atari_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 = 0b111
-        self.checked_locations_sent: bool = False
-        self.port_offset = 0
-        self.bat_no_touch_locations: [BatNoTouchLocation] = []
-        self.local_item_locations = {}
-        self.dragon_speed_info = {}
-
-        options = Utils.get_options()
-        self.display_msgs = options["adventure_options"]["display_msgs"]
-
-    async def server_auth(self, password_requested: bool = False):
-        if password_requested and not self.password:
-            await super(AdventureContext, self).server_auth(password_requested)
-        if not self.auth:
-            self.auth = self.player_name
-        if not self.auth:
-            self.awaiting_rom = True
-            logger.info('Awaiting connection to adventure_connector to get Player information')
-            return
-
-        await self.send_connect()
-
-    def _set_message(self, msg: str, msg_id: int):
-        if self.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 Utils.get_options()["adventure_options"].get("death_link", False):
-                self.set_deathlink = True
-            async_start(self.get_freeincarnates_used())
-        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)
-        elif cmd == "Retrieved":
-            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"]
-                if self.freeincarnates_used is None:
-                    self.freeincarnates_used = 0
-                self.freeincarnates_used += self.freeincarnate_pending
-                self.send_pending_freeincarnates()
-
-    def on_deathlink(self, data: dict):
-        self.deathlink_pending = True
-        super().on_deathlink(data)
-
-    def run_gui(self):
-        from kvui import GameManager
-
-        class AdventureManager(GameManager):
-            logging_pairs = [
-                ("Client", "Archipelago")
-            ]
-            base_title = "Archipelago Adventure Client"
-
-        self.ui = AdventureManager(self)
-        self.ui_task = asyncio.create_task(self.ui.async_run(), name="UI")
-
-    async def get_freeincarnates_used(self):
-        if self.server and not self.server.socket.closed:
-            await self.send_msgs([{"cmd": "SetNotify", "keys": [f"adventure_{self.auth}_freeincarnates_used"]}])
-            await self.send_msgs([{"cmd": "Get", "keys": [f"adventure_{self.auth}_freeincarnates_used"]}])
-
-    def send_pending_freeincarnates(self):
-        if self.freeincarnate_pending > 0:
-            async_start(self.send_pending_freeincarnates_impl(self.freeincarnate_pending))
-            self.freeincarnate_pending = 0
-
-    async def send_pending_freeincarnates_impl(self, send_val: int) -> None:
-        await self.send_msgs([{"cmd": "Set", "key": f"adventure_{self.auth}_freeincarnates_used",
-                               "default": 0, "want_reply": False,
-                               "operations": [{"operation": "add", "value": send_val}]}])
-
-    async def used_freeincarnate(self) -> None:
-        if self.server and not self.server.socket.closed:
-            await self.send_msgs([{"cmd": "Set", "key": f"adventure_{self.auth}_freeincarnates_used",
-                                   "default": 0, "want_reply": True,
-                                   "operations": [{"operation": "add", "value": 1}]}])
-        else:
-            self.freeincarnate_pending = self.freeincarnate_pending + 1
-
-
-def convert_item_id(ap_item_id: int):
-    static_item_index = ap_item_id - base_adventure_item_id
-    return static_item_index * static_item_element_size
-
-
-def get_payload(ctx: AdventureContext):
-    current_time = time.time()
-    items = []
-    dragon_speed_update = {}
-    diff_a_locked = ctx.diff_a_mode > 0
-    diff_b_locked = ctx.diff_b_mode > 0
-    freeincarnate_count = 0
-    for item in ctx.items_received:
-        item_id_str = str(item.item)
-        if base_adventure_item_id < item.item <= standard_item_max:
-            items.append(convert_item_id(item.item))
-        elif item_id_str in ctx.dragon_speed_info:
-            if item.item in dragon_speed_update:
-                last_index = len(ctx.dragon_speed_info[item_id_str]) - 1
-                dragon_speed_update[item.item] = ctx.dragon_speed_info[item_id_str][last_index]
-            else:
-                dragon_speed_update[item.item] = ctx.dragon_speed_info[item_id_str][0]
-        elif item.item == item_table["Left Difficulty Switch"].id:
-            diff_a_locked = False
-        elif item.item == item_table["Right Difficulty Switch"].id:
-            diff_b_locked = False
-        elif item.item == item_table["Freeincarnate"].id:
-            freeincarnate_count = freeincarnate_count + 1
-    freeincarnates_available = 0
-
-    if ctx.freeincarnates_used >= 0:
-        freeincarnates_available = freeincarnate_count - (ctx.freeincarnates_used + ctx.freeincarnate_pending)
-    ret = json.dumps(
-        {
-            "items": items,
-            "messages": {f'{key[0]}:{key[1]}': value for key, value in ctx.messages.items()
-                         if key[0] > current_time - 10},
-            "deathlink": ctx.deathlink_pending,
-            "dragon_speeds": dragon_speed_update,
-            "difficulty_a_locked": diff_a_locked,
-            "difficulty_b_locked": diff_b_locked,
-            "freeincarnates_available": freeincarnates_available,
-            "bat_logic": ctx.bat_logic
-        }
-    )
-    ctx.deathlink_pending = False
-    return ret
-
-
-async def parse_locations(data: List, ctx: AdventureContext):
-    locations = data
-
-    # for loc_name, loc_data in location_table.items():
-
-    # 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}])
-
-
-def send_ap_foreign_items(adventure_context):
-    foreign_item_json_list = []
-    autocollect_item_json_list = []
-    bat_no_touch_locations_json_list = []
-    for fi in adventure_context.foreign_items:
-        foreign_item_json_list.append(fi.get_dict())
-    for fi in adventure_context.autocollect_items:
-        autocollect_item_json_list.append(fi.get_dict())
-    for ntl in adventure_context.bat_no_touch_locations:
-        bat_no_touch_locations_json_list.append(ntl.get_dict())
-    payload = json.dumps(
-        {
-            "foreign_items": foreign_item_json_list,
-            "autocollect_items": autocollect_item_json_list,
-            "local_item_locations": adventure_context.local_item_locations,
-            "bat_no_touch_locations": bat_no_touch_locations_json_list
-        }
-    )
-    print("sending foreign items")
-    msg = payload.encode()
-    (reader, writer) = adventure_context.atari_streams
-    writer.write(msg)
-    writer.write(b'\n')
-
-
-def send_checked_locations_if_needed(adventure_context):
-    if not adventure_context.checked_locations_sent and adventure_context.checked_locations is not None:
-        if len(adventure_context.checked_locations) == 0:
-            return
-        checked_short_ids = []
-        for location in adventure_context.checked_locations:
-            checked_short_ids.append(location - base_location_id)
-        print("Sending checked locations")
-        payload = json.dumps(
-            {
-                "checked_locations": checked_short_ids,
-            }
-        )
-        msg = payload.encode()
-        (reader, writer) = adventure_context.atari_streams
-        writer.write(msg)
-        writer.write(b'\n')
-        adventure_context.checked_locations_sent = True
-
-
-async def atari_sync_task(ctx: AdventureContext):
-    logger.info("Starting Atari 2600 connector. Use /2600 for status information")
-    while not ctx.exit_event.is_set():
-        try:
-            error_status = None
-            if ctx.atari_streams:
-                (reader, writer) = ctx.atari_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 1+ fields
-                        # 1. A keepalive response of the Players Name (always)
-                        # 2. romhash field with sha256 hash of the ROM memory region
-                        # 3. locations, messages, and deathLink
-                        # 4. freeincarnate, to indicate a freeincarnate was used
-                        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 AdventureClient are from the same Archipelago installation."
-                            logger.info(msg, extra={'compact_gui': True})
-                            ctx.gui_error('Error', msg)
-                            error_status = CONNECTION_RESET_STATUS
-                        if ctx.seed_name and bytes(ctx.seed_name, encoding='ASCII') != ctx.seed_name_from_data:
-                            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
-                        if 'romhash' in data_decoded:
-                            if ctx.rom_hash.upper() != data_decoded['romhash'].upper():
-                                msg = "The rom hash does not match the client rom hash data"
-                                print("got " + data_decoded['romhash'])
-                                print("expected " + str(ctx.rom_hash))
-                                logger.info(msg, extra={'compact_gui': True})
-                                ctx.gui_error('Error', msg)
-                                error_status = CONNECTION_RESET_STATUS
-                                if ctx.auth is None:
-                                    ctx.auth = ctx.player_name
-                            if ctx.awaiting_rom:
-                                await ctx.server_auth(False)
-                        if 'locations' in data_decoded and ctx.game and ctx.atari_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'] > 0 and 'DeathLink' in ctx.tags:
-                            dragon_name = "a dragon"
-                            if data_decoded['deathLink'] == 1:
-                                dragon_name = "Rhindle"
-                            elif data_decoded['deathLink'] == 2:
-                                dragon_name = "Yorgle"
-                            elif data_decoded['deathLink'] == 3:
-                                dragon_name = "Grundle"
-                            print (ctx.auth + " has been eaten by " + dragon_name )
-                            await ctx.send_death(ctx.auth + " has been eaten by " + dragon_name)
-                            # TODO - also if player reincarnates with a dragon onscreen ' dies to avoid being eaten by '
-                        if 'victory' in data_decoded and not ctx.finished_game:
-                            await ctx.send_msgs([{"cmd": "StatusUpdate", "status": ClientStatus.CLIENT_GOAL}])
-                            ctx.finished_game = True
-                        if 'freeincarnate' in data_decoded:
-                            await ctx.used_freeincarnate()
-                        if ctx.set_deathlink:
-                            await ctx.update_death_link(True)
-                        send_checked_locations_if_needed(ctx)
-                    except asyncio.TimeoutError:
-                        logger.debug("Read Timed Out, Reconnecting")
-                        error_status = CONNECTION_TIMING_OUT_STATUS
-                        writer.close()
-                        ctx.atari_streams = None
-                    except ConnectionResetError as e:
-                        logger.debug("Read failed due to Connection Lost, Reconnecting")
-                        error_status = CONNECTION_RESET_STATUS
-                        writer.close()
-                        ctx.atari_streams = None
-                except TimeoutError:
-                    logger.debug("Connection Timed Out, Reconnecting")
-                    error_status = CONNECTION_TIMING_OUT_STATUS
-                    writer.close()
-                    ctx.atari_streams = None
-                except ConnectionResetError:
-                    logger.debug("Connection Lost, Reconnecting")
-                    error_status = CONNECTION_RESET_STATUS
-                    writer.close()
-                    ctx.atari_streams = None
-                except CancelledError:
-                    logger.debug("Connection Cancelled, Reconnecting")
-                    error_status = CONNECTION_RESET_STATUS
-                    writer.close()
-                    ctx.atari_streams = None
-                    pass
-                except Exception as e:
-                    print("unknown exception " + e)
-                    raise
-                if ctx.atari_status == CONNECTION_TENTATIVE_STATUS:
-                    if not error_status:
-                        logger.info("Successfully Connected to 2600")
-                        ctx.atari_status = CONNECTION_CONNECTED_STATUS
-                        ctx.checked_locations_sent = False
-                        send_ap_foreign_items(ctx)
-                        send_checked_locations_if_needed(ctx)
-                    else:
-                        ctx.atari_status = f"Was tentatively connected but error occurred: {error_status}"
-                elif error_status:
-                    ctx.atari_status = error_status
-                    logger.info("Lost connection to 2600 and attempting to reconnect. Use /2600 for status updates")
-            else:
-                try:
-                    port = ctx.lua_connector_port + ctx.port_offset
-                    logger.debug(f"Attempting to connect to 2600 on port {port}")
-                    print(f"Attempting to connect to 2600 on port {port}")
-                    ctx.atari_streams = await asyncio.wait_for(
-                        asyncio.open_connection("localhost",
-                                                port),
-                        timeout=10)
-                    ctx.atari_status = CONNECTION_TENTATIVE_STATUS
-                except TimeoutError:
-                    logger.debug("Connection Timed Out, Trying Again")
-                    ctx.atari_status = CONNECTION_TIMING_OUT_STATUS
-                    continue
-                except ConnectionRefusedError:
-                    logger.debug("Connection Refused, Trying Again")
-                    ctx.atari_status = CONNECTION_REFUSED_STATUS
-                    continue
-                except CancelledError:
-                    pass
-        except CancelledError:
-            pass
-    print("exiting atari sync task")
-
-
-async def run_game(romfile):
-    auto_start = Utils.get_options()["adventure_options"].get("rom_start", True)
-    rom_args = Utils.get_options()["adventure_options"].get("rom_args")
-    if auto_start is True:
-        import webbrowser
-        webbrowser.open(romfile)
-    elif os.path.isfile(auto_start):
-        open_args = [auto_start, romfile]
-        if rom_args is not None:
-            open_args.insert(1, rom_args)
-        subprocess.Popen(open_args,
-                         stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
-
-
-async def patch_and_run_game(patch_file, ctx):
-    base_name = os.path.splitext(patch_file)[0]
-    comp_path = base_name + '.a26'
-    try:
-        base_rom = AdventureDeltaPatch.get_source_data()
-    except Exception as msg:
-        logger.info(msg, extra={'compact_gui': True})
-        ctx.gui_error('Error', msg)
-
-    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)
-
-    with zipfile.ZipFile(patch_file, 'r') as patch_archive:
-        if not AdventureDeltaPatch.check_version(patch_archive):
-            logger.error("apadvn version doesn't match this client.  Make sure your generator and client are the same")
-            raise Exception("apadvn version doesn't match this client.")
-
-        ctx.foreign_items = AdventureDeltaPatch.read_foreign_items(patch_archive)
-        ctx.autocollect_items = AdventureDeltaPatch.read_autocollect_items(patch_archive)
-        ctx.local_item_locations = AdventureDeltaPatch.read_local_item_locations(patch_archive)
-        ctx.dragon_speed_info = AdventureDeltaPatch.read_dragon_speed_info(patch_archive)
-        ctx.seed_name_from_data, ctx.player_name = AdventureDeltaPatch.read_rom_info(patch_archive)
-        ctx.diff_a_mode, ctx.diff_b_mode = AdventureDeltaPatch.read_difficulty_switch_info(patch_archive)
-        ctx.bat_logic = AdventureDeltaPatch.read_bat_logic(patch_archive)
-        ctx.bat_no_touch_locations = AdventureDeltaPatch.read_bat_no_touch(patch_archive)
-        ctx.rom_deltas = AdventureDeltaPatch.read_rom_deltas(patch_archive)
-        ctx.auth = ctx.player_name
-
-    patched_rom_data = AdventureDeltaPatch.apply_rom_deltas(base_patched_rom_data, ctx.rom_deltas)
-    rom_hash = hashlib.sha256()
-    rom_hash.update(patched_rom_data)
-    ctx.rom_hash = rom_hash.hexdigest()
-    ctx.port_offset = patched_rom_data[connector_port_offset]
-
-    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("AdventureClient")
-
-    async def main():
-        parser = get_base_parser()
-        parser.add_argument('patch_file', default="", type=str, nargs="?",
-                            help='Path to an ADVNTURE.BIN rom file')
-        parser.add_argument('port', default=17242, type=int, nargs="?",
-                            help='port for adventure_connector connection')
-        args = parser.parse_args()
-
-        ctx = AdventureContext(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.atari_sync_task = asyncio.create_task(atari_sync_task(ctx), name="Adventure Sync")
-
-        if args.patch_file:
-            ext = args.patch_file.split(".")[len(args.patch_file.split(".")) - 1].lower()
-            if ext == "apadvn":
-                logger.info("apadvn file supplied, beginning patching process...")
-                async_start(patch_and_run_game(args.patch_file, ctx))
-            else:
-                logger.warning(f"Unknown patch file extension {ext}")
-        if args.port is int:
-            ctx.lua_connector_port = args.port
-
-        await ctx.exit_event.wait()
-        ctx.server_address = None
-
-        await ctx.shutdown()
-
-        if ctx.atari_sync_task:
-            await ctx.atari_sync_task
-            print("finished atari_sync_task (main)")
-
-
-    import colorama
-
-    colorama.init()
-
-    asyncio.run(main())
-    colorama.deinit()

BizHawkClient.py

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

CommonClient.py

@@ -1,6 +1,4 @@
 from __future__ import annotations
-
-import copy
 import logging
 import asyncio
 import urllib.parse
@@ -20,12 +18,11 @@ if __name__ == "__main__":
     Utils.init_logging("TextClient", exception_logger="Client")
 
 from MultiServer import CommandProcessor
-from NetUtils import (Endpoint, decode, NetworkItem, encode, JSONtoTextParser, ClientStatus, Permission, NetworkSlot,
-                      RawJSONtoTextParser, add_json_text, add_json_location, add_json_item, JSONTypes)
+from NetUtils import Endpoint, decode, NetworkItem, encode, JSONtoTextParser, \
+    ClientStatus, Permission, NetworkSlot, RawJSONtoTextParser
 from Utils import Version, stream_input, async_start
 from worlds import network_data_package, AutoWorldRegister
 import os
-import ssl
 
 if typing.TYPE_CHECKING:
     import kvui
@@ -36,12 +33,6 @@ 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
@@ -72,29 +63,19 @@ class ClientCommandProcessor(CommandProcessor):
 
     def _cmd_received(self) -> bool:
         """List all received items"""
-        item: NetworkItem
-        self.output(f'{len(self.ctx.items_received)} received items, sorted by time:')
+        self.output(f'{len(self.ctx.items_received)} received items:')
         for index, item in enumerate(self.ctx.items_received, 1):
-            parts = []
-            add_json_item(parts, item.item, self.ctx.slot, item.flags)
-            add_json_text(parts, " from ")
-            add_json_location(parts, item.location, item.player)
-            add_json_text(parts, " by ")
-            add_json_text(parts, item.player, type=JSONTypes.player_id)
-            self.ctx.on_print_json({"data": parts, "cmd": "PrintJSON"})
+            self.output(f"{self.ctx.item_names[item.item]} from {self.ctx.player_names[item.player]}")
         return True
 
-    def _cmd_missing(self, filter_text = "") -> bool:
-        """List all missing location checks, from your local game state.
-        Can be given text, which will be used as filter."""
+    def _cmd_missing(self) -> bool:
+        """List all missing location checks, from your local game state"""
         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:
@@ -122,15 +103,6 @@ class ClientCommandProcessor(CommandProcessor):
         for item_name in AutoWorldRegister.world_types[self.ctx.game].item_name_to_id:
             self.output(item_name)
 
-    def _cmd_item_groups(self):
-        """List all item group names for the currently running game."""
-        if not self.ctx.game:
-            self.output("No game set, cannot determine existing item groups.")
-            return False
-        self.output(f"Item Group Names for {self.ctx.game}")
-        for group_name in AutoWorldRegister.world_types[self.ctx.game].item_name_groups:
-            self.output(group_name)
-
     def _cmd_locations(self):
         """List all location names for the currently running game."""
         if not self.ctx.game:
@@ -140,15 +112,6 @@ class ClientCommandProcessor(CommandProcessor):
         for location_name in AutoWorldRegister.world_types[self.ctx.game].location_name_to_id:
             self.output(location_name)
 
-    def _cmd_location_groups(self):
-        """List all location group names for the currently running game."""
-        if not self.ctx.game:
-            self.output("No game set, cannot determine existing location groups.")
-            return False
-        self.output(f"Location Group Names for {self.ctx.game}")
-        for group_name in AutoWorldRegister.world_types[self.ctx.game].location_name_groups:
-            self.output(group_name)
-
     def _cmd_ready(self):
         """Send ready status to server."""
         self.ctx.ready = not self.ctx.ready
@@ -173,7 +136,7 @@ class CommonContext:
     items_handling: typing.Optional[int] = None
     want_slot_data: bool = True  # should slot_data be retrieved via Connect
 
-    # data package
+    # datapackage
     # Contents in flux until connection to server is made, to download correct data for this multiworld.
     item_names: typing.Dict[int, str] = Utils.KeyedDefaultDict(lambda code: f'Unknown item (ID:{code})')
     location_names: typing.Dict[int, str] = Utils.KeyedDefaultDict(lambda code: f'Unknown location (ID:{code})')
@@ -191,9 +154,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
-    max_size: int = 16*1024*1024  # 16 MB of max incoming packet size
 
     last_death_link: float = time.time()  # last send/received death link on AP layer
 
@@ -202,7 +163,6 @@ 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
@@ -219,10 +179,6 @@ 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
@@ -258,9 +214,6 @@ 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
 
@@ -270,8 +223,7 @@ class CommonContext:
         self.watcher_event = asyncio.Event()
 
         self.jsontotextparser = JSONtoTextParser(self)
-        self.rawjsontotextparser = RawJSONtoTextParser(self)
-        self.update_data_package(network_data_package)
+        self.update_datapackage(network_data_package)
 
         # execution
         self.keep_alive_task = asyncio.create_task(keep_alive(self), name="Bouncy")
@@ -304,7 +256,6 @@ 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
@@ -406,13 +357,10 @@ class CommonContext:
 
     def on_print_json(self, args: dict):
         if self.ui:
-            # 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})
+            self.ui.print_json(args["data"])
+        else:
+            text = self.jsontotextparser(args["data"])
+            logger.info(text)
 
     def on_package(self, cmd: str, args: dict):
         """For custom package handling in subclasses."""
@@ -451,42 +399,34 @@ class CommonContext:
             self.input_task.cancel()
 
     # DataPackage
-    async def prepare_data_package(self, relevant_games: typing.Set[str],
-                                   remote_date_package_versions: typing.Dict[str, int],
-                                   remote_data_package_checksums: typing.Dict[str, str]):
+    async def prepare_datapackage(self, relevant_games: typing.Set[str],
+                                  remote_datepackage_versions: typing.Dict[str, int]):
         """Validate that all data is present for the current multiworld.
         Download, assimilate and cache missing data from the server."""
         # by documentation any game can use Archipelago locations/items -> always relevant
         relevant_games.add("Archipelago")
 
+        cache_package = Utils.persistent_load().get("datapackage", {}).get("games", {})
         needed_updates: typing.Set[str] = set()
         for game in relevant_games:
-            if game not in remote_date_package_versions and game not in remote_data_package_checksums:
+            if game not in remote_datepackage_versions:
                 continue
+            remote_version: int = remote_datepackage_versions[game]
 
-            remote_version: int = remote_date_package_versions.get(game, 0)
-            remote_checksum: typing.Optional[str] = remote_data_package_checksums.get(game)
-
-            if remote_version == 0 and not remote_checksum:  # custom data package and no checksum for this game
+            if remote_version == 0:  # custom datapackage for this game
                 needed_updates.add(game)
                 continue
-
             local_version: int = network_data_package["games"].get(game, {}).get("version", 0)
-            local_checksum: typing.Optional[str] = network_data_package["games"].get(game, {}).get("checksum")
             # no action required if local version is new enough
-            if (not remote_checksum and (remote_version > local_version or remote_version == 0)) \
-                    or remote_checksum != local_checksum:
-                cached_game = Utils.load_data_package_for_checksum(game, remote_checksum)
-                cache_version: int = cached_game.get("version", 0)
-                cache_checksum: typing.Optional[str] = cached_game.get("checksum")
+            if remote_version > local_version:
+                cache_version: int = cache_package.get(game, {}).get("version", 0)
                 # download remote version if cache is not new enough
-                if (not remote_checksum and (remote_version > cache_version or remote_version == 0)) \
-                        or remote_checksum != cache_checksum:
+                if remote_version > cache_version:
                     needed_updates.add(game)
                 else:
-                    self.update_game(cached_game)
+                    self.update_game(cache_package[game])
         if needed_updates:
-            await self.send_msgs([{"cmd": "GetDataPackage", "games": [game_name]} for game_name in needed_updates])
+            await self.send_msgs([{"cmd": "GetDataPackage", "games": list(needed_updates)}])
 
     def update_game(self, game_package: dict):
         for item_name, item_id in game_package["item_name_to_id"].items():
@@ -494,33 +434,15 @@ class CommonContext:
         for location_name, location_id in game_package["location_name_to_id"].items():
             self.location_names[location_id] = location_name
 
-    def update_data_package(self, data_package: dict):
-        for game, game_data in data_package["games"].items():
-            self.update_game(game_data)
+    def update_datapackage(self, data_package: dict):
+        for game, gamedata in data_package["games"].items():
+            self.update_game(gamedata)
 
-    def consume_network_data_package(self, data_package: dict):
-        self.update_data_package(data_package)
+    def consume_network_datapackage(self, data_package: dict):
+        self.update_datapackage(data_package)
         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
 
@@ -644,16 +566,14 @@ async def server_loop(ctx: CommonContext, address: typing.Optional[str] = None)
         ctx.username = server_url.username
     if server_url.password:
         ctx.password = server_url.password
+    port = server_url.port or 38281
 
     def reconnect_hint() -> str:
         return ", type /connect to reconnect" if ctx.server_address else ""
 
     logger.info(f'Connecting to Archipelago server at {address}')
     try:
-        port = server_url.port or 38281  # raises ValueError if invalid
-        socket = await websockets.connect(address, port=port, ping_timeout=None, ping_interval=None,
-                                          ssl=get_ssl_context() if address.startswith("wss://") else None,
-                                          max_size=ctx.max_size)
+        socket = await websockets.connect(address, port=port, ping_timeout=None, ping_interval=None)
         if ctx.ui is not None:
             ctx.ui.update_address_bar(server_url.netloc)
         ctx.server = Endpoint(socket)
@@ -668,7 +588,6 @@ 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"
@@ -713,16 +632,11 @@ async def process_server_cmd(ctx: CommonContext, args: dict):
             logger.info('Room Information:')
             logger.info('--------------------------------')
             version = args["version"]
-            ctx.server_version = Version(*version)
+            ctx.server_version = tuple(version)
+            version = ".".join(str(item) for item in version)
 
-            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"])}')
+            logger.info(f'Server protocol version: {version}')
+            logger.info("Server protocol tags: " + ", ".join(args["tags"]))
             if args['password']:
                 logger.info('Password required')
             ctx.update_permissions(args.get("permissions", {}))
@@ -747,27 +661,23 @@ async def process_server_cmd(ctx: CommonContext, args: dict):
                             current_team = network_player.team
                         logger.info('    %s (Player %d)' % (network_player.alias, network_player.slot))
 
-            # update data package
-            data_package_versions = args.get("datapackage_versions", {})
-            data_package_checksums = args.get("datapackage_checksums", {})
-            await ctx.prepare_data_package(set(args["games"]), data_package_versions, data_package_checksums)
+            # update datapackage
+            await ctx.prepare_datapackage(set(args["games"]), args["datapackage_versions"])
 
             await ctx.server_auth(args['password'])
 
     elif cmd == 'DataPackage':
-        ctx.consume_network_data_package(args['data'])
+        logger.info("Got new ID/Name DataPackage")
+        ctx.consume_network_datapackage(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. '
-                            'This probably means you have to update.')
+            raise Exception('Server reported your client version as incompatible')
         elif 'InvalidItemsHandling' in errors:
             raise Exception('The item handling flags requested by the client are not supported')
         # last to check, recoverable problem
@@ -786,9 +696,7 @@ 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",
@@ -796,11 +704,6 @@ 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:
@@ -864,17 +767,8 @@ 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":
-        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"):
+        if args["key"] == "EnergyLink":
             ctx.current_energy_link_value = args["value"]
             if ctx.ui:
                 ctx.ui.set_new_energy_link_value()
@@ -914,10 +808,11 @@ def get_base_parser(description: typing.Optional[str] = None):
     return parser
 
 
-def run_as_textclient():
+if __name__ == '__main__':
+    # Text Mode to use !hint and such with games that have no text entry
+
     class TextContext(CommonContext):
-        # Text Mode to use !hint and such with games that have no text entry
-        tags = CommonContext.tags | {"TextOnly"}
+        tags = {"AP", "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
@@ -931,11 +826,12 @@ def run_as_textclient():
         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
@@ -948,6 +844,7 @@ def run_as_textclient():
         await ctx.exit_event.wait()
         await ctx.shutdown()
 
+
     import colorama
 
     parser = get_base_parser(description="Gameless Archipelago Client, for text interfacing.")
@@ -967,8 +864,3 @@ def run_as_textclient():
 
     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 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_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_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 EmuHawk"""
+        """Toggle displaying messages in bizhawk"""
         global DISPLAY_MSGS
         DISPLAY_MSGS = not DISPLAY_MSGS
         logger.info(f"Messages are now {'enabled' if DISPLAY_MSGS  else 'disabled'}")

FactorioClient.py

@@ -1,12 +1,553 @@
 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()
 
-from worlds.factorio.Client import check_stdin, launch
+import factorio_rcon
+import colorama
+import asyncio
+from queue import Queue
 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()
-    launch()
+
+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()

Fill.py

@@ -1,11 +1,10 @@
-import collections
-import itertools
 import logging
 import typing
+import collections
+import itertools
 from collections import Counter, deque
 
-from BaseClasses import CollectionState, Item, Location, LocationProgressType, MultiWorld
-from Options import Accessibility
+from BaseClasses import CollectionState, Location, LocationProgressType, MultiWorld, Item, ItemClassification
 
 from worlds.AutoWorld import call_all
 from worlds.generic.Rules import add_item_rule
@@ -15,10 +14,6 @@ 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:
@@ -27,48 +22,28 @@ def sweep_from_pool(base_state: CollectionState, itempool: typing.Sequence[Item]
     return new_state
 
 
-def fill_restrictive(multiworld: MultiWorld, base_state: CollectionState, locations: typing.List[Location],
-                     item_pool: typing.List[Item], single_player_placement: bool = False, lock: bool = False,
+def fill_restrictive(world: MultiWorld, base_state: CollectionState, locations: typing.List[Location],
+                     itempool: typing.List[Item], single_player_placement: bool = False, lock: bool = False,
                      swap: bool = True, on_place: typing.Optional[typing.Callable[[Location], None]] = None,
-                     allow_partial: bool = False, allow_excluded: bool = False, name: str = "Unknown") -> None:
-    """
-    :param multiworld: Multiworld to be filled.
-    :param base_state: State assumed before fill.
-    :param locations: Locations to be filled with item_pool
-    :param item_pool: Items to fill into the locations
-    :param single_player_placement: if true, can speed up placement if everything belongs to a single player
-    :param lock: locations are set to locked as they are filled
-    :param swap: if true, swaps of already place items are done in the event of a dead end
-    :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
-    """
+                     allow_partial: bool = False) -> None:
     unplaced_items: typing.List[Item] = []
     placements: typing.List[Location] = []
-    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
+    swapped_items: typing.Counter[typing.Tuple[int, str]] = Counter()
+    reachable_items: typing.Dict[int, typing.Deque[Item]] = {}
+    for item in itempool:
+        reachable_items.setdefault(item.player, deque()).append(item)
 
     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:
-            for p, pool_item in enumerate(item_pool):
-                if pool_item is item:
-                    item_pool.pop(p)
-                    break
+            itempool.remove(item)
         maximum_exploration_state = sweep_from_pool(
-            base_state, item_pool + unplaced_items)
+            base_state, itempool + unplaced_items)
 
-        has_beaten_game = multiworld.has_beaten_game(maximum_exploration_state)
+        has_beaten_game = world.has_beaten_game(maximum_exploration_state)
 
         while items_to_place:
             # if we have run out of locations to fill,break out of this loop
@@ -80,8 +55,8 @@ def fill_restrictive(multiworld: MultiWorld, base_state: CollectionState, locati
             spot_to_fill: typing.Optional[Location] = None
 
             # if minimal accessibility, only check whether location is reachable if game not beatable
-            if multiworld.worlds[item_to_place.player].options.accessibility == Accessibility.option_minimal:
-                perform_access_check = not multiworld.has_beaten_game(maximum_exploration_state,
+            if world.accessibility[item_to_place.player] == 'minimal':
+                perform_access_check = not world.has_beaten_game(maximum_exploration_state,
                                                                  item_to_place.player) \
                     if single_player_placement else not has_beaten_game
             else:
@@ -98,35 +73,32 @@ def fill_restrictive(multiworld: MultiWorld, base_state: CollectionState, locati
             else:
                 # we filled all reachable spots.
                 if swap:
-                    # 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:
+                    # try swapping this item with previously placed items
+                    for (i, location) in enumerate(placements):
                         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, unsafe]
+                        swap_count = swapped_items[placed_item.player,
+                                                   placed_item.name]
                         if swap_count > 1:
                             continue
 
                         location.item = None
                         placed_item.location = None
-                        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.
+                        swap_state = sweep_from_pool(base_state, [placed_item])
+                        # swap_state assumes we can collect placed item before item_to_place
                         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 placing this item won't reduce available locations, which would be a useless swap.
+                            # 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.
                             prev_state = swap_state.copy()
                             prev_loc_count = len(
-                                multiworld.get_reachable_locations(prev_state))
+                                world.get_reachable_locations(prev_state))
 
                             swap_state.collect(item_to_place, True)
                             new_loc_count = len(
-                                multiworld.get_reachable_locations(swap_state))
+                                world.get_reachable_locations(swap_state))
 
                             if new_loc_count >= prev_loc_count:
                                 # Add this item to the existing placement, and
@@ -134,14 +106,12 @@ def fill_restrictive(multiworld: MultiWorld, base_state: CollectionState, locati
                                 spot_to_fill = placements.pop(i)
 
                                 swap_count += 1
-                                swapped_items[placed_item.player, placed_item.name, unsafe] = swap_count
+                                swapped_items[placed_item.player,
+                                              placed_item.name] = 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
+                                itempool.append(placed_item)
 
                                 break
 
@@ -156,70 +126,31 @@ def fill_restrictive(multiworld: MultiWorld, base_state: CollectionState, locati
                 else:
                     unplaced_items.append(item_to_place)
                     continue
-            multiworld.push_item(spot_to_fill, item_to_place, False)
+            world.push_item(spot_to_fill, item_to_place, False)
             spot_to_fill.locked = lock
             placements.append(spot_to_fill)
-            placed += 1
-            if not placed % 1000:
-                _log_fill_progress(name, placed, total)
+            spot_to_fill.event = item_to_place.advancement
             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 = [
-            location for location in locations
-            if location.progress_type == location.progress_type.EXCLUDED and not location.item
-        ]
-        if excluded_locations:
-            for location in excluded_locations:
-                location.progress_type = location.progress_type.DEFAULT
-            fill_restrictive(multiworld, base_state, excluded_locations, unplaced_items, single_player_placement, lock,
-                             swap, on_place, allow_partial, False)
-            for location in excluded_locations:
-                if not location.item:
-                    location.progress_type = location.progress_type.EXCLUDED
-
     if not allow_partial and len(unplaced_items) > 0 and len(locations) > 0:
         # There are leftover unplaceable items and locations that won't accept them
-        if multiworld.can_beat_game():
+        if world.can_beat_game():
             logging.warning(
-                f"Not all items placed. Game beatable anyway.\nCould not place:\n"
-                f"{', '.join(str(item) for item in unplaced_items)}")
+                f'Not all items placed. Game beatable anyway. (Could not place {unplaced_items})')
         else:
-            raise FillError(f"No more spots to place {len(unplaced_items)} items. Remaining locations are invalid.\n"
-                            f"Unplaced items:\n"
-                            f"{', '.join(str(item) for item in unplaced_items)}\n"
-                            f"Unfilled locations:\n"
-                            f"{', '.join(str(location) for location in locations)}\n"
-                            f"Already placed {len(placements)}:\n"
-                            f"{', '.join(str(place) for place in placements)}")
+            raise FillError(f'No more spots to place {unplaced_items}, locations {locations} are invalid. '
+                            f'Already placed {len(placements)}: {", ".join(str(place) for place in placements)}')
 
-    item_pool.extend(unplaced_items)
+    itempool.extend(unplaced_items)
 
 
-def remaining_fill(multiworld: MultiWorld,
+def remaining_fill(world: MultiWorld,
                    locations: typing.List[Location],
-                   itempool: typing.List[Item],
-                   name: str = "Remaining") -> None:
+                   itempool: typing.List[Item]) -> None:
     unplaced_items: typing.List[Item] = []
     placements: typing.List[Location] = []
     swapped_items: typing.Counter[typing.Tuple[int, str]] = Counter()
-    total = min(len(itempool),  len(locations))
-    placed = 0
     while locations and itempool:
         item_to_place = itempool.pop()
         spot_to_fill: typing.Optional[Location] = None
@@ -267,41 +198,30 @@ def remaining_fill(multiworld: MultiWorld,
                 unplaced_items.append(item_to_place)
                 continue
 
-        multiworld.push_item(spot_to_fill, item_to_place, False)
+        world.push_item(spot_to_fill, item_to_place, False)
         placements.append(spot_to_fill)
-        placed += 1
-        if not placed % 1000:
-            _log_fill_progress(name, placed, total)
-
-    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 {len(unplaced_items)} items. Remaining locations are invalid.\n"
-                        f"Unplaced items:\n"
-                        f"{', '.join(str(item) for item in unplaced_items)}\n"
-                        f"Unfilled locations:\n"
-                        f"{', '.join(str(location) for location in locations)}\n"
-                        f"Already placed {len(placements)}:\n"
-                        f"{', '.join(str(place) for place in placements)}")
+        raise FillError(f'No more spots to place {unplaced_items}, locations {locations} are invalid. '
+                        f'Already placed {len(placements)}: {", ".join(str(place) for place in placements)}')
 
     itempool.extend(unplaced_items)
 
 
-def fast_fill(multiworld: MultiWorld,
+def fast_fill(world: MultiWorld,
               item_pool: typing.List[Item],
               fill_locations: typing.List[Location]) -> typing.Tuple[typing.List[Item], typing.List[Location]]:
     placing = min(len(item_pool), len(fill_locations))
     for item, location in zip(item_pool, fill_locations):
-        multiworld.push_item(location, item, False)
+        world.push_item(location, item, False)
     return item_pool[placing:], fill_locations[placing:]
 
 
-def accessibility_corrections(multiworld: MultiWorld, state: CollectionState, locations, pool=[]):
+def accessibility_corrections(world: MultiWorld, state: CollectionState, locations, pool=[]):
     maximum_exploration_state = sweep_from_pool(state, pool)
-    minimal_players = {player for player in multiworld.player_ids if multiworld.worlds[player].options.accessibility == "minimal"}
-    unreachable_locations = [location for location in multiworld.get_locations() if location.player in minimal_players and
+    minimal_players = {player for player in world.player_ids if world.accessibility[player] == "minimal"}
+    unreachable_locations = [location for location in world.get_locations() if location.player in minimal_players and
                              not location.can_reach(maximum_exploration_state)]
     for location in unreachable_locations:
         if (location.item is not None and location.item.advancement and location.address is not None and not
@@ -309,41 +229,42 @@ def accessibility_corrections(multiworld: MultiWorld, state: CollectionState, lo
             pool.append(location.item)
             state.remove(location.item)
             location.item = None
+            location.event = False
             if location in state.events:
                 state.events.remove(location)
             locations.append(location)
     if pool and locations:
         locations.sort(key=lambda loc: loc.progress_type != LocationProgressType.PRIORITY)
-        fill_restrictive(multiworld, state, locations, pool, name="Accessibility Corrections")
+        fill_restrictive(world, state, locations, pool)
 
 
-def inaccessible_location_rules(multiworld: MultiWorld, state: CollectionState, locations):
+def inaccessible_location_rules(world: MultiWorld, state: CollectionState, locations):
     maximum_exploration_state = sweep_from_pool(state)
     unreachable_locations = [location for location in locations if not location.can_reach(maximum_exploration_state)]
     if unreachable_locations:
         def forbid_important_item_rule(item: Item):
-            return not ((item.classification & 0b0011) and multiworld.worlds[item.player].options.accessibility != 'minimal')
+            return not ((item.classification & 0b0011) and world.accessibility[item.player] != 'minimal')
 
         for location in unreachable_locations:
             add_item_rule(location, forbid_important_item_rule)
 
 
-def distribute_early_items(multiworld: MultiWorld,
+def distribute_early_items(world: MultiWorld,
                            fill_locations: typing.List[Location],
                            itempool: typing.List[Item]) -> typing.Tuple[typing.List[Location], typing.List[Item]]:
     """ returns new fill_locations and itempool """
     early_items_count: typing.Dict[typing.Tuple[str, int], typing.List[int]] = {}
-    for player in multiworld.player_ids:
-        items = itertools.chain(multiworld.early_items[player], multiworld.local_early_items[player])
+    for player in world.player_ids:
+        items = itertools.chain(world.early_items[player], world.local_early_items[player])
         for item in items:
-            early_items_count[item, player] = [multiworld.early_items[player].get(item, 0),
-                                               multiworld.local_early_items[player].get(item, 0)]
+            early_items_count[item, player] = [world.early_items[player].get(item, 0),
+                                               world.local_early_items[player].get(item, 0)]
     if early_items_count:
         early_locations: typing.List[Location] = []
         early_priority_locations: typing.List[Location] = []
         loc_indexes_to_remove: typing.Set[int] = set()
-        base_state = multiworld.state.copy()
-        base_state.sweep_for_events(locations=(loc for loc in multiworld.get_filled_locations() if loc.address is None))
+        base_state = world.state.copy()
+        base_state.sweep_for_events(locations=(loc for loc in world.get_filled_locations() if loc.address is None))
         for i, loc in enumerate(fill_locations):
             if loc.can_reach(base_state):
                 if loc.progress_type == LocationProgressType.PRIORITY:
@@ -355,8 +276,8 @@ def distribute_early_items(multiworld: MultiWorld,
 
         early_prog_items: typing.List[Item] = []
         early_rest_items: typing.List[Item] = []
-        early_local_prog_items: typing.Dict[int, typing.List[Item]] = {player: [] for player in multiworld.player_ids}
-        early_local_rest_items: typing.Dict[int, typing.List[Item]] = {player: [] for player in multiworld.player_ids}
+        early_local_prog_items: typing.Dict[int, typing.List[Item]] = {player: [] for player in world.player_ids}
+        early_local_rest_items: typing.Dict[int, typing.List[Item]] = {player: [] for player in world.player_ids}
         item_indexes_to_remove: typing.Set[int] = set()
         for i, item in enumerate(itempool):
             if (item.name, item.player) in early_items_count:
@@ -380,29 +301,27 @@ def distribute_early_items(multiworld: MultiWorld,
                     if len(early_items_count) == 0:
                         break
         itempool = [item for i, item in enumerate(itempool) if i not in item_indexes_to_remove]
-        for player in multiworld.player_ids:
+        for player in world.player_ids:
             player_local = early_local_rest_items[player]
-            fill_restrictive(multiworld, base_state,
+            fill_restrictive(world, base_state,
                              [loc for loc in early_locations if loc.player == player],
-                             player_local, lock=True, allow_partial=True, name=f"Local Early Items P{player}")
+                             player_local, lock=True, allow_partial=True)
             if player_local:
                 logging.warning(f"Could not fulfill rules of early items: {player_local}")
                 early_rest_items.extend(early_local_rest_items[player])
         early_locations = [loc for loc in early_locations if not loc.item]
-        fill_restrictive(multiworld, base_state, early_locations, early_rest_items, lock=True, allow_partial=True,
-                         name="Early Items")
+        fill_restrictive(world, base_state, early_locations, early_rest_items, lock=True, allow_partial=True)
         early_locations += early_priority_locations
-        for player in multiworld.player_ids:
+        for player in world.player_ids:
             player_local = early_local_prog_items[player]
-            fill_restrictive(multiworld, base_state,
+            fill_restrictive(world, base_state,
                              [loc for loc in early_locations if loc.player == player],
-                             player_local, lock=True, allow_partial=True, name=f"Local Early Progression P{player}")
+                             player_local, lock=True, allow_partial=True)
             if player_local:
                 logging.warning(f"Could not fulfill rules of early items: {player_local}")
                 early_prog_items.extend(player_local)
         early_locations = [loc for loc in early_locations if not loc.item]
-        fill_restrictive(multiworld, base_state, early_locations, early_prog_items, lock=True, allow_partial=True,
-                         name="Early Progression")
+        fill_restrictive(world, base_state, early_locations, early_prog_items, lock=True, allow_partial=True)
         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 "
@@ -410,18 +329,18 @@ def distribute_early_items(multiworld: MultiWorld,
             itempool += unplaced_early_items
 
         fill_locations.extend(early_locations)
-        multiworld.random.shuffle(fill_locations)
+        world.random.shuffle(fill_locations)
     return fill_locations, itempool
 
 
-def distribute_items_restrictive(multiworld: MultiWorld) -> None:
-    fill_locations = sorted(multiworld.get_unfilled_locations())
-    multiworld.random.shuffle(fill_locations)
+def distribute_items_restrictive(world: MultiWorld) -> None:
+    fill_locations = sorted(world.get_unfilled_locations())
+    world.random.shuffle(fill_locations)
     # get items to distribute
-    itempool = sorted(multiworld.itempool)
-    multiworld.random.shuffle(itempool)
+    itempool = sorted(world.itempool)
+    world.random.shuffle(itempool)
 
-    fill_locations, itempool = distribute_early_items(multiworld, fill_locations, itempool)
+    fill_locations, itempool = distribute_early_items(world, fill_locations, itempool)
 
     progitempool: typing.List[Item] = []
     usefulitempool: typing.List[Item] = []
@@ -435,7 +354,7 @@ def distribute_items_restrictive(multiworld: MultiWorld) -> None:
         else:
             filleritempool.append(item)
 
-    call_all(multiworld, "fill_hook", progitempool, usefulitempool, filleritempool, fill_locations)
+    call_all(world, "fill_hook", progitempool, usefulitempool, filleritempool, fill_locations)
 
     locations: typing.Dict[LocationProgressType, typing.List[Location]] = {
         loc_type: [] for loc_type in LocationProgressType}
@@ -456,79 +375,74 @@ def distribute_items_restrictive(multiworld: MultiWorld) -> None:
 
     if prioritylocations:
         # "priority fill"
-        fill_restrictive(multiworld, multiworld.state, prioritylocations, progitempool, swap=False, on_place=mark_for_locking,
-                         name="Priority")
-        accessibility_corrections(multiworld, multiworld.state, prioritylocations, progitempool)
+        fill_restrictive(world, world.state, prioritylocations, progitempool, swap=False, on_place=mark_for_locking)
+        accessibility_corrections(world, world.state, prioritylocations, progitempool)
         defaultlocations = prioritylocations + defaultlocations
 
     if progitempool:
-        # "advancement/progression fill"
-        fill_restrictive(multiworld, multiworld.state, defaultlocations, progitempool, name="Progression")
+        # "progression fill"
+        fill_restrictive(world, world.state, defaultlocations, progitempool)
         if progitempool:
             raise FillError(
-                f"Not enough locations for progression items. "
-                f"There are {len(progitempool)} more progression items than there are available locations."
-            )
-        accessibility_corrections(multiworld, multiworld.state, defaultlocations)
+                f'Not enough locations for progress items. There are {len(progitempool)} more items than locations')
+        accessibility_corrections(world, world.state, defaultlocations)
 
     for location in lock_later:
         if location.item:
             location.locked = True
     del mark_for_locking, lock_later
 
-    inaccessible_location_rules(multiworld, multiworld.state, defaultlocations)
+    inaccessible_location_rules(world, world.state, defaultlocations)
 
-    remaining_fill(multiworld, excludedlocations, filleritempool, "Remaining Excluded")
+    remaining_fill(world, excludedlocations, filleritempool)
     if excludedlocations:
         raise FillError(
-            f"Not enough filler items for excluded locations. "
-            f"There are {len(excludedlocations)} more excluded locations than filler or trap items."
-        )
+            f"Not enough filler items for excluded locations. There are {len(excludedlocations)} more locations than items")
 
-    restitempool = filleritempool + usefulitempool
+    restitempool = usefulitempool + filleritempool
 
-    remaining_fill(multiworld, defaultlocations, restitempool)
+    remaining_fill(world, defaultlocations, restitempool)
 
     unplaced = restitempool
     unfilled = defaultlocations
 
     if unplaced or unfilled:
         logging.warning(
-            f"Unplaced items({len(unplaced)}): {unplaced} - Unfilled Locations({len(unfilled)}): {unfilled}")
-        items_counter = Counter(location.item.player for location in multiworld.get_locations() if location.item)
-        locations_counter = Counter(location.player for location in multiworld.get_locations())
+            f'Unplaced items({len(unplaced)}): {unplaced} - Unfilled Locations({len(unfilled)}): {unfilled}')
+        items_counter = Counter(location.item.player for location in world.get_locations() if location.item)
+        locations_counter = Counter(location.player for location in world.get_locations())
         items_counter.update(item.player for item in unplaced)
         locations_counter.update(location.player for location in unfilled)
         print_data = {"items": items_counter, "locations": locations_counter}
-        logging.info(f"Per-Player counts: {print_data})")
+        logging.info(f'Per-Player counts: {print_data})')
 
 
-def flood_items(multiworld: MultiWorld) -> None:
+def flood_items(world: MultiWorld) -> None:
     # get items to distribute
-    multiworld.random.shuffle(multiworld.itempool)
-    itempool = multiworld.itempool
+    world.random.shuffle(world.itempool)
+    itempool = world.itempool
     progress_done = False
 
     # sweep once to pick up preplaced items
-    multiworld.state.sweep_for_events()
+    world.state.sweep_for_events()
 
-    # fill multiworld from top of itempool while we can
+    # fill world from top of itempool while we can
     while not progress_done:
-        location_list = multiworld.get_unfilled_locations()
-        multiworld.random.shuffle(location_list)
+        location_list = world.get_unfilled_locations()
+        world.random.shuffle(location_list)
         spot_to_fill = None
         for location in location_list:
-            if location.can_fill(multiworld.state, itempool[0]):
+            if location.can_fill(world.state, itempool[0]):
                 spot_to_fill = location
                 break
 
         if spot_to_fill:
             item = itempool.pop(0)
-            multiworld.push_item(spot_to_fill, item, True)
+            world.push_item(spot_to_fill, item, True)
             continue
 
         # ran out of spots, check if we need to step in and correct things
-        if len(multiworld.get_reachable_locations()) == len(multiworld.get_locations()):
+        if len(world.get_reachable_locations()) == len(world.get_locations()):
             progress_done = True
             continue
 
@@ -538,7 +452,7 @@ def flood_items(multiworld: MultiWorld) -> None:
         for item in itempool:
             if item.advancement:
                 candidate_item_to_place = item
-                if multiworld.unlocks_new_location(item):
+                if world.unlocks_new_location(item):
                     item_to_place = item
                     break
 
@@ -551,20 +465,20 @@ def flood_items(multiworld: MultiWorld) -> None:
                 raise FillError('No more progress items left to place.')
 
         # find item to replace with progress item
-        location_list = multiworld.get_reachable_locations()
-        multiworld.random.shuffle(location_list)
+        location_list = world.get_reachable_locations()
+        world.random.shuffle(location_list)
         for location in location_list:
             if location.item is not None and not location.item.advancement:
                 # safe to replace
                 replace_item = location.item
                 replace_item.location = None
                 itempool.append(replace_item)
-                multiworld.push_item(location, item_to_place, True)
+                world.push_item(location, item_to_place, True)
                 itempool.remove(item_to_place)
                 break
 
 
-def balance_multiworld_progression(multiworld: MultiWorld) -> None:
+def balance_multiworld_progression(world: 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.
@@ -572,29 +486,29 @@ def balance_multiworld_progression(multiworld: 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: multiworld.worlds[player].options.progression_balancing / 100
-        for player in multiworld.player_ids
-        if multiworld.worlds[player].options.progression_balancing > 0
+        player: world.progression_balancing[player] / 100
+        for player in world.player_ids
+        if world.progression_balancing[player] > 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(multiworld)
+        state: CollectionState = CollectionState(world)
         checked_locations: typing.Set[Location] = set()
-        unchecked_locations: typing.Set[Location] = set(multiworld.get_locations())
+        unchecked_locations: typing.Set[Location] = set(world.get_locations())
 
-        total_locations_count: typing.Counter[int] = Counter(
-            location.player
-            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
+            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()
+            if not location.locked
+        )
         balanceable_players = {
             player: balanceable_players[player]
             for player in balanceable_players
@@ -611,10 +525,6 @@ def balance_multiworld_progression(multiworld: 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,
@@ -657,7 +567,7 @@ def balance_multiworld_progression(multiworld: MultiWorld) -> None:
                     while True:
                         # Check locations in the current sphere and gather progression items to swap earlier
                         for location in balancing_sphere:
-                            if location.advancement:
+                            if location.event:
                                 balancing_state.collect(location.item, True, location)
                                 player = location.item.player
                                 # only replace items that end up in another player's world
@@ -672,7 +582,7 @@ def balance_multiworld_progression(multiworld: MultiWorld) -> None:
                             balancing_unchecked_locations.remove(location)
                             if not location.locked:
                                 balancing_reachables[location.player] += 1
-                        if multiworld.has_beaten_game(balancing_state) or all(
+                        if world.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):
@@ -689,7 +599,7 @@ def balance_multiworld_progression(multiworld: MultiWorld) -> None:
                         locations_to_test = unlocked_locations[player]
                         items_to_test = list(candidate_items[player])
                         items_to_test.sort()
-                        multiworld.random.shuffle(items_to_test)
+                        world.random.shuffle(items_to_test)
                         while items_to_test:
                             testing = items_to_test.pop()
                             reducing_state = state.copy()
@@ -701,8 +611,8 @@ def balance_multiworld_progression(multiworld: MultiWorld) -> None:
 
                             reducing_state.sweep_for_events(locations=locations_to_test)
 
-                            if multiworld.has_beaten_game(balancing_state):
-                                if not multiworld.has_beaten_game(reducing_state):
+                            if world.has_beaten_game(balancing_state):
+                                if not world.has_beaten_game(reducing_state):
                                     items_to_replace.append(testing)
                             else:
                                 reduced_sphere = get_sphere_locations(reducing_state, locations_to_test)
@@ -710,32 +620,33 @@ def balance_multiworld_progression(multiworld: MultiWorld) -> None:
                                 if p < threshold_percentages[player]:
                                     items_to_replace.append(testing)
 
-                    old_moved_item_count = moved_item_count
+                    replaced_items = False
 
                     # sort then shuffle to maintain deterministic behaviour,
                     # while allowing use of set for better algorithm growth behaviour elsewhere
-                    replacement_locations = sorted(l for l in checked_locations if not l.advancement and not l.locked)
-                    multiworld.random.shuffle(replacement_locations)
+                    replacement_locations = sorted(l for l in checked_locations if not l.event and not l.locked)
+                    world.random.shuffle(replacement_locations)
                     items_to_replace.sort()
-                    multiworld.random.shuffle(items_to_replace)
+                    world.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 i, new_location in enumerate(replacement_locations):
+                        for new_location in replacement_locations:
                             if new_location.can_fill(state, old_location.item, False) and \
                                     old_location.can_fill(state, new_location.item, False):
-                                replacement_locations.pop(i)
+                                replacement_locations.remove(new_location)
                                 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 old_moved_item_count < moved_item_count:
+                    if replaced_items:
                         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):
@@ -745,11 +656,11 @@ def balance_multiworld_progression(multiworld: MultiWorld) -> None:
                             sphere_locations.add(location)
 
             for location in sphere_locations:
-                if location.advancement:
+                if location.event:
                     state.collect(location.item, True, location)
             checked_locations |= sphere_locations
 
-            if multiworld.has_beaten_game(state):
+            if world.has_beaten_game(state):
                 break
             elif not sphere_locations:
                 logging.warning("Progression Balancing ran out of paths.")
@@ -766,9 +677,10 @@ def swap_location_item(location_1: Location, location_2: Location, check_locked:
     location_2.item, location_1.item = location_1.item, location_2.item
     location_1.item.location = location_1
     location_2.item.location = location_2
+    location_1.event, location_2.event = location_2.event, location_1.event
 
 
-def distribute_planned(multiworld: MultiWorld) -> None:
+def distribute_planned(world: MultiWorld) -> None:
     def warn(warning: str, force: typing.Union[bool, str]) -> None:
         if force in [True, 'fail', 'failure', 'none', False, 'warn', 'warning']:
             logging.warning(f'{warning}')
@@ -781,43 +693,42 @@ def distribute_planned(multiworld: MultiWorld) -> None:
         else:
             warn(warning, force)
 
-    swept_state = multiworld.state.copy()
+    swept_state = world.state.copy()
     swept_state.sweep_for_events()
-    reachable = frozenset(multiworld.get_reachable_locations(swept_state))
+    reachable = frozenset(world.get_reachable_locations(swept_state))
     early_locations: typing.Dict[int, typing.List[str]] = collections.defaultdict(list)
     non_early_locations: typing.Dict[int, typing.List[str]] = collections.defaultdict(list)
-    for loc in multiworld.get_unfilled_locations():
+    for loc in world.get_unfilled_locations():
         if loc in reachable:
             early_locations[loc.player].append(loc.name)
         else:  # not reachable with swept state
             non_early_locations[loc.player].append(loc.name)
 
-    world_name_lookup = multiworld.world_name_lookup
+    # TODO: remove. Preferably by implementing key drop
+    from worlds.alttp.Regions import key_drop_data
+    world_name_lookup = world.world_name_lookup
 
     block_value = typing.Union[typing.List[str], typing.Dict[str, typing.Any], str]
     plando_blocks: typing.List[typing.Dict[str, typing.Any]] = []
-    player_ids = set(multiworld.player_ids)
+    player_ids = set(world.player_ids)
     for player in player_ids:
-        for block in multiworld.plando_items[player]:
+        for block in world.plando_items[player]:
             block['player'] = player
             if 'force' not in block:
                 block['force'] = 'silent'
             if 'from_pool' not in block:
                 block['from_pool'] = True
-            elif not isinstance(block['from_pool'], bool):
-                from_pool_type = type(block['from_pool'])
-                raise Exception(f'Plando "from_pool" has to be boolean, not {from_pool_type} for player {player}.')
             if 'world' not in block:
                 target_world = False
             else:
                 target_world = block['world']
 
-            if target_world is False or multiworld.players == 1:  # target own world
+            if target_world is False or world.players == 1:  # target own world
                 worlds: typing.Set[int] = {player}
             elif target_world is True:  # target any worlds besides own
-                worlds = set(multiworld.player_ids) - {player}
+                worlds = set(world.player_ids) - {player}
             elif target_world is None:  # target all worlds
-                worlds = set(multiworld.player_ids)
+                worlds = set(world.player_ids)
             elif type(target_world) == list:  # list of target worlds
                 worlds = set()
                 for listed_world in target_world:
@@ -827,9 +738,9 @@ def distribute_planned(multiworld: MultiWorld) -> None:
                         continue
                     worlds.add(world_name_lookup[listed_world])
             elif type(target_world) == int:  # target world by slot number
-                if target_world not in range(1, multiworld.players + 1):
+                if target_world not in range(1, world.players + 1):
                     failed(
-                        f"Cannot place item in world {target_world} as it is not in range of (1, {multiworld.players})",
+                        f"Cannot place item in world {target_world} as it is not in range of (1, {world.players})",
                         block['force'])
                     continue
                 worlds = {target_world}
@@ -857,7 +768,7 @@ def distribute_planned(multiworld: MultiWorld) -> None:
                 item_list: typing.List[str] = []
                 for key, value in items.items():
                     if value is True:
-                        value = multiworld.itempool.count(multiworld.worlds[player].create_item(key))
+                        value = world.itempool.count(world.worlds[player].create_item(key))
                     item_list += [key] * value
                 items = item_list
             if isinstance(items, str):
@@ -880,14 +791,15 @@ def distribute_planned(multiworld: MultiWorld) -> None:
 
             if "early_locations" in locations:
                 locations.remove("early_locations")
-                for target_player in worlds:
-                    locations += early_locations[target_player]
+                for player in worlds:
+                    locations += early_locations[player]
             if "non_early_locations" in locations:
                 locations.remove("non_early_locations")
-                for target_player in worlds:
-                    locations += non_early_locations[target_player]
+                for player in worlds:
+                    locations += non_early_locations[player]
 
-            block['locations'] = list(dict.fromkeys(locations))
+
+            block['locations'] = locations
 
             if not block['count']:
                 block['count'] = (min(len(block['items']), len(block['locations'])) if
@@ -907,17 +819,17 @@ def distribute_planned(multiworld: MultiWorld) -> None:
                 count = block['count']
                 failed(f"Plando count {count} greater than locations specified", block['force'])
                 block['count'] = len(block['locations'])
-            block['count']['target'] = multiworld.random.randint(block['count']['min'], block['count']['max'])
+            block['count']['target'] = world.random.randint(block['count']['min'], block['count']['max'])
 
             if block['count']['target'] > 0:
                 plando_blocks.append(block)
 
     # shuffle, but then sort blocks by number of locations minus number of items,
     # so less-flexible blocks get priority
-    multiworld.random.shuffle(plando_blocks)
+    world.random.shuffle(plando_blocks)
     plando_blocks.sort(key=lambda block: (len(block['locations']) - block['count']['target']
                                           if len(block['locations']) > 0
-                                          else len(multiworld.get_unfilled_locations(player)) - block['count']['target']))
+                                          else len(world.get_unfilled_locations(player)) - block['count']['target']))
 
     for placement in plando_blocks:
         player = placement['player']
@@ -928,50 +840,52 @@ def distribute_planned(multiworld: MultiWorld) -> None:
             maxcount = placement['count']['target']
             from_pool = placement['from_pool']
 
-            candidates = list(multiworld.get_unfilled_locations_for_players(locations, sorted(worlds)))
-            multiworld.random.shuffle(candidates)
-            multiworld.random.shuffle(items)
+            candidates = list(world.get_unfilled_locations_for_players(locations, sorted(worlds)))
+            world.random.shuffle(candidates)
+            world.random.shuffle(items)
             count = 0
             err: typing.List[str] = []
             successful_pairs: typing.List[typing.Tuple[Item, Location]] = []
             for item_name in items:
-                item = multiworld.worlds[player].create_item(item_name)
+                item = world.worlds[player].create_item(item_name)
                 for location in reversed(candidates):
-                    if (location.address is None) == (item.code is None):  # either both None or both not None
-                        if not location.item:
-                            if location.item_rule(item):
-                                if location.can_fill(multiworld.state, item, False):
-                                    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.")
+                    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
                             else:
-                                err.append(f"{item_name} not allowed at {location}.")
+                                err.append(f"Can't place item at {location} due to fill condition not met.")
                         else:
-                            err.append(f"Cannot place {item_name} into already filled location {location}.")
+                            err.append(f"{item_name} not allowed at {location}.")
                     else:
-                        err.append(f"Mismatch between {item_name} and {location}, only one is an event.")
+                        err.append(f"Cannot place {item_name} into already filled location {location}.")
                 if count == maxcount:
                     break
             if count < placement['count']['min']:
                 m = placement['count']['min']
                 failed(
-                    f"Plando block failed to place {m - count} of {m} item(s) for {multiworld.player_name[player]}, error(s): {' '.join(err)}",
+                    f"Plando block failed to place {m - count} of {m} item(s) for {world.player_name[player]}, error(s): {' '.join(err)}",
                     placement['force'])
             for (item, location) in successful_pairs:
-                multiworld.push_item(location, item, collect=False)
+                world.push_item(location, item, collect=False)
+                location.event = True  # flag location to be checked during fill
                 location.locked = True
                 logging.debug(f"Plando placed {item} at {location}")
                 if from_pool:
                     try:
-                        multiworld.itempool.remove(item)
+                        world.itempool.remove(item)
                     except ValueError:
                         warn(
-                            f"Could not remove {item} from pool for {multiworld.player_name[player]} as it's already missing from it.",
+                            f"Could not remove {item} from pool for {world.player_name[player]} as it's already missing from it.",
                             placement['force'])
 
         except Exception as e:
             raise Exception(
-                f"Error running plando for player {player} ({multiworld.player_name[player]})") from e
+                f"Error running plando for player {player} ({world.player_name[player]})") from e

Generate.py

@@ -7,55 +7,55 @@ import random
 import string
 import urllib.parse
 import urllib.request
-from collections import Counter
-from typing import Any, Dict, Tuple, Union
+from collections import Counter, ChainMap
+from typing import Dict, Tuple, Callable, Any, Union
 
 import ModuleUpdate
 
 ModuleUpdate.update()
 
-import copy
 import Utils
-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.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 worlds.alttp.Text import TextTable
 from worlds.AutoWorld import AutoWorldRegister
-from worlds.generic import PlandoConnection
-from worlds import failed_world_loads
+import copy
+
+
+
 
 
 def mystery_argparse():
-    options = get_settings()
-    defaults = options.generator
+    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)
 
     parser = argparse.ArgumentParser(description="CMD Generation Interface, defaults come from host.yaml.")
-    parser.add_argument('--weights_file_path', default=defaults.weights_file_path,
-                        help='Path to the weights file to use for rolling game options, urls are also valid')
-    parser.add_argument('--sameoptions', help='Rolls options per weights file rather than per player',
+    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=defaults.player_files_path,
+    parser.add_argument('--player_files_path', default=resolve_path(defaults["player_files_path"], user_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=options.general_options.output_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=resolve_path(options["general_options"]["output_path"], user_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,16 +72,12 @@ 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, ...]] = {}
@@ -89,22 +85,22 @@ 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 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')}")
+            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')}")
 
     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 invalid. Please fix your yaml.") from e
-        logging.info(f"Meta: {args.meta_file_path} >> {get_choice('meta_description', meta_weights)}")
+            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)}")
         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:
             raise ValueError("No meta description found for meta.yaml. Unable to verify.") from e
-        if args.sameoptions:
-            raise Exception("Cannot mix --sameoptions with --meta")
+        if args.samesettings:
+            raise Exception("Cannot mix --samesettings with --meta")
     else:
         meta_weights = None
     player_id = 1
@@ -117,46 +113,38 @@ def main(args=None, callback=ERmain):
             try:
                 weights_cache[fname] = read_weights_yamls(path)
             except Exception as e:
-                raise ValueError(f"File {fname} is invalid. Please fix your yaml.") from e
+                raise ValueError(f"File {fname} is destroyed. 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:
-                logging.info(f"P{player_id} Weights: {filename} >> "
-                             f"{get_choice('description', yaml, 'No description specified')}")
+                print(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)
-
-    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}")
+    print(f"Generating for {args.multi} player{'s' if args.multi > 1 else ''}, {seed_name} Seed {seed} with plando: "
+          f"{args.plando}")
 
     if not weights_cache:
-        raise Exception(f"No weights found. "
-                        f"Provide a general weights file ({args.weights_file_path}) or individual player files. "
+        raise Exception(f"No weights found. 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
-    erargs.skip_prog_balancing = args.skip_prog_balancing
-    erargs.skip_output = args.skip_output
+
+    Utils.init_logging(f"Generate_{seed}", loglevel=args.log_level)
 
     settings_cache: Dict[str, Tuple[argparse.Namespace, ...]] = \
-        {fname: (tuple(roll_settings(yaml, args.plando) for yaml in yamls) if args.sameoptions else None)
+        {fname: (tuple(roll_settings(yaml, args.plando) for yaml in yamls) if args.samesettings else None)
          for fname, yamls in weights_cache.items()}
 
     if meta_weights:
@@ -168,8 +156,7 @@ 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.CommonOptions.type_hints:
+                                    if category in AutoWorldRegister.world_types and key in Options.common_options:
                                         yaml[category][key] = option
                             elif category_name not in yaml:
                                 logging.warning(f"Meta: Category {category_name} is not present in {path}.")
@@ -180,7 +167,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_options = {}
+    erargs.player_settings = {}
 
     player = 1
     while player <= args.multi:
@@ -207,7 +194,7 @@ def main(args=None, callback=ERmain):
 
                     player += 1
             except Exception as e:
-                raise ValueError(f"File {path} is invalid. Please fix your yaml.") from e
+                raise ValueError(f"File {path} is destroyed. Please fix your yaml.") from e
         else:
             raise RuntimeError(f'No weights specified for player {player}')
 
@@ -236,7 +223,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)
 
-    return callback(erargs, seed)
+    callback(erargs, seed)
 
 
 def read_weights_yamls(path) -> Tuple[Any, ...]:
@@ -302,43 +289,46 @@ def handle_name(name: str, player: int, name_counter: Counter):
                                                                  NUMBER=(number if number > 1 else ''),
                                                                  player=player,
                                                                  PLAYER=(player if player > 1 else '')))
-    # Run .strip twice for edge case where after the initial .slice new_name has a leading whitespace.
-    # Could cause issues for some clients that cannot handle the additional whitespace.
-    new_name = new_name.strip()[:16].strip()
+    new_name = new_name.strip()[:16]
     if new_name == "Archipelago":
         raise Exception(f"You cannot name yourself \"{new_name}\"")
     return new_name
 
 
+def prefer_int(input_data: str) -> Union[str, int]:
+    try:
+        return int(input_data)
+    except:
+        return input_data
+
+
+goals = {
+    'ganon': 'ganon',
+    'crystals': 'crystals',
+    'bosses': 'bosses',
+    'pedestal': 'pedestal',
+    'ganon_pedestal': 'ganonpedestal',
+    'triforce_hunt': 'triforcehunt',
+    'local_triforce_hunt': 'localtriforcehunt',
+    'ganon_triforce_hunt': 'ganontriforcehunt',
+    'local_ganon_triforce_hunt': 'localganontriforcehunt',
+    'ice_rod_hunt': 'icerodhunt',
+}
+
+
 def roll_percentage(percentage: Union[int, float]) -> bool:
     """Roll a percentage chance.
     percentage is expected to be in range [0, 100]"""
     return random.random() < (float(percentage) / 100)
 
 
-def update_weights(weights: dict, new_weights: dict, update_type: str, name: str) -> dict:
+def update_weights(weights: dict, new_weights: dict, type: str, name: str) -> dict:
     logging.debug(f'Applying {new_weights}')
-    cleaned_weights = {}
-    for option in new_weights:
-        option_name = option.lstrip("+")
-        if option.startswith("+") and option_name in weights:
-            cleaned_value = weights[option_name]
-            new_value = new_weights[option]
-            if isinstance(new_value, (set, dict)):
-                cleaned_value.update(new_value)
-            elif isinstance(new_value, list):
-                cleaned_value.extend(new_value)
-            else:
-                raise Exception(f"Cannot apply merge to non-dict, set, or list type {option_name},"
-                                f" received {type(new_value).__name__}.")
-            cleaned_weights[option_name] = cleaned_value
-        else:
-            cleaned_weights[option_name] = new_weights[option]
-    new_options = set(cleaned_weights) - set(weights)
-    weights.update(cleaned_weights)
+    new_options = set(new_weights) - set(weights)
+    weights.update(new_weights)
     if new_options:
         for new_option in new_options:
-            logging.warning(f'{update_type} Suboption "{new_option}" of "{name}" did not '
+            logging.warning(f'{type} Suboption "{new_option}" of "{name}" did not '
                             f'overwrite a root option. '
                             f'This is probably in error.')
     return weights
@@ -349,11 +339,20 @@ 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 = game_world.options_dataclass.type_hints
+        options = ChainMap(game_world.option_definitions, Options.per_game_common_options)
         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}.")
 
 
@@ -374,7 +373,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 invalid. "
+            raise ValueError(f"Linked option {option_set['name']} is destroyed. "
                              f"Please fix your linked option.") from e
     return weights
 
@@ -404,7 +403,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 invalid. "
+            raise ValueError(f"Your trigger number {i + 1} is destroyed. "
                              f"Please fix your triggers.") from e
     return weights
 
@@ -445,59 +444,151 @@ def roll_settings(weights: dict, plando_options: PlandoOptions = PlandoOptions.b
                                 f"which is not enabled.")
 
     ret = argparse.Namespace()
-    for option_key in Options.PerGameCommonOptions.type_hints:
-        if option_key in weights and option_key not in Options.CommonOptions.type_hints:
+    for option_key in Options.per_game_common_options:
+        if option_key in weights and option_key not in Options.common_options:
             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.CommonOptions.type_hints.items():
+    for option_key, option in Options.common_options.items():
         setattr(ret, option_key, option.from_any(get_choice(option_key, weights, option.default)))
 
-    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")
-                ))
+    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}")
 
     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:
@@ -511,6 +602,17 @@ def roll_alttp_settings(ret: argparse.Namespace, weights, plando_options):
                     raise Exception(f"No text target \"{at}\" found.")
                 ret.plando_texts[at] = str(get_choice_legacy("text", placement))
 
+    ret.plando_connections = []
+    if PlandoOptions.connections in plando_options:
+        options = weights.get("plando_connections", [])
+        for placement in options:
+            if roll_percentage(get_choice_legacy("percentage", placement, 100)):
+                ret.plando_connections.append(PlandoConnection(
+                    get_choice_legacy("entrance", placement),
+                    get_choice_legacy("exit", placement),
+                    get_choice_legacy("direction", placement, "both")
+                ))
+
     ret.sprite_pool = weights.get('sprite_pool', [])
     ret.sprite = get_choice_legacy('sprite', weights, "Link")
     if 'random_sprite_on_event' in weights:
@@ -538,15 +640,6 @@ def roll_alttp_settings(ret: argparse.Namespace, weights, plando_options):
 if __name__ == '__main__':
     import atexit
     confirmation = atexit.register(input, "Press enter to close.")
-    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."
+    main()
     # in case of error-free exit should not need confirmation
     atexit.unregister(confirmation)

KH2Client.py

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

Launcher.py

@@ -11,19 +11,13 @@ 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 enum import Enum, auto
 from os.path import isfile
 from shutil import which
-from typing import Sequence, Union, Optional
-
-import Utils
-import settings
-from worlds.LauncherComponents import Component, components, Type, SuffixIdentifier, icon_paths
+from typing import Iterable, Sequence, Callable, Union, Optional
 
 if __name__ == "__main__":
     import ModuleUpdate
@@ -34,8 +28,7 @@ from Utils import is_frozen, user_path, local_path, init_logging, open_filename,
 
 
 def open_host_yaml():
-    file = settings.get_settings().filename
-    assert file, "host.yaml missing"
+    file = user_path('host.yaml')
     if is_linux:
         exe = which('sensible-editor') or which('gedit') or \
               which('xdg-open') or which('gnome-open') or which('kde-open')
@@ -44,103 +37,171 @@ 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 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
+        if isfile(get_exe(c)[-1]):
+            suffixes += c.file_identifier.suffixes if c.type == Type.CLIENT and \
+                                                      isinstance(c.file_identifier, SuffixIdentifier) else []
     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:
-            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)
+            launch([*get_exe(component), file], component.cli)
 
 
 def browse_files():
-    open_folder(user_path())
-
-
-def open_folder(folder_path):
+    file = user_path()
     if is_linux:
         exe = which('xdg-open') or which('gnome-open') or which('kde-open')
-        subprocess.Popen([exe, folder_path])
+        subprocess.Popen([exe, file])
     elif is_macos:
         exe = which("open")
-        subprocess.Popen([exe, folder_path])
+        subprocess.Popen([exe, file])
     else:
-        webbrowser.open(folder_path)
+        import webbrowser
+        webbrowser.open(file)
 
 
-def update_settings():
-    from settings import get_settings
-    get_settings().save()
+# noinspection PyArgumentList
+class Type(Enum):
+    TOOL = auto()
+    FUNC = auto()  # not a real component
+    CLIENT = auto()
+    ADJUSTER = auto()
 
 
-components.extend([
+class SuffixIdentifier:
+    suffixes: Iterable[str]
+
+    def __init__(self, *args: str):
+        self.suffixes = args
+
+    def __call__(self, path: str):
+        if isinstance(path, str):
+            for suffix in self.suffixes:
+                if path.endswith(suffix):
+                    return True
+        return False
+
+
+class Component:
+    display_name: str
+    type: Optional[Type]
+    script_name: Optional[str]
+    frozen_name: Optional[str]
+    icon: str  # just the name, no suffix
+    cli: bool
+    func: Optional[Callable]
+    file_identifier: Optional[Callable[[str], bool]]
+
+    def __init__(self, display_name: str, script_name: Optional[str] = None, frozen_name: Optional[str] = None,
+                 cli: bool = False, icon: str = 'icon', component_type: Type = None, func: Optional[Callable] = None,
+                 file_identifier: Optional[Callable[[str], bool]] = None):
+        self.display_name = display_name
+        self.script_name = script_name
+        self.frozen_name = frozen_name or f'Archipelago{script_name}' if script_name else None
+        self.icon = icon
+        self.cli = cli
+        self.type = component_type or \
+            None if not display_name else \
+            Type.FUNC if func else \
+            Type.CLIENT if 'Client' in display_name else \
+            Type.ADJUSTER if 'Adjuster' in display_name else Type.TOOL
+        self.func = func
+        self.file_identifier = file_identifier
+
+    def handles_file(self, path: str):
+        return self.file_identifier(path) if self.file_identifier else False
+
+
+components: Iterable[Component] = (
+    # Launcher
+    Component('', 'Launcher'),
+    # Core
+    Component('Host', 'MultiServer', 'ArchipelagoServer', cli=True,
+              file_identifier=SuffixIdentifier('.archipelago', '.zip')),
+    Component('Generate', 'Generate', cli=True),
+    Component('Text Client', 'CommonClient', 'ArchipelagoTextClient'),
+    # SNI
+    Component('SNI Client', 'SNIClient',
+              file_identifier=SuffixIdentifier('.apz3', '.apm3', '.apsoe', '.aplttp', '.apsm', '.apsmz3', '.apdkc3',
+                                               '.apsmw', '.apl2ac')),
+    Component('LttP Adjuster', 'LttPAdjuster'),
+    # Factorio
+    Component('Factorio Client', 'FactorioClient'),
+    # Minecraft
+    Component('Minecraft Client', 'MinecraftClient', icon='mcicon', cli=True,
+              file_identifier=SuffixIdentifier('.apmc')),
+    # Ocarina of Time
+    Component('OoT Client', 'OoTClient',
+              file_identifier=SuffixIdentifier('.apz5')),
+    Component('OoT Adjuster', 'OoTAdjuster'),
+    # FF1
+    Component('FF1 Client', 'FF1Client'),
+    # Pokémon
+    Component('Pokemon Client', 'PokemonClient', file_identifier=SuffixIdentifier('.apred', '.apblue')),
+    # TLoZ
+    Component('Zelda 1 Client', 'Zelda1Client'),
+    # ChecksFinder
+    Component('ChecksFinder Client', 'ChecksFinderClient'),
+    # Starcraft 2
+    Component('Starcraft 2 Client', 'Starcraft2Client'),
+    # Wargroove
+    Component('Wargroove Client', 'WargrooveClient'),
+    # Zillion
+    Component('Zillion Client', 'ZillionClient',
+              file_identifier=SuffixIdentifier('.apzl')),
     # Functions
-    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),
-])
+    Component('Open host.yaml', func=open_host_yaml),
+    Component('Open Patch', func=open_patch),
+    Component('Browse Files', func=browse_files),
+)
+icon_paths = {
+    'icon': local_path('data', 'icon.ico' if is_windows else 'icon.png'),
+    'mcicon': local_path('data', 'mcicon.ico')
+}
 
 
 def identify(path: Union[None, str]):
     if path is None:
-        return None, None
+        return None, None, None
     for component in components:
         if component.handles_file(path):
-            return path, component
-        elif path == component.display_name or path == component.script_name:
-            return None, component
-    return None, None
+            return path, component.script_name, component
+    return (None, None, None) if '/' in path or '\\' in path else (None, path, 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}")] if component.frozen_name else None
+        suffix = '.exe' if is_windows else ''
+        return [local_path(f'{component.frozen_name}{suffix}')]
     else:
-        return [sys.executable, local_path(f"{component.script_name}.py")] if component.script_name else None
+        return [sys.executable, local_path(f'{component.script_name}.py')]
 
 
 def launch(exe, in_terminal=False):
@@ -161,19 +222,17 @@ def launch(exe, in_terminal=False):
 
 
 def run_gui():
-    from kvui import App, ContainerLayout, GridLayout, Button, Label, ScrollBox, Widget
-    from kivy.uix.image import AsyncImage
-    from kivy.uix.relativelayout import RelativeLayout
+    from kvui import App, ContainerLayout, GridLayout, Button, Label
 
     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}
-        _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}
+        _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}
 
         def __init__(self, ctx=None):
             self.title = self.base_title
@@ -185,74 +244,39 @@ 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._miscs.items(), self._adjusters.items()), self._clients.items()):
+                    self._tools.items(), self._funcs.items(), self._adjusters.items()), self._clients.items()):
                 # column 1
                 if tool:
-                    tool_layout.layout.add_widget(build_button(tool[1]))
+                    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())
                 # column 2
                 if client:
-                    client_layout.layout.add_widget(build_button(client[1]))
+                    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())
 
             return self.container
 
         @staticmethod
         def component_action(button):
-            if button.component.func:
+            if button.component.type == Type.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()}
@@ -260,40 +284,24 @@ 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:
-        run_component(args["component"], args["file"], *args["args"])
+        subprocess.run([*get_exe(args['component']), args['file'], *args['args']])
     elif 'component' in args:
-        run_component(args["component"], *args["args"])
-    elif not args["update_settings"]:
+        subprocess.run([*get_exe(args['component']), *args['args']])
+    else:
         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')
-    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.")
+    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.")
     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

@@ -1,701 +0,0 @@
-import ModuleUpdate
-ModuleUpdate.update()
-
-import Utils
-
-if __name__ == "__main__":
-    Utils.init_logging("LinksAwakeningContext", exception_logger="Client")
-
-import asyncio
-import base64
-import binascii
-import colorama
-import io
-import os
-import re
-import select
-import shlex
-import socket
-import struct
-import sys
-import subprocess
-import time
-import typing
-
-
-from CommonClient import (CommonContext, get_base_parser, gui_enabled, logger,
-                          server_loop)
-from NetUtils import ClientStatus
-from worlds.ladx.Common import BASE_ID as LABaseID
-from worlds.ladx.GpsTracker import GpsTracker
-from worlds.ladx.ItemTracker import ItemTracker
-from worlds.ladx.LADXR.checkMetadata import checkMetadataTable
-from worlds.ladx.Locations import get_locations_to_id, meta_to_name
-from worlds.ladx.Tracker import LocationTracker, MagpieBridge
-
-
-class GameboyException(Exception):
-    pass
-
-
-class RetroArchDisconnectError(GameboyException):
-    pass
-
-
-class InvalidEmulatorStateError(GameboyException):
-    pass
-
-
-class BadRetroArchResponse(GameboyException):
-    pass
-
-
-def magpie_logo():
-    from kivy.uix.image import CoreImage
-    binary_data = """
-iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAIAAACQkWg2AAAAAXN
-SR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA
-7DAcdvqGQAAADGSURBVDhPhVLBEcIwDHOYhjHCBuXHj2OTbAL8+
-MEGZIxOQ1CinOOk0Op0bmo7tlXXeR9FJMYDLOD9mwcLjQK7+hSZ
-wgcWMZJOAGeGKtChNHFL0j+FZD3jSCuo0w7l03wDrWdg00C4/aW
-eDEYNenuzPOfPspBnxf0kssE80vN0L8361j10P03DK4x6FHabuV
-ear8fHme+b17rwSjbAXeUMLb+EVTV2QHm46MWQanmnydA98KsVS
-XkV+qFpGQXrLhT/fqraQeQLuplpNH5g+WkAAAAASUVORK5CYII="""
-    binary_data = base64.b64decode(binary_data)
-    data = io.BytesIO(binary_data)
-    return CoreImage(data, ext="png").texture
-
-
-class LAClientConstants:
-    # Connector version
-    VERSION = 0x01
-    #
-    # Memory locations of LADXR
-    ROMGameID = 0x0051  # 4 bytes
-    SlotName = 0x0134
-    # Unused
-    # ROMWorldID = 0x0055
-    # ROMConnectorVersion = 0x0056
-    # RO: We should only act if this is higher then 6, as it indicates that the game is running normally
-    wGameplayType = 0xDB95
-    # RO: Starts at 0, increases every time an item is received from the server and processed
-    wLinkSyncSequenceNumber = 0xDDF6
-    wLinkStatusBits = 0xDDF7          # RW:
-    #      Bit0: wLinkGive* contains valid data, set from script cleared from ROM.
-    wLinkHealth = 0xDB5A
-    wLinkGiveItem = 0xDDF8  # RW
-    wLinkGiveItemFrom = 0xDDF9  # RW
-    # All of these six bytes are unused, we can repurpose
-    # wLinkSendItemRoomHigh = 0xDDFA  # RO
-    # wLinkSendItemRoomLow = 0xDDFB  # RO
-    # wLinkSendItemTarget = 0xDDFC  # RO
-    # wLinkSendItemItem = 0xDDFD  # RO
-    # wLinkSendShopItem = 0xDDFE # RO, which item to send (1 based, order of the shop items)
-    # RO, which player to send to, but it's just the X position of the NPC used, so 0x18 is player 0
-    # wLinkSendShopTarget = 0xDDFF
-
-
-    wRecvIndex = 0xDDFD # Two bytes
-    wCheckAddress = 0xC0FF - 0x4
-    WRamCheckSize = 0x4
-    WRamSafetyValue = bytearray([0]*WRamCheckSize)
-
-    MinGameplayValue = 0x06
-    MaxGameplayValue = 0x1A
-    VictoryGameplayAndSub = 0x0102
-
-
-class RAGameboy():
-    cache = []
-    cache_start = 0
-    cache_size = 0
-    last_cache_read = None
-    socket = None
-
-    def __init__(self, address, port) -> None:
-        self.address = address
-        self.port = port
-        self.socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-        assert (self.socket)
-        self.socket.setblocking(False)
-
-    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()
-
-    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
-        self.cache_size = cache_size
-
-    def send(self, b):
-        if type(b) is str:
-            b = b.encode('ascii')
-        self.socket.sendto(b, (self.address, self.port))
-
-    def recv(self):
-        select.select([self.socket], [], [])
-        response, _ = self.socket.recvfrom(4096)
-        return response
-
-    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):
-        async def check_wram():
-            check_values = await self.async_read_memory(LAClientConstants.wCheckAddress, LAClientConstants.WRamCheckSize)
-
-            if check_values != LAClientConstants.WRamSafetyValue:
-                if throw:
-                    raise InvalidEmulatorStateError()
-                return False
-            return True
-
-        if not await check_wram():
-            if throw:
-                raise InvalidEmulatorStateError()
-            return False
-
-        gameplay_value = await self.async_read_memory(LAClientConstants.wGameplayType)
-        gameplay_value = gameplay_value[0]
-        # In gameplay or credits
-        if not (LAClientConstants.MinGameplayValue <= gameplay_value <= LAClientConstants.MaxGameplayValue) and gameplay_value != 0x1:
-            if throw:
-                logger.info("invalid emu state")
-                raise InvalidEmulatorStateError()
-            return False
-        if not await check_wram():
-            if throw:
-                raise InvalidEmulatorStateError()
-            return False
-        return True
-
-    # We're sadly unable to update the whole cache at once
-    # as RetroArch only gives back some number of bytes at a time
-    # So instead read as big as chunks at a time as we can manage
-    async def update_cache(self):
-        # First read the safety address - if it's invalid, bail
-        self.cache = []
-
-        if not await self.check_safe_gameplay():
-            return
-
-        cache = []
-        remaining_size = self.cache_size
-        while remaining_size:
-            block = await self.async_read_memory(self.cache_start + len(cache), remaining_size)
-            remaining_size -= len(block)
-            cache += block
-
-        if not await self.check_safe_gameplay():
-            return
-
-        self.cache = cache
-        self.last_cache_read = time.time()
-
-    async def read_memory_cache(self, addresses):
-        # TODO: can we just update once per frame?
-        if not self.last_cache_read or self.last_cache_read + 0.1 < time.time():
-            await self.update_cache()
-        if not self.cache:
-            return None
-        assert (len(self.cache) == self.cache_size)
-        for address in addresses:
-            assert self.cache_start <= address <= self.cache_start + self.cache_size
-        r = {address: self.cache[address - self.cache_start]
-             for address in addresses}
-        return r
-
-    async def async_read_memory_safe(self, address, size=1):
-        # whenever we do a read for a check, we need to make sure that we aren't reading
-        # garbage memory values - we also need to protect against reading a value, then the emulator resetting
-        #
-        # ...actually, we probably _only_ need the post check
-
-        # Check before read
-        if not await self.check_safe_gameplay():
-            return None
-
-        # Do read
-        r = await self.async_read_memory(address, size)
-
-        # Check after read
-        if not await self.check_safe_gameplay():
-            return None
-
-        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)
-        # Ignore the address for now
-        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):
-        command = "READ_CORE_MEMORY"
-
-        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()
-
-        if response_addr != address:
-            raise BadRetroArchResponse()
-
-        ret = bytearray.fromhex(splits[2])
-        if len(ret) > size:
-            raise BadRetroArchResponse()
-        return ret
-
-    def write_memory(self, address, bytes):
-        command = "WRITE_CORE_MEMORY"
-
-        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)
-
-        if splits[2] == "-1":
-            logger.info(splits[3])
-
-
-class LinksAwakeningClient():
-    socket = None
-    gameboy = None
-    tracker = None
-    auth = None
-    game_crc = None
-    pending_deathlink = False
-    deathlink_debounce = True
-    recvd_checks = {}
-    retroarch_address = None
-    retroarch_port = None
-    gameboy = None
-
-    def msg(self, m):
-        logger.info(m)
-        s = f"SHOW_MSG {m}\n"
-        self.gameboy.send(s)
-
-    def __init__(self, retroarch_address="127.0.0.1", retroarch_port=55355):
-        self.retroarch_address = retroarch_address
-        self.retroarch_port = retroarch_port
-        pass
-
-    stop_bizhawk_spam = False
-    async def wait_for_retroarch_connection(self):
-        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 = 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:
-                    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 (BlockingIOError, TimeoutError, ConnectionResetError):
-                await asyncio.sleep(1.0)
-                pass
-
-    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):
-        await self.wait_for_game_ready()
-        self.tracker = LocationTracker(self.gameboy)
-        self.item_tracker = ItemTracker(self.gameboy)
-        self.gps_tracker = GpsTracker(self.gameboy)
-
-    async def recved_item_from_ap(self, item_id, from_player, next_index):
-        # Don't allow getting an item until you've got your first check
-        if not self.tracker.has_start_item():
-            return
-
-        # Spin until we either:
-        # get an exception from a bad read (emu shut down or reset)
-        # beat the game
-        # the client handles the last pending item
-        status = (await self.gameboy.async_read_memory_safe(LAClientConstants.wLinkStatusBits))[0]
-        while not (await self.is_victory()) and status & 1 == 1:
-            time.sleep(0.1)
-            status = (await self.gameboy.async_read_memory_safe(LAClientConstants.wLinkStatusBits))[0]
-
-        item_id -= LABaseID
-        # The player name table only goes up to 100, so don't go past that
-        # Even if it didn't, the remote player _index_ byte is just a byte, so 255 max
-        if from_player > 100:
-            from_player = 100
-
-        next_index += 1
-        self.gameboy.write_memory(LAClientConstants.wLinkGiveItem, [
-                                  item_id, from_player])
-        status |= 1
-        status = self.gameboy.write_memory(LAClientConstants.wLinkStatusBits, [status])
-        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):
-            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
-
-    async def main_tick(self, item_get_cb, win_cb, deathlink_cb):
-        await self.tracker.readChecks(item_get_cb)
-        await self.item_tracker.readItems()
-        await self.gps_tracker.read_location()
-
-        current_health = (await self.gameboy.read_memory_cache([LAClientConstants.wLinkHealth]))[LAClientConstants.wLinkHealth]
-        if self.deathlink_debounce and current_health != 0:
-            self.deathlink_debounce = False
-        elif not self.deathlink_debounce and current_health == 0:
-            # logger.info("YOU DIED.")
-            await deathlink_cb()
-            self.deathlink_debounce = True
-
-        if self.pending_deathlink:
-            logger.info("Got a deathlink")
-            self.gameboy.write_memory(LAClientConstants.wLinkHealth, [0])
-            self.pending_deathlink = False
-            self.deathlink_debounce = True
-
-        if await self.is_victory():
-            await win_cb()
-
-        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:
-            item = self.recvd_checks[recv_index]
-            await self.recved_item_from_ap(item.item, item.player, recv_index)
-
-
-all_tasks = set()
-
-def create_task_log_exception(awaitable) -> asyncio.Task:
-    async def _log_exception(awaitable):
-        try:
-            return await awaitable
-        except Exception as e:
-            logger.exception(e)
-            pass
-        finally:
-            all_tasks.remove(task)
-    task = asyncio.create_task(_log_exception(awaitable))
-    all_tasks.add(task)
-
-
-class LinksAwakeningContext(CommonContext):
-    tags = {"AP"}
-    game = "Links Awakening DX"
-    items_handling = 0b101
-    want_slot_data = True
-    la_task = None
-    client = None
-    # TODO: does this need to re-read on reset?
-    found_checks = []
-    last_resend = time.time()
-
-    magpie_enabled = False
-    magpie = None
-    magpie_task = None
-    won = False
-
-    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:
-        import webbrowser
-        import kvui
-        from kvui import Button, GameManager
-        from kivy.uix.image import Image
-
-        class LADXManager(GameManager):
-            logging_pairs = [
-                ("Client", "Archipelago"),
-                ("Tracker", "Tracker"),
-            ]
-            base_title = "Archipelago Links Awakening DX Client"
-
-            def build(self):
-                b = super().build()
-
-                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)
-
-                    self.connect_layout.add_widget(button)
-                return b
-
-        self.ui = LADXManager(self)
-        self.ui_task = asyncio.create_task(self.ui.async_run(), name="UI")
-
-    async def send_checks(self):
-        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:
-            message = [{"cmd": 'Deathlink',
-                        'time': time.time(),
-                        'cause': 'Had a nightmare',
-                        # 'source': self.slot_info[self.slot].name,
-                        }]
-            await self.send_msgs(message)
-
-    async def send_victory(self):
-        if not self.won:
-            message = [{"cmd": "StatusUpdate",
-                        "status": ClientStatus.CLIENT_GOAL}]
-            logger.info("victory!")
-            await self.send_msgs(message)
-            self.won = True
-
-    async def on_deathlink(self, data: typing.Dict[str, typing.Any]) -> None:
-        if self.ENABLE_DEATHLINK:
-            self.client.pending_deathlink = True
-
-    def new_checks(self, item_ids, ladxr_ids):
-        self.found_checks += item_ids
-        create_task_log_exception(self.send_checks())
-        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.send_connect()
-
-    def on_package(self, cmd: str, args: dict):
-        if cmd == "Connected":
-            self.game = self.slot_info[self.slot].game
-        # TODO - use watcher_event
-        if cmd == "ReceivedItems":
-            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):
-        def on_item_get(ladxr_checks):
-            checks = [self.item_id_lookup[meta_to_name(
-                checkMetadataTable[check.id])] for check in ladxr_checks]
-            self.new_checks(checks, [check.id for check in ladxr_checks])
-
-        async def victory():
-            await self.send_victory()
-
-        async def deathlink():
-            await self.send_deathlink()
-
-        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
-                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()
-                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:
-                    await self.client.main_tick(on_item_get, victory, deathlink)
-                    await asyncio.sleep(0.1)
-                    now = time.time()
-                    if self.last_resend + 5.0 < now:
-                        self.last_resend = now
-                        await self.send_checks()
-                    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)
-
-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()
-
-    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 and not args.connect:
-            args.connect = meta["server"]
-        logger.info(f"wrote rom file to {rom_file}")
-
-
-    ctx = LinksAwakeningContext(args.connect, args.password, args.magpie)
-
-    ctx.server_task = asyncio.create_task(server_loop(ctx), name="server loop")
-
-    # TODO: nothing about the lambda about has to be in a lambda
-    ctx.la_task = create_task_log_exception(ctx.run_game_loop())
-    if gui_enabled:
-        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()
-
-if __name__ == '__main__':
-    colorama.init()
-    asyncio.run(main())
-    colorama.deinit()

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, get_adjuster_settings_no_defaults, tkinter_center_window, init_logging
+    get_adjuster_settings, tkinter_center_window, init_logging
 
 
 GAME_ALTTP = "A Link to the Past"
@@ -43,49 +43,8 @@ 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):
 
-        _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:
+def main():
     parser = argparse.ArgumentParser(formatter_class=ArgumentDefaultsHelpFormatter)
 
     parser.add_argument('rom', nargs="?", default='AP_LttP.sfc', help='Path to an ALttP rom to adjust.')
@@ -93,8 +52,6 @@ def get_argparser() -> argparse.ArgumentParser:
                         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='''\
@@ -104,7 +61,7 @@ def get_argparser() -> argparse.ArgumentParser:
     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('--music', default=True, help='Enables/Disables game music.', action=BooleanOptionalActionWithDisable)
+    parser.add_argument('--disablemusic', help='Disables game music.', action='store_true')
     parser.add_argument('--triforcehud', default='hide_goal', const='hide_goal', nargs='?',
                         choices=['normal', 'hide_goal', 'hide_required', 'hide_both'],
                         help='''\
@@ -128,6 +85,9 @@ def get_argparser() -> argparse.ArgumentParser:
     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'])
@@ -147,23 +107,10 @@ def get_argparser() -> argparse.ArgumentParser:
                              Alternatively, can be a ALttP Rom patched with a Link
                              sprite that will be extracted.
                              ''')
-    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('--names', default='', type=str)
     parser.add_argument('--update_sprites', action='store_true', help='Update Sprite Database, then exit.')
-    return parser
-
-
-def main():
-    parser = get_argparser()
-    args = parser.parse_args(namespace=get_adjuster_settings_no_defaults(GAME_ALTTP))
-    
+    args = parser.parse_args()
+    args.music = not args.disablemusic
     # set up logger
     loglevel = {'error': logging.ERROR, 'info': logging.INFO, 'warning': logging.WARNING, 'debug': logging.DEBUG}[
         args.loglevel]
@@ -179,13 +126,6 @@ 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):
@@ -225,7 +165,7 @@ def adjust(args):
         world = getattr(args, "world")
 
     apply_rom_settings(rom, args.heartbeep, args.heartcolor, args.quickswap, args.menuspeed, args.music,
-                       args.sprite, args.oof, palettes_options, reduceflashing=args.reduceflashing or racerom, world=world,
+                       args.sprite, 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)
@@ -240,7 +180,7 @@ def adjustGUI():
     from tkinter import Tk, LEFT, BOTTOM, TOP, \
         StringVar, Frame, Label, X, Entry, Button, filedialog, messagebox, ttk
     from argparse import Namespace
-    from Utils import __version__ as MWVersion
+    from Main import __version__ as MWVersion
     adjustWindow = Tk()
     adjustWindow.wm_title("Archipelago %s LttP Adjuster" % MWVersion)
     set_icon(adjustWindow)
@@ -287,7 +227,6 @@ 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)
@@ -326,7 +265,6 @@ 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")
 
@@ -543,38 +481,11 @@ 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: ')
@@ -602,8 +513,32 @@ 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)
@@ -663,50 +598,12 @@ 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=6, column=1, sticky=E)
+    menuspeedFrame.grid(row=1, column=1, sticky=E)
     menuspeedLabel = Label(menuspeedFrame, text='Menu speed')
     menuspeedLabel.pack(side=LEFT)
     vars.menuspeedVar = StringVar()
@@ -1004,7 +901,6 @@ 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)
 
@@ -1160,6 +1056,7 @@ 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

@@ -1,376 +0,0 @@
-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,78 +1,82 @@
 import collections
-import concurrent.futures
 import logging
 import os
+import time
+import zlib
+import concurrent.futures
 import pickle
 import tempfile
-import time
 import zipfile
-import zlib
-from typing import Dict, List, Optional, Set, Tuple, Union
+from typing import Dict, List, Tuple, Optional, Set
 
+from BaseClasses import Item, MultiWorld, CollectionState, Region, LocationProgressType, Location
 import worlds
-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.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 worlds import AutoWorld
-from worlds.generic.Rules import exclusion_rules, locality_rules
 
-__all__ = ["main"]
+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"
+)
 
 
 def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = None):
     if not baked_server_options:
-        baked_server_options = get_settings().server_options.as_dict()
-    assert isinstance(baked_server_options, dict)
+        baked_server_options = get_options()["server_options"]
     if args.outputpath:
         os.makedirs(args.outputpath, exist_ok=True)
         output_path.cached_path = args.outputpath
 
     start = time.perf_counter()
-    # initialize the multiworld
-    multiworld = MultiWorld(args.multi)
+    # initialize the world
+    world = MultiWorld(args.multi)
 
     logger = logging.getLogger()
-    multiworld.set_seed(seed, args.race, str(args.outputname) if args.outputname else None)
-    multiworld.plando_options = args.plando_options
+    world.set_seed(seed, args.race, str(args.outputname) if args.outputname else None)
+    world.plando_options = args.plando_options
 
-    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.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.set_options(args)
-    multiworld.set_item_links()
-    multiworld.state = CollectionState(multiworld)
-    logger.info('Archipelago Version %s  -  Seed: %s\n', __version__, multiworld.seed)
+    world.set_options(args)
+    world.set_item_links()
+    world.state = CollectionState(world)
+    logger.info('Archipelago Version %s  -  Seed: %s\n', __version__, world.seed)
 
     logger.info(f"Found {len(AutoWorld.AutoWorldRegister.world_types)} World Types:")
     longest_name = max(len(text) for text in AutoWorld.AutoWorldRegister.world_types)
@@ -101,117 +105,58 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
 
     del item_digits, location_digits, item_count, location_count
 
-    # This assertion method should not be necessary to run if we are not outputting any multidata.
-    if not args.skip_output:
-        AutoWorld.call_stage(multiworld, "assert_generate")
+    AutoWorld.call_stage(world, "assert_generate")
 
-    AutoWorld.call_all(multiworld, "generate_early")
+    AutoWorld.call_all(world, "generate_early")
 
     logger.info('')
 
-    for player in multiworld.player_ids:
-        for item_name, count in multiworld.worlds[player].options.start_inventory.value.items():
+    for player in world.player_ids:
+        for item_name, count in world.start_inventory[player].value.items():
             for _ in range(count):
-                multiworld.push_precollected(multiworld.create_item(item_name, player))
+                world.push_precollected(world.create_item(item_name, player))
 
-        for item_name, count in getattr(multiworld.worlds[player].options,
-                                        "start_inventory_from_pool",
-                                        StartInventoryPool({})).value.items():
-            for _ 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 World.')
+    AutoWorld.call_all(world, "create_regions")
 
     logger.info('Creating Items.')
-    AutoWorld.call_all(multiworld, "create_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()
 
     logger.info('Calculating Access Rules.')
 
-    for player in multiworld.player_ids:
+    for player in world.player_ids:
         # items can't be both local and non-local, prefer local
-        multiworld.worlds[player].options.non_local_items.value -= multiworld.worlds[player].options.local_items.value
-        multiworld.worlds[player].options.non_local_items.value -= set(multiworld.local_early_items[player])
+        world.non_local_items[player].value -= world.local_items[player].value
+        world.non_local_items[player].value -= set(world.local_early_items[player])
 
-    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)
+    if world.players > 1:
+        locality_rules(world)
     else:
-        multiworld.worlds[1].options.non_local_items.value = set()
-        multiworld.worlds[1].options.local_items.value = set()
-    
-    AutoWorld.call_all(multiworld, "generate_basic")
+        world.non_local_items[1].value = set()
+        world.local_items[1].value = set()
 
-    # 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)
+    AutoWorld.call_all(world, "set_rules")
 
-        # 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
+    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")
 
     # temporary home for item links, should be moved out of Main
-    for group_id, group in multiworld.groups.items():
+    for group_id, group in world.groups.items():
         def find_common_pool(players: Set[int], shared_pool: Set[str]) -> Tuple[
             Optional[Dict[int, Dict[str, int]]], Optional[Dict[str, int]]
         ]:
             classifications: Dict[str, int] = collections.defaultdict(int)
             counters = {player: {name: 0 for name in shared_pool} for player in players}
-            for item in multiworld.itempool:
+            for item in world.itempool:
                 if item.player in counters and item.name in shared_pool:
                     counters[item.player][item.name] += 1
                     classifications[item.name] |= item.classification
@@ -246,13 +191,13 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
                 new_item.classification |= classifications[item_name]
                 new_itempool.append(new_item)
 
-        region = Region("Menu", group_id, multiworld, "ItemLink")
-        multiworld.regions.append(region)
-        locations = region.locations
-        for item in multiworld.itempool:
+        region = Region("Menu", group_id, world, "ItemLink")
+        world.regions.append(region)
+        locations = region.locations = []
+        for item in world.itempool:
             count = common_item_count.get(item.player, {}).get(item.name, 0)
             if count:
-                loc = Location(group_id, f"Item Link: {item.name} -> {multiworld.player_name[item.player]} {count}",
+                loc = Location(group_id, f"Item Link: {item.name} -> {world.player_name[item.player]} {count}",
                                None, region)
                 loc.access_rule = lambda state, item_name = item.name, group_id_ = group_id, count_ = count: \
                     state.has(item_name, group_id_, count_)
@@ -263,10 +208,10 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
             else:
                 new_itempool.append(item)
 
-        itemcount = len(multiworld.itempool)
-        multiworld.itempool = new_itempool
+        itemcount = len(world.itempool)
+        world.itempool = new_itempool
 
-        while itemcount > len(multiworld.itempool):
+        while itemcount > len(world.itempool):
             items_to_add = []
             for player in group["players"]:
                 if group["link_replacement"]:
@@ -274,64 +219,88 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
                 else:
                     item_player = player
                 if group["replacement_items"][player]:
-                    items_to_add.append(AutoWorld.call_single(multiworld, "create_item", item_player,
+                    items_to_add.append(AutoWorld.call_single(world, "create_item", item_player,
                                                                 group["replacement_items"][player]))
                 else:
-                    items_to_add.append(AutoWorld.call_single(multiworld, "create_filler", item_player))
-            multiworld.random.shuffle(items_to_add)
-            multiworld.itempool.extend(items_to_add[:itemcount - len(multiworld.itempool)])
+                    items_to_add.append(AutoWorld.call_single(world, "create_filler", item_player))
+            world.random.shuffle(items_to_add)
+            world.itempool.extend(items_to_add[:itemcount - len(world.itempool)])
 
-    if any(multiworld.item_links.values()):
-        multiworld._all_state = None
+    if any(world.item_links.values()):
+        world._recache()
+        world._all_state = None
 
-    logger.info("Running Item Plando.")
+    logger.info("Running Item Plando")
 
-    distribute_planned(multiworld)
+    distribute_planned(world)
 
     logger.info('Running Pre Main Fill.')
 
-    AutoWorld.call_all(multiworld, "pre_fill")
+    AutoWorld.call_all(world, "pre_fill")
 
-    logger.info(f'Filling the multiworld with {len(multiworld.itempool)} items.')
+    logger.info(f'Filling the world with {len(world.itempool)} items.')
 
-    if multiworld.algorithm == 'flood':
-        flood_items(multiworld)  # different algo, biased towards early game progress items
-    elif multiworld.algorithm == 'balanced':
-        distribute_items_restrictive(multiworld)
+    if world.algorithm == 'flood':
+        flood_items(world)  # different algo, biased towards early game progress items
+    elif world.algorithm == 'balanced':
+        distribute_items_restrictive(world)
 
-    AutoWorld.call_all(multiworld, 'post_fill')
+    AutoWorld.call_all(world, 'post_fill')
 
-    if multiworld.players > 1 and not args.skip_prog_balancing:
-        balance_multiworld_progression(multiworld)
-    else:
-        logger.info("Progression balancing skipped.")
-
-    # we're about to output using multithreading, so we're removing the global random state to prevent accidental use
-    multiworld.random.passthrough = False
-
-    if args.skip_output:
-        logger.info('Done. Skipped output/spoiler generation. Total Time: %s', time.perf_counter() - start)
-        return multiworld
+    if world.players > 1:
+        balance_multiworld_progression(world)
 
     logger.info(f'Beginning output...')
-    outfilebase = 'AP_' + multiworld.seed_name
+
+    # we're about to output using multithreading, so we're removing the global random state to prevent accidental use
+    world.random.passthrough = False
+
+    outfilebase = 'AP_' + world.seed_name
 
     output = tempfile.TemporaryDirectory()
     with output as temp_dir:
-        output_players = [player for player in multiworld.player_ids if AutoWorld.World.generate_output.__code__
-                          is not multiworld.worlds[player].generate_output.__code__]
-        with concurrent.futures.ThreadPoolExecutor(len(output_players) + 2) as pool:
-            check_accessibility_task = pool.submit(multiworld.fulfills_accessibility)
+        with concurrent.futures.ThreadPoolExecutor(world.players + 2) as pool:
+            check_accessibility_task = pool.submit(world.fulfills_accessibility)
 
-            output_file_futures = [pool.submit(AutoWorld.call_stage, multiworld, "generate_output", temp_dir)]
-            for player in output_players:
+            output_file_futures = [pool.submit(AutoWorld.call_stage, world, "generate_output", temp_dir)]
+            for player in world.player_ids:
                 # skip starting a thread for methods that say "pass".
-                output_file_futures.append(
-                    pool.submit(AutoWorld.call_single, multiworld, "generate_output", player, temp_dir))
+                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))
 
             # collect ER hint info
             er_hint_data: Dict[int, Dict[int, str]] = {}
-            AutoWorld.call_all(multiworld, 'extend_hint_information', er_hint_data)
+            AutoWorld.call_all(world, 'extend_hint_information', er_hint_data)
+
+            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)
 
             def write_multidata():
                 import NetUtils
@@ -340,67 +309,65 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
                 games = {}
                 minimum_versions = {"server": AutoWorld.World.required_server_version, "clients": client_versions}
                 slot_info = {}
-                names = [[name for player, name in sorted(multiworld.player_name.items())]]
-                for slot in multiworld.player_ids:
-                    player_world: AutoWorld.World = multiworld.worlds[slot]
+                names = [[name for player, name in sorted(world.player_name.items())]]
+                for slot in world.player_ids:
+                    player_world: AutoWorld.World = world.worlds[slot]
                     minimum_versions["server"] = max(minimum_versions["server"], player_world.required_server_version)
                     client_versions[slot] = player_world.required_client_version
-                    games[slot] = multiworld.game[slot]
-                    slot_info[slot] = NetUtils.NetworkSlot(names[0][slot - 1], multiworld.game[slot],
-                                                           multiworld.player_types[slot])
-                for slot, group in multiworld.groups.items():
-                    games[slot] = multiworld.game[slot]
-                    slot_info[slot] = NetUtils.NetworkSlot(group["name"], multiworld.game[slot], multiworld.player_types[slot],
+                    games[slot] = world.game[slot]
+                    slot_info[slot] = NetUtils.NetworkSlot(names[0][slot - 1], world.game[slot],
+                                                           world.player_types[slot], bool(world.allow_collect[slot].value))
+                for slot, group in world.groups.items():
+                    games[slot] = world.game[slot]
+                    slot_info[slot] = NetUtils.NetworkSlot(group["name"], world.game[slot], world.player_types[slot],
                                                            group_members=sorted(group["players"]))
                 precollected_items = {player: [item.code for item in world_precollected if type(item.code) == int]
-                                      for player, world_precollected in multiworld.precollected_items.items()}
-                precollected_hints = {player: set() for player in range(1, multiworld.players + 1 + len(multiworld.groups))}
+                                      for player, world_precollected in world.precollected_items.items()}
+                precollected_hints = {player: set() for player in range(1, world.players + 1 + len(world.groups))}
 
-                for slot in multiworld.player_ids:
-                    slot_data[slot] = multiworld.worlds[slot].fill_slot_data()
+                for slot in world.player_ids:
+                    slot_data[slot] = world.worlds[slot].fill_slot_data()
 
                 def precollect_hint(location):
                     entrance = er_hint_data.get(location.player, {}).get(location.address, "")
                     hint = NetUtils.Hint(location.item.player, location.player, location.address,
                                          location.item.code, False, entrance, location.item.flags)
                     precollected_hints[location.player].add(hint)
-                    if location.item.player not in multiworld.groups:
+                    if location.item.player not in world.groups:
                         precollected_hints[location.item.player].add(hint)
                     else:
-                        for player in multiworld.groups[location.item.player]["players"]:
+                        for player in world.groups[location.item.player]["players"]:
                             precollected_hints[player].add(hint)
 
-                locations_data: Dict[int, Dict[int, Tuple[int, int, int]]] = {player: {} for player in multiworld.player_ids}
-                for location in multiworld.get_filled_locations():
+                locations_data: Dict[int, Dict[int, Tuple[int, int, int]]] = {player: {} for player in world.player_ids}
+                for location in world.get_filled_locations():
                     if type(location.address) == int:
                         assert location.item.code is not None, "item code None should be event, " \
                                                                "location.address should then also be None. Location: " \
                                                                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 multiworld.worlds[location.player].options.start_location_hints:
+                        if location.name in world.start_location_hints[location.player]:
                             precollect_hint(location)
-                        elif location.item.name in multiworld.worlds[location.item.player].options.start_hints:
+                        elif location.item.name in world.start_hints[location.item.player]:
                             precollect_hint(location)
-                        elif any([location.item.name in multiworld.worlds[player].options.start_hints
-                                  for player in multiworld.groups.get(location.item.player, {}).get("players", [])]):
+                        elif any([location.item.name in world.start_hints[player]
+                                  for player in world.groups.get(location.item.player, {}).get("players", [])]):
                             precollect_hint(location)
 
-                # embedded data package
-                data_package = {
-                    game_world.game: worlds.network_data_package["games"][game_world.game]
-                    for game_world in multiworld.worlds.values()
-                }
-
-                checks_in_area: Dict[int, Dict[str, Union[int, List[int]]]] = {}
+                # custom datapackage
+                datapackage = {}
+                for game_world in world.worlds.values():
+                    if game_world.data_version == 0 and game_world.game not in datapackage:
+                        datapackage[game_world.game] = worlds.network_data_package["games"][game_world.game]
+                        datapackage[game_world.game]["item_name_groups"] = game_world.item_name_groups
+                        datapackage[game_world.game]["location_name_groups"] = game_world.location_name_groups
 
                 multidata = {
                     "slot_data": slot_data,
                     "slot_info": slot_info,
-                    "connect_names": {name: (0, player) for player, name in multiworld.player_name.items()},
+                    "names": names,  # TODO: remove after 0.3.9
+                    "connect_names": {name: (0, player) for player, name in world.player_name.items()},
                     "locations": locations_data,
                     "checks_in_area": checks_in_area,
                     "server_options": baked_server_options,
@@ -410,10 +377,10 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
                     "version": tuple(version_tuple),
                     "tags": ["AP"],
                     "minimum_versions": minimum_versions,
-                    "seed_name": multiworld.seed_name,
-                    "datapackage": data_package,
+                    "seed_name": world.seed_name,
+                    "datapackage": datapackage,
                 }
-                AutoWorld.call_all(multiworld, "modify_multidata", multidata)
+                AutoWorld.call_all(world, "modify_multidata", multidata)
 
                 multidata = zlib.compress(pickle.dumps(multidata), 9)
 
@@ -421,14 +388,15 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
                     f.write(bytes([3]))  # version of format
                     f.write(multidata)
 
-            output_file_futures.append(pool.submit(write_multidata))
+            multidata_task = pool.submit(write_multidata)
             if not check_accessibility_task.result():
-                if not multiworld.can_beat_game():
+                if not world.can_beat_game():
                     raise Exception("Game appears as unbeatable. Aborting.")
                 else:
                     logger.warning("Location Accessibility requirements not fulfilled.")
 
             # 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)}).')
@@ -436,12 +404,12 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
 
         if args.spoiler > 1:
             logger.info('Calculating playthrough.')
-            multiworld.spoiler.create_playthrough(create_paths=args.spoiler > 2)
+            world.spoiler.create_playthrough(create_paths=args.spoiler > 2)
 
         if args.spoiler:
-            multiworld.spoiler.to_file(os.path.join(temp_dir, '%s_Spoiler.txt' % outfilebase))
+            world.spoiler.to_file(os.path.join(temp_dir, '%s_Spoiler.txt' % outfilebase))
 
-        zipfilename = output_path(f"AP_{multiworld.seed_name}.zip")
+        zipfilename = output_path(f"AP_{world.seed_name}.zip")
         logger.info(f"Creating final archive at {zipfilename}")
         with zipfile.ZipFile(zipfilename, mode="w", compression=zipfile.ZIP_DEFLATED,
                              compresslevel=9) as zf:
@@ -449,4 +417,4 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
                 zf.write(file.path, arcname=file.name)
 
     logger.info('Done. Enjoy. Total Time: %s', time.perf_counter() - start)
-    return multiworld
+    return world

MinecraftClient.py

@@ -77,34 +77,49 @@ def read_apmc_file(apmc_file):
         return json.loads(b64decode(f.read()))
 
 
-def update_mod(forge_dir, url: str):
+def update_mod(forge_dir, minecraft_version: str, get_prereleases=False):
     """Check mod version, download new mod from GitHub releases page if needed. """
     ap_randomizer = find_ap_randomizer_jar(forge_dir)
-    os.path.basename(url)
-    if ap_randomizer is not None:
-        logging.info(f"Your current mod is {ap_randomizer}.")
-    else:
-        logging.info(f"You do not have the AP randomizer mod installed.")
 
-    if ap_randomizer != os.path.basename(url):
-        logging.info(f"A new release of the Minecraft AP randomizer mod was found: "
-                     f"{os.path.basename(url)}")
-        if prompt_yes_no("Would you like to update?"):
-            old_ap_mod = os.path.join(forge_dir, 'mods', ap_randomizer) if ap_randomizer is not None else None
-            new_ap_mod = os.path.join(forge_dir, 'mods', os.path.basename(url))
-            logging.info("Downloading AP randomizer mod. This may take a moment...")
-            apmod_resp = requests.get(url)
-            if apmod_resp.status_code == 200:
-                with open(new_ap_mod, 'wb') as f:
-                    f.write(apmod_resp.content)
-                    logging.info(f"Wrote new mod file to {new_ap_mod}")
-                if old_ap_mod is not None:
-                    os.remove(old_ap_mod)
-                    logging.info(f"Removed old mod file from {old_ap_mod}")
-            else:
-                logging.error(f"Error retrieving the randomizer mod (status code {apmod_resp.status_code}).")
-                logging.error(f"Please report this issue on the Archipelago Discord server.")
-                sys.exit(1)
+    client_releases_endpoint = "https://api.github.com/repos/KonoTyran/Minecraft_AP_Randomizer/releases"
+    resp = requests.get(client_releases_endpoint)
+    if resp.status_code == 200:  # OK
+        try:
+            latest_release = next(filter(lambda release: (not release['prerelease'] or get_prereleases) and
+                (minecraft_version in release['assets'][0]['name']),
+                resp.json()))
+            if ap_randomizer != latest_release['assets'][0]['name']:
+                logging.info(f"A new release of the Minecraft AP randomizer mod was found: "
+                             f"{latest_release['assets'][0]['name']}")
+                if ap_randomizer is not None:
+                    logging.info(f"Your current mod is {ap_randomizer}.")
+                else:
+                    logging.info(f"You do not have the AP randomizer mod installed.")
+                if prompt_yes_no("Would you like to update?"):
+                    old_ap_mod = os.path.join(forge_dir, 'mods', ap_randomizer) if ap_randomizer is not None else None
+                    new_ap_mod = os.path.join(forge_dir, 'mods', latest_release['assets'][0]['name'])
+                    logging.info("Downloading AP randomizer mod. This may take a moment...")
+                    apmod_resp = requests.get(latest_release['assets'][0]['browser_download_url'])
+                    if apmod_resp.status_code == 200: 
+                        with open(new_ap_mod, 'wb') as f:
+                            f.write(apmod_resp.content)
+                            logging.info(f"Wrote new mod file to {new_ap_mod}")
+                        if old_ap_mod is not None:
+                            os.remove(old_ap_mod)
+                            logging.info(f"Removed old mod file from {old_ap_mod}")
+                    else:
+                        logging.error(f"Error retrieving the randomizer mod (status code {apmod_resp.status_code}).")
+                        logging.error(f"Please report this issue on the Archipelago Discord server.")
+                        sys.exit(1)
+        except StopIteration:
+            logging.warning(f"No compatible mod version found for {minecraft_version}.")
+            if not prompt_yes_no("Run server anyway?"):
+                sys.exit(0)
+    else:
+        logging.error(f"Error checking for randomizer mod updates (status code {resp.status_code}).")
+        logging.error(f"If this was not expected, please report this issue on the Archipelago Discord server.")
+        if not prompt_yes_no("Continue anyways?"):
+            sys.exit(0)
 
 
 def check_eula(forge_dir):
@@ -249,13 +264,8 @@ def get_minecraft_versions(version, release_channel="release"):
             return next(filter(lambda entry: entry["version"] == version, data[release_channel]))
         else:
             return resp.json()[release_channel][0]
-    except (StopIteration, KeyError):
-        logging.error(f"No compatible mod version found for client version {version} on \"{release_channel}\" channel.")
-        if release_channel != "release":
-            logging.error("Consider switching \"release_channel\" to \"release\" in your Host.yaml file")
-        else:
-            logging.error("No suitable mod found on the \"release\" channel. Please Contact us on discord to report this error.")
-        sys.exit(0)
+    except StopIteration:
+        logging.error(f"No compatible mod version found for client version {version}.")
 
 
 def is_correct_forge(forge_dir) -> bool:
@@ -276,8 +286,6 @@ if __name__ == '__main__':
                         help="specify java version.")
     parser.add_argument('--forge', '-f', metavar='1.18.2-40.1.0', dest='forge', type=str, default=False, action='store',
                         help="specify forge version. (Minecraft Version-Forge Version)")
-    parser.add_argument('--version', '-v', metavar='9', dest='data_version', type=int, action='store',
-                        help="specify Mod data version to download.")
 
     args = parser.parse_args()
     apmc_file = os.path.abspath(args.apmc_file) if args.apmc_file else None
@@ -288,22 +296,21 @@ if __name__ == '__main__':
     options = Utils.get_options()
     channel = args.channel or options["minecraft_options"]["release_channel"]
     apmc_data = None
-    data_version = args.data_version or None
+    data_version = None
 
     if apmc_file is None and not args.install:
         apmc_file = Utils.open_filename('Select APMC file', (('APMC File', ('.apmc',)),))
 
-    if apmc_file is not None and data_version is None:
+    if apmc_file is not None:
         apmc_data = read_apmc_file(apmc_file)
         data_version = apmc_data.get('client_version', '')
 
     versions = get_minecraft_versions(data_version, channel)
 
-    forge_dir = options["minecraft_options"]["forge_directory"]
+    forge_dir = Utils.user_path(options["minecraft_options"]["forge_directory"])
     max_heap = options["minecraft_options"]["max_heap_size"]
     forge_version = args.forge or versions["forge"]
     java_version = args.java or versions["java"]
-    mod_url = versions["url"]
     java_dir = find_jdk_dir(java_version)
 
     if args.install:
@@ -337,7 +344,7 @@ if __name__ == '__main__':
     if not max_heap_re.match(max_heap):
         raise Exception(f"Max heap size {max_heap} in incorrect format. Use a number followed by M or G, e.g. 512M or 2G.")
 
-    update_mod(forge_dir, mod_url)
+    update_mod(forge_dir, f"MC{forge_version.split('-')[0]}", channel != "release")
     replace_apmc_files(forge_dir, apmc_file)
     check_eula(forge_dir)
     server_process = run_forge_server(forge_dir, java_version, max_heap)

ModuleUpdate.py

@@ -1,32 +1,16 @@
 import os
 import sys
 import subprocess
-import multiprocessing
+import pkg_resources
 import warnings
 
+local_dir = os.path.dirname(__file__)
+requirements_files = {os.path.join(local_dir, 'requirements.txt')}
 
 if sys.version_info < (3, 8, 6):
     raise RuntimeError("Incompatible Python Version. 3.8.7+ is supported.")
 
-# don't run update if environment is frozen/compiled or if not the parent process (skip in subprocess)
-_skip_update = bool(getattr(sys, "frozen", False) or multiprocessing.parent_process())
-update_ran = _skip_update
-
-
-class RequirementsSet(set):
-    def add(self, e):
-        global update_ran
-        update_ran &= _skip_update
-        super().add(e)
-
-    def update(self, *s):
-        global update_ran
-        update_ran &= _skip_update
-        super().update(*s)
-
-
-local_dir = os.path.dirname(__file__)
-requirements_files = RequirementsSet((os.path.join(local_dir, 'requirements.txt'),))
+update_ran = getattr(sys, "frozen", False)  # don't run update if environment is frozen/compiled
 
 if not update_ran:
     for entry in os.scandir(os.path.join(local_dir, "worlds")):
@@ -38,67 +22,26 @@ if not update_ran:
                     requirements_files.add(req_file)
 
 
-def check_pip():
-    # detect if pip is available
-    try:
-        import pip  # noqa: F401
-    except ImportError:
-        raise RuntimeError("pip not available. Please install pip.")
-
-
-def confirm(msg: str):
-    try:
-        input(f"\n{msg}")
-    except KeyboardInterrupt:
-        print("\nAborting")
-        sys.exit(1)
-
-
 def update_command():
-    check_pip()
     for file in requirements_files:
-        subprocess.call([sys.executable, "-m", "pip", "install", "-r", file, "--upgrade"])
+        subprocess.call([sys.executable, '-m', 'pip', 'install', '-r', file, '--upgrade'])
 
 
-def install_pkg_resources(yes=False):
-    try:
-        import pkg_resources  # noqa: F401
-    except ImportError:
-        check_pip()
-        if not yes:
-            confirm("pkg_resources not found, press enter to install it")
-        subprocess.call([sys.executable, "-m", "pip", "install", "--upgrade", "setuptools"])
-
-
-def update(yes: bool = False, force: bool = False) -> None:
+def update(yes=False, force=False):
     global update_ran
     if not update_ran:
         update_ran = True
-
         if force:
             update_command()
             return
-
-        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.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 not line or line[0] == "#":
+                        continue  # ignore comments
                     if line.startswith(("https://", "git+https://")):
                         # extract name and version for url
                         rest = line.split('/')[-1]
@@ -109,7 +52,7 @@ def update(yes: bool = False, force: bool = False) -> None:
                             egg = egg.split(";", 1)[0].rstrip()
                             if any(compare in egg for compare in ("==", ">=", ">", "<", "<=", "!=")):
                                 warnings.warn(f"Specifying version as #egg={egg} will become unavailable in pip 25.0. "
-                                              "Use name @ url#version instead.", DeprecationWarning)
+                                               "Use name @ url#version instead.", DeprecationWarning)
                                 line = egg
                         else:
                             egg = ""
@@ -136,7 +79,11 @@ def update(yes: bool = False, force: bool = False) -> None:
                             if not yes:
                                 import traceback
                                 traceback.print_exc()
-                                confirm(f"Requirement {requirement} is not satisfied, press enter to install it")
+                                try:
+                                    input(f"\nRequirement {requirement} is not satisfied, press enter to install it")
+                                except KeyboardInterrupt:
+                                    print("\nAborting")
+                                    sys.exit(1)
                             update_command()
                             return
 

MultiServer.py

@@ -2,23 +2,22 @@ from __future__ import annotations
 
 import argparse
 import asyncio
-import collections
 import copy
-import datetime
 import functools
-import hashlib
-import inspect
-import itertools
 import logging
-import math
-import operator
-import pickle
-import random
-import threading
-import time
-import typing
-import weakref
 import zlib
+import collections
+import typing
+import inspect
+import weakref
+import datetime
+import threading
+import random
+import pickle
+import itertools
+import time
+import operator
+import hashlib
 
 import ModuleUpdate
 
@@ -39,7 +38,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, LocationStore
+    SlotType
 
 min_client_version = Version(0, 1, 6)
 colorama.init()
@@ -68,25 +67,21 @@ def update_dict(dictionary, entries):
 
 # functions callable on storable data on the server by clients
 modify_functions = {
-    # 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,
+    "replace": lambda old, new: new,
+    "default": lambda old, new: old,
+    "pow": operator.pow,
     # 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,
@@ -157,17 +152,14 @@ class Context:
                       "compatibility": int}
     # team -> slot id -> list of clients authenticated to slot.
     clients: typing.Dict[int, typing.Dict[int, typing.List[Client]]]
-    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]
+    locations: typing.Dict[int, typing.Dict[int, 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]]]
     location_names: typing.Dict[int, str] = Utils.KeyedDefaultDict(lambda code: f'Unknown location (ID:{code})')
@@ -194,6 +186,8 @@ 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
@@ -228,7 +222,8 @@ class Context:
         self.save_dirty = False
         self.tags = ['AP']
         self.games: typing.Dict[int, str] = {}
-        self.minimum_client_versions: typing.Dict[int, Version] = {}
+        self.allow_collect: typing.Dict[int, bool] = {}
+        self.minimum_client_versions: typing.Dict[int, Utils.Version] = {}
         self.seed_name = ""
         self.groups = {}
         self.group_collected: typing.Dict[int, typing.Set[int]] = {}
@@ -239,7 +234,6 @@ class Context:
 
         # init empty to satisfy linter, I suppose
         self.gamespackage = {}
-        self.checksums = {}
         self.item_name_groups = {}
         self.location_name_groups = {}
         self.all_item_and_group_names = {}
@@ -248,7 +242,7 @@ class Context:
 
         self._load_game_data()
 
-    # Data package retrieval
+    # Datapackage retrieval
     def _load_game_data(self):
         import worlds
         self.gamespackage = worlds.network_data_package["games"]
@@ -262,8 +256,6 @@ class Context:
 
     def _init_game_data(self):
         for game_name, game_package in self.gamespackage.items():
-            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():
@@ -271,7 +263,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.get(game_name, []))
+                set(game_package["location_name_to_id"]) | set(self.location_name_groups[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
@@ -289,7 +281,6 @@ 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}")
@@ -303,7 +294,6 @@ 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}")
@@ -318,7 +308,6 @@ 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}")
@@ -363,6 +352,7 @@ class Context:
                                     for text in texts]))
 
     # loading
+
     def load(self, multidatapath: str, use_embedded_server_options: bool = False):
         if multidatapath.lower().endswith(".zip"):
             import zipfile
@@ -377,7 +367,7 @@ class Context:
             with open(multidatapath, 'rb') as f:
                 data = f.read()
 
-        self._load(self.decompress(data), {}, use_embedded_server_options)
+        self._load(self.decompress(data), use_embedded_server_options)
         self.data_filename = multidatapath
 
     @staticmethod
@@ -387,24 +377,24 @@ class Context:
             raise Utils.VersionException("Incompatible multidata.")
         return restricted_loads(zlib.decompress(data[1:]))
 
-    def _load(self, decoded_obj: dict, game_data_packages: typing.Dict[str, typing.Any],
-              use_embedded_server_options: bool):
-
+    def _load(self, decoded_obj: dict, use_embedded_server_options: bool):
         self.read_data = {}
         mdata_ver = decoded_obj["minimum_versions"]["server"]
-        if mdata_ver > version_tuple:
+        if mdata_ver > Utils.version_tuple:
             raise RuntimeError(f"Supplied Multidata (.archipelago) requires a server of at least version {mdata_ver},"
-                               f"however this server is of version {version_tuple}")
-        self.generator_version = Version(*decoded_obj["version"])
+                               f"however this server is of version {Utils.version_tuple}")
         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(Version(*version), min_client_version)
+            self.minimum_client_versions[player] = max(Utils.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()}
         self.groups = {slot: slot_info.group_members for slot, slot_info in self.slot_info.items()
                        if slot_info.type == SlotType.group}
+        # TODO: around 0.4.2 or so, remove the if/else backwards compatibility check.
+        self.allow_collect = {slot: slot_info.allow_collect if type(slot_info.allow_collect) is bool else True
+                              for slot, slot_info in self.slot_info.items()}
 
         self.clients = {0: {}}
         slot_info: NetworkSlot
@@ -417,13 +407,11 @@ 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 = LocationStore(decoded_obj.pop("locations"))  # pre-emptively free memory
+        self.locations = decoded_obj['locations']
         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
@@ -447,17 +435,14 @@ class Context:
             server_options = decoded_obj.get("server_options", {})
             self._set_options(server_options)
 
-        # embedded data package
+        # custom datapackage
         for game_name, data in decoded_obj.get("datapackage", {}).items():
-            if game_name in game_data_packages:
-                data = game_data_packages[game_name]
-            logging.info(f"Loading embedded data package for game {game_name}")
+            logging.info(f"Loading custom datapackage for game {game_name}")
             self.gamespackage[game_name] = data
             self.item_name_groups[game_name] = data["item_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
+            self.location_name_groups[game_name] = data["location_name_groups"]
+            del data["item_name_groups"]  # remove from datapackage, 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]
@@ -553,7 +538,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,
-                             "release_mode": self.release_mode,
+                             "forfeit_mode": self.release_mode, "release_mode": self.release_mode,  # TODO remove forfeit_mode around 0.4
                              "remaining_mode": self.remaining_mode, "collect_mode": self.collect_mode,
                              "item_cheat": self.item_cheat, "compatibility": self.compatibility}
 
@@ -586,7 +571,7 @@ class Context:
             self.location_check_points = savedata["game_options"]["location_check_points"]
             self.server_password = savedata["game_options"]["server_password"]
             self.password = savedata["game_options"]["password"]
-            self.release_mode = savedata["game_options"]["release_mode"]
+            self.release_mode = savedata["game_options"].get("release_mode", savedata["game_options"].get("forfeit_mode", "goal"))
             self.remaining_mode = savedata["game_options"]["remaining_mode"]
             self.collect_mode = savedata["game_options"]["collect_mode"]
             self.item_cheat = savedata["game_options"]["item_cheat"]
@@ -606,7 +591,7 @@ class Context:
 
     def get_hint_cost(self, slot):
         if self.hint_cost:
-            return max(1, int(self.hint_cost * 0.01 * len(self.locations[slot])))
+            return max(0, int(self.hint_cost * 0.01 * len(self.locations[slot])))
         return 0
 
     def recheck_hints(self, team: typing.Optional[int] = None, slot: typing.Optional[int] = None):
@@ -631,6 +616,8 @@ class Context:
 
     def _set_options(self, server_options: dict):
         for key, value in server_options.items():
+            if key == "forfeit_mode":
+                key = "release_mode"
             data_type = self.simple_options.get(key, None)
             if data_type is not None:
                 if value not in {False, True, None}:  # some can be boolean OR text, such as password
@@ -654,8 +641,7 @@ class Context:
         else:
             return self.player_names[team, slot]
 
-    def notify_hints(self, team: int, hints: typing.List[NetUtils.Hint], only_new: bool = False,
-                     recipients: typing.Sequence[int] = None):
+    def notify_hints(self, team: int, hints: typing.List[NetUtils.Hint], only_new: bool = False):
         """Send and remember hints."""
         if only_new:
             hints = [hint for hint in hints if hint not in self.hints[team, hint.finding_player]]
@@ -684,13 +670,12 @@ class Context:
         for slot in new_hint_events:
             self.on_new_hint(team, slot)
         for slot, hint_data in concerns.items():
-            if recipients is None or slot in recipients:
-                clients = self.clients[team].get(slot)
-                if not clients:
-                    continue
-                client_hints = [datum[1] for datum in sorted(hint_data, key=lambda x: x[0].finding_player == slot)]
-                for client in clients:
-                    async_start(self.send_msgs(client, client_hints))
+            clients = self.clients[team].get(slot)
+            if not clients:
+                continue
+            client_hints = [datum[1] for datum in sorted(hint_data, key=lambda x: x[0].finding_player == slot)]
+            for client in clients:
+                async_start(self.send_msgs(client, client_hints))
 
     # "events"
 
@@ -705,24 +690,11 @@ 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",
@@ -767,24 +739,19 @@ async def on_client_connected(ctx: Context, client: Client):
                     NetworkPlayer(team, slot,
                                   ctx.name_aliases.get((team, slot), name), name)
                 )
-    games = {ctx.games[x] for x in range(1, len(ctx.games) + 1)}
-    games.add("Archipelago")
     await ctx.send_msgs(client, [{
         'cmd': 'RoomInfo',
         'password': bool(ctx.password),
-        'games': games,
+        'games': {ctx.games[x] for x in range(1, len(ctx.games) + 1)},
         # tags are for additional features in the communication.
         # Name them by feature or fork, as you feel is appropriate.
         'tags': ctx.tags,
-        'version': version_tuple,
-        'generator_version': ctx.generator_version,
+        'version': Utils.version_tuple,
         '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 and "checksum" in game_data},
+                                 in ctx.gamespackage.items()},
         'seed_name': ctx.seed_name,
         'time': time.time(),
     }])
@@ -792,6 +759,7 @@ 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)
@@ -804,14 +772,13 @@ async def on_client_disconnected(ctx: Context, client: Client):
 
 
 async def on_client_joined(ctx: Context, client: Client):
-    if ctx.client_game_state[client.team, client.slot] == ClientStatus.CLIENT_UNKNOWN:
-        update_client_status(ctx, client, ClientStatus.CLIENT_CONNECTED)
+    update_client_status(ctx, client, ClientStatus.CLIENT_CONNECTED)
     version_str = '.'.join(str(x) for x in client.version)
     verb = "tracking" if "Tracker" in client.tags else "playing"
     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. "
@@ -822,12 +789,11 @@ async def on_client_joined(ctx: Context, client: Client):
 
 
 async def on_client_left(ctx: Context, client: Client):
-    if len(ctx.clients[client.team][client.slot]) < 1:
-        update_client_status(ctx, client, ClientStatus.CLIENT_UNKNOWN)
-        ctx.client_connection_timers[client.team, client.slot] = datetime.datetime.now(datetime.timezone.utc)
+    update_client_status(ctx, client, ClientStatus.CLIENT_UNKNOWN)
     ctx.broadcast_text_all(
         "%s (Team #%d) has left the game" % (ctx.get_aliased_name(client.team, client.slot), client.team + 1),
         {"type": "Part", "team": client.team, "slot": client.slot})
+    ctx.client_connection_timers[client.team, client.slot] = datetime.datetime.now(datetime.timezone.utc)
 
 
 async def countdown(ctx: Context, timer: int):
@@ -921,7 +887,13 @@ 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 = ctx.locations.get_for_player(slot)
+    all_locations = collections.defaultdict(set)
+    for source_slot, location_data in ctx.locations.items():
+        if not ctx.allow_collect[source_slot]:
+            continue
+        for location_id, values in location_data.items():
+            if values[1] == slot:
+                all_locations[source_slot].add(location_id)
 
     ctx.broadcast_text_all("%s (Team #%d) has collected their items from other worlds."
                            % (ctx.player_names[(team, slot)], team + 1),
@@ -940,7 +912,11 @@ 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]:
-    return ctx.locations.get_remaining(ctx.location_checks, team, slot)
+    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)
 
 
 def send_items_to(ctx: Context, team: int, target_slot: int, *items: NetworkItem):
@@ -976,10 +952,7 @@ def register_location_checks(ctx: Context, team: int, slot: int, locations: typi
             "hint_points": get_slot_points(ctx, team, slot),
             "checked_locations": new_locations,  # send back new checks only
         }])
-        old_hints = ctx.hints[team, slot].copy()
-        ctx.recheck_hints(team, slot)
-        if old_hints != ctx.hints[team, slot]:
-            ctx.on_changed_hints(team, slot)
+
         ctx.save()
 
 
@@ -991,12 +964,13 @@ 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, 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))
+    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))
 
     return hints
 
@@ -1056,19 +1030,17 @@ def get_intended_text(input_text: str, possible_answers) -> typing.Tuple[str, bo
         if picks[0][1] == 100:
             return picks[0][0], True, "Perfect Match"
         elif picks[0][1] < 75:
-            return picks[0][0], False, f"Didn't find something that closely matches '{input_text}', " \
-                                       f"did you mean '{picks[0][0]}'? ({picks[0][1]}% sure)"
+            return picks[0][0], False, f"Didn't find something that closely matches, " \
+                                       f"did you mean {picks[0][0]}? ({picks[0][1]}% sure)"
         elif dif > 5:
             return picks[0][0], True, "Close Match"
         else:
-            return picks[0][0], False, f"Too many close matches for '{input_text}', " \
-                                       f"did you mean '{picks[0][0]}'? ({picks[0][1]}% sure)"
+            return picks[0][0], False, f"Too many close matches, did you mean {picks[0][0]}? ({picks[0][1]}% sure)"
     else:
         if picks[0][1] > 90:
             return picks[0][0], True, "Only Option Match"
         else:
-            return picks[0][0], False, f"Didn't find something that closely matches '{input_text}', " \
-                                       f"did you mean '{picks[0][0]}'? ({picks[0][1]}% sure)"
+            return picks[0][0], False, f"Did you mean {picks[0][0]}? ({picks[0][1]}% sure)"
 
 
 class CommandMeta(type):
@@ -1345,51 +1317,27 @@ class ClientMessageProcessor(CommonCommandProcessor):
                     "Sorry, !remaining requires you to have beaten the game on this server")
                 return False
 
-    @mark_raw
-    def _cmd_missing(self, filter_text="") -> bool:
-        """List all missing location checks from the server's perspective.
-        Can be given text, which will be used as filter."""
+    def _cmd_missing(self) -> bool:
+        """List all missing location checks from the server's perspective"""
 
         locations = get_missing_checks(self.ctx, self.client.team, self.client.slot)
 
         if locations:
-            names = [self.ctx.location_names[location] for location in locations]
-            if filter_text:
-                location_groups = self.ctx.location_name_groups[self.ctx.games[self.client.slot]]
-                if filter_text in location_groups:  # location group name
-                    names = [name for name in names if name in location_groups[filter_text]]
-                else:
-                    names = [name for name in names if filter_text in name]
-            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")
+            texts = [f'Missing: {self.ctx.location_names[location]}' for location in locations]
+            texts.append(f"Found {len(locations)} missing location checks")
             self.output_multiple(texts)
         else:
             self.output("No missing location checks found.")
         return True
 
-    @mark_raw
-    def _cmd_checked(self, filter_text="") -> bool:
-        """List all done location checks from the server's perspective.
-        Can be given text, which will be used as filter."""
+    def _cmd_checked(self) -> bool:
+        """List all done location checks from the server's perspective"""
 
         locations = get_checked_checks(self.ctx, self.client.team, self.client.slot)
 
         if locations:
-            names = [self.ctx.location_names[location] for location in locations]
-            if filter_text:
-                location_groups = self.ctx.location_name_groups[self.ctx.games[self.client.slot]]
-                if filter_text in location_groups:  # location group name
-                    names = [name for name in names if name in location_groups[filter_text]]
-                else:
-                    names = [name for name in names if filter_text in name]
-            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")
+            texts = [f'Checked: {self.ctx.location_names[location]}' for location in locations]
+            texts.append(f"Found {len(locations)} done location checks")
             self.output_multiple(texts)
         else:
             self.output("No done location checks found.")
@@ -1447,13 +1395,9 @@ class ClientMessageProcessor(CommonCommandProcessor):
             hints = {hint.re_check(self.ctx, self.client.team) for hint in
                      self.ctx.hints[self.client.team, self.client.slot]}
             self.ctx.hints[self.client.team, self.client.slot] = hints
-            self.ctx.notify_hints(self.client.team, list(hints), recipients=(self.client.slot,))
+            self.ctx.notify_hints(self.client.team, list(hints))
             self.output(f"A hint costs {self.ctx.get_hint_cost(self.client.slot)} points. "
                         f"You have {points_available} points.")
-            if hints and Utils.version_tuple < (0, 5, 0):
-                self.output("It was recently changed, so that the above hints are only shown to you. "
-                            "If you meant to alert another player of an above hint, "
-                            "please let them know of the content or to run !hint themselves.")
             return True
 
         elif input_text.isnumeric():
@@ -1584,11 +1528,15 @@ class ClientMessageProcessor(CommonCommandProcessor):
 
 
 def get_checked_checks(ctx: Context, team: int, slot: int) -> typing.List[int]:
-    return ctx.locations.get_checked(ctx.location_checks, team, slot)
+    return [location_id for
+            location_id in ctx.locations[slot] if
+            location_id in ctx.location_checks[team, slot]]
 
 
 def get_missing_checks(ctx: Context, team: int, slot: int) -> typing.List[int]:
-    return ctx.locations.get_missing(ctx.location_checks, team, slot)
+    return [location_id for
+            location_id in ctx.locations[slot] if
+            location_id not in ctx.location_checks[team, slot]]
 
 
 def get_client_points(ctx: Context, client: Client) -> int:
@@ -1668,8 +1616,7 @@ 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,
-                "hint_points": get_slot_points(ctx, team, slot),
+                "slot_info": ctx.slot_info
             }
             reply = [connected_packet]
             start_inventory = get_start_inventory(ctx, slot, client.remote_start_inventory)
@@ -1771,8 +1718,6 @@ 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':
@@ -1831,7 +1776,6 @@ 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:
@@ -1847,15 +1791,8 @@ def update_client_status(ctx: Context, client: Client, new_status: ClientStatus)
     if current != ClientStatus.CLIENT_GOAL:  # can't undo goal completion
         if new_status == ClientStatus.CLIENT_GOAL:
             ctx.on_goal_achieved(client)
-            # if player has yet to ever connect to the server, they will not be in client_game_state
-            if all(player in ctx.client_game_state and ctx.client_game_state[player] == ClientStatus.CLIENT_GOAL
-                   for player in ctx.player_names
-                   if player[0] == client.team and player[1] != client.slot):
-                ctx.broadcast_text_all(f"Team #{client.team + 1} has completed all of their games! Congratulations!")
 
         ctx.client_game_state[client.team, client.slot] = new_status
-        ctx.on_client_status_change(client.team, client.slot)
-        ctx.save()
 
 
 class ServerCommandProcessor(CommonCommandProcessor):
@@ -1896,7 +1833,7 @@ class ServerCommandProcessor(CommonCommandProcessor):
 
     def _cmd_exit(self) -> bool:
         """Shutdown the server"""
-        self.ctx.server.ws_server.close()
+        async_start(self.ctx.server.ws_server._close())
         if self.ctx.shutdown_task:
             self.ctx.shutdown_task.cancel()
         self.ctx.exit_event.set()
@@ -1985,7 +1922,7 @@ class ServerCommandProcessor(CommonCommandProcessor):
 
     @mark_raw
     def _cmd_forbid_release(self, player_name: str) -> bool:
-        """Disallow the specified player from using the !release command."""
+        """"Disallow the specified player from using the !release command."""
         player = self.resolve_player(player_name)
         if player:
             team, slot, name = player
@@ -2105,8 +2042,8 @@ class ServerCommandProcessor(CommonCommandProcessor):
 
             if full_name.isnumeric():
                 location, usable, response = int(full_name), True, None
-            elif game in self.ctx.all_location_and_group_names:
-                location, usable, response = get_intended_text(full_name, self.ctx.all_location_and_group_names[game])
+            elif self.ctx.location_names_for_game(game) is not None:
+                location, usable, response = get_intended_text(full_name, self.ctx.location_names_for_game(game))
             else:
                 self.output("Can't look up location for unknown game. Hint for ID instead.")
                 return False
@@ -2114,11 +2051,6 @@ class ServerCommandProcessor(CommonCommandProcessor):
             if usable:
                 if isinstance(location, int):
                     hints = collect_hint_location_id(self.ctx, team, slot, location)
-                elif game in self.ctx.location_name_groups and location in self.ctx.location_name_groups[game]:
-                    hints = []
-                    for loc_name_from_group in self.ctx.location_name_groups[game][location]:
-                        if loc_name_from_group in self.ctx.location_names_for_game(game):
-                            hints.extend(collect_hint_location_name(self.ctx, team, slot, loc_name_from_group))
                 else:
                     hints = collect_hint_location_name(self.ctx, team, slot, location)
                 if hints:
@@ -2164,15 +2096,13 @@ class ServerCommandProcessor(CommonCommandProcessor):
 async def console(ctx: Context):
     import sys
     queue = asyncio.Queue()
-    worker = Utils.stream_input(sys.stdin, queue)
+    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)
@@ -2183,7 +2113,7 @@ async def console(ctx: Context):
 
 def parse_args() -> argparse.Namespace:
     parser = argparse.ArgumentParser()
-    defaults = Utils.get_options()["server_options"].as_dict()
+    defaults = Utils.get_options()["server_options"]
     parser.add_argument('multidata', nargs="?", default=defaults["multidata"])
     parser.add_argument('--host', default=defaults["host"])
     parser.add_argument('--port', default=defaults["port"], type=int)
@@ -2242,24 +2172,25 @@ def parse_args() -> argparse.Namespace:
 
 async def auto_shutdown(ctx, to_cancel=None):
     await asyncio.sleep(ctx.auto_shutdown)
-
-    def inactivity_shutdown():
-        ctx.server.ws_server.close()
-        ctx.exit_event.set()
-        if to_cancel:
-            for task in to_cancel:
-                task.cancel()
-        logging.info("Shutting down due to inactivity.")
-
     while not ctx.exit_event.is_set():
         if not ctx.client_activity_timers.values():
-            inactivity_shutdown()
+            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.")
         else:
             newest_activity = max(ctx.client_activity_timers.values())
             delta = datetime.datetime.now(datetime.timezone.utc) - newest_activity
             seconds = ctx.auto_shutdown - delta.total_seconds()
             if seconds < 0:
-                inactivity_shutdown()
+                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.")
             else:
                 await asyncio.sleep(seconds)
 
@@ -2291,15 +2222,12 @@ 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.")
-                # when cx_Freeze'd the built-in exit is not available, so we import sys.exit instead
-                import sys
-                sys.exit(1)
+                exit(1)
             raise
 
         if not data_filename:
             logging.info("No file selected. Exiting.")
-            import sys
-            sys.exit(1)
+            exit(1)
 
     try:
         ctx.load(data_filename, args.use_embedded_options)
@@ -2312,7 +2240,8 @@ async def main(args: argparse.Namespace):
 
     ssl_context = load_server_cert(args.cert, args.cert_key) if args.cert else None
 
-    ctx.server = websockets.serve(functools.partial(server, ctx=ctx), host=ctx.host, port=ctx.port, ssl=ssl_context)
+    ctx.server = websockets.serve(functools.partial(server, ctx=ctx), host=ctx.host, port=ctx.port, ping_timeout=None,
+                                  ping_interval=None, 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,12 +2,11 @@ from __future__ import annotations
 
 import typing
 import enum
-import warnings
 from json import JSONEncoder, JSONDecoder
 
 import websockets
 
-from Utils import ByValue, Version
+from Utils import Version
 
 
 class JSONMessagePart(typing.TypedDict, total=False):
@@ -21,7 +20,7 @@ class JSONMessagePart(typing.TypedDict, total=False):
     flags: int
 
 
-class ClientStatus(ByValue, enum.IntEnum):
+class ClientStatus(enum.IntEnum):
     CLIENT_UNKNOWN = 0
     CLIENT_CONNECTED = 5
     CLIENT_READY = 10
@@ -29,18 +28,18 @@ class ClientStatus(ByValue, enum.IntEnum):
     CLIENT_GOAL = 30
 
 
-class SlotType(ByValue, enum.IntFlag):
+class SlotType(enum.IntFlag):
     spectator = 0b00
     player = 0b01
     group = 0b10
 
     @property
     def always_goal(self) -> bool:
-        """Mark this slot as having reached its goal instantly."""
+        """Mark this slot has having reached its goal instantly."""
         return self.value != 0b01
 
 
-class Permission(ByValue, enum.IntFlag):
+class Permission(enum.IntFlag):
     disabled = 0b000  # 0, completely disables access
     enabled = 0b001  # 1, allows manual use
     goal = 0b010  # 2, allows manual use after goal completion
@@ -72,6 +71,7 @@ class NetworkSlot(typing.NamedTuple):
     name: str
     game: str
     type: SlotType
+    allow_collect: bool = True
     group_members: typing.Union[typing.List[int], typing.Tuple] = ()  # only populated if type == group
 
 
@@ -290,8 +290,8 @@ def add_json_item(parts: list, item_id: int, player: int = 0, item_flags: int =
     parts.append({"text": str(item_id), "player": player, "flags": item_flags, "type": JSONTypes.item_id, **kwargs})
 
 
-def add_json_location(parts: list, location_id: int, player: int = 0, **kwargs) -> None:
-    parts.append({"text": str(location_id), "player": player, "type": JSONTypes.location_id, **kwargs})
+def add_json_location(parts: list, item_id: int, player: int = 0, **kwargs) -> None:
+    parts.append({"text": str(item_id), "player": player, "type": JSONTypes.location_id, **kwargs})
 
 
 class Hint(typing.NamedTuple):
@@ -344,85 +344,3 @@ 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 Utils import __version__ as MWVersion
+    from Main 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 multiworld and OOTWorld to use as a base
-    multiworld = MultiWorld(1)
-    multiworld.per_slot_randoms = {1: random}
-    ootworld = OOTWorld(multiworld, 1)
+    # Create a fake world and OOTWorld to use as a base
+    world = MultiWorld(1)
+    world.per_slot_randoms = {1: random}
+    ootworld = OOTWorld(world, 1)
     # Set options in the fake OOTWorld
     for name, option in chain(cosmetic_options.items(), sfx_options.items()):
         result = getattr(args, name, None)

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 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_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_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 EmuHawk to get player information')
+            logger.info('Awaiting connection to Bizhawk to get player information')
             return
 
         await self.send_connect()
@@ -179,12 +179,6 @@ 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
@@ -295,17 +289,11 @@ async def patch_and_run_game(apz5_file):
     decomp_path = base_name + '-decomp.z64'
     comp_path = base_name + '.z64'
     # Load vanilla ROM, patch file, compress ROM
-    rom_file_name = Utils.get_options()["oot_options"]["rom_file"]
-    rom = Rom(rom_file_name)
-
-    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 = Rom(Utils.local_path(Utils.get_options()["oot_options"]["rom_file"]))
+    apply_patch_file(rom, apz5_file,
+        sub_file=(os.path.basename(base_name) + '.zpf'
+            if zipfile.is_zipfile(apz5_file)
+            else None))
     rom.write_to_file(decomp_path)
     os.chdir(data_path("Compress"))
     compress_rom_file(decomp_path, comp_path)

Options.py

@@ -1,33 +1,18 @@
 from __future__ import annotations
-
 import abc
-import functools
 import logging
+from copy import deepcopy
 import math
 import numbers
-import random
 import typing
-import enum
-from copy import deepcopy
-from dataclasses import dataclass
+import random
 
-from schema import And, Optional, Or, Schema
-
-from Utils import get_fuzzy_results, is_iterable_except_str
+from schema import Schema, And, Or, Optional
+from Utils import get_fuzzy_results
 
 if typing.TYPE_CHECKING:
     from BaseClasses import PlandoOptions
     from worlds.AutoWorld import World
-    import pathlib
-
-
-class Visibility(enum.IntFlag):
-    none = 0b0000
-    template = 0b0001
-    simple_ui = 0b0010  # show option in simple menus, such as player-options
-    complex_ui = 0b0100  # show option in complex menus, such as weighted-options
-    spoiler = 0b1000
-    all = 0b1111
 
 
 class AssembleOptions(abc.ABCMeta):
@@ -51,11 +36,6 @@ class AssembleOptions(abc.ABCMeta):
         aliases = {name[6:].lower(): option_id for name, option_id in attrs.items() if
                    name.startswith("alias_")}
 
-        assert (
-            name in {"Option", "VerifyKeys"} or  # base abstract classes don't need default
-            "default" in attrs or
-            any(hasattr(base, "default") for base in bases)
-        ), f"Option class {name} needs default value"
         assert "random" not in aliases, "Choice option 'random' cannot be manually assigned."
 
         # auto-alias Off and On being parsed as True and False
@@ -73,7 +53,6 @@ class AssembleOptions(abc.ABCMeta):
                 def verify(self, *args, **kwargs) -> None:
                     for f in verifiers:
                         f(self, *args, **kwargs)
-
                 attrs["verify"] = verify
             else:
                 assert verifiers, "class Option is supposed to implement def verify"
@@ -111,8 +90,7 @@ T = typing.TypeVar('T')
 
 class Option(typing.Generic[T], metaclass=AssembleOptions):
     value: T
-    default: typing.ClassVar[typing.Any]  # something that __init__ will be able to convert to the correct type
-    visibility = Visibility.all
+    default = 0
 
     # convert option_name_long into Name Long as display_name, otherwise name_long is the result.
     # Handled in get_option_name()
@@ -122,9 +100,8 @@ class Option(typing.Generic[T], metaclass=AssembleOptions):
     supports_weighting = True
 
     # filled by AssembleOptions:
-    name_lookup: typing.ClassVar[typing.Dict[T, str]]  # type: ignore
-    # https://github.com/python/typing/discussions/1460 the reason for this type: ignore
-    options: typing.ClassVar[typing.Dict[str, int]]
+    name_lookup: typing.Dict[T, str]
+    options: typing.Dict[str, int]
 
     def __repr__(self) -> str:
         return f"{self.__class__.__name__}({self.current_option_name})"
@@ -177,8 +154,6 @@ class FreeText(Option[str]):
     """Text option that allows users to enter strings.
     Needs to be validated by the world or option definition."""
 
-    default = ""
-
     def __init__(self, value: str):
         assert isinstance(value, str), "value of FreeText must be a string"
         self.value = value
@@ -199,18 +174,9 @@ class FreeText(Option[str]):
     def get_option_name(cls, value: str) -> str:
         return value
 
-    def __eq__(self, other):
-        if isinstance(other, self.__class__):
-            return other.value == self.value
-        elif isinstance(other, str):
-            return other == self.value
-        else:
-            raise TypeError(f"Can't compare {self.__class__.__name__} with {other.__class__.__name__}")
-
 
 class NumericOption(Option[int], numbers.Integral, abc.ABC):
     default = 0
-
     # note: some of the `typing.Any`` here is a result of unresolved issue in python standards
     # `int` is not a `numbers.Integral` according to the official typestubs
     # (even though isinstance(5, numbers.Integral) == True)
@@ -242,12 +208,6 @@ 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)
 
@@ -626,7 +586,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]
@@ -724,19 +684,11 @@ class Range(NumericOption):
         return int(round(random.triangular(lower, end, tri), 0))
 
 
-class NamedRange(Range):
+class SpecialRange(Range):
+    special_range_cutoff = 0
     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()
@@ -744,19 +696,6 @@ class NamedRange(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":
@@ -776,16 +715,8 @@ class SpecialRange(NamedRange):
                             f"random-range-high-<min>-<max>, or random-range-<min>-<max>.")
 
 
-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
+class VerifyKeys:
+    valid_keys = frozenset()
     valid_keys_casefold: bool = False
     convert_name_groups: bool = False
     verify_item_name: bool = False
@@ -793,14 +724,14 @@ class VerifyKeys(metaclass=FreezeValidKeys):
     value: typing.Any
 
     @classmethod
-    def verify_keys(cls, data: typing.Iterable[str]) -> None:
+    def verify_keys(cls, data: typing.List[str]):
         if cls.valid_keys:
             data = set(data)
             dataset = set(word.casefold() for word in data) if cls.valid_keys_casefold else set(data)
-            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:
@@ -829,8 +760,8 @@ class VerifyKeys(metaclass=FreezeValidKeys):
                                     f"Did you mean '{picks[0][0]}' ({picks[0][1]}% sure)")
 
 
-class OptionDict(Option[typing.Dict[str, typing.Any]], VerifyKeys, typing.Mapping[str, typing.Any]):
-    default = {}
+class OptionDict(Option[typing.Dict[str, typing.Any]], VerifyKeys):
+    default: typing.Dict[str, typing.Any] = {}
     supports_weighting = False
 
     def __init__(self, value: typing.Dict[str, typing.Any]):
@@ -847,14 +778,8 @@ class OptionDict(Option[typing.Dict[str, typing.Any]], VerifyKeys, typing.Mappin
     def get_option_name(self, value):
         return ", ".join(f"{key}: {v}" for key, v in value.items())
 
-    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__()
+    def __contains__(self, item):
+        return item in self.value
 
 
 class ItemDict(OptionDict):
@@ -867,15 +792,11 @@ class ItemDict(OptionDict):
 
 
 class OptionList(Option[typing.List[typing.Any]], VerifyKeys):
-    # 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 = ()
+    default: typing.List[typing.Any] = []
     supports_weighting = False
 
-    def __init__(self, value: typing.Iterable[typing.Any]):
-        self.value = list(deepcopy(value))
+    def __init__(self, value: typing.List[typing.Any]):
+        self.value = deepcopy(value)
         super(OptionList, self).__init__()
 
     @classmethod
@@ -884,7 +805,7 @@ class OptionList(Option[typing.List[typing.Any]], VerifyKeys):
 
     @classmethod
     def from_any(cls, data: typing.Any):
-        if is_iterable_except_str(data):
+        if type(data) == list:
             cls.verify_keys(data)
             return cls(data)
         return cls.from_text(str(data))
@@ -897,7 +818,7 @@ class OptionList(Option[typing.List[typing.Any]], VerifyKeys):
 
 
 class OptionSet(Option[typing.Set[str]], VerifyKeys):
-    default = frozenset()
+    default: typing.Union[typing.Set[str], typing.FrozenSet[str]] = frozenset()
     supports_weighting = False
 
     def __init__(self, value: typing.Iterable[str]):
@@ -910,7 +831,7 @@ class OptionSet(Option[typing.Set[str]], VerifyKeys):
 
     @classmethod
     def from_any(cls, data: typing.Any):
-        if is_iterable_except_str(data):
+        if isinstance(data, (list, set, frozenset)):
             cls.verify_keys(data)
             return cls(data)
         return cls.from_text(str(data))
@@ -940,7 +861,7 @@ class Accessibility(Choice):
     default = 1
 
 
-class ProgressionBalancing(NamedRange):
+class ProgressionBalancing(SpecialRange):
     """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
@@ -954,58 +875,18 @@ class ProgressionBalancing(NamedRange):
     }
 
 
-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)
+class AllowCollect(DefaultOnToggle):
+    """Controls whether items are collected from the slot when a player does a !collect or not.
+    The impact for the collecting player is that the collector might not get all of their items, until
+     the player(s) that has disallowed collection actually completes or releases their location checks."""
+    display_name = "Allow Collect"
 
 
-@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
+common_options = {
+    "progression_balancing": ProgressionBalancing,
+    "accessibility": Accessibility,
+    "allow_collect": AllowCollect
+}
 
 
 class LocalItems(ItemSet):
@@ -1024,13 +905,6 @@ 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"
@@ -1038,7 +912,6 @@ class StartHints(ItemSet):
 
 class LocationSet(OptionSet):
     verify_location_name = True
-    convert_name_groups = True
 
 
 class StartLocationHints(LocationSet):
@@ -1063,7 +936,6 @@ class DeathLink(Toggle):
 
 class ItemLinks(OptionList):
     """Share part of your item pool with other players."""
-    display_name = "Item Links"
     default = []
     schema = Schema([
         {
@@ -1126,90 +998,17 @@ class ItemLinks(OptionList):
             link.setdefault("link_replacement", None)
 
 
-class Removed(FreeText):
-    """This Option has been Removed."""
-    default = ""
-    visibility = Visibility.none
-
-    def __init__(self, value: str):
-        if value:
-            raise Exception("Option removed, please update your options file.")
-        super().__init__(value)
-
-
-@dataclass
-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] = {
-                option_name: option for option_name, option in world.options_dataclass.type_hints.items()
-                if option.visibility & Visibility.template
-            }
-
-            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)
-
+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
+}
 
 if __name__ == "__main__":
 

Patch.py

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

PokemonClient.py

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

SNIClient.py

@@ -68,11 +68,12 @@ 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:
@@ -114,8 +115,8 @@ class SNIClientCommandProcessor(ClientCommandProcessor):
 
 class SNIContext(CommonContext):
     command_processor: typing.Type[SNIClientCommandProcessor] = SNIClientCommandProcessor
-    game: typing.Optional[str] = None  # set in validate_rom
-    items_handling: typing.Optional[int] = None  # set in game_watcher
+    game = None  # set in validate_rom
+    items_handling = None  # set in game_watcher
     snes_connect_task: "typing.Optional[asyncio.Task[None]]" = None
     snes_autoreconnect_task: typing.Optional["asyncio.Task[None]"] = None
 
@@ -207,12 +208,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, death_text: str = "") -> None:
+    async def handle_deathlink_state(self, currently_dead: bool) -> 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(death_text)
+                await self.send_death()
         # 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
@@ -314,7 +315,7 @@ def launch_sni() -> None:
             f"please start it yourself if it is not running")
 
 
-async def _snes_connect(ctx: SNIContext, address: str, retry: bool = True) -> WebSocketClientProtocol:
+async def _snes_connect(ctx: SNIContext, address: str) -> 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()
@@ -335,8 +336,6 @@ async def _snes_connect(ctx: SNIContext, address: str, retry: bool = True) -> We
             await asyncio.sleep(1)
         else:
             return snes_socket
-        if not retry:
-            break
 
 
 class SNESRequest(typing.TypedDict):
@@ -564,7 +563,9 @@ async def snes_write(ctx: SNIContext, write_list: typing.List[typing.Tuple[int,
         PutAddress_Request: SNESRequest = {"Opcode": "PutAddress", "Operands": [], 'Space': 'SNES'}
         try:
             for address, data in write_list:
-                PutAddress_Request['Operands'] = [hex(address)[2:], hex(min(len(data), 256))[2:]]
+                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)
@@ -683,8 +684,6 @@ 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

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

@@ -1,11 +1,9 @@
 from __future__ import annotations
 
 import asyncio
-import json
 import typing
 import builtins
 import os
-import itertools
 import subprocess
 import sys
 import pickle
@@ -14,23 +12,20 @@ import io
 import collections
 import importlib
 import logging
-import warnings
-
-from argparse import Namespace
-from settings import Settings, get_settings
 from typing import BinaryIO, Coroutine, Optional, Set, Dict, Any, Union
-from typing_extensions import TypeGuard
-from yaml import load, load_all, dump
+
+from yaml import load, load_all, dump, SafeLoader
 
 try:
-    from yaml import CLoader as UnsafeLoader, CSafeLoader as SafeLoader, CDumper as Dumper
+    from yaml import CLoader as UnsafeLoader
+    from yaml import CDumper as Dumper
 except ImportError:
-    from yaml import Loader as UnsafeLoader, SafeLoader, Dumper
+    from yaml import Loader as UnsafeLoader
+    from yaml import Dumper
 
 if typing.TYPE_CHECKING:
     import tkinter
     import pathlib
-    from BaseClasses import Region
 
 
 def tuplize_version(version: str) -> Version:
@@ -42,11 +37,8 @@ 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.6"
+__version__ = "0.3.9"
 version_tuple = tuplize_version(__version__)
 
 is_linux = sys.platform.startswith("linux")
@@ -73,8 +65,6 @@ 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]:
@@ -92,40 +82,12 @@ 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))
 
 
 def local_path(*path: str) -> str:
-    """
-    Returns path to a file in the local Archipelago installation or source.
-    This might be read-only and user_path should be used instead for ROMs, configuration, etc.
-    """
+    """Returns path to a file in the local Archipelago installation or source."""
     if hasattr(local_path, 'cached_path'):
         pass
     elif is_frozen():
@@ -169,35 +131,17 @@ def user_path(*path: str) -> str:
         user_path.cached_path = local_path()
     else:
         user_path.cached_path = home_path()
-        # 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)
+        # 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))
 
     return os.path.join(user_path.cached_path, *path)
 
 
-def cache_path(*path: str) -> str:
-    """Returns path to a file in the user's Archipelago cache directory."""
-    if hasattr(cache_path, "cached_path"):
-        pass
-    else:
-        import platformdirs
-        cache_path.cached_path = platformdirs.user_cache_dir("Archipelago", False)
-
-    return os.path.join(cache_path.cached_path, *path)
-
-
 def output_path(*path: str) -> str:
     if hasattr(output_path, 'cached_path'):
         return os.path.join(output_path.cached_path, *path)
@@ -225,9 +169,6 @@ class UniqueKeyLoader(SafeLoader):
             if key in mapping:
                 logging.error(f"YAML duplicates sanity check failed{key_node.start_mark}")
                 raise KeyError(f"Duplicate key {key} found in YAML. Already found keys: {mapping}.")
-            if (str(key).startswith("+") and (str(key)[1:] in mapping)) or (f"+{key}" in mapping):
-                logging.error(f"YAML merge duplicates sanity check failed{key_node.start_mark}")
-                raise KeyError(f"Equivalent key {key} found in YAML. Already found keys: {mapping}.")
             mapping.add(key)
         return super().construct_mapping(node, deep)
 
@@ -251,13 +192,7 @@ def get_cert_none_ssl_context():
 def get_public_ipv4() -> str:
     import socket
     import urllib.request
-    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"
-
+    ip = socket.gethostbyname(socket.gethostname())
     ctx = get_cert_none_ssl_context()
     try:
         ip = urllib.request.urlopen("https://checkip.amazonaws.com/", context=ctx, timeout=10).read().decode("utf8").strip()
@@ -275,13 +210,7 @@ def get_public_ipv4() -> str:
 def get_public_ipv6() -> str:
     import socket
     import urllib.request
-    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"
-
+    ip = socket.gethostbyname(socket.gethostname())
     ctx = get_cert_none_ssl_context()
     try:
         ip = urllib.request.urlopen("https://v6.ident.me", context=ctx, timeout=10).read().decode("utf8").strip()
@@ -291,13 +220,142 @@ def get_public_ipv6() -> str:
     return ip
 
 
-OptionsType = Settings  # TODO: remove when removing get_options
+OptionsType = typing.Dict[str, typing.Dict[str, typing.Any]]
 
 
-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()
+@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",
+        },
+        "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"
+        }
+    }
+    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 persistent_store(category: str, key: typing.Any, value: typing.Any):
@@ -327,65 +385,11 @@ def persistent_load() -> typing.Dict[str, dict]:
     return storage
 
 
-def get_file_safe_name(name: str) -> str:
-    return "".join(c for c in name if c not in '<>:"/\\|?*')
-
-
-def load_data_package_for_checksum(game: str, checksum: typing.Optional[str]) -> Dict[str, Any]:
-    if checksum and game:
-        if checksum != get_file_safe_name(checksum):
-            raise ValueError(f"Bad symbols in checksum: {checksum}")
-        path = cache_path("datapackage", get_file_safe_name(game), f"{checksum}.json")
-        if os.path.exists(path):
-            try:
-                with open(path, "r", encoding="utf-8-sig") as f:
-                    return json.load(f)
-            except Exception as e:
-                logging.debug(f"Could not load data package: {e}")
-
-    # fall back to old cache
-    cache = persistent_load().get("datapackage", {}).get("games", {}).get(game, {})
-    if cache.get("checksum") == checksum:
-        return cache
-
-    # cache does not match
-    return {}
-
-
-def store_data_package_for_checksum(game: str, data: typing.Dict[str, Any]) -> None:
-    checksum = data.get("checksum")
-    if checksum and game:
-        if checksum != get_file_safe_name(checksum):
-            raise ValueError(f"Bad symbols in checksum: {checksum}")
-        game_folder = cache_path("datapackage", get_file_safe_name(game))
-        os.makedirs(game_folder, exist_ok=True)
-        try:
-            with open(os.path.join(game_folder, f"{checksum}.json"), "w", encoding="utf-8-sig") as f:
-                json.dump(data, f, ensure_ascii=False, separators=(",", ":"))
-        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)
@@ -405,13 +409,11 @@ 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 = None
+        self.generic_properties_module = importlib.import_module("worlds.generic")
 
     def find_class(self, module, name):
         if module == "builtins" and name in safe_builtins:
@@ -421,8 +423,6 @@ 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"):
@@ -442,15 +442,6 @@ 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]
@@ -483,7 +474,6 @@ 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(
@@ -491,21 +481,11 @@ 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:
-        stream_handler = logging.StreamHandler(sys.stdout)
-        stream_handler.addFilter(Filter("NoFile", lambda record: not getattr(record, "NoStream", False)))
-        root_logger.addHandler(stream_handler)
+        root_logger.addHandler(
+            logging.StreamHandler(sys.stdout)
+        )
 
     # Relay unhandled exceptions to logger.
     if not getattr(sys.excepthook, "_wrapped", False):  # skip if already modified
@@ -617,7 +597,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]]], suggest: str = "") \
+def open_filename(title: str, filetypes: typing.Sequence[typing.Tuple[str, typing.Sequence[str]]]) \
         -> typing.Optional[str]:
     def run(*args: str):
         return subprocess.run(args, capture_output=True, text=True).stdout.split("\n", 1)[0] or None
@@ -628,12 +608,11 @@ 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", suggest or ".", k_filters)
+            return run(kdialog, f"--title={title}", "--getopenfilename", ".", k_filters)
         zenity = which("zenity")
         if zenity:
             z_filters = (f'--file-filter={text} ({", ".join(ext)}) | *{" *".join(ext)}' for (text, ext) in filetypes)
-            selection = (f"--filename={suggest}",) if suggest else ()
-            return run(zenity, f"--title={title}", "--file-selection", *z_filters, *selection)
+            return run(zenity, f"--title={title}", "--file-selection", *z_filters)
 
     # fall back to tk
     try:
@@ -644,47 +623,9 @@ 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:
-        try:
-            root = tkinter.Tk()
-        except tkinter.TclError:
-            return None  # GUI not available. None is the same as a user clicking "cancel"
+        root = tkinter.Tk()
         root.withdraw()
-        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)
+        return tkinter.filedialog.askopenfilename(title=title, filetypes=((t[0], ' '.join(t[1])) for t in filetypes))
 
 
 def messagebox(title: str, text: str, error: bool = False) -> None:
@@ -712,11 +653,6 @@ 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
@@ -754,10 +690,10 @@ def read_snes_rom(stream: BinaryIO, strip_header: bool = True) -> bytearray:
     return buffer
 
 
-_faf_tasks: "Set[asyncio.Task[typing.Any]]" = set()
+_faf_tasks: "Set[asyncio.Task[None]]" = set()
 
 
-def async_start(co: Coroutine[None, None, typing.Any], name: Optional[str] = None) -> None:
+def async_start(co: Coroutine[typing.Any, typing.Any, bool], 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"
@@ -770,210 +706,6 @@ def async_start(co: Coroutine[None, None, typing.Any], name: Optional[str] = Non
     # ```
     # This implementation follows the pattern given in that documentation.
 
-    task: asyncio.Task[typing.Any] = asyncio.create_task(co, name=name)
+    task = 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,9 +113,6 @@ 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):
@@ -127,9 +124,6 @@ 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):
@@ -408,10 +402,8 @@ 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,19 +10,23 @@ 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
-settings.no_gui = True
+
+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
+
 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"]:
@@ -34,7 +38,6 @@ 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
@@ -69,7 +72,6 @@ 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")
@@ -115,11 +117,6 @@ 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:
@@ -136,5 +133,4 @@ 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"] = 1
+app.config["JOB_THRESHOLD"] = 2
 # 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,10 +49,11 @@ app.config["PONY"] = {
     'create_db': True
 }
 app.config["MAX_ROLL"] = 20
-app.config["CACHE_TYPE"] = "SimpleCache"
+app.config["CACHE_TYPE"] = "flask_caching.backends.SimpleCache"
+app.config["JSON_AS_ASCII"] = False
 app.config["HOST_ADDRESS"] = ""
 
-cache = Cache()
+cache = Cache(app)
 Compress(app)
 
 

WebHostLib/api/__init__.py

@@ -2,9 +2,8 @@
 from typing import List, Tuple
 from uuid import UUID
 
-from flask import Blueprint, abort, url_for
+from flask import Blueprint, abort
 
-import worlds.Files
 from .. import cache
 from ..models import Room, Seed
 
@@ -22,30 +21,12 @@ def room_info(room: UUID):
     room = Room.get(id=room)
     if room is None:
         return abort(404)
-    
-    def supports_apdeltapatch(game: str):
-        return game in worlds.Files.AutoPatchRegister.patch_types
-    downloads = []
-    for slot in sorted(room.seed.slots):
-        if slot.data and not supports_apdeltapatch(slot.game):
-            slot_download = {
-                "slot": slot.player_id,
-                "download": url_for("download_slot_file", room_id=room.id, player_id=slot.player_id)
-            }
-            downloads.append(slot_download)
-        elif slot.data:
-            slot_download = {
-                "slot": slot.player_id,
-                "download": url_for("download_patch", patch_id=slot.id, room_id=room.id)
-            }
-            downloads.append(slot_download)
     return {
         "tracker": room.tracker,
         "players": get_players(room.seed),
         "last_port": room.last_port,
         "last_activity": room.last_activity,
-        "timeout": room.timeout,
-        "downloads": downloads,
+        "timeout": room.timeout
     }
 
 
@@ -58,21 +39,12 @@ def get_datapackage():
 
 @api_endpoints.route('/datapackage_version')
 @cache.cached()
+
 def get_datapackage_versions():
-    from worlds import AutoWorldRegister
+    from worlds import network_data_package, AutoWorldRegister
 
     version_package = {game: world.data_version for game, world in AutoWorldRegister.world_types.items()}
     return version_package
 
 
-@api_endpoints.route('/datapackage_checksum')
-@cache.cached()
-def get_datapackage_checksums():
-    from worlds import network_data_package
-    version_package = {
-        game: game_data["checksum"] for game, game_data in network_data_package["games"].items()
-    }
-    return version_package
-
-
 from . import generate, user  # trigger registration

WebHostLib/api/generate.py

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

WebHostLib/autolauncher.py

@@ -3,16 +3,65 @@ from __future__ import annotations
 import json
 import logging
 import multiprocessing
+import os
+import sys
 import threading
 import time
 import typing
-from uuid import UUID
 from datetime import timedelta, datetime
 
 from pony.orm import db_session, select, commit
 
 from Utils import restricted_loads
-from .locker import Locker, AlreadyRunningException
+
+
+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()
 
 
 def launch_room(room: Room, config: dict):
@@ -63,16 +112,6 @@ def autohost(config: dict):
     def keep_running():
         try:
             with Locker("autohost"):
-                # delete unowned user-content
-                with db_session:
-                    # >>> bool(uuid.UUID(int=0))
-                    # True
-                    rooms = Room.select(lambda room: room.owner == UUID(int=0)).delete(bulk=True)
-                    seeds = Seed.select(lambda seed: seed.owner == UUID(int=0) and not seed.rooms).delete(bulk=True)
-                    slots = Slot.select(lambda slot: not slot.seed).delete(bulk=True)
-                    # Command gets deleted by ponyorm Cascade Delete, as Room is Required
-                if rooms or seeds or slots:
-                    logging.info(f"{rooms} Rooms, {seeds} Seeds and {slots} Slots have been deleted.")
                 run_guardian()
                 while 1:
                     time.sleep(0.1)
@@ -96,7 +135,7 @@ def autogen(config: dict):
             with Locker("autogen"):
 
                 with multiprocessing.Pool(config["GENERATORS"], initializer=init_db,
-                                          initargs=(config["PONY"],), maxtasksperchild=10) as generator_pool:
+                                          initargs=(config["PONY"],)) as generator_pool:
                     with db_session:
                         to_start = select(generation for generation in Generation if generation.state == STATE_STARTED)
 
@@ -202,6 +241,6 @@ def run_guardian():
             guardian = threading.Thread(name="Guardian", target=guard)
 
 
-from .models import Room, Generation, STATE_QUEUED, STATE_STARTED, STATE_ERROR, db, Seed, Slot
+from .models import Room, Generation, STATE_QUEUED, STATE_STARTED, STATE_ERROR, db, Seed
 from .customserver import run_server_process, get_static_server_data
 from .generate import gen_game

WebHostLib/check.py

@@ -1,13 +1,16 @@
-import os
 import zipfile
-import base64
-from typing import Union, Dict, Set, Tuple
+from typing import *
 
-from flask import request, flash, redirect, url_for, render_template
-from markupsafe import Markup
+from flask import request, flash, redirect, url_for, render_template, Markup
 
 from WebHostLib import app
-from WebHostLib.upload import allowed_options, allowed_options_extensions, banned_file
+
+banned_zip_contents = (".sfc",)
+
+
+def allowed_file(filename):
+    return filename.endswith(('.txt', ".yaml", ".zip"))
+
 
 from Generate import roll_settings, PlandoOptions
 from Utils import parse_yamls
@@ -20,21 +23,13 @@ def check():
         if 'file' not in request.files:
             flash('No file part')
         else:
-            files = request.files.getlist('file')
-            options = get_yaml_data(files)
+            file = request.files['file']
+            options = get_yaml_data(file)
             if isinstance(options, str):
                 flash(options)
             else:
                 results, _ = roll_options(options)
-                if len(options) > 1:
-                    # offer combined file back
-                    combined_yaml = "\n---\n".join(f"# original filename: {file_name}\n{file_content.decode('utf-8-sig')}"
-                                                 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("checkResult.html", results=results)
     return render_template("check.html")
 
 
@@ -43,44 +38,31 @@ def mysterycheck():
     return redirect(url_for("check"), 301)
 
 
-def get_yaml_data(files) -> Union[Dict[str, str], str, Markup]:
+def get_yaml_data(file) -> Union[Dict[str, str], str, Markup]:
     options = {}
-    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."
+    # 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"):
 
-                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)
+            with zipfile.ZipFile(file, 'r') as zfile:
+                infolist = zfile.infolist()
 
-                        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()
+                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>?')
 
+                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 f"Did not find any valid files to process. Accepted formats: {allowed_options_extensions}"
+        return "Did not find a .yaml file to process."
     return options
 
 
@@ -108,10 +90,7 @@ def roll_options(options: Dict[str, Union[dict, str]],
                         rolled_results[f"{filename}/{i + 1}"] = roll_settings(yaml_data,
                                                                               plando_options=plando_options)
             except Exception as e:
-                if e.__cause__:
-                    results[filename] = f"Failed to generate options in {filename}: {e} - {e.__cause__}"
-                else:
-                    results[filename] = f"Failed to generate options in {filename}: {e}"
+                results[filename] = f"Failed to generate mystery in {filename}: {e}"
             else:
                 results[filename] = True
     return results, rolled_results

WebHostLib/customserver.py

@@ -11,7 +11,6 @@ import socket
 import threading
 import time
 import typing
-import sys
 
 import websockets
 from pony.orm import commit, db_session, select
@@ -19,18 +18,15 @@ 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 restricted_loads, cache_argsless
-from .locker import Locker
-from .models import Command, GameDataPackage, Room, db
+from Utils import get_public_ipv4, get_public_ipv6, restricted_loads, cache_argsless
+from .models import Room, Command, db
 
 
 class CustomClientMessageProcessor(ClientMessageProcessor):
     ctx: WebHostContext
 
-    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.
-        """
+    def _cmd_video(self, platform, user):
+        """Set a link for your name in the WebHostLib tracker pointing to a video stream"""
         if platform.lower().startswith("t"):  # twitch
             self.ctx.video[self.client.team, self.client.slot] = "Twitch", user
             self.ctx.save()
@@ -96,21 +92,7 @@ class WebHostContext(Context):
         else:
             self.port = get_random_port()
 
-        multidata = self.decompress(room.seed.multidata)
-        game_data_packages = {}
-        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"]:
-                    # non-custom. remove from multidata
-                    # games package could be dropped from static data once all rooms embed data package
-                    del multidata["datapackage"][game]
-                else:
-                    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)
+        return self._load(self.decompress(room.seed.multidata), True)
 
     @db_session
     def init_save(self, enabled: bool = True):
@@ -167,22 +149,19 @@ 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, ssl=ssl_context)
+            ctx.server = websockets.serve(functools.partial(server, ctx=ctx), ctx.host, ctx.port, ping_timeout=None,
+                                          ping_interval=None, ssl=ssl_context)
 
             await ctx.server
-        except OSError:  # likely port in use
-            ctx.server = websockets.serve(functools.partial(server, ctx=ctx), ctx.host, 0, ssl=ssl_context)
+        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)
 
             await ctx.server
         port = 0
@@ -205,23 +184,13 @@ 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, 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 Exception:
+        except:
             with db_session:
                 room = Room.get(id=room_id)
                 room.last_port = -1

WebHostLib/downloads.py

@@ -88,10 +88,6 @@ def download_slot_file(room_id, player_id: int):
             fname = f"AP_{app.jinja_env.filters['suuid'](room_id)}_SP.apsm64ex"
         elif slot_data.game == "Dark Souls III":
             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 Any, Dict, List, Optional, Union
+from typing import Dict, Optional, Any
 
-from flask import flash, redirect, render_template, request, session, url_for
+from flask import request, flash, redirect, url_for, session, render_template
 from pony.orm import commit, db_session
 
-from BaseClasses import get_seed, seeddigits
-from Generate import PlandoOptions, handle_name
+from BaseClasses import seeddigits, get_seed
+from Generate import handle_name, PlandoOptions
 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, race: bool = False) -> Dict[str, Union[List[str], Dict[str, Any]]]:
+def get_meta(options_source: dict) -> dict:
     plando_options = {
         options_source.get("plando_bosses", ""),
         options_source.get("plando_items", ""),
@@ -39,21 +39,7 @@ def get_meta(options_source: dict, race: bool = False) -> Dict[str, Union[List[s
         "item_cheat": bool(int(options_source.get("item_cheat", 1))),
         "server_password": options_source.get("server_password", None),
     }
-    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,
-    }
+    return {"server_options": server_options, "plando_options": list(plando_options)}
 
 
 @app.route('/generate', methods=['GET', 'POST'])
@@ -64,13 +50,18 @@ def generate(race=False):
         if 'file' not in request.files:
             flash('No file part')
         else:
-            files = request.files.getlist('file')
-            options = get_yaml_data(files)
+            file = request.files['file']
+            options = get_yaml_data(file)
             if isinstance(options, str):
                 flash(options)
             else:
-                meta = get_meta(request.form, race)
-                results, gen_options = roll_options(options, set(meta["plando_options"]))
+                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"
 
                 if any(type(result) == str for result in results.values()):
                     return render_template("checkResult.html", results=results)
@@ -106,7 +97,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("generator_options", {}).setdefault("race", False)
+    race = meta.setdefault("race", False)
 
     def task():
         target = tempfile.TemporaryDirectory()
@@ -123,15 +114,13 @@ 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 = meta["generator_options"].get("spoiler", 0)
+        erargs.spoiler = 0 if race else 3
         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"}))
-        erargs.skip_prog_balancing = False
-        erargs.skip_output = False
+                                                                        {"bosses", "items", "connections", "texts"}))
 
         name_counter = Counter()
         for player, (playerfile, settings) in enumerate(gen_options.items(), 1):

WebHostLib/locker.py

@@ -1,51 +0,0 @@
-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,40 +32,29 @@ def page_not_found(err):
 
 # Start Playing Page
 @app.route('/start-playing')
-@cache.cached()
 def start_playing():
     return render_template(f"startPlaying.html")
 
 
-# TODO for back compat. remove around 0.4.5
-@app.route("/weighted-settings")
+@app.route('/weighted-settings')
 def weighted_settings():
-    return redirect("weighted-options", 301)
+    return render_template(f"weighted-settings.html")
 
 
-@app.route("/weighted-options")
-@cache.cached()
-def weighted_options():
-    return render_template("weighted-options.html")
-
-
-# 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))
+# 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))
 
 
 # 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():
@@ -75,25 +64,21 @@ 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)
 
@@ -131,11 +116,7 @@ def display_log(room: UUID):
     if room is None:
         return abort(404)
     if room.owner == session["_id"]:
-        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 Response(_read_log(os.path.join("logs", str(room.id) + ".txt")), mimetype="text/plain;charset=UTF-8")
     return "Access Denied", 403
 
 
@@ -162,7 +143,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')
 
 
@@ -182,11 +163,10 @@ 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.options_page, bool) and world.web.options_page
+            has_settings: bool = isinstance(world.web.settings_page, bool) and world.web.settings_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(), index=True)  # index used by landing page
+    creation_time = Required(datetime, default=lambda: datetime.utcnow())
     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(), index=True)  # index used by landing page
+    creation_time = Required(datetime, default=lambda: datetime.utcnow())
     slots = Set(Slot)
     spoiler = Optional(LongStr, lazy=True)
     meta = Required(LongStr, default=lambda: "{\"race\": false}")  # additional meta information/tags
@@ -56,8 +56,3 @@ class Generation(db.Entity):
     options = Required(buffer, lazy=True)
     meta = Required(LongStr, default=lambda: "{\"race\": false}")
     state = Required(int, default=0, index=True)
-
-
-class GameDataPackage(db.Entity):
-    checksum = PrimaryKey(str)
-    data = Required(bytes)

WebHostLib/options.py

@@ -3,29 +3,53 @@ import logging
 import os
 import typing
 
+import yaml
+from jinja2 import Template
+
 import Options
-from Utils import local_path
+from Utils import __version__, local_path
 from worlds.AutoWorld import AutoWorldRegister
 
 handled_in_js = {"start_inventory", "local_items", "non_local_items", "start_hints", "start_location_hints",
-                 "exclude_locations", "priority_locations"}
+                 "exclude_locations"}
 
 
 def create():
     target_folder = local_path("WebHostLib", "static", "generated")
     yaml_folder = os.path.join(target_folder, "configs")
+    os.makedirs(yaml_folder, exist_ok=True)
 
-    Options.generate_yaml_templates(yaml_folder)
+    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
 
     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_options = {
+    weighted_settings = {
         "baseOptions": {
             "description": "Generated by https://archipelago.gg/",
-            "name": "",
+            "name": "Player",
             "game": {},
         },
         "games": {},
@@ -33,31 +57,38 @@ def create():
 
     for game_name, world in AutoWorldRegister.world_types.items():
 
-        all_options: typing.Dict[str, Options.AssembleOptions] = world.options_dataclass.type_hints
+        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,
+        )
 
-        # Generate JSON files for player-options pages
-        player_options = {
+        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 = {
             "baseOptions": {
-                "description": f"Generated by https://archipelago.gg/ for {game_name}",
+                "description": "Generated by https://archipelago.gg/",
                 "game": game_name,
-                "name": "",
+                "name": "Player",
             },
         }
 
         game_options = {}
-        visible: typing.Set[str] = set()
-        visible_weighted: typing.Set[str] = set()
-
         for option_name, option in all_options.items():
-            if option.visibility & Options.Visibility.simple_ui:
-                visible.add(option_name)
-            if option.visibility & Options.Visibility.complex_ui:
-                visible_weighted.add(option_name)
-
             if option_name in handled_in_js:
                 pass
 
-            elif issubclass(option, Options.Choice) or issubclass(option, Options.Toggle):
+            elif option.options:
                 game_options[option_name] = this_option = {
                     "type": "select",
                     "displayName": option.display_name if hasattr(option, "display_name") else option_name,
@@ -67,15 +98,15 @@ def create():
                 }
 
                 for sub_option_id, sub_option_name in option.name_lookup.items():
-                    if sub_option_name != "random":
-                        this_option["options"].append({
-                            "name": option.get_option_name(sub_option_id),
-                            "value": sub_option_name,
-                        })
+                    this_option["options"].append({
+                        "name": option.get_option_name(sub_option_id),
+                        "value": sub_option_name,
+                    })
+
                     if sub_option_id == option.default:
                         this_option["defaultValue"] = sub_option_name
 
-                if not this_option["defaultValue"]:
+                if option.default == "random":
                     this_option["defaultValue"] = "random"
 
             elif issubclass(option, Options.Range):
@@ -89,117 +120,51 @@ def create():
                     "max": option.range_end,
                 }
 
-                if issubclass(option, Options.NamedRange):
-                    game_options[option_name]["type"] = 'named_range'
+                if issubclass(option, Options.SpecialRange):
+                    game_options[option_name]["type"] = 'special_range'
                     game_options[option_name]["value_names"] = {}
                     for key, val in option.special_range_names.items():
                         game_options[option_name]["value_names"][key] = val
 
-            elif issubclass(option, Options.ItemSet):
+            elif getattr(option, "verify_item_name", False):
                 game_options[option_name] = {
                     "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):
+            elif getattr(option, "verify_location_name", False):
                 game_options[option_name] = {
                     "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) and not issubclass(option, Options.OptionDict):
+            elif issubclass(option, Options.OptionList) or issubclass(option, Options.OptionSet):
                 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 Options.")
+                logging.debug(f"{option} not exported to Web Settings.")
 
-        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."
+        player_settings["gameOptions"] = game_options
 
-                # Normal random is supported, but needs to be handled explicitly.
-                if option_value == "random":
-                    player_options["presetOptions"][preset_name][option_name] = option_value
-                    continue
+        os.makedirs(os.path.join(target_folder, 'player-settings'), exist_ok=True)
 
-                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}."
+        with open(os.path.join(target_folder, 'player-settings', game_name + ".json"), "w") as f:
+            json.dump(player_settings, f, indent=2, separators=(',', ': '))
 
-                    # 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)
-
-        filtered_player_options = player_options
-        filtered_player_options["gameOptions"] = {
-            option_name: option_data for option_name, option_data in game_options.items()
-            if option_name in visible
-        }
-
-        with open(os.path.join(target_folder, 'player-options', game_name + ".json"), "w") as f:
-            json.dump(filtered_player_options, f, indent=2, separators=(',', ': '))
-
-        filtered_player_options["gameOptions"] = {
-            option_name: option_data for option_name, option_data in game_options.items()
-            if option_name in visible_weighted
-        }
-
-        if not world.hidden and world.web.options_page is True:
-            # Add the random option to Choice, TextChoice, and Toggle options
-            for option in filtered_player_options["gameOptions"].values():
-                if option["type"] == "select":
-                    option["options"].append({"name": "Random", "value": "random"})
-
-                    if not option["defaultValue"]:
-                        option["defaultValue"] = "random"
-
-            weighted_options["baseOptions"]["game"][game_name] = 0
-            weighted_options["games"][game_name] = {
-                "gameSettings": filtered_player_options["gameOptions"],
-                "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=(',', ': '))
+        if not world.hidden and world.web.settings_page is True:
+            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)
 
+    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,9 +1,7 @@
-flask>=3.0.0
-pony>=0.7.17
+flask>=2.2.3
+pony>=0.7.16
 waitress>=2.1.2
-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
+Flask-Caching>=2.0.2
+Flask-Compress>=1.13
+Flask-Limiter>=3.3.0
+bokeh>=3.1.0

WebHostLib/static/assets/baseHeader.js

@@ -1,11 +1,9 @@
 window.addEventListener('load', () => {
-  // Mobile menu handling
   const menuButton = document.getElementById('base-header-mobile-menu-button');
   const mobileMenu = document.getElementById('base-header-mobile-menu');
 
   menuButton.addEventListener('click', (evt) => {
     evt.preventDefault();
-    evt.stopPropagation();
 
     if (!mobileMenu.style.display || mobileMenu.style.display === 'none') {
       return mobileMenu.style.display = 'flex';
@@ -17,24 +15,4 @@ window.addEventListener('load', () => {
   window.addEventListener('resize', () => {
     mobileMenu.style.display = 'none';
   });
-
-  // Popover handling
-  const popoverText = document.getElementById('base-header-popover-text');
-  const popoverMenu = document.getElementById('base-header-popover-menu');
-
-  popoverText.addEventListener('click', (evt) => {
-    evt.preventDefault();
-    evt.stopPropagation();
-
-    if (!popoverMenu.style.display || popoverMenu.style.display === 'none') {
-      return popoverMenu.style.display = 'flex';
-    }
-
-    popoverMenu.style.display = 'none';
-  });
-
-  document.body.addEventListener('click', () => {
-    mobileMenu.style.display = 'none';
-    popoverMenu.style.display = 'none';
-  });
 });

WebHostLib/static/assets/faq/faq_en.md

@@ -2,62 +2,13 @@
 
 ## What is a randomizer?
 
-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
+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
 game, you might first find item C, then A, then B.
 
-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).
+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.
 
 ## What happens if an item is placed somewhere it is impossible to get?
 
@@ -66,15 +17,53 @@ 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:  
-[Archipelago GitHub Page](https://github.com/ArchipelagoMW/Archipelago).
+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).
 
-There, you will find examples of games in the `worlds` folder:  
-[/worlds Folder in Archipelago Code](https://github.com/ArchipelagoMW/Archipelago/tree/main/worlds).
+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).
 
-You may also find developer documentation in the `docs` folder:  
-[/docs Folder in Archipelago Code](https://github.com/ArchipelagoMW/Archipelago/tree/main/docs).
+You may also find developer documentation in the docs folder
+at [/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

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

@@ -0,0 +1,395 @@
+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/sc2wolTracker.js

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

WebHostLib/static/assets/supportedGames.js

@@ -1,64 +0,0 @@
-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,34 +4,16 @@ 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++) {
-        // 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`;
+    for(let i=0; i < tableWrappers.length; i++){
+        const maxHeight = (window.innerHeight - upperDistance) / 2;
+        tableWrappers[i].style.maxHeight = `calc(${maxHeight}px - 1rem)`;
     }
 };
 
-/**
- * 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,
@@ -45,31 +27,24 @@ 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 Number.MAX_VALUE;
+                            return -1;
 
                         return parseInt(data);
                     }
                     if (data === "None")
                         return data;
 
-                    return secondsToHours(data);
+                    let hours   = Math.floor(data / 3600);
+                    let minutes = Math.floor((data - (hours * 3600)) / 60);
+
+                    if (minutes < 10) {minutes = "0"+minutes;}
+                    return hours+':'+minutes;
                 }
             },
             {
@@ -139,16 +114,11 @@ 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();
-                    if (footer_tr.length) {
-                        $(old_table.table).find("tfoot").html(footer_tr);
-                    }
-                    old_table.rows.add(new_trs);
-                    old_table.draw();
+                    old_table.rows.add(new_trs).draw();
                     $(old_table.settings()[0].nScrollBody).scrollTop(topscroll);
                     $(old_table.settings()[0].nScrollBody).scrollLeft(leftscroll);
                 });

WebHostLib/static/styles/islandFooter.css

@@ -15,33 +15,3 @@
     padding-left: 0.5rem;
     color: #dfedc6;
 }
-@media all and (max-width: 900px) {
-    #island-footer{
-        font-size: 17px;
-        font-size: 2vw;
-    }
-}
-@media all and (max-width: 768px) {
-    #island-footer{
-        font-size: 15px;
-        font-size: 2vw;
-    }
-}
-@media all and (max-width: 650px) {
-    #island-footer{
-        font-size: 13px;
-        font-size: 2vw;
-    }
-}
-@media all and (max-width: 580px) {
-    #island-footer{
-        font-size: 11px;
-        font-size: 2vw;
-    }
-}
-@media all and (max-width: 512px) {
-    #island-footer{
-        font-size: 9px;
-        font-size: 2vw;
-    }
-}

WebHostLib/static/styles/landing.css

@@ -21,6 +21,7 @@ html{
     margin-right: auto;
     margin-top: 10px;
     height: 140px;
+    z-index: 10;
 }
 
 #landing-header h4{
@@ -222,7 +223,7 @@ html{
 }
 
 #landing{
-    max-width: 700px;
+    width: 700px;
     min-height: 280px;
     margin-left: auto;
     margin-right: auto;
@@ -235,6 +236,9 @@ html{
     line-height: 30px;
 }
 
+#landing .variable{
+    color: #ffff00;
+}
 
 .landing-deco{
     position: absolute;

WebHostLib/static/styles/player-settings.css

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

WebHostLib/static/styles/sc2Tracker.css

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

WebHostLib/static/styles/sc2wolTracker.css

@@ -0,0 +1,110 @@
+#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,22 +18,6 @@
     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;
 }
@@ -47,13 +31,3 @@
     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/themes/base.css

@@ -30,8 +30,6 @@ html{
 }
 
 #base-header-right{
-    display: flex;
-    flex-direction: row;
     margin-top: 4px;
 }
 
@@ -44,7 +42,7 @@ html{
     margin-top: 4px;
 }
 
-#base-header a, #base-header-mobile-menu a, #base-header-popover-text{
+#base-header a, #base-header-mobile-menu a{
     color: #2f6b83;
     text-decoration: none;
     cursor: pointer;
@@ -74,92 +72,22 @@ html{
     position: absolute;
     top: 7rem;
     right: 0;
+    padding-top: 1rem;
 }
 
 #base-header-mobile-menu a{
-    padding: 3rem 1.5rem;
-    font-size: 4rem;
+    padding: 4rem 2rem;
+    font-size: 5rem;
     line-height: 5rem;
     color: #699ca8;
     border-top: 1px solid #d3d3d3;
 }
 
-#base-header-mobile-menu :first-child, #base-header-popover-menu :first-child{
-    border-top: none;
-}
-
 #base-header-right-mobile img{
     height: 3rem;
 }
 
-#base-header-popover-menu{
-    display: none;
-    flex-direction: column;
-    position: absolute;
-    background-color: #fff;
-    margin-left: -108px;
-    margin-top: 2.25rem;
-    border-radius: 10px;
-    border-left: 2px solid #d0ebe6;
-    border-bottom: 2px solid #d0ebe6;
-    border-right: 1px solid #d0ebe6;
-    filter: drop-shadow(-6px 6px 2px #2e3e83);
-}
-
-#base-header-popover-menu a{
-    color: #699ca8;
-    border-top: 1px solid #d3d3d3;
-    text-align: center;
-    font-size: 1.5rem;
-    line-height: 3rem;
-    margin-right: 2px;
-    padding: 0.25rem 1rem;
-}
-
-#base-header-popover-icon {
-    width: 14px;
-    margin-bottom: 3px;
-    margin-left: 2px;
-}
-
-@media all and (max-width: 960px), only screen and (max-device-width: 768px) {
-    #base-header-right{
-        display: none;
-    }
-
-    #base-header-right-mobile{
-        display: unset;
-    }
-}
-
-@media all and (max-width: 960px){
-    #base-header-right-mobile{
-        margin-top: 0.5rem;
-        margin-right: 0;
-    }
-
-    #base-header-right-mobile img{
-        height: 1.5rem;
-    }
-
-    #base-header-mobile-menu{
-        top: 3.3rem;
-        width: unset;
-        border-left: 2px solid #d0ebe6;
-        border-bottom: 2px solid #d0ebe6;
-        filter: drop-shadow(-6px 6px 2px #2e3e83);
-        border-top-left-radius: 10px;
-    }
-
-    #base-header-mobile-menu a{
-        font-size: 1.5rem;
-        line-height: 3rem;
-        margin: 0;
-        padding: 0.25rem 1rem;
-    }
-}
-
-@media only screen and (max-device-width: 768px){
+@media all and (max-width: 1580px){
     html{
         padding-top: 260px;
         scroll-padding-top: 230px;
@@ -175,4 +103,12 @@ html{
         margin-top: 30px;
         margin-left: 20px;
     }
+
+    #base-header-right{
+        display: none;
+    }
+
+    #base-header-right-mobile{
+        display: unset;
+    }
 }

WebHostLib/static/styles/tracker.css

@@ -7,55 +7,134 @@
     width: calc(100% - 1rem);
 }
 
-#tracker-wrapper a {
+#tracker-wrapper a{
     color: #234ae4;
     text-decoration: none;
     cursor: pointer;
 }
 
-#tracker-header-bar {
-    display: flex;
-    flex-direction: row;
-    justify-content: flex-start;
-    align-content: center;
-    line-height: 20px;
-    gap: 0.5rem;
+.table-wrapper{
+    overflow-y: auto;
+    overflow-x: auto;
     margin-bottom: 1rem;
 }
 
-#tracker-header-bar .info {
+#tracker-header-bar{
+    display: flex;
+    flex-direction: row;
+    justify-content: flex-start;
+    line-height: 20px;
+}
+
+#tracker-header-bar .info{
     color: #ffffff;
-    padding: 2px;
-    flex-grow: 1;
-    align-self: center;
-    text-align: justify;
+}
+
+#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;
 }
 
 #tracker-navigation {
-    display: flex;
-    flex-wrap: wrap;
-    margin: 0 0.5rem 0.5rem 0.5rem;
-    user-select: none;
-    height: 2rem;
-}
-
-.tracker-navigation-bar {
-    display: flex;
+    display: inline-flex;
     background-color: #b0a77d;
+    margin: 0.5rem;
     border-radius: 4px;
 }
 
 .tracker-navigation-button {
-    display: flex;
-    justify-content: center;
-    align-items: center;
+    display: block;
     margin: 4px;
     padding-left: 12px;
     padding-right: 12px;
     border-radius: 4px;
     text-align: center;
     font-size: 14px;
-    color: black !important;
+    color: #000;
     font-weight: lighter;
 }
 
@@ -67,100 +146,6 @@
     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;
@@ -170,7 +155,7 @@ img.icon-sprite {
         top: 0;
     }
 
-    table.dataTable thead th.lower-row {
+    table.dataTable thead th.lower-row{
         position: -webkit-sticky;
         position: sticky;
         background-color: #b0a77d;
@@ -178,11 +163,11 @@ img.icon-sprite {
         top: 37px;
     }
 
-    table.dataTable, table.dataTable.no-footer {
+    table.dataTable, table.dataTable.no-footer{
         font-size: 0.8rem;
     }
 
-    img.icon-sprite {
+    img.alttp-sprite {
         height: auto;
         max-height: 24px;
         min-height: 10px;
@@ -198,7 +183,7 @@ img.icon-sprite {
         top: 0;
     }
 
-    table.dataTable thead th.lower-row {
+    table.dataTable thead th.lower-row{
         position: -webkit-sticky;
         position: sticky;
         background-color: #b0a77d;
@@ -206,11 +191,11 @@ img.icon-sprite {
         top: 32px;
     }
 
-    table.dataTable, table.dataTable.no-footer {
+    table.dataTable, table.dataTable.no-footer{
         font-size: 0.6rem;
     }
 
-    img.icon-sprite {
+    img.alttp-sprite {
         height: auto;
         max-height: 20px;
         min-height: 10px;

WebHostLib/static/styles/weighted-settings.css

@@ -157,29 +157,41 @@ html{
     background-color: rgba(0, 0, 0, 0.1);
 }
 
-#weighted-settings .hints-div, #weighted-settings .locations-div{
+#weighted-settings .hints-div{
     margin-top: 2rem;
 }
 
-#weighted-settings .hints-div h3, #weighted-settings .locations-div h3{
+#weighted-settings .hints-div h3{
     margin-bottom: 0.5rem;
 }
 
-#weighted-settings .hints-container, #weighted-settings .locations-container{
+#weighted-settings .hints-div .hints-container{
     display: flex;
     flex-direction: row;
     justify-content: space-between;
-}
-
-#weighted-settings .hints-wrapper, #weighted-settings .locations-wrapper{
-    width: calc(50% - 0.5rem);
     font-weight: bold;
 }
 
-#weighted-settings .hints-wrapper .simple-list, #weighted-settings .locations-wrapper .simple-list{
-    margin-top: 0.25rem;
-    height: 300px;
-    font-weight: normal;
+#weighted-settings .hints-div .hints-wrapper{
+    width: 32.5%;
+}
+
+#weighted-settings .hints-div .hints-wrapper .hint-div{
+    display: flex;
+    flex-direction: row;
+    cursor: pointer;
+    user-select: none;
+    -moz-user-select: none;
+}
+
+#weighted-settings .hints-div .hints-wrapper .hint-div:hover{
+    background-color: rgba(0, 0, 0, 0.1);
+}
+
+#weighted-settings .hints-div .hints-wrapper .hint-div label{
+    flex-grow: 1;
+    padding: 0.125rem 0.5rem;
+    cursor: pointer;
 }
 
 #weighted-settings #weighted-settings-button-row{
@@ -268,36 +280,6 @@ html{
     flex-direction: column;
 }
 
-#weighted-settings .simple-list{
-    display: flex;
-    flex-direction: column;
-
-    max-height: 300px;
-    overflow-y: auto;
-    border: 1px solid #ffffff;
-    border-radius: 4px;
-}
-
-#weighted-settings .simple-list .list-row label{
-    display: block;
-    width: calc(100% - 0.5rem);
-    padding: 0.0625rem 0.25rem;
-}
-
-#weighted-settings .simple-list .list-row label:hover{
-    background-color: rgba(0, 0, 0, 0.1);
-}
-
-#weighted-settings .simple-list .list-row label input[type=checkbox]{
-    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" multiple>
+                    <input id="file-input" type="file" name="file">
                 </form>
-                <button id="check-button">Upload File(s)</button>
+                <button id="check-button">Upload</button>
             </div>
         </div>
     </div>

WebHostLib/templates/checkResult.html

@@ -28,10 +28,6 @@
                     {% 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/checksfinderTracker.html

@@ -7,11 +7,6 @@
 </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/generate.html

@@ -69,8 +69,8 @@
                                     </td>
                                     <td>
                                         <select name="collect_mode" id="collect_mode">
-                                            <option value="auto">Automatic on goal completion</option>
                                             <option value="goal">Allow !collect after goal completion</option>
+                                            <option value="auto">Automatic on goal completion</option>
                                             <option value="auto-enabled">
                                                 Automatic on goal completion and manual !collect
                                             </option>
@@ -93,9 +93,9 @@
                                             {% if race -%}
                                                 <option value="disabled">Disabled in Race mode</option>
                                             {%- else -%}
+                                                <option value="disabled">Disabled</option>
                                                 <option value="goal">Allow !remaining after goal completion</option>
                                                 <option value="enabled">Manual !remaining</option>
-                                                <option value="disabled">Disabled</option>
                                             {%- endif -%}
                                         </select>
                                     </td>
@@ -119,28 +119,6 @@
                                         </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>
@@ -185,12 +163,12 @@ Warning: playthrough can take a significant amount of time for larger multiworld
                                             </span>
                                         </td>
                                         <td>
-                                            <input type="checkbox" id="plando_items" name="plando_items" value="items">
-                                            <label for="plando_items">Items</label><br>
-
                                             <input type="checkbox" id="plando_bosses" name="plando_bosses" value="bosses" checked>
                                             <label for="plando_bosses">Bosses</label><br>
 
+                                            <input type="checkbox" id="plando_items" name="plando_items" value="items" checked>
+                                            <label for="plando_items">Items</label><br>
+
                                             <input type="checkbox" id="plando_connections" name="plando_connections" value="connections" checked>
                                             <label for="plando_connections">Connections</label><br>
 
@@ -203,10 +181,10 @@ Warning: playthrough can take a significant amount of time for larger multiworld
                         </div>
                     </div>
                     <div id="generate-form-button-row">
-                        <input id="file-input" type="file" name="file" multiple>
+                        <input id="file-input" type="file" name="file">
                     </div>
                 </form>
-                <button id="generate-game-button">Upload File(s)</button>
+                <button id="generate-game-button">Upload File</button>
             </div>
         </div>
     </div>

WebHostLib/templates/genericTracker.html

@@ -1,57 +1,36 @@
-{% 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-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 }}">
+    {% 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" />
-            <div class="info">This tracker will automatically update itself periodically.</div>
+            <input placeholder="Search" id="search"/>
+            <span class="info">This tracker will automatically update itself periodically.</span>
         </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>Last Order Received</th>
+                            <th>Order Received</th>
                         </tr>
                     </thead>
                     <tbody>
 
-                    {% 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>
+                    {% for id, count in inventory.items() %}
+                    <tr>
+                        <td>{{ id | item_name }}</td>
+                        <td>{{ count }}</td>
+                        <td>{{received_items[id]}}</td>
+                    </tr>
                     {%- endfor -%}
 
                     </tbody>
@@ -60,62 +39,24 @@
             <div class="table-wrapper">
                 <table id="locations-table" class="table non-unique-item-table">
                     <thead>
-                        <tr>
-                            <th>Location</th>
-                            <th class="center-column">Checked</th>
-                        </tr>
+                    <tr>
+                        <th>Location</th>
+                        <th>Checked</th>
+                    </tr>
                     </thead>
                     <tbody>
-
-                    {%- for location in locations -%}
+                        {% for name in checked_locations %}
                         <tr>
-                            <td>{{ location_id_to_name[game][location] }}</td>
-                            <td class="center-column">
-                                {% if location in checked_locations %}✔{% endif %}
-                            </td>
+                            <td>{{ name | location_name}}</td>
+                            <td>✔</td>
                         </tr>
-                    {%- endfor -%}
-
-                    </tbody>
-                </table>
-            </div>
-            <div class="table-wrapper">
-                <table id="hints-table" class="table non-unique-item-table">
-                    <thead>
+                        {%- endfor -%}
+                        {% for name in not_checked_locations %}
                         <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>
+                            <td>{{ name | location_name}}</td>
+                            <td></td>
                         </tr>
-                    </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 -%}
+                        {%- endfor -%}
                     </tbody>
                 </table>
             </div>

WebHostLib/templates/header/baseHeader.html

@@ -11,18 +11,10 @@
             </a>
         </div>
         <div id="base-header-right">
-            <div id="base-header-popover-text">
-                <img id="base-header-popover-icon" src="/static/static/button-images/popover.png" alt="Popover Menu" />
-                get started
-            </div>
-            <div id="base-header-popover-menu">
-                <a href="/games">supported games</a>
-                <a href="/tutorial">setup guides</a>
-                <a href="/generate">generate game</a>
-                <a href="/uploads">host game</a>
-                <a href="/user-content">user content</a>
-            </div>
-            <a href="/faq/en">f.a.q</a>
+            <a href="/games">supported games</a>
+            <a href="/tutorial">setup guides</a>
+            <a href="/start-playing">start playing</a>
+            <a href="/faq/en">f.a.q.</a>
             <a href="https://discord.gg/8Z65BR2" target="_blank">discord</a>
         </div>
         <div id="base-header-right-mobile">
@@ -30,14 +22,12 @@
                 <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="/start-playing">start playing</a>
+        <a href="/faq/en">f.a.q.</a>
+        <a href="https://discord.gg/8Z65BR2" target="_blank">discord</a>
+    </div>
 {% endblock %}

WebHostLib/templates/hostRoom.html

@@ -3,16 +3,6 @@
 {% 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 %}
 
@@ -42,18 +32,13 @@
         {% endif %}
         {{ macros.list_patches_room(room) }}
         {% if room.owner == session["_id"] %}
-            <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>
+            <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 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 2024 Archipelago</div>
+        <div id="copyright-notice">Copyright 2022 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>
-                    <a href="{{ url_for("stats") }}">{{ seeds }}</a>
+                    <span class="variable">{{ seeds }}</span>
                     games were generated and
-                    <a href="{{ url_for("stats") }}">{{ rooms }}</a>
+                    <span class="variable">{{ rooms }}</span>
                     were hosted in the last 7 days.
                 </p>
             </div>

WebHostLib/templates/lttpMultiTracker.html

@@ -0,0 +1,188 @@
+{% 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,37 +22,30 @@
             {% 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}}:None@{{ config['HOST_ADDRESS'] }}:{{ room.last_port }}">{{ patch.player_name }}</a></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>{{ patch.game }}</td>
                     <td>
-                        {% 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 == "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 %}
+                        {% 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 == "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>
                         {% else %}
                             No file to download for this game.
                         {% endif %}

WebHostLib/templates/minecraftTracker.html

@@ -8,18 +8,13 @@
 </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/multiFactorioTracker.html

@@ -0,0 +1,44 @@
+{% 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

@@ -0,0 +1,95 @@
+{% 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 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>
+                                    {%- 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

@@ -0,0 +1,9 @@
+{%- 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

@@ -1,144 +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" />
-
-            <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

@@ -1,37 +0,0 @@
-{% 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

@@ -1,16 +0,0 @@
-{% 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

@@ -1,205 +0,0 @@
-{% 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

@@ -1,41 +0,0 @@
-{% 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/options.yaml

@@ -17,10 +17,10 @@
 # A. This is a .yaml file. You are allowed to use most characters.
 #    To test if your yaml is valid or not, you can use this website:
 #        http://www.yamllint.com/
-#    You can also verify that your Archipelago options are valid at this site:
+#    You can also verify your Archipelago settings are valid at this site:
 #        https://archipelago.gg/check
 
-# Your name in-game, limited to 16 characters.
+# Your name in-game. Spaces will be replaced with underscores and there is a 16-character limit.
 #     {player} will be replaced with the player's slot number.
 #     {PLAYER} will be replaced with the player's slot number, if that slot number is greater than 1.
 #     {number} will be replaced with the counter value of the name.

WebHostLib/templates/pageWrapper.html

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

WebHostLib/templates/player-settings.html

@@ -1,26 +1,26 @@
 {% extends 'pageWrapper.html' %}
 
 {% block head %}
-    <title>{{ game }} Options</title>
+    <title>{{ game }} Settings</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-options.css") }}" />
+    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename="styles/player-settings.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-options.js") }}"></script>
+    <script type="application/ecmascript" src="{{ url_for('static', filename="assets/player-settings.js") }}"></script>
 {% endblock %}
 
 {% block body %}
     {% include 'header/'+theme+'Header.html' %}
-    <div id="player-options" class="markdown" data-game="{{ game }}">
+    <div id="player-settings" class="markdown" data-game="{{ game }}">
         <div id="user-message"></div>
-        <h1><span id="game-name">Player</span> Options</h1>
+        <h1><span id="game-name">Player</span> Settings</h1>
         <p>Choose the options you would like to play with! You may generate a single-player game from this page,
-            or download an options file you can use to participate in a MultiWorld.</p>
+            or download a settings file you can use to participate in a MultiWorld.</p>
 
         <p>
-            A more advanced options configuration for all games can be found on the
-            <a href="/weighted-options">Weighted options</a> page.
+            A more advanced settings configuration for all games can be found on the
+            <a href="/weighted-settings">Weighted Settings</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,24 +28,10 @@
             <a href="/static/generated/configs/{{ game }}.yaml">template file for this game</a>.
         </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>
+        <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>
 
         <h2>Game Options</h2>
         <div id="game-options">
@@ -53,8 +39,8 @@
             <div id="game-options-right" class="right"></div>
         </div>
 
-        <div id="player-options-button-row">
-            <button id="export-options">Export Options</button>
+        <div id="player-settings-button-row">
+            <button id="export-settings">Export Settings</button>
             <button id="generate-game">Generate Game</button>
             <button id="generate-race">Generate Race</button>
         </div>