Simplify sentence

The current flow of accessibility works like this:

```
if fulfills_accessibility fails:
    if multiworld can be beaten:
        log a warning
    else:
        raise Exception

if playthrough is enabled:
    if any progression items are not reachable:
        raise Exception
```

This means that if you do a generation where the game is beatable but some full players' items are not reachable, it doesn't crash on accessibility check, but then crashes on playthrough. This means that **whether it crashes depends on whether you have playthrough enabled or not**.

Imo, erroring on something accessibility-related is outside of the scope of create_playthrough. Create_playthrough only needs to care about whether it can fulfill its own goal - Building a minimal playthrough to everyone's victory.
The actual accessibility check should take care of the accessibility.

.coveragerc

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

.dockerignore

@@ -0,0 +1,210 @@
+.git
+.github
+.run
+docs
+test
+typings
+*Client.py
+
+.idea
+.vscode
+
+*_Spoiler.txt
+*.bmbp
+*.apbp
+*.apl2ac
+*.apm3
+*.apmc
+*.apz5
+*.aptloz
+*.apemerald
+*.pyc
+*.pyd
+*.sfc
+*.z64
+*.n64
+*.nes
+*.smc
+*.sms
+*.gb
+*.gbc
+*.gba
+*.wixobj
+*.lck
+*.db3
+*multidata
+*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/
+_persistent_storage.yaml
+mystery_result_*.yaml
+*-errors.txt
+success.txt
+output/
+Output Logs/
+/factorio/
+/Minecraft Forge Server/
+/WebHostLib/static/generated
+/freeze_requirements.txt
+/Archipelago.zip
+/setup.ini
+/installdelete.iss
+/data/user.kv
+/datapackage
+/custom_worlds
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+*.dll
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+installer.log
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# vim editor
+*.swp
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv*
+env/
+venv/
+/venv*/
+ENV/
+env.bak/
+venv.bak/
+*.code-workspace
+shell.nix
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# Cython intermediates
+_speedups.c
+_speedups.cpp
+_speedups.html
+
+# minecraft server stuff
+jdk*/
+minecraft*/
+minecraft_versions.json
+!worlds/minecraft/
+
+# pyenv
+.python-version
+
+#undertale stuff
+/Undertale/
+
+# OS General Files
+.DS_Store
+.AppleDouble
+.LSOverride
+Thumbs.db
+[Dd]esktop.ini

.gitattributes

@@ -0,0 +1,2 @@
+worlds/blasphemous/region_data.py linguist-generated=true
+worlds/yachtdice/YachtWeights.py linguist-generated=true

.github/labeler.yml

@@ -0,0 +1,30 @@
+'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/**'
+    - '!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

@@ -0,0 +1,40 @@
+{
+  "include": [
+    "../BizHawkClient.py",
+    "../Patch.py",
+    "../test/param.py",
+    "../test/general/test_groups.py",
+    "../test/general/test_helpers.py",
+    "../test/general/test_memory.py",
+    "../test/general/test_names.py",
+    "../test/multiworld/__init__.py",
+    "../test/multiworld/test_multiworlds.py",
+    "../test/netutils/__init__.py",
+    "../test/programs/__init__.py",
+    "../test/programs/test_multi_server.py",
+    "../test/utils/__init__.py",
+    "../test/webhost/test_descriptions.py",
+    "../worlds/AutoSNIClient.py",
+    "type_check.py"
+  ],
+
+  "exclude": [
+    "**/__pycache__"
+  ],
+
+  "stubPath": "../typings",
+
+  "typeCheckingMode": "strict",
+  "reportImplicitOverride": "error",
+  "reportMissingImports": true,
+  "reportMissingTypeStubs": true,
+
+  "pythonVersion": "3.11",
+  "pythonPlatform": "Windows",
+
+  "executionEnvironments": [
+    {
+      "root": ".."
+    }
+  ]
+}

.github/type_check.py

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

@@ -0,0 +1,80 @@
+name: Analyze modified files
+
+on:
+  pull_request:
+    paths:
+      - "**.py"
+  push:
+    paths:
+      - "**.py"
+
+env:
+  BASE: ${{ github.event.pull_request.base.sha }}
+  HEAD: ${{ github.event.pull_request.head.sha }}
+  BEFORE: ${{ github.event.before }}
+  AFTER: ${{ github.event.after }}
+
+jobs:
+  flake8-or-mypy:
+    strategy:
+      fail-fast: false
+      matrix:
+        task: [flake8, mypy]
+
+    name: ${{ matrix.task }}
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: "Determine modified files (pull_request)"
+        if: github.event_name == 'pull_request'
+        run: |
+          git fetch origin $BASE $HEAD
+          DIFF=$(git diff --diff-filter=d --name-only $BASE...$HEAD -- "*.py")
+          echo "modified files:"
+          echo "$DIFF"
+          echo "diff=${DIFF//$'\n'/$' '}" >> $GITHUB_ENV
+
+      - name: "Determine modified files (push)"
+        if: github.event_name == 'push' && github.event.before != '0000000000000000000000000000000000000000'
+        run: |
+          git fetch origin $BEFORE $AFTER
+          DIFF=$(git diff --diff-filter=d --name-only $BEFORE..$AFTER -- "*.py")
+          echo "modified files:"
+          echo "$DIFF"
+          echo "diff=${DIFF//$'\n'/$' '}" >> $GITHUB_ENV
+
+      - name: "Treat all files as modified (new branch)"
+        if: github.event_name == 'push' && github.event.before == '0000000000000000000000000000000000000000'
+        run: |
+          echo "diff=." >> $GITHUB_ENV
+
+      - uses: actions/setup-python@v5
+        if: env.diff != ''
+        with:
+          python-version: '3.11'
+
+      - 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 --ignore F824 --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

@@ -2,104 +2,215 @@
 
 name: Build
 
-on: workflow_dispatch
+on:
+  push:
+    paths:
+      - '.github/workflows/build.yml'
+      - 'setup.py'
+      - 'requirements.txt'
+      - '*.iss'
+  pull_request:
+    paths:
+      - '.github/workflows/build.yml'
+      - 'setup.py'
+      - 'requirements.txt'
+      - '*.iss'
+  workflow_dispatch:
 
 env:
-  SNI_VERSION: v0.0.84
   ENEMIZER_VERSION: 7.1
-  APPIMAGETOOL_VERSION: 13
+  # NOTE: since appimage/appimagetool and appimage/type2-runtime does not have tags anymore,
+  #       we check the sha256 and require manual intervention if it was updated.
+  APPIMAGETOOL_VERSION: continuous
+  APPIMAGETOOL_X86_64_HASH: '29348a20b80827cd261c28e95172ff828b69d43d4e4e18e3fd069e2c8693c94e'
+  APPIMAGE_RUNTIME_VERSION: continuous
+  APPIMAGE_RUNTIME_X86_64_HASH: 'e70ffa9b69b211574d0917adc482dd66f25a0083427b5945783965d55b0b0a8b'
+
+permissions:  # permissions required for attestation
+  id-token: 'write'
+  attestations: 'write'
 
 jobs:
   # build-release-macos: # LF volunteer
 
-  build-win-py38: # RCs will still be built and signed by hand
+  build-win: # RCs and releases may still be built and signed by hand
     runs-on: windows-latest
     steps:
-      - uses: actions/checkout@v2
+      # - copy code below to release.yml -
+      - uses: actions/checkout@v4
       - name: Install python
-        uses: actions/setup-python@v3
+        uses: actions/setup-python@v5
         with:
-          python-version: '3.8'
+          python-version: '~3.12.7'
+          check-latest: true
       - name: Download run-time dependencies
         run: |
-          Invoke-WebRequest -Uri https://github.com/alttpo/sni/releases/download/${Env:SNI_VERSION}/sni-${Env:SNI_VERSION}-windows-amd64.zip -OutFile sni.zip
-          Expand-Archive -Path sni.zip -DestinationPath SNI -Force
           Invoke-WebRequest -Uri https://github.com/Ijwu/Enemizer/releases/download/${Env:ENEMIZER_VERSION}/win-x64.zip -OutFile enemizer.zip
           Expand-Archive -Path enemizer.zip -DestinationPath EnemizerCLI -Force
+          choco install innosetup --version=6.2.2 --allow-downgrade
       - name: Build
         run: |
-          python -m pip install --upgrade pip setuptools
-          pip install -r requirements.txt
+          python -m pip install --upgrade pip
           python setup.py build_exe --yes
-          $NAME="$(ls build)".Split('.',2)[1]
+          if ( $? -eq $false ) {
+            Write-Error "setup.py failed!"
+            exit 1
+          }
+          $NAME="$(ls build | Select-String -Pattern 'exe')".Split('.',2)[1]
           $ZIP_NAME="Archipelago_$NAME.7z"
+          echo "$NAME -> $ZIP_NAME"
           echo "ZIP_NAME=$ZIP_NAME" >> $Env:GITHUB_ENV
           New-Item -Path dist -ItemType Directory -Force
           cd build
-          Rename-Item exe.$NAME Archipelago
+          Rename-Item "exe.$NAME" Archipelago
           7z a -mx=9 -mhe=on -ms "../dist/$ZIP_NAME" Archipelago
+          Rename-Item Archipelago "exe.$NAME"  # inno_setup.iss expects the original name
+      - name: Build Setup
+        run: |
+          & "${env:ProgramFiles(x86)}\Inno Setup 6\iscc.exe" inno_setup.iss /DNO_SIGNTOOL
+          if ( $? -eq $false ) {
+            Write-Error "Building setup failed!"
+            exit 1
+          }
+          $contents = Get-ChildItem -Path setups/*.exe -Force -Recurse
+          $SETUP_NAME=$contents[0].Name
+          echo "SETUP_NAME=$SETUP_NAME" >> $Env:GITHUB_ENV
+      # - copy code above to release.yml -
+      - name: Attest Build
+        if: ${{ github.event_name == 'workflow_dispatch' }}
+        uses: actions/attest-build-provenance@v2
+        with:
+          subject-path: |
+            build/exe.*/ArchipelagoLauncher.exe
+            build/exe.*/ArchipelagoLauncherDebug.exe
+            build/exe.*/ArchipelagoGenerate.exe
+            build/exe.*/ArchipelagoServer.exe
+            dist/${{ env.ZIP_NAME }}
+            setups/${{ env.SETUP_NAME }}
+      - name: Check build loads expected worlds
+        shell: bash
+        run: |
+          cd build/exe*
+          mv Players/Templates/meta.yaml .
+          ls -1 Players/Templates | sort > setup-player-templates.txt
+          rm -R Players/Templates
+          timeout 30 ./ArchipelagoLauncher "Generate Template Options" || true
+          ls -1 Players/Templates | sort > generated-player-templates.txt
+          cmp setup-player-templates.txt generated-player-templates.txt \
+            || diff setup-player-templates.txt generated-player-templates.txt
+          mv meta.yaml Players/Templates/
+      - name: Test Generate
+        shell: bash
+        run: |
+          cd build/exe*
+          cp Players/Templates/VVVVVV.yaml Players/
+          timeout 30 ./ArchipelagoGenerate
       - name: Store 7z
-        uses: actions/upload-artifact@v2
+        uses: actions/upload-artifact@v4
         with:
           name: ${{ env.ZIP_NAME }}
           path: dist/${{ env.ZIP_NAME }}
+          compression-level: 0  # .7z is incompressible by zip
+          if-no-files-found: error
+          retention-days: 7  # keep for 7 days, should be enough
+      - name: Store Setup
+        uses: actions/upload-artifact@v4
+        with:
+          name: ${{ env.SETUP_NAME }}
+          path: setups/${{ env.SETUP_NAME }}
+          if-no-files-found: error
           retention-days: 7  # keep for 7 days, should be enough
 
-  build-ubuntu1804:
-    runs-on: ubuntu-18.04
+  build-ubuntu2204:
+    runs-on: ubuntu-22.04
     steps:
       # - copy code below to release.yml -
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
       - name: Install base dependencies
         run: |
           sudo apt update
           sudo apt -y install build-essential p7zip xz-utils wget libglib2.0-0
           sudo apt -y install python3-gi libgirepository1.0-dev  # should pull dependencies for gi installation below
       - name: Get a recent python
-        uses: actions/setup-python@v3
+        uses: actions/setup-python@v5
         with:
-          python-version: '3.9'
+          python-version: '~3.12.7'
+          check-latest: true
       - name: Install build-time dependencies
         run: |
-          echo "PYTHON=python3.9" >> $GITHUB_ENV
-          wget -nv https://github.com/AppImage/AppImageKit/releases/download/$APPIMAGETOOL_VERSION/appimagetool-x86_64.AppImage
+          echo "PYTHON=python3.12" >> $GITHUB_ENV
+          wget -nv https://github.com/AppImage/appimagetool/releases/download/$APPIMAGETOOL_VERSION/appimagetool-x86_64.AppImage
+          echo "$APPIMAGETOOL_X86_64_HASH appimagetool-x86_64.AppImage" | sha256sum -c
+          wget -nv https://github.com/AppImage/type2-runtime/releases/download/$APPIMAGE_RUNTIME_VERSION/runtime-x86_64
+          echo "$APPIMAGE_RUNTIME_X86_64_HASH runtime-x86_64" | sha256sum -c
           chmod a+rx appimagetool-x86_64.AppImage
           ./appimagetool-x86_64.AppImage --appimage-extract
-          echo -e '#/bin/sh\n./squashfs-root/AppRun "$@"' > appimagetool
+          echo -e '#/bin/sh\n./squashfs-root/AppRun --runtime-file runtime-x86_64 "$@"' > appimagetool
           chmod a+rx appimagetool
       - name: Download run-time dependencies
         run: |
-          wget -nv https://github.com/alttpo/sni/releases/download/$SNI_VERSION/sni-$SNI_VERSION-manylinux2014-amd64.tar.xz
-          tar xf sni-*.tar.xz
-          rm sni-*.tar.xz
-          mv sni-* SNI
           wget -nv https://github.com/Ijwu/Enemizer/releases/download/$ENEMIZER_VERSION/ubuntu.16.04-x64.7z
           7za x -oEnemizerCLI/ ubuntu.16.04-x64.7z
       - name: Build
         run: |
           # pygobject is an optional dependency for kivy that's not in requirements
-          "${{ env.PYTHON }}" -m pip install --upgrade pip virtualenv PyGObject setuptools
+          # charset-normalizer was somehow incomplete in the github runner
           "${{ env.PYTHON }}" -m venv venv
           source venv/bin/activate
-          pip install -r requirements.txt
+          "${{ env.PYTHON }}" -m pip install --upgrade pip "PyGObject<3.51.0" charset-normalizer
           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`"
           cd dist && export APPIMAGE_NAME="`ls *.AppImage`" && cd ..
           export TAR_NAME="${APPIMAGE_NAME%.AppImage}.tar.gz"
-          (cd build && DIR_NAME="`ls | grep exe`" && mv "$DIR_NAME" Archipelago && tar -czvf ../dist/$TAR_NAME Archipelago && mv Archipelago "$DIR_NAME")
+          (cd build && DIR_NAME="`ls | grep exe`" && mv "$DIR_NAME" Archipelago && tar -cv Archipelago | gzip -8 > ../dist/$TAR_NAME && mv Archipelago "$DIR_NAME")
           echo "APPIMAGE_NAME=$APPIMAGE_NAME" >> $GITHUB_ENV
           echo "TAR_NAME=$TAR_NAME" >> $GITHUB_ENV
       # - copy code above to release.yml -
+      - name: Attest Build
+        if: ${{ github.event_name == 'workflow_dispatch' }}
+        uses: actions/attest-build-provenance@v2
+        with:
+          subject-path: |
+            build/exe.*/ArchipelagoLauncher
+            build/exe.*/ArchipelagoGenerate
+            build/exe.*/ArchipelagoServer
+            dist/${{ env.APPIMAGE_NAME }}*
+            dist/${{ env.TAR_NAME }}
+      - name: Build Again
+        run: |
+          source venv/bin/activate
+          python setup.py build_exe --yes
+      - name: Check build loads expected worlds
+        shell: bash
+        run: |
+          cd build/exe*
+          mv Players/Templates/meta.yaml .
+          ls -1 Players/Templates | sort > setup-player-templates.txt
+          rm -R Players/Templates
+          timeout 30 ./ArchipelagoLauncher "Generate Template Options" || true
+          ls -1 Players/Templates | sort > generated-player-templates.txt
+          cmp setup-player-templates.txt generated-player-templates.txt \
+            || diff setup-player-templates.txt generated-player-templates.txt
+          mv meta.yaml Players/Templates/
+      - name: Test Generate
+        shell: bash
+        run: |
+          cd build/exe*
+          cp Players/Templates/VVVVVV.yaml Players/
+          timeout 30 ./ArchipelagoGenerate
       - name: Store AppImage
-        uses: actions/upload-artifact@v2
+        uses: actions/upload-artifact@v4
         with:
           name: ${{ env.APPIMAGE_NAME }}
           path: dist/${{ env.APPIMAGE_NAME }}
+          if-no-files-found: error
           retention-days: 7
       - name: Store .tar.gz
-        uses: actions/upload-artifact@v2
+        uses: actions/upload-artifact@v4
         with:
           name: ${{ env.TAR_NAME }}
           path: dist/${{ env.TAR_NAME }}
+          compression-level: 0  # .gz is incompressible by zip
+          if-no-files-found: error
           retention-days: 7

.github/workflows/codeql-analysis.yml

@@ -14,9 +14,17 @@ name: "CodeQL"
 on:
   push:
     branches: [ main ]
+    paths:
+      - '**.py'
+      - '**.js'
+      - '.github/workflows/codeql-analysis.yml'
   pull_request:
     # The branches below must be a subset of the branches above
     branches: [ main ]
+    paths:
+      - '**.py'
+      - '**.js'
+      - '.github/workflows/codeql-analysis.yml'
   schedule:
     - cron: '44 8 * * 1'
 
@@ -35,11 +43,11 @@ jobs:
 
     steps:
     - name: Checkout repository
-      uses: actions/checkout@v2
+      uses: actions/checkout@v4
 
     # Initializes the CodeQL tools for scanning.
     - name: Initialize CodeQL
-      uses: github/codeql-action/init@v1
+      uses: github/codeql-action/init@v3
       with:
         languages: ${{ matrix.language }}
         # If you wish to specify custom queries, you can do so here or in a config file.
@@ -50,7 +58,7 @@ jobs:
     # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
     # If this step fails, then you should remove it and run the build manually (see below)
     - name: Autobuild
-      uses: github/codeql-action/autobuild@v1
+      uses: github/codeql-action/autobuild@v3
 
     # ℹ️ Command-line programs to run using the OS shell.
     # 📚 https://git.io/JvXDl
@@ -64,4 +72,4 @@ jobs:
     #   make release
 
     - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v1
+      uses: github/codeql-action/analyze@v3

.github/workflows/ctest.yml

@@ -0,0 +1,54 @@
+# Run CMake / CTest C++ unit tests
+
+name: ctest
+
+on:
+  push:
+    paths:
+      - '**.cc?'
+      - '**.cpp'
+      - '**.cxx'
+      - '**.hh?'
+      - '**.hpp'
+      - '**.hxx'
+      - '**/CMakeLists.txt'
+      - '.github/workflows/ctest.yml'
+  pull_request:
+    paths:
+      - '**.cc?'
+      - '**.cpp'
+      - '**.cxx'
+      - '**.hh?'
+      - '**.hpp'
+      - '**.hxx'
+      - '**/CMakeLists.txt'
+      - '.github/workflows/ctest.yml'
+
+jobs:
+  ctest:
+    runs-on: ${{ matrix.os }}
+    name: Test C++ ${{ matrix.os }}
+
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest]
+
+    steps:
+    - uses: actions/checkout@v4
+    - uses: ilammy/msvc-dev-cmd@0b201ec74fa43914dc39ae48a89fd1d8cb592756
+      if: startsWith(matrix.os,'windows')
+    - uses: Bacondish2023/setup-googletest@49065d1f7a6d21f6134864dd65980fe5dbe06c73
+      with:
+        build-type: 'Release'
+    - name: Build tests
+      run: |
+        cd test/cpp
+        mkdir build
+        cmake -S . -B build/ -DCMAKE_BUILD_TYPE=Release
+        cmake --build build/ --config Release
+        ls
+    - name: Run tests
+      run: |
+        cd test/cpp
+        ctest --test-dir build/ -C Release --output-on-failure

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

@@ -0,0 +1,48 @@
+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
+env:
+  GH_REPO: ${{ github.repository }}
+
+jobs:
+  labeler:
+    name: 'Apply content-based labels'
+    if: github.event.action == 'opened' || github.event.action == 'reopened' || github.event.action == 'synchronize'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/labeler@v5
+        with:
+          sync-labels: false
+  peer_review:
+    name: 'Apply peer review label'
+    needs: labeler
+    if: >-
+      (github.event.action == 'opened' || github.event.action == 'reopened' || 
+      github.event.action == 'ready_for_review') && !github.event.pull_request.draft
+    runs-on: ubuntu-latest
+    steps:
+      - name: 'Add label'
+        run: "gh pr edit \"$PR_URL\" --add-label 'waiting-on: peer-review'"
+        env:
+          PR_URL: ${{ github.event.pull_request.html_url }}
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+  unblock_draft_prs:
+    name: 'Remove waiting-on labels'
+    needs: labeler
+    if: github.event.action == 'converted_to_draft' || github.event.action == 'closed'
+    runs-on: ubuntu-latest
+    steps:
+      - name: 'Remove labels'
+        run: |-
+          gh pr edit "$PR_URL" --remove-label 'waiting-on: peer-review' \
+            --remove-label 'waiting-on: core-review' \
+            --remove-label 'waiting-on: world-maintainer' \
+            --remove-label 'waiting-on: author'
+        env:
+          PR_URL: ${{ github.event.pull_request.html_url }}
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/lint.yml

@@ -1,29 +0,0 @@
-# This workflow will install Python dependencies, run tests and lint with a single version of Python
-# For more information see: https://help.github.com/actions/language-and-framework-guides/using-python-with-github-actions
-
-name: lint
-
-on: [push, pull_request]
-
-jobs:
-  build:
-
-    runs-on: ubuntu-latest
-
-    steps:
-    - uses: actions/checkout@v2
-    - name: Set up Python 3.9
-      uses: actions/setup-python@v1
-      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

@@ -5,12 +5,21 @@ name: Release
 on:
   push:
     tags:
-      - '*.*.*'
+      - 'v?[0-9]+.[0-9]+.[0-9]*'
 
 env:
-  SNI_VERSION: v0.0.84
   ENEMIZER_VERSION: 7.1
-  APPIMAGETOOL_VERSION: 13
+  # NOTE: since appimage/appimagetool and appimage/type2-runtime does not have tags anymore,
+  #       we check the sha256 and require manual intervention if it was updated.
+  APPIMAGETOOL_VERSION: continuous
+  APPIMAGETOOL_X86_64_HASH: '29348a20b80827cd261c28e95172ff828b69d43d4e4e18e3fd069e2c8693c94e'
+  APPIMAGE_RUNTIME_VERSION: continuous
+  APPIMAGE_RUNTIME_X86_64_HASH: 'e70ffa9b69b211574d0917adc482dd66f25a0083427b5945783965d55b0b0a8b'
+
+permissions:  # permissions required for attestation
+  id-token: 'write'
+  attestations: 'write'
+  contents: 'write'  # additionally required for release
 
 jobs:
   create-release:
@@ -19,7 +28,7 @@ jobs:
       - name: Set env
         run: echo "RELEASE_VERSION=${GITHUB_REF#refs/*/}" >> $GITHUB_ENV  # tag x.y.z will become "Archipelago x.y.z"
       - name: Create Release
-        uses: softprops/action-gh-release@b7e450da2a4b4cb4bfbae528f788167786cfcedf
+        uses: softprops/action-gh-release@975c1b265e11dd76618af1c374e7981f9a6ff44a
         with:
           draft: true  # don't publish right away, especially since windows build is added by hand
           prerelease: false
@@ -27,59 +36,135 @@ jobs:
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
-  # build-release-windows: # this is done by hand because of signing
   # build-release-macos: # LF volunteer
 
-  build-release-ubuntu1804:
-    runs-on: ubuntu-18.04
+  build-release-win:
+    runs-on: windows-latest
+    if: ${{ true }}  # change to false to skip if release is built by hand
+    needs: create-release
+    steps:
+      - name: Set env
+        shell: bash
+        run: echo "RELEASE_VERSION=${GITHUB_REF#refs/*/}" >> $GITHUB_ENV
+      # - code below copied from build.yml -
+      - uses: actions/checkout@v4
+      - name: Install python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '~3.12.7'
+          check-latest: true
+      - name: Download run-time dependencies
+        run: |
+          Invoke-WebRequest -Uri https://github.com/Ijwu/Enemizer/releases/download/${Env:ENEMIZER_VERSION}/win-x64.zip -OutFile enemizer.zip
+          Expand-Archive -Path enemizer.zip -DestinationPath EnemizerCLI -Force
+          choco install innosetup --version=6.2.2 --allow-downgrade
+      - name: Build
+        run: |
+          python -m pip install --upgrade pip
+          python setup.py build_exe --yes
+          if ( $? -eq $false ) {
+            Write-Error "setup.py failed!"
+            exit 1
+          }
+          $NAME="$(ls build | Select-String -Pattern 'exe')".Split('.',2)[1]
+          $ZIP_NAME="Archipelago_$NAME.7z"
+          echo "$NAME -> $ZIP_NAME"
+          echo "ZIP_NAME=$ZIP_NAME" >> $Env:GITHUB_ENV
+          New-Item -Path dist -ItemType Directory -Force
+          cd build
+          Rename-Item "exe.$NAME" Archipelago
+          7z a -mx=9 -mhe=on -ms "../dist/$ZIP_NAME" Archipelago
+          Rename-Item Archipelago "exe.$NAME"  # inno_setup.iss expects the original name
+      - name: Build Setup
+        run: |
+          & "${env:ProgramFiles(x86)}\Inno Setup 6\iscc.exe" inno_setup.iss /DNO_SIGNTOOL
+          if ( $? -eq $false ) {
+            Write-Error "Building setup failed!"
+            exit 1
+          }
+          $contents = Get-ChildItem -Path setups/*.exe -Force -Recurse
+          $SETUP_NAME=$contents[0].Name
+          echo "SETUP_NAME=$SETUP_NAME" >> $Env:GITHUB_ENV
+      # - code above copied from build.yml -
+      - name: Attest Build
+        uses: actions/attest-build-provenance@v2
+        with:
+          subject-path: |
+            build/exe.*/ArchipelagoLauncher.exe
+            build/exe.*/ArchipelagoLauncherDebug.exe
+            build/exe.*/ArchipelagoGenerate.exe
+            build/exe.*/ArchipelagoServer.exe
+            setups/*
+      - name: Add to Release
+        uses: softprops/action-gh-release@975c1b265e11dd76618af1c374e7981f9a6ff44a
+        with:
+          draft: true  # see above
+          prerelease: false
+          name: Archipelago ${{ env.RELEASE_VERSION }}
+          files: |
+            setups/*
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+  build-release-ubuntu2204:
+    runs-on: ubuntu-22.04
+    needs: create-release
     steps:
       - name: Set env
         run: echo "RELEASE_VERSION=${GITHUB_REF#refs/*/}" >> $GITHUB_ENV
       # - code below copied from build.yml -
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
       - name: Install base dependencies
         run: |
           sudo apt update
           sudo apt -y install build-essential p7zip xz-utils wget libglib2.0-0
           sudo apt -y install python3-gi libgirepository1.0-dev  # should pull dependencies for gi installation below
       - name: Get a recent python
-        uses: actions/setup-python@v3
+        uses: actions/setup-python@v5
         with:
-          python-version: '3.9'
+          python-version: '~3.12.7'
+          check-latest: true
       - name: Install build-time dependencies
         run: |
-          echo "PYTHON=python3.9" >> $GITHUB_ENV
-          wget -nv https://github.com/AppImage/AppImageKit/releases/download/$APPIMAGETOOL_VERSION/appimagetool-x86_64.AppImage
+          echo "PYTHON=python3.12" >> $GITHUB_ENV
+          wget -nv https://github.com/AppImage/appimagetool/releases/download/$APPIMAGETOOL_VERSION/appimagetool-x86_64.AppImage
+          echo "$APPIMAGETOOL_X86_64_HASH appimagetool-x86_64.AppImage" | sha256sum -c
+          wget -nv https://github.com/AppImage/type2-runtime/releases/download/$APPIMAGE_RUNTIME_VERSION/runtime-x86_64
+          echo "$APPIMAGE_RUNTIME_X86_64_HASH runtime-x86_64" | sha256sum -c
           chmod a+rx appimagetool-x86_64.AppImage
           ./appimagetool-x86_64.AppImage --appimage-extract
-          echo -e '#/bin/sh\n./squashfs-root/AppRun "$@"' > appimagetool
+          echo -e '#/bin/sh\n./squashfs-root/AppRun --runtime-file runtime-x86_64 "$@"' > appimagetool
           chmod a+rx appimagetool
       - name: Download run-time dependencies
         run: |
-          wget -nv https://github.com/alttpo/sni/releases/download/$SNI_VERSION/sni-$SNI_VERSION-manylinux2014-amd64.tar.xz
-          tar xf sni-*.tar.xz
-          rm sni-*.tar.xz
-          mv sni-* SNI
           wget -nv https://github.com/Ijwu/Enemizer/releases/download/$ENEMIZER_VERSION/ubuntu.16.04-x64.7z
           7za x -oEnemizerCLI/ ubuntu.16.04-x64.7z
       - name: Build
         run: |
           # pygobject is an optional dependency for kivy that's not in requirements
-          "${{ env.PYTHON }}" -m pip install --upgrade pip virtualenv PyGObject setuptools
+          # charset-normalizer was somehow incomplete in the github runner
           "${{ env.PYTHON }}" -m venv venv
           source venv/bin/activate
-          pip install -r requirements.txt
-          python setup.py build --yes bdist_appimage --yes
+          "${{ env.PYTHON }}" -m pip install --upgrade pip "PyGObject<3.51.0" charset-normalizer
+          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`"
           cd dist && export APPIMAGE_NAME="`ls *.AppImage`" && cd ..
           export TAR_NAME="${APPIMAGE_NAME%.AppImage}.tar.gz"
-          (cd build && DIR_NAME="`ls | grep exe`" && mv "$DIR_NAME" Archipelago && tar -czvf ../dist/$TAR_NAME Archipelago && mv Archipelago "$DIR_NAME")
+          (cd build && DIR_NAME="`ls | grep exe`" && mv "$DIR_NAME" Archipelago && tar -cv Archipelago | gzip -8 > ../dist/$TAR_NAME && mv Archipelago "$DIR_NAME")
           echo "APPIMAGE_NAME=$APPIMAGE_NAME" >> $GITHUB_ENV
           echo "TAR_NAME=$TAR_NAME" >> $GITHUB_ENV
       # - code above copied from build.yml -
+      - name: Attest Build
+        uses: actions/attest-build-provenance@v2
+        with:
+          subject-path: |
+            build/exe.*/ArchipelagoLauncher
+            build/exe.*/ArchipelagoGenerate
+            build/exe.*/ArchipelagoServer
+            dist/*
       - name: Add to Release
-        uses: softprops/action-gh-release@b7e450da2a4b4cb4bfbae528f788167786cfcedf
+        uses: softprops/action-gh-release@975c1b265e11dd76618af1c374e7981f9a6ff44a
         with:
           draft: true  # see above
           prerelease: false

.github/workflows/scan-build.yml

@@ -0,0 +1,65 @@
+name: Native Code Static Analysis
+
+on:
+  push:
+    paths:
+      - '**.c'
+      - '**.cc'
+      - '**.cpp'
+      - '**.cxx'
+      - '**.h'
+      - '**.hh'
+      - '**.hpp'
+      - '**.pyx'
+      - 'setup.py'
+      - 'requirements.txt'
+      - '.github/workflows/scan-build.yml'
+  pull_request:
+    paths:
+      - '**.c'
+      - '**.cc'
+      - '**.cpp'
+      - '**.cxx'
+      - '**.h'
+      - '**.hh'
+      - '**.hpp'
+      - '**.pyx'
+      - 'setup.py'
+      - 'requirements.txt'
+      - '.github/workflows/scan-build.yml'
+
+jobs:
+  scan-build:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        submodules: recursive
+    - name: Install newer Clang
+      run: |
+        wget https://apt.llvm.org/llvm.sh
+        chmod +x ./llvm.sh
+        sudo ./llvm.sh 19
+    - name: Install scan-build command
+      run: |
+        sudo apt install clang-tools-19
+    - 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-19 --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

@@ -0,0 +1,33 @@
+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.392.post0
+          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

@@ -3,10 +3,34 @@
 
 name: unittests
 
-on: [push, pull_request]
+on:
+  push:
+    paths:
+      - '**'
+      - '!docs/**'
+      - '!deploy/**'
+      - '!setup.py'
+      - '!Dockerfile'
+      - '!*.iss'
+      - '!.gitignore'
+      - '!.dockerignore'
+      - '!.github/workflows/**'
+      - '.github/workflows/unittests.yml'
+  pull_request:
+    paths:
+      - '**'
+      - '!docs/**'
+      - '!deploy/**'
+      - '!setup.py'
+      - '!Dockerfile'
+      - '!*.iss'
+      - '!.gitignore'
+      - '!.dockerignore'
+      - '!.github/workflows/**'
+      - '.github/workflows/unittests.yml'
 
 jobs:
-  build:
+  unit:
     runs-on: ${{ matrix.os }}
     name: Test Python ${{ matrix.python.version }} ${{ matrix.os }}
 
@@ -15,26 +39,58 @@ jobs:
       matrix:
         os: [ubuntu-latest]
         python:
-          - {version: '3.8'}
-          - {version: '3.9'}
-          - {version: '3.10'}
+          - {version: '3.11.2'} # Change to '3.11' around 2026-06-10
+          - {version: '3.12'}
+          - {version: '3.13'}
         include:
-          - python: {version: '3.8'}  # win7 compat
+          - python: {version: '3.11'}  # old compat
             os: windows-latest
-          - python: {version: '3.10'}  # current
+          - python: {version: '3.13'}  # current
             os: windows-latest
+          - python: {version: '3.13'}  # current
+            os: macos-latest
 
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v4
     - name: Set up Python ${{ matrix.python.version }}
-      uses: actions/setup-python@v1
+      uses: actions/setup-python@v5
       with:
         python-version: ${{ matrix.python.version }}
     - name: Install dependencies
       run: |
-        python -m pip install --upgrade pip wheel
-        pip install flake8 pytest pytest-subtests
+        python -m pip install --upgrade pip
+        pip install pytest pytest-subtests pytest-xdist
         python ModuleUpdate.py --yes --force --append "WebHostLib/requirements.txt"
+        python Launcher.py --update_settings  # make sure host.yaml exists for tests
     - name: Unittests
       run: |
-        pytest
+        pytest -n auto
+
+  hosting:
+    runs-on: ${{ matrix.os }}
+    name: Test hosting with ${{ matrix.python.version }} on ${{ matrix.os }}
+
+    strategy:
+      matrix:
+        os:
+          - ubuntu-latest
+        python:
+          - {version: '3.13'}  # current
+
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up Python ${{ matrix.python.version }}
+      uses: actions/setup-python@v5
+      with:
+        python-version: ${{ matrix.python.version }}
+    - name: Install dependencies
+      run: |
+        python -m venv venv
+        source venv/bin/activate
+        python -m pip install --upgrade pip
+        python ModuleUpdate.py --yes --force --append "WebHostLib/requirements.txt"
+    - name: Test hosting
+      run: |
+        source venv/bin/activate
+        export PYTHONPATH=$(pwd)
+        timeout 600 python test/hosting/__main__.py

.gitignore

@@ -4,16 +4,21 @@
 *_Spoiler.txt
 *.bmbp
 *.apbp
+*.apcivvi
 *.apl2ac
 *.apm3
 *.apmc
 *.apz5
+*.aptloz
+*.aptww
+*.apemerald
 *.pyc
 *.pyd
 *.sfc
 *.z64
 *.n64
 *.nes
+*.smc
 *.sms
 *.gb
 *.gbc
@@ -25,15 +30,22 @@
 *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/
@@ -44,12 +56,14 @@ success.txt
 output/
 Output Logs/
 /factorio/
-/Minecraft Forge Server/
 /WebHostLib/static/generated
 /freeze_requirements.txt
 /Archipelago.zip
 /setup.ini
 /installdelete.iss
+/data/user.kv
+/datapackage
+/custom_worlds
 
 # Byte-compiled / optimized / DLL files
 __pycache__/
@@ -133,10 +147,12 @@ ipython_config.py
 .venv*
 env/
 venv/
+/venv*/
 ENV/
 env.bak/
 venv.bak/
-.code-workspace
+*.code-workspace
+shell.nix
 
 # Spyder project settings
 .spyderproject
@@ -162,14 +178,17 @@ dmypy.json
 # Cython debug symbols
 cython_debug/
 
-# minecraft server stuff
-jdk*/
-minecraft*/
-minecraft_versions.json
+# Cython intermediates
+_speedups.c
+_speedups.cpp
+_speedups.html
 
 # pyenv
 .python-version
 
+#undertale stuff
+/Undertale/
+
 # OS General Files
 .DS_Store
 .AppleDouble

.run/Archipelago Unittests.run.xml

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

AHITClient.py

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

AdventureClient.py

@@ -0,0 +1,520 @@
+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 settings import get_settings
+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 = get_settings().adventure_options
+        self.display_msgs = 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 get_settings().adventure_options.as_dict().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.lookup_in_game(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
+                    await asyncio.sleep(1)
+                    continue
+                except CancelledError:
+                    pass
+        except CancelledError:
+            pass
+    print("exiting atari sync task")
+
+
+async def run_game(romfile):
+    options = get_settings().adventure_options
+    auto_start = options.rom_start
+    rom_args = options.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.just_fix_windows_console()
+
+    asyncio.run(main())
+    colorama.deinit()

BizHawkClient.py

@@ -0,0 +1,10 @@
+from __future__ import annotations
+
+import sys
+import ModuleUpdate
+ModuleUpdate.update()
+
+from worlds._bizhawk.context import launch
+
+if __name__ == "__main__":
+    launch(*sys.argv[1:])

CommonClient.py

@@ -1,4 +1,7 @@
 from __future__ import annotations
+
+import collections
+import copy
 import logging
 import asyncio
 import urllib.parse
@@ -6,6 +9,7 @@ import sys
 import typing
 import time
 import functools
+import warnings
 
 import ModuleUpdate
 ModuleUpdate.update()
@@ -17,15 +21,17 @@ import Utils
 if __name__ == "__main__":
     Utils.init_logging("TextClient", exception_logger="Client")
 
-from MultiServer import CommandProcessor
-from NetUtils import Endpoint, decode, NetworkItem, encode, JSONtoTextParser, \
-    ClientStatus, Permission, NetworkSlot, RawJSONtoTextParser
+from MultiServer import CommandProcessor, mark_raw
+from NetUtils import (Endpoint, decode, NetworkItem, encode, JSONtoTextParser, ClientStatus, Permission, NetworkSlot,
+                      RawJSONtoTextParser, add_json_text, add_json_location, add_json_item, JSONTypes, HintStatus, SlotType)
 from Utils import Version, stream_input, async_start
 from worlds import network_data_package, AutoWorldRegister
 import os
+import ssl
 
 if typing.TYPE_CHECKING:
     import kvui
+    import argparse
 
 logger = logging.getLogger("Client")
 
@@ -33,11 +39,28 @@ 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):
+    """
+    The Command Processor will parse every method of the class that starts with "_cmd_" as a command to be called
+    when parsing user input, i.e. _cmd_exit will be called when the user sends the command "/exit".
+
+    The decorator @mark_raw can be imported from MultiServer and tells the parser to only split on the first
+    space after the command i.e. "/exit one two three" will be passed in as method("one two three") with mark_raw
+    and method("one", "two", "three") without.
+
+    In addition all docstrings for command methods will be displayed to the user on launch and when using "/help"
+    """
     def __init__(self, ctx: CommonContext):
         self.ctx = ctx
 
     def output(self, text: str):
+        """Helper function to abstract logging to the CommonClient UI"""
         logger.info(text)
 
     def _cmd_exit(self) -> bool:
@@ -50,6 +73,7 @@ class ClientCommandProcessor(CommandProcessor):
         if address:
             self.ctx.server_address = None
             self.ctx.username = None
+            self.ctx.password = None
         elif not self.ctx.server_address:
             self.output("Please specify an address.")
             return False
@@ -63,19 +87,31 @@ class ClientCommandProcessor(CommandProcessor):
 
     def _cmd_received(self) -> bool:
         """List all received items"""
-        logger.info(f'{len(self.ctx.items_received)} received items:')
+        item: NetworkItem
+        self.output(f'{len(self.ctx.items_received)} received items, sorted by time:')
         for index, item in enumerate(self.ctx.items_received, 1):
-            self.output(f"{self.ctx.item_names[item.item]} from {self.ctx.player_names[item.player]}")
+            parts = []
+            add_json_item(parts, item.item, self.ctx.slot, item.flags)
+            add_json_text(parts, " from ")
+            add_json_location(parts, item.location, item.player)
+            add_json_text(parts, " by ")
+            add_json_text(parts, item.player, type=JSONTypes.player_id)
+            self.ctx.on_print_json({"data": parts, "cmd": "PrintJSON"})
         return True
 
-    def _cmd_missing(self) -> bool:
-        """List all missing location checks, from your local game state"""
+    def _cmd_missing(self, filter_text = "") -> bool:
+        """List all missing location checks, from your local game state.
+        Can be given text, which will be used as filter."""
         if not self.ctx.game:
             self.output("No game set, cannot determine missing checks.")
             return False
         count = 0
         checked_count = 0
-        for location, location_id in AutoWorldRegister.world_types[self.ctx.game].location_name_to_id.items():
+
+        lookup = self.ctx.location_names[self.ctx.game]
+        for location_id, location in lookup.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:
@@ -94,25 +130,87 @@ class ClientCommandProcessor(CommandProcessor):
             self.output("No missing location checks found.")
         return True
 
-    def _cmd_items(self):
+    def output_datapackage_part(self, name: typing.Literal["Item Names", "Location Names"]) -> bool:
+        """
+        Helper to digest a specific section of this game's datapackage.
+
+        :param name: Printed to the user as context for the part.
+
+        :return: Whether the process was successful.
+        """
+        if not self.ctx.game:
+            self.output(f"No game set, cannot determine {name}.")
+            return False
+
+        lookup = self.ctx.item_names if name == "Item Names" else self.ctx.location_names
+        lookup = lookup[self.ctx.game]
+        self.output(f"{name} for {self.ctx.game}")
+        for name in lookup.values():
+            self.output(name)
+        return True
+
+    def _cmd_items(self) -> bool:
         """List all item names for the currently running game."""
-        if not self.ctx.game:
-            self.output("No game set, cannot determine existing items.")
-            return False
-        self.output(f"Item Names for {self.ctx.game}")
-        for item_name in AutoWorldRegister.world_types[self.ctx.game].item_name_to_id:
-            self.output(item_name)
+        return self.output_datapackage_part("Item Names")
 
-    def _cmd_locations(self):
+    def _cmd_locations(self) -> bool:
         """List all location names for the currently running game."""
-        if not self.ctx.game:
-            self.output("No game set, cannot determine existing locations.")
-            return False
-        self.output(f"Location Names for {self.ctx.game}")
-        for location_name in AutoWorldRegister.world_types[self.ctx.game].location_name_to_id:
-            self.output(location_name)
+        return self.output_datapackage_part("Location Names")
 
-    def _cmd_ready(self):
+    def output_group_part(self, group_key: typing.Literal["item_name_groups", "location_name_groups"],
+                          filter_key: str,
+                          name: str) -> bool:
+        """
+        Logs an item or location group from the player's game's datapackage.
+
+        :param group_key: Either Item or Location group to be processed.
+        :param filter_key: Which group key to filter to. If an empty string is passed will log all item/location groups.
+        :param name: Printed to the user as context for the part.
+
+        :return: Whether the process was successful.
+        """
+        if not self.ctx.game:
+            self.output(f"No game set, cannot determine existing {name} Groups.")
+            return False
+        lookup = Utils.persistent_load().get("groups_by_checksum", {}).get(self.ctx.checksums[self.ctx.game], {})\
+            .get(self.ctx.game, {}).get(group_key, {})
+        if lookup is None:
+            self.output("datapackage not yet loaded, try again")
+            return False
+
+        if filter_key:
+            if filter_key not in lookup:
+                self.output(f"Unknown {name} Group {filter_key}")
+                return False
+
+            self.output(f"{name}s for {name} Group \"{filter_key}\"")
+            for entry in lookup[filter_key]:
+                self.output(entry)
+        else:
+            self.output(f"{name} Groups for {self.ctx.game}")
+            for group in lookup:
+                self.output(group)
+        return True
+
+    @mark_raw
+    def _cmd_item_groups(self, key: str = "") -> bool:
+        """
+        List all item group names for the currently running game.
+
+        :param key: Which item group to filter to. Will log all groups if empty.
+        """
+        return self.output_group_part("item_name_groups", key, "Item")
+
+    @mark_raw
+    def _cmd_location_groups(self, key: str = "") -> bool:
+        """
+        List all location group names for the currently running game.
+
+        :param key: Which item group to filter to. Will log all groups if empty.
+        """
+        return self.output_group_part("location_name_groups", key, "Location")
+
+    def _cmd_ready(self) -> bool:
         """Send ready status to server."""
         self.ctx.ready = not self.ctx.ready
         if self.ctx.ready:
@@ -122,30 +220,85 @@ class ClientCommandProcessor(CommandProcessor):
             state = ClientStatus.CLIENT_CONNECTED
             self.output("Unreadied.")
         async_start(self.ctx.send_msgs([{"cmd": "StatusUpdate", "status": state}]), name="send StatusUpdate")
+        return True
 
     def default(self, raw: str):
+        """The default message parser to be used when parsing any messages that do not match a command"""
         raw = self.ctx.on_user_say(raw)
         if raw:
             async_start(self.ctx.send_msgs([{"cmd": "Say", "text": raw}]), name="send Say")
 
 
 class CommonContext:
-    # Should be adjusted as needed in subclasses
+    # The following attributes are used to Connect and should be adjusted as needed in subclasses
     tags: typing.Set[str] = {"AP"}
     game: typing.Optional[str] = None
     items_handling: typing.Optional[int] = None
     want_slot_data: bool = True  # should slot_data be retrieved via Connect
 
-    # 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})')
+    class NameLookupDict:
+        """A specialized dict, with helper methods, for id -> name item/location data package lookups by game."""
+        def __init__(self, ctx: CommonContext, lookup_type: typing.Literal["item", "location"]):
+            self.ctx: CommonContext = ctx
+            self.lookup_type: typing.Literal["item", "location"] = lookup_type
+            self._unknown_item: typing.Callable[[int], str] = lambda key: f"Unknown {lookup_type} (ID: {key})"
+            self._archipelago_lookup: typing.Dict[int, str] = {}
+            self._game_store: typing.Dict[str, typing.ChainMap[int, str]] = collections.defaultdict(
+                lambda: collections.ChainMap(self._archipelago_lookup, Utils.KeyedDefaultDict(self._unknown_item)))
+
+        # noinspection PyTypeChecker
+        def __getitem__(self, key: str) -> typing.Mapping[int, str]:
+            assert isinstance(key, str), f"ctx.{self.lookup_type}_names used with an id, use the lookup_in_ helpers instead"
+            return self._game_store[key]
+
+        def __len__(self) -> int:
+            return len(self._game_store)
+
+        def __iter__(self) -> typing.Iterator[str]:
+            return iter(self._game_store)
+
+        def __repr__(self) -> str:
+            return repr(self._game_store)
+
+        def lookup_in_game(self, code: int, game_name: typing.Optional[str] = None) -> str:
+            """Returns the name for an item/location id in the context of a specific game or own game if `game` is
+            omitted.
+            """
+            if game_name is None:
+                game_name = self.ctx.game
+                assert game_name is not None, f"Attempted to lookup {self.lookup_type} with no game name available."
+
+            return self._game_store[game_name][code]
+
+        def lookup_in_slot(self, code: int, slot: typing.Optional[int] = None) -> str:
+            """Returns the name for an item/location id in the context of a specific slot or own slot if `slot` is
+            omitted.
+
+            Use of `lookup_in_slot` should not be used when not connected to a server. If looking in own game, set
+            `ctx.game` and use `lookup_in_game` method instead.
+            """
+            if slot is None:
+                slot = self.ctx.slot
+                assert slot is not None, f"Attempted to lookup {self.lookup_type} with no slot info available."
+
+            return self.lookup_in_game(code, self.ctx.slot_info[slot].game)
+
+        def update_game(self, game: str, name_to_id_lookup_table: typing.Dict[str, int]) -> None:
+            """Overrides existing lookup tables for a particular game."""
+            id_to_name_lookup_table = Utils.KeyedDefaultDict(self._unknown_item)
+            id_to_name_lookup_table.update({code: name for name, code in name_to_id_lookup_table.items()})
+            self._game_store[game] = collections.ChainMap(self._archipelago_lookup, id_to_name_lookup_table)
+            if game == "Archipelago":
+                # Keep track of the Archipelago data package separately so if it gets updated in a custom datapackage,
+                # it updates in all chain maps automatically.
+                self._archipelago_lookup.clear()
+                self._archipelago_lookup.update(id_to_name_lookup_table)
 
     # defaults
     starting_reconnect_delay: int = 5
     current_reconnect_delay: int = starting_reconnect_delay
     command_processor: typing.Type[CommandProcessor] = ClientCommandProcessor
-    ui = None
+    ui: typing.Optional["kvui.GameManager"] = None
     ui_task: typing.Optional["asyncio.Task[None]"] = None
     input_task: typing.Optional["asyncio.Task[None]"] = None
     keep_alive_task: typing.Optional["asyncio.Task[None]"] = None
@@ -154,38 +307,80 @@ 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
 
     # remaining type info
-    slot_info: typing.Dict[int, NetworkSlot]
-    server_address: typing.Optional[str]
-    password: typing.Optional[str]
-    hint_cost: typing.Optional[int]
-    player_names: typing.Dict[int, str]
+    slot_info: dict[int, NetworkSlot]
+    """Slot Info from the server for the current connection"""
+    server_address: str | None
+    """Autoconnect address provided by the ctx constructor"""
+    password: str | None
+    """Password used for Connecting, expected by server_auth"""
+    hint_cost: int | None
+    """Current Hint Cost per Hint from the server"""
+    hint_points: int | None
+    """Current avaliable Hint Points from the server"""
+    player_names: dict[int, str]
+    """Current lookup of slot number to player display name from server (includes aliases)"""
 
     finished_game: bool
+    """
+    Bool to signal that status should be updated to Goal after reconnecting
+    to be used to ensure that a StatusUpdate packet does not get lost when disconnected
+    """
     ready: bool
-    auth: typing.Optional[str]
-    seed_name: typing.Optional[str]
+    """Bool to keep track of state for the /ready command"""
+    team: int | None
+    """Team number of currently connected slot"""
+    slot: int | None
+    """Slot number of currently connected slot"""
+    auth: str | None
+    """Name used in Connect packet"""
+    seed_name: str | None
+    """Seed name that will be validated on opening a socket if present"""
 
     # locations
-    locations_checked: typing.Set[int]  # local state
-    locations_scouted: typing.Set[int]
-    items_received: typing.List[NetworkItem]
-    missing_locations: typing.Set[int]  # server state
-    checked_locations: typing.Set[int]  # server state
-    server_locations: typing.Set[int]  # all locations the server knows of, missing_location | checked_locations
-    locations_info: typing.Dict[int, NetworkItem]
+    locations_checked: set[int]
+    """
+    Local container of location ids checked to signal that LocationChecks should be resent after reconnecting
+    to be used to ensure that a LocationChecks packet does not get lost when disconnected
+    """
+    locations_scouted: set[int]
+    """
+    Local container of location ids scouted to signal that LocationScouts should be resent after reconnecting
+    to be used to ensure that a LocationScouts packet does not get lost when disconnected
+    """
+    items_received: list[NetworkItem]
+    """List of NetworkItems recieved from the server"""
+    missing_locations: set[int]
+    """Container of Locations that are unchecked per server state"""
+    checked_locations: set[int]
+    """Container of Locations that are checked per server state"""
+    server_locations: set[int]
+    """Container of Locations that exist per server state; a combination between missing and checked locations"""
+    locations_info: dict[int, NetworkItem]
+    """Dict of location id: NetworkItem info from LocationScouts request"""
+
+    # data storage
+    stored_data: dict[str, typing.Any]
+    """
+    Data Storage values by key that were retrieved from the server
+    any keys subscribed to with SetNotify will be kept up to date
+    """
+    stored_data_notification_keys: set[str]
+    """Current container of watched Data Storage keys, managed by ctx.set_notify"""
 
     # internals
-    # current message box through kvui
     _messagebox: typing.Optional["kvui.MessageBox"] = None
-    # message box reporting a loss of connection
+    """Current message box through kvui"""
     _messagebox_connection_loss: typing.Optional["kvui.MessageBox"] = None
+    """Message box reporting a loss of connection"""
 
-    def __init__(self, server_address: typing.Optional[str], password: typing.Optional[str]) -> None:
+    def __init__(self, server_address: typing.Optional[str] = None, password: typing.Optional[str] = None) -> None:
         # server state
         self.server_address = server_address
         self.username = None
@@ -214,6 +409,9 @@ class CommonContext:
         self.server_locations = set()  # all locations the server knows of, missing_location | checked_locations
         self.locations_info = {}
 
+        self.stored_data = {}
+        self.stored_data_notification_keys = set()
+
         self.input_queue = asyncio.Queue()
         self.input_requests = 0
 
@@ -222,8 +420,15 @@ class CommonContext:
         self.exit_event = asyncio.Event()
         self.watcher_event = asyncio.Event()
 
+        self.item_names = self.NameLookupDict(self, "item")
+        self.location_names = self.NameLookupDict(self, "location")
+        self.checksums = {}
+
         self.jsontotextparser = JSONtoTextParser(self)
-        self.update_datapackage(network_data_package)
+        self.rawjsontotextparser = RawJSONtoTextParser(self)
+        if self.game:
+            self.checksums[self.game] = network_data_package["games"][self.game]["checksum"]
+        self.update_data_package(network_data_package)
 
         # execution
         self.keep_alive_task = asyncio.create_task(keep_alive(self), name="Bouncy")
@@ -256,6 +461,7 @@ class CommonContext:
         self.items_received = []
         self.locations_info = {}
         self.server_version = Version(0, 0, 0)
+        self.generator_version = Version(0, 0, 0)
         self.server = None
         self.server_task = None
         self.hint_cost = None
@@ -274,6 +480,8 @@ class CommonContext:
             await self.server.socket.close()
         if self.server_task is not None:
             await self.server_task
+        if self.ui:
+            self.ui.update_hints()
 
     async def send_msgs(self, msgs: typing.List[typing.Any]) -> None:
         """ `msgs` JSON serializable """
@@ -305,7 +513,10 @@ class CommonContext:
                 self.auth = await self.console_input()
 
     async def send_connect(self, **kwargs: typing.Any) -> None:
-        """ send `Connect` packet to log in to server """
+        """
+        Send a `Connect` packet to log in to the server,
+        additional keyword args can override any value in the connection packet
+        """
         payload = {
             'cmd': 'Connect',
             'password': self.password, 'name': self.auth, 'version': Utils.version_tuple,
@@ -315,6 +526,14 @@ class CommonContext:
         if kwargs:
             payload.update(kwargs)
         await self.send_msgs([payload])
+        await self.send_msgs([{"cmd": "Get", "keys": ["_read_race_mode"]}])
+
+    async def check_locations(self, locations: typing.Collection[int]) -> set[int]:
+        """Send new location checks to the server. Returns the set of actually new locations that were sent."""
+        locations = set(locations) & self.missing_locations
+        if locations:
+            await self.send_msgs([{"cmd": 'LocationChecks', "locations": tuple(locations)}])
+        return locations
 
     async def console_input(self) -> str:
         if self.ui:
@@ -335,12 +554,19 @@ class CommonContext:
         return False
 
     def slot_concerns_self(self, slot) -> bool:
+        """Helper function to abstract player groups, should be used instead of checking slot == self.slot directly."""
         if slot == self.slot:
             return True
         if slot in self.slot_info:
             return self.slot in self.slot_info[slot].group_members
         return False
 
+    def is_echoed_chat(self, print_json_packet: dict) -> bool:
+        """Helper function for filtering out messages sent by self."""
+        return print_json_packet.get("type", "") == "Chat" \
+            and print_json_packet.get("team", None) == self.team \
+            and print_json_packet.get("slot", None) == self.slot
+
     def is_uninteresting_item_send(self, print_json_packet: dict) -> bool:
         """Helper function for filtering out ItemSend prints that do not concern the local player."""
         return print_json_packet.get("type", "") == "ItemSend" \
@@ -352,10 +578,13 @@ class CommonContext:
 
     def on_print_json(self, args: dict):
         if self.ui:
-            self.ui.print_json(args["data"])
-        else:
-            text = self.jsontotextparser(args["data"])
-            logger.info(text)
+            # send copy to UI
+            self.ui.print_json(copy.deepcopy(args["data"]))
+
+        logging.getLogger("FileLog").info(self.rawjsontotextparser(copy.deepcopy(args["data"])),
+                                          extra={"NoStream": True})
+        logging.getLogger("StreamLog").info(self.jsontotextparser(copy.deepcopy(args["data"])),
+                                            extra={"NoFile": True})
 
     def on_package(self, cmd: str, args: dict):
         """For custom package handling in subclasses."""
@@ -366,7 +595,13 @@ class CommonContext:
         Returned text is sent, or sending is aborted if None is returned."""
         return text
 
+    def on_ui_command(self, text: str) -> None:
+        """Gets called by kivy when the user executes a command starting with `/` or `!`.
+        The command processor is still called; this is just intended for command echoing."""
+        self.ui.print_json([{"text": text, "type": "color", "color": "orange"}])
+
     def update_permissions(self, permissions: typing.Dict[str, int]):
+        """Internal method to parse and save server permissions from RoomInfo"""
         for permission_name, permission_flag in permissions.items():
             try:
                 flag = Permission(permission_flag)
@@ -378,6 +613,7 @@ class CommonContext:
     async def shutdown(self):
         self.server_address = ""
         self.username = None
+        self.password = None
         self.cancel_autoreconnect()
         if self.server and not self.server.socket.closed:
             await self.server.socket.close()
@@ -392,52 +628,97 @@ class CommonContext:
             await self.ui_task
         if self.input_task:
             self.input_task.cancel()
-
+    
+    # Hints
+    def update_hint(self, location: int, finding_player: int, status: typing.Optional[HintStatus]) -> None:
+        msg = {"cmd": "UpdateHint", "location": location, "player": finding_player}
+        if status is not None:
+            msg["status"] = status
+        async_start(self.send_msgs([msg]), name="update_hint")
+    
     # DataPackage
-    async def prepare_datapackage(self, relevant_games: typing.Set[str],
-                                  remote_datepackage_versions: typing.Dict[str, int]):
+    async def prepare_data_package(self, relevant_games: typing.Set[str],
+                                   remote_data_package_checksums: typing.Dict[str, str]):
         """Validate that all data is present for the current multiworld.
         Download, assimilate and cache missing data from the server."""
         # 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_datepackage_versions:
+            if game not in remote_data_package_checksums:
                 continue
-            remote_version: int = remote_datepackage_versions[game]
 
-            if remote_version == 0:  # custom datapackage for this game
+            remote_checksum: typing.Optional[str] = remote_data_package_checksums.get(game)
+
+            if not remote_checksum:  # custom data package and no checksum for this game
                 needed_updates.add(game)
                 continue
-            local_version: int = network_data_package["games"].get(game, {}).get("version", 0)
-            # no action required if local version is new enough
-            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 remote_version > cache_version:
-                    needed_updates.add(game)
+
+            cached_checksum: typing.Optional[str] = self.checksums.get(game)
+            # no action required if cached version is new enough
+            if remote_checksum != cached_checksum:
+                local_checksum: typing.Optional[str] = network_data_package["games"].get(game, {}).get("checksum")
+                if remote_checksum == local_checksum:
+                    self.update_game(network_data_package["games"][game], game)
                 else:
-                    self.update_game(cache_package[game])
+                    cached_game = Utils.load_data_package_for_checksum(game, remote_checksum)
+                    cache_checksum: typing.Optional[str] = cached_game.get("checksum")
+                    # download remote version if cache is not new enough
+                    if remote_checksum != cache_checksum:
+                        needed_updates.add(game)
+                    else:
+                        self.update_game(cached_game, game)
         if needed_updates:
-            await self.send_msgs([{"cmd": "GetDataPackage", "games": list(needed_updates)}])
+            await self.send_msgs([{"cmd": "GetDataPackage", "games": [game_name]} for game_name in needed_updates])
 
-    def update_game(self, game_package: dict):
-        for item_name, item_id in game_package["item_name_to_id"].items():
-            self.item_names[item_id] = item_name
-        for location_name, location_id in game_package["location_name_to_id"].items():
-            self.location_names[location_id] = location_name
+    def update_game(self, game_package: dict, game: str):
+        self.item_names.update_game(game, game_package["item_name_to_id"])
+        self.location_names.update_game(game, game_package["location_name_to_id"])
+        self.checksums[game] = game_package.get("checksum")
 
-    def update_datapackage(self, data_package: dict):
-        for game, gamedata in data_package["games"].items():
-            self.update_game(gamedata)
+    def update_data_package(self, data_package: dict):
+        for game, game_data in data_package["games"].items():
+            self.update_game(game_data, game)
 
-    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)
+    def consume_network_data_package(self, data_package: dict):
+        self.update_data_package(data_package)
+        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)
+
+    def consume_network_item_groups(self):
+        data = {"item_name_groups": self.stored_data[f"_read_item_name_groups_{self.game}"]}
+        current_cache = Utils.persistent_load().get("groups_by_checksum", {}).get(self.checksums[self.game], {})
+        if self.game in current_cache:
+            current_cache[self.game].update(data)
+        else:
+            current_cache[self.game] = data
+        Utils.persistent_store("groups_by_checksum", self.checksums[self.game], current_cache)
+
+    def consume_network_location_groups(self):
+        data = {"location_name_groups": self.stored_data[f"_read_location_name_groups_{self.game}"]}
+        current_cache = Utils.persistent_load().get("groups_by_checksum", {}).get(self.checksums[self.game], {})
+        if self.game in current_cache:
+            current_cache[self.game].update(data)
+        else:
+            current_cache[self.game] = data
+        Utils.persistent_store("groups_by_checksum", self.checksums[self.game], current_cache)
+
+    # 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
 
@@ -451,6 +732,7 @@ class CommonContext:
             logger.info(f"DeathLink: Received from {data['source']}")
 
     async def send_death(self, death_text: str = ""):
+        """Helper function to send a deathlink using death_text as the unique death cause string."""
         if self.server and self.server.socket:
             logger.info("DeathLink: Sending death to your friends...")
             self.last_death_link = time.time()
@@ -464,6 +746,7 @@ class CommonContext:
             }])
 
     async def update_death_link(self, death_link: bool):
+        """Helper function to set Death Link connection tag on/off and update the connection if already connected."""
         old_tags = self.tags.copy()
         if death_link:
             self.tags.add("DeathLink")
@@ -473,7 +756,7 @@ class CommonContext:
             await self.send_msgs([{"cmd": "ConnectUpdate", "tags": self.tags}])
 
     def gui_error(self, title: str, text: typing.Union[Exception, str]) -> typing.Optional["kvui.MessageBox"]:
-        """Displays an error messagebox"""
+        """Displays an error messagebox in the loaded Kivy UI. Override if using a different UI framework"""
         if not self.ui:
             return None
         title = title or "Error"
@@ -500,21 +783,36 @@ class CommonContext:
         logger.exception(msg, exc_info=exc_info, extra={'compact_gui': True})
         self._messagebox_connection_loss = self.gui_error(msg, exc_info[1])
 
-    def run_gui(self):
-        """Import kivy UI system and start running it as self.ui_task."""
+    def make_gui(self) -> "type[kvui.GameManager]":
+        """
+        To return the Kivy `App` class needed for `run_gui` so it can be overridden before being built
+
+        Common changes are changing `base_title` to update the window title of the client and
+        updating `logging_pairs` to automatically make new tabs that can be filled with their respective logger.
+
+        ex. `logging_pairs.append(("Foo", "Bar"))`
+        will add a "Bar" tab which follows the logger returned from `logging.getLogger("Foo")`
+        """
         from kvui import GameManager
 
         class TextManager(GameManager):
-            logging_pairs = [
-                ("Client", "Archipelago")
-            ]
             base_title = "Archipelago Text Client"
 
-        self.ui = TextManager(self)
+        return TextManager
+
+    def run_gui(self):
+        """Import kivy UI system from make_gui() and start running it as self.ui_task."""
+        ui_class = self.make_gui()
+        self.ui = ui_class(self)
         self.ui_task = asyncio.create_task(self.ui.async_run(), name="UI")
 
     def run_cli(self):
         if sys.stdin:
+            if sys.stdin.fileno() != 0:
+                from multiprocessing import parent_process
+                if parent_process():
+                    return  # ignore MultiProcessing pipe
+
             # steam overlay breaks when starting console_loop
             if 'gameoverlayrenderer' in os.environ.get('LD_PRELOAD', ''):
                 logger.info("Skipping terminal input, due to conflicting Steam Overlay detected. Please use GUI only.")
@@ -561,14 +859,16 @@ async def server_loop(ctx: CommonContext, address: typing.Optional[str] = None)
         ctx.username = server_url.username
     if server_url.password:
         ctx.password = server_url.password
-    port = server_url.port or 38281
 
     def reconnect_hint() -> str:
         return ", type /connect to reconnect" if ctx.server_address else ""
 
     logger.info(f'Connecting to Archipelago server at {address}')
     try:
-        socket = await websockets.connect(address, port=port, ping_timeout=None, ping_interval=None)
+        port = server_url.port or 38281  # raises ValueError if invalid
+        socket = await websockets.connect(address, port=port, ping_timeout=None, ping_interval=None,
+                                          ssl=get_ssl_context() if address.startswith("wss://") else None,
+                                          max_size=ctx.max_size)
         if ctx.ui is not None:
             ctx.ui.update_address_bar(server_url.netloc)
         ctx.server = Endpoint(socket)
@@ -583,6 +883,7 @@ async def server_loop(ctx: CommonContext, address: typing.Optional[str] = None)
     except websockets.InvalidMessage:
         # probably encrypted
         if address.startswith("ws://"):
+            # try wss
             await server_loop(ctx, "ws" + address[1:])
         else:
             ctx.handle_connection_loss(f"Lost connection to the multiworld server due to InvalidMessage"
@@ -627,11 +928,16 @@ async def process_server_cmd(ctx: CommonContext, args: dict):
             logger.info('Room Information:')
             logger.info('--------------------------------')
             version = args["version"]
-            ctx.server_version = tuple(version)
-            version = ".".join(str(item) for item in version)
+            ctx.server_version = Version(*version)
 
-            logger.info(f'Server protocol version: {version}')
-            logger.info("Server protocol tags: " + ", ".join(args["tags"]))
+            if "generator_version" in args:
+                ctx.generator_version = Version(*args["generator_version"])
+                logger.info(f'Server protocol version: {ctx.server_version.as_simple_string()}, '
+                            f'generator version: {ctx.generator_version.as_simple_string()}, '
+                            f'tags: {", ".join(args["tags"])}')
+            else:
+                logger.info(f'Server protocol version: {ctx.server_version.as_simple_string()}, '
+                            f'tags: {", ".join(args["tags"])}')
             if args['password']:
                 logger.info('Password required')
             ctx.update_permissions(args.get("permissions", {}))
@@ -656,23 +962,27 @@ 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 datapackage
-            await ctx.prepare_datapackage(set(args["games"]), args["datapackage_versions"])
+            # update data package
+            data_package_checksums = args.get("datapackage_checksums", {})
+            await ctx.prepare_data_package(set(args["games"]), data_package_checksums)
 
             await ctx.server_auth(args['password'])
 
     elif cmd == 'DataPackage':
-        logger.info("Got new ID/Name DataPackage")
-        ctx.consume_network_datapackage(args['data'])
+        ctx.consume_network_data_package(args['data'])
 
     elif cmd == 'ConnectionRefused':
         errors = args["errors"]
         if 'InvalidSlot' in errors:
+            ctx.disconnected_intentionally = True
             ctx.event_invalid_slot()
         elif 'InvalidGame' in errors:
+            ctx.disconnected_intentionally = True
             ctx.event_invalid_game()
         elif 'IncompatibleVersion' in errors:
-            raise Exception('Server reported your client version as incompatible')
+            ctx.disconnected_intentionally = True
+            raise Exception('Server reported your client version as incompatible. '
+                            'This probably means you have to update.')
         elif 'InvalidItemsHandling' in errors:
             raise Exception('The item handling flags requested by the client are not supported')
         # last to check, recoverable problem
@@ -690,8 +1000,17 @@ async def process_server_cmd(ctx: CommonContext, args: dict):
         ctx.team = args["team"]
         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.slot_info = {0: NetworkSlot("Archipelago", "Archipelago", SlotType.player)}
+        ctx.slot_info.update({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}")
+        if ctx.game:
+            game = ctx.game
+        else:
+            game = ctx.slot_info[ctx.slot][1]
+        ctx.stored_data_notification_keys.add(f"_read_item_name_groups_{game}")
+        ctx.stored_data_notification_keys.add(f"_read_location_name_groups_{game}")
         msgs = []
         if ctx.locations_checked:
             msgs.append({"cmd": "LocationChecks",
@@ -699,6 +1018,11 @@ async def process_server_cmd(ctx: CommonContext, args: dict):
         if ctx.locations_scouted:
             msgs.append({"cmd": "LocationScouts",
                          "locations": list(ctx.locations_scouted)})
+        if ctx.stored_data_notification_keys:
+            msgs.append({"cmd": "Get",
+                         "keys": list(ctx.stored_data_notification_keys)})
+            msgs.append({"cmd": "SetNotify",
+                         "keys": list(ctx.stored_data_notification_keys)})
         if msgs:
             await ctx.send_msgs(msgs)
         if ctx.finished_game:
@@ -762,8 +1086,25 @@ 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()
+        if f"_read_item_name_groups_{ctx.game}" in args["keys"]:
+            ctx.consume_network_item_groups()
+        if f"_read_location_name_groups_{ctx.game}" in args["keys"]:
+            ctx.consume_network_location_groups()
+
     elif cmd == "SetReply":
-        if args["key"] == "EnergyLink":
+        ctx.stored_data[args["key"]] = args["value"]
+        if ctx.ui and f"_read_hints_{ctx.team}_{ctx.slot}" == args["key"]:
+            ctx.ui.update_hints()
+        elif f"_read_item_name_groups_{ctx.game}" == args["key"]:
+            ctx.consume_network_item_groups()
+        elif f"_read_location_name_groups_{ctx.game}" == args["key"]:
+            ctx.consume_network_location_groups()
+        elif args["key"].startswith("EnergyLink"):
             ctx.current_energy_link_value = args["value"]
             if ctx.ui:
                 ctx.ui.set_new_energy_link_value()
@@ -794,6 +1135,7 @@ async def console_loop(ctx: CommonContext):
 
 
 def get_base_parser(description: typing.Optional[str] = None):
+    """Base argument parser to be reused for components subclassing off of CommonClient"""
     import argparse
     parser = argparse.ArgumentParser(description=description)
     parser.add_argument('--connect', default=None, help='Address of the multiworld host.')
@@ -803,11 +1145,36 @@ def get_base_parser(description: typing.Optional[str] = None):
     return parser
 
 
-if __name__ == '__main__':
-    # Text Mode to use !hint and such with games that have no text entry
+def handle_url_arg(args: "argparse.Namespace",
+                   parser: "typing.Optional[argparse.ArgumentParser]" = None) -> "argparse.Namespace":
+    """
+    Parse the url arg "archipelago://name:pass@host:port" from launcher into correct launch args for CommonClient
+    If alternate data is required the urlparse response is saved back to args.url if valid
+    """
+    if not args.url:
+        return args
+        
+    url = urllib.parse.urlparse(args.url)
+    if url.scheme != "archipelago":
+        if not parser:
+            parser = get_base_parser()
+        parser.error(f"bad url, found {args.url}, expected url in form of archipelago://archipelago.gg:38281")
+        return args
 
+    args.url = url
+    args.connect = url.netloc
+    if url.username:
+        args.name = urllib.parse.unquote(url.username)
+    if url.password:
+        args.password = urllib.parse.unquote(url.password)
+
+    return args
+
+
+def run_as_textclient(*args):
     class TextContext(CommonContext):
-        tags = {"AP", "TextOnly"}
+        # Text Mode to use !hint and such with games that have no text entry
+        tags = CommonContext.tags | {"TextOnly"}
         game = ""  # empty matches any game since 0.3.2
         items_handling = 0b111  # receive all items for /received
         want_slot_data = False  # Can't use game specific slot_data
@@ -816,17 +1183,16 @@ if __name__ == '__main__':
             if password_requested and not self.password:
                 await super(TextContext, self).server_auth(password_requested)
             await self.get_username()
-            await self.send_connect()
+            await self.send_connect(game="")
 
         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
@@ -839,23 +1205,22 @@ if __name__ == '__main__':
         await ctx.exit_event.wait()
         await ctx.shutdown()
 
-
     import colorama
 
     parser = get_base_parser(description="Gameless Archipelago Client, for text interfacing.")
     parser.add_argument('--name', default=None, help="Slot Name to connect as.")
     parser.add_argument("url", nargs="?", help="Archipelago connection url")
-    args = parser.parse_args()
+    args = parser.parse_args(args)
 
-    if args.url:
-        url = urllib.parse.urlparse(args.url)
-        args.connect = url.netloc
-        if url.username:
-            args.name = urllib.parse.unquote(url.username)
-        if url.password:
-            args.password = urllib.parse.unquote(url.password)
+    args = handle_url_arg(args, parser=parser)
 
-    colorama.init()
+    # use colorama to display colored text highlighting on windows
+    colorama.just_fix_windows_console()
 
     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(*sys.argv[1:])  # default value for parse_args

Dockerfile

@@ -0,0 +1,100 @@
+# hadolint global ignore=SC1090,SC1091
+
+# Source
+FROM scratch AS release
+WORKDIR /release
+ADD https://github.com/Ijwu/Enemizer/releases/latest/download/ubuntu.16.04-x64.zip Enemizer.zip
+
+# Enemizer
+FROM alpine:3.21 AS enemizer
+ARG TARGETARCH
+WORKDIR /release
+COPY --from=release /release/Enemizer.zip .
+
+# No release for arm architecture. Skip.
+RUN if [ "$TARGETARCH" = "amd64" ]; then \
+    apk add unzip=6.0-r15 --no-cache && \
+    unzip -u Enemizer.zip -d EnemizerCLI && \
+    chmod -R 777 EnemizerCLI; \
+    else touch EnemizerCLI; fi
+
+# Cython builder stage
+FROM python:3.12 AS cython-builder
+
+WORKDIR /build
+
+# Copy and install requirements first (better caching)
+COPY requirements.txt WebHostLib/requirements.txt
+
+RUN pip install --no-cache-dir -r \
+    WebHostLib/requirements.txt \
+    "setuptools>=75,<81"
+
+COPY _speedups.pyx .
+COPY intset.h .
+
+RUN cythonize -b -i _speedups.pyx
+
+# Archipelago
+FROM python:3.12-slim-bookworm AS archipelago
+ARG TARGETARCH
+ENV VIRTUAL_ENV=/opt/venv
+ENV PYTHONUNBUFFERED=1
+WORKDIR /app
+
+# Install requirements
+# hadolint ignore=DL3008
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+    git \
+    gcc=4:12.2.0-3 \
+    libc6-dev \
+    libtk8.6=8.6.13-2 \
+    g++=4:12.2.0-3 \
+    curl && \
+    apt-get clean && \
+    rm -rf /var/lib/apt/lists/*
+
+# Create and activate venv
+RUN python -m venv $VIRTUAL_ENV; \
+    . $VIRTUAL_ENV/bin/activate
+
+# Copy and install requirements first (better caching)
+COPY WebHostLib/requirements.txt WebHostLib/requirements.txt
+
+RUN pip install --no-cache-dir -r \
+    WebHostLib/requirements.txt \
+    gunicorn==23.0.0
+
+COPY . .
+
+COPY --from=cython-builder /build/*.so ./
+
+# Run ModuleUpdate
+RUN python ModuleUpdate.py -y
+
+# Purge unneeded packages
+RUN apt-get purge -y \
+    git \
+    gcc \
+    libc6-dev \
+    g++ && \
+    apt-get autoremove -y
+
+# Copy necessary components
+COPY --from=enemizer /release/EnemizerCLI /tmp/EnemizerCLI
+
+# No release for arm architecture. Skip.
+RUN if [ "$TARGETARCH" = "amd64" ]; then \
+    cp -r /tmp/EnemizerCLI EnemizerCLI; \
+    fi; \
+    rm -rf /tmp/EnemizerCLI
+
+# Define health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=40s --retries=3 \
+    CMD curl -f http://localhost:${PORT:-80} || exit 1
+
+# Ensure no runtime ModuleUpdate.
+ENV SKIP_REQUIREMENTS_UPDATE=true
+
+ENTRYPOINT [ "python", "WebHost.py" ]

FF1Client.py

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

Generate.py

@@ -1,150 +1,178 @@
 from __future__ import annotations
 
 import argparse
+import copy
 import logging
 import os
 import random
 import string
+import sys
 import urllib.parse
 import urllib.request
-from collections import Counter, ChainMap
-from typing import Dict, Tuple, Callable, Any, Union
+from collections import Counter
+from itertools import chain
+from typing import Any
 
 import ModuleUpdate
 
 ModuleUpdate.update()
 
 import Utils
-from worlds.alttp import Options as LttPOptions
-from worlds.generic import PlandoConnection
-from Utils import parse_yamls, version_tuple, __version__, tuplize_version, get_options, user_path
-from worlds.alttp.EntranceRandomizer import parse_arguments
-from Main import main as ERmain
-from BaseClasses import seeddigits, get_seed, PlandoOptions
 import Options
-from worlds.alttp.Text import TextTable
-from worlds.AutoWorld import AutoWorldRegister
-import copy
-
-
-
+from BaseClasses import seeddigits, get_seed, PlandoOptions
+from Utils import parse_yamls, version_tuple, __version__, tuplize_version
 
 
 def mystery_argparse():
-    options = get_options()
-    defaults = options["generator"]
-
-    def resolve_path(path: str, resolver: Callable[[str], str]) -> str:
-        return path if os.path.isabs(path) else resolver(path)
+    from settings import get_settings
+    settings = get_settings()
+    defaults = settings.generator
 
     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 settings, urls are also valid')
-    parser.add_argument('--samesettings', help='Rolls settings 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 options, urls are also valid')
+    parser.add_argument('--sameoptions', help='Rolls options per weights file rather than per player',
                         action='store_true')
-    parser.add_argument('--player_files_path', default=resolve_path(defaults["player_files_path"], user_path),
+    parser.add_argument('--player_files_path', default=defaults.player_files_path,
                         help="Input directory for player files.")
     parser.add_argument('--seed', help='Define seed number to generate.', type=int)
-    parser.add_argument('--multi', default=defaults["players"], type=lambda value: max(int(value), 1))
-    parser.add_argument('--spoiler', type=int, default=defaults["spoiler"])
-    parser.add_argument('--outputpath', default=resolve_path(options["general_options"]["output_path"], user_path),
+    parser.add_argument('--multi', default=defaults.players, type=lambda value: max(int(value), 1))
+    parser.add_argument('--spoiler', type=int, default=defaults.spoiler)
+    parser.add_argument('--outputpath', default=settings.general_options.output_path,
                         help="Path to output folder. Absolute or relative to cwd.")  # absolute or relative to cwd
-    parser.add_argument('--race', action='store_true', default=defaults["race"])
-    parser.add_argument('--meta_file_path', default=defaults["meta_file_path"])
-    parser.add_argument('--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"],
-                        help='List of options that can be set manually. Can be combined, for example "bosses, items"')
+    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=defaults.loglevel, help='Sets log level')
+    parser.add_argument('--log_time', help="Add timestamps to STDOUT",
+                        default=defaults.logtime, action='store_true')
+    parser.add_argument("--csv_output", action="store_true",
+                        help="Output rolled player options to csv (made for async multiworld).")
+    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.")
+    parser.add_argument("--spoiler_only", action="store_true",
+                        help="Skips generation assertion and multidata, outputting only a spoiler log. "
+                             "Intended for debugging and testing purposes.")
     args = parser.parse_args()
+
+    if args.skip_output and args.spoiler_only:
+        parser.error("Cannot mix --skip_output and --spoiler_only")
+    elif args.spoiler == 0 and args.spoiler_only:
+        parser.error("Cannot use --spoiler_only when --spoiler=0. Use --skip_output or set --spoiler to a different value")
+
     if not os.path.isabs(args.weights_file_path):
         args.weights_file_path = os.path.join(args.player_files_path, args.weights_file_path)
     if not os.path.isabs(args.meta_file_path):
         args.meta_file_path = os.path.join(args.player_files_path, args.meta_file_path)
     args.plando: PlandoOptions = PlandoOptions.from_option_string(args.plando)
-    return args, options
+
+    return args
 
 
 def get_seed_name(random_source) -> str:
     return f"{random_source.randint(0, pow(10, seeddigits) - 1)}".zfill(seeddigits)
 
 
-def main(args=None, callback=ERmain):
+def main(args=None) -> tuple[argparse.Namespace, int]:
+    # __name__ == "__main__" check so unittests that already imported worlds don't trip this.
+    if __name__ == "__main__" and "worlds" in sys.modules:
+        raise Exception("Worlds system should not be loaded before logging init.")
+
     if not args:
-        args, options = mystery_argparse()
+        args = mystery_argparse()
 
     seed = get_seed(args.seed)
+
+    Utils.init_logging(f"Generate_{seed}", loglevel=args.log_level, add_timestamp=args.log_time)
     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, ...]] = {}
+    weights_cache: dict[str, tuple[Any, ...]] = {}
     if args.weights_file_path and os.path.exists(args.weights_file_path):
         try:
             weights_cache[args.weights_file_path] = read_weights_yamls(args.weights_file_path)
         except Exception as e:
-            raise ValueError(f"File {args.weights_file_path} is destroyed. Please fix your yaml.") from e
-        print(f"Weights: {args.weights_file_path} >> "
-              f"{get_choice('description', weights_cache[args.weights_file_path][-1], 'No description specified')}")
+            raise ValueError(f"File {args.weights_file_path} is invalid. Please fix your yaml.") from e
+        logging.info(f"Weights: {args.weights_file_path} >> "
+                     f"{get_choice('description', weights_cache[args.weights_file_path][-1], 'No description specified')}")
 
     if args.meta_file_path and os.path.exists(args.meta_file_path):
         try:
             meta_weights = read_weights_yamls(args.meta_file_path)[-1]
         except Exception as e:
-            raise ValueError(f"File {args.meta_file_path} is destroyed. Please fix your yaml.") from e
-        print(f"Meta: {args.meta_file_path} >> {get_choice('meta_description', meta_weights)}")
+            raise ValueError(f"File {args.meta_file_path} is invalid. Please fix your yaml.") from e
+        logging.info(f"Meta: {args.meta_file_path} >> {get_choice('meta_description', meta_weights)}")
         try:  # meta description allows us to verify that the file named meta.yaml is intentionally a meta file
             del(meta_weights["meta_description"])
         except Exception as e:
             raise ValueError("No meta description found for meta.yaml. Unable to verify.") from e
-        if args.samesettings:
-            raise Exception("Cannot mix --samesettings with --meta")
+        if args.sameoptions:
+            raise Exception("Cannot mix --sameoptions with --meta")
     else:
         meta_weights = None
+
+
     player_id = 1
     player_files = {}
     for file in os.scandir(args.player_files_path):
         fname = file.name
-        if file.is_file() and not file.name.startswith(".") and \
+        if file.is_file() and not fname.startswith(".") and not fname.lower().endswith(".ini") and \
                 os.path.join(args.player_files_path, fname) not in {args.meta_file_path, args.weights_file_path}:
             path = os.path.join(args.player_files_path, fname)
             try:
-                weights_cache[fname] = read_weights_yamls(path)
+                weights_for_file = []
+                for doc_idx, yaml in enumerate(read_weights_yamls(path)):
+                    if yaml is None:
+                        logging.warning(f"Ignoring empty yaml document #{doc_idx + 1} in {fname}")
+                    else:
+                        weights_for_file.append(yaml)
+                weights_cache[fname] = tuple(weights_for_file)
+                        
             except Exception as e:
-                raise ValueError(f"File {fname} is destroyed. Please fix your yaml.") from e
+                raise ValueError(f"File {fname} is invalid. Please fix your yaml.") from e
 
     # sort dict for consistent results across platforms:
-    weights_cache = {key: value for key, value in sorted(weights_cache.items())}
+    weights_cache = {key: value for key, value in sorted(weights_cache.items(), key=lambda k: k[0].casefold())}
     for filename, yaml_data in weights_cache.items():
         if filename not in {args.meta_file_path, args.weights_file_path}:
             for yaml in yaml_data:
-                print(f"P{player_id} Weights: {filename} >> "
-                      f"{get_choice('description', yaml, 'No description specified')}")
+                logging.info(f"P{player_id} Weights: {filename} >> "
+                             f"{get_choice('description', yaml, 'No description specified')}")
                 player_files[player_id] = filename
                 player_id += 1
 
     args.multi = max(player_id - 1, args.multi)
-    print(f"Generating for {args.multi} player{'s' if args.multi > 1 else ''}, {seed_name} Seed {seed} with plando: "
-          f"{args.plando}")
+
+    if args.multi == 0:
+        raise ValueError(
+            "No individual player files found and number of players is 0. "
+            "Provide individual player files or specify the number of players via host.yaml or --multi."
+        )
+
+    logging.info(f"Generating for {args.multi} player{'s' if args.multi > 1 else ''}, "
+                 f"{seed_name} Seed {seed} with plando: {args.plando}")
 
     if not weights_cache:
-        raise Exception(f"No weights found. Provide a general weights file ({args.weights_file_path}) or individual player files. "
+        raise Exception(f"No weights found. "
+                        f"Provide a general weights file ({args.weights_file_path}) or individual player files. "
                         f"A mix is also permitted.")
-    erargs = parse_arguments(['--multi', str(args.multi)])
-    erargs.seed = seed
-    erargs.plando_options = args.plando
-    erargs.glitch_triforce = options["generator"]["glitch_triforce_room"]
-    erargs.spoiler = args.spoiler
-    erargs.race = args.race
-    erargs.outputname = seed_name
-    erargs.outputpath = args.outputpath
 
-    Utils.init_logging(f"Generate_{seed}", loglevel=args.log_level)
+    from worlds.AutoWorld import AutoWorldRegister
+    args.outputname = seed_name
+    args.sprite = dict.fromkeys(range(1, args.multi+1), None)
+    args.sprite_pool = dict.fromkeys(range(1, args.multi+1), None)
+    args.name = {}
 
-    settings_cache: Dict[str, Tuple[argparse.Namespace, ...]] = \
-        {fname: (tuple(roll_settings(yaml, args.plando) for yaml in yamls) if args.samesettings else None)
+    settings_cache: dict[str, tuple[argparse.Namespace, ...]] = \
+        {fname: (tuple(roll_settings(yaml, args.plando) for yaml in yamls) if args.sameoptions else None)
          for fname, yamls in weights_cache.items()}
 
     if meta_weights:
@@ -156,7 +184,8 @@ def main(args=None, callback=ERmain):
                         for yaml in weights_cache[path]:
                             if category_name is None:
                                 for category in yaml:
-                                    if category in AutoWorldRegister.world_types and key in Options.common_options:
+                                    if category in AutoWorldRegister.world_types and \
+                                            key in Options.CommonOptions.type_hints:
                                         yaml[category][key] = option
                             elif category_name not in yaml:
                                 logging.warning(f"Meta: Category {category_name} is not present in {path}.")
@@ -167,66 +196,48 @@ def main(args=None, callback=ERmain):
     for player in range(1, args.multi + 1):
         player_path_cache[player] = player_files.get(player, args.weights_file_path)
     name_counter = Counter()
-    erargs.player_settings = {}
+    args.player_options = {}
 
     player = 1
     while player <= args.multi:
         path = player_path_cache[player]
         if path:
             try:
-                settings: Tuple[argparse.Namespace, ...] = settings_cache[path] if settings_cache[path] else \
+                settings: tuple[argparse.Namespace, ...] = settings_cache[path] if settings_cache[path] else \
                     tuple(roll_settings(yaml, args.plando) for yaml in weights_cache[path])
                 for settingsObject in settings:
                     for k, v in vars(settingsObject).items():
                         if v is not None:
                             try:
-                                getattr(erargs, k)[player] = v
+                                getattr(args, k)[player] = v
                             except AttributeError:
-                                setattr(erargs, k, {player: v})
+                                setattr(args, k, {player: v})
                             except Exception as e:
                                 raise Exception(f"Error setting {k} to {v} for player {player}") from e
 
-                    if path == args.weights_file_path:  # if name came from the weights file, just use base player name
-                        erargs.name[player] = f"Player{player}"
-                    elif not erargs.name[player]:  # if name was not specified, generate it from filename
-                        erargs.name[player] = os.path.splitext(os.path.split(path)[-1])[0]
-                    erargs.name[player] = handle_name(erargs.name[player], player, name_counter)
+                    # name was not specified
+                    if player not in args.name:
+                        if path == args.weights_file_path:
+                            # weights file, so we need to make the name unique
+                            args.name[player] = f"Player{player}"
+                        else:
+                            # use the filename
+                            args.name[player] = os.path.splitext(os.path.split(path)[-1])[0]
+                    args.name[player] = handle_name(args.name[player], player, name_counter)
 
                     player += 1
             except Exception as e:
-                raise ValueError(f"File {path} is destroyed. Please fix your yaml.") from e
+                raise ValueError(f"File {path} is invalid. Please fix your yaml.") from e
         else:
             raise RuntimeError(f'No weights specified for player {player}')
 
-    if len(set(name.lower() for name in erargs.name.values())) != len(erargs.name):
-        raise Exception(f"Names have to be unique. Names: {Counter(name.lower() for name in erargs.name.values())}")
+    if len(set(name.lower() for name in args.name.values())) != len(args.name):
+        raise Exception(f"Names have to be unique. Names: {Counter(name.lower() for name in args.name.values())}")
 
-    if args.yaml_output:
-        import yaml
-        important = {}
-        for option, player_settings in vars(erargs).items():
-            if type(player_settings) == dict:
-                if all(type(value) != list for value in player_settings.values()):
-                    if len(player_settings.values()) > 1:
-                        important[option] = {player: value for player, value in player_settings.items() if
-                                             player <= args.yaml_output}
-                    else:
-                        logging.debug(f"No player settings defined for option '{option}'")
-
-            else:
-                if player_settings != "":  # is not empty name
-                    important[option] = player_settings
-                else:
-                    logging.debug(f"No player settings defined for option '{option}'")
-        if args.outputpath:
-            os.makedirs(args.outputpath, exist_ok=True)
-        with open(os.path.join(args.outputpath if args.outputpath else ".", f"generate_{seed_name}.yaml"), "wt") as f:
-            yaml.dump(important, f)
-
-    callback(erargs, seed)
+    return args, seed
 
 
-def read_weights_yamls(path) -> Tuple[Any, ...]:
+def read_weights_yamls(path) -> tuple[Any, ...]:
     try:
         if urllib.parse.urlparse(path).scheme in ('https', 'file'):
             yaml = str(urllib.request.urlopen(path).read(), "utf-8-sig")
@@ -236,7 +247,20 @@ def read_weights_yamls(path) -> Tuple[Any, ...]:
     except Exception as e:
         raise Exception(f"Failed to read weights ({path})") from e
 
-    return tuple(parse_yamls(yaml))
+    from yaml.error import MarkedYAMLError
+    try:
+        return tuple(parse_yamls(yaml))
+    except MarkedYAMLError as ex:
+        if ex.problem_mark:
+            lines = yaml.splitlines()
+            if ex.context_mark:
+                relevant_lines = "\n".join(lines[ex.context_mark.line:ex.problem_mark.line+1])
+            else:
+                relevant_lines = lines[ex.problem_mark.line]
+            error_line = " " * ex.problem_mark.column + "^"
+            raise Exception(f"{ex.context} {ex.problem} on line {ex.problem_mark.line}:"
+                            f"\n{relevant_lines}\n{error_line}")
+        raise ex
 
 
 def interpret_on_off(value) -> bool:
@@ -276,84 +300,92 @@ def get_choice(option, root, value=None) -> Any:
     raise RuntimeError(f"All options specified in \"{option}\" are weighted as zero.")
 
 
-class SafeDict(dict):
-    def __missing__(self, key):
-        return '{' + key + '}'
+class SafeFormatter(string.Formatter):
+    def get_value(self, key, args, kwargs):
+        if isinstance(key, int):
+            if key < len(args):
+                return args[key]
+            else:
+                return "{" + str(key) + "}"
+        else:
+            return kwargs.get(key, "{" + key + "}")
 
 
 def handle_name(name: str, player: int, name_counter: Counter):
     name_counter[name.lower()] += 1
     number = name_counter[name.lower()]
     new_name = "%".join([x.replace("%number%", "{number}").replace("%player%", "{player}") for x in name.split("%%")])
-    new_name = string.Formatter().vformat(new_name, (), SafeDict(number=number,
-                                                                 NUMBER=(number if number > 1 else ''),
-                                                                 player=player,
-                                                                 PLAYER=(player if player > 1 else '')))
-    new_name = new_name.strip()[:16]
+
+    new_name = SafeFormatter().vformat(new_name, (), {"number": number,
+                                                      "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()
+
     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, type: str, name: str) -> dict:
+def update_weights(weights: dict, new_weights: dict, update_type: str, name: str) -> dict:
     logging.debug(f'Applying {new_weights}')
-    new_options = set(new_weights) - set(weights)
-    weights.update(new_weights)
+    cleaned_weights = {}
+    for option in new_weights:
+        option_name = option.lstrip("+-")
+        if option.startswith("+") and option_name in weights:
+            cleaned_value = weights[option_name]
+            new_value = new_weights[option]
+            if isinstance(new_value, set):
+                cleaned_value.update(new_value)
+            elif isinstance(new_value, list):
+                cleaned_value.extend(new_value)
+            elif isinstance(new_value, dict):
+                cleaned_value = dict(Counter(cleaned_value) + Counter(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
+        elif option.startswith("-") and option_name in weights:
+            cleaned_value = weights[option_name]
+            new_value = new_weights[option]
+            if isinstance(new_value, set):
+                cleaned_value.difference_update(new_value)
+            elif isinstance(new_value, list):
+                for element in new_value:
+                    cleaned_value.remove(element)
+            elif isinstance(new_value, dict):
+                cleaned_value = dict(Counter(cleaned_value) - Counter(new_value))
+            else:
+                raise Exception(f"Cannot apply remove to non-dict, set, or list type {option_name},"
+                                f" received {type(new_value).__name__}.")
+            cleaned_weights[option_name] = cleaned_value
+        else:
+            cleaned_weights[option_name] = new_weights[option]
+    new_options = set(cleaned_weights) - set(weights)
+    weights.update(cleaned_weights)
     if new_options:
         for new_option in new_options:
-            logging.warning(f'{type} Suboption "{new_option}" of "{name}" did not '
+            logging.warning(f'{update_type} Suboption "{new_option}" of "{name}" did not '
                             f'overwrite a root option. '
                             f'This is probably in error.')
     return weights
 
 
-def roll_meta_option(option_key, game: str, category_dict: Dict) -> Any:
+def roll_meta_option(option_key, game: str, category_dict: dict) -> Any:
+    from worlds import AutoWorldRegister
+
     if not game:
         return get_choice(option_key, category_dict)
     if game in AutoWorldRegister.world_types:
         game_world = AutoWorldRegister.world_types[game]
-        options = ChainMap(game_world.option_definitions, Options.per_game_common_options)
+        options = game_world.options_dataclass.type_hints
         if option_key in options:
             if options[option_key].supports_weighting:
                 return get_choice(option_key, category_dict)
             return category_dict[option_key]
-    if game == "A Link to the Past":  # TODO wow i hate this
-        if option_key in {"glitches_required", "dark_room_logic", "entrance_shuffle", "goals", "triforce_pieces_mode",
-                          "triforce_pieces_percentage", "triforce_pieces_available", "triforce_pieces_extra",
-                          "triforce_pieces_required", "shop_shuffle", "mode", "item_pool", "item_functionality",
-                          "boss_shuffle", "enemy_damage", "enemy_health", "timer", "countdown_start_time",
-                          "red_clock_time", "blue_clock_time", "green_clock_time", "dungeon_counters", "shuffle_prizes",
-                          "misery_mire_medallion", "turtle_rock_medallion", "sprite_pool", "sprite",
-                          "random_sprite_on_event"}:
-            return get_choice(option_key, category_dict)
-    raise Exception(f"Error generating meta option {option_key} for {game}.")
+    raise Options.OptionError(f"Error generating meta option {option_key} for {game}.")
 
 
 def roll_linked_options(weights: dict) -> dict:
@@ -362,7 +394,7 @@ def roll_linked_options(weights: dict) -> dict:
         if "name" not in option_set:
             raise ValueError("One of your linked options does not have a name.")
         try:
-            if roll_percentage(option_set["percentage"]):
+            if Options.roll_percentage(option_set["percentage"]):
                 logging.debug(f"Linked option {option_set['name']} triggered.")
                 new_options = option_set["options"]
                 for category_name, category_options in new_options.items():
@@ -373,12 +405,12 @@ def roll_linked_options(weights: dict) -> dict:
             else:
                 logging.debug(f"linked option {option_set['name']} skipped.")
         except Exception as e:
-            raise ValueError(f"Linked option {option_set['name']} is destroyed. "
+            raise ValueError(f"Linked option {option_set['name']} is invalid. "
                              f"Please fix your linked option.") from e
     return weights
 
 
-def roll_triggers(weights: dict, triggers: list) -> dict:
+def roll_triggers(weights: dict, triggers: list, valid_keys: set) -> dict:
     weights = copy.deepcopy(weights)  # make sure we don't write back to other weights sets in same_settings
     weights["_Generator_Version"] = Utils.__version__
     for i, option_set in enumerate(triggers):
@@ -395,41 +427,53 @@ def roll_triggers(weights: dict, triggers: list) -> dict:
             trigger_result = get_choice("option_result", option_set)
             result = get_choice(key, currently_targeted_weights)
             currently_targeted_weights[key] = result
-            if result == trigger_result and roll_percentage(get_choice("percentage", option_set, 100)):
+            if result == trigger_result and Options.roll_percentage(get_choice("percentage", option_set, 100)):
                 for category_name, category_options in option_set["options"].items():
                     currently_targeted_weights = weights
                     if category_name:
                         currently_targeted_weights = currently_targeted_weights[category_name]
                     update_weights(currently_targeted_weights, category_options, "Triggered", option_set["option_name"])
-
+            valid_keys.add(key)
         except Exception as e:
-            raise ValueError(f"Your trigger number {i + 1} is destroyed. "
+            raise ValueError(f"Your trigger number {i + 1} is invalid. "
                              f"Please fix your triggers.") from e
     return weights
 
 
 def handle_option(ret: argparse.Namespace, game_weights: dict, option_key: str, option: type(Options.Option), plando_options: PlandoOptions):
-    if option_key in game_weights:
-        try:
+    try:
+        if option_key in game_weights:
             if not option.supports_weighting:
                 player_option = option.from_any(game_weights[option_key])
             else:
                 player_option = option.from_any(get_choice(option_key, game_weights))
-            setattr(ret, option_key, player_option)
-        except Exception as e:
-            raise Exception(f"Error generating option {option_key} in {ret.game}") from e
         else:
-            player_option.verify(AutoWorldRegister.world_types[ret.game], ret.name, plando_options)
+            player_option = option.from_any(option.default)  # call the from_any here to support default "random"
+        setattr(ret, option_key, player_option)
+    except Exception as e:
+        raise Options.OptionError(f"Error generating option {option_key} in {ret.game}") from e
     else:
-        setattr(ret, option_key, option.from_any(option.default))  # call the from_any here to support default "random"
+        from worlds import AutoWorldRegister
+        player_option.verify(AutoWorldRegister.world_types[ret.game], ret.name, plando_options)
 
 
 def roll_settings(weights: dict, plando_options: PlandoOptions = PlandoOptions.bosses):
+    """
+    Roll options from specified weights, usually originating from a .yaml options file.
+
+    Important note:
+    The same weights dict is shared between all slots using the same yaml (e.g. generic weights file for filler slots).
+    This means it should never be modified without making a deepcopy first.
+    """
+
+    from worlds import AutoWorldRegister
+
     if "linked_options" in weights:
         weights = roll_linked_options(weights)
 
+    valid_keys = {"triggers"}
     if "triggers" in weights:
-        weights = roll_triggers(weights, weights["triggers"])
+        weights = roll_triggers(weights, weights["triggers"], valid_keys)
 
     requirements = weights.get("requires", {})
     if requirements:
@@ -444,175 +488,65 @@ def roll_settings(weights: dict, plando_options: PlandoOptions = PlandoOptions.b
                                 f"which is not enabled.")
 
     ret = argparse.Namespace()
-    for option_key in Options.per_game_common_options:
-        if option_key in weights and option_key not in Options.common_options:
+    for option_key in Options.PerGameCommonOptions.type_hints:
+        if option_key in weights and option_key not in Options.CommonOptions.type_hints:
             raise Exception(f"Option {option_key} has to be in a game's section, not on its own.")
 
     ret.game = get_choice("game", weights)
+    if not isinstance(ret.game, str):
+        if ret.game is None:
+            raise Exception('"game" not specified')
+        raise Exception(f"Invalid game: {ret.game}")
+    if ret.game not in AutoWorldRegister.world_types:
+        from worlds import failed_world_loads
+        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]
 
+    for weight in chain(game_weights, weights):
+        if weight.startswith("+"):
+            raise Exception(f"Merge tag cannot be used outside of trigger contexts. Found {weight}")
+        if weight.startswith("-"):
+            raise Exception(f"Remove tag cannot be used outside of trigger contexts. Found {weight}")
+
     if "triggers" in game_weights:
-        weights = roll_triggers(weights, game_weights["triggers"])
+        weights = roll_triggers(weights, game_weights["triggers"], valid_keys)
         game_weights = weights[ret.game]
 
     ret.name = get_choice('name', weights)
-    for option_key, option in Options.common_options.items():
+    for option_key, option in Options.CommonOptions.type_hints.items():
         setattr(ret, option_key, option.from_any(get_choice(option_key, weights, option.default)))
 
-    if ret.game in AutoWorldRegister.world_types:
-        for option_key, option in world_type.option_definitions.items():
-            handle_option(ret, game_weights, option_key, option, plando_options)
-        for option_key, option in Options.per_game_common_options.items():
-            # skip setting this option if already set from common_options, defaulting to root option
-            if option_key not in world_type.option_definitions and \
-                    (option_key not in Options.common_options or option_key in game_weights):
-                handle_option(ret, game_weights, option_key, option, plando_options)
-        if PlandoOptions.items in plando_options:
-            ret.plando_items = game_weights.get("plando_items", [])
-        if ret.game == "Minecraft" or ret.game == "Ocarina of Time":
-            # bad hardcoded behavior to make this work for now
-            ret.plando_connections = []
-            if PlandoOptions.connections in plando_options:
-                options = game_weights.get("plando_connections", [])
-                for placement in options:
-                    if roll_percentage(get_choice("percentage", placement, 100)):
-                        ret.plando_connections.append(PlandoConnection(
-                            get_choice("entrance", placement),
-                            get_choice("exit", placement),
-                            get_choice("direction", placement)
-                        ))
-        elif ret.game == "A Link to the Past":
-            roll_alttp_settings(ret, game_weights, plando_options)
-    else:
-        raise Exception(f"Unsupported game {ret.game}")
+    for option_key, option in world_type.options_dataclass.type_hints.items():
+        handle_option(ret, game_weights, option_key, option, plando_options)
+        valid_keys.add(option_key)
+
+    if ret.game == "A Link to the Past":
+        # TODO there are still more LTTP options not on the options system
+        valid_keys |= {"sprite_pool", "sprite", "random_sprite_on_event"}
+        roll_alttp_settings(ret, game_weights)
+
+    # log a warning for options within a game section that aren't determined as valid
+    for option_key in game_weights:
+        if option_key in valid_keys:
+            continue
+        logging.warning(f"{option_key} is not a valid option name for {ret.game} and is not present in triggers "
+                        f"for player {ret.name}.")
 
     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:
-        tt = TextTable()
-        tt.removeUnwantedText()
-        options = weights.get("plando_texts", [])
-        for placement in options:
-            if roll_percentage(get_choice_legacy("percentage", placement, 100)):
-                at = str(get_choice_legacy("at", placement))
-                if at not in tt:
-                    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")
-                ))
-
+def roll_alttp_settings(ret: argparse.Namespace, weights):
     ret.sprite_pool = weights.get('sprite_pool', [])
     ret.sprite = get_choice_legacy('sprite', weights, "Link")
     if 'random_sprite_on_event' in weights:
@@ -640,6 +574,17 @@ def roll_alttp_settings(ret: argparse.Namespace, weights, plando_options):
 if __name__ == '__main__':
     import atexit
     confirmation = atexit.register(input, "Press enter to close.")
-    main()
+    erargs, seed = main()
+    from Main import main as ERmain
+    multiworld = ERmain(erargs, seed)
+    if __debug__:
+        import gc
+        import sys
+        import weakref
+        weak = weakref.ref(multiworld)
+        del multiworld
+        gc.collect()  # need to collect to deref all hard references
+        assert not weak(), f"MultiWorld object was not de-allocated, it's referenced {sys.getrefcount(weak())} times." \
+                           " This would be a memory leak."
     # in case of error-free exit should not need confirmation
     atexit.unregister(confirmation)

KH1Client.py

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

KH2Client.py

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

LICENSE

@@ -1,7 +1,7 @@
 MIT License
 
 Copyright (c) 2017 LLCoolDave
-Copyright (c) 2022 Berserker66
+Copyright (c) 2025 Berserker66
 Copyright (c) 2022 CaitSith2
 Copyright (c) 2021 LegendaryLinux
 

Launcher.py

@@ -1,208 +1,203 @@
 """
-Archipelago launcher for bundled app.
+Archipelago Launcher
 
-* if run with APBP as argument, launch corresponding client.
-* if run with executable as argument, run it passing argv[2:] as arguments
-* if run without arguments, open launcher GUI
+* If run with a patch file as argument, launch corresponding client with the patch file as an argument.
+* If run with component name as argument, run it passing argv[2:] as arguments.
+* If run without arguments or unknown arguments, open launcher GUI.
 
-Scroll down to components= to add components to the launcher as well as setup.py
+Additional components can be added to worlds.LauncherComponents.components.
 """
 
-
 import argparse
-import itertools
+import logging
+import multiprocessing
+import os
 import shlex
 import subprocess
 import sys
-from enum import Enum, auto
+import urllib.parse
+import webbrowser
+from collections.abc import Callable, Sequence
 from os.path import isfile
 from shutil import which
-from typing import Iterable, Sequence, Callable, Union, Optional
+from typing import Any
 
 if __name__ == "__main__":
     import ModuleUpdate
+
     ModuleUpdate.update()
 
-from Utils import is_frozen, user_path, local_path, init_logging, open_filename, messagebox, \
-    is_windows, is_macos, is_linux
+import settings
+import Utils
+from Utils import (init_logging, is_frozen, is_linux, is_macos, is_windows, local_path, messagebox, open_filename,
+                   user_path)
+from worlds.LauncherComponents import Component, components, icon_paths, SuffixIdentifier, Type
 
 
 def open_host_yaml():
-    file = user_path('host.yaml')
+    s = settings.get_settings()
+    file = s.filename
+    s.save()
+    assert file, "host.yaml missing"
     if is_linux:
         exe = which('sensible-editor') or which('gedit') or \
               which('xdg-open') or which('gnome-open') or which('kde-open')
-        subprocess.Popen([exe, file])
     elif is_macos:
         exe = which("open")
-        subprocess.Popen([exe, file])
     else:
-        import webbrowser
         webbrowser.open(file)
+        return
 
+    env = os.environ
+    if "LD_LIBRARY_PATH" in env:
+        env = env.copy()
+        del env["LD_LIBRARY_PATH"]  # exe is a system binary, so reset LD_LIBRARY_PATH
+    subprocess.Popen([exe, file], env=env)
 
 def open_patch():
     suffixes = []
     for c in components:
-        if isfile(get_exe(c)[-1]):
-            suffixes += c.file_identifier.suffixes if c.type == Type.CLIENT and \
-                                                      isinstance(c.file_identifier, SuffixIdentifier) else []
+        if c.type == Type.CLIENT and \
+                isinstance(c.file_identifier, SuffixIdentifier) and \
+                (c.script_name is None or isfile(get_exe(c)[-1])):
+            suffixes += c.file_identifier.suffixes
     try:
-        filename = open_filename('Select patch', (('Patches', suffixes),))
+        filename = open_filename("Select patch", (("Patches", suffixes),))
     except Exception as e:
-        messagebox('Error', str(e), error=True)
+        messagebox("Error", str(e), error=True)
     else:
-        file, _, component = identify(filename)
+        file, component = identify(filename)
         if file and component:
-            launch([*get_exe(component), file], component.cli)
+            exe = get_exe(component)
+            if exe is None or not isfile(exe[-1]):
+                exe = get_exe("Launcher")
+
+            launch([*exe, file], component.cli)
+
+
+def generate_yamls():
+    from Options import generate_yaml_templates
+
+    target = Utils.user_path("Players", "Templates")
+    generate_yaml_templates(target, False)
+    open_folder(target)
 
 
 def browse_files():
-    file = user_path()
+    open_folder(user_path())
+
+
+def open_folder(folder_path):
     if is_linux:
         exe = which('xdg-open') or which('gnome-open') or which('kde-open')
-        subprocess.Popen([exe, file])
     elif is_macos:
         exe = which("open")
-        subprocess.Popen([exe, file])
     else:
-        import webbrowser
-        webbrowser.open(file)
+        webbrowser.open(folder_path)
+        return
+
+    if exe:
+        env = os.environ
+        if "LD_LIBRARY_PATH" in env:
+            env = env.copy()
+            del env["LD_LIBRARY_PATH"]  # exe is a system binary, so reset LD_LIBRARY_PATH
+        subprocess.Popen([exe, folder_path], env=env)
+    else:
+        logging.warning(f"No file browser available to open {folder_path}")
 
 
-# noinspection PyArgumentList
-class Type(Enum):
-    TOOL = auto()
-    FUNC = auto()  # not a real component
-    CLIENT = auto()
-    ADJUSTER = auto()
+def update_settings():
+    from settings import get_settings
+    get_settings().save()
 
 
-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')),
-    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')),
-    # ChecksFinder
-    Component('ChecksFinder Client', 'ChecksFinderClient'),
-    # Starcraft 2
-    Component('Starcraft 2 Client', 'Starcraft2Client'),
-    # Zillion
-    Component('Zillion Client', 'ZillionClient',
-              file_identifier=SuffixIdentifier('.apzl')),
+components.extend([
     # Functions
-    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')
-}
+    Component("Open host.yaml", func=open_host_yaml,
+              description="Open the host.yaml file to change settings for generation, games, and more."),
+    Component("Open Patch", func=open_patch,
+              description="Open a patch file, downloaded from the room page or provided by the host."),
+    Component("Generate Template Options", func=generate_yamls,
+              description="Generate template YAMLs for currently installed games."),
+    Component("Archipelago Website", func=lambda: webbrowser.open("https://archipelago.gg/"),
+              description="Open archipelago.gg in your browser."),
+    Component("Discord Server", icon="discord", func=lambda: webbrowser.open("https://discord.gg/8Z65BR2"),
+              description="Join the Discord server to play public multiworlds, report issues, or just chat!"),
+    Component("Unrated/18+ Discord Server", icon="discord",
+              func=lambda: webbrowser.open("https://discord.gg/fqvNCCRsu4"),
+              description="Find unrated and 18+ games in the After Dark Discord server."),
+    Component("Browse Files", func=browse_files,
+              description="Open the Archipelago installation folder in your file browser."),
+])
 
 
-def identify(path: Union[None, str]):
+def handle_uri(path: str) -> tuple[list[Component], Component]:
+    url = urllib.parse.urlparse(path)
+    queries = urllib.parse.parse_qs(url.query)
+    client_components = []
+    text_client_component = None
+    game = queries["game"][0]
+    for component in components:
+        if component.supports_uri and component.game_name == game:
+            client_components.append(component)
+        elif component.display_name == "Text Client":
+            text_client_component = component
+    return client_components, text_client_component
+
+
+def build_uri_popup(component_list: list[Component], launch_args: tuple[str, ...]) -> None:
+    from kvui import ButtonsPrompt
+    component_options = {
+        component.display_name: component for component in component_list
+    }
+    popup = ButtonsPrompt("Connect to Multiworld",
+                          "Select client to open and connect with.",
+                          lambda component_name: run_component(component_options[component_name], *launch_args),
+                          *component_options.keys())
+    popup.open()
+
+
+def identify(path: None | str) -> tuple[None | str, None | Component]:
     if path is None:
-        return None, None, None
+        return None, None
     for component in components:
         if component.handles_file(path):
-            return path, component.script_name, component
-    return (None, None, None) if '/' in path or '\\' in path else (None, path, None)
+            return path, component
+        elif path == component.display_name or path == component.script_name:
+            return None, component
+    return None, None
 
 
-def get_exe(component: Union[str, Component]) -> Optional[Sequence[str]]:
+def get_exe(component: str | Component) -> Sequence[str] | None:
     if isinstance(component, str):
         name = component
         component = None
-        if name.startswith('Archipelago'):
+        if name.startswith("Archipelago"):
             name = name[11:]
-        if name.endswith('.exe'):
+        if name.endswith(".exe"):
             name = name[:-4]
-        if name.endswith('.py'):
+        if name.endswith(".py"):
             name = name[:-3]
         if not name:
             return None
         for c in components:
-            if c.script_name == name or c.frozen_name == f'Archipelago{name}':
+            if c.script_name == name or c.frozen_name == f"Archipelago{name}":
                 component = c
                 break
         if not component:
             return None
     if is_frozen():
-        suffix = '.exe' if is_windows else ''
-        return [local_path(f'{component.frozen_name}{suffix}')]
+        suffix = ".exe" if is_windows else ""
+        return [local_path(f"{component.frozen_name}{suffix}")] if component.frozen_name else None
     else:
-        return [sys.executable, local_path(f'{component.script_name}.py')]
+        return [sys.executable, local_path(f"{component.script_name}.py")] if component.script_name else None
 
 
 def launch(exe, in_terminal=False):
     if in_terminal:
         if is_windows:
-            subprocess.Popen(['start', *exe], shell=True)
+            # intentionally using a window title with a space so it gets quoted and treated as a title
+            subprocess.Popen(["start", "Running Archipelago", *exe], shell=True)
             return
         elif is_linux:
             terminal = which('x-terminal-emulator') or which('gnome-terminal') or which('xterm')
@@ -216,87 +211,298 @@ def launch(exe, in_terminal=False):
     subprocess.Popen(exe)
 
 
-def run_gui():
-    from kvui import App, ContainerLayout, GridLayout, Button, Label
+def create_shortcut(button: Any, component: Component) -> None:
+    from pyshortcuts import make_shortcut
+    script = sys.argv[0]
+    wkdir = Utils.local_path()
 
-    class Launcher(App):
+    script = f"{script} \"{component.display_name}\""
+    make_shortcut(script, name=f"Archipelago {component.display_name}", icon=local_path("data", "icon.ico"),
+                  startmenu=False, terminal=False, working_dir=wkdir)
+    button.menu.dismiss()
+
+
+refresh_components: Callable[[], None] | None = None
+
+
+def run_gui(launch_components: list[Component], args: Any) -> None:
+    from kvui import (ThemedApp, MDFloatLayout, MDGridLayout, ScrollBox)
+    from kivy.properties import ObjectProperty
+    from kivy.core.window import Window
+    from kivy.metrics import dp
+    from kivymd.uix.button import MDIconButton, MDButton
+    from kivymd.uix.card import MDCard
+    from kivymd.uix.menu import MDDropdownMenu
+    from kivymd.uix.snackbar import MDSnackbar, MDSnackbarText
+    from kivymd.uix.textfield import MDTextField
+
+    from kivy.lang.builder import Builder
+
+    class LauncherCard(MDCard):
+        component: Component | None
+        image: str
+        context_button: MDIconButton = ObjectProperty(None)
+
+        def __init__(self, *args, component: Component | None = None, image_path: str = "", **kwargs):
+            self.component = component
+            self.image = image_path
+            super().__init__(args, kwargs)
+
+    class Launcher(ThemedApp):
         base_title: str = "Archipelago Launcher"
-        container: ContainerLayout
-        grid: GridLayout
+        top_screen: MDFloatLayout = ObjectProperty(None)
+        navigation: MDGridLayout = ObjectProperty(None)
+        grid: MDGridLayout = ObjectProperty(None)
+        button_layout: ScrollBox = ObjectProperty(None)
+        search_box: MDTextField = ObjectProperty(None)
+        cards: list[LauncherCard]
+        current_filter: Sequence[str | Type] | None
 
-        _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
+        def __init__(self, ctx=None, components=None, args=None):
+            self.title = self.base_title + " " + Utils.__version__
             self.ctx = ctx
             self.icon = r"data/icon.png"
+            self.favorites = []
+            self.launch_components = components
+            self.launch_args = args
+            self.cards = []
+            self.current_filter = (Type.CLIENT, Type.TOOL, Type.ADJUSTER, Type.MISC)
+            persistent = Utils.persistent_load()
+            if "launcher" in persistent:
+                if "favorites" in persistent["launcher"]:
+                    self.favorites.extend(persistent["launcher"]["favorites"])
+                if "filter" in persistent["launcher"]:
+                    if persistent["launcher"]["filter"]:
+                        filters = []
+                        for filter in persistent["launcher"]["filter"].split(", "):
+                            if filter == "favorites":
+                                filters.append(filter)
+                            else:
+                                filters.append(Type[filter])
+                        self.current_filter = filters
             super().__init__()
 
+        def set_favorite(self, caller):
+            if caller.component.display_name in self.favorites:
+                self.favorites.remove(caller.component.display_name)
+                caller.icon = "star-outline"
+            else:
+                self.favorites.append(caller.component.display_name)
+                caller.icon = "star"
+
+        def build_card(self, component: Component) -> LauncherCard:
+            """
+                Builds a card widget for a given component.
+
+                :param component: The component associated with the button.
+
+                :return: The created Card Widget.
+                """
+            button_card = LauncherCard(component=component,
+                                       image_path=icon_paths[component.icon])
+
+            def open_menu(caller):
+                caller.menu.open()
+
+            menu_items = [
+                {
+                    "text": "Add shortcut on desktop",
+                    "leading_icon": "laptop",
+                    "on_release": lambda: create_shortcut(button_card.context_button, component)
+                }
+            ]
+            button_card.context_button.menu = MDDropdownMenu(caller=button_card.context_button, items=menu_items)
+            button_card.context_button.bind(on_release=open_menu)
+
+            return button_card
+
+        def _refresh_components(self, type_filter: Sequence[str | Type] | None = None) -> None:
+            if not type_filter:
+                type_filter = [Type.CLIENT, Type.ADJUSTER, Type.TOOL, Type.MISC]
+            favorites = "favorites" in type_filter
+
+            # clear before repopulating
+            assert self.button_layout, "must call `build` first"
+            tool_children = reversed(self.button_layout.layout.children)
+            for child in tool_children:
+                self.button_layout.layout.remove_widget(child)
+
+            cards = [card for card in self.cards if card.component.type in type_filter
+                     or favorites and card.component.display_name in self.favorites]
+
+            self.current_filter = type_filter
+
+            for card in cards:
+                self.button_layout.layout.add_widget(card)
+
+            top = self.button_layout.children[0].y + self.button_layout.children[0].height \
+                           - self.button_layout.height
+            scroll_percent = self.button_layout.convert_distance_to_scroll(0, top)
+            self.button_layout.scroll_y = max(0, min(1, scroll_percent[1]))
+
+        def filter_clients_by_type(self, caller: MDButton):
+            self._refresh_components(caller.type)
+            self.search_box.text = ""
+
+        def filter_clients_by_name(self, caller: MDTextField, name: str) -> None:
+            if len(name) == 0:
+                self._refresh_components(self.current_filter)
+                return
+
+            sub_matches = [
+                card for card in self.cards
+                if name.lower() in card.component.display_name.lower() and card.component.type != Type.HIDDEN
+            ]
+            self.button_layout.layout.clear_widgets()
+            for card in sub_matches:
+                self.button_layout.layout.add_widget(card)
+
         def build(self):
-            self.container = ContainerLayout()
-            self.grid = GridLayout(cols=2)
-            self.container.add_widget(self.grid)
+            self.top_screen = Builder.load_file(Utils.local_path("data/launcher.kv"))
+            self.grid = self.top_screen.ids.grid
+            self.navigation = self.top_screen.ids.navigation
+            self.button_layout = self.top_screen.ids.button_layout
+            self.search_box = self.top_screen.ids.search_box
+            self.set_colors()
+            self.top_screen.md_bg_color = self.theme_cls.backgroundColor
 
-            button_layout = self.grid  # make buttons fill the window
-            for (tool, client) in itertools.zip_longest(itertools.chain(
-                    self._tools.items(), self._funcs.items(), self._adjusters.items()), self._clients.items()):
-                # column 1
-                if tool:
-                    button = Button(text=tool[0])
-                    button.component = tool[1]
-                    button.bind(on_release=self.component_action)
-                    button_layout.add_widget(button)
-                else:
-                    button_layout.add_widget(Label())
-                # column 2
-                if client:
-                    button = Button(text=client[0])
-                    button.component = client[1]
-                    button.bind(on_press=self.component_action)
-                    button_layout.add_widget(button)
-                else:
-                    button_layout.add_widget(Label())
+            global refresh_components
+            refresh_components = self._refresh_components
 
-            return self.container
+            Window.bind(on_drop_file=self._on_drop_file)
+            Window.bind(on_keyboard=self._on_keyboard)
+
+            for component in components:
+                self.cards.append(self.build_card(component))
+
+            self._refresh_components(self.current_filter)
+
+            # Uncomment to re-enable the Kivy console/live editor
+            # Ctrl-E to enable it, make sure numlock/capslock is disabled
+            # from kivy.modules.console import create_console
+            # create_console(Window, self.top_screen)
+
+            return self.top_screen
+
+        def on_start(self):
+            if self.launch_components:
+                build_uri_popup(self.launch_components, self.launch_args)
+                self.launch_components = None
+                self.launch_args = None
 
         @staticmethod
         def component_action(button):
-            if button.component.type == Type.FUNC:
+            MDSnackbar(MDSnackbarText(text="Opening in a new window..."), y=dp(24), pos_hint={"center_x": 0.5},
+                       size_hint_x=0.5).open()
+            if button.component.func:
                 button.component.func()
             else:
                 launch(get_exe(button.component), button.component.cli)
 
-    Launcher().run()
+        def _on_drop_file(self, window: Window, filename: bytes, x: int, y: int) -> None:
+            """ When a patch file is dropped into the window, run the associated component. """
+            file, component = identify(filename.decode())
+            if file and component:
+                run_component(component, file)
+            else:
+                logging.warning(f"unable to identify component for {filename}")
+
+        def _on_keyboard(self, window: Window, key: int, scancode: int, codepoint: str, modifier: list[str]):
+            # Activate search as soon as we start typing, no matter if we are focused on the search box or not.
+            # Focus first, then capture the first character we type, otherwise it gets swallowed and lost.
+            # Limit text input to ASCII non-control characters (space bar to tilde).
+            if not self.search_box.focus:
+                self.search_box.focus = True
+                if key in range(32, 126):
+                    self.search_box.text += codepoint
+
+        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)
+
+        def on_stop(self):
+            Utils.persistent_store("launcher", "favorites", self.favorites)
+            Utils.persistent_store("launcher", "filter", ", ".join(filter.name if isinstance(filter, Type) else filter
+                                                                   for filter in self.current_filter))
+            super().on_stop()
+
+    Launcher(components=launch_components, args=args).run()
+
+    # avoiding Launcher reference leak
+    # and don't try to do something with widgets after window closed
+    global refresh_components
+    refresh_components = None
 
 
-def main(args: Optional[Union[argparse.Namespace, dict]] = None):
+def run_component(component: Component, *args):
+    if component.func:
+        component.func(*args)
+        if refresh_components:
+            refresh_components()
+    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: argparse.Namespace | dict | None = None):
     if isinstance(args, argparse.Namespace):
         args = {k: v for k, v in args._get_kwargs()}
     elif not args:
         args = {}
 
-    if "Patch|Game|Component" in args:
-        file, component, _ = identify(args["Patch|Game|Component"])
-        if file:
-            args['file'] = file
-        if component:
-            args['component'] = component
+    path = args.get("Patch|Game|Component|url", None)
+    if path is not None:
+        if path.startswith("archipelago://"):
+            args["args"] = (path, *args.get("args", ()))
+            # add the url arg to the passthrough args
+            components, text_client_component = handle_uri(path)
+            if not components:
+                args["component"] = text_client_component
+            else:
+                args['launch_components'] = [text_client_component, *components]
+        else:
+            file, component = identify(path)
+            if file:
+                args['file'] = file
+            if component:
+                args['component'] = component
+            if not component:
+                logging.warning(f"Could not identify Component responsible for {path}")
 
-    if 'file' in args:
-        subprocess.run([*get_exe(args['component']), args['file'], *args['args']])
-    elif 'component' in args:
-        subprocess.run([*get_exe(args['component']), *args['args']])
-    else:
-        run_gui()
+    if args["update_settings"]:
+        update_settings()
+    if "file" in args:
+        run_component(args["component"], args["file"], *args["args"])
+    elif "component" in args:
+        run_component(args["component"], *args["args"])
+    elif not args["update_settings"]:
+        run_gui(args.get("launch_components", None), args.get("args", ()))
 
 
 if __name__ == '__main__':
     init_logging('Launcher')
-    parser = argparse.ArgumentParser(description='Archipelago Launcher')
-    parser.add_argument('Patch|Game|Component', type=str, nargs='?',
-                        help="Pass either a patch file, a generated game or the name of a component to run.")
-    parser.add_argument('args', nargs="*", help="Arguments to pass to component.")
+    multiprocessing.freeze_support()
+    multiprocessing.set_start_method("spawn")  # if launched process uses kivy, fork won't work
+    parser = argparse.ArgumentParser(
+        description='Archipelago Launcher',
+        usage="[-h] [--update_settings] [Patch|Game|Component] [-- component args here]"
+    )
+    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|url", type=str, nargs="?",
+                           help="Pass either a patch file, a generated game, the component name to run, or a url to "
+                                "connect with.")
+    run_group.add_argument("args", nargs="*",
+                           help="Arguments to pass to component.")
     main(parser.parse_args())
+
+    from worlds.LauncherComponents import processes
+
+    for process in processes:
+        # we await all child processes to close before we tear down the process host
+        # this makes it feel like each one is its own program, as the Launcher is closed now
+        process.join()

LinksAwakeningClient.py

@@ -0,0 +1,801 @@
+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 import LinksAwakeningWorld
+from worlds.ladx.Common import BASE_ID as LABaseID
+from worlds.ladx.GpsTracker import GpsTracker
+from worlds.ladx.TrackerConsts import storage_key
+from worlds.ladx.ItemTracker import ItemTracker
+from worlds.ladx.LADXR.checkMetadata import checkMetadataTable
+from worlds.ladx.Locations import get_locations_to_id, meta_to_name
+from worlds.ladx.Tracker import LocationTracker, MagpieBridge, Check
+
+
+class GameboyException(Exception):
+    pass
+
+
+class RetroArchDisconnectError(GameboyException):
+    pass
+
+
+class InvalidEmulatorStateError(GameboyException):
+    pass
+
+
+class BadRetroArchResponse(GameboyException):
+    pass
+
+
+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)
+
+    wRamStart = 0xC000
+    hRamStart = 0xFF80
+    hRamSize = 0x80
+
+    MinGameplayValue = 0x06
+    MaxGameplayValue = 0x1A
+    VictoryGameplayAndSub = 0x0102
+
+class RAGameboy():
+    cache = []
+    last_cache_read = None
+    socket = None
+
+    def __init__(self, address, port) -> None:
+        self.cache_start = LAClientConstants.wRamStart
+        self.cache_size = LAClientConstants.hRamStart + LAClientConstants.hRamSize - LAClientConstants.wRamStart
+
+        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_checks_range(self, checks_start, checks_size):
+        self.checks_start = checks_start
+        self.checks_size = checks_size
+
+    def set_location_range(self, location_start, location_size, critical_addresses):
+        self.location_start = location_start
+        self.location_size = location_size
+        self.critical_location_addresses = critical_addresses
+
+    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
+
+        attempts = 0
+        while True:
+            # RA doesn't let us do an atomic read of a large enough block of RAM
+            # Some bytes can't change in between reading location_block and hram_block
+            location_block = await self.read_memory_block(self.location_start, self.location_size)
+            hram_block = await self.read_memory_block(LAClientConstants.hRamStart, LAClientConstants.hRamSize)
+            verification_block = await self.read_memory_block(self.location_start, self.location_size)
+
+            valid = True
+            for address in self.critical_location_addresses:
+                if location_block[address - self.location_start] != verification_block[address - self.location_start]:
+                    valid = False
+
+            if valid:
+                break
+
+            attempts += 1
+
+            # Shouldn't really happen, but keep it from choking
+            if attempts > 5:
+                return
+
+        checks_block = await self.read_memory_block(self.checks_start, self.checks_size)
+
+        if not await self.check_safe_gameplay():
+            return
+
+        self.cache = bytearray(self.cache_size)
+
+        start = self.checks_start - self.cache_start
+        self.cache[start:start + len(checks_block)] = checks_block
+
+        start = self.location_start - self.cache_start
+        self.cache[start:start + len(location_block)] = location_block
+
+        start = LAClientConstants.hRamStart - self.cache_start
+        self.cache[start:start + len(hram_block)] = hram_block
+
+        self.last_cache_read = time.time()
+
+    async def read_memory_block(self, address: int, size: int):
+        block = bytearray()
+        remaining_size = size
+        while remaining_size:
+            chunk = await self.async_read_memory(address + len(block), remaining_size)
+            remaining_size -= len(chunk)
+            block += chunk
+
+        return block
+
+    async def read_memory_cache(self, addresses):
+        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(r"\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, magpie: MagpieBridge):
+        await self.wait_for_game_ready()
+        self.tracker = LocationTracker(self.gameboy)
+        self.item_tracker = ItemTracker(self.gameboy)
+        self.gps_tracker = GpsTracker(self.gameboy)
+        magpie.gps_tracker = self.gps_tracker
+
+    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.gameboy.update_cache()
+        await self.tracker.readChecks(item_get_cb)
+        await self.item_tracker.readItems()
+        await self.gps_tracker.read_location()
+        await self.gps_tracker.read_entrances()
+
+        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 = set()
+    last_resend = time.time()
+
+    magpie_enabled = False
+    magpie = None
+    magpie_task = None
+    won = False
+
+    @property
+    def slot_storage_key(self):
+        return f"{self.slot_info[self.slot].name}_{storage_key}"
+
+    def __init__(self, server_address: typing.Optional[str], password: typing.Optional[str], magpie: typing.Optional[bool]) -> None:
+        self.client = LinksAwakeningClient()
+        self.slot_data = {}
+
+        if magpie:
+            self.magpie_enabled = True
+            self.magpie = MagpieBridge()
+        super().__init__(server_address, password)
+
+    def run_gui(self) -> None:
+        import webbrowser
+        from kvui import GameManager
+        from kivy.metrics import dp
+        from kivymd.uix.button import MDButton, MDButtonText
+
+        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 = MDButton(MDButtonText(text="Open Tracker"), style="filled", size=(dp(100), dp(70)), radius=5,
+                                      size_hint_x=None, size_hint_y=None, pos_hint={"center_y": 0.55},
+                                      on_press=lambda _: webbrowser.open('https://magpietracker.us/?enable_autotracker=1'))
+                    button.height = self.server_connect_bar.height
+                    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_new_entrances(self, entrances: typing.Dict[str, str]):
+        # Store the entrances we find on the server for future sessions
+        message = [{
+            "cmd": "Set",
+            "key": self.slot_storage_key,
+            "default": {},
+            "want_reply": False,
+            "operations": [{"operation": "update", "value": entrances}],
+        }]
+
+        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 request_found_entrances(self):
+        await self.send_msgs([{"cmd": "Get", "keys": [self.slot_storage_key]}])
+
+        # Ask for updates so that players can co-op entrances in a seed
+        await self.send_msgs([{"cmd": "SetNotify", "keys": [self.slot_storage_key]}])
+
+    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.update(item_ids)
+        create_task_log_exception(self.check_locations(self.found_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)
+
+            # Just return if we're closing
+            if self.exit_event.is_set():
+                return
+        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
+            self.slot_data = args.get("slot_data", {})
+            # This is sent to magpie over local websocket to make its own connection
+            self.slot_data.update({
+                "server_address": self.server_address,
+                "slot_name": self.player_names[self.slot],
+                "password": self.password,
+            })
+
+            # We can process linked items on already-checked checks now that we have slot_data
+            if self.client.tracker:
+                checked_checks = set(self.client.tracker.all_checks) - set(self.client.tracker.remaining_checks)
+                self.add_linked_items(checked_checks)
+
+        # TODO - use watcher_event
+        if cmd == "ReceivedItems":
+            for index, item in enumerate(args["items"], start=args["index"]):
+                self.client.recvd_checks[index] = item
+
+        if cmd == "Retrieved" and self.magpie_enabled and self.slot_storage_key in args["keys"]:
+            self.client.gps_tracker.receive_found_entrances(args["keys"][self.slot_storage_key])
+
+        if cmd == "SetReply" and self.magpie_enabled and args["key"] == self.slot_storage_key:
+            self.client.gps_tracker.receive_found_entrances(args["value"])
+
+    async def sync(self):
+        sync_msg = [{'cmd': 'Sync'}]
+        await self.send_msgs(sync_msg)
+
+    def add_linked_items(self, checks: typing.List[Check]):
+        for check in checks:
+            if check.value and check.linkedItem:
+                linkedItem = check.linkedItem
+                if 'condition' not in linkedItem or (self.slot_data and linkedItem['condition'](self.slot_data)):
+                    self.client.item_tracker.setExtraItem(check.linkedItem['item'], check.linkedItem['qty'])
+
+    item_id_lookup = get_locations_to_id()
+
+    async def run_game_loop(self):
+        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])
+
+            self.add_linked_items(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(self.magpie)
+
+                min_tick_duration = 0.1
+                last_tick = time.time()
+                while True:
+                    await self.client.main_tick(on_item_get, victory, deathlink)
+
+                    now = time.time()
+                    tick_duration = now - last_tick
+                    sleep_duration = max(min_tick_duration - tick_duration, 0)
+                    await asyncio.sleep(sleep_duration)
+
+                    last_tick = now
+
+                    if self.last_resend + 5.0 < now:
+                        self.last_resend = now
+                        await self.check_locations(self.found_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)
+                            if self.slot_data and "slot_data" in self.magpie.features and not self.magpie.has_sent_slot_data:
+                                self.magpie.slot_data = self.slot_data
+                                await self.magpie.send_slot_data()
+
+                            if self.client.gps_tracker.needs_found_entrances:
+                                await self.request_found_entrances()
+                                self.client.gps_tracker.needs_found_entrances = False
+
+                            new_entrances = await self.magpie.send_gps(self.client.gps_tracker)
+                            if new_entrances:
+                                await self.send_new_entrances(new_entrances)
+                        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 = LinksAwakeningWorld.settings.rom_start
+
+    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.just_fix_windows_console()
+    asyncio.run(main())
+    colorama.deinit()

LttPAdjuster.py

@@ -14,7 +14,7 @@ import tkinter as tk
 from argparse import Namespace
 from concurrent.futures import as_completed, ThreadPoolExecutor
 from glob import glob
-from tkinter import Tk, Frame, Label, StringVar, Entry, filedialog, messagebox, Button, Radiobutton, LEFT, X, TOP, LabelFrame, \
+from tkinter import Tk, Frame, Label, StringVar, Entry, filedialog, messagebox, Button, Radiobutton, LEFT, X, BOTH, TOP, LabelFrame, \
     IntVar, Checkbutton, E, W, OptionMenu, Toplevel, BOTTOM, RIGHT, font as font, PhotoImage
 from tkinter.constants import DISABLED, NORMAL
 from urllib.parse import urlparse
@@ -25,17 +25,23 @@ ModuleUpdate.update()
 
 from worlds.alttp.Rom import Sprite, LocalRom, apply_rom_settings, get_base_rom_bytes
 from Utils import output_path, local_path, user_path, open_file, get_cert_none_ssl_context, persistent_store, \
-    get_adjuster_settings, tkinter_center_window, init_logging
+    get_adjuster_settings, get_adjuster_settings_no_defaults, tkinter_center_window, init_logging
 
 
 GAME_ALTTP = "A Link to the Past"
+WINDOW_MIN_HEIGHT = 525
+WINDOW_MIN_WIDTH = 425
 
 
 class AdjusterWorld(object):
+    class AdjusterSubWorld(object):
+        def __init__(self, random):
+            self.random = random
+
     def __init__(self, sprite_pool):
         import random
         self.sprite_pool = {1: sprite_pool}
-        self.slot_seeds = {1: random}
+        self.worlds = {1: self.AdjusterSubWorld(random)}
 
 
 class ArgumentDefaultsHelpFormatter(argparse.RawTextHelpFormatter):
@@ -44,7 +50,49 @@ class ArgumentDefaultsHelpFormatter(argparse.RawTextHelpFormatter):
         return textwrap.dedent(action.help)
 
 
-def main():
+# 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:
     parser = argparse.ArgumentParser(formatter_class=ArgumentDefaultsHelpFormatter)
 
     parser.add_argument('rom', nargs="?", default='AP_LttP.sfc', help='Path to an ALttP rom to adjust.')
@@ -52,6 +100,8 @@ def main():
                         help='Path to an ALttP Japan(1.0) rom to use as a base.')
     parser.add_argument('--loglevel', default='info', const='info', nargs='?',
                         choices=['error', 'info', 'warning', 'debug'], help='Select level of logging for output.')
+    parser.add_argument('--auto_apply', default='ask',
+                        choices=['ask', 'always', 'never'], help='Whether or not to apply settings automatically in the future.')
     parser.add_argument('--menuspeed', default='normal', const='normal', nargs='?',
                         choices=['normal', 'instant', 'double', 'triple', 'quadruple', 'half'],
                         help='''\
@@ -61,7 +111,7 @@ def main():
     parser.add_argument('--quickswap', help='Enable quick item swapping with L and R.', action='store_true')
     parser.add_argument('--deathlink', help='Enable DeathLink system.', action='store_true')
     parser.add_argument('--allowcollect', help='Allow collection of other player items', action='store_true')
-    parser.add_argument('--disablemusic', help='Disables game music.', action='store_true')
+    parser.add_argument('--music', default=True, help='Enables/Disables game music.', action=BooleanOptionalActionWithDisable)
     parser.add_argument('--triforcehud', default='hide_goal', const='hide_goal', nargs='?',
                         choices=['normal', 'hide_goal', 'hide_required', 'hide_both'],
                         help='''\
@@ -85,9 +135,6 @@ def main():
     parser.add_argument('--ow_palettes', default='default',
                         choices=['default', 'random', 'blackout', 'puke', 'classic', 'grayscale', 'negative', 'dizzy',
                                  'sick'])
-    # parser.add_argument('--link_palettes', default='default',
-    #                     choices=['default', 'random', 'blackout', 'puke', 'classic', 'grayscale', 'negative', 'dizzy',
-    #                              'sick'])
     parser.add_argument('--shield_palettes', default='default',
                         choices=['default', 'random', 'blackout', 'puke', 'classic', 'grayscale', 'negative', 'dizzy',
                                  'sick'])
@@ -107,10 +154,23 @@ def main():
                              Alternatively, can be a ALttP Rom patched with a Link
                              sprite that will be extracted.
                              ''')
-    parser.add_argument('--names', default='', type=str)
+    parser.add_argument('--sprite_pool', nargs='+', default=[], help='''
+                             A list of sprites to pull from.
+                        ''')
+    parser.add_argument('--oof', help='''\
+                             Path to a sound effect to replace Link's "oof" sound.
+                             Needs to be in a .brr format and have a length of no
+                             more than 2673 bytes, created from a 16-bit signed PCM
+                             .wav at 12khz. https://github.com/boldowa/snesbrr
+                             ''')
     parser.add_argument('--update_sprites', action='store_true', help='Update Sprite Database, then exit.')
-    args = parser.parse_args()
-    args.music = not args.disablemusic
+    return parser
+
+
+def main():
+    parser = get_argparser()
+    args = parser.parse_args(namespace=get_adjuster_settings_no_defaults(GAME_ALTTP))
+    
     # set up logger
     loglevel = {'error': logging.ERROR, 'info': logging.INFO, 'warning': logging.WARNING, 'debug': logging.DEBUG}[
         args.loglevel]
@@ -126,6 +186,13 @@ def main():
         if args.sprite is not None and not os.path.isfile(args.sprite) and not Sprite.get_sprite_from_name(args.sprite):
             input('Could not find link sprite sheet at given location. \nPress Enter to exit.')
             sys.exit(1)
+        if args.oof is not None and not os.path.isfile(args.oof):
+            input('Could not find oof sound effect at given location. \nPress Enter to exit.')
+            sys.exit(1)
+        if args.oof is not None and os.path.getsize(args.oof) > 2673:
+            input('"oof" sound effect cannot exceed 2673 bytes. \nPress Enter to exit.')
+            sys.exit(1)
+            
 
         args, path = adjust(args=args)
         if isinstance(args.sprite, Sprite):
@@ -165,7 +232,7 @@ def adjust(args):
         world = getattr(args, "world")
 
     apply_rom_settings(rom, args.heartbeep, args.heartcolor, args.quickswap, args.menuspeed, args.music,
-                       args.sprite, palettes_options, reduceflashing=args.reduceflashing or racerom, world=world,
+                       args.sprite, args.oof, palettes_options, reduceflashing=args.reduceflashing or racerom, world=world,
                        deathlink=args.deathlink, allowcollect=args.allowcollect)
     path = output_path(f'{os.path.basename(args.rom)[:-4]}_adjusted.sfc')
     rom.write_to_file(path)
@@ -180,18 +247,19 @@ def adjustGUI():
     from tkinter import Tk, LEFT, BOTTOM, TOP, \
         StringVar, Frame, Label, X, Entry, Button, filedialog, messagebox, ttk
     from argparse import Namespace
-    from Main import __version__ as MWVersion
+    from Utils import __version__ as MWVersion
     adjustWindow = Tk()
+    adjustWindow.minsize(WINDOW_MIN_WIDTH, WINDOW_MIN_HEIGHT)
     adjustWindow.wm_title("Archipelago %s LttP Adjuster" % MWVersion)
     set_icon(adjustWindow)
 
     rom_options_frame, rom_vars, set_sprite = get_rom_options_frame(adjustWindow)
 
-    bottomFrame2 = Frame(adjustWindow)
+    bottomFrame2 = Frame(adjustWindow, padx=8, pady=2)
 
     romFrame, romVar = get_rom_frame(adjustWindow)
 
-    romDialogFrame = Frame(adjustWindow)
+    romDialogFrame = Frame(adjustWindow, padx=8, pady=2)
     baseRomLabel2 = Label(romDialogFrame, text='Rom to adjust')
     romVar2 = StringVar()
     romEntry2 = Entry(romDialogFrame, textvariable=romVar2)
@@ -201,9 +269,9 @@ def adjustGUI():
         romVar2.set(rom)
 
     romSelectButton2 = Button(romDialogFrame, text='Select Rom', command=RomSelect2)
-    romDialogFrame.pack(side=TOP, expand=True, fill=X)
-    baseRomLabel2.pack(side=LEFT)
-    romEntry2.pack(side=LEFT, expand=True, fill=X)
+    romDialogFrame.pack(side=TOP, expand=False, fill=X)
+    baseRomLabel2.pack(side=LEFT, expand=False, fill=X, padx=(0, 8))
+    romEntry2.pack(side=LEFT, expand=True, fill=BOTH, pady=1)
     romSelectButton2.pack(side=LEFT)
 
     def adjustRom():
@@ -227,6 +295,7 @@ def adjustGUI():
         guiargs.sprite = rom_vars.sprite
         if rom_vars.sprite_pool:
             guiargs.world = AdjusterWorld(rom_vars.sprite_pool)
+        guiargs.oof = rom_vars.oof
 
         try:
             guiargs, path = adjust(args=guiargs)
@@ -265,16 +334,16 @@ 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")
 
     adjustButton = Button(bottomFrame2, text='Adjust Rom', command=adjustRom)
-    rom_options_frame.pack(side=TOP)
+    rom_options_frame.pack(side=TOP, padx=8, pady=8, fill=BOTH, expand=True)
     adjustButton.pack(side=LEFT, padx=(5,5))
 
     saveButton = Button(bottomFrame2, text='Save Settings', command=saveGUISettings)
     saveButton.pack(side=LEFT, padx=(5,5))
-
     bottomFrame2.pack(side=TOP, pady=(5,5))
 
     tkinter_center_window(adjustWindow)
@@ -296,10 +365,10 @@ def run_sprite_update():
     logging.info("Done updating sprites")
 
 
-def update_sprites(task, on_finish=None):
+def update_sprites(task, on_finish=None, repository_url: str = "https://alttpr.com/sprites"):
     resultmessage = ""
     successful = True
-    sprite_dir = user_path("data", "sprites", "alttpr")
+    sprite_dir = user_path("data", "sprites", "alttp", "remote")
     os.makedirs(sprite_dir, exist_ok=True)
     ctx = get_cert_none_ssl_context()
 
@@ -309,11 +378,11 @@ def update_sprites(task, on_finish=None):
             on_finish(successful, resultmessage)
 
     try:
-        task.update_status("Downloading alttpr sprites list")
-        with urlopen('https://alttpr.com/sprites', context=ctx) as response:
+        task.update_status("Downloading remote sprites list")
+        with urlopen(repository_url, context=ctx) as response:
             sprites_arr = json.loads(response.read().decode("utf-8"))
     except Exception as e:
-        resultmessage = "Error getting list of alttpr sprites. Sprites not updated.\n\n%s: %s" % (type(e).__name__, e)
+        resultmessage = "Error getting list of remote sprites. Sprites not updated.\n\n%s: %s" % (type(e).__name__, e)
         successful = False
         task.queue_event(finished)
         return
@@ -321,13 +390,13 @@ def update_sprites(task, on_finish=None):
     try:
         task.update_status("Determining needed sprites")
         current_sprites = [os.path.basename(file) for file in glob(sprite_dir + '/*')]
-        alttpr_sprites = [(sprite['file'], os.path.basename(urlparse(sprite['file']).path))
+        remote_sprites = [(sprite['file'], os.path.basename(urlparse(sprite['file']).path))
                           for sprite in sprites_arr if sprite["author"] != "Nintendo"]
-        needed_sprites = [(sprite_url, filename) for (sprite_url, filename) in alttpr_sprites if
+        needed_sprites = [(sprite_url, filename) for (sprite_url, filename) in remote_sprites if
                           filename not in current_sprites]
 
-        alttpr_filenames = [filename for (_, filename) in alttpr_sprites]
-        obsolete_sprites = [sprite for sprite in current_sprites if sprite not in alttpr_filenames]
+        remote_filenames = [filename for (_, filename) in remote_sprites]
+        obsolete_sprites = [sprite for sprite in current_sprites if sprite not in remote_filenames]
     except Exception as e:
         resultmessage = "Error Determining which sprites to update. Sprites not updated.\n\n%s: %s" % (
         type(e).__name__, e)
@@ -379,7 +448,7 @@ def update_sprites(task, on_finish=None):
                 successful = False
 
     if successful:
-        resultmessage = "alttpr sprites updated successfully"
+        resultmessage = "Remote sprites updated successfully"
 
     task.queue_event(finished)
 
@@ -481,13 +550,40 @@ 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)
+    romFrame = Frame(parent, padx=8, pady=8)
     baseRomLabel = Label(romFrame, text='LttP Base Rom: ')
     romVar = StringVar(value=adjuster_settings.baserom)
     romEntry = Entry(romFrame, textvariable=romVar)
@@ -507,44 +603,19 @@ def get_rom_frame(parent=None):
     romSelectButton = Button(romFrame, text='Select Rom', command=RomSelect)
 
     baseRomLabel.pack(side=LEFT)
-    romEntry.pack(side=LEFT, expand=True, fill=X)
+    romEntry.pack(side=LEFT, expand=True, fill=BOTH, pady=1)
     romSelectButton.pack(side=LEFT)
-    romFrame.pack(side=TOP, expand=True, fill=X)
+    romFrame.pack(side=TOP, fill=X)
 
     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)
-    romOptionsFrame.columnconfigure(1, weight=1)
+    romOptionsFrame = LabelFrame(parent, text="Rom options", padx=8, pady=8)
+
     for i in range(5):
-        romOptionsFrame.rowconfigure(i, weight=1)
+        romOptionsFrame.rowconfigure(i, weight=0, pad=4)
     vars = Namespace()
 
     vars.MusicVar = IntVar()
@@ -595,15 +666,53 @@ def get_rom_options_frame(parent=None):
     spriteSelectButton = Button(spriteDialogFrame, text='...', command=SpriteSelect)
 
     baseSpriteLabel.pack(side=LEFT)
-    spriteEntry.pack(side=LEFT)
+    spriteEntry.pack(side=LEFT, expand=True, fill=X)
     spriteSelectButton.pack(side=LEFT)
 
+    oofDialogFrame = Frame(romOptionsFrame)
+    oofDialogFrame.grid(row=1, column=1)
+    baseOofLabel = Label(oofDialogFrame, text='"OOF" Sound:')
+
+    vars.oofNameVar = StringVar()
+    vars.oof = adjuster_settings.oof
+
+    def set_oof(oof_param):
+        nonlocal vars
+        if isinstance(oof_param, str) and os.path.isfile(oof_param) and os.path.getsize(oof_param) <= 2673:
+            vars.oof = oof_param
+            vars.oofNameVar.set(oof_param.rsplit('/',1)[-1])
+        else:
+            vars.oof = None
+            vars.oofNameVar.set('(unchanged)')
+
+    set_oof(adjuster_settings.oof)
+    oofEntry = Label(oofDialogFrame, textvariable=vars.oofNameVar)
+
+    def OofSelect():
+        nonlocal vars
+        oof_file = filedialog.askopenfilename(
+            filetypes=[("BRR files", ".brr"),
+                       ("All Files", "*")])
+        try:
+            set_oof(oof_file)
+        except Exception:
+            set_oof(None)
+
+    oofSelectButton = Button(oofDialogFrame, text='...', command=OofSelect)
+    AttachTooltip(oofSelectButton,
+                  text="Select a .brr file no more than 2673 bytes.\n" + \
+                  "This can be created from a <=0.394s 16-bit signed PCM .wav file at 12khz using snesbrr.")
+
+    baseOofLabel.pack(side=LEFT)
+    oofEntry.pack(side=LEFT)
+    oofSelectButton.pack(side=LEFT)
+
     vars.quickSwapVar = IntVar(value=adjuster_settings.quickswap)
     quickSwapCheckbutton = Checkbutton(romOptionsFrame, text="L/R Quickswapping", variable=vars.quickSwapVar)
     quickSwapCheckbutton.grid(row=1, column=0, sticky=E)
 
     menuspeedFrame = Frame(romOptionsFrame)
-    menuspeedFrame.grid(row=1, column=1, sticky=E)
+    menuspeedFrame.grid(row=6, column=1, sticky=E)
     menuspeedLabel = Label(menuspeedFrame, text='Menu speed')
     menuspeedLabel.pack(side=LEFT)
     vars.menuspeedVar = StringVar()
@@ -760,7 +869,7 @@ class SpriteSelector():
         def open_custom_sprite_dir(_evt):
             open_file(self.custom_sprite_dir)
 
-        alttpr_frametitle = Label(self.window, text='ALTTPR Sprites')
+        remote_frametitle = Label(self.window, text='Remote Sprites')
 
         custom_frametitle = Frame(self.window)
         title_text = Label(custom_frametitle, text="Custom Sprites")
@@ -769,8 +878,8 @@ class SpriteSelector():
         title_link.pack(side=LEFT)
         title_link.bind("<Button-1>", open_custom_sprite_dir)
 
-        self.icon_section(alttpr_frametitle, self.alttpr_sprite_dir,
-                          'ALTTPR sprites not found. Click "Update alttpr sprites" to download them.')
+        self.icon_section(remote_frametitle, self.remote_sprite_dir,
+                          'Remote sprites not found. Click "Update remote sprites" to download them.')
         self.icon_section(custom_frametitle, self.custom_sprite_dir,
                           'Put sprites in the custom sprites folder (see open link above) to have them appear here.')
         if not randomOnEvent:
@@ -783,11 +892,18 @@ class SpriteSelector():
             button = Button(frame, text="Browse for file...", command=self.browse_for_sprite)
             button.pack(side=RIGHT, padx=(5, 0))
 
-        button = Button(frame, text="Update alttpr sprites", command=self.update_alttpr_sprites)
+        button = Button(frame, text="Update remote sprites", command=self.update_remote_sprites)
         button.pack(side=RIGHT, padx=(5, 0))
+
+        repository_label = Label(frame, text='Sprite Repository:')
+        self.repository_url = StringVar(frame, "https://alttpr.com/sprites")
+        repository_entry = Entry(frame, textvariable=self.repository_url)
         
+        repository_entry.pack(side=RIGHT, expand=True, fill=BOTH, pady=1)
+        repository_label.pack(side=RIGHT, expand=False, padx=(0, 5))
+
         button = Button(frame, text="Do not adjust sprite",command=self.use_default_sprite)
-        button.pack(side=LEFT,padx=(0,5))
+        button.pack(side=LEFT, padx=(0, 5))
 
         button = Button(frame, text="Default Link sprite", command=self.use_default_link_sprite)
         button.pack(side=LEFT, padx=(0, 5))
@@ -901,6 +1017,7 @@ class SpriteSelector():
                 self.add_to_sprite_pool(sprite)
 
     def icon_section(self, frame_label, path, no_results_label):
+        os.makedirs(path, exist_ok=True)
         frame = LabelFrame(self.window, labelwidget=frame_label, padx=5, pady=5)
         frame.pack(side=TOP, fill=X)
 
@@ -946,7 +1063,7 @@ class SpriteSelector():
         for i, button in enumerate(frame.buttons):
             button.grid(row=i // self.spritesPerRow, column=i % self.spritesPerRow)
 
-    def update_alttpr_sprites(self):
+    def update_remote_sprites(self):
         # need to wrap in try catch. We don't want errors getting the json or downloading the files to break us.
         self.window.destroy()
         self.parent.update()
@@ -959,7 +1076,8 @@ class SpriteSelector():
                 messagebox.showerror("Sprite Updater", resultmessage)
             SpriteSelector(self.parent, self.callback, self.adjuster)
 
-        BackgroundTaskProgress(self.parent, update_sprites, "Updating Sprites", on_finish)
+        BackgroundTaskProgress(self.parent, update_sprites, "Updating Sprites",
+                               on_finish, self.repository_url.get())
 
     def browse_for_sprite(self):
         sprite = filedialog.askopenfilename(
@@ -1049,12 +1167,12 @@ class SpriteSelector():
             os.makedirs(self.custom_sprite_dir)
 
     @property
-    def alttpr_sprite_dir(self):
-        return user_path("data", "sprites", "alttpr")
+    def remote_sprite_dir(self):
+        return user_path("data", "sprites", "alttp", "remote")
 
     @property
     def custom_sprite_dir(self):
-        return user_path("data", "sprites", "custom")
+        return user_path("data", "sprites", "alttp", "custom")
 
 
 def get_image_for_sprite(sprite, gif_only: bool = False):

MMBN3Client.py

@@ -0,0 +1,374 @@
+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
+                await asyncio.sleep(1)
+                continue
+
+
+async def run_game(romfile):
+    from worlds.mmbn3 import MMBN3World
+    auto_start = MMBN3World.settings.rom_start
+    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(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.just_fix_windows_console()
+
+    asyncio.run(main())
+    colorama.deinit()

Main.py

@@ -1,398 +1,364 @@
 import collections
+from collections.abc import Mapping
+import concurrent.futures
 import logging
 import os
-import time
-import zlib
-import concurrent.futures
-import pickle
 import tempfile
+import time
+from typing import Any
 import zipfile
-from typing import Dict, List, Tuple, Optional, Set
+import zlib
 
-from BaseClasses import Item, MultiWorld, CollectionState, Region, RegionType, LocationProgressType, Location
 import worlds
-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 SHOP_ID_START, total_shop_slots, FillDisabledShopSlots
-from Utils import output_path, get_options, __version__, version_tuple
-from worlds.generic.Rules import locality_rules, exclusion_rules
+from BaseClasses import CollectionState, Item, Location, LocationProgressType, MultiWorld
+from Fill import FillError, balance_multiworld_progression, distribute_items_restrictive, flood_items, \
+    parse_planned_blocks, distribute_planned_blocks, resolve_early_locations_for_planned
+from NetUtils import convert_to_base_types
+from Options import StartInventoryPool
+from Utils import __version__, output_path, restricted_dumps, version_tuple
+from settings import get_settings
 from worlds import AutoWorld
+from worlds.generic.Rules import exclusion_rules, locality_rules
 
-ordered_areas = (
-    'Light World', 'Dark World', 'Hyrule Castle', 'Agahnims Tower', 'Eastern Palace', 'Desert Palace',
-    'Tower of Hera', 'Palace of Darkness', 'Swamp Palace', 'Skull Woods', 'Thieves Town', 'Ice Palace',
-    'Misery Mire', 'Turtle Rock', 'Ganons Tower', "Total"
-)
+__all__ = ["main"]
 
 
-def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = None):
+def main(args, seed=None, baked_server_options: dict[str, object] | None = None):
     if not baked_server_options:
-        baked_server_options = get_options()["server_options"]
+        baked_server_options = get_settings().server_options.as_dict()
+    assert isinstance(baked_server_options, dict)
     if args.outputpath:
         os.makedirs(args.outputpath, exist_ok=True)
         output_path.cached_path = args.outputpath
 
     start = time.perf_counter()
-    # initialize the world
-    world = MultiWorld(args.multi)
+    # initialize the multiworld
+    multiworld = MultiWorld(args.multi)
 
     logger = logging.getLogger()
-    world.set_seed(seed, args.race, str(args.outputname if args.outputname else world.seed))
-    world.plando_options = args.plando_options
+    multiworld.set_seed(seed, args.race, str(args.outputname) if args.outputname else None)
+    multiworld.plando_options = args.plando
+    multiworld.game = args.game.copy()
+    multiworld.player_name = args.name.copy()
+    multiworld.sprite = args.sprite.copy()
+    multiworld.sprite_pool = args.sprite_pool.copy()
 
-    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.timer = args.timer.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)
+    if args.csv_output:
+        from Options import dump_player_options
+        dump_player_options(multiworld)
+    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("Found World Types:")
+    logger.info(f"Found {len(AutoWorld.AutoWorldRegister.world_types)} World Types:")
     longest_name = max(len(text) for text in AutoWorld.AutoWorldRegister.world_types)
 
-    max_item = 0
-    max_location = 0
-    for cls in AutoWorld.AutoWorldRegister.world_types.values():
-        if cls.item_id_to_name:
-            max_item = max(max_item, max(cls.item_id_to_name))
-            max_location = max(max_location, max(cls.location_id_to_name))
-
-    item_digits = len(str(max_item))
-    location_digits = len(str(max_location))
     item_count = len(str(max(len(cls.item_names) for cls in AutoWorld.AutoWorldRegister.world_types.values())))
     location_count = len(str(max(len(cls.location_names) for cls in AutoWorld.AutoWorldRegister.world_types.values())))
-    del max_item, max_location
 
     for name, cls in AutoWorld.AutoWorldRegister.world_types.items():
         if not cls.hidden and len(cls.item_names) > 0:
-            logger.info(f" {name:{longest_name}}: {len(cls.item_names):{item_count}} "
-                        f"Items (IDs: {min(cls.item_id_to_name):{item_digits}} - "
-                        f"{max(cls.item_id_to_name):{item_digits}}) | "
-                        f"{len(cls.location_names):{location_count}} "
-                        f"Locations (IDs: {min(cls.location_id_to_name):{location_digits}} - "
-                        f"{max(cls.location_id_to_name):{location_digits}})")
+            logger.info(f" {name:{longest_name}}: Items: {len(cls.item_names):{item_count}} | "
+                        f"Locations: {len(cls.location_names):{location_count}}")
 
-    del item_digits, location_digits, item_count, location_count
+    del item_count, location_count
 
-    AutoWorld.call_stage(world, "assert_generate")
+    # This assertion method should not be necessary to run if we are not outputting any multidata.
+    if not args.skip_output and not args.spoiler_only:
+        AutoWorld.call_stage(multiworld, "assert_generate")
 
-    AutoWorld.call_all(world, "generate_early")
+    AutoWorld.call_all(multiworld, "generate_early")
 
     logger.info('')
 
-    for player in world.player_ids:
-        for item_name, count in world.start_inventory[player].value.items():
+    for player in multiworld.player_ids:
+        for item_name, count in multiworld.worlds[player].options.start_inventory.value.items():
             for _ in range(count):
-                world.push_precollected(world.create_item(item_name, player))
+                multiworld.push_precollected(multiworld.create_item(item_name, player))
 
-    logger.info('Creating World.')
-    AutoWorld.call_all(world, "create_regions")
+        for item_name, count in getattr(multiworld.worlds[player].options,
+                                        "start_inventory_from_pool",
+                                        StartInventoryPool({})).value.items():
+            for _ in range(count):
+                multiworld.push_precollected(multiworld.create_item(item_name, player))
+            # remove from_pool items also from early items handling, as starting is plenty early.
+            early = multiworld.early_items[player].get(item_name, 0)
+            if early:
+                multiworld.early_items[player][item_name] = max(0, early-count)
+                remaining_count = count-early
+                if remaining_count > 0:
+                    local_early = multiworld.local_early_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
+
+        # 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])
+
+    # Clear non-applicable local and non-local items.
+    if multiworld.players == 1:
+        multiworld.worlds[1].options.non_local_items.value = set()
+        multiworld.worlds[1].options.local_items.value = set()
+
+    logger.info('Creating MultiWorld.')
+    AutoWorld.call_all(multiworld, "create_regions")
 
     logger.info('Creating Items.')
-    AutoWorld.call_all(world, "create_items")
-
-    # All worlds should have finished creating all regions, locations, and entrances.
-    # Recache to ensure that they are all visible for locality rules.
-    world._recache()
+    AutoWorld.call_all(multiworld, "create_items")
 
     logger.info('Calculating Access Rules.')
+    AutoWorld.call_all(multiworld, "set_rules")
 
-    for player in world.player_ids:
-        # items can't be both local and non-local, prefer local
-        world.non_local_items[player].value -= world.local_items[player].value
-        world.non_local_items[player].value -= set(world.local_early_items[player])
+    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
+        world_excluded_locations = set()
+        for location_name in multiworld.worlds[player].options.priority_locations.value:
+            try:
+                location = multiworld.get_location(location_name, player)
+            except KeyError:
+                continue
 
-    if world.players > 1:
-        locality_rules(world)
-    else:
-        world.non_local_items[1].value = set()
-        world.local_items[1].value = set()
+            if location.progress_type != LocationProgressType.EXCLUDED:
+                location.progress_type = LocationProgressType.PRIORITY
+            else:
+                logger.warning(f"Unable to prioritize location \"{location_name}\" in player {player}'s world because the world excluded it.")
+                world_excluded_locations.add(location_name)
+        multiworld.worlds[player].options.priority_locations.value -= world_excluded_locations
 
-    AutoWorld.call_all(world, "set_rules")
+    # Set local and non-local item rules.
+    # This function is called so late because worlds might otherwise overwrite item_rules which are how locality works
+    if multiworld.players > 1:
+        locality_rules(multiworld)
 
-    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
+    multiworld.plando_item_blocks = parse_planned_blocks(multiworld)
 
-    AutoWorld.call_all(world, "generate_basic")
+    AutoWorld.call_all(multiworld, "connect_entrances")
+    AutoWorld.call_all(multiworld, "generate_basic")
 
-    # temporary home for item links, should be moved out of Main
-    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 world.itempool:
-                if item.player in counters and item.name in shared_pool:
-                    counters[item.player][item.name] += 1
-                    classifications[item.name] |= item.classification
+    # remove starting inventory from pool items.
+    # Because some worlds don't actually create items during create_items this has to be as late as possible.
+    fallback_inventory = StartInventoryPool({})
+    depletion_pool: dict[int, dict[str, int]] = {
+        player: getattr(multiworld.worlds[player].options, "start_inventory_from_pool", fallback_inventory).value.copy()
+        for player in multiworld.player_ids
+    }
+    target_per_player = {
+        player: sum(target_items.values()) for player, target_items in depletion_pool.items() if target_items
+    }
 
-            for player in players.copy():
-                if all([counters[player][item] == 0 for item in shared_pool]):
-                    players.remove(player)
-                    del (counters[player])
+    if target_per_player:
+        new_itempool: list[Item] = []
 
-            if not players:
-                return None, None
-
-            for item in shared_pool:
-                count = min(counters[player][item] for player in players)
-                if count:
-                    for player in players:
-                        counters[player][item] = count
-                else:
-                    for player in players:
-                        del (counters[player][item])
-            return counters, classifications
-
-        common_item_count, classifications = find_common_pool(group["players"], group["item_pool"])
-        if not common_item_count:
-            continue
-
-        new_itempool: List[Item] = []
-        for item_name, item_count in next(iter(common_item_count.values())).items():
-            for _ in range(item_count):
-                new_item = group["world"].create_item(item_name)
-                # mangle together all original classification bits
-                new_item.classification |= classifications[item_name]
-                new_itempool.append(new_item)
-
-        region = Region("Menu", RegionType.Generic, "ItemLink", group_id, world)
-        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} -> {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_)
-
-                locations.append(loc)
-                loc.place_locked_item(item)
-                common_item_count[item.player][item.name] -= 1
+        # Make new itempool with start_inventory_from_pool items removed
+        for item in multiworld.itempool:
+            if depletion_pool[item.player].get(item.name, 0):
+                depletion_pool[item.player][item.name] -= 1
             else:
                 new_itempool.append(item)
 
-        itemcount = len(world.itempool)
-        world.itempool = new_itempool
+        # Create filler in place of the removed items, warn if any items couldn't be found in the multiworld itempool
+        for player, target in target_per_player.items():
+            unfound_items = {item: count for item, count in depletion_pool[player].items() if count}
 
-        while itemcount > len(world.itempool):
-            items_to_add = []
-            for player in group["players"]:
-                if group["link_replacement"]:
-                    item_player = group_id
-                else:
-                    item_player = player
-                if group["replacement_items"][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(world, "create_filler", item_player))
-            world.random.shuffle(items_to_add)
-            world.itempool.extend(items_to_add[:itemcount - len(world.itempool)])
+            if unfound_items:
+                player_name = multiworld.get_player_name(player)
+                logger.warning(f"{player_name} tried to remove items from their pool that don't exist: {unfound_items}")
 
-    if any(world.item_links.values()):
-        world._recache()
-        world._all_state = None
+            needed_items = target_per_player[player] - sum(unfound_items.values())
+            new_itempool += [multiworld.worlds[player].create_filler() for _ in range(needed_items)]
 
-    logger.info("Running Item Plando")
+        assert len(multiworld.itempool) == len(new_itempool), "Item Pool amounts should not change."
+        multiworld.itempool[:] = new_itempool
 
-    distribute_planned(world)
+    multiworld.link_items()
+
+    if any(world.options.item_links for world in multiworld.worlds.values()):
+        multiworld._all_state = None
+
+    logger.info("Running Item Plando.")
+    resolve_early_locations_for_planned(multiworld)
+    distribute_planned_blocks(multiworld, [x for player in multiworld.plando_item_blocks
+                                           for x in multiworld.plando_item_blocks[player]])
 
     logger.info('Running Pre Main Fill.')
 
-    AutoWorld.call_all(world, "pre_fill")
+    AutoWorld.call_all(multiworld, "pre_fill")
 
-    logger.info(f'Filling the world with {len(world.itempool)} items.')
+    logger.info(f'Filling the multiworld with {len(multiworld.itempool)} items.')
 
-    if world.algorithm == 'flood':
-        flood_items(world)  # different algo, biased towards early game progress items
-    elif world.algorithm == 'balanced':
-        distribute_items_restrictive(world)
+    if multiworld.algorithm == 'flood':
+        flood_items(multiworld)  # different algo, biased towards early game progress items
+    elif multiworld.algorithm == 'balanced':
+        distribute_items_restrictive(multiworld, get_settings().generator.panic_method)
 
-    AutoWorld.call_all(world, 'post_fill')
+    AutoWorld.call_all(multiworld, 'post_fill')
 
-    if world.players > 1:
-        balance_multiworld_progression(world)
+    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
 
     logger.info(f'Beginning output...')
-    outfilebase = 'AP_' + world.seed_name
+    outfilebase = 'AP_' + multiworld.seed_name
+
+    if args.spoiler_only:
+        if args.spoiler > 1:
+            logger.info('Calculating playthrough.')
+            multiworld.spoiler.create_playthrough(create_paths=args.spoiler > 2)
+
+        multiworld.spoiler.to_file(output_path('%s_Spoiler.txt' % outfilebase))
+        logger.info('Done. Skipped multidata modification. Total time: %s', time.perf_counter() - start)
+        return multiworld
 
     output = tempfile.TemporaryDirectory()
     with output as temp_dir:
-        with concurrent.futures.ThreadPoolExecutor(world.players + 2) as pool:
-            check_accessibility_task = pool.submit(world.fulfills_accessibility)
+        output_players = [player for player in multiworld.player_ids if AutoWorld.World.generate_output.__code__
+                          is not multiworld.worlds[player].generate_output.__code__]
+        with concurrent.futures.ThreadPoolExecutor(len(output_players) + 2) as pool:
+            check_accessibility_task = pool.submit(multiworld.fulfills_accessibility)
 
-            output_file_futures = [pool.submit(AutoWorld.call_stage, world, "generate_output", temp_dir)]
-            for player in world.player_ids:
+            output_file_futures = [pool.submit(AutoWorld.call_stage, multiworld, "generate_output", temp_dir)]
+            for player in output_players:
                 # skip starting a thread for methods that say "pass".
-                if AutoWorld.World.generate_output.__code__ is not world.worlds[player].generate_output.__code__:
-                    output_file_futures.append(
-                        pool.submit(AutoWorld.call_single, world, "generate_output", player, temp_dir))
+                output_file_futures.append(
+                    pool.submit(AutoWorld.call_single, multiworld, "generate_output", player, temp_dir))
 
             # collect ER hint info
-            er_hint_data: Dict[int, Dict[int, str]] = {}
-            AutoWorld.call_all(world, 'extend_hint_information', er_hint_data)
-
-            checks_in_area = {player: {area: list() for area in ordered_areas}
-                              for player in range(1, world.players + 1)}
-
-            for player in range(1, world.players + 1):
-                checks_in_area[player]["Total"] = 0
-
-            for location in world.get_filled_locations():
-                if type(location.address) is int:
-                    if location.game != "A Link to the Past":
-                        checks_in_area[location.player]["Light World"].append(location.address)
-                    else:
-                        main_entrance = location.parent_region.get_connecting_entrance(is_main_entrance)
-                        if location.parent_region.dungeon:
-                            dungeonname = {'Inverted Agahnims Tower': 'Agahnims Tower',
-                                           'Inverted Ganons Tower': 'Ganons Tower'} \
-                                .get(location.parent_region.dungeon.name, location.parent_region.dungeon.name)
-                            checks_in_area[location.player][dungeonname].append(location.address)
-                        elif location.parent_region.type == RegionType.LightWorld:
-                            checks_in_area[location.player]["Light World"].append(location.address)
-                        elif location.parent_region.type == RegionType.DarkWorld:
-                            checks_in_area[location.player]["Dark World"].append(location.address)
-                        elif main_entrance.parent_region.type == RegionType.LightWorld:
-                            checks_in_area[location.player]["Light World"].append(location.address)
-                        elif main_entrance.parent_region.type == RegionType.DarkWorld:
-                            checks_in_area[location.player]["Dark World"].append(location.address)
-                    checks_in_area[location.player]["Total"] += 1
-
-            FillDisabledShopSlots(world)
+            er_hint_data: dict[int, dict[int, str]] = {}
+            AutoWorld.call_all(multiworld, 'extend_hint_information', er_hint_data)
 
             def write_multidata():
                 import NetUtils
-                slot_data = {}
-                client_versions = {}
-                games = {}
-                minimum_versions = {"server": AutoWorld.World.required_server_version, "clients": client_versions}
-                slot_info = {}
-                names = [[name for player, name in sorted(world.player_name.items())]]
-                for slot in world.player_ids:
-                    player_world: AutoWorld.World = world.worlds[slot]
+                from NetUtils import HintStatus
+                slot_data: dict[int, Mapping[str, Any]] = {}
+                client_versions: dict[int, tuple[int, int, int]] = {}
+                games: dict[int, str] = {}
+                minimum_versions: NetUtils.MinimumVersions = {
+                    "server": AutoWorld.World.required_server_version, "clients": client_versions
+                }
+                slot_info: dict[int, NetUtils.NetworkSlot] = {}
+                names = [[name for player, name in sorted(multiworld.player_name.items())]]
+                for slot in multiworld.player_ids:
+                    player_world: AutoWorld.World = multiworld.worlds[slot]
                     minimum_versions["server"] = max(minimum_versions["server"], player_world.required_server_version)
                     client_versions[slot] = player_world.required_client_version
-                    games[slot] = world.game[slot]
-                    slot_info[slot] = NetUtils.NetworkSlot(names[0][slot - 1], world.game[slot],
-                                                           world.player_types[slot])
-                for slot, group in world.groups.items():
-                    games[slot] = world.game[slot]
-                    slot_info[slot] = NetUtils.NetworkSlot(group["name"], world.game[slot], world.player_types[slot],
+                    games[slot] = multiworld.game[slot]
+                    slot_info[slot] = NetUtils.NetworkSlot(names[0][slot - 1], multiworld.game[slot],
+                                                           multiworld.player_types[slot])
+                for slot, group in multiworld.groups.items():
+                    games[slot] = multiworld.game[slot]
+                    slot_info[slot] = NetUtils.NetworkSlot(group["name"], multiworld.game[slot], multiworld.player_types[slot],
                                                            group_members=sorted(group["players"]))
                 precollected_items = {player: [item.code for item in world_precollected if type(item.code) == int]
-                                      for player, world_precollected in world.precollected_items.items()}
-                precollected_hints = {player: set() for player in range(1, world.players + 1 + len(world.groups))}
+                                      for player, world_precollected in multiworld.precollected_items.items()}
+                precollected_hints: dict[int, set[NetUtils.Hint]] = {
+                    player: set() for player in range(1, multiworld.players + 1 + len(multiworld.groups))
+                }
 
-                for slot in world.player_ids:
-                    slot_data[slot] = world.worlds[slot].fill_slot_data()
+                for slot in multiworld.player_ids:
+                    slot_data[slot] = multiworld.worlds[slot].fill_slot_data()
 
-                def precollect_hint(location):
+                def precollect_hint(location: Location, auto_status: HintStatus):
                     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)
+                                         location.item.code, False, entrance, location.item.flags, auto_status)
                     precollected_hints[location.player].add(hint)
-                    if location.item.player not in world.groups:
+                    if location.item.player not in multiworld.groups:
                         precollected_hints[location.item.player].add(hint)
                     else:
-                        for player in world.groups[location.item.player]["players"]:
+                        for player in multiworld.groups[location.item.player]["players"]:
                             precollected_hints[player].add(hint)
 
-                locations_data: Dict[int, Dict[int, Tuple[int, int, int]]] = {player: {} for player in world.player_ids}
-                for location in world.get_filled_locations():
+                locations_data: dict[int, dict[int, tuple[int, int, int]]] = {player: {} for player in multiworld.player_ids}
+                for location in multiworld.get_filled_locations():
                     if type(location.address) == int:
                         assert location.item.code is not None, "item code None should be event, " \
                                                                "location.address should then also be None. Location: " \
-                                                               f" {location}"
+                                                               f" {location}, Item: {location.item}"
+                        assert location.address not in locations_data[location.player], (
+                            f"Locations with duplicate address. {location} and "
+                            f"{locations_data[location.player][location.address]}")
                         locations_data[location.player][location.address] = \
                             location.item.code, location.item.player, location.item.flags
-                        if location.name in world.start_location_hints[location.player]:
-                            precollect_hint(location)
-                        elif location.item.name in world.start_hints[location.item.player]:
-                            precollect_hint(location)
-                        elif any([location.item.name in world.start_hints[player]
-                                  for player in world.groups.get(location.item.player, {}).get("players", [])]):
-                            precollect_hint(location)
+                        auto_status = HintStatus.HINT_AVOID if location.item.trap else HintStatus.HINT_PRIORITY
+                        if location.name in multiworld.worlds[location.player].options.start_location_hints:
+                            if not location.item.trap:  # Unspecified status for location hints, except traps
+                                auto_status = HintStatus.HINT_UNSPECIFIED
+                            precollect_hint(location, auto_status)
+                        elif location.item.name in multiworld.worlds[location.item.player].options.start_hints:
+                            precollect_hint(location, auto_status)
+                        elif any([location.item.name in multiworld.worlds[player].options.start_hints
+                                  for player in multiworld.groups.get(location.item.player, {}).get("players", [])]):
+                            precollect_hint(location, auto_status)
 
-                # 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
+                # embedded data package
+                data_package = {
+                    game_world.game: worlds.network_data_package["games"][game_world.game]
+                    for game_world in multiworld.worlds.values()
+                }
+                data_package["Archipelago"] = worlds.network_data_package["games"]["Archipelago"]
 
-                multidata = {
+                checks_in_area: dict[int, dict[str, int | list[int]]] = {}
+
+                # get spheres -> filter address==None -> skip empty
+                spheres: list[dict[int, set[int]]] = []
+                for sphere in multiworld.get_sendable_spheres():
+                    current_sphere: dict[int, set[int]] = collections.defaultdict(set)
+                    for sphere_location in sphere:
+                        current_sphere[sphere_location.player].add(sphere_location.address)
+
+                    if current_sphere:
+                        spheres.append(dict(current_sphere))
+
+                multidata: NetUtils.MultiData | bytes = {
                     "slot_data": slot_data,
                     "slot_info": slot_info,
-                    "names": names,  # TODO: remove around 0.2.5 in favor of slot_info
-                    "games": games,  # TODO: remove around 0.2.5 in favor of slot_info
-                    "connect_names": {name: (0, player) for player, name in world.player_name.items()},
+                    "connect_names": {name: (0, player) for player, name in multiworld.player_name.items()},
                     "locations": locations_data,
                     "checks_in_area": checks_in_area,
                     "server_options": baked_server_options,
                     "er_hint_data": er_hint_data,
                     "precollected_items": precollected_items,
                     "precollected_hints": precollected_hints,
-                    "version": tuple(version_tuple),
+                    "version": (version_tuple.major, version_tuple.minor, version_tuple.build),
                     "tags": ["AP"],
                     "minimum_versions": minimum_versions,
-                    "seed_name": world.seed_name,
-                    "datapackage": datapackage,
+                    "seed_name": multiworld.seed_name,
+                    "spheres": spheres,
+                    "datapackage": data_package,
+                    "race_mode": int(multiworld.is_race),
                 }
-                AutoWorld.call_all(world, "modify_multidata", multidata)
+                # TODO: change to `"version": version_tuple` after getting better serialization
+                AutoWorld.call_all(multiworld, "modify_multidata", multidata)
 
-                multidata = zlib.compress(pickle.dumps(multidata), 9)
+                for key in ("slot_data", "er_hint_data"):
+                    multidata[key] = convert_to_base_types(multidata[key])
+
+                multidata = zlib.compress(restricted_dumps(multidata), 9)
 
                 with open(os.path.join(temp_dir, f'{outfilebase}.archipelago'), 'wb') as f:
                     f.write(bytes([3]))  # version of format
                     f.write(multidata)
 
-            multidata_task = pool.submit(write_multidata)
+            output_file_futures.append(pool.submit(write_multidata))
             if not check_accessibility_task.result():
-                if not world.can_beat_game():
-                    raise Exception("Game appears as unbeatable. Aborting.")
+                if not multiworld.can_beat_game():
+                    raise FillError("Game appears as unbeatable. Aborting.", multiworld=multiworld)
                 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)}).')
@@ -400,12 +366,12 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
 
         if args.spoiler > 1:
             logger.info('Calculating playthrough.')
-            world.spoiler.create_playthrough(create_paths=args.spoiler > 2)
+            multiworld.spoiler.create_playthrough(create_paths=args.spoiler > 2)
 
         if args.spoiler:
-            world.spoiler.to_file(os.path.join(temp_dir, '%s_Spoiler.txt' % outfilebase))
+            multiworld.spoiler.to_file(os.path.join(temp_dir, '%s_Spoiler.txt' % outfilebase))
 
-        zipfilename = output_path(f"AP_{world.seed_name}.zip")
+        zipfilename = output_path(f"AP_{multiworld.seed_name}.zip")
         logger.info(f"Creating final archive at {zipfilename}")
         with zipfile.ZipFile(zipfilename, mode="w", compression=zipfile.ZIP_DEFLATED,
                              compresslevel=9) as zf:
@@ -413,4 +379,4 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
                 zf.write(file.path, arcname=file.name)
 
     logger.info('Done. Enjoy. Total Time: %s', time.perf_counter() - start)
-    return world
+    return multiworld

MinecraftClient.py

@@ -1,351 +0,0 @@
-import argparse
-import json
-import os
-import sys
-import re
-import atexit
-import shutil
-from subprocess import Popen
-from shutil import copyfile
-from time import strftime
-import logging
-
-import requests
-
-import Utils
-from Utils import is_windows
-
-atexit.register(input, "Press enter to exit.")
-
-# 1 or more digits followed by m or g, then optional b
-max_heap_re = re.compile(r"^\d+[mMgG][bB]?$")
-
-
-def prompt_yes_no(prompt):
-    yes_inputs = {'yes', 'ye', 'y'}
-    no_inputs = {'no', 'n'}
-    while True:
-        choice = input(prompt + " [y/n] ").lower()
-        if choice in yes_inputs: 
-            return True
-        elif choice in no_inputs: 
-            return False
-        else:
-            print('Please respond with "y" or "n".')
-
-
-def find_ap_randomizer_jar(forge_dir):
-    """Create mods folder if needed; find AP randomizer jar; return None if not found."""
-    mods_dir = os.path.join(forge_dir, 'mods')
-    if os.path.isdir(mods_dir):
-        for entry in os.scandir(mods_dir):
-            if entry.name.startswith("aprandomizer") and entry.name.endswith(".jar"):
-                logging.info(f"Found AP randomizer mod: {entry.name}")
-                return entry.name
-        return None
-    else:
-        os.mkdir(mods_dir)
-        logging.info(f"Created mods folder in {forge_dir}")
-        return None
-
-
-def replace_apmc_files(forge_dir, apmc_file):
-    """Create APData folder if needed; clean .apmc files from APData; copy given .apmc into directory."""
-    if apmc_file is None:
-        return
-    apdata_dir = os.path.join(forge_dir, 'APData')
-    copy_apmc = True
-    if not os.path.isdir(apdata_dir):
-        os.mkdir(apdata_dir)
-        logging.info(f"Created APData folder in {forge_dir}")
-    for entry in os.scandir(apdata_dir):
-        if entry.name.endswith(".apmc") and entry.is_file():
-            if not os.path.samefile(apmc_file, entry.path):
-                os.remove(entry.path)
-                logging.info(f"Removed {entry.name} in {apdata_dir}")
-            else: # apmc already in apdata
-                copy_apmc = False
-    if copy_apmc:
-        copyfile(apmc_file, os.path.join(apdata_dir, os.path.basename(apmc_file)))
-        logging.info(f"Copied {os.path.basename(apmc_file)} to {apdata_dir}")
-
-
-def read_apmc_file(apmc_file):
-    from base64 import b64decode
-
-    with open(apmc_file, 'r') as f:
-        return json.loads(b64decode(f.read()))
-
-
-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)
-
-    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):
-    """Check if the EULA is agreed to, and prompt the user to read and agree if necessary."""
-    eula_path = os.path.join(forge_dir, "eula.txt")
-    if not os.path.isfile(eula_path):
-        # Create eula.txt
-        with open(eula_path, 'w') as f:
-            f.write("#By changing the setting below to TRUE you are indicating your agreement to our EULA (https://account.mojang.com/documents/minecraft_eula).\n")
-            f.write(f"#{strftime('%a %b %d %X %Z %Y')}\n")
-            f.write("eula=false\n")
-    with open(eula_path, 'r+') as f:
-        text = f.read()
-        if 'false' in text:
-            # Prompt user to agree to the EULA
-            logging.info("You need to agree to the Minecraft EULA in order to run the server.")
-            logging.info("The EULA can be found at https://account.mojang.com/documents/minecraft_eula")
-            if prompt_yes_no("Do you agree to the EULA?"):
-                f.seek(0)
-                f.write(text.replace('false', 'true'))
-                f.truncate()
-                logging.info(f"Set {eula_path} to true")
-            else:
-                sys.exit(0)
-
-
-def find_jdk_dir(version: str) -> str:
-    """get the specified versions jdk directory"""
-    for entry in os.listdir():
-        if os.path.isdir(entry) and entry.startswith(f"jdk{version}"):
-            return os.path.abspath(entry)
-
-
-def find_jdk(version: str) -> str:
-    """get the java exe location"""
-
-    if is_windows:
-        jdk = find_jdk_dir(version)
-        jdk_exe = os.path.join(jdk, "bin", "java.exe")
-        if os.path.isfile(jdk_exe):
-            return jdk_exe
-    else:
-        jdk_exe = shutil.which(options["minecraft_options"].get("java", "java"))
-        if not jdk_exe:
-            raise Exception("Could not find Java. Is Java installed on the system?")
-        return jdk_exe
-
-
-def download_java(java: str):
-    """Download Corretto (Amazon JDK)"""
-
-    jdk = find_jdk_dir(java)
-    if jdk is not None:
-        print(f"Removing old JDK...")
-        from shutil import rmtree
-        rmtree(jdk)
-
-    print(f"Downloading Java...")
-    jdk_url = f"https://corretto.aws/downloads/latest/amazon-corretto-{java}-x64-windows-jdk.zip"
-    resp = requests.get(jdk_url)
-    if resp.status_code == 200:  # OK
-        print(f"Extracting...")
-        import zipfile
-        from io import BytesIO
-        with zipfile.ZipFile(BytesIO(resp.content)) as zf:
-            zf.extractall()
-    else:
-        print(f"Error downloading Java (status code {resp.status_code}).")
-        print(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 install_forge(directory: str, forge_version: str, java_version: str):
-    """download and install forge"""
-
-    java_exe = find_jdk(java_version)
-    if java_exe is not None:
-        print(f"Downloading Forge {forge_version}...")
-        forge_url = f"https://maven.minecraftforge.net/net/minecraftforge/forge/{forge_version}/forge-{forge_version}-installer.jar"
-        resp = requests.get(forge_url)
-        if resp.status_code == 200:  # OK
-            forge_install_jar = os.path.join(directory, "forge_install.jar")
-            if not os.path.exists(directory):
-                os.mkdir(directory)
-            with open(forge_install_jar, 'wb') as f:
-                f.write(resp.content)
-            print(f"Installing Forge...")
-            install_process = Popen([java_exe, "-jar", forge_install_jar, "--installServer", directory])
-            install_process.wait()
-            os.remove(forge_install_jar)
-
-
-def run_forge_server(forge_dir: str, java_version: str, heap_arg: str) -> Popen:
-    """Run the Forge server."""
-
-    java_exe = find_jdk(java_version)
-    if not os.path.isfile(java_exe):
-        java_exe = "java"  # try to fall back on java in the PATH
-
-    heap_arg = max_heap_re.match(heap_arg).group()
-    if heap_arg[-1] in ['b', 'B']:
-        heap_arg = heap_arg[:-1]
-    heap_arg = "-Xmx" + heap_arg
-
-    os_args = "win_args.txt" if is_windows else "unix_args.txt"
-    args_file = os.path.join(forge_dir, "libraries", "net", "minecraftforge", "forge", forge_version, os_args)
-    forge_args = []
-    with open(args_file) as argfile:
-        for line in argfile:
-            forge_args.extend(line.strip().split(" "))
-
-    args = [java_exe, heap_arg, *forge_args, "-nogui"]
-    logging.info(f"Running Forge server: {args}")
-    os.chdir(forge_dir)
-    return Popen(args)
-
-
-def get_minecraft_versions(version, release_channel="release"):
-    version_file_endpoint = "https://raw.githubusercontent.com/KonoTyran/Minecraft_AP_Randomizer/master/versions/minecraft_versions.json"
-    resp = requests.get(version_file_endpoint)
-    local = False
-    if resp.status_code == 200:  # OK
-        try:
-            data = resp.json()
-        except requests.exceptions.JSONDecodeError:
-            logging.warning(f"Unable to fetch version update file, using local version. (status code {resp.status_code}).")
-            local = True
-    else:
-        logging.warning(f"Unable to fetch version update file, using local version. (status code {resp.status_code}).")
-        local = True
-
-    if local:
-        with open(Utils.user_path("minecraft_versions.json"), 'r') as f:
-            data = json.load(f)
-    else:
-        with open(Utils.user_path("minecraft_versions.json"), 'w') as f:
-            json.dump(data, f)
-
-    try:
-        if version:
-            return next(filter(lambda entry: entry["version"] == version, data[release_channel]))
-        else:
-            return resp.json()[release_channel][0]
-    except StopIteration:
-        logging.error(f"No compatible mod version found for client version {version}.")
-
-
-def is_correct_forge(forge_dir) -> bool:
-    if os.path.isdir(os.path.join(forge_dir, "libraries", "net", "minecraftforge", "forge", forge_version)):
-        return True
-    return False
-
-
-if __name__ == '__main__':
-    Utils.init_logging("MinecraftClient")
-    parser = argparse.ArgumentParser()
-    parser.add_argument("apmc_file", default=None, nargs='?', help="Path to an Archipelago Minecraft data file (.apmc)")
-    parser.add_argument('--install', '-i', dest='install', default=False, action='store_true',
-                        help="Download and install Java and the Forge server. Does not launch the client afterwards.")
-    parser.add_argument('--release_channel', '-r', dest="channel", type=str, action='store',
-                        help="Specify release channel to use.")
-    parser.add_argument('--java', '-j', metavar='17', dest='java', type=str, default=False, action='store',
-                        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)")
-
-    args = parser.parse_args()
-    apmc_file = os.path.abspath(args.apmc_file) if args.apmc_file else None
-
-    # Change to executable's working directory
-    os.chdir(os.path.abspath(os.path.dirname(sys.argv[0])))
-
-    options = Utils.get_options()
-    channel = args.channel or options["minecraft_options"]["release_channel"]
-    apmc_data = 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:
-        apmc_data = read_apmc_file(apmc_file)
-        data_version = apmc_data.get('client_version', '')
-
-    versions = get_minecraft_versions(data_version, channel)
-
-    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"]
-    java_dir = find_jdk_dir(java_version)
-
-    if args.install:
-        if is_windows:
-            print("Installing Java")
-            download_java(java_version)
-        if not is_correct_forge(forge_dir):
-            print("Installing Minecraft Forge")
-            install_forge(forge_dir, forge_version, java_version)
-        else:
-            print("Correct Forge version already found, skipping install.")
-        sys.exit(0)
-
-    if apmc_data is None:
-        raise FileNotFoundError(f"APMC file does not exist or is inaccessible at the given location ({apmc_file})")
-
-    if is_windows:
-        if java_dir is None or not os.path.isdir(java_dir):
-            if prompt_yes_no("Did not find java directory. Download and install java now?"):
-                download_java(java_version)
-                java_dir = find_jdk_dir(java_version)
-            if java_dir is None or not os.path.isdir(java_dir):
-                raise NotADirectoryError(f"Path {java_dir} does not exist or could not be accessed.")
-
-    if not is_correct_forge(forge_dir):
-        if prompt_yes_no(f"Did not find forge version {forge_version} download and install it now?"):
-            install_forge(forge_dir, forge_version, java_version)
-        if not os.path.isdir(forge_dir):
-            raise NotADirectoryError(f"Path {forge_dir} does not exist or could not be accessed.")
-
-    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, 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)
-    server_process.wait()

ModuleUpdate.py

@@ -1,15 +1,43 @@
 import os
 import sys
 import subprocess
-import pkg_resources
+import multiprocessing
+import warnings
+
+
+if sys.platform in ("win32", "darwin") and sys.version_info < (3, 11, 9):
+    # Official micro version updates. This should match the number in docs/running from source.md.
+    raise RuntimeError(f"Incompatible Python Version found: {sys.version_info}. Official 3.11.9+ is supported.")
+elif sys.platform in ("win32", "darwin") and sys.version_info < (3, 11, 13):
+    # There are known security issues, but no easy way to install fixed versions on Windows for testing.
+    warnings.warn(f"Python Version {sys.version_info} has security issues. Don't use in production.")
+elif sys.version_info < (3, 11, 0):
+    # Other platforms may get security backports instead of micro updates, so the number is unreliable.
+    raise RuntimeError(f"Incompatible Python Version found: {sys.version_info}. 3.11.0+ is supported.")
+
+# 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() or 
+    os.environ.get("SKIP_REQUIREMENTS_UPDATE", "").lower() in ("1", "true", "yes")
+)
+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 = {os.path.join(local_dir, 'requirements.txt')}
-
-if sys.version_info < (3, 8, 6):
-    raise RuntimeError("Incompatible Python Version. 3.8.7+ is supported.")
-
-update_ran = getattr(sys, "frozen", False)  # don't run update if environment is frozen/compiled
+requirements_files = RequirementsSet((os.path.join(local_dir, 'requirements.txt'),))
 
 if not update_ran:
     for entry in os.scandir(os.path.join(local_dir, "worlds")):
@@ -21,24 +49,67 @@ 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 update(yes=False, force=False):
+def install_pkg_resources(yes=False):
+    try:
+        import pkg_resources  # noqa: F401
+    except (AttributeError, 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>=75,<81"])
+
+
+def update(yes: bool = False, force: bool = False) -> None:
     global update_ran
     if not update_ran:
         update_ran = True
+
+        install_pkg_resources(yes=yes)
+        import pkg_resources
+
         if force:
             update_command()
             return
+
+        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 line.startswith(("https://", "git+https://")):
                         # extract name and version for url
                         rest = line.split('/')[-1]
@@ -46,8 +117,10 @@ def update(yes=False, force=False):
                         if "#egg=" in rest:
                             # from egg info
                             rest, egg = rest.split("#egg=", 1)
-                            egg = egg.split(";", 1)[0]
+                            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)
                                 line = egg
                         else:
                             egg = ""
@@ -58,16 +131,23 @@ def update(yes=False, force=False):
                             rest = rest.replace(".zip", "-").replace(".tar.gz", "-")
                             name, version, _ = rest.split("-", 2)
                             line = f'{egg or name}=={version}'
+                    elif "@" in line and "#" in line:
+                        # PEP 508 does not allow us to specify a version, so we use custom syntax
+                        # name @ url#version ; marker
+                        name, rest = line.split("@", 1)
+                        version = rest.split("#", 1)[1].split(";", 1)[0].rstrip()
+                        line = f"{name.rstrip()}=={version}"
+                        if ";" in rest:  # keep marker
+                            line += rest[rest.find(";"):]
                     requirements = pkg_resources.parse_requirements(line)
-                    for requirement in requirements:
-                        requirement = str(requirement)
+                    for requirement in map(str, requirements):
                         try:
                             pkg_resources.require(requirement)
                         except pkg_resources.ResolutionError:
                             if not yes:
                                 import traceback
                                 traceback.print_exc()
-                                input(f'Requirement {requirement} is not satisfied, press enter to install it')
+                                confirm(f"Requirement {requirement} is not satisfied, press enter to install it")
                             update_command()
                             return
 

NetUtils.py

@@ -1,12 +1,23 @@
 from __future__ import annotations
 
+from collections.abc import Mapping, Sequence
 import typing
 import enum
+import warnings
 from json import JSONEncoder, JSONDecoder
 
-import websockets
+if typing.TYPE_CHECKING:
+    from websockets import WebSocketServerProtocol as ServerConnection
 
-from Utils import Version
+from Utils import ByValue, Version
+
+
+class HintStatus(ByValue, enum.IntEnum):
+    HINT_UNSPECIFIED = 0
+    HINT_NO_PRIORITY = 10
+    HINT_AVOID = 20
+    HINT_PRIORITY = 30
+    HINT_FOUND = 40
 
 
 class JSONMessagePart(typing.TypedDict, total=False):
@@ -18,9 +29,11 @@ class JSONMessagePart(typing.TypedDict, total=False):
     player: int
     # if type == item indicates item flags
     flags: int
+    # if type == hint_status
+    hint_status: HintStatus
 
 
-class ClientStatus(enum.IntEnum):
+class ClientStatus(ByValue, enum.IntEnum):
     CLIENT_UNKNOWN = 0
     CLIENT_CONNECTED = 5
     CLIENT_READY = 10
@@ -28,18 +41,18 @@ class ClientStatus(enum.IntEnum):
     CLIENT_GOAL = 30
 
 
-class SlotType(enum.IntFlag):
+class SlotType(ByValue, enum.IntFlag):
     spectator = 0b00
     player = 0b01
     group = 0b10
 
     @property
     def always_goal(self) -> bool:
-        """Mark this slot has having reached its goal instantly."""
+        """Mark this slot as having reached its goal instantly."""
         return self.value != 0b01
 
 
-class Permission(enum.IntFlag):
+class Permission(ByValue, enum.IntFlag):
     disabled = 0b000  # 0, completely disables access
     enabled = 0b001  # 1, allows manual use
     goal = 0b010  # 2, allows manual use after goal completion
@@ -71,13 +84,14 @@ class NetworkSlot(typing.NamedTuple):
     name: str
     game: str
     type: SlotType
-    group_members: typing.Union[typing.List[int], typing.Tuple] = ()  # only populated if type == group
+    group_members: Sequence[int] = ()  # only populated if type == group
 
 
 class NetworkItem(typing.NamedTuple):
     item: int
     location: int
     player: int
+    """ Sending player, except in LocationInfo (from LocationScouts), where it is the receiving player. """
     flags: int = 0
 
 
@@ -93,6 +107,27 @@ def _scan_for_TypedTuples(obj: typing.Any) -> typing.Any:
     return obj
 
 
+_base_types = str | int | bool | float | None | tuple["_base_types", ...] | dict["_base_types", "base_types"]
+
+
+def convert_to_base_types(obj: typing.Any) -> _base_types:
+    if isinstance(obj, (tuple, list, set, frozenset)):
+        return tuple(convert_to_base_types(o) for o in obj)
+    elif isinstance(obj, dict):
+        return {convert_to_base_types(key): convert_to_base_types(value) for key, value in obj.items()}
+    elif obj is None or type(obj) in (str, int, float, bool):
+        return obj
+    # unwrap simple types to their base, such as StrEnum
+    elif isinstance(obj, str):
+        return str(obj)
+    elif isinstance(obj, int):
+        return int(obj)
+    elif isinstance(obj, float):
+        return float(obj)
+    else:
+        raise Exception(f"Cannot handle {type(obj)}")
+
+
 _encode = JSONEncoder(
     ensure_ascii=False,
     check_circular=False,
@@ -139,7 +174,7 @@ decode = JSONDecoder(object_hook=_object_hook).decode
 
 
 class Endpoint:
-    socket: websockets.WebSocketServerProtocol
+    socket: "ServerConnection"
 
     def __init__(self, socket):
         self.socket = socket
@@ -182,6 +217,7 @@ class JSONTypes(str, enum.Enum):
     location_name = "location_name"
     location_id = "location_id"
     entrance_name = "entrance_name"
+    hint_status = "hint_status"
 
 
 class JSONtoTextParser(metaclass=HandlerMeta):
@@ -197,7 +233,8 @@ class JSONtoTextParser(metaclass=HandlerMeta):
         "slateblue": "6D8BE8",
         "plum": "AF99EF",
         "salmon": "FA8072",
-        "white": "FFFFFF"
+        "white": "FFFFFF",
+        "orange": "FF7700",
     }
 
     def __init__(self, ctx):
@@ -221,7 +258,7 @@ class JSONtoTextParser(metaclass=HandlerMeta):
 
     def _handle_player_id(self, node: JSONMessagePart):
         player = int(node["text"])
-        node["color"] = 'magenta' if player == self.ctx.slot else 'yellow'
+        node["color"] = 'magenta' if self.ctx.slot_concerns_self(player) else 'yellow'
         node["text"] = self.ctx.player_names[player]
         return self._handle_color(node)
 
@@ -246,7 +283,7 @@ class JSONtoTextParser(metaclass=HandlerMeta):
 
     def _handle_item_id(self, node: JSONMessagePart):
         item_id = int(node["text"])
-        node["text"] = self.ctx.item_names[item_id]
+        node["text"] = self.ctx.item_names.lookup_in_slot(item_id, node["player"])
         return self._handle_item_name(node)
 
     def _handle_location_name(self, node: JSONMessagePart):
@@ -254,14 +291,18 @@ class JSONtoTextParser(metaclass=HandlerMeta):
         return self._handle_color(node)
 
     def _handle_location_id(self, node: JSONMessagePart):
-        item_id = int(node["text"])
-        node["text"] = self.ctx.location_names[item_id]
+        location_id = int(node["text"])
+        node["text"] = self.ctx.location_names.lookup_in_slot(location_id, node["player"])
         return self._handle_location_name(node)
 
     def _handle_entrance_name(self, node: JSONMessagePart):
         node["color"] = 'blue'
         return self._handle_color(node)
 
+    def _handle_hint_status(self, node: JSONMessagePart):
+        node["color"] = status_colors.get(node["hint_status"], "red")
+        return self._handle_color(node)
+
 
 class RawJSONtoTextParser(JSONtoTextParser):
     def _handle_color(self, node: JSONMessagePart):
@@ -270,7 +311,8 @@ class RawJSONtoTextParser(JSONtoTextParser):
 
 color_codes = {'reset': 0, 'bold': 1, 'underline': 4, 'black': 30, 'red': 31, 'green': 32, 'yellow': 33, 'blue': 34,
                'magenta': 35, 'cyan': 36, 'white': 37, 'black_bg': 40, 'red_bg': 41, 'green_bg': 42, 'yellow_bg': 43,
-               'blue_bg': 44, 'magenta_bg': 45, 'cyan_bg': 46, 'white_bg': 47}
+               'blue_bg': 44, 'magenta_bg': 45, 'cyan_bg': 46, 'white_bg': 47,
+               'plum': 35, 'slateblue': 34, 'salmon': 31,}  # convert ui colors to terminal colors
 
 
 def color_code(*args):
@@ -289,8 +331,29 @@ def add_json_item(parts: list, item_id: int, player: int = 0, item_flags: int =
     parts.append({"text": str(item_id), "player": player, "flags": item_flags, "type": JSONTypes.item_id, **kwargs})
 
 
-def add_json_location(parts: list, item_id: int, player: int = 0, **kwargs) -> None:
-    parts.append({"text": str(item_id), "player": player, "type": JSONTypes.location_id, **kwargs})
+def add_json_location(parts: list, location_id: int, player: int = 0, **kwargs) -> None:
+    parts.append({"text": str(location_id), "player": player, "type": JSONTypes.location_id, **kwargs})
+
+
+status_names: typing.Dict[HintStatus, str] = {
+    HintStatus.HINT_FOUND: "(found)",
+    HintStatus.HINT_UNSPECIFIED: "(unspecified)",
+    HintStatus.HINT_NO_PRIORITY: "(no priority)",
+    HintStatus.HINT_AVOID: "(avoid)",
+    HintStatus.HINT_PRIORITY: "(priority)",
+}
+status_colors: typing.Dict[HintStatus, str] = {
+    HintStatus.HINT_FOUND: "green",
+    HintStatus.HINT_UNSPECIFIED: "white",
+    HintStatus.HINT_NO_PRIORITY: "slateblue",
+    HintStatus.HINT_AVOID: "salmon",
+    HintStatus.HINT_PRIORITY: "plum",
+}
+
+
+def add_json_hint_status(parts: list, hint_status: HintStatus, text: typing.Optional[str] = None, **kwargs):
+    parts.append({"text": text if text != None else status_names.get(hint_status, "(unknown)"),
+                  "hint_status": hint_status, "type": JSONTypes.hint_status, **kwargs})
 
 
 class Hint(typing.NamedTuple):
@@ -301,14 +364,21 @@ class Hint(typing.NamedTuple):
     found: bool
     entrance: str = ""
     item_flags: int = 0
+    status: HintStatus = HintStatus.HINT_UNSPECIFIED
 
     def re_check(self, ctx, team) -> Hint:
-        if self.found:
+        if self.found and self.status == HintStatus.HINT_FOUND:
             return self
         found = self.location in ctx.location_checks[team, self.finding_player]
         if found:
-            return Hint(self.receiving_player, self.finding_player, self.location, self.item, found, self.entrance,
-                        self.item_flags)
+            return self._replace(found=found, status=HintStatus.HINT_FOUND)
+        return self
+    
+    def re_prioritize(self, ctx, status: HintStatus) -> Hint:
+        if self.found and status != HintStatus.HINT_FOUND:
+            status = HintStatus.HINT_FOUND
+        if status != self.status:
+            return self._replace(status=status)
         return self
 
     def __hash__(self):
@@ -330,10 +400,7 @@ class Hint(typing.NamedTuple):
         else:
             add_json_text(parts, "'s World")
         add_json_text(parts, ". ")
-        if self.found:
-            add_json_text(parts, "(found)", type="color", color="green")
-        else:
-            add_json_text(parts, "(not found)", type="color", color="red")
+        add_json_hint_status(parts, self.status)
 
         return {"cmd": "PrintJSON", "data": parts, "type": "Hint",
                 "receiving": self.receiving_player,
@@ -343,3 +410,123 @@ 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.
+            if slot not in self:
+                raise KeyError(slot)
+            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[typing.Tuple[int, int]]:
+        checked = state[team, slot]
+        player_locations = self[slot]
+        return sorted([(player_locations[location_id][1], player_locations[location_id][0]) for
+                        location_id in player_locations if
+                        location_id not in checked])
+
+
+class MinimumVersions(typing.TypedDict):
+    server: tuple[int, int, int]
+    clients: dict[int, tuple[int, int, int]]
+
+
+class GamesPackage(typing.TypedDict, total=False):
+    item_name_groups: dict[str, list[str]]
+    item_name_to_id: dict[str, int]
+    location_name_groups: dict[str, list[str]]
+    location_name_to_id: dict[str, int]
+    checksum: str
+
+
+class DataPackage(typing.TypedDict):
+    games: dict[str, GamesPackage]
+
+
+class MultiData(typing.TypedDict):
+    slot_data: dict[int, Mapping[str, typing.Any]]
+    slot_info: dict[int, NetworkSlot]
+    connect_names: dict[str, tuple[int, int]]
+    locations: dict[int, dict[int, tuple[int, int, int]]]
+    checks_in_area: dict[int, dict[str, int | list[int]]]
+    server_options: dict[str, object]
+    er_hint_data: dict[int, dict[int, str]]
+    precollected_items: dict[int, list[int]]
+    precollected_hints: dict[int, set[Hint]]
+    version: tuple[int, int, int]
+    tags: list[str]
+    minimum_versions: MinimumVersions
+    seed_name: str
+    spheres: list[dict[int, set[int]]]
+    datapackage: dict[str, GamesPackage]
+    race_mode: int
+
+
+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

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

OoTClient.py

@@ -12,14 +12,15 @@ from CommonClient import CommonContext, server_loop, gui_enabled, \
 import Utils
 from Utils import async_start
 from worlds import network_data_package
+from worlds.oot import OOTWorld
 from worlds.oot.Rom import Rom, compress_rom_file
 from worlds.oot.N64Patch import apply_patch_file
 from worlds.oot.Utils import data_path
 
 
-CONNECTION_TIMING_OUT_STATUS = "Connection timing out. Please restart your emulator, then restart oot_connector.lua"
-CONNECTION_REFUSED_STATUS = "Connection refused. Please start your emulator and make sure oot_connector.lua is running"
-CONNECTION_RESET_STATUS = "Connection was reset. Please restart your emulator, then restart oot_connector.lua"
+CONNECTION_TIMING_OUT_STATUS = "Connection timing out. Please restart your emulator, then restart connector_oot.lua"
+CONNECTION_REFUSED_STATUS = "Connection refused. Please start your emulator and make sure connector_oot.lua is running"
+CONNECTION_RESET_STATUS = "Connection was reset. Please restart your emulator, then restart connector_oot.lua"
 CONNECTION_TENTATIVE_STATUS = "Initial Connection Made"
 CONNECTION_CONNECTED_STATUS = "Connected"
 CONNECTION_INITIAL_STATUS = "Connection has not been initiated"
@@ -100,7 +101,7 @@ class OoTContext(CommonContext):
             await super(OoTContext, self).server_auth(password_requested)
         if not self.auth:
             self.awaiting_rom = True
-            logger.info('Awaiting connection to Bizhawk to get player information')
+            logger.info('Awaiting connection to EmuHawk to get player information')
             return
 
         await self.send_connect()
@@ -179,6 +180,12 @@ async def parse_payload(payload: dict, ctx: OoTContext, force: bool):
     locations = payload['locations']
     collectibles = payload['collectibles']
 
+    # The Lua JSON library serializes an empty table into a list instead of a dict. Verify types for safety:
+    if isinstance(locations, list):
+        locations = {}
+    if isinstance(collectibles, list):
+        collectibles = {}
+
     if ctx.location_table != locations or ctx.collectible_table != collectibles:
         ctx.location_table = locations
         ctx.collectible_table = collectibles
@@ -270,11 +277,12 @@ async def n64_sync_task(ctx: OoTContext):
             except ConnectionRefusedError:
                 logger.debug("Connection Refused, Trying Again")
                 ctx.n64_status = CONNECTION_REFUSED_STATUS
+                await asyncio.sleep(1)
                 continue
 
 
 async def run_game(romfile):
-    auto_start = Utils.get_options()["oot_options"].get("rom_start", True)
+    auto_start = OOTWorld.settings.rom_start
     if auto_start is True:
         import webbrowser
         webbrowser.open(romfile)
@@ -289,11 +297,17 @@ 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 = 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_file_name = OOTWorld.settings.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.write_to_file(decomp_path)
     os.chdir(data_path("Compress"))
     compress_rom_file(decomp_path, comp_path)
@@ -334,7 +348,7 @@ if __name__ == '__main__':
 
     import colorama
 
-    colorama.init()
+    colorama.just_fix_windows_console()
 
     asyncio.run(main())
     colorama.deinit()

Patch.py

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

PokemonClient.py

@@ -1,335 +0,0 @@
-import asyncio
-import json
-import time
-import os
-import bsdiff4
-import subprocess
-import zipfile
-from asyncio import StreamReader, StreamWriter
-from typing import List
-
-
-import Utils
-from Utils import async_start
-from CommonClient import CommonContext, server_loop, gui_enabled, ClientCommandProcessor, logger, \
-    get_base_parser
-
-from worlds.pokemon_rb.locations import location_data
-from worlds.pokemon_rb.rom import RedDeltaPatch, BlueDeltaPatch
-
-location_map = {"Rod": {}, "EventFlag": {}, "Missable": {}, "Hidden": {}, "list": {}}
-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 = 1
-
-
-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
-
-    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
-        }
-    )
-    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:]}
-
-    if len(flags['Rod']) > 1:
-        return
-
-    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 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

@@ -1,31 +1,29 @@
 # [Archipelago](https://archipelago.gg) ![Discord Shield](https://discordapp.com/api/guilds/731205301247803413/widget.png?style=shield) | [Install](https://github.com/ArchipelagoMW/Archipelago/releases)
 
-Archipelago provides a generic framework for developing multiworld capability for game randomizers. In all cases, presently, Archipelago is also the randomizer itself.
+Archipelago provides a generic framework for developing multiworld capability for game randomizers. In all cases,
+presently, Archipelago is also the randomizer itself.
 
 Currently, the following games are supported:
+
 * The Legend of Zelda: A Link to the Past
 * Factorio
-* Minecraft
 * Subnautica
-* Slay the Spire
 * Risk of Rain 2
 * The Legend of Zelda: Ocarina of Time
 * Timespinner
 * Super Metroid
 * Secret of Evermore
 * Final Fantasy
-* Rogue Legacy
 * VVVVVV
 * Raft
 * Super Mario 64
 * Meritous
 * Super Metroid/Link to the Past combo randomizer (SMZ3)
 * ChecksFinder
-* ArchipIDLE
 * Hollow Knight
 * The Witness
 * Sonic Adventure 2: Battle
-* Starcraft 2: Wings of Liberty
+* Starcraft 2
 * Donkey Kong Country 3
 * Dark Souls 3
 * Super Mario World
@@ -34,6 +32,56 @@ Currently, the following games are supported:
 * Overcooked! 2
 * Zillion
 * Lufia II Ancient Cave
+* Blasphemous
+* Wargroove
+* Stardew Valley
+* The Legend of Zelda
+* The Messenger
+* Kingdom Hearts 2
+* The Legend of Zelda: Link's Awakening DX
+* 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
+* Castlevania 64
+* A Short Hike
+* Yoshi's Island
+* Mario & Luigi: Superstar Saga
+* Bomb Rush Cyberfunk
+* Aquaria
+* Yu-Gi-Oh! Ultimate Masters: World Championship Tournament 2006
+* A Hat in Time
+* Old School Runescape
+* Kingdom Hearts 1
+* Mega Man 2
+* Yacht Dice
+* Faxanadu
+* Saving Princess
+* Castlevania: Circle of the Moon
+* Inscryption
+* Civilization VI
+* The Legend of Zelda: The Wind Waker
+* Jak and Daxter: The Precursor Legacy
+* Super Mario Land 2: 6 Golden Coins
+* shapez
+* Paint
+* Celeste (Open World)
+* Choo-Choo Charles
 
 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
@@ -41,36 +89,57 @@ windows binaries.
 
 ## History
 
-Archipelago is built upon a strong legacy of brilliant hobbyists. We want to honor that legacy by showing it here. The repositories which Archipelago is built upon, inspired by, or otherwise owes its gratitude to are:
+Archipelago is built upon a strong legacy of brilliant hobbyists. We want to honor that legacy by showing it here.
+The repositories which Archipelago is built upon, inspired by, or otherwise owes its gratitude to are:
 
 * [bonta0's MultiWorld](https://github.com/Bonta0/ALttPEntranceRandomizer/tree/multiworld_31)
 * [AmazingAmpharos' Entrance Randomizer](https://github.com/AmazingAmpharos/ALttPEntranceRandomizer)
 * [VT Web Randomizer](https://github.com/sporchia/alttp_vt_randomizer)
 * [Dessyreqt's alttprandomizer](https://github.com/Dessyreqt/alttprandomizer)
-* [Zarby89's](https://github.com/Ijwu/Enemizer/commits?author=Zarby89) and [sosuke3's](https://github.com/Ijwu/Enemizer/commits?author=sosuke3) contributions to Enemizer, which make the vast majority of Enemizer contributions.
+* [Zarby89's](https://github.com/Ijwu/Enemizer/commits?author=Zarby89)
+  and [sosuke3's](https://github.com/Ijwu/Enemizer/commits?author=sosuke3) contributions to Enemizer, which make up the
+  vast majority of Enemizer contributions.
 
-We recognize that there is a strong community of incredibly smart people that have come before us and helped pave the path. Just because one person's name may be in a repository title does not mean that only one person made that project happen. We can't hope to perfectly cover every single contribution that lead up to Archipelago but we hope to honor them fairly.
+We recognize that there is a strong community of incredibly smart people that have come before us and helped pave the
+path. Just because one person's name may be in a repository title does not mean that only one person made that project
+happen. We can't hope to perfectly cover every single contribution that lead up to Archipelago, but we hope to honor
+them fairly.
 
 ### Path to the Archipelago
-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.
+
+Archipelago was directly forked from bonta0's `multiworld_31` branch of ALttPEntranceRandomizer (this project has a
+long legacy of its own, please check it out linked above) on January 12, 2020. The repository was then named to
+_MultiWorld-Utilities_ to better encompass its intended function. As Archipelago matured, then known as
+"Berserker's MultiWorld" by some, we found it necessary to transform our repository into a root level repository
+(as opposed to a 'forked repo') and change the name (which came later) to better reflect our project.
 
 ## Running Archipelago
-For most people all you need to do is head over to the [releases](https://github.com/ArchipelagoMW/Archipelago/releases) page then download and run the appropriate installer. The installers function on Windows only.
 
-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).
+For most people, all you need to do is head over to
+the [releases page](https://github.com/ArchipelagoMW/Archipelago/releases), then download and run the appropriate
+installer, or AppImage for Linux-based systems.
+
+If you are a developer or are running on a platform with no compiled releases available, please see our doc on
+[running Archipelago from source](docs/running%20from%20source.md).
 
 ## Related Repositories
-This project makes use of multiple other projects. We wouldn't be here without these other repositories and the contributions of their developers, past and present.
+
+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.
 
 * [z3randomizer](https://github.com/ArchipelagoMW/z3randomizer)
 * [Enemizer](https://github.com/Ijwu/Enemizer)
 * [Ocarina of Time Randomizer](https://github.com/TestRunnerSRL/OoT-Randomizer)
 
 ## Contributing
-For contribution guidelines, please see our [Contributing doc.](/docs/contributing.md)
+
+To contribute to Archipelago, including the WebHost, core program, or by adding a new game, see our
+[Contributing guidelines](/docs/contributing.md).
 
 ## FAQ
-For Frequently asked questions, please see the website's [FAQ Page.](https://archipelago.gg/faq/en/)
+
+For Frequently asked questions, please see the website's [FAQ Page](https://archipelago.gg/faq/en/).
 
 ## Code of Conduct
-Please refer to our [code of conduct.](/docs/code_of_conduct.md)
+
+Please refer to our [code of conduct](/docs/code_of_conduct.md).

SNIClient.py

@@ -18,6 +18,7 @@ from json import loads, dumps
 from CommonClient import CommonContext, server_loop, ClientCommandProcessor, gui_enabled, get_base_parser
 
 import Utils
+from settings import Settings
 from Utils import async_start
 from MultiServer import mark_raw
 if typing.TYPE_CHECKING:
@@ -56,7 +57,9 @@ class SNIClientCommandProcessor(ClientCommandProcessor):
         """Connect to a snes. Optionally include network address of a snes to connect to,
         otherwise show available devices; and a SNES device number if more than one SNES is detected.
         Examples: "/snes", "/snes 1", "/snes localhost:23074 1" """
-
+        if self.ctx.snes_state in {SNESState.SNES_ATTACHED, SNESState.SNES_CONNECTED, SNESState.SNES_CONNECTING}:
+            self.output("Already connected to SNES. Disconnecting first.")
+            self._cmd_snes_close()
         return self.connect_to_snes(snes_options)
 
     def connect_to_snes(self, snes_options: str = "") -> bool:
@@ -66,12 +69,11 @@ class SNIClientCommandProcessor(ClientCommandProcessor):
         options = snes_options.split()
         num_options = len(options)
 
-        if num_options > 0:
-            snes_device_number = int(options[0])
-
         if num_options > 1:
             snes_address = options[0]
             snes_device_number = int(options[1])
+        elif num_options > 0:
+            snes_device_number = int(options[0])
 
         self.ctx.snes_reconnect_address = None
         if self.ctx.snes_connect_task:
@@ -84,7 +86,8 @@ class SNIClientCommandProcessor(ClientCommandProcessor):
         """Close connection to a currently connected snes"""
         self.ctx.snes_reconnect_address = None
         self.ctx.cancel_snes_autoreconnect()
-        if self.ctx.snes_socket is not None and not self.ctx.snes_socket.closed:
+        self.ctx.snes_state = SNESState.SNES_DISCONNECTED
+        if self.ctx.snes_socket and not self.ctx.snes_socket.closed:
             async_start(self.ctx.snes_socket.close())
             return True
         else:
@@ -113,8 +116,8 @@ class SNIClientCommandProcessor(ClientCommandProcessor):
 
 class SNIContext(CommonContext):
     command_processor: typing.Type[SNIClientCommandProcessor] = SNIClientCommandProcessor
-    game = None  # set in validate_rom
-    items_handling = None  # set in game_watcher
+    game: typing.Optional[str] = None  # set in validate_rom
+    items_handling: typing.Optional[int] = None  # set in game_watcher
     snes_connect_task: "typing.Optional[asyncio.Task[None]]" = None
     snes_autoreconnect_task: typing.Optional["asyncio.Task[None]"] = None
 
@@ -206,12 +209,12 @@ class SNIContext(CommonContext):
             self.killing_player_task = asyncio.create_task(deathlink_kill_player(self))
         super(SNIContext, self).on_deathlink(data)
 
-    async def handle_deathlink_state(self, currently_dead: bool) -> None:
+    async def handle_deathlink_state(self, currently_dead: bool, death_text: str = "") -> None:
         # in this state we only care about triggering a death send
         if self.death_state == DeathState.alive:
             if currently_dead:
                 self.death_state = DeathState.dead
-                await self.send_death()
+                await self.send_death(death_text)
         # in this state we care about confirming a kill, to move state to dead
         elif self.death_state == DeathState.killing_player:
             # this is being handled in deathlink_kill_player(ctx) already
@@ -241,6 +244,9 @@ class SNIContext(CommonContext):
                 # Once the games handled by SNIClient gets made to be remote items,
                 # this will no longer be needed.
                 async_start(self.send_msgs([{"cmd": "LocationScouts", "locations": list(new_locations)}]))
+                
+        if self.client_handler is not None:
+            self.client_handler.on_package(self, cmd, args)
 
     def run_gui(self) -> None:
         from kvui import GameManager
@@ -280,7 +286,7 @@ class SNESState(enum.IntEnum):
 
 
 def launch_sni() -> None:
-    sni_path = Utils.get_options()["sni_options"]["sni_path"]
+    sni_path = Settings.sni_options.sni_path
 
     if not os.path.isdir(sni_path):
         sni_path = Utils.local_path(sni_path)
@@ -313,7 +319,7 @@ def launch_sni() -> None:
             f"please start it yourself if it is not running")
 
 
-async def _snes_connect(ctx: SNIContext, address: str) -> WebSocketClientProtocol:
+async def _snes_connect(ctx: SNIContext, address: str, retry: bool = True) -> WebSocketClientProtocol:
     address = f"ws://{address}" if "://" not in address else address
     snes_logger.info("Connecting to SNI at %s ..." % address)
     seen_problems: typing.Set[str] = set()
@@ -334,6 +340,8 @@ async def _snes_connect(ctx: SNIContext, address: str) -> WebSocketClientProtoco
             await asyncio.sleep(1)
         else:
             return snes_socket
+        if not retry:
+            break
 
 
 class SNESRequest(typing.TypedDict):
@@ -442,7 +450,8 @@ async def snes_connect(ctx: SNIContext, address: str, deviceIndex: int = -1) ->
         recv_task = asyncio.create_task(snes_recv_loop(ctx))
 
     except Exception as e:
-        if recv_task is not None:
+        ctx.snes_state = SNESState.SNES_DISCONNECTED
+        if task_alive(recv_task):
             if not ctx.snes_socket.closed:
                 await ctx.snes_socket.close()
         else:
@@ -450,15 +459,9 @@ async def snes_connect(ctx: SNIContext, address: str, deviceIndex: int = -1) ->
                 if not ctx.snes_socket.closed:
                     await ctx.snes_socket.close()
                 ctx.snes_socket = None
-            ctx.snes_state = SNESState.SNES_DISCONNECTED
-        if not ctx.snes_reconnect_address:
-            snes_logger.error("Error connecting to snes (%s)" % e)
-        else:
-            snes_logger.error(f"Error connecting to snes, retrying in {_global_snes_reconnect_delay} seconds")
-            assert ctx.snes_autoreconnect_task is None
-            ctx.snes_autoreconnect_task = asyncio.create_task(snes_autoreconnect(ctx), name="snes auto-reconnect")
+        snes_logger.error(f"Error connecting to snes ({e}), retrying in {_global_snes_reconnect_delay} seconds")
+        ctx.snes_autoreconnect_task = asyncio.create_task(snes_autoreconnect(ctx), name="snes auto-reconnect")
         _global_snes_reconnect_delay *= 2
-
     else:
         _global_snes_reconnect_delay = ctx.starting_reconnect_delay
         snes_logger.info(f"Attached to {device}")
@@ -471,10 +474,17 @@ async def snes_disconnect(ctx: SNIContext) -> None:
         ctx.snes_socket = None
 
 
+def task_alive(task: typing.Optional[asyncio.Task]) -> bool:
+    if task:
+        return not task.done()
+    return False
+
+
 async def snes_autoreconnect(ctx: SNIContext) -> None:
     await asyncio.sleep(_global_snes_reconnect_delay)
-    if ctx.snes_reconnect_address and not ctx.snes_socket and not ctx.snes_connect_task:
-        ctx.snes_connect_task = asyncio.create_task(snes_connect(ctx, ctx.snes_reconnect_address), name="SNES Connect")
+    if not ctx.snes_socket and not task_alive(ctx.snes_connect_task):
+        address = ctx.snes_reconnect_address if ctx.snes_reconnect_address else ctx.snes_address
+        ctx.snes_connect_task = asyncio.create_task(snes_connect(ctx, address), name="SNES Connect")
 
 
 async def snes_recv_loop(ctx: SNIContext) -> None:
@@ -560,8 +570,6 @@ async def snes_write(ctx: SNIContext, write_list: typing.List[typing.Tuple[int,
         try:
             for address, data in write_list:
                 PutAddress_Request['Operands'] = [hex(address)[2:], hex(len(data))[2:]]
-                # REVIEW: above: `if snes_socket is None: return False`
-                # Does it need to be checked again?
                 if ctx.snes_socket is not None:
                     await ctx.snes_socket.send(dumps(PutAddress_Request))
                     await ctx.snes_socket.send(data)
@@ -629,7 +637,13 @@ async def game_watcher(ctx: SNIContext) -> None:
         if not ctx.client_handler:
             continue
 
-        rom_validated = await ctx.client_handler.validate_rom(ctx)
+        try:
+            rom_validated = await ctx.client_handler.validate_rom(ctx)
+        except Exception as e:
+            snes_logger.error(f"An error occurred, see logs for details: {e}")
+            text_file_logger = logging.getLogger()
+            text_file_logger.exception(e)
+            rom_validated = False
 
         if not rom_validated or (ctx.auth and ctx.auth != ctx.rom):
             snes_logger.warning("ROM change detected, please reconnect to the multiworld server")
@@ -645,12 +659,17 @@ async def game_watcher(ctx: SNIContext) -> None:
 
         perf_counter = time.perf_counter()
 
-        await ctx.client_handler.game_watcher(ctx)
+        try:
+            await ctx.client_handler.game_watcher(ctx)
+        except Exception as e:
+            snes_logger.error(f"An error occurred, see logs for details: {e}")
+            text_file_logger = logging.getLogger()
+            text_file_logger.exception(e)
+            await snes_disconnect(ctx)
 
 
 async def run_game(romfile: str) -> None:
-    auto_start = typing.cast(typing.Union[bool, str],
-                             Utils.get_options()["sni_options"].get("snes_rom_start", True))
+    auto_start = Settings.sni_options.snes_rom_start
     if auto_start is True:
         import webbrowser
         webbrowser.open(romfile)
@@ -680,6 +699,8 @@ async def main() -> None:
         logging.info(f"Wrote rom file to {romfile}")
         if args.diff_file.endswith(".apsoe"):
             import webbrowser
+            async_start(run_game(romfile))
+            await _snes_connect(SNIContext(args.snes, args.connect, args.password), args.snes, False)
             webbrowser.open(f"http://www.evermizer.com/apclient/#server={meta['server']}")
             logging.info("Starting Evermizer Client in your Browser...")
             import time
@@ -714,6 +735,6 @@ async def main() -> None:
 
 
 if __name__ == '__main__':
-    colorama.init()
+    colorama.just_fix_windows_console()
     asyncio.run(main())
     colorama.deinit()

UndertaleClient.py

@@ -0,0 +1,512 @@
+from __future__ import annotations
+import os
+import sys
+import asyncio
+import typing
+import bsdiff4
+import shutil
+
+import Utils
+
+from NetUtils import NetworkItem, ClientStatus
+from worlds import undertale
+from MultiServer import mark_raw
+from CommonClient import CommonContext, server_loop, \
+    gui_enabled, ClientCommandProcessor, logger, get_base_parser
+from Utils import async_start
+
+
+class UndertaleCommandProcessor(ClientCommandProcessor):
+    def __init__(self, ctx):
+        super().__init__(ctx)
+
+    def _cmd_resync(self):
+        """Manually trigger a resync."""
+        if isinstance(self.ctx, UndertaleContext):
+            self.output(f"Syncing items.")
+            self.ctx.syncing = True
+
+    def _cmd_patch(self):
+        """Patch the game. Only use this command if /auto_patch fails."""
+        if isinstance(self.ctx, UndertaleContext):
+            os.makedirs(name=Utils.user_path("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=Utils.user_path("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),
+                               Utils.user_path("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(Utils.user_path("Undertale", "data.win"), "rb") as f:
+            patchedFile = bsdiff4.patch(f.read(), undertale.data_path("patch.bsdiff"))
+        with open(Utils.user_path("Undertale", "data.win"), "wb") as f:
+            f.write(patchedFile)
+        os.makedirs(name=Utils.user_path("Undertale", "Custom Sprites"), exist_ok=True)
+        with open(os.path.expandvars(Utils.user_path("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.lookup_in_game(l.item))):
+                        toDraw += str(ctx.item_names.lookup_in_game(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.just_fix_windows_console()
+
+    asyncio.run(_main())
+    colorama.deinit()
+
+
+if __name__ == "__main__":
+    parser = get_base_parser(description="Undertale Client, for text interfacing.")
+    args = parser.parse_args()
+    main()

WebHost.py

@@ -1,3 +1,4 @@
+import argparse
 import os
 import multiprocessing
 import logging
@@ -10,52 +11,67 @@ ModuleUpdate.update()
 
 # in case app gets imported by something like gunicorn
 import Utils
+import settings
+from Utils import get_file_safe_name
 
-Utils.local_path.cached_path = os.path.dirname(__file__) or "."  # py3.8 is not abs. remove "." when dropping 3.8
-
-from WebHostLib import register, app as raw_app
-from waitress import serve
-
-from WebHostLib.models import db
-from WebHostLib.autolauncher import autohost, autogen
-from WebHostLib.lttpsprites import update_sprites_lttp
-from WebHostLib.options import create as create_options_files
+if typing.TYPE_CHECKING:
+    from flask import Flask
 
+Utils.local_path.cached_path = os.path.dirname(__file__)
+settings.no_gui = True
 configpath = os.path.abspath("config.yaml")
 if not os.path.exists(configpath):  # fall back to config.yaml in home
     configpath = os.path.abspath(Utils.user_path('config.yaml'))
 
 
-def get_app():
-    register()
+def get_app() -> "Flask":
+    from WebHostLib import register, cache, app as raw_app
+    from WebHostLib.models import db
+
     app = raw_app
     if os.path.exists(configpath) and not app.config["TESTING"]:
         import yaml
         app.config.from_file(configpath, yaml.safe_load)
         logging.info(f"Updated config from {configpath}")
+    # inside get_app() so it's usable in systems like gunicorn, which do not run WebHost.py, but import it.
+    parser = argparse.ArgumentParser(allow_abbrev=False)
+    parser.add_argument('--config_override', default=None,
+                        help="Path to yaml config file that overrules config.yaml.")
+    args = parser.parse_known_args()[0]
+    if args.config_override:
+        import yaml
+        app.config.from_file(os.path.abspath(args.config_override), yaml.safe_load)
+        logging.info(f"Updated config from {args.config_override}")
+    if not app.config["HOST_ADDRESS"]:
+        logging.info("Getting public IP, as HOST_ADDRESS is empty.")
+        app.config["HOST_ADDRESS"] = Utils.get_public_ipv4()
+        logging.info(f"HOST_ADDRESS was set to {app.config['HOST_ADDRESS']}")
+
+    register()
+    cache.init_app(app)
     db.bind(**app.config["PONY"])
     db.generate_mapping(create_tables=True)
     return app
 
 
-def create_ordered_tutorials_file() -> typing.List[typing.Dict[str, typing.Any]]:
-    import json
+def copy_tutorials_files_to_static() -> None:
     import shutil
     import zipfile
+    from werkzeug.utils import secure_filename
 
     zfile: zipfile.ZipInfo
 
     from worlds.AutoWorld import AutoWorldRegister
     worlds = {}
-    data = []
     for game, world in AutoWorldRegister.world_types.items():
         if hasattr(world.web, 'tutorials') and (not world.hidden or game == 'Archipelago'):
             worlds[game] = world
 
     base_target_path = Utils.local_path("WebHostLib", "static", "generated", "docs")
+    shutil.rmtree(base_target_path, ignore_errors=True)
     for game, world in worlds.items():
         # copy files from world's docs folder to the generated folder
-        target_path = os.path.join(base_target_path, game)
+        target_path = os.path.join(base_target_path, secure_filename(game))
         os.makedirs(target_path, exist_ok=True)
 
         if world.zip_path:
@@ -67,59 +83,34 @@ 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:
-                        zf.extract(zfile, target_path)
+                        zfile.filename = os.path.basename(zfile.filename)
+                        with open(os.path.join(target_path, secure_filename(zfile.filename)), "wb") as f:
+                            f.write(zf.read(zfile))
         else:
             source_path = Utils.local_path(os.path.dirname(world.__file__), "docs")
             files = os.listdir(source_path)
             for file in files:
-                shutil.copyfile(Utils.local_path(source_path, file), Utils.local_path(target_path, file))
-
-        # build a json tutorial dict per game
-        game_data = {'gameTitle': game, 'tutorials': []}
-        for tutorial in world.web.tutorials:
-            # build dict for the json file
-            current_tutorial = {
-                'name': tutorial.tutorial_name,
-                'description': tutorial.description,
-                'files': [{
-                    'language': tutorial.language,
-                    'filename': game + '/' + tutorial.file_name,
-                    'link': f'{game}/{tutorial.link}',
-                    'authors': tutorial.authors
-                }]
-            }
-
-            # check if the name of the current guide exists already
-            for guide in game_data['tutorials']:
-                if guide and tutorial.tutorial_name == guide['name']:
-                    guide['files'].append(current_tutorial['files'][0])
-                    break
-            else:
-                game_data['tutorials'].append(current_tutorial)
-
-        data.append(game_data)
-    with open(Utils.local_path("WebHostLib", "static", "generated", "tutorials.json"), 'w', encoding='utf-8-sig') as json_target:
-        generic_data = {}
-        for games in data:
-            if 'Archipelago' in games['gameTitle']:
-                generic_data = data.pop(data.index(games))
-        sorted_data = [generic_data] + Utils.title_sorted(data, key=lambda entry: entry["gameTitle"])
-        json.dump(sorted_data, json_target, indent=2, ensure_ascii=False)
-    return sorted_data
+                shutil.copyfile(Utils.local_path(source_path, file),
+                                Utils.local_path(target_path, secure_filename(file)))
 
 
 if __name__ == "__main__":
     multiprocessing.freeze_support()
     multiprocessing.set_start_method('spawn')
     logging.basicConfig(format='[%(asctime)s] %(message)s', level=logging.INFO)
+
+    from WebHostLib.autolauncher import autohost, autogen, stop
+    from WebHostLib.options import create as create_options_files
+
     try:
+        from WebHostLib.lttpsprites import update_sprites_lttp
         update_sprites_lttp()
     except Exception as e:
         logging.exception(e)
         logging.warning("Could not update LttP sprites.")
     app = get_app()
     create_options_files()
-    create_ordered_tutorials_file()
+    copy_tutorials_files_to_static()
     if app.config["SELFLAUNCH"]:
         autohost(app.config)
     if app.config["SELFGEN"]:
@@ -128,4 +119,13 @@ 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"])
+    else:
+        from time import sleep
+        try:
+            while True:
+                sleep(1)  # wait for process to be killed
+        except (SystemExit, KeyboardInterrupt):
+            pass
+    stop()  # stop worker threads

WebHostLib/__init__.py

@@ -9,7 +9,7 @@ from flask_compress import Compress
 from pony.flask import Pony
 from werkzeug.routing import BaseConverter
 
-from Utils import title_sorted
+from Utils import title_sorted, get_file_safe_name
 
 UPLOAD_FOLDER = os.path.relpath('uploads')
 LOGS_FOLDER = os.path.relpath('logs')
@@ -20,9 +20,11 @@ Pony(app)
 
 app.jinja_env.filters['any'] = any
 app.jinja_env.filters['all'] = all
+app.jinja_env.filters['get_file_safe_name'] = get_file_safe_name
 
 app.config["SELFHOST"] = True  # application process is in charge of running the websites
 app.config["GENERATORS"] = 8  # maximum concurrent world gens
+app.config["HOSTERS"] = 8  # maximum concurrent room hosters
 app.config["SELFLAUNCH"] = True  # application process is in charge of launching Rooms.
 app.config["SELFLAUNCHCERT"] = None  # can point to a SSL Certificate to encrypt Room websocket connections
 app.config["SELFLAUNCHKEY"] = None  # can point to a SSL Certificate Key to encrypt Room websocket connections
@@ -34,9 +36,11 @@ app.config['MAX_CONTENT_LENGTH'] = 64 * 1024 * 1024  # 64 megabyte limit
 # if you want to deploy, make sure you have a non-guessable secret key
 app.config["SECRET_KEY"] = bytes(socket.gethostname(), encoding="utf-8")
 # at what amount of worlds should scheduling be used, instead of rolling in the web-thread
-app.config["JOB_THRESHOLD"] = 2
+app.config["JOB_THRESHOLD"] = 1
 # after what time in seconds should generation be aborted, freeing the queue slot. Can be set to None to disable.
 app.config["JOB_TIME"] = 600
+# memory limit for generator processes in bytes
+app.config["GENERATOR_MEMORY_LIMIT"] = 4294967296
 app.config['SESSION_PERMANENT'] = True
 
 # waitress uses one thread for I/O, these are for processing of views that then get sent
@@ -49,40 +53,51 @@ app.config["PONY"] = {
     'create_db': True
 }
 app.config["MAX_ROLL"] = 20
-app.config["CACHE_TYPE"] = "flask_caching.backends.SimpleCache"
-app.config["JSON_AS_ASCII"] = False
-app.config["PATCH_TARGET"] = "archipelago.gg"
+app.config["CACHE_TYPE"] = "SimpleCache"
+app.config["HOST_ADDRESS"] = ""
+app.config["ASSET_RIGHTS"] = False
 
-cache = Cache(app)
+cache = Cache()
 Compress(app)
 
 
+def to_python(value):
+    return uuid.UUID(bytes=base64.urlsafe_b64decode(value + '=='))
+
+
+def to_url(value):
+    return base64.urlsafe_b64encode(value.bytes).rstrip(b'=').decode('ascii')
+
+
 class B64UUIDConverter(BaseConverter):
 
     def to_python(self, value):
-        return uuid.UUID(bytes=base64.urlsafe_b64decode(value + '=='))
+        return to_python(value)
 
     def to_url(self, value):
-        return base64.urlsafe_b64encode(value.bytes).rstrip(b'=').decode('ascii')
+        return to_url(value)
 
 
 # short UUID
 app.url_map.converters["suuid"] = B64UUIDConverter
-app.jinja_env.filters['suuid'] = lambda value: base64.urlsafe_b64encode(value.bytes).rstrip(b'=').decode('ascii')
+app.jinja_env.filters["suuid"] = to_url
 app.jinja_env.filters["title_sorted"] = title_sorted
 
 
 def register():
     """Import submodules, triggering their registering on flask routing.
     Note: initializes worlds subsystem."""
+    import importlib
+
+    from werkzeug.utils import find_modules
     # has automatic patch integration
-    import worlds.AutoWorld
     import worlds.Files
-    app.jinja_env.filters['supports_apdeltapatch'] = lambda game_name: \
-        game_name in worlds.Files.AutoPatchRegister.patch_types
+    app.jinja_env.filters['is_applayercontainer'] = worlds.Files.is_ap_player_container
 
     from WebHostLib.customserver import run_server_process
-    # to trigger app routing picking up on it
-    from . import tracker, upload, landing, check, generate, downloads, api, stats, misc
 
+    for module in find_modules("WebHostLib", include_packages=True):
+        importlib.import_module(module)
+
+    from . import api
     app.register_blueprint(api.api_endpoints)

WebHostLib/api/__init__.py

@@ -1,50 +1,15 @@
 """API endpoints package."""
 from typing import List, Tuple
-from uuid import UUID
 
-from flask import Blueprint, abort
+from flask import Blueprint
 
-from .. import cache
-from ..models import Room, Seed
+from ..models import Seed, Slot
 
 api_endpoints = Blueprint('api', __name__, url_prefix="/api")
 
-# unsorted/misc endpoints
-
 
 def get_players(seed: Seed) -> List[Tuple[str, str]]:
-    return [(slot.player_name, slot.game) for slot in seed.slots]
+    return [(slot.player_name, slot.game) for slot in seed.slots.order_by(Slot.player_id)]
 
-
-@api_endpoints.route('/room_status/<suuid:room>')
-def room_info(room: UUID):
-    room = Room.get(id=room)
-    if room is None:
-        return abort(404)
-    return {
-        "tracker": room.tracker,
-        "players": get_players(room.seed),
-        "last_port": room.last_port,
-        "last_activity": room.last_activity,
-        "timeout": room.timeout
-    }
-
-
-@api_endpoints.route('/datapackage')
-@cache.cached()
-def get_datapackage():
-    from worlds import network_data_package
-    return network_data_package
-
-
-@api_endpoints.route('/datapackage_version')
-@cache.cached()
-
-def get_datapackage_versions():
-    from worlds import network_data_package, AutoWorldRegister
-
-    version_package = {game: world.data_version for game, world in AutoWorldRegister.world_types.items()}
-    return version_package
-
-
-from . import generate, user  # trigger registration
+# trigger endpoint registration
+from . import datapackage, generate, room, tracker, user

WebHostLib/api/datapackage.py

@@ -0,0 +1,32 @@
+from flask import abort
+
+from Utils import restricted_loads
+from WebHostLib import cache
+from WebHostLib.models import GameDataPackage
+from . import api_endpoints
+
+
+@api_endpoints.route('/datapackage')
+@cache.cached()
+def get_datapackage():
+    from worlds import network_data_package
+    return network_data_package
+
+
+@api_endpoints.route('/datapackage/<string:checksum>')
+@cache.memoize(timeout=3600)
+def get_datapackage_by_checksum(checksum: str):
+    package = GameDataPackage.get(checksum=checksum)
+    if package:
+        return restricted_loads(package.data)
+    return abort(404)
+
+
+@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

WebHostLib/api/generate.py

@@ -1,10 +1,11 @@
 import json
-import pickle
 from uuid import UUID
 
-from flask import request, session, url_for, Markup
+from flask import request, session, url_for
+from markupsafe import Markup
 from pony.orm import commit
 
+from Utils import restricted_dumps
 from WebHostLib import app
 from WebHostLib.check import get_yaml_data, roll_options
 from WebHostLib.generate import get_meta
@@ -19,8 +20,8 @@ def generate_api():
         race = False
         meta_options_source = {}
         if 'file' in request.files:
-            file = request.files['file']
-            options = get_yaml_data(file)
+            files = request.files.getlist('file')
+            options = get_yaml_data(files)
             if isinstance(options, Markup):
                 return {"text": options.striptags()}, 400
             if isinstance(options, str):
@@ -48,15 +49,14 @@ def generate_api():
         if len(options) > app.config["MAX_ROLL"]:
             return {"text": "Max size of multiworld exceeded",
                     "detail": app.config["MAX_ROLL"]}, 409
-        meta = get_meta(meta_options_source)
-        meta["race"] = race
-        results, gen_options = roll_options(options, meta["plando_options"])
+        meta = get_meta(meta_options_source, race)
+        results, gen_options = roll_options(options, set(meta["plando_options"]))
         if any(type(result) == str for result in results.values()):
             return {"text": str(results),
                     "detail": results}, 400
         else:
             gen = Generation(
-                options=pickle.dumps({name: vars(options) for name, options in gen_options.items()}),
+                options=restricted_dumps({name: vars(options) for name, options in gen_options.items()}),
                 # convert to json compatible
                 meta=json.dumps(meta), state=STATE_QUEUED,
                 owner=session["_id"])

WebHostLib/api/room.py

@@ -0,0 +1,43 @@
+from typing import Any, Dict
+from uuid import UUID
+
+from flask import abort, url_for
+
+from WebHostLib import to_url
+import worlds.Files
+from . import api_endpoints, get_players
+from ..models import Room
+
+
+@api_endpoints.route('/room_status/<suuid:room_id>')
+def room_info(room_id: UUID) -> Dict[str, Any]:
+    room = Room.get(id=room_id)
+    if room is None:
+        return abort(404)
+
+    def supports_apdeltapatch(game: str) -> bool:
+        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": to_url(room.tracker),
+        "players": get_players(room.seed),
+        "last_port": room.last_port,
+        "last_activity": room.last_activity,
+        "timeout": room.timeout,
+        "downloads": downloads,
+    }

WebHostLib/api/tracker.py

@@ -0,0 +1,232 @@
+from datetime import datetime, timezone
+from typing import Any, TypedDict
+from uuid import UUID
+
+from flask import abort
+
+from NetUtils import ClientStatus, Hint, NetworkItem, SlotType
+from WebHostLib import cache
+from WebHostLib.api import api_endpoints
+from WebHostLib.models import Room
+from WebHostLib.tracker import TrackerData
+
+
+@api_endpoints.route("/tracker/<suuid:tracker>")
+@cache.memoize(timeout=60)
+def tracker_data(tracker: UUID) -> dict[str, Any]:
+    """
+    Outputs json data to <root_path>/api/tracker/<id of current session tracker>.
+
+    :param tracker: UUID of current session tracker.
+
+    :return: Tracking data for all players in the room. Typing and docstrings describe the format of each value.
+    """
+    room: Room | None = Room.get(tracker=tracker)
+    if not room:
+        abort(404)
+
+    tracker_data = TrackerData(room)
+
+    all_players: dict[int, list[int]] = tracker_data.get_all_players()
+
+    class PlayerAlias(TypedDict):
+        player: int
+        name: str | None
+
+    player_aliases: list[dict[str, int | list[PlayerAlias]]] = []
+    """Slot aliases of all players."""
+    for team, players in all_players.items():
+        team_player_aliases: list[PlayerAlias] = []
+        team_aliases = {"team": team, "players": team_player_aliases}
+        player_aliases.append(team_aliases)
+        for player in players:
+            team_player_aliases.append({"player": player, "alias": tracker_data.get_player_alias(team, player)})
+
+    class PlayerItemsReceived(TypedDict):
+        player: int
+        items: list[NetworkItem]
+
+    player_items_received: list[dict[str, int | list[PlayerItemsReceived]]] = []
+    """Items received by each player."""
+    for team, players in all_players.items():
+        player_received_items: list[PlayerItemsReceived] = []
+        team_items_received = {"team": team, "players": player_received_items}
+        player_items_received.append(team_items_received)
+        for player in players:
+            player_received_items.append(
+                {"player": player, "items": tracker_data.get_player_received_items(team, player)})
+
+    class PlayerChecksDone(TypedDict):
+        player: int
+        locations: list[int]
+
+    player_checks_done: list[dict[str, int | list[PlayerChecksDone]]] = []
+    """ID of all locations checked by each player."""
+    for team, players in all_players.items():
+        per_player_checks: list[PlayerChecksDone] = []
+        team_checks_done = {"team": team, "players": per_player_checks}
+        player_checks_done.append(team_checks_done)
+        for player in players:
+            per_player_checks.append(
+                {"player": player, "locations": sorted(tracker_data.get_player_checked_locations(team, player))})
+
+    total_checks_done: list[dict[str, int]] = [
+        {"team": team, "checks_done": checks_done}
+        for team, checks_done in tracker_data.get_team_locations_checked_count().items()
+    ]
+    """Total number of locations checked for the entire multiworld per team."""
+
+    class PlayerHints(TypedDict):
+        player: int
+        hints: list[Hint]
+
+    hints: list[dict[str, int | list[PlayerHints]]] = []
+    """Hints that all players have used or received."""
+    for team, players in tracker_data.get_all_slots().items():
+        per_player_hints: list[PlayerHints] = []
+        team_hints = {"team": team, "players": per_player_hints}
+        hints.append(team_hints)
+        for player in players:
+            player_hints = sorted(tracker_data.get_player_hints(team, player))
+            per_player_hints.append({"player": player, "hints": player_hints})
+            slot_info = tracker_data.get_slot_info(team, player)
+            # this assumes groups are always after players
+            if slot_info.type != SlotType.group:
+                continue
+            for member in slot_info.group_members:
+                team_hints[member]["hints"] += player_hints
+
+    class PlayerTimer(TypedDict):
+        player: int
+        time: datetime | None
+
+    activity_timers: list[dict[str, int | list[PlayerTimer]]] = []
+    """Time of last activity per player. Returned as RFC 1123 format and null if no connection has been made."""
+    for team, players in all_players.items():
+        player_timers: list[PlayerTimer] = []
+        team_timers = {"team": team, "players": player_timers}
+        activity_timers.append(team_timers)
+        for player in players:
+            player_timers.append({"player": player, "time": None})
+
+    client_activity_timers: tuple[tuple[int, int], float] = tracker_data._multisave.get("client_activity_timers", ())
+    for (team, player), timestamp in client_activity_timers:
+        # use index since we can rely on order
+        # FIX: key is "players" (not "player_timers")
+        activity_timers[team]["players"][player - 1]["time"] = datetime.fromtimestamp(timestamp, timezone.utc)
+
+
+    connection_timers: list[dict[str, int | list[PlayerTimer]]] = []
+    """Time of last connection per player. Returned as RFC 1123 format and null if no connection has been made."""
+    for team, players in all_players.items():
+        player_timers: list[PlayerTimer] = []
+        team_connection_timers = {"team": team, "players": player_timers}
+        connection_timers.append(team_connection_timers)
+        for player in players:
+            player_timers.append({"player": player, "time": None})
+
+    client_connection_timers: tuple[tuple[int, int], float] = tracker_data._multisave.get(
+        "client_connection_timers", ())
+    for (team, player), timestamp in client_connection_timers:
+        connection_timers[team]["players"][player - 1]["time"] = datetime.fromtimestamp(timestamp, timezone.utc)
+
+    class PlayerStatus(TypedDict):
+        player: int
+        status: ClientStatus
+
+    player_status: list[dict[str, int | list[PlayerStatus]]] = []
+    """The current client status for each player."""
+    for team, players in all_players.items():
+        player_statuses: list[PlayerStatus] = []
+        team_status = {"team": team, "players": player_statuses}
+        player_status.append(team_status)
+        for player in players:
+            player_statuses.append({"player": player, "status": tracker_data.get_player_client_status(team, player)})
+
+    return {
+        **get_static_tracker_data(room),
+        "aliases": player_aliases,
+        "player_items_received": player_items_received,
+        "player_checks_done": player_checks_done,
+        "total_checks_done": total_checks_done,
+        "hints": hints,
+        "activity_timers": activity_timers,
+        "connection_timers": connection_timers,
+        "player_status": player_status,
+        "datapackage": tracker_data._multidata["datapackage"],
+    }
+
+@cache.memoize()
+def get_static_tracker_data(room: Room) -> dict[str, Any]:
+    """
+    Builds and caches the static data for this active session tracker, so that it doesn't need to be recalculated.
+    """
+
+    tracker_data = TrackerData(room)
+
+    all_players: dict[int, list[int]] = tracker_data.get_all_players()
+
+    class PlayerGroups(TypedDict):
+        slot: int
+        name: str
+        members: list[int]
+
+    groups: list[dict[str, int | list[PlayerGroups]]] = []
+    """The Slot ID of groups and the IDs of the group's members."""
+    for team, players in tracker_data.get_all_slots().items():
+        groups_in_team: list[PlayerGroups] = []
+        team_groups = {"team": team, "groups": groups_in_team}
+        groups.append(team_groups)
+        for player in players:
+            slot_info = tracker_data.get_slot_info(team, player)
+            if slot_info.type != SlotType.group or not slot_info.group_members:
+                continue
+            groups_in_team.append(
+                {
+                    "slot": player,
+                    "name": slot_info.name,
+                    "members": list(slot_info.group_members),
+                })
+    class PlayerName(TypedDict):
+        player: int
+        name: str
+
+    player_names: list[dict[str, str | list[PlayerName]]] = []
+    """Slot names of all players."""
+    for team, players in all_players.items():
+        per_team_player_names: list[PlayerName] = []
+        team_names = {"team": team, "players": per_team_player_names}
+        player_names.append(team_names)
+        for player in players:
+            per_team_player_names.append({"player": player, "name": tracker_data.get_player_name(team, player)})
+
+    class PlayerGame(TypedDict):
+        player: int
+        game: str
+
+    games: list[dict[str, int | list[PlayerGame]]] = []
+    """The game each player is playing."""
+    for team, players in all_players.items():
+        player_games: list[PlayerGame] = []
+        team_games = {"team": team, "players": player_games}
+        games.append(team_games)
+        for player in players:
+            player_games.append({"player": player, "game": tracker_data.get_player_game(team, player)})
+
+    class PlayerSlotData(TypedDict):
+        player: int
+        slot_data: dict[str, Any]
+
+    slot_data: list[dict[str, int | list[PlayerSlotData]]] = []
+    """Slot data for each player."""
+    for team, players in all_players.items():
+        player_slot_data: list[PlayerSlotData] = []
+        team_slot_data = {"team": team, "players": player_slot_data}
+        slot_data.append(team_slot_data)
+        for player in players:
+            player_slot_data.append({"player": player, "slot_data": tracker_data.get_slot_data(team, player)})
+
+    return {
+        "groups": groups,
+        "slot_data": slot_data,
+    }

WebHostLib/api/user.py

@@ -1,6 +1,7 @@
 from flask import session, jsonify
 from pony.orm import select
 
+from WebHostLib import to_url
 from WebHostLib.models import Room, Seed
 from . import api_endpoints, get_players
 
@@ -10,13 +11,13 @@ def get_rooms():
     response = []
     for room in select(room for room in Room if room.owner == session["_id"]):
         response.append({
-            "room_id": room.id,
-            "seed_id": room.seed.id,
+            "room_id": to_url(room.id),
+            "seed_id": to_url(room.seed.id),
             "creation_time": room.creation_time,
             "last_activity": room.last_activity,
             "last_port": room.last_port,
             "timeout": room.timeout,
-            "tracker": room.tracker,
+            "tracker": to_url(room.tracker),
         })
     return jsonify(response)
 
@@ -26,8 +27,8 @@ def get_seeds():
     response = []
     for seed in select(seed for seed in Seed if seed.owner == session["_id"]):
         response.append({
-            "seed_id": seed.id,
+            "seed_id": to_url(seed.id),
             "creation_time": seed.creation_time,
-            "players": get_players(seed.slots),
+            "players": get_players(seed),
         })
-    return jsonify(response)
+    return jsonify(response)

WebHostLib/autolauncher.py

@@ -3,75 +3,26 @@ from __future__ import annotations
 import json
 import logging
 import multiprocessing
-import os
-import sys
-import threading
-import time
 import typing
 from datetime import timedelta, datetime
+from threading import Event, Thread
+from typing import Any
+from uuid import UUID
 
-from pony.orm import db_session, select, commit
+from pony.orm import db_session, select, commit, PrimaryKey
 
 from Utils import restricted_loads
+from .locker import Locker, AlreadyRunningException
+
+_stop_event = Event()
 
 
-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):
-    # requires db_session!
-    if room.last_activity >= datetime.utcnow() - timedelta(seconds=room.timeout):
-        multiworld = multiworlds.get(room.id, None)
-        if not multiworld:
-            multiworld = MultiworldInstance(room, config)
-
-        multiworld.start()
+def stop():
+    """Stops previously launched threads"""
+    global _stop_event
+    stop_event = _stop_event
+    _stop_event = Event()  # new event for new threads
+    stop_event.set()
 
 
 def handle_generation_success(seed_id):
@@ -85,12 +36,21 @@ def handle_generation_failure(result: BaseException):
         logging.exception(e)
 
 
+def _mp_gen_game(gen_options: dict, meta: dict[str, Any] | None = None, owner=None, sid=None) -> PrimaryKey | None:
+    from setproctitle import setproctitle
+
+    setproctitle(f"Generator ({sid})")
+    res = gen_game(gen_options, meta=meta, owner=owner, sid=sid)
+    setproctitle(f"Generator (idle)")
+    return res
+
+
 def launch_generator(pool: multiprocessing.pool.Pool, generation: Generation):
     try:
         meta = json.loads(generation.meta)
         options = restricted_loads(generation.options)
         logging.info(f"Generating {generation.id} for {len(options)} players")
-        pool.apply_async(gen_game, (options,),
+        pool.apply_async(_mp_gen_game, (options,),
                          {"meta": meta,
                           "sid": generation.id,
                           "owner": generation.owner},
@@ -103,39 +63,78 @@ def launch_generator(pool: multiprocessing.pool.Pool, generation: Generation):
         generation.state = STATE_STARTED
 
 
-def init_db(pony_config: dict):
+def init_generator(config: dict[str, Any]) -> None:
+    from setproctitle import setproctitle
+
+    setproctitle("Generator (idle)")
+
+    try:
+        import resource
+    except ModuleNotFoundError:
+        pass  # unix only module
+    else:
+        # set soft limit for memory to from config (default 4GiB)
+        soft_limit = config["GENERATOR_MEMORY_LIMIT"]
+        old_limit, hard_limit = resource.getrlimit(resource.RLIMIT_AS)
+        if soft_limit != old_limit:
+            resource.setrlimit(resource.RLIMIT_AS, (soft_limit, hard_limit))
+            logging.debug(f"Changed AS mem limit {old_limit} -> {soft_limit}")
+        del resource, soft_limit, hard_limit
+
+    pony_config = config["PONY"]
     db.bind(**pony_config)
     db.generate_mapping()
 
 
+def cleanup():
+    """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.")
+
+
 def autohost(config: dict):
     def keep_running():
+        stop_event = _stop_event
         try:
             with Locker("autohost"):
-                run_guardian()
-                while 1:
-                    time.sleep(0.1)
+                cleanup()
+                hosters = []
+                for x in range(config["HOSTERS"]):
+                    hoster = MultiworldInstance(config, x)
+                    hosters.append(hoster)
+                    hoster.start()
+
+                while not stop_event.wait(0.1):
                     with db_session:
                         rooms = select(
                             room for room in Room if
                             room.last_activity >= datetime.utcnow() - timedelta(days=3))
                         for room in rooms:
-                            launch_room(room, config)
+                            # we have to filter twice, as the per-room timeout can't currently be PonyORM transpiled.
+                            if room.last_activity >= datetime.utcnow() - timedelta(seconds=room.timeout + 5):
+                                hosters[room.id.int % len(hosters)].start_room(room.id)
 
         except AlreadyRunningException:
             logging.info("Autohost reports as already running, not starting another.")
 
-    import threading
-    threading.Thread(target=keep_running, name="AP_Autohost").start()
+    Thread(target=keep_running, name="AP_Autohost").start()
 
 
 def autogen(config: dict):
     def keep_running():
+        stop_event = _stop_event
         try:
             with Locker("autogen"):
 
-                with multiprocessing.Pool(config["GENERATORS"], initializer=init_db,
-                                          initargs=(config["PONY"],)) as generator_pool:
+                with multiprocessing.Pool(config["GENERATORS"], initializer=init_generator,
+                                          initargs=(config,), maxtasksperchild=10) as generator_pool:
                     with db_session:
                         to_start = select(generation for generation in Generation if generation.state == STATE_STARTED)
 
@@ -151,8 +150,7 @@ def autogen(config: dict):
                             commit()
                         select(generation for generation in Generation if generation.state == STATE_ERROR).delete()
 
-                    while 1:
-                        time.sleep(0.1)
+                    while not stop_event.wait(0.1):
                         with db_session:
                             # for update locks the database row(s) during transaction, preventing writes from elsewhere
                             to_start = select(
@@ -163,36 +161,42 @@ def autogen(config: dict):
         except AlreadyRunningException:
             logging.info("Autogen reports as already running, not starting another.")
 
-    import threading
-    threading.Thread(target=keep_running, name="AP_Autogen").start()
-
-
-multiworlds: typing.Dict[type(Room.id), MultiworldInstance] = {}
+    Thread(target=keep_running, name="AP_Autogen").start()
 
 
 class MultiworldInstance():
-    def __init__(self, room: Room, config: dict):
-        self.room_id = room.id
+    def __init__(self, config: dict, id: int):
+        self.room_ids = set()
         self.process: typing.Optional[multiprocessing.Process] = None
-        with guardian_lock:
-            multiworlds[self.room_id] = self
         self.ponyconfig = config["PONY"]
         self.cert = config["SELFLAUNCHCERT"]
         self.key = config["SELFLAUNCHKEY"]
+        self.host = config["HOST_ADDRESS"]
+        self.rooms_to_start = multiprocessing.Queue()
+        self.rooms_shutting_down = multiprocessing.Queue()
+        self.name = f"MultiHoster{id}"
 
     def start(self):
         if self.process and self.process.is_alive():
             return False
 
-        logging.info(f"Spinning up {self.room_id}")
         process = multiprocessing.Process(group=None, target=run_server_process,
-                                          args=(self.room_id, self.ponyconfig, get_static_server_data(),
-                                                self.cert, self.key),
-                                          name="MultiHost")
+                                          args=(self.name, self.ponyconfig, get_static_server_data(),
+                                                self.cert, self.key, self.host,
+                                                self.rooms_to_start, self.rooms_shutting_down),
+                                          name=self.name)
         process.start()
-        # bind after start to prevent thread sync issues with guardian.
         self.process = process
 
+    def start_room(self, room_id):
+        while not self.rooms_shutting_down.empty():
+            self.room_ids.remove(self.rooms_shutting_down.get(block=True, timeout=None))
+        if room_id in self.room_ids:
+            pass  # should already be hosted currently.
+        else:
+            self.room_ids.add(room_id)
+            self.rooms_to_start.put(room_id)
+
     def stop(self):
         if self.process:
             self.process.terminate()
@@ -206,40 +210,6 @@ class MultiworldInstance():
         self.process = None
 
 
-guardian = None
-guardian_lock = threading.Lock()
-
-
-def run_guardian():
-    global guardian
-    global multiworlds
-    with guardian_lock:
-        if not guardian:
-            try:
-                import resource
-            except ModuleNotFoundError:
-                pass  # unix only module
-            else:
-                # Each Server is another file handle, so request as many as we can from the system
-                file_limit = resource.getrlimit(resource.RLIMIT_NOFILE)[1]
-                # set soft limit to hard limit
-                resource.setrlimit(resource.RLIMIT_NOFILE, (file_limit, file_limit))
-
-            def guard():
-                while 1:
-                    time.sleep(1)
-                    done = []
-                    with guardian_lock:
-                        for key, instance in multiworlds.items():
-                            if instance.done():
-                                instance.collect()
-                                done.append(key)
-                        for key in done:
-                            del (multiworlds[key])
-
-            guardian = threading.Thread(name="Guardian", target=guard)
-
-
-from .models import Room, Generation, STATE_QUEUED, STATE_STARTED, STATE_ERROR, db, Seed
+from .models import Room, Generation, STATE_QUEUED, STATE_STARTED, STATE_ERROR, db, Seed, Slot
 from .customserver import run_server_process, get_static_server_data
 from .generate import gen_game

WebHostLib/check.py

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

WebHostLib/customserver.py

@@ -5,12 +5,14 @@ import collections
 import datetime
 import functools
 import logging
+import multiprocessing
 import pickle
 import random
 import socket
 import threading
 import time
 import typing
+import sys
 
 import websockets
 from pony.orm import commit, db_session, select
@@ -18,15 +20,18 @@ from pony.orm import commit, db_session, select
 import Utils
 
 from MultiServer import Context, server, auto_shutdown, ServerCommandProcessor, ClientMessageProcessor, load_server_cert
-from Utils import get_public_ipv4, get_public_ipv6, restricted_loads, cache_argsless
-from .models import Room, Command, db
+from Utils import restricted_loads, cache_argsless
+from .locker import Locker
+from .models import Command, GameDataPackage, Room, db
 
 
 class CustomClientMessageProcessor(ClientMessageProcessor):
     ctx: WebHostContext
 
-    def _cmd_video(self, platform, user):
-        """Set a link for your name in the WebHostLib tracker pointing to a video stream"""
+    def _cmd_video(self, platform: str, user: str):
+        """Set a link for your name in the WebHostLib tracker pointing to a video stream.
+        Currently, only YouTube and Twitch platforms are supported.
+        """
         if platform.lower().startswith("t"):  # twitch
             self.ctx.video[self.client.team, self.client.slot] = "Twitch", user
             self.ctx.save()
@@ -49,24 +54,35 @@ del MultiServer
 
 class DBCommandProcessor(ServerCommandProcessor):
     def output(self, text: str):
-        logging.info(text)
+        self.ctx.logger.info(text)
 
 
 class WebHostContext(Context):
     room_id: int
 
-    def __init__(self, static_server_data: dict):
+    def __init__(self, static_server_data: dict, logger: logging.Logger):
         # static server data is used during _load_game_data to load required data,
         # without needing to import worlds system, which takes quite a bit of memory
         self.static_server_data = static_server_data
-        super(WebHostContext, self).__init__("", 0, "", "", 1, 40, True, "enabled", "enabled", "enabled", 0, 2)
+        super(WebHostContext, self).__init__("", 0, "", "", 1,
+                                             40, True, "enabled", "enabled",
+                                             "enabled", 0, 2, logger=logger)
         del self.static_server_data
         self.main_loop = asyncio.get_running_loop()
         self.video = {}
         self.tags = ["AP", "WebHost"]
 
+    def __del__(self):
+        try:
+            import psutil
+            from Utils import format_SI_prefix
+            self.logger.debug(f"Context destroyed, Mem: {format_SI_prefix(psutil.Process().memory_info().rss, 1024)}iB")
+        except ImportError:
+            self.logger.debug("Context destroyed")
+
     def _load_game_data(self):
         for key, value in self.static_server_data.items():
+            # NOTE: attributes are mutable and shared, so they will have to be copied before being modified
             setattr(self, key, value)
         self.non_hintable_names = collections.defaultdict(frozenset, self.non_hintable_names)
 
@@ -92,7 +108,43 @@ class WebHostContext(Context):
         else:
             self.port = get_random_port()
 
-        return self._load(self.decompress(room.seed.multidata), True)
+        multidata = self.decompress(room.seed.multidata)
+        game_data_packages = {}
+
+        static_gamespackage = self.gamespackage  # this is shared across all rooms
+        static_item_name_groups = self.item_name_groups
+        static_location_name_groups = self.location_name_groups
+        self.gamespackage = {"Archipelago": static_gamespackage.get("Archipelago", {})}  # this may be modified by _load
+        self.item_name_groups = {"Archipelago": static_item_name_groups.get("Archipelago", {})}
+        self.location_name_groups = {"Archipelago": static_location_name_groups.get("Archipelago", {})}
+        missing_checksum = False
+
+        for game in list(multidata.get("datapackage", {})):
+            game_data = multidata["datapackage"][game]
+            if "checksum" in game_data:
+                if static_gamespackage.get(game, {}).get("checksum") == game_data["checksum"]:
+                    # non-custom. remove from multidata and use static data
+                    # 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] = restricted_loads(row.data)
+                        continue
+                    else:
+                        self.logger.warning(f"Did not find game_data_package for {game}: {game_data['checksum']}")
+            else:
+                missing_checksum = True  # Game rolled on old AP and will load data package from multidata
+            self.gamespackage[game] = static_gamespackage.get(game, {})
+            self.item_name_groups[game] = static_item_name_groups.get(game, {})
+            self.location_name_groups[game] = static_location_name_groups.get(game, {})
+
+        if not game_data_packages and not missing_checksum:
+            # all static -> use the static dicts directly
+            self.gamespackage = static_gamespackage
+            self.item_name_groups = static_item_name_groups
+            self.location_name_groups = static_location_name_groups
+        return self._load(multidata, game_data_packages, True)
 
     @db_session
     def init_save(self, enabled: bool = True):
@@ -101,12 +153,13 @@ class WebHostContext(Context):
             savegame_data = Room.get(id=self.room_id).multisave
             if savegame_data:
                 self.set_save(restricted_loads(Room.get(id=self.room_id).multisave))
-            self._start_async_saving()
+            self._start_async_saving(atexit_save=False)
         threading.Thread(target=self.listen_to_db_commands, daemon=True).start()
 
     @db_session
     def _save(self, exit_save: bool = False) -> bool:
         room = Room.get(id=self.room_id)
+        # Does not use Utils.restricted_dumps because we'd rather make a save than not make one
         room.multisave = pickle.dumps(self.get_save())
         # saving only occurs on activity, so we can "abuse" this information to mark this as last_activity
         if not exit_save:  # we don't want to count a shutdown as activity, which would restart the server again
@@ -127,69 +180,198 @@ def get_random_port():
 def get_static_server_data() -> dict:
     import worlds
     data = {
-        "non_hintable_names": {},
-        "gamespackage": worlds.network_data_package["games"],
-        "item_name_groups": {world_name: world.item_name_groups for world_name, world in
-                             worlds.AutoWorldRegister.world_types.items()},
+        "non_hintable_names": {
+            world_name: world.hint_blacklist
+            for world_name, world in worlds.AutoWorldRegister.world_types.items()
+        },
+        "gamespackage": {
+            world_name: {
+                key: value
+                for key, value in game_package.items()
+                if key not in ("item_name_groups", "location_name_groups")
+            }
+            for world_name, game_package in worlds.network_data_package["games"].items()
+        },
+        "item_name_groups": {
+            world_name: world.item_name_groups
+            for world_name, world in worlds.AutoWorldRegister.world_types.items()
+        },
+        "location_name_groups": {
+            world_name: world.location_name_groups
+            for world_name, world in worlds.AutoWorldRegister.world_types.items()
+        },
     }
 
-    for world_name, world in worlds.AutoWorldRegister.world_types.items():
-        data["non_hintable_names"][world_name] = world.hint_blacklist
-
     return data
 
 
-def run_server_process(room_id, ponyconfig: dict, static_server_data: dict,
-                       cert_file: typing.Optional[str], cert_key_file: typing.Optional[str]):
+def set_up_logging(room_id) -> logging.Logger:
+    import os
+    # logger setup
+    logger = logging.getLogger(f"RoomLogger {room_id}")
+
+    # this *should* be empty, but just in case.
+    for handler in logger.handlers[:]:
+        logger.removeHandler(handler)
+        handler.close()
+
+    file_handler = logging.FileHandler(
+        os.path.join(Utils.user_path("logs"), f"{room_id}.txt"),
+        "a",
+        encoding="utf-8-sig")
+    file_handler.setFormatter(logging.Formatter("[%(asctime)s]: %(message)s"))
+    logger.setLevel(logging.INFO)
+    logger.addHandler(file_handler)
+    return logger
+
+
+def run_server_process(name: str, ponyconfig: dict, static_server_data: dict,
+                       cert_file: typing.Optional[str], cert_key_file: typing.Optional[str],
+                       host: str, rooms_to_run: multiprocessing.Queue, rooms_shutting_down: multiprocessing.Queue):
+    from setproctitle import setproctitle
+
+    setproctitle(name)
+    Utils.init_logging(name)
+    try:
+        import resource
+    except ModuleNotFoundError:
+        pass  # unix only module
+    else:
+        # Each Server is another file handle, so request as many as we can from the system
+        file_limit = resource.getrlimit(resource.RLIMIT_NOFILE)[1]
+        # set soft limit to hard limit
+        resource.setrlimit(resource.RLIMIT_NOFILE, (file_limit, file_limit))
+        del resource, file_limit
+
     # establish DB connection for multidata and multisave
     db.bind(**ponyconfig)
     db.generate_mapping(check_tables=False)
 
-    async def main():
-        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
-        try:
-            ctx.server = websockets.serve(functools.partial(server, ctx=ctx), ctx.host, ctx.port, ping_timeout=None,
-                                          ping_interval=None, ssl=ssl_context)
+    if "worlds" in sys.modules:
+        raise Exception("Worlds system should not be loaded in the custom server.")
 
-            await ctx.server
-        except Exception:  # likely port in use - in windows this is OSError, but I didn't check the others
-            ctx.server = websockets.serve(functools.partial(server, ctx=ctx), ctx.host, 0, ping_timeout=None,
-                                          ping_interval=None, ssl=ssl_context)
+    import gc
 
-            await ctx.server
-        port = 0
-        for wssocket in ctx.server.ws_server.sockets:
-            socketname = wssocket.getsockname()
-            if wssocket.family == socket.AF_INET6:
-                logging.info(f'Hosting game at [{get_public_ipv6()}]:{socketname[1]}')
-                # Prefer IPv4, as most users seem to not have working ipv6 support
-                if not port:
-                    port = socketname[1]
-            elif wssocket.family == socket.AF_INET:
-                logging.info(f'Hosting game at {get_public_ipv4()}:{socketname[1]}')
-                port = socketname[1]
-        if port:
-            with db_session:
-                room = Room.get(id=ctx.room_id)
-                room.last_port = port
-        with db_session:
-            ctx.auto_shutdown = Room.get(id=room_id).timeout
-        ctx.shutdown_task = asyncio.create_task(auto_shutdown(ctx, []))
-        await ctx.shutdown_task
-        logging.info("Shutting down")
+    if not cert_file:
+        def get_ssl_context():
+            return None
+    else:
+        load_date = None
+        ssl_context = load_server_cert(cert_file, cert_key_file)
 
-    from .autolauncher import Locker
-    with Locker(room_id):
-        try:
-            asyncio.run(main())
-        except:
-            with db_session:
-                room = Room.get(id=room_id)
-                room.last_port = -1
-                # 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)
-            raise
+        def get_ssl_context():
+            nonlocal load_date, ssl_context
+            today = datetime.date.today()
+            if load_date != today:
+                ssl_context = load_server_cert(cert_file, cert_key_file)
+                load_date = today
+            return ssl_context
+
+    del ponyconfig
+    gc.collect()  # free intermediate objects used during setup
+
+    loop = asyncio.get_event_loop()
+
+    async def start_room(room_id):
+        with Locker(f"RoomLocker {room_id}"):
+            try:
+                logger = set_up_logging(room_id)
+                ctx = WebHostContext(static_server_data, logger)
+                ctx.load(room_id)
+                ctx.init_save()
+                assert ctx.server is None
+                try:
+                    ctx.server = websockets.serve(
+                        functools.partial(server, ctx=ctx), ctx.host, ctx.port, ssl=get_ssl_context())
+
+                    await ctx.server
+                except OSError:  # likely port in use
+                    ctx.server = websockets.serve(
+                        functools.partial(server, ctx=ctx), ctx.host, 0, ssl=get_ssl_context())
+
+                    await ctx.server
+                port = 0
+                for wssocket in ctx.server.ws_server.sockets:
+                    socketname = wssocket.getsockname()
+                    if wssocket.family == socket.AF_INET6:
+                        # Prefer IPv4, as most users seem to not have working ipv6 support
+                        if not port:
+                            port = socketname[1]
+                    elif wssocket.family == socket.AF_INET:
+                        port = socketname[1]
+                if port:
+                    ctx.logger.info(f'Hosting game at {host}:{port}')
+                    with db_session:
+                        room = Room.get(id=ctx.room_id)
+                        room.last_port = port
+                else:
+                    ctx.logger.exception("Could not determine port. Likely hosting failure.")
+                with db_session:
+                    ctx.auto_shutdown = Room.get(id=room_id).timeout
+                if ctx.saving:
+                    setattr(asyncio.current_task(), "save", lambda: ctx._save(True))
+                assert ctx.shutdown_task is None
+                ctx.shutdown_task = asyncio.create_task(auto_shutdown(ctx, []))
+                await ctx.shutdown_task
+
+            except (KeyboardInterrupt, SystemExit):
+                if ctx.saving:
+                    ctx._save()
+                    setattr(asyncio.current_task(), "save", None)
+            except Exception as e:
+                with db_session:
+                    room = Room.get(id=room_id)
+                    room.last_port = -1
+                logger.exception(e)
+                raise
+            else:
+                if ctx.saving:
+                    ctx._save()
+                    setattr(asyncio.current_task(), "save", None)
+            finally:
+                try:
+                    ctx.save_dirty = False  # make sure the saving thread does not write to DB after final wakeup
+                    ctx.exit_event.set()  # make sure the saving thread stops at some point
+                    # NOTE: async saving should probably be an async task and could be merged with shutdown_task
+                    with (db_session):
+                        # ensure the Room does not spin up again on its own, minute of safety buffer
+                        room = Room.get(id=room_id)
+                        room.last_activity = datetime.datetime.utcnow() - \
+                                             datetime.timedelta(minutes=1, seconds=room.timeout)
+                    logging.info(f"Shutting down room {room_id} on {name}.")
+                finally:
+                    await asyncio.sleep(5)
+                    rooms_shutting_down.put(room_id)
+
+    class Starter(threading.Thread):
+        _tasks: typing.List[asyncio.Future]
+
+        def __init__(self):
+            super().__init__()
+            self._tasks = []
+
+        def _done(self, task: asyncio.Future):
+            self._tasks.remove(task)
+            task.result()
+
+        def run(self):
+            while 1:
+                next_room = rooms_to_run.get(block=True,  timeout=None)
+                gc.collect()
+                task = asyncio.run_coroutine_threadsafe(start_room(next_room), loop)
+                self._tasks.append(task)
+                task.add_done_callback(self._done)
+                logging.info(f"Starting room {next_room} on {name}.")
+                del task  # delete reference to task object
+
+    starter = Starter()
+    starter.daemon = True
+    starter.start()
+    try:
+        loop.run_forever()
+    finally:
+        # save all tasks that want to be saved during shutdown
+        for task in asyncio.all_tasks(loop):
+            save: typing.Optional[typing.Callable[[], typing.Any]] = getattr(task, "save", None)
+            if save:
+                save()

WebHostLib/downloads.py

@@ -26,7 +26,7 @@ def download_patch(room_id, patch_id):
             with zipfile.ZipFile(filelike, "a") as zf:
                 with zf.open("archipelago.json", "r") as f:
                     manifest = json.load(f)
-                manifest["server"] = f"{app.config['PATCH_TARGET']}:{last_port}" if last_port else None
+                manifest["server"] = f"{app.config['HOST_ADDRESS']}:{last_port}" if last_port else None
                 with zipfile.ZipFile(new_file, "w") as new_zip:
                     for file in zf.infolist():
                         if file.filename == "archipelago.json":
@@ -61,12 +61,7 @@ def download_slot_file(room_id, player_id: int):
     else:
         import io
 
-        if slot_data.game == "Minecraft":
-            from worlds.minecraft import mc_update_output
-            fname = f"AP_{app.jinja_env.filters['suuid'](room_id)}_P{slot_data.player_id}_{slot_data.player_name}.apmc"
-            data = mc_update_output(slot_data.data, server=app.config['PATCH_TARGET'], port=room.last_port)
-            return send_file(io.BytesIO(data), as_attachment=True, download_name=fname)
-        elif slot_data.game == "Factorio":
+        if slot_data.game == "Factorio":
             with zipfile.ZipFile(io.BytesIO(slot_data.data)) as zf:
                 for name in zf.namelist():
                     if name.endswith("info.json"):
@@ -88,6 +83,10 @@ 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,45 +1,56 @@
+import concurrent.futures
 import json
 import os
-import pickle
 import random
 import tempfile
 import zipfile
-import concurrent.futures
 from collections import Counter
-from typing import Dict, Optional, Any
+from pickle import PicklingError
+from typing import Any
 
-from flask import request, flash, redirect, url_for, session, render_template
+from flask import flash, redirect, render_template, request, session, url_for
 from pony.orm import commit, db_session
 
-from BaseClasses import seeddigits, get_seed
-from Generate import handle_name, PlandoOptions
+from BaseClasses import get_seed, seeddigits
+from Generate import PlandoOptions, handle_name, mystery_argparse
 from Main import main as ERmain
-from Utils import __version__
+from Utils import __version__, restricted_dumps
 from WebHostLib import app
-from worlds.alttp.EntranceRandomizer import parse_arguments
+from settings import ServerOptions, GeneratorOptions
 from .check import get_yaml_data, roll_options
 from .models import Generation, STATE_ERROR, STATE_QUEUED, Seed, UUID
 from .upload import upload_zip_to_db
 
 
-def get_meta(options_source: dict) -> dict:
-    plando_options = {
-        options_source.get("plando_bosses", ""),
-        options_source.get("plando_items", ""),
-        options_source.get("plando_connections", ""),
-        options_source.get("plando_texts", "")
-    }
-    plando_options -= {""}
+def get_meta(options_source: dict, race: bool = False) -> dict[str, list[str] | dict[str, Any]]:
+    plando_options: set[str] = set()
+    for substr in ("bosses", "items", "connections", "texts"):
+        if options_source.get(f"plando_{substr}", substr in GeneratorOptions.plando_options):
+            plando_options.add(substr)
 
     server_options = {
-        "hint_cost": int(options_source.get("hint_cost", 10)),
-        "release_mode": options_source.get("release_mode", "goal"),
-        "remaining_mode": options_source.get("remaining_mode", "disabled"),
-        "collect_mode": options_source.get("collect_mode", "disabled"),
-        "item_cheat": bool(int(options_source.get("item_cheat", 1))),
-        "server_password": options_source.get("server_password", None),
+        "hint_cost": int(options_source.get("hint_cost", ServerOptions.hint_cost)),
+        "release_mode": str(options_source.get("release_mode", ServerOptions.release_mode)),
+        "remaining_mode": str(options_source.get("remaining_mode", ServerOptions.remaining_mode)),
+        "collect_mode": str(options_source.get("collect_mode", ServerOptions.collect_mode)),
+        "item_cheat": bool(int(options_source.get("item_cheat", not ServerOptions.disable_item_cheat))),
+        "server_password": str(options_source.get("server_password", None)),
+    }
+    generator_options = {
+        "spoiler": int(options_source.get("spoiler", GeneratorOptions.spoiler)),
+        "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'])
@@ -50,54 +61,60 @@ def generate(race=False):
         if 'file' not in request.files:
             flash('No file part')
         else:
-            file = request.files['file']
-            options = get_yaml_data(file)
+            files = request.files.getlist('file')
+            options = get_yaml_data(files)
             if isinstance(options, str):
                 flash(options)
             else:
-                meta = get_meta(request.form)
-                meta["race"] = race
-                results, gen_options = roll_options(options, meta["plando_options"])
-
-                if race:
-                    meta["server_options"]["item_cheat"] = False
-                    meta["server_options"]["remaining_mode"] = "disabled"
-
-                if any(type(result) == str for result in results.values()):
-                    return render_template("checkResult.html", results=results)
-                elif len(gen_options) > app.config["MAX_ROLL"]:
-                    flash(f"Sorry, generating of multiworlds is limited to {app.config['MAX_ROLL']} players. "
-                          f"If you have a larger group, please generate it yourself and upload it.")
-                elif len(gen_options) >= app.config["JOB_THRESHOLD"]:
-                    gen = Generation(
-                        options=pickle.dumps({name: vars(options) for name, options in gen_options.items()}),
-                        # convert to json compatible
-                        meta=json.dumps(meta),
-                        state=STATE_QUEUED,
-                        owner=session["_id"])
-                    commit()
-
-                    return redirect(url_for("wait_seed", seed=gen.id))
-                else:
-                    try:
-                        seed_id = gen_game({name: vars(options) for name, options in gen_options.items()},
-                                           meta=meta, owner=session["_id"].int)
-                    except BaseException as e:
-                        from .autolauncher import handle_generation_failure
-                        handle_generation_failure(e)
-                        return render_template("seedError.html", seed_error=(e.__class__.__name__ + ": " + str(e)))
-
-                    return redirect(url_for("view_seed", seed=seed_id))
+                meta = get_meta(request.form, race)
+                return start_generation(options, meta)
 
     return render_template("generate.html", race=race, version=__version__)
 
 
-def gen_game(gen_options: dict, meta: Optional[Dict[str, Any]] = None, owner=None, sid=None):
-    if not meta:
-        meta: Dict[str, Any] = {}
+def start_generation(options: dict[str, dict | str], meta: dict[str, Any]):
+    results, gen_options = roll_options(options, set(meta["plando_options"]))
+
+    if any(type(result) == str for result in results.values()):
+        return render_template("checkResult.html", results=results)
+    elif len(gen_options) > app.config["MAX_ROLL"]:
+        flash(f"Sorry, generating of multiworlds is limited to {app.config['MAX_ROLL']} players. "
+              f"If you have a larger group, please generate it yourself and upload it.")
+        return redirect(url_for(request.endpoint, **(request.view_args or {})))
+    elif len(gen_options) >= app.config["JOB_THRESHOLD"]:
+        try:
+            gen = Generation(
+                options=restricted_dumps({name: vars(options) for name, options in gen_options.items()}),
+                # convert to json compatible
+                meta=json.dumps(meta),
+                state=STATE_QUEUED,
+                owner=session["_id"])
+        except PicklingError as e:
+            from .autolauncher import handle_generation_failure
+            handle_generation_failure(e)
+            return render_template("seedError.html", seed_error=("PicklingError: " + str(e)))
+
+        commit()
+
+        return redirect(url_for("wait_seed", seed=gen.id))
+    else:
+        try:
+            seed_id = gen_game({name: vars(options) for name, options in gen_options.items()},
+                               meta=meta, owner=session["_id"].int)
+        except BaseException as e:
+            from .autolauncher import handle_generation_failure
+            handle_generation_failure(e)
+            return render_template("seedError.html", seed_error=(e.__class__.__name__ + ": " + str(e)))
+
+        return redirect(url_for("view_seed", seed=seed_id))
+
+
+def gen_game(gen_options: dict, meta: dict[str, Any] | None = None, owner=None, sid=None):
+    if meta is None:
+        meta = {}
 
     meta.setdefault("server_options", {}).setdefault("hint_cost", 10)
-    race = meta.setdefault("race", False)
+    race = meta.setdefault("generator_options", {}).setdefault("race", False)
 
     def task():
         target = tempfile.TemporaryDirectory()
@@ -111,32 +128,39 @@ def gen_game(gen_options: dict, meta: Optional[Dict[str, Any]] = None, owner=Non
 
         seedname = "W" + (f"{random.randint(0, pow(10, seeddigits) - 1)}".zfill(seeddigits))
 
-        erargs = parse_arguments(['--multi', str(playercount)])
-        erargs.seed = seed
-        erargs.name = {x: "" for x in range(1, playercount + 1)}  # only so it can be overwritten in mystery
-        erargs.spoiler = 0 if race else 3
-        erargs.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"}))
+        args = mystery_argparse()
+        args.multi = playercount
+        args.seed = seed
+        args.name = {x: "" for x in range(1, playercount + 1)}  # only so it can be overwritten in mystery
+        args.spoiler = meta["generator_options"].get("spoiler", 0)
+        args.race = race
+        args.outputname = seedname
+        args.outputpath = target.name
+        args.teams = 1
+        args.plando_options = PlandoOptions.from_set(meta.setdefault("plando_options",
+                                                                     {"bosses", "items", "connections", "texts"}))
+        args.skip_prog_balancing = False
+        args.skip_output = False
+        args.spoiler_only = False
+        args.csv_output = False
+        args.sprite = dict.fromkeys(range(1, args.multi+1), None)
+        args.sprite_pool = dict.fromkeys(range(1, args.multi+1), None)
 
         name_counter = Counter()
         for player, (playerfile, settings) in enumerate(gen_options.items(), 1):
             for k, v in settings.items():
                 if v is not None:
-                    if hasattr(erargs, k):
-                        getattr(erargs, k)[player] = v
+                    if hasattr(args, k):
+                        getattr(args, k)[player] = v
                     else:
-                        setattr(erargs, k, {player: v})
+                        setattr(args, k, {player: v})
 
-            if not erargs.name[player]:
-                erargs.name[player] = os.path.splitext(os.path.split(playerfile)[-1])[0]
-            erargs.name[player] = handle_name(erargs.name[player], player, name_counter)
-        if len(set(erargs.name.values())) != len(erargs.name):
-            raise Exception(f"Names have to be unique. Names: {Counter(erargs.name.values())}")
-        ERmain(erargs, seed, baked_server_options=meta["server_options"])
+            if not args.name[player]:
+                args.name[player] = os.path.splitext(os.path.split(playerfile)[-1])[0]
+            args.name[player] = handle_name(args.name[player], player, name_counter)
+        if len(set(args.name.values())) != len(args.name):
+            raise Exception(f"Names have to be unique. Names: {Counter(args.name.values())}")
+        ERmain(args, seed, baked_server_options=meta["server_options"])
 
         return upload_to_db(target.name, sid, owner, race)
     thread_pool = concurrent.futures.ThreadPoolExecutor(max_workers=1)

WebHostLib/locker.py

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

WebHostLib/lttpsprites.py

@@ -3,10 +3,10 @@ import threading
 import json
 
 from Utils import local_path, user_path
-from worlds.alttp.Rom import Sprite
 
 
 def update_sprites_lttp():
+    from worlds.alttp.Rom import Sprite
     from tkinter import Tk
     from LttPAdjuster import get_image_for_sprite
     from LttPAdjuster import BackgroundTaskProgress
@@ -14,7 +14,7 @@ def update_sprites_lttp():
     from LttPAdjuster import update_sprites
 
     # Target directories
-    input_dir = user_path("data", "sprites", "alttpr")
+    input_dir = user_path("data", "sprites", "alttp", "remote")
     output_dir = local_path("WebHostLib", "static", "generated")  # TODO: move to user_path
 
     os.makedirs(os.path.join(output_dir, "sprites"), exist_ok=True)

WebHostLib/misc.py

@@ -1,26 +1,73 @@
 import datetime
 import os
+from typing import Any, IO, Dict, Iterator, List, Tuple, Union
 
 import jinja2.exceptions
 from flask import request, redirect, url_for, render_template, Response, session, abort, send_from_directory
 from pony.orm import count, commit, db_session
+from werkzeug.utils import secure_filename
 
-from worlds.AutoWorld import AutoWorldRegister
+from worlds.AutoWorld import AutoWorldRegister, World
 from . import app, cache
 from .models import Seed, Room, Command, UUID, uuid4
+from Utils import title_sorted
 
 
-def get_world_theme(game_name: str):
+def get_world_theme(game_name: str) -> str:
     if game_name in AutoWorldRegister.world_types:
         return AutoWorldRegister.world_types[game_name].web.theme
     return 'grass'
 
 
-@app.before_request
-def register_session():
-    session.permanent = True  # technically 31 days after the last visit
-    if not session.get("_id", None):
-        session["_id"] = uuid4()  # uniquely identify each session without needing a login
+def get_visible_worlds() -> dict[str, type(World)]:
+    worlds = {}
+    for game, world in AutoWorldRegister.world_types.items():
+        if not world.hidden:
+            worlds[game] = world
+    return worlds
+
+
+def render_markdown(path: str) -> str:
+    import mistune
+    from collections import Counter
+
+    markdown = mistune.create_markdown(
+        escape=False,
+        plugins=[
+            "strikethrough",
+            "footnotes",
+            "table",
+            "speedup",
+        ],
+    )
+
+    heading_id_count: Counter[str] = Counter()
+
+    def heading_id(text: str) -> str:
+        nonlocal heading_id_count
+        import re  # there is no good way to do this without regex
+
+        s = re.sub(r"[^\w\- ]", "", text.lower()).replace(" ", "-").strip("-")
+        n = heading_id_count[s]
+        heading_id_count[s] += 1
+        if n > 0:
+            s += f"-{n}"
+        return s
+
+    def id_hook(_: mistune.Markdown, state: mistune.BlockState) -> None:
+        for tok in state.tokens:
+            if tok["type"] == "heading" and tok["attrs"]["level"] < 4:
+                text = tok["text"]
+                assert isinstance(text, str)
+                unique_id = heading_id(text)
+                tok["attrs"]["id"] = unique_id
+                tok["text"] = f"<a href=\"#{unique_id}\">{text}</a>"  # make header link to itself
+
+    markdown.before_render_hooks.append(id_hook)
+
+    with open(path, encoding="utf-8-sig") as f:
+        document = f.read()
+    return markdown(document)
 
 
 @app.errorhandler(404)
@@ -31,55 +78,109 @@ def page_not_found(err):
 
 # Start Playing Page
 @app.route('/start-playing')
+@cache.cached()
 def start_playing():
     return render_template(f"startPlaying.html")
 
 
-@app.route('/weighted-settings')
-def weighted_settings():
-    return render_template(f"weighted-settings.html")
-
-
-# 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))
+    """Game Info Pages"""
+    try:
+        theme = get_world_theme(game)
+        secure_game_name = secure_filename(game)
+        lang = secure_filename(lang)
+        document = render_markdown(os.path.join(
+            app.static_folder, "generated", "docs",
+            secure_game_name, f"{lang}_{secure_game_name}.md"
+        ))
+        return render_template(
+            "markdown_document.html",
+            title=f"{game} Guide",
+            html_from_markdown=document,
+            theme=theme,
+        )
+    except FileNotFoundError:
+        return abort(404)
 
 
-# List of supported games
 @app.route('/games')
+@cache.cached()
 def games():
-    worlds = {}
-    for game, world in AutoWorldRegister.world_types.items():
-        if not world.hidden:
-            worlds[game] = world
-    return render_template("supportedGames.html", worlds=worlds)
+    """List of supported games"""
+    return render_template("supportedGames.html", worlds=get_visible_worlds())
+
+
+@app.route('/tutorial/<string:game>/<string:file>')
+@cache.cached()
+def tutorial(game: str, file: str):
+    try:
+        theme = get_world_theme(game)
+        secure_game_name = secure_filename(game)
+        file = secure_filename(file)
+        document = render_markdown(os.path.join(
+            app.static_folder, "generated", "docs",
+            secure_game_name, file+".md"
+        ))
+        return render_template(
+            "markdown_document.html",
+            title=f"{game} Guide",
+            html_from_markdown=document,
+            theme=theme,
+        )
+    except FileNotFoundError:
+        return abort(404)
 
 
 @app.route('/tutorial/<string:game>/<string:file>/<string:lang>')
-def tutorial(game, file, lang):
-    return render_template("tutorial.html", game=game, file=file, lang=lang, theme=get_world_theme(game))
+def tutorial_redirect(game: str, file: str, lang: str):
+    """
+    Permanent redirect old tutorial URLs to new ones to keep search engines happy.
+    e.g. /tutorial/Archipelago/setup/en -> /tutorial/Archipelago/setup_en
+    """
+    return redirect(url_for("tutorial", game=game, file=f"{file}_{lang}"), code=301)
 
 
 @app.route('/tutorial/')
+@cache.cached()
 def tutorial_landing():
-    return render_template("tutorialLanding.html")
+    tutorials = {}
+    worlds = AutoWorldRegister.world_types
+    for world_name, world_type in worlds.items():
+        current_world = tutorials[world_name] = {}
+        for tutorial in world_type.web.tutorials:
+            current_tutorial = current_world.setdefault(tutorial.tutorial_name, {
+                "description": tutorial.description, "files": {}})
+            current_tutorial["files"][secure_filename(tutorial.file_name).rsplit(".", 1)[0]] = {
+                "authors": tutorial.authors,
+                "language": tutorial.language
+            }
+    tutorials = {world_name: tutorials for world_name, tutorials in title_sorted(
+        tutorials.items(), key=lambda element: "\x00" if element[0] == "Archipelago" else worlds[element[0]].game)}
+    return render_template("tutorialLanding.html", worlds=worlds, tutorials=tutorials)
 
 
 @app.route('/faq/<string:lang>/')
-def faq(lang):
-    return render_template("faq.html", lang=lang)
+@cache.cached()
+def faq(lang: str):
+    document = render_markdown(os.path.join(app.static_folder, "assets", "faq", secure_filename(lang)+".md"))
+    return render_template(
+        "markdown_document.html",
+        title="Frequently Asked Questions",
+        html_from_markdown=document,
+    )
 
 
 @app.route('/glossary/<string:lang>/')
-def terms(lang):
-    return render_template("glossary.html", lang=lang)
+@cache.cached()
+def glossary(lang: str):
+    document = render_markdown(os.path.join(app.static_folder, "assets", "glossary", secure_filename(lang)+".md"))
+    return render_template(
+        "markdown_document.html",
+        title="Glossary",
+        html_from_markdown=document,
+    )
 
 
 @app.route('/seed/<suuid:seed>')
@@ -100,49 +201,96 @@ def new_room(seed: UUID):
     return redirect(url_for("host_room", room=room.id))
 
 
-def _read_log(path: str):
-    if os.path.exists(path):
-        with open(path, encoding="utf-8-sig") as log:
-            yield from log
-    else:
-        yield f"Logfile {path} does not exist. " \
-              f"Likely a crash during spinup of multiworld instance or it is still spinning up."
+def _read_log(log: IO[Any], offset: int = 0) -> Iterator[bytes]:
+    marker = log.read(3)  # skip optional BOM
+    if marker != b'\xEF\xBB\xBF':
+        log.seek(0, os.SEEK_SET)
+    log.seek(offset, os.SEEK_CUR)
+    yield from log
+    log.close()  # free file handle as soon as possible
 
 
 @app.route('/log/<suuid:room>')
-def display_log(room: UUID):
+def display_log(room: UUID) -> Union[str, Response, Tuple[str, int]]:
     room = Room.get(id=room)
     if room is None:
         return abort(404)
     if room.owner == session["_id"]:
-        return Response(_read_log(os.path.join("logs", str(room.id) + ".txt")), mimetype="text/plain;charset=UTF-8")
+        file_path = os.path.join("logs", str(room.id) + ".txt")
+        try:
+            log = open(file_path, "rb")
+            range_header = request.headers.get("Range")
+            if range_header:
+                range_type, range_values = range_header.split('=')
+                start, end = map(str.strip, range_values.split('-', 1))
+                if range_type != "bytes" or end != "":
+                    return "Unsupported range", 500
+                # NOTE: we skip Content-Range in the response here, which isn't great but works for our JS
+                return Response(_read_log(log, int(start)), mimetype="text/plain", status=206)
+            return Response(_read_log(log), mimetype="text/plain")
+        except FileNotFoundError:
+            return Response(f"Logfile {file_path} does not exist. "
+                            f"Likely a crash during spinup of multiworld instance or it is still spinning up.",
+                            mimetype="text/plain")
+
     return "Access Denied", 403
 
 
-@app.route('/room/<suuid:room>', methods=['GET', 'POST'])
+@app.post("/room/<suuid:room>")
+def host_room_command(room: UUID):
+    room: Room = Room.get(id=room)
+    if room is None:
+        return abort(404)
+
+    if room.owner == session["_id"]:
+        cmd = request.form["cmd"]
+        if cmd:
+            Command(room=room, commandtext=cmd)
+            commit()
+    return redirect(url_for("host_room", room=room.id))
+
+
+@app.get("/room/<suuid:room>")
 def host_room(room: UUID):
     room: Room = Room.get(id=room)
     if room is None:
         return abort(404)
-    if request.method == "POST":
-        if room.owner == session["_id"]:
-            cmd = request.form["cmd"]
-            if cmd:
-                Command(room=room, commandtext=cmd)
-                commit()
 
     now = datetime.datetime.utcnow()
     # indicate that the page should reload to get the assigned port
-    should_refresh = not room.last_port and now - room.creation_time < datetime.timedelta(seconds=3)
+    should_refresh = ((not room.last_port and now - room.creation_time < datetime.timedelta(seconds=3))
+                      or room.last_activity < now - datetime.timedelta(seconds=room.timeout))
     with db_session:
         room.last_activity = now  # will trigger a spinup, if it's not already running
 
-    return render_template("hostRoom.html", room=room, should_refresh=should_refresh)
+    browser_tokens = "Mozilla", "Chrome", "Safari"
+    automated = ("update" in request.args
+                 or "Discordbot" in request.user_agent.string
+                 or not any(browser_token in request.user_agent.string for browser_token in browser_tokens))
+
+    def get_log(max_size: int = 0 if automated else 1024000) -> str:
+        if max_size == 0:
+            return "…"
+        try:
+            with open(os.path.join("logs", str(room.id) + ".txt"), "rb") as log:
+                raw_size = 0
+                fragments: List[str] = []
+                for block in _read_log(log):
+                    if raw_size + len(block) > max_size:
+                        fragments.append("…")
+                        break
+                    raw_size += len(block)
+                    fragments.append(block.decode("utf-8"))
+                return "".join(fragments)
+        except FileNotFoundError:
+            return ""
+
+    return render_template("hostRoom.html", room=room, should_refresh=should_refresh, get_log=get_log)
 
 
 @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')
 
 
@@ -162,9 +310,11 @@ def get_datapackage():
 
 @app.route('/index')
 @app.route('/sitemap')
+@cache.cached()
 def get_sitemap():
-    available_games = []
+    available_games: List[Dict[str, Union[str, bool]]] = []
     for game, world in AutoWorldRegister.world_types.items():
         if not world.hidden:
-            available_games.append(game)
+            has_settings: bool = isinstance(world.web.options_page, bool) and world.web.options_page
+            available_games.append({ 'title': game, 'has_settings': has_settings })
     return render_template("siteMap.html", games=available_games)

WebHostLib/models.py

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

@@ -1,170 +1,292 @@
+import collections.abc
 import json
-import logging
 import os
-import typing
+from textwrap import dedent
+from typing import Dict, Union
+from docutils.core import publish_parts
 
 import yaml
-from jinja2 import Template
+from flask import redirect, render_template, request, Response, abort
 
 import Options
-from Utils import __version__, local_path
+from Utils import local_path
 from worlds.AutoWorld import AutoWorldRegister
-
-handled_in_js = {"start_inventory", "local_items", "non_local_items", "start_hints", "start_location_hints",
-                 "exclude_locations"}
+from . import app, cache
+from .generate import get_meta
 
 
-def create():
+def create() -> None:
     target_folder = local_path("WebHostLib", "static", "generated")
     yaml_folder = os.path.join(target_folder, "configs")
-    os.makedirs(yaml_folder, exist_ok=True)
 
-    for file in os.listdir(yaml_folder):
-        full_path: str = os.path.join(yaml_folder, file)
-        if os.path.isfile(full_path):
-            os.unlink(full_path)
+    Options.generate_yaml_templates(yaml_folder)
 
-    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]
+def get_world_theme(game_name: str) -> str:
+    if game_name in AutoWorldRegister.world_types:
+        return AutoWorldRegister.world_types[game_name].web.theme
+    return 'grass'
+
+
+def render_options_page(template: str, world_name: str, is_complex: bool = False) -> Union[Response, str]:
+    world = AutoWorldRegister.world_types[world_name]
+    if world.hidden or world.web.options_page is False:
+        return redirect("games")
+    visibility_flag = Options.Visibility.complex_ui if is_complex else Options.Visibility.simple_ui
+
+    start_collapsed = {"Game Options": False}
+    for group in world.web.option_groups:
+        start_collapsed[group.name] = group.start_collapsed
+
+    return render_template(
+        template,
+        world_name=world_name,
+        world=world,
+        option_groups=Options.get_option_groups(world, visibility_level=visibility_flag),
+        start_collapsed=start_collapsed,
+        issubclass=issubclass,
+        Options=Options,
+        theme=get_world_theme(world_name),
+    )
+
+
+def generate_game(options: Dict[str, Union[dict, str]]) -> Union[Response, str]:
+    from .generate import start_generation
+    return start_generation(options, get_meta({}))
+
+
+def send_yaml(player_name: str, formatted_options: dict) -> Response:
+    response = Response(yaml.dump(formatted_options, sort_keys=False))
+    response.headers["Content-Type"] = "text/yaml"
+    response.headers["Content-Disposition"] = f"attachment; filename={player_name}.yaml"
+    return response
+
+
+@app.template_filter("dedent")
+def filter_dedent(text: str) -> str:
+    return dedent(text).strip("\n ")
+
+
+@app.template_filter("rst_to_html")
+def filter_rst_to_html(text: str) -> str:
+    """Converts reStructuredText (such as a Python docstring) to HTML."""
+    if text.startswith(" ") or text.startswith("\t"):
+        text = dedent(text)
+    elif "\n" in text:
+        lines = text.splitlines()
+        text = lines[0] + "\n" + dedent("\n".join(lines[1:]))
+
+    return publish_parts(text, writer_name='html', settings=None, settings_overrides={
+        'raw_enable': False,
+        'file_insertion_enabled': False,
+        'output_encoding': 'unicode'
+    })['body']
+
+
+@app.template_test("ordered")
+def test_ordered(obj):
+    return isinstance(obj, collections.abc.Sequence)
+
+
+@app.route("/games/<string:game>/option-presets", methods=["GET"])
+@cache.cached()
+def option_presets(game: str) -> Response:
+    world = AutoWorldRegister.world_types[game]
+
+    presets = {}
+    for preset_name, preset in world.web.options_presets.items():
+        presets[preset_name] = {}
+        for preset_option_name, preset_option in preset.items():
+            if preset_option == "random":
+                presets[preset_name][preset_option_name] = preset_option
+                continue
+
+            option = world.options_dataclass.type_hints[preset_option_name].from_any(preset_option)
+            if isinstance(option, Options.NamedRange) and isinstance(preset_option, str):
+                assert preset_option in option.special_range_names, \
+                    f"Invalid preset value '{preset_option}' for '{preset_option_name}' in '{preset_name}'. " \
+                    f"Expected {option.special_range_names.keys()} or {option.range_start}-{option.range_end}."
+
+                presets[preset_name][preset_option_name] = option.value
+            elif isinstance(option, (Options.Range, Options.OptionSet, Options.OptionList, Options.OptionCounter)):
+                presets[preset_name][preset_option_name] = option.value
+            elif isinstance(preset_option, str):
+                # Ensure the option value is valid for Choice and Toggle options
+                assert option.name_lookup[option.value] == preset_option, \
+                    f"Invalid option value '{preset_option}' for '{preset_option_name}' in preset '{preset_name}'. " \
+                    f"Values must not be resolved to a different option via option.from_text (or an alias)."
+                # Use the name of the option
+                presets[preset_name][preset_option_name] = option.current_key
             else:
-                data[name] = 0
+                # Use the name of the option
+                presets[preset_name][preset_option_name] = option.current_key
 
-        return data, notes
+    class SetEncoder(json.JSONEncoder):
+        def default(self, obj):
+            from collections.abc import Set
+            if isinstance(obj, Set):
+                return list(obj)
+            return json.JSONEncoder.default(self, obj)
 
-    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()
+    json_data = json.dumps(presets, cls=SetEncoder)
+    response = Response(json_data)
+    response.headers["Content-Type"] = "application/json"
+    return response
 
-    weighted_settings = {
-        "baseOptions": {
-            "description": "Generated by https://archipelago.gg/",
-            "name": "Player",
-            "game": {},
-        },
-        "games": {},
-    }
 
-    for game_name, world in AutoWorldRegister.world_types.items():
+@app.route("/weighted-options")
+def weighted_options_old():
+    return redirect("games", 301)
 
-        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,
-        )
 
-        del file_data
+@app.route("/games/<string:game>/weighted-options")
+@cache.cached()
+def weighted_options(game: str):
+    try:
+        return render_options_page("weightedOptions/weightedOptions.html", game, is_complex=True)
+    except KeyError:
+        return abort(404)
 
-        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": "Generated by https://archipelago.gg/",
-                "game": game_name,
-                "name": "Player",
-            },
+@app.route("/games/<string:game>/generate-weighted-yaml", methods=["POST"])
+def generate_weighted_yaml(game: str):
+    if request.method == "POST":
+        intent_generate = False
+        options = {}
+
+        for key, val in request.form.items():
+            if val == "_ensure-empty-list":
+                options[key] = {}
+            elif "||" not in key:
+                if len(str(val)) == 0:
+                    continue
+
+                options[key] = val
+            else:
+                if int(val) == 0:
+                    continue
+
+                [option, setting] = key.split("||")
+                options.setdefault(option, {})[setting] = int(val)
+
+        # Error checking
+        if "name" not in options:
+            return "Player name is required."
+
+        # Remove POST data irrelevant to YAML
+        if "intent-generate" in options:
+            intent_generate = True
+            del options["intent-generate"]
+        if "intent-export" in options:
+            del options["intent-export"]
+
+        # Properly format YAML output
+        player_name = options["name"]
+        del options["name"]
+
+        formatted_options = {
+            "name": player_name,
+            "game": game,
+            "description": f"Generated by https://archipelago.gg/ for {game}",
+            game: options,
         }
 
-        game_options = {}
-        for option_name, option in all_options.items():
-            if option_name in handled_in_js:
-                pass
+        if intent_generate:
+            return generate_game({player_name: formatted_options})
 
-            elif option.options:
-                game_options[option_name] = this_option = {
-                    "type": "select",
-                    "displayName": option.display_name if hasattr(option, "display_name") else option_name,
-                    "description": get_html_doc(option),
-                    "defaultValue": None,
-                    "options": []
-                }
+        else:
+            return send_yaml(player_name, formatted_options)
 
-                for sub_option_id, sub_option_name in option.name_lookup.items():
-                    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
+# Player options pages
+@app.route("/games/<string:game>/player-options")
+@cache.cached()
+def player_options(game: str):
+    try:
+        return render_options_page("playerOptions/playerOptions.html", game, is_complex=False)
+    except KeyError:
+        return abort(404)
 
-                if option.default == "random":
-                    this_option["defaultValue"] = "random"
 
-            elif issubclass(option, Options.Range):
-                game_options[option_name] = {
-                    "type": "range",
-                    "displayName": option.display_name if hasattr(option, "display_name") else option_name,
-                    "description": get_html_doc(option),
-                    "defaultValue": option.default if hasattr(
-                        option, "default") and option.default != "random" else option.range_start,
-                    "min": option.range_start,
-                    "max": option.range_end,
-                }
-
-                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 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),
-                }
-
-            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),
-                }
-
-            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),
-                    }
+# YAML generator for player-options
+@app.route("/games/<string:game>/generate-yaml", methods=["POST"])
+def generate_yaml(game: str):
+    if request.method == "POST":
+        options = {}
+        intent_generate = False
 
+        for key, val in request.form.items(multi=True):
+            if val == "_ensure-empty-list":
+                options[key] = []
+            elif options.get(key):
+                if not isinstance(options[key], list):
+                    options[key] = [options[key]]
+                options[key].append(val)
             else:
-                logging.debug(f"{option} not exported to Web Settings.")
+                options[key] = val
 
-        player_settings["gameOptions"] = game_options
+        for key, val in options.copy().items():
+            key_parts = key.rsplit("||", 2)
+            # Detect and build OptionCounter options from their name pattern
+            if key_parts[-1] == "qty":
+                if key_parts[0] not in options:
+                    options[key_parts[0]] = {}
+                if val != "0":
+                    options[key_parts[0]][key_parts[1]] = int(val)
+                del options[key]
 
-        os.makedirs(os.path.join(target_folder, 'player-settings'), exist_ok=True)
+            # Detect keys which end with -custom, indicating a TextChoice with a possible custom value
+            elif key_parts[-1].endswith("-custom"):
+                if val:
+                    options[key_parts[-1][:-7]] = val
 
-        with open(os.path.join(target_folder, 'player-settings', game_name + ".json"), "w") as f:
-            json.dump(player_settings, f, indent=2, separators=(',', ': '))
+                del options[key]
 
-        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)
+            # Detect keys which end with -range, indicating a NamedRange with a possible custom value
+            elif key_parts[-1].endswith("-range"):
+                if options[key_parts[-1][:-6]] == "custom":
+                    options[key_parts[-1][:-6]] = val
 
-    with open(os.path.join(target_folder, 'weighted-settings.json'), "w") as f:
-        json.dump(weighted_settings, f, indent=2, separators=(',', ': '))
+                del options[key]
+
+        # Detect random-* keys and set their options accordingly
+        for key, val in options.copy().items():
+            if key.startswith("random-"):
+                options[key.removeprefix("random-")] = "random"
+                del options[key]
+
+        # Error checking
+        if not options["name"]:
+            return "Player name is required."
+
+        # Remove POST data irrelevant to YAML
+        preset_name = 'default'
+        if "intent-generate" in options:
+            intent_generate = True
+            del options["intent-generate"]
+        if "intent-export" in options:
+            del options["intent-export"]
+        if "game-options-preset" in options:
+            preset_name = options["game-options-preset"]
+            del options["game-options-preset"]
+
+        # Properly format YAML output
+        player_name = options["name"]
+        del options["name"]
+
+        description = f"Generated by https://archipelago.gg/ for {game}"
+        if preset_name != 'default' and preset_name != 'custom':
+            description += f" using {preset_name} preset"
+
+        formatted_options = {
+            "name": player_name,
+            "game": game,
+            "description": description,
+            game: options,
+        }
+
+        if intent_generate:
+            return generate_game({player_name: formatted_options})
+
+        else:
+            return send_yaml(player_name, formatted_options)

WebHostLib/requirements.txt

@@ -1,7 +1,12 @@
-flask>=2.2.2
-pony>=0.7.16
-waitress>=2.1.2
-Flask-Caching>=2.0.1
-Flask-Compress>=1.13
-Flask-Limiter>=2.8.1
-bokeh>=3.0.2
+flask>=3.1.1
+werkzeug>=3.1.3
+pony>=0.7.19; python_version <= '3.12'
+pony @ git+https://github.com/black-sliver/pony@7feb1221953b7fa4a6735466bf21a8b4d35e33ba#0.7.19; python_version >= '3.13'
+waitress>=3.0.2
+Flask-Caching>=2.3.0
+Flask-Compress>=1.17
+Flask-Limiter>=3.12
+bokeh>=3.6.3
+markupsafe>=3.0.2
+setproctitle>=1.3.5
+mistune>=3.1.3

WebHostLib/robots.py

@@ -0,0 +1,15 @@
+from WebHostLib import app
+from flask import abort
+from . import cache
+
+
+@cache.cached()
+@app.route('/robots.txt')
+def robots():
+    # If this host is not official, do not allow search engine crawling
+    if not app.config["ASSET_RIGHTS"]:
+        # filename changed in case the path is intercepted and served by an outside service
+        return app.send_static_file('robots_file.txt')
+
+    # Send 404 if the host has affirmed this to be the official WebHost
+    abort(404)

WebHostLib/session.py

@@ -0,0 +1,31 @@
+from uuid import uuid4, UUID
+
+from flask import session, render_template
+
+from WebHostLib import app
+
+
+@app.before_request
+def register_session():
+    session.permanent = True  # technically 31 days after the last visit
+    if not session.get("_id", None):
+        session["_id"] = uuid4()  # uniquely identify each session without needing a login
+
+
+@app.route('/session')
+def show_session():
+    return render_template(
+        "session.html",
+    )
+
+
+@app.route('/session/<string:_id>')
+def set_session(_id: str):
+    new_id: UUID = UUID(_id, version=4)
+    old_id: UUID = session["_id"]
+    if old_id != new_id:
+        session["_id"] = new_id
+    return render_template(
+        "session.html",
+        old_id=old_id,
+    )

WebHostLib/static/assets/baseHeader.js

@@ -0,0 +1,40 @@
+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';
+    }
+
+    mobileMenu.style.display = 'none';
+  });
+
+  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/checksfinderTracker.js

@@ -1,5 +1,5 @@
 window.addEventListener('load', () => {
-  // Reload tracker every 15 seconds
+  // Reload tracker every 60 seconds
   const url = window.location;
   setInterval(() => {
     const ajax = new XMLHttpRequest();
@@ -21,7 +21,7 @@ window.addEventListener('load', () => {
     };
     ajax.open('GET', url);
     ajax.send();
-  }, 15000)
+}, 60000)
 
   // Collapsible advancement sections
   const categories = document.getElementsByClassName("location-category");

WebHostLib/static/assets/faq.js

@@ -1,51 +0,0 @@
-window.addEventListener('load', () => {
-    const tutorialWrapper = document.getElementById('faq-wrapper');
-    new Promise((resolve, reject) => {
-        const ajax = new XMLHttpRequest();
-        ajax.onreadystatechange = () => {
-            if (ajax.readyState !== 4) { return; }
-            if (ajax.status === 404) {
-                reject("Sorry, the tutorial is not available in that language yet.");
-                return;
-            }
-            if (ajax.status !== 200) {
-                reject("Something went wrong while loading the tutorial.");
-                return;
-            }
-            resolve(ajax.responseText);
-        };
-        ajax.open('GET', `${window.location.origin}/static/assets/faq/` +
-          `faq_${tutorialWrapper.getAttribute('data-lang')}.md`, true);
-        ajax.send();
-    }).then((results) => {
-        // Populate page with HTML generated from markdown
-        showdown.setOption('tables', true);
-        showdown.setOption('strikethrough', true);
-        showdown.setOption('literalMidWordUnderscores', true);
-        tutorialWrapper.innerHTML += (new showdown.Converter()).makeHtml(results);
-        adjustHeaderWidth();
-
-        // Reset the id of all header divs to something nicer
-        for (const header of document.querySelectorAll('h1, h2, h3, h4, h5, h6')) {
-            const headerId = header.innerText.replace(/\s+/g, '-').toLowerCase();
-            header.setAttribute('id', headerId);
-            header.addEventListener('click', () => {
-                window.location.hash = `#${headerId}`;
-                header.scrollIntoView();
-            });
-        }
-
-        // Manually scroll the user to the appropriate header if anchor navigation is used
-        document.fonts.ready.finally(() => {
-            if (window.location.hash) {
-                const scrollTarget = document.getElementById(window.location.hash.substring(1));
-                scrollTarget?.scrollIntoView();
-            }
-        });
-    }).catch((error) => {
-        console.error(error);
-        tutorialWrapper.innerHTML =
-            `<h2>This page is out of logic!</h2>
-            <h3>Click <a href="${window.location.origin}">here</a> to return to safety.</h3>`;
-    });
-});

WebHostLib/static/assets/faq/en.md

@@ -0,0 +1,80 @@
+# Frequently Asked Questions
+
+## 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
+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 multiworlds.
+Here is a list of our [Supported Games](https://archipelago.gg/games).
+
+## Can I generate a single-player game with Archipelago?
+
+Yes. All of our supported games can be generated as single-player experiences both on the website and by installing 
+the Archipelago generator software. The fastest way to do this is on the website. Find the Supported Game you wish to
+play, open the Settings Page, pick your settings, and click Generate Game.
+
+## How do I get started?
+
+We have a [Getting Started](https://archipelago.gg/tutorial/Archipelago/setup/en) guide that will help you get the
+software set up. You can use that guide to learn how to generate multiworlds. There are also basic instructions for
+including multiple games, and hosting multiworlds on the website for ease and convenience.
+
+If you are ready to start randomizing games, or want to start playing your favorite randomizer with others, please join
+our discord server at the [Archipelago Discord](https://discord.gg/8Z65BR2). There are always people ready to answer
+any questions you might have.
+
+## What are some common terms I should know?
+
+As randomizers and multiworld randomizers have been around for a while now, there are quite a few common terms used
+by the communities surrounding them. A list of Archipelago jargon and terms commonly used by the community can be
+found in the [Glossary](/glossary/en).
+
+## Does everyone need to be connected at the same time?
+
+There are two different play-styles that are common for Archipelago multiworld sessions. These sessions can either
+be considered synchronous (or "sync"), where everyone connects and plays at the same time, or asynchronous (or "async"),
+where players connect and play at their own pace. The setup for both is identical. The difference in play-style is how
+you and your friends choose to organize and play your multiworld. Most groups decide on the format before creating
+their multiworld.
+
+If a player must leave early, they can use Archipelago's release system. When a player releases their game, all items
+in that game belonging to other players are sent out automatically. This allows other players to continue to play
+uninterrupted. Here is a list of all of our [Server Commands](https://archipelago.gg/tutorial/Archipelago/commands/en).
+
+## What happens if an item is placed somewhere it is impossible to get?
+
+The randomizer has many strict sets of rules it must follow when generating a game. One of the functions of these rules
+is to ensure items necessary to complete the game will be accessible to the player. Many games also have a subset of
+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.
+
+## 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).
+
+There, you will find examples of games in the `worlds` folder:  
+[/worlds Folder in Archipelago Code](https://github.com/ArchipelagoMW/Archipelago/tree/main/worlds).
+
+You may also find developer documentation in the `docs` folder:  
+[/docs Folder in Archipelago Code](https://github.com/ArchipelagoMW/Archipelago/tree/main/docs).
+
+If you have more questions, feel free to ask in the **#ap-world-dev** channel on our Discord.

WebHostLib/static/assets/faq/faq_en.md

@@ -1,69 +0,0 @@
-# Frequently Asked Questions
-
-## What is a randomizer?
-
-A randomizer is a modification of a video game which reorganizes the items required to progress through the game. A
-normal play-through of a game might require you to use item A to unlock item B, then C, and so forth. In a randomized
-game, you might first find item C, then A, then B.
-
-This transforms games from a linear experience into a puzzle, presenting players with a new challenge each time they
-play a randomized game. Putting items in non-standard locations can require the player to think about the game world and
-the items they encounter in new and interesting ways.
-
-## What happens if an item is placed somewhere it is impossible to get?
-
-The randomizer has many strict sets of rules it must follow when generating a game. One of the functions of these rules
-is to ensure items necessary to complete the game will be accessible to the player. Many games also have a subset of
-rules allowing certain items to be placed in normally unreachable locations, provided the player has indicated they are
-comfortable exploiting certain glitches in the game.
-
-## What is a multi-world?
-
-While a randomizer shuffles a game, a multi-world randomizer shuffles that game for multiple players. For example, in a
-two player multi-world, players A and B each get their own randomized version of a game, called a world. In each player's
-game, they may find items which belong to the other player. If player A finds an item which belongs to player B, the
-item will be sent to player B's world over the internet.
-
-This creates a cooperative experience during multi-world games, requiring players to rely upon each other to complete
-their game.
-
-## What happens if a person has to leave early?
-
-If a player must leave early, they can use Archipelago's release system. When a player releases their game, all the
-items in that game which belong to other players are sent out automatically, so other players can continue to play.
-
-## What does multi-game mean?
-
-While a multi-world game traditionally requires all players to be playing the same game, a multi-game multi-world allows
-players to randomize any of a number of supported games, and send items between them. This allows players of different
-games to interact with one another in a single multiplayer environment.
-
-## Can I generate a single-player game with Archipelago?
-
-Yes. All our supported games can be generated as single-player experiences, and so long as you download the software,
-the website is not required to generate them.
-
-## How do I get started?
-
-If you are ready to start randomizing games, or want to start playing your favorite randomizer with others, please join
-our discord server at the [Archipelago Discord](https://discord.gg/8Z65BR2). There are always people ready to answer
-any questions you might have.
-
-## What are some common terms I should know?
-
-As randomizers and multiworld randomizers have been around for a while now there are quite a lot of common terms
-and jargon that is used in conjunction by the communities surrounding them. For a lot of the terms that are more common
-to Archipelago and its specific systems please see the [Glossary](/glossary/en).
-
-## I want to add a game to the Archipelago randomizer. How do I do that?
-
-The best way to get started is to take a look at our code on GitHub
-at [Archipelago GitHub Page](https://github.com/ArchipelagoMW/Archipelago).
-
-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
-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/gameInfo.js

@@ -1,51 +0,0 @@
-window.addEventListener('load', () => {
-    const gameInfo = document.getElementById('game-info');
-    new Promise((resolve, reject) => {
-        const ajax = new XMLHttpRequest();
-        ajax.onreadystatechange = () => {
-            if (ajax.readyState !== 4) { return; }
-            if (ajax.status === 404) {
-                reject("Sorry, this game's info page is not available in that language yet.");
-                return;
-            }
-            if (ajax.status !== 200) {
-                reject("Something went wrong while loading the info page.");
-                return;
-            }
-            resolve(ajax.responseText);
-        };
-        ajax.open('GET', `${window.location.origin}/static/generated/docs/${gameInfo.getAttribute('data-game')}/` +
-          `${gameInfo.getAttribute('data-lang')}_${gameInfo.getAttribute('data-game')}.md`, true);
-        ajax.send();
-    }).then((results) => {
-        // Populate page with HTML generated from markdown
-        showdown.setOption('tables', true);
-        showdown.setOption('strikethrough', true);
-        showdown.setOption('literalMidWordUnderscores', true);
-        gameInfo.innerHTML += (new showdown.Converter()).makeHtml(results);
-        adjustHeaderWidth();
-
-        // Reset the id of all header divs to something nicer
-        for (const header of document.querySelectorAll('h1, h2, h3, h4, h5, h6')) {
-            const headerId = header.innerText.replace(/\s+/g, '-').toLowerCase();
-            header.setAttribute('id', headerId);
-            header.addEventListener('click', () => {
-                window.location.hash = `#${headerId}`;
-                header.scrollIntoView();
-            });
-        }
-
-        // Manually scroll the user to the appropriate header if anchor navigation is used
-        document.fonts.ready.finally(() => {
-            if (window.location.hash) {
-                const scrollTarget = document.getElementById(window.location.hash.substring(1));
-                scrollTarget?.scrollIntoView();
-            }
-        });
-    }).catch((error) => {
-        console.error(error);
-        gameInfo.innerHTML =
-            `<h2>This page is out of logic!</h2>
-            <h3>Click <a href="${window.location.origin}">here</a> to return to safety.</h3>`;
-    });
-});

WebHostLib/static/assets/glossary.js

@@ -1,51 +0,0 @@
-window.addEventListener('load', () => {
-    const tutorialWrapper = document.getElementById('glossary-wrapper');
-    new Promise((resolve, reject) => {
-        const ajax = new XMLHttpRequest();
-        ajax.onreadystatechange = () => {
-            if (ajax.readyState !== 4) { return; }
-            if (ajax.status === 404) {
-                reject("Sorry, the glossary page is not available in that language yet.");
-                return;
-            }
-            if (ajax.status !== 200) {
-                reject("Something went wrong while loading the glossary.");
-                return;
-            }
-            resolve(ajax.responseText);
-        };
-        ajax.open('GET', `${window.location.origin}/static/assets/faq/` +
-          `glossary_${tutorialWrapper.getAttribute('data-lang')}.md`, true);
-        ajax.send();
-    }).then((results) => {
-        // Populate page with HTML generated from markdown
-        showdown.setOption('tables', true);
-        showdown.setOption('strikethrough', true);
-        showdown.setOption('literalMidWordUnderscores', true);
-        tutorialWrapper.innerHTML += (new showdown.Converter()).makeHtml(results);
-        adjustHeaderWidth();
-
-        // Reset the id of all header divs to something nicer
-        for (const header of document.querySelectorAll('h1, h2, h3, h4, h5, h6')) {
-            const headerId = header.innerText.replace(/\s+/g, '-').toLowerCase();
-            header.setAttribute('id', headerId);
-            header.addEventListener('click', () => {
-                window.location.hash = `#${headerId}`;
-                header.scrollIntoView();
-            });
-        }
-
-        // Manually scroll the user to the appropriate header if anchor navigation is used
-        document.fonts.ready.finally(() => {
-            if (window.location.hash) {
-                const scrollTarget = document.getElementById(window.location.hash.substring(1));
-                scrollTarget?.scrollIntoView();
-            }
-        });
-    }).catch((error) => {
-        console.error(error);
-        tutorialWrapper.innerHTML =
-            `<h2>This page is out of logic!</h2>
-            <h3>Click <a href="${window.location.origin}">here</a> to return to safety.</h3>`;
-    });
-});

WebHostLib/static/assets/hostGame.js

@@ -6,6 +6,4 @@ window.addEventListener('load', () => {
     document.getElementById('file-input').addEventListener('change', () => {
         document.getElementById('host-game-form').submit();
     });
-
-    adjustFooterHeight();
 });

WebHostLib/static/assets/lttp-tracker.js

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

WebHostLib/static/assets/lttpMultiTracker.js

@@ -0,0 +1,6 @@
+window.addEventListener('load', () => {
+    $(".table-wrapper").scrollsync({
+        y_sync: true,
+        x_sync: true
+    });
+});

WebHostLib/static/assets/player-settings.js

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

WebHostLib/static/assets/playerOptions.js

@@ -0,0 +1,340 @@
+let presets = {};
+
+window.addEventListener('load', async () => {
+  // Load settings from localStorage, if available
+  loadSettings();
+
+  // Fetch presets if available
+  await fetchPresets();
+
+  // Handle changes to range inputs
+  document.querySelectorAll('input[type=range]').forEach((range) => {
+    const optionName = range.getAttribute('id');
+    range.addEventListener('change', () => {
+      document.getElementById(`${optionName}-value`).innerText = range.value;
+
+      // Handle updating named range selects to "custom" if appropriate
+      const select = document.querySelector(`select[data-option-name=${optionName}]`);
+      if (select) {
+        let updated = false;
+        select?.childNodes.forEach((option) => {
+          if (option.value === range.value) {
+            select.value = range.value;
+            updated = true;
+          }
+        });
+        if (!updated) {
+          select.value = 'custom';
+        }
+      }
+    });
+  });
+
+  // Handle changes to named range selects
+  document.querySelectorAll('.named-range-container select').forEach((select) => {
+    const optionName = select.getAttribute('data-option-name');
+    select.addEventListener('change', (evt) => {
+      document.getElementById(optionName).value = evt.target.value;
+      document.getElementById(`${optionName}-value`).innerText = evt.target.value;
+    });
+  });
+
+  // Handle changes to randomize checkboxes
+  document.querySelectorAll('.randomize-checkbox').forEach((checkbox) => {
+    const optionName = checkbox.getAttribute('data-option-name');
+    checkbox.addEventListener('change', () => {
+      const optionInput = document.getElementById(optionName);
+      const namedRangeSelect = document.querySelector(`select[data-option-name=${optionName}]`);
+      const customInput = document.getElementById(`${optionName}-custom`);
+      if (checkbox.checked) {
+        optionInput.setAttribute('disabled', '1');
+        namedRangeSelect?.setAttribute('disabled', '1');
+        if (customInput) {
+          customInput.setAttribute('disabled', '1');
+        }
+      } else {
+        optionInput.removeAttribute('disabled');
+        namedRangeSelect?.removeAttribute('disabled');
+        if (customInput) {
+          customInput.removeAttribute('disabled');
+        }
+      }
+    });
+  });
+
+  // Handle changes to TextChoice input[type=text]
+  document.querySelectorAll('.text-choice-container input[type=text]').forEach((input) => {
+    const optionName = input.getAttribute('data-option-name');
+    input.addEventListener('input', () => {
+      const select = document.getElementById(optionName);
+      const optionValues = [];
+      select.childNodes.forEach((option) => optionValues.push(option.value));
+      select.value = (optionValues.includes(input.value)) ? input.value : 'custom';
+    });
+  });
+
+  // Handle changes to TextChoice select
+  document.querySelectorAll('.text-choice-container select').forEach((select) => {
+    const optionName = select.getAttribute('id');
+    select.addEventListener('change', () => {
+      document.getElementById(`${optionName}-custom`).value = '';
+    });
+  });
+
+  // Update the "Option Preset" select to read "custom" when changes are made to relevant inputs
+  const presetSelect = document.getElementById('game-options-preset');
+  document.querySelectorAll('input, select').forEach((input) => {
+    if ( // Ignore inputs which have no effect on yaml generation
+      (input.id === 'player-name') ||
+      (input.id === 'game-options-preset') ||
+      (input.classList.contains('group-toggle')) ||
+      (input.type === 'submit')
+    ) {
+      return;
+    }
+    input.addEventListener('change', () => {
+      presetSelect.value = 'custom';
+    });
+  });
+
+  // Handle changes to presets select
+  document.getElementById('game-options-preset').addEventListener('change', choosePreset);
+
+  // Save settings to localStorage when form is submitted
+  document.getElementById('options-form').addEventListener('submit', (evt) => {
+    const playerName = document.getElementById('player-name');
+    if (!playerName.value.trim()) {
+      evt.preventDefault();
+      window.scrollTo(0, 0);
+      showUserMessage('You must enter a player name!');
+    }
+
+    saveSettings();
+  });
+});
+
+// Save all settings to localStorage
+const saveSettings = () => {
+  const options = {
+    inputs: {},
+    checkboxes: {},
+  };
+  document.querySelectorAll('input, select').forEach((input) => {
+    if (input.type === 'submit') {
+      // Ignore submit inputs
+    }
+    else if (input.type === 'checkbox') {
+      options.checkboxes[input.id] = input.checked;
+    }
+    else {
+      options.inputs[input.id] = input.value
+    }
+  });
+  const game = document.getElementById('player-options').getAttribute('data-game');
+  localStorage.setItem(game, JSON.stringify(options));
+};
+
+// Load all options from localStorage
+const loadSettings = () => {
+  const game = document.getElementById('player-options').getAttribute('data-game');
+
+  const options = JSON.parse(localStorage.getItem(game));
+  if (options) {
+    if (!options.inputs || !options.checkboxes) {
+      localStorage.removeItem(game);
+      return;
+    }
+
+    // Restore value-based inputs and selects
+    Object.keys(options.inputs).forEach((key) => {
+      try{
+        document.getElementById(key).value = options.inputs[key];
+        const rangeValue = document.getElementById(`${key}-value`);
+        if (rangeValue) {
+          rangeValue.innerText = options.inputs[key];
+        }
+      } catch (err) {
+        console.error(`Unable to restore value to input with id ${key}`);
+      }
+    });
+
+    // Restore checkboxes
+    Object.keys(options.checkboxes).forEach((key) => {
+      try{
+        if (options.checkboxes[key]) {
+          document.getElementById(key).setAttribute('checked', '1');
+        }
+      } catch (err) {
+        console.error(`Unable to restore value to input with id ${key}`);
+      }
+    });
+  }
+
+  // Ensure any input for which the randomize checkbox is checked by default, the relevant inputs are disabled
+  document.querySelectorAll('.randomize-checkbox').forEach((checkbox) => {
+    const optionName = checkbox.getAttribute('data-option-name');
+    if (checkbox.checked) {
+      const input = document.getElementById(optionName);
+      if (input) {
+        input.setAttribute('disabled', '1');
+      }
+      const customInput = document.getElementById(`${optionName}-custom`);
+      if (customInput) {
+        customInput.setAttribute('disabled', '1');
+      }
+    }
+  });
+};
+
+/**
+ * Fetch the preset data for this game and apply the presets if localStorage indicates one was previously chosen
+ * @returns {Promise<void>}
+ */
+const fetchPresets = async () => {
+  const response = await fetch('option-presets');
+  presets = await response.json();
+  const presetSelect = document.getElementById('game-options-preset');
+  presetSelect.removeAttribute('disabled');
+
+  const game = document.getElementById('player-options').getAttribute('data-game');
+  const presetToApply = localStorage.getItem(`${game}-preset`);
+  const playerName = localStorage.getItem(`${game}-player`);
+  if (presetToApply) {
+    localStorage.removeItem(`${game}-preset`);
+    presetSelect.value = presetToApply;
+    applyPresets(presetToApply);
+  }
+
+  if (playerName) {
+    document.getElementById('player-name').value = playerName;
+    localStorage.removeItem(`${game}-player`);
+  }
+};
+
+/**
+ * Clear the localStorage for this game and set a preset to be loaded upon page reload
+ * @param evt
+ */
+const choosePreset = (evt) => {
+  if (evt.target.value === 'custom') { return; }
+
+  const game = document.getElementById('player-options').getAttribute('data-game');
+  localStorage.removeItem(game);
+
+  localStorage.setItem(`${game}-player`, document.getElementById('player-name').value);
+  if (evt.target.value !== 'default') {
+    localStorage.setItem(`${game}-preset`, evt.target.value);
+  }
+
+  document.querySelectorAll('#options-form input, #options-form select').forEach((input) => {
+    if (input.id === 'player-name') { return; }
+    input.removeAttribute('value');
+  });
+
+  window.location.replace(window.location.href);
+};
+
+const applyPresets = (presetName) => {
+  // Ignore the "default" preset, because it gets set automatically by Jinja
+  if (presetName === 'default') {
+    saveSettings();
+    return;
+  }
+
+  if (!presets[presetName]) {
+    console.error(`Unknown preset ${presetName} chosen`);
+    return;
+  }
+
+  const preset = presets[presetName];
+  Object.keys(preset).forEach((optionName) => {
+    const optionValue = preset[optionName];
+
+    // Handle List and Set options
+    if (Array.isArray(optionValue)) {
+      document.querySelectorAll(`input[type=checkbox][name=${optionName}]`).forEach((checkbox) => {
+        if (optionValue.includes(checkbox.value)) {
+          checkbox.setAttribute('checked', '1');
+        } else {
+          checkbox.removeAttribute('checked');
+        }
+      });
+      return;
+    }
+
+    // Handle Dict options
+    if (typeof(optionValue) === 'object' && optionValue !== null) {
+      const itemNames = Object.keys(optionValue);
+      document.querySelectorAll(`input[type=number][data-option-name=${optionName}]`).forEach((input) => {
+        const itemName = input.getAttribute('data-item-name');
+        input.value = (itemNames.includes(itemName)) ? optionValue[itemName] : 0
+      });
+      return;
+    }
+
+    // Identify all possible elements
+    const normalInput = document.getElementById(optionName);
+    const customInput = document.getElementById(`${optionName}-custom`);
+    const rangeValue = document.getElementById(`${optionName}-value`);
+    const randomizeInput = document.getElementById(`random-${optionName}`);
+    const namedRangeSelect = document.getElementById(`${optionName}-select`);
+
+    // It is possible for named ranges to use name of a value rather than the value itself. This is accounted for here
+    let trueValue = optionValue;
+    if (namedRangeSelect) {
+      namedRangeSelect.querySelectorAll('option').forEach((opt) => {
+        if (opt.innerText.startsWith(optionValue)) {
+          trueValue = opt.value;
+        }
+      });
+      namedRangeSelect.value = trueValue;
+      // It is also possible for a preset to use an unnamed value. If this happens, set the dropdown to "Custom"
+      if (namedRangeSelect.selectedIndex == -1)
+      {
+        namedRangeSelect.value = "custom";
+      }
+    }
+
+    // Handle options whose presets are "random"
+    if (optionValue === 'random') {
+      normalInput.setAttribute('disabled', '1');
+      randomizeInput.setAttribute('checked', '1');
+      if (customInput) {
+        customInput.setAttribute('disabled', '1');
+      }
+      if (rangeValue) {
+        rangeValue.innerText = normalInput.value;
+      }
+      if (namedRangeSelect) {
+        namedRangeSelect.setAttribute('disabled', '1');
+      }
+      return;
+    }
+
+    // Handle normal (text, number, select, etc.) and custom inputs (custom inputs exist with TextChoice only)
+    normalInput.value = trueValue;
+    normalInput.removeAttribute('disabled');
+    randomizeInput.removeAttribute('checked');
+    if (customInput) {
+      document.getElementById(`${optionName}-custom`).removeAttribute('disabled');
+    }
+    if (rangeValue) {
+      rangeValue.innerText = trueValue;
+    }
+  });
+
+  saveSettings();
+};
+
+const showUserMessage = (text) => {
+  const userMessage = document.getElementById('user-message');
+  userMessage.innerText = text;
+  userMessage.addEventListener('click', hideUserMessage);
+  userMessage.style.display = 'block';
+};
+
+const hideUserMessage = () => {
+  const userMessage = document.getElementById('user-message');
+  userMessage.removeEventListener('click', hideUserMessage);
+  userMessage.style.display = 'none';
+};

WebHostLib/static/assets/sc2Tracker.js

@@ -0,0 +1,43 @@
+let updateSection = (sectionName, fakeDOM) => {
+    document.getElementById(sectionName).innerHTML = fakeDOM.getElementById(sectionName).innerHTML;
+}
+
+window.addEventListener('load', () => {
+    // Reload tracker every 60 seconds (sync'd)
+    const url = window.location;
+    // Note: This synchronization code is adapted from code in trackerCommon.js
+    const targetSecond = parseInt(document.getElementById('player-tracker').getAttribute('data-second')) + 3;
+    console.log("Target second of refresh: " + targetSecond);
+
+    let getSleepTimeSeconds = () => {
+        // -40 % 60 is -40, which is absolutely wrong and should burn
+        var sleepSeconds = (((targetSecond - new Date().getSeconds()) % 60) + 60) % 60;
+        return sleepSeconds || 60;
+    };
+
+    let updateTracker = () => {
+        const ajax = new XMLHttpRequest();
+        ajax.onreadystatechange = () => {
+            if (ajax.readyState !== 4) { return; }
+    
+            // Create a fake DOM using the returned HTML
+            const domParser = new DOMParser();
+            const fakeDOM = domParser.parseFromString(ajax.responseText, 'text/html');
+    
+            // Update dynamic sections
+            updateSection('player-info', fakeDOM);
+            updateSection('section-filler', fakeDOM);
+            updateSection('section-terran', fakeDOM);
+            updateSection('section-zerg', fakeDOM);
+            updateSection('section-protoss', fakeDOM);
+            updateSection('section-nova', fakeDOM);
+            updateSection('section-kerrigan', fakeDOM);
+            updateSection('section-keys', fakeDOM);
+            updateSection('section-locations', fakeDOM);
+        };
+        ajax.open('GET', url);
+        ajax.send();
+        updater = setTimeout(updateTracker, getSleepTimeSeconds() * 1000);
+    };
+    window.updater = setTimeout(updateTracker, getSleepTimeSeconds() * 1000);
+});

WebHostLib/static/assets/sc2wolTracker.js

@@ -1,49 +0,0 @@
-window.addEventListener('load', () => {
-  // Reload tracker every 15 seconds
-  const url = window.location;
-  setInterval(() => {
-    const ajax = new XMLHttpRequest();
-    ajax.onreadystatechange = () => {
-      if (ajax.readyState !== 4) { return; }
-
-      // Create a fake DOM using the returned HTML
-      const domParser = new DOMParser();
-      const fakeDOM = domParser.parseFromString(ajax.responseText, 'text/html');
-
-      // Update item tracker
-      document.getElementById('inventory-table').innerHTML = fakeDOM.getElementById('inventory-table').innerHTML;
-      // Update only counters in the location-table
-      let counters = document.getElementsByClassName('counter');
-      const fakeCounters = fakeDOM.getElementsByClassName('counter');
-      for (let i = 0; i < counters.length; i++) {
-        counters[i].innerHTML = fakeCounters[i].innerHTML;
-      }
-    };
-    ajax.open('GET', url);
-    ajax.send();
-  }, 15000)
-
-  // Collapsible advancement sections
-  const categories = document.getElementsByClassName("location-category");
-  for (let i = 0; i < categories.length; i++) {
-    let hide_id = categories[i].id.split('-')[0];
-    if (hide_id == 'Total') {
-      continue;
-    }
-    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 orig_text = tab_header.innerHTML;
-      let new_text;
-      if (orig_text.includes("▼")) {
-        new_text = orig_text.replace("▼", "▲");
-      }
-      else {
-        new_text = orig_text.replace("▲", "▼");
-      }
-      tab_header.innerHTML = new_text;
-    });
-  }
-});

WebHostLib/static/assets/styleController.js

@@ -1,47 +0,0 @@
-const adjustFooterHeight = () => {
-  // If there is no footer on this page, do nothing
-  const footer = document.getElementById('island-footer');
-  if (!footer) { return; }
-
-  // If the body is taller than the window, also do nothing
-  if (document.body.offsetHeight > window.innerHeight) {
-    footer.style.marginTop = '0';
-    return;
-  }
-
-  // Add a margin-top to the footer to position it at the bottom of the screen
-  const sibling = footer.previousElementSibling;
-  const margin = (window.innerHeight - sibling.offsetTop - sibling.offsetHeight - footer.offsetHeight);
-  if (margin < 1) {
-    footer.style.marginTop = '0';
-    return;
-  }
-  footer.style.marginTop = `${margin}px`;
-};
-
-const adjustHeaderWidth = () => {
-  // If there is no header, do nothing
-  const header = document.getElementById('base-header');
-  if (!header) { return; }
-
-  const tempDiv = document.createElement('div');
-  tempDiv.style.width = '100px';
-  tempDiv.style.height = '100px';
-  tempDiv.style.overflow = 'scroll';
-  tempDiv.style.position = 'absolute';
-  tempDiv.style.top = '-500px';
-  document.body.appendChild(tempDiv);
-  const scrollbarWidth = tempDiv.offsetWidth - tempDiv.clientWidth;
-  document.body.removeChild(tempDiv);
-
-  const documentRoot = document.compatMode === 'BackCompat' ? document.body : document.documentElement;
-  const margin = (documentRoot.scrollHeight > documentRoot.clientHeight) ? 0-scrollbarWidth : 0;
-  document.getElementById('base-header-right').style.marginRight = `${margin}px`;
-};
-
-window.addEventListener('load', () => {
-  window.addEventListener('resize', adjustFooterHeight);
-  window.addEventListener('resize', adjustHeaderWidth);
-  adjustFooterHeight();
-  adjustHeaderWidth();
-});

WebHostLib/static/assets/supportedGames.js

@@ -0,0 +1,44 @@
+window.addEventListener('load', () => {
+  // Add toggle listener to all elements with .collapse-toggle
+  const toggleButtons = document.querySelectorAll('details');
+
+  // 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 games as collapsed
+      return toggleButtons.forEach((header) => {
+        header.style.display = null;
+        header.removeAttribute('open');
+      });
+    }
+
+    // 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.setAttribute('open', '1');
+      } else {
+        header.style.display = 'none';
+        header.removeAttribute('open');
+      }
+    });
+  });
+
+  document.getElementById('expand-all').addEventListener('click', expandAll);
+  document.getElementById('collapse-all').addEventListener('click', collapseAll);
+});
+
+const expandAll = () => {
+  document.querySelectorAll('details').forEach((detail) => {
+    detail.setAttribute('open', '1');
+  });
+};
+
+const collapseAll = () => {
+  document.querySelectorAll('details').forEach((detail) => {
+    detail.removeAttribute('open');
+  });
+};

WebHostLib/static/assets/tracker.js

@@ -1,123 +0,0 @@
-const adjustTableHeight = () => {
-    const tablesContainer = document.getElementById('tables-container');
-    const upperDistance = tablesContainer.getBoundingClientRect().top;
-
-    const containerHeight = window.innerHeight - upperDistance;
-    tablesContainer.style.maxHeight = `calc(${containerHeight}px - 1rem)`;
-
-    const tableWrappers = document.getElementsByClassName('table-wrapper');
-    for(let i=0; i < tableWrappers.length; i++){
-        const maxHeight = (window.innerHeight - upperDistance) / 2;
-        tableWrappers[i].style.maxHeight = `calc(${maxHeight}px - 1rem)`;
-    }
-};
-
-window.addEventListener('load', () => {
-    const tables = $(".table").DataTable({
-        paging: false,
-        info: false,
-        dom: "t",
-        stateSave: true,
-        stateSaveCallback: function(settings,data) {
-            localStorage.setItem(`DataTables_${settings.sInstance}_/tracker`, JSON.stringify(data));
-        },
-        stateLoadCallback: function(settings) {
-            return JSON.parse(localStorage.getItem(`DataTables_${settings.sInstance}_/tracker`));
-        },
-        columnDefs: [
-            {
-                targets: 'hours',
-                render: function (data, type, row) {
-                    if (type === "sort" || type === 'type') {
-                        if (data === "None")
-                            return -1;
-
-                        return parseInt(data);
-                    }
-                    if (data === "None")
-                        return data;
-
-                    let hours   = Math.floor(data / 3600);
-                    let minutes = Math.floor((data - (hours * 3600)) / 60);
-
-                    if (minutes < 10) {minutes = "0"+minutes;}
-                    return hours+':'+minutes;
-                }
-            },
-            {
-                targets: 'number',
-                render: function (data, type, row) {
-                    if (type === "sort" || type === 'type') {
-                        return parseFloat(data);
-                    }
-                    return data;
-                }
-            },
-            {
-                targets: 'fraction',
-                render: function (data, type, row) {
-                    let splitted = data.split("/", 1);
-                    let current = splitted[0]
-                    if (type === "sort" || type === 'type') {
-                        return parseInt(current);
-                    }
-                    return data;
-                }
-            },
-        ],
-
-        // DO NOT use the scrollX or scrollY options. They cause DataTables to split the thead from
-        // the tbody and render two separate tables.
-    });
-
-    document.getElementById('search').addEventListener('keyup', (event) => {
-        tables.search(event.target.value);
-        console.info(tables.search());
-        tables.draw();
-    });
-    const tracker = document.getElementById('tracker-wrapper').getAttribute('data-tracker');
-    const target_second = document.getElementById('tracker-wrapper').getAttribute('data-second') + 3;
-
-    function getSleepTimeSeconds(){
-        // -40 % 60 is -40, which is absolutely wrong and should burn
-        var sleepSeconds = (((target_second - new Date().getSeconds()) % 60) + 60) % 60;
-        return sleepSeconds || 60;
-    }
-
-    const update = () => {
-        const target = $("<div></div>");
-        console.log("Updating Tracker...");
-        target.load("/tracker/" + tracker, function (response, status) {
-            if (status === "success") {
-                target.find(".table").each(function (i, new_table) {
-                    const new_trs = $(new_table).find("tbody>tr");
-                    const old_table = tables.eq(i);
-                    const topscroll = $(old_table.settings()[0].nScrollBody).scrollTop();
-                    const leftscroll = $(old_table.settings()[0].nScrollBody).scrollLeft();
-                    old_table.clear();
-                    old_table.rows.add(new_trs).draw();
-                    $(old_table.settings()[0].nScrollBody).scrollTop(topscroll);
-                    $(old_table.settings()[0].nScrollBody).scrollLeft(leftscroll);
-                });
-                $("#multi-stream-link").replaceWith(target.find("#multi-stream-link"));
-            } else {
-                console.log("Failed to connect to Server, in order to update Table Data.");
-                console.log(response);
-            }
-        })
-        setTimeout(update, getSleepTimeSeconds()*1000);
-    }
-    setTimeout(update, getSleepTimeSeconds()*1000);
-
-    window.addEventListener('resize', () => {
-        adjustTableHeight();
-        tables.draw();
-    });
-
-    $(".table-wrapper").scrollsync({
-        y_sync: true,
-        x_sync: true
-    });
-
-    adjustTableHeight();
-});

WebHostLib/static/assets/trackerCommon.js

@@ -0,0 +1,186 @@
+const adjustTableHeight = () => {
+    const tablesContainer = document.getElementById('tables-container');
+    if (!tablesContainer)
+        return;
+    const upperDistance = tablesContainer.getBoundingClientRect().top;
+
+    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`;
+    }
+};
+
+/**
+ * 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,
+        info: false,
+        dom: "t",
+        stateSave: true,
+        stateSaveCallback: function (settings, data) {
+            delete data.search;
+            localStorage.setItem(`DataTables_${settings.sInstance}_/tracker`, JSON.stringify(data));
+        },
+        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 parseInt(data);
+                    }
+                    if (data === "None")
+                        return data;
+
+                    return secondsToHours(data);
+                }
+            },
+            {
+                targets: 'number',
+                render: function (data, type, row) {
+                    if (type === "sort" || type === 'type') {
+                        return parseFloat(data);
+                    }
+                    return data;
+                }
+            },
+            {
+                targets: 'fraction',
+                render: function (data, type, row) {
+                    let splitted = data.split("/", 1);
+                    let current = splitted[0]
+                    if (type === "sort" || type === 'type') {
+                        return parseInt(current);
+                    }
+                    return data;
+                }
+            },
+        ],
+
+        // DO NOT use the scrollX or scrollY options. They cause DataTables to split the thead from
+        // the tbody and render two separate tables.
+    });
+
+    const searchBox = document.getElementById("search");
+    searchBox.value = tables.search();
+    searchBox.focus();
+    searchBox.select();
+    const doSearch = () => {
+        tables.search(searchBox.value);
+        tables.draw();
+    };
+    searchBox.addEventListener("keyup", doSearch);
+    window.addEventListener("keydown", (event) => {
+        if (!event.ctrlKey && !event.altKey && event.key.length === 1 && document.activeElement !== searchBox) {
+            searchBox.focus();
+            searchBox.select();
+        }
+        if (!event.ctrlKey && !event.altKey && !event.shiftKey && event.key === "Escape") {
+            if (searchBox.value !== "") {
+                searchBox.value = "";
+                doSearch();
+            }
+            searchBox.blur();
+            if (!document.getElementById("tables-container"))
+                window.scroll(0, 0);
+            event.preventDefault();
+        }
+    });
+    const target_second = parseInt(document.getElementById('tracker-wrapper').getAttribute('data-second')) + 3;
+    console.log("Target second of refresh: " + target_second);
+
+    function getSleepTimeSeconds() {
+        // -40 % 60 is -40, which is absolutely wrong and should burn
+        var sleepSeconds = (((target_second - new Date().getSeconds()) % 60) + 60) % 60;
+        return sleepSeconds || 60;
+    }
+
+    let update_on_view = false;
+    const update = () => {
+        if (document.hidden) {
+            console.log("Document reporting as not visible, not updating Tracker...");
+            update_on_view = true;
+        } else {
+            update_on_view = false;
+            const target = $("<div></div>");
+            console.log("Updating Tracker...");
+            target.load(location.href, function (response, status) {
+                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.settings()[0].nScrollBody).scrollTop(topscroll);
+                        $(old_table.settings()[0].nScrollBody).scrollLeft(leftscroll);
+                    });
+                    $("#multi-stream-link").replaceWith(target.find("#multi-stream-link"));
+                } else {
+                    console.log("Failed to connect to Server, in order to update Table Data.");
+                    console.log(response);
+                }
+            })
+        }
+        updater = setTimeout(update, getSleepTimeSeconds() * 1000);
+    }
+    let updater = setTimeout(update, getSleepTimeSeconds() * 1000);
+
+    window.addEventListener('resize', () => {
+        adjustTableHeight();
+        tables.draw();
+    });
+
+    window.addEventListener('visibilitychange', () => {
+        if (!document.hidden && update_on_view) {
+            console.log("Page became visible, tracker should be refreshed.");
+            clearTimeout(updater);
+            update();
+        }
+    });
+
+    adjustTableHeight();
+});

WebHostLib/static/assets/tutorial.js

@@ -1,58 +0,0 @@
-window.addEventListener('load', () => {
-    const tutorialWrapper = document.getElementById('tutorial-wrapper');
-    new Promise((resolve, reject) => {
-        const ajax = new XMLHttpRequest();
-        ajax.onreadystatechange = () => {
-            if (ajax.readyState !== 4) { return; }
-            if (ajax.status === 404) {
-                reject("Sorry, the tutorial is not available in that language yet.");
-                return;
-            }
-            if (ajax.status !== 200) {
-                reject("Something went wrong while loading the tutorial.");
-                return;
-            }
-            resolve(ajax.responseText);
-        };
-        ajax.open('GET', `${window.location.origin}/static/generated/docs/` +
-            `${tutorialWrapper.getAttribute('data-game')}/${tutorialWrapper.getAttribute('data-file')}_` +
-            `${tutorialWrapper.getAttribute('data-lang')}.md`, true);
-        ajax.send();
-    }).then((results) => {
-        // Populate page with HTML generated from markdown
-        showdown.setOption('tables', true);
-        showdown.setOption('strikethrough', true);
-        showdown.setOption('literalMidWordUnderscores', true);
-        showdown.setOption('disableForced4SpacesIndentedSublists', true);
-        tutorialWrapper.innerHTML += (new showdown.Converter()).makeHtml(results);
-        adjustHeaderWidth();
-
-        const title = document.querySelector('h1')
-        if (title) {
-            document.title = title.textContent;
-        }
-
-        // Reset the id of all header divs to something nicer
-        for (const header of document.querySelectorAll('h1, h2, h3, h4, h5, h6')) {
-            const headerId = header.innerText.replace(/\s+/g, '-').toLowerCase();
-            header.setAttribute('id', headerId);
-            header.addEventListener('click', () => {
-                window.location.hash = `#${headerId}`;
-                header.scrollIntoView();
-            });
-        }
-
-        // Manually scroll the user to the appropriate header if anchor navigation is used
-        document.fonts.ready.finally(() => {
-            if (window.location.hash) {
-                const scrollTarget = document.getElementById(window.location.hash.substring(1));
-                scrollTarget?.scrollIntoView();
-            }
-        });
-    }).catch((error) => {
-        console.error(error);
-        tutorialWrapper.innerHTML =
-            `<h2>This page is out of logic!</h2>
-            <h3>Click <a href="${window.location.origin}/tutorial">here</a> to return to safety.</h3>`;
-    });
-});

WebHostLib/static/assets/tutorialLanding.js

@@ -1,81 +0,0 @@
-const showError = () => {
-  const tutorial = document.getElementById('tutorial-landing');
-  document.getElementById('page-title').innerText = 'This page is out of logic!';
-  tutorial.removeChild(document.getElementById('loading'));
-  const userMessage = document.createElement('h3');
-  const homepageLink = document.createElement('a');
-  homepageLink.innerText = 'Click here';
-  homepageLink.setAttribute('href', '/');
-  userMessage.append(homepageLink);
-  userMessage.append(' to go back to safety!');
-  tutorial.append(userMessage);
-};
-
-window.addEventListener('load', () => {
-  const ajax = new XMLHttpRequest();
-  ajax.onreadystatechange = () => {
-    if (ajax.readyState !== 4) { return; }
-    const tutorialDiv = document.getElementById('tutorial-landing');
-    if (ajax.status !== 200) { return showError(); }
-
-    try {
-      const games = JSON.parse(ajax.responseText);
-      games.forEach((game) => {
-        const gameTitle = document.createElement('h2');
-        gameTitle.innerText = game.gameTitle;
-        gameTitle.id = `${encodeURIComponent(game.gameTitle)}`;
-        tutorialDiv.appendChild(gameTitle);
-
-        game.tutorials.forEach((tutorial) => {
-          const tutorialName = document.createElement('h3');
-          tutorialName.innerText = tutorial.name;
-          tutorialDiv.appendChild(tutorialName);
-
-          const tutorialDescription = document.createElement('p');
-          tutorialDescription.innerText = tutorial.description;
-          tutorialDiv.appendChild(tutorialDescription);
-
-          const intro = document.createElement('p');
-          intro.innerText = 'This guide is available in the following languages:';
-          tutorialDiv.appendChild(intro);
-
-          const fileList = document.createElement('ul');
-          tutorial.files.forEach((file) => {
-            const listItem = document.createElement('li');
-            const anchor = document.createElement('a');
-            anchor.innerText = file.language;
-            anchor.setAttribute('href', `${window.location.origin}/tutorial/${file.link}`);
-            listItem.appendChild(anchor);
-
-            listItem.append(' by ');
-            for (let author of file.authors) {
-              listItem.append(author);
-              if (file.authors.indexOf(author) !== (file.authors.length -1)) {
-                listItem.append(', ');
-              }
-            }
-
-            fileList.appendChild(listItem);
-          });
-          tutorialDiv.appendChild(fileList);
-        });
-      });
-
-      tutorialDiv.removeChild(document.getElementById('loading'));
-    } catch (error) {
-      showError();
-      console.error(error);
-    }
-
-    // Check if we are on an anchor when coming in, and scroll to it.
-    const hash = window.location.hash;
-    if (hash) {
-      const offset = 128;  // To account for navbar banner at top of page.
-      window.scrollTo(0, 0);
-      const rect = document.getElementById(hash.slice(1)).getBoundingClientRect();
-      window.scrollTo(rect.left, rect.top - offset);
-    }
-  };
-  ajax.open('GET', `${window.location.origin}/static/generated/tutorials.json`, true);
-  ajax.send();
-});

WebHostLib/static/assets/weightedOptions.js

@@ -0,0 +1,223 @@
+let deletedOptions = {};
+
+window.addEventListener('load', () => {
+  const worldName = document.querySelector('#weighted-options').getAttribute('data-game');
+
+  // Generic change listener. Detecting unique qualities and acting on them here reduces initial JS initialisation time
+  // and handles dynamically created elements
+  document.addEventListener('change', (evt) => {
+    // Handle updates to range inputs
+    if (evt.target.type === 'range') {
+      // Update span containing range value. All ranges have a corresponding `{rangeId}-value` span
+      document.getElementById(`${evt.target.id}-value`).innerText = evt.target.value;
+
+      // If the changed option was the name of a game, determine whether to show or hide that game's div
+      if (evt.target.id.startsWith('game||')) {
+        const gameName = evt.target.id.split('||')[1];
+        const gameDiv = document.getElementById(`${gameName}-container`);
+        if (evt.target.value > 0) {
+          gameDiv.classList.remove('hidden');
+        } else {
+          gameDiv.classList.add('hidden');
+        }
+      }
+    }
+  });
+
+  // Generic click listener
+  document.addEventListener('click', (evt) => {
+    // Handle creating new rows for Range options
+    if (evt.target.classList.contains('add-range-option-button')) {
+      const optionName = evt.target.getAttribute('data-option');
+      addRangeRow(optionName);
+    }
+
+    // Handle deleting range rows
+    if (evt.target.classList.contains('range-option-delete')) {
+      const targetRow = document.querySelector(`tr[data-row="${evt.target.getAttribute('data-target')}"]`);
+      setDeletedOption(
+        targetRow.getAttribute('data-option-name'),
+        targetRow.getAttribute('data-value'),
+      );
+      targetRow.parentElement.removeChild(targetRow);
+    }
+  });
+
+  // Listen for enter presses on inputs intended to add range rows
+  document.addEventListener('keydown', (evt) => {
+    if (evt.key === 'Enter') {
+      evt.preventDefault();
+    }
+
+    if (evt.key === 'Enter' && evt.target.classList.contains('range-option-value')) {
+      const optionName = evt.target.getAttribute('data-option');
+      addRangeRow(optionName);
+    }
+  });
+
+  // Detect form submission
+  document.getElementById('weighted-options-form').addEventListener('submit', (evt) => {
+    // Save data to localStorage
+    const weightedOptions = {};
+    document.querySelectorAll('input[name]').forEach((input) => {
+      const keys = input.getAttribute('name').split('||');
+
+      // Determine keys
+      const optionName = keys[0] ?? null;
+      const subOption = keys[1] ?? null;
+
+      // Ensure keys exist
+      if (!weightedOptions[optionName]) { weightedOptions[optionName] = {}; }
+      if (subOption && !weightedOptions[optionName][subOption]) {
+        weightedOptions[optionName][subOption] = null;
+      }
+
+      if (subOption) { return weightedOptions[optionName][subOption] = determineValue(input); }
+      if (optionName) { return weightedOptions[optionName] = determineValue(input); }
+    });
+
+    localStorage.setItem(`${worldName}-weights`, JSON.stringify(weightedOptions));
+    localStorage.setItem(`${worldName}-deletedOptions`, JSON.stringify(deletedOptions));
+  });
+
+  // Remove all deleted values as specified by localStorage
+  deletedOptions = JSON.parse(localStorage.getItem(`${worldName}-deletedOptions`) || '{}');
+  Object.keys(deletedOptions).forEach((optionName) => {
+    deletedOptions[optionName].forEach((value) => {
+      const targetRow = document.querySelector(`tr[data-row="${value}-row"]`);
+      targetRow.parentElement.removeChild(targetRow);
+    });
+  });
+
+  // Populate all settings from localStorage on page initialisation
+  const previousSettingsJson = localStorage.getItem(`${worldName}-weights`);
+  if (previousSettingsJson) {
+    const previousSettings = JSON.parse(previousSettingsJson);
+    Object.keys(previousSettings).forEach((option) => {
+      if (typeof previousSettings[option] === 'string') {
+        return document.querySelector(`input[name="${option}"]`).value = previousSettings[option];
+      }
+
+      Object.keys(previousSettings[option]).forEach((value) => {
+        const input = document.querySelector(`input[name="${option}||${value}"]`);
+        if (!input?.type) {
+          return console.error(`Unable to populate option with name ${option}||${value}.`);
+        }
+
+        switch (input.type) {
+          case 'checkbox':
+            input.checked = (parseInt(previousSettings[option][value], 10) === 1);
+            break;
+          case 'range':
+            input.value = parseInt(previousSettings[option][value], 10);
+            break;
+          case 'number':
+            input.value = previousSettings[option][value].toString();
+            break;
+          default:
+            console.error(`Found unsupported input type: ${input.type}`);
+        }
+      });
+    });
+  }
+});
+
+const addRangeRow = (optionName) => {
+  const inputQuery = `input[type=number][data-option="${optionName}"].range-option-value`;
+  const inputTarget = document.querySelector(inputQuery);
+  const newValue = inputTarget.value;
+  if (!/^-?\d+$/.test(newValue)) {
+    alert('Range values must be a positive or negative integer!');
+    return;
+  }
+  inputTarget.value = '';
+  const tBody = document.querySelector(`table[data-option="${optionName}"].range-rows tbody`);
+  const tr = document.createElement('tr');
+  tr.setAttribute('data-row', `${optionName}-${newValue}-row`);
+  tr.setAttribute('data-option-name', optionName);
+  tr.setAttribute('data-value', newValue);
+  const tdLeft = document.createElement('td');
+  tdLeft.classList.add('td-left');
+  const label = document.createElement('label');
+  label.setAttribute('for', `${optionName}||${newValue}`);
+  label.innerText = newValue.toString();
+  tdLeft.appendChild(label);
+  tr.appendChild(tdLeft);
+  const tdMiddle = document.createElement('td');
+  tdMiddle.classList.add('td-middle');
+  const range = document.createElement('input');
+  range.setAttribute('type', 'range');
+  range.setAttribute('min', '0');
+  range.setAttribute('max', '50');
+  range.setAttribute('value', '0');
+  range.setAttribute('id', `${optionName}||${newValue}`);
+  range.setAttribute('name', `${optionName}||${newValue}`);
+  tdMiddle.appendChild(range);
+  tr.appendChild(tdMiddle);
+  const tdRight = document.createElement('td');
+  tdRight.classList.add('td-right');
+  const valueSpan = document.createElement('span');
+  valueSpan.setAttribute('id', `${optionName}||${newValue}-value`);
+  valueSpan.innerText = '0';
+  tdRight.appendChild(valueSpan);
+  tr.appendChild(tdRight);
+  const tdDelete = document.createElement('td');
+  const deleteSpan = document.createElement('span');
+  deleteSpan.classList.add('range-option-delete');
+  deleteSpan.classList.add('js-required');
+  deleteSpan.setAttribute('data-target', `${optionName}-${newValue}-row`);
+  deleteSpan.innerText = '❌';
+  tdDelete.appendChild(deleteSpan);
+  tr.appendChild(tdDelete);
+  tBody.appendChild(tr);
+
+  // Remove this option from the set of deleted options if it exists
+  unsetDeletedOption(optionName, newValue);
+};
+
+/**
+ * Determines the value of an input element, or returns a 1 or 0 if the element is a checkbox
+ *
+ * @param {object} input - The input element.
+ * @returns {number} The value of the input element.
+ */
+const determineValue = (input) => {
+  switch (input.type) {
+    case 'checkbox':
+      return (input.checked ? 1 : 0);
+    case 'range':
+      return parseInt(input.value, 10);
+    default:
+      return input.value;
+  }
+};
+
+/**
+ * Sets the deleted option value for a given world and option name.
+ * If the world or option does not exist, it creates the necessary entries.
+ *
+ * @param {string} optionName - The name of the option.
+ * @param {*} value - The value to be set for the deleted option.
+ * @returns {void}
+ */
+const setDeletedOption = (optionName, value) => {
+  deletedOptions[optionName] = deletedOptions[optionName] || [];
+  deletedOptions[optionName].push(`${optionName}-${value}`);
+};
+
+/**
+ * Removes a specific value from the deletedOptions object.
+ *
+ * @param {string} optionName - The name of the option.
+ * @param {*} value - The value to be removed
+ * @returns {void}
+ */
+const unsetDeletedOption = (optionName, value) => {
+  if (!deletedOptions.hasOwnProperty(optionName)) { return; }
+  if (deletedOptions[optionName].includes(`${optionName}-${value}`)) {
+    deletedOptions[optionName].splice(deletedOptions[optionName].indexOf(`${optionName}-${value}`), 1);
+  }
+  if (deletedOptions[optionName].length === 0) {
+    delete deletedOptions[optionName];
+  }
+};

WebHostLib/static/robots_file.txt

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