Fix options pages not redirecting to appropriate host url for /api/generate

.dockerignore

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

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

.github/labeler.yml

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

.github/pyright-config.json

@@ -1,25 +1,8 @@
 {
   "include": [
-    "../BizHawkClient.py",
+    "type_check.py",
-    "../Patch.py",
-    "../rule_builder/cached_world.py",
-    "../rule_builder/options.py",
-    "../rule_builder/rules.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/general/test_rule_builder.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"
+    "../Patch.py"
   ],
 
   "exclude": [
@@ -33,7 +16,7 @@
   "reportMissingImports": true,
   "reportMissingTypeStubs": true,
 
-  "pythonVersion": "3.11",
+  "pythonVersion": "3.8",
   "pythonPlatform": "Windows",
 
   "executionEnvironments": [

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

@@ -53,7 +53,7 @@ jobs:
       - uses: actions/setup-python@v5
         if: env.diff != ''
         with:
-          python-version: '3.11'
+          python-version: 3.8
 
       - name: "Install dependencies"
         if: env.diff != ''
@@ -65,7 +65,7 @@ jobs:
         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 }}
+          flake8 --count --select=E9,F63,F7,F82 --show-source --statistics ${{ env.diff }}
 
       - name: "flake8: Lint modified files"
         continue-on-error: true

.github/workflows/build.yml

@@ -1,5 +1,4 @@
-# This workflow will build a release-like distribution when manually dispatched:
+# This workflow will build a release-like distribution when manually dispatched
-# a Windows x64 7zip, a Windows x64 Installer, a Linux AppImage and a Linux binary .tar.gz.
 
 name: Build
 
@@ -10,56 +9,37 @@ on:
       - 'setup.py'
       - 'requirements.txt'
       - '*.iss'
-      - 'worlds/*/archipelago.json'
   pull_request:
     paths:
       - '.github/workflows/build.yml'
       - 'setup.py'
       - 'requirements.txt'
       - '*.iss'
-      - 'worlds/*/archipelago.json'
   workflow_dispatch:
 
 env:
   ENEMIZER_VERSION: 7.1
-  # NOTE: since appimage/appimagetool and appimage/type2-runtime does not have tags anymore,
+  APPIMAGETOOL_VERSION: 13
-  #       we check the sha256 and require manual intervention if it was updated.
-  APPIMAGE_FORK: 'PopTracker'
-  APPIMAGETOOL_VERSION: 'r-2025-11-18'
-  APPIMAGETOOL_X86_64_HASH: '4577a452b30af2337123fbb383aea154b618e51ad5448c3b62085cbbbfbfd9a2'
-  APPIMAGE_RUNTIME_VERSION: 'r-2025-11-07'
-  APPIMAGE_RUNTIME_X86_64_HASH: '27ddd3f78e483fc5f7856e413d7c17092917f8c35bfe3318a0d378aa9435ad17'
-
-permissions:  # permissions required for attestation
-  id-token: 'write'
-  attestations: 'write'
 
 jobs:
   # build-release-macos: # LF volunteer
 
-  build-win: # RCs and releases may still be built and signed by hand
+  build-win-py38: # RCs will still be built and signed by hand
     runs-on: windows-latest
     steps:
-      # - copy code below to release.yml -
       - uses: actions/checkout@v4
       - name: Install python
         uses: actions/setup-python@v5
         with:
-          python-version: '~3.12.7'
+          python-version: '3.8'
-          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.7.0 --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"
@@ -69,6 +49,12 @@ jobs:
           Rename-Item "exe.$NAME" Archipelago
           7z a -mx=9 -mhe=on -ms "../dist/$ZIP_NAME" Archipelago
           Rename-Item Archipelago "exe.$NAME"  # inno_setup.iss expects the original name
+      - name: Store 7z
+        uses: actions/upload-artifact@v4
+        with:
+          name: ${{ env.ZIP_NAME }}
+          path: dist/${{ env.ZIP_NAME }}
+          retention-days: 7  # keep for 7 days, should be enough
       - name: Build Setup
         run: |
           & "${env:ProgramFiles(x86)}\Inno Setup 6\iscc.exe" inno_setup.iss /DNO_SIGNTOOL
@@ -79,54 +65,15 @@ jobs:
           $contents = Get-ChildItem -Path setups/*.exe -Force -Recurse
           $SETUP_NAME=$contents[0].Name
           echo "SETUP_NAME=$SETUP_NAME" >> $Env:GITHUB_ENV
-      # - copy code above to release.yml -
-      - name: Attest Build
-        if: ${{ github.event_name == 'workflow_dispatch' }}
-        uses: actions/attest-build-provenance@v2
-        with:
-          subject-path: |
-            build/exe.*/ArchipelagoLauncher.exe
-            build/exe.*/ArchipelagoLauncherDebug.exe
-            build/exe.*/ArchipelagoGenerate.exe
-            build/exe.*/ArchipelagoServer.exe
-            dist/${{ env.ZIP_NAME }}
-            setups/${{ env.SETUP_NAME }}
-      - name: Check build loads expected worlds
-        shell: bash
-        run: |
-          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@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-ubuntu2204:
+  build-ubuntu2004:
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-20.04
     steps:
       # - copy code below to release.yml -
       - uses: actions/checkout@v4
@@ -138,18 +85,14 @@ jobs:
       - name: Get a recent python
         uses: actions/setup-python@v5
         with:
-          python-version: '~3.12.7'
+          python-version: '3.11'
-          check-latest: true
       - name: Install build-time dependencies
         run: |
-          echo "PYTHON=python3.12" >> $GITHUB_ENV
+          echo "PYTHON=python3.11" >> $GITHUB_ENV
-          wget -nv https://github.com/$APPIMAGE_FORK/appimagetool/releases/download/$APPIMAGETOOL_VERSION/appimagetool-x86_64.AppImage
+          wget -nv https://github.com/AppImage/AppImageKit/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_FORK/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 --runtime-file runtime-x86_64 "$@"' > appimagetool
+          echo -e '#/bin/sh\n./squashfs-root/AppRun "$@"' > appimagetool
           chmod a+rx appimagetool
       - name: Download run-time dependencies
         run: |
@@ -161,60 +104,29 @@ jobs:
           # charset-normalizer was somehow incomplete in the github runner
           "${{ env.PYTHON }}" -m venv venv
           source venv/bin/activate
-          "${{ env.PYTHON }}" -m pip install --upgrade pip "PyGObject<3.51.0" charset-normalizer
+          "${{ env.PYTHON }}" -m pip install --upgrade pip PyGObject 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 -cv Archipelago | gzip -8 > ../dist/$TAR_NAME && mv Archipelago "$DIR_NAME")
+          (cd build && DIR_NAME="`ls | grep exe`" && mv "$DIR_NAME" Archipelago && tar -czvf ../dist/$TAR_NAME Archipelago && 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@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@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

@@ -47,7 +47,7 @@ jobs:
 
     # Initializes the CodeQL tools for scanning.
     - name: Initialize CodeQL
-      uses: github/codeql-action/init@v3
+      uses: github/codeql-action/init@v2
       with:
         languages: ${{ matrix.language }}
         # If you wish to specify custom queries, you can do so here or in a config file.
@@ -58,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@v3
+      uses: github/codeql-action/autobuild@v2
 
     # ℹ️ Command-line programs to run using the OS shell.
     # 📚 https://git.io/JvXDl
@@ -72,4 +72,4 @@ jobs:
     #   make release
 
     - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v3
+      uses: github/codeql-action/analyze@v2

.github/workflows/ctest.yml

@@ -1,54 +0,0 @@
-# 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/docker.yml

@@ -1,154 +0,0 @@
-name: Build and Publish Docker Images
-
-on:
-  push:
-    paths:
-      - "**"
-      - "!docs/**"
-      - "!deploy/**"
-      - "!setup.py"
-      - "!.gitignore"
-      - "!.github/workflows/**"
-      - ".github/workflows/docker.yml"
-    branches:
-      - "main"
-    tags:
-      - "v?[0-9]+.[0-9]+.[0-9]*"
-  workflow_dispatch:
-
-env:
-  REGISTRY: ghcr.io
-
-jobs:
-  prepare:
-    runs-on: ubuntu-latest
-    outputs:
-      image-name: ${{ steps.image.outputs.name }}
-      tags: ${{ steps.meta.outputs.tags }}
-      labels: ${{ steps.meta.outputs.labels }}
-      package-name: ${{ steps.package.outputs.name }}
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Set lowercase image name
-        id: image
-        run: |
-          echo "name=${GITHUB_REPOSITORY,,}" >> $GITHUB_OUTPUT
-
-      - name: Set package name
-        id: package
-        run: |
-          echo "name=$(basename ${GITHUB_REPOSITORY,,})" >> $GITHUB_OUTPUT
-
-      - name: Extract metadata
-        id: meta
-        uses: docker/metadata-action@v5
-        with:
-          images: ${{ env.REGISTRY }}/${{ steps.image.outputs.name }}
-          tags: |
-            type=ref,event=branch,enable={{is_not_default_branch}}
-            type=semver,pattern={{version}}
-            type=semver,pattern={{major}}.{{minor}}
-            type=raw,value=nightly,enable={{is_default_branch}}
-
-      - name: Compute final tags
-        id: final-tags
-        run: |
-          readarray -t tags <<< "${{ steps.meta.outputs.tags }}"
-
-          if [[ "${{ github.ref_type }}" == "tag" ]]; then
-            tag="${{ github.ref_name }}"
-            if [[ "$tag" =~ ^v?[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
-              full_latest="${{ env.REGISTRY }}/${{ steps.image.outputs.name }}:latest"
-              # Check if latest is already in tags to avoid duplicates
-              if ! printf '%s\n' "${tags[@]}" | grep -q "^$full_latest$"; then
-                tags+=("$full_latest")
-              fi
-            fi
-          fi
-
-          # Set multiline output
-          echo "tags<<EOF" >> $GITHUB_OUTPUT
-          printf '%s\n' "${tags[@]}" >> $GITHUB_OUTPUT
-          echo "EOF" >> $GITHUB_OUTPUT
-
-  build:
-    needs: prepare
-    runs-on: ${{ matrix.runner }}
-    permissions:
-      contents: read
-      packages: write
-    strategy:
-      matrix:
-        include:
-          - platform: amd64
-            runner: ubuntu-latest
-            suffix: amd64
-            cache-scope: amd64
-          - platform: arm64
-            runner: ubuntu-24.04-arm
-            suffix: arm64
-            cache-scope: arm64
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-
-      - name: Log in to GitHub Container Registry
-        uses: docker/login-action@v3
-        with:
-          registry: ${{ env.REGISTRY }}
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Compute suffixed tags
-        id: tags
-        run: |
-          readarray -t tags <<< "${{ needs.prepare.outputs.tags }}"
-          suffixed=()
-          for t in "${tags[@]}"; do
-            suffixed+=("$t-${{ matrix.suffix }}")
-          done
-          echo "tags=$(IFS=','; echo "${suffixed[*]}")" >> $GITHUB_OUTPUT
-
-      - name: Build and push Docker image
-        uses: docker/build-push-action@v5
-        with:
-          context: .
-          file: ./Dockerfile
-          platforms: linux/${{ matrix.platform }}
-          push: true
-          tags: ${{ steps.tags.outputs.tags }}
-          labels: ${{ needs.prepare.outputs.labels }}
-          cache-from: type=gha,scope=${{ matrix.cache-scope }}
-          cache-to: type=gha,mode=max,scope=${{ matrix.cache-scope }}
-          provenance: false
-
-  manifest:
-    needs: [prepare, build]
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      packages: write
-    steps:
-      - name: Log in to GitHub Container Registry
-        uses: docker/login-action@v3
-        with:
-          registry: ${{ env.REGISTRY }}
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Create and push multi-arch manifest
-        run: |
-          readarray -t tag_array <<< "${{ needs.prepare.outputs.tags }}"
-
-          for tag in "${tag_array[@]}"; do
-            docker manifest create "$tag" \
-              "$tag-amd64" \
-              "$tag-arm64"
-            
-            docker manifest push "$tag"
-          done

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

@@ -6,12 +6,11 @@ on:
 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

.github/workflows/release.yml

@@ -5,22 +5,11 @@ name: Release
 on:
   push:
     tags:
-      - 'v?[0-9]+.[0-9]+.[0-9]*'
+      - '*.*.*'
 
 env:
   ENEMIZER_VERSION: 7.1
-  # NOTE: since appimage/appimagetool and appimage/type2-runtime does not have tags anymore,
+  APPIMAGETOOL_VERSION: 13
-  #       we check the sha256 and require manual intervention if it was updated.
-  APPIMAGE_FORK: 'PopTracker'
-  APPIMAGETOOL_VERSION: 'r-2025-11-18'
-  APPIMAGETOOL_X86_64_HASH: '4577a452b30af2337123fbb383aea154b618e51ad5448c3b62085cbbbfbfd9a2'
-  APPIMAGE_RUNTIME_VERSION: 'r-2025-11-07'
-  APPIMAGE_RUNTIME_X86_64_HASH: '27ddd3f78e483fc5f7856e413d7c17092917f8c35bfe3318a0d378aa9435ad17'
-
-permissions:  # permissions required for attestation
-  id-token: 'write'
-  attestations: 'write'
-  contents: 'write'  # additionally required for release
 
 jobs:
   create-release:
@@ -37,79 +26,11 @@ jobs:
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
+  # build-release-windows: # this is done by hand because of signing
   # build-release-macos: # LF volunteer
 
-  build-release-win:
+  build-release-ubuntu2004:
-    runs-on: windows-latest
+    runs-on: ubuntu-20.04
-    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
@@ -123,18 +44,14 @@ jobs:
       - name: Get a recent python
         uses: actions/setup-python@v5
         with:
-          python-version: '~3.12.7'
+          python-version: '3.11'
-          check-latest: true
       - name: Install build-time dependencies
         run: |
-          echo "PYTHON=python3.12" >> $GITHUB_ENV
+          echo "PYTHON=python3.11" >> $GITHUB_ENV
-          wget -nv https://github.com/$APPIMAGE_FORK/appimagetool/releases/download/$APPIMAGETOOL_VERSION/appimagetool-x86_64.AppImage
+          wget -nv https://github.com/AppImage/AppImageKit/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_FORK/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 --runtime-file runtime-x86_64 "$@"' > appimagetool
+          echo -e '#/bin/sh\n./squashfs-root/AppRun "$@"' > appimagetool
           chmod a+rx appimagetool
       - name: Download run-time dependencies
         run: |
@@ -146,24 +63,16 @@ jobs:
           # charset-normalizer was somehow incomplete in the github runner
           "${{ env.PYTHON }}" -m venv venv
           source venv/bin/activate
-          "${{ env.PYTHON }}" -m pip install --upgrade pip "PyGObject<3.51.0" charset-normalizer
+          "${{ env.PYTHON }}" -m pip install --upgrade pip PyGObject 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 -cv Archipelago | gzip -8 > ../dist/$TAR_NAME && mv Archipelago "$DIR_NAME")
+          (cd build && DIR_NAME="`ls | grep exe`" && mv "$DIR_NAME" Archipelago && tar -czvf ../dist/$TAR_NAME Archipelago && 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@975c1b265e11dd76618af1c374e7981f9a6ff44a
         with:

.github/workflows/scan-build.yml

@@ -40,10 +40,10 @@ jobs:
       run: |
         wget https://apt.llvm.org/llvm.sh
         chmod +x ./llvm.sh
-        sudo ./llvm.sh 19
+        sudo ./llvm.sh 17
     - name: Install scan-build command
       run: |
-        sudo apt install clang-tools-19
+        sudo apt install clang-tools-17
     - name: Get a recent python
       uses: actions/setup-python@v5
       with:
@@ -56,7 +56,7 @@ jobs:
     - 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
+        scan-build-17 --status-bugs -o scan-build-reports -disable-checker deadcode.DeadStores python setup.py build -y
     - name: Store report
       if: failure()
       uses: actions/upload-artifact@v4

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

@@ -26,7 +26,7 @@ jobs:
 
       - name: "Install dependencies"
         run: |
-          python -m pip install --upgrade pip pyright==1.1.392.post0
+          python -m pip install --upgrade pip pyright==1.1.358
           python ModuleUpdate.py --append "WebHostLib/requirements.txt" --force --yes
 
       - name: "pyright: strict check on specific files"

.github/workflows/unittests.yml

@@ -8,29 +8,23 @@ on:
     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:
-  unit:
+  build:
     runs-on: ${{ matrix.os }}
     name: Test Python ${{ matrix.python.version }} ${{ matrix.os }}
 
@@ -39,15 +33,16 @@ jobs:
       matrix:
         os: [ubuntu-latest]
         python:
-          - {version: '3.11.2'} # Change to '3.11' around 2026-06-10
+          - {version: '3.8'}
-          - {version: '3.12'}
+          - {version: '3.9'}
-          - {version: '3.13'}
+          - {version: '3.10'}
+          - {version: '3.11'}
         include:
-          - python: {version: '3.11'}  # old compat
+          - python: {version: '3.8'}  # win7 compat
             os: windows-latest
-          - python: {version: '3.13'}  # current
+          - python: {version: '3.11'}  # current
             os: windows-latest
-          - python: {version: '3.13'}  # current
+          - python: {version: '3.11'}  # current
             os: macos-latest
 
     steps:
@@ -59,38 +54,9 @@ jobs:
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip
-        pip install -r ci-requirements.txt
+        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 -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,13 +4,11 @@
 *_Spoiler.txt
 *.bmbp
 *.apbp
-*.apcivvi
 *.apl2ac
 *.apm3
 *.apmc
 *.apz5
 *.aptloz
-*.aptww
 *.apemerald
 *.pyc
 *.pyd
@@ -45,7 +43,6 @@ EnemizerCLI/
 /SNI/
 /sni-*/
 /appimagetool*
-/VC_redist.x64.exe
 /host.yaml
 /options.yaml
 /config.yaml
@@ -57,6 +54,7 @@ success.txt
 output/
 Output Logs/
 /factorio/
+/Minecraft Forge Server/
 /WebHostLib/static/generated
 /freeze_requirements.txt
 /Archipelago.zip
@@ -64,10 +62,6 @@ Output Logs/
 /installdelete.iss
 /data/user.kv
 /datapackage
-/datapackage_export.json
-/custom_worlds
-# stubgen output
-/out/
 
 # Byte-compiled / optimized / DLL files
 __pycache__/
@@ -155,7 +149,7 @@ venv/
 ENV/
 env.bak/
 venv.bak/
-*.code-workspace
+.code-workspace
 shell.nix
 
 # Spyder project settings
@@ -183,10 +177,15 @@ dmypy.json
 cython_debug/
 
 # Cython intermediates
-_speedups.c
 _speedups.cpp
 _speedups.html
 
+# minecraft server stuff
+jdk*/
+minecraft*/
+minecraft_versions.json
+!worlds/minecraft/
+
 # pyenv
 .python-version
 

.run/Build APWorlds.run.xml

@@ -1,24 +0,0 @@
-<component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="Build APWorlds" type="PythonConfigurationType" factoryName="Python">
-    <module name="Archipelago" />
-    <option name="ENV_FILES" value="" />
-    <option name="INTERPRETER_OPTIONS" value="" />
-    <option name="PARENT_ENVS" value="true" />
-    <envs>
-      <env name="PYTHONUNBUFFERED" value="1" />
-    </envs>
-    <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" />
-    <option name="SCRIPT_NAME" value="$PROJECT_DIR$/Launcher.py" />
-    <option name="PARAMETERS" value="&quot;Build APWorlds&quot;" />
-    <option name="SHOW_COMMAND_LINE" value="false" />
-    <option name="EMULATE_TERMINAL" value="false" />
-    <option name="MODULE_MODE" value="false" />
-    <option name="REDIRECT_INPUT" value="false" />
-    <option name="INPUT_FILE" value="" />
-    <method v="2" />
-  </configuration>
-</component>

AHITClient.py

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

@@ -11,7 +11,6 @@ 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, \
@@ -81,8 +80,8 @@ class AdventureContext(CommonContext):
         self.local_item_locations = {}
         self.dragon_speed_info = {}
 
-        options = get_settings().adventure_options
+        options = Utils.get_options()
-        self.display_msgs = options.display_msgs
+        self.display_msgs = options["adventure_options"]["display_msgs"]
 
     async def server_auth(self, password_requested: bool = False):
         if password_requested and not self.password:
@@ -103,7 +102,7 @@ class AdventureContext(CommonContext):
     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):
+            if Utils.get_options()["adventure_options"].get("death_link", False):
                 self.set_deathlink = True
             async_start(self.get_freeincarnates_used())
         elif cmd == "RoomInfo":
@@ -113,7 +112,7 @@ class AdventureContext(CommonContext):
             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']])}"
+            msg = f"Received {', '.join([self.item_names[item.item] for item in args['items']])}"
             self._set_message(msg, SYSTEM_MESSAGE_ID)
         elif cmd == "Retrieved":
             if f"adventure_{self.auth}_freeincarnates_used" in args["keys"]:
@@ -407,7 +406,6 @@ async def atari_sync_task(ctx: AdventureContext):
                 except ConnectionRefusedError:
                     logger.debug("Connection Refused, Trying Again")
                     ctx.atari_status = CONNECTION_REFUSED_STATUS
-                    await asyncio.sleep(1)
                     continue
                 except CancelledError:
                     pass
@@ -417,9 +415,8 @@ async def atari_sync_task(ctx: AdventureContext):
 
 
 async def run_game(romfile):
-    options = get_settings().adventure_options
+    auto_start = Utils.get_options()["adventure_options"].get("rom_start", True)
-    auto_start = options.rom_start
+    rom_args = Utils.get_options()["adventure_options"].get("rom_args")
-    rom_args = options.rom_args
     if auto_start is True:
         import webbrowser
         webbrowser.open(romfile)
@@ -514,7 +511,7 @@ if __name__ == '__main__':
 
     import colorama
 
-    colorama.just_fix_windows_console()
+    colorama.init()
 
     asyncio.run(main())
     colorama.deinit()

BizHawkClient.py

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

CommonClient.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import collections
 import copy
 import logging
 import asyncio
@@ -9,7 +8,6 @@ import sys
 import typing
 import time
 import functools
-import warnings
 
 import ModuleUpdate
 ModuleUpdate.update()
@@ -21,20 +19,22 @@ import Utils
 if __name__ == "__main__":
     Utils.init_logging("TextClient", exception_logger="Client")
 
-from MultiServer import CommandProcessor, mark_raw
+from MultiServer import CommandProcessor
 from NetUtils import (Endpoint, decode, NetworkItem, encode, JSONtoTextParser, ClientStatus, Permission, NetworkSlot,
-                      RawJSONtoTextParser, add_json_text, add_json_location, add_json_item, JSONTypes, HintStatus, SlotType)
+                      RawJSONtoTextParser, add_json_text, add_json_location, add_json_item, JSONTypes)
-from Utils import gui_enabled, Version, stream_input, async_start
+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")
 
+# without terminal, we have to use gui mode
+gui_enabled = not sys.stdout or "--nogui" not in sys.argv
+
 
 @Utils.cache_argsless
 def get_ssl_context():
@@ -43,27 +43,14 @@ def get_ssl_context():
 
 
 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:
         """Close connections and client"""
-        if self.ctx.ui:
-            self.ctx.ui.stop()
         self.ctx.exit_event.set()
         return True
 
@@ -72,7 +59,6 @@ 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
@@ -106,9 +92,7 @@ class ClientCommandProcessor(CommandProcessor):
             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:
@@ -129,87 +113,43 @@ class ClientCommandProcessor(CommandProcessor):
             self.output("No missing location checks found.")
         return True
 
-    def output_datapackage_part(self, name: typing.Literal["Item Names", "Location Names"]) -> bool:
+    def _cmd_items(self):
-        """
-        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."""
-        return self.output_datapackage_part("Item Names")
-
-    def _cmd_locations(self) -> bool:
-        """List all location names for the currently running game."""
-        return self.output_datapackage_part("Location Names")
-
-    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.")
+            self.output("No game set, cannot determine existing items.")
             return False
-        lookup = Utils.persistent_load().get("groups_by_checksum", {}).get(self.ctx.checksums[self.ctx.game], {})\
+        self.output(f"Item Names for {self.ctx.game}")
-            .get(self.ctx.game, {}).get(group_key, {})
+        for item_name in AutoWorldRegister.world_types[self.ctx.game].item_name_to_id:
-        if lookup is None:
+            self.output(item_name)
-            self.output("datapackage not yet loaded, try again")
+
+    def _cmd_item_groups(self):
+        """List all item group names for the currently running game."""
+        if not self.ctx.game:
+            self.output("No game set, cannot determine existing item groups.")
             return False
+        self.output(f"Item Group Names for {self.ctx.game}")
+        for group_name in AutoWorldRegister.world_types[self.ctx.game].item_name_groups:
+            self.output(group_name)
 
-        if filter_key:
+    def _cmd_locations(self):
-            if filter_key not in lookup:
+        """List all location names for the currently running game."""
-                self.output(f"Unknown {name} Group {filter_key}")
+        if not self.ctx.game:
-                return False
+            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)
 
-            self.output(f"{name}s for {name} Group \"{filter_key}\"")
+    def _cmd_location_groups(self):
-            for entry in lookup[filter_key]:
+        """List all location group names for the currently running game."""
-                self.output(entry)
+        if not self.ctx.game:
-        else:
+            self.output("No game set, cannot determine existing location groups.")
-            self.output(f"{name} Groups for {self.ctx.game}")
+            return False
-            for group in lookup:
+        self.output(f"Location Group Names for {self.ctx.game}")
-                self.output(group)
+        for group_name in AutoWorldRegister.world_types[self.ctx.game].location_name_groups:
-        return True
+            self.output(group_name)
 
-    @mark_raw
+    def _cmd_ready(self):
-    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:
@@ -219,85 +159,30 @@ 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:
-    # The following attributes are used to Connect and should be adjusted as needed in subclasses
+    # 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
 
-    class NameLookupDict:
+    # data package
-        """A specialized dict, with helper methods, for id -> name item/location data package lookups by game."""
+    # Contents in flux until connection to server is made, to download correct data for this multiworld.
-        def __init__(self, ctx: CommonContext, lookup_type: typing.Literal["item", "location"]):
+    item_names: typing.Dict[int, str] = Utils.KeyedDefaultDict(lambda code: f'Unknown item (ID:{code})')
-            self.ctx: CommonContext = ctx
+    location_names: typing.Dict[int, str] = Utils.KeyedDefaultDict(lambda code: f'Unknown location (ID:{code})')
-            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: typing.Optional["kvui.GameManager"] = None
+    ui = 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
@@ -313,73 +198,40 @@ class CommonContext:
     last_death_link: float = time.time()  # last send/received death link on AP layer
 
     # remaining type info
-    slot_info: dict[int, NetworkSlot]
+    slot_info: typing.Dict[int, NetworkSlot]
-    """Slot Info from the server for the current connection"""
+    server_address: typing.Optional[str]
-    server_address: str | None
+    password: typing.Optional[str]
-    """Autoconnect address provided by the ctx constructor"""
+    hint_cost: typing.Optional[int]
-    password: str | None
+    hint_points: typing.Optional[int]
-    """Password used for Connecting, expected by server_auth"""
+    player_names: typing.Dict[int, str]
-    hint_cost: int | None
-    """Current Hint Cost per Hint from the server"""
-    hint_points: int | None
-    """Current available 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
-    """Bool to keep track of state for the /ready command"""
+    team: typing.Optional[int]
-    team: int | None
+    slot: typing.Optional[int]
-    """Team number of currently connected slot"""
+    auth: typing.Optional[str]
-    slot: int | None
+    seed_name: typing.Optional[str]
-    """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: set[int]
+    locations_checked: typing.Set[int]  # local state
-    """
+    locations_scouted: typing.Set[int]
-    Local container of location ids checked to signal that LocationChecks should be resent after reconnecting
+    items_received: typing.List[NetworkItem]
-    to be used to ensure that a LocationChecks packet does not get lost when disconnected
+    missing_locations: typing.Set[int]  # server state
-    """
+    checked_locations: typing.Set[int]  # server state
-    locations_scouted: set[int]
+    server_locations: typing.Set[int]  # all locations the server knows of, missing_location | checked_locations
-    """
+    locations_info: typing.Dict[int, NetworkItem]
-    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]
+    stored_data: typing.Dict[str, typing.Any]
-    """
+    stored_data_notification_keys: typing.Set[str]
-    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
-    """Current message box through kvui"""
+    # message box reporting a loss of connection
     _messagebox_connection_loss: typing.Optional["kvui.MessageBox"] = None
-    """Message box reporting a loss of connection"""
 
-    def __init__(self, server_address: typing.Optional[str] = None, password: typing.Optional[str] = None) -> None:
+    def __init__(self, server_address: typing.Optional[str], password: typing.Optional[str]) -> None:
         # server state
         self.server_address = server_address
         self.username = None
@@ -419,14 +271,8 @@ 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.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
@@ -479,8 +325,6 @@ 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 """
@@ -512,10 +356,7 @@ 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,
@@ -525,14 +366,6 @@ 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:
@@ -553,7 +386,6 @@ 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:
@@ -561,7 +393,6 @@ class CommonContext:
         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
@@ -571,10 +402,6 @@ class CommonContext:
         return print_json_packet.get("type", "") == "ItemSend" \
             and not self.slot_concerns_self(print_json_packet["receiving"]) \
             and not self.slot_concerns_self(print_json_packet["item"].player)
-    
-    def is_connection_change(self, print_json_packet: dict) -> bool:
-        """Helper function for filtering out connection changes."""
-        return print_json_packet.get("type", "") in ["Join","Part"]
 
     def on_print(self, args: dict):
         logger.info(args["text"])
@@ -598,13 +425,7 @@ 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)
@@ -616,7 +437,6 @@ 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()
@@ -631,16 +451,10 @@ 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_data_package(self, relevant_games: typing.Set[str],
+                                   remote_date_package_versions: typing.Dict[str, int],
                                    remote_data_package_checksums: typing.Dict[str, str]):
         """Validate that all data is present for the current multiworld.
         Download, assimilate and cache missing data from the server."""
@@ -649,65 +463,52 @@ class CommonContext:
 
         needed_updates: typing.Set[str] = set()
         for game in relevant_games:
-            if game not in remote_data_package_checksums:
+            if game not in remote_date_package_versions and game not in remote_data_package_checksums:
                 continue
 
+            remote_version: int = remote_date_package_versions.get(game, 0)
             remote_checksum: typing.Optional[str] = remote_data_package_checksums.get(game)
 
-            if not remote_checksum:  # custom data package and no checksum for this game
+            if remote_version == 0 and not remote_checksum:  # custom data package and no checksum for this game
                 needed_updates.add(game)
                 continue
 
-            cached_checksum: typing.Optional[str] = self.checksums.get(game)
+            local_version: int = network_data_package["games"].get(game, {}).get("version", 0)
-            # no action required if cached version is new enough
+            local_checksum: typing.Optional[str] = network_data_package["games"].get(game, {}).get("checksum")
-            if remote_checksum != cached_checksum:
+            # no action required if local version is new enough
-                local_checksum: typing.Optional[str] = network_data_package["games"].get(game, {}).get("checksum")
+            if (not remote_checksum and (remote_version > local_version or remote_version == 0)) \
-                if remote_checksum == local_checksum:
+                    or remote_checksum != local_checksum:
-                    self.update_game(network_data_package["games"][game], game)
+                cached_game = Utils.load_data_package_for_checksum(game, remote_checksum)
+                cache_version: int = cached_game.get("version", 0)
+                cache_checksum: typing.Optional[str] = cached_game.get("checksum")
+                # download remote version if cache is not new enough
+                if (not remote_checksum and (remote_version > cache_version or remote_version == 0)) \
+                        or remote_checksum != cache_checksum:
+                    needed_updates.add(game)
                 else:
-                    cached_game = Utils.load_data_package_for_checksum(game, remote_checksum)
+                    self.update_game(cached_game)
-                    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": [game_name]} for game_name in needed_updates])
 
-    def update_game(self, game_package: dict, game: str):
+    def update_game(self, game_package: dict):
-        self.item_names.update_game(game, game_package["item_name_to_id"])
+        for item_name, item_id in game_package["item_name_to_id"].items():
-        self.location_names.update_game(game, game_package["location_name_to_id"])
+            self.item_names[item_id] = item_name
-        self.checksums[game] = game_package.get("checksum")
+        for location_name, location_id in game_package["location_name_to_id"].items():
+            self.location_names[location_id] = location_name
 
     def update_data_package(self, data_package: dict):
         for game, game_data in data_package["games"].items():
-            self.update_game(game_data, game)
+            self.update_game(game_data)
 
     def consume_network_data_package(self, data_package: dict):
         self.update_data_package(data_package)
+        current_cache = Utils.persistent_load().get("datapackage", {}).get("games", {})
+        current_cache.update(data_package["games"])
+        Utils.persistent_store("datapackage", "games", current_cache)
         logger.info(f"Got new ID/Name DataPackage for {', '.join(data_package['games'])}")
         for game, game_data in data_package["games"].items():
             Utils.store_data_package_for_checksum(game, game_data)
 
-    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:
@@ -735,7 +536,6 @@ 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()
@@ -749,7 +549,6 @@ 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")
@@ -759,7 +558,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 in the loaded Kivy UI. Override if using a different UI framework"""
+        """Displays an error messagebox"""
         if not self.ui:
             return None
         title = title or "Error"
@@ -773,7 +572,7 @@ class CommonContext:
         if len(parts) == 1:
             parts = title.split(', ', 1)
         if len(parts) > 1:
-            text = f"{parts[1]}\n\n{text}" if text else parts[1]
+            text = parts[1] + '\n\n' + text
             title = parts[0]
         # display error
         self._messagebox = MessageBox(title, text, error=True)
@@ -786,36 +585,21 @@ 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 make_gui(self) -> "type[kvui.GameManager]":
+    def run_gui(self):
-        """
+        """Import kivy UI system and start running it as self.ui_task."""
-        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"
 
-        return TextManager
+        self.ui = TextManager(self)
-
-    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.")
@@ -859,9 +643,9 @@ async def server_loop(ctx: CommonContext, address: typing.Optional[str] = None)
 
     server_url = urllib.parse.urlparse(address)
     if server_url.username:
-        ctx.username = urllib.parse.unquote(server_url.username)
+        ctx.username = server_url.username
     if server_url.password:
-        ctx.password = urllib.parse.unquote(server_url.password)
+        ctx.password = server_url.password
 
     def reconnect_hint() -> str:
         return ", type /connect to reconnect" if ctx.server_address else ""
@@ -896,8 +680,6 @@ async def server_loop(ctx: CommonContext, address: typing.Optional[str] = None)
                                    "May not be running Archipelago on that address or port.")
     except websockets.InvalidURI:
         ctx.handle_connection_loss("Failed to connect to the multiworld server (invalid URI)")
-    except asyncio.TimeoutError:
-        ctx.handle_connection_loss("Failed to connect to the multiworld server. Connection timed out.")
     except OSError:
         ctx.handle_connection_loss("Failed to connect to the multiworld server")
     except Exception:
@@ -968,8 +750,9 @@ async def process_server_cmd(ctx: CommonContext, args: dict):
                         logger.info('    %s (Player %d)' % (network_player.alias, network_player.slot))
 
             # update data package
+            data_package_versions = args.get("datapackage_versions", {})
             data_package_checksums = args.get("datapackage_checksums", {})
-            await ctx.prepare_data_package(set(args["games"]), data_package_checksums)
+            await ctx.prepare_data_package(set(args["games"]), data_package_versions, data_package_checksums)
 
             await ctx.server_auth(args['password'])
 
@@ -985,7 +768,6 @@ async def process_server_cmd(ctx: CommonContext, args: dict):
             ctx.disconnected_intentionally = True
             ctx.event_invalid_game()
         elif 'IncompatibleVersion' in errors:
-            ctx.disconnected_intentionally = True
             raise Exception('Server reported your client version as incompatible. '
                             'This probably means you have to update.')
         elif 'InvalidItemsHandling' in errors:
@@ -1005,17 +787,10 @@ 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 = {0: NetworkSlot("Archipelago", "Archipelago", SlotType.player)}
+        ctx.slot_info = {int(pid): data for pid, data in args["slot_info"].items()}
-        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",
@@ -1096,19 +871,11 @@ async def process_server_cmd(ctx: CommonContext, args: dict):
         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":
         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:
@@ -1140,7 +907,6 @@ 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.')
@@ -1150,33 +916,7 @@ def get_base_parser(description: typing.Optional[str] = None):
     return parser
 
 
-def handle_url_arg(args: "argparse.Namespace",
+def run_as_textclient():
-                   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):
         # Text Mode to use !hint and such with games that have no text entry
         tags = CommonContext.tags | {"TextOnly"}
@@ -1188,7 +928,7 @@ def run_as_textclient(*args):
             if password_requested and not self.password:
                 await super(TextContext, self).server_auth(password_requested)
             await self.get_username()
-            await self.send_connect(game="")
+            await self.send_connect()
 
         def on_package(self, cmd: str, args: dict):
             if cmd == "Connected":
@@ -1215,12 +955,17 @@ def run_as_textclient(*args):
     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)
+    args = parser.parse_args()
 
-    args = handle_url_arg(args, parser=parser)
+    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)
 
-    # use colorama to display colored text highlighting on windows
+    colorama.init()
-    colorama.just_fix_windows_console()
 
     asyncio.run(main(args))
     colorama.deinit()
@@ -1228,4 +973,4 @@ def run_as_textclient(*args):
 
 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
+    run_as_textclient()

Dockerfile

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

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

FactorioClient.py

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

Fill.py

@@ -4,7 +4,7 @@ import logging
 import typing
 from collections import Counter, deque
 
-from BaseClasses import CollectionState, Item, Location, LocationProgressType, MultiWorld, PlandoItemBlock
+from BaseClasses import CollectionState, Item, Location, LocationProgressType, MultiWorld
 from Options import Accessibility
 
 from worlds.AutoWorld import call_all
@@ -12,12 +12,7 @@ from worlds.generic.Rules import add_item_rule
 
 
 class FillError(RuntimeError):
-    def __init__(self, *args: typing.Union[str, typing.Any], **kwargs) -> None:
+    pass
-        if "multiworld" in kwargs and isinstance(args[0], str):
-            placements = (args[0] + f"\nAll Placements:\n" +
-                          f"{[(loc, loc.item) for loc in kwargs['multiworld'].get_filled_locations()]}")
-            args = (placements, *args[1:])
-        super().__init__(*args)
 
 
 def _log_fill_progress(name: str, placed: int, total_items: int) -> None:
@@ -29,20 +24,19 @@ def sweep_from_pool(base_state: CollectionState, itempool: typing.Sequence[Item]
     new_state = base_state.copy()
     for item in itempool:
         new_state.collect(item, True)
-    new_state.sweep_for_advancements(locations=locations)
+    new_state.sweep_for_events(locations=locations)
     return new_state
 
 
 def fill_restrictive(multiworld: MultiWorld, base_state: CollectionState, locations: typing.List[Location],
                      item_pool: typing.List[Item], single_player_placement: bool = False, lock: bool = False,
                      swap: bool = True, on_place: typing.Optional[typing.Callable[[Location], None]] = None,
-                     allow_partial: bool = False, allow_excluded: bool = False, one_item_per_player: bool = True,
+                     allow_partial: bool = False, allow_excluded: bool = False, name: str = "Unknown") -> None:
-                     name: str = "Unknown") -> None:
     """
     :param multiworld: Multiworld to be filled.
     :param base_state: State assumed before fill.
-    :param locations: Locations to be filled with item_pool, gets mutated by removing locations that get filled.
+    :param locations: Locations to be filled with item_pool
-    :param item_pool: Items to fill into the locations, gets mutated by removing items that get placed.
+    :param item_pool: Items to fill into the locations
     :param single_player_placement: if true, can speed up placement if everything belongs to a single player
     :param lock: locations are set to locked as they are filled
     :param swap: if true, swaps of already place items are done in the event of a dead end
@@ -64,24 +58,14 @@ def fill_restrictive(multiworld: MultiWorld, base_state: CollectionState, locati
     placed = 0
 
     while any(reachable_items.values()) and locations:
-        if one_item_per_player:
+        # grab one item per player
-            # grab one item per player
+        items_to_place = [items.pop()
-            items_to_place = [items.pop()
+                          for items in reachable_items.values() if items]
-                              for items in reachable_items.values() if items]
-        else:
-            next_player = multiworld.random.choice([player for player, items in reachable_items.items() if items])
-            items_to_place = []
-            if item_pool:
-                items_to_place.append(reachable_items[next_player].pop())
-
         for item in items_to_place:
-            # The items added into `reachable_items` are placed starting from the end of each deque in
+            for p, pool_item in enumerate(item_pool):
-            # `reachable_items`, so the items being placed are more likely to be found towards the end of `item_pool`.
-            for p, pool_item in enumerate(reversed(item_pool), start=1):
                 if pool_item is item:
-                    del item_pool[-p]
+                    item_pool.pop(p)
                     break
-
         maximum_exploration_state = sweep_from_pool(
             base_state, item_pool + unplaced_items, multiworld.get_filled_locations(item.player)
             if single_player_placement else None)
@@ -100,7 +84,7 @@ def fill_restrictive(multiworld: MultiWorld, base_state: CollectionState, locati
             # if minimal accessibility, only check whether location is reachable if game not beatable
             if multiworld.worlds[item_to_place.player].options.accessibility == Accessibility.option_minimal:
                 perform_access_check = not multiworld.has_beaten_game(maximum_exploration_state,
-                                                                      item_to_place.player) \
+                                                                 item_to_place.player) \
                     if single_player_placement else not has_beaten_game
             else:
                 perform_access_check = True
@@ -116,23 +100,12 @@ def fill_restrictive(multiworld: MultiWorld, base_state: CollectionState, locati
             else:
                 # we filled all reachable spots.
                 if swap:
-                    # Keep a cache of previous safe swap states that might be usable to sweep from to produce the next
-                    # swap state, instead of sweeping from `base_state` each time.
-                    previous_safe_swap_state_cache: typing.Deque[CollectionState] = deque()
-                    # Almost never are more than 2 states needed. The rare cases that do are usually highly restrictive
-                    # single_player_placement=True pre-fills which can go through more than 10 states in some seeds.
-                    max_swap_base_state_cache_length = 3
-
                     # try swapping this item with previously placed items in a safe way then in an unsafe way
                     swap_attempts = ((i, location, unsafe)
                                      for unsafe in (False, True)
                                      for i, location in enumerate(placements))
                     for (i, location, unsafe) in swap_attempts:
                         placed_item = location.item
-                        if item_to_place == placed_item:
-                            # The number of allowed swaps is limited, so do not allow a swap of an item with a copy of
-                            # itself.
-                            continue
                         # Unplaceable items can sometimes be swapped infinitely. Limit the
                         # number of times we will swap an individual item to prevent this
                         swap_count = swapped_items[placed_item.player, placed_item.name, unsafe]
@@ -141,50 +114,40 @@ def fill_restrictive(multiworld: MultiWorld, base_state: CollectionState, locati
 
                         location.item = None
                         placed_item.location = None
-
+                        swap_state = sweep_from_pool(base_state, [placed_item, *item_pool] if unsafe else item_pool,
-                        for previous_safe_swap_state in previous_safe_swap_state_cache:
+                                                     multiworld.get_filled_locations(item.player)
-                            # If a state has already checked the location of the swap, then it cannot be used.
+                                                     if single_player_placement else None)
-                            if location not in previous_safe_swap_state.advancements:
-                                # Previous swap states will have collected all items in `item_pool`, so the new
-                                # `swap_state` can skip having to collect them again.
-                                # Previous swap states will also have already checked many locations, making the sweep
-                                # faster.
-                                swap_state = sweep_from_pool(previous_safe_swap_state, (placed_item,) if unsafe else (),
-                                                             multiworld.get_filled_locations(item.player)
-                                                             if single_player_placement else None)
-                                break
-                        else:
-                            # No previous swap_state was usable as a base state to sweep from, so create a new one.
-                            swap_state = sweep_from_pool(base_state, [placed_item, *item_pool] if unsafe else item_pool,
-                                                         multiworld.get_filled_locations(item.player)
-                                                         if single_player_placement else None)
-                            # Unsafe states should not be added to the cache because they have collected `placed_item`.
-                            if not unsafe:
-                                if len(previous_safe_swap_state_cache) >= max_swap_base_state_cache_length:
-                                    # Remove the oldest cached state.
-                                    previous_safe_swap_state_cache.pop()
-                                # Add the new state to the start of the cache.
-                                previous_safe_swap_state_cache.appendleft(swap_state)
                         # unsafe means swap_state assumes we can somehow collect placed_item before item_to_place
                         # by continuing to swap, which is not guaranteed. This is unsafe because there is no mechanic
                         # to clean that up later, so there is a chance generation fails.
                         if (not single_player_placement or location.player == item_to_place.player) \
                                 and location.can_fill(swap_state, item_to_place, perform_access_check):
-                            # Add this item to the existing placement, and
-                            # add the old item to the back of the queue
-                            spot_to_fill = placements.pop(i)
 
-                            swap_count += 1
+                            # Verify placing this item won't reduce available locations, which would be a useless swap.
-                            swapped_items[placed_item.player, placed_item.name, unsafe] = swap_count
+                            prev_state = swap_state.copy()
+                            prev_loc_count = len(
+                                multiworld.get_reachable_locations(prev_state))
 
-                            reachable_items[placed_item.player].appendleft(
+                            swap_state.collect(item_to_place, True)
-                                placed_item)
+                            new_loc_count = len(
-                            item_pool.append(placed_item)
+                                multiworld.get_reachable_locations(swap_state))
 
-                            # cleanup at the end to hopefully get better errors
+                            if new_loc_count >= prev_loc_count:
-                            cleanup_required = True
+                                # Add this item to the existing placement, and
+                                # add the old item to the back of the queue
+                                spot_to_fill = placements.pop(i)
 
-                            break
+                                swap_count += 1
+                                swapped_items[placed_item.player, placed_item.name, unsafe] = swap_count
+
+                                reachable_items[placed_item.player].appendleft(
+                                    placed_item)
+                                item_pool.append(placed_item)
+
+                                # cleanup at the end to hopefully get better errors
+                                cleanup_required = True
+
+                                break
 
                         # Item can't be placed here, restore original item
                         location.item = placed_item
@@ -249,7 +212,7 @@ def fill_restrictive(multiworld: MultiWorld, base_state: CollectionState, locati
                             f"Unfilled locations:\n"
                             f"{', '.join(str(location) for location in locations)}\n"
                             f"Already placed {len(placements)}:\n"
-                            f"{', '.join(str(place) for place in placements)}", multiworld=multiworld)
+                            f"{', '.join(str(place) for place in placements)}")
 
     item_pool.extend(unplaced_items)
 
@@ -257,32 +220,18 @@ def fill_restrictive(multiworld: MultiWorld, base_state: CollectionState, locati
 def remaining_fill(multiworld: MultiWorld,
                    locations: typing.List[Location],
                    itempool: typing.List[Item],
-                   name: str = "Remaining", 
+                   name: str = "Remaining") -> None:
-                   move_unplaceable_to_start_inventory: bool = False,
-                   check_location_can_fill: bool = False) -> None:
     unplaced_items: typing.List[Item] = []
     placements: typing.List[Location] = []
     swapped_items: typing.Counter[typing.Tuple[int, str]] = Counter()
-    total = min(len(itempool), len(locations))
+    total = min(len(itempool),  len(locations))
     placed = 0
-
-    # Optimisation: Decide whether to do full location.can_fill check (respect excluded), or only check the item rule
-    if check_location_can_fill:
-        state = CollectionState(multiworld)
-
-        def location_can_fill_item(location_to_fill: Location, item_to_fill: Item):
-            return location_to_fill.can_fill(state, item_to_fill, check_access=False)
-    else:
-        def location_can_fill_item(location_to_fill: Location, item_to_fill: Item):
-            return location_to_fill.item_rule(item_to_fill)
-
     while locations and itempool:
         item_to_place = itempool.pop()
         spot_to_fill: typing.Optional[Location] = None
 
-        # going through locations in the same order as the provided `locations` argument
         for i, location in enumerate(locations):
-            if location_can_fill_item(location, item_to_place):
+            if location.item_rule(item_to_place):
                 # popping by index is faster than removing by content,
                 spot_to_fill = locations.pop(i)
                 # skipping a scan for the element
@@ -303,7 +252,7 @@ def remaining_fill(multiworld: MultiWorld,
 
                 location.item = None
                 placed_item.location = None
-                if location_can_fill_item(location, item_to_place):
+                if location.item_rule(item_to_place):
                     # Add this item to the existing placement, and
                     # add the old item to the back of the queue
                     spot_to_fill = placements.pop(i)
@@ -335,21 +284,13 @@ def remaining_fill(multiworld: MultiWorld,
 
     if unplaced_items and locations:
         # There are leftover unplaceable items and locations that won't accept them
-        if move_unplaceable_to_start_inventory:
+        raise FillError(f"No more spots to place {len(unplaced_items)} items. Remaining locations are invalid.\n"
-            last_batch = []
+                        f"Unplaced items:\n"
-            for item in unplaced_items:
+                        f"{', '.join(str(item) for item in unplaced_items)}\n"
-                logging.debug(f"Moved {item} to start_inventory to prevent fill failure.")
+                        f"Unfilled locations:\n"
-                multiworld.push_precollected(item)
+                        f"{', '.join(str(location) for location in locations)}\n"
-                last_batch.append(multiworld.worlds[item.player].create_filler())
+                        f"Already placed {len(placements)}:\n"
-            remaining_fill(multiworld, locations, unplaced_items, name + " Start Inventory Retry")
+                        f"{', '.join(str(place) for place in placements)}")
-        else:
-            raise FillError(f"No more spots to place {len(unplaced_items)} items. Remaining locations are invalid.\n"
-                            f"Unplaced items:\n"
-                            f"{', '.join(str(item) for item in unplaced_items)}\n"
-                            f"Unfilled locations:\n"
-                            f"{', '.join(str(location) for location in locations)}\n"
-                            f"Already placed {len(placements)}:\n"
-                            f"{', '.join(str(place) for place in placements)}", multiworld=multiworld)
 
     itempool.extend(unplaced_items)
 
@@ -363,26 +304,19 @@ def fast_fill(multiworld: MultiWorld,
     return item_pool[placing:], fill_locations[placing:]
 
 
-def accessibility_corrections(multiworld: MultiWorld,
+def accessibility_corrections(multiworld: MultiWorld, state: CollectionState, locations, pool=[]):
-                              state: CollectionState,
-                              locations: list[Location],
-                              pool: list[Item] | None = None) -> None:
-    if pool is None:
-        pool = []
     maximum_exploration_state = sweep_from_pool(state, pool)
-    minimal_players = {player for player in multiworld.player_ids if
+    minimal_players = {player for player in multiworld.player_ids if multiworld.worlds[player].options.accessibility == "minimal"}
-                       multiworld.worlds[player].options.accessibility == "minimal"}
+    unreachable_locations = [location for location in multiworld.get_locations() if location.player in minimal_players and
-    unreachable_locations = [location for location in multiworld.get_locations() if
-                             location.player in minimal_players and
                              not location.can_reach(maximum_exploration_state)]
     for location in unreachable_locations:
         if (location.item is not None and location.item.advancement and location.address is not None and not
                 location.locked and location.item.player not in minimal_players):
             pool.append(location.item)
+            state.remove(location.item)
             location.item = None
-            if location in state.advancements:
+            if location in state.events:
-                state.advancements.remove(location)
+                state.events.remove(location)
-                state.remove(location.item)
             locations.append(location)
     if pool and locations:
         locations.sort(key=lambda loc: loc.progress_type != LocationProgressType.PRIORITY)
@@ -394,7 +328,7 @@ def inaccessible_location_rules(multiworld: MultiWorld, state: CollectionState,
     unreachable_locations = [location for location in locations if not location.can_reach(maximum_exploration_state)]
     if unreachable_locations:
         def forbid_important_item_rule(item: Item):
-            return not ((item.classification & 0b0011) and multiworld.worlds[item.player].options.accessibility != "minimal")
+            return not ((item.classification & 0b0011) and multiworld.worlds[item.player].options.accessibility != 'minimal')
 
         for location in unreachable_locations:
             add_item_rule(location, forbid_important_item_rule)
@@ -415,7 +349,7 @@ def distribute_early_items(multiworld: MultiWorld,
         early_priority_locations: typing.List[Location] = []
         loc_indexes_to_remove: typing.Set[int] = set()
         base_state = multiworld.state.copy()
-        base_state.sweep_for_advancements(locations=(loc for loc in multiworld.get_filled_locations() if loc.address is None))
+        base_state.sweep_for_events(locations=(loc for loc in multiworld.get_filled_locations() if loc.address is None))
         for i, loc in enumerate(fill_locations):
             if loc.can_reach(base_state):
                 if loc.progress_type == LocationProgressType.PRIORITY:
@@ -486,14 +420,7 @@ def distribute_early_items(multiworld: MultiWorld,
     return fill_locations, itempool
 
 
-def distribute_items_restrictive(multiworld: MultiWorld,
+def distribute_items_restrictive(multiworld: MultiWorld) -> None:
-                                 panic_method: typing.Literal["swap", "raise", "start_inventory"] = "swap") -> None:
-    assert all(item.location is None for item in multiworld.itempool), (
-        "At the start of distribute_items_restrictive, "
-        "there are items in the multiworld itempool that are already placed on locations:\n"
-        f"{[(item.location, item) for item in multiworld.itempool if item.location is not None]}"
-    )
-
     fill_locations = sorted(multiworld.get_unfilled_locations())
     multiworld.random.shuffle(fill_locations)
     # get items to distribute
@@ -533,85 +460,22 @@ def distribute_items_restrictive(multiworld: MultiWorld,
         nonlocal lock_later
         lock_later.append(location)
 
-    single_player = multiworld.players == 1 and not multiworld.groups
-
     if prioritylocations:
-        regular_progression = []
-        deprioritized_progression = []
-        for item in progitempool:
-            if item.deprioritized:
-                deprioritized_progression.append(item)
-            else:
-                regular_progression.append(item)
-
         # "priority fill"
-        # try without deprioritized items in the mix at all. This means they need to be collected into state first.
+        fill_restrictive(multiworld, multiworld.state, prioritylocations, progitempool,
-        priority_fill_state = sweep_from_pool(multiworld.state, deprioritized_progression)
+                         single_player_placement=multiworld.players == 1, swap=False, on_place=mark_for_locking,
-        fill_restrictive(multiworld, priority_fill_state, prioritylocations, regular_progression,
+                         name="Priority")
-                         single_player_placement=single_player, swap=False, on_place=mark_for_locking,
-                         name="Priority", one_item_per_player=True, allow_partial=True)
-
-        if prioritylocations and regular_progression:
-            # retry with one_item_per_player off because some priority fills can fail to fill with that optimization
-            # deprioritized items are still not in the mix, so they need to be collected into state first.
-            # allow_partial should only be set if there is deprioritized progression to fall back on.
-            priority_retry_state = sweep_from_pool(multiworld.state, deprioritized_progression)
-            fill_restrictive(multiworld, priority_retry_state, prioritylocations, regular_progression,
-                             single_player_placement=single_player, swap=False, on_place=mark_for_locking,
-                             name="Priority Retry", one_item_per_player=False,
-                             allow_partial=bool(deprioritized_progression))
-
-        if prioritylocations and deprioritized_progression:
-            # There are no more regular progression items that can be placed on any priority locations.
-            # We'd still prefer to place deprioritized progression items on priority locations over filler items.
-            # Since we're leaving out the remaining regular progression now, we need to collect it into state first.
-            priority_retry_2_state = sweep_from_pool(multiworld.state, regular_progression)
-            fill_restrictive(multiworld, priority_retry_2_state, prioritylocations, deprioritized_progression,
-                             single_player_placement=single_player, swap=False, on_place=mark_for_locking,
-                             name="Priority Retry 2", one_item_per_player=True, allow_partial=True)
-
-        if prioritylocations and deprioritized_progression:
-            # retry with deprioritized items AND without one_item_per_player optimisation
-            # Since we're leaving out the remaining regular progression now, we need to collect it into state first.
-            priority_retry_3_state = sweep_from_pool(multiworld.state, regular_progression)
-            fill_restrictive(multiworld, priority_retry_3_state, prioritylocations, deprioritized_progression,
-                             single_player_placement=single_player, swap=False, on_place=mark_for_locking,
-                             name="Priority Retry 3", one_item_per_player=False)
-
-        # restore original order of progitempool
-        progitempool[:] = [item for item in progitempool if not item.location]
         accessibility_corrections(multiworld, multiworld.state, prioritylocations, progitempool)
         defaultlocations = prioritylocations + defaultlocations
 
     if progitempool:
         # "advancement/progression fill"
-        maximum_exploration_state = sweep_from_pool(multiworld.state)
+        fill_restrictive(multiworld, multiworld.state, defaultlocations, progitempool, single_player_placement=multiworld.players == 1,
-        if panic_method == "swap":
+                         name="Progression")
-            fill_restrictive(multiworld, maximum_exploration_state, defaultlocations, progitempool, swap=True,
-                             name="Progression", single_player_placement=single_player)
-        elif panic_method == "raise":
-            fill_restrictive(multiworld, maximum_exploration_state, defaultlocations, progitempool, swap=False,
-                             name="Progression", single_player_placement=single_player)
-        elif panic_method == "start_inventory":
-            fill_restrictive(multiworld, maximum_exploration_state, defaultlocations, progitempool, swap=False,
-                             allow_partial=True, name="Progression", single_player_placement=single_player)
-            if progitempool:
-                for item in progitempool:
-                    logging.debug(f"Moved {item} to start_inventory to prevent fill failure.")
-                    multiworld.push_precollected(item)
-                    filleritempool.append(multiworld.worlds[item.player].create_filler())
-                logging.warning(f"{len(progitempool)} items moved to start inventory,"
-                                f" due to failure in Progression fill step.")
-                progitempool[:] = []
-
-        else:
-            raise ValueError(f"Generator Panic Method {panic_method} not recognized.")
         if progitempool:
             raise FillError(
                 f"Not enough locations for progression items. "
-                f"There are {len(progitempool)} more progression items than there are available locations.\n"
+                f"There are {len(progitempool)} more progression items than there are available locations."
-                f"Unfilled locations:\n{multiworld.get_unfilled_locations()}.",
-                multiworld=multiworld,
             )
         accessibility_corrections(multiworld, multiworld.state, defaultlocations)
 
@@ -622,20 +486,16 @@ def distribute_items_restrictive(multiworld: MultiWorld,
 
     inaccessible_location_rules(multiworld, multiworld.state, defaultlocations)
 
-    remaining_fill(multiworld, excludedlocations, filleritempool, "Remaining Excluded",
+    remaining_fill(multiworld, excludedlocations, filleritempool, "Remaining Excluded")
-                   move_unplaceable_to_start_inventory=panic_method=="start_inventory")
-
     if excludedlocations:
         raise FillError(
             f"Not enough filler items for excluded locations. "
-            f"There are {len(excludedlocations)} more excluded locations than excludable items.",
+            f"There are {len(excludedlocations)} more excluded locations than filler or trap items."
-            multiworld=multiworld,
         )
 
     restitempool = filleritempool + usefulitempool
 
-    remaining_fill(multiworld, defaultlocations, restitempool,
+    remaining_fill(multiworld, defaultlocations, restitempool)
-                   move_unplaceable_to_start_inventory=panic_method=="start_inventory")
 
     unplaced = restitempool
     unfilled = defaultlocations
@@ -649,26 +509,6 @@ def distribute_items_restrictive(multiworld: MultiWorld,
         print_data = {"items": items_counter, "locations": locations_counter}
         logging.info(f"Per-Player counts: {print_data})")
 
-        more_locations = locations_counter - items_counter
-        more_items = items_counter - locations_counter
-        for player in multiworld.player_ids:
-            if more_locations[player]:
-                logging.error(
-                    f"Player {multiworld.get_player_name(player)} had {more_locations[player]} more locations than items.")
-            elif more_items[player]:
-                logging.warning(
-                    f"Player {multiworld.get_player_name(player)} had {more_items[player]} more items than locations.")
-        if unfilled:
-            raise FillError(
-                f"Unable to fill all locations.\n" +
-                f"Unfilled locations({len(unfilled)}): {unfilled}"
-            )
-        else:
-            logging.warning(
-                f"Unable to place all items.\n" +
-                f"Unplaced items({len(unplaced)}): {unplaced}"
-            )
-
 
 def flood_items(multiworld: MultiWorld) -> None:
     # get items to distribute
@@ -677,7 +517,7 @@ def flood_items(multiworld: MultiWorld) -> None:
     progress_done = False
 
     # sweep once to pick up preplaced items
-    multiworld.state.sweep_for_advancements()
+    multiworld.state.sweep_for_events()
 
     # fill multiworld from top of itempool while we can
     while not progress_done:
@@ -715,7 +555,7 @@ def flood_items(multiworld: MultiWorld) -> None:
             if candidate_item_to_place is not None:
                 item_to_place = candidate_item_to_place
             else:
-                raise FillError('No more progress items left to place.', multiworld=multiworld)
+                raise FillError('No more progress items left to place.')
 
         # find item to replace with progress item
         location_list = multiworld.get_reachable_locations()
@@ -744,9 +584,9 @@ def balance_multiworld_progression(multiworld: MultiWorld) -> None:
         if multiworld.worlds[player].options.progression_balancing > 0
     }
     if not balanceable_players:
-        logging.info("Skipping multiworld progression balancing.")
+        logging.info('Skipping multiworld progression balancing.')
     else:
-        logging.info(f"Balancing multiworld progression for {len(balanceable_players)} Players.")
+        logging.info(f'Balancing multiworld progression for {len(balanceable_players)} Players.')
         logging.debug(balanceable_players)
         state: CollectionState = CollectionState(multiworld)
         checked_locations: typing.Set[Location] = set()
@@ -772,6 +612,7 @@ def balance_multiworld_progression(multiworld: MultiWorld) -> None:
 
         def get_sphere_locations(sphere_state: CollectionState,
                                  locations: typing.Set[Location]) -> typing.Set[Location]:
+            sphere_state.sweep_for_events(key_only=True, locations=locations)
             return {loc for loc in locations if sphere_state.can_reach(loc)}
 
         def item_percentage(player: int, num: int) -> float:
@@ -844,7 +685,7 @@ def balance_multiworld_progression(multiworld: MultiWorld) -> None:
                                 if player in threshold_percentages):
                             break
                         elif not balancing_sphere:
-                            raise RuntimeError("Not all required items reachable. Something went terribly wrong here.")
+                            raise RuntimeError('Not all required items reachable. Something went terribly wrong here.')
                     # Gather a set of locations which we can swap items into
                     unlocked_locations: typing.Dict[int, typing.Set[Location]] = collections.defaultdict(set)
                     for l in unchecked_locations:
@@ -860,12 +701,12 @@ def balance_multiworld_progression(multiworld: MultiWorld) -> None:
                             testing = items_to_test.pop()
                             reducing_state = state.copy()
                             for location in itertools.chain((
-                                    l for l in items_to_replace
+                                l for l in items_to_replace
-                                    if l.item.player == player
+                                if l.item.player == player
                             ), items_to_test):
                                 reducing_state.collect(location.item, True, location)
 
-                            reducing_state.sweep_for_advancements(locations=locations_to_test)
+                            reducing_state.sweep_for_events(locations=locations_to_test)
 
                             if multiworld.has_beaten_game(balancing_state):
                                 if not multiworld.has_beaten_game(reducing_state):
@@ -934,30 +775,52 @@ def swap_location_item(location_1: Location, location_2: Location, check_locked:
     location_2.item.location = location_2
 
 
-def parse_planned_blocks(multiworld: MultiWorld) -> dict[int, list[PlandoItemBlock]]:
+def distribute_planned(multiworld: MultiWorld) -> None:
-    def warn(warning: str, force: bool | str) -> None:
+    def warn(warning: str, force: typing.Union[bool, str]) -> None:
-        if isinstance(force, bool):
+        if force in [True, 'fail', 'failure', 'none', False, 'warn', 'warning']:
-            logging.warning(f"{warning}")
+            logging.warning(f'{warning}')
         else:
-            logging.debug(f"{warning}")
+            logging.debug(f'{warning}')
 
-    def failed(warning: str, force: bool | str) -> None:
+    def failed(warning: str, force: typing.Union[bool, str]) -> None:
-        if force is True:
+        if force in [True, 'fail', 'failure']:
             raise Exception(warning)
         else:
             warn(warning, force)
 
+    swept_state = multiworld.state.copy()
+    swept_state.sweep_for_events()
+    reachable = frozenset(multiworld.get_reachable_locations(swept_state))
+    early_locations: typing.Dict[int, typing.List[str]] = collections.defaultdict(list)
+    non_early_locations: typing.Dict[int, typing.List[str]] = collections.defaultdict(list)
+    for loc in multiworld.get_unfilled_locations():
+        if loc in reachable:
+            early_locations[loc.player].append(loc.name)
+        else:  # not reachable with swept state
+            non_early_locations[loc.player].append(loc.name)
+
     world_name_lookup = multiworld.world_name_lookup
 
-    plando_blocks: dict[int, list[PlandoItemBlock]] = dict()
+    block_value = typing.Union[typing.List[str], typing.Dict[str, typing.Any], str]
-    player_ids: set[int] = set(multiworld.player_ids)
+    plando_blocks: typing.List[typing.Dict[str, typing.Any]] = []
+    player_ids = set(multiworld.player_ids)
     for player in player_ids:
-        plando_blocks[player] = []
+        for block in multiworld.plando_items[player]:
-        for block in multiworld.worlds[player].options.plando_items:
+            block['player'] = player
-            new_block: PlandoItemBlock = PlandoItemBlock(player, block.from_pool, block.force)
+            if 'force' not in block:
-            target_world = block.world
+                block['force'] = 'silent'
+            if 'from_pool' not in block:
+                block['from_pool'] = True
+            elif not isinstance(block['from_pool'], bool):
+                from_pool_type = type(block['from_pool'])
+                raise Exception(f'Plando "from_pool" has to be boolean, not {from_pool_type} for player {player}.')
+            if 'world' not in block:
+                target_world = False
+            else:
+                target_world = block['world']
+
             if target_world is False or multiworld.players == 1:  # target own world
-                worlds: set[int] = {player}
+                worlds: typing.Set[int] = {player}
             elif target_world is True:  # target any worlds besides own
                 worlds = set(multiworld.player_ids) - {player}
             elif target_world is None:  # target all worlds
@@ -966,201 +829,156 @@ def parse_planned_blocks(multiworld: MultiWorld) -> dict[int, list[PlandoItemBlo
                 worlds = set()
                 for listed_world in target_world:
                     if listed_world not in world_name_lookup:
-                        failed(f"Cannot place item to {listed_world}'s world as that world does not exist.",
+                        failed(f"Cannot place item to {target_world}'s world as that world does not exist.",
-                               block.force)
+                               block['force'])
                         continue
                     worlds.add(world_name_lookup[listed_world])
             elif type(target_world) == int:  # target world by slot number
                 if target_world not in range(1, multiworld.players + 1):
                     failed(
                         f"Cannot place item in world {target_world} as it is not in range of (1, {multiworld.players})",
-                        block.force)
+                        block['force'])
                     continue
                 worlds = {target_world}
             else:  # target world by slot name
                 if target_world not in world_name_lookup:
                     failed(f"Cannot place item to {target_world}'s world as that world does not exist.",
-                           block.force)
+                           block['force'])
                     continue
                 worlds = {world_name_lookup[target_world]}
-            new_block.worlds = worlds
+            block['world'] = worlds
 
-            items: list[str] | dict[str, typing.Any] = block.items
+            items: block_value = []
+            if "items" in block:
+                items = block["items"]
+                if 'count' not in block:
+                    block['count'] = False
+            elif "item" in block:
+                items = block["item"]
+                if 'count' not in block:
+                    block['count'] = 1
+            else:
+                failed("You must specify at least one item to place items with plando.", block['force'])
+                continue
             if isinstance(items, dict):
-                item_list: list[str] = []
+                item_list: typing.List[str] = []
                 for key, value in items.items():
                     if value is True:
                         value = multiworld.itempool.count(multiworld.worlds[player].create_item(key))
                     item_list += [key] * value
                 items = item_list
-            new_block.items = items
+            if isinstance(items, str):
+                items = [items]
+            block['items'] = items
 
-            locations: list[str] = block.locations
+            locations: block_value = []
+            if 'location' in block:
+                locations = block['location']  # just allow 'location' to keep old yamls compatible
+            elif 'locations' in block:
+                locations = block['locations']
             if isinstance(locations, str):
                 locations = [locations]
 
-            resolved_locations: list[Location] = []
+            if isinstance(locations, dict):
-            for target_player in worlds:
+                location_list = []
-                locations_from_groups: list[str] = []
+                for key, value in locations.items():
-                world_locations = multiworld.get_unfilled_locations(target_player)
+                    location_list += [key] * value
-                for group in multiworld.worlds[target_player].location_name_groups:
+                locations = location_list
-                    if group in locations:
-                        locations_from_groups.extend(multiworld.worlds[target_player].location_name_groups[group])
-                resolved_locations.extend(location for location in world_locations
-                                          if location.name in [*locations, *locations_from_groups])
-            new_block.locations = sorted(dict.fromkeys(locations))
-            new_block.resolved_locations = sorted(set(resolved_locations))
 
-            count = block.count
-            if not count:
-                count = (min(len(new_block.items), len(new_block.resolved_locations))
-                         if new_block.resolved_locations else len(new_block.items))
-            if isinstance(count, int):
-                count = {"min": count, "max": count}
-            if "min" not in count:
-                count["min"] = 0
-            if "max" not in count:
-                count["max"] = (min(len(new_block.items), len(new_block.resolved_locations))
-                                if new_block.resolved_locations else len(new_block.items))
-
-
-            new_block.count = count
-            plando_blocks[player].append(new_block)
-
-    return plando_blocks
-
-
-def resolve_early_locations_for_planned(multiworld: MultiWorld):
-    def warn(warning: str, force: bool | str) -> None:
-        if isinstance(force, bool):
-            logging.warning(f"{warning}")
-        else:
-            logging.debug(f"{warning}")
-
-    def failed(warning: str, force: bool | str) -> None:
-        if force is True:
-            raise Exception(warning)
-        else:
-            warn(warning, force)
-
-    swept_state = multiworld.state.copy()
-    swept_state.sweep_for_advancements()
-    reachable = frozenset(multiworld.get_reachable_locations(swept_state))
-    early_locations: dict[int, list[Location]] = collections.defaultdict(list)
-    non_early_locations: dict[int, list[Location]] = collections.defaultdict(list)
-    for loc in multiworld.get_unfilled_locations():
-        if loc in reachable:
-            early_locations[loc.player].append(loc)
-        else:  # not reachable with swept state
-            non_early_locations[loc.player].append(loc)
-
-    for player in multiworld.plando_item_blocks:
-        removed = []
-        for block in multiworld.plando_item_blocks[player]:
-            locations = block.locations
-            resolved_locations = block.resolved_locations
-            worlds = block.worlds
             if "early_locations" in locations:
+                locations.remove("early_locations")
                 for target_player in worlds:
-                    resolved_locations += early_locations[target_player]
+                    locations += early_locations[target_player]
             if "non_early_locations" in locations:
+                locations.remove("non_early_locations")
                 for target_player in worlds:
-                    resolved_locations += non_early_locations[target_player]
+                    locations += non_early_locations[target_player]
 
-            if block.count["max"] > len(block.items):
+            block['locations'] = list(dict.fromkeys(locations))
-                count = block.count["max"]
-                failed(f"Plando count {count} greater than items specified", block.force)
-                block.count["max"] = len(block.items)
-                if block.count["min"] > len(block.items):
-                    block.count["min"] = len(block.items)
-            if block.count["max"] > len(block.resolved_locations) > 0:
-                count = block.count["max"]
-                failed(f"Plando count {count} greater than locations specified", block.force)
-                block.count["max"] = len(block.resolved_locations)
-                if block.count["min"] > len(block.resolved_locations):
-                    block.count["min"] = len(block.resolved_locations)
-            block.count["target"] = multiworld.random.randint(block.count["min"],
-                                                                     block.count["max"])
 
-            if not block.count["target"]:
+            if not block['count']:
-                removed.append(block)
+                block['count'] = (min(len(block['items']), len(block['locations'])) if
+                                  len(block['locations']) > 0 else len(block['items']))
+            if isinstance(block['count'], int):
+                block['count'] = {'min': block['count'], 'max': block['count']}
+            if 'min' not in block['count']:
+                block['count']['min'] = 0
+            if 'max' not in block['count']:
+                block['count']['max'] = (min(len(block['items']), len(block['locations'])) if
+                                         len(block['locations']) > 0 else len(block['items']))
+            if block['count']['max'] > len(block['items']):
+                count = block['count']
+                failed(f"Plando count {count} greater than items specified", block['force'])
+                block['count'] = len(block['items'])
+            if block['count']['max'] > len(block['locations']) > 0:
+                count = block['count']
+                failed(f"Plando count {count} greater than locations specified", block['force'])
+                block['count'] = len(block['locations'])
+            block['count']['target'] = multiworld.random.randint(block['count']['min'], block['count']['max'])
 
-        for block in removed:
+            if block['count']['target'] > 0:
-            multiworld.plando_item_blocks[player].remove(block)
+                plando_blocks.append(block)
-
-
-def distribute_planned_blocks(multiworld: MultiWorld, plando_blocks: list[PlandoItemBlock]):
-    def warn(warning: str, force: bool | str) -> None:
-        if isinstance(force, bool):
-            logging.warning(f"{warning}")
-        else:
-            logging.debug(f"{warning}")
-
-    def failed(warning: str, force: bool | str) -> None:
-        if force is True:
-            raise Exception(warning)
-        else:
-            warn(warning, force)
 
     # shuffle, but then sort blocks by number of locations minus number of items,
     # so less-flexible blocks get priority
     multiworld.random.shuffle(plando_blocks)
-    plando_blocks.sort(key=lambda block: (len(block.resolved_locations) - block.count["target"]
+    plando_blocks.sort(key=lambda block: (len(block['locations']) - block['count']['target']
-                                          if len(block.resolved_locations) > 0
+                                          if len(block['locations']) > 0
-                                          else len(multiworld.get_unfilled_locations(block.player)) -
+                                          else len(multiworld.get_unfilled_locations(player)) - block['count']['target']))
-                                          block.count["target"]))
+
     for placement in plando_blocks:
-        player = placement.player
+        player = placement['player']
         try:
-            worlds = placement.worlds
+            worlds = placement['world']
-            locations = placement.resolved_locations
+            locations = placement['locations']
-            items = placement.items
+            items = placement['items']
-            maxcount = placement.count["target"]
+            maxcount = placement['count']['target']
-            from_pool = placement.from_pool
+            from_pool = placement['from_pool']
 
-            item_candidates = []
+            candidates = list(multiworld.get_unfilled_locations_for_players(locations, sorted(worlds)))
-            if from_pool:
-                instances = [item for item in multiworld.itempool if item.player == player and item.name in items]
-                for item in multiworld.random.sample(items, maxcount):
-                    candidate = next((i for i in instances if i.name == item), None)
-                    if candidate is None:
-                        warn(f"Could not remove {item} from pool for {multiworld.player_name[player]} as "
-                             f"it's already missing from it", placement.force)
-                        candidate = multiworld.worlds[player].create_item(item)
-                    else:
-                        multiworld.itempool.remove(candidate)
-                        instances.remove(candidate)
-                    item_candidates.append(candidate)
-            else:
-                item_candidates = [multiworld.worlds[player].create_item(item)
-                                   for item in multiworld.random.sample(items, maxcount)]
-            if any(item.code is None for item in item_candidates) \
-               and not all(item.code is None for item in item_candidates):
-                failed(f"Plando block for player {player} ({multiworld.player_name[player]}) contains both "
-                       f"event items and non-event items. "
-                       f"Event items: {[item for item in item_candidates if item.code is None]}, "
-                       f"Non-event items: {[item for item in item_candidates if item.code is not None]}",
-                       placement.force)
-                continue
-            else:
-                is_real = item_candidates[0].code is not None
-            candidates = [candidate for candidate in locations if candidate.item is None
-                          and bool(candidate.address) == is_real]
             multiworld.random.shuffle(candidates)
-            allstate = multiworld.get_all_state(False)
+            multiworld.random.shuffle(items)
-            mincount = placement.count["min"]
+            count = 0
-            allowed_margin = len(item_candidates) - mincount
+            err: typing.List[str] = []
-            fill_restrictive(multiworld, allstate, candidates, item_candidates, lock=True,
+            successful_pairs: typing.List[typing.Tuple[Item, Location]] = []
-                             allow_partial=True, name="Plando Main Fill")
+            for item_name in items:
+                item = multiworld.worlds[player].create_item(item_name)
+                for location in reversed(candidates):
+                    if (location.address is None) == (item.code is None):  # either both None or both not None
+                        if not location.item:
+                            if location.item_rule(item):
+                                if location.can_fill(multiworld.state, item, False):
+                                    successful_pairs.append((item, location))
+                                    candidates.remove(location)
+                                    count = count + 1
+                                    break
+                                else:
+                                    err.append(f"Can't place item at {location} due to fill condition not met.")
+                            else:
+                                err.append(f"{item_name} not allowed at {location}.")
+                        else:
+                            err.append(f"Cannot place {item_name} into already filled location {location}.")
+                    else:
+                        err.append(f"Mismatch between {item_name} and {location}, only one is an event.")
+                if count == maxcount:
+                    break
+            if count < placement['count']['min']:
+                m = placement['count']['min']
+                failed(
+                    f"Plando block failed to place {m - count} of {m} item(s) for {multiworld.player_name[player]}, error(s): {' '.join(err)}",
+                    placement['force'])
+            for (item, location) in successful_pairs:
+                multiworld.push_item(location, item, collect=False)
+                location.locked = True
+                logging.debug(f"Plando placed {item} at {location}")
+                if from_pool:
+                    try:
+                        multiworld.itempool.remove(item)
+                    except ValueError:
+                        warn(
+                            f"Could not remove {item} from pool for {multiworld.player_name[player]} as it's already missing from it.",
+                            placement['force'])
 
-            if len(item_candidates) > allowed_margin:
-                failed(f"Could not place {len(item_candidates)} "
-                       f"of {mincount + allowed_margin} item(s) "
-                       f"for {multiworld.player_name[player]}, "
-                       f"remaining items: {item_candidates}",
-                       placement.force)
-            if from_pool:
-                multiworld.itempool.extend([item for item in item_candidates if item.code is not None])
         except Exception as e:
             raise Exception(
                 f"Error running plando for player {player} ({multiworld.player_name[player]})") from e

Generate.py

@@ -1,32 +1,36 @@
 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
-from itertools import chain
+from typing import Any, Dict, Tuple, Union
-from typing import Any
 
 import ModuleUpdate
 
 ModuleUpdate.update()
 
+import copy
 import Utils
 import Options
 from BaseClasses import seeddigits, get_seed, PlandoOptions
+from Main import main as ERmain
+from settings import get_settings
 from Utils import parse_yamls, version_tuple, __version__, tuplize_version
+from worlds.alttp.EntranceRandomizer import parse_arguments
+from worlds.alttp.Text import TextTable
+from worlds.AutoWorld import AutoWorldRegister
+from worlds.generic import PlandoConnection
+from worlds import failed_world_loads
 
 
-def mystery_argparse(argv: list[str] | None = None) -> argparse.Namespace:
+def mystery_argparse():
-    from settings import get_settings
+    options = get_settings()
-    settings = get_settings()
+    defaults = options.generator
-    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,
@@ -38,56 +42,41 @@ def mystery_argparse(argv: list[str] | None = None) -> argparse.Namespace:
     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=settings.general_options.output_path,
+    parser.add_argument('--outputpath', default=options.general_options.output_path,
                         help="Path to output folder. Absolute or relative to cwd.")  # absolute or relative to cwd
     parser.add_argument('--race', action='store_true', default=defaults.race)
     parser.add_argument('--meta_file_path', default=defaults.meta_file_path)
-    parser.add_argument('--log_level', default=defaults.loglevel, help='Sets log level')
+    parser.add_argument('--log_level', default='info', help='Sets log level')
-    parser.add_argument('--log_time', help="Add timestamps to STDOUT",
+    parser.add_argument('--yaml_output', default=0, type=lambda value: max(int(value), 0),
-                        default=defaults.logtime, action='store_true')
+                        help='Output rolled mystery results to yaml up to specified number (made for async multiworld)')
-    parser.add_argument("--csv_output", action="store_true",
+    parser.add_argument('--plando', default=defaults.plando_options,
-                        help="Output rolled player options to csv (made for async multiworld).")
+                        help='List of options that can be set manually. Can be combined, for example "bosses, items"')
-    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",
+    args = parser.parse_args()
-                        help="Skips generation assertion and multidata, outputting only a spoiler log. "
-                             "Intended for debugging and testing purposes.")
-    args = parser.parse_args(argv)
-
-    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.from_option_string(args.plando)
+    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) -> tuple[argparse.Namespace, int]:
+def main(args=None, callback=ERmain):
-    # __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 = mystery_argparse()
+        args, options = mystery_argparse()
+    else:
+        options = get_settings()
 
     seed = get_seed(args.seed)
-
+    Utils.init_logging(f"Generate_{seed}", loglevel=args.log_level)
-    Utils.init_logging(f"Generate_{seed}", loglevel=args.log_level, add_timestamp=args.log_time)
     random.seed(seed)
     seed_name = get_seed_name(random)
 
@@ -95,7 +84,7 @@ def main(args=None) -> tuple[argparse.Namespace, int]:
         logging.info("Race mode enabled. Using non-deterministic random source.")
         random.seed()  # reset to time-based random source
 
-    weights_cache: dict[str, tuple[Any, ...]] = {}
+    weights_cache: Dict[str, Tuple[Any, ...]] = {}
     if args.weights_file_path and os.path.exists(args.weights_file_path):
         try:
             weights_cache[args.weights_file_path] = read_weights_yamls(args.weights_file_path)
@@ -118,30 +107,17 @@ def main(args=None) -> tuple[argparse.Namespace, int]:
             raise Exception("Cannot mix --sameoptions with --meta")
     else:
         meta_weights = None
-
+    player_id = 1
-    player_id: int = 1
+    player_files = {}
-    player_files: dict[int, str] = {}
-    player_errors: list[str] = []
     for file in os.scandir(args.player_files_path):
         fname = file.name
-        if file.is_file() and not fname.startswith(".") and not fname.lower().endswith(".ini") and \
+        if file.is_file() and not fname.startswith(".") 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_for_file = []
+                weights_cache[fname] = read_weights_yamls(path)
-                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:
-                logging.exception(f"Exception reading weights in file {fname}")
+                raise ValueError(f"File {fname} is invalid. Please fix your yaml.") from e
-                player_errors.append(
-                    f"{len(player_errors) + 1}. "
-                    f"File {fname} is invalid. Please fix your yaml.\n{Utils.get_all_causes(e)}"
-                )
 
     # sort dict for consistent results across platforms:
     weights_cache = {key: value for key, value in sorted(weights_cache.items(), key=lambda k: k[0].casefold())}
@@ -156,10 +132,6 @@ def main(args=None) -> tuple[argparse.Namespace, int]:
     args.multi = max(player_id - 1, args.multi)
 
     if args.multi == 0:
-        if player_errors:
-            errors = "\n\n".join(player_errors)
-            raise ValueError(f"Encountered {len(player_errors)} error(s) in player files. "
-                             f"See logs for full tracebacks.\n\n{errors}")
         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."
@@ -169,19 +141,22 @@ def main(args=None) -> tuple[argparse.Namespace, int]:
                  f"{seed_name} Seed {seed} with plando: {args.plando}")
 
     if not weights_cache:
-        if player_errors:
-            errors = "\n\n".join(player_errors)
-            raise ValueError(f"Encountered {len(player_errors)} error(s) in player files. "
-                             f"See logs for full tracebacks.\n\n{errors}")
         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.spoiler = args.spoiler
+    erargs.race = args.race
+    erargs.outputname = seed_name
+    erargs.outputpath = args.outputpath
+    erargs.skip_prog_balancing = args.skip_prog_balancing
+    erargs.skip_output = args.skip_output
 
-    from worlds.AutoWorld import AutoWorldRegister
+    settings_cache: Dict[str, Tuple[argparse.Namespace, ...]] = \
-    args.outputname = seed_name
+        {fname: (tuple(roll_settings(yaml, args.plando) for yaml in yamls) if args.sameoptions else None)
-    args.sprite = dict.fromkeys(range(1, args.multi+1), None)
+         for fname, yamls in weights_cache.items()}
-    args.sprite_pool = dict.fromkeys(range(1, args.multi+1), None)
-    args.name = {}
 
     if meta_weights:
         for category_name, category_dict in meta_weights.items():
@@ -197,98 +172,73 @@ def main(args=None) -> tuple[argparse.Namespace, int]:
                                         yaml[category][key] = option
                             elif category_name not in yaml:
                                 logging.warning(f"Meta: Category {category_name} is not present in {path}.")
-                            elif key == "triggers":
-                                if "triggers" not in yaml[category_name]:
-                                    yaml[category_name][key] = []
-                                for trigger in option:
-                                    yaml[category_name][key].append(trigger)
                             else:
                                 yaml[category_name][key] = option
 
-    settings_cache: dict[str, tuple[argparse.Namespace, ...] | None] = {fname: None for fname in weights_cache}
+    player_path_cache = {}
-    if args.sameoptions:
-        for fname, yamls in weights_cache.items():
-            try:
-                settings_cache[fname] = tuple(roll_settings(yaml, args.plando) for yaml in yamls)
-            except Exception as e:
-                logging.exception(f"Exception reading settings in file {fname}")
-                player_errors.append(
-                    f"{len(player_errors) + 1}. "
-                    f"File {fname} is invalid. Please fix your yaml.\n{Utils.get_all_causes(e)}"
-                )
-        # Exit early here to avoid throwing the same errors again later
-        if player_errors:
-            errors = "\n\n".join(player_errors)
-            raise ValueError(f"Encountered {len(player_errors)} error(s) in player files. "
-                             f"See logs for full tracebacks.\n\n{errors}")
-
-    player_path_cache: dict[int, str] = {}
     for player in range(1, args.multi + 1):
         player_path_cache[player] = player_files.get(player, args.weights_file_path)
-    name_counter: Counter[str] = Counter()
+    name_counter = Counter()
-    args.player_options = {}
+    erargs.player_options = {}
 
     player = 1
     while player <= args.multi:
         path = player_path_cache[player]
-        if not path:
+        if path:
-            player_errors.append(f'No weights specified for player {player}')
-            player += 1
-            continue
-
-        for doc_index, yaml in enumerate(weights_cache[path]):
-            name = yaml.get("name")
             try:
-                # Use the cached settings object if it exists, otherwise roll settings within the try-catch
+                settings: Tuple[argparse.Namespace, ...] = settings_cache[path] if settings_cache[path] else \
-                # Invariant: settings_cache[path] and weights_cache[path] have the same length
+                    tuple(roll_settings(yaml, args.plando) for yaml in weights_cache[path])
-                cached = settings_cache[path]
+                for settingsObject in settings:
-                settings_object: argparse.Namespace = (cached[doc_index] if cached else roll_settings(yaml, args.plando))
+                    for k, v in vars(settingsObject).items():
+                        if v is not None:
+                            try:
+                                getattr(erargs, k)[player] = v
+                            except AttributeError:
+                                setattr(erargs, k, {player: v})
+                            except Exception as e:
+                                raise Exception(f"Error setting {k} to {v} for player {player}") from e
 
-                for k, v in vars(settings_object).items():
+                    if path == args.weights_file_path:  # if name came from the weights file, just use base player name
-                    if v is not None:
+                        erargs.name[player] = f"Player{player}"
-                        try:
+                    elif not erargs.name[player]:  # if name was not specified, generate it from filename
-                            getattr(args, k)[player] = v
+                        erargs.name[player] = os.path.splitext(os.path.split(path)[-1])[0]
-                        except AttributeError:
+                    erargs.name[player] = handle_name(erargs.name[player], player, name_counter)
-                            setattr(args, k, {player: v})
-                        except Exception as e:
-                            raise Exception(f"Error setting {k} to {v} for player {player}") from e
-
-                # name was not specified
-                if player not in 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:
-                logging.exception(f"Exception reading settings in file {path} document #{doc_index + 1} "
+                raise ValueError(f"File {path} is invalid. Please fix your yaml.") from e
-                                  f"(name: {args.name.get(player, name)})")
+        else:
-                player_errors.append(
+            raise RuntimeError(f'No weights specified for player {player}')
-                    f"{len(player_errors) + 1}. "
-                    f"File {path} document #{doc_index + 1} (name: {args.name.get(player, name)}) is invalid. "
-                    f"Please fix your yaml.\n{Utils.get_all_causes(e)}")
 
-            # increment for each yaml document in the file
+    if len(set(name.lower() for name in erargs.name.values())) != len(erargs.name):
-            player += 1
+        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):
+    if args.yaml_output:
-        player_errors.append(
+        import yaml
-            f"{len(player_errors) + 1}. "
+        important = {}
-            f"Names have to be unique. Names: {Counter(name.lower() for name in args.name.values())}"
+        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}'")
 
-    if player_errors:
+            else:
-        errors = "\n\n".join(player_errors)
+                if player_settings != "":  # is not empty name
-        raise ValueError(f"Encountered {len(player_errors)} error(s) in player files. "
+                    important[option] = player_settings
-                         f"See logs for full tracebacks.\n\n{errors}")
+                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)
 
-    return args, seed
+    return callback(erargs, seed)
 
 
-def read_weights_yamls(path) -> tuple[Any, ...]:
+def read_weights_yamls(path) -> Tuple[Any, ...]:
     try:
         if urllib.parse.urlparse(path).scheme in ('https', 'file'):
             yaml = str(urllib.request.urlopen(path).read(), "utf-8-sig")
@@ -298,20 +248,7 @@ def read_weights_yamls(path) -> tuple[Any, ...]:
     except Exception as e:
         raise Exception(f"Failed to read weights ({path})") from e
 
-    from yaml.error import MarkedYAMLError
+    return tuple(parse_yamls(yaml))
-    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:
@@ -351,76 +288,51 @@ def get_choice(option, root, value=None) -> Any:
     raise RuntimeError(f"All options specified in \"{option}\" are weighted as zero.")
 
 
-class SafeFormatter(string.Formatter):
+class SafeDict(dict):
-    def get_value(self, key, args, kwargs):
+    def __missing__(self, key):
-        if isinstance(key, int):
+        return '{' + key + '}'
-            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[str]):
+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,
-    new_name = SafeFormatter().vformat(new_name, (), {"number": number,
+                                                                 NUMBER=(number if number > 1 else ''),
-                                                      "NUMBER": (number if number > 1 else ''),
+                                                                 player=player,
-                                                      "player": player,
+                                                                 PLAYER=(player if player > 1 else '')))
-                                                      "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 roll_percentage(percentage: Union[int, float]) -> bool:
+    """Roll a percentage chance.
+    percentage is expected to be in range [0, 100]"""
+    return random.random() < (float(percentage) / 100)
+
+
 def update_weights(weights: dict, new_weights: dict, update_type: str, name: str) -> dict:
     logging.debug(f'Applying {new_weights}')
     cleaned_weights = {}
     for option in new_weights:
-        option_name = option.lstrip("+-")
+        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):
+            if isinstance(new_value, (set, dict)):
                 cleaned_value.update(new_value)
             elif isinstance(new_value, list):
                 cleaned_value.extend(new_value)
-            elif isinstance(new_value, dict):
-                counter_value = Counter(cleaned_value)
-                counter_value.update(new_value)
-                cleaned_value = dict(counter_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):
-                counter_value = Counter(cleaned_value)
-                counter_value.subtract(new_value)
-                cleaned_value = dict(counter_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:
-            # Options starting with + and - may modify values in-place, and new_weights may be shared by multiple slots
+            cleaned_weights[option_name] = new_weights[option]
-            # using the same .yaml, so ensure that the new value is a copy.
-            cleaned_value = copy.deepcopy(new_weights[option])
-            cleaned_weights[option_name] = cleaned_value
     new_options = set(cleaned_weights) - set(weights)
     weights.update(cleaned_weights)
     if new_options:
@@ -431,9 +343,7 @@ def update_weights(weights: dict, new_weights: dict, update_type: str, name: str
     return weights
 
 
-def roll_meta_option(option_key, game: str, category_dict: dict) -> Any:
+def roll_meta_option(option_key, game: str, category_dict: Dict) -> Any:
-    from worlds import AutoWorldRegister
-
     if not game:
         return get_choice(option_key, category_dict)
     if game in AutoWorldRegister.world_types:
@@ -443,8 +353,6 @@ def roll_meta_option(option_key, game: str, category_dict: dict) -> Any:
             if options[option_key].supports_weighting:
                 return get_choice(option_key, category_dict)
             return category_dict[option_key]
-        if option_key == "triggers":
-            return category_dict[option_key]
     raise Options.OptionError(f"Error generating meta option {option_key} for {game}.")
 
 
@@ -454,7 +362,7 @@ def roll_linked_options(weights: dict) -> dict:
         if "name" not in option_set:
             raise ValueError("One of your linked options does not have a name.")
         try:
-            if Options.roll_percentage(option_set["percentage"]):
+            if roll_percentage(option_set["percentage"]):
                 logging.debug(f"Linked option {option_set['name']} triggered.")
                 new_options = option_set["options"]
                 for category_name, category_options in new_options.items():
@@ -487,7 +395,7 @@ def roll_triggers(weights: dict, triggers: list, valid_keys: set) -> dict:
             trigger_result = get_choice("option_result", option_set)
             result = get_choice(key, currently_targeted_weights)
             currently_targeted_weights[key] = result
-            if result == trigger_result and Options.roll_percentage(get_choice("percentage", option_set, 100)):
+            if result == trigger_result and roll_percentage(get_choice("percentage", option_set, 100)):
                 for category_name, category_options in option_set["options"].items():
                     currently_targeted_weights = weights
                     if category_name:
@@ -500,40 +408,30 @@ def roll_triggers(weights: dict, triggers: list, valid_keys: set) -> dict:
     return weights
 
 
-def handle_option(ret: argparse.Namespace, game_weights: dict, option_key: str, option: type[Options.Option], plando_options: PlandoOptions):
+def handle_option(ret: argparse.Namespace, game_weights: dict, option_key: str, option: type(Options.Option), plando_options: PlandoOptions):
     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))
+            del game_weights[option_key]
         else:
             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:
-        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"}
+    valid_trigger_names = set()
     if "triggers" in weights:
-        weights = roll_triggers(weights, weights["triggers"], valid_keys)
+        weights = roll_triggers(weights, weights["triggers"], valid_trigger_names)
 
     requirements = weights.get("requires", {})
     if requirements:
@@ -546,34 +444,14 @@ def roll_settings(weights: dict, plando_options: PlandoOptions = PlandoOptions.b
             if required_plando_options:
                 raise Exception(f"Settings reports required plando module {str(required_plando_options)}, "
                                 f"which is not enabled.")
-        games = requirements.get("game", {})
+
-        for game, version in games.items():
-            if game not in AutoWorldRegister.world_types:
-                continue
-            if not version:
-                raise Exception(f"Invalid version for game {game}: {version}.")
-            if isinstance(version, str):
-                version = {"min": version}
-            if "min" in version and tuplize_version(version["min"]) > AutoWorldRegister.world_types[game].world_version:
-                raise Exception(f"Settings reports required version of world \"{game}\" is at least {version['min']}, "
-                                f"however world is of version "
-                                f"{AutoWorldRegister.world_types[game].world_version.as_simple_string()}.")
-            if "max" in version and tuplize_version(version["max"]) < AutoWorldRegister.world_types[game].world_version:
-                raise Exception(f"Settings reports required version of world \"{game}\" is no later than {version['max']}, "
-                                f"however world is of version "
-                                f"{AutoWorldRegister.world_types[game].world_version.as_simple_string()}.")
     ret = argparse.Namespace()
     for option_key in Options.PerGameCommonOptions.type_hints:
         if option_key in weights and option_key not in Options.CommonOptions.type_hints:
             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}. "
@@ -588,14 +466,12 @@ def roll_settings(weights: dict, plando_options: PlandoOptions = PlandoOptions.b
     world_type = AutoWorldRegister.world_types[ret.game]
     game_weights = weights[ret.game]
 
-    for weight in chain(game_weights, weights):
+    if any(weight.startswith("+") for weight in game_weights) or \
-        if weight.startswith("+"):
+       any(weight.startswith("+") for weight in weights):
-            raise Exception(f"Merge tag cannot be used outside of trigger contexts. Found {weight}")
+        raise Exception(f"Merge tag cannot be used outside of trigger contexts.")
-        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"], valid_keys)
+        weights = roll_triggers(weights, game_weights["triggers"], valid_trigger_names)
         game_weights = weights[ret.game]
 
     ret.name = get_choice('name', weights)
@@ -604,24 +480,42 @@ def roll_settings(weights: dict, plando_options: PlandoOptions = PlandoOptions.b
 
     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:
+        if option_key in {"triggers", *valid_trigger_names}:
             continue
-        logging.warning(f"{option_key} is not a valid option name for {ret.game} and is not present in triggers "
+        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}.")
+    if PlandoOptions.items in plando_options:
+        ret.plando_items = game_weights.get("plando_items", [])
+    if ret.game == "A Link to the Past":
+        roll_alttp_settings(ret, game_weights, plando_options)
+    if PlandoOptions.connections in plando_options:
+        ret.plando_connections = []
+        options = game_weights.get("plando_connections", [])
+        for placement in options:
+            if roll_percentage(get_choice("percentage", placement, 100)):
+                ret.plando_connections.append(PlandoConnection(
+                    get_choice("entrance", placement),
+                    get_choice("exit", placement),
+                    get_choice("direction", placement, "both")
+                ))
 
     return ret
 
 
-def roll_alttp_settings(ret: argparse.Namespace, weights):
+def roll_alttp_settings(ret: argparse.Namespace, weights, plando_options):
+
+    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.sprite_pool = weights.get('sprite_pool', [])
     ret.sprite = get_choice_legacy('sprite', weights, "Link")
     if 'random_sprite_on_event' in weights:
@@ -649,9 +543,7 @@ def roll_alttp_settings(ret: argparse.Namespace, weights):
 if __name__ == '__main__':
     import atexit
     confirmation = atexit.register(input, "Press enter to close.")
-    erargs, seed = main()
+    multiworld = main()
-    from Main import main as ERmain
-    multiworld = ERmain(erargs, seed)
     if __debug__:
         import gc
         import sys

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) 2025 Berserker66
+Copyright (c) 2022 Berserker66
 Copyright (c) 2022 CaitSith2
 Copyright (c) 2021 LegendaryLinux
 

Launcher.py

@@ -1,62 +1,51 @@
 """
-Archipelago Launcher
+Archipelago launcher for bundled app.
 
-* If run with a patch file as argument, launch corresponding client with the patch file as an argument.
+* if run with APBP as argument, launch corresponding client.
-* If run with component name as argument, run it passing argv[2:] as arguments.
+* if run with executable as argument, run it passing argv[2:] as arguments
-* If run without arguments or unknown arguments, open launcher GUI.
+* if run without arguments, open launcher GUI
 
-Additional components can be added to worlds.LauncherComponents.components.
+Scroll down to components= to add components to the launcher as well as setup.py
 """
 
+
 import argparse
+import itertools
 import logging
 import multiprocessing
-import os
 import shlex
 import subprocess
 import sys
-import urllib.parse
 import webbrowser
-from collections.abc import Callable, Sequence
 from os.path import isfile
 from shutil import which
-from typing import Any
+from typing import Sequence, Union, Optional
+
+import Utils
+import settings
+from worlds.LauncherComponents import Component, components, Type, SuffixIdentifier, icon_paths
 
 if __name__ == "__main__":
     import ModuleUpdate
-
     ModuleUpdate.update()
 
-import settings
+from Utils import is_frozen, user_path, local_path, init_logging, open_filename, messagebox, \
-import Utils
+    is_windows, is_macos, is_linux
-from Utils import (init_logging, is_frozen, is_linux, is_macos, is_windows, local_path, messagebox, open_filename,
-                   user_path)
-
-if __name__ == "__main__":
-    init_logging('Launcher')
-
-from worlds.LauncherComponents import Component, components, icon_paths, SuffixIdentifier, Type
 
 
 def open_host_yaml():
-    s = settings.get_settings()
+    file = settings.get_settings().filename
-    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:
         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 = []
@@ -79,17 +68,12 @@ def open_patch():
             launch([*exe, file], component.cli)
 
 
-def generate_yamls(*args):
+def generate_yamls():
     from Options import generate_yaml_templates
 
-    parser = argparse.ArgumentParser(description="Generate Template Options", usage="[-h] [--skip_open_folder]")
-    parser.add_argument("--skip_open_folder", action="store_true")
-    args = parser.parse_args(args)
-
     target = Utils.user_path("Players", "Templates")
     generate_yaml_templates(target, False)
-    if not args.skip_open_folder:
+    open_folder(target)
-        open_folder(target)
 
 
 def browse_files():
@@ -99,20 +83,12 @@ def browse_files():
 def open_folder(folder_path):
     if is_linux:
         exe = which('xdg-open') or which('gnome-open') or which('kde-open')
+        subprocess.Popen([exe, folder_path])
     elif is_macos:
         exe = which("open")
+        subprocess.Popen([exe, folder_path])
     else:
         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}")
 
 
 def update_settings():
@@ -122,51 +98,16 @@ def update_settings():
 
 components.extend([
     # Functions
-    Component("Open host.yaml", func=open_host_yaml,
+    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),
-    Component("Open Patch", func=open_patch,
+    Component("Generate Template Options", func=generate_yamls),
-              description="Open a patch file, downloaded from the room page or provided by the host."),
+    Component("Discord Server", icon="discord", func=lambda: webbrowser.open("https://discord.gg/8Z65BR2")),
-    Component("Generate Template Options", func=generate_yamls,
+    Component("Unrated/18+ Discord Server", icon="discord", func=lambda: webbrowser.open("https://discord.gg/fqvNCCRsu4")),
-              description="Generate template YAMLs for currently installed games."),
+    Component("Browse Files", func=browse_files),
-    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 handle_uri(path: str) -> tuple[list[Component], Component]:
+def identify(path: Union[None, str]):
-    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
     for component in components:
@@ -177,7 +118,7 @@ def identify(path: None | str) -> tuple[None | str, None | Component]:
     return None, None
 
 
-def get_exe(component: str | Component) -> Sequence[str] | None:
+def get_exe(component: Union[str, Component]) -> Optional[Sequence[str]]:
     if isinstance(component, str):
         name = component
         component = None
@@ -205,8 +146,7 @@ def get_exe(component: str | Component) -> Sequence[str] | None:
 def launch(exe, in_terminal=False):
     if in_terminal:
         if is_windows:
-            # intentionally using a window title with a space so it gets quoted and treated as a title
+            subprocess.Popen(['start', *exe], shell=True)
-            subprocess.Popen(["start", "Running Archipelago", *exe], shell=True)
             return
         elif is_linux:
             terminal = which('x-terminal-emulator') or which('gnome-terminal') or which('xterm')
@@ -220,301 +160,139 @@ def launch(exe, in_terminal=False):
     subprocess.Popen(exe)
 
 
-def create_shortcut(button: Any, component: Component) -> None:
+def run_gui():
-    from pyshortcuts import make_shortcut
+    from kvui import App, ContainerLayout, GridLayout, Button, Label, ScrollBox, Widget
-    env = os.environ
+    from kivy.uix.image import AsyncImage
-    if "APPIMAGE" in env:
+    from kivy.uix.relativelayout import RelativeLayout
-        script = env["ARGV0"]
-        wkdir = None # defaults to ~ on Linux
-    else:
-        script = sys.argv[0]
-        wkdir = Utils.local_path()
 
-    script = f"{script} \"{component.display_name}\""
+    class Launcher(App):
-    make_shortcut(script, name=f"Archipelago {component.display_name}", icon=local_path("data", "icon.ico"),
-                  startmenu=False, terminal=False, working_dir=wkdir, noexe=Utils.is_frozen())
-    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"
-        top_screen: MDFloatLayout = ObjectProperty(None)
+        container: ContainerLayout
-        navigation: MDGridLayout = ObjectProperty(None)
+        grid: GridLayout
-        grid: MDGridLayout = ObjectProperty(None)
-        button_layout: ScrollBox = ObjectProperty(None)
-        search_box: MDTextField = ObjectProperty(None)
-        cards: list[LauncherCard]
-        current_filter: Sequence[str | Type] | None
 
-        def __init__(self, ctx=None, components=None, args=None):
+        _tools = {c.display_name: c for c in components if c.type == Type.TOOL}
-            self.title = self.base_title + " " + Utils.__version__
+        _clients = {c.display_name: c for c in components if c.type == Type.CLIENT}
+        _adjusters = {c.display_name: c for c in components if c.type == Type.ADJUSTER}
+        _miscs = {c.display_name: c for c in components if c.type == Type.MISC}
+
+        def __init__(self, ctx=None):
+            self.title = self.base_title
             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.top_screen = Builder.load_file(Utils.local_path("data/launcher.kv"))
+            self.container = ContainerLayout()
-            self.grid = self.top_screen.ids.grid
+            self.grid = GridLayout(cols=2)
-            self.navigation = self.top_screen.ids.navigation
+            self.container.add_widget(self.grid)
-            self.button_layout = self.top_screen.ids.button_layout
+            self.grid.add_widget(Label(text="General", size_hint_y=None, height=40))
-            self.search_box = self.top_screen.ids.search_box
+            self.grid.add_widget(Label(text="Clients", size_hint_y=None, height=40))
-            self.set_colors()
+            tool_layout = ScrollBox()
-            self.top_screen.md_bg_color = self.theme_cls.backgroundColor
+            tool_layout.layout.orientation = "vertical"
+            self.grid.add_widget(tool_layout)
+            client_layout = ScrollBox()
+            client_layout.layout.orientation = "vertical"
+            self.grid.add_widget(client_layout)
 
-            global refresh_components
+            def build_button(component: Component) -> Widget:
-            refresh_components = self._refresh_components
+                """
+                Builds a button widget for a given component.
 
-            Window.bind(on_drop_file=self._on_drop_file)
+                Args:
-            Window.bind(on_keyboard=self._on_keyboard)
+                    component (Component): The component associated with the button.
 
-            for component in components:
+                Returns:
-                self.cards.append(self.build_card(component))
+                    None. The button is added to the parent grid layout.
 
-            self._refresh_components(self.current_filter)
+                """
+                button = Button(text=component.display_name, size_hint_y=None, height=40)
+                button.component = component
+                button.bind(on_release=self.component_action)
+                if component.icon != "icon":
+                    image = AsyncImage(source=icon_paths[component.icon],
+                                       size=(38, 38), size_hint=(None, 1), pos=(5, 0))
+                    box_layout = RelativeLayout(size_hint_y=None, height=40)
+                    box_layout.add_widget(button)
+                    box_layout.add_widget(image)
+                    return box_layout
+                return button
 
-            # Uncomment to re-enable the Kivy console/live editor
+            for (tool, client) in itertools.zip_longest(itertools.chain(
-            # Ctrl-E to enable it, make sure numlock/capslock is disabled
+                    self._tools.items(), self._miscs.items(), self._adjusters.items()), self._clients.items()):
-            # from kivy.modules.console import create_console
+                # column 1
-            # create_console(Window, self.top_screen)
+                if tool:
+                    tool_layout.layout.add_widget(build_button(tool[1]))
+                # column 2
+                if client:
+                    client_layout.layout.add_widget(build_button(client[1]))
 
-            return self.top_screen
+            return self.container
-
-        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):
-            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)
 
-        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):
+    Launcher().run()
-            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 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):
+def main(args: Optional[Union[argparse.Namespace, dict]] = None):
     if isinstance(args, argparse.Namespace):
         args = {k: v for k, v in args._get_kwargs()}
     elif not args:
         args = {}
 
-    path = args.get("Patch|Game|Component|url", None)
+    if args.get("Patch|Game|Component", None) is not None:
-    if path is not None:
+        file, component = identify(args["Patch|Game|Component"])
-        if path.startswith("archipelago://"):
+        if file:
-            args["args"] = (path, *args.get("args", ()))
+            args['file'] = file
-            # add the url arg to the passthrough args
+        if component:
-            components, text_client_component = handle_uri(path)
+            args['component'] = component
-            if not components:
+        if not component:
-                args["component"] = text_client_component
+            logging.warning(f"Could not identify Component responsible for {args['Patch|Game|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 args["update_settings"]:
         update_settings()
-    if "file" in args:
+    if 'file' in args:
         run_component(args["component"], args["file"], *args["args"])
-    elif "component" in 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", ()))
+        run_gui()
 
 
 if __name__ == '__main__':
-    multiprocessing.freeze_support()
+    init_logging('Launcher')
+    Utils.freeze_support()
     multiprocessing.set_start_method("spawn")  # if launched process uses kivy, fork won't work
-    parser = argparse.ArgumentParser(
+    parser = argparse.ArgumentParser(description='Archipelago Launcher')
-        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="?",
+    run_group.add_argument("Patch|Game|Component", type=str, nargs="?",
-                           help="Pass either a patch file, a generated game, the component name to run, or a url to "
+                           help="Pass either a patch file, a generated game or the name of a component to run.")
-                                "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

LinksAwakeningClient.py

@@ -3,6 +3,9 @@ ModuleUpdate.update()
 
 import Utils
 
+if __name__ == "__main__":
+    Utils.init_logging("LinksAwakeningContext", exception_logger="Client")
+
 import asyncio
 import base64
 import binascii
@@ -23,14 +26,14 @@ import typing
 from CommonClient import (CommonContext, get_base_parser, gui_enabled, logger,
                           server_loop)
 from NetUtils import ClientStatus
-from . import LinksAwakeningWorld
+from worlds.ladx.Common import BASE_ID as LABaseID
-from .Common import BASE_ID as LABaseID
+from worlds.ladx.GpsTracker import GpsTracker
-from .GpsTracker import GpsTracker
+from worlds.ladx.ItemTracker import ItemTracker
-from .TrackerConsts import storage_key
+from worlds.ladx.LADXR.checkMetadata import checkMetadataTable
-from .ItemTracker import ItemTracker
+from worlds.ladx.Locations import get_locations_to_id, meta_to_name
-from .LADXR.checkMetadata import checkMetadataTable
+from worlds.ladx.Tracker import LocationTracker, MagpieBridge
-from .Locations import get_locations_to_id, meta_to_name
+
-from .Tracker import LocationTracker, MagpieBridge, Check
+
 class GameboyException(Exception):
     pass
 
@@ -47,8 +50,20 @@ class BadRetroArchResponse(GameboyException):
     pass
 
 
-class VersionError(Exception):
+def magpie_logo():
-    pass
+    from kivy.uix.image import CoreImage
+    binary_data = """
+iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAIAAACQkWg2AAAAAXN
+SR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA
+7DAcdvqGQAAADGSURBVDhPhVLBEcIwDHOYhjHCBuXHj2OTbAL8+
+MEGZIxOQ1CinOOk0Op0bmo7tlXXeR9FJMYDLOD9mwcLjQK7+hSZ
+wgcWMZJOAGeGKtChNHFL0j+FZD3jSCuo0w7l03wDrWdg00C4/aW
+eDEYNenuzPOfPspBnxf0kssE80vN0L8361j10P03DK4x6FHabuV
+ear8fHme+b17rwSjbAXeUMLb+EVTV2QHm46MWQanmnydA98KsVS
+XkV+qFpGQXrLhT/fqraQeQLuplpNH5g+WkAAAAASUVORK5CYII="""
+    binary_data = base64.b64decode(binary_data)
+    data = io.BytesIO(binary_data)
+    return CoreImage(data, ext="png").texture
 
 
 class LAClientConstants:
@@ -85,23 +100,19 @@ class LAClientConstants:
     WRamCheckSize = 0x4
     WRamSafetyValue = bytearray([0]*WRamCheckSize)
 
-    wRamStart = 0xC000
-    hRamStart = 0xFF80
-    hRamSize = 0x80
-
     MinGameplayValue = 0x06
     MaxGameplayValue = 0x1A
     VictoryGameplayAndSub = 0x0102
 
+
 class RAGameboy():
     cache = []
+    cache_start = 0
+    cache_size = 0
     last_cache_read = None
     socket = None
 
     def __init__(self, address, port) -> None:
-        self.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)
@@ -120,14 +131,9 @@ class RAGameboy():
     async def get_retroarch_status(self):
         return await self.send_command("GET_STATUS")
 
-    def set_checks_range(self, checks_start, checks_size):
+    def set_cache_limits(self, cache_start, cache_size):
-        self.checks_start = checks_start
+        self.cache_start = cache_start
-        self.checks_size = checks_size
+        self.cache_size = cache_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:
@@ -140,7 +146,7 @@ class RAGameboy():
         return response
 
     async def async_recv(self, timeout=1.0):
-        response = await asyncio.wait_for(asyncio.get_running_loop().sock_recv(self.socket, 4096), timeout)
+        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):
@@ -182,57 +188,21 @@ class RAGameboy():
         if not await self.check_safe_gameplay():
             return
 
-        attempts = 0
+        cache = []
-        while True:
+        remaining_size = self.cache_size
-            # RA doesn't let us do an atomic read of a large enough block of RAM
+        while remaining_size:
-            # Some bytes can't change in between reading location_block and hram_block
+            block = await self.async_read_memory(self.cache_start + len(cache), remaining_size)
-            location_block = await self.read_memory_block(self.location_start, self.location_size)
+            remaining_size -= len(block)
-            hram_block = await self.read_memory_block(LAClientConstants.hRamStart, LAClientConstants.hRamSize)
+            cache += block
-            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)
+        self.cache = cache
-
-        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):
+        # TODO: can we just update once per frame?
         if not self.last_cache_read or self.last_cache_read + 0.1 < time.time():
             await self.update_cache()
         if not self.cache:
@@ -265,7 +235,7 @@ class RAGameboy():
 
     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
+            ok = re.match("\d+\.\d+\.\d+", response.decode('ascii')) is not None
         else:
             ok = response.startswith(command.encode())
         if not ok:
@@ -389,12 +359,11 @@ class LinksAwakeningClient():
         auth = binascii.hexlify(await self.gameboy.async_read_memory(0x0134, 12)).decode()
         self.auth = auth
 
-    async def wait_and_init_tracker(self, magpie: MagpieBridge):
+    async def wait_and_init_tracker(self):
         await self.wait_for_game_ready()
         self.tracker = LocationTracker(self.gameboy)
         self.item_tracker = ItemTracker(self.gameboy)
         self.gps_tracker = GpsTracker(self.gameboy)
-        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
@@ -411,10 +380,10 @@ class LinksAwakeningClient():
             status = (await self.gameboy.async_read_memory_safe(LAClientConstants.wLinkStatusBits))[0]
 
         item_id -= LABaseID
-        # The player name table only goes up to 101, so don't go past that
+        # 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 > 101:
+        if from_player > 100:
-            from_player = 101
+            from_player = 100
 
         next_index += 1
         self.gameboy.write_memory(LAClientConstants.wLinkGiveItem, [
@@ -436,11 +405,9 @@ class LinksAwakeningClient():
         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:
@@ -490,7 +457,7 @@ class LinksAwakeningContext(CommonContext):
     la_task = None
     client = None
     # TODO: does this need to re-read on reset?
-    found_checks = set()
+    found_checks = []
     last_resend = time.time()
 
     magpie_enabled = False
@@ -498,14 +465,8 @@ class LinksAwakeningContext(CommonContext):
     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()
@@ -513,42 +474,38 @@ class LinksAwakeningContext(CommonContext):
 
     def run_gui(self) -> None:
         import webbrowser
-        from kvui import GameManager
+        import kvui
-        from kivy.metrics import dp
+        from kvui import Button, GameManager
-        from kivymd.uix.button import MDButton, MDButtonText
+        from kivy.uix.image import Image
 
         class LADXManager(GameManager):
             logging_pairs = [
                 ("Client", "Archipelago"),
                 ("Tracker", "Tracker"),
             ]
-            base_title = f"Links Awakening DX Client {LinksAwakeningWorld.world_version.as_simple_string()} | Archipelago"
+            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,
+                    button = Button(text="", size=(30, 30), size_hint_x=None,
-                                      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'))
-                                      on_press=lambda _: webbrowser.open('https://magpietracker.us/?enable_autotracker=1'))
+                    image = Image(size=(16, 16), texture=magpie_logo())
-                    button.height = self.server_connect_bar.height
+                    button.add_widget(image)
-                    self.connect_layout.add_widget(button)
 
+                    def set_center(_, center):
+                        image.center = center
+                    button.bind(center=set_center)
+
+                    self.connect_layout.add_widget(button)
                 return b
 
         self.ui = LADXManager(self)
         self.ui_task = asyncio.create_task(self.ui.async_run(), name="UI")
 
-    async def send_new_entrances(self, entrances: typing.Dict[str, str]):
+    async def send_checks(self):
-        # Store the entrances we find on the server for future sessions
+        message = [{"cmd": 'LocationChecks', "locations": self.found_checks}]
-        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
@@ -578,19 +535,13 @@ class LinksAwakeningContext(CommonContext):
             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)
+        self.found_checks += item_ids
-        create_task_log_exception(self.check_locations(self.found_checks))
+        create_task_log_exception(self.send_checks())
         if self.magpie_enabled:
             create_task_log_exception(self.magpie.send_new_checks(ladxr_ids))
 
@@ -607,60 +558,21 @@ class LinksAwakeningContext(CommonContext):
 
         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", {})
-            generated_version = Utils.tuplize_version(self.slot_data.get("world_version", "2.0.0"))
-            client_version = LinksAwakeningWorld.world_version
-            if generated_version.major != client_version.major:
-                self.disconnected_intentionally = True
-                raise VersionError(
-                    f"The installed world ({client_version.as_simple_string()}) is incompatible with "
-                    f"the world this game was generated on ({generated_version.as_simple_string()})"
-                )
-            # 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,
-                "client_version": client_version.as_simple_string(),
-            })
-
-            # 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):
@@ -669,8 +581,6 @@ class LinksAwakeningContext(CommonContext):
                 checkMetadataTable[check.id])] for check in ladxr_checks]
             self.new_checks(checks, [check.id for check in ladxr_checks])
 
-            self.add_linked_items(ladxr_checks)
-
         async def victory():
             await self.send_victory()
 
@@ -704,38 +614,20 @@ class LinksAwakeningContext(CommonContext):
                 if not self.client.recvd_checks:
                     await self.sync()
 
-                await self.client.wait_and_init_tracker(self.magpie)
+                await self.client.wait_and_init_tracker()
 
-                min_tick_duration = 0.1
-                last_tick = time.time()
                 while True:
                     await self.client.main_tick(on_item_get, victory, deathlink)
-
+                    await asyncio.sleep(0.1)
                     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)
+                        await self.send_checks()
                     if self.magpie_enabled:
                         try:
                             self.magpie.set_checks(self.client.tracker.all_checks)
                             await self.magpie.set_item_tracker(self.client.item_tracker)
-                            if self.slot_data and "slot_data" in self.magpie.features and not self.magpie.has_sent_slot_data:
+                            await self.magpie.send_gps(self.client.gps_tracker)
-                                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
@@ -746,8 +638,8 @@ class LinksAwakeningContext(CommonContext):
                 await asyncio.sleep(1.0)
 
 def run_game(romfile: str) -> None:
-    auto_start = LinksAwakeningWorld.settings.rom_start
+    auto_start = typing.cast(typing.Union[bool, str],
-
+                            Utils.get_options()["ladx_options"].get("rom_start", True))
     if auto_start is True:
         import webbrowser
         webbrowser.open(romfile)
@@ -768,44 +660,42 @@ def run_game(romfile: str) -> None:
         except FileNotFoundError:
             logger.error(f"Couldn't launch ROM, {args[0]} is missing")
 
-def launch(*launch_args):
+async def main():
-    async def main():
+    parser = get_base_parser(description="Link's Awakening Client.")
-        parser = get_base_parser(description="Link's Awakening Client.")
+    parser.add_argument("--url", help="Archipelago connection url")
-        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("--no-magpie", dest='magpie', default=True, action='store_false', help="Disable magpie bridge")
+    parser.add_argument('diff_file', default="", type=str, nargs="?",
-        parser.add_argument('diff_file', default="", type=str, nargs="?",
+                        help='Path to a .apladx Archipelago Binary Patch file')
-                            help='Path to a .apladx Archipelago Binary Patch file')
 
-        args = parser.parse_args(launch_args)
+    args = parser.parse_args()
 
-        if args.diff_file:
+    if args.diff_file:
-            import Patch
+        import Patch
-            logger.info("patch file was supplied - creating rom...")
+        logger.info("patch file was supplied - creating rom...")
-            meta, rom_file = Patch.create_rom_file(args.diff_file)
+        meta, rom_file = Patch.create_rom_file(args.diff_file)
-            if "server" in meta and not args.connect:
+        if "server" in meta and not args.connect:
-                args.connect = meta["server"]
+            args.connect = meta["server"]
-            logger.info(f"wrote rom file to {rom_file}")
+        logger.info(f"wrote rom file to {rom_file}")
 
 
-        ctx = LinksAwakeningContext(args.connect, args.password, args.magpie)
+    ctx = LinksAwakeningContext(args.connect, args.password, args.magpie)
 
-        ctx.server_task = asyncio.create_task(server_loop(ctx), name="server loop")
+    ctx.server_task = asyncio.create_task(server_loop(ctx), name="server loop")
 
-        # TODO: nothing about the lambda about has to be in a lambda
+    # TODO: nothing about the lambda about has to be in a lambda
-        ctx.la_task = create_task_log_exception(ctx.run_game_loop())
+    ctx.la_task = create_task_log_exception(ctx.run_game_loop())
-        if gui_enabled:
+    if gui_enabled:
-            ctx.run_gui()
+        ctx.run_gui()
-        ctx.run_cli()
+    ctx.run_cli()
 
-        # Down below run_gui so that we get errors out of the process
+    # Down below run_gui so that we get errors out of the process
-        if args.diff_file:
+    if args.diff_file:
-            run_game(rom_file)
+        run_game(rom_file)
 
-        await ctx.exit_event.wait()
+    await ctx.exit_event.wait()
-        await ctx.shutdown()
+    await ctx.shutdown()
 
-    Utils.init_logging("LinksAwakeningContext", exception_logger="Client")
+if __name__ == '__main__':
-
+    colorama.init()
-    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, BOTH, TOP, LabelFrame, \
+from tkinter import Tk, Frame, Label, StringVar, Entry, filedialog, messagebox, Button, Radiobutton, LEFT, X, 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
@@ -29,19 +29,13 @@ from Utils import output_path, local_path, user_path, open_file, get_cert_none_s
 
 
 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.worlds = {1: self.AdjusterSubWorld(random)}
+        self.per_slot_randoms = {1: random}
 
 
 class ArgumentDefaultsHelpFormatter(argparse.RawTextHelpFormatter):
@@ -49,7 +43,6 @@ class ArgumentDefaultsHelpFormatter(argparse.RawTextHelpFormatter):
     def _get_help_string(self, action):
         return textwrap.dedent(action.help)
 
-
 # See argparse.BooleanOptionalAction
 class BooleanOptionalActionWithDisable(argparse.Action):
     def __init__(self,
@@ -249,17 +242,16 @@ def adjustGUI():
     from argparse import Namespace
     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, padx=8, pady=2)
+    bottomFrame2 = Frame(adjustWindow)
 
     romFrame, romVar = get_rom_frame(adjustWindow)
 
-    romDialogFrame = Frame(adjustWindow, padx=8, pady=2)
+    romDialogFrame = Frame(adjustWindow)
     baseRomLabel2 = Label(romDialogFrame, text='Rom to adjust')
     romVar2 = StringVar()
     romEntry2 = Entry(romDialogFrame, textvariable=romVar2)
@@ -269,9 +261,9 @@ def adjustGUI():
         romVar2.set(rom)
 
     romSelectButton2 = Button(romDialogFrame, text='Select Rom', command=RomSelect2)
-    romDialogFrame.pack(side=TOP, expand=False, fill=X)
+    romDialogFrame.pack(side=TOP, expand=True, fill=X)
-    baseRomLabel2.pack(side=LEFT, expand=False, fill=X, padx=(0, 8))
+    baseRomLabel2.pack(side=LEFT)
-    romEntry2.pack(side=LEFT, expand=True, fill=BOTH, pady=1)
+    romEntry2.pack(side=LEFT, expand=True, fill=X)
     romSelectButton2.pack(side=LEFT)
 
     def adjustRom():
@@ -339,11 +331,12 @@ def adjustGUI():
         messagebox.showinfo(title="Success", message="Settings saved to persistent storage")
 
     adjustButton = Button(bottomFrame2, text='Adjust Rom', command=adjustRom)
-    rom_options_frame.pack(side=TOP, padx=8, pady=8, fill=BOTH, expand=True)
+    rom_options_frame.pack(side=TOP)
     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)
@@ -365,10 +358,10 @@ def run_sprite_update():
     logging.info("Done updating sprites")
 
 
-def update_sprites(task, on_finish=None, repository_url: str = "https://alttpr.com/sprites"):
+def update_sprites(task, on_finish=None):
     resultmessage = ""
     successful = True
-    sprite_dir = user_path("data", "sprites", "alttp", "remote")
+    sprite_dir = user_path("data", "sprites", "alttpr")
     os.makedirs(sprite_dir, exist_ok=True)
     ctx = get_cert_none_ssl_context()
 
@@ -378,11 +371,11 @@ def update_sprites(task, on_finish=None, repository_url: str = "https://alttpr.c
             on_finish(successful, resultmessage)
 
     try:
-        task.update_status("Downloading remote sprites list")
+        task.update_status("Downloading alttpr sprites list")
-        with urlopen(repository_url, context=ctx) as response:
+        with urlopen('https://alttpr.com/sprites', context=ctx) as response:
             sprites_arr = json.loads(response.read().decode("utf-8"))
     except Exception as e:
-        resultmessage = "Error getting list of remote sprites. Sprites not updated.\n\n%s: %s" % (type(e).__name__, e)
+        resultmessage = "Error getting list of alttpr sprites. Sprites not updated.\n\n%s: %s" % (type(e).__name__, e)
         successful = False
         task.queue_event(finished)
         return
@@ -390,13 +383,13 @@ def update_sprites(task, on_finish=None, repository_url: str = "https://alttpr.c
     try:
         task.update_status("Determining needed sprites")
         current_sprites = [os.path.basename(file) for file in glob(sprite_dir + '/*')]
-        remote_sprites = [(sprite['file'], os.path.basename(urlparse(sprite['file']).path))
+        alttpr_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 remote_sprites if
+        needed_sprites = [(sprite_url, filename) for (sprite_url, filename) in alttpr_sprites if
                           filename not in current_sprites]
 
-        remote_filenames = [filename for (_, filename) in remote_sprites]
+        alttpr_filenames = [filename for (_, filename) in alttpr_sprites]
-        obsolete_sprites = [sprite for sprite in current_sprites if sprite not in remote_filenames]
+        obsolete_sprites = [sprite for sprite in current_sprites if sprite not in alttpr_filenames]
     except Exception as e:
         resultmessage = "Error Determining which sprites to update. Sprites not updated.\n\n%s: %s" % (
         type(e).__name__, e)
@@ -448,7 +441,7 @@ def update_sprites(task, on_finish=None, repository_url: str = "https://alttpr.c
                 successful = False
 
     if successful:
-        resultmessage = "Remote sprites updated successfully"
+        resultmessage = "alttpr sprites updated successfully"
 
     task.queue_event(finished)
 
@@ -583,7 +576,7 @@ class AttachTooltip(object):
 def get_rom_frame(parent=None):
     adjuster_settings = get_adjuster_settings(GAME_ALTTP)
 
-    romFrame = Frame(parent, padx=8, pady=8)
+    romFrame = Frame(parent)
     baseRomLabel = Label(romFrame, text='LttP Base Rom: ')
     romVar = StringVar(value=adjuster_settings.baserom)
     romEntry = Entry(romFrame, textvariable=romVar)
@@ -603,19 +596,20 @@ 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=BOTH, pady=1)
+    romEntry.pack(side=LEFT, expand=True, fill=X)
     romSelectButton.pack(side=LEFT)
-    romFrame.pack(side=TOP, fill=X)
+    romFrame.pack(side=TOP, expand=True, fill=X)
 
     return romFrame, romVar
 
 def get_rom_options_frame(parent=None):
     adjuster_settings = get_adjuster_settings(GAME_ALTTP)
 
-    romOptionsFrame = LabelFrame(parent, text="Rom options", padx=8, pady=8)
+    romOptionsFrame = LabelFrame(parent, text="Rom options")
-
+    romOptionsFrame.columnconfigure(0, weight=1)
+    romOptionsFrame.columnconfigure(1, weight=1)
     for i in range(5):
-        romOptionsFrame.rowconfigure(i, weight=0, pad=4)
+        romOptionsFrame.rowconfigure(i, weight=1)
     vars = Namespace()
 
     vars.MusicVar = IntVar()
@@ -666,7 +660,7 @@ def get_rom_options_frame(parent=None):
     spriteSelectButton = Button(spriteDialogFrame, text='...', command=SpriteSelect)
 
     baseSpriteLabel.pack(side=LEFT)
-    spriteEntry.pack(side=LEFT, expand=True, fill=X)
+    spriteEntry.pack(side=LEFT)
     spriteSelectButton.pack(side=LEFT)
 
     oofDialogFrame = Frame(romOptionsFrame)
@@ -869,7 +863,7 @@ class SpriteSelector():
         def open_custom_sprite_dir(_evt):
             open_file(self.custom_sprite_dir)
 
-        remote_frametitle = Label(self.window, text='Remote Sprites')
+        alttpr_frametitle = Label(self.window, text='ALTTPR Sprites')
 
         custom_frametitle = Frame(self.window)
         title_text = Label(custom_frametitle, text="Custom Sprites")
@@ -878,8 +872,8 @@ class SpriteSelector():
         title_link.pack(side=LEFT)
         title_link.bind("<Button-1>", open_custom_sprite_dir)
 
-        self.icon_section(remote_frametitle, self.remote_sprite_dir,
+        self.icon_section(alttpr_frametitle, self.alttpr_sprite_dir,
-                          'Remote sprites not found. Click "Update remote sprites" to download them.')
+                          'ALTTPR sprites not found. Click "Update alttpr 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:
@@ -892,18 +886,11 @@ 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 remote sprites", command=self.update_remote_sprites)
+        button = Button(frame, text="Update alttpr sprites", command=self.update_alttpr_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))
@@ -1063,7 +1050,7 @@ class SpriteSelector():
         for i, button in enumerate(frame.buttons):
             button.grid(row=i // self.spritesPerRow, column=i % self.spritesPerRow)
 
-    def update_remote_sprites(self):
+    def update_alttpr_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()
@@ -1076,8 +1063,7 @@ class SpriteSelector():
                 messagebox.showerror("Sprite Updater", resultmessage)
             SpriteSelector(self.parent, self.callback, self.adjuster)
 
-        BackgroundTaskProgress(self.parent, update_sprites, "Updating Sprites",
+        BackgroundTaskProgress(self.parent, update_sprites, "Updating Sprites", on_finish)
-                               on_finish, self.repository_url.get())
 
     def browse_for_sprite(self):
         sprite = filedialog.askopenfilename(
@@ -1167,13 +1153,12 @@ class SpriteSelector():
             os.makedirs(self.custom_sprite_dir)
 
     @property
-    def remote_sprite_dir(self):
+    def alttpr_sprite_dir(self):
-        return user_path("data", "sprites", "alttp", "remote")
+        return user_path("data", "sprites", "alttpr")
 
     @property
     def custom_sprite_dir(self):
-        return user_path("data", "sprites", "alttp", "custom")
+        return user_path("data", "sprites", "custom")
-
 
 def get_image_for_sprite(sprite, gif_only: bool = False):
     if not sprite.valid:

MMBN3Client.py

@@ -286,14 +286,16 @@ async def gba_sync_task(ctx: MMBN3Context):
             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
+    options = Utils.get_options().get("mmbn3_options", None)
-    auto_start = MMBN3World.settings.rom_start
+    if options is None:
-    if auto_start is True:
+        auto_start = True
+    else:
+        auto_start = options.get("rom_start", True)
+    if auto_start:
         import webbrowser
         webbrowser.open(romfile)
     elif os.path.isfile(auto_start):
@@ -368,7 +370,7 @@ if __name__ == "__main__":
 
     import colorama
 
-    colorama.just_fix_windows_console()
+    colorama.init()
 
     asyncio.run(main())
     colorama.deinit()

Main.py

@@ -1,21 +1,19 @@
 import collections
-from collections.abc import Mapping
 import concurrent.futures
 import logging
 import os
+import pickle
 import tempfile
 import time
-from typing import Any
 import zipfile
 import zlib
+from typing import Dict, List, Optional, Set, Tuple, Union
 
 import worlds
-from BaseClasses import CollectionState, Item, Location, LocationProgressType, MultiWorld
+from BaseClasses import CollectionState, Item, Location, LocationProgressType, MultiWorld, Region
-from Fill import FillError, balance_multiworld_progression, distribute_items_restrictive, flood_items, \
+from Fill import balance_multiworld_progression, distribute_items_restrictive, distribute_planned, 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 Utils import __version__, output_path, version_tuple
 from settings import get_settings
 from worlds import AutoWorld
 from worlds.generic.Rules import exclusion_rules, locality_rules
@@ -23,7 +21,7 @@ from worlds.generic.Rules import exclusion_rules, locality_rules
 __all__ = ["main"]
 
 
-def main(args, seed=None, baked_server_options: dict[str, object] | None = None):
+def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = None):
     if not baked_server_options:
         baked_server_options = get_settings().server_options.as_dict()
     assert isinstance(baked_server_options, dict)
@@ -37,16 +35,16 @@ def main(args, seed=None, baked_server_options: dict[str, object] | None = None)
 
     logger = logging.getLogger()
     multiworld.set_seed(seed, args.race, str(args.outputname) if args.outputname else None)
-    multiworld.plando_options = args.plando
+    multiworld.plando_options = args.plando_options
+    multiworld.plando_items = args.plando_items.copy()
+    multiworld.plando_texts = args.plando_texts.copy()
+    multiworld.plando_connections = args.plando_connections.copy()
     multiworld.game = args.game.copy()
     multiworld.player_name = args.name.copy()
     multiworld.sprite = args.sprite.copy()
     multiworld.sprite_pool = args.sprite_pool.copy()
 
     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)
@@ -54,23 +52,32 @@ def main(args, seed=None, baked_server_options: dict[str, object] | None = None)
     logger.info(f"Found {len(AutoWorld.AutoWorldRegister.world_types)} World Types:")
     longest_name = max(len(text) for text in AutoWorld.AutoWorldRegister.world_types)
 
-    world_classes = AutoWorld.AutoWorldRegister.world_types.values()
+    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))
 
-    version_count = max(len(cls.world_version.as_simple_string()) for cls in world_classes)
+    item_digits = len(str(max_item))
-    item_count = len(str(max(len(cls.item_names) for cls in world_classes)))
+    location_digits = len(str(max_location))
-    location_count = len(str(max(len(cls.location_names) for cls in world_classes)))
+    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}}: "
+            logger.info(f" {name:{longest_name}}: {len(cls.item_names):{item_count}} "
-                        f"v{cls.world_version.as_simple_string():{version_count}} | "
+                        f"Items (IDs: {min(cls.item_id_to_name):{item_digits}} - "
-                        f"Items: {len(cls.item_names):{item_count}} | "
+                        f"{max(cls.item_id_to_name):{item_digits}}) | "
-                        f"Locations: {len(cls.location_names):{location_count}}")
+                        f"{len(cls.location_names):{location_count}} "
+                        f"Locations (IDs: {min(cls.location_id_to_name):{location_digits}} - "
+                        f"{max(cls.location_id_to_name):{location_digits}})")
 
-    del item_count, location_count
+    del item_digits, location_digits, item_count, location_count
 
     # This assertion method should not be necessary to run if we are not outputting any multidata.
-    if not args.skip_output and not args.spoiler_only:
+    if not args.skip_output:
         AutoWorld.call_stage(multiworld, "assert_generate")
 
     AutoWorld.call_all(multiworld, "generate_early")
@@ -93,21 +100,12 @@ def main(args, seed=None, baked_server_options: dict[str, object] | None = None)
                 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)
+                    local_early = multiworld.early_local_items[player].get(item_name, 0)
                     if local_early:
                         multiworld.early_items[player][item_name] = max(0, local_early - remaining_count)
                     del local_early
             del early
 
-        # 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")
 
@@ -115,79 +113,155 @@ def main(args, seed=None, baked_server_options: dict[str, object] | None = None)
     AutoWorld.call_all(multiworld, "create_items")
 
     logger.info('Calculating Access Rules.')
+
+    for player in multiworld.player_ids:
+        # items can't be both local and non-local, prefer local
+        multiworld.worlds[player].options.non_local_items.value -= multiworld.worlds[player].options.local_items.value
+        multiworld.worlds[player].options.non_local_items.value -= set(multiworld.local_early_items[player])
+
     AutoWorld.call_all(multiworld, "set_rules")
 
     for player in multiworld.player_ids:
         exclusion_rules(multiworld, player, multiworld.worlds[player].options.exclude_locations.value)
         multiworld.worlds[player].options.priority_locations.value -= multiworld.worlds[player].options.exclude_locations.value
-        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:
+            except KeyError as e:  # failed to find the given location. Check if it's a legitimate location
-                continue
+                if location_name not in multiworld.worlds[player].location_name_to_id:
-
+                    raise Exception(f"Unable to prioritize location {location_name} in player {player}'s world.") from e
-            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.")
+                location.progress_type = LocationProgressType.PRIORITY
-                world_excluded_locations.add(location_name)
-        multiworld.worlds[player].options.priority_locations.value -= world_excluded_locations
 
     # 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)
-
+    else:
-    multiworld.plando_item_blocks = parse_planned_blocks(multiworld)
+        multiworld.worlds[1].options.non_local_items.value = set()
-
+        multiworld.worlds[1].options.local_items.value = set()
-    AutoWorld.call_all(multiworld, "connect_entrances")
+    
     AutoWorld.call_all(multiworld, "generate_basic")
 
     # remove starting inventory from pool items.
     # Because some worlds don't actually create items during create_items this has to be as late as possible.
-    fallback_inventory = StartInventoryPool({})
+    if any(getattr(multiworld.worlds[player].options, "start_inventory_from_pool", None) for player in multiworld.player_ids):
-    depletion_pool: dict[int, dict[str, int]] = {
+        new_items: List[Item] = []
-        player: getattr(multiworld.worlds[player].options, "start_inventory_from_pool", fallback_inventory).value.copy()
+        depletion_pool: Dict[int, Dict[str, int]] = {
-        for player in multiworld.player_ids
+            player: getattr(multiworld.worlds[player].options,
-    }
+                            "start_inventory_from_pool",
-    target_per_player = {
+                            StartInventoryPool({})).value.copy()
-        player: sum(target_items.values()) for player, target_items in depletion_pool.items() if target_items
+            for player in multiworld.player_ids
-    }
+        }
-
+        for player, items in depletion_pool.items():
-    if target_per_player:
+            player_world: AutoWorld.World = multiworld.worlds[player]
-        new_itempool: list[Item] = []
+            for count in items.values():
-
+                for _ in range(count):
-        # Make new itempool with start_inventory_from_pool items removed
+                    new_items.append(player_world.create_filler())
-        for item in multiworld.itempool:
+        target: int = sum(sum(items.values()) for items in depletion_pool.values())
+        for i, item in enumerate(multiworld.itempool):
             if depletion_pool[item.player].get(item.name, 0):
+                target -= 1
                 depletion_pool[item.player][item.name] -= 1
+                # quick abort if we have found all items
+                if not target:
+                    new_items.extend(multiworld.itempool[i+1:])
+                    break
+            else:
+                new_items.append(item)
+
+        # leftovers?
+        if target:
+            for player, remaining_items in depletion_pool.items():
+                remaining_items = {name: count for name, count in remaining_items.items() if count}
+                if remaining_items:
+                    raise Exception(f"{multiworld.get_player_name(player)}"
+                                    f" is trying to remove items from their pool that don't exist: {remaining_items}")
+        assert len(multiworld.itempool) == len(new_items), "Item Pool amounts should not change."
+        multiworld.itempool[:] = new_items
+
+    # temporary home for item links, should be moved out of Main
+    for group_id, group in multiworld.groups.items():
+        def find_common_pool(players: Set[int], shared_pool: Set[str]) -> Tuple[
+            Optional[Dict[int, Dict[str, int]]], Optional[Dict[str, int]]
+        ]:
+            classifications: Dict[str, int] = collections.defaultdict(int)
+            counters = {player: {name: 0 for name in shared_pool} for player in players}
+            for item in multiworld.itempool:
+                if item.player in counters and item.name in shared_pool:
+                    counters[item.player][item.name] += 1
+                    classifications[item.name] |= item.classification
+
+            for player in players.copy():
+                if all([counters[player][item] == 0 for item in shared_pool]):
+                    players.remove(player)
+                    del (counters[player])
+
+            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", group_id, multiworld, "ItemLink")
+        multiworld.regions.append(region)
+        locations = region.locations
+        for item in multiworld.itempool:
+            count = common_item_count.get(item.player, {}).get(item.name, 0)
+            if count:
+                loc = Location(group_id, f"Item Link: {item.name} -> {multiworld.player_name[item.player]} {count}",
+                               None, region)
+                loc.access_rule = lambda state, item_name = item.name, group_id_ = group_id, count_ = count: \
+                    state.has(item_name, group_id_, count_)
+
+                locations.append(loc)
+                loc.place_locked_item(item)
+                common_item_count[item.player][item.name] -= 1
             else:
                 new_itempool.append(item)
 
-        # Create filler in place of the removed items, warn if any items couldn't be found in the multiworld itempool
+        itemcount = len(multiworld.itempool)
-        for player, target in target_per_player.items():
+        multiworld.itempool = new_itempool
-            unfound_items = {item: count for item, count in depletion_pool[player].items() if count}
 
-            if unfound_items:
+        while itemcount > len(multiworld.itempool):
-                player_name = multiworld.get_player_name(player)
+            items_to_add = []
-                logger.warning(f"{player_name} tried to remove items from their pool that don't exist: {unfound_items}")
+            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(multiworld, "create_item", item_player,
+                                                                group["replacement_items"][player]))
+                else:
+                    items_to_add.append(AutoWorld.call_single(multiworld, "create_filler", item_player))
+            multiworld.random.shuffle(items_to_add)
+            multiworld.itempool.extend(items_to_add[:itemcount - len(multiworld.itempool)])
 
-            needed_items = target_per_player[player] - sum(unfound_items.values())
+    if any(multiworld.item_links.values()):
-            new_itempool += [multiworld.worlds[player].create_filler() for _ in range(needed_items)]
-
-        assert len(multiworld.itempool) == len(new_itempool), "Item Pool amounts should not change."
-        multiworld.itempool[:] = new_itempool
-
-    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
+    distribute_planned(multiworld)
-                                           for x in multiworld.plando_item_blocks[player]])
 
     logger.info('Running Pre Main Fill.')
 
@@ -198,7 +272,7 @@ def main(args, seed=None, baked_server_options: dict[str, object] | None = None)
     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)
+        distribute_items_restrictive(multiworld)
 
     AutoWorld.call_all(multiworld, 'post_fill')
 
@@ -207,9 +281,6 @@ def main(args, seed=None, baked_server_options: dict[str, object] | None = None)
     else:
         logger.info("Progression balancing skipped.")
 
-    AutoWorld.call_all(multiworld, "finalize_multiworld")
-    AutoWorld.call_all(multiworld, "pre_output")
-
     # we're about to output using multithreading, so we're removing the global random state to prevent accidental use
     multiworld.random.passthrough = False
 
@@ -220,15 +291,6 @@ def main(args, seed=None, baked_server_options: dict[str, object] | None = None)
     logger.info(f'Beginning output...')
     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:
         output_players = [player for player in multiworld.player_ids if AutoWorld.World.generate_output.__code__
@@ -243,19 +305,16 @@ def main(args, seed=None, baked_server_options: dict[str, object] | None = None)
                     pool.submit(AutoWorld.call_single, multiworld, "generate_output", player, temp_dir))
 
             # collect ER hint info
-            er_hint_data: dict[int, dict[int, str]] = {}
+            er_hint_data: Dict[int, Dict[int, str]] = {}
             AutoWorld.call_all(multiworld, 'extend_hint_information', er_hint_data)
 
             def write_multidata():
                 import NetUtils
-                from NetUtils import HintStatus
+                slot_data = {}
-                slot_data: dict[int, Mapping[str, Any]] = {}
+                client_versions = {}
-                client_versions: dict[int, tuple[int, int, int]] = {}
+                games = {}
-                games: dict[int, str] = {}
+                minimum_versions = {"server": AutoWorld.World.required_server_version, "clients": client_versions}
-                minimum_versions: NetUtils.MinimumVersions = {
+                slot_info = {}
-                    "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]
@@ -270,17 +329,15 @@ def main(args, seed=None, baked_server_options: dict[str, object] | None = None)
                                                            group_members=sorted(group["players"]))
                 precollected_items = {player: [item.code for item in world_precollected if type(item.code) == int]
                                       for player, world_precollected in multiworld.precollected_items.items()}
-                precollected_hints: dict[int, set[NetUtils.Hint]] = {
+                precollected_hints = {player: set() for player in range(1, multiworld.players + 1 + len(multiworld.groups))}
-                    player: set() for player in range(1, multiworld.players + 1 + len(multiworld.groups))
-                }
 
                 for slot in multiworld.player_ids:
                     slot_data[slot] = multiworld.worlds[slot].fill_slot_data()
 
-                def precollect_hint(location: Location, auto_status: HintStatus):
+                def precollect_hint(location):
                     entrance = er_hint_data.get(location.player, {}).get(location.address, "")
                     hint = NetUtils.Hint(location.item.player, location.player, location.address,
-                                         location.item.code, False, entrance, location.item.flags, auto_status)
+                                         location.item.code, False, entrance, location.item.flags)
                     precollected_hints[location.player].add(hint)
                     if location.item.player not in multiworld.groups:
                         precollected_hints[location.item.player].add(hint)
@@ -288,48 +345,34 @@ def main(args, seed=None, baked_server_options: dict[str, object] | None = None)
                         for player in multiworld.groups[location.item.player]["players"]:
                             precollected_hints[player].add(hint)
 
-                locations_data: dict[int, dict[int, tuple[int, int, int]]] = {player: {} for player in multiworld.player_ids}
+                locations_data: Dict[int, Dict[int, Tuple[int, int, int]]] = {player: {} for player in multiworld.player_ids}
                 for location in multiworld.get_filled_locations():
                     if type(location.address) == int:
                         assert location.item.code is not None, "item code None should be event, " \
                                                                "location.address should then also be None. Location: " \
-                                                               f" {location}, Item: {location.item}"
+                                                               f" {location}"
                         assert location.address not in locations_data[location.player], (
                             f"Locations with duplicate address. {location} and "
                             f"{locations_data[location.player][location.address]}")
                         locations_data[location.player][location.address] = \
                             location.item.code, location.item.player, location.item.flags
-                        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
+                            precollect_hint(location)
-                                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)
+                            precollect_hint(location)
                         elif any([location.item.name in multiworld.worlds[player].options.start_hints
                                   for player in multiworld.groups.get(location.item.player, {}).get("players", [])]):
-                            precollect_hint(location, auto_status)
+                            precollect_hint(location)
 
                 # embedded data package
                 data_package = {
                     game_world.game: worlds.network_data_package["games"][game_world.game]
                     for game_world in multiworld.worlds.values()
                 }
-                data_package["Archipelago"] = worlds.network_data_package["games"]["Archipelago"]
 
-                checks_in_area: dict[int, dict[str, int | list[int]]] = {}
+                checks_in_area: Dict[int, Dict[str, Union[int, List[int]]]] = {}
 
-                # get spheres -> filter address==None -> skip empty
+                multidata = {
-                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 = {
                     "slot_data": slot_data,
                     "slot_info": slot_info,
                     "connect_names": {name: (0, player) for player, name in multiworld.player_name.items()},
@@ -339,30 +382,24 @@ def main(args, seed=None, baked_server_options: dict[str, object] | None = None)
                     "er_hint_data": er_hint_data,
                     "precollected_items": precollected_items,
                     "precollected_hints": precollected_hints,
-                    "version": (version_tuple.major, version_tuple.minor, version_tuple.build),
+                    "version": tuple(version_tuple),
                     "tags": ["AP"],
                     "minimum_versions": minimum_versions,
                     "seed_name": multiworld.seed_name,
-                    "spheres": spheres,
                     "datapackage": data_package,
-                    "race_mode": int(multiworld.is_race),
                 }
-                # TODO: change to `"version": version_tuple` after getting better serialization
                 AutoWorld.call_all(multiworld, "modify_multidata", multidata)
 
-                for key in ("slot_data", "er_hint_data"):
+                multidata = zlib.compress(pickle.dumps(multidata), 9)
-                    multidata[key] = convert_to_base_types(multidata[key])
-
-                serialized_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(serialized_multidata)
+                    f.write(multidata)
 
             output_file_futures.append(pool.submit(write_multidata))
             if not check_accessibility_task.result():
                 if not multiworld.can_beat_game():
-                    raise FillError("Game appears as unbeatable. Aborting.", multiworld=multiworld)
+                    raise Exception("Game appears as unbeatable. Aborting.")
                 else:
                     logger.warning("Location Accessibility requirements not fulfilled.")
 

MinecraftClient.py

@@ -0,0 +1,344 @@
+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, url: str):
+    """Check mod version, download new mod from GitHub releases page if needed. """
+    ap_randomizer = find_ap_randomizer_jar(forge_dir)
+    os.path.basename(url)
+    if ap_randomizer is not None:
+        logging.info(f"Your current mod is {ap_randomizer}.")
+    else:
+        logging.info(f"You do not have the AP randomizer mod installed.")
+
+    if ap_randomizer != os.path.basename(url):
+        logging.info(f"A new release of the Minecraft AP randomizer mod was found: "
+                     f"{os.path.basename(url)}")
+        if prompt_yes_no("Would you like to update?"):
+            old_ap_mod = os.path.join(forge_dir, 'mods', ap_randomizer) if ap_randomizer is not None else None
+            new_ap_mod = os.path.join(forge_dir, 'mods', os.path.basename(url))
+            logging.info("Downloading AP randomizer mod. This may take a moment...")
+            apmod_resp = requests.get(url)
+            if apmod_resp.status_code == 200:
+                with open(new_ap_mod, 'wb') as f:
+                    f.write(apmod_resp.content)
+                    logging.info(f"Wrote new mod file to {new_ap_mod}")
+                if old_ap_mod is not None:
+                    os.remove(old_ap_mod)
+                    logging.info(f"Removed old mod file from {old_ap_mod}")
+            else:
+                logging.error(f"Error retrieving the randomizer mod (status code {apmod_resp.status_code}).")
+                logging.error(f"Please report this issue on the Archipelago Discord server.")
+                sys.exit(1)
+
+
+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, KeyError):
+        logging.error(f"No compatible mod version found for client version {version} on \"{release_channel}\" channel.")
+        if release_channel != "release":
+            logging.error("Consider switching \"release_channel\" to \"release\" in your Host.yaml file")
+        else:
+            logging.error("No suitable mod found on the \"release\" channel. Please Contact us on discord to report this error.")
+        sys.exit(0)
+
+
+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)")
+    parser.add_argument('--version', '-v', metavar='9', dest='data_version', type=int, action='store',
+                        help="specify Mod data version to download.")
+
+    args = parser.parse_args()
+    apmc_file = os.path.abspath(args.apmc_file) if args.apmc_file else None
+
+    # 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 = args.data_version or None
+
+    if apmc_file is None and not args.install:
+        apmc_file = Utils.open_filename('Select APMC file', (('APMC File', ('.apmc',)),))
+
+    if apmc_file is not None and data_version is None:
+        apmc_data = read_apmc_file(apmc_file)
+        data_version = apmc_data.get('client_version', '')
+
+    versions = get_minecraft_versions(data_version, channel)
+
+    forge_dir = options["minecraft_options"]["forge_directory"]
+    max_heap = options["minecraft_options"]["max_heap_size"]
+    forge_version = args.forge or versions["forge"]
+    java_version = args.java or versions["java"]
+    mod_url = versions["url"]
+    java_dir = find_jdk_dir(java_version)
+
+    if args.install:
+        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, mod_url)
+    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

@@ -5,23 +5,11 @@ import multiprocessing
 import warnings
 
 
-if sys.platform in ("win32", "darwin") and not (3, 11, 9) <= sys.version_info < (3, 14, 0):
+if sys.version_info < (3, 8, 6):
-    # Official micro version updates. This should match the number in docs/running from source.md.
+    raise RuntimeError("Incompatible Python Version. 3.8.7+ is supported.")
-    raise RuntimeError(f"Incompatible Python Version found: {sys.version_info}. "
-                       "Official 3.11.9 through 3.13.x 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 not (3, 11, 0) <= sys.version_info < (3, 14, 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 through 3.13.x is supported.")
 
 # don't run update if environment is frozen/compiled or if not the parent process (skip in subprocess)
-_skip_update = bool(
+_skip_update = bool(getattr(sys, "frozen", False) or multiprocessing.parent_process())
-    getattr(sys, "frozen", False) or 
-    multiprocessing.parent_process() or 
-    os.environ.get("SKIP_REQUIREMENTS_UPDATE", "").lower() in ("1", "true", "yes")
-)
 update_ran = _skip_update
 
 
@@ -75,11 +63,11 @@ def update_command():
 def install_pkg_resources(yes=False):
     try:
         import pkg_resources  # noqa: F401
-    except (AttributeError, ImportError):
+    except ImportError:
         check_pip()
         if not yes:
             confirm("pkg_resources not found, press enter to install it")
-        subprocess.call([sys.executable, "-m", "pip", "install", "--upgrade", "setuptools>=75,<81"])
+        subprocess.call([sys.executable, "-m", "pip", "install", "--upgrade", "setuptools"])
 
 
 def update(yes: bool = False, force: bool = False) -> None:
@@ -87,13 +75,13 @@ def update(yes: bool = False, force: bool = False) -> None:
     if not update_ran:
         update_ran = True
 
-        install_pkg_resources(yes=yes)
-        import pkg_resources
-
         if force:
             update_command()
             return
 
+        install_pkg_resources(yes=yes)
+        import pkg_resources
+
         prev = ""  # if a line ends in \ we store here and merge later
         for req_file in requirements_files:
             path = os.path.join(os.path.dirname(sys.argv[0]), req_file)

NetUtils.py

@@ -1,25 +1,15 @@
 from __future__ import annotations
 
-from collections.abc import Mapping, Sequence
 import typing
 import enum
 import warnings
 from json import JSONEncoder, JSONDecoder
 
-if typing.TYPE_CHECKING:
+import websockets
-    from websockets import WebSocketServerProtocol as ServerConnection
 
 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):
     text: str
     # optional
@@ -29,8 +19,6 @@ 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(ByValue, enum.IntEnum):
@@ -84,14 +72,13 @@ class NetworkSlot(typing.NamedTuple):
     name: str
     game: str
     type: SlotType
-    group_members: Sequence[int] = ()  # only populated if type == group
+    group_members: typing.Union[typing.List[int], typing.Tuple] = ()  # 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
 
 
@@ -107,27 +94,6 @@ 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,
@@ -174,9 +140,7 @@ decode = JSONDecoder(object_hook=_object_hook).decode
 
 
 class Endpoint:
-    __slots__ = ("socket",)
+    socket: websockets.WebSocketServerProtocol
-
-    socket: "ServerConnection"
 
     def __init__(self, socket):
         self.socket = socket
@@ -219,7 +183,6 @@ 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):
@@ -235,8 +198,7 @@ class JSONtoTextParser(metaclass=HandlerMeta):
         "slateblue": "6D8BE8",
         "plum": "AF99EF",
         "salmon": "FA8072",
-        "white": "FFFFFF",
+        "white": "FFFFFF"
-        "orange": "FF7700",
     }
 
     def __init__(self, ctx):
@@ -260,7 +222,7 @@ class JSONtoTextParser(metaclass=HandlerMeta):
 
     def _handle_player_id(self, node: JSONMessagePart):
         player = int(node["text"])
-        node["color"] = 'magenta' if self.ctx.slot_concerns_self(player) else 'yellow'
+        node["color"] = 'magenta' if player == self.ctx.slot else 'yellow'
         node["text"] = self.ctx.player_names[player]
         return self._handle_color(node)
 
@@ -285,7 +247,7 @@ class JSONtoTextParser(metaclass=HandlerMeta):
 
     def _handle_item_id(self, node: JSONMessagePart):
         item_id = int(node["text"])
-        node["text"] = self.ctx.item_names.lookup_in_slot(item_id, node["player"])
+        node["text"] = self.ctx.item_names[item_id]
         return self._handle_item_name(node)
 
     def _handle_location_name(self, node: JSONMessagePart):
@@ -293,18 +255,14 @@ class JSONtoTextParser(metaclass=HandlerMeta):
         return self._handle_color(node)
 
     def _handle_location_id(self, node: JSONMessagePart):
-        location_id = int(node["text"])
+        item_id = int(node["text"])
-        node["text"] = self.ctx.location_names.lookup_in_slot(location_id, node["player"])
+        node["text"] = self.ctx.location_names[item_id]
         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):
@@ -313,8 +271,7 @@ 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):
@@ -337,27 +294,6 @@ def add_json_location(parts: list, location_id: int, player: int = 0, **kwargs)
     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):
     receiving_player: int
     finding_player: int
@@ -366,21 +302,14 @@ 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 and self.status == HintStatus.HINT_FOUND:
+        if self.found:
             return self
         found = self.location in ctx.location_checks[team, self.finding_player]
         if found:
-            return self._replace(found=found, status=HintStatus.HINT_FOUND)
+            return Hint(self.receiving_player, self.finding_player, self.location, self.item, found, self.entrance,
-        return self
+                        self.item_flags)
-    
-    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):
@@ -402,7 +331,10 @@ class Hint(typing.NamedTuple):
         else:
             add_json_text(parts, "'s World")
         add_json_text(parts, ". ")
-        add_json_hint_status(parts, self.status)
+        if self.found:
+            add_json_text(parts, "(found)", type="color", color="green")
+        else:
+            add_json_text(parts, "(not found)", type="color", color="red")
 
         return {"cmd": "PrintJSON", "data": parts, "type": "Hint",
                 "receiving": self.receiving_player,
@@ -448,8 +380,6 @@ class _LocationStore(dict, typing.MutableMapping[int, typing.Dict[int, typing.Tu
         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
@@ -466,48 +396,12 @@ class _LocationStore(dict, typing.MutableMapping[int, typing.Dict[int, typing.Tu
                 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]]:
+                      ) -> typing.List[int]:
         checked = state[team, slot]
         player_locations = self[slot]
-        return sorted([(player_locations[location_id][1], player_locations[location_id][0]) for
+        return sorted([player_locations[location_id][0] for
-                        location_id in player_locations if
+                       location_id in player_locations if
-                        location_id not in checked])
+                       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

OoTAdjuster.py

@@ -1,6 +1,7 @@
 import tkinter as tk
 import argparse
 import logging
+import random
 import os
 import zipfile
 from itertools import chain
@@ -196,6 +197,7 @@ def set_icon(window):
 def adjust(args):
     # Create a fake multiworld and OOTWorld to use as a base
     multiworld = MultiWorld(1)
+    multiworld.per_slot_randoms = {1: random}
     ootworld = OOTWorld(multiworld, 1)
     # Set options in the fake OOTWorld
     for name, option in chain(cosmetic_options.items(), sfx_options.items()):

OoTClient.py

@@ -12,7 +12,6 @@ from CommonClient import CommonContext, server_loop, gui_enabled, \
 import Utils
 from Utils import async_start
 from worlds import network_data_package
-from worlds.oot import OOTWorld
 from worlds.oot.Rom import Rom, compress_rom_file
 from worlds.oot.N64Patch import apply_patch_file
 from worlds.oot.Utils import data_path
@@ -277,12 +276,11 @@ 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 = OOTWorld.settings.rom_start
+    auto_start = Utils.get_options()["oot_options"].get("rom_start", True)
     if auto_start is True:
         import webbrowser
         webbrowser.open(romfile)
@@ -297,7 +295,7 @@ async def patch_and_run_game(apz5_file):
     decomp_path = base_name + '-decomp.z64'
     comp_path = base_name + '.z64'
     # Load vanilla ROM, patch file, compress ROM
-    rom_file_name = OOTWorld.settings.rom_file
+    rom_file_name = Utils.get_options()["oot_options"]["rom_file"]
     rom = Rom(rom_file_name)
 
     sub_file = None
@@ -348,7 +346,7 @@ if __name__ == '__main__':
 
     import colorama
 
-    colorama.just_fix_windows_console()
+    colorama.init()
 
     asyncio.run(main())
     colorama.deinit()

OptionsCreator.py

@@ -1,708 +0,0 @@
-if __name__ == "__main__":
-    import ModuleUpdate
-
-    ModuleUpdate.update()
-
-
-from kvui import (ThemedApp, ScrollBox, MainLayout, ContainerLayout, dp, Widget, MDBoxLayout, TooltipLabel, MDLabel,
-                  ToggleButton, MarkupDropdown, ResizableTextField)
-from kivy.clock import Clock
-from kivy.uix.behaviors.button import ButtonBehavior
-from kivymd.uix.behaviors import RotateBehavior
-from kivymd.uix.anchorlayout import MDAnchorLayout
-from kivymd.uix.expansionpanel import MDExpansionPanel, MDExpansionPanelContent, MDExpansionPanelHeader
-from kivymd.uix.list import MDListItem, MDListItemTrailingIcon, MDListItemSupportingText
-from kivymd.uix.slider import MDSlider
-from kivymd.uix.snackbar import MDSnackbar, MDSnackbarText
-from kivymd.uix.menu import MDDropdownMenu
-from kivymd.uix.button import MDButton, MDButtonText, MDIconButton
-from kivymd.uix.dialog import MDDialog
-from kivy.core.text.markup import MarkupLabel
-from kivy.utils import escape_markup
-from kivy.lang.builder import Builder
-from kivy.properties import ObjectProperty
-from textwrap import dedent
-from copy import deepcopy
-import Utils
-import typing
-import webbrowser
-import re
-from urllib.parse import urlparse
-from worlds.AutoWorld import AutoWorldRegister, World
-from Options import (Option, Toggle, TextChoice, Choice, FreeText, NamedRange, Range, OptionSet, OptionList,
-                     OptionCounter, Visibility)
-
-
-def validate_url(x):
-    try:
-        result = urlparse(x)
-        return all([result.scheme, result.netloc])
-    except AttributeError:
-        return False
-
-
-def filter_tooltip(tooltip):
-    if tooltip is None:
-        tooltip = "No tooltip available."
-    tooltip = dedent(tooltip).strip().replace("\n", "<br>").replace("&", "&amp;") \
-        .replace("[", "&bl;").replace("]", "&br;")
-    tooltip = re.sub(r"\*\*(.+?)\*\*", r"[b]\g<1>[/b]", tooltip)
-    tooltip = re.sub(r"\*(.+?)\*", r"[i]\g<1>[/i]", tooltip)
-    return escape_markup(tooltip)
-
-
-def option_can_be_randomized(option: typing.Type[Option]):
-    # most options can be randomized, so we should just check for those that cannot
-    if not option.supports_weighting:
-        return False
-    elif issubclass(option, FreeText) and not issubclass(option, TextChoice):
-        return False
-    return True
-
-
-def check_random(value: typing.Any):
-    if not isinstance(value, str):
-        return value  # cannot be random if evaluated
-    if value.startswith("random-"):
-        return "random"
-    return value
-
-
-class TrailingPressedIconButton(ButtonBehavior, RotateBehavior, MDListItemTrailingIcon):
-    pass
-
-
-class WorldButton(ToggleButton):
-    world_cls: typing.Type[World]
-
-
-class VisualRange(MDBoxLayout):
-    option: typing.Type[Range]
-    name: str
-    tag: MDLabel = ObjectProperty(None)
-    slider: MDSlider = ObjectProperty(None)
-
-    def __init__(self, *args, option: typing.Type[Range], name: str, **kwargs):
-        self.option = option
-        self.name = name
-        super().__init__(*args, **kwargs)
-
-        def update_points(*update_args):
-            pass
-
-        self.slider._update_points = update_points
-
-
-class VisualChoice(MDButton):
-    option: typing.Type[Choice]
-    name: str
-    text: MDButtonText = ObjectProperty(None)
-
-    def __init__(self, *args, option: typing.Type[Choice], name: str, **kwargs):
-        self.option = option
-        self.name = name
-        super().__init__(*args, **kwargs)
-
-
-class VisualNamedRange(MDBoxLayout):
-    option: typing.Type[NamedRange]
-    name: str
-    range: VisualRange = ObjectProperty(None)
-    choice: MDButton = ObjectProperty(None)
-
-    def __init__(self, *args, option: typing.Type[NamedRange], name: str, range_widget: VisualRange, **kwargs):
-        self.option = option
-        self.name = name
-        super().__init__(*args, **kwargs)
-        self.range = range_widget
-        self.add_widget(self.range)
-
-
-class VisualFreeText(ResizableTextField):
-    option: typing.Type[FreeText] | typing.Type[TextChoice]
-    name: str
-
-    def __init__(self, *args, option: typing.Type[FreeText] | typing.Type[TextChoice], name: str, **kwargs):
-        self.option = option
-        self.name = name
-        super().__init__(*args, **kwargs)
-
-
-class VisualTextChoice(MDBoxLayout):
-    option: typing.Type[TextChoice]
-    name: str
-    choice: VisualChoice = ObjectProperty(None)
-    text: VisualFreeText = ObjectProperty(None)
-
-    def __init__(self, *args, option: typing.Type[TextChoice], name: str, choice: VisualChoice,
-                 text: VisualFreeText, **kwargs):
-        self.option = option
-        self.name = name
-        super(MDBoxLayout, self).__init__(*args, **kwargs)
-        self.choice = choice
-        self.text = text
-        self.add_widget(self.choice)
-        self.add_widget(self.text)
-
-
-class VisualToggle(MDBoxLayout):
-    button: MDIconButton = ObjectProperty(None)
-    option: typing.Type[Toggle]
-    name: str
-
-    def __init__(self, *args, option: typing.Type[Toggle], name: str, **kwargs):
-        self.option = option
-        self.name = name
-        super().__init__(*args, **kwargs)
-
-
-class CounterItemValue(ResizableTextField):
-    pat = re.compile('[^0-9]')
-
-    def insert_text(self, substring, from_undo=False):
-        return super().insert_text(re.sub(self.pat, "", substring), from_undo=from_undo)
-
-
-class VisualListSetCounter(MDDialog):
-    button: MDIconButton = ObjectProperty(None)
-    option: typing.Type[OptionSet] | typing.Type[OptionList] | typing.Type[OptionCounter]
-    scrollbox: ScrollBox = ObjectProperty(None)
-    add: MDIconButton = ObjectProperty(None)
-    save: MDButton = ObjectProperty(None)
-    input: ResizableTextField = ObjectProperty(None)
-    dropdown: MDDropdownMenu
-    valid_keys: typing.Iterable[str]
-
-    def __init__(self, *args, option: typing.Type[OptionSet] | typing.Type[OptionList],
-                 name: str, valid_keys: typing.Iterable[str], **kwargs):
-        self.option = option
-        self.name = name
-        self.valid_keys = valid_keys
-        super().__init__(*args, **kwargs)
-        self.dropdown = MarkupDropdown(caller=self.input, border_margin=dp(2),
-                                       width=self.input.width, position="bottom")
-        self.input.bind(text=self.on_text)
-        self.input.bind(on_text_validate=self.validate_add)
-
-    def validate_add(self, instance):
-        if self.valid_keys:
-            if self.input.text not in self.valid_keys:
-                MDSnackbar(MDSnackbarText(text="Item must be a valid key for this option."), y=dp(24),
-                           pos_hint={"center_x": 0.5}, size_hint_x=0.5).open()
-                return
-
-        if not issubclass(self.option, OptionList):
-            if any(self.input.text == child.text.text for child in self.scrollbox.layout.children):
-                MDSnackbar(MDSnackbarText(text="This value is already in the set."), y=dp(24),
-                           pos_hint={"center_x": 0.5}, size_hint_x=0.5).open()
-                return
-
-        self.add_set_item(self.input.text)
-        self.input.set_text(self.input, "")
-
-    def remove_item(self, button: MDIconButton):
-        list_item = button.parent
-        self.scrollbox.layout.remove_widget(list_item)
-
-    def add_set_item(self, key: str, value: int | None = None):
-        text = MDListItemSupportingText(text=key, id="value")
-        if issubclass(self.option, OptionCounter):
-            value_txt = CounterItemValue(text=str(value) if value else "1")
-            item = MDListItem(text,
-                              value_txt,
-                              MDIconButton(icon="minus", on_release=self.remove_item), focus_behavior=False)
-            item.value = value_txt
-        else:
-            item = MDListItem(text, MDIconButton(icon="minus", on_release=self.remove_item), focus_behavior=False)
-        item.text = text
-        self.scrollbox.layout.add_widget(item)
-
-    def on_text(self, instance, value):
-        if not self.valid_keys:
-            return
-        if len(value) >= 3:
-            self.dropdown.items.clear()
-
-            def on_press(txt):
-                split_text = MarkupLabel(text=txt, markup=True).markup
-                self.input.set_text(self.input, "".join(text_frag for text_frag in split_text
-                                                        if not text_frag.startswith("[")))
-                self.input.focus = True
-                self.dropdown.dismiss()
-
-            lowered = value.lower()
-            for item_name in self.valid_keys:
-                try:
-                    index = item_name.lower().index(lowered)
-                except ValueError:
-                    pass  # substring not found
-                else:
-                    text = escape_markup(item_name)
-                    text = text[:index] + "[b]" + text[index:index + len(value)] + "[/b]" + text[index + len(value):]
-                    self.dropdown.items.append({
-                        "text": text,
-                        "on_release": lambda txt=text: on_press(txt),
-                        "markup": True
-                    })
-            if not self.dropdown.parent:
-                self.dropdown.open()
-        else:
-            self.dropdown.dismiss()
-
-
-class OptionsCreator(ThemedApp):
-    base_title: str = "Archipelago Options Creator"
-    container: ContainerLayout
-    main_layout: MainLayout
-    scrollbox: ScrollBox
-    main_panel: MainLayout
-    player_options: MainLayout
-    option_layout: MainLayout
-    name_input: ResizableTextField
-    game_label: MDLabel
-    current_game: str
-    options: typing.Dict[str, typing.Any]
-
-    def __init__(self):
-        self.title = self.base_title + " " + Utils.__version__
-        self.icon = r"data/icon.png"
-        self.current_game = ""
-        self.options = {}
-        super().__init__()
-
-    @staticmethod
-    def show_result_snack(text: str) -> None:
-        MDSnackbar(MDSnackbarText(text=text), y=dp(24), pos_hint={"center_x": 0.5}, size_hint_x=0.5).open()
-
-    def on_export_result(self, text: str | None) -> None:
-        self.container.disabled = False
-        if text is not None:
-            Clock.schedule_once(lambda _: self.show_result_snack(text), 0)
-
-    def export_options_background(self, options: dict[str, typing.Any]) -> None:
-        try:
-            file_name = Utils.save_filename("Export Options File As...", [("YAML", [".yaml"])],
-                                            Utils.get_file_safe_name(f"{self.name_input.text}.yaml"))
-        except Exception:
-            self.on_export_result("Could not open dialog. Already open?")
-            raise
-
-        if not file_name:
-            self.on_export_result(None)  # No file selected. No need to show a message for this.
-            return
-
-        try:
-            with open(file_name, 'w') as f:
-                f.write(Utils.dump(options, sort_keys=False))
-                f.close()
-                self.on_export_result("File saved successfully.")
-        except Exception:
-            self.on_export_result("Could not save file.")
-            raise
-
-    def export_options(self, button: Widget) -> None:
-        if 0 < len(self.name_input.text) < 17 and self.current_game:
-            import threading
-            options = {
-                "name": self.name_input.text,
-                "description": f"YAML generated by Archipelago {Utils.__version__}.",
-                "game": self.current_game,
-                self.current_game: {k: check_random(v) for k, v in self.options.items()}
-            }
-            threading.Thread(target=self.export_options_background, args=(options,), daemon=True).start()
-            self.container.disabled = True
-        elif not self.name_input.text:
-            self.show_result_snack("Name must not be empty.")
-        elif not self.current_game:
-            self.show_result_snack("You must select a game to play.")
-        else:
-            self.show_result_snack("Name cannot be longer than 16 characters.")
-
-    def create_range(self, option: typing.Type[Range], name: str, bind=True):
-        def update_text(range_box: VisualRange):
-            self.options[name] = int(range_box.slider.value)
-            range_box.tag.text = str(int(range_box.slider.value))
-            return
-
-        box = VisualRange(option=option, name=name)
-        if bind:
-            box.slider.bind(value=lambda _, _1: update_text(box))
-        self.options[name] = option.default
-        return box
-
-    def create_named_range(self, option: typing.Type[NamedRange], name: str):
-        def set_to_custom(range_box: VisualNamedRange):
-            range_box.range.tag.text = str(int(range_box.range.slider.value))
-            if range_box.range.slider.value in option.special_range_names.values():
-                value = next(key for key, val in option.special_range_names.items()
-                             if val == range_box.range.slider.value)
-                self.options[name] = value
-                set_button_text(box.choice, value.title())
-            else:
-                self.options[name] = int(range_box.range.slider.value)
-                set_button_text(range_box.choice, "Custom")
-
-        def set_button_text(button: MDButton, text: str):
-            button.text.text = text
-
-        def set_value(text: str, range_box: VisualNamedRange):
-            range_box.range.slider.value = min(max(option.special_range_names[text.lower()], option.range_start),
-                                               option.range_end)
-            range_box.range.tag.text = str(option.special_range_names[text.lower()])
-            set_button_text(range_box.choice, text)
-            self.options[name] = text.lower()
-            range_box.range.slider.dropdown.dismiss()
-
-        def open_dropdown(button):
-            # for some reason this fixes an issue causing some to not open
-            box.range.slider.dropdown.open()
-
-        box = VisualNamedRange(option=option, name=name, range_widget=self.create_range(option, name, bind=False))
-        default: int | str = option.default
-        if default in option.special_range_names:
-            # value can get mismatched in this case
-            box.range.slider.value = min(max(option.special_range_names[default], option.range_start),
-                                               option.range_end)
-            box.range.tag.text = str(int(box.range.slider.value))
-        elif default in option.special_range_names.values():
-            # better visual
-            default = next(key for key, val in option.special_range_names.items() if val == option.default)
-            set_button_text(box.choice, default.title())
-        box.range.slider.bind(value=lambda _, _2: set_to_custom(box))
-        items = [
-            {
-                "text": choice.title(),
-                "on_release": lambda text=choice.title(): set_value(text, box)
-            }
-            for choice in option.special_range_names
-        ]
-        box.range.slider.dropdown = MDDropdownMenu(caller=box.choice, items=items)
-        box.choice.bind(on_release=open_dropdown)
-        self.options[name] = default
-        return box
-
-    def create_free_text(self, option: typing.Type[FreeText] | typing.Type[TextChoice], name: str):
-        text = VisualFreeText(option=option, name=name)
-
-        def set_value(instance):
-            self.options[name] = instance.text
-
-        text.bind(on_text_validate=set_value)
-        return text
-
-    def create_choice(self, option: typing.Type[Choice], name: str):
-        def set_button_text(button: VisualChoice, text: str):
-            button.text.text = text
-
-        def set_value(text, value):
-            set_button_text(main_button, text)
-            self.options[name] = value
-            dropdown.dismiss()
-
-        def open_dropdown(button):
-            # for some reason this fixes an issue causing some to not open
-            dropdown.open()
-
-        default_string = isinstance(option.default, str)
-        main_button = VisualChoice(option=option, name=name)
-        main_button.bind(on_release=open_dropdown)
-
-        items = [
-            {
-                "text": option.get_option_name(choice),
-                "on_release": lambda val=choice: set_value(option.get_option_name(val), option.name_lookup[val])
-            }
-            for choice in option.name_lookup
-        ]
-        dropdown = MDDropdownMenu(caller=main_button, items=items)
-        self.options[name] = option.name_lookup[option.default] if not default_string else option.default
-        return main_button
-
-    def create_text_choice(self, option: typing.Type[TextChoice], name: str):
-        def set_button_text(button: MDButton, text: str):
-            for child in button.children:
-                if isinstance(child, MDButtonText):
-                    child.text = text
-
-        box = VisualTextChoice(option=option, name=name, choice=self.create_choice(option, name),
-                               text=self.create_free_text(option, name))
-
-        def set_value(instance):
-            set_button_text(box.choice, "Custom")
-            self.options[name] = instance.text
-
-        box.text.bind(on_text_validate=set_value)
-        return box
-
-    def create_toggle(self, option: typing.Type[Toggle], name: str) -> Widget:
-        def set_value(instance: MDIconButton):
-            if instance.icon == "checkbox-outline":
-                instance.icon = "checkbox-blank-outline"
-            else:
-                instance.icon = "checkbox-outline"
-            self.options[name] = bool(not self.options[name])
-
-        self.options[name] = bool(option.default)
-        checkbox = VisualToggle(option=option, name=name)
-        checkbox.button.bind(on_release=set_value)
-
-        return checkbox
-
-    def create_popup(self, option: typing.Type[OptionList] | typing.Type[OptionSet] | typing.Type[OptionCounter],
-                     name: str, world: typing.Type[World]):
-
-        valid_keys = sorted(option.valid_keys)
-        if option.verify_item_name:
-            valid_keys += list(world.item_name_to_id.keys())
-            if option.convert_name_groups:
-                valid_keys += list(world.item_name_groups.keys())
-        if option.verify_location_name:
-            valid_keys += list(world.location_name_to_id.keys())
-            if option.convert_name_groups:
-                valid_keys += list(world.location_name_groups.keys())
-
-        if not issubclass(option, OptionCounter):
-            def apply_changes(button):
-                self.options[name].clear()
-                for list_item in dialog.scrollbox.layout.children:
-                    self.options[name].append(getattr(list_item.text, "text"))
-                dialog.dismiss()
-        else:
-            def apply_changes(button):
-                self.options[name].clear()
-                for list_item in dialog.scrollbox.layout.children:
-                    self.options[name][getattr(list_item.text, "text")] = int(getattr(list_item.value, "text"))
-                dialog.dismiss()
-
-        dialog = VisualListSetCounter(option=option, name=name, valid_keys=valid_keys)
-        dialog.ids.container.spacing = dp(30)
-        dialog.scrollbox.layout.theme_bg_color = "Custom"
-        dialog.scrollbox.layout.md_bg_color = self.theme_cls.surfaceContainerLowColor
-        dialog.scrollbox.layout.spacing = dp(5)
-        dialog.scrollbox.layout.padding = [0, dp(5), 0, 0]
-
-        if issubclass(option, OptionCounter):
-            for value in sorted(self.options[name]):
-                dialog.add_set_item(value, self.options[name].get(value, None))
-        else:
-            for value in sorted(self.options[name]):
-                dialog.add_set_item(value)
-
-        dialog.save.bind(on_release=apply_changes)
-        dialog.open()
-
-    def create_option_set_list_counter(self, option: typing.Type[OptionList] | typing.Type[OptionSet] |
-                                       typing.Type[OptionCounter], name: str, world: typing.Type[World]):
-        main_button = MDButton(MDButtonText(text="Edit"), on_release=lambda x: self.create_popup(option, name, world))
-
-        if name not in self.options:
-            # convert from non-mutable to mutable
-            # We use list syntax even for sets, set behavior is enforced through GUI
-            if issubclass(option, OptionCounter):
-                self.options[name] = deepcopy(option.default)
-            else:
-                self.options[name] = sorted(option.default)
-
-        return main_button
-
-    def create_option(self, option: typing.Type[Option], name: str, world: typing.Type[World]) -> Widget:
-        option_base = MDBoxLayout(orientation="vertical", size_hint_y=None, padding=[0, 0, dp(5), dp(5)])
-
-        tooltip = filter_tooltip(option.__doc__)
-        option_label = TooltipLabel(text=f"[ref=0|{tooltip}]{getattr(option, 'display_name', name)}")
-        label_box = MDBoxLayout(orientation="horizontal")
-        label_anchor = MDAnchorLayout(anchor_x="right", anchor_y="center")
-        label_anchor.add_widget(option_label)
-        label_box.add_widget(label_anchor)
-
-        option_base.add_widget(label_box)
-        if issubclass(option, NamedRange):
-            option_base.add_widget(self.create_named_range(option, name))
-        elif issubclass(option, Range):
-            option_base.add_widget(self.create_range(option, name))
-        elif issubclass(option, Toggle):
-            option_base.add_widget(self.create_toggle(option, name))
-        elif issubclass(option, TextChoice):
-            option_base.add_widget(self.create_text_choice(option, name))
-        elif issubclass(option, Choice):
-            option_base.add_widget(self.create_choice(option, name))
-        elif issubclass(option, FreeText):
-            option_base.add_widget(self.create_free_text(option, name))
-        elif any(issubclass(option, cls) for cls in (OptionSet, OptionList, OptionCounter)):
-            option_base.add_widget(self.create_option_set_list_counter(option, name, world))
-        else:
-            option_base.add_widget(MDLabel(text="This option isn't supported by the option creator.\n"
-                                                "Please edit your yaml manually to set this option."))
-
-        if option_can_be_randomized(option):
-            def randomize_option(instance: Widget, value: str):
-                value = value == "down"
-                if value:
-                    self.options[name] = "random-" + str(self.options[name])
-                else:
-                    self.options[name] = self.options[name].replace("random-", "")
-                    if self.options[name].isnumeric():
-                        self.options[name] = int(self.options[name])
-                    elif self.options[name] in ("True", "False"):
-                        self.options[name] = self.options[name] == "True"
-
-                base_object = instance.parent.parent
-                label_object = instance.parent
-                for child in base_object.children:
-                    if child is not label_object:
-                        child.disabled = value
-
-            default_random = option.default == "random"
-            random_toggle = ToggleButton(MDButtonText(text="Random?"), size_hint_x=None, width=dp(100),
-                                         state="down" if default_random else "normal")
-            random_toggle.bind(state=randomize_option)
-            label_box.add_widget(random_toggle)
-            if default_random:
-                randomize_option(random_toggle, "down")
-
-        return option_base
-
-    def create_options_panel(self, world_button: WorldButton):
-        self.option_layout.clear_widgets()
-        self.options.clear()
-        cls: typing.Type[World] = world_button.world_cls
-
-        self.current_game = cls.game
-        if not cls.web.options_page:
-            self.current_game = "None"
-            return
-        elif isinstance(cls.web.options_page, str):
-            self.current_game = "None"
-            if validate_url(cls.web.options_page):
-                webbrowser.open(cls.web.options_page)
-                MDSnackbar(MDSnackbarText(text="Launching in default browser..."), y=dp(24), pos_hint={"center_x": 0.5},
-                           size_hint_x=0.5).open()
-                world_button.state = "normal"
-            else:
-                # attach onto archipelago.gg and see if we pass
-                new_url = "https://archipelago.gg/" + cls.web.options_page
-                if validate_url(new_url):
-                    webbrowser.open(new_url)
-                    MDSnackbar(MDSnackbarText(text="Launching in default browser..."), y=dp(24),
-                               pos_hint={"center_x": 0.5},
-                               size_hint_x=0.5).open()
-                else:
-                    MDSnackbar(MDSnackbarText(text="Invalid options page, please report to world developer."), y=dp(24),
-                               pos_hint={"center_x": 0.5},
-                               size_hint_x=0.5).open()
-                world_button.state = "normal"
-                # else just fall through
-        else:
-            expansion_box = ScrollBox()
-            expansion_box.layout.orientation = "vertical"
-            expansion_box.layout.spacing = dp(3)
-            expansion_box.scroll_type = ["bars"]
-            expansion_box.do_scroll_x = False
-            group_names = ["Game Options", *(group.name for group in cls.web.option_groups)]
-            groups = {name: [] for name in group_names}
-            for name, option in cls.options_dataclass.type_hints.items():
-                group = next((group.name for group in cls.web.option_groups if option in group.options), "Game Options")
-                groups[group].append((name, option))
-
-            for group, options in groups.items():
-                options = [(name, option) for name, option in options
-                           if name and option.visibility & Visibility.simple_ui]
-                if not options:
-                    continue  # Game Options can be empty if every other option is in another group
-                    # Can also have an option group of options that should not render on simple ui
-                group_item = MDExpansionPanel(size_hint_y=None)
-                group_header = MDExpansionPanelHeader(MDListItem(MDListItemSupportingText(text=group),
-                                                                 TrailingPressedIconButton(icon="chevron-right",
-                                                                                           on_release=lambda x,
-                                                                                           item=group_item:
-                                                                                           self.tap_expansion_chevron(
-                                                                                               item, x)),
-                                                                 md_bg_color=self.theme_cls.surfaceContainerLowestColor,
-                                                                 theme_bg_color="Custom",
-                                                                 on_release=lambda x, item=group_item:
-                                                                 self.tap_expansion_chevron(item, x)))
-                group_content = MDExpansionPanelContent(orientation="vertical", theme_bg_color="Custom",
-                                                        md_bg_color=self.theme_cls.surfaceContainerLowestColor,
-                                                        padding=[dp(12), dp(100), dp(12), 0],
-                                                        spacing=dp(3))
-                group_item.add_widget(group_header)
-                group_item.add_widget(group_content)
-                group_box = ScrollBox()
-                group_box.layout.orientation = "vertical"
-                group_box.layout.spacing = dp(3)
-                for name, option in options:
-                    group_content.add_widget(self.create_option(option, name, cls))
-                expansion_box.layout.add_widget(group_item)
-            self.option_layout.add_widget(expansion_box)
-        self.game_label.text = f"Game: {self.current_game}"
-
-    @staticmethod
-    def tap_expansion_chevron(panel: MDExpansionPanel, chevron: TrailingPressedIconButton | MDListItem):
-        if isinstance(chevron, MDListItem):
-            chevron = next((child for child in chevron.ids.trailing_container.children
-                            if isinstance(child, TrailingPressedIconButton)), None)
-        panel.open() if not panel.is_open else panel.close()
-        if chevron:
-            panel.set_chevron_down(
-                chevron
-            ) if not panel.is_open else panel.set_chevron_up(chevron)
-
-    def build(self):
-        self.set_colors()
-        self.options = {}
-        self.container = Builder.load_file(Utils.local_path("data/optionscreator.kv"))
-        self.root = self.container
-        self.main_layout = self.container.ids.main
-        self.scrollbox = self.container.ids.scrollbox
-
-        def world_button_action(world_btn: WorldButton):
-            if self.current_game != world_btn.world_cls.game:
-                old_button = next((button for button in self.scrollbox.layout.children
-                                   if button.world_cls.game == self.current_game), None)
-                if old_button:
-                    old_button.state = "normal"
-            else:
-                world_btn.state = "down"
-            self.create_options_panel(world_btn)
-
-        for world, cls in sorted(AutoWorldRegister.world_types.items(), key=lambda x: x[0]):
-            if cls.hidden:
-                continue
-            world_text = MDButtonText(text=world, size_hint_y=None, width=dp(150),
-                                      pos_hint={"x": 0.03, "center_y": 0.5})
-            world_text.text_size = (world_text.width, None)
-            world_text.bind(width=lambda *x, text=world_text: text.setter('text_size')(text, (text.width, None)),
-                            texture_size=lambda *x, text=world_text: text.setter("height")(text,
-                                                                                           world_text.texture_size[1]))
-            world_button = WorldButton(world_text, size_hint_x=None, width=dp(150), theme_width="Custom",
-                                       radius=(dp(5), dp(5), dp(5), dp(5)))
-            world_button.bind(on_release=world_button_action)
-            world_button.world_cls = cls
-            self.scrollbox.layout.add_widget(world_button)
-        self.main_panel = self.container.ids.player_layout
-        self.player_options = self.container.ids.player_options
-        self.game_label = self.container.ids.game
-        self.name_input = self.container.ids.player_name
-        self.option_layout = self.container.ids.options
-
-        def set_height(instance, value):
-            instance.height = value[1]
-
-        self.game_label.bind(texture_size=set_height)
-
-        # 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
-        # from kivy.core.window import Window
-        # create_console(Window, self.container)
-
-        return self.container
-
-
-def launch():
-    OptionsCreator().run()
-
-
-if __name__ == "__main__":
-    Utils.init_logging("OptionsCreator")
-    launch()

README.md

@@ -1,25 +1,27 @@
 # [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,
+Archipelago provides a generic framework for developing multiworld capability for game randomizers. In all cases, presently, Archipelago is also the randomizer itself.
-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
@@ -39,6 +41,7 @@ Currently, the following games are supported:
 * The Messenger
 * Kingdom Hearts 2
 * The Legend of Zelda: Link's Awakening DX
+* Clique
 * Adventure
 * DLC Quest
 * Noita
@@ -58,34 +61,13 @@ Currently, the following games are supported:
 * TUNIC
 * Kirby's Dream Land 3
 * Celeste 64
+* Zork Grand Inquisitor
 * Castlevania 64
 * A Short Hike
 * Yoshi's Island
 * 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
-* APQuest
-* Satisfactory
-* EarthBound
-* Mega Man 3
 
 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
@@ -93,57 +75,36 @@ windows binaries.
 
 ## History
 
-Archipelago is built upon a strong legacy of brilliant hobbyists. We want to honor that legacy by showing it here.
+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:
-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)
+* [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.
-  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
+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. 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, or AppImage for Linux-based systems.
 
-For most people, all you need to do is head over to
+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).
-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,7 +18,6 @@ from json import loads, dumps
 from CommonClient import CommonContext, server_loop, ClientCommandProcessor, gui_enabled, get_base_parser
 
 import Utils
-import settings
 from Utils import async_start
 from MultiServer import mark_raw
 if typing.TYPE_CHECKING:
@@ -244,9 +243,6 @@ 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
@@ -286,7 +282,7 @@ class SNESState(enum.IntEnum):
 
 
 def launch_sni() -> None:
-    sni_path = settings.get_settings().sni_options.sni_path
+    sni_path = Utils.get_settings()["sni_options"]["sni_path"]
 
     if not os.path.isdir(sni_path):
         sni_path = Utils.local_path(sni_path)
@@ -637,13 +633,7 @@ async def game_watcher(ctx: SNIContext) -> None:
         if not ctx.client_handler:
             continue
 
-        try:
+        rom_validated = await ctx.client_handler.validate_rom(ctx)
-            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")
@@ -659,17 +649,12 @@ async def game_watcher(ctx: SNIContext) -> None:
 
         perf_counter = time.perf_counter()
 
-        try:
+        await ctx.client_handler.game_watcher(ctx)
-            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 = settings.get_settings().sni_options.snes_rom_start
+    auto_start = typing.cast(typing.Union[bool, str],
+                             Utils.get_settings()["sni_options"].get("snes_rom_start", True))
     if auto_start is True:
         import webbrowser
         webbrowser.open(romfile)
@@ -735,6 +720,6 @@ async def main() -> None:
 
 
 if __name__ == '__main__':
-    colorama.just_fix_windows_console()
+    colorama.init()
     asyncio.run(main())
     colorama.deinit()

Starcraft2Client.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+import ModuleUpdate
+ModuleUpdate.update()
+
+from worlds.sc2.Client import launch
+import Utils
+
+if __name__ == "__main__":
+    Utils.init_logging("Starcraft2Client", exception_logger="Client")
+    launch()

UndertaleClient.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 import os
 import sys
-import time
 import asyncio
 import typing
 import bsdiff4
@@ -16,9 +15,6 @@ from CommonClient import CommonContext, server_loop, \
     gui_enabled, ClientCommandProcessor, logger, get_base_parser
 from Utils import async_start
 
-# Heartbeat for position sharing via bounces, in seconds
-UNDERTALE_STATUS_INTERVAL = 30.0
-UNDERTALE_ONLINE_TIMEOUT  = 60.0
 
 class UndertaleCommandProcessor(ClientCommandProcessor):
     def __init__(self, ctx):
@@ -33,7 +29,7 @@ class UndertaleCommandProcessor(ClientCommandProcessor):
     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)
+            os.makedirs(name=os.path.join(os.getcwd(), "Undertale"), exist_ok=True)
             self.ctx.patch_game()
             self.output("Patched.")
 
@@ -47,7 +43,7 @@ class UndertaleCommandProcessor(ClientCommandProcessor):
     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)
+            os.makedirs(name=os.path.join(os.getcwd(), "Undertale"), exist_ok=True)
             tempInstall = steaminstall
             if not os.path.isfile(os.path.join(tempInstall, "data.win")):
                 tempInstall = None
@@ -66,7 +62,7 @@ class UndertaleCommandProcessor(ClientCommandProcessor):
                 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))
+                               os.path.join(os.getcwd(), "Undertale", file_name))
                 self.ctx.patch_game()
                 self.output("Patching successful!")
 
@@ -113,19 +109,14 @@ class UndertaleContext(CommonContext):
         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")
-        self.last_sent_position: typing.Optional[tuple] = None
-        self.last_room: typing.Optional[str] = None
-        self.last_status_write: float = 0.0
-        self.other_undertale_status: dict[int, dict] = {}
-
 
     def patch_game(self):
-        with open(Utils.user_path("Undertale", "data.win"), "rb") as f:
+        with open(os.path.join(os.getcwd(), "Undertale", "data.win"), "rb") as f:
             patchedFile = bsdiff4.patch(f.read(), undertale.data_path("patch.bsdiff"))
-        with open(Utils.user_path("Undertale", "data.win"), "wb") as f:
+        with open(os.path.join(os.getcwd(), "Undertale", "data.win"), "wb") as f:
             f.write(patchedFile)
-        os.makedirs(name=Utils.user_path("Undertale", "Custom Sprites"), exist_ok=True)
+        os.makedirs(name=os.path.join(os.getcwd(), "Undertale", "Custom Sprites"), exist_ok=True)
-        with open(os.path.expandvars(Utils.user_path("Undertale", "Custom Sprites",
+        with open(os.path.expandvars(os.path.join(os.getcwd(), "Undertale", "Custom Sprites",
                                      "Which Character.txt")), "w") as f:
             f.writelines(["// Put the folder name of the sprites you want to play as, make sure it is the only "
                           "line other than this one.\n", "frisk"])
@@ -228,9 +219,6 @@ async def process_undertale_cmd(ctx: UndertaleContext, cmd: str, args: dict):
         await ctx.send_msgs([{"cmd": "SetNotify", "keys": [str(ctx.slot)+" RoutesDone neutral",
                                                            str(ctx.slot)+" RoutesDone pacifist",
                                                            str(ctx.slot)+" RoutesDone genocide"]}])
-        if any(info.game == "Undertale" and slot != ctx.slot 
-               for slot, info in ctx.slot_info.items()):
-            ctx.set_notify("undertale_room_status")
         if args["slot_data"]["only_flakes"]:
             with open(os.path.join(ctx.save_game_folder, "GenoNoChest.flag"), "w") as f:
                 f.close()
@@ -259,8 +247,8 @@ async def process_undertale_cmd(ctx: UndertaleContext, cmd: str, args: dict):
             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))):
+                    if i < len(str(ctx.item_names[l.item])):
-                        toDraw += str(ctx.item_names.lookup_in_game(l.item))[i]
+                        toDraw += str(ctx.item_names[l.item])[i]
                     else:
                         break
                 f.write(toDraw)
@@ -275,12 +263,6 @@ async def process_undertale_cmd(ctx: UndertaleContext, cmd: str, args: dict):
         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"]
-        if "undertale_room_status" in args["keys"] and args["keys"]["undertale_room_status"]:
-            status = args["keys"]["undertale_room_status"]
-            ctx.other_undertale_status = {
-                int(key): val for key, val in status.items()
-                if int(key) != ctx.slot
-            }
     elif cmd == "SetReply":
         if args["value"] is not None:
             if str(ctx.slot)+" RoutesDone pacifist" == args["key"]:
@@ -289,19 +271,17 @@ async def process_undertale_cmd(ctx: UndertaleContext, cmd: str, args: dict):
                 ctx.completed_routes["genocide"] = args["value"]
             elif str(ctx.slot)+" RoutesDone neutral" == args["key"]:
                 ctx.completed_routes["neutral"] = args["value"]
-        if args.get("key") == "undertale_room_status" and args.get("value"):
-            ctx.other_undertale_status = {
-                int(key): val for key, val in args["value"].items()
-                if int(key) != ctx.slot
-            }
     elif cmd == "ReceivedItems":
         start_index = args["index"]
 
         if start_index == 0:
             ctx.items_received = []
         elif start_index != len(ctx.items_received):
-            await ctx.check_locations(ctx.locations_checked)
+            sync_msg = [{"cmd": "Sync"}]
-            await ctx.send_msgs([{"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
@@ -388,8 +368,9 @@ async def process_undertale_cmd(ctx: UndertaleContext, cmd: str, args: dict):
                 f.close()
 
     elif cmd == "Bounced":
-        data = args.get("data", {})
+        tags = args.get("tags", [])
-        if "x" in data and "room" in data:
+        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:
@@ -400,63 +381,21 @@ async def process_undertale_cmd(ctx: UndertaleContext, cmd: str, args: dict):
 
 async def multi_watcher(ctx: UndertaleContext):
     while not ctx.exit_event.is_set():
-        if "Online" in ctx.tags and any(
+        path = ctx.save_game_folder
-                info.game == "Undertale" and slot != ctx.slot
+        for root, dirs, files in os.walk(path):
-                for slot, info in ctx.slot_info.items()):
+            for file in files:
-            now = time.time()
+                if "spots.mine" in file and "Online" in ctx.tags:
-            path = ctx.save_game_folder
+                    with open(os.path.join(root, file), "r") as mine:
-            for root, dirs, files in os.walk(path):
+                        this_x = mine.readline()
-                for file in files:
+                        this_y = mine.readline()
-                    if "spots.mine" in file:
+                        this_room = mine.readline()
-                        with open(os.path.join(root, file), "r") as mine:
+                        this_sprite = mine.readline()
-                            this_x = mine.readline()
+                        this_frame = mine.readline()
-                            this_y = mine.readline()
+                        mine.close()
-                            this_room = mine.readline()
+                    message = [{"cmd": "Bounce", "tags": ["Online"],
-                            this_sprite = mine.readline()
+                                "data": {"player": ctx.slot, "x": this_x, "y": this_y, "room": this_room,
-                            this_frame = mine.readline()
+                                         "spr": this_sprite, "frm": this_frame}}]
-
+                    await ctx.send_msgs(message)
-                        if this_room != ctx.last_room or \
-                                now - ctx.last_status_write >= UNDERTALE_STATUS_INTERVAL:
-                            ctx.last_room = this_room
-                            ctx.last_status_write = now
-                            await ctx.send_msgs([{
-                                "cmd": "Set",
-                                "key": "undertale_room_status",
-                                "default": {},
-                                "want_reply": False,
-                                "operations": [{"operation": "update",
-                                                "value": {str(ctx.slot): {"room": this_room,
-                                                                           "time": now}}}]
-                            }])
-
-                        # If player was visible but timed out (heartbeat) or left the room, remove them.
-                        for slot, entry in ctx.other_undertale_status.items():
-                            if entry.get("room") != this_room or \
-                                    now - entry.get("time", now) > UNDERTALE_ONLINE_TIMEOUT:
-                                playerspot = os.path.join(ctx.save_game_folder,
-                                                          f"FRISK{slot}.playerspot")
-                                if os.path.exists(playerspot):
-                                    os.remove(playerspot)
-
-                        current_position = (this_x, this_y, this_room, this_sprite, this_frame)
-                        if current_position == ctx.last_sent_position:
-                            continue
-
-                        # Empty status dict = no data yet → send to bootstrap.
-                        online_in_room = any(
-                            entry.get("room") == this_room and
-                            now - entry.get("time", now) <= UNDERTALE_ONLINE_TIMEOUT
-                            for entry in ctx.other_undertale_status.values()
-                        )
-                        if ctx.other_undertale_status and not online_in_room:
-                            continue
-
-                        message = [{"cmd": "Bounce", "games": ["Undertale"],
-                                    "data": {"player": ctx.slot, "x": this_x, "y": this_y,
-                                             "room": this_room, "spr": this_sprite,
-                                             "frm": this_frame}}]
-                        await ctx.send_msgs(message)
-                        ctx.last_sent_position = current_position
 
         await asyncio.sleep(0.1)
 
@@ -470,9 +409,10 @@ async def game_watcher(ctx: UndertaleContext):
                 for file in files:
                     if ".item" in file:
                         os.remove(os.path.join(root, file))
-            await ctx.check_locations(ctx.locations_checked)
+            sync_msg = [{"cmd": "Sync"}]
-            await ctx.send_msgs([{"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
@@ -507,7 +447,7 @@ async def game_watcher(ctx: UndertaleContext):
                         for l in lines:
                             sending = sending+[(int(l.rstrip('\n')))+12000]
                     finally:
-                        await ctx.check_locations(sending)
+                        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:
@@ -560,7 +500,7 @@ def main():
 
     import colorama
 
-    colorama.just_fix_windows_console()
+    colorama.init()
 
     asyncio.run(_main())
     colorama.deinit()

Utils.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import asyncio
-import concurrent.futures
 import json
 import typing
 import builtins
@@ -18,14 +17,10 @@ import logging
 import warnings
 
 from argparse import Namespace
-from datetime import datetime, timezone
-
 from settings import Settings, get_settings
-from time import sleep
+from typing import BinaryIO, Coroutine, Optional, Set, Dict, Any, Union
-from typing import BinaryIO, Coroutine, Optional, Set, Dict, Any, Union, TypeGuard
+from typing_extensions import TypeGuard
 from yaml import load, load_all, dump
-from pathspec import PathSpec, GitIgnoreSpec
-from typing_extensions import deprecated
 
 try:
     from yaml import CLoader as UnsafeLoader, CSafeLoader as SafeLoader, CDumper as Dumper
@@ -36,11 +31,10 @@ if typing.TYPE_CHECKING:
     import tkinter
     import pathlib
     from BaseClasses import Region
-    import multiprocessing
 
 
 def tuplize_version(version: str) -> Version:
-    return Version(*(int(piece) for piece in version.split(".")))
+    return Version(*(int(piece, 10) for piece in version.split(".")))
 
 
 class Version(typing.NamedTuple):
@@ -52,7 +46,7 @@ class Version(typing.NamedTuple):
         return ".".join(str(item) for item in self)
 
 
-__version__ = "0.6.7"
+__version__ = "0.4.6"
 version_tuple = tuplize_version(__version__)
 
 is_linux = sys.platform.startswith("linux")
@@ -107,7 +101,8 @@ def cache_self1(function: typing.Callable[[S, T], RetType]) -> typing.Callable[[
 
     @functools.wraps(function)
     def wrap(self: S, arg: T) -> RetType:
-        cache: Optional[Dict[T, RetType]] = getattr(self, cache_name, None)
+        cache: Optional[Dict[T, RetType]] = typing.cast(Optional[Dict[T, RetType]],
+                                                        getattr(self, cache_name, None))
         if cache is None:
             res = function(self, arg)
             setattr(self, cache_name, {arg: res})
@@ -119,8 +114,6 @@ def cache_self1(function: typing.Callable[[S, T], RetType]) -> typing.Callable[[
             cache[arg] = res
             return res
 
-    wrap.__defaults__ = function.__defaults__
-
     return wrap
 
 
@@ -144,11 +137,8 @@ def local_path(*path: str) -> str:
             local_path.cached_path = os.path.dirname(os.path.abspath(sys.argv[0]))
     else:
         import __main__
-        if globals().get("__file__") and os.path.isfile(__file__):
+        if hasattr(__main__, "__file__") and os.path.isfile(__main__.__file__):
             # we are running in a normal Python environment
-            local_path.cached_path = os.path.dirname(os.path.abspath(__file__))
-        elif hasattr(__main__, "__file__") and os.path.isfile(__main__.__file__):
-            # we are running in a normal Python environment, but AP was imported weirdly
             local_path.cached_path = os.path.dirname(os.path.abspath(__main__.__file__))
         else:
             # pray
@@ -162,18 +152,7 @@ def home_path(*path: str) -> str:
     if hasattr(home_path, 'cached_path'):
         pass
     elif sys.platform.startswith('linux'):
-        xdg_data_home = os.getenv('XDG_DATA_HOME', os.path.expanduser('~/.local/share'))
+        home_path.cached_path = os.path.expanduser('~/Archipelago')
-        home_path.cached_path = xdg_data_home + '/Archipelago'
-        if not os.path.isdir(home_path.cached_path):
-            legacy_home_path = os.path.expanduser('~/Archipelago')
-            if os.path.isdir(legacy_home_path):
-                os.renames(legacy_home_path, home_path.cached_path)
-                os.symlink(home_path.cached_path, legacy_home_path)
-            else:
-                os.makedirs(home_path.cached_path, 0o700, exist_ok=True)
-    elif sys.platform == 'darwin':
-        import platformdirs
-        home_path.cached_path = platformdirs.user_data_dir("Archipelago", False)
         os.makedirs(home_path.cached_path, 0o700, exist_ok=True)
     else:
         # not implemented
@@ -186,7 +165,7 @@ def user_path(*path: str) -> str:
     """Returns either local_path or home_path based on write permissions."""
     if hasattr(user_path, "cached_path"):
         pass
-    elif os.access(local_path(), os.W_OK) and not (is_macos and is_frozen()):
+    elif os.access(local_path(), os.W_OK):
         user_path.cached_path = local_path()
     else:
         user_path.cached_path = home_path()
@@ -230,17 +209,11 @@ def output_path(*path: str) -> str:
 
 def open_file(filename: typing.Union[str, "pathlib.Path"]) -> None:
     if is_windows:
-        os.startfile(filename)  # type: ignore
+        os.startfile(filename)
     else:
         from shutil import which
         open_command = which("open") if is_macos else (which("xdg-open") or which("gnome-open") or which("kde-open"))
-        assert open_command, "Didn't find program for open_file! Please report this together with system details."
+        subprocess.call([open_command, filename])
-
-        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.call([open_command, filename], env=env)
 
 
 # from https://gist.github.com/pypt/94d747fe5180851196eb#gistcomment-4015118 with some changes
@@ -318,29 +291,30 @@ def get_public_ipv6() -> str:
     return ip
 
 
-@deprecated("Utils.get_options() is deprecated. Use the settings API instead.")
+OptionsType = Settings  # TODO: remove when removing get_options
+
+
 def get_options() -> Settings:
-    deprecate("Utils.get_options() is deprecated. Use the settings API instead.")
+    # TODO: switch to Utils.deprecate after 0.4.4
+    warnings.warn("Utils.get_options() is deprecated. Use the settings API instead.", DeprecationWarning)
     return get_settings()
 
 
-def persistent_store(category: str, key: str, value: typing.Any, force_store: bool = False):
+def persistent_store(category: str, key: typing.Any, value: typing.Any):
-    storage = persistent_load()
-    if not force_store and category in storage and key in storage[category] and storage[category][key] == value:
-        return  # no changes necessary
-    category_dict = storage.setdefault(category, {})
-    category_dict[key] = value
     path = user_path("_persistent_storage.yaml")
+    storage: dict = persistent_load()
+    category = storage.setdefault(category, {})
+    category[key] = value
     with open(path, "wt") as f:
         f.write(dump(storage, Dumper=Dumper))
 
 
-def persistent_load() -> Dict[str, Dict[str, Any]]:
+def persistent_load() -> typing.Dict[str, dict]:
-    storage: Union[Dict[str, Dict[str, Any]], None] = getattr(persistent_load, "storage", None)
+    storage = getattr(persistent_load, "storage", None)
     if storage:
         return storage
     path = user_path("_persistent_storage.yaml")
-    storage = {}
+    storage: dict = {}
     if os.path.exists(path):
         try:
             with open(path, "r") as f:
@@ -349,7 +323,7 @@ def persistent_load() -> Dict[str, Dict[str, Any]]:
             logging.debug(f"Could not read store: {e}")
     if storage is None:
         storage = {}
-    setattr(persistent_load, "storage", storage)
+    persistent_load.storage = storage
     return storage
 
 
@@ -391,15 +365,6 @@ def store_data_package_for_checksum(game: str, data: typing.Dict[str, Any]) -> N
         except Exception as e:
             logging.debug(f"Could not store data package: {e}")
 
-
-def read_apignore(filename: str | pathlib.Path) -> PathSpec | None:
-    try:
-        with open(filename) as ignore_file:
-            return GitIgnoreSpec.from_lines(ignore_file)
-    except FileNotFoundError:
-        return None
-
-
 def get_default_adjuster_settings(game_name: str) -> Namespace:
     import LttPAdjuster
     adjuster_settings = Namespace()
@@ -418,33 +383,18 @@ def get_adjuster_settings(game_name: str) -> Namespace:
     default_settings = get_default_adjuster_settings(game_name)
 
     # Fill in any arguments from the argparser that we haven't seen before
-    return Namespace(**vars(adjuster_settings), **{
+    return Namespace(**vars(adjuster_settings), **{k:v for k,v in vars(default_settings).items() if k not in vars(adjuster_settings)})
-        k: v for k, v in vars(default_settings).items() if k not in vars(adjuster_settings)
-    })
 
 
 @cache_argsless
 def get_unique_identifier():
-    common_path = cache_path("common.json")
+    uuid = persistent_load().get("client", {}).get("uuid", None)
-    try:
-        with open(common_path) as f:
-            common_file = json.load(f)
-            uuid = common_file.get("uuid", None)
-    except FileNotFoundError:
-        common_file = {}
-        uuid = None
-
     if uuid:
         return uuid
 
-    from uuid import uuid4
+    import uuid
-    uuid = str(uuid4())
+    uuid = uuid.getnode()
-    common_file["uuid"] = uuid
+    persistent_store("client", "uuid", uuid)
-
-    cache_folder = os.path.dirname(common_path)
-    os.makedirs(cache_folder, exist_ok=True)
-    with open(common_path, "w") as f:
-        json.dump(common_file, f, separators=(",", ":"))
     return uuid
 
 
@@ -457,25 +407,20 @@ safe_builtins = frozenset((
 class RestrictedUnpickler(pickle.Unpickler):
     generic_properties_module: Optional[object]
 
-    def __init__(self, *args: Any, **kwargs: Any) -> None:
+    def __init__(self, *args, **kwargs):
         super(RestrictedUnpickler, self).__init__(*args, **kwargs)
         self.options_module = importlib.import_module("Options")
         self.net_utils_module = importlib.import_module("NetUtils")
         self.generic_properties_module = None
 
-    def find_class(self, module: str, name: str) -> type:
+    def find_class(self, module, name):
         if module == "builtins" and name in safe_builtins:
             return getattr(builtins, name)
-        # used by OptionCounter
-        # necessary because the actual Options class instances are pickled when transfered to WebHost generation pool
-        if module == "collections" and name == "Counter":
-            return collections.Counter
         # used by MultiServer -> savegame/multidata
-        if module == "NetUtils" and name in {"NetworkItem", "ClientStatus", "Hint",
+        if module == "NetUtils" and name in {"NetworkItem", "ClientStatus", "Hint", "SlotType", "NetworkSlot"}:
-                                             "SlotType", "NetworkSlot", "HintStatus"}:
             return getattr(self.net_utils_module, name)
         # Options and Plando are unpickled by WebHost -> Generate
-        if module == "worlds.generic" and name == "PlandoItem":
+        if module == "worlds.generic" and name in {"PlandoItem", "PlandoConnection"}:
             if not self.generic_properties_module:
                 self.generic_properties_module = importlib.import_module("worlds.generic")
             return getattr(self.generic_properties_module, name)
@@ -486,30 +431,17 @@ class RestrictedUnpickler(pickle.Unpickler):
             else:
                 mod = importlib.import_module(module)
             obj = getattr(mod, name)
-            if issubclass(obj, (self.options_module.Option, self.options_module.PlandoConnection,
+            if issubclass(obj, self.options_module.Option):
-                                self.options_module.PlandoItem, self.options_module.PlandoText)):
                 return obj
         # Forbid everything else.
         raise pickle.UnpicklingError(f"global '{module}.{name}' is forbidden")
 
 
-def restricted_loads(s: bytes) -> Any:
+def restricted_loads(s):
     """Helper function analogous to pickle.loads()."""
     return RestrictedUnpickler(io.BytesIO(s)).load()
 
 
-def restricted_dumps(obj: Any) -> bytes:
-    """Helper function analogous to pickle.dumps()."""
-    s = pickle.dumps(obj)
-    # Assert that the string can be successfully loaded by restricted_loads
-    try:
-        restricted_loads(s)
-    except pickle.UnpicklingError as e:
-        raise pickle.PicklingError(e) from e
-
-    return s
-
-
 class ByValue:
     """
     Mixin for enums to pickle value instead of name (restores pre-3.11 behavior). Use as left-most parent.
@@ -523,15 +455,6 @@ class KeyedDefaultDict(collections.defaultdict):
     """defaultdict variant that uses the missing key as argument to default_factory"""
     default_factory: typing.Callable[[typing.Any], typing.Any]
 
-    def __init__(self,
-                 default_factory: typing.Callable[[Any], Any] = None,
-                 seq: typing.Union[typing.Mapping, typing.Iterable, None] = None,
-                 **kwargs):
-        if seq is not None:
-            super().__init__(default_factory, seq, **kwargs)
-        else:
-            super().__init__(default_factory, **kwargs)
-
     def __missing__(self, key):
         self[key] = value = self.default_factory(key)
         return value
@@ -548,9 +471,9 @@ def get_text_after(text: str, start: str) -> str:
 loglevel_mapping = {'error': logging.ERROR, 'info': logging.INFO, 'warning': logging.WARNING, 'debug': logging.DEBUG}
 
 
-def init_logging(name: str, loglevel: typing.Union[str, int] = logging.INFO,
+def init_logging(name: str, loglevel: typing.Union[str, int] = logging.INFO, write_mode: str = "w",
-                 write_mode: str = "w", log_format: str = "[%(name)s at %(asctime)s]: %(message)s",
+                 log_format: str = "[%(name)s at %(asctime)s]: %(message)s",
-                 add_timestamp: bool = False, exception_logger: typing.Optional[str] = None):
+                 exception_logger: typing.Optional[str] = None):
     import datetime
     loglevel: int = loglevel_mapping.get(loglevel, loglevel)
     log_folder = user_path("logs")
@@ -570,25 +493,19 @@ def init_logging(name: str, loglevel: typing.Union[str, int] = logging.INFO,
     file_handler.setFormatter(logging.Formatter(log_format))
 
     class Filter(logging.Filter):
-        def __init__(self, filter_name: str, condition: typing.Callable[[logging.LogRecord], bool]) -> None:
+        def __init__(self, filter_name, condition):
             super().__init__(filter_name)
             self.condition = condition
 
         def filter(self, record: logging.LogRecord) -> bool:
             return self.condition(record)
 
-    file_handler.addFilter(Filter("NoStream", lambda record: not getattr(record, "NoFile", False)))
+    file_handler.addFilter(Filter("NoStream", lambda record: not getattr(record,  "NoFile", False)))
-    file_handler.addFilter(Filter("NoCarriageReturn", lambda record: '\r' not in record.getMessage()))
     root_logger.addHandler(file_handler)
     if sys.stdout:
-        formatter = logging.Formatter(fmt='[%(asctime)s] %(message)s', datefmt='%Y-%m-%d %H:%M:%S')
         stream_handler = logging.StreamHandler(sys.stdout)
         stream_handler.addFilter(Filter("NoFile", lambda record: not getattr(record, "NoStream", False)))
-        if add_timestamp:
-            stream_handler.setFormatter(formatter)
         root_logger.addHandler(stream_handler)
-        if hasattr(sys.stdout, "reconfigure"):
-            sys.stdout.reconfigure(encoding="utf-8", errors="replace")
 
     # Relay unhandled exceptions to logger.
     if not getattr(sys.excepthook, "_wrapped", False):  # skip if already modified
@@ -599,8 +516,7 @@ def init_logging(name: str, loglevel: typing.Union[str, int] = logging.INFO,
                 sys.__excepthook__(exc_type, exc_value, exc_traceback)
                 return
             logging.getLogger(exception_logger).exception("Uncaught exception",
-                                                          exc_info=(exc_type, exc_value, exc_traceback),
+                                                          exc_info=(exc_type, exc_value, exc_traceback))
-                                                          extra={"NoStream": exception_logger is None})
             return orig_hook(exc_type, exc_value, exc_traceback)
 
         handle_exception._wrapped = True
@@ -623,13 +539,12 @@ def init_logging(name: str, loglevel: typing.Union[str, int] = logging.INFO,
     import platform
     logging.info(
         f"Archipelago ({__version__}) logging initialized"
-        f" on {platform.platform()} process {os.getpid()}"
+        f" on {platform.platform()}"
         f" running Python {sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}"
-        f"{' (frozen)' if is_frozen() else ''}"
     )
 
 
-def stream_input(stream: typing.TextIO, queue: "asyncio.Queue[str]"):
+def stream_input(stream, queue):
     def queuer():
         while 1:
             try:
@@ -639,8 +554,6 @@ def stream_input(stream: typing.TextIO, queue: "asyncio.Queue[str]"):
             else:
                 if text:
                     queue.put_nowait(text)
-                else:
-                    sleep(0.01)  # non-blocking stream
 
     from threading import Thread
     thread = Thread(target=queuer, name=f"Stream handler for {stream.name}", daemon=True)
@@ -659,7 +572,7 @@ class VersionException(Exception):
     pass
 
 
-def chaining_prefix(index: int, labels: typing.Sequence[str]) -> str:
+def chaining_prefix(index: int, labels: typing.Tuple[str]) -> str:
     text = ""
     max_label = len(labels) - 1
     while index > max_label:
@@ -682,117 +595,47 @@ def format_SI_prefix(value, power=1000, power_labels=("", "k", "M", "G", "T", "P
     return f"{value.quantize(decimal.Decimal('1.00'))} {chaining_prefix(n, power_labels)}"
 
 
-def get_fuzzy_results(input_word: str, word_list: typing.Collection[str], limit: typing.Optional[int] = None) \
+def get_fuzzy_results(input_word: str, wordlist: typing.Sequence[str], limit: typing.Optional[int] = None) \
         -> typing.List[typing.Tuple[str, int]]:
     import jellyfish
 
     def get_fuzzy_ratio(word1: str, word2: str) -> float:
-        if word1 == word2:
-            return 1.01
         return (1 - jellyfish.damerau_levenshtein_distance(word1.lower(), word2.lower())
                 / max(len(word1), len(word2)))
 
-    limit = limit if limit else len(word_list)
+    limit: int = limit if limit else len(wordlist)
     return list(
         map(
             lambda container: (container[0], int(container[1]*100)),  # convert up to limit to int %
             sorted(
-                map(lambda candidate: (candidate, get_fuzzy_ratio(input_word, candidate)), word_list),
+                map(lambda candidate:
+                    (candidate,  get_fuzzy_ratio(input_word, candidate)),
+                    wordlist),
                 key=lambda element: element[1],
-                reverse=True
+                reverse=True)[0:limit]
-            )[0:limit]
         )
     )
 
 
-def get_intended_text(input_text: str, possible_answers) -> typing.Tuple[str, bool, str]:
+def open_filename(title: str, filetypes: typing.Sequence[typing.Tuple[str, typing.Sequence[str]]], suggest: str = "") \
-    picks = get_fuzzy_results(input_text, possible_answers, limit=2)
-    if len(picks) > 1:
-        dif = picks[0][1] - picks[1][1]
-        if picks[0][1] == 101:
-            return picks[0][0], True, "Perfect Match"
-        elif picks[0][1] == 100:
-            return picks[0][0], True, "Case Insensitive Perfect Match"
-        elif picks[0][1] < 75:
-            return picks[0][0], False, f"Didn't find something that closely matches '{input_text}', " \
-                                       f"did you mean '{picks[0][0]}'? ({picks[0][1]}% sure)"
-        elif dif > 5:
-            return picks[0][0], True, "Close Match"
-        else:
-            return picks[0][0], False, f"Too many close matches for '{input_text}', " \
-                                       f"did you mean '{picks[0][0]}'? ({picks[0][1]}% sure)"
-    else:
-        if picks[0][1] > 90:
-            return picks[0][0], True, "Only Option Match"
-        else:
-            return picks[0][0], False, f"Didn't find something that closely matches '{input_text}', " \
-                                       f"did you mean '{picks[0][0]}'? ({picks[0][1]}% sure)"
-
-
-def get_input_text_from_response(text: str, command: str) -> typing.Optional[str]:
-    """
-    Parses the response text from `get_intended_text` to find the suggested input and autocomplete the command in
-    arguments with it.
-
-    :param text: The response text from `get_intended_text`.
-    :param command: The command to which the input text should be added. Must contain the prefix used by the command
-                    (`!` or `/`).
-    :return: The command with the suggested input text appended, or None if no suggestion was found.
-    """
-    if "did you mean " in text:
-        for question in ("Didn't find something that closely matches",
-                         "Too many close matches"):
-            if text.startswith(question):
-                name = get_text_between(text, "did you mean '",
-                                        "'? (")
-                return f"{command} {name}"
-    elif text.startswith("Missing: "):
-        return text.replace("Missing: ", "!hint_location ")
-    return None
-
-
-def is_kivy_running() -> bool:
-    if "kivy" in sys.modules:
-        from kivy.app import App
-        return App.get_running_app() is not None
-    return False
-
-
-def _mp_open_filename(res: "multiprocessing.Queue[typing.Optional[str]]", *args: Any) -> None:
-    if is_kivy_running():
-        raise RuntimeError("kivy should not be running in multiprocess")
-    res.put(open_filename(*args))
-
-
-def _mp_save_filename(res: "multiprocessing.Queue[typing.Optional[str]]", *args: Any) -> None:
-    if is_kivy_running():
-        raise RuntimeError("kivy should not be running in multiprocess")
-    res.put(save_filename(*args))
-    
-def _run_for_stdout(*args: str):
-    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
-    return subprocess.run(args, capture_output=True, text=True, env=env).stdout.split("\n", 1)[0] or None
-
-
-def open_filename(title: str, filetypes: typing.Iterable[typing.Tuple[str, typing.Iterable[str]]], suggest: str = "") \
         -> typing.Optional[str]:
     logging.info(f"Opening file input dialog for {title}.")
 
+    def run(*args: str):
+        return subprocess.run(args, capture_output=True, text=True).stdout.split("\n", 1)[0] or None
+
     if is_linux:
         # prefer native dialog
         from shutil import which
         kdialog = which("kdialog")
         if kdialog:
             k_filters = '|'.join((f'{text} (*{" *".join(ext)})' for (text, ext) in filetypes))
-            return _run_for_stdout(kdialog, f"--title={title}", "--getopenfilename", suggest or ".", k_filters)
+            return run(kdialog, f"--title={title}", "--getopenfilename", suggest or ".", k_filters)
         zenity = which("zenity")
         if zenity:
             z_filters = (f'--file-filter={text} ({", ".join(ext)}) | *{" *".join(ext)}' for (text, ext) in filetypes)
             selection = (f"--filename={suggest}",) if suggest else ()
-            return _run_for_stdout(zenity, f"--title={title}", "--file-selection", *z_filters, *selection)
+            return run(zenity, f"--title={title}", "--file-selection", *z_filters, *selection)
 
     # fall back to tk
     try:
@@ -803,95 +646,31 @@ def open_filename(title: str, filetypes: typing.Iterable[typing.Tuple[str, typin
                       f'This attempt was made because open_filename was used for "{title}".')
         raise e
     else:
-        if is_macos and is_kivy_running():
-            # on macOS, mixing kivy and tk does not work, so spawn a new process
-            # FIXME: performance of this is pretty bad, and we should (also) look into alternatives
-            from multiprocessing import Process, Queue
-            res: "Queue[typing.Optional[str]]" = Queue()
-            Process(target=_mp_open_filename, args=(res, title, filetypes, suggest)).start()
-            return res.get()
         try:
             root = tkinter.Tk()
         except tkinter.TclError:
             return None  # GUI not available. None is the same as a user clicking "cancel"
         root.withdraw()
-        try:
+        return tkinter.filedialog.askopenfilename(title=title, filetypes=((t[0], ' '.join(t[1])) for t in filetypes),
-            return tkinter.filedialog.askopenfilename(
+                                                  initialfile=suggest or None)
-                title=title,
-                filetypes=((t[0], ' '.join(t[1])) for t in filetypes),
-                initialfile=suggest or None,
-            )
-        finally:
-            root.destroy()
-
-
-def save_filename(title: str, filetypes: typing.Iterable[typing.Tuple[str, typing.Iterable[str]]], suggest: str = "") \
-        -> typing.Optional[str]:
-    logging.info(f"Opening file save dialog for {title}.")
-
-    if is_linux:
-        # prefer native dialog
-        from shutil import which
-        kdialog = which("kdialog")
-        if kdialog:
-            k_filters = '|'.join((f'{text} (*{" *".join(ext)})' for (text, ext) in filetypes))
-            return _run_for_stdout(kdialog, f"--title={title}", "--getsavefilename", suggest or ".", k_filters)
-        zenity = which("zenity")
-        if zenity:
-            z_filters = (f'--file-filter={text} ({", ".join(ext)}) | *{" *".join(ext)}' for (text, ext) in filetypes)
-            selection = (f"--filename={suggest}",) if suggest else ()
-            return _run_for_stdout(zenity, f"--title={title}", "--file-selection", "--save", *z_filters, *selection)
-
-    # fall back to tk
-    try:
-        import tkinter
-        import tkinter.filedialog
-    except Exception as e:
-        logging.error('Could not load tkinter, which is likely not installed. '
-                      f'This attempt was made because save_filename was used for "{title}".')
-        raise e
-    else:
-        if is_macos and is_kivy_running():
-            # on macOS, mixing kivy and tk does not work, so spawn a new process
-            # FIXME: performance of this is pretty bad, and we should (also) look into alternatives
-            from multiprocessing import Process, Queue
-            res: "Queue[typing.Optional[str]]" = Queue()
-            Process(target=_mp_save_filename, args=(res, title, filetypes, suggest)).start()
-            return res.get()
-        try:
-            root = tkinter.Tk()
-        except tkinter.TclError:
-            return None  # GUI not available. None is the same as a user clicking "cancel"
-        root.withdraw()
-        try:
-            return tkinter.filedialog.asksaveasfilename(
-                title=title,
-                filetypes=((t[0], ' '.join(t[1])) for t in filetypes),
-                initialfile=suggest or None,
-            )
-        finally:
-            root.destroy()
-
-
-def _mp_open_directory(res: "multiprocessing.Queue[typing.Optional[str]]", *args: Any) -> None:
-    if is_kivy_running():
-        raise RuntimeError("kivy should not be running in multiprocess")
-    res.put(open_directory(*args))
 
 
 def open_directory(title: str, suggest: str = "") -> typing.Optional[str]:
+    def run(*args: str):
+        return subprocess.run(args, capture_output=True, text=True).stdout.split("\n", 1)[0] or None
+
     if is_linux:
         # prefer native dialog
         from shutil import which
         kdialog = which("kdialog")
         if kdialog:
-            return _run_for_stdout(kdialog, f"--title={title}", "--getexistingdirectory",
+            return run(kdialog, f"--title={title}", "--getexistingdirectory",
                        os.path.abspath(suggest) if suggest else ".")
         zenity = which("zenity")
         if zenity:
             z_filters = ("--directory",)
             selection = (f"--filename={os.path.abspath(suggest)}/",) if suggest else ()
-            return _run_for_stdout(zenity, f"--title={title}", "--file-selection", *z_filters, *selection)
+            return run(zenity, f"--title={title}", "--file-selection", *z_filters, *selection)
 
     # fall back to tk
     try:
@@ -899,16 +678,9 @@ def open_directory(title: str, suggest: str = "") -> typing.Optional[str]:
         import tkinter.filedialog
     except Exception as e:
         logging.error('Could not load tkinter, which is likely not installed. '
-                      f'This attempt was made because open_directory was used for "{title}".')
+                      f'This attempt was made because open_filename was used for "{title}".')
         raise e
     else:
-        if is_macos and is_kivy_running():
-            # on macOS, mixing kivy and tk does not work, so spawn a new process
-            # FIXME: performance of this is pretty bad, and we should (also) look into alternatives
-            from multiprocessing import Process, Queue
-            res: "Queue[typing.Optional[str]]" = Queue()
-            Process(target=_mp_open_directory, args=(res, title, suggest)).start()
-            return res.get()
         try:
             root = tkinter.Tk()
         except tkinter.TclError:
@@ -918,12 +690,14 @@ def open_directory(title: str, suggest: str = "") -> typing.Optional[str]:
 
 
 def messagebox(title: str, text: str, error: bool = False) -> None:
-    if not gui_enabled:
+    def run(*args: str):
-        if error:
+        return subprocess.run(args, capture_output=True, text=True).stdout.split("\n", 1)[0] or None
-            logging.error(f"{title}: {text}")
+
-        else:
+    def is_kivy_running():
-            logging.info(f"{title}: {text}")
+        if "kivy" in sys.modules:
-        return
+            from kivy.app import App
+            return App.get_running_app() is not None
+        return False
 
     if is_kivy_running():
         from kvui import MessageBox
@@ -935,10 +709,10 @@ def messagebox(title: str, text: str, error: bool = False) -> None:
         from shutil import which
         kdialog = which("kdialog")
         if kdialog:
-            return _run_for_stdout(kdialog, f"--title={title}", "--error" if error else "--msgbox", text)
+            return run(kdialog, f"--title={title}", "--error" if error else "--msgbox", text)
         zenity = which("zenity")
         if zenity:
-            return _run_for_stdout(zenity, f"--title={title}", f"--text={text}", "--error" if error else "--info")
+            return run(zenity, f"--title={title}", f"--text={text}", "--error" if error else "--info")
 
     elif is_windows:
         import ctypes
@@ -960,10 +734,7 @@ def messagebox(title: str, text: str, error: bool = False) -> None:
         root.update()
 
 
-gui_enabled = not sys.stdout or "--nogui" not in sys.argv
+def title_sorted(data: typing.Sequence, key=None, ignore: typing.Set = frozenset(("a", "the"))):
-"""Checks if the user wanted no GUI mode and has a terminal to use it with."""
-
-def title_sorted(data: typing.Iterable, key=None, ignore: typing.AbstractSet[str] = frozenset(("a", "the"))):
     """Sorts a sequence of text ignoring typical articles like "a" or "the" in the beginning."""
     def sorter(element: Union[str, Dict[str, Any]]) -> str:
         if (not isinstance(element, str)):
@@ -993,7 +764,7 @@ def async_start(co: Coroutine[None, None, typing.Any], name: Optional[str] = Non
     Use this to start a task when you don't keep a reference to it or immediately await it,
     to prevent early garbage collection. "fire-and-forget"
     """
-    # https://docs.python.org/3.11/library/asyncio-task.html#asyncio.create_task
+    # https://docs.python.org/3.10/library/asyncio-task.html#asyncio.create_task
     # Python docs:
     # ```
     # Important: Save a reference to the result of [asyncio.create_task],
@@ -1006,40 +777,41 @@ def async_start(co: Coroutine[None, None, typing.Any], name: Optional[str] = Non
     task.add_done_callback(_faf_tasks.discard)
 
 
-def deprecate(message: str, add_stacklevels: int = 0):
+def deprecate(message: str):
-    """also use typing_extensions.deprecated wherever you use this"""
     if __debug__:
         raise Exception(message)
-    warnings.warn(message, stacklevel=2 + add_stacklevels)
+    import warnings
+    warnings.warn(message)
 
 
 class DeprecateDict(dict):
     log_message: str
     should_error: bool
 
-    def __init__(self, message: str, error: bool = False) -> None:
+    def __init__(self, message, error: bool = False) -> None:
         self.log_message = message
         self.should_error = error
         super().__init__()
 
     def __getitem__(self, item: Any) -> Any:
         if self.should_error:
-            deprecate(self.log_message, add_stacklevels=1)
+            deprecate(self.log_message)
         elif __debug__:
-            warnings.warn(self.log_message, stacklevel=2)
+            import warnings
+            warnings.warn(self.log_message)
         return super().__getitem__(item)
 
 
 def _extend_freeze_support() -> None:
-    """Extend multiprocessing.freeze_support() to also work on Non-Windows and without setting spawn method first."""
+    """Extend multiprocessing.freeze_support() to also work on Non-Windows for spawn."""
-    # original upstream issue: https://github.com/python/cpython/issues/76327
+    # upstream issue: https://github.com/python/cpython/issues/76327
     # code based on https://github.com/pyinstaller/pyinstaller/blob/develop/PyInstaller/hooks/rthooks/pyi_rth_multiprocessing.py#L26
     import multiprocessing
     import multiprocessing.spawn
 
     def _freeze_support() -> None:
         """Minimal freeze_support. Only apply this if frozen."""
-        from subprocess import _args_from_interpreter_flags  # noqa
+        from subprocess import _args_from_interpreter_flags
 
         # Prevent `spawn` from trying to read `__main__` in from the main script
         multiprocessing.process.ORIGINAL_DIR = None
@@ -1047,7 +819,8 @@ def _extend_freeze_support() -> None:
         # Handle the first process that MP will create
         if (
             len(sys.argv) >= 2 and sys.argv[-2] == '-c' and sys.argv[-1].startswith((
-                'from multiprocessing.resource_tracker import main',
+                'from multiprocessing.semaphore_tracker import main',  # Py<3.8
+                'from multiprocessing.resource_tracker import main',  # Py>=3.8
                 'from multiprocessing.forkserver import main'
             )) and set(sys.argv[1:-2]) == set(_args_from_interpreter_flags())
         ):
@@ -1066,36 +839,20 @@ def _extend_freeze_support() -> None:
             multiprocessing.spawn.spawn_main(**kwargs)
             sys.exit()
 
-    def _noop() -> None:
+    if not is_windows and is_frozen():
-        pass
+        multiprocessing.freeze_support = multiprocessing.spawn.freeze_support = _freeze_support
-
-    multiprocessing.freeze_support = multiprocessing.spawn.freeze_support = _freeze_support if is_frozen() else _noop
 
 
-@deprecated("Use multiprocessing.freeze_support() instead")
 def freeze_support() -> None:
-    """This now only calls multiprocessing.freeze_support since we are patching freeze_support on module load."""
+    """This behaves like multiprocessing.freeze_support but also works on Non-Windows."""
     import multiprocessing
-
+    _extend_freeze_support()
-    deprecate("Use multiprocessing.freeze_support() instead")
     multiprocessing.freeze_support()
 
 
-_extend_freeze_support()
+def visualize_regions(root_region: Region, file_name: str, *,
-
+                      show_entrance_names: bool = False, show_locations: bool = True, show_other_regions: bool = True,
-
+                      linetype_ortho: bool = True) -> None:
-def visualize_regions(
-        root_region: Region,
-        file_name: str,
-        *,
-        show_entrance_names: bool = False,
-        show_locations: bool = True,
-        show_other_regions: bool = True,
-        linetype_ortho: bool = True,
-        regions_to_highlight: set[Region] | None = None,
-        entrance_highlighting: dict[int, int] | None = None,
-        detail_other_regions: bool = False,
-        auto_assign_colors: bool = False) -> None:
     """Visualize the layout of a world as a PlantUML diagram.
 
     :param root_region: The region from which to start the diagram from. (Usually the "Menu" region of your world.)
@@ -1111,29 +868,16 @@ def visualize_regions(
             Items without ID will be shown in italics.
     :param show_other_regions: (default True) If enabled, regions that can't be reached by traversing exits are shown.
     :param linetype_ortho: (default True) If enabled, orthogonal straight line parts will be used; otherwise polylines.
-    :param regions_to_highlight: Regions that will be highlighted in green if they are reachable.
-    :param entrance_highlighting: a mapping from your world's entrance randomization groups to RGB values, used to color
-            your entrances
-    :param detail_other_regions: (default False) If enabled, will fully visualize regions that aren't reachable
-            from root_region.
-    :param auto_assign_colors: (default False) If enabled, will automatically assign random colors to entrances of the
-            same randomization group. Uses entrance_highlighting first, and only picks random colors for entrance groups
-            not found in the passed-in map
 
     Example usage in World code:
     from Utils import visualize_regions
-    state = self.multiworld.get_all_state(False)
+    visualize_regions(self.multiworld.get_region("Menu", self.player), "my_world.puml")
-    state.update_reachable_regions(self.player)
-    visualize_regions(self.get_region("Menu"), "my_world.puml", show_entrance_names=True,
-                      regions_to_highlight=state.reachable_regions[self.player])
 
     Example usage in Main code:
     from Utils import visualize_regions
     for player in multiworld.player_ids:
         visualize_regions(multiworld.get_region("Menu", player), f"{multiworld.get_out_file_name_base(player)}.puml")
     """
-    if regions_to_highlight is None:
-        regions_to_highlight = set()
     assert root_region.multiworld, "The multiworld attribute of root_region has to be filled"
     from BaseClasses import Entrance, Item, Location, LocationProgressType, MultiWorld, Region
     from collections import deque
@@ -1144,34 +888,6 @@ def visualize_regions(
     regions: typing.Deque[Region] = deque((root_region,))
     multiworld: MultiWorld = root_region.multiworld
 
-    colors_used: set[int] = set()
-    if entrance_highlighting:
-        for color in entrance_highlighting.values():
-            # filter the colors to their most-significant bits to avoid too similar colors
-            colors_used.add(color & 0xF0F0F0)
-    else:
-        # assign an empty dict to not crash later
-        # the parameter is optional for ease of use when you don't care about colors
-        entrance_highlighting = {}
-
-    def select_color(group: int) -> int:
-        # specifically spacing color indexes by three different prime numbers (3, 5, 7) for the RGB components to avoid
-        # obvious cyclical color patterns
-        COLOR_INDEX_SPACING: int = 0x357
-        new_color_index: int = (group * COLOR_INDEX_SPACING) % 0x1000
-        new_color = ((new_color_index & 0xF00) << 12) + \
-                    ((new_color_index & 0xF0) << 8) + \
-                    ((new_color_index & 0xF) << 4)
-        while new_color in colors_used:
-            # while this is technically unbounded, expected collisions are low. There are 4095 possible colors
-            # and worlds are unlikely to get to anywhere close to that many entrance groups
-            # intentionally not using multiworld.random to not affect output when debugging with this tool
-            new_color_index += COLOR_INDEX_SPACING
-            new_color = ((new_color_index & 0xF00) << 12) + \
-                        ((new_color_index & 0xF0) << 8) + \
-                        ((new_color_index & 0xF) << 4)
-        return new_color
-
     def fmt(obj: Union[Entrance, Item, Location, Region]) -> str:
         name = obj.name
         if isinstance(obj, Item):
@@ -1191,28 +907,18 @@ def visualize_regions(
 
     def visualize_exits(region: Region) -> None:
         for exit_ in region.exits:
-            color_code: str = ""
-            if exit_.randomization_group in entrance_highlighting:
-                color_code = f" #{entrance_highlighting[exit_.randomization_group]:0>6X}"
             if exit_.connected_region:
                 if show_entrance_names:
-                    uml.append(f"\"{fmt(region)}\" --> \"{fmt(exit_.connected_region)}\" : \"{fmt(exit_)}\"{color_code}")
+                    uml.append(f"\"{fmt(region)}\" --> \"{fmt(exit_.connected_region)}\" : \"{fmt(exit_)}\"")
                 else:
                     try:
-                        uml.remove(f"\"{fmt(exit_.connected_region)}\" --> \"{fmt(region)}\"{color_code}")
+                        uml.remove(f"\"{fmt(exit_.connected_region)}\" --> \"{fmt(region)}\"")
-                        uml.append(f"\"{fmt(exit_.connected_region)}\" <--> \"{fmt(region)}\"{color_code}")
+                        uml.append(f"\"{fmt(exit_.connected_region)}\" <--> \"{fmt(region)}\"")
                     except ValueError:
-                        uml.append(f"\"{fmt(region)}\" --> \"{fmt(exit_.connected_region)}\"{color_code}")
+                        uml.append(f"\"{fmt(region)}\" --> \"{fmt(exit_.connected_region)}\"")
             else:
-                uml.append(f"circle \"unconnected exit:\\n{fmt(exit_)}\" {color_code}")
+                uml.append(f"circle \"unconnected exit:\\n{fmt(exit_)}\"")
-                uml.append(f"\"{fmt(region)}\" --> \"unconnected exit:\\n{fmt(exit_)}\"{color_code}")
+                uml.append(f"\"{fmt(region)}\" --> \"unconnected exit:\\n{fmt(exit_)}\"")
-        for entrance in region.entrances:
-            color_code: str = ""
-            if entrance.randomization_group in entrance_highlighting:
-                color_code = f" #{entrance_highlighting[entrance.randomization_group]:0>6X}"
-            if not entrance.parent_region:
-                uml.append(f"circle \"unconnected entrance:\\n{fmt(entrance)}\"{color_code}")
-                uml.append(f"\"unconnected entrance:\\n{fmt(entrance)}\" --> \"{fmt(region)}\"{color_code}")
 
     def visualize_locations(region: Region) -> None:
         any_lock = any(location.locked for location in region.locations)
@@ -1224,7 +930,7 @@ def visualize_regions(
                 uml.append(f"\"{fmt(region)}\" : {{field}} {lock}{fmt(location)}")
 
     def visualize_region(region: Region) -> None:
-        uml.append(f"class \"{fmt(region)}\" {'#00FF00' if region in regions_to_highlight else ''}")
+        uml.append(f"class \"{fmt(region)}\"")
         if show_locations:
             visualize_locations(region)
         visualize_exits(region)
@@ -1233,27 +939,9 @@ def visualize_regions(
         if other_regions := [region for region in multiworld.get_regions(root_region.player) if region not in seen]:
             uml.append("package \"other regions\" <<Cloud>> {")
             for region in other_regions:
-                if detail_other_regions:
+                uml.append(f"class \"{fmt(region)}\"")
-                    visualize_region(region)
-                else:
-                    uml.append(f"class \"{fmt(region)}\"")
             uml.append("}")
 
-    if auto_assign_colors:
-        all_entrances: list[Entrance] = []
-        for region in multiworld.get_regions(root_region.player):
-            all_entrances.extend(region.entrances)
-            all_entrances.extend(region.exits)
-        all_groups: list[int] = sorted(set([entrance.randomization_group for entrance in all_entrances]))
-        for group in all_groups:
-            if group not in entrance_highlighting:
-                if len(colors_used) >= 0x1000:
-                    # on the off chance someone makes 4096 different entrance groups, don't cycle forever
-                    break
-                new_color: int = select_color(group)
-                entrance_highlighting[group] = new_color
-                colors_used.add(new_color)
-
     uml.append("@startuml")
     uml.append("hide circle")
     uml.append("hide empty members")
@@ -1264,7 +952,7 @@ def visualize_regions(
             seen.add(current_region)
             visualize_region(current_region)
             regions.extend(exit_.connected_region for exit_ in current_region.exits if exit_.connected_region)
-    if show_other_regions or detail_other_regions:
+    if show_other_regions:
         visualize_other_regions()
     uml.append("@enduml")
 
@@ -1291,81 +979,3 @@ def is_iterable_except_str(obj: object) -> TypeGuard[typing.Iterable[typing.Any]
     if isinstance(obj, str):
         return False
     return isinstance(obj, typing.Iterable)
-
-
-def utcnow() -> datetime:
-    """
-    Implementation of Python's datetime.utcnow() function for use after deprecation.
-    Needed for timezone-naive UTC datetimes stored in databases with PonyORM (upstream).
-    https://ponyorm.org/ponyorm-list/2014-August/000113.html
-    """
-    return datetime.now(timezone.utc).replace(tzinfo=None)
-
-
-class DaemonThreadPoolExecutor(concurrent.futures.ThreadPoolExecutor):
-    """
-    ThreadPoolExecutor that uses daemonic threads that do not keep the program alive.
-    NOTE: use this with caution because killed threads will not properly clean up.
-    """
-
-    def _adjust_thread_count(self):
-        # see upstream ThreadPoolExecutor for details
-        import threading
-        import weakref
-        from concurrent.futures.thread import _worker
-
-        if self._idle_semaphore.acquire(timeout=0):
-            return
-
-        def weakref_cb(_, q=self._work_queue):
-            q.put(None)
-
-        num_threads = len(self._threads)
-        if num_threads < self._max_workers:
-            thread_name = f"{self._thread_name_prefix or self}_{num_threads}"
-            t = threading.Thread(
-                name=thread_name,
-                target=_worker,
-                args=(
-                    weakref.ref(self, weakref_cb),
-                    self._work_queue,
-                    self._initializer,
-                    self._initargs,
-                ),
-                daemon=True,
-            )
-            t.start()
-            self._threads.add(t)
-            # NOTE: don't add to _threads_queues so we don't block on shutdown
-
-
-def get_full_typename(t: type) -> str:
-    """Returns the full qualified name of a type, including its module (if not builtins)."""
-    module = t.__module__
-    if module and module != "builtins":
-        return f"{module}.{t.__qualname__}"
-    return t.__qualname__
-
-
-def get_all_causes(ex: Exception) -> str:
-    """Return a string describing the recursive causes of this exception.
-
-    :param ex: The exception to be described.
-    :return A multiline string starting with the initial exception on the first line and each resulting exception
-            on subsequent lines with progressive indentation.
-
-            For example:
-
-            ```
-            Exception: Invalid value 'bad'.
-             Which caused: Options.OptionError: Error generating option
-              Which caused: ValueError: File bad.yaml is invalid.
-            ```
-    """
-    cause = ex
-    causes = [f"{get_full_typename(type(ex))}: {ex}"]
-    while cause := cause.__cause__:
-        causes.append(f"{get_full_typename(type(cause))}: {cause}")
-    top = causes[-1]
-    others = "".join(f"\n{' ' * (i + 1)}Which caused: {c}" for i, c in enumerate(reversed(causes[:-1])))
-    return f"{top}{others}"

WargrooveClient.py

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

WebHost.py

@@ -1,4 +1,3 @@
-import argparse
 import os
 import multiprocessing
 import logging
@@ -12,20 +11,15 @@ ModuleUpdate.update()
 # in case app gets imported by something like gunicorn
 import Utils
 import settings
-from Utils import get_file_safe_name
 
-if typing.TYPE_CHECKING:
+Utils.local_path.cached_path = os.path.dirname(__file__) or "."  # py3.8 is not abs. remove "." when dropping 3.8
-    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):
+if not os.path.exists(configpath):  # fall back to config.yaml in home
-    # fall back to config.yaml in user_path if config does not exist in cwd to match settings.py
     configpath = os.path.abspath(Utils.user_path('config.yaml'))
 
 
-def get_app() -> "Flask":
+def get_app():
     from WebHostLib import register, cache, app as raw_app
     from WebHostLib.models import db
 
@@ -34,15 +28,6 @@ def get_app() -> "Flask":
         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()
@@ -55,24 +40,24 @@ def get_app() -> "Flask":
     return app
 
 
-def copy_tutorials_files_to_static() -> None:
+def create_ordered_tutorials_file() -> typing.List[typing.Dict[str, typing.Any]]:
+    import json
     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, secure_filename(game))
+        target_path = os.path.join(base_target_path, game)
         os.makedirs(target_path, exist_ok=True)
 
         if world.zip_path:
@@ -85,14 +70,45 @@ def copy_tutorials_files_to_static() -> None:
                 for zfile in zf.infolist():
                     if not zfile.is_dir() and "/docs/" in zfile.filename:
                         zfile.filename = os.path.basename(zfile.filename)
-                        with open(os.path.join(target_path, secure_filename(zfile.filename)), "wb") as f:
+                        zf.extract(zfile, target_path)
-                            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),
+                shutil.copyfile(Utils.local_path(source_path, file), Utils.local_path(target_path, file))
-                                Utils.local_path(target_path, secure_filename(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
 
 
 if __name__ == "__main__":
@@ -100,25 +116,18 @@ if __name__ == "__main__":
     multiprocessing.set_start_method('spawn')
     logging.basicConfig(format='[%(asctime)s] %(message)s', level=logging.INFO)
 
-    from WebHostLib.autolauncher import autohost, autogen, stop
+    from WebHostLib.lttpsprites import update_sprites_lttp
+    from WebHostLib.autolauncher import autohost, autogen
     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()
-    from worlds import AutoWorldRegister
-    # Update to only valid WebHost worlds
-    invalid_worlds = {name for name, world in AutoWorldRegister.world_types.items()
-                      if not hasattr(world.web, "tutorials")}
-    if invalid_worlds:
-        logging.error(f"Following worlds not loaded as they are invalid for WebHost: {invalid_worlds}")
-    AutoWorldRegister.world_types = {k: v for k, v in AutoWorldRegister.world_types.items() if k not in invalid_worlds}
     create_options_files()
-    copy_tutorials_files_to_static()
+    create_ordered_tutorials_file()
     if app.config["SELFLAUNCH"]:
         autohost(app.config)
     if app.config["SELFGEN"]:
@@ -129,11 +138,3 @@ if __name__ == "__main__":
         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/README.md

@@ -1,20 +1,46 @@
 # WebHost
 
-## Asset License
-
-The image files used in the page design were specifically designed for archipelago.gg and are **not** covered by the top
-level LICENSE.
-See individual LICENSE files in `./static/static/**`.
-
-You are only allowed to use them for personal use, testing and development.
-If the site is reachable over the internet, have a robots.txt in place (see `ASSET_RIGHTS` in `config.yaml`)
-and do not promote it publicly. Alternatively replace or remove the assets.
-
 ## Contribution Guidelines
+**Thank you for your interest in contributing to the Archipelago website!**  
+Much of the content on the website is generated automatically, but there are some things
+that need a personal touch. For those things, we rely on contributions from both the core
+team and the community. The current primary maintainer of the website is Farrak Kilhn.
+He may be found on Discord as `Farrak Kilhn#0418`, or on GitHub as `LegendaryLinux`.
 
-Pages should preferably be rendered on the server side with Jinja. Features should work with noscript if feasible.
+### Small Changes
-Design changes have to fit the overall design.
+Little changes like adding a button or a couple new select elements are perfectly fine.
+Tweaks to style specific to a PR's content are also probably not a problem. For example, if
+you build a new page which needs two side by side tables, and you need to write a CSS file
+specific to your page, that is perfectly reasonable.
 
-Introduction of JS dependencies should first be discussed on Discord or in a draft PR.
+### Content Additions
+Once you develop a new feature or add new content the website, make a pull request. It will
+be reviewed by the community and there will probably be some discussion around it. Depending
+on the size of the feature, and if new styles are required, there may be an additional step
+before the PR is accepted wherein Farrak works with the designer to implement styles.
 
-See also [docs/style.md](/docs/style.md) for the style guide.
+### Restrictions on Style Changes
+A professional designer is paid to develop the styles and assets for the Archipelago website.
+In an effort to maintain a consistent look and feel, pull requests which *exclusively*
+change site styles are rejected. Please note this applies to code which changes the overall
+look and feel of the site, not to small tweaks to CSS for your custom page. The intention
+behind these restrictions is to maintain a curated feel for the design of the site. If
+any PR affects the overall feel of the site but includes additive changes, there will
+likely be a conversation about how to implement those changes without compromising the
+curated site style. It is therefore worth noting there are a couple files which, if
+changed in your pull request, will cause it to draw additional scrutiny.
+
+These closely guarded files are:
+- `globalStyles.css`
+- `islandFooter.css`
+- `landing.css`
+- `markdown.css`
+- `tooltip.css`
+
+### Site Themes
+There are several themes available for game pages. It is possible to request a new theme in
+the `#art-and-design` channel on Discord. Because themes are created by the designer, they
+are not free, and take some time to create. Farrak works closely with the designer to implement
+these themes, and pays for the assets out of pocket. Therefore, only a couple themes per year
+are added. If a proposed theme seems like a cool idea and the community likes it, there is a
+good chance it will become a reality.

WebHostLib/__init__.py

@@ -1,7 +1,6 @@
 import base64
 import os
 import socket
-import typing
 import uuid
 
 from flask import Flask
@@ -10,8 +9,7 @@ from flask_compress import Compress
 from pony.flask import Pony
 from werkzeug.routing import BaseConverter
 
-from Utils import title_sorted, get_file_safe_name
+from Utils import title_sorted
-from .cli import CLI
 
 UPLOAD_FOLDER = os.path.relpath('uploads')
 LOGS_FOLDER = os.path.relpath('logs')
@@ -22,19 +20,7 @@ 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
 
-# overwrites of flask default config
-app.config["DEBUG"] = False
-app.config["PORT"] = 80
-app.config["UPLOAD_FOLDER"] = UPLOAD_FOLDER
-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")
-app.config["SESSION_PERMANENT"] = True
-app.config["MAX_FORM_MEMORY_SIZE"] = 2 * 1024 * 1024  # 2 MB, needed for large option pages such as SC2
-
-# custom config
 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
@@ -42,14 +28,17 @@ app.config["SELFLAUNCH"] = True  # application process is in charge of launching
 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
 app.config["SELFGEN"] = True  # application process is in charge of scheduling Generations.
+app.config["DEBUG"] = False
+app.config["PORT"] = 80
+app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
+app.config['MAX_CONTENT_LENGTH'] = 64 * 1024 * 1024  # 64 megabyte limit
+# if you want to deploy, make sure you have a non-guessable secret key
+app.config["SECRET_KEY"] = bytes(socket.gethostname(), encoding="utf-8")
 # at what amount of worlds should scheduling be used, instead of rolling in the web-thread
 app.config["JOB_THRESHOLD"] = 1
 # 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
-# maximum time in seconds since last activity for a room to be hosted
+app.config['SESSION_PERMANENT'] = True
-app.config["MAX_ROOM_TIMEOUT"] = 259200
-# memory limit for generator processes in bytes
-app.config["GENERATOR_MEMORY_LIMIT"] = 4294967296
 
 # waitress uses one thread for I/O, these are for processing of views that then get sent
 # archipelago.gg uses gunicorn + nginx; ignoring this option
@@ -67,47 +56,34 @@ app.config["ASSET_RIGHTS"] = False
 
 cache = Cache()
 Compress(app)
-CLI(app)
-
-
-def to_python(value: str) -> uuid.UUID:
-    return uuid.UUID(bytes=base64.urlsafe_b64decode(value + '=='))
-
-
-def to_url(value: uuid.UUID) -> str:
-    return base64.urlsafe_b64encode(value.bytes).rstrip(b'=').decode('ascii')
 
 
 class B64UUIDConverter(BaseConverter):
 
-    def to_python(self, value: str) -> uuid.UUID:
+    def to_python(self, value):
-        return to_python(value)
+        return uuid.UUID(bytes=base64.urlsafe_b64decode(value + '=='))
 
-    def to_url(self, value: typing.Any) -> str:
+    def to_url(self, value):
-        assert isinstance(value, uuid.UUID)
+        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"] = to_url
+app.jinja_env.filters['suuid'] = lambda value: base64.urlsafe_b64encode(value.bytes).rstrip(b'=').decode('ascii')
 app.jinja_env.filters["title_sorted"] = title_sorted
 
 
-def register() -> None:
+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['is_applayercontainer'] = worlds.Files.is_ap_player_container
+    app.jinja_env.filters['supports_apdeltapatch'] = lambda game_name: \
+        game_name in worlds.Files.AutoPatchRegister.patch_types
 
     from WebHostLib.customserver import run_server_process
+    # to trigger app routing picking up on it
+    from . import tracker, upload, landing, check, generate, downloads, api, stats, misc, robots, options
 
-    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,25 +1,78 @@
 """API endpoints package."""
 from typing import List, Tuple
+from uuid import UUID
 
-from flask import Blueprint
+from flask import Blueprint, abort, url_for
-from flask_cors import CORS
 
-from ..models import Seed, Slot
+import worlds.Files
+from .. import cache
+from ..models import Room, Seed
 
 api_endpoints = Blueprint('api', __name__, url_prefix="/api")
-cors = CORS(api_endpoints, resources={
+
-                r"/api/datapackage/*": {"origins": "*"},
+# unsorted/misc endpoints
-                r"/api/datapackage": {"origins": "*"},
-                r"/api/datapackage_checksum/*": {"origins": "*"},
-                r"/api/room_status/*": {"origins": "*"},
-                r"/api/tracker/*": {"origins": "*"},
-                r"/api/static_tracker/*": {"origins": "*"},
-                r"/api/slot_data_tracker/*": {"origins": "*"}
-            })
 
 
 def get_players(seed: Seed) -> List[Tuple[str, str]]:
-    return [(slot.player_name, slot.game) for slot in seed.slots.order_by(Slot.player_id)]
+    return [(slot.player_name, slot.game) for slot in seed.slots]
 
-# trigger endpoint registration
+
-from . import datapackage, generate, room, tracker, user
+@api_endpoints.route('/room_status/<suuid:room>')
+def room_info(room: UUID):
+    room = Room.get(id=room)
+    if room is None:
+        return abort(404)
+    
+    def supports_apdeltapatch(game: str):
+        return game in worlds.Files.AutoPatchRegister.patch_types
+    downloads = []
+    for slot in sorted(room.seed.slots):
+        if slot.data and not supports_apdeltapatch(slot.game):
+            slot_download = {
+                "slot": slot.player_id,
+                "download": url_for("download_slot_file", room_id=room.id, player_id=slot.player_id)
+            }
+            downloads.append(slot_download)
+        elif slot.data:
+            slot_download = {
+                "slot": slot.player_id,
+                "download": url_for("download_patch", patch_id=slot.id, room_id=room.id)
+            }
+            downloads.append(slot_download)
+    return {
+        "tracker": room.tracker,
+        "players": get_players(room.seed),
+        "last_port": room.last_port,
+        "last_activity": room.last_activity,
+        "timeout": room.timeout,
+        "downloads": downloads,
+    }
+
+
+@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 AutoWorldRegister
+
+    version_package = {game: world.data_version for game, world in AutoWorldRegister.world_types.items()}
+    return version_package
+
+
+@api_endpoints.route('/datapackage_checksum')
+@cache.cached()
+def get_datapackage_checksums():
+    from worlds import network_data_package
+    version_package = {
+        game: game_data["checksum"] for game, game_data in network_data_package["games"].items()
+    }
+    return version_package
+
+
+from . import generate, user  # trigger registration

WebHostLib/api/datapackage.py

@@ -1,32 +0,0 @@
-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,11 +1,11 @@
 import json
+import pickle
 from uuid import UUID
 
 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
@@ -56,7 +56,7 @@ def generate_api():
                     "detail": results}, 400
         else:
             gen = Generation(
-                options=restricted_dumps({name: vars(options) for name, options in gen_options.items()}),
+                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"])

WebHostLib/api/room.py

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

@@ -1,258 +0,0 @@
-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
-
-
-class PlayerAlias(TypedDict):
-    team: int
-    player: int
-    alias: str | None
-
-
-class PlayerItemsReceived(TypedDict):
-    team: int
-    player: int
-    items: list[NetworkItem]
-
-
-class PlayerChecksDone(TypedDict):
-    team: int
-    player: int
-    locations: list[int]
-
-
-class TeamTotalChecks(TypedDict):
-    team: int
-    checks_done: int
-
-
-class PlayerHints(TypedDict):
-    team: int
-    player: int
-    hints: list[Hint]
-
-
-class PlayerTimer(TypedDict):
-    team: int
-    player: int
-    time: datetime | None
-
-
-class PlayerStatus(TypedDict):
-    team: int
-    player: int
-    status: ClientStatus
-
-
-class PlayerLocationsTotal(TypedDict):
-    team: int
-    player: int
-    total_locations: int
-
-
-class PlayerGame(TypedDict):
-    team: int
-    player: int
-    game: str
-
-
-@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()
-
-    player_aliases: list[PlayerAlias] = []
-    """Slot aliases of all players."""
-    for team, players in all_players.items():
-        for player in players:
-            player_aliases.append(
-                {"team": team, "player": player, "alias": tracker_data.get_player_alias(team, player)})
-
-    player_items_received: list[PlayerItemsReceived] = []
-    """Items received by each player."""
-    for team, players in all_players.items():
-        for player in players:
-            player_items_received.append(
-                {"team": team, "player": player, "items": tracker_data.get_player_received_items(team, player)})
-
-    player_checks_done: list[PlayerChecksDone] = []
-    """ID of all locations checked by each player."""
-    for team, players in all_players.items():
-        for player in players:
-            player_checks_done.append(
-                {"team": team, "player": player,
-                 "locations": sorted(tracker_data.get_player_checked_locations(team, player))})
-
-    total_checks_done: list[TeamTotalChecks] = [
-        {"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."""
-
-    hints: list[PlayerHints] = []
-    """Hints that all players have used or received."""
-    for team, players in tracker_data.get_all_slots().items():
-        for player in players:
-            player_hints = sorted(tracker_data.get_player_hints(team, player))
-            hints.append({"team": team, "player": player, "hints": player_hints})
-            slot_info = tracker_data.get_slot_info(player)
-            # this assumes groups are always after players
-            if slot_info.type != SlotType.group:
-                continue
-            for member in slot_info.group_members:
-                hints[member - 1]["hints"] += player_hints
-
-    activity_timers: 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():
-        for player in players:
-            activity_timers.append({"team": team, "player": player, "time": None})
-
-    for (team, player), timestamp in tracker_data._multisave.get("client_activity_timers", []):
-        for entry in activity_timers:
-            if entry["team"] == team and entry["player"] == player:
-                entry["time"] = datetime.fromtimestamp(timestamp, timezone.utc)
-                break
-
-    connection_timers: 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():
-        for player in players:
-            connection_timers.append({"team": team, "player": player, "time": None})
-
-    for (team, player), timestamp in tracker_data._multisave.get("client_connection_timers", []):
-        # find the matching entry
-        for entry in connection_timers:
-            if entry["team"] == team and entry["player"] == player:
-                entry["time"] = datetime.fromtimestamp(timestamp, timezone.utc)
-                break
-
-    player_status: list[PlayerStatus] = []
-    """The current client status for each player."""
-    for team, players in all_players.items():
-        for player in players:
-            player_status.append(
-                {"team": team, "player": player, "status": tracker_data.get_player_client_status(team, player)})
-
-    return {
-        "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,
-    }
-
-
-class PlayerGroups(TypedDict):
-    slot: int
-    name: str
-    members: list[int]
-
-
-class PlayerSlotData(TypedDict):
-    player: int
-    slot_data: dict[str, Any]
-
-
-@api_endpoints.route("/static_tracker/<suuid:tracker>")
-@cache.memoize(timeout=300)
-def static_tracker_data(tracker: UUID) -> dict[str, Any]:
-    """
-    Outputs json data to <root_path>/api/static_tracker/<id of current session tracker>.
-
-    :param tracker: UUID of current session tracker.
-
-    :return: Static 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()
-
-    groups: 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():
-        for player in players:
-            slot_info = tracker_data.get_slot_info(player)
-            if slot_info.type != SlotType.group or not slot_info.group_members:
-                continue
-            groups.append(
-                {
-                    "slot": player,
-                    "name": slot_info.name,
-                    "members": list(slot_info.group_members),
-                })
-        break
-
-    player_locations_total: list[PlayerLocationsTotal] = []
-    for team, players in all_players.items():
-        for player in players:
-            player_locations_total.append(
-                {"team": team, "player": player, "total_locations": len(tracker_data.get_player_locations(player))})
-
-    player_game: list[PlayerGame] = []
-    """The played game per player slot."""
-    for team, players in all_players.items():
-        for player in players:
-            player_game.append({"team": team, "player": player, "game": tracker_data.get_player_game(player)})
-
-    return {
-        "groups": groups,
-        "datapackage": tracker_data._multidata["datapackage"],
-        "player_locations_total": player_locations_total,
-        "player_game": player_game,
-    }
-
-
-# It should be exceedingly rare that slot data is needed, so it's separated out.
-@api_endpoints.route("/slot_data_tracker/<suuid:tracker>")
-@cache.memoize(timeout=300)
-def tracker_slot_data(tracker: UUID) -> list[PlayerSlotData]:
-    """
-    Outputs json data to <root_path>/api/slot_data_tracker/<id of current session tracker>.
-
-    :param tracker: UUID of current session tracker.
-
-    :return: Slot data for all players in the room. Typing completely arbitrary per game.
-    """
-    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()
-
-    slot_data: list[PlayerSlotData] = []
-    """Slot data for each player."""
-    for team, players in all_players.items():
-        for player in players:
-            slot_data.append({"player": player, "slot_data": tracker_data.get_slot_data(player)})
-        break
-
-    return slot_data

WebHostLib/api/user.py

@@ -1,7 +1,6 @@
 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
 
@@ -11,13 +10,13 @@ def get_rooms():
     response = []
     for room in select(room for room in Room if room.owner == session["_id"]):
         response.append({
-            "room_id": to_url(room.id),
+            "room_id": room.id,
-            "seed_id": to_url(room.seed.id),
+            "seed_id": room.seed.id,
             "creation_time": room.creation_time,
             "last_activity": room.last_activity,
             "last_port": room.last_port,
             "timeout": room.timeout,
-            "tracker": to_url(room.tracker),
+            "tracker": room.tracker,
         })
     return jsonify(response)
 
@@ -27,8 +26,8 @@ def get_seeds():
     response = []
     for seed in select(seed for seed in Seed if seed.owner == session["_id"]):
         response.append({
-            "seed_id": to_url(seed.id),
+            "seed_id": seed.id,
             "creation_time": seed.creation_time,
-            "players": get_players(seed),
+            "players": get_players(seed.slots),
         })
-    return jsonify(response)
+    return jsonify(response)

WebHostLib/autolauncher.py

@@ -3,27 +3,16 @@ from __future__ import annotations
 import json
 import logging
 import multiprocessing
+import time
 import typing
-from datetime import timedelta
-from threading import Event, Thread
-from typing import Any
 from uuid import UUID
+from datetime import timedelta, datetime
 
-from pony.orm import db_session, select, commit, PrimaryKey, desc
+from pony.orm import db_session, select, commit
 
-from Utils import restricted_loads, utcnow
+from Utils import restricted_loads
 from .locker import Locker, AlreadyRunningException
 
-_stop_event = Event()
-
-
-def stop() -> None:
-    """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):
     logging.info(f"Generation finished for seed {seed_id}")
@@ -36,39 +25,16 @@ def handle_generation_failure(result: BaseException):
         logging.exception(e)
 
 
-def _mp_gen_game(
+def launch_generator(pool: multiprocessing.pool.Pool, generation: Generation):
-    gen_options: dict,
-    meta: dict[str, Any] | None = None,
-    owner=None,
-    sid=None,
-    timeout: int|None = None,
-) -> PrimaryKey | None:
-    from setproctitle import setproctitle
-
-    setproctitle(f"Generator ({sid})")
-    try:
-        return gen_game(gen_options, meta=meta, owner=owner, sid=sid, timeout=timeout)
-    finally:
-        setproctitle(f"Generator (idle)")
-
-
-def launch_generator(pool: multiprocessing.pool.Pool, generation: Generation, timeout: int|None) -> None:
     try:
         meta = json.loads(generation.meta)
         options = restricted_loads(generation.options)
         logging.info(f"Generating {generation.id} for {len(options)} players")
-        pool.apply_async(
+        pool.apply_async(gen_game, (options,),
-            _mp_gen_game,
+                         {"meta": meta,
-            (options,),
+                          "sid": generation.id,
-            {
+                          "owner": generation.owner},
-                "meta": meta,
+                         handle_generation_success, handle_generation_failure)
-                "sid": generation.id,
-                "owner": generation.owner,
-                "timeout": timeout,
-            },
-            handle_generation_success,
-            handle_generation_failure,
-        )
     except Exception as e:
         generation.state = STATE_ERROR
         commit()
@@ -77,25 +43,7 @@ def launch_generator(pool: multiprocessing.pool.Pool, generation: Generation, ti
         generation.state = STATE_STARTED
 
 
-def init_generator(config: dict[str, Any]) -> None:
+def init_db(pony_config: dict):
-    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()
 
@@ -115,7 +63,6 @@ def cleanup():
 
 def autohost(config: dict):
     def keep_running():
-        stop_event = _stop_event
         try:
             with Locker("autohost"):
                 cleanup()
@@ -125,32 +72,31 @@ def autohost(config: dict):
                     hosters.append(hoster)
                     hoster.start()
 
-                while not stop_event.wait(0.1):
+                while 1:
+                    time.sleep(0.1)
                     with db_session:
                         rooms = select(
                             room for room in Room if
-                            room.last_activity >= utcnow() - timedelta(
+                            room.last_activity >= datetime.utcnow() - timedelta(days=3))
-                                seconds=config["MAX_ROOM_TIMEOUT"])).order_by(desc(Room.last_port))
                         for room in rooms:
                             # we have to filter twice, as the per-room timeout can't currently be PonyORM transpiled.
-                            if room.last_activity >= utcnow() - timedelta(seconds=room.timeout + 5):
+                            if room.last_activity >= datetime.utcnow() - timedelta(seconds=room.timeout):
                                 hosters[room.id.int % len(hosters)].start_room(room.id)
 
         except AlreadyRunningException:
             logging.info("Autohost reports as already running, not starting another.")
 
-    Thread(target=keep_running, name="AP_Autohost").start()
+    import threading
+    threading.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_generator,
+                with multiprocessing.Pool(config["GENERATORS"], initializer=init_db,
-                                          initargs=(config,), maxtasksperchild=10) as generator_pool:
+                                          initargs=(config["PONY"],), maxtasksperchild=10) as generator_pool:
-                    job_time = config["JOB_TIME"]
                     with db_session:
                         to_start = select(generation for generation in Generation if generation.state == STATE_STARTED)
 
@@ -161,23 +107,28 @@ def autogen(config: dict):
                                 if sid:
                                     generation.delete()
                                 else:
-                                    launch_generator(generator_pool, generation, timeout=job_time)
+                                    launch_generator(generator_pool, generation)
 
                             commit()
                         select(generation for generation in Generation if generation.state == STATE_ERROR).delete()
 
-                    while not stop_event.wait(0.1):
+                    while 1:
+                        time.sleep(0.1)
                         with db_session:
                             # for update locks the database row(s) during transaction, preventing writes from elsewhere
                             to_start = select(
                                 generation for generation in Generation
                                 if generation.state == STATE_QUEUED).for_update()
                             for generation in to_start:
-                                launch_generator(generator_pool, generation, timeout=job_time)
+                                launch_generator(generator_pool, generation)
         except AlreadyRunningException:
             logging.info("Autogen reports as already running, not starting another.")
 
-    Thread(target=keep_running, name="AP_Autogen").start()
+    import threading
+    threading.Thread(target=keep_running, name="AP_Autogen").start()
+
+
+multiworlds: typing.Dict[type(Room.id), MultiworldInstance] = {}
 
 
 class MultiworldInstance():

WebHostLib/check.py

@@ -1,7 +1,7 @@
 import os
 import zipfile
 import base64
-from collections.abc import Set
+from typing import Union, Dict, Set, Tuple
 
 from flask import request, flash, redirect, url_for, render_template
 from markupsafe import Markup
@@ -43,7 +43,7 @@ def mysterycheck():
     return redirect(url_for("check"), 301)
 
 
-def get_yaml_data(files) -> dict[str, str] | str | Markup:
+def get_yaml_data(files) -> Union[Dict[str, str], str, Markup]:
     options = {}
     for uploaded_file in files:
         if banned_file(uploaded_file.filename):
@@ -84,12 +84,12 @@ def get_yaml_data(files) -> dict[str, str] | str | Markup:
     return options
 
 
-def roll_options(options: dict[str, dict | str],
+def roll_options(options: Dict[str, Union[dict, str]],
                  plando_options: Set[str] = frozenset({"bosses", "items", "connections", "texts"})) -> \
-        tuple[dict[str, str | bool], dict[str, dict]]:
+        Tuple[Dict[str, Union[str, bool]], Dict[str, dict]]:
     plando_options = PlandoOptions.from_set(set(plando_options))
-    results: dict[str, str | bool] = {}
+    results = {}
-    rolled_results: dict[str, dict] = {}
+    rolled_results = {}
     for filename, text in options.items():
         try:
             if type(text) is dict:
@@ -105,9 +105,8 @@ def roll_options(options: dict[str, dict | str],
                                                              plando_options=plando_options)
                 else:
                     for i, yaml_data in enumerate(yaml_datas):
-                        if yaml_data is not None:
+                        rolled_results[f"{filename}/{i + 1}"] = roll_settings(yaml_data,
-                            rolled_results[f"{filename}/{i + 1}"] = roll_settings(yaml_data,
+                                                                              plando_options=plando_options)
-                                                                                  plando_options=plando_options)
             except Exception as e:
                 if e.__cause__:
                     results[filename] = f"Failed to generate options in {filename}: {e} - {e.__cause__}"

WebHostLib/cli/__init__.py

@@ -1,8 +0,0 @@
-from flask import Flask
-
-
-class CLI:
-    def __init__(self, app: Flask) -> None:
-        from .stats import stats_cli
-
-        app.cli.add_command(stats_cli)

WebHostLib/cli/stats.py

@@ -1,36 +0,0 @@
-import click
-from flask.cli import AppGroup
-from pony.orm import raw_sql
-
-from Utils import format_SI_prefix
-
-stats_cli = AppGroup("stats")
-
-
-@stats_cli.command("show")
-def show() -> None:
-    from pony.orm import db_session, select
-
-    from WebHostLib.models import GameDataPackage
-
-    total_games_package_count: int = 0
-    total_games_package_size: int
-    top_10_package_sizes: list[tuple[int, str]] = []
-
-    with db_session:
-        data_length = raw_sql("LENGTH(data)")
-        data_length_desc = raw_sql("LENGTH(data) DESC")
-        data_length_sum = raw_sql("SUM(LENGTH(data))")
-        total_games_package_count = GameDataPackage.select().count()
-        total_games_package_size = select(data_length_sum for _ in GameDataPackage).first()  # type: ignore
-        top_10_package_sizes = list(
-            select((data_length, dp.checksum) for dp in GameDataPackage)  # type: ignore
-            .order_by(lambda _, _2: data_length_desc)
-            .limit(10)
-        )
-
-    click.echo(f"Total number of games packages: {total_games_package_count}")
-    click.echo(f"Total size of games packages:   {format_SI_prefix(total_games_package_size, power=1024)}B")
-    click.echo(f"Top {len(top_10_package_sizes)} biggest games packages:")
-    for size, checksum in top_10_package_sizes:
-        click.echo(f"    {checksum}: {size:>8d}")

WebHostLib/customserver.py

@@ -19,10 +19,7 @@ from pony.orm import commit, db_session, select
 
 import Utils
 
-from MultiServer import (
+from MultiServer import Context, server, auto_shutdown, ServerCommandProcessor, ClientMessageProcessor, load_server_cert
-    Context, server, auto_shutdown, ServerCommandProcessor, ClientMessageProcessor, load_server_cert,
-    server_per_message_deflate_factory,
-)
 from Utils import restricted_loads, cache_argsless
 from .locker import Locker
 from .models import Command, GameDataPackage, Room, db
@@ -75,38 +72,23 @@ class WebHostContext(Context):
         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)
 
-    async def listen_to_db_commands(self):
+    def listen_to_db_commands(self):
         cmdprocessor = DBCommandProcessor(self)
 
         while not self.exit_event.is_set():
-            await self.main_loop.run_in_executor(None, self._process_db_commands, cmdprocessor)
+            with db_session:
-            try:
+                commands = select(command for command in Command if command.room.id == self.room_id)
-                await asyncio.wait_for(self.exit_event.wait(), 5)
+                if commands:
-            except asyncio.TimeoutError:
+                    for command in commands:
-                pass
+                        self.main_loop.call_soon_threadsafe(cmdprocessor, command.commandtext)
-
+                        command.delete()
-    def _process_db_commands(self, cmdprocessor):
+                    commit()
-        with db_session:
+            time.sleep(5)
-            commands = select(command for command in Command if command.room.id == self.room_id)
-            if commands:
-                for command in commands:
-                    self.main_loop.call_soon_threadsafe(cmdprocessor, command.commandtext)
-                    command.delete()
-                commit()
 
     @db_session
     def load(self, room_id: int):
@@ -119,60 +101,37 @@ class WebHostContext(Context):
 
         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"]:
+                if self.gamespackage.get(game, {}).get("checksum") == game_data["checksum"]:
-                    # non-custom. remove from multidata and use static data
+                    # non-custom. remove from multidata
                     # games package could be dropped from static data once all rooms embed data package
                     del multidata["datapackage"][game]
                 else:
                     row = GameDataPackage.get(checksum=game_data["checksum"])
                     if row:  # None if rolled on >= 0.3.9 but uploaded to <= 0.3.8. multidata should be complete
-                        game_data_packages[game] = restricted_loads(row.data)
+                        game_data_packages[game] = Utils.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):
         self.saving = enabled
         if self.saving:
-            with db_session:
+            savegame_data = Room.get(id=self.room_id).multisave
-                savegame_data = Room.get(id=self.room_id).multisave
+            if savegame_data:
-                if savegame_data:
+                self.set_save(restricted_loads(Room.get(id=self.room_id).multisave))
-                    self.set_save(restricted_loads(savegame_data))
+            self._start_async_saving()
-            self._start_async_saving(atexit_save=False)
+        threading.Thread(target=self.listen_to_db_commands, daemon=True).start()
-        asyncio.create_task(self.listen_to_db_commands())
 
     @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
-            room.last_activity = Utils.utcnow()
+            room.last_activity = datetime.datetime.utcnow()
         return True
 
     def get_save(self) -> dict:
@@ -189,28 +148,17 @@ def get_random_port():
 def get_static_server_data() -> dict:
     import worlds
     data = {
-        "non_hintable_names": {
+        "non_hintable_names": {},
-            world_name: world.hint_blacklist
+        "gamespackage": worlds.network_data_package["games"],
-            for world_name, world in worlds.AutoWorldRegister.world_types.items()
+        "item_name_groups": {world_name: world.item_name_groups for world_name, world in
-        },
+                             worlds.AutoWorldRegister.world_types.items()},
-        "gamespackage": {
+        "location_name_groups": {world_name: world.location_name_groups for world_name, world in
-            world_name: {
+                                 worlds.AutoWorldRegister.world_types.items()},
-                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
 
 
@@ -234,23 +182,9 @@ def set_up_logging(room_id) -> logging.Logger:
     return logger
 
 
-def tear_down_logging(room_id):
-    """Close logging handling for a room."""
-    logger_name = f"RoomLogger {room_id}"
-    if logger_name in logging.Logger.manager.loggerDict:
-        logger = logging.getLogger(logger_name)
-        for handler in logger.handlers[:]:
-            logger.removeHandler(handler)
-            handler.close()
-        del logging.Logger.manager.loggerDict[logger_name]
-
-
 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
@@ -271,139 +205,75 @@ def run_server_process(name: str, ponyconfig: dict, static_server_data: dict,
         raise Exception("Worlds system should not be loaded in the custom server.")
 
     import gc
-
+    ssl_context = load_server_cert(cert_file, cert_key_file) if cert_file else None
-    if not cert_file:
+    del cert_file, cert_key_file, ponyconfig
-        def get_ssl_context():
-            return None
-    else:
-        load_date = None
-        ssl_context = load_server_cert(cert_file, cert_key_file)
-
-        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()
             try:
-                logger = set_up_logging(room_id)
+                ctx.server = websockets.serve(functools.partial(server, ctx=ctx), ctx.host, ctx.port, ssl=ssl_context)
-                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(),
-                        extensions=[server_per_message_deflate_factory],
-                    )
-                    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
+                await ctx.server
-                port = 0
+            except OSError:  # likely port in use
-                for wssocket in ctx.server.ws_server.sockets:
+                ctx.server = websockets.serve(functools.partial(server, ctx=ctx), ctx.host, 0, ssl=ssl_context)
-                    socketname = wssocket.getsockname()
+
-                    if wssocket.family == socket.AF_INET6:
+                await ctx.server
-                        # Prefer IPv4, as most users seem to not have working ipv6 support
+            port = 0
-                        if not port:
+            for wssocket in ctx.server.ws_server.sockets:
-                            port = socketname[1]
+                socketname = wssocket.getsockname()
-                    elif wssocket.family == socket.AF_INET:
+                if wssocket.family == socket.AF_INET6:
+                    # Prefer IPv4, as most users seem to not have working ipv6 support
+                    if not port:
                         port = socketname[1]
-                if port:
+                elif wssocket.family == socket.AF_INET:
-                    ctx.logger.info(f'Hosting game at {host}:{port}')
+                    port = socketname[1]
-                    with db_session:
+            if port:
-                        room = Room.get(id=ctx.room_id)
+                ctx.logger.info(f'Hosting game at {host}:{port}')
-                        room.last_port = port
-                    del room
-                else:
-                    ctx.logger.exception("Could not determine port. Likely hosting failure.")
                 with db_session:
-                    ctx.auto_shutdown = Room.get(id=room_id).timeout
+                    room = Room.get(id=ctx.room_id)
-                if ctx.saving:
+                    room.last_port = port
-                    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(True)
-                    setattr(asyncio.current_task(), "save", None)
-            except Exception as e:
-                with db_session:
-                    room = Room.get(id=room_id)
-                    room.last_port = -1
-                del room
-                logger.exception(e)
-                raise
             else:
-                if ctx.saving:
+                ctx.logger.exception("Could not determine port. Likely hosting failure.")
-                    ctx._save(True)
+            with db_session:
-                    setattr(asyncio.current_task(), "save", None)
+                ctx.auto_shutdown = Room.get(id=room_id).timeout
-            finally:
+            ctx.shutdown_task = asyncio.create_task(auto_shutdown(ctx, []))
-                try:
+            await ctx.shutdown_task
-                    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
 
-                    if ctx.server and hasattr(ctx.server, "ws_server"):
+            # ensure auto launch is on the same page in regard to room activity.
-                        ctx.server.ws_server.close()
+            with db_session:
-                        await ctx.server.ws_server.wait_closed()
+                room: Room = Room.get(id=ctx.room_id)
+                room.last_activity = datetime.datetime.utcnow() - datetime.timedelta(seconds=room.timeout + 60)
 
-                    with db_session:
+        except (KeyboardInterrupt, SystemExit):
-                        # ensure the Room does not spin up again on its own, minute of safety buffer
+            with db_session:
-                        room = Room.get(id=room_id)
+                room = Room.get(id=room_id)
-                        room.last_activity = Utils.utcnow() - datetime.timedelta(minutes=1, seconds=room.timeout)
+                # ensure the Room does not spin up again on its own, minute of safety buffer
-                    del room
+                room.last_activity = datetime.datetime.utcnow() - datetime.timedelta(minutes=1, seconds=room.timeout)
-                    tear_down_logging(room_id)
+        except Exception:
-                    logging.info(f"Shutting down room {room_id} on {name}.")
+            with db_session:
-                finally:
+                room = Room.get(id=room_id)
-                    await asyncio.sleep(5)
+                room.last_port = -1
-                    rooms_shutting_down.put(room_id)
+                # ensure the Room does not spin up again on its own, minute of safety buffer
+                room.last_activity = datetime.datetime.utcnow() - datetime.timedelta(minutes=1, seconds=room.timeout)
+            raise
+        finally:
+            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()
+                asyncio.run_coroutine_threadsafe(start_room(next_room), loop)
-                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()
-        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

@@ -61,7 +61,12 @@ def download_slot_file(room_id, player_id: int):
     else:
         import io
 
-        if slot_data.game == "Factorio":
+        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['HOST_ADDRESS'], port=room.last_port)
+            return send_file(io.BytesIO(data), as_attachment=True, download_name=fname)
+        elif slot_data.game == "Factorio":
             with zipfile.ZipFile(io.BytesIO(slot_data.data)) as zf:
                 for name in zf.namelist():
                     if name.endswith("info.json"):

WebHostLib/generate.py

@@ -1,45 +1,47 @@
 import concurrent.futures
 import json
 import os
+import pickle
 import random
 import tempfile
 import zipfile
 from collections import Counter
-from pickle import PicklingError
+from typing import Any, Dict, List, Optional, Union
-from typing import Any
 
 from flask import flash, redirect, render_template, request, session, url_for
 from pony.orm import commit, db_session
 
 from BaseClasses import get_seed, seeddigits
-from Generate import PlandoOptions, handle_name, mystery_argparse
+from Generate import PlandoOptions, handle_name
 from Main import main as ERmain
-from Utils import __version__, restricted_dumps, DaemonThreadPoolExecutor
+from Utils import __version__
 from WebHostLib import app
-from settings import ServerOptions, GeneratorOptions
+from worlds.alttp.EntranceRandomizer import parse_arguments
 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, race: bool = False) -> dict[str, list[str] | dict[str, Any]]:
+def get_meta(options_source: dict, race: bool = False) -> Dict[str, Union[List[str], Dict[str, Any]]]:
-    plando_options: set[str] = set()
+    plando_options = {
-    for substr in ("bosses", "items", "connections", "texts"):
+        options_source.get("plando_bosses", ""),
-        if options_source.get(f"plando_{substr}", substr in GeneratorOptions.plando_options):
+        options_source.get("plando_items", ""),
-            plando_options.add(substr)
+        options_source.get("plando_connections", ""),
+        options_source.get("plando_texts", "")
+    }
+    plando_options -= {""}
 
     server_options = {
-        "hint_cost": int(options_source.get("hint_cost", ServerOptions.hint_cost)),
+        "hint_cost": int(options_source.get("hint_cost", 10)),
-        "release_mode": str(options_source.get("release_mode", ServerOptions.release_mode)),
+        "release_mode": options_source.get("release_mode", "goal"),
-        "remaining_mode": str(options_source.get("remaining_mode", ServerOptions.remaining_mode)),
+        "remaining_mode": options_source.get("remaining_mode", "disabled"),
-        "collect_mode": str(options_source.get("collect_mode", ServerOptions.collect_mode)),
+        "collect_mode": options_source.get("collect_mode", "disabled"),
-        "countdown_mode": str(options_source.get("countdown_mode", ServerOptions.countdown_mode)),
+        "item_cheat": bool(int(options_source.get("item_cheat", 1))),
-        "item_cheat": bool(int(options_source.get("item_cheat", not ServerOptions.disable_item_cheat))),
+        "server_password": options_source.get("server_password", None),
-        "server_password": str(options_source.get("server_password", None)),
     }
     generator_options = {
-        "spoiler": int(options_source.get("spoiler", GeneratorOptions.spoiler)),
+        "spoiler": int(options_source.get("spoiler", 0)),
-        "race": race,
+        "race": race
     }
 
     if race:
@@ -68,59 +70,40 @@ def generate(race=False):
                 flash(options)
             else:
                 meta = get_meta(request.form, race)
-                return start_generation(options, meta)
+                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.")
+                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))
 
     return render_template("generate.html", race=race, version=__version__)
 
 
-def format_exception(e: BaseException) -> str:
+def gen_game(gen_options: dict, meta: Optional[Dict[str, Any]] = None, owner=None, sid=None):
-    return f"{e.__class__.__name__}: {e}"
+    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)
-            meta["error"] = format_exception(e)
-            details = json.dumps(meta, indent=4).strip()
-            return render_template("seedError.html", seed_error=meta["error"], details=details)
-
-        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, timeout=app.config["JOB_TIME"])
-        except BaseException as e:
-            from .autolauncher import handle_generation_failure
-            handle_generation_failure(e)
-            meta["error"] = format_exception(e)
-            details = json.dumps(meta, indent=4).strip()
-            return render_template("seedError.html", seed_error=meta["error"], details=details)
-
-        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, timeout: int|None = None):
-    if meta is None:
-        meta = {}
 
     meta.setdefault("server_options", {}).setdefault("hint_cost", 10)
     race = meta.setdefault("generator_options", {}).setdefault("race", False)
@@ -137,47 +120,41 @@ def gen_game(gen_options: dict, meta: dict[str, Any] | None = None, owner=None,
 
         seedname = "W" + (f"{random.randint(0, pow(10, seeddigits) - 1)}".zfill(seeddigits))
 
-        args = mystery_argparse([])  # Just to set up the Namespace with defaults
+        erargs = parse_arguments(['--multi', str(playercount)])
-        args.multi = playercount
+        erargs.seed = seed
-        args.seed = seed
+        erargs.name = {x: "" for x in range(1, playercount + 1)}  # only so it can be overwritten in mystery
-        args.name = {x: "" for x in range(1, playercount + 1)}  # only so it can be overwritten in mystery
+        erargs.spoiler = meta["generator_options"].get("spoiler", 0)
-        args.spoiler = meta["generator_options"].get("spoiler", 0)
+        erargs.race = race
-        args.race = race
+        erargs.outputname = seedname
-        args.outputname = seedname
+        erargs.outputpath = target.name
-        args.outputpath = target.name
+        erargs.teams = 1
-        args.teams = 1
+        erargs.plando_options = PlandoOptions.from_set(meta.setdefault("plando_options",
-        args.plando_options = PlandoOptions.from_set(meta.setdefault("plando_options",
+                                                                       {"bosses", "items", "connections", "texts"}))
-                                                                     {"bosses", "items", "connections", "texts"}))
+        erargs.skip_prog_balancing = False
-        args.skip_prog_balancing = False
+        erargs.skip_output = 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(args, k):
+                    if hasattr(erargs, k):
-                        getattr(args, k)[player] = v
+                        getattr(erargs, k)[player] = v
                     else:
-                        setattr(args, k, {player: v})
+                        setattr(erargs, k, {player: v})
 
-            if not args.name[player]:
+            if not erargs.name[player]:
-                args.name[player] = os.path.splitext(os.path.split(playerfile)[-1])[0]
+                erargs.name[player] = os.path.splitext(os.path.split(playerfile)[-1])[0]
-            args.name[player] = handle_name(args.name[player], player, name_counter)
+            erargs.name[player] = handle_name(erargs.name[player], player, name_counter)
-        if len(set(args.name.values())) != len(args.name):
+        if len(set(erargs.name.values())) != len(erargs.name):
-            raise Exception(f"Names have to be unique. Names: {Counter(args.name.values())}")
+            raise Exception(f"Names have to be unique. Names: {Counter(erargs.name.values())}")
-        ERmain(args, seed, baked_server_options=meta["server_options"])
+        ERmain(erargs, seed, baked_server_options=meta["server_options"])
 
         return upload_to_db(target.name, sid, owner, race)
-
+    thread_pool = concurrent.futures.ThreadPoolExecutor(max_workers=1)
-    thread_pool = DaemonThreadPoolExecutor(max_workers=1)
     thread = thread_pool.submit(task)
 
     try:
-        return thread.result(timeout)
+        return thread.result(app.config["JOB_TIME"])
     except concurrent.futures.TimeoutError as e:
         if sid:
             with db_session:
@@ -185,14 +162,11 @@ def gen_game(gen_options: dict, meta: dict[str, Any] | None = None, owner=None,
                 if gen is not None:
                     gen.state = STATE_ERROR
                     meta = json.loads(gen.meta)
-                    meta["error"] = ("Allowed time for Generation exceeded, " +
+                    meta["error"] = (
-                                     "please consider generating locally instead. " +
+                            "Allowed time for Generation exceeded, please consider generating locally instead. " +
-                                     format_exception(e))
+                            e.__class__.__name__ + ": " + str(e))
                     gen.meta = json.dumps(meta)
                     commit()
-    except (KeyboardInterrupt, SystemExit):
-        # don't update db, retry next time
-        raise
     except BaseException as e:
         if sid:
             with db_session:
@@ -200,15 +174,10 @@ def gen_game(gen_options: dict, meta: dict[str, Any] | None = None, owner=None,
                 if gen is not None:
                     gen.state = STATE_ERROR
                     meta = json.loads(gen.meta)
-                    meta["error"] = format_exception(e)
+                    meta["error"] = (e.__class__.__name__ + ": " + str(e))
                     gen.meta = json.dumps(meta)
                     commit()
         raise
-    finally:
-        # free resources claimed by thread pool, if possible
-        # NOTE: Timeout depends on the process being killed at some point
-        #       since we can't actually cancel a running gen at the moment.
-        thread_pool.shutdown(wait=False, cancel_futures=True)
 
 
 @app.route('/wait/<suuid:seed>')
@@ -222,9 +191,7 @@ def wait_seed(seed: UUID):
     if not generation:
         return "Generation not found."
     elif generation.state == STATE_ERROR:
-        meta = json.loads(generation.meta)
+        return render_template("seedError.html", seed_error=generation.meta)
-        details = json.dumps(meta, indent=4).strip()
-        return render_template("seedError.html", seed_error=meta["error"], details=details)
     return render_template("waitSeed.html", seed_id=seed_id)
 
 

WebHostLib/landing.py

@@ -1,9 +1,8 @@
-from datetime import timedelta
+from datetime import timedelta, datetime
 
 from flask import render_template
 from pony.orm import count
 
-from Utils import utcnow
 from WebHostLib import app, cache
 from .models import Room, Seed
 
@@ -11,6 +10,6 @@ from .models import Room, Seed
 @app.route('/', methods=['GET', 'POST'])
 @cache.cached(timeout=300)  # cache has to appear under app route for caching to work
 def landing():
-    rooms = count(room for room in Room if room.creation_time >= utcnow() - timedelta(days=7))
+    rooms = count(room for room in Room if room.creation_time >= datetime.utcnow() - timedelta(days=7))
-    seeds = count(seed for seed in Seed if seed.creation_time >= utcnow() - timedelta(days=7))
+    seeds = count(seed for seed in Seed if seed.creation_time >= datetime.utcnow() - timedelta(days=7))
     return render_template("landing.html", rooms=rooms, seeds=seeds)

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", "alttp", "remote")
+    input_dir = user_path("data", "sprites", "alttpr")
     output_dir = local_path("WebHostLib", "static", "generated")  # TODO: move to user_path
 
     os.makedirs(os.path.join(output_dir, "sprites"), exist_ok=True)

WebHostLib/markdown.py

@@ -1,90 +0,0 @@
-import re
-from collections import Counter
-
-import mistune
-from werkzeug.utils import secure_filename
-
-
-__all__ = [
-    "ImgUrlRewriteInlineParser",
-    'render_markdown',
-]
-
-
-class ImgUrlRewriteInlineParser(mistune.InlineParser):
-    relative_url_base: str
-
-    def __init__(self, relative_url_base: str, hard_wrap: bool = False) -> None:
-        super().__init__(hard_wrap)
-        self.relative_url_base = relative_url_base
-
-    @staticmethod
-    def _find_game_name_by_folder_name(name: str) -> str | None:
-        from worlds.AutoWorld import AutoWorldRegister
-
-        for world_name, world_type in AutoWorldRegister.world_types.items():
-            if world_type.__module__ == f"worlds.{name}":
-                return world_name
-        return None
-
-    def parse_link(self, m: re.Match[str], state: mistune.InlineState) -> int | None:
-        res = super().parse_link(m, state)
-        if res is not None and state.tokens and state.tokens[-1]["type"] == "image":
-            image_token = state.tokens[-1]
-            url: str = image_token["attrs"]["url"]
-            if not url.startswith("/") and not "://" in url:
-                # replace relative URL to another world's doc folder with the webhost folder layout
-                if url.startswith("../../") and "/docs/" in self.relative_url_base:
-                    parts = url.split("/", 4)
-                    if parts[2] != ".." and parts[3] == "docs":
-                        game_name = self._find_game_name_by_folder_name(parts[2])
-                        if game_name is not None:
-                            url = "/".join(parts[1:2] + [secure_filename(game_name)] + parts[4:])
-                # change relative URL to point to deployment folder
-                url = f"{self.relative_url_base}/{url}"
-                image_token['attrs']['url'] = url
-        return res
-
-
-def render_markdown(path: str, img_url_base: str | None = None) -> str:
-    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
-
-        # 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)
-    if img_url_base:
-        markdown.inline = ImgUrlRewriteInlineParser(img_url_base)
-
-    with open(path, encoding="utf-8-sig") as f:
-        document = f.read()
-    html = markdown(document)
-    assert isinstance(html, str), "Unexpected mistune renderer in render_markdown"
-    return html

WebHostLib/misc.py

@@ -1,48 +1,27 @@
 import datetime
 import os
-import warnings
+from typing import List, Dict, Union
-from enum import StrEnum
-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 .markdown import render_markdown
 from .models import Seed, Room, Command, UUID, uuid4
-from Utils import title_sorted, utcnow
-
-class WebWorldTheme(StrEnum):
-    DIRT = "dirt"
-    GRASS = "grass"
-    GRASS_FLOWERS = "grassFlowers"
-    ICE = "ice"
-    JUNGLE = "jungle"
-    OCEAN = "ocean"
-    PARTY_TIME = "partyTime"
-    STONE = "stone"
-
-def get_world_theme(game_name: str) -> str:
-    if game_name not in AutoWorldRegister.world_types:
-        return "grass"
-    chosen_theme = AutoWorldRegister.world_types[game_name].web.theme
-    available_themes = [theme.value for theme in WebWorldTheme]
-    if chosen_theme not in available_themes:
-        warnings.warn(f"Theme '{chosen_theme}' for {game_name} not valid, switching to default 'grass' theme.")
-        return "grass"
-    return chosen_theme
 
 
-def get_visible_worlds() -> dict[str, type(World)]:
+def get_world_theme(game_name: str):
-    worlds = {}
+    if game_name in AutoWorldRegister.world_types:
-    for game, world in AutoWorldRegister.world_types.items():
+        return AutoWorldRegister.world_types[game_name].web.theme
-        if not world.hidden:
+    return 'grass'
-            worlds[game] = world
+
-    return worlds
+
+@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.errorhandler(404)
@@ -58,107 +37,46 @@ def start_playing():
     return render_template(f"startPlaying.html")
 
 
+# Game Info Pages
 @app.route('/games/<string:game>/info/<string:lang>')
 @cache.cached()
 def game_info(game, lang):
-    """Game Info Pages"""
+    return render_template('gameInfo.html', game=game, lang=lang, theme=get_world_theme(game))
-    try:
-        theme = get_world_theme(game)
-        secure_game_name = secure_filename(game)
-        lang = secure_filename(lang)
-        file_dir = os.path.join(app.static_folder, "generated", "docs", secure_game_name)
-        file_dir_url = url_for("static", filename=f"generated/docs/{secure_game_name}")
-        document = render_markdown(os.path.join(file_dir, f"{lang}_{secure_game_name}.md"), file_dir_url)
-        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():
-    """List of supported games"""
+    worlds = {}
-    return render_template("supportedGames.html", worlds=get_visible_worlds())
+    for game, world in AutoWorldRegister.world_types.items():
-
+        if not world.hidden:
-
+            worlds[game] = world
-@app.route('/tutorial/<string:game>/<string:file>')
+    return render_template("supportedGames.html", worlds=worlds)
-@cache.cached()
-def tutorial(game: str, file: str):
-    try:
-        theme = get_world_theme(game)
-        secure_game_name = secure_filename(game)
-        file = secure_filename(file)
-        file_dir = os.path.join(app.static_folder, "generated", "docs", secure_game_name)
-        file_dir_url = url_for("static", filename=f"generated/docs/{secure_game_name}")
-        document = render_markdown(os.path.join(file_dir, f"{file}.md"), file_dir_url)
-        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_redirect(game: str, file: str, lang: str):
+@cache.cached()
-    """
+def tutorial(game, file, lang):
-    Permanent redirect old tutorial URLs to new ones to keep search engines happy.
+    return render_template("tutorial.html", game=game, file=file, lang=lang, theme=get_world_theme(game))
-    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():
-    tutorials = {}
+    return render_template("tutorialLanding.html")
-    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
-            }
-
-    worlds = dict(
-        title_sorted(
-            worlds.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>/')
 @cache.cached()
-def faq(lang: str):
+def faq(lang):
-    document = render_markdown(os.path.join(app.static_folder, "assets", "faq", secure_filename(lang)+".md"))
+    return render_template("faq.html", lang=lang)
-    return render_template(
-        "markdown_document.html",
-        title="Frequently Asked Questions",
-        html_from_markdown=document,
-    )
 
 
 @app.route('/glossary/<string:lang>/')
 @cache.cached()
-def glossary(lang: str):
+def terms(lang):
-    document = render_markdown(os.path.join(app.static_folder, "assets", "glossary", secure_filename(lang)+".md"))
+    return render_template("glossary.html", lang=lang)
-    return render_template(
-        "markdown_document.html",
-        title="Glossary",
-        html_from_markdown=document,
-    )
 
 
 @app.route('/seed/<suuid:seed>')
@@ -179,95 +97,49 @@ def new_room(seed: UUID):
     return redirect(url_for("host_room", room=room.id))
 
 
-def _read_log(log: IO[Any], offset: int = 0) -> Iterator[bytes]:
+def _read_log(path: str):
-    marker = log.read(3)  # skip optional BOM
+    if os.path.exists(path):
-    if marker != b'\xEF\xBB\xBF':
+        with open(path, encoding="utf-8-sig") as log:
-        log.seek(0, os.SEEK_SET)
+            yield from log
-    log.seek(offset, os.SEEK_CUR)
+    else:
-    yield from log
+        yield f"Logfile {path} does not exist. " \
-    log.close()  # free file handle as soon as possible
+              f"Likely a crash during spinup of multiworld instance or it is still spinning up."
 
 
 @app.route('/log/<suuid:room>')
-def display_log(room: UUID) -> Union[str, Response, Tuple[str, int]]:
+def display_log(room: UUID):
     room = Room.get(id=room)
     if room is None:
         return abort(404)
     if room.owner == session["_id"]:
         file_path = os.path.join("logs", str(room.id) + ".txt")
-        try:
+        if os.path.exists(file_path):
-            log = open(file_path, "rb")
+            return Response(_read_log(file_path), mimetype="text/plain;charset=UTF-8")
-            range_header = request.headers.get("Range")
+        return "Log File does not exist."
-            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.post("/room/<suuid:room>")
+@app.route('/room/<suuid:room>', methods=['GET', 'POST'])
-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()
+        return redirect(url_for("host_room", room=room.id))
 
-    now = utcnow()
+    now = datetime.datetime.utcnow()
     # indicate that the page should reload to get the assigned port
-    should_refresh = (
+    should_refresh = not room.last_port and now - room.creation_time < datetime.timedelta(seconds=3)
-        (not room.last_port and now - room.creation_time < datetime.timedelta(seconds=3))
+    with db_session:
-        or room.last_activity < now - datetime.timedelta(seconds=room.timeout)
-    )
-    if now - room.last_activity > datetime.timedelta(minutes=1):
-        # we only set last_activity if needed, otherwise parallel access on /room will cause an internal server error
-        # due to "pony.orm.core.OptimisticCheckError: Object Room was updated outside of current transaction"
         room.last_activity = now  # will trigger a spinup, if it's not already running
 
-    browser_tokens = "Mozilla", "Chrome", "Safari"
+    return render_template("hostRoom.html", room=room, should_refresh=should_refresh)
-    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) -> Tuple[str, int]:
-        if max_size == 0:
-            return "…", 0
-        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), raw_size
-        except FileNotFoundError:
-            return "", 0
-
-    return render_template("hostRoom.html", room=room, should_refresh=should_refresh, get_log=get_log)
 
 
 @app.route('/favicon.ico')

WebHostLib/models.py

@@ -2,8 +2,6 @@ from datetime import datetime
 from uuid import UUID, uuid4
 from pony.orm import Database, PrimaryKey, Required, Set, Optional, buffer, LongStr
 
-from Utils import utcnow
-
 db = Database()
 
 STATE_QUEUED = 0
@@ -22,8 +20,8 @@ class Slot(db.Entity):
 
 class Room(db.Entity):
     id = PrimaryKey(UUID, default=uuid4)
-    last_activity: datetime = Required(datetime, default=lambda: utcnow(), index=True)
+    last_activity = Required(datetime, default=lambda: datetime.utcnow(), index=True)
-    creation_time: datetime = Required(datetime, default=lambda: utcnow(), index=True)  # index used by landing page
+    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)
@@ -40,7 +38,7 @@ class Seed(db.Entity):
     rooms = Set(Room)
     multidata = Required(bytes, lazy=True)
     owner = Required(UUID, index=True)
-    creation_time: datetime = Required(datetime, default=lambda: utcnow(), index=True)  # index used by landing page
+    creation_time = Required(datetime, default=lambda: datetime.utcnow(), index=True)  # index used by landing page
     slots = Set(Slot)
     spoiler = Optional(LongStr, lazy=True)
     meta = Required(LongStr, default=lambda: "{\"race\": false}")  # additional meta information/tags

WebHostLib/options.py

@@ -1,56 +1,87 @@
 import collections.abc
-import json
 import os
-from textwrap import dedent
-from typing import Dict, Union
-from docutils.core import publish_parts
-
 import yaml
-from flask import redirect, render_template, request, Response, abort
+import requests
+import json
+import flask
+from urllib.parse import urlparse
 
 import Options
-from Utils import local_path
+from Options import Visibility
+from flask import redirect, render_template, request, Response
 from worlds.AutoWorld import AutoWorldRegister
+from Utils import local_path
+from textwrap import dedent
 from . import app, cache
-from .generate import get_meta
-from .misc import get_world_theme
 
 
-def create() -> None:
+def create():
     target_folder = local_path("WebHostLib", "static", "generated")
     yaml_folder = os.path.join(target_folder, "configs")
 
     Options.generate_yaml_templates(yaml_folder)
 
 
-def render_options_page(template: str, world_name: str, is_complex: bool = False) -> Union[Response, str]:
+def get_world_theme(game_name: 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):
     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}
+    option_groups = {option: option_group.name
-    for group in world.web.option_groups:
+                     for option_group in world.web.option_groups
-        start_collapsed[group.name] = group.start_collapsed
+                     for option in option_group.options}
+    ordered_groups = ["Game Options", *[group.name for group in world.web.option_groups]]
+    grouped_options = {group: {} for group in ordered_groups}
+    for option_name, option in world.options_dataclass.type_hints.items():
+        # Exclude settings from options pages if their visibility is disabled
+        if not is_complex and option.visibility < Visibility.simple_ui:
+            continue
+
+        if is_complex and option.visibility < Visibility.complex_ui:
+            continue
+
+        grouped_options[option_groups.get(option, "Game Options")][option_name] = option
 
     return render_template(
         template,
         world_name=world_name,
         world=world,
-        option_groups=Options.get_option_groups(world, visibility_level=visibility_flag),
+        option_groups=grouped_options,
-        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]:
+def generate_game(player_name: str, formatted_options: dict):
-    from .generate import start_generation
+    payload = {
-    return start_generation(options, get_meta({}))
+        "race": 0,
+        "hint_cost": 10,
+        "forfeit_mode": "auto",
+        "remaining_mode": "disabled",
+        "collect_mode": "goal",
+        "weights": {
+            player_name: formatted_options,
+        },
+    }
+
+    url = urlparse(request.base_url)
+    port_string = f":{url.port}" if url.port else ""
+    r = requests.post(f"{url.scheme}://{url.hostname}{port_string}/api/generate", json=payload)
+    if 200 <= r.status_code <= 299:
+        response_data = r.json()
+        return redirect(response_data["url"])
+    else:
+        return r.text
 
 
-def send_yaml(player_name: str, formatted_options: dict) -> Response:
+def send_yaml(player_name: str, formatted_options: dict):
     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"
@@ -58,26 +89,10 @@ def send_yaml(player_name: str, formatted_options: dict) -> Response:
 
 
 @app.template_filter("dedent")
-def filter_dedent(text: str) -> str:
+def filter_dedent(text: 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='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)
@@ -87,34 +102,10 @@ def test_ordered(obj):
 @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 world.web.options_presets:
-            if isinstance(option, Options.NamedRange) and isinstance(preset_option, str):
+        presets = presets | world.web.options_presets
-                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:
-                # Use the name of the option
-                presets[preset_name][preset_option_name] = option.current_key
 
     class SetEncoder(json.JSONEncoder):
         def default(self, obj):
@@ -124,7 +115,7 @@ def option_presets(game: str) -> Response:
             return json.JSONEncoder.default(self, obj)
 
     json_data = json.dumps(presets, cls=SetEncoder)
-    response = Response(json_data)
+    response = flask.Response(json_data)
     response.headers["Content-Type"] = "application/json"
     return response
 
@@ -137,10 +128,7 @@ def weighted_options_old():
 @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)
-        return render_options_page("weightedOptions/weightedOptions.html", game, is_complex=True)
-    except KeyError:
-        return abort(404)
 
 
 @app.route("/games/<string:game>/generate-weighted-yaml", methods=["POST"])
@@ -150,9 +138,7 @@ def generate_weighted_yaml(game: str):
         options = {}
 
         for key, val in request.form.items():
-            if val == "_ensure-empty-list":
+            if "||" not in key:
-                options[key] = {}
-            elif "||" not in key:
                 if len(str(val)) == 0:
                     continue
 
@@ -187,7 +173,7 @@ def generate_weighted_yaml(game: str):
         }
 
         if intent_generate:
-            return generate_game({player_name: formatted_options})
+            return generate_game(player_name, formatted_options)
 
         else:
             return send_yaml(player_name, formatted_options)
@@ -197,10 +183,7 @@ def generate_weighted_yaml(game: str):
 @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)
-        return render_options_page("playerOptions/playerOptions.html", game, is_complex=False)
-    except KeyError:
-        return abort(404)
 
 
 # YAML generator for player-options
@@ -209,41 +192,24 @@ 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":
+            if key in options:
-                options[key] = []
-            elif options.get(key):
                 if not isinstance(options[key], list):
                     options[key] = [options[key]]
                 options[key].append(val)
             else:
                 options[key] = val
 
+        # Detect and build ItemDict options from their name pattern
         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 and val != "0":
+                if val != "0":
                     options[key_parts[0]][key_parts[1]] = int(val)
                 del options[key]
 
-            # 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
-
-                del options[key]
-
-            # 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
-
-                del options[key]
-
         # Detect random-* keys and set their options accordingly
         for key, val in options.copy().items():
             if key.startswith("random-"):
@@ -281,7 +247,7 @@ def generate_yaml(game: str):
         }
 
         if intent_generate:
-            return generate_game({player_name: formatted_options})
+            return generate_game(player_name, formatted_options)
 
         else:
             return send_yaml(player_name, formatted_options)

WebHostLib/requirements.txt

@@ -1,14 +1,9 @@
-flask>=3.1.1
+flask>=3.0.0
-werkzeug>=3.1.3
+pony>=0.7.17
-pony>=0.7.19; python_version <= '3.12'
+waitress>=2.1.2
-pony @ git+https://github.com/black-sliver/pony@7feb1221953b7fa4a6735466bf21a8b4d35e33ba#0.7.19; python_version >= '3.13'
+Flask-Caching>=2.1.0
-waitress>=3.0.2
+Flask-Compress>=1.14
-Flask-Caching>=2.3.0
+Flask-Limiter>=3.5.0
-Flask-Compress==1.18  # pkg_resources can't resolve the "backports.zstd" dependency of >1.18, breaking ModuleUpdate.py
+bokeh>=3.1.1; python_version <= '3.8'
-Flask-Limiter>=3.12
+bokeh>=3.3.2; python_version >= '3.9'
-Flask-Cors>=6.0.2
+markupsafe>=2.1.3
-bokeh>=3.6.3
-markupsafe>=3.0.2
-setproctitle>=1.3.5
-mistune>=3.1.3
-docutils>=0.22.2

WebHostLib/robots.py

@@ -8,8 +8,7 @@ from . import cache
 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.txt')
-        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

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

@@ -0,0 +1,51 @@
+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/faq_en.md

@@ -22,8 +22,8 @@ players to rely upon each other to complete their game.
 
 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.
+games to interact with one another in a single multiplayer environment.  Archipelago supports multi-game multiworld.
-Here is a list of our [Supported Games](/games).
+Here is a list of our [Supported Games](https://archipelago.gg/games).
 
 ## Can I generate a single-player game with Archipelago?
 
@@ -33,7 +33,7 @@ play, open the Settings Page, pick your settings, and click Generate Game.
 
 ## How do I get started?
 
-We have a [Getting Started](/tutorial/Archipelago/setup/en) guide that will help you get the
+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.
 
@@ -57,7 +57,7 @@ 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](/tutorial/Archipelago/commands/en).
+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?
 
@@ -66,7 +66,7 @@ is to ensure items necessary to complete the game will be accessible to the play
 rules allowing certain items to be placed in normally unreachable locations, provided the player has indicated they are
 comfortable exploiting certain glitches in the game.
 
-## I want to develop a game implementation for Archipelago. How do I do that?
+## 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).
@@ -77,5 +77,4 @@ There, you will find examples of games in the `worlds` folder:
 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 regarding development of a game implementation, feel free to ask in the **#ap-world-dev** 
+If you have more questions, feel free to ask in the **#archipelago-dev** channel on our Discord.
-channel on our Discord.

WebHostLib/static/assets/gameInfo.js

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

@@ -0,0 +1,51 @@
+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,4 +6,6 @@ window.addEventListener('load', () => {
     document.getElementById('file-input').addEventListener('change', () => {
         document.getElementById('host-game-form').submit();
     });
+
+    adjustFooterHeight();
 });

WebHostLib/static/assets/minecraftTracker.js

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

@@ -288,11 +288,6 @@ const applyPresets = (presetName) => {
         }
       });
       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"

WebHostLib/static/assets/sc2Tracker.js

@@ -1,43 +1,49 @@
-let updateSection = (sectionName, fakeDOM) => {
-    document.getElementById(sectionName).innerHTML = fakeDOM.getElementById(sectionName).innerHTML;
-}
-
 window.addEventListener('load', () => {
-    // Reload tracker every 60 seconds (sync'd)
+  // Reload tracker every 15 seconds
-    const url = window.location;
+  const url = window.location;
-    // Note: This synchronization code is adapted from code in trackerCommon.js
+  setInterval(() => {
-    const targetSecond = parseInt(document.getElementById('player-tracker').getAttribute('data-second')) + 3;
+    const ajax = new XMLHttpRequest();
-    console.log("Target second of refresh: " + targetSecond);
+    ajax.onreadystatechange = () => {
+      if (ajax.readyState !== 4) { return; }
 
-    let getSleepTimeSeconds = () => {
+      // Create a fake DOM using the returned HTML
-        // -40 % 60 is -40, which is absolutely wrong and should burn
+      const domParser = new DOMParser();
-        var sleepSeconds = (((targetSecond - new Date().getSeconds()) % 60) + 60) % 60;
+      const fakeDOM = domParser.parseFromString(ajax.responseText, 'text/html');
-        return sleepSeconds || 60;
-    };
 
-    let updateTracker = () => {
+      // Update item tracker
-        const ajax = new XMLHttpRequest();
+      document.getElementById('inventory-table').innerHTML = fakeDOM.getElementById('inventory-table').innerHTML;
-        ajax.onreadystatechange = () => {
+      // Update only counters in the location-table
-            if (ajax.readyState !== 4) { return; }
+      let counters = document.getElementsByClassName('counter');
-    
+      const fakeCounters = fakeDOM.getElementsByClassName('counter');
-            // Create a fake DOM using the returned HTML
+      for (let i = 0; i < counters.length; i++) {
-            const domParser = new DOMParser();
+        counters[i].innerHTML = fakeCounters[i].innerHTML;
-            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);
+    ajax.open('GET', url);
+    ajax.send();
+  }, 15000)
+
+  // Collapsible advancement sections
+  const categories = document.getElementsByClassName("location-category");
+  for (let category of categories) {
+    let hide_id = category.id.split('_')[0];
+    if (hide_id === 'Total') {
+      continue;
+    }
+    category.addEventListener('click', function() {
+      // Toggle the advancement list
+      document.getElementById(hide_id).classList.toggle("hide");
+      // Change text of the header
+      const tab_header = document.getElementById(hide_id+'_header').children[0];
+      const 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

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

@@ -27,7 +27,7 @@ const adjustTableHeight = () => {
  * @returns {string}
  */
 const secondsToHours = (seconds) => {
-    let hours = Math.floor(seconds / 3600);
+    let hours   = Math.floor(seconds / 3600);
     let minutes = Math.floor((seconds - (hours * 3600)) / 60).toString().padStart(2, '0');
     return `${hours}:${minutes}`;
 };
@@ -38,18 +38,18 @@ window.addEventListener('load', () => {
         info: false,
         dom: "t",
         stateSave: true,
-        stateSaveCallback: function (settings, data) {
+        stateSaveCallback: function(settings, data) {
             delete data.search;
             localStorage.setItem(`DataTables_${settings.sInstance}_/tracker`, JSON.stringify(data));
         },
-        stateLoadCallback: function (settings) {
+        stateLoadCallback: function(settings) {
             return JSON.parse(localStorage.getItem(`DataTables_${settings.sInstance}_/tracker`));
         },
-        footerCallback: function (tfoot, data, start, end, display) {
+        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';
+                  (activityData.length) ? secondsToHours(Math.min(...activityData)) : 'None';
             }
         },
         columnDefs: [
@@ -123,64 +123,49 @@ window.addEventListener('load', () => {
             event.preventDefault();
         }
     });
-    const target_second = parseInt(document.getElementById('tracker-wrapper').getAttribute('data-second')) + 3;
+    const tracker = document.getElementById('tracker-wrapper').getAttribute('data-tracker');
-    console.log("Target second of refresh: " + target_second);
+    const target_second = document.getElementById('tracker-wrapper').getAttribute('data-second') + 3;
 
-    function getSleepTimeSeconds() {
+    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) {
+        const target = $("<div></div>");
-            console.log("Document reporting as not visible, not updating Tracker...");
+        console.log("Updating Tracker...");
-            update_on_view = true;
+        target.load(location.href, function (response, status) {
-        } else {
+            if (status === "success") {
-            update_on_view = false;
+                target.find(".table").each(function (i, new_table) {
-            const target = $("<div></div>");
+                    const new_trs = $(new_table).find("tbody>tr");
-            console.log("Updating Tracker...");
+                    const footer_tr = $(new_table).find("tfoot>tr");
-            target.load(location.href, function (response, status) {
+                    const old_table = tables.eq(i);
-                if (status === "success") {
+                    const topscroll = $(old_table.settings()[0].nScrollBody).scrollTop();
-                    target.find(".table").each(function (i, new_table) {
+                    const leftscroll = $(old_table.settings()[0].nScrollBody).scrollLeft();
-                        const new_trs = $(new_table).find("tbody>tr");
+                    old_table.clear();
-                        const footer_tr = $(new_table).find("tfoot>tr");
+                    if (footer_tr.length) {
-                        const old_table = tables.eq(i);
+                        $(old_table.table).find("tfoot").html(footer_tr);
-                        const topscroll = $(old_table.settings()[0].nScrollBody).scrollTop();
+                    }
-                        const leftscroll = $(old_table.settings()[0].nScrollBody).scrollLeft();
+                    old_table.rows.add(new_trs);
-                        old_table.clear();
+                    old_table.draw();
-                        if (footer_tr.length) {
+                    $(old_table.settings()[0].nScrollBody).scrollTop(topscroll);
-                            $(old_table.table).find("tfoot").html(footer_tr);
+                    $(old_table.settings()[0].nScrollBody).scrollLeft(leftscroll);
-                        }
+                });
-                        old_table.rows.add(new_trs);
+                $("#multi-stream-link").replaceWith(target.find("#multi-stream-link"));
-                        old_table.draw();
+            } else {
-                        $(old_table.settings()[0].nScrollBody).scrollTop(topscroll);
+                console.log("Failed to connect to Server, in order to update Table Data.");
-                        $(old_table.settings()[0].nScrollBody).scrollLeft(leftscroll);
+                console.log(response);
-                    });
+            }
-                    $("#multi-stream-link").replaceWith(target.find("#multi-stream-link"));
+        })
-                } else {
+        setTimeout(update, getSleepTimeSeconds()*1000);
-                    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);
+    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

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

@@ -0,0 +1,81 @@
+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();
+});