Core: update version

Co-authored-by: black-sliver <59490463+black-sliver@users.noreply.github.com>
Co-authored-by: strotlog <49286967+strotlog@users.noreply.github.com>

.github/workflows/build.yml

@@ -0,0 +1,98 @@
+# This workflow will build a release-like distribution when manually dispatched
+
+name: Build
+
+on: workflow_dispatch
+
+jobs:
+  # build-release-macos: # LF volunteer
+
+  build-win-py38: # RCs will still be built and signed by hand
+    runs-on: windows-latest
+    steps:
+      - uses: actions/checkout@v2
+      - name: Install python
+        uses: actions/setup-python@v3
+        with:
+          python-version: '3.8'
+      - name: Download run-time dependencies
+        run: |
+          Invoke-WebRequest -Uri https://github.com/alttpo/sni/releases/download/v0.0.82/sni-v0.0.82-windows-amd64.zip -OutFile sni.zip
+          Expand-Archive -Path sni.zip -DestinationPath SNI -Force
+          Invoke-WebRequest -Uri https://github.com/Ijwu/Enemizer/releases/download/7.0.1/win-x64.zip -OutFile enemizer.zip
+          Expand-Archive -Path enemizer.zip -DestinationPath EnemizerCLI -Force
+      - name: Build
+        run: |
+          python -m pip install --upgrade pip setuptools
+          pip install -r requirements.txt
+          python setup.py build --yes
+          $NAME="$(ls build)".Split('.',2)[1]
+          $ZIP_NAME="Archipelago_$NAME.7z"
+          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
+      - name: Store 7z
+        uses: actions/upload-artifact@v2
+        with:
+          name: ${{ env.ZIP_NAME }}
+          path: dist/${{ env.ZIP_NAME }}
+          retention-days: 7  # keep for 7 days, should be enough
+
+  build-ubuntu1804:
+    runs-on: ubuntu-18.04
+    steps:
+      - uses: actions/checkout@v2
+      - name: Install base dependencies
+        run: |
+          sudo apt update
+          sudo apt -y install build-essential p7zip xz-utils wget libglib2.0-0
+          sudo apt -y install python3-gi libgirepository1.0-dev  # should pull dependencies for gi installation below
+      - name: Get a recent python
+        uses: actions/setup-python@v3
+        with:
+          python-version: '3.9'
+      - name: Install build-time dependencies
+        run: |
+          echo "PYTHON=python3.9" >> $GITHUB_ENV
+          wget -nv https://github.com/AppImage/AppImageKit/releases/download/13/appimagetool-x86_64.AppImage
+          chmod a+rx appimagetool-x86_64.AppImage
+          ./appimagetool-x86_64.AppImage --appimage-extract
+          echo -e '#/bin/sh\n./squashfs-root/AppRun "$@"' > appimagetool
+          chmod a+rx appimagetool
+      - name: Download run-time dependencies
+        run: |
+          wget -nv https://github.com/alttpo/sni/releases/download/v0.0.82/sni-v0.0.82-manylinux2014-amd64.tar.xz
+          tar xf sni-*.tar.xz
+          rm sni-*.tar.xz
+          mv sni-* SNI
+          wget -nv https://github.com/Ijwu/Enemizer/releases/download/7.0.1/ubuntu.16.04-x64.7z
+          7za x -oEnemizerCLI/ ubuntu.16.04-x64.7z
+      - name: Build
+        run: |
+          # pygobject is an optional dependency for kivy that's not in requirements
+          "${{ env.PYTHON }}" -m pip install --upgrade pip virtualenv PyGObject setuptools
+          "${{ env.PYTHON }}" -m venv venv
+          source venv/bin/activate
+          pip install -r requirements.txt
+          python setup.py build --yes bdist_appimage --yes
+          echo -e "setup.py build output:\n `ls build`"
+          echo -e "setup.py dist output:\n `ls dist`"
+          cd dist && export APPIMAGE_NAME="`ls *.AppImage`" && cd ..
+          export TAR_NAME="${APPIMAGE_NAME%.AppImage}.tar.gz"
+          (cd build && DIR_NAME="`ls | grep exe`" && mv "$DIR_NAME" Archipelago && tar -czvf ../dist/$TAR_NAME Archipelago && mv Archipelago "$DIR_NAME")
+          echo "APPIMAGE_NAME=$APPIMAGE_NAME" >> $GITHUB_ENV
+          echo "TAR_NAME=$TAR_NAME" >> $GITHUB_ENV
+      - name: Store AppImage
+        uses: actions/upload-artifact@v2
+        with:
+          name: ${{ env.APPIMAGE_NAME }}
+          path: dist/${{ env.APPIMAGE_NAME }}
+          retention-days: 7
+      - name: Store .tar.gz
+        uses: actions/upload-artifact@v2
+        with:
+          name: ${{ env.TAR_NAME }}
+          path: dist/${{ env.TAR_NAME }}
+          retention-days: 7

.github/workflows/lint.yml

@@ -12,10 +12,10 @@ jobs:
 
     steps:
     - uses: actions/checkout@v2
-    - name: Set up Python 3.8
+    - name: Set up Python 3.9
       uses: actions/setup-python@v1
       with:
-        python-version: 3.8
+        python-version: 3.9
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip

.github/workflows/release.yml

@@ -0,0 +1,84 @@
+# This workflow will create a release and store builds to it when an x.y.z tag is pushed
+
+name: Release
+
+on:
+  push:
+    tags:
+      - '*.*.*'
+
+jobs:
+  create-release:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Set env
+        run: echo "RELEASE_VERSION=${GITHUB_REF#refs/*/}" >> $GITHUB_ENV  # tag x.y.z will become "Archipelago x.y.z"
+      - name: Create Release
+        uses: softprops/action-gh-release@b7e450da2a4b4cb4bfbae528f788167786cfcedf
+        with:
+          draft: true  # don't publish right away, especially since windows build is added by hand
+          prerelease: false
+          name: Archipelago ${{ env.RELEASE_VERSION }}
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+  # build-release-windows: # this is done by hand because of signing
+  # build-release-macos: # LF volunteer
+
+  build-release-ubuntu1804:
+    runs-on: ubuntu-18.04
+    steps:
+      - name: Set env
+        run: echo "RELEASE_VERSION=${GITHUB_REF#refs/*/}" >> $GITHUB_ENV
+      # - code below copied from build.yml -
+      - uses: actions/checkout@v2
+      - name: Install base dependencies
+        run: |
+          sudo apt update
+          sudo apt -y install build-essential p7zip xz-utils wget libglib2.0-0
+          sudo apt -y install python3-gi libgirepository1.0-dev  # should pull dependencies for gi installation below
+      - name: Get a recent python
+        uses: actions/setup-python@v3
+        with:
+          python-version: '3.9'
+      - name: Install build-time dependencies
+        run: |
+          echo "PYTHON=python3.9" >> $GITHUB_ENV
+          wget -nv https://github.com/AppImage/AppImageKit/releases/download/13/appimagetool-x86_64.AppImage
+          chmod a+rx appimagetool-x86_64.AppImage
+          ./appimagetool-x86_64.AppImage --appimage-extract
+          echo -e '#/bin/sh\n./squashfs-root/AppRun "$@"' > appimagetool
+          chmod a+rx appimagetool
+      - name: Download run-time dependencies
+        run: |
+          wget -nv https://github.com/alttpo/sni/releases/download/v0.0.82/sni-v0.0.82-manylinux2014-amd64.tar.xz
+          tar xf sni-*.tar.xz
+          rm sni-*.tar.xz
+          mv sni-* SNI
+          wget -nv https://github.com/Ijwu/Enemizer/releases/download/7.0.1/ubuntu.16.04-x64.7z
+          7za x -oEnemizerCLI/ ubuntu.16.04-x64.7z
+      - name: Build
+        run: |
+          "${{ env.PYTHON }}" -m pip install --upgrade pip setuptools virtualenv PyGObject  # pygobject should probably move to requirements
+          "${{ env.PYTHON }}" -m venv venv
+          source venv/bin/activate
+          pip install -r requirements.txt
+          python setup.py build --yes bdist_appimage --yes
+          echo -e "setup.py build output:\n `ls build`"
+          echo -e "setup.py dist output:\n `ls dist`"
+          cd dist && export APPIMAGE_NAME="`ls *.AppImage`" && cd ..
+          export TAR_NAME="${APPIMAGE_NAME%.AppImage}.tar.gz"
+          (cd build && DIR_NAME="`ls | grep exe`" && mv "$DIR_NAME" Archipelago && tar -czvf ../dist/$TAR_NAME Archipelago && mv Archipelago "$DIR_NAME")
+          echo "APPIMAGE_NAME=$APPIMAGE_NAME" >> $GITHUB_ENV
+          echo "TAR_NAME=$TAR_NAME" >> $GITHUB_ENV
+      # - code above copied from build.yml -
+      - name: Add to Release
+        uses: softprops/action-gh-release@b7e450da2a4b4cb4bfbae528f788167786cfcedf
+        with:
+          draft: true  # see above
+          prerelease: false
+          name: Archipelago ${{ env.RELEASE_VERSION }}
+          files: |
+            dist/*
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/unittests.yml

@@ -7,20 +7,34 @@ on: [push, pull_request]
 
 jobs:
   build:
+    runs-on: ${{ matrix.os }}
+    name: Test Python ${{ matrix.python.version }} ${{ matrix.os }}
 
-    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest]
+        python:
+          - {version: '3.8'}
+          - {version: '3.9'}
+          - {version: '3.10'}
+        include:
+          - python: {version: '3.8'}  # win7 compat
+            os: windows-latest
+          - python: {version: '3.10'}  # current
+            os: windows-latest
 
     steps:
     - uses: actions/checkout@v2
-    - name: Set up Python 3.8
+    - name: Set up Python ${{ matrix.python.version }}
       uses: actions/setup-python@v1
       with:
-        python-version: 3.8
+        python-version: ${{ matrix.python.version }}
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip
         pip install flake8 pytest
-        if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
+        python ModuleUpdate.py --yes --force --append "WebHostLib/requirements.txt"
     - name: Unittests
       run: |
         pytest test

.gitignore

@@ -4,9 +4,15 @@
 *_Spoiler.txt
 *.bmbp
 *.apbp
+*.apm3
+*.apmc
+*.apz5
 *.pyc
 *.pyd
 *.sfc
+*.z64
+*.n64
+*.nes
 *.wixobj
 *.lck
 *.db3
@@ -16,20 +22,14 @@
 *.apsave
 
 build
-/build_factorio/
 bundle/components.wxs
 dist
 README.html
 .vs/
 EnemizerCLI/
-RaceRom.py
-weights/
-/MultiMystery/
 /Players/
-/QUsb2Snes/
 /options.yaml
 /config.yaml
-/uploads/
 /logs/
 _persistent_storage.yaml
 mystery_result_*.yaml
@@ -38,6 +38,12 @@ success.txt
 output/
 Output Logs/
 /factorio/
+/Minecraft Forge Server/
+/WebHostLib/static/generated
+/freeze_requirements.txt
+/Archipelago.zip
+/setup.ini
+
 
 # Byte-compiled / optimized / DLL files
 __pycache__/
@@ -71,6 +77,7 @@ MANIFEST
 # Installer logs
 pip-log.txt
 pip-delete-this-directory.txt
+installer.log
 
 # Unit test / coverage reports
 htmlcov/
@@ -109,6 +116,9 @@ target/
 profile_default/
 ipython_config.py
 
+# vim editor
+*.swp
+
 # SageMath parsed files
 *.sage.py
 
@@ -144,3 +154,18 @@ dmypy.json
 
 # Cython debug symbols
 cython_debug/
+
+# minecraft server stuff
+jdk*/
+minecraft*/
+minecraft_versions.json
+
+# pyenv
+.python-version
+
+# OS General Files
+.DS_Store
+.AppleDouble
+.LSOverride
+Thumbs.db
+[Dd]esktop.ini

ChecksFinderClient.py

@@ -0,0 +1,172 @@
+from __future__ import annotations
+import os
+import sys
+import asyncio
+import shutil
+
+import ModuleUpdate
+ModuleUpdate.update()
+
+import Utils
+
+if __name__ == "__main__":
+    Utils.init_logging("ChecksFinderClient", exception_logger="Client")
+
+from NetUtils import NetworkItem, ClientStatus
+from CommonClient import gui_enabled, logger, get_base_parser, ClientCommandProcessor, \
+    CommonContext, server_loop
+
+
+class ChecksFinderClientCommandProcessor(ClientCommandProcessor):
+    def _cmd_resync(self):
+        """Manually trigger a resync."""
+        self.output(f"Syncing items.")
+        self.ctx.syncing = True
+
+
+class ChecksFinderContext(CommonContext):
+    command_processor: int = ChecksFinderClientCommandProcessor
+    game = "ChecksFinder"
+    items_handling = 0b111  # full remote
+
+    def __init__(self, server_address, password):
+        super(ChecksFinderContext, self).__init__(server_address, password)
+        self.send_index: int = 0
+        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
+        if "localappdata" in os.environ:
+            self.game_communication_path = os.path.expandvars(r"%localappdata%/ChecksFinder")
+        else:
+            # not windows. game is an exe so let's see if wine might be around to run it
+            if "WINEPREFIX" in os.environ:
+                wineprefix = os.environ["WINEPREFIX"]
+            elif shutil.which("wine") or shutil.which("wine-stable"):
+                wineprefix = os.path.expanduser("~/.wine") # default root of wine system data, deep in which is app data
+            else:
+                msg = "ChecksFinderClient couldn't detect system type. Unable to infer required game_communication_path"
+                logger.error("Error: " + msg)
+                Utils.messagebox("Error", msg, error=True)
+                sys.exit(1)
+            self.game_communication_path = os.path.join(
+                wineprefix,
+                "drive_c",
+                os.path.expandvars("users/$USER/Local Settings/Application Data/ChecksFinder"))
+
+    async def server_auth(self, password_requested: bool = False):
+        if password_requested and not self.password:
+            await super(ChecksFinderContext, self).server_auth(password_requested)
+        await self.get_username()
+        await self.send_connect()
+
+    async def connection_closed(self):
+        await super(ChecksFinderContext, self).connection_closed()
+        for root, dirs, files in os.walk(self.game_communication_path):
+            for file in files:
+                if file.find("obtain") <= -1:
+                    os.remove(root + "/" + file)
+
+    @property
+    def endpoints(self):
+        if self.server:
+            return [self.server]
+        else:
+            return []
+
+    async def shutdown(self):
+        await super(ChecksFinderContext, self).shutdown()
+        for root, dirs, files in os.walk(self.game_communication_path):
+            for file in files:
+                if file.find("obtain") <= -1:
+                    os.remove(root+"/"+file)
+
+    def on_package(self, cmd: str, args: dict):
+        if cmd in {"Connected"}:
+            if not os.path.exists(self.game_communication_path):
+                os.makedirs(self.game_communication_path)
+            for ss in self.checked_locations:
+                filename = f"send{ss}"
+                with open(os.path.join(self.game_communication_path, filename), 'w') as f:
+                    f.close()
+        if cmd in {"ReceivedItems"}:
+            start_index = args["index"]
+            if start_index != len(self.items_received):
+                for item in args['items']:
+                    filename = f"AP_{str(NetworkItem(*item).location)}PLR{str(NetworkItem(*item).player)}.item"
+                    with open(os.path.join(self.game_communication_path, filename), 'w') as f:
+                        f.write(str(NetworkItem(*item).item))
+                        f.close()
+
+        if cmd in {"RoomUpdate"}:
+            if "checked_locations" in args:
+                for ss in self.checked_locations:
+                    filename = f"send{ss}"
+                    with open(os.path.join(self.game_communication_path, filename), 'w') as f:
+                        f.close()
+
+    def run_gui(self):
+        """Import kivy UI system and start running it as self.ui_task."""
+        from kvui import GameManager
+
+        class ChecksFinderManager(GameManager):
+            logging_pairs = [
+                ("Client", "Archipelago")
+            ]
+            base_title = "Archipelago ChecksFinder Client"
+
+        self.ui = ChecksFinderManager(self)
+        self.ui_task = asyncio.create_task(self.ui.async_run(), name="UI")
+
+
+async def game_watcher(ctx: ChecksFinderContext):
+    from worlds.checksfinder.Locations import lookup_id_to_name
+    while not ctx.exit_event.is_set():
+        if ctx.syncing == True:
+            sync_msg = [{'cmd': 'Sync'}]
+            if ctx.locations_checked:
+                sync_msg.append({"cmd": "LocationChecks", "locations": list(ctx.locations_checked)})
+            await ctx.send_msgs(sync_msg)
+            ctx.syncing = False
+        sending = []
+        victory = False
+        for root, dirs, files in os.walk(ctx.game_communication_path):
+            for file in files:
+                if file.find("send") > -1:
+                    st = file.split("send", -1)[1]
+                    sending = sending+[(int(st))]
+                if file.find("victory") > -1:
+                    victory = True
+        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)
+
+
+if __name__ == '__main__':
+    async def main(args):
+        ctx = ChecksFinderContext(args.connect, args.password)
+        ctx.server_task = asyncio.create_task(server_loop(ctx), name="server loop")
+        if gui_enabled:
+            ctx.run_gui()
+        ctx.run_cli()
+        progression_watcher = asyncio.create_task(
+            game_watcher(ctx), name="ChecksFinderProgressionWatcher")
+
+        await ctx.exit_event.wait()
+        ctx.server_address = None
+
+        await progression_watcher
+
+        await ctx.shutdown()
+
+    import colorama
+
+    parser = get_base_parser(description="ChecksFinder Client, for text interfacing.")
+
+    args, rest = parser.parse_known_args()
+    colorama.init()
+    asyncio.run(main(args))
+    colorama.deinit()

CommonClient.py

@@ -1,26 +1,33 @@
 from __future__ import annotations
 import logging
-import typing
 import asyncio
 import urllib.parse
+import sys
+import typing
+import time
+
+import ModuleUpdate
+ModuleUpdate.update()
 
-import prompt_toolkit
 import websockets
-from prompt_toolkit.patch_stdout import patch_stdout
 
 import Utils
+
+if __name__ == "__main__":
+    Utils.init_logging("TextClient", exception_logger="Client")
+
 from MultiServer import CommandProcessor
-
-from NetUtils import Endpoint, decode, NetworkItem, encode, JSONtoTextParser, color, ClientStatus
-from Utils import Version
-
-# logging note:
-# logging.* gets send to only the text console, logger.* gets send to the WebUI as well, if it's initialized.
-from worlds import network_data_package
-from worlds.alttp import Items, Regions
+from NetUtils import Endpoint, decode, NetworkItem, encode, JSONtoTextParser, ClientStatus, Permission, NetworkSlot
+from Utils import Version, stream_input
+from worlds import network_data_package, AutoWorldRegister
+import os
 
 logger = logging.getLogger("Client")
 
+# without terminal, we have to use gui mode
+gui_enabled = not sys.stdout or "--nogui" not in sys.argv
+
+
 class ClientCommandProcessor(CommandProcessor):
     def __init__(self, ctx: CommonContext):
         self.ctx = ctx
@@ -36,30 +43,32 @@ class ClientCommandProcessor(CommandProcessor):
     def _cmd_connect(self, address: str = "") -> bool:
         """Connect to a MultiWorld Server"""
         self.ctx.server_address = None
-        asyncio.create_task(self.ctx.connect(address if address else None))
+        self.ctx.username = None
+        asyncio.create_task(self.ctx.connect(address if address else None), name="connecting")
         return True
 
     def _cmd_disconnect(self) -> bool:
         """Disconnect from a MultiWorld Server"""
         self.ctx.server_address = None
-        asyncio.create_task(self.ctx.disconnect())
+        self.ctx.username = None
+        asyncio.create_task(self.ctx.disconnect(), name="disconnecting")
         return True
 
     def _cmd_received(self) -> bool:
         """List all received items"""
-        logger.info('Received items:')
+        logger.info(f'{len(self.ctx.items_received)} received items:')
         for index, item in enumerate(self.ctx.items_received, 1):
-            logging.info('%s from %s (%s) (%d/%d in list)' % (
-                color(self.ctx.item_name_getter(item.item), 'red', 'bold'),
-                color(self.ctx.player_names[item.player], 'yellow'),
-                self.ctx.location_name_getter(item.location), index, len(self.ctx.items_received)))
+            self.output(f"{self.ctx.item_names[item.item]} from {self.ctx.player_names[item.player]}")
         return True
 
     def _cmd_missing(self) -> bool:
         """List all missing location checks, from your local game state"""
+        if not self.ctx.game:
+            self.output("No game set, cannot determine missing checks.")
+            return False
         count = 0
         checked_count = 0
-        for location, location_id in Regions.lookup_name_to_id.items():
+        for location, location_id in AutoWorldRegister.world_types[self.ctx.game].location_name_to_id.items():
             if location_id < 0:
                 continue
             if location_id not in self.ctx.locations_checked:
@@ -78,9 +87,20 @@ class ClientCommandProcessor(CommandProcessor):
             self.output("No missing location checks found.")
         return True
 
+    def _cmd_items(self):
+        """List all item names for the currently running game."""
+        self.output(f"Item Names for {self.ctx.game}")
+        for item_name in AutoWorldRegister.world_types[self.ctx.game].item_name_to_id:
+            self.output(item_name)
 
+    def _cmd_locations(self):
+        """List all location names for the currently running game."""
+        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)
 
     def _cmd_ready(self):
+        """Send ready status to server."""
         self.ctx.ready = not self.ctx.ready
         if self.ctx.ready:
             state = ClientStatus.CLIENT_READY
@@ -88,94 +108,126 @@ class ClientCommandProcessor(CommandProcessor):
         else:
             state = ClientStatus.CLIENT_CONNECTED
             self.output("Unreadied.")
-        asyncio.create_task(self.ctx.send_msgs([{"cmd": "StatusUpdate", "status": state}]))
+        asyncio.create_task(self.ctx.send_msgs([{"cmd": "StatusUpdate", "status": state}]), name="send StatusUpdate")
 
     def default(self, raw: str):
-        asyncio.create_task(self.ctx.send_msgs([{"cmd": "Say", "text": raw}]))
+        raw = self.ctx.on_user_say(raw)
+        if raw:
+            asyncio.create_task(self.ctx.send_msgs([{"cmd": "Say", "text": raw}]), name="send Say")
 
-class CommonContext():
-    starting_reconnect_delay = 5
-    current_reconnect_delay = starting_reconnect_delay
-    command_processor = ClientCommandProcessor
-    def __init__(self, server_address, password, found_items: bool):
+
+class CommonContext:
+    # Should be adjusted as needed in subclasses
+    tags: typing.Set[str] = {"AP"}
+    game: typing.Optional[str] = None
+    items_handling: typing.Optional[int] = None
+
+    # datapackage
+    # Contents in flux until connection to server is made, to download correct data for this multiworld.
+    item_names: typing.Dict[int, str] = Utils.KeyedDefaultDict(lambda code: f'Unknown item (ID:{code})')
+    location_names: typing.Dict[int, str] = Utils.KeyedDefaultDict(lambda code: f'Unknown location (ID:{code})')
+
+    # defaults
+    starting_reconnect_delay: int = 5
+    current_reconnect_delay: int = starting_reconnect_delay
+    command_processor: type(CommandProcessor) = ClientCommandProcessor
+    ui = None
+    ui_task: typing.Optional[asyncio.Task] = None
+    input_task: typing.Optional[asyncio.Task] = None
+    keep_alive_task: typing.Optional[asyncio.Task] = None
+    server_task: typing.Optional[asyncio.Task] = None
+    server: typing.Optional[Endpoint] = None
+    server_version: Version = Version(0, 0, 0)
+    current_energy_link_value: int = 0  # to display in UI, gets set by server
+
+    last_death_link: float = time.time()  # last send/received death link on AP layer
+
+    # remaining type info
+    slot_info: typing.Dict[int, NetworkSlot]
+    server_address: str
+    password: typing.Optional[str]
+    hint_cost: typing.Optional[int]
+    player_names: typing.Dict[int, str]
+
+    # locations
+    locations_checked: typing.Set[int]  # local state
+    locations_scouted: typing.Set[int]
+    missing_locations: typing.Set[int]
+    checked_locations: typing.Set[int]  # server state
+    locations_info: typing.Dict[int, NetworkItem]
+
+    # internals
+    # current message box through kvui
+    _messagebox = None
+
+    def __init__(self, server_address, password):
         # server state
         self.server_address = server_address
+        self.username = None
         self.password = password
-        self.server_task = None
-        self.server: typing.Optional[Endpoint] = None
-        self.server_version = Version(0, 0, 0)
+        self.hint_cost = None
+        self.slot_info = {}
+        self.permissions = {
+            "forfeit": "disabled",
+            "collect": "disabled",
+            "remaining": "disabled",
+        }
 
         # own state
         self.finished_game = False
         self.ready = False
-        self.found_items = found_items
         self.team = None
         self.slot = None
         self.auth = None
         self.seed_name = None
 
-        self.locations_checked: typing.Set[int] = set()
-        self.locations_scouted: typing.Set[int] = set()
+        self.locations_checked = set()  # local state
+        self.locations_scouted = set()
         self.items_received = []
-        self.missing_locations: typing.List[int] = []
-        self.checked_locations: typing.List[int] = []
+        self.missing_locations = set()
+        self.checked_locations = set()  # server state
         self.locations_info = {}
 
         self.input_queue = asyncio.Queue()
         self.input_requests = 0
 
         # game state
-        self.player_names: typing.Dict[int: str] = {0: "Archipelago"}
+        self.player_names = {0: "Archipelago"}
         self.exit_event = asyncio.Event()
         self.watcher_event = asyncio.Event()
 
-        self.slow_mode = False
         self.jsontotextparser = JSONtoTextParser(self)
-        self.set_getters(network_data_package)
+        self.update_datapackage(network_data_package)
+
+        # execution
+        self.keep_alive_task = asyncio.create_task(keep_alive(self), name="Bouncy")
+
+    @property
+    def total_locations(self) -> typing.Optional[int]:
+        """Will return None until connected."""
+        if self.checked_locations or self.missing_locations:
+            return len(self.checked_locations | self.missing_locations)
 
     async def connection_closed(self):
+        self.reset_server_state()
+        if self.server and self.server.socket is not None:
+            await self.server.socket.close()
+
+    def reset_server_state(self):
         self.auth = None
+        self.slot = None
+        self.team = None
         self.items_received = []
         self.locations_info = {}
         self.server_version = Version(0, 0, 0)
-        if self.server and self.server.socket is not None:
-            await self.server.socket.close()
         self.server = None
         self.server_task = None
-
-    def set_getters(self, data_package: dict, network=False):
-        if not network:  # local data; check if newer data was already downloaded
-            local_package = Utils.persistent_load().get("datapackage", {}).get("latest", {})
-            if local_package and local_package["version"] > network_data_package["version"]:
-                data_package: dict = local_package
-        elif network:  # check if data from server is newer
-            for key, value in data_package.items():
-                if type(value) == dict:  # convert to int keys
-                    data_package[key] = \
-                        {int(subkey) if subkey.isdigit() else subkey: subvalue for subkey, subvalue in value.items()}
-
-            if data_package["version"] > network_data_package["version"]:
-                Utils.persistent_store("datapackage", "latest", network_data_package)
-
-        item_lookup: dict = data_package["lookup_any_item_id_to_name"]
-        locations_lookup: dict = data_package["lookup_any_location_id_to_name"]
-
-        def get_item_name_from_id(code: int):
-            return item_lookup.get(code, f'Unknown item (ID:{code})')
-
-        self.item_name_getter = get_item_name_from_id
-
-        def get_location_name_from_address(address: int):
-            return locations_lookup.get(address, f'Unknown location (ID:{address})')
-
-        self.location_name_getter = get_location_name_from_address
-
-    @property
-    def endpoints(self):
-        if self.server:
-            return [self.server]
-        else:
-            return []
+        self.hint_cost = None
+        self.permissions = {
+            "forfeit": "disabled",
+            "collect": "disabled",
+            "remaining": "disabled",
+        }
 
     async def disconnect(self):
         if self.server and not self.server.socket.closed:
@@ -195,31 +247,227 @@ class CommonContext():
     def event_invalid_slot(self):
         raise Exception('Invalid Slot; please verify that you have connected to the correct world.')
 
-    async def server_auth(self, password_requested):
+    def event_invalid_game(self):
+        raise Exception('Invalid Game; please verify that you connected with the right game to the correct world.')
+
+    async def server_auth(self, password_requested: bool = False):
         if password_requested and not self.password:
             logger.info('Enter the password required to join this game:')
             self.password = await self.console_input()
             return self.password
 
+    async def get_username(self):
+        if not self.auth:
+            self.auth = self.username
+            if not self.auth:
+                logger.info('Enter slot name:')
+                self.auth = await self.console_input()
+
+    async def send_connect(self, **kwargs):
+        payload = {
+            'cmd': 'Connect',
+            'password': self.password, 'name': self.auth, 'version': Utils.version_tuple,
+            'tags': self.tags, 'items_handling': self.items_handling,
+            'uuid': Utils.get_unique_identifier(), 'game': self.game
+        }
+        if kwargs:
+            payload.update(kwargs)
+        await self.send_msgs([payload])
+
     async def console_input(self):
         self.input_requests += 1
         return await self.input_queue.get()
 
-    async def connect(self, address= None):
+    async def connect(self, address=None):
         await self.disconnect()
-        self.server_task = asyncio.create_task(server_loop(self, address))
+        self.server_task = asyncio.create_task(server_loop(self, address), name="server loop")
+
+    def slot_concerns_self(self, slot) -> bool:
+        if slot == self.slot:
+            return True
+        if slot in self.slot_info:
+            return self.slot in self.slot_info[slot].group_members
+        return False
 
     def on_print(self, args: dict):
         logger.info(args["text"])
 
     def on_print_json(self, args: dict):
-        if not self.found_items and args.get("type", None) == "ItemSend" and args["receiving"] == args["sending"]:
-            pass  # don't want info on other player's local pickups.
-        logger.info(self.jsontotextparser(args["data"]))
+        if self.ui:
+            self.ui.print_json(args["data"])
+        else:
+            text = self.jsontotextparser(args["data"])
+            logger.info(text)
+
+    def on_package(self, cmd: str, args: dict):
+        """For custom package handling in subclasses."""
+        pass
+
+    def on_user_say(self, text: str) -> typing.Optional[str]:
+        """Gets called before sending a Say to the server from the user.
+        Returned text is sent, or sending is aborted if None is returned."""
+        return text
+
+    def update_permissions(self, permissions: typing.Dict[str, int]):
+        for permission_name, permission_flag in permissions.items():
+            try:
+                flag = Permission(permission_flag)
+                logger.info(f"{permission_name.capitalize()} permission: {flag.name}")
+                self.permissions[permission_name] = flag.name
+            except Exception as e:  # safeguard against permissions that may be implemented in the future
+                logger.exception(e)
+
+    async def shutdown(self):
+        self.server_address = ""
+        self.username = None
+        if self.server and not self.server.socket.closed:
+            await self.server.socket.close()
+        if self.server_task:
+            await self.server_task
+
+        while self.input_requests > 0:
+            self.input_queue.put_nowait(None)
+            self.input_requests -= 1
+        self.keep_alive_task.cancel()
+        if self.ui_task:
+            await self.ui_task
+        if self.input_task:
+            self.input_task.cancel()
+
+    # DataPackage
+    async def prepare_datapackage(self, relevant_games: typing.Set[str],
+                                  remote_datepackage_versions: typing.Dict[str, int]):
+        """Validate that all data is present for the current multiworld.
+        Download, assimilate and cache missing data from the server."""
+        # by documentation any game can use Archipelago locations/items -> always relevant
+        relevant_games.add("Archipelago")
+
+        cache_package = Utils.persistent_load().get("datapackage", {}).get("games", {})
+        needed_updates: typing.Set[str] = set()
+        for game in relevant_games:
+            remote_version: int = remote_datepackage_versions[game]
+
+            if remote_version == 0:  # custom datapackage for this game
+                needed_updates.add(game)
+                continue
+            local_version: int = network_data_package["games"].get(game, {}).get("version", 0)
+            # no action required if local version is new enough
+            if remote_version > local_version:
+                cache_version: int = cache_package.get(game, {}).get("version", 0)
+                # download remote version if cache is not new enough
+                if remote_version > cache_version:
+                    needed_updates.add(game)
+                else:
+                    self.update_game(cache_package[game])
+        if needed_updates:
+            await self.send_msgs([{"cmd": "GetDataPackage", "games": list(needed_updates)}])
+
+    def update_game(self, game_package: dict):
+        for item_name, item_id in game_package["item_name_to_id"].items():
+            self.item_names[item_id] = item_name
+        for location_name, location_id in game_package["location_name_to_id"].items():
+            self.location_names[location_id] = location_name
+
+    def update_datapackage(self, data_package: dict):
+        for game, gamedata in data_package["games"].items():
+            self.update_game(gamedata)
+
+    def consume_network_datapackage(self, data_package: dict):
+        self.update_datapackage(data_package)
+        current_cache = Utils.persistent_load().get("datapackage", {}).get("games", {})
+        current_cache.update(data_package["games"])
+        Utils.persistent_store("datapackage", "games", current_cache)
+
+    # DeathLink hooks
+
+    def on_deathlink(self, data: dict):
+        """Gets dispatched when a new DeathLink is triggered by another linked player."""
+        self.last_death_link = max(data["time"], self.last_death_link)
+        text = data.get("cause", "")
+        if text:
+            logger.info(f"DeathLink: {text}")
+        else:
+            logger.info(f"DeathLink: Received from {data['source']}")
+
+    async def send_death(self, death_text: str = ""):
+        if self.server and self.server.socket:
+            logger.info("DeathLink: Sending death to your friends...")
+            self.last_death_link = time.time()
+            await self.send_msgs([{
+                "cmd": "Bounce", "tags": ["DeathLink"],
+                "data": {
+                    "time": self.last_death_link,
+                    "source": self.player_names[self.slot],
+                    "cause": death_text
+                }
+            }])
+
+    async def update_death_link(self, death_link: bool):
+        old_tags = self.tags.copy()
+        if death_link:
+            self.tags.add("DeathLink")
+        else:
+            self.tags -= {"DeathLink"}
+        if old_tags != self.tags and self.server and not self.server.socket.closed:
+            await self.send_msgs([{"cmd": "ConnectUpdate", "tags": self.tags}])
+
+    def gui_error(self, title: str, text: typing.Union[Exception, str]):
+        """Displays an error messagebox"""
+        if not self.ui:
+            return
+        title = title or "Error"
+        from kvui import MessageBox
+        if self._messagebox:
+            self._messagebox.dismiss()
+        # make "Multiple exceptions" look nice
+        text = str(text).replace('[Errno', '\n[Errno').strip()
+        # split long messages into title and text
+        parts = title.split('. ', 1)
+        if len(parts) == 1:
+            parts = title.split(', ', 1)
+        if len(parts) > 1:
+            text = parts[1] + '\n\n' + text
+            title = parts[0]
+        # display error
+        self._messagebox = MessageBox(title, text, error=True)
+        self._messagebox.open()
+
+    def run_gui(self):
+        """Import kivy UI system and start running it as self.ui_task."""
+        from kvui import GameManager
+
+        class TextManager(GameManager):
+            logging_pairs = [
+                ("Client", "Archipelago")
+            ]
+            base_title = "Archipelago Text Client"
+
+        self.ui = TextManager(self)
+        self.ui_task = asyncio.create_task(self.ui.async_run(), name="UI")
+
+    def run_cli(self):
+        if sys.stdin:
+            # 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.")
+            else:
+                self.input_task = asyncio.create_task(console_loop(self), name="Input")
+
+
+async def keep_alive(ctx: CommonContext, seconds_between_checks=100):
+    """some ISPs/network configurations drop TCP connections if no payload is sent (ignore TCP-keep-alive)
+     so we send a payload to prevent drop and if we were dropped anyway this will cause an auto-reconnect."""
+    seconds_elapsed = 0
+    while not ctx.exit_event.is_set():
+        await asyncio.sleep(1)  # short sleep to not block program shutdown
+        if ctx.server and ctx.slot:
+            seconds_elapsed += 1
+            if seconds_elapsed > seconds_between_checks:
+                await ctx.send_msgs([{"cmd": "Bounce", "slots": [ctx.slot]}])
+                seconds_elapsed = 0
 
 
 async def server_loop(ctx: CommonContext, address=None):
-    cached_address = None
     if ctx.server and ctx.server.socket:
         logger.error('Already connected')
         return
@@ -232,12 +480,20 @@ async def server_loop(ctx: CommonContext, address=None):
         logger.info('Please connect to an Archipelago server.')
         return
 
-    address = f"ws://{address}" if "://" not in address else address
-    port = urllib.parse.urlparse(address).port or 38281
+    address = f"ws://{address}" if "://" not in address \
+        else address.replace("archipelago://", "ws://")
+
+    server_url = urllib.parse.urlparse(address)
+    if server_url.username:
+        ctx.username = server_url.username
+    if server_url.password:
+        ctx.password = server_url.password
+    port = server_url.port or 38281
 
     logger.info(f'Connecting to Archipelago server at {address}')
     try:
         socket = await websockets.connect(address, port=port, ping_timeout=None, ping_interval=None)
+        ctx.ui.update_address_bar(server_url.netloc)
         ctx.server = Endpoint(socket)
         logger.info('Connected')
         ctx.server_address = address
@@ -246,30 +502,34 @@ async def server_loop(ctx: CommonContext, address=None):
             for msg in decode(data):
                 await process_server_cmd(ctx, msg)
         logger.warning('Disconnected from multiworld server, type /connect to reconnect')
-    except ConnectionRefusedError:
-        if cached_address:
-            logger.error('Unable to connect to multiworld server at cached address. '
-                         'Please use the connect button above.')
-        else:
-            logger.error('Connection refused by the multiworld server')
-    except (OSError, websockets.InvalidURI):
-        logger.error('Failed to connect to the multiworld server')
+    except ConnectionRefusedError as e:
+        msg = 'Connection refused by the server. May not be running Archipelago on that address or port.'
+        logger.exception(msg, extra={'compact_gui': True})
+        ctx.gui_error(msg, e)
+    except websockets.InvalidURI as e:
+        msg = 'Failed to connect to the multiworld server (invalid URI)'
+        logger.exception(msg, extra={'compact_gui': True})
+        ctx.gui_error(msg, e)
+    except OSError as e:
+        msg = 'Failed to connect to the multiworld server'
+        logger.exception(msg, extra={'compact_gui': True})
+        ctx.gui_error(msg, e)
     except Exception as e:
-        logger.error('Lost connection to the multiworld server, type /connect to reconnect')
-        if not isinstance(e, websockets.WebSocketException):
-            logger.exception(e)
+        msg = 'Lost connection to the multiworld server, type /connect to reconnect'
+        logger.exception(msg, extra={'compact_gui': True})
+        ctx.gui_error(msg, e)
     finally:
         await ctx.connection_closed()
         if ctx.server_address:
             logger.info(f"... reconnecting in {ctx.current_reconnect_delay}s")
-            asyncio.create_task(server_autoreconnect(ctx))
+            asyncio.create_task(server_autoreconnect(ctx), name="server auto reconnect")
         ctx.current_reconnect_delay *= 2
 
 
 async def server_autoreconnect(ctx: CommonContext):
     await asyncio.sleep(ctx.current_reconnect_delay)
     if ctx.server_address and ctx.server_task is None:
-        ctx.server_task = asyncio.create_task(server_loop(ctx))
+        ctx.server_task = asyncio.create_task(server_loop(ctx), name="server loop")
 
 
 async def process_server_cmd(ctx: CommonContext, args: dict):
@@ -280,7 +540,9 @@ async def process_server_cmd(ctx: CommonContext, args: dict):
         raise
     if cmd == 'RoomInfo':
         if ctx.seed_name and ctx.seed_name != args["seed_name"]:
-            logger.info("The server is running a different multiworld than your client is. (invalid seed_name)")
+            msg = "The server is running a different multiworld than your client is. (invalid seed_name)"
+            logger.info(msg, extra={'compact_gui': True})
+            ctx.gui_error('Error', msg)
         else:
             logger.info('--------------------------------')
             logger.info('Room Information:')
@@ -293,54 +555,60 @@ async def process_server_cmd(ctx: CommonContext, args: dict):
             logger.info("Server protocol tags: " + ", ".join(args["tags"]))
             if args['password']:
                 logger.info('Password required')
-            logger.info(f"Forfeit setting: {args['forfeit_mode']}")
-            logger.info(f"Remaining setting: {args['remaining_mode']}")
-            logger.info(f"A !hint costs {args['hint_cost']}% of checks points and you get {args['location_check_points']}"
-                         f" for each location checked. Use !hint for more information.")
+            ctx.update_permissions(args.get("permissions", {}))
+            logger.info(
+                f"A !hint costs {args['hint_cost']}% of your total location count as points"
+                f" and you get {args['location_check_points']}"
+                f" for each location checked. Use !hint for more information.")
             ctx.hint_cost = int(args['hint_cost'])
             ctx.check_points = int(args['location_check_points'])
-            ctx.forfeit_mode = args['forfeit_mode']
-            ctx.remaining_mode = args['remaining_mode']
-            if len(args['players']) < 1:
+            players = args.get("players", [])
+            if len(players) < 1:
                 logger.info('No player connected')
             else:
-                args['players'].sort()
+                players.sort()
                 current_team = -1
-                logger.info('Players:')
-                for network_player in args['players']:
+                logger.info('Connected Players:')
+                for network_player in players:
                     if network_player.team != current_team:
                         logger.info(f'  Team #{network_player.team + 1}')
                         current_team = network_player.team
                     logger.info('    %s (Player %d)' % (network_player.alias, network_player.slot))
-            if args["datapackage_version"] > network_data_package["version"] or args["datapackage_version"] == 0:
-                await ctx.send_msgs([{"cmd": "GetDataPackage"}])
+            # update datapackage
+            await ctx.prepare_datapackage(set(args["games"]), args["datapackage_versions"])
+
             await ctx.server_auth(args['password'])
 
     elif cmd == 'DataPackage':
-        logger.info("Got new ID/Name Datapackage")
-        ctx.set_getters(args['data'], network=True)
+        logger.info("Got new ID/Name DataPackage")
+        ctx.consume_network_datapackage(args['data'])
 
     elif cmd == 'ConnectionRefused':
         errors = args["errors"]
         if 'InvalidSlot' in errors:
             ctx.event_invalid_slot()
-
-        elif 'SlotAlreadyTaken' in errors:
-            raise Exception('Player slot already in use for that team')
+        elif 'InvalidGame' in errors:
+            ctx.event_invalid_game()
         elif 'IncompatibleVersion' in errors:
             raise Exception('Server reported your client version as incompatible')
+        elif 'InvalidItemsHandling' in errors:
+            raise Exception('The item handling flags requested by the client are not supported')
         # last to check, recoverable problem
         elif 'InvalidPassword' in errors:
             logger.error('Invalid password')
             ctx.password = None
             await ctx.server_auth(True)
-        else:
+        elif errors:
             raise Exception("Unknown connection errors: " + str(errors))
-        raise Exception('Connection refused by the multiworld host, no reason provided')
+        else:
+            raise Exception('Connection refused by the multiworld host, no reason provided')
 
     elif cmd == 'Connected':
+        ctx.username = ctx.auth
         ctx.team = args["team"]
         ctx.slot = args["slot"]
+        # int keys get lost in JSON transfer
+        ctx.slot_info = {int(pid): data for pid, data in args["slot_info"].items()}
         ctx.consume_players_package(args["players"])
         msgs = []
         if ctx.locations_checked:
@@ -358,8 +626,8 @@ async def process_server_cmd(ctx: CommonContext, args: dict):
         # This list is used to only send to the server what is reported as ACTUALLY Missing.
         # This also serves to allow an easy visual of what locations were already checked previously
         # when /missing is used for the client side view of what is missing.
-        ctx.missing_locations = args["missing_locations"]
-        ctx.checked_locations = args["checked_locations"]
+        ctx.missing_locations = set(args["missing_locations"])
+        ctx.checked_locations = set(args["checked_locations"])
 
     elif cmd == 'ReceivedItems':
         start_index = args["index"]
@@ -378,9 +646,8 @@ async def process_server_cmd(ctx: CommonContext, args: dict):
         ctx.watcher_event.set()
 
     elif cmd == 'LocationInfo':
-        for item, location, player in args['locations']:
-            if location not in ctx.locations_info:
-                ctx.locations_info[location] = (item, player)
+        for item in [NetworkItem(*item) for item in args['locations']]:
+            ctx.locations_info[item.location] = item
         ctx.watcher_event.set()
 
     elif cmd == "RoomUpdate":
@@ -388,6 +655,12 @@ async def process_server_cmd(ctx: CommonContext, args: dict):
             ctx.consume_players_package(args["players"])
         if "hint_points" in args:
             ctx.hint_points = args['hint_points']
+        if "checked_locations" in args:
+            checked = set(args["checked_locations"])
+            ctx.checked_locations |= checked
+            ctx.missing_locations -= checked
+        if "permissions" in args:
+            ctx.update_permissions(args["permissions"])
 
     elif cmd == 'Print':
         ctx.on_print(args)
@@ -395,22 +668,33 @@ async def process_server_cmd(ctx: CommonContext, args: dict):
     elif cmd == 'PrintJSON':
         ctx.on_print_json(args)
 
-    elif cmd == 'InvalidArguments':
-        logger.warning(f"Invalid Arguments: {args['text']}")
+    elif cmd == 'InvalidPacket':
+        logger.warning(f"Invalid Packet of {args['type']}: {args['text']}")
 
+    elif cmd == "Bounced":
+        tags = args.get("tags", [])
+        # we can skip checking "DeathLink" in ctx.tags, as otherwise we wouldn't have been send this
+        if "DeathLink" in tags and ctx.last_death_link != args["data"]["time"]:
+            ctx.on_deathlink(args["data"])
+    elif cmd == "SetReply":
+        if args["key"] == "EnergyLink":
+            ctx.current_energy_link_value = args["value"]
+            if ctx.ui:
+                ctx.ui.set_new_energy_link_value()
     else:
         logger.debug(f"unknown command {cmd}")
 
+    ctx.on_package(cmd, args)
+
 
 async def console_loop(ctx: CommonContext):
-    import sys
     commandprocessor = ctx.command_processor(ctx)
+    queue = asyncio.Queue()
+    stream_input(sys.stdin, queue)
     while not ctx.exit_event.is_set():
         try:
-            input_text = await asyncio.get_event_loop().run_in_executor(
-                None, sys.stdin.readline
-            )
-            input_text = input_text.strip()
+            input_text = await queue.get()
+            queue.task_done()
 
             if ctx.input_requests > 0:
                 ctx.input_requests -= 1
@@ -420,4 +704,68 @@ async def console_loop(ctx: CommonContext):
             if input_text:
                 commandprocessor(input_text)
         except Exception as e:
-            logging.exception(e)
+            logger.exception(e)
+
+
+def get_base_parser(description=None):
+    import argparse
+    parser = argparse.ArgumentParser(description=description)
+    parser.add_argument('--connect', default=None, help='Address of the multiworld host.')
+    parser.add_argument('--password', default=None, help='Password of the multiworld host.')
+    if sys.stdout:  # If terminal output exists, offer gui-less mode
+        parser.add_argument('--nogui', default=False, action='store_true', help="Turns off Client GUI.")
+    return parser
+
+
+if __name__ == '__main__':
+    # Text Mode to use !hint and such with games that have no text entry
+
+    class TextContext(CommonContext):
+        tags = {"AP", "IgnoreGame", "TextOnly"}
+        game = ""  # empty matches any game since 0.3.2
+        items_handling = 0  # don't receive any NetworkItems
+
+        async def server_auth(self, password_requested: bool = False):
+            if password_requested and not self.password:
+                await super(TextContext, self).server_auth(password_requested)
+            await self.get_username()
+            await self.send_connect()
+
+        def on_package(self, cmd: str, args: dict):
+            if cmd == "Connected":
+                self.game = self.slot_info[self.slot].game
+
+
+    async def main(args):
+        ctx = TextContext(args.connect, args.password)
+        ctx.auth = args.name
+        ctx.server_address = args.connect
+        ctx.server_task = asyncio.create_task(server_loop(ctx), name="server loop")
+
+        if gui_enabled:
+            ctx.run_gui()
+        ctx.run_cli()
+
+        await ctx.exit_event.wait()
+        await ctx.shutdown()
+
+
+    import colorama
+
+    parser = get_base_parser(description="Gameless Archipelago Client, for text interfacing.")
+    parser.add_argument('--name', default=None, help="Slot Name to connect as.")
+    parser.add_argument("url", nargs="?", help="Archipelago connection url")
+    args = parser.parse_args()
+
+    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)
+
+    colorama.init()
+
+    asyncio.run(main(args))
+    colorama.deinit()

ER_hint_reference.txt

@@ -1,359 +0,0 @@
-Hint description:
-
-Hints will appear in the following ratios across the 15 telepathic tiles that have hints and the five storyteller locations:
-
-4 hints for inconvenient entrances.
-4 hints for random entrances (this can by coincidence pick inconvenient entrances that aren't used for the first set of hints).
-3 hints for inconvenient item locations.
-5 hints for valuable items.
-4 junk hints.
-
-In the vanilla, dungeonssimple, and dungeonsfull shuffles, the following ratios will be used instead:
-
-5 hints for inconvenient item locations.
-8 hints for valuable items.
-7 junk hints.
-
-In the simple, restricted, and restricted legacy shuffles, these are the ratios:
-
-2 hints for inconvenient entrances.
-1 hint for an inconvenient dungeon entrance.
-4 hints for random entrances (this can by coincidence pick inconvenient entrances that aren't used for the first set of hints).
-3 hints for inconvenient item locations.
-5 hints for valuable items.
-5 junk hints.
-
-These hints will use the following format:
-
-Entrance hints go "[Entrance on overworld] leads to [interior]".
-
-Inconvenient item locations are a little more custom but amount to "[Location] has [item name]". The item name is literal and will specify which dungeon the dungeon specific items hail from (small key/big key/map/compass).
-
-The valuable items are of the format "[item name] can be found [location]". The item name is again literal, and the location text is taken from Ganon's silver arrow hints. Note that the way it works is that every unique valuable item that exists is considered independently, and you won't get multiple hints for the EXACT same item (so you can only get one hint for Progressive Sword no matter how many swords exist in the seed, but if swords are not progressive, you could get hints for both Master Sword and Tempered Sword). More copies of an item existing does not increase the probability of getting a hint for that particular item (you are equally likely to get a hint for a Progressive Sword as for the Hammer). Unlike the IR, item names are never obfuscated by "something unique", and there is no special bias for hints for GT Big Key or Pegasus Boots.
-
-Hint Locations:
-
-Eastern Palace room before Big Chest
-Desert Palace bonk torch room
-Tower of Hera entrance room
-Tower of Hera Big Chest room
-Castle Tower after dark rooms
-Palace of Darkness before Bow section
-Swamp Palace entryway
-Thieves' Town upstairs
-Ice Palace entrance
-Ice Palace after first drop
-Ice Palace tall ice floor room
-Misery Mire cutscene room
-Turtle Rock entrance
-Spectacle Rock cave
-Spiky Hint cave
-PoD Bdlg NPC
-Near PoD Storyteller (bug near bomb wall)
-Dark Sanctuary Storyteller (long room with tables)
-Near Mire Storyteller (feather duster in winding cave)
-SE DW Storyteller (owl in winding cave)
-
-Inconvenient entrance list:
-
-Skull Woods Final
-Ice Palace
-Misery Mire
-Turtle Rock
-Ganon's Tower
-Mimic Ledge
-SW DM Foothills Cave (mirror from upper Bumper ledge)
-Hammer Pegs (near purple chest)
-Super Bomb cracked wall
-
-Inconvenient location list:
-
-Swamp left (two chests)
-Mire left (two chests)
-Hera basement
-Eastern Palace Big Key chest (protected by anti-fairies)
-Thieves' Town Big Chest
-Ice Palace Big Chest
-Ganon's Tower Big Chest
-Purple Chest
-Spike Cave
-Magic Bat
-Sahasrahla (Green Pendant)
-
-In the vanilla, dungeonssimple, and dungeonsfull shuffles, the following two locations are added to the inconvenient locations list:
-
-Graveyard Cave
-Mimic Cave
-
-Valuable Items are simply all items that are shown on the pause subscreen (Y, B, or A sections) minus Silver Arrows and plus Triforce Pieces, Magic Upgrades (1/2 or 1/4), and the Single Arrow. If key shuffle is being used, you can additionally get hints for Small Keys or Big Keys but not hints for Maps or Compasses.
-
-While the exact verbage of location names and item names can be found in the source code, here's a copy for reference:
-
-Overworld Entrance naming:
-
-Turtle Rock: Turtle Rock Main
-Misery Mire: Misery Mire
-Ice Palace: Ice Palace
-Skull Woods Final Section: The back of Skull Woods
-Death Mountain Return Cave (West): The SW DM Foothills Cave
-Mimic Cave: Mimic Ledge
-Dark World Hammer Peg Cave: The rows of pegs
-Pyramid Fairy: The crack on the pyramid
-Eastern Palace: Eastern Palace
-Elder House (East): Elder House
-Elder House (West): Elder House
-Two Brothers House (East): Eastern Quarreling Brothers' house
-Old Man Cave (West): The lower DM entrance
-Hyrule Castle Entrance (South): The ground level castle door
-Thieves Town: Thieves' Town
-Bumper Cave (Bottom): The lower Bumper Cave
-Swamp Palace: Swamp Palace
-Dark Death Mountain Ledge (West): The East dark DM connector ledge
-Dark Death Mountain Ledge (East): The East dark DM connector ledge
-Superbunny Cave (Top): The summit of dark DM cave
-Superbunny Cave (Bottom): The base of east dark DM
-Hookshot Cave: The rock on dark DM
-Desert Palace Entrance (South): The book sealed passage
-Tower of Hera: The Tower of Hera
-Two Brothers House (West): The door near the race game
-Old Man Cave (East): The SW-most cave on west DM
-Old Man House (Bottom): A cave with a door on west DM
-Old Man House (Top): The eastmost cave on west DM
-Death Mountain Return Cave (East): The westmost cave on west DM
-Spectacle Rock Cave Peak: The highest cave on west DM
-Spectacle Rock Cave: The right ledge on west DM
-Spectacle Rock Cave (Bottom): The left ledge on west DM
-Paradox Cave (Bottom): The right paired cave on east DM
-Paradox Cave (Middle): The southmost cave on east DM
-Paradox Cave (Top): The east DM summit cave
-Fairy Ascension Cave (Bottom): The east DM cave behind rocks
-Fairy Ascension Cave (Top): The central ledge on east DM
-Spiral Cave: The left ledge on east DM
-Spiral Cave (Bottom): The SWmost cave on east DM
-Palace of Darkness: Palace of Darkness
-Hyrule Castle Entrance (West): The left castle door
-Hyrule Castle Entrance (East): The right castle door
-Agahnims Tower: The sealed castle door
-Desert Palace Entrance (West): The westmost building in the desert
-Desert Palace Entrance (North): The northmost cave in the desert
-Blinds Hideout: Blind's old house
-Lake Hylia Fairy: A cave NE of Lake Hylia
-Light Hype Fairy: The cave south of your house
-Desert Fairy: The cave near the desert
-Chicken House: The chicken lady's house
-Aginahs Cave: The open desert cave
-Sahasrahlas Hut: The house near armos
-Cave Shop (Lake Hylia): The cave NW Lake Hylia
-Blacksmiths Hut: The old smithery
-Sick Kids House: The central house in Kakariko
-Lost Woods Gamble: A tree trunk door
-Fortune Teller (Light): A building NE of Kakariko
-Snitch Lady (East): A house guarded by a snitch
-Snitch Lady (West): A house guarded by a snitch
-Bush Covered House: A house with an uncut lawn
-Tavern (Front): A building with a backdoor
-Light World Bomb Hut: A Kakariko building with no door
-Kakariko Shop: The old Kakariko shop
-Mini Moldorm Cave: The cave south of Lake Hylia
-Long Fairy Cave: The eastmost portal cave
-Good Bee Cave: The open cave SE Lake Hylia
-20 Rupee Cave: The rock SE Lake Hylia
-50 Rupee Cave: The rock near the desert
-Ice Rod Cave: The sealed cave SE Lake Hylia
-Library: The old library
-Potion Shop: The witch's building
-Dam: The old dam
-Lumberjack House: The lumberjack house
-Lake Hylia Fortune Teller: The building NW Lake Hylia
-Kakariko Gamble Game: The old Kakariko gambling den
-Waterfall of Wishing: Going behind the waterfall
-Capacity Upgrade: The cave on the island
-Bonk Rock Cave: The rock pile near Sanctuary
-Graveyard Cave: The graveyard ledge
-Checkerboard Cave: The NE desert ledge
-Cave 45: The ledge south of haunted grove
-Kings Grave: The northeastmost grave
-Bonk Fairy (Light): The rock pile near your home
-Hookshot Fairy: A cave on east DM
-Bonk Fairy (Dark): The rock pile near the old bomb shop
-Dark Sanctuary Hint: The dark sanctuary cave
-Dark Lake Hylia Fairy: The cave NE dark Lake Hylia
-C-Shaped House: The NE house in Village of Outcasts
-Big Bomb Shop: The old bomb shop
-Dark Death Mountain Fairy: The SW cave on dark DM
-Dark Lake Hylia Shop: The building NW dark Lake Hylia
-Dark World Shop: The hammer sealed building
-Red Shield Shop: The fenced in building
-Mire Shed: The western hut in the mire
-East Dark World Hint: The dark cave near the eastmost portal
-Dark Desert Hint: The cave east of the mire
-Spike Cave: The ledge cave on west dark DM
-Palace of Darkness Hint: The building south of Kiki
-Dark Lake Hylia Ledge Spike Cave: The rock SE dark Lake Hylia
-Cave Shop (Dark Death Mountain): The base of east dark DM
-Dark World Potion Shop: The building near the catfish
-Archery Game: The old archery game
-Dark World Lumberjack Shop: The northmost Dark World building
-Hype Cave: The cave south of the old bomb shop
-Brewery: The Village of Outcasts building with no door
-Dark Lake Hylia Ledge Hint: The open cave SE dark Lake Hylia
-Chest Game: The westmost building in the Village of Outcasts
-Dark Desert Fairy: The eastern hut in the mire
-Dark Lake Hylia Ledge Fairy: The sealed cave SE dark Lake Hylia
-Fortune Teller (Dark): The building NE the Village of Outcasts
-Sanctuary: Sanctuary
-Lumberjack Tree Cave: The cave Behind Lumberjacks
-Lost Woods Hideout Stump: The stump in Lost Woods
-North Fairy Cave: The cave East of Graveyard
-Bat Cave Cave: The cave in eastern Kakariko
-Kakariko Well Cave: The cave in northern Kakariko
-Hyrule Castle Secret Entrance Stairs: The tunnel near the castle
-Skull Woods First Section Door: The southeastmost skull
-Skull Woods Second Section Door (East): The central open skull
-Skull Woods Second Section Door (West): The westmost open skull
-Desert Palace Entrance (East): The eastern building in the desert
-Turtle Rock Isolated Ledge Entrance: The isolated ledge on east dark DM
-Bumper Cave (Top): The upper Bumper Cave
-Hookshot Cave Back Entrance: The stairs on the floating island
-
-Destination Entrance Naming:
-
-Hyrule Castle: Hyrule Castle (all three entrances)
-Eastern Palace: Eastern Palace
-Desert Palace: Desert Palace (all four entrances, including final)
-Tower of Hera: Tower of Hera
-Palace of Darkness: Palace of Darkness
-Swamp Palace: Swamp Palace
-Skull Woods: Skull Woods (any entrance including final)
-Thieves' Town: Thieves' Town
-Ice Palace: Ice Palace
-Misery Mire: Misery Mire
-Turtle Rock: Turtle Rock (all four entrances)
-Ganon's Tower: Ganon's Tower
-Castle Tower: Agahnim's Tower
-A connector: Paradox Cave, Spectacle Rock Cave, Hookshot Cave, Superbunny Cave, Spiral Cave, Old Man Fetch Cave, Old Man House, Elder House, Quarreling Brothers' House, Bumper Cave, DM Fairy Ascent Cave, DM Exit Cave
-A bounty of five items: Mini-moldorm cave, Hype Cave, Blind's Hideout
-Sahasrahla: Sahasrahla
-A cave with two items: Mire hut, Waterfall Fairy, Pyramid Fairy
-A fairy fountain: Any healer fairy cave, either bonk cave with four fairies, the "long fairy" cave
-A common shop: Any shop that sells bombs by default
-The rare shop: The shop that sells the Red Shield by default
-The potion shop: Potion Shop
-The bomb shop: Bomb Shop
-A fortune teller: Any of the three fortune tellers
-A house with a chest: Chicken Lady's house, C-House, Brewery
-A cave with an item: Checkerboard cave, Hammer Pegs cave, Cave 45, Graveyard Ledge cave
-A cave with a chest: Sanc Bonk Rock Cave, Cape Grave Cave, Ice Rod Cave, Aginah's Cave
-The dam: Watergate
-The sick kid: Sick Kid
-The library: Library
-Mimic Cave: Mimic Cave
-Spike Cave: Spike Cave
-A game of 16 chests: VoO chest game (for the item)
-A storyteller: The four DW NPCs who charge 20 rupees for a hint as well as the PoD Bdlg guy who gives a free hint
-A cave with some cash: 20 rupee cave, 50 rupee cave (both have thieves and some pots)
-A game of chance: Gambling game (just for cash, no items)
-A game of skill: Archery minigame
-The queen of fairies: Capacity Upgrade Fairy
-A drop's exit: Sanctuary, LW Thieves' Hideout, Kakariko Well, Magic Bat, Useless Fairy, Uncle Tunnel, Ganon drop exit
-A restock room: The Kakariko bomb/arrow restock room
-The tavern: The Kakariko tavern
-The grass man: The Kakariko man with many beds
-A cold bee: The "wrong side" of Ice Rod cave where you can get a Good Bee
-Fairies deep in a cave: Hookshot Fairy
-
-Location naming reference:
-
-Mushroom: in the woods
-Master Sword Pedestal: at the pedestal
-Bottle Merchant: with a merchant
-Stumpy: with tree boy
-Flute Spot: underground
-Digging Game: underground
-Lake Hylia Island: on an island
-Floating Island: on an island
-Bumper Cave Ledge: on a ledge
-Spectacle Rock: atop a rock
-Maze Race: at the race
-Desert Ledge: in the desert
-Pyramid: on the pyramid
-Catfish: with a catfish
-Ether Tablet: at a monument
-Bombos Tablet: at a monument
-Hobo: with the hobo
-Zora's Ledge: near Zora
-King Zora: at a high price
-Sunken Treasure: underwater
-Floodgate Chest: in the dam
-Blacksmith: with the smith
-Purple Chest: from a box
-Old Man: with the old man
-Link's Uncle: with your uncle
-Secret Passage: near your uncle
-Kakariko Well (5 items): in a well
-Lost Woods Hideout: near a thief
-Lumberjack Tree: in a hole
-Magic Bat: with the bat
-Paradox Cave (7 items): in a cave with seven chests
-Blind's Hideout (5 items): in a basement
-Mini Moldorm Cave (5 items): near Moldorms
-Hype Cave (4 back chests): near a bat-like man
-Hype Cave - Generous Guy: with a bat-like man
-Hookshot Cave (4 items): across pits
-Sahasrahla's Hut (chests in back): near the elder
-Sahasrahla: with the elder
-Waterfall Fairy (2 items): near a fairy
-Pyramid Fairy (2 items): near a fairy
-Mire Shed (2 items): near sparks
-Superbunny Cave (2 items): in a connection
-Spiral Cave: in spiral cave
-Kakariko Tavern: in the bar
-Link's House: in your home
-Sick Kid: with the sick
-Library: near books
-Potion Shop: near potions
-Spike Cave: beyond spikes
-Mimic Cave: in a cave of mimicry
-Chest Game: as a prize
-Chicken House: near poultry
-Aginah's Cave: with Aginah
-Ice Rod Cave: in a frozen cave
-Brewery: alone in a home
-C-Shaped House: alone in a home
-Spectacle Rock Cave: alone in a cave
-King's Tomb: alone in a cave
-Cave 45: alone in a cave
-Graveyard Cave: alone in a cave
-Checkerboard Cave: alone in a cave
-Bonk Rock Cave: alone in a cave
-Peg Cave: alone in a cave
-Sanctuary: in Sanctuary
-Hyrule Castle - Boomerang Chest: in Hyrule Castle
-Hyrule Castle - Map Chest: in Hyrule Castle
-Hyrule Castle - Zelda's Chest: in Hyrule Castle
-Sewers - Dark Cross: in the sewers
-Sewers - Secret Room (3 items): in the sewers
-Eastern Palace - Boss: with the Armos
-Eastern Palace (otherwise, 5 items): in Eastern Palace
-Desert Palace - Boss: with Lanmolas
-Desert Palace (otherwise, 5 items): in Desert Palace
-Tower of Hera - Boss: with Moldorm
-Tower of Hera (otherwise, 5 items): in Tower of Hera
-Castle Tower (2 items): in Castle Tower
-Palace of Darkness - Boss: with Helmasaur King
-Palace of Darkness (otherwise, 13 items): in Palace of Darkness
-Swamp Palace - Boss: with Arrghus
-Swamp Palace (otherwise, 9 items): in Swamp Palace
-Skull Woods - Bridge Room: near Mothula
-Skull Woods - Boss: with Mothula
-Skull Woods (otherwise, 6 items): in Skull Woods
-Thieves' Town - Boss: with Blind
-Thieves' Town (otherwise, 7 items): in Thieves' Town
-Ice Palace - Boss: with Kholdstare
-Ice Palace (otherwise, 7 items): in Ice Palace
-Misery Mire - Boss: with Vitreous
-Misery Mire (otherwise, 7 items): in Misery Mire
-Turtle Rock - Boss: with Trinexx
-Turtle Rock (otherwise, 11 items): in Turtle Rock
-Ganons Tower (after climb, 4 items): atop Ganon's Tower
-Ganon's Tower (otherwise, 23 items): in Ganon's Tower

FF1Client.py

@@ -0,0 +1,269 @@
+import asyncio
+import json
+import time
+from asyncio import StreamReader, StreamWriter
+from typing import List
+
+
+import Utils
+from CommonClient import CommonContext, server_loop, gui_enabled, console_loop, ClientCommandProcessor, logger, \
+    get_base_parser
+
+SYSTEM_MESSAGE_ID = 0
+
+CONNECTION_TIMING_OUT_STATUS = "Connection timing out. Please restart your emulator, then restart ff1_connector.lua"
+CONNECTION_REFUSED_STATUS = "Connection Refused. Please start your emulator and make sure ff1_connector.lua is running"
+CONNECTION_RESET_STATUS = "Connection was reset. Please restart your emulator, then restart ff1_connector.lua"
+CONNECTION_TENTATIVE_STATUS = "Initial Connection Made"
+CONNECTION_CONNECTED_STATUS = "Connected"
+CONNECTION_INITIAL_STATUS = "Connection has not been initiated"
+
+DISPLAY_MSGS = True
+
+
+class FF1CommandProcessor(ClientCommandProcessor):
+    def __init__(self, ctx: CommonContext):
+        super().__init__(ctx)
+
+    def _cmd_nes(self):
+        """Check NES Connection State"""
+        if isinstance(self.ctx, FF1Context):
+            logger.info(f"NES Status: {self.ctx.nes_status}")
+
+    def _cmd_toggle_msgs(self):
+        """Toggle displaying messages in bizhawk"""
+        global DISPLAY_MSGS
+        DISPLAY_MSGS = not DISPLAY_MSGS
+        logger.info(f"Messages are now {'enabled' if DISPLAY_MSGS  else 'disabled'}")
+
+
+class FF1Context(CommonContext):
+    command_processor = FF1CommandProcessor
+    game = 'Final Fantasy'
+    items_handling = 0b111  # full remote
+
+    def __init__(self, server_address, password):
+        super().__init__(server_address, password)
+        self.nes_streams: (StreamReader, StreamWriter) = None
+        self.nes_sync_task = None
+        self.messages = {}
+        self.locations_array = None
+        self.nes_status = CONNECTION_INITIAL_STATUS
+        self.awaiting_rom = False
+        self.display_msgs = True
+
+    async def server_auth(self, password_requested: bool = False):
+        if password_requested and not self.password:
+            await super(FF1Context, self).server_auth(password_requested)
+        if not self.auth:
+            self.awaiting_rom = True
+            logger.info('Awaiting connection to NES to get Player information')
+            return
+
+        await self.send_connect()
+
+    def _set_message(self, msg: str, msg_id: int):
+        if DISPLAY_MSGS:
+            self.messages[(time.time(), msg_id)] = msg
+
+    def on_package(self, cmd: str, args: dict):
+        if cmd == 'Connected':
+            asyncio.create_task(parse_locations(self.locations_array, self, True))
+        elif cmd == 'Print':
+            msg = args['text']
+            if ': !' not in msg:
+                self._set_message(msg, SYSTEM_MESSAGE_ID)
+        elif cmd == "ReceivedItems":
+            msg = f"Received {', '.join([self.item_names[item.item] for item in args['items']])}"
+            self._set_message(msg, SYSTEM_MESSAGE_ID)
+        elif cmd == 'PrintJSON':
+            print_type = args['type']
+            item = args['item']
+            receiving_player_id = args['receiving']
+            receiving_player_name = self.player_names[receiving_player_id]
+            sending_player_id = item.player
+            sending_player_name = self.player_names[item.player]
+            if print_type == 'Hint':
+                msg = f"Hint: Your {self.item_names[item.item]} is at" \
+                      f" {self.player_names[item.player]}'s {self.location_names[item.location]}"
+                self._set_message(msg, item.item)
+            elif print_type == 'ItemSend' and receiving_player_id != self.slot:
+                if sending_player_id == self.slot:
+                    if receiving_player_id == self.slot:
+                        msg = f"You found your own {self.item_names[item.item]}"
+                    else:
+                        msg = f"You sent {self.item_names[item.item]} to {receiving_player_name}"
+                else:
+                    if receiving_player_id == sending_player_id:
+                        msg = f"{sending_player_name} found their {self.item_names[item.item]}"
+                    else:
+                        msg = f"{sending_player_name} sent {self.item_names[item.item]} to " \
+                              f"{receiving_player_name}"
+                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
+                        asyncio.create_task(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

@@ -4,40 +4,28 @@ import logging
 import json
 import string
 import copy
-import sys
-from concurrent.futures import ThreadPoolExecutor
+import subprocess
+import time
+import random
 
+import ModuleUpdate
+ModuleUpdate.update()
+
+import factorio_rcon
 import colorama
 import asyncio
 from queue import Queue
-from CommonClient import CommonContext, server_loop, console_loop, ClientCommandProcessor, logger
-from MultiServer import mark_raw
-
 import Utils
-import random
-from NetUtils import RawJSONtoTextParser, NetworkItem, ClientStatus, JSONtoTextParser, JSONMessagePart
 
-from worlds.factorio.Technologies import lookup_id_to_name
+if __name__ == "__main__":
+    Utils.init_logging("FactorioClient", exception_logger="Client")
 
-rcon_port = 24242
-rcon_password = ''.join(random.choice(string.ascii_letters) for x in range(32))
-save_name = "Archipelago"
+from CommonClient import CommonContext, server_loop, console_loop, ClientCommandProcessor, logger, gui_enabled, \
+    get_base_parser
+from MultiServer import mark_raw
+from NetUtils import NetworkItem, ClientStatus, JSONtoTextParser, JSONMessagePart
 
-logging.basicConfig(format='[%(name)s]: %(message)s', level=logging.INFO)
-options = Utils.get_options()
-executable = options["factorio_options"]["executable"]
-bin_dir = os.path.dirname(executable)
-if not os.path.isdir(bin_dir):
-    raise FileNotFoundError(bin_dir)
-if not os.path.exists(executable):
-    if os.path.exists(executable + ".exe"):
-        executable = executable + ".exe"
-    else:
-        raise FileNotFoundError(executable)
-
-server_args = (save_name, "--rcon-port", rcon_port, "--rcon-password", rcon_password, *sys.argv[1:])
-
-thread_pool = ThreadPoolExecutor(10)
+from worlds.factorio import Factorio
 
 
 class FactorioCommandProcessor(ClientCommandProcessor):
@@ -47,106 +35,185 @@ class FactorioCommandProcessor(ClientCommandProcessor):
     def _cmd_factorio(self, text: str) -> bool:
         """Send the following command to the bound Factorio Server."""
         if self.ctx.rcon_client:
+            # TODO: Print the command non-silently only for race seeds, or otherwise block anything but /factorio /save in race seeds.
+            self.ctx.print_to_game(f"/factorio {text}")
             result = self.ctx.rcon_client.send_command(text)
             if result:
                 self.output(result)
             return True
         return False
 
-    def _cmd_connect(self, address: str = "") -> bool:
-        """Connect to a MultiWorld Server"""
-        if not self.ctx.auth:
-            self.output("Cannot connect to a server with unknown own identity, bridge to Factorio first.")
-        return super(FactorioCommandProcessor, self)._cmd_connect(address)
+    def _cmd_resync(self):
+        """Manually trigger a resync."""
+        self.ctx.awaiting_bridge = True
 
 
 class FactorioContext(CommonContext):
     command_processor = FactorioCommandProcessor
+    game = "Factorio"
+    items_handling = 0b111  # full remote
 
-    def __init__(self, *args, **kwargs):
-        super(FactorioContext, self).__init__(*args, **kwargs)
-        self.send_index = 0
+    # updated by spinup server
+    mod_version: Utils.Version = Utils.Version(0, 0, 0)
+
+    def __init__(self, server_address, password):
+        super(FactorioContext, self).__init__(server_address, password)
+        self.send_index: int = 0
         self.rcon_client = None
         self.awaiting_bridge = False
-        self.raw_json_text_parser = RawJSONtoTextParser(self)
+        self.write_data_path = None
+        self.death_link_tick: int = 0  # last send death link on Factorio layer
         self.factorio_json_text_parser = FactorioJSONtoTextParser(self)
+        self.energy_link_increment = 0
+        self.last_deplete = 0
 
-    async def server_auth(self, password_requested):
+    async def server_auth(self, password_requested: bool = False):
         if password_requested and not self.password:
             await super(FactorioContext, self).server_auth(password_requested)
 
-        await self.send_msgs([{"cmd": 'Connect',
-                               'password': self.password, 'name': self.auth, 'version': Utils._version_tuple,
-                               'tags': ['AP'],
-                               'uuid': Utils.get_unique_identifier(), 'game': "Factorio"
-                               }])
+        if self.rcon_client:
+            await get_info(self, self.rcon_client)  # retrieve current auth code
+        else:
+            raise Exception("Cannot connect to a server with unknown own identity, "
+                            "bridge to Factorio first.")
+
+        await self.send_connect()
 
     def on_print(self, args: dict):
-        logger.info(args["text"])
+        super(FactorioContext, self).on_print(args)
         if self.rcon_client:
-            cleaned_text = args['text'].replace('"', '')
-            self.rcon_client.send_command(f"/sc game.print(\"[font=default-large-bold]Archipelago:[/font] "
-                                          f"{cleaned_text}\")")
+            self.print_to_game(args['text'])
 
     def on_print_json(self, args: dict):
-        if not self.found_items and args.get("type", None) == "ItemSend" and args["receiving"] == args["sending"]:
-            pass  # don't want info on other player's local pickups.
-        text = self.raw_json_text_parser(copy.deepcopy(args["data"]))
-        logger.info(text)
         if self.rcon_client:
-            text = self.factorio_json_text_parser(args["data"])
-            cleaned_text = text.replace('"', '')
-            self.rcon_client.send_command(f"/sc game.print(\"[font=default-large-bold]Archipelago:[/font] "
-                                          f"{cleaned_text}\")")
+            text = self.factorio_json_text_parser(copy.deepcopy(args["data"]))
+            self.print_to_game(text)
+        super(FactorioContext, self).on_print_json(args)
+
+    @property
+    def savegame_name(self) -> str:
+        return f"AP_{self.seed_name}_{self.auth}_Save.zip"
+
+    def print_to_game(self, text):
+        self.rcon_client.send_command(f"/ap-print [font=default-large-bold]Archipelago:[/font] "
+                                      f"{text}")
+
+    def on_deathlink(self, data: dict):
+        if self.rcon_client:
+            self.rcon_client.send_command(f"/ap-deathlink {data['source']}")
+        super(FactorioContext, self).on_deathlink(data)
+
+    def on_package(self, cmd: str, args: dict):
+        if cmd in {"Connected", "RoomUpdate"}:
+            # catch up sync anything that is already cleared.
+            if "checked_locations" in args and args["checked_locations"]:
+                self.rcon_client.send_commands({item_name: f'/ap-get-technology ap-{item_name}-\t-1' for
+                                                item_name in args["checked_locations"]})
+            if cmd == "Connected" and self.energy_link_increment:
+                asyncio.create_task(self.send_msgs([{
+                    "cmd": "SetNotify", "keys": ["EnergyLink"]
+                }]))
+        elif cmd == "SetReply":
+            if args["key"] == "EnergyLink":
+                if self.energy_link_increment and args.get("last_deplete", -1) == self.last_deplete:
+                    # it's our deplete request
+                    gained = int(args["original_value"] - args["value"])
+                    gained_text = Utils.format_SI_prefix(gained) + "J"
+                    if gained:
+                        logger.debug(f"EnergyLink: Received {gained_text}. "
+                                     f"{Utils.format_SI_prefix(args['value'])}J remaining.")
+                        self.rcon_client.send_command(f"/ap-energylink {gained}")
+
+    def run_gui(self):
+        from kvui import GameManager
+
+        class FactorioManager(GameManager):
+            logging_pairs = [
+                ("Client", "Archipelago"),
+                ("FactorioServer", "Factorio Server Log"),
+                ("FactorioWatcher", "Bridge Data Log"),
+            ]
+            base_title = "Archipelago Factorio Client"
+
+        self.ui = FactorioManager(self)
+        self.ui_task = asyncio.create_task(self.ui.async_run(), name="UI")
 
 
-async def game_watcher(ctx: FactorioContext, bridge_file: str):
+async def game_watcher(ctx: FactorioContext):
     bridge_logger = logging.getLogger("FactorioWatcher")
     from worlds.factorio.Technologies import lookup_id_to_name
-    bridge_counter = 0
+    next_bridge = time.perf_counter() + 1
     try:
         while not ctx.exit_event.is_set():
-            if os.path.exists(bridge_file):
-                bridge_logger.info("Found Factorio Bridge file.")
-                while not ctx.exit_event.is_set():
-                    if ctx.awaiting_bridge:
-                        ctx.awaiting_bridge = False
-                        with open(bridge_file) as f:
-                            data = json.load(f)
-                            research_data = data["research_done"]
-                            research_data = {int(tech_name.split("-")[1]) for tech_name in research_data}
-                            victory = data["victory"]
-                            ctx.auth = data["slot_name"]
-                            ctx.seed_name = data["seed_name"]
+            # TODO: restore on-demand refresh
+            if ctx.rcon_client and time.perf_counter() > next_bridge:
+                next_bridge = time.perf_counter() + 1
+                ctx.awaiting_bridge = False
+                data = json.loads(ctx.rcon_client.send_command("/ap-sync"))
+                if not ctx.auth:
+                    pass  # auth failed, wait for new attempt
+                elif data["slot_name"] != ctx.auth:
+                    bridge_logger.warning(f"Connected World is not the expected one {data['slot_name']} != {ctx.auth}")
+                elif data["seed_name"] != ctx.seed_name:
+                    bridge_logger.warning(
+                        f"Connected Multiworld is not the expected one {data['seed_name']} != {ctx.seed_name}")
+                else:
+                    data = data["info"]
+                    research_data = data["research_done"]
+                    research_data = {int(tech_name.split("-")[1]) for tech_name in research_data}
+                    victory = data["victory"]
+                    await ctx.update_death_link(data["death_link"])
 
-                        if not ctx.finished_game and victory:
-                            await ctx.send_msgs([{"cmd": "StatusUpdate", "status": ClientStatus.CLIENT_GOAL}])
-                            ctx.finished_game = True
+                    if not ctx.finished_game and victory:
+                        await ctx.send_msgs([{"cmd": "StatusUpdate", "status": ClientStatus.CLIENT_GOAL}])
+                        ctx.finished_game = True
+
+                    if ctx.locations_checked != research_data:
+                        bridge_logger.debug(
+                            f"New researches done: "
+                            f"{[lookup_id_to_name[rid] for rid in research_data - ctx.locations_checked]}")
+                        ctx.locations_checked = research_data
+                        await ctx.send_msgs([{"cmd": 'LocationChecks', "locations": tuple(research_data)}])
+                    death_link_tick = data.get("death_link_tick", 0)
+                    if death_link_tick != ctx.death_link_tick:
+                        ctx.death_link_tick = death_link_tick
+                        if "DeathLink" in ctx.tags:
+                            asyncio.create_task(ctx.send_death())
+                    if ctx.energy_link_increment:
+                        in_world_bridges = data["energy_bridges"]
+                        if in_world_bridges:
+                            in_world_energy = data["energy"]
+                            if in_world_energy < (ctx.energy_link_increment * in_world_bridges):
+                                # attempt to refill
+                                ctx.last_deplete = time.time()
+                                asyncio.create_task(ctx.send_msgs([{
+                                    "cmd": "Set", "key": "EnergyLink", "operations":
+                                        [{"operation": "add", "value": -ctx.energy_link_increment * in_world_bridges},
+                                         {"operation": "max", "value": 0}],
+                                    "last_deplete": ctx.last_deplete
+                                }]))
+                            # Above Capacity - (len(Bridges) * ENERGY_INCREMENT)
+                            elif in_world_energy > (in_world_bridges * ctx.energy_link_increment * 5) - \
+                                ctx.energy_link_increment*in_world_bridges:
+                                value = ctx.energy_link_increment * in_world_bridges
+                                asyncio.create_task(ctx.send_msgs([{
+                                    "cmd": "Set", "key": "EnergyLink", "operations":
+                                        [{"operation": "add", "value": value}]
+                                }]))
+                                ctx.rcon_client.send_command(
+                                    f"/ap-energylink -{value}")
+                                logger.debug(f"EnergyLink: Sent {Utils.format_SI_prefix(value)}J")
+
+            await asyncio.sleep(0.1)
 
-                        if ctx.locations_checked != research_data:
-                            bridge_logger.info(
-                                f"New researches done: "
-                                f"{[lookup_id_to_name[rid] for rid in research_data - ctx.locations_checked]}")
-                            ctx.locations_checked = research_data
-                            await ctx.send_msgs([{"cmd": 'LocationChecks', "locations": tuple(research_data)}])
-                    await asyncio.sleep(1)
-            else:
-                bridge_counter += 1
-                if bridge_counter >= 60:
-                    bridge_logger.info(
-                        "Did not find Factorio Bridge file, "
-                        "waiting for mod to run, which requires the server to run, "
-                        "which requires a player to be connected.")
-                    bridge_counter = 0
-                await asyncio.sleep(1)
     except Exception as e:
         logging.exception(e)
         logging.error("Aborted Factorio Server Bridge")
 
 
-def stream_factorio_output(pipe, queue):
+def stream_factorio_output(pipe, queue, process):
     def queuer():
-        while 1:
+        while process.poll() is None:
             text = pipe.readline().strip()
             if text:
                 queue.put_nowait(text)
@@ -155,114 +222,213 @@ def stream_factorio_output(pipe, queue):
 
     thread = Thread(target=queuer, name="Factorio Output Queue", daemon=True)
     thread.start()
+    return thread
 
 
 async def factorio_server_watcher(ctx: FactorioContext):
-    import subprocess
-    import factorio_rcon
-    factorio_server_logger = logging.getLogger("FactorioServer")
-    factorio_process = subprocess.Popen((executable, "--start-server", *(str(elem) for elem in server_args)),
+    savegame_name = os.path.abspath(ctx.savegame_name)
+    if not os.path.exists(savegame_name):
+        logger.info(f"Creating savegame {savegame_name}")
+        subprocess.run((
+            executable, "--create", savegame_name, "--preset", "archipelago"
+        ))
+    factorio_process = subprocess.Popen((executable, "--start-server", ctx.savegame_name,
+                                         *(str(elem) for elem in server_args)),
                                         stderr=subprocess.PIPE,
                                         stdout=subprocess.PIPE,
                                         stdin=subprocess.DEVNULL,
                                         encoding="utf-8")
     factorio_server_logger.info("Started Factorio Server")
     factorio_queue = Queue()
-    stream_factorio_output(factorio_process.stdout, factorio_queue)
-    stream_factorio_output(factorio_process.stderr, factorio_queue)
-    script_folder = None
-    progression_watcher = None
+    stream_factorio_output(factorio_process.stdout, factorio_queue, factorio_process)
+    stream_factorio_output(factorio_process.stderr, factorio_queue, factorio_process)
     try:
         while not ctx.exit_event.is_set():
+            if factorio_process.poll():
+                factorio_server_logger.info("Factorio server has exited.")
+                ctx.exit_event.set()
+
             while not factorio_queue.empty():
                 msg = factorio_queue.get()
-                factorio_server_logger.info(msg)
+                factorio_queue.task_done()
+
                 if not ctx.rcon_client and "Starting RCON interface at IP ADDR:" in msg:
                     ctx.rcon_client = factorio_rcon.RCONClient("localhost", rcon_port, rcon_password)
-                    # trigger lua interface confirmation
-                    ctx.rcon_client.send_command("/sc game.print('Starting Archipelago Bridge')")
-                    ctx.rcon_client.send_command("/sc game.print('Starting Archipelago Bridge')")
-                    ctx.rcon_client.send_command("/ap-sync")
-                if not script_folder and "Write data path:" in msg:
-                    script_folder = msg.split("Write data path: ", 1)[1].split("[", 1)[0].strip()
-                    bridge_file = os.path.join(script_folder, "script-output", "ap_bridge.json")
-                    if os.path.exists(bridge_file):
-                        os.remove(bridge_file)
-                    logging.info(f"Bridge File Path: {bridge_file}")
-                    progression_watcher = asyncio.create_task(
-                        game_watcher(ctx, bridge_file), name="FactorioProgressionWatcher")
-                if not ctx.awaiting_bridge and "Archipelago Bridge File written for game tick " in msg:
+                    if not ctx.server:
+                        logger.info("Established bridge to Factorio Server. "
+                                    "Ready to connect to Archipelago via /connect")
+
+                if not ctx.awaiting_bridge and "Archipelago Bridge Data available for game tick " in msg:
                     ctx.awaiting_bridge = True
+                    factorio_server_logger.debug(msg)
+                else:
+                    factorio_server_logger.info(msg)
             if ctx.rcon_client:
+                commands = {}
                 while ctx.send_index < len(ctx.items_received):
                     transfer_item: NetworkItem = ctx.items_received[ctx.send_index]
                     item_id = transfer_item.item
                     player_name = ctx.player_names[transfer_item.player]
-                    if item_id not in lookup_id_to_name:
-                        logging.error(f"Cannot send unknown item ID: {item_id}")
+                    if item_id not in Factorio.item_id_to_name:
+                        factorio_server_logger.error(f"Cannot send unknown item ID: {item_id}")
                     else:
-                        item_name = lookup_id_to_name[item_id]
+                        item_name = Factorio.item_id_to_name[item_id]
                         factorio_server_logger.info(f"Sending {item_name} to Nauvis from {player_name}.")
-                        ctx.rcon_client.send_command(f'/ap-get-technology {item_name} {player_name}')
+                        commands[ctx.send_index] = f'/ap-get-technology {item_name}\t{ctx.send_index}\t{player_name}'
                     ctx.send_index += 1
-            await asyncio.sleep(1)
+                if commands:
+                    ctx.rcon_client.send_commands(commands)
+            await asyncio.sleep(0.1)
 
     except Exception as e:
         logging.exception(e)
         logging.error("Aborted Factorio Server Bridge")
+        ctx.rcon_client = None
+        ctx.exit_event.set()
 
     finally:
         factorio_process.terminate()
-        if progression_watcher:
-            await progression_watcher
+        factorio_process.wait(5)
 
 
-async def main():
-    ctx = FactorioContext(None, None, True)
-    # testing shortcuts
-    # ctx.server_address = "localhost"
-    # ctx.auth = "Nauvis"
-    if ctx.server_task is None:
-        ctx.server_task = asyncio.create_task(server_loop(ctx), name="ServerLoop")
-    await asyncio.sleep(3)
-    input_task = asyncio.create_task(console_loop(ctx), name="Input")
-    factorio_server_task = asyncio.create_task(factorio_server_watcher(ctx), name="FactorioServer")
-    await ctx.exit_event.wait()
-    ctx.server_address = None
-    ctx.snes_reconnect_address = None
+async def get_info(ctx: FactorioContext, rcon_client: factorio_rcon.RCONClient):
+    info = json.loads(rcon_client.send_command("/ap-rcon-info"))
+    ctx.auth = info["slot_name"]
+    ctx.seed_name = info["seed_name"]
+    # 0.2.0 addition, not present earlier
+    death_link = bool(info.get("death_link", False))
+    ctx.energy_link_increment = info.get("energy_link", 0)
+    logger.debug(f"Energy Link Increment: {ctx.energy_link_increment}")
+    if ctx.energy_link_increment and ctx.ui:
+        ctx.ui.enable_energy_link()
+    await ctx.update_death_link(death_link)
 
-    await asyncio.gather(input_task, factorio_server_task)
 
-    if ctx.server is not None and not ctx.server.socket.closed:
-        await ctx.server.socket.close()
-    if ctx.server_task is not None:
-        await ctx.server_task
-    await factorio_server_task
+async def factorio_spinup_server(ctx: FactorioContext) -> bool:
+    savegame_name = os.path.abspath("Archipelago.zip")
+    if not os.path.exists(savegame_name):
+        logger.info(f"Creating savegame {savegame_name}")
+        subprocess.run((
+            executable, "--create", savegame_name
+        ))
+    factorio_process = subprocess.Popen(
+        (executable, "--start-server", savegame_name, *(str(elem) for elem in server_args)),
+        stderr=subprocess.PIPE,
+        stdout=subprocess.PIPE,
+        stdin=subprocess.DEVNULL,
+        encoding="utf-8")
+    factorio_server_logger.info("Started Information Exchange Factorio Server")
+    factorio_queue = Queue()
+    stream_factorio_output(factorio_process.stdout, factorio_queue, factorio_process)
+    stream_factorio_output(factorio_process.stderr, factorio_queue, factorio_process)
+    rcon_client = None
+    try:
+        while not ctx.auth:
+            while not factorio_queue.empty():
+                msg = factorio_queue.get()
+                factorio_server_logger.info(msg)
+                if "Loading mod AP-" in msg and msg.endswith("(data.lua)"):
+                    parts = msg.split()
+                    ctx.mod_version = Utils.Version(*(int(number) for number in parts[-2].split(".")))
+                elif "Write data path: " in msg:
+                    ctx.write_data_path = Utils.get_text_between(msg, "Write data path: ", " [")
+                    if "AppData" in ctx.write_data_path:
+                        logger.warning("It appears your mods are loaded from Appdata, "
+                                       "this can lead to problems with multiple Factorio instances. "
+                                       "If this is the case, you will get a file locked error running Factorio.")
+                if not rcon_client and "Starting RCON interface at IP ADDR:" in msg:
+                    rcon_client = factorio_rcon.RCONClient("localhost", rcon_port, rcon_password)
+                    if ctx.mod_version == ctx.__class__.mod_version:
+                        raise Exception("No Archipelago mod was loaded. Aborting.")
+                    await get_info(ctx, rcon_client)
+            await asyncio.sleep(0.01)
 
-    while ctx.input_requests > 0:
-        ctx.input_queue.put_nowait(None)
-        ctx.input_requests -= 1
+    except Exception as e:
+        logger.exception(e, extra={"compact_gui": True})
+        msg = "Aborted Factorio Server Bridge"
+        logger.error(msg)
+        ctx.gui_error(msg, e)
+        ctx.exit_event.set()
 
-    await input_task
+    else:
+        logger.info(
+            f"Got World Information from AP Mod {tuple(ctx.mod_version)} for seed {ctx.seed_name} in slot {ctx.auth}")
+        return True
+    finally:
+        factorio_process.terminate()
+        factorio_process.wait(5)
+    return False
+
+
+async def main(args):
+    ctx = FactorioContext(args.connect, args.password)
+    ctx.server_task = asyncio.create_task(server_loop(ctx), name="ServerLoop")
+
+    if gui_enabled:
+        ctx.run_gui()
+    ctx.run_cli()
+
+    factorio_server_task = asyncio.create_task(factorio_spinup_server(ctx), name="FactorioSpinupServer")
+    successful_launch = await factorio_server_task
+    if successful_launch:
+        factorio_server_task = asyncio.create_task(factorio_server_watcher(ctx), name="FactorioServer")
+        progression_watcher = asyncio.create_task(
+            game_watcher(ctx), name="FactorioProgressionWatcher")
+
+        await ctx.exit_event.wait()
+        ctx.server_address = None
+
+        await progression_watcher
+        await factorio_server_task
+
+    await ctx.shutdown()
 
 
 class FactorioJSONtoTextParser(JSONtoTextParser):
     def _handle_color(self, node: JSONMessagePart):
         colors = node["color"].split(";")
         for color in colors:
-            if color in {"red", "green", "blue", "orange", "yellow", "pink", "purple", "white", "black", "gray",
-                         "brown", "cyan", "acid"}:
-                node["text"] = f"[color={color}]{node['text']}[/color]"
-                return self._handle_text(node)
-            elif color == "magenta":
-                node["text"] = f"[color=pink]{node['text']}[/color]"
+            if color in self.color_codes:
+                node["text"] = f"[color=#{self.color_codes[color]}]{node['text']}[/color]"
             return self._handle_text(node)
         return self._handle_text(node)
 
 
 if __name__ == '__main__':
+    parser = get_base_parser(description="Optional arguments to FactorioClient follow. "
+                                         "Remaining arguments get passed into bound Factorio instance."
+                                         "Refer to Factorio --help for those.")
+    parser.add_argument('--rcon-port', default='24242', type=int, help='Port to use to communicate with Factorio')
+    parser.add_argument('--rcon-password', help='Password to authenticate with RCON.')
+    parser.add_argument('--server-settings', help='Factorio server settings configuration file.')
+
+    args, rest = parser.parse_known_args()
     colorama.init()
-    loop = asyncio.get_event_loop()
-    loop.run_until_complete(main())
-    loop.close()
+    rcon_port = args.rcon_port
+    rcon_password = args.rcon_password if args.rcon_password else ''.join(
+        random.choice(string.ascii_letters) for x in range(32))
+
+    factorio_server_logger = logging.getLogger("FactorioServer")
+    options = Utils.get_options()
+    executable = options["factorio_options"]["executable"]
+    server_settings = args.server_settings if args.server_settings else options["factorio_options"].get("server_settings", None)
+    if server_settings:
+        server_settings = os.path.abspath(server_settings)
+
+    if not os.path.exists(os.path.dirname(executable)):
+        raise FileNotFoundError(f"Path {os.path.dirname(executable)} does not exist or could not be accessed.")
+    if os.path.isdir(executable):  # user entered a path to a directory, let's find the executable therein
+        executable = os.path.join(executable, "factorio")
+    if not os.path.isfile(executable):
+        if os.path.isfile(executable + ".exe"):
+            executable = executable + ".exe"
+        else:
+            raise FileNotFoundError(f"Path {executable} is not an executable file.")
+
+    if server_settings and os.path.isfile(server_settings):
+        server_args = ("--rcon-port", rcon_port, "--rcon-password", rcon_password, "--server-settings", server_settings, *rest)
+    else:
+        server_args = ("--rcon-port", rcon_port, "--rcon-password", rcon_password, *rest)
+
+    asyncio.run(main(args))
     colorama.deinit()

FactorioClientGUI.py

@@ -1,167 +0,0 @@
-import os
-import logging
-import sys
-os.makedirs("logs", exist_ok=True)
-if getattr(sys, "frozen", False):
-    logging.basicConfig(format='[%(name)s]: %(message)s', level=logging.INFO,
-                        filename=os.path.join("logs", "FactorioClient.txt"), filemode="w")
-else:
-    logging.basicConfig(format='[%(name)s]: %(message)s', level=logging.INFO)
-    logging.getLogger().addHandler(logging.FileHandler(os.path.join("logs", "FactorioClient.txt"), "w"))
-os.environ["KIVY_NO_CONSOLELOG"] = "1"
-os.environ["KIVY_NO_FILELOG"] = "1"
-os.environ["KIVY_NO_ARGS"] = "1"
-
-import asyncio
-from CommonClient import server_loop, logger
-from FactorioClient import FactorioContext, factorio_server_watcher
-
-
-async def main():
-    ctx = FactorioContext(None, None, True)
-
-    ctx.server_task = asyncio.create_task(server_loop(ctx), name="ServerLoop")
-    factorio_server_task = asyncio.create_task(factorio_server_watcher(ctx), name="FactorioServer")
-    ui_app = FactorioManager(ctx)
-    ui_task = asyncio.create_task(ui_app.async_run(), name="UI")
-
-    await ctx.exit_event.wait()  # wait for signal to exit application
-    ui_app.stop()
-    ctx.server_address = None
-    ctx.snes_reconnect_address = None
-    # allow tasks to quit
-    await ui_task
-    await factorio_server_task
-    await ctx.server_task
-
-    if ctx.server is not None and not ctx.server.socket.closed:
-        await ctx.server.socket.close()
-    if ctx.server_task is not None:
-        await ctx.server_task
-
-    while ctx.input_requests > 0:  # clear queue for shutdown
-        ctx.input_queue.put_nowait(None)
-        ctx.input_requests -= 1
-
-
-from kivy.app import App
-from kivy.uix.label import Label
-from kivy.base import ExceptionHandler, ExceptionManager, Config
-from kivy.uix.gridlayout import GridLayout
-from kivy.uix.textinput import TextInput
-from kivy.uix.recycleview import RecycleView
-from kivy.uix.tabbedpanel import TabbedPanel, TabbedPanelItem
-from kivy.lang import Builder
-
-
-class FactorioManager(App):
-    def __init__(self, ctx):
-        super(FactorioManager, self).__init__()
-        self.ctx = ctx
-        self.commandprocessor = ctx.command_processor(ctx)
-        self.icon = "data/icon.png"
-
-    def build(self):
-        self.grid = GridLayout()
-        self.grid.cols = 1
-        self.tabs = TabbedPanel()
-        self.tabs.default_tab_text = "All"
-        self.title = "Archipelago Factorio Client"
-        pairs = [
-            ("Client", "Archipelago"),
-            ("FactorioServer", "Factorio Server Log"),
-            ("FactorioWatcher", "Bridge File Log"),
-        ]
-        self.tabs.default_tab_content = UILog(*(logging.getLogger(logger_name) for logger_name, name in pairs))
-        for logger_name, display_name in pairs:
-            bridge_logger = logging.getLogger(logger_name)
-            panel = TabbedPanelItem(text=display_name)
-            panel.content = UILog(bridge_logger)
-            self.tabs.add_widget(panel)
-
-        self.grid.add_widget(self.tabs)
-        textinput = TextInput(size_hint_y=None, height=30, multiline=False)
-        textinput.bind(on_text_validate=self.on_message)
-        self.grid.add_widget(textinput)
-        self.commandprocessor("/help")
-        return self.grid
-
-    def on_stop(self):
-        self.ctx.exit_event.set()
-
-    def on_message(self, textinput: TextInput):
-        try:
-            input_text = textinput.text.strip()
-            textinput.text = ""
-
-            if self.ctx.input_requests > 0:
-                self.ctx.input_requests -= 1
-                self.ctx.input_queue.put_nowait(input_text)
-            elif input_text:
-                self.commandprocessor(input_text)
-        except Exception as e:
-            logger.exception(e)
-
-
-class LogtoUI(logging.Handler):
-    def __init__(self, on_log):
-        super(LogtoUI, self).__init__(logging.DEBUG)
-        self.on_log = on_log
-
-    def handle(self, record: logging.LogRecord) -> None:
-        self.on_log(record)
-
-
-class UILog(RecycleView):
-    cols = 1
-
-    def __init__(self, *loggers_to_handle, **kwargs):
-        super(UILog, self).__init__(**kwargs)
-        self.data = []
-        for logger in loggers_to_handle:
-            logger.addHandler(LogtoUI(self.on_log))
-
-    def on_log(self, record: logging.LogRecord) -> None:
-        self.data.append({"text": record.getMessage()})
-
-
-class E(ExceptionHandler):
-    def handle_exception(self, inst):
-        logger.exception(inst)
-        return ExceptionManager.RAISE
-
-ExceptionManager.add_handler(E())
-
-
-Config.set("input", "mouse", "mouse,disable_multitouch")
-Builder.load_string('''
-<TabbedPanel>
-    tab_width: 200
-<Row@Label>:
-    canvas.before:
-        Color:
-            rgba: 0.2, 0.2, 0.2, 1
-        Rectangle:
-            size: self.size
-            pos: self.pos
-    text_size: self.width, None
-    size_hint_y: None
-    height: self.texture_size[1]
-    font_size: dp(20)
-<UILog>:
-    viewclass: 'Row'
-    scroll_y: 0
-    effect_cls: "ScrollEffect"
-    RecycleBoxLayout:
-        default_size: None, dp(20)
-        default_size_hint: 1, None
-        size_hint_y: None
-        height: self.minimum_height
-        orientation: 'vertical'
-        spacing: dp(3)
-''')
-
-if __name__ == '__main__':
-    loop = asyncio.get_event_loop()
-    loop.run_until_complete(main())
-    loop.close()

Fill.py

@@ -2,146 +2,206 @@ import logging
 import typing
 import collections
 import itertools
+from collections import Counter, deque
 
-from BaseClasses import CollectionState, PlandoItem, Location
-from worlds.alttp.Items import ItemFactory
-from worlds.alttp.Regions import key_drop_data
+from BaseClasses import CollectionState, Location, LocationProgressType, MultiWorld, Item
+
+from worlds.AutoWorld import call_all
 
 
 class FillError(RuntimeError):
     pass
 
 
-def fill_restrictive(world, base_state: CollectionState, locations, itempool, single_player_placement=False,
-                     lock=False):
-    def sweep_from_pool():
-        new_state = base_state.copy()
-        for item in itempool:
-            new_state.collect(item, True)
-        new_state.sweep_for_events()
-        return new_state
-
-    unplaced_items = []
-    placements = []
-
-    reachable_items = {}
+def sweep_from_pool(base_state: CollectionState, itempool: typing.Sequence[Item] = tuple()) -> CollectionState:
+    new_state = base_state.copy()
     for item in itempool:
-        reachable_items.setdefault(item.player, []).append(item)
+        new_state.collect(item, True)
+    new_state.sweep_for_events()
+    return new_state
+
+
+def fill_restrictive(world: MultiWorld, base_state: CollectionState, locations: typing.List[Location],
+                     itempool: typing.List[Item], single_player_placement: bool = False, lock: bool = False) -> None:
+    unplaced_items: typing.List[Item] = []
+    placements: typing.List[Location] = []
+
+    swapped_items: typing.Counter[typing.Tuple[int, str]] = Counter()
+    reachable_items: typing.Dict[int, typing.Deque[Item]] = {}
+    for item in itempool:
+        reachable_items.setdefault(item.player, deque()).append(item)
 
     while any(reachable_items.values()) and locations:
-        items_to_place = [items.pop() for items in reachable_items.values() if items]  # grab one item per player
+        # grab one item per player
+        items_to_place = [items.pop()
+                          for items in reachable_items.values() if items]
         for item in items_to_place:
             itempool.remove(item)
-        maximum_exploration_state = sweep_from_pool()
+        maximum_exploration_state = sweep_from_pool(
+            base_state, itempool + unplaced_items)
+
         has_beaten_game = world.has_beaten_game(maximum_exploration_state)
 
-        for item_to_place in items_to_place:
-            if world.accessibility[item_to_place.player] == 'none':
+        while items_to_place:
+            # if we have run out of locations to fill,break out of this loop
+            if not locations:
+                unplaced_items += items_to_place
+                break
+            item_to_place = items_to_place.pop(0)
+
+            spot_to_fill: typing.Optional[Location] = None
+
+            # if minimal accessibility, only check whether location is reachable if game not beatable
+            if world.accessibility[item_to_place.player] == 'minimal':
                 perform_access_check = not world.has_beaten_game(maximum_exploration_state,
-                                                                 item_to_place.player) if single_player_placement else not has_beaten_game
+                                                                 item_to_place.player) \
+                    if single_player_placement else not has_beaten_game
             else:
                 perform_access_check = True
 
             for i, location in enumerate(locations):
                 if (not single_player_placement or location.player == item_to_place.player) \
                         and location.can_fill(maximum_exploration_state, item_to_place, perform_access_check):
-                    spot_to_fill = locations.pop(i) # poping by index is faster than removing by content,
+                    # popping by index is faster than removing by content,
+                    spot_to_fill = locations.pop(i)
                     # skipping a scan for the element
                     break
 
             else:
-                # we filled all reachable spots. Maybe the game can be beaten anyway?
-                unplaced_items.append(item_to_place)
-                if world.accessibility[item_to_place.player] != 'none' and world.can_beat_game():
-                    logging.warning(
-                        f'Not all items placed. Game beatable anyway. (Could not place {item_to_place})')
-                    continue
+                # we filled all reachable spots.
+                # try swapping this item with previously placed items
+                for (i, location) in enumerate(placements):
+                    placed_item = location.item
+                    # Unplaceable items can sometimes be swapped infinitely. Limit the
+                    # number of times we will swap an individual item to prevent this
+                    swap_count = swapped_items[placed_item.player,
+                                               placed_item.name]
+                    if swap_count > 1:
+                        continue
 
-                raise FillError(f'No more spots to place {item_to_place}, locations {locations} are invalid. '
-                                f'Already placed {len(placements)}: {", ".join(str(place) for place in placements)}')
+                    location.item = None
+                    placed_item.location = None
+                    swap_state = sweep_from_pool(base_state)
+                    if (not single_player_placement or location.player == item_to_place.player) \
+                            and location.can_fill(swap_state, item_to_place, perform_access_check):
+
+                        # Verify that placing this item won't reduce available locations
+                        prev_state = swap_state.copy()
+                        prev_state.collect(placed_item)
+                        prev_loc_count = len(
+                            world.get_reachable_locations(prev_state))
+
+                        swap_state.collect(item_to_place, True)
+                        new_loc_count = len(
+                            world.get_reachable_locations(swap_state))
+
+                        if new_loc_count >= prev_loc_count:
+                            # 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
+                            swapped_items[placed_item.player,
+                                          placed_item.name] = swap_count
+
+                            reachable_items[placed_item.player].appendleft(
+                                placed_item)
+                            itempool.append(placed_item)
+
+                            break
+
+                    # Item can't be placed here, restore original item
+                    location.item = placed_item
+                    placed_item.location = location
+
+                if spot_to_fill is None:
+                    # Can't place this item, move on to the next
+                    unplaced_items.append(item_to_place)
+                    continue
 
             world.push_item(spot_to_fill, item_to_place, False)
             spot_to_fill.locked = lock
             placements.append(spot_to_fill)
-            spot_to_fill.event = True
+            spot_to_fill.event = item_to_place.advancement
+
+    if len(unplaced_items) > 0 and len(locations) > 0:
+        # There are leftover unplaceable items and locations that won't accept them
+        if world.can_beat_game():
+            logging.warning(
+                f'Not all items placed. Game beatable anyway. (Could not place {unplaced_items})')
+        else:
+            raise FillError(f'No more spots to place {unplaced_items}, locations {locations} are invalid. '
+                            f'Already placed {len(placements)}: {", ".join(str(place) for place in placements)}')
 
     itempool.extend(unplaced_items)
 
 
-def distribute_items_restrictive(world, gftower_trash=False, fill_locations=None):
-    # If not passed in, then get a shuffled list of locations to fill in
-    if not fill_locations:
-        fill_locations = world.get_unfilled_locations()
-        world.random.shuffle(fill_locations)
+def distribute_items_restrictive(world: MultiWorld) -> None:
+    fill_locations = sorted(world.get_unfilled_locations())
+    world.random.shuffle(fill_locations)
 
     # get items to distribute
-    world.random.shuffle(world.itempool)
-    progitempool = []
-    localrestitempool = {player: [] for player in range(1, world.players + 1)}
-    restitempool = []
+    itempool = sorted(world.itempool)
+    world.random.shuffle(itempool)
+    progitempool: typing.List[Item] = []
+    nonexcludeditempool: typing.List[Item] = []
+    localrestitempool: typing.Dict[int, typing.List[Item]] = {player: [] for player in range(1, world.players + 1)}
+    nonlocalrestitempool: typing.List[Item] = []
+    restitempool: typing.List[Item] = []
 
-    for item in world.itempool:
+    for item in itempool:
         if item.advancement:
             progitempool.append(item)
-        elif item.name in world.local_items[item.player]:
+        elif item.useful:  # this only gets nonprogression items which should not appear in excluded locations
+            nonexcludeditempool.append(item)
+        elif item.name in world.local_items[item.player].value:
             localrestitempool[item.player].append(item)
+        elif item.name in world.non_local_items[item.player].value:
+            nonlocalrestitempool.append(item)
         else:
             restitempool.append(item)
 
-    standard_keyshuffle_players = set()
+    call_all(world, "fill_hook", progitempool, nonexcludeditempool,
+             localrestitempool, nonlocalrestitempool, restitempool, fill_locations)
 
-    # fill in gtower locations with trash first
-    for player in world.alttp_player_ids:
-        if not gftower_trash or not world.ganonstower_vanilla[player] or \
-                world.logic[player] in {'owglitches', "nologic"}:
-            gtower_trash_count = 0
-        elif 'triforcehunt' in world.goal[player] and ('local' in world.goal[player] or world.players == 1):
-            gtower_trash_count = world.random.randint(world.crystals_needed_for_gt[player] * 2,
-                                                      world.crystals_needed_for_gt[player] * 4)
-        else:
-            gtower_trash_count = world.random.randint(0, world.crystals_needed_for_gt[player] * 2)
+    locations: typing.Dict[LocationProgressType, typing.List[Location]] = {
+        loc_type: [] for loc_type in LocationProgressType}
 
-        if gtower_trash_count:
-            gtower_locations = [location for location in fill_locations if
-                                'Ganons Tower' in location.name and location.player == player]
-            world.random.shuffle(gtower_locations)
-            trashcnt = 0
-            localrest = localrestitempool[player]
-            if localrest:
-                gt_item_pool = restitempool + localrest
-                world.random.shuffle(gt_item_pool)
-            else:
-                gt_item_pool = restitempool.copy()
+    for loc in fill_locations:
+        locations[loc.progress_type].append(loc)
 
-            while gtower_locations and gt_item_pool and trashcnt < gtower_trash_count:
-                spot_to_fill = gtower_locations.pop()
-                item_to_place = gt_item_pool.pop()
-                if item_to_place in localrest:
-                    localrest.remove(item_to_place)
-                else:
-                    restitempool.remove(item_to_place)
-                world.push_item(spot_to_fill, item_to_place, False)
-                fill_locations.remove(spot_to_fill)
-                trashcnt += 1
-        if world.mode[player] == 'standard' and world.keyshuffle[player] is True:
-            standard_keyshuffle_players.add(player)
+    prioritylocations = locations[LocationProgressType.PRIORITY]
+    defaultlocations = locations[LocationProgressType.DEFAULT]
+    excludedlocations = locations[LocationProgressType.EXCLUDED]
 
+    fill_restrictive(world, world.state, prioritylocations, progitempool, lock=True)
+    if prioritylocations:
+        defaultlocations = prioritylocations + defaultlocations
 
-    # Make sure the escape small key is placed first in standard with key shuffle to prevent running out of spots
-    if standard_keyshuffle_players:
-        progitempool.sort(
-            key=lambda item: 1 if item.name == 'Small Key (Hyrule Castle)' and
-                                  item.player in standard_keyshuffle_players else 0)
+    if progitempool:
+        fill_restrictive(world, world.state, defaultlocations, progitempool)
+        if progitempool:
+            raise FillError(
+                f'Not enough locations for progress items. There are {len(progitempool)} more items than locations')
 
-    world.random.shuffle(fill_locations)
-    fill_restrictive(world, world.state, fill_locations, progitempool)
+    if nonexcludeditempool:
+        world.random.shuffle(defaultlocations)
+        # needs logical fill to not conflict with local items
+        fill_restrictive(
+            world, world.state, defaultlocations, nonexcludeditempool)
+        if nonexcludeditempool:
+            raise FillError(
+                f'Not enough locations for non-excluded items. There are {len(nonexcludeditempool)} more items than locations')
+
+    defaultlocations = defaultlocations + excludedlocations
+    world.random.shuffle(defaultlocations)
 
     if any(localrestitempool.values()):  # we need to make sure some fills are limited to certain worlds
-        local_locations = {player: [] for player in world.player_ids}
-        for location in fill_locations:
+        local_locations: typing.Dict[int, typing.List[Location]] = {player: [] for player in world.player_ids}
+        for location in defaultlocations:
             local_locations[location.player].append(location)
-        for locations in local_locations.values():
-            world.random.shuffle(locations)
+        for player_locations in local_locations.values():
+            world.random.shuffle(player_locations)
 
         for player, items in localrestitempool.items():  # items already shuffled
             player_local_locations = local_locations[player]
@@ -152,29 +212,45 @@ def distribute_items_restrictive(world, gftower_trash=False, fill_locations=None
                     break
                 spot_to_fill = player_local_locations.pop()
                 world.push_item(spot_to_fill, item_to_place, False)
-                fill_locations.remove(spot_to_fill)
+                defaultlocations.remove(spot_to_fill)
 
-    world.random.shuffle(fill_locations)
+    for item_to_place in nonlocalrestitempool:
+        for i, location in enumerate(defaultlocations):
+            if location.player != item_to_place.player:
+                world.push_item(defaultlocations.pop(i), item_to_place, False)
+                break
+        else:
+            logging.warning(
+                f"Could not place non_local_item {item_to_place} among {defaultlocations}, tossing.")
 
-    restitempool, fill_locations = fast_fill(world, restitempool, fill_locations)
-    unplaced = [item for item in progitempool + restitempool]
-    unfilled = [location.name for location in fill_locations]
+    world.random.shuffle(defaultlocations)
 
-    for location in fill_locations:
-        world.push_item(location, ItemFactory('Nothing', location.player), False)
+    restitempool, defaultlocations = fast_fill(
+        world, restitempool, defaultlocations)
+    unplaced = progitempool + restitempool
+    unfilled = defaultlocations
 
     if unplaced or unfilled:
-        logging.warning(f'Unplaced items({len(unplaced)}): {unplaced} - Unfilled Locations({len(unfilled)}): {unfilled}')
+        logging.warning(
+            f'Unplaced items({len(unplaced)}): {unplaced} - Unfilled Locations({len(unfilled)}): {unfilled}')
+        items_counter = Counter(location.item.player for location in world.get_locations() if location.item)
+        locations_counter = Counter(location.player for location in world.get_locations())
+        items_counter.update(item.player for item in unplaced)
+        locations_counter.update(location.player for location in unfilled)
+        print_data = {"items": items_counter, "locations": locations_counter}
+        logging.info(f'Per-Player counts: {print_data})')
 
 
-def fast_fill(world, item_pool: typing.List, fill_locations: typing.List) -> typing.Tuple[typing.List, typing.List]:
+def fast_fill(world: MultiWorld,
+              item_pool: typing.List[Item],
+              fill_locations: typing.List[Location]) -> typing.Tuple[typing.List[Item], typing.List[Location]]:
     placing = min(len(item_pool), len(fill_locations))
     for item, location in zip(item_pool, fill_locations):
         world.push_item(location, item, False)
     return item_pool[placing:], fill_locations[placing:]
 
 
-def flood_items(world):
+def flood_items(world: MultiWorld) -> None:
     # get items to distribute
     world.random.shuffle(world.itempool)
     itempool = world.itempool
@@ -213,7 +289,8 @@ def flood_items(world):
                     item_to_place = item
                     break
 
-        # we might be in a situation where all new locations require multiple items to reach. If that is the case, just place any advancement item we've found and continue trying
+        # we might be in a situation where all new locations require multiple items to reach.
+        # If that is the case, just place any advancement item we've found and continue trying
         if item_to_place is None:
             if candidate_item_to_place is not None:
                 item_to_place = candidate_item_to_place
@@ -224,7 +301,7 @@ def flood_items(world):
         location_list = world.get_reachable_locations()
         world.random.shuffle(location_list)
         for location in location_list:
-            if location.item is not None and not location.item.advancement and not location.item.smallkey and not location.item.bigkey:
+            if location.item is not None and not location.item.advancement:
                 # safe to replace
                 replace_item = location.item
                 replace_item.location = None
@@ -234,68 +311,135 @@ def flood_items(world):
                 break
 
 
-def balance_multiworld_progression(world):
-    balanceable_players = {player for player in range(1, world.players + 1) if world.progression_balancing[player]}
+def balance_multiworld_progression(world: MultiWorld) -> None:
+    # A system to reduce situations where players have no checks remaining, popularly known as "BK mode."
+    # Overall progression balancing algorithm:
+    # Gather up all locations in a sphere.
+    # Define a threshold value based on the player with the most available locations.
+    # If other players are below the threshold value, swap progression in this sphere into earlier spheres,
+    #   which gives more locations available by this sphere.
+    balanceable_players: typing.Dict[int, float] = {
+        player: world.progression_balancing[player] / 100
+        for player in world.player_ids
+        if world.progression_balancing[player] > 0
+    }
     if not balanceable_players:
         logging.info('Skipping multiworld progression balancing.')
     else:
         logging.info(f'Balancing multiworld progression for {len(balanceable_players)} Players.')
-        state = CollectionState(world)
-        checked_locations = set()
-        unchecked_locations = set(world.get_locations())
+        logging.debug(balanceable_players)
+        state: CollectionState = CollectionState(world)
+        checked_locations: typing.Set[Location] = set()
+        unchecked_locations: typing.Set[Location] = set(world.get_locations())
 
-        reachable_locations_count = {player: 0 for player in world.player_ids}
+        reachable_locations_count: typing.Dict[int, int] = {
+            player: 0
+            for player in world.player_ids
+            if len(world.get_filled_locations(player)) != 0
+        }
+        total_locations_count: typing.Counter[int] = Counter(
+            location.player
+            for location in world.get_locations()
+            if not location.locked
+        )
+        balanceable_players = {
+            player: balanceable_players[player]
+            for player in balanceable_players
+            if total_locations_count[player]
+        }
+        sphere_num: int = 1
+        moved_item_count: int = 0
 
-        def get_sphere_locations(sphere_state, locations):
+        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:
+            return num / total_locations_count[player]
+
         while True:
+            # Gather non-locked locations.
+            # This ensures that only shuffled locations get counted for progression balancing,
+            #   i.e. the items the players will be checking.
             sphere_locations = get_sphere_locations(state, unchecked_locations)
             for location in sphere_locations:
                 unchecked_locations.remove(location)
-                reachable_locations_count[location.player] += 1
+                if not location.locked:
+                    reachable_locations_count[location.player] += 1
+
+            logging.debug(f"Sphere {sphere_num}")
+            logging.debug(f"Reachable locations: {reachable_locations_count}")
+            debug_percentages = {
+                player: round(item_percentage(player, num), 2)
+                for player, num in reachable_locations_count.items()
+            }
+            logging.debug(f"Reachable percentages: {debug_percentages}\n")
+            sphere_num += 1
 
             if checked_locations:
-                threshold = max(reachable_locations_count.values()) - 20
-                balancing_players = {player for player, reachables in reachable_locations_count.items() if
-                                     reachables < threshold and player in balanceable_players}
+                max_percentage = max(map(lambda p: item_percentage(p, reachable_locations_count[p]),
+                                         reachable_locations_count))
+                threshold_percentages = {
+                    player: max_percentage * balanceable_players[player]
+                    for player in balanceable_players
+                }
+                logging.debug(f"Thresholds: {threshold_percentages}")
+                balancing_players = {
+                    player
+                    for player, reachables in reachable_locations_count.items()
+                    if (player in threshold_percentages
+                        and item_percentage(player, reachables) < threshold_percentages[player])
+                }
                 if balancing_players:
                     balancing_state = state.copy()
                     balancing_unchecked_locations = unchecked_locations.copy()
                     balancing_reachables = reachable_locations_count.copy()
                     balancing_sphere = sphere_locations.copy()
-                    candidate_items = collections.defaultdict(set)
+                    candidate_items: typing.Dict[int, typing.Set[Location]] = collections.defaultdict(set)
                     while True:
+                        # Check locations in the current sphere and gather progression items to swap earlier
                         for location in balancing_sphere:
                             if location.event:
                                 balancing_state.collect(location.item, True, location)
                                 player = location.item.player
                                 # only replace items that end up in another player's world
-                                if not location.locked and player in balancing_players and location.player != player:
+                                if (not location.locked and not location.item.skip_in_prog_balancing and
+                                        player in balancing_players and
+                                        location.player != player and
+                                        location.progress_type != LocationProgressType.PRIORITY):
                                     candidate_items[player].add(location)
+                                    logging.debug(f"Candidate item: {location.name}, {location.item.name}")
                         balancing_sphere = get_sphere_locations(balancing_state, balancing_unchecked_locations)
                         for location in balancing_sphere:
                             balancing_unchecked_locations.remove(location)
-                            balancing_reachables[location.player] += 1
+                            if not location.locked:
+                                balancing_reachables[location.player] += 1
                         if world.has_beaten_game(balancing_state) or all(
-                                reachables >= threshold for reachables in balancing_reachables.values()):
+                                item_percentage(player, reachables) >= threshold_percentages[player]
+                                for player, reachables in balancing_reachables.items()
+                                if player in threshold_percentages):
                             break
                         elif not balancing_sphere:
                             raise RuntimeError('Not all required items reachable. Something went terribly wrong here.')
-                    unlocked_locations = collections.defaultdict(set)
+                    # 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:
                         if l not in balancing_unchecked_locations:
                             unlocked_locations[l.player].add(l)
-                    items_to_replace = []
+                    items_to_replace: typing.List[Location] = []
                     for player in balancing_players:
                         locations_to_test = unlocked_locations[player]
-                        items_to_test = candidate_items[player]
+                        items_to_test = list(candidate_items[player])
+                        items_to_test.sort()
+                        world.random.shuffle(items_to_test)
                         while items_to_test:
                             testing = items_to_test.pop()
                             reducing_state = state.copy()
-                            for location in itertools.chain((l for l in items_to_replace if l.item.player == player),
-                                                            items_to_test):
+                            for location in itertools.chain((
+                                l for l in items_to_replace
+                                if l.item.player == player
+                            ), items_to_test):
                                 reducing_state.collect(location.item, True, location)
 
                             reducing_state.sweep_for_events(locations=locations_to_test)
@@ -305,7 +449,8 @@ def balance_multiworld_progression(world):
                                     items_to_replace.append(testing)
                             else:
                                 reduced_sphere = get_sphere_locations(reducing_state, locations_to_test)
-                                if reachable_locations_count[player] + len(reduced_sphere) < threshold:
+                                p = item_percentage(player, reachable_locations_count[player] + len(reduced_sphere))
+                                if p < threshold_percentages[player]:
                                     items_to_replace.append(testing)
 
                     replaced_items = False
@@ -317,6 +462,7 @@ def balance_multiworld_progression(world):
                     items_to_replace.sort()
                     world.random.shuffle(items_to_replace)
 
+                    # Start swapping items. Since we swap into earlier spheres, no need for accessibility checks. 
                     while replacement_locations and items_to_replace:
                         old_location = items_to_replace.pop()
                         for new_location in replacement_locations:
@@ -326,6 +472,7 @@ def balance_multiworld_progression(world):
                                 swap_location_item(old_location, new_location)
                                 logging.debug(f"Progression balancing moved {new_location.item} to {new_location}, "
                                               f"displacing {old_location.item} into {old_location}")
+                                moved_item_count += 1
                                 state.collect(new_location.item, True, new_location)
                                 replaced_items = True
                                 break
@@ -333,10 +480,12 @@ def balance_multiworld_progression(world):
                             logging.warning(f"Could not Progression Balance {old_location.item}")
 
                     if replaced_items:
+                        logging.debug(f"Moved {moved_item_count} items so far\n")
                         unlocked = {fresh for player in balancing_players for fresh in unlocked_locations[player]}
                         for location in get_sphere_locations(state, unlocked):
                             unchecked_locations.remove(location)
-                            reachable_locations_count[location.player] += 1
+                            if not location.locked:
+                                reachable_locations_count[location.player] += 1
                             sphere_locations.add(location)
 
             for location in sphere_locations:
@@ -347,10 +496,11 @@ def balance_multiworld_progression(world):
             if world.has_beaten_game(state):
                 break
             elif not sphere_locations:
-                raise RuntimeError('Not all required items reachable. Something went terribly wrong here.')
+                logging.warning("Progression Balancing ran out of paths.")
+                break
 
 
-def swap_location_item(location_1: Location, location_2: Location, check_locked=True):
+def swap_location_item(location_1: Location, location_2: Location, check_locked: bool = True) -> None:
     """Swaps Items of locations. Does NOT swap flags like shop_slot or locked, but does swap event"""
     if check_locked:
         if location_1.locked:
@@ -363,73 +513,186 @@ def swap_location_item(location_1: Location, location_2: Location, check_locked=
     location_1.event, location_2.event = location_2.event, location_1.event
 
 
-def distribute_planned(world):
+def distribute_planned(world: MultiWorld) -> None:
+    def warn(warning: str, force: typing.Union[bool, str]) -> None:
+        if force in [True, 'fail', 'failure', 'none', False, 'warn', 'warning']:
+            logging.warning(f'{warning}')
+        else:
+            logging.debug(f'{warning}')
+
+    def failed(warning: str, force: typing.Union[bool, str]) -> None:
+        if force in [True, 'fail', 'failure']:
+            raise Exception(warning)
+        else:
+            warn(warning, force)
+
+    # TODO: remove. Preferably by implementing key drop
+    from worlds.alttp.Regions import key_drop_data
     world_name_lookup = world.world_name_lookup
 
-    for player in world.player_ids:
-        placement: PlandoItem
-        for placement in world.plando_items[player]:
-            if placement.location in key_drop_data:
-                placement.warn(
-                    f"Can't place '{placement.item}' at '{placement.location}', as key drop shuffle locations are not supported yet.")
+    block_value = typing.Union[typing.List[str], typing.Dict[str, typing.Any], str]
+    plando_blocks: typing.List[typing.Dict[str, typing.Any]] = []
+    player_ids = set(world.player_ids)
+    for player in player_ids:
+        for block in world.plando_items[player]:
+            block['player'] = player
+            if 'force' not in block:
+                block['force'] = 'silent'
+            if 'from_pool' not in block:
+                block['from_pool'] = True
+            if 'world' not in block:
+                block['world'] = False
+            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
-            item = ItemFactory(placement.item, player)
-            target_world: int = placement.world
-            if target_world is False or world.players == 1:
-                target_world = player  # in own world
-            elif target_world is True:  # in any other world
-                unfilled = list(location for location in world.get_unfilled_locations_for_players(
-                    placement.location,
-                    set(world.player_ids) - {player}) if location.item_rule(item)
-                                )
-                if not unfilled:
-                    placement.failed(f"Could not find a world with an unfilled location {placement.location}",
-                                     FillError)
-                    continue
+            if isinstance(items, dict):
+                item_list: typing.List[str] = []
+                for key, value in items.items():
+                    if value is True:
+                        value = world.itempool.count(world.worlds[player].create_item(key))
+                    item_list += [key] * value
+                items = item_list
+            if isinstance(items, str):
+                items = [items]
+            block['items'] = items
 
-                target_world = world.random.choice(unfilled).player
+            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]
 
-            elif target_world is None:  # any random world
-                unfilled = list(location for location in world.get_unfilled_locations_for_players(
-                    placement.location,
-                    set(world.player_ids)) if location.item_rule(item)
-                                )
-                if not unfilled:
-                    placement.failed(f"Could not find a world with an unfilled location {placement.location}",
-                                     FillError)
-                    continue
+            if isinstance(locations, dict):
+                location_list = []
+                for key, value in locations.items():
+                    location_list += [key] * value
+                locations = location_list
+            block['locations'] = locations
 
-                target_world = world.random.choice(unfilled).player
+            if not block['count']:
+                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'] = world.random.randint(block['count']['min'], block['count']['max'])
 
-            elif type(target_world) == int:  # target world by player id
+            if block['count']['target'] > 0:
+                plando_blocks.append(block)
+
+    # shuffle, but then sort blocks by number of locations minus number of items,
+    # so less-flexible blocks get priority
+    world.random.shuffle(plando_blocks)
+    plando_blocks.sort(key=lambda block: (len(block['locations']) - block['count']['target']
+                                          if len(block['locations']) > 0
+                                          else len(world.get_unfilled_locations(player)) - block['count']['target']))
+
+    for placement in plando_blocks:
+        player = placement['player']
+        try:
+            target_world = placement['world']
+            locations = placement['locations']
+            items = placement['items']
+            maxcount = placement['count']['target']
+            from_pool = placement['from_pool']
+            if target_world is False or world.players == 1:  # target own world
+                worlds: typing.Set[int] = {player}
+            elif target_world is True:  # target any worlds besides own
+                worlds = set(world.player_ids) - {player}
+            elif target_world is None:  # target all worlds
+                worlds = set(world.player_ids)
+            elif type(target_world) == list:  # list of target worlds
+                worlds = set()
+                for listed_world in target_world:
+                    if listed_world not in world_name_lookup:
+                        failed(f"Cannot place item to {target_world}'s world as that world does not exist.",
+                               placement['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, world.players + 1):
-                    placement.failed(
+                    failed(
                         f"Cannot place item in world {target_world} as it is not in range of (1, {world.players})",
-                        ValueError)
+                        placement['force'])
                     continue
-            else:  # find world by name
+                worlds = {target_world}
+            else:  # target world by slot name
                 if target_world not in world_name_lookup:
-                    placement.failed(f"Cannot place item to {target_world}'s world as that world does not exist.",
-                                     ValueError)
+                    failed(f"Cannot place item to {target_world}'s world as that world does not exist.",
+                           placement['force'])
                     continue
-                target_world = world_name_lookup[target_world]
+                worlds = {world_name_lookup[target_world]}
 
-            location = world.get_location(placement.location, target_world)
-            if location.item:
-                placement.failed(f"Cannot place item into already filled location {location}.")
-                continue
-
-            if location.can_fill(world.state, item, False):
+            candidates = list(location for location in world.get_unfilled_locations_for_players(locations,
+                                                                                                worlds))
+            world.random.shuffle(candidates)
+            world.random.shuffle(items)
+            count = 0
+            err: typing.List[str] = []
+            successful_pairs: typing.List[typing.Tuple[Item, Location]] = []
+            for item_name in items:
+                item = world.worlds[player].create_item(item_name)
+                for location in reversed(candidates):
+                    if location in key_drop_data:
+                        warn(
+                            f"Can't place '{item_name}' at '{placement.location}', as key drop shuffle locations are not supported yet.")
+                        continue
+                    if not location.item:
+                        if location.item_rule(item):
+                            if location.can_fill(world.state, item, False):
+                                successful_pairs.append((item, location))
+                                candidates.remove(location)
+                                count = count + 1
+                                break
+                            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}.")
+                if count == maxcount:
+                    break
+            if count < placement['count']['min']:
+                m = placement['count']['min']
+                failed(
+                    f"Plando block failed to place {m - count} of {m} item(s) for {world.player_name[player]}, error(s): {' '.join(err)}",
+                    placement['force'])
+            for (item, location) in successful_pairs:
                 world.push_item(location, item, collect=False)
                 location.event = True  # flag location to be checked during fill
                 location.locked = True
                 logging.debug(f"Plando placed {item} at {location}")
-            else:
-                placement.failed(f"Can't place {item} at {location} due to fill condition not met.")
-                continue
+                if from_pool:
+                    try:
+                        world.itempool.remove(item)
+                    except ValueError:
+                        warn(
+                            f"Could not remove {item} from pool for {world.player_name[player]} as it's already missing from it.",
+                            placement['force'])
 
-            if placement.from_pool:  # Should happen AFTER the item is placed, in case it was allowed to skip failed placement.
-                try:
-                    world.itempool.remove(item)
-                except ValueError:
-                    placement.warn(f"Could not remove {item} from pool as it's already missing from it.")
+        except Exception as e:
+            raise Exception(
+                f"Error running plando for player {player} ({world.player_name[player]})") from e

Generate.py

@@ -0,0 +1,713 @@
+from __future__ import annotations
+
+import argparse
+import logging
+import random
+import urllib.request
+import urllib.parse
+from typing import Set, Dict, Tuple, Callable, Any, Union
+import os
+from collections import Counter
+import string
+import enum
+
+import ModuleUpdate
+
+ModuleUpdate.update()
+
+import Utils
+from worlds.alttp import Options as LttPOptions
+from worlds.generic import PlandoConnection
+from Utils import parse_yamls, version_tuple, __version__, tuplize_version, get_options, local_path, user_path
+from worlds.alttp.EntranceRandomizer import parse_arguments
+from Main import main as ERmain
+from BaseClasses import seeddigits, get_seed
+import Options
+from worlds.alttp import Bosses
+from worlds.alttp.Text import TextTable
+from worlds.AutoWorld import AutoWorldRegister
+import copy
+
+
+class PlandoSettings(enum.IntFlag):
+    items = 0b0001
+    connections = 0b0010
+    texts = 0b0100
+    bosses = 0b1000
+
+    @classmethod
+    def from_option_string(cls, option_string: str) -> PlandoSettings:
+        result = cls(0)
+        for part in option_string.split(","):
+            part = part.strip().lower()
+            if part:
+                result = cls._handle_part(part, result)
+        return result
+
+    @classmethod
+    def from_set(cls, option_set: Set[str]) -> PlandoSettings:
+        result = cls(0)
+        for part in option_set:
+            result = cls._handle_part(part, result)
+        return result
+
+    @classmethod
+    def _handle_part(cls, part: str, base: PlandoSettings) -> PlandoSettings:
+        try:
+            part = cls[part]
+        except Exception as e:
+            raise KeyError(f"{part} is not a recognized name for a plando module. "
+                           f"Known options: {', '.join(flag.name for flag in cls)}") from e
+        else:
+            return base | part
+
+    def __str__(self) -> str:
+        if self.value:
+            return ", ".join((flag.name for flag in PlandoSettings if self.value & flag.value))
+        return "Off"
+
+
+def mystery_argparse():
+    options = get_options()
+    defaults = options["generator"]
+
+    def resolve_path(path: str, resolver: Callable[[str], str]) -> str:
+        return path if os.path.isabs(path) else resolver(path)
+
+    parser = argparse.ArgumentParser(description="CMD Generation Interface, defaults come from host.yaml.")
+    parser.add_argument('--weights_file_path', default=defaults["weights_file_path"],
+                        help='Path to the weights file to use for rolling game settings, urls are also valid')
+    parser.add_argument('--samesettings', help='Rolls settings per weights file rather than per player',
+                        action='store_true')
+    parser.add_argument('--player_files_path', default=resolve_path(defaults["player_files_path"], user_path),
+                        help="Input directory for player files.")
+    parser.add_argument('--seed', help='Define seed number to generate.', type=int)
+    parser.add_argument('--multi', default=defaults["players"], type=lambda value: max(int(value), 1))
+    parser.add_argument('--spoiler', type=int, default=defaults["spoiler"])
+    parser.add_argument('--lttp_rom', default=options["lttp_options"]["rom_file"],
+                        help="Path to the 1.0 JP LttP Baserom.")  # absolute, relative to cwd or relative to app path
+    parser.add_argument('--sm_rom', default=options["sm_options"]["rom_file"],
+                        help="Path to the 1.0 JP SM Baserom.")
+    parser.add_argument('--enemizercli', default=resolve_path(defaults["enemizer_path"], local_path))
+    parser.add_argument('--outputpath', default=resolve_path(options["general_options"]["output_path"], user_path),
+                        help="Path to output folder. Absolute or relative to cwd.")  # absolute or relative to cwd
+    parser.add_argument('--race', action='store_true', default=defaults["race"])
+    parser.add_argument('--meta_file_path', default=defaults["meta_file_path"])
+    parser.add_argument('--log_level', default='info', help='Sets log level')
+    parser.add_argument('--yaml_output', default=0, type=lambda value: max(int(value), 0),
+                        help='Output rolled mystery results to yaml up to specified number (made for async multiworld)')
+    parser.add_argument('--plando', default=defaults["plando_options"],
+                        help='List of options that can be set manually. Can be combined, for example "bosses, items"')
+    args = parser.parse_args()
+    if not os.path.isabs(args.weights_file_path):
+        args.weights_file_path = os.path.join(args.player_files_path, args.weights_file_path)
+    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: PlandoSettings = PlandoSettings.from_option_string(args.plando)
+    return args, options
+
+
+def get_seed_name(random_source) -> str:
+    return f"{random_source.randint(0, pow(10, seeddigits) - 1)}".zfill(seeddigits)
+
+
+def main(args=None, callback=ERmain):
+    if not args:
+        args, options = mystery_argparse()
+
+    seed = get_seed(args.seed)
+    random.seed(seed)
+    seed_name = get_seed_name(random)
+
+    if args.race:
+        random.seed()  # reset to time-based random source
+
+    weights_cache: Dict[str, Tuple[Any, ...]] = {}
+    if args.weights_file_path and os.path.exists(args.weights_file_path):
+        try:
+            weights_cache[args.weights_file_path] = read_weights_yamls(args.weights_file_path)
+        except Exception as e:
+            raise ValueError(f"File {args.weights_file_path} is destroyed. Please fix your yaml.") from e
+        print(f"Weights: {args.weights_file_path} >> "
+              f"{get_choice('description', weights_cache[args.weights_file_path][-1], 'No description specified')}")
+
+    if args.meta_file_path and os.path.exists(args.meta_file_path):
+        try:
+            weights_cache[args.meta_file_path] = read_weights_yamls(args.meta_file_path)
+        except Exception as e:
+            raise ValueError(f"File {args.meta_file_path} is destroyed. Please fix your yaml.") from e
+        meta_weights = weights_cache[args.meta_file_path][-1]
+        print(f"Meta: {args.meta_file_path} >> {get_choice('meta_description', meta_weights)}")
+        del(meta_weights["meta_description"])
+        if args.samesettings:
+            raise Exception("Cannot mix --samesettings with --meta")
+    else:
+        meta_weights = None
+    player_id = 1
+    player_files = {}
+    for file in os.scandir(args.player_files_path):
+        fname = file.name
+        if file.is_file() and not file.name.startswith(".") and \
+                os.path.join(args.player_files_path, fname) not in {args.meta_file_path, args.weights_file_path}:
+            path = os.path.join(args.player_files_path, fname)
+            try:
+                weights_cache[fname] = read_weights_yamls(path)
+            except Exception as e:
+                raise ValueError(f"File {fname} is destroyed. Please fix your yaml.") from e
+
+    # sort dict for consistent results across platforms:
+    weights_cache = {key: value for key, value in sorted(weights_cache.items())}
+    for filename, yaml_data in weights_cache.items():
+        for yaml in yaml_data:
+            print(f"P{player_id} Weights: {filename} >> "
+                  f"{get_choice('description', yaml, 'No description specified')}")
+            player_files[player_id] = filename
+            player_id += 1
+
+    args.multi = max(player_id-1, args.multi)
+    print(f"Generating for {args.multi} player{'s' if args.multi > 1 else ''}, {seed_name} Seed {seed} with plando: "
+          f"{args.plando}")
+
+    if not weights_cache:
+        raise Exception(f"No weights found. 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.glitch_triforce = options["generator"]["glitch_triforce_room"]
+    erargs.spoiler = args.spoiler
+    erargs.race = args.race
+    erargs.outputname = seed_name
+    erargs.outputpath = args.outputpath
+
+    Utils.init_logging(f"Generate_{seed}", loglevel=args.log_level)
+
+    erargs.lttp_rom = args.lttp_rom
+    erargs.sm_rom = args.sm_rom
+    erargs.enemizercli = args.enemizercli
+
+    settings_cache: Dict[str, Tuple[argparse.Namespace, ...]] = \
+        {fname: ( tuple(roll_settings(yaml, args.plando) for yaml in yamls) if args.samesettings else None)
+                for fname, yamls in weights_cache.items()}
+    player_path_cache = {}
+    for player in range(1, args.multi + 1):
+        player_path_cache[player] = player_files.get(player, args.weights_file_path)
+
+    if meta_weights:
+        for category_name, category_dict in meta_weights.items():
+            for key in category_dict:
+                option = get_choice(key, category_dict)
+                if option is not None:
+                    for player, path in player_path_cache.items():
+                        for yaml in weights_cache[path]:
+                            if category_name is None:
+                                yaml[key] = option
+                            elif category_name not in yaml:
+                                logging.warning(f"Meta: Category {category_name} is not present in {path}.")
+                            else:
+                               yaml[category_name][key] = option
+
+    name_counter = Counter()
+    erargs.player_settings = {}
+
+    player = 1
+    while player <= args.multi:
+        path = player_path_cache[player]
+        if path:
+            try:
+                settings: Tuple[argparse.Namespace, ...] = settings_cache[path] if settings_cache[path] else \
+                    tuple(roll_settings(yaml, args.plando) for yaml in weights_cache[path])
+                for settingsObject in settings:
+                    for k, v in vars(settingsObject).items():
+                        if v is not None:
+                            try:
+                                getattr(erargs, k)[player] = v
+                            except AttributeError:
+                                setattr(erargs, k, {player: v})
+                            except Exception as e:
+                                raise Exception(f"Error setting {k} to {v} for player {player}") from e
+
+                    if path == args.weights_file_path:  # if name came from the weights file, just use base player name
+                        erargs.name[player] = f"Player{player}"
+                    elif not erargs.name[player]:  # if name was not specified, generate it from filename
+                        erargs.name[player] = os.path.splitext(os.path.split(path)[-1])[0]
+                    erargs.name[player] = handle_name(erargs.name[player], player, name_counter)
+                    
+                    player += 1
+            except Exception as e:
+                raise ValueError(f"File {path} is destroyed. Please fix your yaml.") from e
+        else:
+            raise RuntimeError(f'No weights specified for player {player}')
+
+    if len(set(erargs.name.values())) != len(erargs.name):
+        raise Exception(f"Names have to be unique. Names: {Counter(erargs.name.values())}")
+
+    if args.yaml_output:
+        import yaml
+        important = {}
+        for option, player_settings in vars(erargs).items():
+            if type(player_settings) == dict:
+                if all(type(value) != list for value in player_settings.values()):
+                    if len(player_settings.values()) > 1:
+                        important[option] = {player: value for player, value in player_settings.items() if
+                                             player <= args.yaml_output}
+                    else:
+                        logging.debug(f"No player settings defined for option '{option}'")
+
+            else:
+                if player_settings != "":  # is not empty name
+                    important[option] = player_settings
+                else:
+                    logging.debug(f"No player settings defined for option '{option}'")
+        if args.outputpath:
+            os.makedirs(args.outputpath, exist_ok=True)
+        with open(os.path.join(args.outputpath if args.outputpath else ".", f"generate_{seed_name}.yaml"), "wt") as f:
+            yaml.dump(important, f)
+
+    callback(erargs, seed)
+
+
+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")
+        else:
+            with open(path, 'rb') as f:
+                yaml = str(f.read(), "utf-8-sig")
+    except Exception as e:
+        raise Exception(f"Failed to read weights ({path})") from e
+
+    return tuple(parse_yamls(yaml))
+
+
+def interpret_on_off(value) -> bool:
+    return {"on": True, "off": False}.get(value, value)
+
+
+def convert_to_on_off(value) -> str:
+    return {True: "on", False: "off"}.get(value, value)
+
+
+def get_choice_legacy(option, root, value=None) -> Any:
+    if option not in root:
+        return value
+    if type(root[option]) is list:
+        return interpret_on_off(random.choices(root[option])[0])
+    if type(root[option]) is not dict:
+        return interpret_on_off(root[option])
+    if not root[option]:
+        return value
+    if any(root[option].values()):
+        return interpret_on_off(
+            random.choices(list(root[option].keys()), weights=list(map(int, root[option].values())))[0])
+    raise RuntimeError(f"All options specified in \"{option}\" are weighted as zero.")
+
+
+def get_choice(option, root, value=None) -> Any:
+    if option not in root:
+        return value
+    if type(root[option]) is list:
+        return random.choices(root[option])[0]
+    if type(root[option]) is not dict:
+        return root[option]
+    if not root[option]:
+        return value
+    if any(root[option].values()):
+        return random.choices(list(root[option].keys()), weights=list(map(int, root[option].values())))[0]
+    raise RuntimeError(f"All options specified in \"{option}\" are weighted as zero.")
+
+
+class SafeDict(dict):
+    def __missing__(self, key):
+        return '{' + key + '}'
+
+
+def handle_name(name: str, player: int, name_counter: Counter):
+    name_counter[name] += 1
+    new_name = "%".join([x.replace("%number%", "{number}").replace("%player%", "{player}") for x in name.split("%%")])
+    new_name = string.Formatter().vformat(new_name, (), SafeDict(number=name_counter[name],
+                                                                 NUMBER=(name_counter[name] if name_counter[
+                                                                                                   name] > 1 else ''),
+                                                                 player=player,
+                                                                 PLAYER=(player if player > 1 else '')))
+    new_name = new_name.strip()[:16]
+    if new_name == "Archipelago":
+        raise Exception(f"You cannot name yourself \"{new_name}\"")
+    return new_name
+
+
+def prefer_int(input_data: str) -> Union[str, int]:
+    try:
+        return int(input_data)
+    except:
+        return input_data
+
+
+available_boss_names: Set[str] = {boss.lower() for boss in Bosses.boss_table if boss not in
+                                         {'Agahnim', 'Agahnim2', 'Ganon'}}
+available_boss_locations: Set[str] = {f"{loc.lower()}{f' {level}' if level else ''}" for loc, level in
+                                             Bosses.boss_location_table}
+
+boss_shuffle_options = {None: 'none',
+                        'none': 'none',
+                        'basic': 'basic',
+                        'full': 'full',
+                        'chaos': 'chaos',
+                        'singularity': 'singularity'
+                        }
+
+goals = {
+    'ganon': 'ganon',
+    'crystals': 'crystals',
+    'bosses': 'bosses',
+    'pedestal': 'pedestal',
+    'ganon_pedestal': 'ganonpedestal',
+    'triforce_hunt': 'triforcehunt',
+    'local_triforce_hunt': 'localtriforcehunt',
+    'ganon_triforce_hunt': 'ganontriforcehunt',
+    'local_ganon_triforce_hunt': 'localganontriforcehunt',
+    'ice_rod_hunt': 'icerodhunt',
+}
+
+
+def roll_percentage(percentage: Union[int, float]) -> bool:
+    """Roll a percentage chance.
+    percentage is expected to be in range [0, 100]"""
+    return random.random() < (float(percentage) / 100)
+
+
+def update_weights(weights: dict, new_weights: dict, type: str, name: str) -> dict:
+    logging.debug(f'Applying {new_weights}')
+    new_options = set(new_weights) - set(weights)
+    weights.update(new_weights)
+    if new_options:
+        for new_option in new_options:
+            logging.warning(f'{type} Suboption "{new_option}" of "{name}" did not '
+                            f'overwrite a root option. '
+                            f'This is probably in error.')
+    return weights
+
+
+def roll_linked_options(weights: dict) -> dict:
+    weights = copy.deepcopy(weights)  # make sure we don't write back to other weights sets in same_settings
+    for option_set in weights["linked_options"]:
+        if "name" not in option_set:
+            raise ValueError("One of your linked options does not have a name.")
+        try:
+            if roll_percentage(option_set["percentage"]):
+                logging.debug(f"Linked option {option_set['name']} triggered.")
+                new_options = option_set["options"]
+                for category_name, category_options in new_options.items():
+                    currently_targeted_weights = weights
+                    if category_name:
+                        currently_targeted_weights = currently_targeted_weights[category_name]
+                    update_weights(currently_targeted_weights, category_options, "Linked", option_set["name"])
+            else:
+                logging.debug(f"linked option {option_set['name']} skipped.")
+        except Exception as e:
+            raise ValueError(f"Linked option {option_set['name']} is destroyed. "
+                             f"Please fix your linked option.") from e
+    return weights
+
+
+def roll_triggers(weights: dict, triggers: list) -> dict:
+    weights = copy.deepcopy(weights)  # make sure we don't write back to other weights sets in same_settings
+    weights["_Generator_Version"] = Utils.__version__
+    for i, option_set in enumerate(triggers):
+        try:
+            currently_targeted_weights = weights
+            category = option_set.get("option_category", None)
+            if category:
+                currently_targeted_weights = currently_targeted_weights[category]
+            key = get_choice("option_name", option_set)
+            if key not in currently_targeted_weights:
+                logging.warning(f'Specified option name {option_set["option_name"]} did not '
+                                f'match with a root option. '
+                                f'This is probably in error.')
+            trigger_result = get_choice("option_result", option_set)
+            result = get_choice(key, currently_targeted_weights)
+            currently_targeted_weights[key] = result
+            if result == trigger_result and roll_percentage(get_choice("percentage", option_set, 100)):
+                for category_name, category_options in option_set["options"].items():
+                    currently_targeted_weights = weights
+                    if category_name:
+                        currently_targeted_weights = currently_targeted_weights[category_name]
+                    update_weights(currently_targeted_weights, category_options, "Triggered", option_set["option_name"])
+
+        except Exception as e:
+            raise ValueError(f"Your trigger number {i + 1} is destroyed. "
+                             f"Please fix your triggers.") from e
+    return weights
+
+
+def get_plando_bosses(boss_shuffle: str, plando_options: Set[str]) -> str:
+    if boss_shuffle in boss_shuffle_options:
+        return boss_shuffle_options[boss_shuffle]
+    elif PlandoSettings.bosses in plando_options:
+        options = boss_shuffle.lower().split(";")
+        remainder_shuffle = "none"  # vanilla
+        bosses = []
+        for boss in options:
+            if boss in boss_shuffle_options:
+                remainder_shuffle = boss_shuffle_options[boss]
+            elif "-" in boss:
+                loc, boss_name = boss.split("-")
+                if boss_name not in available_boss_names:
+                    raise ValueError(f"Unknown Boss name {boss_name}")
+                if loc not in available_boss_locations:
+                    raise ValueError(f"Unknown Boss Location {loc}")
+                level = ''
+                if loc.split(" ")[-1] in {"top", "middle", "bottom"}:
+                    # split off level
+                    loc = loc.split(" ")
+                    level = f" {loc[-1]}"
+                    loc = " ".join(loc[:-1])
+                loc = loc.title().replace("Of", "of")
+                if not Bosses.can_place_boss(boss_name.title(), loc, level):
+                    raise ValueError(f"Cannot place {boss_name} at {loc}{level}")
+                bosses.append(boss)
+            elif boss not in available_boss_names:
+                raise ValueError(f"Unknown Boss name or Boss shuffle option {boss}.")
+            else:
+                bosses.append(boss)
+        return ";".join(bosses + [remainder_shuffle])
+    else:
+        raise Exception(f"Boss Shuffle {boss_shuffle} is unknown and boss plando is turned off.")
+
+
+def handle_option(ret: argparse.Namespace, game_weights: dict, option_key: str, option: type(Options.Option)):
+    if option_key in game_weights:
+        try:
+            if not option.supports_weighting:
+                player_option = option.from_any(game_weights[option_key])
+            else:
+                player_option = option.from_any(get_choice(option_key, game_weights))
+            setattr(ret, option_key, player_option)
+        except Exception as e:
+            raise Exception(f"Error generating option {option_key} in {ret.game}") from e
+        else:
+            if hasattr(player_option, "verify"):
+                player_option.verify(AutoWorldRegister.world_types[ret.game])
+    else:
+        setattr(ret, option_key, option(option.default))
+
+
+def roll_settings(weights: dict, plando_options: PlandoSettings = PlandoSettings.bosses):
+    if "linked_options" in weights:
+        weights = roll_linked_options(weights)
+
+    if "triggers" in weights:
+        weights = roll_triggers(weights, weights["triggers"])
+
+    requirements = weights.get("requires", {})
+    if requirements:
+        version = requirements.get("version", __version__)
+        if tuplize_version(version) > version_tuple:
+            raise Exception(f"Settings reports required version of generator is at least {version}, "
+                            f"however generator is of version {__version__}")
+        required_plando_options = PlandoSettings.from_option_string(requirements.get("plando", ""))
+        if required_plando_options not in plando_options:
+            if required_plando_options:
+                raise Exception(f"Settings reports required plando module {str(required_plando_options)}, "
+                                f"which is not enabled.")
+
+    ret = argparse.Namespace()
+    for option_key in Options.per_game_common_options:
+        if option_key in weights and option_key not in Options.common_options:
+            raise Exception(f"Option {option_key} has to be in a game's section, not on its own.")
+
+    ret.game = get_choice("game", weights)
+    if ret.game not in weights:
+        raise Exception(f"No game options for selected game \"{ret.game}\" found.")
+
+    world_type = AutoWorldRegister.world_types[ret.game]
+    game_weights = weights[ret.game]
+
+    if "triggers" in game_weights:
+        weights = roll_triggers(weights, game_weights["triggers"])
+        game_weights = weights[ret.game]
+
+    ret.name = get_choice('name', weights)
+    for option_key, option in Options.common_options.items():
+        setattr(ret, option_key, option.from_any(get_choice(option_key, weights, option.default)))
+
+    if ret.game in AutoWorldRegister.world_types:
+        for option_key, option in world_type.options.items():
+            handle_option(ret, game_weights, option_key, option)
+        for option_key, option in Options.per_game_common_options.items():
+            # skip setting this option if already set from common_options, defaulting to root option
+            if not (option_key in Options.common_options and option_key not in game_weights):
+                handle_option(ret, game_weights, option_key, option)
+        if PlandoSettings.items in plando_options:
+            ret.plando_items = game_weights.get("plando_items", [])
+        if ret.game == "Minecraft" or ret.game == "Ocarina of Time":
+            # bad hardcoded behavior to make this work for now
+            ret.plando_connections = []
+            if PlandoSettings.connections in plando_options:
+                options = game_weights.get("plando_connections", [])
+                for placement in options:
+                    if roll_percentage(get_choice("percentage", placement, 100)):
+                        ret.plando_connections.append(PlandoConnection(
+                            get_choice("entrance", placement),
+                            get_choice("exit", placement),
+                            get_choice("direction", placement)
+                        ))
+        elif ret.game == "A Link to the Past":
+            roll_alttp_settings(ret, game_weights, plando_options)
+    else:
+        raise Exception(f"Unsupported game {ret.game}")
+
+    return ret
+
+
+def roll_alttp_settings(ret: argparse.Namespace, weights, plando_options):
+    if "dungeon_items" in weights and get_choice_legacy('dungeon_items', weights, "none") != "none":
+        raise Exception(f"dungeon_items key in A Link to the Past was removed, but is present in these weights as {get_choice_legacy('dungeon_items', weights, False)}.")
+    glitches_required = get_choice_legacy('glitches_required', weights)
+    if glitches_required not in [None, 'none', 'no_logic', 'overworld_glitches', 'hybrid_major_glitches', 'minor_glitches']:
+        logging.warning("Only NMG, OWG, HMG and No Logic supported")
+        glitches_required = 'none'
+    ret.logic = {None: 'noglitches', 'none': 'noglitches', 'no_logic': 'nologic', 'overworld_glitches': 'owglitches',
+                 'minor_glitches': 'minorglitches', 'hybrid_major_glitches': 'hybridglitches'}[
+        glitches_required]
+
+    ret.dark_room_logic = get_choice_legacy("dark_room_logic", weights, "lamp")
+    if not ret.dark_room_logic:  # None/False
+        ret.dark_room_logic = "none"
+    if ret.dark_room_logic == "sconces":
+        ret.dark_room_logic = "torches"
+    if ret.dark_room_logic not in {"lamp", "torches", "none"}:
+        raise ValueError(f"Unknown Dark Room Logic: \"{ret.dark_room_logic}\"")
+
+    entrance_shuffle = get_choice_legacy('entrance_shuffle', weights, 'vanilla')
+    if entrance_shuffle.startswith('none-'):
+        ret.shuffle = 'vanilla'
+    else:
+        ret.shuffle = entrance_shuffle if entrance_shuffle != 'none' else 'vanilla'
+
+    goal = get_choice_legacy('goals', weights, 'ganon')
+
+    ret.goal = goals[goal]
+
+
+    extra_pieces = get_choice_legacy('triforce_pieces_mode', weights, 'available')
+
+    ret.triforce_pieces_required = LttPOptions.TriforcePieces.from_any(get_choice_legacy('triforce_pieces_required', weights, 20))
+
+    # sum a percentage to required
+    if extra_pieces == 'percentage':
+        percentage = max(100, float(get_choice_legacy('triforce_pieces_percentage', weights, 150))) / 100
+        ret.triforce_pieces_available = int(round(ret.triforce_pieces_required * percentage, 0))
+    # vanilla mode (specify how many pieces are)
+    elif extra_pieces == 'available':
+        ret.triforce_pieces_available = LttPOptions.TriforcePieces.from_any(
+            get_choice_legacy('triforce_pieces_available', weights, 30))
+    # required pieces + fixed extra
+    elif extra_pieces == 'extra':
+        extra_pieces = max(0, int(get_choice_legacy('triforce_pieces_extra', weights, 10)))
+        ret.triforce_pieces_available = ret.triforce_pieces_required + extra_pieces
+
+    # change minimum to required pieces to avoid problems
+    ret.triforce_pieces_available = min(max(ret.triforce_pieces_required, int(ret.triforce_pieces_available)), 90)
+
+    ret.shop_shuffle = get_choice_legacy('shop_shuffle', weights, '')
+    if not ret.shop_shuffle:
+        ret.shop_shuffle = ''
+
+    ret.mode = get_choice_legacy("mode", weights)
+
+    ret.difficulty = get_choice_legacy('item_pool', weights)
+
+    ret.item_functionality = get_choice_legacy('item_functionality', weights)
+
+    boss_shuffle = get_choice_legacy('boss_shuffle', weights)
+    ret.shufflebosses = get_plando_bosses(boss_shuffle, plando_options)
+
+    ret.enemy_damage = {None: 'default',
+                        'default': 'default',
+                        'shuffled': 'shuffled',
+                        'random': 'chaos', # to be removed
+                        'chaos': 'chaos',
+                        }[get_choice_legacy('enemy_damage', weights)]
+
+    ret.enemy_health = get_choice_legacy('enemy_health', weights)
+
+    ret.timer = {'none': False,
+                 None: False,
+                 False: False,
+                 'timed': 'timed',
+                 'timed_ohko': 'timed-ohko',
+                 'ohko': 'ohko',
+                 'timed_countdown': 'timed-countdown',
+                 'display': 'display'}[get_choice_legacy('timer', weights, False)]
+
+    ret.countdown_start_time = int(get_choice_legacy('countdown_start_time', weights, 10))
+    ret.red_clock_time = int(get_choice_legacy('red_clock_time', weights, -2))
+    ret.blue_clock_time = int(get_choice_legacy('blue_clock_time', weights, 2))
+    ret.green_clock_time = int(get_choice_legacy('green_clock_time', weights, 4))
+
+    ret.dungeon_counters = get_choice_legacy('dungeon_counters', weights, 'default')
+
+    ret.shuffle_prizes = get_choice_legacy('shuffle_prizes', weights, "g")
+
+    ret.required_medallions = [get_choice_legacy("misery_mire_medallion", weights, "random"),
+                               get_choice_legacy("turtle_rock_medallion", weights, "random")]
+
+    for index, medallion in enumerate(ret.required_medallions):
+        ret.required_medallions[index] = {"ether": "Ether", "quake": "Quake", "bombos": "Bombos", "random": "random"} \
+            .get(medallion.lower(), None)
+        if not ret.required_medallions[index]:
+            raise Exception(f"unknown Medallion {medallion} for {'misery mire' if index == 0 else 'turtle rock'}")
+
+    ret.plando_texts = {}
+    if PlandoSettings.texts in plando_options:
+        tt = TextTable()
+        tt.removeUnwantedText()
+        options = weights.get("plando_texts", [])
+        for placement in options:
+            if roll_percentage(get_choice_legacy("percentage", placement, 100)):
+                at = str(get_choice_legacy("at", placement))
+                if at not in tt:
+                    raise Exception(f"No text target \"{at}\" found.")
+                ret.plando_texts[at] = str(get_choice_legacy("text", placement))
+
+    ret.plando_connections = []
+    if PlandoSettings.connections in plando_options:
+        options = weights.get("plando_connections", [])
+        for placement in options:
+            if roll_percentage(get_choice_legacy("percentage", placement, 100)):
+                ret.plando_connections.append(PlandoConnection(
+                    get_choice_legacy("entrance", placement),
+                    get_choice_legacy("exit", placement),
+                    get_choice_legacy("direction", placement, "both")
+                ))
+
+    ret.sprite_pool = weights.get('sprite_pool', [])
+    ret.sprite = get_choice_legacy('sprite', weights, "Link")
+    if 'random_sprite_on_event' in weights:
+        randomoneventweights = weights['random_sprite_on_event']
+        if get_choice_legacy('enabled', randomoneventweights, False):
+            ret.sprite = 'randomon'
+            ret.sprite += '-hit' if get_choice_legacy('on_hit', randomoneventweights, True) else ''
+            ret.sprite += '-enter' if get_choice_legacy('on_enter', randomoneventweights, False) else ''
+            ret.sprite += '-exit' if get_choice_legacy('on_exit', randomoneventweights, False) else ''
+            ret.sprite += '-slash' if get_choice_legacy('on_slash', randomoneventweights, False) else ''
+            ret.sprite += '-item' if get_choice_legacy('on_item', randomoneventweights, False) else ''
+            ret.sprite += '-bonk' if get_choice_legacy('on_bonk', randomoneventweights, False) else ''
+            ret.sprite = 'randomonall' if get_choice_legacy('on_everything', randomoneventweights, False) else ret.sprite
+            ret.sprite = 'randomonnone' if ret.sprite == 'randomon' else ret.sprite
+
+            if (not ret.sprite_pool or get_choice_legacy('use_weighted_sprite_pool', randomoneventweights, False)) \
+                    and 'sprite' in weights:  # Use sprite as a weighted sprite pool, if a sprite pool is not already defined.
+                for key, value in weights['sprite'].items():
+                    if key.startswith('random'):
+                        ret.sprite_pool += ['random'] * int(value)
+                    else:
+                        ret.sprite_pool += [key] * int(value)
+
+
+if __name__ == '__main__':
+    import atexit
+    confirmation = atexit.register(input, "Press enter to close.")
+    main()
+    # in case of error-free exit should not need confirmation
+    atexit.unregister(confirmation)

GuiUtils.py

@@ -1,192 +0,0 @@
-import queue
-import threading
-import tkinter as tk
-
-from Utils import local_path
-
-def set_icon(window):
-    logo = tk.PhotoImage(file=local_path('data', 'icon.png'))
-    window.tk.call('wm', 'iconphoto', window._w, logo)
-
-# Although tkinter is intended to be thread safe, there are many reports of issues
-# some which may be platform specific, or depend on if the TCL library was compiled without
-# multithreading support. Therefore I will assume it is not thread safe to avoid any possible problems
-class BackgroundTask(object):
-    def __init__(self, window, code_to_run, *args):
-        self.window = window
-        self.queue = queue.Queue()
-        self.running = True
-        self.process_queue()
-        self.task = threading.Thread(target=code_to_run, args=(self, *args))
-        self.task.start()
-
-    def stop(self):
-        self.running = False
-
-    # safe to call from worker
-    def queue_event(self, event):
-        self.queue.put(event)
-
-    def process_queue(self):
-        try:
-            while True:
-                if not self.running:
-                    return
-                event = self.queue.get_nowait()
-                event()
-                if self.running:
-                    #if self is no longer running self.window may no longer be valid
-                    self.window.update_idletasks()
-        except queue.Empty:
-            pass
-        if self.running:
-            self.window.after(100, self.process_queue)
-
-class BackgroundTaskProgress(BackgroundTask):
-    def __init__(self, parent, code_to_run, title, *args):
-        self.parent = parent
-        self.window = tk.Toplevel(parent)
-        self.window['padx'] = 5
-        self.window['pady'] = 5
-
-        try:
-            self.window.attributes("-toolwindow", 1)
-        except tk.TclError:
-            pass
-
-        self.window.wm_title(title)
-        self.label_var = tk.StringVar()
-        self.label_var.set("")
-        self.label = tk.Label(self.window, textvariable=self.label_var, width=50)
-        self.label.pack()
-        self.window.resizable(width=False, height=False)
-
-        set_icon(self.window)
-        self.window.focus()
-        super().__init__(self.window, code_to_run, *args)
-
-    #safe to call from worker thread
-    def update_status(self, text):
-        self.queue_event(lambda: self.label_var.set(text))
-
-    # only call this in an event callback
-    def close_window(self):
-        self.stop()
-        self.window.destroy()
-
-
-
-class ToolTips(object):
-    # This class derived from wckToolTips which is available under the following license:
-
-    # Copyright (c) 1998-2007 by Secret Labs AB
-    # Copyright (c) 1998-2007 by Fredrik Lundh
-    #
-    # By obtaining, using, and/or copying this software and/or its
-    # associated documentation, you agree that you have read, understood,
-    # and will comply with the following terms and conditions:
-    #
-    # Permission to use, copy, modify, and distribute this software and its
-    # associated documentation for any purpose and without fee is hereby
-    # granted, provided that the above copyright notice appears in all
-    # copies, and that both that copyright notice and this permission notice
-    # appear in supporting documentation, and that the name of Secret Labs
-    # AB or the author not be used in advertising or publicity pertaining to
-    # distribution of the software without specific, written prior
-    # permission.
-    #
-    # SECRET LABS AB AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO
-    # THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
-    # FITNESS.  IN NO EVENT SHALL SECRET LABS AB OR THE AUTHOR BE LIABLE FOR
-    # ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-    # WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-    # ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
-    # OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-    label = None
-    window = None
-    active = 0
-    tag = None
-    after_id = None
-
-    @classmethod
-    def getcontroller(cls, widget):
-        if cls.tag is None:
-
-            cls.tag = "ui_tooltip_%d" % id(cls)
-            widget.bind_class(cls.tag, "<Enter>", cls.enter)
-            widget.bind_class(cls.tag, "<Leave>", cls.leave)
-            widget.bind_class(cls.tag, "<Motion>", cls.motion)
-            widget.bind_class(cls.tag, "<Destroy>", cls.leave)
-
-            # pick suitable colors for tooltips
-            try:
-                cls.bg = "systeminfobackground"
-                cls.fg = "systeminfotext"
-                widget.winfo_rgb(cls.fg)  # make sure system colors exist
-                widget.winfo_rgb(cls.bg)
-            except Exception:
-                cls.bg = "#ffffe0"
-                cls.fg = "black"
-
-        return cls.tag
-
-    @classmethod
-    def register(cls, widget, text):
-        widget.ui_tooltip_text = text
-        tags = list(widget.bindtags())
-        tags.append(cls.getcontroller(widget))
-        widget.bindtags(tuple(tags))
-
-    @classmethod
-    def unregister(cls, widget):
-        tags = list(widget.bindtags())
-        tags.remove(cls.getcontroller(widget))
-        widget.bindtags(tuple(tags))
-
-    # event handlers
-    @classmethod
-    def enter(cls, event):
-        widget = event.widget
-        if not cls.label:
-            # create and hide balloon help window
-            cls.popup = tk.Toplevel(bg=cls.fg, bd=1)
-            cls.popup.overrideredirect(1)
-            cls.popup.withdraw()
-            cls.label = tk.Label(
-                cls.popup, fg=cls.fg, bg=cls.bg, bd=0, padx=2, justify=tk.LEFT
-            )
-            cls.label.pack()
-            cls.active = 0
-        cls.xy = event.x_root + 16, event.y_root + 10
-        cls.event_xy = event.x, event.y
-        cls.after_id = widget.after(200, cls.display, widget)
-
-    @classmethod
-    def motion(cls, event):
-        cls.xy = event.x_root + 16, event.y_root + 10
-        cls.event_xy = event.x, event.y
-
-    @classmethod
-    def display(cls, widget):
-        if not cls.active:
-            # display balloon help window
-            text = widget.ui_tooltip_text
-            if callable(text):
-                text = text(widget, cls.event_xy)
-            cls.label.config(text=text)
-            cls.popup.deiconify()
-            cls.popup.lift()
-            cls.popup.geometry("+%d+%d" % cls.xy)
-            cls.active = 1
-            cls.after_id = None
-
-    @classmethod
-    def leave(cls, event):
-        widget = event.widget
-        if cls.active:
-            cls.popup.withdraw()
-            cls.active = 0
-        if cls.after_id:
-            widget.after_cancel(cls.after_id)
-            cls.after_id = None

LICENSE

@@ -1,8 +1,8 @@
 MIT License
 
 Copyright (c) 2017 LLCoolDave
-Copyright (c) 2021 Berserker66
-Copyright (c) 2021 CaitSith2
+Copyright (c) 2022 Berserker66
+Copyright (c) 2022 CaitSith2
 Copyright (c) 2021 LegendaryLinux
 
 Permission is hereby granted, free of charge, to any person obtaining a copy

Launcher.py

@@ -0,0 +1,291 @@
+"""
+Archipelago launcher for bundled app.
+
+* if run with APBP as argument, launch corresponding client.
+* if run with executable as argument, run it passing argv[2:] as arguments
+* if run without arguments, open launcher GUI
+
+Scroll down to components= to add components to the launcher as well as setup.py
+"""
+
+
+import argparse
+from os.path import isfile
+import sys
+from typing import Iterable, Sequence, Callable, Union, Optional
+import subprocess
+import itertools
+from Utils import is_frozen, user_path, local_path, init_logging, open_filename, messagebox,\
+    is_windows, is_macos, is_linux
+from shutil import which
+import shlex
+from enum import Enum, auto
+
+
+def open_host_yaml():
+    file = user_path('host.yaml')
+    if is_linux:
+        exe = which('sensible-editor') or which('gedit') or \
+              which('xdg-open') or which('gnome-open') or which('kde-open')
+        subprocess.Popen([exe, file])
+    elif is_macos:
+        exe = which("open")
+        subprocess.Popen([exe, file])
+    else:
+        import webbrowser
+        webbrowser.open(file)
+
+
+def open_patch():
+    suffixes = []
+    for c in components:
+        if isfile(get_exe(c)[-1]):
+            suffixes += c.file_identifier.suffixes if c.type == Type.CLIENT and \
+                                                      isinstance(c.file_identifier, SuffixIdentifier) else []
+    try:
+        filename = open_filename('Select patch', (('Patches', suffixes),))
+    except Exception as e:
+        messagebox('Error', str(e), error=True)
+    else:
+        file, _, component = identify(filename)
+        if file and component:
+            launch([*get_exe(component), file], component.cli)
+
+
+def browse_files():
+    file = user_path()
+    if is_linux:
+        exe = which('xdg-open') or which('gnome-open') or which('kde-open')
+        subprocess.Popen([exe, file])
+    elif is_macos:
+        exe = which("open")
+        subprocess.Popen([exe, file])
+    else:
+        import webbrowser
+        webbrowser.open(file)
+
+
+class Type(Enum):
+    TOOL = auto()
+    FUNC = auto()  # not a real component
+    CLIENT = auto()
+    ADJUSTER = auto()
+
+
+class SuffixIdentifier:
+    suffixes: Iterable[str]
+
+    def __init__(self, *args: str):
+        self.suffixes = args
+
+    def __call__(self, path: str):
+        if isinstance(path, str):
+            for suffix in self.suffixes:
+                if path.endswith(suffix):
+                    return True
+        return False
+
+
+class Component:
+    display_name: str
+    type: Optional[Type]
+    script_name: Optional[str]
+    frozen_name: Optional[str]
+    icon: str  # just the name, no suffix
+    cli: bool
+    func: Optional[Callable]
+    file_identifier: Optional[Callable[[str], bool]]
+
+    def __init__(self, display_name: str, script_name: Optional[str] = None, frozen_name: Optional[str] = None,
+                 cli: bool = False, icon: str = 'icon', component_type: Type = None, func: Optional[Callable] = None,
+                 file_identifier: Optional[Callable[[str], bool]] = None):
+        self.display_name = display_name
+        self.script_name = script_name
+        self.frozen_name = frozen_name or f'Archipelago{script_name}' if script_name else None
+        self.icon = icon
+        self.cli = cli
+        self.type = component_type or \
+            None if not display_name else \
+            Type.FUNC if func else \
+            Type.CLIENT if 'Client' in display_name else \
+            Type.ADJUSTER if 'Adjuster' in display_name else Type.TOOL
+        self.func = func
+        self.file_identifier = file_identifier
+
+    def handles_file(self, path: str):
+        return self.file_identifier(path) if self.file_identifier else False
+
+
+components: Iterable[Component] = (
+    # Launcher
+    Component('', 'Launcher'),
+    # Core
+    Component('Host', 'MultiServer', 'ArchipelagoServer', cli=True,
+              file_identifier=SuffixIdentifier('.archipelago', '.zip')),
+    Component('Generate', 'Generate', cli=True),
+    Component('Text Client', 'CommonClient', 'ArchipelagoTextClient'),
+    # SNI
+    Component('SNI Client', 'SNIClient',
+              file_identifier=SuffixIdentifier('.apz3', '.apm3', '.apsoe', '.aplttp', '.apsm', '.apsmz3', '.apdkc3')),
+    Component('LttP Adjuster', 'LttPAdjuster'),
+    # Factorio
+    Component('Factorio Client', 'FactorioClient'),
+    # Minecraft
+    Component('Minecraft Client', 'MinecraftClient', icon='mcicon', cli=True,
+              file_identifier=SuffixIdentifier('.apmc')),
+    # Ocarina of Time
+    Component('OoT Client', 'OoTClient',
+              file_identifier=SuffixIdentifier('.apz5')),
+    Component('OoT Adjuster', 'OoTAdjuster'),
+    # FF1
+    Component('FF1 Client', 'FF1Client'),
+    # ChecksFinder
+    Component('ChecksFinder Client', 'ChecksFinderClient'),
+    # Starcraft 2
+    Component('Starcraft 2 Client', 'Starcraft2Client'),
+    # Functions
+    Component('Open host.yaml', func=open_host_yaml),
+    Component('Open Patch', func=open_patch),
+    Component('Browse Files', func=browse_files),
+)
+icon_paths = {
+    'icon': local_path('data', 'icon.ico' if is_windows else 'icon.png'),
+    'mcicon': local_path('data', 'mcicon.ico')
+}
+
+
+def identify(path: Union[None, str]):
+    if path is None:
+        return None, None, None
+    for component in components:
+        if component.handles_file(path):
+            return path, component.script_name, component
+    return (None, None, None) if '/' in path or '\\' in path else (None, path, None)
+
+
+def get_exe(component: Union[str, Component]) -> Optional[Sequence[str]]:
+    if isinstance(component, str):
+        name = component
+        component = None
+        if name.startswith('Archipelago'):
+            name = name[11:]
+        if name.endswith('.exe'):
+            name = name[:-4]
+        if name.endswith('.py'):
+            name = name[:-3]
+        if not name:
+            return None
+        for c in components:
+            if c.script_name == name or c.frozen_name == f'Archipelago{name}':
+                component = c
+                break
+        if not component:
+            return None
+    if is_frozen():
+        suffix = '.exe' if is_windows else ''
+        return [local_path(f'{component.frozen_name}{suffix}')]
+    else:
+        return [sys.executable, local_path(f'{component.script_name}.py')]
+
+
+def launch(exe, in_terminal=False):
+    if in_terminal:
+        if is_windows:
+            subprocess.Popen(['start', *exe], shell=True)
+            return
+        elif is_linux:
+            terminal = which('x-terminal-emulator') or which('gnome-terminal') or which('xterm')
+            if terminal:
+                subprocess.Popen([terminal, '-e', shlex.join(exe)])
+                return
+        elif is_macos:
+            terminal = [which('open'), '-W', '-a', 'Terminal.app']
+            subprocess.Popen([*terminal, *exe])
+            return
+    subprocess.Popen(exe)
+
+
+def run_gui():
+    from kvui import App, ContainerLayout, GridLayout, Button, Label
+
+    class Launcher(App):
+        base_title: str = "Archipelago Launcher"
+        container: ContainerLayout
+        grid: GridLayout
+
+        _tools = {c.display_name: c for c in components if c.type == Type.TOOL and isfile(get_exe(c)[-1])}
+        _clients = {c.display_name: c for c in components if c.type == Type.CLIENT and isfile(get_exe(c)[-1])}
+        _adjusters = {c.display_name: c for c in components if c.type == Type.ADJUSTER and isfile(get_exe(c)[-1])}
+        _funcs = {c.display_name: c for c in components if c.type == Type.FUNC}
+
+        def __init__(self, ctx=None):
+            self.title = self.base_title
+            self.ctx = ctx
+            self.icon = r"data/icon.png"
+            super().__init__()
+
+        def build(self):
+            self.container = ContainerLayout()
+            self.grid = GridLayout(cols=2)
+            self.container.add_widget(self.grid)
+
+            button_layout = self.grid  # make buttons fill the window
+            for (tool, client) in itertools.zip_longest(itertools.chain(
+                    self._tools.items(), self._funcs.items(), self._adjusters.items()), self._clients.items()):
+                # column 1
+                if tool:
+                    button = Button(text=tool[0])
+                    button.component = tool[1]
+                    button.bind(on_release=self.component_action)
+                    button_layout.add_widget(button)
+                else:
+                    button_layout.add_widget(Label())
+                # column 2
+                if client:
+                    button = Button(text=client[0])
+                    button.component = client[1]
+                    button.bind(on_press=self.component_action)
+                    button_layout.add_widget(button)
+                else:
+                    button_layout.add_widget(Label())
+
+            return self.container
+
+        @staticmethod
+        def component_action(button):
+            if button.component.type == Type.FUNC:
+                button.component.func()
+            else:
+                launch(get_exe(button.component), button.component.cli)
+
+    Launcher().run()
+
+
+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 = {}
+
+    if "Patch|Game|Component" in args:
+        file, component, _ = identify(args["Patch|Game|Component"])
+        if file:
+            args['file'] = file
+        if component:
+            args['component'] = component
+
+    if 'file' in args:
+        subprocess.run([*get_exe(args['component']), args['file'], *args['args']])
+    elif 'component' in args:
+        subprocess.run([*get_exe(args['component']), *args['args']])
+    else:
+        run_gui()
+
+
+if __name__ == '__main__':
+    init_logging('Launcher')
+    parser = argparse.ArgumentParser(description='Archipelago Launcher')
+    parser.add_argument('Patch|Game|Component', type=str, nargs='?',
+                        help="Pass either a patch file, a generated game or the name of a component to run.")
+    parser.add_argument('args', nargs="*", help="Arguments to pass to component.")
+    main(parser.parse_args())

LttPClient.py

@@ -1,954 +0,0 @@
-import argparse
-import atexit
-import time
-import multiprocessing
-import os
-import subprocess
-import base64
-import shutil
-from json import loads, dumps
-
-from Utils import get_item_name_from_id
-
-exit_func = atexit.register(input, "Press enter to close.")
-
-import ModuleUpdate
-
-ModuleUpdate.update()
-
-import colorama
-
-from NetUtils import *
-
-from worlds.alttp import Regions, Shops
-from worlds.alttp import Items
-import Utils
-from CommonClient import CommonContext, server_loop, logger, console_loop, ClientCommandProcessor
-
-
-from MultiServer import mark_raw
-
-
-class LttPCommandProcessor(ClientCommandProcessor):
-    def _cmd_slow_mode(self, toggle: str = ""):
-        """Toggle slow mode, which limits how fast you send / receive items."""
-        if toggle:
-            self.ctx.slow_mode = toggle.lower() in {"1", "true", "on"}
-        else:
-            self.ctx.slow_mode = not self.ctx.slow_mode
-
-        self.output(f"Setting slow mode to {self.ctx.slow_mode}")
-
-    @mark_raw
-    def _cmd_snes(self, snes_address: str = "") -> bool:
-        """Connect to a snes. Optionally include network address of a snes to connect to, otherwise show available devices"""
-        self.ctx.snes_reconnect_address = None
-        asyncio.create_task(snes_connect(self.ctx, snes_address if snes_address else self.ctx.snes_address))
-        return True
-
-    def _cmd_snes_close(self) -> bool:
-        """Close connection to a currently connected snes"""
-        self.ctx.snes_reconnect_address = None
-        if self.ctx.snes_socket is not None and not self.ctx.snes_socket.closed:
-            asyncio.create_task(self.ctx.snes_socket.close())
-            return True
-        else:
-            return False
-
-class Context(CommonContext):
-    command_processor = LttPCommandProcessor
-    def __init__(self, snes_address, server_address, password, found_items):
-        super(Context, self).__init__(server_address, password, found_items)
-
-        # snes stuff
-        self.snes_address = snes_address
-        self.snes_socket = None
-        self.snes_state = SNESState.SNES_DISCONNECTED
-        self.snes_attached_device = None
-        self.snes_reconnect_address = None
-        self.snes_recv_queue = asyncio.Queue()
-        self.snes_request_lock = asyncio.Lock()
-        self.is_sd2snes = False
-        self.snes_write_buffer = []
-
-        self.awaiting_rom = False
-        self.rom = None
-        self.prev_rom = None
-
-    async def connection_closed(self):
-        await super(Context, self).connection_closed()
-        self.awaiting_rom = False
-
-    def event_invalid_slot(self):
-        if self.snes_socket is not None and not self.snes_socket.closed:
-            asyncio.create_task(self.snes_socket.close())
-        raise Exception('Invalid ROM detected, '
-                        'please verify that you have loaded the correct rom and reconnect your snes (/snes)')
-
-    async def server_auth(self, password_requested):
-        if password_requested and not self.password:
-            await super(Context, self).server_auth(password_requested)
-        if self.rom is None:
-            self.awaiting_rom = True
-            logger.info(
-                'No ROM detected, awaiting snes connection to authenticate to the multiworld server (/snes)')
-            return
-        self.awaiting_rom = False
-        self.auth = self.rom
-        auth = base64.b64encode(self.rom).decode()
-        await self.send_msgs([{"cmd": 'Connect',
-                              'password': self.password, 'name': auth, 'version': Utils._version_tuple,
-                              'tags': get_tags(self),
-                              'uuid': Utils.get_unique_identifier(), 'game': "A Link to the Past"
-                              }])
-
-
-def color_item(item_id: int, green: bool = False) -> str:
-    item_name = get_item_name_from_id(item_id)
-    item_colors = ['green' if green else 'cyan']
-    if item_name in Items.progression_items:
-        item_colors.append("white_bg")
-    return color(item_name, *item_colors)
-
-
-SNES_RECONNECT_DELAY = 5
-
-ROM_START = 0x000000
-WRAM_START = 0xF50000
-WRAM_SIZE = 0x20000
-SRAM_START = 0xE00000
-
-ROMNAME_START = SRAM_START + 0x2000
-ROMNAME_SIZE = 0x15
-
-INGAME_MODES = {0x07, 0x09, 0x0b}
-ENDGAME_MODES = {0x19, 0x1a}
-
-SAVEDATA_START = WRAM_START + 0xF000
-SAVEDATA_SIZE = 0x500
-
-RECV_PROGRESS_ADDR = SAVEDATA_START + 0x4D0         # 2 bytes
-RECV_ITEM_ADDR = SAVEDATA_START + 0x4D2             # 1 byte
-RECV_ITEM_PLAYER_ADDR = SAVEDATA_START + 0x4D3      # 1 byte
-ROOMID_ADDR = SAVEDATA_START + 0x4D4                # 2 bytes
-ROOMDATA_ADDR = SAVEDATA_START + 0x4D6              # 1 byte
-SCOUT_LOCATION_ADDR = SAVEDATA_START + 0x4D7        # 1 byte
-SCOUTREPLY_LOCATION_ADDR = SAVEDATA_START + 0x4D8   # 1 byte
-SCOUTREPLY_ITEM_ADDR = SAVEDATA_START + 0x4D9       # 1 byte
-SCOUTREPLY_PLAYER_ADDR = SAVEDATA_START + 0x4DA     # 1 byte
-SHOP_ADDR = SAVEDATA_START + 0x302                  # 2 bytes
-
-location_shop_order = [name for name, info in
-                       Shops.shop_table.items()]  # probably don't leave this here.  This relies on python 3.6+ dictionary keys having defined order
-location_shop_ids = set([info[0] for name, info in Shops.shop_table.items()])
-
-location_table_uw = {"Blind's Hideout - Top": (0x11d, 0x10),
-                     "Blind's Hideout - Left": (0x11d, 0x20),
-                     "Blind's Hideout - Right": (0x11d, 0x40),
-                     "Blind's Hideout - Far Left": (0x11d, 0x80),
-                     "Blind's Hideout - Far Right": (0x11d, 0x100),
-                     'Secret Passage': (0x55, 0x10),
-                     'Waterfall Fairy - Left': (0x114, 0x10),
-                     'Waterfall Fairy - Right': (0x114, 0x20),
-                     "King's Tomb": (0x113, 0x10),
-                     'Floodgate Chest': (0x10b, 0x10),
-                     "Link's House": (0x104, 0x10),
-                     'Kakariko Tavern': (0x103, 0x10),
-                     'Chicken House': (0x108, 0x10),
-                     "Aginah's Cave": (0x10a, 0x10),
-                     "Sahasrahla's Hut - Left": (0x105, 0x10),
-                     "Sahasrahla's Hut - Middle": (0x105, 0x20),
-                     "Sahasrahla's Hut - Right": (0x105, 0x40),
-                     'Kakariko Well - Top': (0x2f, 0x10),
-                     'Kakariko Well - Left': (0x2f, 0x20),
-                     'Kakariko Well - Middle': (0x2f, 0x40),
-                     'Kakariko Well - Right': (0x2f, 0x80),
-                     'Kakariko Well - Bottom': (0x2f, 0x100),
-                     'Lost Woods Hideout': (0xe1, 0x200),
-                     'Lumberjack Tree': (0xe2, 0x200),
-                     'Cave 45': (0x11b, 0x400),
-                     'Graveyard Cave': (0x11b, 0x200),
-                     'Checkerboard Cave': (0x126, 0x200),
-                     'Mini Moldorm Cave - Far Left': (0x123, 0x10),
-                     'Mini Moldorm Cave - Left': (0x123, 0x20),
-                     'Mini Moldorm Cave - Right': (0x123, 0x40),
-                     'Mini Moldorm Cave - Far Right': (0x123, 0x80),
-                     'Mini Moldorm Cave - Generous Guy': (0x123, 0x400),
-                     'Ice Rod Cave': (0x120, 0x10),
-                     'Bonk Rock Cave': (0x124, 0x10),
-                     'Desert Palace - Big Chest': (0x73, 0x10),
-                     'Desert Palace - Torch': (0x73, 0x400),
-                     'Desert Palace - Map Chest': (0x74, 0x10),
-                     'Desert Palace - Compass Chest': (0x85, 0x10),
-                     'Desert Palace - Big Key Chest': (0x75, 0x10),
-                     'Desert Palace - Desert Tiles 1 Pot Key': (0x63, 0x400),
-                     'Desert Palace - Beamos Hall Pot Key': (0x53, 0x400),
-                     'Desert Palace - Desert Tiles 2 Pot Key': (0x43, 0x400),
-                     'Desert Palace - Boss': (0x33, 0x800),
-                     'Eastern Palace - Compass Chest': (0xa8, 0x10),
-                     'Eastern Palace - Big Chest': (0xa9, 0x10),
-                     'Eastern Palace - Dark Square Pot Key': (0xba, 0x400),
-                     'Eastern Palace - Dark Eyegore Key Drop': (0x99, 0x400),
-                     'Eastern Palace - Cannonball Chest': (0xb9, 0x10),
-                     'Eastern Palace - Big Key Chest': (0xb8, 0x10),
-                     'Eastern Palace - Map Chest': (0xaa, 0x10),
-                     'Eastern Palace - Boss': (0xc8, 0x800),
-                     'Hyrule Castle - Boomerang Chest': (0x71, 0x10),
-                     'Hyrule Castle - Boomerang Guard Key Drop': (0x71, 0x400),
-                     'Hyrule Castle - Map Chest': (0x72, 0x10),
-                     'Hyrule Castle - Map Guard Key Drop': (0x72, 0x400),
-                     "Hyrule Castle - Zelda's Chest": (0x80, 0x10),
-                     'Hyrule Castle - Big Key Drop': (0x80, 0x400),
-                     'Sewers - Dark Cross': (0x32, 0x10),
-                     'Hyrule Castle - Key Rat Key Drop': (0x21, 0x400),
-                     'Sewers - Secret Room - Left': (0x11, 0x10),
-                     'Sewers - Secret Room - Middle': (0x11, 0x20),
-                     'Sewers - Secret Room - Right': (0x11, 0x40),
-                     'Sanctuary': (0x12, 0x10),
-                     'Castle Tower - Room 03': (0xe0, 0x10),
-                     'Castle Tower - Dark Maze': (0xd0, 0x10),
-                     'Castle Tower - Dark Archer Key Drop': (0xc0, 0x400),
-                     'Castle Tower - Circle of Pots Key Drop': (0xb0, 0x400),
-                     'Spectacle Rock Cave': (0xea, 0x400),
-                     'Paradox Cave Lower - Far Left': (0xef, 0x10),
-                     'Paradox Cave Lower - Left': (0xef, 0x20),
-                     'Paradox Cave Lower - Right': (0xef, 0x40),
-                     'Paradox Cave Lower - Far Right': (0xef, 0x80),
-                     'Paradox Cave Lower - Middle': (0xef, 0x100),
-                     'Paradox Cave Upper - Left': (0xff, 0x10),
-                     'Paradox Cave Upper - Right': (0xff, 0x20),
-                     'Spiral Cave': (0xfe, 0x10),
-                     'Tower of Hera - Basement Cage': (0x87, 0x400),
-                     'Tower of Hera - Map Chest': (0x77, 0x10),
-                     'Tower of Hera - Big Key Chest': (0x87, 0x10),
-                     'Tower of Hera - Compass Chest': (0x27, 0x20),
-                     'Tower of Hera - Big Chest': (0x27, 0x10),
-                     'Tower of Hera - Boss': (0x7, 0x800),
-                     'Hype Cave - Top': (0x11e, 0x10),
-                     'Hype Cave - Middle Right': (0x11e, 0x20),
-                     'Hype Cave - Middle Left': (0x11e, 0x40),
-                     'Hype Cave - Bottom': (0x11e, 0x80),
-                     'Hype Cave - Generous Guy': (0x11e, 0x400),
-                     'Peg Cave': (0x127, 0x400),
-                     'Pyramid Fairy - Left': (0x116, 0x10),
-                     'Pyramid Fairy - Right': (0x116, 0x20),
-                     'Brewery': (0x106, 0x10),
-                     'C-Shaped House': (0x11c, 0x10),
-                     'Chest Game': (0x106, 0x400),
-                     'Mire Shed - Left': (0x10d, 0x10),
-                     'Mire Shed - Right': (0x10d, 0x20),
-                     'Superbunny Cave - Top': (0xf8, 0x10),
-                     'Superbunny Cave - Bottom': (0xf8, 0x20),
-                     'Spike Cave': (0x117, 0x10),
-                     'Hookshot Cave - Top Right': (0x3c, 0x10),
-                     'Hookshot Cave - Top Left': (0x3c, 0x20),
-                     'Hookshot Cave - Bottom Right': (0x3c, 0x80),
-                     'Hookshot Cave - Bottom Left': (0x3c, 0x40),
-                     'Mimic Cave': (0x10c, 0x10),
-                     'Swamp Palace - Entrance': (0x28, 0x10),
-                     'Swamp Palace - Map Chest': (0x37, 0x10),
-                     'Swamp Palace - Pot Row Pot Key': (0x38, 0x400),
-                     'Swamp Palace - Trench 1 Pot Key': (0x37, 0x400),
-                     'Swamp Palace - Hookshot Pot Key': (0x36, 0x400),
-                     'Swamp Palace - Big Chest': (0x36, 0x10),
-                     'Swamp Palace - Compass Chest': (0x46, 0x10),
-                     'Swamp Palace - Trench 2 Pot Key': (0x35, 0x400),
-                     'Swamp Palace - Big Key Chest': (0x35, 0x10),
-                     'Swamp Palace - West Chest': (0x34, 0x10),
-                     'Swamp Palace - Flooded Room - Left': (0x76, 0x10),
-                     'Swamp Palace - Flooded Room - Right': (0x76, 0x20),
-                     'Swamp Palace - Waterfall Room': (0x66, 0x10),
-                     'Swamp Palace - Waterway Pot Key': (0x16, 0x400),
-                     'Swamp Palace - Boss': (0x6, 0x800),
-                     "Thieves' Town - Big Key Chest": (0xdb, 0x20),
-                     "Thieves' Town - Map Chest": (0xdb, 0x10),
-                     "Thieves' Town - Compass Chest": (0xdc, 0x10),
-                     "Thieves' Town - Ambush Chest": (0xcb, 0x10),
-                     "Thieves' Town - Hallway Pot Key": (0xbc, 0x400),
-                     "Thieves' Town - Spike Switch Pot Key": (0xab, 0x400),
-                     "Thieves' Town - Attic": (0x65, 0x10),
-                     "Thieves' Town - Big Chest": (0x44, 0x10),
-                     "Thieves' Town - Blind's Cell": (0x45, 0x10),
-                     "Thieves' Town - Boss": (0xac, 0x800),
-                     'Skull Woods - Compass Chest': (0x67, 0x10),
-                     'Skull Woods - Map Chest': (0x58, 0x20),
-                     'Skull Woods - Big Chest': (0x58, 0x10),
-                     'Skull Woods - Pot Prison': (0x57, 0x20),
-                     'Skull Woods - Pinball Room': (0x68, 0x10),
-                     'Skull Woods - Big Key Chest': (0x57, 0x10),
-                     'Skull Woods - West Lobby Pot Key': (0x56, 0x400),
-                     'Skull Woods - Bridge Room': (0x59, 0x10),
-                     'Skull Woods - Spike Corner Key Drop': (0x39, 0x400),
-                     'Skull Woods - Boss': (0x29, 0x800),
-                     'Ice Palace - Jelly Key Drop': (0x0e, 0x400),
-                     'Ice Palace - Compass Chest': (0x2e, 0x10),
-                     'Ice Palace - Conveyor Key Drop': (0x3e, 0x400),
-                     'Ice Palace - Freezor Chest': (0x7e, 0x10),
-                     'Ice Palace - Big Chest': (0x9e, 0x10),
-                     'Ice Palace - Iced T Room': (0xae, 0x10),
-                     'Ice Palace - Many Pots Pot Key': (0x9f, 0x400),
-                     'Ice Palace - Spike Room': (0x5f, 0x10),
-                     'Ice Palace - Big Key Chest': (0x1f, 0x10),
-                     'Ice Palace - Hammer Block Key Drop': (0x3f, 0x400),
-                     'Ice Palace - Map Chest': (0x3f, 0x10),
-                     'Ice Palace - Boss': (0xde, 0x800),
-                     'Misery Mire - Big Chest': (0xc3, 0x10),
-                     'Misery Mire - Map Chest': (0xc3, 0x20),
-                     'Misery Mire - Main Lobby': (0xc2, 0x10),
-                     'Misery Mire - Bridge Chest': (0xa2, 0x10),
-                     'Misery Mire - Spikes Pot Key': (0xb3, 0x400),
-                     'Misery Mire - Spike Chest': (0xb3, 0x10),
-                     'Misery Mire - Fishbone Pot Key': (0xa1, 0x400),
-                     'Misery Mire - Conveyor Crystal Key Drop': (0xc1, 0x400),
-                     'Misery Mire - Compass Chest': (0xc1, 0x10),
-                     'Misery Mire - Big Key Chest': (0xd1, 0x10),
-                     'Misery Mire - Boss': (0x90, 0x800),
-                     'Turtle Rock - Compass Chest': (0xd6, 0x10),
-                     'Turtle Rock - Roller Room - Left': (0xb7, 0x10),
-                     'Turtle Rock - Roller Room - Right': (0xb7, 0x20),
-                     'Turtle Rock - Pokey 1 Key Drop': (0xb6, 0x400),
-                     'Turtle Rock - Chain Chomps': (0xb6, 0x10),
-                     'Turtle Rock - Pokey 2 Key Drop': (0x13, 0x400),
-                     'Turtle Rock - Big Key Chest': (0x14, 0x10),
-                     'Turtle Rock - Big Chest': (0x24, 0x10),
-                     'Turtle Rock - Crystaroller Room': (0x4, 0x10),
-                     'Turtle Rock - Eye Bridge - Bottom Left': (0xd5, 0x80),
-                     'Turtle Rock - Eye Bridge - Bottom Right': (0xd5, 0x40),
-                     'Turtle Rock - Eye Bridge - Top Left': (0xd5, 0x20),
-                     'Turtle Rock - Eye Bridge - Top Right': (0xd5, 0x10),
-                     'Turtle Rock - Boss': (0xa4, 0x800),
-                     'Palace of Darkness - Shooter Room': (0x9, 0x10),
-                     'Palace of Darkness - The Arena - Bridge': (0x2a, 0x20),
-                     'Palace of Darkness - Stalfos Basement': (0xa, 0x10),
-                     'Palace of Darkness - Big Key Chest': (0x3a, 0x10),
-                     'Palace of Darkness - The Arena - Ledge': (0x2a, 0x10),
-                     'Palace of Darkness - Map Chest': (0x2b, 0x10),
-                     'Palace of Darkness - Compass Chest': (0x1a, 0x20),
-                     'Palace of Darkness - Dark Basement - Left': (0x6a, 0x10),
-                     'Palace of Darkness - Dark Basement - Right': (0x6a, 0x20),
-                     'Palace of Darkness - Dark Maze - Top': (0x19, 0x10),
-                     'Palace of Darkness - Dark Maze - Bottom': (0x19, 0x20),
-                     'Palace of Darkness - Big Chest': (0x1a, 0x10),
-                     'Palace of Darkness - Harmless Hellway': (0x1a, 0x40),
-                     'Palace of Darkness - Boss': (0x5a, 0x800),
-                     'Ganons Tower - Conveyor Cross Pot Key': (0x8b, 0x400),
-                     "Ganons Tower - Bob's Torch": (0x8c, 0x400),
-                     'Ganons Tower - Hope Room - Left': (0x8c, 0x20),
-                     'Ganons Tower - Hope Room - Right': (0x8c, 0x40),
-                     'Ganons Tower - Tile Room': (0x8d, 0x10),
-                     'Ganons Tower - Compass Room - Top Left': (0x9d, 0x10),
-                     'Ganons Tower - Compass Room - Top Right': (0x9d, 0x20),
-                     'Ganons Tower - Compass Room - Bottom Left': (0x9d, 0x40),
-                     'Ganons Tower - Compass Room - Bottom Right': (0x9d, 0x80),
-                     'Ganons Tower - Conveyor Star Pits Pot Key': (0x7b, 0x400),
-                     'Ganons Tower - DMs Room - Top Left': (0x7b, 0x10),
-                     'Ganons Tower - DMs Room - Top Right': (0x7b, 0x20),
-                     'Ganons Tower - DMs Room - Bottom Left': (0x7b, 0x40),
-                     'Ganons Tower - DMs Room - Bottom Right': (0x7b, 0x80),
-                     'Ganons Tower - Map Chest': (0x8b, 0x10),
-                     'Ganons Tower - Double Switch Pot Key': (0x9b, 0x400),
-                     'Ganons Tower - Firesnake Room': (0x7d, 0x10),
-                     'Ganons Tower - Randomizer Room - Top Left': (0x7c, 0x10),
-                     'Ganons Tower - Randomizer Room - Top Right': (0x7c, 0x20),
-                     'Ganons Tower - Randomizer Room - Bottom Left': (0x7c, 0x40),
-                     'Ganons Tower - Randomizer Room - Bottom Right': (0x7c, 0x80),
-                     "Ganons Tower - Bob's Chest": (0x8c, 0x80),
-                     'Ganons Tower - Big Chest': (0x8c, 0x10),
-                     'Ganons Tower - Big Key Room - Left': (0x1c, 0x20),
-                     'Ganons Tower - Big Key Room - Right': (0x1c, 0x40),
-                     'Ganons Tower - Big Key Chest': (0x1c, 0x10),
-                     'Ganons Tower - Mini Helmasaur Room - Left': (0x3d, 0x10),
-                     'Ganons Tower - Mini Helmasaur Room - Right': (0x3d, 0x20),
-                     'Ganons Tower - Mini Helmasaur Key Drop': (0x3d, 0x400),
-                     'Ganons Tower - Pre-Moldorm Chest': (0x3d, 0x40),
-                     'Ganons Tower - Validation Chest': (0x4d, 0x10)}
-
-location_table_uw_id = {Regions.lookup_name_to_id[name] : data for name, data in location_table_uw.items()}
-
-location_table_npc = {'Mushroom': 0x1000,
-                      'King Zora': 0x2,
-                      'Sahasrahla': 0x10,
-                      'Blacksmith': 0x400,
-                      'Magic Bat': 0x8000,
-                      'Sick Kid': 0x4,
-                      'Library': 0x80,
-                      'Potion Shop': 0x2000,
-                      'Old Man': 0x1,
-                      'Ether Tablet': 0x100,
-                      'Catfish': 0x20,
-                      'Stumpy': 0x8,
-                      'Bombos Tablet': 0x200}
-
-location_table_npc_id = {Regions.lookup_name_to_id[name] : data for name, data in location_table_npc.items()}
-
-location_table_ow = {'Flute Spot': 0x2a,
-                     'Sunken Treasure': 0x3b,
-                     "Zora's Ledge": 0x81,
-                     'Lake Hylia Island': 0x35,
-                     'Maze Race': 0x28,
-                     'Desert Ledge': 0x30,
-                     'Master Sword Pedestal': 0x80,
-                     'Spectacle Rock': 0x3,
-                     'Pyramid': 0x5b,
-                     'Digging Game': 0x68,
-                     'Bumper Cave Ledge': 0x4a,
-                     'Floating Island': 0x5}
-
-location_table_ow_id = {Regions.lookup_name_to_id[name] : data for name, data in location_table_ow.items()}
-
-location_table_misc = {'Bottle Merchant': (0x3c9, 0x2),
-                       'Purple Chest': (0x3c9, 0x10),
-                       "Link's Uncle": (0x3c6, 0x1),
-                       'Hobo': (0x3c9, 0x1)}
-
-location_table_misc_id = {Regions.lookup_name_to_id[name] : data for name, data in location_table_misc.items()}
-
-class SNESState(enum.IntEnum):
-    SNES_DISCONNECTED = 0
-    SNES_CONNECTING = 1
-    SNES_CONNECTED = 2
-    SNES_ATTACHED = 3
-
-
-def launch_qusb2snes(ctx: Context):
-    qusb2snes_path = Utils.get_options()["lttp_options"]["qusb2snes"]
-
-    if not os.path.isfile(qusb2snes_path):
-        qusb2snes_path = Utils.local_path(qusb2snes_path)
-
-    if os.path.isfile(qusb2snes_path):
-        logger.info(f"Attempting to start {qusb2snes_path}")
-        import subprocess
-        subprocess.Popen(qusb2snes_path, cwd=os.path.dirname(qusb2snes_path))
-    else:
-        logger.info(
-            f"Attempt to start (Q)Usb2Snes was aborted as path {qusb2snes_path} was not found, "
-            f"please start it yourself if it is not running")
-
-
-async def _snes_connect(ctx: Context, address: str):
-    address = f"ws://{address}" if "://" not in address else address
-
-    logger.info("Connecting to QUsb2snes at %s ..." % address)
-    seen_problems = set()
-    succesful = False
-    while not succesful:
-        try:
-            snes_socket = await websockets.connect(address, ping_timeout=None, ping_interval=None)
-            succesful = True
-        except Exception as e:
-            problem = "%s" % e
-            # only tell the user about new problems, otherwise silently lay in wait for a working connection
-            if problem not in seen_problems:
-                seen_problems.add(problem)
-                logger.error(f"Error connecting to QUsb2snes ({problem})")
-
-                if len(seen_problems) == 1:
-                    # this is the first problem. Let's try launching QUsb2snes if it isn't already running
-                    launch_qusb2snes(ctx)
-
-            await asyncio.sleep(1)
-        else:
-            return snes_socket
-
-
-async def get_snes_devices(ctx: Context):
-    socket = await _snes_connect(ctx, ctx.snes_address)  # establish new connection to poll
-    DeviceList_Request = {
-        "Opcode": "DeviceList",
-        "Space": "SNES"
-    }
-    await socket.send(dumps(DeviceList_Request))
-
-    reply = loads(await socket.recv())
-    devices = reply['Results'] if 'Results' in reply and len(reply['Results']) > 0 else None
-
-    if not devices:
-        logger.info('No SNES device found. Ensure QUsb2Snes is running and connect it to the multibridge.')
-        while not devices:
-            await asyncio.sleep(1)
-            await socket.send(dumps(DeviceList_Request))
-            reply = loads(await socket.recv())
-            devices = reply['Results'] if 'Results' in reply and len(reply['Results']) > 0 else None
-
-
-    await socket.close()
-    return devices
-
-
-async def snes_connect(ctx: Context, address):
-    global SNES_RECONNECT_DELAY
-    if ctx.snes_socket is not None and ctx.snes_state == SNESState.SNES_CONNECTED:
-        logger.error('Already connected to snes')
-        return
-
-    recv_task = None
-    ctx.snes_state = SNESState.SNES_CONNECTING
-    socket = await _snes_connect(ctx, address)
-    ctx.snes_socket = socket
-    ctx.snes_state = SNESState.SNES_CONNECTED
-
-    try:
-        devices = await get_snes_devices(ctx)
-
-        if len(devices) == 1:
-            device = devices[0]
-        elif ctx.snes_reconnect_address:
-            if ctx.snes_attached_device[1] in devices:
-                device = ctx.snes_attached_device[1]
-            else:
-                device = devices[ctx.snes_attached_device[0]]
-        else:
-            await snes_disconnect(ctx)
-            return
-
-        logger.info("Attaching to " + device)
-
-        Attach_Request = {
-            "Opcode": "Attach",
-            "Space": "SNES",
-            "Operands": [device]
-        }
-        await ctx.snes_socket.send(dumps(Attach_Request))
-        ctx.snes_state = SNESState.SNES_ATTACHED
-        ctx.snes_attached_device = (devices.index(device), device)
-
-        if 'sd2snes' in device.lower() or 'COM' in device:
-            logger.info("SD2SNES/FXPAK Detected")
-            ctx.is_sd2snes = True
-            await ctx.snes_socket.send(dumps({"Opcode": "Info", "Space": "SNES"}))
-            reply = loads(await ctx.snes_socket.recv())
-            if reply and 'Results' in reply:
-                logger.info(reply['Results'])
-        else:
-            ctx.is_sd2snes = False
-
-        ctx.snes_reconnect_address = address
-        recv_task = asyncio.create_task(snes_recv_loop(ctx))
-        SNES_RECONNECT_DELAY = ctx.starting_reconnect_delay
-
-    except Exception as e:
-        if recv_task is not None:
-            if not ctx.snes_socket.closed:
-                await ctx.snes_socket.close()
-        else:
-            if ctx.snes_socket is not None:
-                if not ctx.snes_socket.closed:
-                    await ctx.snes_socket.close()
-                ctx.snes_socket = None
-            ctx.snes_state = SNESState.SNES_DISCONNECTED
-        if not ctx.snes_reconnect_address:
-            logger.error("Error connecting to snes (%s)" % e)
-        else:
-            logger.error(f"Error connecting to snes, attempt again in {SNES_RECONNECT_DELAY}s")
-            asyncio.create_task(snes_autoreconnect(ctx))
-        SNES_RECONNECT_DELAY *= 2
-
-
-async def snes_disconnect(ctx: Context):
-    if ctx.snes_socket:
-        if not ctx.snes_socket.closed:
-            await ctx.snes_socket.close()
-        ctx.snes_socket = None
-
-
-async def snes_autoreconnect(ctx: Context):
-    # unfortunately currently broken. See: https://github.com/prompt-toolkit/python-prompt-toolkit/issues/1033
-    # with prompt_toolkit.shortcuts.ProgressBar() as pb:
-    #    for _ in pb(range(100)):
-    #        await asyncio.sleep(RECONNECT_DELAY/100)
-
-    await asyncio.sleep(SNES_RECONNECT_DELAY)
-    if ctx.snes_reconnect_address and ctx.snes_socket is None:
-        await snes_connect(ctx, ctx.snes_reconnect_address)
-
-
-async def snes_recv_loop(ctx: Context):
-    try:
-        async for msg in ctx.snes_socket:
-            ctx.snes_recv_queue.put_nowait(msg)
-        logger.warning("Snes disconnected")
-    except Exception as e:
-        if not isinstance(e, websockets.WebSocketException):
-            logger.exception(e)
-        logger.error("Lost connection to the snes, type /snes to reconnect")
-    finally:
-        socket, ctx.snes_socket = ctx.snes_socket, None
-        if socket is not None and not socket.closed:
-            await socket.close()
-
-        ctx.snes_state = SNESState.SNES_DISCONNECTED
-        ctx.snes_recv_queue = asyncio.Queue()
-        ctx.hud_message_queue = []
-
-        ctx.rom = None
-
-        if ctx.snes_reconnect_address:
-            logger.info(f"...reconnecting in {SNES_RECONNECT_DELAY}s")
-            asyncio.create_task(snes_autoreconnect(ctx))
-
-
-async def snes_read(ctx: Context, address, size):
-    try:
-        await ctx.snes_request_lock.acquire()
-
-        if ctx.snes_state != SNESState.SNES_ATTACHED or ctx.snes_socket is None or not ctx.snes_socket.open or ctx.snes_socket.closed:
-            return None
-
-        GetAddress_Request = {
-            "Opcode": "GetAddress",
-            "Space": "SNES",
-            "Operands": [hex(address)[2:], hex(size)[2:]]
-        }
-        try:
-            await ctx.snes_socket.send(dumps(GetAddress_Request))
-        except websockets.ConnectionClosed:
-            return None
-
-        data = bytes()
-        while len(data) < size:
-            try:
-                data += await asyncio.wait_for(ctx.snes_recv_queue.get(), 5)
-            except asyncio.TimeoutError:
-                break
-
-        if len(data) != size:
-            logger.error('Error reading %s, requested %d bytes, received %d' % (hex(address), size, len(data)))
-            if len(data):
-                logger.error(str(data))
-                logger.warning('Unable to connect to SNES Device because QUsb2Snes broke temporarily.'
-                               'Try un-selecting and re-selecting the SNES Device.')
-            if ctx.snes_socket is not None and not ctx.snes_socket.closed:
-                await ctx.snes_socket.close()
-            return None
-
-        return data
-    finally:
-        ctx.snes_request_lock.release()
-
-
-async def snes_write(ctx: Context, write_list):
-    try:
-        await ctx.snes_request_lock.acquire()
-
-        if ctx.snes_state != SNESState.SNES_ATTACHED or ctx.snes_socket is None or \
-                not ctx.snes_socket.open or ctx.snes_socket.closed:
-            return False
-
-        PutAddress_Request = {"Opcode": "PutAddress", "Operands": [], 'Space': 'SNES'}
-
-        if ctx.is_sd2snes:
-            cmd = b'\x00\xE2\x20\x48\xEB\x48'
-
-            for address, data in write_list:
-                if (address < WRAM_START) or ((address + len(data)) > (WRAM_START + WRAM_SIZE)):
-                    logger.error("SD2SNES: Write out of range %s (%d)" % (hex(address), len(data)))
-                    return False
-                for ptr, byte in enumerate(data, address + 0x7E0000 - WRAM_START):
-                    cmd += b'\xA9'  # LDA
-                    cmd += bytes([byte])
-                    cmd += b'\x8F'  # STA.l
-                    cmd += bytes([ptr & 0xFF, (ptr >> 8) & 0xFF, (ptr >> 16) & 0xFF])
-
-            cmd += b'\xA9\x00\x8F\x00\x2C\x00\x68\xEB\x68\x28\x6C\xEA\xFF\x08'
-
-            PutAddress_Request['Space'] = 'CMD'
-            PutAddress_Request['Operands'] = ["2C00", hex(len(cmd) - 1)[2:], "2C00", "1"]
-            try:
-                if ctx.snes_socket is not None:
-                    await ctx.snes_socket.send(dumps(PutAddress_Request))
-                    await ctx.snes_socket.send(cmd)
-                else:
-                    logger.warning(f"Could not send data to SNES: {cmd}")
-            except websockets.ConnectionClosed:
-                return False
-        else:
-            PutAddress_Request['Space'] = 'SNES'
-            try:
-                # will pack those requests as soon as qusb2snes actually supports that for real
-                for address, data in write_list:
-                    PutAddress_Request['Operands'] = [hex(address)[2:], hex(len(data))[2:]]
-                    if ctx.snes_socket is not None:
-                        await ctx.snes_socket.send(dumps(PutAddress_Request))
-                        await ctx.snes_socket.send(data)
-                    else:
-                        logger.warning(f"Could not send data to SNES: {data}")
-            except websockets.ConnectionClosed:
-                return False
-
-        return True
-    finally:
-        ctx.snes_request_lock.release()
-
-
-def snes_buffered_write(ctx: Context, address, data):
-    if ctx.snes_write_buffer and (ctx.snes_write_buffer[-1][0] + len(ctx.snes_write_buffer[-1][1])) == address:
-        # append to existing write command, bundling them
-        ctx.snes_write_buffer[-1] = (ctx.snes_write_buffer[-1][0], ctx.snes_write_buffer[-1][1] + data)
-    else:
-        ctx.snes_write_buffer.append((address, data))
-
-
-async def snes_flush_writes(ctx: Context):
-    if not ctx.snes_write_buffer:
-        return
-
-    # swap buffers
-    ctx.snes_write_buffer, writes = [], ctx.snes_write_buffer
-    await snes_write(ctx, writes)
-
-
-# kept as function for easier wrapping by plugins
-def get_tags(ctx: Context):
-    tags = ['AP']
-    return tags
-
-
-
-
-
-async def track_locations(ctx: Context, roomid, roomdata):
-    new_locations = []
-
-    def new_check(location_id):
-        new_locations.append(location_id)
-        ctx.locations_checked.add(location_id)
-        location = ctx.location_name_getter(location_id)
-        logger.info(f'New Check: {location} ({len(ctx.locations_checked)}/{len(ctx.missing_locations) + len(ctx.checked_locations)})')
-
-    try:
-        if roomid in location_shop_ids:
-            misc_data = await snes_read(ctx, SHOP_ADDR, (len(location_shop_order) * 3) + 5)
-            for cnt, b in enumerate(misc_data):
-                if int(b) and (Shops.SHOP_ID_START + cnt) not in ctx.locations_checked:
-                    new_check(Shops.SHOP_ID_START + cnt)
-    except Exception as e:
-        logger.info(f"Exception: {e}")
-
-    for location_id, (loc_roomid, loc_mask) in location_table_uw_id.items():
-        try:
-
-            if location_id not in ctx.locations_checked and loc_roomid == roomid and (
-                    roomdata << 4) & loc_mask != 0:
-                new_check(location_id)
-        except Exception as e:
-            logger.exception(f"Exception: {e}")
-
-    uw_begin = 0x129
-    ow_end = uw_end = 0
-    uw_unchecked = {}
-    for location, (roomid, mask) in location_table_uw.items():
-        location_id = Regions.lookup_name_to_id[location]
-        if location_id not in ctx.locations_checked:
-            uw_unchecked[location_id] = (roomid, mask)
-            uw_begin = min(uw_begin, roomid)
-            uw_end = max(uw_end, roomid + 1)
-
-    if uw_begin < uw_end:
-        uw_data = await snes_read(ctx, SAVEDATA_START + (uw_begin * 2), (uw_end - uw_begin) * 2)
-        if uw_data is not None:
-            for location_id, (roomid, mask) in uw_unchecked.items():
-                offset = (roomid - uw_begin) * 2
-                roomdata = uw_data[offset] | (uw_data[offset + 1] << 8)
-                if roomdata & mask != 0:
-                    new_check(location_id)
-
-    ow_begin = 0x82
-    ow_unchecked = {}
-    for location_id, screenid in location_table_ow_id.items():
-        if location_id not in ctx.locations_checked:
-            ow_unchecked[location_id] = screenid
-            ow_begin = min(ow_begin, screenid)
-            ow_end = max(ow_end, screenid + 1)
-
-    if ow_begin < ow_end:
-        ow_data = await snes_read(ctx, SAVEDATA_START + 0x280 + ow_begin, ow_end - ow_begin)
-        if ow_data is not None:
-            for location_id, screenid in ow_unchecked.items():
-                if ow_data[screenid - ow_begin] & 0x40 != 0:
-                    new_check(location_id)
-
-    if not ctx.locations_checked.issuperset(location_table_npc_id):
-        npc_data = await snes_read(ctx, SAVEDATA_START + 0x410, 2)
-        if npc_data is not None:
-            npc_value = npc_data[0] | (npc_data[1] << 8)
-            for location_id, mask in location_table_npc_id.items():
-                if npc_value & mask != 0 and location_id not in ctx.locations_checked:
-                    new_check(location_id)
-
-    if not ctx.locations_checked.issuperset(location_table_misc_id):
-        misc_data = await snes_read(ctx, SAVEDATA_START + 0x3c6, 4)
-        if misc_data is not None:
-            for location_id, (offset, mask) in location_table_misc_id.items():
-                assert (0x3c6 <= offset <= 0x3c9)
-                if misc_data[offset - 0x3c6] & mask != 0 and location_id not in ctx.locations_checked:
-                    new_check(location_id)
-
-
-    if new_locations:
-        await ctx.send_msgs([{"cmd": 'LocationChecks', "locations": new_locations}])
-
-
-async def game_watcher(ctx: Context):
-    prev_game_timer = 0
-    perf_counter = time.perf_counter()
-    while not ctx.exit_event.is_set():
-        try:
-            await asyncio.wait_for(ctx.watcher_event.wait(), 0.125)
-        except asyncio.TimeoutError:
-            pass
-        ctx.watcher_event.clear()
-
-        if not ctx.rom:
-            ctx.finished_game = False
-            rom = await snes_read(ctx, ROMNAME_START, ROMNAME_SIZE)
-            if rom is None or rom == bytes([0] * ROMNAME_SIZE):
-                continue
-
-            ctx.rom = rom
-            if not ctx.prev_rom or ctx.prev_rom != ctx.rom:
-                ctx.locations_checked = set()
-                ctx.locations_scouted = set()
-            ctx.prev_rom = ctx.rom
-
-            if ctx.awaiting_rom:
-                await ctx.server_auth(False)
-
-        if ctx.auth and ctx.auth != ctx.rom:
-            logger.warning("ROM change detected, please reconnect to the multiworld server")
-            await ctx.disconnect()
-
-        gamemode = await snes_read(ctx, WRAM_START + 0x10, 1)
-        gameend = await snes_read(ctx, SAVEDATA_START + 0x443, 1)
-        game_timer = await snes_read(ctx, SAVEDATA_START + 0x42E, 4)
-        if gamemode is None or gameend is None or game_timer is None or \
-                (gamemode[0] not in INGAME_MODES and gamemode[0] not in ENDGAME_MODES):
-            continue
-
-        delay = 7 if ctx.slow_mode else 2
-        if gameend[0]:
-            if not ctx.finished_game:
-                await ctx.send_msgs([{"cmd": "StatusUpdate", "status": ClientStatus.CLIENT_GOAL}])
-                ctx.finished_game = True
-
-            if time.perf_counter() - perf_counter < delay:
-                continue
-            else:
-                perf_counter = time.perf_counter()
-        else:
-            game_timer = game_timer[0] | (game_timer[1] << 8) | (game_timer[2] << 16) | (game_timer[3] << 24)
-            if abs(game_timer - prev_game_timer) < (delay * 60):
-                continue
-            else:
-                prev_game_timer = game_timer
-
-        if gamemode in ENDGAME_MODES:  # triforce room and credits
-            continue
-
-        data = await snes_read(ctx, RECV_PROGRESS_ADDR, 8)
-        if data is None:
-            continue
-
-        recv_index = data[0] | (data[1] << 8)
-        recv_item = data[2]
-        roomid = data[4] | (data[5] << 8)
-        roomdata = data[6]
-        scout_location = data[7]
-
-        if recv_index < len(ctx.items_received) and recv_item == 0:
-            item = ctx.items_received[recv_index]
-            logging.info('Received %s from %s (%s) (%d/%d in list)' % (
-                color(ctx.item_name_getter(item.item), 'red', 'bold'), color(ctx.player_names[item.player], 'yellow'),
-                ctx.location_name_getter(item.location), recv_index + 1, len(ctx.items_received)))
-            recv_index += 1
-            snes_buffered_write(ctx, RECV_PROGRESS_ADDR, bytes([recv_index & 0xFF, (recv_index >> 8) & 0xFF]))
-            snes_buffered_write(ctx, RECV_ITEM_ADDR, bytes([item.item]))
-            snes_buffered_write(ctx, RECV_ITEM_PLAYER_ADDR, bytes([item.player if item.player != ctx.slot else 0]))
-        if scout_location > 0 and scout_location in ctx.locations_info:
-            snes_buffered_write(ctx, SCOUTREPLY_LOCATION_ADDR, bytes([scout_location]))
-            snes_buffered_write(ctx, SCOUTREPLY_ITEM_ADDR, bytes([ctx.locations_info[scout_location][0]]))
-            snes_buffered_write(ctx, SCOUTREPLY_PLAYER_ADDR, bytes([ctx.locations_info[scout_location][1]]))
-
-        await snes_flush_writes(ctx)
-
-        if scout_location > 0 and scout_location not in ctx.locations_scouted:
-            ctx.locations_scouted.add(scout_location)
-            await ctx.send_msgs([{"cmd": "LocationScouts", "locations": [scout_location]}])
-        await track_locations(ctx, roomid, roomdata)
-
-
-async def run_game(romfile):
-    auto_start = Utils.get_options()["lttp_options"].get("rom_start", True)
-    if auto_start is True:
-        import webbrowser
-        webbrowser.open(romfile)
-    elif os.path.isfile(auto_start):
-        subprocess.Popen([auto_start, romfile],
-                         stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
-
-async def main():
-    multiprocessing.freeze_support()
-    parser = argparse.ArgumentParser()
-    parser.add_argument('diff_file', default="", type=str, nargs="?",
-                        help='Path to a Archipelago Binary Patch file')
-    parser.add_argument('--snes', default='localhost:8080', help='Address of the QUsb2snes server.')
-    parser.add_argument('--connect', default=None, help='Address of the multiworld host.')
-    parser.add_argument('--password', default=None, help='Password of the multiworld host.')
-    parser.add_argument('--loglevel', default='info', choices=['debug', 'info', 'warning', 'error', 'critical'])
-    parser.add_argument('--founditems', default=False, action='store_true',
-                        help='Show items found by other players for themselves.')
-    args = parser.parse_args()
-    logging.basicConfig(format='%(message)s', level=getattr(logging, args.loglevel.upper(), logging.INFO))
-    if args.diff_file:
-        import Patch
-        logging.info("Patch file was supplied. Creating sfc rom..")
-        meta, romfile = Patch.create_rom_file(args.diff_file)
-        args.connect = meta["server"]
-        logging.info(f"Wrote rom file to {romfile}")
-        adjustedromfile, adjusted = Utils.get_adjuster_settings(romfile)
-        if adjusted:
-            try:
-                shutil.move(adjustedromfile, romfile)
-                adjustedromfile = romfile
-            except Exception as e:
-                logging.exception(e)
-        asyncio.create_task(run_game(adjustedromfile if adjusted else romfile))
-
-    port = None
-
-    ctx = Context(args.snes, args.connect, args.password, args.founditems)
-    input_task = asyncio.create_task(console_loop(ctx), name="Input")
-
-    if ctx.server_task is None:
-        ctx.server_task = asyncio.create_task(server_loop(ctx), name="ServerLoop")
-
-    watcher_task = asyncio.create_task(game_watcher(ctx), name="GameWatcher")
-
-    await ctx.exit_event.wait()
-    ctx.server_address = None
-    ctx.snes_reconnect_address = None
-
-    await watcher_task
-
-    if ctx.server is not None and not ctx.server.socket.closed:
-        await ctx.server.socket.close()
-    if ctx.server_task is not None:
-        await ctx.server_task
-
-    if ctx.snes_socket is not None and not ctx.snes_socket.closed:
-        await ctx.snes_socket.close()
-
-    while ctx.input_requests > 0:
-        ctx.input_queue.put_nowait(None)
-        ctx.input_requests -= 1
-
-    await input_task
-
-
-if __name__ == '__main__':
-    colorama.init()
-    loop = asyncio.get_event_loop()
-    loop.run_until_complete(main())
-    loop.close()
-    colorama.deinit()
-    atexit.unregister(exit_func)

Main.py

@@ -1,281 +1,219 @@
-import copy
-from itertools import zip_longest
+import collections
+from itertools import zip_longest, chain
 import logging
 import os
-import random
 import time
 import zlib
 import concurrent.futures
 import pickle
-from typing import Dict, Tuple
+import tempfile
+import zipfile
+from typing import Dict, Tuple, Optional, Set
 
-from BaseClasses import MultiWorld, CollectionState, Region, Item
-from worlds.alttp.Items import ItemFactory, item_name_groups
-from worlds.alttp.Regions import create_regions, mark_light_world_regions, \
-    lookup_vanilla_location_to_entrance
-from worlds.alttp.InvertedRegions import create_inverted_regions, mark_dark_world_regions
-from worlds.alttp.EntranceShuffle import link_entrances, link_inverted_entrances, plando_connect
-from worlds.alttp.Rom import patch_rom, patch_race_rom, patch_enemizer, apply_rom_settings, LocalRom, get_hash_string
-from worlds.alttp.Rules import set_rules
-from worlds.alttp.Dungeons import create_dungeons, fill_dungeons, fill_dungeons_restrictive
+from BaseClasses import MultiWorld, CollectionState, Region, RegionType, LocationProgressType, Location
+from worlds.alttp.Items import item_name_groups
+from worlds.alttp.Regions import lookup_vanilla_location_to_entrance
 from Fill import distribute_items_restrictive, flood_items, balance_multiworld_progression, distribute_planned
-from worlds.alttp.Shops import create_shops, ShopSlotFill, SHOP_ID_START, total_shop_slots, FillDisabledShopSlots
-from worlds.alttp.ItemPool import generate_itempool, difficulties, fill_prizes
-from Utils import output_path, parse_player_names, get_options, __version__, _version_tuple
-from worlds.hk import gen_hollow
-from worlds.hk import create_regions as hk_create_regions
-from worlds.factorio import gen_factorio, factorio_create_regions
-from worlds.factorio.Mod import generate_mod
-from worlds.minecraft import gen_minecraft, fill_minecraft_slot_data, generate_mc_data
-from worlds.minecraft.Regions import minecraft_create_regions
-from worlds.generic.Rules import locality_rules
-from worlds import Games, lookup_any_item_name_to_id
-import Patch
+from worlds.alttp.Shops import SHOP_ID_START, total_shop_slots, FillDisabledShopSlots
+from Utils import output_path, get_options, __version__, version_tuple
+from worlds.generic.Rules import locality_rules, exclusion_rules, group_locality_rules
+from worlds import AutoWorld
 
-seeddigits = 20
+ordered_areas = (
+    'Light World', 'Dark World', 'Hyrule Castle', 'Agahnims Tower', 'Eastern Palace', 'Desert Palace',
+    'Tower of Hera', 'Palace of Darkness', 'Swamp Palace', 'Skull Woods', 'Thieves Town', 'Ice Palace',
+    'Misery Mire', 'Turtle Rock', 'Ganons Tower', "Total"
+)
 
 
-def get_seed(seed=None):
-    if seed is None:
-        random.seed(None)
-        return random.randint(0, pow(10, seeddigits) - 1)
-    return seed
-
-
-def get_same_seed(world: MultiWorld, seed_def: tuple) -> str:
-    seeds: Dict[tuple, str] = getattr(world, "__named_seeds", {})
-    if seed_def in seeds:
-        return seeds[seed_def]
-    seeds[seed_def] = str(world.random.randint(0, 2 ** 64))
-    world.__named_seeds = seeds
-    return seeds[seed_def]
-
-
-def main(args, seed=None):
+def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = None):
+    if not baked_server_options:
+        baked_server_options = get_options()["server_options"]
     if args.outputpath:
         os.makedirs(args.outputpath, exist_ok=True)
         output_path.cached_path = args.outputpath
 
     start = time.perf_counter()
-
     # initialize the world
     world = MultiWorld(args.multi)
 
-    logger = logging.getLogger('')
-    world.seed = get_seed(seed)
-    if args.race:
-        world.secure()
-    else:
-        world.random.seed(world.seed)
-    world.seed_name = str(args.outputname if args.outputname else world.seed)
+    logger = logging.getLogger()
+    world.set_seed(seed, args.race, str(args.outputname if args.outputname else world.seed))
 
     world.shuffle = args.shuffle.copy()
     world.logic = args.logic.copy()
     world.mode = args.mode.copy()
-    world.swordless = args.swordless.copy()
     world.difficulty = args.difficulty.copy()
     world.item_functionality = args.item_functionality.copy()
     world.timer = args.timer.copy()
-    world.progressive = args.progressive.copy()
     world.goal = args.goal.copy()
-    world.local_items = args.local_items.copy()
-    if hasattr(args, "algorithm"): # current GUI options
-        world.algorithm = args.algorithm
-        world.shuffleganon = args.shuffleganon
-        world.custom = args.custom
-        world.customitemarray = args.customitemarray
-
-    world.accessibility = args.accessibility.copy()
-    world.retro = args.retro.copy()
-
-    world.hints = args.hints.copy()
-
-    world.mapshuffle = args.mapshuffle.copy()
-    world.compassshuffle = args.compassshuffle.copy()
-    world.keyshuffle = args.keyshuffle.copy()
-    world.bigkeyshuffle = args.bigkeyshuffle.copy()
-    world.crystals_needed_for_ganon = {
-        player: world.random.randint(0, 7) if args.crystals_ganon[player] == 'random' else int(
-            args.crystals_ganon[player]) for player in range(1, world.players + 1)}
-    world.crystals_needed_for_gt = {
-        player: world.random.randint(0, 7) if args.crystals_gt[player] == 'random' else int(args.crystals_gt[player])
-        for player in range(1, world.players + 1)}
-    world.open_pyramid = args.open_pyramid.copy()
     world.boss_shuffle = args.shufflebosses.copy()
-    world.enemy_shuffle = args.enemy_shuffle.copy()
     world.enemy_health = args.enemy_health.copy()
     world.enemy_damage = args.enemy_damage.copy()
-    world.killable_thieves = args.killable_thieves.copy()
-    world.bush_shuffle = args.bush_shuffle.copy()
-    world.tile_shuffle = args.tile_shuffle.copy()
-    world.beemizer = args.beemizer.copy()
+    world.beemizer_total_chance = args.beemizer_total_chance.copy()
+    world.beemizer_trap_chance = args.beemizer_trap_chance.copy()
     world.timer = args.timer.copy()
     world.countdown_start_time = args.countdown_start_time.copy()
     world.red_clock_time = args.red_clock_time.copy()
     world.blue_clock_time = args.blue_clock_time.copy()
     world.green_clock_time = args.green_clock_time.copy()
-    world.shufflepots = args.shufflepots.copy()
-    world.progressive = args.progressive.copy()
     world.dungeon_counters = args.dungeon_counters.copy()
-    world.glitch_boots = args.glitch_boots.copy()
     world.triforce_pieces_available = args.triforce_pieces_available.copy()
     world.triforce_pieces_required = args.triforce_pieces_required.copy()
     world.shop_shuffle = args.shop_shuffle.copy()
-    world.shop_shuffle_slots = args.shop_shuffle_slots.copy()
-    world.progression_balancing = args.progression_balancing.copy()
     world.shuffle_prizes = args.shuffle_prizes.copy()
     world.sprite_pool = args.sprite_pool.copy()
     world.dark_room_logic = args.dark_room_logic.copy()
     world.plando_items = args.plando_items.copy()
     world.plando_texts = args.plando_texts.copy()
     world.plando_connections = args.plando_connections.copy()
-    world.er_seeds = getattr(args, "er_seeds", {})
-    world.restrict_dungeon_item_on_boss = args.restrict_dungeon_item_on_boss.copy()
     world.required_medallions = args.required_medallions.copy()
     world.game = args.game.copy()
-    import Options
-    for hk_option in Options.hollow_knight_options:
-        setattr(world, hk_option, getattr(args, hk_option, {}))
-    for factorio_option in Options.factorio_options:
-        setattr(world, factorio_option, getattr(args, factorio_option, {}))
-    for minecraft_option in Options.minecraft_options: 
-        setattr(world, minecraft_option, getattr(args, minecraft_option, {}))
+    world.player_name = args.name.copy()
+    world.enemizer = args.enemizercli
+    world.sprite = args.sprite.copy()
     world.glitch_triforce = args.glitch_triforce  # This is enabled/disabled globally, no per player option.
 
-    world.rom_seeds = {player: random.Random(world.random.randint(0, 999999999)) for player in range(1, world.players + 1)}
-
-    for player in range(1, world.players+1):
-        world.er_seeds[player] = str(world.random.randint(0, 2 ** 64))
-
-        if "-" in world.shuffle[player]:
-            shuffle, seed = world.shuffle[player].split("-", 1)
-            world.shuffle[player] = shuffle
-            if shuffle == "vanilla":
-                world.er_seeds[player] = "vanilla"
-            elif seed.startswith("group-") or args.race:
-                # renamed from team to group to not confuse with existing team name use
-                world.er_seeds[player] = get_same_seed(world, (shuffle, seed, world.retro[player], world.mode[player], world.logic[player]))
-            else:  # not a race or group seed, use set seed as is.
-                world.er_seeds[player] = seed
-        elif world.shuffle[player] == "vanilla":
-            world.er_seeds[player] = "vanilla"
-
+    world.set_options(args)
+    world.set_item_links()
+    world.state = CollectionState(world)
     logger.info('Archipelago Version %s  -  Seed: %s\n', __version__, world.seed)
 
-    parsed_names = parse_player_names(args.names, world.players, args.teams)
-    world.teams = len(parsed_names)
-    for i, team in enumerate(parsed_names, 1):
-        if world.players > 1:
-            logger.info('%s%s', 'Team%d: ' % i if world.teams > 1 else 'Players: ', ', '.join(team))
-        for player, name in enumerate(team, 1):
-            world.player_names[player].append(name)
+    logger.info("Found World Types:")
+    longest_name = max(len(text) for text in AutoWorld.AutoWorldRegister.world_types)
+    numlength = 8
+    for name, cls in AutoWorld.AutoWorldRegister.world_types.items():
+        if not cls.hidden:
+            logger.info(f"  {name:{longest_name}}: {len(cls.item_names):3} "
+                        f"Items (IDs: {min(cls.item_id_to_name):{numlength}} - "
+                        f"{max(cls.item_id_to_name):{numlength}}) | "
+                        f"{len(cls.location_names):3} "
+                        f"Locations (IDs: {min(cls.location_id_to_name):{numlength}} - "
+                        f"{max(cls.location_id_to_name):{numlength}})")
+
+    AutoWorld.call_stage(world, "assert_generate")
+
+    AutoWorld.call_all(world, "generate_early")
 
     logger.info('')
-    for player in world.alttp_player_ids:
-        world.difficulty_requirements[player] = difficulties[world.difficulty[player]]
 
     for player in world.player_ids:
-        for item_name in args.startinventory[player]:
-            item = Item(item_name, True, lookup_any_item_name_to_id[item_name], player)
-            item.game = world.game[player]
-            world.push_precollected(item)
+        for item_name, count in world.start_inventory[player].value.items():
+            for _ in range(count):
+                world.push_precollected(world.create_item(item_name, player))
 
     for player in world.player_ids:
+        if player in world.get_game_players("A Link to the Past"):
+            # enforce pre-defined local items.
+            if world.goal[player] in ["localtriforcehunt", "localganontriforcehunt"]:
+                world.local_items[player].value.add('Triforce Piece')
 
-        # enforce pre-defined local items.
-        if world.goal[player] in ["localtriforcehunt", "localganontriforcehunt"]:
-            world.local_items[player].add('Triforce Piece')
+            # Not possible to place pendants/crystals out side of boss prizes yet.
+            world.non_local_items[player].value -= item_name_groups['Pendants']
+            world.non_local_items[player].value -= item_name_groups['Crystals']
 
         # items can't be both local and non-local, prefer local
-        world.non_local_items[player] -= world.local_items[player]
+        world.non_local_items[player].value -= world.local_items[player].value
 
-        # dungeon items can't be in non-local if the appropriate dungeon item shuffle setting is not set.
-        if not world.mapshuffle[player]:
-            world.non_local_items[player] -= item_name_groups['Maps']
+    logger.info('Creating World.')
+    AutoWorld.call_all(world, "create_regions")
 
-        if not world.compassshuffle[player]:
-            world.non_local_items[player] -= item_name_groups['Compasses']
-
-        if not world.keyshuffle[player]:
-            world.non_local_items[player] -= item_name_groups['Small Keys']
-
-        if not world.bigkeyshuffle[player]:
-            world.non_local_items[player] -= item_name_groups['Big Keys']
-
-        # Not possible to place pendants/crystals out side of boss prizes yet.
-        world.non_local_items[player] -= item_name_groups['Pendants']
-        world.non_local_items[player] -= item_name_groups['Crystals']
-
-    for player in world.hk_player_ids:
-        hk_create_regions(world, player)
-
-    for player in world.factorio_player_ids:
-        factorio_create_regions(world, player)
-
-    for player in world.minecraft_player_ids:
-        minecraft_create_regions(world, player)
-
-    for player in world.alttp_player_ids:
-        if world.open_pyramid[player] == 'goal':
-            world.open_pyramid[player] = world.goal[player] in {'crystals', 'ganontriforcehunt', 'localganontriforcehunt', 'ganonpedestal'}
-        elif world.open_pyramid[player] == 'auto':
-            world.open_pyramid[player] = world.goal[player] in {'crystals', 'ganontriforcehunt', 'localganontriforcehunt', 'ganonpedestal'} and \
-                                         (world.shuffle[player] in {'vanilla', 'dungeonssimple', 'dungeonsfull', 'dungeonscrossed'} or not world.shuffle_ganon)
-        else:
-            world.open_pyramid[player] = {'on': True, 'off': False, 'yes': True, 'no': False}.get(world.open_pyramid[player], world.open_pyramid[player])
-
-
-        world.triforce_pieces_available[player] = max(world.triforce_pieces_available[player], world.triforce_pieces_required[player])
-
-        if world.mode[player] != 'inverted':
-            create_regions(world, player)
-        else:
-            create_inverted_regions(world, player)
-        create_shops(world, player)
-        create_dungeons(world, player)
-
-    logger.info('Shuffling the World about.')
-
-    for player in world.alttp_player_ids:
-        if world.logic[player] not in ["noglitches", "minorglitches"] and world.shuffle[player] in \
-                {"vanilla", "dungeonssimple", "dungeonsfull", "simple", "restricted", "full"}:
-            world.fix_fake_world[player] = False
-
-        # seeded entrance shuffle
-        old_random = world.random
-        world.random = random.Random(world.er_seeds[player])
-
-        if world.mode[player] != 'inverted':
-            link_entrances(world, player)
-            mark_light_world_regions(world, player)
-        else:
-            link_inverted_entrances(world, player)
-            mark_dark_world_regions(world, player)
-
-        world.random = old_random
-        plando_connect(world, player)
-
-    logger.info('Generating Item Pool.')
-
-    for player in world.alttp_player_ids:
-        generate_itempool(world, player)
+    logger.info('Creating Items.')
+    AutoWorld.call_all(world, "create_items")
 
     logger.info('Calculating Access Rules.')
     if world.players > 1:
         for player in world.player_ids:
             locality_rules(world, player)
+        group_locality_rules(world)
+    else:
+        world.non_local_items[1].value = set()
+        world.local_items[1].value = set()
 
-    for player in world.alttp_player_ids:
-        set_rules(world, player)
+    AutoWorld.call_all(world, "set_rules")
 
-    for player in world.hk_player_ids:
-        gen_hollow(world, player)
+    for player in world.player_ids:
+        exclusion_rules(world, player, world.exclude_locations[player].value)
+        world.priority_locations[player].value -= world.exclude_locations[player].value
+        for location_name in world.priority_locations[player].value:
+            world.get_location(location_name, player).progress_type = LocationProgressType.PRIORITY
 
-    for player in world.factorio_player_ids:
-        gen_factorio(world, player)
+    AutoWorld.call_all(world, "generate_basic")
 
-    for player in world.minecraft_player_ids:
-        gen_minecraft(world, player)
+    # temporary home for item links, should be moved out of Main
+    for group_id, group in world.groups.items():
+        def find_common_pool(players: Set[int], shared_pool: Set[str]):
+            classifications = collections.defaultdict(int)
+            counters = {player: {name: 0 for name in shared_pool} for player in players}
+            for item in world.itempool:
+                if item.player in counters and item.name in shared_pool:
+                    counters[item.player][item.name] += 1
+                    classifications[item.name] |= item.classification
+
+            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 = []
+        for item_name, item_count in next(iter(common_item_count.values())).items():
+            for _ in range(item_count):
+                new_item = group["world"].create_item(item_name)
+                # mangle together all original classification bits
+                new_item.classification |= classifications[item_name]
+                new_itempool.append(new_item)
+
+        region = Region("Menu", RegionType.Generic, "ItemLink", group_id, world)
+        world.regions.append(region)
+        locations = region.locations = []
+        for item in world.itempool:
+            count = common_item_count.get(item.player, {}).get(item.name, 0)
+            if count:
+                loc = Location(group_id, f"Item Link: {item.name} -> {world.player_name[item.player]} {count}",
+                               None, region)
+                loc.access_rule = lambda state, item_name = item.name, group_id_ = group_id, count_ = count: \
+                    state.has(item_name, group_id_, count_)
+
+                locations.append(loc)
+                loc.place_locked_item(item)
+                common_item_count[item.player][item.name] -= 1
+            else:
+                new_itempool.append(item)
+
+        itemcount = len(world.itempool)
+        world.itempool = new_itempool
+
+        while itemcount > len(world.itempool):
+            items_to_add = []
+            for player in group["players"]:
+                if group["replacement_items"][player]:
+                    items_to_add.append(AutoWorld.call_single(world, "create_item", player,
+                                                                group["replacement_items"][player]))
+                else:
+                    items_to_add.append(AutoWorld.call_single(world, "create_filler", player))
+            world.random.shuffle(items_to_add)
+            world.itempool.extend(items_to_add[:itemcount - len(world.itempool)])
+
+    if any(world.item_links.values()):
+        world._recache()
+        world._all_state = None
 
     logger.info("Running Item Plando")
 
@@ -284,310 +222,215 @@ def main(args, seed=None):
 
     distribute_planned(world)
 
-    logger.info('Placing Dungeon Prizes.')
+    logger.info('Running Pre Main Fill.')
 
-    fill_prizes(world)
+    AutoWorld.call_all(world, "pre_fill")
 
-    logger.info('Placing Dungeon Items.')
-
-    if world.algorithm in ['balanced', 'vt26'] or any(
-            list(args.mapshuffle.values()) + list(args.compassshuffle.values()) +
-            list(args.keyshuffle.values()) + list(args.bigkeyshuffle.values())):
-        fill_dungeons_restrictive(world)
-    else:
-        fill_dungeons(world)
-
-    logger.info('Fill the world.')
+    logger.info(f'Filling the world with {len(world.itempool)} items.')
 
     if world.algorithm == 'flood':
         flood_items(world)  # different algo, biased towards early game progress items
-    elif world.algorithm == 'vt25':
-        distribute_items_restrictive(world, False)
-    elif world.algorithm == 'vt26':
-        distribute_items_restrictive(world, True)
     elif world.algorithm == 'balanced':
-        distribute_items_restrictive(world, True)
+        distribute_items_restrictive(world)
 
-    logger.info("Filling Shop Slots")
-
-    ShopSlotFill(world)
+    AutoWorld.call_all(world, 'post_fill')
 
     if world.players > 1:
         balance_multiworld_progression(world)
 
-    logger.info('Generating output files.')
+    logger.info(f'Beginning output...')
     outfilebase = 'AP_' + world.seed_name
-    rom_names = []
 
-    def _gen_rom(team: int, player: int):
-        use_enemizer = (world.boss_shuffle[player] != 'none' or world.enemy_shuffle[player]
-                        or world.enemy_health[player] != 'default' or world.enemy_damage[player] != 'default'
-                        or world.shufflepots[player] or world.bush_shuffle[player]
-                        or world.killable_thieves[player])
+    output = tempfile.TemporaryDirectory()
+    with output as temp_dir:
+        with concurrent.futures.ThreadPoolExecutor(world.players + 2) as pool:
+            check_accessibility_task = pool.submit(world.fulfills_accessibility)
 
-        rom = LocalRom(args.rom)
+            output_file_futures = [pool.submit(AutoWorld.call_stage, world, "generate_output", temp_dir)]
+            for player in world.player_ids:
+                # skip starting a thread for methods that say "pass".
+                if AutoWorld.World.generate_output.__code__ is not world.worlds[player].generate_output.__code__:
+                    output_file_futures.append(
+                        pool.submit(AutoWorld.call_single, world, "generate_output", player, temp_dir))
 
-        patch_rom(world, rom, player, team, use_enemizer)
+            def get_entrance_to_region(region: Region):
+                for entrance in region.entrances:
+                    if entrance.parent_region.type in (RegionType.DarkWorld, RegionType.LightWorld, RegionType.Generic):
+                        return entrance
+                for entrance in region.entrances:  # BFS might be better here, trying DFS for now.
+                    return get_entrance_to_region(entrance.parent_region)
 
-        if use_enemizer:
-            patch_enemizer(world, team, player, rom, args.enemizercli)
+            # collect ER hint info
+            er_hint_data = {player: {} for player in world.get_game_players("A Link to the Past") if
+                            world.shuffle[player] != "vanilla" or world.retro_caves[player]}
 
-        if args.race:
-            patch_race_rom(rom, world, player)
+            for region in world.regions:
+                if region.player in er_hint_data and region.locations:
+                    main_entrance = get_entrance_to_region(region)
+                    for location in region.locations:
+                        if type(location.address) == int:  # skips events and crystals
+                            if lookup_vanilla_location_to_entrance[location.address] != main_entrance.name:
+                                er_hint_data[region.player][location.address] = main_entrance.name
 
-        world.spoiler.hashes[(player, team)] = get_hash_string(rom.hash)
+            checks_in_area = {player: {area: list() for area in ordered_areas}
+                              for player in range(1, world.players + 1)}
 
-        palettes_options={}
-        palettes_options['dungeon']=args.uw_palettes[player]
-        palettes_options['overworld']=args.ow_palettes[player]
-        palettes_options['hud']=args.hud_palettes[player]
-        palettes_options['sword']=args.sword_palettes[player]
-        palettes_options['shield']=args.shield_palettes[player]
-        palettes_options['link']=args.link_palettes[player]
+            for player in range(1, world.players + 1):
+                checks_in_area[player]["Total"] = 0
 
-        apply_rom_settings(rom, args.heartbeep[player], args.heartcolor[player], args.quickswap[player],
-                           args.fastmenu[player], args.disablemusic[player], args.sprite[player],
-                           palettes_options, world, player, True,
-                           reduceflashing=args.reduceflashing[player] or args.race,
-                           triforcehud=args.triforcehud[player])
+            for location in world.get_filled_locations():
+                if type(location.address) is int:
+                    main_entrance = get_entrance_to_region(location.parent_region)
+                    if location.game != "A Link to the Past":
+                        checks_in_area[location.player]["Light World"].append(location.address)
+                    elif location.parent_region.dungeon:
+                        dungeonname = {'Inverted Agahnims Tower': 'Agahnims Tower',
+                                       'Inverted Ganons Tower': 'Ganons Tower'} \
+                            .get(location.parent_region.dungeon.name, location.parent_region.dungeon.name)
+                        checks_in_area[location.player][dungeonname].append(location.address)
+                    elif location.parent_region.type == RegionType.LightWorld:
+                        checks_in_area[location.player]["Light World"].append(location.address)
+                    elif location.parent_region.type == RegionType.DarkWorld:
+                        checks_in_area[location.player]["Dark World"].append(location.address)
+                    elif main_entrance.parent_region.type == RegionType.LightWorld:
+                        checks_in_area[location.player]["Light World"].append(location.address)
+                    elif main_entrance.parent_region.type == RegionType.DarkWorld:
+                        checks_in_area[location.player]["Dark World"].append(location.address)
+                    checks_in_area[location.player]["Total"] += 1
 
-        mcsb_name = ''
-        if all([world.mapshuffle[player], world.compassshuffle[player], world.keyshuffle[player],
-                world.bigkeyshuffle[player]]):
-            mcsb_name = '-keysanity'
-        elif [world.mapshuffle[player], world.compassshuffle[player], world.keyshuffle[player],
-              world.bigkeyshuffle[player]].count(True) == 1:
-            mcsb_name = '-mapshuffle' if world.mapshuffle[player] else \
-                '-compassshuffle' if world.compassshuffle[player] else \
-                '-universal_keys' if world.keyshuffle[player] == "universal" else \
-                '-keyshuffle' if world.keyshuffle[player] else '-bigkeyshuffle'
-        elif any([world.mapshuffle[player], world.compassshuffle[player], world.keyshuffle[player],
-                  world.bigkeyshuffle[player]]):
-            mcsb_name = '-%s%s%s%sshuffle' % (
-                'M' if world.mapshuffle[player] else '', 'C' if world.compassshuffle[player] else '',
-                'U' if world.keyshuffle[player] == "universal" else 'S' if world.keyshuffle[player] else '',
-                'B' if world.bigkeyshuffle[player] else '')
+            oldmancaves = []
+            takeanyregions = ["Old Man Sword Cave", "Take-Any #1", "Take-Any #2", "Take-Any #3", "Take-Any #4"]
+            for index, take_any in enumerate(takeanyregions):
+                for region in [world.get_region(take_any, player) for player in
+                               world.get_game_players("A Link to the Past") if world.retro_caves[player]]:
+                    item = world.create_item(
+                        region.shop.inventory[(0 if take_any == "Old Man Sword Cave" else 1)]['item'],
+                        region.player)
+                    player = region.player
+                    location_id = SHOP_ID_START + total_shop_slots + index
 
-        outfilepname = f'_P{player}'
-        outfilepname += f"_{world.player_names[player][team].replace(' ', '_')}" \
-            if world.player_names[player][team] != 'Player%d' % player else ''
-        outfilestuffs = {
-          "logic": world.logic[player],                                    # 0
-          "difficulty": world.difficulty[player],                          # 1
-          "item_functionality": world.item_functionality[player],          # 2
-          "mode": world.mode[player],                                      # 3
-          "goal": world.goal[player],                                      # 4
-          "timer": str(world.timer[player]),                               # 5
-          "shuffle": world.shuffle[player],                                # 6
-          "algorithm": world.algorithm,                                    # 7
-          "mscb": mcsb_name,                                               # 8
-          "retro": world.retro[player],                                    # 9
-          "progressive": world.progressive,                                # A
-          "hints": 'True' if world.hints[player] else 'False'              # B
-        }
-        #                  0  1  2  3  4 5  6  7 8 9 A B
-        outfilesuffix = ('_%s_%s-%s-%s-%s%s_%s-%s%s%s%s%s' % (
-          #  0          1      2      3    4     5    6      7     8        9         A     B           C
-          # _noglitches_normal-normal-open-ganon-ohko_simple-balanced-keysanity-retro-prog_random-nohints
-          # _noglitches_normal-normal-open-ganon     _simple-balanced-keysanity-retro
-          # _noglitches_normal-normal-open-ganon     _simple-balanced-keysanity      -prog_random
-          # _noglitches_normal-normal-open-ganon     _simple-balanced-keysanity                  -nohints
-          outfilestuffs["logic"], # 0
+                    main_entrance = get_entrance_to_region(region)
+                    if main_entrance.parent_region.type == RegionType.LightWorld:
+                        checks_in_area[player]["Light World"].append(location_id)
+                    else:
+                        checks_in_area[player]["Dark World"].append(location_id)
+                    checks_in_area[player]["Total"] += 1
 
-          outfilestuffs["difficulty"],              # 1
-          outfilestuffs["item_functionality"],      # 2
-          outfilestuffs["mode"],                    # 3
-          outfilestuffs["goal"],                    # 4
-          "" if outfilestuffs["timer"] in ['False', 'none', 'display'] else "-" + outfilestuffs["timer"], # 5
+                    er_hint_data[player][location_id] = main_entrance.name
+                    oldmancaves.append(((location_id, player), (item.code, player)))
 
-          outfilestuffs["shuffle"],     # 6
-          outfilestuffs["algorithm"],   # 7
-          outfilestuffs["mscb"],        # 8
+            FillDisabledShopSlots(world)
 
-          "-retro" if outfilestuffs["retro"] == "True" else "",  # 9
-          "-prog_" + outfilestuffs["progressive"] if outfilestuffs["progressive"] in ['off', 'random'] else "",  # A
-          "-nohints" if not outfilestuffs["hints"] == "True" else "")  # B
-        ) if not args.outputname else ''
-        rompath = output_path(f'{outfilebase}{outfilepname}{outfilesuffix}.sfc')
-        rom.write_to_file(rompath, hide_enemizer=True)
-        if args.create_diff:
-            Patch.create_patch_file(rompath, player=player, player_name = world.player_names[player][team])
-        return player, team, bytes(rom.name)
-
-    pool = concurrent.futures.ThreadPoolExecutor()
-
-    check_accessibility_task = pool.submit(world.fulfills_accessibility)
-
-    rom_futures = []
-    mod_futures = []
-    for team in range(world.teams):
-        for player in world.alttp_player_ids:
-            rom_futures.append(pool.submit(_gen_rom, team, player))
-    for player in world.factorio_player_ids:
-        mod_futures.append(pool.submit(generate_mod, world, player))
-
-    def get_entrance_to_region(region: Region):
-        for entrance in region.entrances:
-            if entrance.parent_region.type in (RegionType.DarkWorld, RegionType.LightWorld):
-                return entrance
-        for entrance in region.entrances:  # BFS might be better here, trying DFS for now.
-            return get_entrance_to_region(entrance.parent_region)
-
-    # collect ER hint info
-    er_hint_data = {player: {} for player in range(1, world.players + 1) if world.shuffle[player] != "vanilla" or world.retro[player]}
-    from worlds.alttp.Regions import RegionType
-    for region in world.regions:
-        if region.player in er_hint_data and region.locations:
-            main_entrance = get_entrance_to_region(region)
-            for location in region.locations:
-                if type(location.address) == int:  # skips events and crystals
-                    if lookup_vanilla_location_to_entrance[location.address] != main_entrance.name:
-                        er_hint_data[region.player][location.address] = main_entrance.name
-
-    ordered_areas = ('Light World', 'Dark World', 'Hyrule Castle', 'Agahnims Tower', 'Eastern Palace', 'Desert Palace',
-                     'Tower of Hera', 'Palace of Darkness', 'Swamp Palace', 'Skull Woods', 'Thieves Town', 'Ice Palace',
-                     'Misery Mire', 'Turtle Rock', 'Ganons Tower', "Total")
-
-    checks_in_area = {player: {area: list() for area in ordered_areas}
-                      for player in range(1, world.players + 1)}
-
-    for player in range(1, world.players + 1):
-        checks_in_area[player]["Total"] = 0
-
-    for location in [loc for loc in world.get_filled_locations() if type(loc.address) is int]:
-        main_entrance = get_entrance_to_region(location.parent_region)
-        if location.game != Games.LTTP:
-            checks_in_area[location.player]["Light World"].append(location.address)
-        elif location.parent_region.dungeon:
-            dungeonname = {'Inverted Agahnims Tower': 'Agahnims Tower',
-                           'Inverted Ganons Tower': 'Ganons Tower'}\
-                .get(location.parent_region.dungeon.name, location.parent_region.dungeon.name)
-            checks_in_area[location.player][dungeonname].append(location.address)
-        elif main_entrance.parent_region.type == RegionType.LightWorld:
-            checks_in_area[location.player]["Light World"].append(location.address)
-        elif main_entrance.parent_region.type == RegionType.DarkWorld:
-            checks_in_area[location.player]["Dark World"].append(location.address)
-        checks_in_area[location.player]["Total"] += 1
-
-    oldmancaves = []
-    takeanyregions = ["Old Man Sword Cave", "Take-Any #1", "Take-Any #2", "Take-Any #3", "Take-Any #4"]
-    for index, take_any in enumerate(takeanyregions):
-        for region in [world.get_region(take_any, player) for player in range(1, world.players + 1) if world.retro[player]]:
-            item = ItemFactory(region.shop.inventory[(0 if take_any == "Old Man Sword Cave" else 1)]['item'], region.player)
-            player = region.player
-            location_id = SHOP_ID_START + total_shop_slots + index
-
-            main_entrance = get_entrance_to_region(region)
-            if main_entrance.parent_region.type == RegionType.LightWorld:
-                checks_in_area[player]["Light World"].append(location_id)
-            else:
-                checks_in_area[player]["Dark World"].append(location_id)
-            checks_in_area[player]["Total"] += 1
-
-            er_hint_data[player][location_id] = main_entrance.name
-            oldmancaves.append(((location_id, player), (item.code, player)))
+            def write_multidata():
+                import NetUtils
+                slot_data = {}
+                client_versions = {}
+                games = {}
+                minimum_versions = {"server": AutoWorld.World.required_server_version, "clients": client_versions}
+                slot_info = {}
+                names = [[name for player, name in sorted(world.player_name.items())]]
+                for slot in world.player_ids:
+                    player_world: AutoWorld.World = world.worlds[slot]
+                    minimum_versions["server"] = max(minimum_versions["server"], player_world.required_server_version)
+                    client_versions[slot] = player_world.required_client_version
+                    games[slot] = world.game[slot]
+                    slot_info[slot] = NetUtils.NetworkSlot(names[0][slot - 1], world.game[slot],
+                                                           world.player_types[slot])
+                for slot, group in world.groups.items():
+                    games[slot] = world.game[slot]
+                    slot_info[slot] = NetUtils.NetworkSlot(group["name"], world.game[slot], world.player_types[slot],
+                                                           group_members=sorted(group["players"]))
+                precollected_items = {player: [item.code for item in world_precollected if type(item.code) == int]
+                                      for player, world_precollected in world.precollected_items.items()}
+                precollected_hints = {player: set() for player in range(1, world.players + 1 + len(world.groups))}
 
 
+                for slot in world.player_ids:
+                    slot_data[slot] = world.worlds[slot].fill_slot_data()
 
-    FillDisabledShopSlots(world)
-
-    def write_multidata(roms, mods):
-        import base64
-        import NetUtils
-        for future in roms:
-            rom_name = future.result()
-            rom_names.append(rom_name)
-        slot_data = {}
-        client_versions = {}
-        minimum_versions = {"server": (0, 1, 1), "clients": client_versions}
-        games = {}
-        for slot in world.player_ids:
-            if world.game[slot] == "Factorio":
-                client_versions[slot] = (0, 1, 2)
-            else:
-                client_versions[slot] = (0, 0, 3)
-            games[slot] = world.game[slot]
-        connect_names = {base64.b64encode(rom_name).decode(): (team, slot) for
-                          slot, team, rom_name in rom_names}
-        precollected_items = {player: [] for player in range(1, world.players+1)}
-        for item in world.precollected_items:
-            precollected_items[item.player].append(item.code)
-        precollected_hints = {player: set() for player in range(1, world.players+1)}
-        # for now special case Factorio visibility
-        sending_visible_players = set()
-        for player in world.factorio_player_ids:
-            if world.visibility[player]:
-                sending_visible_players.add(player)
-
-        for i, team in enumerate(parsed_names):
-            for player, name in enumerate(team, 1):
-                if player not in world.alttp_player_ids:
-                    connect_names[name] = (i, player)
-        for slot in world.hk_player_ids:
-            slots_data = slot_data[slot] = {}
-            for option_name in Options.hollow_knight_options:
-                option = getattr(world, option_name)[slot]
-                slots_data[option_name] = int(option.value)
-        for slot in world.minecraft_player_ids:
-            slot_data[slot] = fill_minecraft_slot_data(world, slot)
-
-        locations_data: Dict[int, Dict[int, Tuple[int, int]]] = {player: {} for player in world.player_ids}
-        for location in world.get_filled_locations():
-            if type(location.address) == int:
-                locations_data[location.player][location.address] = (location.item.code, location.item.player)
-                if location.player in sending_visible_players and location.item.player != location.player:
+                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)
+                                         location.item.code, False, entrance, location.item.flags)
                     precollected_hints[location.player].add(hint)
-                    precollected_hints[location.item.player].add(hint)
-                elif location.item.name in args.start_hints[location.item.player]:
-                    hint = NetUtils.Hint(location.item.player, location.player, location.address,
-                                         location.item.code, False,
-                                         er_hint_data.get(location.player, {}).get(location.address, ""))
-                    precollected_hints[location.player].add(hint)
-                    precollected_hints[location.item.player].add(hint)
+                    if location.item.player not in world.groups:
+                        precollected_hints[location.item.player].add(hint)
+                    else:
+                        for player in world.groups[location.item.player]["players"]:
+                            precollected_hints[player].add(hint)
 
-        multidata = zlib.compress(pickle.dumps({
-            "slot_data" : slot_data,
-            "games": games,
-            "names": parsed_names,
-            "connect_names": connect_names,
-            "remote_items": {player for player in range(1, world.players + 1) if
-                             world.remote_items[player]},
-            "locations": locations_data,
-            "checks_in_area": checks_in_area,
-            "server_options": get_options()["server_options"],
-            "er_hint_data": er_hint_data,
-            "precollected_items": precollected_items,
-            "precollected_hints": precollected_hints,
-            "version": tuple(_version_tuple),
-            "tags": ["AP"],
-            "minimum_versions": minimum_versions,
-            "seed_name": world.seed_name
-        }), 9)
+                locations_data: Dict[int, Dict[int, Tuple[int, int, int]]] = {player: {} for player in world.player_ids}
+                for location in world.get_filled_locations():
+                    if type(location.address) == int:
+                        assert location.item.code is not None, "item code None should be event, " \
+                                                               "location.address should then also be None. Location: " \
+                                                               f" {location}"
+                        locations_data[location.player][location.address] = \
+                            location.item.code, location.item.player, location.item.flags
+                        if location.name in world.start_location_hints[location.player]:
+                            precollect_hint(location)
+                        elif location.item.name in world.start_hints[location.item.player]:
+                            precollect_hint(location)
+                        elif any([location.item.name in world.start_hints[player]
+                                  for player in world.groups.get(location.item.player, {}).get("players", [])]):
+                            precollect_hint(location)
 
-        with open(output_path('%s.archipelago' % outfilebase), 'wb') as f:
-            f.write(bytes([1]))  # version of format
-            f.write(multidata)
-        for future in mods:
-            future.result() # collect errors if they occured
+                multidata = {
+                    "slot_data": slot_data,
+                    "slot_info": slot_info,
+                    "names": names,  # TODO: remove around 0.2.5 in favor of slot_info
+                    "games": games,  # TODO: remove around 0.2.5 in favor of slot_info
+                    "connect_names": {name: (0, player) for player, name in world.player_name.items()},
+                    "remote_items": {player for player in world.player_ids if
+                                     world.worlds[player].remote_items},
+                    "remote_start_inventory": {player for player in world.player_ids if
+                                               world.worlds[player].remote_start_inventory},
+                    "locations": locations_data,
+                    "checks_in_area": checks_in_area,
+                    "server_options": baked_server_options,
+                    "er_hint_data": er_hint_data,
+                    "precollected_items": precollected_items,
+                    "precollected_hints": precollected_hints,
+                    "version": tuple(version_tuple),
+                    "tags": ["AP"],
+                    "minimum_versions": minimum_versions,
+                    "seed_name": world.seed_name
+                }
+                AutoWorld.call_all(world, "modify_multidata", multidata)
 
-    multidata_task = pool.submit(write_multidata, rom_futures, mod_futures)
-    if not check_accessibility_task.result():
-        if not world.can_beat_game():
-            raise Exception("Game appears as unbeatable. Aborting.")
-        else:
-            logger.warning("Location Accessibility requirements not fulfilled.")
-    if multidata_task:
-        multidata_task.result()  # retrieve exception if one exists
-    pool.shutdown()  # wait for all queued tasks to complete
-    for player in world.minecraft_player_ids: # Doing this after shutdown prevents the .apmc from being generated if there's an error
-        generate_mc_data(world, player)
-    if not args.skip_playthrough:
-        logger.info('Calculating playthrough.')
-        create_playthrough(world)
-    if args.create_spoiler:  # needs spoiler.hashes to be filled, that depend on rom_futures being done
-        world.spoiler.to_file(output_path('%s_Spoiler.txt' % outfilebase))
+                multidata = zlib.compress(pickle.dumps(multidata), 9)
+
+                with open(os.path.join(temp_dir, f'{outfilebase}.archipelago'), 'wb') as f:
+                    f.write(bytes([3]))  # version of format
+                    f.write(multidata)
+
+            multidata_task = pool.submit(write_multidata)
+            if not check_accessibility_task.result():
+                if not world.can_beat_game():
+                    raise Exception("Game appears as unbeatable. Aborting.")
+                else:
+                    logger.warning("Location Accessibility requirements not fulfilled.")
+
+            # retrieve exceptions via .result() if they occurred.
+            multidata_task.result()
+            for i, future in enumerate(concurrent.futures.as_completed(output_file_futures), start=1):
+                if i % 10 == 0 or i == len(output_file_futures):
+                    logger.info(f'Generating output files ({i}/{len(output_file_futures)}).')
+                future.result()
+
+        if args.spoiler > 1:
+            logger.info('Calculating playthrough.')
+            create_playthrough(world)
+
+        if args.spoiler:
+            world.spoiler.to_file(os.path.join(temp_dir, '%s_Spoiler.txt' % outfilebase))
+
+        zipfilename = output_path(f"AP_{world.seed_name}.zip")
+        logger.info(f'Creating final archive at {zipfilename}.')
+        with zipfile.ZipFile(zipfilename, mode="w", compression=zipfile.ZIP_DEFLATED,
+                             compresslevel=9) as zf:
+            for file in os.scandir(temp_dir):
+                zf.write(file.path, arcname=file.name)
 
     logger.info('Done. Enjoy. Total Time: %s', time.perf_counter() - start)
     return world
@@ -603,9 +446,9 @@ def create_playthrough(world):
     sphere_candidates = set(prog_locations)
     logging.debug('Building up collection spheres.')
     while sphere_candidates:
-        state.sweep_for_events(key_only=True)
 
-        # build up spheres of collection radius. Everything in each sphere is independent from each other in dependencies and only depends on lower spheres
+        # build up spheres of collection radius.
+        # Everything in each sphere is independent from each other in dependencies and only depends on lower spheres
 
         sphere = {location for location in sphere_candidates if state.can_reach(location)}
 
@@ -622,7 +465,7 @@ def create_playthrough(world):
             logging.debug('The following items could not be reached: %s', ['%s (Player %d) at %s (Player %d)' % (
                 location.item.name, location.item.player, location.name, location.player) for location in
                                                                            sphere_candidates])
-            if any([world.accessibility[location.item.player] != 'none' for location in sphere_candidates]):
+            if any([world.accessibility[location.item.player] != 'minimal' for location in sphere_candidates]):
                 raise RuntimeError(f'Not all progression items reachable ({sphere_candidates}). '
                                    f'Something went terribly wrong here.')
             else:
@@ -636,7 +479,8 @@ def create_playthrough(world):
         to_delete = set()
         for location in sphere:
             # we remove the item at location and check if game is still beatable
-            logging.debug('Checking if %s (Player %d) is required to beat the game.', location.item.name, location.item.player)
+            logging.debug('Checking if %s (Player %d) is required to beat the game.', location.item.name,
+                          location.item.player)
             old_item = location.item
             location.item = None
             if world.can_beat_game(state_cache[num]):
@@ -651,9 +495,9 @@ def create_playthrough(world):
 
     # second phase, sphere 0
     removed_precollected = []
-    for item in (i for i in world.precollected_items if i.advancement):
+    for item in (i for i in chain.from_iterable(world.precollected_items.values()) if i.advancement):
         logging.debug('Checking if %s (Player %d) is required to beat the game.', item.name, item.player)
-        world.precollected_items.remove(item)
+        world.precollected_items[item.player].remove(item)
         world.state.remove(item)
         if not world.can_beat_game():
             world.push_precollected(item)
@@ -681,7 +525,8 @@ def create_playthrough(world):
 
         collection_spheres.append(sphere)
 
-        logging.debug('Calculated final sphere %i, containing %i of %i progress items.', len(collection_spheres), len(sphere), len(required_locations))
+        logging.debug('Calculated final sphere %i, containing %i of %i progress items.', len(collection_spheres),
+                      len(sphere), len(required_locations))
         if not sphere:
             raise RuntimeError(f'Not all required items reachable. Unreachable locations: {required_locations}')
 
@@ -698,19 +543,27 @@ def create_playthrough(world):
         pathpairs = zip_longest(pathsiter, pathsiter)
         return list(pathpairs)
 
-    world.spoiler.paths = dict()
-    for player in range(1, world.players + 1):
-        world.spoiler.paths.update({ str(location) : get_path(state, location.parent_region) for sphere in collection_spheres for location in sphere if location.player == player})
-        if player in world.alttp_player_ids:
-            for path in dict(world.spoiler.paths).values():
-                if any(exit == 'Pyramid Fairy' for (_, exit) in path):
-                    if world.mode[player] != 'inverted':
-                        world.spoiler.paths[str(world.get_region('Big Bomb Shop', player))] = get_path(state, world.get_region('Big Bomb Shop', player))
-                    else:
-                        world.spoiler.paths[str(world.get_region('Inverted Big Bomb Shop', player))] = get_path(state, world.get_region('Inverted Big Bomb Shop', player))
+    world.spoiler.paths = {}
+    topology_worlds = (player for player in world.player_ids if world.worlds[player].topology_present)
+    for player in topology_worlds:
+        world.spoiler.paths.update(
+            {str(location): get_path(state, location.parent_region) for sphere in collection_spheres for location in
+             sphere if location.player == player})
+        if player in world.get_game_players("A Link to the Past"):
+            # If Pyramid Fairy Entrance needs to be reached, also path to Big Bomb Shop
+            # Maybe move the big bomb over to the Event system instead?
+            if any(exit_path == 'Pyramid Fairy' for path in world.spoiler.paths.values() for (_, exit_path) in path):
+                if world.mode[player] != 'inverted':
+                    world.spoiler.paths[str(world.get_region('Big Bomb Shop', player))] = \
+                        get_path(state, world.get_region('Big Bomb Shop', player))
+                else:
+                    world.spoiler.paths[str(world.get_region('Inverted Big Bomb Shop', player))] = \
+                        get_path(state, world.get_region('Inverted Big Bomb Shop', player))
 
     # we can finally output our playthrough
-    world.spoiler.playthrough = {"0": sorted([str(item) for item in world.precollected_items if item.advancement])}
+    world.spoiler.playthrough = {"0": sorted([str(item) for item in
+                                              chain.from_iterable(world.precollected_items.values())
+                                              if item.advancement])}
 
     for i, sphere in enumerate(collection_spheres):
         world.spoiler.playthrough[str(i + 1)] = {str(location): str(location.item) for location in sorted(sphere)}

MinecraftClient.py

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

ModuleUpdate.py

@@ -3,7 +3,8 @@ import sys
 import subprocess
 import pkg_resources
 
-requirements_files = {'requirements.txt'}
+local_dir = os.path.dirname(__file__)
+requirements_files = {os.path.join(local_dir, 'requirements.txt')}
 
 if sys.version_info < (3, 8, 6):
     raise RuntimeError("Incompatible Python Version. 3.8.7+ is supported.")
@@ -11,7 +12,7 @@ if sys.version_info < (3, 8, 6):
 update_ran = getattr(sys, "frozen", False)  # don't run update if environment is frozen/compiled
 
 if not update_ran:
-    for entry in os.scandir("worlds"):
+    for entry in os.scandir(os.path.join(local_dir, "worlds")):
         if entry.is_dir():
             req_file = os.path.join(entry.path, "requirements.txt")
             if os.path.exists(req_file):
@@ -23,27 +24,47 @@ def update_command():
         subprocess.call([sys.executable, '-m', 'pip', 'install', '-r', file, '--upgrade'])
 
 
-def update():
+def update(yes=False, force=False):
     global update_ran
     if not update_ran:
         update_ran = True
+        if force:
+            update_command()
+            return
         for req_file in requirements_files:
             path = os.path.join(os.path.dirname(sys.argv[0]), req_file)
             if not os.path.exists(path):
                 path = os.path.join(os.path.dirname(__file__), req_file)
             with open(path) as requirementsfile:
-                requirements = pkg_resources.parse_requirements(requirementsfile)
-                for requirement in requirements:
-                    requirement = str(requirement)
-                    try:
-                        pkg_resources.require(requirement)
-                    except pkg_resources.ResolutionError:
-                        import traceback
-                        traceback.print_exc()
-                        input(f'Requirement {requirement} is not satisfied, press enter to install it')
-                        update_command()
-                        return
+                for line in requirementsfile:
+                    if line.startswith('https://'):
+                        # extract name and version from url
+                        wheel = line.split('/')[-1]
+                        name, version, _ = wheel.split('-', 2)
+                        line = f'{name}=={version}'
+                    requirements = pkg_resources.parse_requirements(line)
+                    for requirement in requirements:
+                        requirement = str(requirement)
+                        try:
+                            pkg_resources.require(requirement)
+                        except pkg_resources.ResolutionError:
+                            if not yes:
+                                import traceback
+                                traceback.print_exc()
+                                input(f'Requirement {requirement} is not satisfied, press enter to install it')
+                            update_command()
+                            return
 
 
 if __name__ == "__main__":
-    update()
+    import argparse
+
+    parser = argparse.ArgumentParser(description='Install archipelago requirements')
+    parser.add_argument('-y', '--yes', dest='yes', action='store_true', help='answer "yes" to all questions')
+    parser.add_argument('-f', '--force', dest='force', action='store_true', help='force update')
+    parser.add_argument('-a', '--append', nargs="*", dest='additional_requirements',
+                        help='List paths to additional requirement files.')
+    args = parser.parse_args()
+    if args.additional_requirements:
+        requirements_files.update(args.additional_requirements)
+    update(args.yes, args.force)

MultiMystery.py

@@ -1,222 +0,0 @@
-import os
-import subprocess
-import sys
-import threading
-import concurrent.futures
-import argparse
-import logging
-import random
-
-
-def feedback(text: str):
-    logging.info(text)
-    input("Press Enter to ignore and probably crash.")
-
-
-if __name__ == "__main__":
-    logging.basicConfig(format='%(message)s', level=logging.INFO)
-    try:
-        import ModuleUpdate
-
-        ModuleUpdate.update()
-
-        parser = argparse.ArgumentParser(add_help=False)
-        parser.add_argument('--disable_autohost', action='store_true')
-        args = parser.parse_args()
-
-        from Utils import get_public_ipv4, get_options
-        from Mystery import get_seed_name
-
-        options = get_options()
-
-        multi_mystery_options = options["multi_mystery_options"]
-        output_path = options["general_options"]["output_path"]
-        enemizer_path = multi_mystery_options["enemizer_path"]
-        player_files_path = multi_mystery_options["player_files_path"]
-        target_player_count = multi_mystery_options["players"]
-        glitch_triforce = multi_mystery_options["glitch_triforce_room"]
-        race = multi_mystery_options["race"]
-        plando_options = multi_mystery_options["plando_options"]
-        create_spoiler = multi_mystery_options["create_spoiler"]
-        zip_roms = multi_mystery_options["zip_roms"]
-        zip_diffs = multi_mystery_options["zip_diffs"]
-        zip_apmcs = multi_mystery_options["zip_apmcs"]
-        zip_spoiler = multi_mystery_options["zip_spoiler"]
-        zip_multidata = multi_mystery_options["zip_multidata"]
-        zip_format = multi_mystery_options["zip_format"]
-        # zip_password = multi_mystery_options["zip_password"] not at this time
-        meta_file_path = multi_mystery_options["meta_file_path"]
-        weights_file_path = multi_mystery_options["weights_file_path"]
-        pre_roll = multi_mystery_options["pre_roll"]
-        teams = multi_mystery_options["teams"]
-        rom_file = options["lttp_options"]["rom_file"]
-        host = options["server_options"]["host"]
-        port = options["server_options"]["port"]
-
-        py_version = f"{sys.version_info.major}.{sys.version_info.minor}"
-
-        if not os.path.exists(enemizer_path):
-            feedback(
-                f"Enemizer not found at {enemizer_path}, please adjust the path in MultiMystery.py's config or put Enemizer in the default location.")
-        if not os.path.exists(rom_file):
-            feedback(f"Base rom is expected as {rom_file} in the Multiworld root folder please place/rename it there.")
-        player_files = []
-        os.makedirs(player_files_path, exist_ok=True)
-        for file in os.listdir(player_files_path):
-            lfile = file.lower()
-            if lfile.endswith(".yaml") and lfile != meta_file_path.lower() and lfile != weights_file_path.lower():
-                player_files.append(file)
-                logging.info(f"Found player's file {file}.")
-
-        player_string = ""
-        for i, file in enumerate(player_files, 1):
-            player_string += f"--p{i} \"{os.path.join(player_files_path, file)}\" "
-
-        if os.path.exists("ArchipelagoMystery.exe"):
-            basemysterycommand = "ArchipelagoMystery.exe"  # compiled windows
-        elif os.path.exists("ArchipelagoMystery"):
-            basemysterycommand = "ArchipelagoMystery"  # compiled linux
-        else:
-            basemysterycommand = f"py -{py_version} Mystery.py"  # source
-
-        weights_file_path = os.path.join(player_files_path, weights_file_path)
-        if os.path.exists(weights_file_path):
-            target_player_count = max(len(player_files), target_player_count)
-        else:
-            target_player_count = len(player_files)
-
-        if target_player_count == 0:
-            feedback(f"No player files found. Please put them in a {player_files_path} folder.")
-        else:
-            logging.info(f"{target_player_count} Players found.")
-        seed_name = get_seed_name(random)
-        command = f"{basemysterycommand} --multi {target_player_count} {player_string} " \
-                  f"--rom \"{rom_file}\" --enemizercli \"{enemizer_path}\" " \
-                  f"--outputpath \"{output_path}\" --teams {teams} --plando \"{plando_options}\" " \
-                  f"--seed_name {seed_name}"
-
-        if create_spoiler:
-            command += " --create_spoiler"
-            if create_spoiler == 2:
-                command += " --skip_playthrough"
-        if zip_diffs:
-            command += " --create_diff"
-        if glitch_triforce:
-            command += " --glitch_triforce"
-        if race:
-            command += " --race"
-        if os.path.exists(os.path.join(player_files_path, meta_file_path)):
-            command += f" --meta {os.path.join(player_files_path, meta_file_path)}"
-        if os.path.exists(weights_file_path):
-            command += f" --weights {weights_file_path}"
-        if pre_roll:
-            command += " --pre_roll"
-
-        logging.info(command)
-        import time
-
-        start = time.perf_counter()
-        text = subprocess.check_output(command, shell=True).decode()
-        logging.info(f"Took {time.perf_counter() - start:.3f} seconds to generate multiworld.")
-
-        multidataname = f"AP_{seed_name}.archipelago"
-        spoilername = f"AP_{seed_name}_Spoiler.txt"
-        romfilename = ""
-
-        if any((zip_roms, zip_multidata, zip_spoiler, zip_diffs, zip_apmcs)):
-            import zipfile
-
-            compression = {1: zipfile.ZIP_DEFLATED,
-                           2: zipfile.ZIP_LZMA,
-                           3: zipfile.ZIP_BZIP2}[zip_format]
-
-            typical_zip_ending = {1: "zip",
-                                  2: "7z",
-                                  3: "bz2"}[zip_format]
-
-            ziplock = threading.Lock()
-
-
-            def pack_file(file: str):
-                with ziplock:
-                    zf.write(os.path.join(output_path, file), file)
-                    logging.info(f"Packed {file} into zipfile {zipname}")
-
-
-            def remove_zipped_file(file: str):
-                os.remove(os.path.join(output_path, file))
-                logging.info(f"Removed {file} which is now present in the zipfile")
-
-
-            zipname = os.path.join(output_path, f"AP_{seed_name}.{typical_zip_ending}")
-
-            logging.info(f"Creating zipfile {zipname}")
-            ipv4 = (host if host else get_public_ipv4()) + ":" + str(port)
-
-
-            def _handle_sfc_file(file: str):
-                if zip_roms:
-                    pack_file(file)
-                    if zip_roms == 2:
-                        remove_zipped_file(file)
-
-
-            def _handle_diff_file(file: str):
-                if zip_diffs > 0:
-                    pack_file(file)
-                    if zip_diffs == 2:
-                        remove_zipped_file(file)
-
-
-            def _handle_apmc_file(file: str):
-                if zip_apmcs:
-                    pack_file(file)
-                    if zip_apmcs == 2:
-                        remove_zipped_file(file)
-
-
-            with concurrent.futures.ThreadPoolExecutor() as pool:
-                futures = []
-                files = os.listdir(output_path)
-                with zipfile.ZipFile(zipname, "w", compression=compression, compresslevel=9) as zf:
-                    for file in files:
-                        if seed_name in file:
-                            if file.endswith(".sfc"):
-                                futures.append(pool.submit(_handle_sfc_file, file))
-                            elif file.endswith(".apbp"):
-                                futures.append(pool.submit(_handle_diff_file, file))
-                            elif file.endswith(".apmc"):
-                                futures.append(pool.submit(_handle_apmc_file, file))
-                            # just handle like a diff file for now
-                            elif file.endswith(".zip"):
-                                futures.append(pool.submit(_handle_diff_file, file))
-
-                    if zip_multidata and os.path.exists(os.path.join(output_path, multidataname)):
-                        pack_file(multidataname)
-                        if zip_multidata == 2:
-                            remove_zipped_file(multidataname)
-
-                    if zip_spoiler and create_spoiler:
-                        pack_file(spoilername)
-                        if zip_spoiler == 2:
-                            remove_zipped_file(spoilername)
-
-                    for future in futures:
-                        future.result()  # make sure we close the zip AFTER any packing is done
-
-        if not args.disable_autohost:
-            if os.path.exists(os.path.join(output_path, multidataname)):
-                if os.path.exists("ArchipelagoServer.exe"):
-                    baseservercommand = "ArchipelagoServer.exe"  # compiled windows
-                elif os.path.exists("ArchipelagoServer"):
-                    baseservercommand = "ArchipelagoServer"  # compiled linux
-                else:
-                    baseservercommand = f"py -{py_version} MultiServer.py"  # source
-                # don't have a mac to test that. If you try to run compiled on mac, good luck.
-
-                subprocess.call(f"{baseservercommand} --multidata {os.path.join(output_path, multidataname)}")
-    except:
-        import traceback
-
-        traceback.print_exc()
-        input("Press enter to close")

Mystery.py

@@ -1,842 +0,0 @@
-import argparse
-import logging
-import random
-import urllib.request
-import urllib.parse
-import typing
-import os
-from collections import Counter
-import string
-
-import ModuleUpdate
-from worlds.generic import PlandoItem, PlandoConnection
-
-ModuleUpdate.update()
-
-from Utils import parse_yaml
-from worlds.alttp.EntranceRandomizer import parse_arguments
-from Main import main as ERmain
-from Main import get_seed, seeddigits
-import Options
-from worlds import lookup_any_item_name_to_id
-from worlds.alttp.Items import item_name_groups, item_table
-from worlds.alttp import Bosses
-from worlds.alttp.Text import TextTable
-from worlds.alttp.Regions import location_table, key_drop_data
-
-
-def mystery_argparse():
-    parser = argparse.ArgumentParser(add_help=False)
-    parser.add_argument('--multi', default=1, type=lambda value: min(max(int(value), 1), 255))
-    multiargs, _ = parser.parse_known_args()
-
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--weights',
-                        help='Path to the weights file to use for rolling game settings, urls are also valid')
-    parser.add_argument('--samesettings', help='Rolls settings per weights file rather than per player',
-                        action='store_true')
-    parser.add_argument('--seed', help='Define seed number to generate.', type=int)
-    parser.add_argument('--multi', default=1, type=lambda value: min(max(int(value), 1), 255))
-    parser.add_argument('--teams', default=1, type=lambda value: max(int(value), 1))
-    parser.add_argument('--create_spoiler', action='store_true')
-    parser.add_argument('--skip_playthrough', action='store_true')
-    parser.add_argument('--pre_roll', action='store_true')
-    parser.add_argument('--rom')
-    parser.add_argument('--enemizercli')
-    parser.add_argument('--outputpath')
-    parser.add_argument('--glitch_triforce', action='store_true')
-    parser.add_argument('--race', action='store_true')
-    parser.add_argument('--meta', default=None)
-    parser.add_argument('--log_output_path', help='Path to store output log')
-    parser.add_argument('--loglevel', default='info', help='Sets log level')
-    parser.add_argument('--create_diff', action="store_true")
-    parser.add_argument('--yaml_output', default=0, type=lambda value: min(max(int(value), 0), 255),
-                        help='Output rolled mystery results to yaml up to specified number (made for async multiworld)')
-    parser.add_argument('--plando', default="bosses",
-                        help='List of options that can be set manually. Can be combined, for example "bosses, items"')
-    parser.add_argument('--seed_name')
-    for player in range(1, multiargs.multi + 1):
-        parser.add_argument(f'--p{player}', help=argparse.SUPPRESS)
-    args = parser.parse_args()
-    args.plando: typing.Set[str] = {arg.strip().lower() for arg in args.plando.split(",")}
-    return args
-
-def get_seed_name(random):
-    return f"{random.randint(0, pow(10, seeddigits) - 1)}".zfill(seeddigits)
-
-def main(args=None, callback=ERmain):
-    if not args:
-        args = mystery_argparse()
-
-    seed = get_seed(args.seed)
-    random.seed(seed)
-    seed_name = args.seed_name if args.seed_name else get_seed_name(random)
-    print(f"Generating for {args.multi} player{'s' if args.multi > 1 else ''}, {seed_name} Seed {seed}")
-
-    if args.race:
-        random.seed()  # reset to time-based random source
-
-    weights_cache = {}
-    if args.weights:
-        try:
-            weights_cache[args.weights] = get_weights(args.weights)
-        except Exception as e:
-            raise ValueError(f"File {args.weights} is destroyed. Please fix your yaml.") from e
-        print(f"Weights: {args.weights} >> "
-              f"{get_choice('description', weights_cache[args.weights], 'No description specified')}")
-    if args.meta:
-        try:
-            weights_cache[args.meta] = get_weights(args.meta)
-        except Exception as e:
-            raise ValueError(f"File {args.meta} is destroyed. Please fix your yaml.") from e
-        meta_weights = weights_cache[args.meta]
-        print(f"Meta: {args.meta} >> {get_choice('meta_description', meta_weights, 'No description specified')}")
-        if args.samesettings:
-            raise Exception("Cannot mix --samesettings with --meta")
-
-    for player in range(1, args.multi + 1):
-        path = getattr(args, f'p{player}')
-        if path:
-            try:
-                if path not in weights_cache:
-                    weights_cache[path] = get_weights(path)
-                print(f"P{player} Weights: {path} >> "
-                      f"{get_choice('description', weights_cache[path], 'No description specified')}")
-
-            except Exception as e:
-                raise ValueError(f"File {path} is destroyed. Please fix your yaml.") from e
-    erargs = parse_arguments(['--multi', str(args.multi)])
-    erargs.seed = seed
-    erargs.name = {x: "" for x in range(1, args.multi + 1)}  # only so it can be overwrittin in mystery
-    erargs.create_spoiler = args.create_spoiler
-    erargs.create_diff = args.create_diff
-    erargs.glitch_triforce = args.glitch_triforce
-    erargs.race = args.race
-    erargs.skip_playthrough = args.skip_playthrough
-    erargs.outputname = seed_name
-    erargs.outputpath = args.outputpath
-    erargs.teams = args.teams
-
-    # set up logger
-    if args.loglevel:
-        erargs.loglevel = args.loglevel
-    loglevel = {'error': logging.ERROR, 'info': logging.INFO, 'warning': logging.WARNING, 'debug': logging.DEBUG}[
-        erargs.loglevel]
-
-    if args.log_output_path:
-        import sys
-        class LoggerWriter(object):
-            def __init__(self, writer):
-                self._writer = writer
-                self._msg = ''
-
-            def write(self, message):
-                self._msg = self._msg + message
-                while '\n' in self._msg:
-                    pos = self._msg.find('\n')
-                    self._writer(self._msg[:pos])
-                    self._msg = self._msg[pos + 1:]
-
-            def flush(self):
-                if self._msg != '':
-                    self._writer(self._msg)
-                    self._msg = ''
-
-        log = logging.getLogger("stderr")
-        log.addHandler(logging.StreamHandler())
-        sys.stderr = LoggerWriter(log.error)
-        os.makedirs(args.log_output_path, exist_ok=True)
-        logging.basicConfig(format='%(message)s', level=loglevel,
-                            filename=os.path.join(args.log_output_path, f"{seed}.log"))
-    else:
-        logging.basicConfig(format='%(message)s', level=loglevel)
-    if args.rom:
-        erargs.rom = args.rom
-
-    if args.enemizercli:
-        erargs.enemizercli = args.enemizercli
-
-    settings_cache = {k: (roll_settings(v, args.plando) if args.samesettings else None)
-                      for k, v in weights_cache.items()}
-    player_path_cache = {}
-    for player in range(1, args.multi + 1):
-        player_path_cache[player] = getattr(args, f'p{player}') if getattr(args, f'p{player}') else args.weights
-
-    if args.meta:
-        for player, path in player_path_cache.items():
-            weights_cache[path].setdefault("meta_ignore", [])
-        meta_weights = weights_cache[args.meta]
-        for key in meta_weights:
-            option = get_choice(key, meta_weights)
-            if option is not None:
-                for player, path in player_path_cache.items():
-                    players_meta = weights_cache[path].get("meta_ignore", [])
-                    if key not in players_meta:
-                        weights_cache[path][key] = option
-                    elif type(players_meta) == dict and players_meta[key] and option not in players_meta[key]:
-                        weights_cache[path][key] = option
-
-    name_counter = Counter()
-    erargs.player_settings = {}
-    for player in range(1, args.multi + 1):
-        path = player_path_cache[player]
-        if path:
-            try:
-                settings = settings_cache[path] if settings_cache[path] else \
-                    roll_settings(weights_cache[path], args.plando)
-                if args.pre_roll:
-                    import yaml
-                    if path == args.weights:
-                        settings.name = f"Player{player}"
-                    elif not settings.name:
-                        settings.name = os.path.splitext(os.path.split(path)[-1])[0]
-
-                    if "-" not in settings.shuffle and settings.shuffle != "vanilla":
-                        settings.shuffle += f"-{random.randint(0, 2 ** 64)}"
-
-                    pre_rolled = dict()
-                    pre_rolled["original_seed_number"] = seed
-                    pre_rolled["original_seed_name"] = seed_name
-                    pre_rolled["pre_rolled"] = vars(settings).copy()
-                    if "plando_items" in pre_rolled["pre_rolled"]:
-                        pre_rolled["pre_rolled"]["plando_items"] = [item.to_dict() for item in
-                                                                    pre_rolled["pre_rolled"]["plando_items"]]
-                    if "plando_connections" in pre_rolled["pre_rolled"]:
-                        pre_rolled["pre_rolled"]["plando_connections"] = [connection.to_dict() for connection in
-                                                                          pre_rolled["pre_rolled"][
-                                                                              "plando_connections"]]
-
-                    with open(os.path.join(args.outputpath if args.outputpath else ".",
-                                           f"{os.path.split(path)[-1].split('.')[0]}_pre_rolled.yaml"), "wt") as f:
-                        yaml.dump(pre_rolled, f)
-                for k, v in vars(settings).items():
-                    if v is not None:
-                        try:
-                            getattr(erargs, k)[player] = v
-                        except AttributeError:
-                            setattr(erargs, k, {player: v})
-            except Exception as e:
-                raise ValueError(f"File {path} is destroyed. Please fix your yaml.") from e
-        else:
-            raise RuntimeError(f'No weights specified for player {player}')
-        if path == args.weights:  # if name came from the weights file, just use base player name
-            erargs.name[player] = f"Player{player}"
-        elif not erargs.name[player]:  # if name was not specified, generate it from filename
-            erargs.name[player] = os.path.splitext(os.path.split(path)[-1])[0]
-        erargs.name[player] = handle_name(erargs.name[player], player, name_counter)
-
-    erargs.names = ",".join(erargs.name[i] for i in range(1, args.multi + 1))
-    del (erargs.name)
-    if args.yaml_output:
-        import yaml
-        important = {}
-        for option, player_settings in vars(erargs).items():
-            if type(player_settings) == dict:
-                if all(type(value) != list for value in player_settings.values()):
-                    if len(player_settings.values()) > 1:
-                        important[option] = {player: value for player, value in player_settings.items() if
-                                             player <= args.yaml_output}
-                    elif len(player_settings.values()) > 0:
-                        important[option] = player_settings[1]
-                    else:
-                        logging.debug(f"No player settings defined for option '{option}'")
-
-            else:
-                if player_settings != "":  # is not empty name
-                    important[option] = player_settings
-                else:
-                    logging.debug(f"No player settings defined for option '{option}'")
-        if args.outputpath:
-            os.makedirs(args.outputpath, exist_ok=True)
-        with open(os.path.join(args.outputpath if args.outputpath else ".", f"mystery_result_{seed}.yaml"), "wt") as f:
-            yaml.dump(important, f)
-
-    callback(erargs, seed)
-
-
-def get_weights(path):
-    try:
-        if urllib.parse.urlparse(path).scheme:
-            yaml = str(urllib.request.urlopen(path).read(), "utf-8")
-        else:
-            with open(path, 'rb') as f:
-                yaml = str(f.read(), "utf-8")
-    except Exception as e:
-        raise Exception(f"Failed to read weights ({path})") from e
-
-    return parse_yaml(yaml)
-
-
-def interpret_on_off(value):
-    return {"on": True, "off": False}.get(value, value)
-
-
-def convert_to_on_off(value):
-    return {True: "on", False: "off"}.get(value, value)
-
-
-def get_choice(option, root, value=None) -> typing.Any:
-    if option not in root:
-        return value
-    if type(root[option]) is list:
-        return interpret_on_off(random.choices(root[option])[0])
-    if type(root[option]) is not dict:
-        return interpret_on_off(root[option])
-    if not root[option]:
-        return value
-    if any(root[option].values()):
-        return interpret_on_off(
-            random.choices(list(root[option].keys()), weights=list(map(int, root[option].values())))[0])
-    raise RuntimeError(f"All options specified in \"{option}\" are weighted as zero.")
-
-
-class SafeDict(dict):
-    def __missing__(self, key):
-        return '{' + key + '}'
-
-
-def handle_name(name: str, player: int, name_counter: Counter):
-    name_counter[name] += 1
-    new_name = "%".join([x.replace("%number%", "{number}").replace("%player%", "{player}") for x in name.split("%%")])
-    new_name = string.Formatter().vformat(new_name, (), SafeDict(number=name_counter[name],
-                                                                 NUMBER=(name_counter[name] if name_counter[
-                                                                                                   name] > 1 else ''),
-                                                                 player=player,
-                                                                 PLAYER=(player if player > 1 else '')))
-    new_name = new_name.strip().replace(' ', '_')[:16]
-    if new_name == "Archipelago":
-        raise Exception(f"You cannot name yourself \"{new_name}\"")
-    return new_name
-
-
-def prefer_int(input_data: str) -> typing.Union[str, int]:
-    try:
-        return int(input_data)
-    except:
-        return input_data
-
-
-available_boss_names: typing.Set[str] = {boss.lower() for boss in Bosses.boss_table if boss not in
-                                         {'Agahnim', 'Agahnim2', 'Ganon'}}
-available_boss_locations: typing.Set[str] = {f"{loc.lower()}{f' {level}' if level else ''}" for loc, level in
-                                             Bosses.boss_location_table}
-
-boss_shuffle_options = {None: 'none',
-                        'none': 'none',
-                        'basic': 'basic',
-                        'full': 'full',
-                        'chaos': 'chaos',
-                        'singularity': 'singularity'
-                        }
-
-goals = {
-    'ganon': 'ganon',
-    'crystals': 'crystals',
-    'bosses': 'bosses',
-    'pedestal': 'pedestal',
-    'ganon_pedestal': 'ganonpedestal',
-    'triforce_hunt': 'triforcehunt',
-    'local_triforce_hunt': 'localtriforcehunt',
-    'ganon_triforce_hunt': 'ganontriforcehunt',
-    'local_ganon_triforce_hunt': 'localganontriforcehunt',
-    'ice_rod_hunt': 'icerodhunt',
-}
-
-# remove sometime before 1.0.0, warn before
-legacy_boss_shuffle_options = {
-    # legacy, will go away:
-    'simple': 'basic',
-    'random': 'full',
-    'normal': 'full'
-}
-
-legacy_goals = {
-    'dungeons': 'bosses',
-    'fast_ganon': 'crystals',
-}
-
-
-def roll_percentage(percentage: typing.Union[int, float]) -> bool:
-    """Roll a percentage chance.
-    percentage is expected to be in range [0, 100]"""
-    return random.random() < (float(percentage) / 100)
-
-
-def update_weights(weights: dict, new_weights: dict, type: str, name: str) -> dict:
-    logging.debug(f'Applying {new_weights}')
-    new_options = set(new_weights) - set(weights)
-    weights.update(new_weights)
-    if new_options:
-        for new_option in new_options:
-            logging.warning(f'{type} Suboption "{new_option}" of "{name}" did not '
-                            f'overwrite a root option. '
-                            f'This is probably in error.')
-    return weights
-
-
-def roll_linked_options(weights: dict) -> dict:
-    weights = weights.copy()  # make sure we don't write back to other weights sets in same_settings
-    for option_set in weights["linked_options"]:
-        if "name" not in option_set:
-            raise ValueError("One of your linked options does not have a name.")
-        try:
-            if roll_percentage(option_set["percentage"]):
-                logging.debug(f"Linked option {option_set['name']} triggered.")
-                if "options" in option_set:
-                    weights = update_weights(weights, option_set["options"], "Linked", option_set["name"])
-                if "rom_options" in option_set:
-                    rom_weights = weights.get("rom", dict())
-                    rom_weights = update_weights(rom_weights, option_set["rom_options"], "Linked Rom",
-                                                 option_set["name"])
-                    weights["rom"] = rom_weights
-            else:
-                logging.debug(f"linked option {option_set['name']} skipped.")
-        except Exception as e:
-            raise ValueError(f"Linked option {option_set['name']} is destroyed. "
-                             f"Please fix your linked option.") from e
-    return weights
-
-
-def roll_triggers(weights: dict) -> dict:
-    weights = weights.copy()  # make sure we don't write back to other weights sets in same_settings
-    weights["_Generator_Version"] = "Archipelago"  # Some means for triggers to know if the seed is on main or doors.
-    for i, option_set in enumerate(weights["triggers"]):
-        try:
-            key = get_choice("option_name", option_set)
-            if key not in weights:
-                logging.warning(f'Specified option name {option_set["option_name"]} did not '
-                                f'match with a root option. '
-                                f'This is probably in error.')
-            trigger_result = get_choice("option_result", option_set)
-            result = get_choice(key, weights)
-            if result == trigger_result and roll_percentage(get_choice("percentage", option_set, 100)):
-                if "options" in option_set:
-                    weights = update_weights(weights, option_set["options"], "Triggered", option_set["option_name"])
-
-                if "rom_options" in option_set:
-                    rom_weights = weights.get("rom", dict())
-                    rom_weights = update_weights(rom_weights, option_set["rom_options"], "Triggered Rom",
-                                                 option_set["option_name"])
-                    weights["rom"] = rom_weights
-            weights[key] = result
-        except Exception as e:
-            raise ValueError(f"Your trigger number {i+1} is destroyed. "
-                             f"Please fix your triggers.") from e
-    return weights
-
-
-def get_plando_bosses(boss_shuffle: str, plando_options: typing.Set[str]) -> str:
-    if boss_shuffle in legacy_boss_shuffle_options:
-        new_boss_shuffle = legacy_boss_shuffle_options[boss_shuffle]
-        logging.warning(f"Boss shuffle {boss_shuffle} is deprecated, "
-                        f"please use {new_boss_shuffle} instead")
-        return new_boss_shuffle
-    if boss_shuffle in boss_shuffle_options:
-        return boss_shuffle_options[boss_shuffle]
-    elif "bosses" in plando_options:
-        options = boss_shuffle.lower().split(";")
-        remainder_shuffle = "none"  # vanilla
-        bosses = []
-        for boss in options:
-            if boss in legacy_boss_shuffle_options:
-                remainder_shuffle = legacy_boss_shuffle_options[boss_shuffle]
-                logging.warning(f"Boss shuffle {boss} is deprecated, "
-                                f"please use {remainder_shuffle} instead")
-            if boss in boss_shuffle_options:
-                remainder_shuffle = boss_shuffle_options[boss]
-            elif "-" in boss:
-                loc, boss_name = boss.split("-")
-                if boss_name not in available_boss_names:
-                    raise ValueError(f"Unknown Boss name {boss_name}")
-                if loc not in available_boss_locations:
-                    raise ValueError(f"Unknown Boss Location {loc}")
-                level = ''
-                if loc.split(" ")[-1] in {"top", "middle", "bottom"}:
-                    # split off level
-                    loc = loc.split(" ")
-                    level = f" {loc[-1]}"
-                    loc = " ".join(loc[:-1])
-                loc = loc.title().replace("Of", "of")
-                if not Bosses.can_place_boss(boss_name.title(), loc, level):
-                    raise ValueError(f"Cannot place {boss_name} at {loc}{level}")
-                bosses.append(boss)
-            elif boss not in available_boss_names:
-                raise ValueError(f"Unknown Boss name or Boss shuffle option {boss}.")
-            else:
-                bosses.append(boss)
-        return ";".join(bosses + [remainder_shuffle])
-    else:
-        raise Exception(f"Boss Shuffle {boss_shuffle} is unknown and boss plando is turned off.")
-
-
-def roll_settings(weights: dict, plando_options: typing.Set[str] = frozenset(("bosses",))):
-    if "pre_rolled" in weights:
-        pre_rolled = weights["pre_rolled"]
-
-        if "plando_items" in pre_rolled:
-            pre_rolled["plando_items"] = [PlandoItem(item["item"],
-                                                     item["location"],
-                                                     item["world"],
-                                                     item["from_pool"],
-                                                     item["force"]) for item in pre_rolled["plando_items"]]
-            if "items" not in plando_options and pre_rolled["plando_items"]:
-                raise Exception("Item Plando is turned off. Reusing this pre-rolled setting not permitted.")
-
-        if "plando_connections" in pre_rolled:
-            pre_rolled["plando_connections"] = [PlandoConnection(connection["entrance"],
-                                                                 connection["exit"],
-                                                                 connection["direction"]) for connection in
-                                                pre_rolled["plando_connections"]]
-            if "connections" not in plando_options and pre_rolled["plando_connections"]:
-                raise Exception("Connection Plando is turned off. Reusing this pre-rolled setting not permitted.")
-
-        if "bosses" not in plando_options:
-            try:
-                pre_rolled["shufflebosses"] = get_plando_bosses(pre_rolled["shufflebosses"], plando_options)
-            except Exception as ex:
-                raise Exception("Boss Plando is turned off. Reusing this pre-rolled setting not permitted.") from ex
-
-        if pre_rolled.get("plando_texts") and "texts" not in plando_options:
-            raise Exception("Text Plando is turned off. Reusing this pre-rolled setting not permitted.")
-
-        return argparse.Namespace(**pre_rolled)
-
-    if "linked_options" in weights:
-        weights = roll_linked_options(weights)
-
-    if "triggers" in weights:
-        weights = roll_triggers(weights)
-
-    ret = argparse.Namespace()
-    ret.name = get_choice('name', weights)
-    ret.accessibility = get_choice('accessibility', weights)
-    ret.progression_balancing = get_choice('progression_balancing', weights, True)
-    ret.game = get_choice("game", weights, "A Link to the Past")
-
-    ret.local_items = set()
-    for item_name in weights.get('local_items', []):
-        items = item_name_groups.get(item_name, {item_name})
-        for item in items:
-            if item in lookup_any_item_name_to_id:
-                ret.local_items.add(item)
-            else:
-                raise Exception(f"Could not force item {item} to be world-local, as it was not recognized.")
-
-    ret.non_local_items = set()
-    for item_name in weights.get('non_local_items', []):
-        items = item_name_groups.get(item_name, {item_name})
-        for item in items:
-            if item in lookup_any_item_name_to_id:
-                ret.non_local_items.add(item)
-            else:
-                raise Exception(f"Could not force item {item} to be world-non-local, as it was not recognized.")
-
-    inventoryweights = weights.get('startinventory', {})
-    startitems = []
-    for item in inventoryweights.keys():
-        itemvalue = get_choice(item, inventoryweights)
-        if isinstance(itemvalue, int):
-            for i in range(int(itemvalue)):
-                startitems.append(item)
-        elif itemvalue:
-            startitems.append(item)
-    ret.startinventory = startitems
-    ret.start_hints = set(weights.get('start_hints', []))
-
-
-    if ret.game == "A Link to the Past":
-        roll_alttp_settings(ret, weights, plando_options)
-    elif ret.game == "Hollow Knight":
-        for option_name, option in Options.hollow_knight_options.items():
-            setattr(ret, option_name, option.from_any(get_choice(option_name, weights, True)))
-    elif ret.game == "Factorio":
-        for option_name, option in Options.factorio_options.items():
-            if option_name in weights:
-                if issubclass(option, Options.OptionDict):  # get_choice should probably land in the Option class
-                    setattr(ret, option_name, option.from_any(weights[option_name]))
-                else:
-                    setattr(ret, option_name, option.from_any(get_choice(option_name, weights)))
-            else:
-                setattr(ret, option_name, option(option.default))
-    elif ret.game == "Minecraft":
-        for option_name, option in Options.minecraft_options.items():
-            if option_name in weights:
-                setattr(ret, option_name, option.from_any(get_choice(option_name, weights)))
-            else:
-                setattr(ret, option_name, option(option.default))
-        # bad hardcoded behavior to make this work for now    
-        ret.plando_connections = []
-        if "connections" in plando_options:
-            options = 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")
-                    ))
-    else:
-        raise Exception(f"Unsupported game {ret.game}")
-    return ret
-
-
-def roll_alttp_settings(ret: argparse.Namespace, weights, plando_options):
-    glitches_required = get_choice('glitches_required', weights)
-    if glitches_required not in [None, 'none', 'no_logic', 'overworld_glitches', 'minor_glitches']:
-        logging.warning("Only NMG, OWG and No Logic supported")
-        glitches_required = 'none'
-    ret.logic = {None: 'noglitches', 'none': 'noglitches', 'no_logic': 'nologic', 'overworld_glitches': 'owglitches',
-                 'minor_glitches': 'minorglitches'}[
-        glitches_required]
-
-    ret.dark_room_logic = get_choice("dark_room_logic", weights, "lamp")
-    if not ret.dark_room_logic:  # None/False
-        ret.dark_room_logic = "none"
-    if ret.dark_room_logic == "sconces":
-        ret.dark_room_logic = "torches"
-    if ret.dark_room_logic not in {"lamp", "torches", "none"}:
-        raise ValueError(f"Unknown Dark Room Logic: \"{ret.dark_room_logic}\"")
-
-    ret.restrict_dungeon_item_on_boss = get_choice('restrict_dungeon_item_on_boss', weights, False)
-
-    dungeon_items = get_choice('dungeon_items', weights)
-    if dungeon_items == 'full' or dungeon_items == True:
-        dungeon_items = 'mcsb'
-    elif dungeon_items == 'standard':
-        dungeon_items = ""
-    elif not dungeon_items:
-        dungeon_items = ""
-    if "u" in dungeon_items:
-        dungeon_items.replace("s", "")
-
-    ret.mapshuffle = get_choice('map_shuffle', weights, 'm' in dungeon_items)
-    ret.compassshuffle = get_choice('compass_shuffle', weights, 'c' in dungeon_items)
-    ret.keyshuffle = get_choice('smallkey_shuffle', weights,
-                                'universal' if 'u' in dungeon_items else 's' in dungeon_items)
-    ret.bigkeyshuffle = get_choice('bigkey_shuffle', weights, 'b' in dungeon_items)
-
-    entrance_shuffle = get_choice('entrance_shuffle', weights, 'vanilla')
-    if entrance_shuffle.startswith('none-'):
-        ret.shuffle = 'vanilla'
-    else:
-        ret.shuffle = entrance_shuffle if entrance_shuffle != 'none' else 'vanilla'
-
-    goal = get_choice('goals', weights, 'ganon')
-
-    if goal in legacy_goals:
-        logging.warning(f"Goal {goal} is depcrecated, please use {legacy_goals[goal]} instead.")
-        goal = legacy_goals[goal]
-    ret.goal = goals[goal]
-
-    # TODO consider moving open_pyramid to an automatic variable in the core roller, set to True when
-    # fast ganon + ganon at hole
-    ret.open_pyramid = get_choice('open_pyramid', weights, 'goal')
-
-    ret.crystals_gt = prefer_int(get_choice('tower_open', weights))
-
-    ret.crystals_ganon = prefer_int(get_choice('ganon_open', weights))
-
-    extra_pieces = get_choice('triforce_pieces_mode', weights, 'available')
-
-    ret.triforce_pieces_required = int(get_choice('triforce_pieces_required', weights, 20))
-    ret.triforce_pieces_required = min(max(1, int(ret.triforce_pieces_required)), 90)
-
-    # sum a percentage to required
-    if extra_pieces == 'percentage':
-        percentage = max(100, float(get_choice('triforce_pieces_percentage', weights, 150))) / 100
-        ret.triforce_pieces_available = int(round(ret.triforce_pieces_required * percentage, 0))
-    # vanilla mode (specify how many pieces are)
-    elif extra_pieces == 'available':
-        ret.triforce_pieces_available = int(get_choice('triforce_pieces_available', weights, 30))
-    # required pieces + fixed extra
-    elif extra_pieces == 'extra':
-        extra_pieces = max(0, int(get_choice('triforce_pieces_extra', weights, 10)))
-        ret.triforce_pieces_available = ret.triforce_pieces_required + extra_pieces
-
-    # change minimum to required pieces to avoid problems
-    ret.triforce_pieces_available = min(max(ret.triforce_pieces_required, int(ret.triforce_pieces_available)), 90)
-    shuffle_slots = get_choice('shop_shuffle_slots', weights, '0')
-    if str(shuffle_slots).lower() == "random":
-        ret.shop_shuffle_slots = random.randint(0, 30)
-    else:
-        ret.shop_shuffle_slots = int(shuffle_slots)
-
-    ret.shop_shuffle = get_choice('shop_shuffle', weights, '')
-    if not ret.shop_shuffle:
-        ret.shop_shuffle = ''
-
-    ret.mode = get_choice("mode", weights)
-    ret.retro = get_choice("retro", weights)
-
-    ret.hints = get_choice('hints', weights)
-
-    ret.swordless = get_choice('swordless', weights, False)
-
-    ret.difficulty = get_choice('item_pool', weights)
-
-    ret.item_functionality = get_choice('item_functionality', weights)
-
-    boss_shuffle = get_choice('boss_shuffle', weights)
-    ret.shufflebosses = get_plando_bosses(boss_shuffle, plando_options)
-
-    ret.enemy_shuffle = bool(get_choice('enemy_shuffle', weights, False))
-
-
-    ret.killable_thieves = get_choice('killable_thieves', weights, False)
-    ret.tile_shuffle = get_choice('tile_shuffle', weights, False)
-    ret.bush_shuffle = get_choice('bush_shuffle', weights, False)
-
-    ret.enemy_damage = {None: 'default',
-                        'default': 'default',
-                        'shuffled': 'shuffled',
-                        'random': 'chaos'
-                        }[get_choice('enemy_damage', weights)]
-
-    ret.enemy_health = get_choice('enemy_health', weights)
-
-    ret.shufflepots = get_choice('pot_shuffle', weights)
-
-    ret.beemizer = int(get_choice('beemizer', weights, 0))
-
-    ret.timer = {'none': False,
-                 None: False,
-                 False: False,
-                 'timed': 'timed',
-                 'timed_ohko': 'timed-ohko',
-                 'ohko': 'ohko',
-                 'timed_countdown': 'timed-countdown',
-                 'display': 'display'}[get_choice('timer', weights, False)]
-
-    ret.countdown_start_time = int(get_choice('countdown_start_time', weights, 10))
-    ret.red_clock_time = int(get_choice('red_clock_time', weights, -2))
-    ret.blue_clock_time = int(get_choice('blue_clock_time', weights, 2))
-    ret.green_clock_time = int(get_choice('green_clock_time', weights, 4))
-
-    ret.dungeon_counters = get_choice('dungeon_counters', weights, 'default')
-
-    ret.progressive = convert_to_on_off(get_choice('progressive', weights, 'on'))
-
-    ret.shuffle_prizes = get_choice('shuffle_prizes', weights, "g")
-
-    ret.required_medallions = [get_choice("misery_mire_medallion", weights, "random"),
-                               get_choice("turtle_rock_medallion", weights, "random")]
-
-    for index, medallion in enumerate(ret.required_medallions):
-        ret.required_medallions[index] = {"ether": "Ether", "quake": "Quake", "bombos": "Bombos", "random": "random"} \
-            .get(medallion.lower(), None)
-        if not ret.required_medallions[index]:
-            raise Exception(f"unknown Medallion {medallion} for {'misery mire' if index == 0 else 'turtle rock'}")
-
-    ret.glitch_boots = get_choice('glitch_boots', weights, True)
-
-    if get_choice("local_keys", weights, "l" in dungeon_items):
-        # () important for ordering of commands, without them the Big Keys section is part of the Small Key else
-        ret.local_items |= item_name_groups["Small Keys"] if ret.keyshuffle else set()
-        ret.local_items |= item_name_groups["Big Keys"] if ret.bigkeyshuffle else set()
-
-    ret.plando_items = []
-    if "items" in plando_options:
-
-        def add_plando_item(item: str, location: str):
-            if item not in item_table:
-                raise Exception(f"Could not plando item {item} as the item was not recognized")
-            if location not in location_table and location not in key_drop_data:
-                raise Exception(
-                    f"Could not plando item {item} at location {location} as the location was not recognized")
-            ret.plando_items.append(PlandoItem(item, location, location_world, from_pool, force))
-
-        options = weights.get("plando_items", [])
-        for placement in options:
-            if roll_percentage(get_choice("percentage", placement, 100)):
-                from_pool = get_choice("from_pool", placement, PlandoItem._field_defaults["from_pool"])
-                location_world = get_choice("world", placement, PlandoItem._field_defaults["world"])
-                force = str(get_choice("force", placement, PlandoItem._field_defaults["force"])).lower()
-                if "items" in placement and "locations" in placement:
-                    items = placement["items"]
-                    locations = placement["locations"]
-                    if isinstance(items, dict):
-                        item_list = []
-                        for key, value in items.items():
-                            item_list += [key] * value
-                        items = item_list
-                    if not items or not locations:
-                        raise Exception("You must specify at least one item and one location to place items.")
-                    random.shuffle(items)
-                    random.shuffle(locations)
-                    for item, location in zip(items, locations):
-                        add_plando_item(item, location)
-                else:
-                    item = get_choice("item", placement, get_choice("items", placement))
-                    location = get_choice("location", placement)
-                    add_plando_item(item, location)
-
-    ret.plando_texts = {}
-    if "texts" in plando_options:
-        tt = TextTable()
-        tt.removeUnwantedText()
-        options = weights.get("plando_texts", [])
-        for placement in options:
-            if roll_percentage(get_choice("percentage", placement, 100)):
-                at = str(get_choice("at", placement))
-                if at not in tt:
-                    raise Exception(f"No text target \"{at}\" found.")
-                ret.plando_texts[at] = str(get_choice("text", placement))
-
-    ret.plando_connections = []
-    if "connections" in plando_options:
-        options = weights.get("plando_connections", [])
-        for placement in options:
-            if roll_percentage(get_choice("percentage", placement, 100)):
-                ret.plando_connections.append(PlandoConnection(
-                    get_choice("entrance", placement),
-                    get_choice("exit", placement),
-                    get_choice("direction", placement, "both")
-                ))
-
-    if 'rom' in weights:
-        romweights = weights['rom']
-
-        ret.sprite_pool = romweights['sprite_pool'] if 'sprite_pool' in romweights else []
-        ret.sprite = get_choice('sprite', romweights, "Link")
-        if 'random_sprite_on_event' in romweights:
-            randomoneventweights = romweights['random_sprite_on_event']
-            if get_choice('enabled', randomoneventweights, False):
-                ret.sprite = 'randomon'
-                ret.sprite += '-hit' if get_choice('on_hit', randomoneventweights, True) else ''
-                ret.sprite += '-enter' if get_choice('on_enter', randomoneventweights, False) else ''
-                ret.sprite += '-exit' if get_choice('on_exit', randomoneventweights, False) else ''
-                ret.sprite += '-slash' if get_choice('on_slash', randomoneventweights, False) else ''
-                ret.sprite += '-item' if get_choice('on_item', randomoneventweights, False) else ''
-                ret.sprite += '-bonk' if get_choice('on_bonk', randomoneventweights, False) else ''
-                ret.sprite = 'randomonall' if get_choice('on_everything', randomoneventweights, False) else ret.sprite
-                ret.sprite = 'randomonnone' if ret.sprite == 'randomon' else ret.sprite
-
-                if (not ret.sprite_pool or get_choice('use_weighted_sprite_pool', randomoneventweights, False)) \
-                        and 'sprite' in romweights:  # Use sprite as a weighted sprite pool, if a sprite pool is not already defined.
-                    for key, value in romweights['sprite'].items():
-                        if key.startswith('random'):
-                            ret.sprite_pool += ['random'] * int(value)
-                        else:
-                            ret.sprite_pool += [key] * int(value)
-
-        ret.disablemusic = get_choice('disablemusic', romweights, False)
-        ret.triforcehud = get_choice('triforcehud', romweights, 'hide_goal')
-        ret.quickswap = get_choice('quickswap', romweights, True)
-        ret.fastmenu = get_choice('menuspeed', romweights, "normal")
-        ret.reduceflashing = get_choice('reduceflashing', romweights, False)
-        ret.heartcolor = get_choice('heartcolor', romweights, "red")
-        ret.heartbeep = convert_to_on_off(get_choice('heartbeep', romweights, "normal"))
-        ret.ow_palettes = get_choice('ow_palettes', romweights, "default")
-        ret.uw_palettes = get_choice('uw_palettes', romweights, "default")
-        ret.hud_palettes = get_choice('hud_palettes', romweights, "default")
-        ret.sword_palettes = get_choice('sword_palettes', romweights, "default")
-        ret.shield_palettes = get_choice('shield_palettes', romweights, "default")
-        ret.link_palettes = get_choice('link_palettes', romweights, "default")
-
-    else:
-        ret.quickswap = True
-        ret.sprite = "Link"
-
-
-if __name__ == '__main__':
-    main()

NetUtils.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
-import asyncio
-import logging
+
 import typing
 import enum
 from json import JSONEncoder, JSONDecoder
@@ -15,8 +14,10 @@ class JSONMessagePart(typing.TypedDict, total=False):
     # optional
     type: str
     color: str
-    # mainly for items, optional
-    found: bool
+    # owning player for location/item
+    player: int
+    # if type == item indicates item flags
+    flags: int
 
 
 class ClientStatus(enum.IntEnum):
@@ -27,17 +28,57 @@ class ClientStatus(enum.IntEnum):
     CLIENT_GOAL = 30
 
 
+class SlotType(enum.IntFlag):
+    spectator = 0b00
+    player = 0b01
+    group = 0b10
+
+    @property
+    def always_goal(self) -> bool:
+        """Mark this slot has having reached its goal instantly."""
+        return self.value != 0b01
+
+
+class Permission(enum.IntFlag):
+    disabled = 0b000  # 0, completely disables access
+    enabled = 0b001  # 1, allows manual use
+    goal = 0b010  # 2, allows manual use after goal completion
+    auto = 0b110  # 6, forces use after goal completion, only works for forfeit
+    auto_enabled = 0b111  # 7, forces use after goal completion, allows manual use any time
+
+    @staticmethod
+    def from_text(text: str):
+        data = 0
+        if "auto" in text:
+            data |= 0b110
+        elif "goal" in text:
+            data |= 0b010
+        if "enabled" in text:
+            data |= 0b001
+        return Permission(data)
+
+
 class NetworkPlayer(typing.NamedTuple):
+    """Represents a particular player on a particular team."""
     team: int
     slot: int
     alias: str
     name: str
 
 
+class NetworkSlot(typing.NamedTuple):
+    """Represents a particular slot across teams."""
+    name: str
+    game: str
+    type: SlotType
+    group_members: typing.Union[typing.List[int], typing.Tuple] = ()  # only populated if type == group
+
+
 class NetworkItem(typing.NamedTuple):
     item: int
     location: int
     player: int
+    flags: int = 0
 
 
 def _scan_for_TypedTuples(obj: typing.Any) -> typing.Any:
@@ -45,7 +86,7 @@ def _scan_for_TypedTuples(obj: typing.Any) -> typing.Any:
         data = obj._asdict()
         data["class"] = obj.__class__.__name__
         return data
-    if isinstance(obj, (tuple, list)):
+    if isinstance(obj, (tuple, list, set)):
         return tuple(_scan_for_TypedTuples(o) for o in obj)
     if isinstance(obj, dict):
         return {key: _scan_for_TypedTuples(value) for key, value in obj.items()}
@@ -55,6 +96,7 @@ def _scan_for_TypedTuples(obj: typing.Any) -> typing.Any:
 _encode = JSONEncoder(
     ensure_ascii=False,
     check_circular=False,
+    separators=(',', ':'),
 ).encode
 
 
@@ -67,9 +109,11 @@ def get_any_version(data: dict) -> Version:
     return Version(int(data["major"]), int(data["minor"]), int(data["build"]))
 
 
-whitelist = {"NetworkPlayer": NetworkPlayer,
-             "NetworkItem": NetworkItem,
-             }
+whitelist = {
+    "NetworkPlayer": NetworkPlayer,
+    "NetworkItem": NetworkItem,
+    "NetworkSlot": NetworkSlot
+}
 
 custom_hooks = {
     "Version": get_any_version
@@ -94,60 +138,12 @@ def _object_hook(o: typing.Any) -> typing.Any:
 decode = JSONDecoder(object_hook=_object_hook).decode
 
 
-class Node:
-    endpoints: typing.List
-    dumper = staticmethod(encode)
-    loader = staticmethod(decode)
-
-    def __init__(self):
-        self.endpoints = []
-        super(Node, self).__init__()
-        self.log_network = 0
-
-    def broadcast_all(self, msgs):
-        msgs = self.dumper(msgs)
-        for endpoint in self.endpoints:
-            asyncio.create_task(self.send_encoded_msgs(endpoint, msgs))
-
-    async def send_msgs(self, endpoint: Endpoint, msgs: typing.Iterable[dict]):
-        if not endpoint.socket or not endpoint.socket.open or endpoint.socket.closed:
-            return
-        msg = self.dumper(msgs)
-        try:
-            await endpoint.socket.send(msg)
-        except websockets.ConnectionClosed:
-            logging.exception(f"Exception during send_msgs, could not send {msg}")
-            await self.disconnect(endpoint)
-        else:
-            if self.log_network:
-                logging.info(f"Outgoing message: {msg}")
-
-    async def send_encoded_msgs(self, endpoint: Endpoint, msg: str):
-        if not endpoint.socket or not endpoint.socket.open or endpoint.socket.closed:
-            return
-        try:
-            await endpoint.socket.send(msg)
-        except websockets.ConnectionClosed:
-            logging.exception("Exception during send_msgs")
-            await self.disconnect(endpoint)
-        else:
-            if self.log_network:
-                logging.info(f"Outgoing message: {msg}")
-
-    async def disconnect(self, endpoint):
-        if endpoint in self.endpoints:
-            self.endpoints.remove(endpoint)
-
-
 class Endpoint:
     socket: websockets.WebSocketServerProtocol
 
     def __init__(self, socket):
         self.socket = socket
 
-    async def disconnect(self):
-        raise NotImplementedError
-
 
 class HandlerMeta(type):
     def __new__(mcs, name, bases, attrs):
@@ -166,11 +162,11 @@ class HandlerMeta(type):
                     break
 
         def __init__(self, *args, **kwargs):
+            if orig_init:
+                orig_init(self, *args, **kwargs)
             # turn functions into bound methods
             self.handlers = {name: method.__get__(self, type(self)) for name, method in
                              handlers.items()}
-            if orig_init:
-                orig_init(self, *args, **kwargs)
 
         attrs['__init__'] = __init__
         return super(HandlerMeta, mcs).__new__(mcs, name, bases, attrs)
@@ -189,6 +185,21 @@ class JSONTypes(str, enum.Enum):
 
 
 class JSONtoTextParser(metaclass=HandlerMeta):
+    color_codes = {
+        # not exact color names, close enough but decent looking
+        "black": "000000",
+        "red": "EE0000",
+        "green": "00FF7F",
+        "yellow": "FAFAD2",
+        "blue": "6495ED",
+        "magenta": "EE00EE",
+        "cyan": "00EEEE",
+        "slateblue": "6D8BE8",
+        "plum": "AF99EF",
+        "salmon": "FA8072",
+        "white": "FFFFFF"
+    }
+
     def __init__(self, ctx):
         self.ctx = ctx
 
@@ -196,13 +207,13 @@ class JSONtoTextParser(metaclass=HandlerMeta):
         return "".join(self.handle_node(section) for section in input_object)
 
     def handle_node(self, node: JSONMessagePart):
-        type = node.get("type", None)
-        handler = self.handlers.get(type, self.handlers["text"])
+        node_type = node.get("type", None)
+        handler = self.handlers.get(node_type, self.handlers["text"])
         return handler(node)
 
     def _handle_color(self, node: JSONMessagePart):
         codes = node["color"].split(";")
-        buffer = "".join(color_code(code) for code in codes)
+        buffer = "".join(color_code(code) for code in codes if code in color_codes)
         return buffer + self._handle_text(node) + color_code("reset")
 
     def _handle_text(self, node: JSONMessagePart):
@@ -220,29 +231,35 @@ class JSONtoTextParser(metaclass=HandlerMeta):
         return self._handle_color(node)
 
     def _handle_item_name(self, node: JSONMessagePart):
-        # todo: use a better info source
-        from worlds.alttp.Items import progression_items
-        node["color"] = 'green' if node.get("found", False) else 'cyan'
-        if node["text"] in progression_items:
-            node["color"] += ";white_bg"
+        flags = node.get("flags", 0)
+        if flags == 0:
+            node["color"] = 'cyan'
+        elif flags & 0b001:  # advancement
+            node["color"] = 'plum'
+        elif flags & 0b010:  # useful
+            node["color"] = 'slateblue'
+        elif flags & 0b100:  # trap
+            node["color"] = 'salmon'
+        else:
+            node["color"] = 'cyan'
         return self._handle_color(node)
 
     def _handle_item_id(self, node: JSONMessagePart):
         item_id = int(node["text"])
-        node["text"] = self.ctx.item_name_getter(item_id)
+        node["text"] = self.ctx.item_names[item_id]
         return self._handle_item_name(node)
 
     def _handle_location_name(self, node: JSONMessagePart):
-        node["color"] = 'blue_bg;white'
+        node["color"] = 'green'
         return self._handle_color(node)
 
     def _handle_location_id(self, node: JSONMessagePart):
         item_id = int(node["text"])
-        node["text"] = self.ctx.location_name_getter(item_id)
-        return self._handle_item_name(node)
+        node["text"] = self.ctx.location_names[item_id]
+        return self._handle_location_name(node)
 
     def _handle_entrance_name(self, node: JSONMessagePart):
-        node["color"] = 'white_bg;black'
+        node["color"] = 'blue'
         return self._handle_color(node)
 
 
@@ -268,6 +285,14 @@ def add_json_text(parts: list, text: typing.Any, **kwargs) -> None:
     parts.append({"text": str(text), **kwargs})
 
 
+def add_json_item(parts: list, item_id: int, player: int = 0, item_flags: int = 0, **kwargs) -> None:
+    parts.append({"text": str(item_id), "player": player, "flags": item_flags, "type": JSONTypes.item_id, **kwargs})
+
+
+def add_json_location(parts: list, item_id: int, player: int = 0, **kwargs) -> None:
+    parts.append({"text": str(item_id), "player": player, "type": JSONTypes.location_id, **kwargs})
+
+
 class Hint(typing.NamedTuple):
     receiving_player: int
     finding_player: int
@@ -275,13 +300,15 @@ class Hint(typing.NamedTuple):
     item: int
     found: bool
     entrance: str = ""
+    item_flags: int = 0
 
     def re_check(self, ctx, team) -> Hint:
         if self.found:
             return self
         found = self.location in ctx.location_checks[team, self.finding_player]
         if found:
-            return Hint(self.receiving_player, self.finding_player, self.location, self.item, found, self.entrance)
+            return Hint(self.receiving_player, self.finding_player, self.location, self.item, found, self.entrance,
+                        self.item_flags)
         return self
 
     def __hash__(self):
@@ -292,9 +319,9 @@ class Hint(typing.NamedTuple):
         add_json_text(parts, "[Hint]: ")
         add_json_text(parts, self.receiving_player, type="player_id")
         add_json_text(parts, "'s ")
-        add_json_text(parts, self.item, type="item_id", found=self.found)
+        add_json_item(parts, self.item, self.receiving_player, self.item_flags)
         add_json_text(parts, " is at ")
-        add_json_text(parts, self.location, type="location_id")
+        add_json_location(parts, self.location, self.finding_player)
         add_json_text(parts, " in ")
         add_json_text(parts, self.finding_player, type="player_id")
         if self.entrance:
@@ -302,12 +329,16 @@ class Hint(typing.NamedTuple):
             add_json_text(parts, self.entrance, type="entrance_name")
         else:
             add_json_text(parts, "'s World")
+        add_json_text(parts, ". ")
         if self.found:
-            add_json_text(parts, ". (found)")
+            add_json_text(parts, "(found)", type="color", color="green")
         else:
-            add_json_text(parts, ".")
+            add_json_text(parts, "(not found)", type="color", color="red")
 
-        return {"cmd": "PrintJSON", "data": parts, "type": "hint"}
+        return {"cmd": "PrintJSON", "data": parts, "type": "Hint",
+                "receiving": self.receiving_player,
+                "item": NetworkItem(self.item, self.location, self.finding_player, self.item_flags),
+                "found": self.found}
 
     @property
     def local(self):

OoTAdjuster.py

@@ -0,0 +1,246 @@
+import tkinter as tk
+import argparse
+import logging
+import random
+import os
+from itertools import chain
+
+from BaseClasses import MultiWorld
+from Options import Choice, Range, Toggle
+from worlds.oot import OOTWorld
+from worlds.oot.Cosmetics import patch_cosmetics
+from worlds.oot.Options import cosmetic_options, sfx_options
+from worlds.oot.Rom import Rom, compress_rom_file
+from worlds.oot.N64Patch import apply_patch_file
+from worlds.oot.Utils import data_path
+from Utils import local_path
+
+logger = logging.getLogger('OoTAdjuster')
+
+def main():
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument('--rom', default='', 
+        help='Path to an OoT randomized ROM to adjust.')
+    parser.add_argument('--vanilla_rom', default='',
+        help='Path to a vanilla OoT ROM for patching.')
+    for name, option in chain(cosmetic_options.items(), sfx_options.items()):
+        parser.add_argument('--'+name, default=None,
+            help=option.__doc__)
+    parser.add_argument('--is_glitched', default=False, action='store_true',
+        help='Setting this to true will enable protection on kokiri tunic colors for weirdshot.')
+    parser.add_argument('--deathlink',
+        help='Enable DeathLink system', action='store_true')
+
+    args = parser.parse_args()
+    if not os.path.isfile(args.rom):
+        adjustGUI()
+    else:
+        adjust(args)
+
+def adjustGUI():
+    from tkinter import Tk, LEFT, BOTTOM, TOP, E, W, \
+        StringVar, IntVar, Checkbutton, Frame, Label, X, Entry, Button, \
+        OptionMenu, filedialog, messagebox, ttk
+    from argparse import Namespace
+    from Main import __version__ as MWVersion
+
+    window = tk.Tk()
+    window.wm_title(f"Archipelago {MWVersion} OoT Adjuster")
+    set_icon(window)
+
+    opts = Namespace()
+
+    # Select ROM
+    romDialogFrame = Frame(window)
+    romLabel = Label(romDialogFrame, text='Rom/patch to adjust')
+    vanillaLabel = Label(romDialogFrame, text='OoT Base Rom')
+    opts.rom = StringVar()
+    opts.vanilla_rom = StringVar(value="The Legend of Zelda - Ocarina of Time.z64")
+    romEntry = Entry(romDialogFrame, textvariable=opts.rom)
+    vanillaEntry = Entry(romDialogFrame, textvariable=opts.vanilla_rom)
+
+    def RomSelect():
+        rom = filedialog.askopenfilename(filetypes=[("Rom Files", (".z64", ".n64", ".apz5")), ("All Files", "*")])
+        opts.rom.set(rom)
+    def VanillaSelect():
+        rom = filedialog.askopenfilename(filetypes=[("Rom Files", (".z64", ".n64")), ("All Files", "*")])
+        opts.vanilla_rom.set(rom)
+
+    romSelectButton = Button(romDialogFrame, text='Select Rom', command=RomSelect)
+    vanillaSelectButton = Button(romDialogFrame, text='Select Rom', command=VanillaSelect)
+    romDialogFrame.pack(side=TOP, expand=True, fill=X)
+    romLabel.pack(side=LEFT)
+    romEntry.pack(side=LEFT, expand=True, fill=X)
+    romSelectButton.pack(side=LEFT)
+    vanillaLabel.pack(side=LEFT)
+    vanillaEntry.pack(side=LEFT, expand=True, fill=X)
+    vanillaSelectButton.pack(side=LEFT)
+
+    # Cosmetic options
+    romSettingsFrame = Frame(window)
+
+    def dropdown_option(type, option_name, row, column):
+        if type == 'cosmetic':
+            option = cosmetic_options[option_name]
+        elif type == 'sfx':
+            option = sfx_options[option_name]
+        optionFrame = Frame(romSettingsFrame)
+        optionFrame.grid(row=row, column=column, sticky=E)
+        optionLabel = Label(optionFrame, text=option.display_name)
+        optionLabel.pack(side=LEFT)
+        setattr(opts, option_name, StringVar())
+        getattr(opts, option_name).set(option.name_lookup[option.default])
+        optionMenu = OptionMenu(optionFrame, getattr(opts, option_name), *option.name_lookup.values())
+        optionMenu.pack(side=LEFT)
+
+    dropdown_option('cosmetic', 'default_targeting', 0, 0)
+    dropdown_option('cosmetic', 'display_dpad', 0, 1)
+    dropdown_option('cosmetic', 'correct_model_colors', 0, 2)
+    dropdown_option('cosmetic', 'background_music', 1, 0)
+    dropdown_option('cosmetic', 'fanfares', 1, 1)
+    dropdown_option('cosmetic', 'ocarina_fanfares', 1, 2)
+    dropdown_option('cosmetic', 'kokiri_color', 2, 0)
+    dropdown_option('cosmetic', 'goron_color', 2, 1)
+    dropdown_option('cosmetic', 'zora_color', 2, 2)
+    dropdown_option('cosmetic', 'silver_gauntlets_color', 3, 0)
+    dropdown_option('cosmetic', 'golden_gauntlets_color', 3, 1)
+    dropdown_option('cosmetic', 'mirror_shield_frame_color', 3, 2)
+    dropdown_option('cosmetic', 'navi_color_default_inner', 4, 0)
+    dropdown_option('cosmetic', 'navi_color_default_outer', 4, 1)
+    dropdown_option('cosmetic', 'navi_color_enemy_inner', 5, 0)
+    dropdown_option('cosmetic', 'navi_color_enemy_outer', 5, 1)
+    dropdown_option('cosmetic', 'navi_color_npc_inner', 6, 0)
+    dropdown_option('cosmetic', 'navi_color_npc_outer', 6, 1)
+    dropdown_option('cosmetic', 'navi_color_prop_inner', 7, 0)
+    dropdown_option('cosmetic', 'navi_color_prop_outer', 7, 1)
+    # sword_trail_duration, 8, 2
+    dropdown_option('cosmetic', 'sword_trail_color_inner', 8, 0)
+    dropdown_option('cosmetic', 'sword_trail_color_outer', 8, 1)
+    dropdown_option('cosmetic', 'bombchu_trail_color_inner', 9, 0)
+    dropdown_option('cosmetic', 'bombchu_trail_color_outer', 9, 1)
+    dropdown_option('cosmetic', 'boomerang_trail_color_inner', 10, 0)
+    dropdown_option('cosmetic', 'boomerang_trail_color_outer', 10, 1)
+    dropdown_option('cosmetic', 'heart_color', 11, 0)
+    dropdown_option('cosmetic', 'magic_color', 12, 0)
+    dropdown_option('cosmetic', 'a_button_color', 11, 1)
+    dropdown_option('cosmetic', 'b_button_color', 11, 2)
+    dropdown_option('cosmetic', 'c_button_color', 12, 1)
+    dropdown_option('cosmetic', 'start_button_color', 12, 2)
+
+    dropdown_option('sfx', 'sfx_navi_overworld', 14, 0)
+    dropdown_option('sfx', 'sfx_navi_enemy', 14, 1)
+    dropdown_option('sfx', 'sfx_low_hp', 14, 2)
+    dropdown_option('sfx', 'sfx_menu_cursor', 15, 0)
+    dropdown_option('sfx', 'sfx_menu_select', 15, 1)
+    dropdown_option('sfx', 'sfx_nightfall', 15, 2)
+    dropdown_option('sfx', 'sfx_horse_neigh', 16, 0)
+    dropdown_option('sfx', 'sfx_hover_boots', 16, 1)
+    dropdown_option('sfx', 'sfx_ocarina', 16, 2)
+
+    # Special cases
+    # Sword trail duration is a range
+    option = cosmetic_options['sword_trail_duration']
+    optionFrame = Frame(romSettingsFrame)
+    optionFrame.grid(row=8, column=2, sticky=E)
+    optionLabel = Label(optionFrame, text=option.display_name)
+    optionLabel.pack(side=LEFT)
+    setattr(opts, 'sword_trail_duration', StringVar())
+    getattr(opts, 'sword_trail_duration').set(option.default)
+    optionMenu = OptionMenu(optionFrame, getattr(opts, 'sword_trail_duration'), *range(4, 21))
+    optionMenu.pack(side=LEFT)
+
+    # Glitched is a checkbox
+    opts.is_glitched = IntVar(value=0)
+    glitched_checkbox = Checkbutton(romSettingsFrame, text="Glitched Logic?", variable=opts.is_glitched)
+    glitched_checkbox.grid(row=17, column=0, sticky=W)
+
+    # Deathlink is a checkbox
+    opts.deathlink = IntVar(value=0)
+    deathlink_checkbox = Checkbutton(romSettingsFrame, text="DeathLink (Team Deaths)", variable=opts.deathlink)
+    deathlink_checkbox.grid(row=17, column=1, sticky=W)
+
+    romSettingsFrame.pack(side=TOP)
+
+    def adjustRom():
+        try:
+            guiargs = Namespace()
+            options = vars(opts)
+            for o in options:
+                result = options[o].get()
+                if result == 'true':
+                    result = True
+                if result == 'false':
+                    result = False
+                setattr(guiargs, o, result)
+            guiargs.sword_trail_duration = int(guiargs.sword_trail_duration)
+            path = adjust(guiargs)
+        except Exception as e:
+            logging.exception(e)
+            messagebox.showerror(title="Error while adjusting Rom", message=str(e))
+        else:
+            messagebox.showinfo(title="Success", message=f"Rom patched successfully to {path}")
+
+    # Adjust button
+    bottomFrame = Frame(window)
+    adjustButton = Button(bottomFrame, text='Adjust Rom', command=adjustRom)
+    adjustButton.pack(side=BOTTOM, padx=(5, 5))
+    bottomFrame.pack(side=BOTTOM, pady=(5, 5))
+
+    window.mainloop()
+
+def set_icon(window):
+    logo = tk.PhotoImage(file=local_path('data', 'icon.png'))
+    window.tk.call('wm', 'iconphoto', window._w, logo)
+
+def adjust(args):
+    # Create a fake world and OOTWorld to use as a base
+    world = MultiWorld(1)
+    world.slot_seeds = {1: random}
+    ootworld = OOTWorld(world, 1)
+    # Set options in the fake OOTWorld
+    for name, option in chain(cosmetic_options.items(), sfx_options.items()):
+        result = getattr(args, name, None)
+        if result is None:
+            if issubclass(option, Choice):
+                result = option.name_lookup[option.default]
+            elif issubclass(option, Range) or issubclass(option, Toggle):
+                result = option.default
+            else:
+                raise Exception("Unsupported option type")
+        setattr(ootworld, name, result)
+    ootworld.logic_rules = 'glitched' if args.is_glitched else 'glitchless'
+    ootworld.death_link = args.deathlink
+
+    delete_zootdec = False
+    if os.path.splitext(args.rom)[-1] in ['.z64', '.n64']:
+        # Load up the ROM
+        rom = Rom(file=args.rom, force_use=True)
+        delete_zootdec = True
+    elif os.path.splitext(args.rom)[-1] == '.apz5':
+        # Load vanilla ROM
+        rom = Rom(file=args.vanilla_rom, force_use=True)
+        # Patch file
+        apply_patch_file(rom, args.rom)
+    else:
+        raise Exception("Invalid file extension; requires .n64, .z64, .apz5")
+    # Call patch_cosmetics
+    try:
+        patch_cosmetics(ootworld, rom)
+        rom.write_byte(rom.sym('DEATH_LINK'), args.deathlink)
+        # Output new file
+        path_pieces = os.path.splitext(args.rom)
+        decomp_path = path_pieces[0] + '-adjusted-decomp.n64'
+        comp_path = path_pieces[0] + '-adjusted.n64'
+        rom.write_to_file(decomp_path)
+        os.chdir(data_path("Compress"))
+        compress_rom_file(decomp_path, comp_path)
+        os.remove(decomp_path)
+    finally:
+        if delete_zootdec:
+            os.chdir(os.path.split(__file__)[0])
+            os.remove("ZOOTDEC.z64")
+    return comp_path
+
+if __name__ == '__main__':
+    main()

OoTClient.py

@@ -0,0 +1,307 @@
+import asyncio
+import json
+import os
+import multiprocessing
+import subprocess
+from asyncio import StreamReader, StreamWriter
+
+from CommonClient import CommonContext, server_loop, gui_enabled, console_loop, \
+    ClientCommandProcessor, logger, get_base_parser
+import Utils
+from worlds import network_data_package
+from worlds.oot.Rom import Rom, compress_rom_file
+from worlds.oot.N64Patch import apply_patch_file
+from worlds.oot.Utils import data_path
+
+
+CONNECTION_TIMING_OUT_STATUS = "Connection timing out. Please restart your emulator, then restart oot_connector.lua"
+CONNECTION_REFUSED_STATUS = "Connection refused. Please start your emulator and make sure oot_connector.lua is running"
+CONNECTION_RESET_STATUS = "Connection was reset. Please restart your emulator, then restart oot_connector.lua"
+CONNECTION_TENTATIVE_STATUS = "Initial Connection Made"
+CONNECTION_CONNECTED_STATUS = "Connected"
+CONNECTION_INITIAL_STATUS = "Connection has not been initiated"
+
+"""
+Payload: lua -> client
+{
+    playerName: string,
+    locations: dict,
+    deathlinkActive: bool,
+    isDead: bool,
+    gameComplete: bool
+}
+
+Payload: client -> lua
+{
+    items: list,
+    playerNames: list,
+    triggerDeath: bool
+}
+
+Deathlink logic:
+"Dead" is true <-> Link is at 0 hp.
+
+deathlink_pending: we need to kill the player
+deathlink_sent_this_death: we interacted with the multiworld on this death, waiting to reset with living link
+
+"""
+
+oot_loc_name_to_id = network_data_package["games"]["Ocarina of Time"]["location_name_to_id"]
+
+script_version: int = 2
+
+def get_item_value(ap_id):
+    return ap_id - 66000
+
+
+class OoTCommandProcessor(ClientCommandProcessor):
+    def __init__(self, ctx): 
+        super().__init__(ctx)
+
+    def _cmd_n64(self):
+        """Check N64 Connection State"""
+        if isinstance(self.ctx, OoTContext):
+            logger.info(f"N64 Status: {self.ctx.n64_status}")
+
+    def _cmd_deathlink(self):
+        """Toggle deathlink from client. Overrides default setting."""
+        if isinstance(self.ctx, OoTContext):
+            self.ctx.deathlink_client_override = True
+            self.ctx.deathlink_enabled = not self.ctx.deathlink_enabled
+            asyncio.create_task(self.ctx.update_death_link(self.ctx.deathlink_enabled), name="Update Deathlink")
+
+
+class OoTContext(CommonContext):
+    command_processor = OoTCommandProcessor
+    items_handling = 0b001  # full local
+
+    def __init__(self, server_address, password):
+        super().__init__(server_address, password)
+        self.game = 'Ocarina of Time'
+        self.n64_streams: (StreamReader, StreamWriter) = None
+        self.n64_sync_task = None
+        self.n64_status = CONNECTION_INITIAL_STATUS
+        self.awaiting_rom = False
+        self.location_table = {}
+        self.deathlink_enabled = False
+        self.deathlink_pending = False
+        self.deathlink_sent_this_death = False
+        self.deathlink_client_override = False
+        self.version_warning = False
+
+    async def server_auth(self, password_requested: bool = False):
+        if password_requested and not self.password:
+            await super(OoTContext, self).server_auth(password_requested)
+        if not self.auth:
+            self.awaiting_rom = True
+            logger.info('Awaiting connection to Bizhawk to get player information')
+            return
+
+        await self.send_connect()
+
+    def on_deathlink(self, data: dict):
+        self.deathlink_pending = True
+        super().on_deathlink(data)
+
+    def run_gui(self):
+        from kvui import GameManager
+
+        class OoTManager(GameManager):
+            logging_pairs = [
+                ("Client", "Archipelago")
+            ]
+            base_title = "Archipelago Ocarina of Time Client"
+
+        self.ui = OoTManager(self)
+        self.ui_task = asyncio.create_task(self.ui.async_run(), name="UI")
+
+
+def get_payload(ctx: OoTContext):
+    if ctx.deathlink_enabled and ctx.deathlink_pending:
+        trigger_death = True
+        ctx.deathlink_sent_this_death = True
+    else:
+        trigger_death = False
+
+    return json.dumps({
+            "items": [get_item_value(item.item) for item in ctx.items_received],
+            "playerNames": [name for (i, name) in ctx.player_names.items() if i != 0],
+            "triggerDeath": trigger_death
+        })
+
+
+async def parse_payload(payload: dict, ctx: OoTContext, force: bool):
+
+    # Turn on deathlink if it is on, and if the client hasn't overriden it
+    if payload['deathlinkActive'] and not ctx.deathlink_enabled and not ctx.deathlink_client_override:
+        await ctx.update_death_link(True)
+        ctx.deathlink_enabled = True
+
+    # Game completion handling
+    if payload['gameComplete'] and not ctx.finished_game:
+        await ctx.send_msgs([{
+            "cmd": "StatusUpdate",
+            "status": 30
+        }])
+        ctx.finished_game = True
+
+    # Locations handling
+    if ctx.location_table != payload['locations']:
+        ctx.location_table = payload['locations']
+        await ctx.send_msgs([{
+            "cmd": "LocationChecks",
+            "locations": [oot_loc_name_to_id[loc] for loc in ctx.location_table if ctx.location_table[loc]]
+        }])
+
+    # Deathlink handling
+    if ctx.deathlink_enabled:
+        if payload['isDead']: # link is dead
+            ctx.deathlink_pending = False
+            if not ctx.deathlink_sent_this_death:
+                ctx.deathlink_sent_this_death = True
+                await ctx.send_death()
+        else: # link is alive
+            ctx.deathlink_sent_this_death = False
+
+
+async def n64_sync_task(ctx: OoTContext): 
+    logger.info("Starting n64 connector. Use /n64 for status information.")
+    while not ctx.exit_event.is_set():
+        error_status = None
+        if ctx.n64_streams:
+            (reader, writer) = ctx.n64_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 six fields:
+                    # 1. str: player name (always)
+                    # 2. int: script version (always)
+                    # 3. bool: deathlink active (always)
+                    # 4. dict[str, bool]: checked locations
+                    # 5. bool: whether Link is currently at 0 HP
+                    # 6. bool: whether the game currently registers as complete
+                    data = await asyncio.wait_for(reader.readline(), timeout=10)
+                    data_decoded = json.loads(data.decode())
+                    reported_version = data_decoded.get('scriptVersion', 0)
+                    if reported_version >= script_version:
+                        if ctx.game is not None and 'locations' in data_decoded:
+                            # Not just a keep alive ping, parse
+                            asyncio.create_task(parse_payload(data_decoded, ctx, False))
+                        if not ctx.auth:
+                            ctx.auth = data_decoded['playerName']
+                            if ctx.awaiting_rom:
+                                await ctx.server_auth(False)
+                    else:
+                        if not ctx.version_warning:
+                            logger.warning(f"Your Lua script is version {reported_version}, expected {script_version}. "
+                                "Please update to the latest version. "
+                                "Your connection to the Archipelago server will not be accepted.")
+                            ctx.version_warning = True
+                except asyncio.TimeoutError:
+                    logger.debug("Read Timed Out, Reconnecting")
+                    error_status = CONNECTION_TIMING_OUT_STATUS
+                    writer.close()
+                    ctx.n64_streams = None
+                except ConnectionResetError as e:
+                    logger.debug("Read failed due to Connection Lost, Reconnecting")
+                    error_status = CONNECTION_RESET_STATUS
+                    writer.close()
+                    ctx.n64_streams = None
+            except TimeoutError:
+                logger.debug("Connection Timed Out, Reconnecting")
+                error_status = CONNECTION_TIMING_OUT_STATUS
+                writer.close()
+                ctx.n64_streams = None
+            except ConnectionResetError:
+                logger.debug("Connection Lost, Reconnecting")
+                error_status = CONNECTION_RESET_STATUS
+                writer.close()
+                ctx.n64_streams = None
+            if ctx.n64_status == CONNECTION_TENTATIVE_STATUS:
+                if not error_status:
+                    logger.info("Successfully Connected to N64")
+                    ctx.n64_status = CONNECTION_CONNECTED_STATUS
+                else:
+                    ctx.n64_status = f"Was tentatively connected but error occured: {error_status}"
+            elif error_status:
+                ctx.n64_status = error_status
+                logger.info("Lost connection to N64 and attempting to reconnect. Use /n64 for status updates")
+        else:
+            try:
+                logger.debug("Attempting to connect to N64")
+                ctx.n64_streams = await asyncio.wait_for(asyncio.open_connection("localhost", 28921), timeout=10)
+                ctx.n64_status = CONNECTION_TENTATIVE_STATUS
+            except TimeoutError:
+                logger.debug("Connection Timed Out, Trying Again")
+                ctx.n64_status = CONNECTION_TIMING_OUT_STATUS
+                continue
+            except ConnectionRefusedError:
+                logger.debug("Connection Refused, Trying Again")
+                ctx.n64_status = CONNECTION_REFUSED_STATUS
+                continue
+
+
+async def run_game(romfile):
+    auto_start = Utils.get_options()["oot_options"].get("rom_start", True)
+    if auto_start is True:
+        import webbrowser
+        webbrowser.open(romfile)
+    elif os.path.isfile(auto_start):
+        subprocess.Popen([auto_start, romfile],
+                         stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+
+
+async def patch_and_run_game(apz5_file):
+    base_name = os.path.splitext(apz5_file)[0]
+    decomp_path = base_name + '-decomp.z64'
+    comp_path = base_name + '.z64'
+    # Load vanilla ROM, patch file, compress ROM
+    rom = Rom(Utils.local_path(Utils.get_options()["oot_options"]["rom_file"]))
+    apply_patch_file(rom, apz5_file)
+    rom.write_to_file(decomp_path)
+    os.chdir(data_path("Compress"))
+    compress_rom_file(decomp_path, comp_path)
+    os.remove(decomp_path)
+    asyncio.create_task(run_game(comp_path))
+
+
+if __name__ == '__main__':
+
+    Utils.init_logging("OoTClient")
+
+    async def main():
+        multiprocessing.freeze_support()
+        parser = get_base_parser()
+        parser.add_argument('apz5_file', default="", type=str, nargs="?",
+                            help='Path to an APZ5 file')
+        args = parser.parse_args()
+
+        if args.apz5_file:
+            logger.info("APZ5 file supplied, beginning patching process...")
+            asyncio.create_task(patch_and_run_game(args.apz5_file))
+
+        ctx = OoTContext(args.connect, args.password)
+        ctx.server_task = asyncio.create_task(server_loop(ctx), name="Server Loop")
+        if gui_enabled:
+            ctx.run_gui()
+        ctx.run_cli()
+
+        ctx.n64_sync_task = asyncio.create_task(n64_sync_task(ctx), name="N64 Sync")
+
+        await ctx.exit_event.wait()
+        ctx.server_address = None
+
+        await ctx.shutdown()
+
+        if ctx.n64_sync_task:
+            await ctx.n64_sync_task
+
+    import colorama
+
+    colorama.init()
+
+    asyncio.run(main())
+    colorama.deinit()

Patch.py

@@ -1,97 +1,284 @@
+from __future__ import annotations
+
+import shutil
+import json
 import bsdiff4
 import yaml
 import os
 import lzma
-import hashlib
 import threading
 import concurrent.futures
 import zipfile
 import sys
-from typing import Tuple, Optional
+from typing import Tuple, Optional, Dict, Any, Union, BinaryIO
+
+import ModuleUpdate
+ModuleUpdate.update()
 
 import Utils
-from worlds.alttp.Rom import JAP10HASH
 
-current_patch_version = 2
+current_patch_version = 4
 
 
-def get_base_rom_path(file_name: str = "") -> str:
-    options = Utils.get_options()
-    if not file_name:
-        file_name = options["lttp_options"]["rom_file"]
-    if not os.path.exists(file_name):
-        file_name = Utils.local_path(file_name)
-    return file_name
+class AutoPatchRegister(type):
+    patch_types: Dict[str, APDeltaPatch] = {}
+    file_endings: Dict[str, APDeltaPatch] = {}
+
+    def __new__(cls, name: str, bases, dct: Dict[str, Any]):
+        # construct class
+        new_class = super().__new__(cls, name, bases, dct)
+        if "game" in dct:
+            AutoPatchRegister.patch_types[dct["game"]] = new_class
+            if not dct["patch_file_ending"]:
+                raise Exception(f"Need an expected file ending for {name}")
+            AutoPatchRegister.file_endings[dct["patch_file_ending"]] = new_class
+        return new_class
+
+    @staticmethod
+    def get_handler(file: str) -> Optional[type(APDeltaPatch)]:
+        for file_ending, handler in AutoPatchRegister.file_endings.items():
+            if file.endswith(file_ending):
+                return handler
 
 
-def get_base_rom_bytes(file_name: str = "") -> bytes:
-    from worlds.alttp.Rom import read_rom
-    base_rom_bytes = getattr(get_base_rom_bytes, "base_rom_bytes", None)
-    if not base_rom_bytes:
-        file_name = get_base_rom_path(file_name)
-        base_rom_bytes = bytes(read_rom(open(file_name, "rb")))
+class APContainer:
+    """A zipfile containing at least archipelago.json"""
+    version: int = current_patch_version
+    compression_level: int = 9
+    compression_method: int = zipfile.ZIP_DEFLATED
+    game: Optional[str] = None
 
-        basemd5 = hashlib.md5()
-        basemd5.update(base_rom_bytes)
-        if JAP10HASH != basemd5.hexdigest():
-            raise Exception('Supplied Base Rom does not match known MD5 for JAP(1.0) release. '
-                            'Get the correct game and version, then dump it')
-        get_base_rom_bytes.base_rom_bytes = base_rom_bytes
-    return base_rom_bytes
+    # instance attributes:
+    path: Optional[str]
+    player: Optional[int]
+    player_name: str
+    server: str
+
+    def __init__(self, path: Optional[str] = None, player: Optional[int] = None,
+                 player_name: str = "", server: str = ""):
+        self.path = path
+        self.player = player
+        self.player_name = player_name
+        self.server = server
+
+    def write(self, file: Optional[Union[str, BinaryIO]] = None):
+        if not self.path and not file:
+            raise FileNotFoundError(f"Cannot write {self.__class__.__name__} due to no path provided.")
+        with zipfile.ZipFile(file if file else self.path, "w", self.compression_method, True, self.compression_level) \
+                as zf:
+            if file:
+                self.path = zf.filename
+            self.write_contents(zf)
+
+    def write_contents(self, opened_zipfile: zipfile.ZipFile):
+        manifest = self.get_manifest()
+        try:
+            manifest = json.dumps(manifest)
+        except Exception as e:
+            raise Exception(f"Manifest {manifest} did not convert to json.") from e
+        else:
+            opened_zipfile.writestr("archipelago.json", manifest)
+
+    def read(self, file: Optional[Union[str, BinaryIO]] = None):
+        """Read data into patch object. file can be file-like, such as an outer zip file's stream."""
+        if not self.path and not file:
+            raise FileNotFoundError(f"Cannot read {self.__class__.__name__} due to no path provided.")
+        with zipfile.ZipFile(file if file else self.path, "r") as zf:
+            if file:
+                self.path = zf.filename
+            self.read_contents(zf)
+
+    def read_contents(self, opened_zipfile: zipfile.ZipFile):
+        with opened_zipfile.open("archipelago.json", "r") as f:
+            manifest = json.load(f)
+        if manifest["compatible_version"] > self.version:
+            raise Exception(f"File (version: {manifest['compatible_version']}) too new "
+                            f"for this handler (version: {self.version})")
+        self.player = manifest["player"]
+        self.server = manifest["server"]
+        self.player_name = manifest["player_name"]
+
+    def get_manifest(self) -> dict:
+        return {
+            "server": self.server,  # allow immediate connection to server in multiworld. Empty string otherwise
+            "player": self.player,
+            "player_name": self.player_name,
+            "game": self.game,
+            # minimum version of patch system expected for patching to be successful
+            "compatible_version": 4,
+            "version": current_patch_version,
+        }
 
 
-def generate_yaml(patch: bytes, metadata: Optional[dict] = None) -> bytes:
+class APDeltaPatch(APContainer, metaclass=AutoPatchRegister):
+    """An APContainer that additionally has delta.bsdiff4
+    containing a delta patch to get the desired file, often a rom."""
+
+    hash = Optional[str]  # base checksum of source file
+    patch_file_ending: str = ""
+    delta: Optional[bytes] = None
+    result_file_ending: str = ".sfc"
+    source_data: bytes
+
+    def __init__(self, *args, patched_path: str = "", **kwargs):
+        self.patched_path = patched_path
+        super(APDeltaPatch, self).__init__(*args, **kwargs)
+
+    def get_manifest(self) -> dict:
+        manifest = super(APDeltaPatch, self).get_manifest()
+        manifest["base_checksum"] = self.hash
+        manifest["result_file_ending"] = self.result_file_ending
+        return manifest
+
+    @classmethod
+    def get_source_data(cls) -> bytes:
+        """Get Base data"""
+        raise NotImplementedError()
+
+    @classmethod
+    def get_source_data_with_cache(cls) -> bytes:
+        if not hasattr(cls, "source_data"):
+            cls.source_data = cls.get_source_data()
+        return cls.source_data
+
+    def write_contents(self, opened_zipfile: zipfile.ZipFile):
+        super(APDeltaPatch, self).write_contents(opened_zipfile)
+        # write Delta
+        opened_zipfile.writestr("delta.bsdiff4",
+                                bsdiff4.diff(self.get_source_data_with_cache(), open(self.patched_path, "rb").read()),
+                                compress_type=zipfile.ZIP_STORED)  # bsdiff4 is a format with integrated compression
+
+    def read_contents(self, opened_zipfile: zipfile.ZipFile):
+        super(APDeltaPatch, self).read_contents(opened_zipfile)
+        self.delta = opened_zipfile.read("delta.bsdiff4")
+
+    def patch(self, target: str):
+        """Base + Delta -> Patched"""
+        if not self.delta:
+            self.read()
+        result = bsdiff4.patch(self.get_source_data_with_cache(), self.delta)
+        with open(target, "wb") as f:
+            f.write(result)
+
+
+# legacy patch handling follows:
+GAME_ALTTP = "A Link to the Past"
+GAME_SM = "Super Metroid"
+GAME_SOE = "Secret of Evermore"
+GAME_SMZ3 = "SMZ3"
+GAME_DKC3 = "Donkey Kong Country 3"
+supported_games = {"A Link to the Past", "Super Metroid", "Secret of Evermore", "SMZ3", "Donkey Kong Country 3"}
+
+preferred_endings = {
+    GAME_ALTTP: "apbp",
+    GAME_SM: "apm3",
+    GAME_SOE: "apsoe",
+    GAME_SMZ3: "apsmz",
+    GAME_DKC3: "apdkc3"
+}
+
+
+def generate_yaml(patch: bytes, metadata: Optional[dict] = None, game: str = GAME_ALTTP) -> bytes:
+    if game == GAME_ALTTP:
+        from worlds.alttp.Rom import LTTPJPN10HASH as HASH
+    elif game == GAME_SM:
+        from worlds.sm.Rom import SMJUHASH as HASH
+    elif game == GAME_SOE:
+        from worlds.soe.Patch import USHASH as HASH
+    elif game == GAME_SMZ3:
+        from worlds.alttp.Rom import LTTPJPN10HASH as ALTTPHASH
+        from worlds.sm.Rom import SMJUHASH as SMHASH
+        HASH = ALTTPHASH + SMHASH
+    elif game == GAME_DKC3:
+        from worlds.dkc3.Rom import USHASH as HASH
+    else:
+        raise RuntimeError(f"Selected game {game} for base rom not found.")
+
     patch = yaml.dump({"meta": metadata,
                        "patch": patch,
-                       "game": "A Link to the Past",
+                       "game": game,
                        # minimum version of patch system expected for patching to be successful
-                       "compatible_version": 1,
+                       "compatible_version": 3,
                        "version": current_patch_version,
-                       "base_checksum": JAP10HASH})
+                       "base_checksum": HASH})
     return patch.encode(encoding="utf-8-sig")
 
 
-def generate_patch(rom: bytes, metadata: Optional[dict] = None) -> bytes:
+def generate_patch(rom: bytes, metadata: Optional[dict] = None, game: str = GAME_ALTTP) -> bytes:
     if metadata is None:
         metadata = {}
-    patch = bsdiff4.diff(get_base_rom_bytes(), rom)
-    return generate_yaml(patch, metadata)
+    patch = bsdiff4.diff(get_base_rom_data(game), rom)
+    return generate_yaml(patch, metadata, game)
 
 
 def create_patch_file(rom_file_to_patch: str, server: str = "", destination: str = None,
-                      player: int = 0, player_name: str = "") -> str:
-    meta = {"server": server, # allow immediate connection to server in multiworld. Empty string otherwise
+                      player: int = 0, player_name: str = "", game: str = GAME_ALTTP) -> str:
+    meta = {"server": server,  # allow immediate connection to server in multiworld. Empty string otherwise
             "player_id": player,
             "player_name": player_name}
     bytes = generate_patch(load_bytes(rom_file_to_patch),
-                           meta)
-    target = destination if destination else os.path.splitext(rom_file_to_patch)[0] + ".apbp"
+                           meta,
+                           game)
+    target = destination if destination else os.path.splitext(rom_file_to_patch)[0] + (
+        ".apbp" if game == GAME_ALTTP
+        else ".apsmz" if game == GAME_SMZ3
+        else ".apdkc3" if game == GAME_DKC3
+        else ".apm3")
     write_lzma(bytes, target)
     return target
 
 
 def create_rom_bytes(patch_file: str, ignore_version: bool = False) -> Tuple[dict, str, bytearray]:
     data = Utils.parse_yaml(lzma.decompress(load_bytes(patch_file)).decode("utf-8-sig"))
+    game_name = data["game"]
     if not ignore_version and data["compatible_version"] > current_patch_version:
         raise RuntimeError("Patch file is incompatible with this patcher, likely an update is required.")
-    patched_data = bsdiff4.patch(get_base_rom_bytes(), data["patch"])
+    patched_data = bsdiff4.patch(get_base_rom_data(game_name), data["patch"])
     rom_hash = patched_data[int(0x7FC0):int(0x7FD5)]
     data["meta"]["hash"] = "".join(chr(x) for x in rom_hash)
     target = os.path.splitext(patch_file)[0] + ".sfc"
     return data["meta"], target, patched_data
 
 
+def get_base_rom_data(game: str):
+    if game == GAME_ALTTP:
+        from worlds.alttp.Rom import get_base_rom_bytes
+    elif game == "alttp":  # old version for A Link to the Past
+        from worlds.alttp.Rom import get_base_rom_bytes
+    elif game == GAME_SM:
+        from worlds.sm.Rom import get_base_rom_bytes
+    elif game == GAME_SOE:
+        from worlds.soe.Patch import get_base_rom_path
+        get_base_rom_bytes = lambda: bytes(read_rom(open(get_base_rom_path(), "rb")))
+    elif game == GAME_SMZ3:
+        from worlds.smz3.Rom import get_base_rom_bytes
+    elif game == GAME_DKC3:
+        from worlds.dkc3.Rom import get_base_rom_bytes
+    else:
+        raise RuntimeError("Selected game for base rom not found.")
+    return get_base_rom_bytes()
+
+
 def create_rom_file(patch_file: str) -> Tuple[dict, str]:
-    data, target, patched_data = create_rom_bytes(patch_file)
-    with open(target, "wb") as f:
-        f.write(patched_data)
-    return data, target
+    auto_handler = AutoPatchRegister.get_handler(patch_file)
+    if auto_handler:
+        handler: APDeltaPatch = auto_handler(patch_file)
+        target = os.path.splitext(patch_file)[0]+handler.result_file_ending
+        handler.patch(target)
+        return {"server": handler.server,
+                "player": handler.player,
+                "player_name": handler.player_name}, target
+    else:
+        data, target, patched_data = create_rom_bytes(patch_file)
+        with open(target, "wb") as f:
+            f.write(patched_data)
+        return data, target
 
 
 def update_patch_data(patch_data: bytes, server: str = "") -> bytes:
     data = Utils.parse_yaml(lzma.decompress(patch_data).decode("utf-8-sig"))
     data["meta"]["server"] = server
-    bytes = generate_yaml(data["patch"], data["meta"])
+    bytes = generate_yaml(data["patch"], data["meta"], data["game"])
     return lzma.compress(bytes)
 
 
@@ -105,6 +292,14 @@ def write_lzma(data: bytes, path: str):
         f.write(data)
 
 
+def read_rom(stream, strip_header=True) -> bytearray:
+    """Reads rom into bytearray and optionally strips off any smc header"""
+    buffer = bytearray(stream.read())
+    if strip_header and len(buffer) % 0x400 == 0x200:
+        return buffer[0x200:]
+    return buffer
+
+
 if __name__ == "__main__":
     host = Utils.get_public_ipv4()
     options = Utils.get_options()['server_options']
@@ -125,10 +320,63 @@ if __name__ == "__main__":
                 elif rom.endswith(".apbp"):
                     print(f"Applying patch {rom}")
                     data, target = create_rom_file(rom)
-                    romfile, adjusted = Utils.get_adjuster_settings(target)
+                    #romfile, adjusted = Utils.get_adjuster_settings(target)
+                    adjuster_settings = Utils.get_adjuster_settings(GAME_ALTTP)
+                    adjusted = False
+                    if adjuster_settings:
+                        import pprint
+                        from worlds.alttp.Rom import get_base_rom_path
+                        adjuster_settings.rom = target
+                        adjuster_settings.baserom = get_base_rom_path()
+                        adjuster_settings.world = None
+                        whitelist = {"music", "menuspeed", "heartbeep", "heartcolor", "ow_palettes", "quickswap",
+                                        "uw_palettes", "sprite", "sword_palettes", "shield_palettes", "hud_palettes",
+                                        "reduceflashing", "deathlink"}
+                        printed_options = {name: value for name, value in vars(adjuster_settings).items() if name in whitelist}
+                        if hasattr(adjuster_settings, "sprite_pool"):
+                            sprite_pool = {}
+                            for sprite in getattr(adjuster_settings, "sprite_pool"):
+                                if sprite in sprite_pool:
+                                    sprite_pool[sprite] += 1
+                                else:
+                                    sprite_pool[sprite] = 1
+                            if sprite_pool:
+                                printed_options["sprite_pool"] = sprite_pool
+
+                        adjust_wanted = str('no')
+                        if not hasattr(adjuster_settings, 'auto_apply') or 'ask' in adjuster_settings.auto_apply:
+                            adjust_wanted = input(f"Last used adjuster settings were found. Would you like to apply these? \n"
+                                                  f"{pprint.pformat(printed_options)}\n"
+                                                  f"Enter yes, no, always or never: ")
+                        if adjuster_settings.auto_apply == 'never':  # never adjust, per user request
+                            adjust_wanted = 'no'
+                        elif adjuster_settings.auto_apply == 'always':
+                            adjust_wanted = 'yes'
+                        
+                        if adjust_wanted and "never" in adjust_wanted:
+                            adjuster_settings.auto_apply = 'never'
+                            Utils.persistent_store("adjuster", GAME_ALTTP, adjuster_settings)
+
+                        elif adjust_wanted and "always" in adjust_wanted:
+                            adjuster_settings.auto_apply = 'always'
+                            Utils.persistent_store("adjuster", GAME_ALTTP, adjuster_settings)
+
+                        if adjust_wanted and adjust_wanted.startswith("y"):
+                            if hasattr(adjuster_settings, "sprite_pool"):
+                                from LttPAdjuster import AdjusterWorld
+                                adjuster_settings.world = AdjusterWorld(getattr(adjuster_settings, "sprite_pool"))
+
+                            adjusted = True
+                            import LttPAdjuster
+                            _, romfile = LttPAdjuster.adjust(adjuster_settings)
+
+                            if hasattr(adjuster_settings, "world"):
+                                delattr(adjuster_settings, "world")
+                        else:
+                            adjusted = False
                     if adjusted:
                         try:
-                            os.replace(romfile, target)
+                            shutil.move(romfile, target)
                             romfile = target
                         except Exception as e:
                             print(e)
@@ -136,25 +384,27 @@ if __name__ == "__main__":
                     if 'server' in data:
                         Utils.persistent_store("servers", data['hash'], data['server'])
                         print(f"Host is {data['server']}")
-
-                elif rom.endswith(".archipelago"):
-                    import json
-                    import zlib
-
-                    with open(rom, 'rb') as fr:
-
-                        multidata = zlib.decompress(fr.read()).decode("utf-8")
-                        with open(rom + '.txt', 'w') as fw:
-                            fw.write(multidata)
-                        multidata = json.loads(multidata)
-                        for romname in multidata['roms']:
-                            Utils.persistent_store("servers", "".join(chr(byte) for byte in romname[2]), address)
-                        from Utils import get_options
-
-                        multidata["server_options"] = get_options()["server_options"]
-                        multidata = zlib.compress(json.dumps(multidata).encode("utf-8"), 9)
-                        with open(rom + "_updated.archipelago", 'wb') as f:
-                            f.write(multidata)
+                elif rom.endswith(".apm3"):
+                    print(f"Applying patch {rom}")
+                    data, target = create_rom_file(rom)
+                    print(f"Created rom {target}.")
+                    if 'server' in data:
+                        Utils.persistent_store("servers", data['hash'], data['server'])
+                        print(f"Host is {data['server']}")
+                elif rom.endswith(".apsmz"):
+                    print(f"Applying patch {rom}")
+                    data, target = create_rom_file(rom)
+                    print(f"Created rom {target}.")
+                    if 'server' in data:
+                        Utils.persistent_store("servers", data['hash'], data['server'])
+                        print(f"Host is {data['server']}")
+                elif rom.endswith(".apdkc3"):
+                    print(f"Applying patch {rom}")
+                    data, target = create_rom_file(rom)
+                    print(f"Created rom {target}.")
+                    if 'server' in data:
+                        Utils.persistent_store("servers", data['hash'], data['server'])
+                        print(f"Host is {data['server']}")
 
                 elif rom.endswith(".zip"):
                     print(f"Updating host in patch files contained in {rom}")
@@ -162,7 +412,9 @@ if __name__ == "__main__":
 
                     def _handle_zip_file_entry(zfinfo: zipfile.ZipInfo, server: str):
                         data = zfr.read(zfinfo)
-                        if zfinfo.filename.endswith(".apbp"):
+                        if zfinfo.filename.endswith(".apbp") or \
+                           zfinfo.filename.endswith(".apm3") or \
+                           zfinfo.filename.endswith(".apdkc3"):
                             data = update_patch_data(data, server)
                         with ziplock:
                             zfw.writestr(zfinfo, data)

README.md

@@ -6,8 +6,30 @@ Currently, the following games are supported:
 * The Legend of Zelda: A Link to the Past
 * Factorio
 * Minecraft
+* Subnautica
+* Slay the Spire
+* Risk of Rain 2
+* The Legend of Zelda: Ocarina of Time
+* Timespinner
+* Super Metroid
+* Secret of Evermore
+* Final Fantasy
+* Rogue Legacy
+* VVVVVV
+* Raft
+* Super Mario 64
+* Meritous
+* Super Metroid/Link to the Past combo randomizer (SMZ3)
+* ChecksFinder
+* ArchipIDLE
+* Hollow Knight
+* The Witness
+* Sonic Adventure 2: Battle
+* Starcraft 2: Wings of Liberty
+* Donkey Kong Country 3
+* Dark Souls 3
 
-For setup and instructions check out our [tutorials page](https://archipelago.gg/tutorial).
+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
 windows binaries.
 
@@ -29,13 +51,14 @@ Archipelago was directly forked from bonta0's `multiworld_31` branch of ALttPEnt
 ## Running Archipelago
 For most people all you need to do is head over to the [releases](https://github.com/ArchipelagoMW/Archipelago/releases) page then download and run the appropriate installer. The installers function on Windows only.
 
-If you are running Archipelago from a non-Windows system then the likely scenario is that you are comfortable running source code directly. Please see our wiki page on [running Archipelago from source](https://github.com/Berserker66/MultiWorld-Utilities/wiki/Running-from-source).
+If you are running Archipelago from a non-Windows system then the likely scenario is that you are comfortable running source code directly. Please see our doc on [running Archipelago from source](docs/running%20from%20source.md).
 
 ## Related Repositories
 This project makes use of multiple other projects. We wouldn't be here without these other repositories and the contributions of their developers, past and present.
 
-* [z3randomizer](https://github.com/CaitSith2/z3randomizer)
+* [z3randomizer](https://github.com/ArchipelagoMW/z3randomizer)
 * [Enemizer](https://github.com/Ijwu/Enemizer)
+* [Ocarina of Time Randomizer](https://github.com/TestRunnerSRL/OoT-Randomizer)
 
 ## Contributing
 Contributions are welcome. We have a few asks of any new contributors.
@@ -45,6 +68,11 @@ Contributions are welcome. We have a few asks of any new contributors.
 
 Otherwise, we tend to judge code on a case to case basis. It is a generally good idea to stick to PEP-8 guidelines to ensure consistency with existing code. (And to make the linter happy.)
 
+For adding a new game to Archipelago and other documentation on how Archipelago functions, please see [the docs folder](docs/) for the relevant information and feel free to ask any questions in the #archipelago-dev channel in our discord.
+
+## FAQ
+For frequently asked questions see the website's [FAQ Page](https://archipelago.gg/faq/en/)
+
 ## Code of Conduct
 We conduct ourselves openly and inclusively here. Please do not contribute to an environment which makes other people uncomfortable. This means that we expect all contributors or participants here to:
 

Starcraft2Client.py

@@ -0,0 +1,920 @@
+from __future__ import annotations
+
+import multiprocessing
+import logging
+import asyncio
+import os.path
+
+import nest_asyncio
+import sc2
+
+from sc2.main import run_game
+from sc2.data import Race
+from sc2.bot_ai import BotAI
+from sc2.player import Bot
+
+from worlds.sc2wol.Regions import MissionInfo
+from worlds.sc2wol.MissionTables import lookup_id_to_mission
+from worlds.sc2wol.Items import lookup_id_to_name, item_table
+from worlds.sc2wol.Locations import SC2WOL_LOC_ID_OFFSET
+from worlds.sc2wol import SC2WoLWorld
+
+from pathlib import Path
+import re
+from MultiServer import mark_raw
+import ctypes
+import sys
+
+from Utils import init_logging, is_windows
+
+if __name__ == "__main__":
+    init_logging("SC2Client", exception_logger="Client")
+
+logger = logging.getLogger("Client")
+sc2_logger = logging.getLogger("Starcraft2")
+
+import colorama
+
+from NetUtils import *
+from CommonClient import CommonContext, server_loop, ClientCommandProcessor, gui_enabled, get_base_parser
+
+nest_asyncio.apply()
+
+
+class StarcraftClientProcessor(ClientCommandProcessor):
+    ctx: SC2Context
+
+    def _cmd_disable_mission_check(self) -> bool:
+        """Disables the check to see if a mission is available to play.  Meant for co-op runs where one player can play
+        the next mission in a chain the other player is doing."""
+        self.ctx.missions_unlocked = True
+        sc2_logger.info("Mission check has been disabled")
+
+    def _cmd_play(self, mission_id: str = "") -> bool:
+        """Start a Starcraft 2 mission"""
+
+        options = mission_id.split()
+        num_options = len(options)
+
+        if num_options > 0:
+            mission_number = int(options[0])
+
+            self.ctx.play_mission(mission_number)
+
+        else:
+            sc2_logger.info(
+                "Mission ID needs to be specified.  Use /unfinished or /available to view ids for available missions.")
+
+        return True
+
+    def _cmd_available(self) -> bool:
+        """Get what missions are currently available to play"""
+
+        request_available_missions(self.ctx.checked_locations, self.ctx.mission_req_table, self.ctx.ui)
+        return True
+
+    def _cmd_unfinished(self) -> bool:
+        """Get what missions are currently available to play and have not had all locations checked"""
+
+        request_unfinished_missions(self.ctx.checked_locations, self.ctx.mission_req_table, self.ctx.ui, self.ctx)
+        return True
+
+    @mark_raw
+    def _cmd_set_path(self, path: str = '') -> bool:
+        """Manually set the SC2 install directory (if the automatic detection fails)."""
+        if path:
+            os.environ["SC2PATH"] = path
+            check_mod_install()
+            return True
+        else:
+            sc2_logger.warning("When using set_path, you must type the path to your SC2 install directory.")
+        return False
+
+
+class SC2Context(CommonContext):
+    command_processor = StarcraftClientProcessor
+    game = "Starcraft 2 Wings of Liberty"
+    items_handling = 0b111
+    difficulty = -1
+    all_in_choice = 0
+    mission_req_table = None
+    items_rec_to_announce = []
+    rec_announce_pos = 0
+    items_sent_to_announce = []
+    sent_announce_pos = 0
+    announcements = []
+    announcement_pos = 0
+    sc2_run_task: typing.Optional[asyncio.Task] = None
+    missions_unlocked = False
+    current_tooltip = None
+    last_loc_list = None
+
+    async def server_auth(self, password_requested: bool = False):
+        if password_requested and not self.password:
+            await super(SC2Context, self).server_auth(password_requested)
+        await self.get_username()
+        await self.send_connect()
+
+    def on_package(self, cmd: str, args: dict):
+        if cmd in {"Connected"}:
+            self.difficulty = args["slot_data"]["game_difficulty"]
+            self.all_in_choice = args["slot_data"]["all_in_map"]
+            slot_req_table = args["slot_data"]["mission_req"]
+            self.mission_req_table = {}
+            # Compatibility for 0.3.2 server data.
+            if "category" not in next(iter(slot_req_table)):
+                for i, mission_data in enumerate(slot_req_table.values()):
+                    mission_data["category"] = wol_default_categories[i]
+            for mission in slot_req_table:
+                self.mission_req_table[mission] = MissionInfo(**slot_req_table[mission])
+
+            # Look for and set SC2PATH.
+            # check_game_install_path() returns True if and only if it finds + sets SC2PATH.
+            if "SC2PATH" not in os.environ and check_game_install_path():
+                check_mod_install()
+
+        if cmd in {"PrintJSON"}:
+            if "receiving" in args:
+                if self.slot_concerns_self(args["receiving"]):
+                    self.announcements.append(args["data"])
+                    return
+            if "item" in args:
+                if self.slot_concerns_self(args["item"].player):
+                    self.announcements.append(args["data"])
+
+    def run_gui(self):
+        from kvui import GameManager, HoverBehavior, ServerToolTip, fade_in_animation
+        from kivy.app import App
+        from kivy.clock import Clock
+        from kivy.uix.tabbedpanel import TabbedPanelItem
+        from kivy.uix.gridlayout import GridLayout
+        from kivy.lang import Builder
+        from kivy.uix.label import Label
+        from kivy.uix.button import Button
+        from kivy.uix.floatlayout import FloatLayout
+        from kivy.properties import StringProperty
+
+        import Utils
+
+        class HoverableButton(HoverBehavior, Button):
+            pass
+
+        class MissionButton(HoverableButton):
+            tooltip_text = StringProperty("Test")
+
+            def __init__(self, *args, **kwargs):
+                super(HoverableButton, self).__init__(*args, **kwargs)
+                self.layout = FloatLayout()
+                self.popuplabel = ServerToolTip(text=self.text)
+                self.layout.add_widget(self.popuplabel)
+
+            def on_enter(self):
+                self.popuplabel.text = self.tooltip_text
+
+                if self.ctx.current_tooltip:
+                    App.get_running_app().root.remove_widget(self.ctx.current_tooltip)
+
+                if self.tooltip_text == "":
+                    self.ctx.current_tooltip = None
+                else:
+                    App.get_running_app().root.add_widget(self.layout)
+                    self.ctx.current_tooltip = self.layout
+
+            def on_leave(self):
+                if self.ctx.current_tooltip:
+                    App.get_running_app().root.remove_widget(self.ctx.current_tooltip)
+
+                self.ctx.current_tooltip = None
+
+            @property
+            def ctx(self) -> CommonContext:
+                return App.get_running_app().ctx
+
+        class MissionLayout(GridLayout):
+            pass
+
+        class MissionCategory(GridLayout):
+            pass
+
+        class SC2Manager(GameManager):
+            logging_pairs = [
+                ("Client", "Archipelago"),
+                ("Starcraft2", "Starcraft2"),
+            ]
+            base_title = "Archipelago Starcraft 2 Client"
+
+            mission_panel = None
+            last_checked_locations = {}
+            mission_id_to_button = {}
+            launching = False
+            refresh_from_launching = True
+            first_check = True
+
+            def __init__(self, ctx):
+                super().__init__(ctx)
+
+            def build(self):
+                container = super().build()
+
+                panel = TabbedPanelItem(text="Starcraft 2 Launcher")
+                self.mission_panel = panel.content = MissionLayout()
+
+                self.tabs.add_widget(panel)
+
+                Clock.schedule_interval(self.build_mission_table, 0.5)
+
+                return container
+
+            def build_mission_table(self, dt):
+                if (not self.launching and (not self.last_checked_locations == self.ctx.checked_locations or
+                                           not self.refresh_from_launching)) or self.first_check:
+                    self.refresh_from_launching = True
+
+                    self.mission_panel.clear_widgets()
+
+                    if self.ctx.mission_req_table:
+                        self.last_checked_locations = self.ctx.checked_locations.copy()
+                        self.first_check = False
+
+                        self.mission_id_to_button = {}
+                        categories = {}
+                        available_missions = []
+                        unfinished_locations = initialize_blank_mission_dict(self.ctx.mission_req_table)
+                        unfinished_missions = calc_unfinished_missions(self.ctx.checked_locations,
+                                                                       self.ctx.mission_req_table,
+                                                                       self.ctx, available_missions=available_missions,
+                                                                       unfinished_locations=unfinished_locations)
+
+                        # separate missions into categories
+                        for mission in self.ctx.mission_req_table:
+                            if not self.ctx.mission_req_table[mission].category in categories:
+                                categories[self.ctx.mission_req_table[mission].category] = []
+
+                            categories[self.ctx.mission_req_table[mission].category].append(mission)
+
+                        for category in categories:
+                            category_panel = MissionCategory()
+                            category_panel.add_widget(Label(text=category, size_hint_y=None, height=50, outline_width=1))
+
+                            # Map is completed
+                            for mission in categories[category]:
+                                text = mission
+                                tooltip = ""
+
+                                # Map has uncollected locations
+                                if mission in unfinished_missions:
+                                    text = f"[color=6495ED]{text}[/color]"
+
+                                    tooltip = f"Uncollected locations:\n"
+                                    tooltip += "\n".join(location for location in unfinished_locations[mission])
+                                elif mission in available_missions:
+                                    text = f"[color=FFFFFF]{text}[/color]"
+                                # Map requirements not met
+                                else:
+                                    text = f"[color=a9a9a9]{text}[/color]"
+                                    tooltip = f"Requires: "
+                                    if len(self.ctx.mission_req_table[mission].required_world) > 0:
+                                        tooltip += ", ".join(list(self.ctx.mission_req_table)[req_mission-1] for
+                                                             req_mission in
+                                                             self.ctx.mission_req_table[mission].required_world)
+
+                                        if self.ctx.mission_req_table[mission].number > 0:
+                                            tooltip += " and "
+                                    if self.ctx.mission_req_table[mission].number > 0:
+                                        tooltip += f"{self.ctx.mission_req_table[mission].number} missions completed"
+
+                                mission_button = MissionButton(text=text, size_hint_y=None, height=50)
+                                mission_button.tooltip_text = tooltip
+                                mission_button.bind(on_press=self.mission_callback)
+                                self.mission_id_to_button[self.ctx.mission_req_table[mission].id] = mission_button
+                                category_panel.add_widget(mission_button)
+
+                            category_panel.add_widget(Label(text=""))
+                            self.mission_panel.add_widget(category_panel)
+
+                elif self.launching:
+                    self.refresh_from_launching = False
+
+                    self.mission_panel.clear_widgets()
+                    self.mission_panel.add_widget(Label(text="Launching Mission"))
+
+            def mission_callback(self, button):
+                if not self.launching:
+                    self.ctx.play_mission(list(self.mission_id_to_button.keys())
+                                          [list(self.mission_id_to_button.values()).index(button)])
+                    self.launching = True
+                    Clock.schedule_once(self.finish_launching, 10)
+
+            def finish_launching(self, dt):
+                self.launching = False
+
+        self.ui = SC2Manager(self)
+        self.ui_task = asyncio.create_task(self.ui.async_run(), name="UI")
+
+        Builder.load_file(Utils.local_path(os.path.dirname(SC2WoLWorld.__file__), "Starcraft2.kv"))
+
+    async def shutdown(self):
+        await super(SC2Context, self).shutdown()
+        if self.sc2_run_task:
+            self.sc2_run_task.cancel()
+
+    def play_mission(self, mission_id):
+        if self.missions_unlocked or \
+                is_mission_available(mission_id, self.checked_locations, self.mission_req_table):
+            if self.sc2_run_task:
+                if not self.sc2_run_task.done():
+                    sc2_logger.warning("Starcraft 2 Client is still running!")
+                self.sc2_run_task.cancel()  # doesn't actually close the game, just stops the python task
+            if self.slot is None:
+                sc2_logger.warning("Launching Mission without Archipelago authentication, "
+                                   "checks will not be registered to server.")
+            self.sc2_run_task = asyncio.create_task(starcraft_launch(self, mission_id),
+                                                        name="Starcraft 2 Launch")
+        else:
+            sc2_logger.info(
+                f"{lookup_id_to_mission[mission_id]} is not currently unlocked.  "
+                f"Use /unfinished or /available to see what is available.")
+
+
+async def main():
+    multiprocessing.freeze_support()
+    parser = get_base_parser()
+    parser.add_argument('--name', default=None, help="Slot Name to connect as.")
+    args = parser.parse_args()
+
+    ctx = SC2Context(args.connect, args.password)
+    ctx.auth = args.name
+    if ctx.server_task is None:
+        ctx.server_task = asyncio.create_task(server_loop(ctx), name="ServerLoop")
+
+    if gui_enabled:
+        ctx.run_gui()
+    ctx.run_cli()
+
+    await ctx.exit_event.wait()
+
+    await ctx.shutdown()
+
+
+maps_table = [
+    "ap_traynor01", "ap_traynor02", "ap_traynor03",
+    "ap_thanson01", "ap_thanson02", "ap_thanson03a", "ap_thanson03b",
+    "ap_ttychus01", "ap_ttychus02", "ap_ttychus03", "ap_ttychus04", "ap_ttychus05",
+    "ap_ttosh01", "ap_ttosh02", "ap_ttosh03a", "ap_ttosh03b",
+    "ap_thorner01", "ap_thorner02", "ap_thorner03", "ap_thorner04", "ap_thorner05s",
+    "ap_tzeratul01", "ap_tzeratul02", "ap_tzeratul03", "ap_tzeratul04",
+    "ap_tvalerian01", "ap_tvalerian02a", "ap_tvalerian02b", "ap_tvalerian03"
+]
+
+wol_default_categories = [
+    "Mar Sara", "Mar Sara", "Mar Sara", "Colonist", "Colonist", "Colonist", "Colonist",
+    "Artifact", "Artifact", "Artifact", "Artifact", "Artifact", "Covert", "Covert", "Covert", "Covert",
+    "Rebellion", "Rebellion", "Rebellion", "Rebellion", "Rebellion", "Prophecy", "Prophecy", "Prophecy", "Prophecy",
+    "Char", "Char", "Char", "Char"
+]
+
+
+def calculate_items(items):
+    unit_unlocks = 0
+    armory1_unlocks = 0
+    armory2_unlocks = 0
+    upgrade_unlocks = 0
+    building_unlocks = 0
+    merc_unlocks = 0
+    lab_unlocks = 0
+    protoss_unlock = 0
+    minerals = 0
+    vespene = 0
+    supply = 0
+
+    for item in items:
+        data = lookup_id_to_name[item.item]
+
+        if item_table[data].type == "Unit":
+            unit_unlocks += (1 << item_table[data].number)
+        elif item_table[data].type == "Upgrade":
+            upgrade_unlocks += (1 << item_table[data].number)
+        elif item_table[data].type == "Armory 1":
+            armory1_unlocks += (1 << item_table[data].number)
+        elif item_table[data].type == "Armory 2":
+            armory2_unlocks += (1 << item_table[data].number)
+        elif item_table[data].type == "Building":
+            building_unlocks += (1 << item_table[data].number)
+        elif item_table[data].type == "Mercenary":
+            merc_unlocks += (1 << item_table[data].number)
+        elif item_table[data].type == "Laboratory":
+            lab_unlocks += (1 << item_table[data].number)
+        elif item_table[data].type == "Protoss":
+            protoss_unlock += (1 << item_table[data].number)
+        elif item_table[data].type == "Minerals":
+            minerals += item_table[data].number
+        elif item_table[data].type == "Vespene":
+            vespene += item_table[data].number
+        elif item_table[data].type == "Supply":
+            supply += item_table[data].number
+
+    return [unit_unlocks, upgrade_unlocks, armory1_unlocks, armory2_unlocks, building_unlocks, merc_unlocks,
+            lab_unlocks, protoss_unlock, minerals, vespene, supply]
+
+
+def calc_difficulty(difficulty):
+    if difficulty == 0:
+        return 'C'
+    elif difficulty == 1:
+        return 'N'
+    elif difficulty == 2:
+        return 'H'
+    elif difficulty == 3:
+        return 'B'
+
+    return 'X'
+
+
+async def starcraft_launch(ctx: SC2Context, mission_id):
+    ctx.rec_announce_pos = len(ctx.items_rec_to_announce)
+    ctx.sent_announce_pos = len(ctx.items_sent_to_announce)
+    ctx.announcements_pos = len(ctx.announcements)
+
+    sc2_logger.info(f"Launching {lookup_id_to_mission[mission_id]}. If game does not launch check log file for errors.")
+
+    with DllDirectory(None):
+        run_game(sc2.maps.get(maps_table[mission_id - 1]), [Bot(Race.Terran, ArchipelagoBot(ctx, mission_id),
+                                                                name="Archipelago", fullscreen=True)], realtime=True)
+
+
+class ArchipelagoBot(sc2.bot_ai.BotAI):
+    game_running = False
+    mission_completed = False
+    first_bonus = False
+    second_bonus = False
+    third_bonus = False
+    fourth_bonus = False
+    fifth_bonus = False
+    sixth_bonus = False
+    seventh_bonus = False
+    eight_bonus = False
+    ctx: SC2Context = None
+    mission_id = 0
+
+    can_read_game = False
+
+    last_received_update = 0
+
+    def __init__(self, ctx: SC2Context, mission_id):
+        self.ctx = ctx
+        self.mission_id = mission_id
+
+        super(ArchipelagoBot, self).__init__()
+
+    async def on_step(self, iteration: int):
+        game_state = 0
+        if iteration == 0:
+            start_items = calculate_items(self.ctx.items_received)
+            difficulty = calc_difficulty(self.ctx.difficulty)
+            await self.chat_send("ArchipelagoLoad {} {} {} {} {} {} {} {} {} {} {} {} {}".format(
+                difficulty,
+                start_items[0], start_items[1], start_items[2], start_items[3], start_items[4],
+                start_items[5], start_items[6], start_items[7], start_items[8], start_items[9],
+                self.ctx.all_in_choice, start_items[10]))
+            self.last_received_update = len(self.ctx.items_received)
+
+        else:
+            if self.ctx.announcement_pos < len(self.ctx.announcements):
+                index = 0
+                message = ""
+                while index < len(self.ctx.announcements[self.ctx.announcement_pos]):
+                    message += self.ctx.announcements[self.ctx.announcement_pos][index]["text"]
+                    index += 1
+
+                index = 0
+                start_rem_pos = -1
+                # Remove unneeded [Color] tags
+                while index < len(message):
+                    if message[index] == '[':
+                        start_rem_pos = index
+                        index += 1
+                    elif message[index] == ']' and start_rem_pos > -1:
+                        temp_msg = ""
+
+                        if start_rem_pos > 0:
+                            temp_msg = message[:start_rem_pos]
+                        if index < len(message) - 1:
+                            temp_msg += message[index + 1:]
+
+                        message = temp_msg
+                        index += start_rem_pos - index
+                        start_rem_pos = -1
+                    else:
+                        index += 1
+
+                await self.chat_send("SendMessage " + message)
+                self.ctx.announcement_pos += 1
+
+            # Archipelago reads the health
+            for unit in self.all_own_units():
+                if unit.health_max == 38281:
+                    game_state = int(38281 - unit.health)
+                    self.can_read_game = True
+
+            if iteration == 160 and not game_state & 1:
+                await self.chat_send("SendMessage Warning: Archipelago unable to connect or has lost connection to " +
+                                     "Starcraft 2 (This is likely a map issue)")
+
+            if self.last_received_update < len(self.ctx.items_received):
+                current_items = calculate_items(self.ctx.items_received)
+                await self.chat_send("UpdateTech {} {} {} {} {} {} {} {}".format(
+                    current_items[0], current_items[1], current_items[2], current_items[3], current_items[4],
+                    current_items[5], current_items[6], current_items[7]))
+                self.last_received_update = len(self.ctx.items_received)
+
+            if game_state & 1:
+                if not self.game_running:
+                    print("Archipelago Connected")
+                    self.game_running = True
+
+                if self.can_read_game:
+                    if game_state & (1 << 1) and not self.mission_completed:
+                        if self.mission_id != 29:
+                            print("Mission Completed")
+                            await self.ctx.send_msgs([
+                                {"cmd": 'LocationChecks', "locations": [SC2WOL_LOC_ID_OFFSET + 100 * self.mission_id]}])
+                            self.mission_completed = True
+                        else:
+                            print("Game Complete")
+                            await self.ctx.send_msgs([{"cmd": 'StatusUpdate', "status": ClientStatus.CLIENT_GOAL}])
+                            self.mission_completed = True
+
+                    if game_state & (1 << 2) and not self.first_bonus:
+                        print("1st Bonus Collected")
+                        await self.ctx.send_msgs(
+                            [{"cmd": 'LocationChecks',
+                              "locations": [SC2WOL_LOC_ID_OFFSET + 100 * self.mission_id + 1]}])
+                        self.first_bonus = True
+
+                    if not self.second_bonus and game_state & (1 << 3):
+                        print("2nd Bonus Collected")
+                        await self.ctx.send_msgs(
+                            [{"cmd": 'LocationChecks',
+                              "locations": [SC2WOL_LOC_ID_OFFSET + 100 * self.mission_id + 2]}])
+                        self.second_bonus = True
+
+                    if not self.third_bonus and game_state & (1 << 4):
+                        print("3rd Bonus Collected")
+                        await self.ctx.send_msgs(
+                            [{"cmd": 'LocationChecks',
+                              "locations": [SC2WOL_LOC_ID_OFFSET + 100 * self.mission_id + 3]}])
+                        self.third_bonus = True
+
+                    if not self.fourth_bonus and game_state & (1 << 5):
+                        print("4th Bonus Collected")
+                        await self.ctx.send_msgs(
+                            [{"cmd": 'LocationChecks',
+                              "locations": [SC2WOL_LOC_ID_OFFSET + 100 * self.mission_id + 4]}])
+                        self.fourth_bonus = True
+
+                    if not self.fifth_bonus and game_state & (1 << 6):
+                        print("5th Bonus Collected")
+                        await self.ctx.send_msgs(
+                            [{"cmd": 'LocationChecks',
+                              "locations": [SC2WOL_LOC_ID_OFFSET + 100 * self.mission_id + 5]}])
+                        self.fifth_bonus = True
+
+                    if not self.sixth_bonus and game_state & (1 << 7):
+                        print("6th Bonus Collected")
+                        await self.ctx.send_msgs(
+                            [{"cmd": 'LocationChecks',
+                              "locations": [SC2WOL_LOC_ID_OFFSET + 100 * self.mission_id + 6]}])
+                        self.sixth_bonus = True
+
+                    if not self.seventh_bonus and game_state & (1 << 8):
+                        print("6th Bonus Collected")
+                        await self.ctx.send_msgs(
+                            [{"cmd": 'LocationChecks',
+                              "locations": [SC2WOL_LOC_ID_OFFSET + 100 * self.mission_id + 7]}])
+                        self.seventh_bonus = True
+
+                    if not self.eight_bonus and game_state & (1 << 9):
+                        print("6th Bonus Collected")
+                        await self.ctx.send_msgs(
+                            [{"cmd": 'LocationChecks',
+                              "locations": [SC2WOL_LOC_ID_OFFSET + 100 * self.mission_id + 8]}])
+                        self.eight_bonus = True
+
+                else:
+                    await self.chat_send("LostConnection - Lost connection to game.")
+
+
+def calc_objectives_completed(mission, missions_info, locations_done, unfinished_locations, ctx):
+    objectives_complete = 0
+
+    if missions_info[mission].extra_locations > 0:
+        for i in range(missions_info[mission].extra_locations):
+            if (missions_info[mission].id * 100 + SC2WOL_LOC_ID_OFFSET + i) in locations_done:
+                objectives_complete += 1
+            else:
+                unfinished_locations[mission].append(ctx.location_names[
+                    missions_info[mission].id * 100 + SC2WOL_LOC_ID_OFFSET + i])
+
+        return objectives_complete
+
+    else:
+        return -1
+
+
+def request_unfinished_missions(locations_done, location_table, ui, ctx):
+    if location_table:
+        message = "Unfinished Missions: "
+        unlocks = initialize_blank_mission_dict(location_table)
+        unfinished_locations = initialize_blank_mission_dict(location_table)
+
+        unfinished_missions = calc_unfinished_missions(locations_done, location_table, ctx, unlocks=unlocks,
+                                                       unfinished_locations=unfinished_locations)
+
+        message += ", ".join(f"{mark_up_mission_name(mission, location_table, ui,unlocks)}[{location_table[mission].id}] " +
+                             mark_up_objectives(
+                                 f"[{unfinished_missions[mission]}/{location_table[mission].extra_locations}]",
+                                 ctx, unfinished_locations, mission)
+                             for mission in unfinished_missions)
+
+        if ui:
+            ui.log_panels['All'].on_message_markup(message)
+            ui.log_panels['Starcraft2'].on_message_markup(message)
+        else:
+            sc2_logger.info(message)
+    else:
+        sc2_logger.warning("No mission table found, you are likely not connected to a server.")
+
+
+def calc_unfinished_missions(locations_done, locations, ctx, unlocks=None, unfinished_locations=None,
+                             available_missions=[]):
+    unfinished_missions = []
+    locations_completed = []
+
+    if not unlocks:
+        unlocks = initialize_blank_mission_dict(locations)
+
+    if not unfinished_locations:
+        unfinished_locations = initialize_blank_mission_dict(locations)
+
+    if len(available_missions) > 0:
+        available_missions = []
+
+    available_missions.extend(calc_available_missions(locations_done, locations, unlocks))
+
+    for name in available_missions:
+        if not locations[name].extra_locations == -1:
+            objectives_completed = calc_objectives_completed(name, locations, locations_done, unfinished_locations, ctx)
+
+            if objectives_completed < locations[name].extra_locations:
+                unfinished_missions.append(name)
+                locations_completed.append(objectives_completed)
+
+        else:
+            unfinished_missions.append(name)
+            locations_completed.append(-1)
+
+    return {unfinished_missions[i]: locations_completed[i] for i in range(len(unfinished_missions))}
+
+
+def is_mission_available(mission_id_to_check, locations_done, locations):
+    unfinished_missions = calc_available_missions(locations_done, locations)
+
+    return any(mission_id_to_check == locations[mission].id for mission in unfinished_missions)
+
+
+def mark_up_mission_name(mission, location_table, ui, unlock_table):
+    """Checks if the mission is required for game completion and adds '*' to the name to mark that."""
+
+    if location_table[mission].completion_critical:
+        if ui:
+            message = "[color=AF99EF]" + mission + "[/color]"
+        else:
+            message = "*" + mission + "*"
+    else:
+        message = mission
+
+    if ui:
+        unlocks = unlock_table[mission]
+
+        if len(unlocks) > 0:
+            pre_message = f"[ref={list(location_table).index(mission)}|Unlocks: "
+            pre_message += ", ".join(f"{unlock}({location_table[unlock].id})" for unlock in unlocks)
+            pre_message += f"]"
+            message = pre_message + message + "[/ref]"
+
+    return message
+
+
+def mark_up_objectives(message, ctx, unfinished_locations, mission):
+    formatted_message = message
+
+    if ctx.ui:
+        locations = unfinished_locations[mission]
+
+        pre_message = f"[ref={list(ctx.mission_req_table).index(mission)+30}|"
+        pre_message += "<br>".join(location for location in locations)
+        pre_message += f"]"
+        formatted_message = pre_message + message + "[/ref]"
+
+    return formatted_message
+
+
+def request_available_missions(locations_done, location_table, ui):
+    if location_table:
+        message = "Available Missions: "
+
+        # Initialize mission unlock table
+        unlocks = initialize_blank_mission_dict(location_table)
+
+        missions = calc_available_missions(locations_done, location_table, unlocks)
+        message += \
+            ", ".join(f"{mark_up_mission_name(mission, location_table, ui, unlocks)}[{location_table[mission].id}]"
+                      for mission in missions)
+
+        if ui:
+            ui.log_panels['All'].on_message_markup(message)
+            ui.log_panels['Starcraft2'].on_message_markup(message)
+        else:
+            sc2_logger.info(message)
+    else:
+        sc2_logger.warning("No mission table found, you are likely not connected to a server.")
+
+
+def calc_available_missions(locations_done, locations, unlocks=None):
+    available_missions = []
+    missions_complete = 0
+
+    # Get number of missions completed
+    for loc in locations_done:
+        if loc % 100 == 0:
+            missions_complete += 1
+
+    for name in locations:
+        # Go through the required missions for each mission and fill up unlock table used later for hover-over tooltips
+        if unlocks:
+            for unlock in locations[name].required_world:
+                unlocks[list(locations)[unlock-1]].append(name)
+
+        if mission_reqs_completed(name, missions_complete, locations_done, locations):
+            available_missions.append(name)
+
+    return available_missions
+
+
+def mission_reqs_completed(location_to_check, missions_complete, locations_done, locations):
+    """Returns a bool signifying if the mission has all requirements complete and can be done
+
+    Keyword arguments:
+    locations_to_check -- the mission string name to check
+    missions_complete -- an int of how many missions have been completed
+    locations_done -- a list of the location ids that have been complete
+    locations -- a dict of MissionInfo for mission requirements for this world"""
+    if len(locations[location_to_check].required_world) >= 1:
+        # A check for when the requirements are being or'd
+        or_success = False
+
+        # Loop through required missions
+        for req_mission in locations[location_to_check].required_world:
+            req_success = True
+
+            # Check if required mission has been completed
+            if not (locations[list(locations)[req_mission-1]].id * 100 + SC2WOL_LOC_ID_OFFSET) in locations_done:
+                if not locations[location_to_check].or_requirements:
+                    return False
+                else:
+                    req_success = False
+
+            # Recursively check required mission to see if it's requirements are met, in case !collect has been done
+            if not mission_reqs_completed(list(locations)[req_mission-1], missions_complete, locations_done,
+                                          locations):
+                if not locations[location_to_check].or_requirements:
+                    return False
+                else:
+                    req_success = False
+
+            # If requirement check succeeded mark or as satisfied
+            if locations[location_to_check].or_requirements and req_success:
+                or_success = True
+
+        if locations[location_to_check].or_requirements:
+            # Return false if or requirements not met
+            if not or_success:
+                return False
+
+        # Check number of missions
+        if missions_complete >= locations[location_to_check].number:
+            return True
+        else:
+            return False
+    else:
+        return True
+
+
+def initialize_blank_mission_dict(location_table):
+    unlocks = {}
+
+    for mission in list(location_table):
+        unlocks[mission] = []
+
+    return unlocks
+
+
+def check_game_install_path() -> bool:
+    # First thing: go to the default location for ExecuteInfo.
+    # An exception for Windows is included because it's very difficult to find ~\Documents if the user moved it.
+    if is_windows:
+        # The next five lines of utterly inscrutable code are brought to you by copy-paste from Stack Overflow.
+        # https://stackoverflow.com/questions/6227590/finding-the-users-my-documents-path/30924555#
+        import ctypes.wintypes
+        CSIDL_PERSONAL = 5  # My Documents
+        SHGFP_TYPE_CURRENT = 0  # Get current, not default value
+
+        buf = ctypes.create_unicode_buffer(ctypes.wintypes.MAX_PATH)
+        ctypes.windll.shell32.SHGetFolderPathW(None, CSIDL_PERSONAL, None, SHGFP_TYPE_CURRENT, buf)
+        documentspath = buf.value
+        einfo = str(documentspath / Path("StarCraft II\\ExecuteInfo.txt"))
+    else:
+        einfo = str(sc2.paths.get_home() / Path(sc2.paths.USERPATH[sc2.paths.PF]))
+
+    # Check if the file exists.
+    if os.path.isfile(einfo):
+
+        # Open the file and read it, picking out the latest executable's path.
+        with open(einfo) as f:
+            content = f.read()
+        if content:
+            base = re.search(r" = (.*)Versions", content).group(1)
+            if os.path.exists(base):
+                executable = sc2.paths.latest_executeble(Path(base).expanduser() / "Versions")
+
+                # Finally, check the path for an actual executable.
+                # If we find one, great. Set up the SC2PATH.
+                if os.path.isfile(executable):
+                    sc2_logger.info(f"Found an SC2 install at {base}!")
+                    sc2_logger.debug(f"Latest executable at {executable}.")
+                    os.environ["SC2PATH"] = base
+                    sc2_logger.debug(f"SC2PATH set to {base}.")
+                    return True
+                else:
+                    sc2_logger.warning(f"We may have found an SC2 install at {base}, but couldn't find {executable}.")
+            else:
+                sc2_logger.warning(f"{einfo} pointed to {base}, but we could not find an SC2 install there.")
+    else:
+        sc2_logger.warning(f"Couldn't find {einfo}. Please run /set_path with your SC2 install directory.")
+    return False
+
+
+def check_mod_install() -> bool:
+    # Pull up the SC2PATH if set. If not, encourage the user to manually run /set_path.
+    try:
+        # Check inside the Mods folder for Archipelago.SC2Mod. If found, tell user. If not, tell user.
+        if os.path.isfile(modfile := (os.environ["SC2PATH"] / Path("Mods") / Path("Archipelago.SC2Mod"))):
+            sc2_logger.info(f"Archipelago mod found at {modfile}.")
+            return True
+        else:
+            sc2_logger.warning(f"Archipelago mod could not be found at {modfile}. Please install the mod file there.")
+    except KeyError:
+        sc2_logger.warning(f"SC2PATH isn't set. Please run /set_path with the path to your SC2 install.")
+    return False
+
+
+class DllDirectory:
+    # Credit to Black Sliver for this code.
+    # More info: https://docs.microsoft.com/en-us/windows/win32/api/winbase/nf-winbase-setdlldirectoryw
+    _old: typing.Optional[str] = None
+    _new: typing.Optional[str] = None
+
+    def __init__(self, new: typing.Optional[str]):
+        self._new = new
+
+    def __enter__(self):
+        old = self.get()
+        if self.set(self._new):
+            self._old = old
+
+    def __exit__(self, *args):
+        if self._old is not None:
+            self.set(self._old)
+
+    @staticmethod
+    def get() -> str:
+        if sys.platform == "win32":
+            n = ctypes.windll.kernel32.GetDllDirectoryW(0, None)
+            buf = ctypes.create_unicode_buffer(n)
+            ctypes.windll.kernel32.GetDllDirectoryW(n, buf)
+            return buf.value
+        # NOTE: other OS may support os.environ["LD_LIBRARY_PATH"], but this fix is windows-specific
+        return None
+
+    @staticmethod
+    def set(s: typing.Optional[str]) -> bool:
+        if sys.platform == "win32":
+            return ctypes.windll.kernel32.SetDllDirectoryW(s) != 0
+        # NOTE: other OS may support os.environ["LD_LIBRARY_PATH"], but this fix is windows-specific
+        return False
+
+
+if __name__ == '__main__':
+    colorama.init()
+    asyncio.run(main())
+    colorama.deinit()

Utils.py

@@ -1,9 +1,26 @@
 from __future__ import annotations
 
+import shutil
 import typing
+import builtins
+import os
+import subprocess
+import sys
+import pickle
+import functools
+import io
+import collections
+import importlib
+import logging
+import decimal
+
+if typing.TYPE_CHECKING:
+    from tkinter import Tk
+else:
+    Tk = typing.Any
 
 
-def tuplize_version(version: str) -> typing.Tuple[int, ...]:
+def tuplize_version(version: str) -> Version:
     return Version(*(int(piece, 10) for piece in version.split(".")))
 
 
@@ -12,18 +29,16 @@ class Version(typing.NamedTuple):
     minor: int
     build: int
 
-__version__ = "0.1.2"
-_version_tuple = tuplize_version(__version__)
 
-import builtins
-import os
-import subprocess
-import sys
-import pickle
-import functools
-import io
+__version__ = "0.3.4"
+version_tuple = tuplize_version(__version__)
 
-from yaml import load, dump, safe_load
+is_linux = sys.platform.startswith('linux')
+is_macos = sys.platform == 'darwin'
+is_windows = sys.platform in ("win32", "cygwin", "msys")
+
+import jellyfish
+from yaml import load, load_all, dump, SafeLoader
 
 try:
     from yaml import CLoader as Loader
@@ -31,52 +46,51 @@ except ImportError:
     from yaml import Loader
 
 
-def int16_as_bytes(value):
+def int16_as_bytes(value: int) -> typing.List[int]:
     value = value & 0xFFFF
     return [value & 0xFF, (value >> 8) & 0xFF]
 
 
-def int32_as_bytes(value):
+def int32_as_bytes(value: int) -> typing.List[int]:
     value = value & 0xFFFFFFFF
     return [value & 0xFF, (value >> 8) & 0xFF, (value >> 16) & 0xFF, (value >> 24) & 0xFF]
 
 
-def pc_to_snes(value):
+def pc_to_snes(value: int) -> int:
     return ((value << 1) & 0x7F0000) | (value & 0x7FFF) | 0x8000
 
 
-def snes_to_pc(value):
+def snes_to_pc(value: int) -> int:
     return ((value & 0x7F0000) >> 1) | (value & 0x7FFF)
 
 
-def parse_player_names(names, players, teams):
-    names = tuple(n for n in (n.strip() for n in names.split(",")) if n)
-    if len(names) != len(set(names)):
-        import collections
-        name_counter = collections.Counter(names)
-        raise ValueError(f"Duplicate Player names is not supported, "
-                         f'found multiple "{name_counter.most_common(1)[0][0]}".')
-    ret = []
-    while names or len(ret) < teams:
-        team = [n[:16] for n in names[:players]]
-        # 16 bytes in rom per player, which will map to more in unicode, but those characters later get filtered
-        while len(team) != players:
-            team.append(f"Player{len(team) + 1}")
-        ret.append(team)
-
-        names = names[players:]
-    return ret
+RetType = typing.TypeVar("RetType")
 
 
-def is_bundled() -> bool:
-    return getattr(sys, 'frozen', False)
+def cache_argsless(function: typing.Callable[[], RetType]) -> typing.Callable[[], RetType]:
+    assert not function.__code__.co_argcount, "Can only cache 0 argument functions with this cache."
+
+    sentinel = object()
+    result: typing.Union[object, RetType] = sentinel
+
+    def _wrap() -> RetType:
+        nonlocal result
+        if result is sentinel:
+            result = function()
+        return typing.cast(RetType, result)
+
+    return _wrap
 
 
-def local_path(*path):
-    if local_path.cached_path:
-        return os.path.join(local_path.cached_path, *path)
+def is_frozen() -> bool:
+    return typing.cast(bool, getattr(sys, 'frozen', False))
 
-    elif is_bundled():
+
+def local_path(*path: str) -> str:
+    """Returns path to a file in the local Archipelago installation or source."""
+    if hasattr(local_path, 'cached_path'):
+        pass
+    elif is_frozen():
         if hasattr(sys, "_MEIPASS"):
             # we are running in a PyInstaller bundle
             local_path.cached_path = sys._MEIPASS  # pylint: disable=protected-access,no-member
@@ -95,21 +109,47 @@ def local_path(*path):
     return os.path.join(local_path.cached_path, *path)
 
 
-local_path.cached_path = None
+def home_path(*path: str) -> str:
+    """Returns path to a file in the user home's Archipelago directory."""
+    if hasattr(home_path, 'cached_path'):
+        pass
+    elif sys.platform.startswith('linux'):
+        home_path.cached_path = os.path.expanduser('~/Archipelago')
+        os.makedirs(home_path.cached_path, 0o700, exist_ok=True)
+    else:
+        # not implemented
+        home_path.cached_path = local_path()  # this will generate the same exceptions we got previously
+
+    return os.path.join(home_path.cached_path, *path)
 
 
-def output_path(*path):
-    if output_path.cached_path:
+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):
+        user_path.cached_path = local_path()
+    else:
+        user_path.cached_path = home_path()
+        # populate home from local - TODO: upgrade feature
+        if user_path.cached_path != local_path() and not os.path.exists(user_path('host.yaml')):
+            for dn in ('Players', 'data/sprites'):
+                shutil.copytree(local_path(dn), user_path(dn), dirs_exist_ok=True)
+            for fn in ('manifest.json', 'host.yaml'):
+                shutil.copy2(local_path(fn), user_path(fn))
+
+    return os.path.join(user_path.cached_path, *path)
+
+
+def output_path(*path: str):
+    if hasattr(output_path, 'cached_path'):
         return os.path.join(output_path.cached_path, *path)
-    output_path.cached_path = local_path(get_options()["general_options"]["output_path"])
+    output_path.cached_path = user_path(get_options()["general_options"]["output_path"])
     path = os.path.join(output_path.cached_path, *path)
     os.makedirs(os.path.dirname(path), exist_ok=True)
     return path
 
 
-output_path.cached_path = None
-
-
 def open_file(filename):
     if sys.platform == 'win32':
         os.startfile(filename)
@@ -118,135 +158,148 @@ def open_file(filename):
         subprocess.call([open_command, filename])
 
 
-def close_console():
-    if sys.platform == 'win32':
-        # windows
-        import ctypes.wintypes
-        try:
-            ctypes.windll.kernel32.FreeConsole()
-        except Exception:
-            pass
+# from https://gist.github.com/pypt/94d747fe5180851196eb#gistcomment-4015118 with some changes
+class UniqueKeyLoader(SafeLoader):
+    def construct_mapping(self, node, deep=False):
+        mapping = set()
+        for key_node, value_node in node.value:
+            key = self.construct_object(key_node, deep=deep)
+            if key in mapping:
+                logging.error(f"YAML duplicates sanity check failed{key_node.start_mark}")
+                raise KeyError(f"Duplicate key {key} found in YAML. Already found keys: {mapping}.")
+            mapping.add(key)
+        return super().construct_mapping(node, deep)
 
 
-parse_yaml = safe_load
+parse_yaml = functools.partial(load, Loader=UniqueKeyLoader)
+parse_yamls = functools.partial(load_all, Loader=UniqueKeyLoader)
 unsafe_parse_yaml = functools.partial(load, Loader=Loader)
 
 
+def get_cert_none_ssl_context():
+    import ssl
+    ctx = ssl.create_default_context()
+    ctx.check_hostname = False
+    ctx.verify_mode = ssl.CERT_NONE
+    return ctx
+
+
+@cache_argsless
 def get_public_ipv4() -> str:
     import socket
     import urllib.request
-    import logging
     ip = socket.gethostbyname(socket.gethostname())
+    ctx = get_cert_none_ssl_context()
     try:
-        ip = urllib.request.urlopen('https://checkip.amazonaws.com/').read().decode('utf8').strip()
+        ip = urllib.request.urlopen('https://checkip.amazonaws.com/', context=ctx).read().decode('utf8').strip()
     except Exception as e:
         try:
-            ip = urllib.request.urlopen('https://v4.ident.me').read().decode('utf8').strip()
+            ip = urllib.request.urlopen('https://v4.ident.me', context=ctx).read().decode('utf8').strip()
         except:
             logging.exception(e)
             pass  # we could be offline, in a local game, so no point in erroring out
     return ip
 
 
+@cache_argsless
 def get_public_ipv6() -> str:
     import socket
     import urllib.request
-    import logging
     ip = socket.gethostbyname(socket.gethostname())
+    ctx = get_cert_none_ssl_context()
     try:
-        ip = urllib.request.urlopen('https://v6.ident.me').read().decode('utf8').strip()
+        ip = urllib.request.urlopen('https://v6.ident.me', context=ctx).read().decode('utf8').strip()
     except Exception as e:
         logging.exception(e)
         pass  # we could be offline, in a local game, or ipv6 may not be available
     return ip
 
 
+@cache_argsless
 def get_default_options() -> dict:
-    if not hasattr(get_default_options, "options"):
-        # Refer to host.yaml for comments as to what all these options mean.
-        options = {
-            "general_options": {
-                "output_path": "output",
-            },
-            "factorio_options": {
-                "executable": "factorio\\bin\\x64\\factorio",
-            },
-            "lttp_options": {
-                "rom_file": "Zelda no Densetsu - Kamigami no Triforce (Japan).sfc",
-                "qusb2snes": "QUsb2Snes\\QUsb2Snes.exe",
-                "rom_start": True,
+    # Refer to host.yaml for comments as to what all these options mean.
+    options = {
+        "general_options": {
+            "output_path": "output",
+        },
+        "factorio_options": {
+            "executable": os.path.join("factorio", "bin", "x64", "factorio"),
+        },
+        "sm_options": {
+            "rom_file": "Super Metroid (JU).sfc",
+            "sni": "SNI",
+            "rom_start": True,
+        },
+        "soe_options": {
+            "rom_file": "Secret of Evermore (USA).sfc",
+        },
+        "lttp_options": {
+            "rom_file": "Zelda no Densetsu - Kamigami no Triforce (Japan).sfc",
+            "sni": "SNI",
+            "rom_start": True,
 
-            },
-            "server_options": {
-                "host": None,
-                "port": 38281,
-                "password": None,
-                "multidata": None,
-                "savefile": None,
-                "disable_save": False,
-                "loglevel": "info",
-                "server_password": None,
-                "disable_item_cheat": False,
-                "location_check_points": 1,
-                "hint_cost": 10,
-                "forfeit_mode": "goal",
-                "remaining_mode": "goal",
-                "auto_shutdown": 0,
-                "compatibility": 2,
-                "log_network": 0
-            },
-            "multi_mystery_options": {
-                "teams": 1,
-                "enemizer_path": "EnemizerCLI/EnemizerCLI.Core.exe",
-                "player_files_path": "Players",
-                "players": 0,
-                "weights_file_path": "weights.yaml",
-                "meta_file_path": "meta.yaml",
-                "pre_roll": False,
-                "create_spoiler": 1,
-                "zip_roms": 0,
-                "zip_diffs": 2,
-                "zip_apmcs": 1,
-                "zip_spoiler": 0,
-                "zip_multidata": 1,
-                "zip_format": 1,
-                "glitch_triforce_room": 1,
-                "race": 0,
-                "cpu_threads": 0,
-                "max_attempts": 0,
-                "take_first_working": False,
-                "keep_all_seeds": False,
-                "log_output_path": "Output Logs",
-                "log_level": None,
-                "plando_options": "bosses",
-            }
-        }
+        },
+        "server_options": {
+            "host": None,
+            "port": 38281,
+            "password": None,
+            "multidata": None,
+            "savefile": None,
+            "disable_save": False,
+            "loglevel": "info",
+            "server_password": None,
+            "disable_item_cheat": False,
+            "location_check_points": 1,
+            "hint_cost": 10,
+            "forfeit_mode": "goal",
+            "collect_mode": "disabled",
+            "remaining_mode": "goal",
+            "auto_shutdown": 0,
+            "compatibility": 2,
+            "log_network": 0
+        },
+        "generator": {
+            "teams": 1,
+            "enemizer_path": os.path.join("EnemizerCLI", "EnemizerCLI.Core"),
+            "player_files_path": "Players",
+            "players": 0,
+            "weights_file_path": "weights.yaml",
+            "meta_file_path": "meta.yaml",
+            "spoiler": 2,
+            "glitch_triforce_room": 1,
+            "race": 0,
+            "plando_options": "bosses",
+        },
+        "minecraft_options": {
+            "forge_directory": "Minecraft Forge server",
+            "max_heap_size": "2G",
+            "release_channel": "release"
+        },
+        "oot_options": {
+            "rom_file": "The Legend of Zelda - Ocarina of Time.z64",
+        },
+        "dkc3_options": {
+            "rom_file": "Donkey Kong Country 3 - Dixie Kong's Double Trouble! (USA) (En,Fr).sfc",
+            "sni": "SNI",
+            "rom_start": True,
+        },
+    }
 
-        get_default_options.options = options
-    return get_default_options.options
-
-
-blacklisted_options = {"multi_mystery_options.cpu_threads",
-                       "multi_mystery_options.max_attempts",
-                       "multi_mystery_options.take_first_working",
-                       "multi_mystery_options.keep_all_seeds",
-                       "multi_mystery_options.log_output_path",
-                       "multi_mystery_options.log_level"}
+    return options
 
 
 def update_options(src: dict, dest: dict, filename: str, keys: list) -> dict:
-    import logging
     for key, value in src.items():
         new_keys = keys.copy()
         new_keys.append(key)
         option_name = '.'.join(new_keys)
         if key not in dest:
             dest[key] = value
-            if filename.endswith("options.yaml") and option_name not in blacklisted_options:
+            if filename.endswith("options.yaml"):
                 logging.info(f"Warning: {filename} is missing {option_name}")
         elif isinstance(value, dict):
             if not isinstance(dest.get(key, None), dict):
-                if filename.endswith("options.yaml") and option_name not in blacklisted_options:
+                if filename.endswith("options.yaml"):
                     logging.info(f"Warning: {filename} has {option_name}, but it is not a dictionary. overwriting.")
                 dest[key] = value
             else:
@@ -254,10 +307,14 @@ def update_options(src: dict, dest: dict, filename: str, keys: list) -> dict:
     return dest
 
 
+@cache_argsless
 def get_options() -> dict:
     if not hasattr(get_options, "options"):
-        locations = ("options.yaml", "host.yaml",
-                     local_path("options.yaml"), local_path("host.yaml"))
+        filenames = ("options.yaml", "host.yaml")
+        locations = []
+        if os.path.join(os.getcwd()) != local_path():
+            locations += filenames  # use files from cwd only if it's not the local_path
+        locations += [user_path(filename) for filename in filenames]
 
         for location in locations:
             if os.path.exists(location):
@@ -267,7 +324,7 @@ def get_options() -> dict:
                 get_options.options = update_options(get_default_options(), options, location, list())
                 break
         else:
-            raise FileNotFoundError(f"Could not find {locations[1]} to load options.")
+            raise FileNotFoundError(f"Could not find {filenames[1]} to load options.")
     return get_options.options
 
 
@@ -282,7 +339,7 @@ def get_location_name_from_id(code: int) -> str:
 
 
 def persistent_store(category: str, key: typing.Any, value: typing.Any):
-    path = local_path("_persistent_storage.yaml")
+    path = user_path("_persistent_storage.yaml")
     storage: dict = persistent_load()
     category = storage.setdefault(category, {})
     category[key] = value
@@ -294,14 +351,13 @@ def persistent_load() -> typing.Dict[dict]:
     storage = getattr(persistent_load, "storage", None)
     if storage:
         return storage
-    path = local_path("_persistent_storage.yaml")
+    path = user_path("_persistent_storage.yaml")
     storage: dict = {}
     if os.path.exists(path):
         try:
             with open(path, "r") as f:
                 storage = unsafe_parse_yaml(f.read())
         except Exception as e:
-            import logging
             logging.debug(f"Could not read store: {e}")
     if storage is None:
         storage = {}
@@ -309,65 +365,12 @@ def persistent_load() -> typing.Dict[dict]:
     return storage
 
 
-def get_adjuster_settings(romfile: str) -> typing.Tuple[str, bool]:
-    if hasattr(get_adjuster_settings, "adjuster_settings"):
-        adjuster_settings = getattr(get_adjuster_settings, "adjuster_settings")
-    else:
-        adjuster_settings = persistent_load().get("adjuster", {}).get("last_settings_3", {})
-
-    if adjuster_settings:
-        import pprint
-        import Patch
-        adjuster_settings.rom = romfile
-        adjuster_settings.baserom = Patch.get_base_rom_path()
-        adjuster_settings.world = None
-        whitelist = {"disablemusic", "fastmenu", "heartbeep", "heartcolor", "ow_palettes", "quickswap",
-                     "uw_palettes", "sprite"}
-        printed_options = {name: value for name, value in vars(adjuster_settings).items() if name in whitelist}
-        if hasattr(adjuster_settings, "sprite_pool"):
-            sprite_pool = {}
-            for sprite in getattr(adjuster_settings, "sprite_pool"):
-                if sprite in sprite_pool:
-                    sprite_pool[sprite] += 1
-                else:
-                    sprite_pool[sprite] = 1
-            if sprite_pool:
-                printed_options["sprite_pool"] = sprite_pool
-
-
-        if hasattr(get_adjuster_settings, "adjust_wanted"):
-            adjust_wanted = getattr(get_adjuster_settings, "adjust_wanted")
-        elif persistent_load().get("adjuster", {}).get("never_adjust", False):  # never adjust, per user request
-            return romfile, False
-        else:
-            adjust_wanted = input(f"Last used adjuster settings were found. Would you like to apply these? \n"
-                                  f"{pprint.pformat(printed_options)}\n"
-                                  f"Enter yes, no or never: ")
-        if adjust_wanted and adjust_wanted.startswith("y"):
-            if hasattr(adjuster_settings, "sprite_pool"):
-                from LttPAdjuster import AdjusterWorld
-                adjuster_settings.world = AdjusterWorld(getattr(adjuster_settings, "sprite_pool"))
-
-            adjusted = True
-            import LttPAdjuster
-            _, romfile = LttPAdjuster.adjust(adjuster_settings)
-
-            if hasattr(adjuster_settings, "world"):
-                delattr(adjuster_settings, "world")
-        elif adjust_wanted and "never" in adjust_wanted:
-            persistent_store("adjuster", "never_adjust", True)
-            return romfile, False
-        else:
-            adjusted = False
-            import logging
-            if not hasattr(get_adjuster_settings, "adjust_wanted"):
-                logging.info(f"Skipping post-patch adjustment")
-        get_adjuster_settings.adjuster_settings = adjuster_settings
-        get_adjuster_settings.adjust_wanted = adjust_wanted
-        return romfile, adjusted
-    return romfile, False
+def get_adjuster_settings(gameName: str):
+    adjuster_settings = persistent_load().get("adjuster", {}).get(gameName, {})
+    return adjuster_settings
 
 
+@cache_argsless
 def get_unique_identifier():
     uuid = persistent_load().get("client", {}).get("uuid", None)
     if uuid:
@@ -386,16 +389,28 @@ safe_builtins = {
 
 
 class RestrictedUnpickler(pickle.Unpickler):
+    def __init__(self, *args, **kwargs):
+        super(RestrictedUnpickler, self).__init__(*args, **kwargs)
+        self.options_module = importlib.import_module("Options")
+        self.net_utils_module = importlib.import_module("NetUtils")
+        self.generic_properties_module = importlib.import_module("worlds.generic")
+
     def find_class(self, module, name):
         if module == "builtins" and name in safe_builtins:
             return getattr(builtins, name)
-        if module == "NetUtils" and name in {"NetworkItem", "ClientStatus", "Hint"}:
-            import NetUtils
-            return getattr(NetUtils, name)
-        if module == "Options":
-            import Options
-            obj = getattr(Options, name)
-            if issubclass(obj, Options.Option):
+        # used by MultiServer -> savegame/multidata
+        if module == "NetUtils" and name in {"NetworkItem", "ClientStatus", "Hint", "SlotType", "NetworkSlot"}:
+            return getattr(self.net_utils_module, name)
+        # Options and Plando are unpickled by WebHost -> Generate
+        if module == "worlds.generic" and name in {"PlandoItem", "PlandoConnection"}:
+            return getattr(self.generic_properties_module, name)
+        if module.endswith("Options"):
+            if module == "Options":
+                mod = self.options_module
+            else:
+                mod = importlib.import_module(module)
+            obj = getattr(mod, name)
+            if issubclass(obj, self.options_module.Option):
                 return obj
         # Forbid everything else.
         raise pickle.UnpicklingError("global '%s.%s' is forbidden" %
@@ -404,4 +419,197 @@ class RestrictedUnpickler(pickle.Unpickler):
 
 def restricted_loads(s):
     """Helper function analogous to pickle.loads()."""
-    return RestrictedUnpickler(io.BytesIO(s)).load()
+    return RestrictedUnpickler(io.BytesIO(s)).load()
+
+
+class KeyedDefaultDict(collections.defaultdict):
+    def __missing__(self, key):
+        self[key] = value = self.default_factory(key)
+        return value
+
+
+def get_text_between(text: str, start: str, end: str) -> str:
+    return text[text.index(start) + len(start): text.rindex(end)]
+
+
+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, write_mode: str = "w",
+                 log_format: str = "[%(name)s at %(asctime)s]: %(message)s",
+                 exception_logger: typing.Optional[str] = None):
+    loglevel: int = loglevel_mapping.get(loglevel, loglevel)
+    log_folder = user_path("logs")
+    os.makedirs(log_folder, exist_ok=True)
+    root_logger = logging.getLogger()
+    for handler in root_logger.handlers[:]:
+        root_logger.removeHandler(handler)
+        handler.close()
+    root_logger.setLevel(loglevel)
+    file_handler = logging.FileHandler(
+        os.path.join(log_folder, f"{name}.txt"),
+        write_mode,
+        encoding="utf-8-sig")
+    file_handler.setFormatter(logging.Formatter(log_format))
+    root_logger.addHandler(file_handler)
+    if sys.stdout:
+        root_logger.addHandler(
+            logging.StreamHandler(sys.stdout)
+        )
+
+    # Relay unhandled exceptions to logger.
+    if not getattr(sys.excepthook, "_wrapped", False):  # skip if already modified
+        orig_hook = sys.excepthook
+
+        def handle_exception(exc_type, exc_value, exc_traceback):
+            if issubclass(exc_type, KeyboardInterrupt):
+                sys.__excepthook__(exc_type, exc_value, exc_traceback)
+                return
+            logging.getLogger(exception_logger).exception("Uncaught exception",
+                                                          exc_info=(exc_type, exc_value, exc_traceback))
+            return orig_hook(exc_type, exc_value, exc_traceback)
+
+        handle_exception._wrapped = True
+
+        sys.excepthook = handle_exception
+
+    logging.info(f"Archipelago ({__version__}) logging initialized.")
+
+
+def stream_input(stream, queue):
+    def queuer():
+        while 1:
+            try:
+                text = stream.readline().strip()
+            except UnicodeDecodeError as e:
+                logging.exception(e)
+            else:
+                if text:
+                    queue.put_nowait(text)
+
+    from threading import Thread
+    thread = Thread(target=queuer, name=f"Stream handler for {stream.name}", daemon=True)
+    thread.start()
+    return thread
+
+
+def tkinter_center_window(window: Tk):
+    window.update()
+    xPos = int(window.winfo_screenwidth() / 2 - window.winfo_reqwidth() / 2)
+    yPos = int(window.winfo_screenheight() / 2 - window.winfo_reqheight() / 2)
+    window.geometry("+{}+{}".format(xPos, yPos))
+
+
+class VersionException(Exception):
+    pass
+
+
+def chaining_prefix(index: int, labels: typing.Tuple[str]) -> str:
+    text = ""
+    max_label = len(labels) - 1
+    while index > max_label:
+        text += labels[-1]
+        index -= max_label
+    return labels[index] + text
+
+
+# noinspection PyPep8Naming
+def format_SI_prefix(value, power=1000, power_labels=('', 'k', 'M', 'G', 'T', "P", "E", "Z", "Y")) -> str:
+    """Formats a value into a value + metric/si prefix. More info at https://en.wikipedia.org/wiki/Metric_prefix"""
+    n = 0
+    value = decimal.Decimal(value)
+    while value >= power:
+        value /= power
+        n += 1
+
+    return f"{value.quantize(decimal.Decimal('1.00'))} {chaining_prefix(n, power_labels)}"
+
+
+def get_fuzzy_ratio(word1: str, word2: str) -> float:
+    return (1 - jellyfish.damerau_levenshtein_distance(word1.lower(), word2.lower())
+            / max(len(word1), len(word2)))
+
+
+def get_fuzzy_results(input_word: str, wordlist: typing.Sequence[str], limit: typing.Optional[int] = None) \
+        -> typing.List[typing.Tuple[str, int]]:
+    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)),
+                    wordlist),
+                key=lambda element: element[1],
+                reverse=True)[0:limit]
+        )
+    )
+
+
+def open_filename(title: str, filetypes: typing.Sequence[typing.Tuple[str, typing.Sequence[str]]]) \
+        -> typing.Optional[str]:
+    def run(*args: str):
+        return subprocess.run(args, capture_output=True, text=True).stdout.split('\n', 1)[0] or None
+
+    if is_linux:
+        # prefer native dialog
+        kdialog = shutil.which('kdialog')
+        if kdialog:
+            k_filters = '|'.join((f'{text} (*{" *".join(ext)})' for (text, ext) in filetypes))
+            return run(kdialog, f'--title={title}', '--getopenfilename', '.', k_filters)
+        zenity = shutil.which('zenity')
+        if zenity:
+            z_filters = (f'--file-filter={text} ({", ".join(ext)}) | *{" *".join(ext)}' for (text, ext) in filetypes)
+            return run(zenity, f'--title={title}', '--file-selection', *z_filters)
+
+    # fall back to tk
+    try:
+        import tkinter
+        import tkinter.filedialog
+    except Exception as e:
+        logging.error('Could not load tkinter, which is likely not installed. '
+                      f'This attempt was made because open_filename was used for "{title}".')
+        raise e
+    else:
+        root = tkinter.Tk()
+        root.withdraw()
+        return tkinter.filedialog.askopenfilename(title=title, filetypes=((t[0], ' '.join(t[1])) for t in filetypes))
+
+
+def messagebox(title: str, text: str, error: bool = False) -> None:
+    def run(*args: str):
+        return subprocess.run(args, capture_output=True, text=True).stdout.split('\n', 1)[0] or None
+
+    def is_kivy_running():
+        if 'kivy' in sys.modules:
+            from kivy.app import App
+            return App.get_running_app() is not None
+        return False
+
+    if is_kivy_running():
+        from kvui import MessageBox
+        MessageBox(title, text, error).open()
+        return
+
+    if is_linux and not 'tkinter' in sys.modules:
+        # prefer native dialog
+        kdialog = shutil.which('kdialog')
+        if kdialog:
+            return run(kdialog, f'--title={title}', '--error' if error else '--msgbox', text)
+        zenity = shutil.which('zenity')
+        if zenity:
+            return run(zenity, f'--title={title}', f'--text={text}', '--error' if error else '--info')
+
+    # fall back to tk
+    try:
+        import tkinter
+        from tkinter.messagebox import showerror, showinfo
+    except Exception as e:
+        logging.error('Could not load tkinter, which is likely not installed. '
+                      f'This attempt was made because messagebox was used for "{title}".')
+        raise e
+    else:
+        root = tkinter.Tk()
+        root.withdraw()
+        showerror(title, text) if error else showinfo(title, text)
+        root.update()

WebHost.py

@@ -1,18 +1,32 @@
 import os
+import sys
 import multiprocessing
 import logging
+import typing
 
 import ModuleUpdate
+
 ModuleUpdate.requirements_files.add(os.path.join("WebHostLib", "requirements.txt"))
 ModuleUpdate.update()
 
+# in case app gets imported by something like gunicorn
+import Utils
+
+Utils.local_path.cached_path = os.path.dirname(__file__)
+
 from WebHostLib import app as raw_app
 from waitress import serve
 
 from WebHostLib.models import db
-from WebHostLib.autolauncher import autohost
+from WebHostLib.autolauncher import autohost, autogen
+from WebHostLib.lttpsprites import update_sprites_lttp
+from WebHostLib.options import create as create_options_files
+
+from worlds.AutoWorld import AutoWorldRegister
 
 configpath = os.path.abspath("config.yaml")
+if not os.path.exists(configpath):  # fall back to config.yaml in home
+    configpath = os.path.abspath(Utils.user_path('config.yaml'))
 
 
 def get_app():
@@ -26,16 +40,74 @@ def get_app():
     return app
 
 
+def create_ordered_tutorials_file() -> typing.List[typing.Dict[str, typing.Any]]:
+    import json
+    import shutil
+    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
+    for game, world in worlds.items():
+        # copy files from world's docs folder to the generated folder
+        source_path = Utils.local_path(os.path.dirname(sys.modules[world.__module__].__file__), 'docs')
+        target_path = Utils.local_path("WebHostLib", "static", "generated", "docs", game)
+        files = os.listdir(source_path)
+        for file in files:
+            os.makedirs(os.path.dirname(Utils.local_path(target_path, file)), exist_ok=True)
+            shutil.copyfile(Utils.local_path(source_path, file), Utils.local_path(target_path, file))
+        # build a json tutorial dict per game
+        game_data = {'gameTitle': game, 'tutorials': []}
+        for tutorial in world.web.tutorials:
+            # build dict for the json file
+            current_tutorial = {
+                'name': tutorial.tutorial_name,
+                'description': tutorial.description,
+                'files': [{
+                    'language': tutorial.language,
+                    'filename': game + '/' + tutorial.file_name,
+                    'link': f'{game}/{tutorial.link}',
+                    'authors': tutorial.authors
+                }]
+            }
+
+            # check if the name of the current guide exists already
+            for guide in game_data['tutorials']:
+                if guide and tutorial.tutorial_name == guide['name']:
+                    guide['files'].append(current_tutorial['files'][0])
+                    break
+            else:
+                game_data['tutorials'].append(current_tutorial)
+
+        data.append(game_data)
+    with open(Utils.local_path("WebHostLib", "static", "generated", "tutorials.json"), 'w', encoding='utf-8-sig') as json_target:
+        generic_data = {}
+        for games in data:
+            if 'Archipelago' in games['gameTitle']:
+                generic_data = data.pop(data.index(games))
+        sorted_data = [generic_data] + sorted(data, key=lambda entry: entry["gameTitle"].lower())
+        json.dump(sorted_data, json_target, indent=2, ensure_ascii=False)
+    return sorted_data
+
+
 if __name__ == "__main__":
     multiprocessing.freeze_support()
     multiprocessing.set_start_method('spawn')
     logging.basicConfig(format='[%(asctime)s] %(message)s', level=logging.INFO)
+    try:
+        update_sprites_lttp()
+    except Exception as e:
+        logging.exception(e)
+        logging.warning("Could not update LttP sprites.")
     app = get_app()
+    create_options_files()
+    create_ordered_tutorials_file()
     if app.config["SELFLAUNCH"]:
         autohost(app.config)
+    if app.config["SELFGEN"]:
+        autogen(app.config)
     if app.config["SELFHOST"]:  # using WSGI, you just want to run get_app()
         if app.config["DEBUG"]:
-            autohost(app.config)
             app.run(debug=True, port=app.config["PORT"])
         else:
             serve(app, port=app.config["PORT"], threads=app.config["WAITRESS_THREADS"])

WebHostLib/__init__.py

@@ -3,10 +3,12 @@ import uuid
 import base64
 import socket
 
+import jinja2.exceptions
 from pony.flask import Pony
 from flask import Flask, request, redirect, url_for, render_template, Response, session, abort, send_from_directory
 from flask_caching import Cache
 from flask_compress import Compress
+from worlds.AutoWorld import AutoWorldRegister
 
 from .models import *
 
@@ -20,13 +22,14 @@ Pony(app)
 app.jinja_env.filters['any'] = any
 app.jinja_env.filters['all'] = all
 
-app.config["SELFHOST"] = True
+app.config["SELFHOST"] = True  # application process is in charge of running the websites
 app.config["GENERATORS"] = 8  # maximum concurrent world gens
-app.config["SELFLAUNCH"] = True
+app.config["SELFLAUNCH"] = True  # application process is in charge of launching Rooms.
+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'] = 4 * 1024 * 1024  # 4 megabyte limit
+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 webthread
@@ -43,7 +46,7 @@ app.config["PONY"] = {
     'create_db': True
 }
 app.config["MAX_ROLL"] = 20
-app.config["CACHE_TYPE"] = "simple"
+app.config["CACHE_TYPE"] = "flask_caching.backends.SimpleCache"
 app.config["JSON_AS_ASCII"] = False
 app.config["PATCH_TARGET"] = "archipelago.gg"
 
@@ -66,6 +69,16 @@ class B64UUIDConverter(BaseConverter):
 app.url_map.converters["suuid"] = B64UUIDConverter
 app.jinja_env.filters['suuid'] = lambda value: base64.urlsafe_b64encode(value.bytes).rstrip(b'=').decode('ascii')
 
+# has automatic patch integration
+import Patch
+app.jinja_env.filters['supports_apdeltapatch'] = lambda game_name: game_name in Patch.AutoPatchRegister.patch_types
+
+
+def get_world_theme(game_name: str):
+    if game_name in AutoWorldRegister.world_types:
+        return AutoWorldRegister.world_types[game_name].web.theme
+    return 'grass'
+
 
 @app.before_request
 def register_session():
@@ -74,33 +87,75 @@ def register_session():
         session["_id"] = uuid4()  # uniquely identify each session without needing a login
 
 
-@app.route('/tutorial/<string:game>/<string:file>/<string:lang>')
-def tutorial(game, file, lang):
-    return render_template("tutorial.html", game=game, file=file, lang=lang)
+@app.errorhandler(404)
+@app.errorhandler(jinja2.exceptions.TemplateNotFound)
+def page_not_found(err):
+    return render_template('404.html'), 404
 
 
-@app.route('/tutorial')
-def tutorial_landing():
-    return render_template("tutorialLanding.html")
-
-
-@app.route('/player-settings')
-def player_settings_simple():
-    return render_template("playerSettings.html")
+# Start Playing Page
+@app.route('/start-playing')
+def start_playing():
+    return render_template(f"startPlaying.html")
 
 
 @app.route('/weighted-settings')
-def player_settings():
-    return render_template("weightedSettings.html")
+def weighted_settings():
+    return render_template(f"weighted-settings.html")
+
+
+# Player settings pages
+@app.route('/games/<string:game>/player-settings')
+def player_settings(game):
+    return render_template(f"player-settings.html", game=game, theme=get_world_theme(game))
+
+
+# Game Info Pages
+@app.route('/games/<string:game>/info/<string:lang>')
+def game_info(game, lang):
+    return render_template('gameInfo.html', game=game, lang=lang, theme=get_world_theme(game))
+
+
+# List of supported games
+@app.route('/games')
+def games():
+    worlds = {}
+    for game, world in AutoWorldRegister.world_types.items():
+        if not world.hidden:
+            worlds[game] = world
+    return render_template("supportedGames.html", worlds=worlds)
+
+
+@app.route('/tutorial/<string:game>/<string:file>/<string:lang>')
+def tutorial(game, file, lang):
+    return render_template("tutorial.html", game=game, file=file, lang=lang, theme=get_world_theme(game))
+
+
+@app.route('/tutorial/')
+def tutorial_landing():
+    worlds = {}
+    for game, world in AutoWorldRegister.world_types.items():
+        if not world.hidden:
+            worlds[game] = world
+    return render_template("tutorialLanding.html")
+
+
+@app.route('/faq/<string:lang>/')
+def faq(lang):
+    return render_template("faq.html", lang=lang)
+
+
+@app.route('/glossary/<string:lang>/')
+def terms(lang):
+    return render_template("glossary.html", lang=lang)
 
 
 @app.route('/seed/<suuid:seed>')
-def viewSeed(seed: UUID):
+def view_seed(seed: UUID):
     seed = Seed.get(id=seed)
     if not seed:
         abort(404)
-    return render_template("viewSeed.html", seed=seed,
-                           rooms=[room for room in seed.rooms if room.owner == session["_id"]])
+    return render_template("viewSeed.html", seed=seed, slot_count=count(seed.slots))
 
 
 @app.route('/new_room/<suuid:seed>')
@@ -110,7 +165,7 @@ def new_room(seed: UUID):
         abort(404)
     room = Room(seed=seed, owner=session["_id"], tracker=uuid4())
     commit()
-    return redirect(url_for("hostRoom", room=room.id))
+    return redirect(url_for("host_room", room=room.id))
 
 
 def _read_log(path: str):
@@ -124,20 +179,25 @@ def _read_log(path: str):
 
 @app.route('/log/<suuid:room>')
 def display_log(room: UUID):
-    # noinspection PyTypeChecker
-    return Response(_read_log(os.path.join("logs", str(room) + ".txt")), mimetype="text/plain;charset=UTF-8")
+    room = Room.get(id=room)
+    if room is None:
+        return abort(404)
+    if room.owner == session["_id"]:
+        return Response(_read_log(os.path.join("logs", str(room.id) + ".txt")), mimetype="text/plain;charset=UTF-8")
+    return "Access Denied", 403
 
 
-@app.route('/hosted/<suuid:room>', methods=['GET', 'POST'])
-def hostRoom(room: UUID):
+@app.route('/room/<suuid:room>', methods=['GET', 'POST'])
+def host_room(room: UUID):
     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"]
-            Command(room=room, commandtext=cmd)
-            commit()
+            if cmd:
+                Command(room=room, commandtext=cmd)
+                commit()
 
     with db_session:
         room.last_activity = datetime.utcnow()  # will trigger a spinup, if it's not already running
@@ -151,6 +211,31 @@ def favicon():
                                'favicon.ico', mimetype='image/vnd.microsoft.icon')
 
 
+@app.route('/discord')
+def discord():
+    return redirect("https://discord.gg/archipelago")
+
+
+@app.route('/datapackage')
+@cache.cached()
+def get_datapackge():
+    """A pretty print version of /api/datapackage"""
+    from worlds import network_data_package
+    import json
+    return Response(json.dumps(network_data_package, indent=4), mimetype="text/plain")
+
+
+@app.route('/index')
+@app.route('/sitemap')
+def get_sitemap():
+    available_games = []
+    for game, world in AutoWorldRegister.world_types.items():
+        if not world.hidden:
+            available_games.append(game)
+    return render_template("siteMap.html", games=available_games)
+
+
 from WebHostLib.customserver import run_server_process
-from . import tracker, upload, landing, check, generate, downloads, api  # to trigger app routing picking up on it
+from . import tracker, upload, landing, check, generate, downloads, api, stats  # to trigger app routing picking up on it
+
 app.register_blueprint(api.api_endpoints)

WebHostLib/api/__init__.py

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

WebHostLib/api/generate.py

@@ -9,6 +9,7 @@ from pony.orm import commit
 
 from WebHostLib import app, Generation, STATE_QUEUED, Seed, STATE_ERROR
 from WebHostLib.check import get_yaml_data, roll_options
+from WebHostLib.generate import get_meta
 
 
 @api_endpoints.route('/generate', methods=['POST'])
@@ -16,7 +17,7 @@ def generate_api():
     try:
         options = {}
         race = False
-
+        meta_options_source = {}
         if 'file' in request.files:
             file = request.files['file']
             options = get_yaml_data(file)
@@ -24,14 +25,17 @@ def generate_api():
                 return {"text": options}, 400
             if "race" in request.form:
                 race = bool(0 if request.form["race"] in {"false"} else int(request.form["race"]))
+            meta_options_source = request.form
 
         json_data = request.get_json()
         if json_data:
+            meta_options_source = json_data
             if 'weights' in json_data:
                 # example: options = {"player1weights" : {<weightsdata>}}
                 options = json_data["weights"]
             if "race" in json_data:
                 race = bool(0 if json_data["race"] in {"false"} else int(json_data["race"]))
+
         if not options:
             return {"text": "No options found. Expected file attachment or json weights."
                     }, 400
@@ -39,8 +43,9 @@ def generate_api():
         if len(options) > app.config["MAX_ROLL"]:
             return {"text": "Max size of multiworld exceeded",
                     "detail": app.config["MAX_ROLL"]}, 409
-
-        results, gen_options = roll_options(options)
+        meta = get_meta(meta_options_source)
+        meta["race"] = race
+        results, gen_options = roll_options(options, meta["plando_options"])
         if any(type(result) == str for result in results.values()):
             return {"text": str(results),
                     "detail": results}, 400
@@ -48,7 +53,7 @@ def generate_api():
             gen = Generation(
                 options=pickle.dumps({name: vars(options) for name, options in gen_options.items()}),
                 # convert to json compatible
-                meta=json.dumps({"race": race}), state=STATE_QUEUED,
+                meta=json.dumps(meta), state=STATE_QUEUED,
                 owner=session["_id"])
             commit()
             return {"text": f"Generation of seed {gen.id} started successfully.",
@@ -60,7 +65,6 @@ def generate_api():
         return {"text": "Uncaught Exception:" + str(e)}, 500
 
 
-
 @api_endpoints.route('/status/<suuid:seed>')
 def wait_seed_api(seed: UUID):
     seed_id = seed

WebHostLib/api/user.py

@@ -1,7 +1,7 @@
 from flask import session, jsonify
 
 from WebHostLib.models import *
-from . import api_endpoints
+from . import api_endpoints, get_players
 
 
 @api_endpoints.route('/get_rooms')
@@ -16,7 +16,6 @@ def get_rooms():
             "last_port": room.last_port,
             "timeout": room.timeout,
             "tracker": room.tracker,
-            "players": room.seed.multidata["names"] if room.seed.multidata else [["Singleplayer"]],
         })
     return jsonify(response)
 
@@ -28,6 +27,6 @@ def get_seeds():
         response.append({
             "seed_id": seed.id,
             "creation_time": seed.creation_time,
-            "players": seed.multidata["names"] if seed.multidata else [["Singleplayer"]],
+            "players": get_players(seed.slots),
         })
     return jsonify(response)

WebHostLib/autolauncher.py

@@ -2,11 +2,13 @@ from __future__ import annotations
 import logging
 import json
 import multiprocessing
+import threading
 from datetime import timedelta, datetime
-import concurrent.futures
+
 import sys
 import typing
 import time
+import os
 
 from pony.orm import db_session, select, commit
 
@@ -15,10 +17,14 @@ from Utils import restricted_loads
 
 class CommonLocker():
     """Uses a file lock to signal that something is already running"""
+    lock_folder = "file_locks"
 
-    def __init__(self, lockname: str):
+    def __init__(self, lockname: str, folder=None):
+        if folder:
+            self.lock_folder = folder
+        os.makedirs(self.lock_folder, exist_ok=True)
         self.lockname = lockname
-        self.lockfile = f"./{self.lockname}.lck"
+        self.lockfile = os.path.join(self.lock_folder, f"{self.lockname}.lck")
 
 
 class AlreadyRunningException(Exception):
@@ -26,9 +32,6 @@ class AlreadyRunningException(Exception):
 
 
 if sys.platform == 'win32':
-    import os
-
-
     class Locker(CommonLocker):
         def __enter__(self):
             try:
@@ -52,7 +55,7 @@ else:  # unix
         def __enter__(self):
             try:
                 self.fp = open(self.lockfile, "wb")
-                fcntl.flock(self.fp.fileno(), fcntl.LOCK_EX)
+                fcntl.flock(self.fp.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
             except OSError as e:
                 raise AlreadyRunningException() from e
 
@@ -88,14 +91,14 @@ def launch_generator(pool: multiprocessing.pool.Pool, generation: Generation):
         options = restricted_loads(generation.options)
         logging.info(f"Generating {generation.id} for {len(options)} players")
         pool.apply_async(gen_game, (options,),
-                         {"race": meta["race"],
+                         {"meta": meta,
                           "sid": generation.id,
                           "owner": generation.owner},
                          handle_generation_success, handle_generation_failure)
-    except:
+    except Exception as e:
         generation.state = STATE_ERROR
         commit()
-        raise
+        logging.exception(e)
     else:
         generation.state = STATE_STARTED
 
@@ -109,6 +112,27 @@ def autohost(config: dict):
     def keep_running():
         try:
             with Locker("autohost"):
+                run_guardian()
+                while 1:
+                    time.sleep(0.1)
+                    with db_session:
+                        rooms = select(
+                            room for room in Room if
+                            room.last_activity >= datetime.utcnow() - timedelta(days=3))
+                        for room in rooms:
+                            launch_room(room, config)
+
+        except AlreadyRunningException:
+            logging.info("Autohost reports as already running, not starting another.")
+
+    import threading
+    threading.Thread(target=keep_running, name="AP_Autohost").start()
+
+
+def autogen(config: dict):
+    def keep_running():
+        try:
+            with Locker("autogen"):
 
                 with multiprocessing.Pool(config["GENERATORS"], initializer=init_db,
                                           initargs=(config["PONY"],)) as generator_pool:
@@ -128,34 +152,30 @@ def autohost(config: dict):
                         select(generation for generation in Generation if generation.state == STATE_ERROR).delete()
 
                     while 1:
-                        time.sleep(0.50)
+                        time.sleep(0.1)
                         with db_session:
-                            rooms = select(
-                                room for room in Room if
-                                room.last_activity >= datetime.utcnow() - timedelta(days=3))
-                            for room in rooms:
-                                launch_room(room, config)
+                            # 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)
+                                generation for generation in Generation
+                                if generation.state == STATE_QUEUED).for_update()
                             for generation in to_start:
                                 launch_generator(generator_pool, generation)
         except AlreadyRunningException:
-            pass
+            logging.info("Autogen reports as already running, not starting another.")
 
     import threading
-    threading.Thread(target=keep_running).start()
+    threading.Thread(target=keep_running, name="AP_Autogen").start()
 
 
-multiworlds = {}
-
-guardians = concurrent.futures.ThreadPoolExecutor(2, thread_name_prefix="Guardian")
+multiworlds: typing.Dict[type(Room.id), MultiworldInstance] = {}
 
 
 class MultiworldInstance():
     def __init__(self, room: Room, config: dict):
         self.room_id = room.id
         self.process: typing.Optional[multiprocessing.Process] = None
-        multiworlds[self.room_id] = self
+        with guardian_lock:
+            multiworlds[self.room_id] = self
         self.ponyconfig = config["PONY"]
 
     def start(self):
@@ -163,21 +183,58 @@ class MultiworldInstance():
             return False
 
         logging.info(f"Spinning up {self.room_id}")
-        self.process = multiprocessing.Process(group=None, target=run_server_process,
-                                               args=(self.room_id, self.ponyconfig),
-                                               name="MultiHost")
-        self.process.start()
-        self.guardian = guardians.submit(self._collect)
+        process = multiprocessing.Process(group=None, target=run_server_process,
+                                          args=(self.room_id, self.ponyconfig),
+                                          name="MultiHost")
+        process.start()
+        # bind after start to prevent thread sync issues with guardian.
+        self.process = process
 
     def stop(self):
         if self.process:
             self.process.terminate()
             self.process = None
 
-    def _collect(self):
+    def done(self):
+        return self.process and not self.process.is_alive()
+
+    def collect(self):
         self.process.join()  # wait for process to finish
         self.process = None
-        self.guardian = None
+
+
+guardian = None
+guardian_lock = threading.Lock()
+
+
+def run_guardian():
+    global guardian
+    global multiworlds
+    with guardian_lock:
+        if not guardian:
+            try:
+                import resource
+            except ModuleNotFoundError:
+                pass  # unix only module
+            else:
+                # Each Server is another file handle, so request as many as we can from the system
+                file_limit = resource.getrlimit(resource.RLIMIT_NOFILE)[1]
+                # set soft limit to hard limit
+                resource.setrlimit(resource.RLIMIT_NOFILE, (file_limit, file_limit))
+
+            def guard():
+                while 1:
+                    time.sleep(1)
+                    done = []
+                    with guardian_lock:
+                        for key, instance in multiworlds.items():
+                            if instance.done():
+                                instance.collect()
+                                done.append(key)
+                        for key in done:
+                            del (multiworlds[key])
+
+            guardian = threading.Thread(name="Guardian", target=guard)
 
 
 from .models import Room, Generation, STATE_QUEUED, STATE_STARTED, STATE_ERROR, db, Seed

WebHostLib/check.py

@@ -12,12 +12,12 @@ def allowed_file(filename):
     return filename.endswith(('.txt', ".yaml", ".zip"))
 
 
-from Mystery import roll_settings
-from Utils import parse_yaml
+from Generate import roll_settings, PlandoSettings
+from Utils import parse_yamls
 
 
-@app.route('/mysterycheck', methods=['GET', 'POST'])
-def mysterycheck():
+@app.route('/check', methods=['GET', 'POST'])
+def check():
     if request.method == 'POST':
         # check if the post request has the file part
         if 'file' not in request.files:
@@ -30,10 +30,14 @@ def mysterycheck():
             else:
                 results, _ = roll_options(options)
                 return render_template("checkResult.html", results=results)
-
     return render_template("check.html")
 
 
+@app.route('/mysterycheck')
+def mysterycheck():
+    return redirect(url_for("check"), 301)
+
+
 def get_yaml_data(file) -> Union[Dict[str, str], str]:
     options = {}
     # if user does not select file, browser also
@@ -49,9 +53,7 @@ def get_yaml_data(file) -> Union[Dict[str, str], str]:
                 for file in infolist:
                     if file.filename.endswith(banned_zip_contents):
                         return "Uploaded data contained a rom file, which is likely to contain copyrighted material. Your file was deleted."
-                    elif file.filename.endswith(".yaml"):
-                        options[file.filename] = zfile.open(file, "r").read()
-                    elif file.filename.endswith(".txt"):
+                    elif file.filename.endswith((".yaml", ".json", ".yml", ".txt")):
                         options[file.filename] = zfile.open(file, "r").read()
         else:
             options = {file.filename: file.read()}
@@ -60,20 +62,29 @@ def get_yaml_data(file) -> Union[Dict[str, str], str]:
     return options
 
 
-def roll_options(options: Dict[str, Union[dict, str]]) -> Tuple[Dict[str, Union[str, bool]], Dict[str, dict]]:
+def roll_options(options: Dict[str, Union[dict, str]],
+                 plando_options: Set[str] = frozenset({"bosses", "items", "connections", "texts"})) -> \
+        Tuple[Dict[str, Union[str, bool]], Dict[str, dict]]:
+    plando_options = PlandoSettings.from_set(set(plando_options))
     results = {}
     rolled_results = {}
     for filename, text in options.items():
         try:
             if type(text) is dict:
-                yaml_data = text
+                yaml_datas = (text, )
             else:
-                yaml_data = parse_yaml(text)
+                yaml_datas = tuple(parse_yamls(text))
         except Exception as e:
             results[filename] = f"Failed to parse YAML data in {filename}: {e}"
         else:
             try:
-                rolled_results[filename] = roll_settings(yaml_data, plando_options={"bosses"})
+                if len(yaml_datas) == 1:
+                    rolled_results[filename] = roll_settings(yaml_datas[0],
+                                                             plando_options=plando_options)
+                else:
+                    for i, yaml_data in enumerate(yaml_datas):
+                        rolled_results[f"{filename}/{i + 1}"] = roll_settings(yaml_data,
+                                                                              plando_options=plando_options)
             except Exception as e:
                 results[filename] = f"Failed to generate mystery in {filename}: {e}"
             else:

WebHostLib/customserver.py

@@ -1,8 +1,6 @@
 from __future__ import annotations
 
 import functools
-import logging
-import os
 import websockets
 import asyncio
 import socket
@@ -10,8 +8,9 @@ import threading
 import time
 import random
 import pickle
+import logging
 
-
+import Utils
 from .models import *
 
 from MultiServer import Context, server, auto_shutdown, ServerCommandProcessor, ClientMessageProcessor
@@ -20,6 +19,7 @@ from Utils import get_public_ipv4, get_public_ipv6, restricted_loads
 
 class CustomClientMessageProcessor(ClientMessageProcessor):
     ctx: WebHostContext
+
     def _cmd_video(self, platform, user):
         """Set a link for your name in the WebHostLib tracker pointing to a video stream"""
         if platform.lower().startswith("t"):  # twitch
@@ -37,6 +37,7 @@ class CustomClientMessageProcessor(ClientMessageProcessor):
 
 # inject
 import MultiServer
+
 MultiServer.client_message_processor = CustomClientMessageProcessor
 del (MultiServer)
 
@@ -48,7 +49,7 @@ class DBCommandProcessor(ServerCommandProcessor):
 
 class WebHostContext(Context):
     def __init__(self):
-        super(WebHostContext, self).__init__("", 0, "", "", 1, 40, True, "enabled", "enabled", 0, 2)
+        super(WebHostContext, self).__init__("", 0, "", "", 1, 40, True, "enabled", "enabled", "enabled", 0, 2)
         self.main_loop = asyncio.get_running_loop()
         self.video = {}
         self.tags = ["AP", "WebHost"]
@@ -56,7 +57,7 @@ class WebHostContext(Context):
     def listen_to_db_commands(self):
         cmdprocessor = DBCommandProcessor(self)
 
-        while self.running:
+        while not self.exit_event.is_set():
             with db_session:
                 commands = select(command for command in Command if command.room.id == self.room_id)
                 if commands:
@@ -75,7 +76,7 @@ class WebHostContext(Context):
         else:
             self.port = get_random_port()
 
-        return self._load(self._decompress(room.seed.multidata), True)
+        return self._load(self.decompress(room.seed.multidata), True)
 
     @db_session
     def init_save(self, enabled: bool = True):
@@ -88,11 +89,11 @@ class WebHostContext(Context):
         threading.Thread(target=self.listen_to_db_commands, daemon=True).start()
 
     @db_session
-    def _save(self, exit_save:bool = False) -> bool:
+    def _save(self, exit_save: bool = False) -> bool:
         room = Room.get(id=self.room_id)
         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
+        if not exit_save:  # we don't want to count a shutdown as activity, which would restart the server again
             room.last_activity = datetime.utcnow()
         return True
 
@@ -101,20 +102,18 @@ class WebHostContext(Context):
         d["video"] = [(tuple(playerslot), videodata) for playerslot, videodata in self.video.items()]
         return d
 
+
 def get_random_port():
     return random.randint(49152, 65535)
 
+
 def run_server_process(room_id, ponyconfig: dict):
     # establish DB connection for multidata and multisave
     db.bind(**ponyconfig)
     db.generate_mapping(check_tables=False)
 
     async def main():
-
-        logging.basicConfig(format='[%(asctime)s] %(message)s',
-                            level=logging.INFO,
-                            handlers=[
-                                logging.FileHandler(os.path.join(LOGS_FOLDER, f"{room_id}.txt"), 'a', 'utf-8-sig')])
+        Utils.init_logging(str(room_id), write_mode="a")
         ctx = WebHostContext()
         ctx.load(room_id)
         ctx.init_save()
@@ -129,22 +128,27 @@ def run_server_process(room_id, ponyconfig: dict):
                                           ping_interval=None)
 
             await ctx.server
+        port = 0
         for wssocket in ctx.server.ws_server.sockets:
             socketname = wssocket.getsockname()
             if wssocket.family == socket.AF_INET6:
                 logging.info(f'Hosting game at [{get_public_ipv6()}]:{socketname[1]}')
-                with db_session:
-                    room = Room.get(id=ctx.room_id)
-                    room.last_port = socketname[1]
+                # Prefer IPv4, as most users seem to not have working ipv6 support
+                if not port:
+                    port = socketname[1]
             elif wssocket.family == socket.AF_INET:
                 logging.info(f'Hosting game at {get_public_ipv4()}:{socketname[1]}')
+                port = socketname[1]
+        if port:
+            with db_session:
+                room = Room.get(id=ctx.room_id)
+                room.last_port = port
         with db_session:
             ctx.auto_shutdown = Room.get(id=room_id).timeout
         ctx.shutdown_task = asyncio.create_task(auto_shutdown(ctx, []))
         await ctx.shutdown_task
         logging.info("Shutting down")
 
-    asyncio.run(main())
-
-
-from WebHostLib import LOGS_FOLDER
+    from .autolauncher import Locker
+    with Locker(room_id):
+        asyncio.run(main())

WebHostLib/downloads.py

@@ -1,9 +1,13 @@
-from flask import send_file, Response
+import zipfile
+import json
+from io import BytesIO
+
+from flask import send_file, Response, render_template
 from pony.orm import select
 
-from Patch import update_patch_data
-from WebHostLib import app, Slot, Room, Seed
-import zipfile
+from Patch import update_patch_data, preferred_endings, AutoPatchRegister
+from WebHostLib import app, Slot, Room, Seed, cache
+
 
 @app.route("/dl_patch/<suuid:room_id>/<int:patch_id>")
 def download_patch(room_id, patch_id):
@@ -11,15 +15,34 @@ def download_patch(room_id, patch_id):
     if not patch:
         return "Patch not found"
     else:
-        import io
-
         room = Room.get(id=room_id)
         last_port = room.last_port
+        filelike = BytesIO(patch.data)
+        greater_than_version_3 = zipfile.is_zipfile(filelike)
+        if greater_than_version_3:
+            # Python's zipfile module cannot overwrite/delete files in a zip, so we recreate the whole thing in ram
+            new_file = BytesIO()
+            with zipfile.ZipFile(filelike, "a") as zf:
+                with zf.open("archipelago.json", "r") as f:
+                    manifest = json.load(f)
+                manifest["server"] = f"{app.config['PATCH_TARGET']}:{last_port}" if last_port else None
+                with zipfile.ZipFile(new_file, "w") as new_zip:
+                    for file in zf.infolist():
+                        if file.filename == "archipelago.json":
+                            new_zip.writestr("archipelago.json", json.dumps(manifest))
+                        else:
+                            new_zip.writestr(file.filename, zf.read(file), file.compress_type, 9)
 
-        patch_data = update_patch_data(patch.data, server=f"{app.config['PATCH_TARGET']}:{last_port}")
-        patch_data = io.BytesIO(patch_data)
+            fname = f"P{patch.player_id}_{patch.player_name}_{app.jinja_env.filters['suuid'](room_id)}" \
+                    f"{AutoPatchRegister.patch_types[patch.game].patch_file_ending}"
+            new_file.seek(0)
+            return send_file(new_file, as_attachment=True, attachment_filename=fname)
+        else:
+            patch_data = update_patch_data(patch.data, server=f"{app.config['PATCH_TARGET']}:{last_port}")
+            patch_data = BytesIO(patch_data)
 
-        fname = f"P{patch.player_id}_{patch.player_name}_{app.jinja_env.filters['suuid'](room_id)}.apbp"
+            fname = f"P{patch.player_id}_{patch.player_name}_{app.jinja_env.filters['suuid'](room_id)}." \
+                    f"{preferred_endings[patch.game]}"
         return send_file(patch_data, as_attachment=True, attachment_filename=fname)
 
 
@@ -28,28 +51,11 @@ def download_spoiler(seed_id):
     return Response(Seed.get(id=seed_id).spoiler, mimetype="text/plain")
 
 
-@app.route("/dl_raw_patch/<suuid:seed_id>/<int:player_id>")
-def download_raw_patch(seed_id, player_id: int):
-    seed = Seed.get(id=seed_id)
-    patch = select(patch for patch in seed.slots if
-                   patch.player_id == player_id).first()
-
-    if not patch:
-        return "Patch not found"
-    else:
-        import io
-
-        patch_data = update_patch_data(patch.data, server="")
-        patch_data = io.BytesIO(patch_data)
-
-        fname = f"P{patch.player_id}_{patch.player_name}_{app.jinja_env.filters['suuid'](seed_id)}.apbp"
-        return send_file(patch_data, as_attachment=True, attachment_filename=fname)
-
-@app.route("/slot_file/<suuid:seed_id>/<int:player_id>")
-def download_slot_file(seed_id, player_id: int):
-    seed = Seed.get(id=seed_id)
-    slot_data: Slot = select(patch for patch in seed.slots if
-                   patch.player_id == player_id).first()
+@app.route("/slot_file/<suuid:room_id>/<int:player_id>")
+def download_slot_file(room_id, player_id: int):
+    room = Room.get(id=room_id)
+    slot_data: Slot = select(patch for patch in room.seed.slots if
+                             patch.player_id == player_id).first()
 
     if not slot_data:
         return "Slot Data not found"
@@ -57,12 +63,34 @@ def download_slot_file(seed_id, player_id: int):
         import io
 
         if slot_data.game == "Minecraft":
-            fname = f"AP_{app.jinja_env.filters['suuid'](seed_id)}_P{slot_data.player_id}_{slot_data.player_name}.apmc"
+            from worlds.minecraft import mc_update_output
+            fname = f"AP_{app.jinja_env.filters['suuid'](room_id)}_P{slot_data.player_id}_{slot_data.player_name}.apmc"
+            data = mc_update_output(slot_data.data, server=app.config['PATCH_TARGET'], port=room.last_port)
+            return send_file(io.BytesIO(data), as_attachment=True, attachment_filename=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"):
-                        fname = name.rsplit("/", 1)[0]+".zip"
+                        fname = name.rsplit("/", 1)[0] + ".zip"
+        elif slot_data.game == "Ocarina of Time":
+            fname = f"AP_{app.jinja_env.filters['suuid'](room_id)}_P{slot_data.player_id}_{slot_data.player_name}.apz5"
+        elif slot_data.game == "VVVVVV":
+            fname = f"AP_{app.jinja_env.filters['suuid'](room_id)}_SP.apv6"
+        elif slot_data.game == "Super Mario 64":
+            fname = f"AP_{app.jinja_env.filters['suuid'](room_id)}_SP.apsm64ex"
+        elif slot_data.game == "Dark Souls III":
+            fname = f"AP_{app.jinja_env.filters['suuid'](room_id)}.json"
         else:
             return "Game download not supported."
-        return send_file(io.BytesIO(slot_data.data), as_attachment=True, attachment_filename=fname)
+        return send_file(io.BytesIO(slot_data.data), as_attachment=True, attachment_filename=fname)
+
+
+@app.route("/templates")
+@cache.cached()
+def list_yaml_templates():
+    files = []
+    from worlds.AutoWorld import AutoWorldRegister
+    for world_name, world in AutoWorldRegister.world_types.items():
+        if not world.hidden:
+            files.append(world_name)
+    return render_template("templates.html", files=files)

WebHostLib/generate.py

@@ -2,19 +2,43 @@ import os
 import tempfile
 import random
 import json
+import zipfile
 from collections import Counter
+from typing import Dict, Optional, Any
+from Utils import __version__
 
 from flask import request, flash, redirect, url_for, session, render_template
 
 from worlds.alttp.EntranceRandomizer import parse_arguments
 from Main import main as ERmain
-from Main import get_seed, seeddigits
-from Mystery import handle_name
+from BaseClasses import seeddigits, get_seed
+from Generate import handle_name, PlandoSettings
 import pickle
 
-from .models import *
+from .models import Generation, STATE_ERROR, STATE_QUEUED, commit, db_session, Seed, UUID
 from WebHostLib import app
 from .check import get_yaml_data, roll_options
+from .upload import upload_zip_to_db
+
+
+def get_meta(options_source: dict) -> dict:
+    plando_options = {
+        options_source.get("plando_bosses", ""),
+        options_source.get("plando_items", ""),
+        options_source.get("plando_connections", ""),
+        options_source.get("plando_texts", "")
+    }
+    plando_options -= {""}
+
+    server_options = {
+        "hint_cost": int(options_source.get("hint_cost", 10)),
+        "forfeit_mode": options_source.get("forfeit_mode", "goal"),
+        "remaining_mode": options_source.get("remaining_mode", "disabled"),
+        "collect_mode": options_source.get("collect_mode", "disabled"),
+        "item_cheat": bool(int(options_source.get("item_cheat", 1))),
+        "server_password": options_source.get("server_password", None),
+    }
+    return {"server_options": server_options, "plando_options": list(plando_options)}
 
 
 @app.route('/generate', methods=['GET', 'POST'])
@@ -30,17 +54,25 @@ def generate(race=False):
             if type(options) == str:
                 flash(options)
             else:
-                results, gen_options = roll_options(options)
+                meta = get_meta(request.form)
+                meta["race"] = race
+                results, gen_options = roll_options(options, meta["plando_options"])
+
+                if race:
+                    meta["server_options"]["item_cheat"] = False
+                    meta["server_options"]["remaining_mode"] = "disabled"
+
                 if any(type(result) == str for result in results.values()):
                     return render_template("checkResult.html", results=results)
                 elif len(gen_options) > app.config["MAX_ROLL"]:
-                    flash(f"Sorry, generating of multiworlds is limited to {app.config['MAX_ROLL']} players for now. "
+                    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({"race": race}), state=STATE_QUEUED,
+                        meta=json.dumps(meta),
+                        state=STATE_QUEUED,
                         owner=session["_id"])
                     commit()
 
@@ -48,55 +80,64 @@ def generate(race=False):
                 else:
                     try:
                         seed_id = gen_game({name: vars(options) for name, options in gen_options.items()},
-                                           race=race, owner=session["_id"].int)
+                                           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 render_template("seedError.html", seed_error=(e.__class__.__name__ + ": " + str(e)))
 
-                    return redirect(url_for("viewSeed", seed=seed_id))
+                    return redirect(url_for("view_seed", seed=seed_id))
 
-    return render_template("generate.html", race=race)
+    return render_template("generate.html", race=race, version=__version__)
 
 
-def gen_game(gen_options, race=False, owner=None, sid=None):
+def gen_game(gen_options, meta: Optional[Dict[str, Any]] = None, owner=None, sid=None):
+    if not meta:
+        meta: Dict[str, Any] = {}
+
+    meta.setdefault("server_options", {}).setdefault("hint_cost", 10)
+    race = meta.setdefault("race", False)
+
     try:
         target = tempfile.TemporaryDirectory()
         playercount = len(gen_options)
         seed = get_seed()
-        random.seed(seed)
 
         if race:
-            random.seed()  # reset to time-based random source
+            random.seed()  # use time-based random source
+        else:
+            random.seed(seed)
 
-        seedname = "M" + (f"{random.randint(0, pow(10, seeddigits) - 1)}".zfill(seeddigits))
+        seedname = "W" + (f"{random.randint(0, pow(10, seeddigits) - 1)}".zfill(seeddigits))
 
         erargs = parse_arguments(['--multi', str(playercount)])
         erargs.seed = seed
-        erargs.name = {x: "" for x in range(1, playercount + 1)}  # only so it can be overwrittin in mystery
-        erargs.create_spoiler = not race
+        erargs.name = {x: "" for x in range(1, playercount + 1)}  # only so it can be overwritten in mystery
+        erargs.spoiler = 0 if race else 2
         erargs.race = race
-        erargs.skip_playthrough = race
         erargs.outputname = seedname
         erargs.outputpath = target.name
         erargs.teams = 1
-        erargs.create_diff = True
+        erargs.plando_options = PlandoSettings.from_set(meta.setdefault("plando_options",
+                                                                        {"bosses", "items", "connections", "texts"}))
 
         name_counter = Counter()
         for player, (playerfile, settings) in enumerate(gen_options.items(), 1):
             for k, v in settings.items():
                 if v is not None:
-                    getattr(erargs, k)[player] = v
+                    if hasattr(erargs, k):
+                        getattr(erargs, k)[player] = v
+                    else:
+                        setattr(erargs, k, {player: v})
 
             if not erargs.name[player]:
                 erargs.name[player] = os.path.splitext(os.path.split(playerfile)[-1])[0]
             erargs.name[player] = handle_name(erargs.name[player], player, name_counter)
+        if len(set(erargs.name.values())) != len(erargs.name):
+            raise Exception(f"Names have to be unique. Names: {Counter(erargs.name.values())}")
+        ERmain(erargs, seed, baked_server_options=meta["server_options"])
 
-        erargs.names = ",".join(erargs.name[i] for i in range(1, playercount + 1))
-        del (erargs.name)
-        ERmain(erargs, seed)
-
-        return upload_to_db(target.name, owner, sid, race)
+        return upload_to_db(target.name, sid, owner, race)
     except BaseException as e:
         if sid:
             with db_session:
@@ -104,9 +145,8 @@ def gen_game(gen_options, race=False, owner=None, sid=None):
                 if gen is not None:
                     gen.state = STATE_ERROR
                     meta = json.loads(gen.meta)
-                    meta["error"] = (e.__class__.__name__ + ": "+ str(e))
+                    meta["error"] = (e.__class__.__name__ + ": " + str(e))
                     gen.meta = json.dumps(meta)
-
                     commit()
         raise
 
@@ -116,7 +156,7 @@ def wait_seed(seed: UUID):
     seed_id = seed
     seed = Seed.get(id=seed_id)
     if seed:
-        return redirect(url_for("viewSeed", seed=seed_id))
+        return redirect(url_for("view_seed", seed=seed_id))
     generation = Generation.get(id=seed_id)
 
     if not generation:
@@ -126,37 +166,19 @@ def wait_seed(seed: UUID):
     return render_template("waitSeed.html", seed_id=seed_id)
 
 
-def upload_to_db(folder, owner, sid, race:bool):
-    slots = set()
-    spoiler = ""
-
-    multidata = None
+def upload_to_db(folder, sid, owner, race):
     for file in os.listdir(folder):
         file = os.path.join(folder, file)
-        if file.endswith(".apbp"):
-            player_text = file.split("_P", 1)[1]
-            player_name = player_text.split("_", 1)[1].split(".", 1)[0]
-            player_id = int(player_text.split(".", 1)[0].split("_", 1)[0])
-            slots.add(Slot(data=open(file, "rb").read(),
-                             player_id=player_id, player_name = player_name, game = "A Link to the Past"))
-        elif file.endswith(".txt"):
-            spoiler = open(file, "rt", encoding="utf-8-sig").read()
-        elif file.endswith(".archipelago"):
-            multidata = open(file, "rb").read()
-    if multidata:
-        with db_session:
-            if sid:
-                seed = Seed(multidata=multidata, spoiler=spoiler, slots=slots, owner=owner,
-                            id=sid, meta=json.dumps({"race": race, "tags": ["generated"]}))
-            else:
-                seed = Seed(multidata=multidata, spoiler=spoiler, slots=slots, owner=owner,
-                            meta=json.dumps({"race": race, "tags": ["generated"]}))
-            for patch in slots:
-                patch.seed = seed
-            if sid:
-                gen = Generation.get(id=sid)
-                if gen is not None:
-                    gen.delete()
-        return seed.id
-    else:
-        raise Exception("Multidata required (.archipelago), but not found.")
+        if file.endswith(".zip"):
+            with db_session:
+                with zipfile.ZipFile(file) as zfile:
+                    res = upload_zip_to_db(zfile, owner, {"race": race}, sid)
+                if type(res) == "str":
+                    raise Exception(res)
+                elif res:
+                    seed = res
+                    gen = Generation.get(id=seed.id)
+                    if gen is not None:
+                        gen.delete()
+                    return seed.id
+    raise Exception("Generation zipfile not found.")

WebHostLib/lttpsprites.py

@@ -0,0 +1,50 @@
+import os
+import threading
+import json
+
+from Utils import local_path, user_path
+from worlds.alttp.Rom import Sprite
+
+
+def update_sprites_lttp():
+    from tkinter import Tk
+    from LttPAdjuster import get_image_for_sprite
+    from LttPAdjuster import BackgroundTaskProgress
+    from LttPAdjuster import BackgroundTaskProgressNullWindow
+    from LttPAdjuster import update_sprites
+
+    # Target directories
+    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)
+    # update sprites through gui.py's functions
+    done = threading.Event()
+    try:
+        top = Tk()
+    except:
+        task = BackgroundTaskProgressNullWindow(update_sprites, lambda successful, resultmessage: done.set())
+    else:
+        top.withdraw()
+        task = BackgroundTaskProgress(top, update_sprites, "Updating Sprites", lambda succesful, resultmessage: done.set())
+    while not done.isSet():
+        task.do_events()
+
+    spriteData = []
+
+    for file in os.listdir(input_dir):
+        sprite = Sprite(os.path.join(input_dir, file))
+
+        if not sprite.name:
+            print("Warning:", file, "has no name.")
+            sprite.name = file.split(".", 1)[0]
+        if sprite.valid:
+            with open(os.path.join(output_dir, "sprites", f"{os.path.splitext(file)[0]}.gif"), 'wb') as image:
+                image.write(get_image_for_sprite(sprite, True))
+            spriteData.append({"file": file, "author": sprite.author_name, "name": sprite.name})
+        else:
+            print(file, "dropped, as it has no valid sprite data.")
+    spriteData.sort(key=lambda entry: entry["name"])
+    with open(f'{output_dir}/spriteData.json', 'w') as file:
+        json.dump({"sprites": spriteData}, file, indent=1)
+    return spriteData

WebHostLib/models.py

@@ -12,7 +12,7 @@ STATE_ERROR = -1
 class Slot(db.Entity):
     id = PrimaryKey(int, auto=True)
     player_id = Required(int)
-    player_name = Required(str, 16)
+    player_name = Required(str)
     data = Optional(bytes, lazy=True)
     seed = Optional('Seed')
     game = Required(str)
@@ -27,7 +27,7 @@ class Room(db.Entity):
     seed = Required('Seed', index=True)
     multisave = Optional(buffer, lazy=True)
     show_spoiler = Required(int, default=0)  # 0 -> never, 1 -> after completion, -> 2 always
-    timeout = Required(int, default=lambda: 6 * 60 * 60)  # seconds since last activity to shutdown
+    timeout = Required(int, default=lambda: 2 * 60 * 60)  # seconds since last activity to shutdown
     tracker = Optional(UUID, index=True)
     last_port = Optional(int, default=lambda: 0)
 
@@ -40,7 +40,7 @@ class Seed(db.Entity):
     creation_time = Required(datetime, default=lambda: datetime.utcnow())
     slots = Set(Slot)
     spoiler = Optional(LongStr, lazy=True)
-    meta = Required(str, default=lambda: "{\"race\": false}")  # additional meta information/tags
+    meta = Required(LongStr, default=lambda: "{\"race\": false}")  # additional meta information/tags
 
 
 class Command(db.Entity):
@@ -53,5 +53,5 @@ class Generation(db.Entity):
     id = PrimaryKey(UUID, default=uuid4)
     owner = Required(UUID)
     options = Required(buffer, lazy=True)
-    meta = Required(str, default=lambda: "{\"race\": false}")
+    meta = Required(LongStr, default=lambda: "{\"race\": false}")
     state = Required(int, default=0, index=True)

WebHostLib/options.py

@@ -0,0 +1,171 @@
+import logging
+import os
+from Utils import __version__
+from jinja2 import Template
+import yaml
+import json
+import typing
+
+from worlds.AutoWorld import AutoWorldRegister
+import Options
+
+target_folder = os.path.join("WebHostLib", "static", "generated")
+
+handled_in_js = {"start_inventory", "local_items", "non_local_items", "start_hints", "start_location_hints",
+                 "exclude_locations"}
+
+
+def create():
+    os.makedirs(os.path.join(target_folder, 'configs'), exist_ok=True)
+
+    def dictify_range(option: typing.Union[Options.Range, Options.SpecialRange]):
+        data = {}
+        special = getattr(option, "special_range_cutoff", None)
+        if special is not None:
+            data[special] = 0
+        data.update({
+            option.range_start: 0,
+            option.range_end: 0,
+            "random": 0, "random-low": 0, "random-high": 0,
+            option.default: 50
+        })
+        notes = {
+            special: "minimum value without special meaning",
+            option.range_start: "minimum value",
+            option.range_end: "maximum value"
+        }
+
+        for name, number in getattr(option, "special_range_names", {}).items():
+            if number in data:
+                data[name] = data[number]
+                del data[number]
+            else:
+                data[name] = 0
+
+        return data, notes
+
+    def default_converter(default_value):
+        if isinstance(default_value, (set, frozenset)):
+            return list(default_value)
+        return default_value
+
+    weighted_settings = {
+        "baseOptions": {
+            "description": "Generated by https://archipelago.gg/",
+            "name": "Player",
+            "game": {},
+        },
+        "games": {},
+    }
+
+    for game_name, world in AutoWorldRegister.world_types.items():
+
+        all_options = {**Options.per_game_common_options, **world.options}
+        res = Template(open(os.path.join("WebHostLib", "templates", "options.yaml")).read()).render(
+            options=all_options,
+            __version__=__version__, game=game_name, yaml_dump=yaml.dump,
+            dictify_range=dictify_range, default_converter=default_converter,
+        )
+
+        with open(os.path.join(target_folder, 'configs', game_name + ".yaml"), "w") as f:
+            f.write(res)
+
+        # Generate JSON files for player-settings pages
+        player_settings = {
+            "baseOptions": {
+                "description": "Generated by https://archipelago.gg/",
+                "game": game_name,
+                "name": "Player",
+            },
+        }
+
+        game_options = {}
+        for option_name, option in all_options.items():
+            if option_name in handled_in_js:
+                pass
+
+            elif option.options:
+                game_options[option_name] = this_option = {
+                    "type": "select",
+                    "displayName": option.display_name if hasattr(option, "display_name") else option_name,
+                    "description": option.__doc__ if option.__doc__ else "Please document me!",
+                    "defaultValue": None,
+                    "options": []
+                }
+
+                for sub_option_id, sub_option_name in option.name_lookup.items():
+                    this_option["options"].append({
+                        "name": option.get_option_name(sub_option_id),
+                        "value": sub_option_name,
+                    })
+
+                    if sub_option_id == option.default:
+                        this_option["defaultValue"] = sub_option_name
+
+                this_option["options"].append({
+                    "name": "Random",
+                    "value": "random",
+                })
+
+                if option.default == "random":
+                    this_option["defaultValue"] = "random"
+
+            elif hasattr(option, "range_start") and hasattr(option, "range_end"):
+                game_options[option_name] = {
+                    "type": "range",
+                    "displayName": option.display_name if hasattr(option, "display_name") else option_name,
+                    "description": option.__doc__ if option.__doc__ else "Please document me!",
+                    "defaultValue": option.default if hasattr(
+                        option, "default") and option.default != "random" else option.range_start,
+                    "min": option.range_start,
+                    "max": option.range_end,
+                }
+
+                if hasattr(option, "special_range_names"):
+                    game_options[option_name]["type"] = 'special_range'
+                    game_options[option_name]["value_names"] = {}
+                    for key, val in option.special_range_names.items():
+                        game_options[option_name]["value_names"][key] = val
+
+            elif getattr(option, "verify_item_name", False):
+                game_options[option_name] = {
+                    "type": "items-list",
+                    "displayName": option.display_name if hasattr(option, "display_name") else option_name,
+                    "description": option.__doc__ if option.__doc__ else "Please document me!",
+                }
+
+            elif getattr(option, "verify_location_name", False):
+                game_options[option_name] = {
+                    "type": "locations-list",
+                    "displayName": option.display_name if hasattr(option, "display_name") else option_name,
+                    "description": option.__doc__ if option.__doc__ else "Please document me!",
+                }
+
+            elif hasattr(option, "valid_keys"):
+                if option.valid_keys:
+                    game_options[option_name] = {
+                        "type": "custom-list",
+                        "displayName": option.display_name if hasattr(option, "display_name") else option_name,
+                        "description": option.__doc__ if option.__doc__ else "Please document me!",
+                        "options": list(option.valid_keys),
+                    }
+
+            else:
+                logging.debug(f"{option} not exported to Web Settings.")
+
+        player_settings["gameOptions"] = game_options
+
+        os.makedirs(os.path.join(target_folder, 'player-settings'), exist_ok=True)
+
+        with open(os.path.join(target_folder, 'player-settings', game_name + ".json"), "w") as f:
+            json.dump(player_settings, f, indent=2, separators=(',', ': '))
+
+        if not world.hidden and world.web.settings_page is True:
+            weighted_settings["baseOptions"]["game"][game_name] = 0
+            weighted_settings["games"][game_name] = {}
+            weighted_settings["games"][game_name]["gameSettings"] = game_options
+            weighted_settings["games"][game_name]["gameItems"] = tuple(world.item_names)
+            weighted_settings["games"][game_name]["gameLocations"] = tuple(world.location_names)
+
+    with open(os.path.join(target_folder, 'weighted-settings.json'), "w") as f:
+        json.dump(weighted_settings, f, indent=2, separators=(',', ': '))

WebHostLib/requirements.txt

@@ -1,6 +1,7 @@
-flask>=2.0.1
-pony>=0.7.14
-waitress>=2.0.0
-flask-caching>=1.10.1
-Flask-Compress>=1.9.0
-Flask-Limiter>=1.4
+flask>=2.1.3
+pony>=0.7.16
+waitress>=2.1.1
+Flask-Caching>=2.0.1
+Flask-Compress>=1.12
+Flask-Limiter>=2.5.0
+bokeh>=2.4.3

WebHostLib/static/assets/faq.js

@@ -0,0 +1,53 @@
+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
+        const headers = Array.from(document.querySelectorAll('h1, h2, h3, h4, h5, h6'));
+        const scrollTargetIndex = window.location.href.search(/#[A-z0-9-_]*$/);
+        for (let i=0; i < headers.length; i++){
+            const headerId = headers[i].innerText.replace(/[ ]/g,'-').toLowerCase()
+            headers[i].setAttribute('id', headerId);
+            headers[i].addEventListener('click', () =>
+                window.location.href = window.location.href.substring(0, scrollTargetIndex) + `#${headerId}`);
+        }
+
+        // Manually scroll the user to the appropriate header if anchor navigation is used
+        if (scrollTargetIndex > -1) {
+            try{
+                const scrollTarget = window.location.href.substring(scrollTargetIndex + 1);
+                document.getElementById(scrollTarget).scrollIntoView({ behavior: "smooth" });
+            } catch(error) {
+                console.error(error);
+            }
+        }
+    }).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

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

WebHostLib/static/assets/faq/glossary_en.md

@@ -0,0 +1,94 @@
+# Multiworld Glossary
+
+There are a lot of common terms used when playing in different game randomizer communities and in multiworld as well.
+This document serves as a lookup for common terms that may be used by users in the community or in various other
+documentation.
+
+## Item
+Items are what get shuffled around in your world or other worlds that you then receive. This could be a sword, a stat 
+upgrade, a spell, or any other potential receivable for your game.
+
+## Location
+Locations are where items are placed in your game. Whenever you interact with a location, you or another player will
+then receive an item. A location could be a chest, an enemy drop, a shop purchase, or any other interactable that can
+contain items in your game.
+
+## Check
+A check is a common term for when you "check", or pick up, a location. In terms of Archipelago this is usually used for
+when a player goes to a location and sends its item, or "checks" the location. Players will often reference their now
+randomized locations as checks.
+
+## Slot
+A slot is the player name and number assigned during generation. The number of slots is equal to the number of players,
+or "worlds", created. Each name must be unique as these are used to identify the slot user.
+
+## World
+World in terms of Archipelago can mean multiple things and is used interchangeably in many situations.
+* During gameplay, a world is a single instance of a game, occupying one player "slot". However, 
+Archipelago allows multiple players to connect to the same slot; then those players can share a world 
+and complete it cooperatively. For games with native cooperative play, you can also play together and
+share a world that way, usually with only one player connected to the multiworld.
+* On the programming side, a world typically represents the package that integrates Archipelago with a
+particular game. For example this could be the entire `worlds/factorio` directory.
+
+## RNG
+Acronym for "Random Number Generator." Archipelago uses its own custom Random object with a unique seed per generation,
+or, if running from source, a seed can be supplied and this seed will control all randomization during generation as all
+game worlds will have access to it.
+
+## Seed
+A "seed" is a number used to initialize a pseudorandom number generator. Whenever you generate a new game on Archipelago
+this is a new "seed" as it has unique item placement, and you can create multiple "rooms" on the Archipelago site from a
+single seed. Using the same seed results in the random placement being the same.
+
+## Room
+Whenever you generate a seed on the Archipelago website you will be put on a seed page that contains all the seed info
+with a link to the spoiler if one exists and will show how many unique rooms exist per seed. Each room has its own 
+unique identifier that is separate from the seed. The room page is where you can find information to connect to the
+multiworld and download any patches if necessary. If you have a particularly fun or interesting seed, and you want to 
+share it with somebody you can link them to this seed page, where they can generate a new room to play it! For seeds 
+generated with race mode enabled, the seed page will only show rooms created by the unique user so the seed page is 
+perfectly safe to share for racing purposes.
+
+## Logic
+Base behavior of all seeds generated by Archipelago is they are expected to be completable based on the requirements of
+the settings. This is done by using "logic" in order to determine valid locations to place items while still being able
+to reach said location without this item. For the purposes of the randomizer a location is considered "in logic" if you 
+can reach it with your current toolset of items or skills based on settings. Some players are able to obtain locations
+"out of logic" by performing various glitches or tricks that the settings may not account for and tend to mention this
+when sending out an item they obtained this way.
+
+## Progression
+Certain items will allow access to more locations and are considered progression items as they "progress" the seed.
+
+## Trash
+A term used for "filler" items that have no bearing on the generation and are either marginally useful for the player
+or useless. These items can be very useful depending on the player but are never very important and as such are usually
+termed trash.
+
+## Burger King / BK Mode
+A term used in multiworlds when a player is unable to continue to progress and is awaiting an item. The term came to be 
+after a player, allegedly, was unable to progress during a multiworld and went to Burger King while waiting to receive
+items from other players.
+
+* "Logical BK" is when the player is unable to progress according to the settings of their game but may still be able to do
+things that would be "out of logic" by the generation.
+
+* "Hard / full BK" is when the player is completely unable to progress even with tricks they may know and are unable to
+continue to play, aside from doing something like killing enemies for experience or money.
+
+## Sphere
+Archipelago calculates the game playthrough by using a "sphere" system where it has a state for each player and checks
+to see what the players are able to reach with their current items. Any location that is reachable with the current
+state of items is a "sphere." For the purposes of Archipelago it starts playthrough calculation by distributing sphere 0
+items which are items that are either forced in the player's inventory by the game or placed in the `start_inventory` in
+their settings. Sphere 1 is then all accessible locations the players can reach with all the items they received from
+sphere 0, or their starting inventory. The playthrough continues in this fashion calculating a number of spheres until
+all players have completed their goal.
+
+## Scouts / Scouting
+In some games there are locations that have visible items even if the item itself is unobtainable at the current time.
+Some games utilize a scouting feature where when the player "sees" the item it will give a free hint for the item in the
+client letting the players know what the exact item is, since if the item was for that game it would know but the item
+being foreign is a lot harder to represent visually.
+

WebHostLib/static/assets/gameInfo.js

@@ -0,0 +1,53 @@
+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
+        const headers = Array.from(document.querySelectorAll('h1, h2, h3, h4, h5, h6'));
+        const scrollTargetIndex = window.location.href.search(/#[A-z0-9-_]*$/);
+        for (let i=0; i < headers.length; i++){
+            const headerId = headers[i].innerText.replace(/[ ]/g,'-').toLowerCase()
+            headers[i].setAttribute('id', headerId);
+            headers[i].addEventListener('click', () =>
+                window.location.href = window.location.href.substring(0, scrollTargetIndex) + `#${headerId}`);
+        }
+
+        // Manually scroll the user to the appropriate header if anchor navigation is used
+        if (scrollTargetIndex > -1) {
+            try{
+                const scrollTarget = window.location.href.substring(scrollTargetIndex + 1);
+                document.getElementById(scrollTarget).scrollIntoView({ behavior: "smooth" });
+            } catch(error) {
+                console.error(error);
+            }
+        }
+    }).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,53 @@
+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
+        const headers = Array.from(document.querySelectorAll('h1, h2, h3, h4, h5, h6'));
+        const scrollTargetIndex = window.location.href.search(/#[A-z0-9-_]*$/);
+        for (let i=0; i < headers.length; i++){
+            const headerId = headers[i].innerText.replace(/[ ]/g,'-').toLowerCase()
+            headers[i].setAttribute('id', headerId);
+            headers[i].addEventListener('click', () =>
+                window.location.href = window.location.href.substring(0, scrollTargetIndex) + `#${headerId}`);
+        }
+
+        // Manually scroll the user to the appropriate header if anchor navigation is used
+        if (scrollTargetIndex > -1) {
+            try{
+                const scrollTarget = window.location.href.substring(scrollTargetIndex + 1);
+                document.getElementById(scrollTarget).scrollIntoView({ behavior: "smooth" });
+            } catch(error) {
+                console.error(error);
+            }
+        }
+    }).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/md5.min.js

@@ -0,0 +1,2 @@
+// Copyright © 2011 Sebastian Tschan, https://blueimp.net
+!function(n){"use strict";function d(n,t){var r=(65535&n)+(65535&t);return(n>>16)+(t>>16)+(r>>16)<<16|65535&r}function f(n,t,r,e,o,u){return d((c=d(d(t,n),d(e,u)))<<(f=o)|c>>>32-f,r);var c,f}function l(n,t,r,e,o,u,c){return f(t&r|~t&e,n,t,o,u,c)}function v(n,t,r,e,o,u,c){return f(t&e|r&~e,n,t,o,u,c)}function g(n,t,r,e,o,u,c){return f(t^r^e,n,t,o,u,c)}function m(n,t,r,e,o,u,c){return f(r^(t|~e),n,t,o,u,c)}function i(n,t){var r,e,o,u;n[t>>5]|=128<<t%32,n[14+(t+64>>>9<<4)]=t;for(var c=1732584193,f=-271733879,i=-1732584194,a=271733878,h=0;h<n.length;h+=16)c=l(r=c,e=f,o=i,u=a,n[h],7,-680876936),a=l(a,c,f,i,n[h+1],12,-389564586),i=l(i,a,c,f,n[h+2],17,606105819),f=l(f,i,a,c,n[h+3],22,-1044525330),c=l(c,f,i,a,n[h+4],7,-176418897),a=l(a,c,f,i,n[h+5],12,1200080426),i=l(i,a,c,f,n[h+6],17,-1473231341),f=l(f,i,a,c,n[h+7],22,-45705983),c=l(c,f,i,a,n[h+8],7,1770035416),a=l(a,c,f,i,n[h+9],12,-1958414417),i=l(i,a,c,f,n[h+10],17,-42063),f=l(f,i,a,c,n[h+11],22,-1990404162),c=l(c,f,i,a,n[h+12],7,1804603682),a=l(a,c,f,i,n[h+13],12,-40341101),i=l(i,a,c,f,n[h+14],17,-1502002290),c=v(c,f=l(f,i,a,c,n[h+15],22,1236535329),i,a,n[h+1],5,-165796510),a=v(a,c,f,i,n[h+6],9,-1069501632),i=v(i,a,c,f,n[h+11],14,643717713),f=v(f,i,a,c,n[h],20,-373897302),c=v(c,f,i,a,n[h+5],5,-701558691),a=v(a,c,f,i,n[h+10],9,38016083),i=v(i,a,c,f,n[h+15],14,-660478335),f=v(f,i,a,c,n[h+4],20,-405537848),c=v(c,f,i,a,n[h+9],5,568446438),a=v(a,c,f,i,n[h+14],9,-1019803690),i=v(i,a,c,f,n[h+3],14,-187363961),f=v(f,i,a,c,n[h+8],20,1163531501),c=v(c,f,i,a,n[h+13],5,-1444681467),a=v(a,c,f,i,n[h+2],9,-51403784),i=v(i,a,c,f,n[h+7],14,1735328473),c=g(c,f=v(f,i,a,c,n[h+12],20,-1926607734),i,a,n[h+5],4,-378558),a=g(a,c,f,i,n[h+8],11,-2022574463),i=g(i,a,c,f,n[h+11],16,1839030562),f=g(f,i,a,c,n[h+14],23,-35309556),c=g(c,f,i,a,n[h+1],4,-1530992060),a=g(a,c,f,i,n[h+4],11,1272893353),i=g(i,a,c,f,n[h+7],16,-155497632),f=g(f,i,a,c,n[h+10],23,-1094730640),c=g(c,f,i,a,n[h+13],4,681279174),a=g(a,c,f,i,n[h],11,-358537222),i=g(i,a,c,f,n[h+3],16,-722521979),f=g(f,i,a,c,n[h+6],23,76029189),c=g(c,f,i,a,n[h+9],4,-640364487),a=g(a,c,f,i,n[h+12],11,-421815835),i=g(i,a,c,f,n[h+15],16,530742520),c=m(c,f=g(f,i,a,c,n[h+2],23,-995338651),i,a,n[h],6,-198630844),a=m(a,c,f,i,n[h+7],10,1126891415),i=m(i,a,c,f,n[h+14],15,-1416354905),f=m(f,i,a,c,n[h+5],21,-57434055),c=m(c,f,i,a,n[h+12],6,1700485571),a=m(a,c,f,i,n[h+3],10,-1894986606),i=m(i,a,c,f,n[h+10],15,-1051523),f=m(f,i,a,c,n[h+1],21,-2054922799),c=m(c,f,i,a,n[h+8],6,1873313359),a=m(a,c,f,i,n[h+15],10,-30611744),i=m(i,a,c,f,n[h+6],15,-1560198380),f=m(f,i,a,c,n[h+13],21,1309151649),c=m(c,f,i,a,n[h+4],6,-145523070),a=m(a,c,f,i,n[h+11],10,-1120210379),i=m(i,a,c,f,n[h+2],15,718787259),f=m(f,i,a,c,n[h+9],21,-343485551),c=d(c,r),f=d(f,e),i=d(i,o),a=d(a,u);return[c,f,i,a]}function a(n){for(var t="",r=32*n.length,e=0;e<r;e+=8)t+=String.fromCharCode(n[e>>5]>>>e%32&255);return t}function h(n){var t=[];for(t[(n.length>>2)-1]=void 0,e=0;e<t.length;e+=1)t[e]=0;for(var r=8*n.length,e=0;e<r;e+=8)t[e>>5]|=(255&n.charCodeAt(e/8))<<e%32;return t}function e(n){for(var t,r="0123456789abcdef",e="",o=0;o<n.length;o+=1)t=n.charCodeAt(o),e+=r.charAt(t>>>4&15)+r.charAt(15&t);return e}function r(n){return unescape(encodeURIComponent(n))}function o(n){return a(i(h(t=r(n)),8*t.length));var t}function u(n,t){return function(n,t){var r,e,o=h(n),u=[],c=[];for(u[15]=c[15]=void 0,16<o.length&&(o=i(o,8*n.length)),r=0;r<16;r+=1)u[r]=909522486^o[r],c[r]=1549556828^o[r];return e=i(u.concat(h(t)),512+8*t.length),a(i(c.concat(e),640))}(r(n),r(t))}function t(n,t,r){return t?r?u(t,n):e(u(t,n)):r?o(n):e(o(n))}"function"==typeof define&&define.amd?define(function(){return t}):"object"==typeof module&&module.exports?module.exports=t:n.md5=t}(this);

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/ootTracker.js

@@ -0,0 +1,52 @@
+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, small keys, and boss keys in the location-table
+      const types = ['counter', 'smallkeys', 'bosskeys'];
+      for (let j = 0; j < types.length; j++) {
+        let counters = document.getElementsByClassName(types[j]);
+        const fakeCounters = fakeDOM.getElementsByClassName(types[j]);
+        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/player-settings.js

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

WebHostLib/static/assets/playerSettings.js

@@ -1,194 +0,0 @@
-window.addEventListener('load', () => {
-  Promise.all([fetchSettingData(), fetchSpriteData()]).then((results) => {
-    // Page setup
-    createDefaultSettings(results[0]);
-    buildUI(results[0]);
-    adjustHeaderWidth();
-
-    // Event listeners
-    document.getElementById('export-settings').addEventListener('click', () => exportSettings());
-    document.getElementById('generate-race').addEventListener('click', () => generateGame(true))
-    document.getElementById('generate-game').addEventListener('click', () => generateGame());
-
-    // Name input field
-    const playerSettings = JSON.parse(localStorage.getItem('playerSettings'));
-    const nameInput = document.getElementById('player-name');
-    nameInput.addEventListener('keyup', (event) => updateSetting(event));
-    nameInput.value = playerSettings.name;
-
-    // Sprite options
-    const spriteData = JSON.parse(results[1]);
-    const spriteSelect = document.getElementById('sprite');
-    spriteData.sprites.forEach((sprite) => {
-      if (sprite.name.trim().length === 0) { return; }
-      const option = document.createElement('option');
-      option.setAttribute('value', sprite.name.trim());
-      if (playerSettings.rom.sprite === sprite.name.trim()) { option.selected = true; }
-      option.innerText = sprite.name;
-      spriteSelect.appendChild(option);
-    });
-  }).catch((error) => {
-    console.error(error);
-  })
-});
-
-const fetchSettingData = () => new Promise((resolve, reject) => {
-  const ajax = new XMLHttpRequest();
-  ajax.onreadystatechange = () => {
-    if (ajax.readyState !== 4) { return; }
-    if (ajax.status !== 200) {
-      reject(ajax.responseText);
-      return;
-    }
-    try{ resolve(JSON.parse(ajax.responseText)); }
-    catch(error){ reject(error); }
-  };
-  ajax.open('GET', `${window.location.origin}/static/static/playerSettings.json`, true);
-  ajax.send();
-});
-
-const createDefaultSettings = (settingData) => {
-  if (!localStorage.getItem('playerSettings')) {
-    const newSettings = {};
-    for (let roSetting of Object.keys(settingData.readOnly)){
-      newSettings[roSetting] = settingData.readOnly[roSetting];
-    }
-    for (let generalOption of Object.keys(settingData.generalOptions)){
-      newSettings[generalOption] = settingData.generalOptions[generalOption];
-    }
-    for (let gameOption of Object.keys(settingData.gameOptions)){
-      newSettings[gameOption] = settingData.gameOptions[gameOption].defaultValue;
-    }
-    newSettings.rom = {};
-    for (let romOption of Object.keys(settingData.romOptions)){
-      newSettings.rom[romOption] = settingData.romOptions[romOption].defaultValue;
-    }
-    localStorage.setItem('playerSettings', JSON.stringify(newSettings));
-  }
-};
-
-const buildUI = (settingData) => {
-  // Game Options
-  const leftGameOpts = {};
-  const rightGameOpts = {};
-  Object.keys(settingData.gameOptions).forEach((key, index) => {
-    if (index < Object.keys(settingData.gameOptions).length / 2) { leftGameOpts[key] = settingData.gameOptions[key]; }
-    else { rightGameOpts[key] = settingData.gameOptions[key]; }
-  });
-  document.getElementById('game-options-left').appendChild(buildOptionsTable(leftGameOpts));
-  document.getElementById('game-options-right').appendChild(buildOptionsTable(rightGameOpts));
-
-  // ROM Options
-  const leftRomOpts = {};
-  const rightRomOpts = {};
-  Object.keys(settingData.romOptions).forEach((key, index) => {
-    if (index < Object.keys(settingData.romOptions).length / 2) { leftRomOpts[key] = settingData.romOptions[key]; }
-    else { rightRomOpts[key] = settingData.romOptions[key]; }
-  });
-  document.getElementById('rom-options-left').appendChild(buildOptionsTable(leftRomOpts, true));
-  document.getElementById('rom-options-right').appendChild(buildOptionsTable(rightRomOpts, true));
-};
-
-const buildOptionsTable = (settings, romOpts = false) => {
-  const currentSettings = JSON.parse(localStorage.getItem('playerSettings'));
-  const table = document.createElement('table');
-  const tbody = document.createElement('tbody');
-
-  Object.keys(settings).forEach((setting) => {
-    const tr = document.createElement('tr');
-
-    // td Left
-    const tdl = document.createElement('td');
-    const label = document.createElement('label');
-    label.setAttribute('for', setting);
-    label.setAttribute('data-tooltip', settings[setting].description);
-    label.innerText = `${settings[setting].friendlyName}:`;
-    tdl.appendChild(label);
-    tr.appendChild(tdl);
-
-    // td Right
-    const tdr = document.createElement('td');
-    const select = document.createElement('select');
-    select.setAttribute('id', setting);
-    select.setAttribute('data-key', setting);
-    if (romOpts) { select.setAttribute('data-romOpt', '1'); }
-    settings[setting].options.forEach((opt) => {
-      const option = document.createElement('option');
-      option.setAttribute('value', opt.value);
-      option.innerText = opt.name;
-      if ((isNaN(currentSettings[setting]) && (parseInt(opt.value, 10) === parseInt(currentSettings[setting]))) ||
-        (opt.value === currentSettings[setting])) {
-        option.selected = true;
-      }
-      select.appendChild(option);
-    });
-    select.addEventListener('change', (event) => updateSetting(event));
-    tdr.appendChild(select);
-    tr.appendChild(tdr);
-    tbody.appendChild(tr);
-  });
-
-  table.appendChild(tbody);
-  return table;
-};
-
-const updateSetting = (event) => {
-  const options = JSON.parse(localStorage.getItem('playerSettings'));
-  if (event.target.getAttribute('data-romOpt')) {
-    options.rom[event.target.getAttribute('data-key')] = isNaN(event.target.value) ?
-      event.target.value : parseInt(event.target.value, 10);
-  } else {
-    options[event.target.getAttribute('data-key')] = isNaN(event.target.value) ?
-      event.target.value : parseInt(event.target.value, 10);
-  }
-  localStorage.setItem('playerSettings', JSON.stringify(options));
-};
-
-const exportSettings = () => {
-  const settings = JSON.parse(localStorage.getItem('playerSettings'));
-  if (!settings.name || settings.name.trim().length === 0) { settings.name = "noname"; }
-  const yamlText = jsyaml.safeDump(settings, { noCompatMode: true }).replaceAll(/'(\d+)':/g, (x, y) => `${y}:`);
-  download(`${document.getElementById('player-name').value}.yaml`, yamlText);
-};
-
-/** Create an anchor and trigger a download of a text file. */
-const download = (filename, text) => {
-  const downloadLink = document.createElement('a');
-  downloadLink.setAttribute('href','data:text/yaml;charset=utf-8,'+ encodeURIComponent(text))
-  downloadLink.setAttribute('download', filename);
-  downloadLink.style.display = 'none';
-  document.body.appendChild(downloadLink);
-  downloadLink.click();
-  document.body.removeChild(downloadLink);
-};
-
-const generateGame = (raceMode = false) => {
-  axios.post('/api/generate', {
-    weights: { player: localStorage.getItem('playerSettings') },
-    presetData: { player: localStorage.getItem('playerSettings') },
-    playerCount: 1,
-    race: raceMode ? '1' : '0',
-  }).then((response) => {
-    window.location.href = response.data.url;
-  }).catch((error) => {
-    const userMessage = document.getElementById('user-message');
-    userMessage.innerText = 'Something went wrong and your game could not be generated.';
-    userMessage.classList.add('visible');
-    window.scrollTo(0, 0);
-    console.error(error);
-  });
-};
-
-const fetchSpriteData = () => new Promise((resolve, reject) => {
-  const ajax = new XMLHttpRequest();
-  ajax.onreadystatechange = () => {
-    if (ajax.readyState !== 4) { return; }
-    if (ajax.status !== 200) {
-      reject('Unable to fetch sprite data.');
-      return;
-    }
-    resolve(ajax.responseText);
-  };
-  ajax.open('GET', `${window.location.origin}/static/static/spriteData.json`, true);
-  ajax.send();
-});

WebHostLib/static/assets/supermetroidTracker.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/timespinnerTracker.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/tracker.js

@@ -17,6 +17,47 @@ window.addEventListener('load', () => {
         paging: false,
         info: false,
         dom: "t",
+        columnDefs: [
+            {
+                targets: 'hours',
+                render: function (data, type, row) {
+                    if (type === "sort" || type === 'type') {
+                        if (data === "None")
+                            return -1;
+
+                        return parseInt(data);
+                    }
+                    if (data === "None")
+                        return data;
+
+                    let hours   = Math.floor(data / 3600);
+                    let minutes = Math.floor((data - (hours * 3600)) / 60);
+
+                    if (minutes < 10) {minutes = "0"+minutes;}
+                    return hours+':'+minutes;
+                }
+            },
+            {
+                targets: 'number',
+                render: function (data, type, row) {
+                    if (type === "sort" || type === 'type') {
+                        return parseFloat(data);
+                    }
+                    return data;
+                }
+            },
+            {
+                targets: 'fraction',
+                render: function (data, type, row) {
+                    let splitted = data.split("/", 1);
+                    let current = splitted[0]
+                    if (type === "sort" || type === 'type') {
+                        return parseInt(current);
+                    }
+                    return data;
+                }
+            },
+        ],
 
         // DO NOT use the scrollX or scrollY options. They cause DataTables to split the thead from
         // the tbody and render two separate tables.

WebHostLib/static/assets/tutorial.js

@@ -14,12 +14,16 @@ window.addEventListener('load', () => {
             }
             resolve(ajax.responseText);
         };
-        ajax.open('GET', `${window.location.origin}/static/assets/tutorial/` +
+        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();
 

WebHostLib/static/assets/tutorial/factorio/setup_en.md

@@ -1,51 +0,0 @@
-# Factorio Randomizer Setup Guide
-
-## Required Software
-
-### Server Host
-- [Factorio](https://factorio.com)
-- [Archipelago](https://github.com/ArchipelagoMW/Archipelago/releases)
-
-### Players
-- [Factorio](https://factorio.com)
-
-## General Concept
-
-One Server Host exists per Factorio World in an Archipelago Multiworld, any number of modded Factorio players can then connect to that world. From the view of Archipelago, this Factorio host is a client.
-## Installation Procedures
-
-### Dedicated Server Setup
-You need a dedicated isolated Factorio installation that the FactorioClient can take control over, if you intend to both emit a world and play, you need to follow both this setup and the player setup.
-This requires two Factorio installations. The easiest and cheapest way to do so is to either buy or register a Factorio on factorio.com, which allows you to download as many Factorio games as you want.
-1. Download the latest Factorio from https://factorio.com/download for your system, for Windows the recommendation is "win64-manual".
-
-2. Make sure the Factorio you play and the Factorio you use for hosting do not share paths. If you downloaded the "manual" version, this is already the case, otherwise, go into the hosting Factorio's folder and put the following text into its `config-path.cfg`:
-```ini
-config-path=__PATH__executable__/../../config
-use-system-read-write-data-directories=false
-```
-3. Navigate to where you installed Archipelago and open the host.yaml file as text. Find the entry `executable` under `factorio_options` and set it to point to your Factorio. If you put Factorio into your Archipelago folder, this would already match.
-
-
-### Player Setup
-- Manually install the AP mod for the correct world you want to join, then use Factorio's built-in multiplayer.
-
-    
-## Joining a MultiWorld Game
-
-1. Make a fresh world. Using any Factorio, create a savegame with options of your choice and save that world as Archipelago.
-
-2. Take that savegame and put it into your Archipelago folder
-
-3. Install the generated Factorio AP Mod
-
-4. Run FactorioClient, it should launch a Factorio server, which you can control with `/factorio <original factorio commands>`, 
-   
-    * It should say it loaded  the Archipelago mod and found a bridge file. If not, the most likely case is that the mod is not correctly installed or activated.
-
-5. In FactorioClient, do `/connect <Archipelago Server Address>` to join that multiworld. You can find further commands with `/help` as well as `!help` once connected.
-
-    * / commands are run on your local client, ! commands are requests for the AP server
-
-    * Players should be able to connect to your Factorio Server and begin playing.
-

WebHostLib/static/assets/tutorial/minecraft/minecraft_en.md

@@ -1,136 +0,0 @@
-# Minecraft Randomizer Setup Guide
-
-## Required Software
-
-### Server Host
-- [Minecraft Forge](https://files.minecraftforge.net/net/minecraftforge/forge/index_1.16.5.html)
-- [Minecraft Archipelago Randomizer Mod](https://github.com/KonoTyran/Minecraft_AP_Randomizer/releases)
-
-### Players
-- [Minecraft Java Edition](https://www.minecraft.net/en-us/store/minecraft-java-edition)
-
-## Installation Procedures
-
-### Dedicated Server Setup
-Only one person has to do this setup and host a dedicated server for everyone else playing to connect to.
-1. Download the 1.16.5 **Minecraft Forge** installer from the link above, making sure to download the most recent recommended version.
-
-2. Run the `forge-1.16.5-xx.x.x-installer.jar` file and choose **install server**.
-    - On this page you will also choose where to install the server to remember this directory it's important in the next step.
-
-3. Navigate to where you installed the server and open `forge-1.16.5-xx.x.x.jar`
-    - Upon first launch of the server it will close and ask you to accept Minecraft's EULA. There will be a new file called `eula.txt` that contains a link to Minecraft's EULA, and a line that you need to change to `eula=true` to accept Minecraft's EULA.
-    - This will create the appropriate directories for you to place the files in the following step.
-
-4. Place the `aprandomizer-x.x.x.jar` from the link above file into the `mods` folder of the above installation of your forge server.
-    - Once again run the server, it will load up and generate the required directory `APData` for when you are ready to play a game!
-
-### Basic Player Setup
-- Purchase and install Minecraft from the above link.
-
-  **You're Done**.
-  
-  Players only need to have a Vanilla unmodified version of Minecraft to play!
-
-### Advanced Player Setup
-***This is not required to play a randomized minecraft game.***
-however this recommended as it helps make the experience more enjoyable.
-
-#### Recomended Mods
-- [JourneyMap](https://www.curseforge.com/minecraft/mc-mods/journeymap) (Minimap)
-
-
-1. Install and run Minecraft from the link above at least once.
-2. Run the `forge-1.16.5-xx.x.x-installer.jar` file and choose **install client**.
-    - Start Minecraft forge at least once to create the directories needed for the next steps.
-3. Navigate to your minecraft install directory and place desired mods `.jar` file the in the `mods` directory.
-    - The default install directories are as follows.
-        - Windows `%APPDATA%\.minecraft\mods`
-        - macOS `~/Library/Application Support/minecraft/mods`
-        - Linux `~/.minecraft/mods`
-
-## Configuring your YAML file
-
-### What is a YAML file and why do I need one?
-Your YAML file contains a set of configuration options which provide the generator with information about how
-it should generate your game. Each player of a multiworld will provide their own YAML file. This setup allows
-each player to enjoy an experience customized for their taste, and different players in the same multiworld
-can all have different options.
-
-### Where do I get a YAML file?
-A basic minecraft yaml will look like this.
-```yaml
-description: Template Name
-# Your name in-game. Spaces will be replaced with underscores and
-# there is a 16 character limit
-name: YourName 
-game: Minecraft
-
-# Shared Options supported by all games:
-accessibility: locations
-progression_balancing: on
-# Minecraft Specific Options
-
-# Number of advancements required (out of 92 total) to spawn the
-# Ender Dragon and complete the game. 
-advancement_goal:
-  few: 0 #30
-  normal: 1 #50
-  many: 0 #70
-  
-# Modifies the level of items logically required for exploring
-# dangerous areas and fighting bosses. 
-combat_difficulty:
-  easy: 0
-  normal: 1
-  hard: 0
-  
-# Junk-fills certain RNG-reliant or tedious advancements with XP rewards. 
-include_hard_advancements:
-  on: 0
-  off: 1
-  
-# Junk-fills extremely difficult advancements;
-# this is only How Did We Get Here? and Adventuring Time.
-include_insane_advancements:
-  on: 0
-  off: 1
-  
-# Some advancements require defeating the Ender Dragon;
-# this will junk-fill them so you won't have to finish to send some items. 
-include_postgame_advancements:
-  on: 0
-  off: 1
-  
-#enables shuffling of villages, outposts, fortresses, bastions, and end cities. 
-shuffle_structures:
-  on: 1
-  off: 0
-```
-
-
-## Joining a MultiWorld Game
-
-### Obtain your Minecraft data file
-**Only one yaml file needs to be submitted per minecraft world regardless of how many players play on it.**
-
-When you join a multiworld game, you will be asked to provide your YAML file to whoever is hosting. Once that
-is done, the host will provide you with either a link to download your data file, or with a zip file containing
-everyone's data files. Your data file should have a `.apmc` extension.
-
-Put your data file in your forge servers `APData` folder. Make sure to remove any previous data file that was in there
-previously.
-
-### Connect to the MultiServer
-After having placed your data file in the `APData` folder, start the Forge server and make sure you have OP
-status by typing `/op YourMinecraftUsername` in the forge server console then connecting in your Minecraft client.
-
-Once in game type `/connect <AP-Address> (Port) (Password)` where `<AP-Address>` is the address of the
-Archipelago server. `(Port)` is only required if the Archipelago server is not using the default port of 38281. `(Password)`
-is only required if the Archipleago server you are using has a password set.
-
-### Play the game
-When the console tells you that you have joined the room, you're ready to begin playing. Congratulations
-on successfully joining a multiworld game! At this point any additional minecraft players may connect to your
-forge server.
-

WebHostLib/static/assets/tutorial/minecraft/minecraft_es.md

@@ -1,121 +0,0 @@
-# Guia instalación de Minecraft Randomizer
-
-## Software Requerido
-
-### Servidor
-- [Minecraft Forge](https://files.minecraftforge.net/net/minecraftforge/forge/index_1.16.5.html)
-- [Minecraft Archipelago Randomizer Mod](https://github.com/KonoTyran/Minecraft_AP_Randomizer/releases)
-
-### Jugadores
-- [Minecraft Java Edition](https://www.minecraft.net/en-us/store/minecraft-java-edition)
-
-## Procedimiento de instalación
-
-### Instalación de servidor dedicado
-Solo una persona ha de realizar este proceso y hospedar un servidor dedicado para que los demas jueguen conectandose a él.
-1. Descarga el instalador de **Minecraft Forge** 1.16.15 desde el enlace proporcionado, siempre asegurandose de bajar la version mas reciente.
-
-2. Ejecuta el fichero `forge-1.16.5-xx.x.x-installer.jar` y elije **install server**.
-    - En esta pagina elegiras ademas donde instalar el servidor, importante recordar esta localización en el siguiente paso.
-
-3. Navega al directorio donde hayas instalado el servidor y abre `forge-1.16.5-xx.x.x.jar`
-    - La primera vez que lances el servidor se cerrara (o no aparecerá nada en absoluto), debería haber un fichero nuevo en el directorio llamado `eula.txt`, el cual que contiene un enlace al EULA de minecraft, cambia la linea a `eula=true` para aceptar el EULA y poder utilizar el software de servidor.
-    - Esto creara la estructura de directorios apropiada para el siguiente paso
-
-4. Coloca el fichero `aprandomizer-x.x.x.jar` del segundo enlace en el directorio `mods`
-    - Cuando se ejecute el servidor de nuevo, generara el directorio `APData` que se necesitara para jugar
-
-### Instalación basica para jugadores
-- Compra e instala Minecraft a traves del tercer enlace.
-  **Y listo!**.
-  Los jugadores solo necesitan una version no modificada de Minecraft para jugar!
-
-### Instalación avanzada para jugadores
-***Esto no es requerido para jugar a minecraft randomizado.***
-Sin embargo lo recomendamos porque hace la experiencia mas llevadera.
-
-#### Recomended Mods
-- [JourneyMap](https://www.curseforge.com/minecraft/mc-mods/journeymap) (Minimap)
-
-
-1. Instala y ejecuta Minecraft al menos una vez.
-2. Ejecuta el fichero `forge-1.16.5-xx.x.x-installer.jar` y elige **install client**.
-    - Ejecuta Minecraft forge al menos una vez para generar los directorios necesarios para el siguiente paso.
-3. Navega a la carpeta de instalación de Minecraft y colocal los mods que quieras en el directorio `mods`
-    - Los directorios por defecto de instalación son:
-        - Windows `%APPDATA%\.minecraft\mods`
-        - macOS `~/Library/Application Support/minecraft/mods`
-        - Linux `~/.minecraft/mods`
-
-## Configura tu fichero YAML
-
-### Que es un fichero YAML y potque necesito uno?
-Tu fichero YAML contiene un numero de opciones que proveen al generador con informacion sobre como debe generar tu juego.
-Cada jugador de un multiworld entregara u propio fichero YAML.
-Esto permite que cada jugador disfrute de una experiencia personalizada a su gusto y diferentes jugadores dentro del mismo multiworld
-pueden tener diferentes opciones
-
-### Where do I get a YAML file?
-Un fichero basico yaml para minecraft tendra este aspecto.
-```yaml
-# Usado para describir tu yaml. Util si tienes multiples ficheros
-description: Template Name 
-# Tu nombre en el juego. Los espacios son reemplazados por guiones bajos, limitado a 16 caracteres
-name: YourName 
-game: Minecraft
-accessibility: locations
-# Recomendado no activar esto ya que el pool de objetos de Minecraft es bastante escueto, ademas hay muchas maneras alternativas de obtener los objetivos de Minecraft.
-progression_balancing: off 
-# Cuantos avances se necesitan para hacer aparecer el Ender Dragon y acabar el juego. few = 30, normal = 50 , many = 70
-advancement_goal: 
-  few: 0 
-  normal: 1 
-  many: 0 
-# Modifica el nivel de objetos lógicamente requeridos para explorar areas peligrosas y pelear contra jefes. 
-combat_difficulty: 
-  easy: 0
-  normal: 1
-  hard: 0
-# Avances que sean tediosos o basados en suerte tendran simplemente experiencia o cosas no necesarias
-include_hard_advancements: 
-  on: 0
-  off: 1
-# Los avances extremadamente difíciles no seran requeridos; esto afecta a How Did We Get Here? y Adventuring Time. 
-include_insane_advancements: 
-  on: 0
-  off: 1
-# Los avances posteriores a Ender Dragon no tendrán objetos necesarios para que otros jugadores en el caso de un MW acaben su partida.
-include_postgame_advancements:
-  on: 0
-  off: 1
-# Actualmente desactivado; permite la mezcla de pueblos, puestos, fortalezas, bastiones y cuidades. 
-shuffle_structures: 
-  on: 0
-  off: 1
-```
-
-
-## Unirse a un juego MultiWorld
-
-### Obten tu ficheros de datos Minecraft
-**Solo un fichero yaml es necesario por mundo minecraft, sin importar el numero de jugadores que jueguen en el.**
-
-Cuando te unes a un juego multiworld, se te pedirá que entregues tu fichero YAML a quien sea que hospede el juego multiworld (no confundir con hospedar el mundo minecraft).
-Una vez la generación acabe, el anfitrión te dará un enlace a tu fichero de datos o un zip con los ficheros de todos.
-Tu fichero de datos tiene una extensión `.apmc`.
-
-Pon tu fichero de datos en el directorio `APData` de tu forge server. Asegurate de eliminar los que hubiera anteriormente
-
-
-### Conectar al multiserver
-Despues de poner tu fichero en el directorio `APData`, arranca el Forge server y asegurate que tienes el estado OP
-tecleando `/op TuUsuarioMinecraft` en la consola del servidor y entonces conectate con tu cliente Minecraft.
-
-Una vez en juego introduce `/connect <AP-Address> (<Password>)` donde `<AP-Address>` es la dirección del servidor
-Archipelago. `(<Password>)`
-solo se necesita si el servidor Archipleago tiene un password activo.
-
-### Jugar al juego
-Cuando la consola te diga que te has unido a la sala, estas lista/o para empezar a jugar. Felicidades
-por unirte exitosamente a un juego multiworld! Llegados a este punto cualquier jugador adicional puede conectarse a tu servidor forge.
-

WebHostLib/static/assets/tutorial/tutorials.json

@@ -1,143 +0,0 @@
-[
-  {
-    "gameTitle": "The Legend of Zelda: A Link to the Past",
-    "tutorials": [
-      {
-        "name": "Multiworld Setup Tutorial",
-        "description": "A guide to setting up the Archipelago ALttP software on your computer. This guide covers single-player, multiworld, and related software.",
-        "files": [
-          {
-            "language": "English",
-            "filename": "zelda3/multiworld_en.md",
-            "link": "zelda3/multiworld/en",
-            "authors": [
-              "Farrak Kilhn"
-            ]
-          },
-          {
-            "language": "Deutsch",
-            "filename": "zelda3/multiworld_de.md",
-            "link": "zelda3/multiworld/de",
-            "authors": [
-              "Fischfilet"
-            ]
-          },
-          {
-            "language": "Español",
-            "filename": "zelda3/multiworld_es.md",
-            "link": "zelda3/multiworld/es",
-            "authors": [
-              "Edos"
-            ]
-          },
-          {
-            "language": "Français",
-            "filename": "zelda3/multiworld_fr.md",
-            "link": "zelda3/multiworld/fr",
-            "authors": [
-              "Coxla"
-            ]
-          }
-        ]
-      },
-      {
-        "name": "MSU-1 Setup Tutorial",
-        "description": "A guide to setting up MSU-1, which allows for custom in-game music.",
-        "files": [
-          {
-            "language": "English",
-            "filename": "zelda3/msu1_en.md",
-            "link": "zelda3/msu1/en",
-            "authors": [
-              "Farrak Kilhn"
-            ]
-          },
-          {
-            "language": "Español",
-            "filename": "zelda3/msu1_es.md",
-            "link": "zelda3/msu1/es",
-            "authors": [
-              "Edos"
-            ]
-          },
-          {
-            "language": "Français",
-            "filename": "msu1_fr.md",
-            "link": "zelda3/msu1/fr",
-            "authors": [
-              "Coxla"
-            ]
-          }
-        ]
-      },
-      {
-        "name": "Plando Tutorial",
-        "description": "A guide to creating Multiworld Plandos",
-        "files": [
-          {
-            "language": "English",
-            "filename": "zelda3/plando_en.md",
-            "link": "zelda3/plando/en",
-            "authors": [
-              "Berserker"
-            ]
-          }
-        ]
-      }
-    ]
-  },
-  {
-    "gameTitle": "Factorio",
-    "tutorials": [
-      {
-        "name": "Multiworld Setup Tutorial",
-        "description": "A guide to setting up the Archipelago Factorio software on your computer.",
-        "files": [
-          {
-            "language": "English",
-            "filename": "factorio/setup_en.md",
-            "link": "factorio/setup/en",
-            "authors": [
-              "Berserker"
-            ]
-          }
-        ]
-      }
-    ]
-  },
-  {
-    "gameTitle": "Minecraft",
-    "tutorials": [
-      {
-        "name": "Multiworld Setup Tutorial",
-        "description": "A guide to setting up the Archipelago Minecraft software on your computer. This guide covers single-player, multiworld, and related software.",
-        "files": [
-          {
-            "language": "English",
-            "filename": "minecraft/minecraft_en.md",
-            "link": "minecraft/minecraft/en",
-            "authors": [
-              "Kono Tyran"
-            ]
-          },
-          {
-            "language": "Spanish",
-            "filename": "minecraft/minecraft_es.md",
-            "link": "minecraft/minecraft/es",
-            "authors": [
-              "Edos"
-            ]
-          },
-          {
-            "language": "Swedish",
-            "filename": "minecraft/minecraft_sv.md",
-            "link": "minecraft/minecraft/sv",
-            "authors": [
-              "Albinum"
-            ]
-          }
-        ]
-      }
-    ]
-  }
-]

WebHostLib/static/assets/tutorial/zelda3/multiworld_en.md

@@ -1,180 +0,0 @@
-# A Link to the Past Randomizer Setup Guide
-
-<div id="tutorial-video-container">
-    <iframe width="560" height="315" src="https://www.youtube-nocookie.com/embed/mJKEHaiyR_Y" frameborder="0"
-      allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen>
-    </iframe>
-</div>
-
-## Required Software
-- [Archipelago](https://github.com/ArchipelagoMW/Archipelago/releases)
-- [QUsb2Snes](https://github.com/Skarsnik/QUsb2snes/releases) (Included in the above Utilities)
-- Hardware or software capable of loading and playing SNES ROM files
-    - An emulator capable of running Lua scripts
-      ([snes9x Multitroid](https://drive.google.com/drive/folders/1_ej-pwWtCAHYXIrvs5Hro16A1s9Hi3Jz),
-      [BizHawk](http://tasvideos.org/BizHawk.html))
-    - An SD2SNES, [FXPak Pro](https://krikzz.com/store/home/54-fxpak-pro.html), or other compatible hardware
-- Your Japanese v1.0 ROM file, probably named `Zelda no Densetsu - Kamigami no Triforce (Japan).sfc`
-
-## Installation Procedures
-
-### Windows Setup
-1. Download and install the MultiWorld Utilities from the link above, making sure to install the most recent version.
-**The file is located in the assets section at the bottom of the version information**. If you intend to play normal
-multiworld games, you want `Setup.Archipelago.exe`
-    - If you intend to play the doors variant of multiworld, you will want to download the alternate doors file.
-    - During the installation process, you will be asked to browse for your Japanese 1.0 ROM file. If you have
-      installed this software before and are simply upgrading now, you will not be prompted to locate your
-      ROM file a second time.
-    - You may also be prompted to install Microsoft Visual C++. If you already have this software on your computer
-      (possibly because a Steam game installed it already), the installer will not prompt you to install it again.
-
-2. If you are using an emulator, you should assign your Lua capable emulator as your default program
-for launching ROM files.
-    1. Extract your emulator's folder to your Desktop, or somewhere you will remember. 
-    2. Right click on a ROM file and select **Open with...**
-    3. Check the box next to **Always use this app to open .sfc files**
-    4. Scroll to the bottom of the list and click the grey text **Look for another App on this PC**
-    5. Browse for your emulator's `.exe` file and click **Open**. This file should be located inside
-       the folder you extracted in step one.
-
-### Macintosh Setup
-- We need volunteers to help fill this section! Please contact **Farrak Kilhn** on Discord if you want to help.
-
-## Configuring your YAML file
-
-### What is a YAML file and why do I need one?
-Your YAML file contains a set of configuration options which provide the generator with information about how
-it should generate your game. Each player of a multiworld will provide their own YAML file. This setup allows
-each player to enjoy an experience customized for their taste, and different players in the same multiworld
-can all have different options.
-
-### Where do I get a YAML file?
-The [Generate Game](/player-settings) page on the website allows you to configure your personal settings and
-export a YAML file from them.
-
-### Advanced YAML configuration
-A more advanced version of the YAML file can be created using the [Weighted Settings](/weighted-settings) page,
-which allows you to configure up to three presets. The Weighted Settings page has many options which are
-primarily represented with sliders. This allows you to choose how likely certain options are to occur relative
-to other options within a category.
-
-For example, imagine the generator creates a bucket labeled "Map Shuffle", and places folded pieces of paper
-into the bucket for each sub-option. Also imagine your chosen value for "On" is 20, and your value for "Off" is 40.
-
-In this example, sixty pieces of paper are put into the bucket. Twenty for "On" and forty for "Off". When the
-generator is deciding whether or not to turn on map shuffle for your game, it reaches into this bucket and pulls
-out a piece of paper at random. In this example, you are much more likely to have map shuffle turned off.
-
-If you never want an option to be chosen, simply set its value to zero. Remember that each setting must have at
-lease one option set to a number greater than zero.
-
-### Verifying your YAML file
-If you would like to validate your YAML file to make sure it works, you may do so on the
-[YAML Validator](/mysterycheck) page.
-
-## Generating a Single-Player Game
-1. Navigate to the [Generate Game](/player-settings), configure your options, and click the "Generate Game" button.
-2. You will be presented with a "Seed Info" page, where you can download your patch file.
-3. Double-click on your patch file, and the emulator should launch with your game automatically. As the
-   Client is unnecessary for single player games, you may close it and the WebUI.
-
-## Joining a MultiWorld Game
-
-### Obtain your patch file and create your ROM
-When you join a multiworld game, you will be asked to provide your YAML file to whoever is hosting. Once that
-is done, the host will provide you with either a link to download your patch file, or with a zip file containing
-everyone's patch files. Your patch file should have a `.bmbp` extension.
-
-Put your patch file on your desktop or somewhere convenient, and double click it. This should automatically
-launch the client, and will also create your ROM file in the same place as your patch file.
-
-### Connect to the client
-
-#### With an emulator
-When the client launched automatically, QUsb2Snes should have also automatically launched in the background.
-If this is its first time launching, you may be prompted to allow it to communicate through the Windows
-Firewall.
-
-##### snes9x Multitroid
-1. Load your ROM file if it hasn't already been loaded.
-2. Click on the File menu and hover on **Lua Scripting**
-3. Click on **New Lua Script Window...**
-4. In the new window, click **Browse...**
-5. Browse to the location you extracted snes9x Multitroid to, enter the `lua` folder, and choose `multibridge.lua`
-6. Observe a name has been assigned to you, and that the client shows "SNES Device: Connected", with that same
-   name in the upper left corner.
-
-##### BizHawk
-1. Ensure you have the BSNES core loaded. You may do this by clicking on the Tools menu in BizHawk and following
-   these menu options:
-   `Config --> Cores --> SNES --> BSNES`  
-   Once you have changed the loaded core, you must restart BizHawk.
-2. Load your ROM file if it hasn't already been loaded.
-3. Click on the Tools menu and click on **Lua Console**
-4. Click the button to open a new Lua script.
-5. Browse to your MultiWorld Utilities installation directory, and into the following directories:  
-   `QUsb2Snes/Qusb2Snes/LuaBridge`
-6. Select `luabridge.lua` and click Open.
-7. Observe a name has been assigned to you, and that the client shows "SNES Device: Connected", with that same
-   name in the upper left corner. 
-
-#### With hardware
-This guide assumes you have downloaded the correct firmware for your device. If you have not
-done so already, please do this now. SD2SNES and FXPak Pro users may download the appropriate firmware
-[here](https://github.com/RedGuyyyy/sd2snes/releases). Other hardware may find helpful information
-[on this page](http://usb2snes.com/#supported-platforms).
-
-1. Close your emulator, which may have auto-launched.
-2. Power on your device and load the ROM.
-3. Observe the client window now shows "SNES Device: Connected", and lists the name of your device.
-
-### Connect to the MultiServer
-The patch file which launched your client should have automatically connected you to the MultiServer.
-There are a few reasons this may not happen however, including if the game is hosted on the website but
-was generated elsewhere. If the client window shows "Server Status: Not Connected", simply ask the host
-for the address of the server, and copy/paste it into the "Server" input field then press enter.
-
-The client will attempt to reconnect to the new server address, and should momentarily show "Server
-Status: Connected". If the client does not connect after a few moments, you may need to refresh the page.
-
-### Play the game
-When the client shows both SNES Device and Server as connected, you're ready to begin playing. Congratulations
-on successfully joining a multiworld game!
-
-## Hosting a MultiWorld game
-The recommended way to host a game is to use the hosting service provided on
-[the website](/generate). The process is relatively simple:
-
-1. Collect YAML files from your players.
-2. Create a zip file containing your players' YAML files.
-3. Upload that zip file to the website linked above.
-4. Wait a moment while the seed is generated.
-5. When the seed is generated, you will be redirected to a "Seed Info" page.
-6. Click "Create New Room". This will take you to the server page. Provide the link to this page to your players,
-   so they may download their patch files from there.  
-   **Note:** The patch files provided on this page will allow players to automatically connect to the server,
-   while the patch files on the "Seed Info" page will not.
-7. Note that a link to a MultiWorld Tracker is at the top of the room page. You should also provide this link
-   to your players, so they can watch the progress of the game. Any observers may also be given the link to
-   this page.
-8. Once all players have joined, you may begin playing.
-
-## Auto-Tracking
-If you would like to use auto-tracking for your game, several pieces of software provide this functionality.  
-The recommended software for auto-tracking is currently
-[OpenTracker](https://github.com/trippsc2/OpenTracker/releases).
-
-### Installation
-1. Download the appropriate installation file for your computer (Windows users want the `.msi` file).
-2. During the installation process, you may be asked to install the Microsoft Visual Studio Build Tools. A link
-   to this software is provided during the installation procedure, and it must be installed manually.
-   
-### Enable auto-tracking
-1. With OpenTracker launched, click the Tracking menu at the top of the window, then choose **AutoTracker...**
-2. Click the **Get Devices** button
-3. Select your SNES device from the drop-down list
-4. If you would like to track small keys and dungeon items, check the box labeled **Race Illegal Tracking**
-5. Click the **Start Autotracking** button
-6. Close the AutoTracker window, as it is no longer necessary
-

WebHostLib/static/assets/tutorialLanding.js

@@ -23,6 +23,7 @@ window.addEventListener('load', () => {
       games.forEach((game) => {
         const gameTitle = document.createElement('h2');
         gameTitle.innerText = game.gameTitle;
+        gameTitle.id = `${encodeURIComponent(game.gameTitle)}`;
         tutorialDiv.appendChild(gameTitle);
 
         game.tutorials.forEach((tutorial) => {
@@ -65,7 +66,16 @@ window.addEventListener('load', () => {
       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/assets/tutorial/tutorials.json`, true);
+  ajax.open('GET', `${window.location.origin}/static/generated/tutorials.json`, true);
   ajax.send();
 });

WebHostLib/static/assets/weightedSettings.js

@@ -1,483 +0,0 @@
-let spriteData = null;
-
-window.addEventListener('load', () => {
-  const gameSettings = document.getElementById('weighted-settings');
-  Promise.all([fetchWeightedSettingsYaml(), fetchWeightedSettingsJson(), fetchSpriteData()]).then((results) => {
-    // Load YAML into object
-    const sourceData = jsyaml.safeLoad(results[0], { json: true });
-    const wsVersion = sourceData.ws_version;
-    delete sourceData.ws_version; // Do not include the settings version number in the export
-
-    // Check if settings exist in localStorage. If no settings are present, this is a first load (or reset to default)
-    // and the version number should be silently updated
-    if (!localStorage.getItem('weightedSettings1')) {
-      localStorage.setItem('wsVersion', wsVersion);
-    }
-
-    // Update localStorage with three settings objects. Preserve original objects if present.
-    for (let i=1; i<=3; i++) {
-      const localSettings = JSON.parse(localStorage.getItem(`weightedSettings${i}`));
-      const updatedObj = localSettings ? Object.assign(sourceData, localSettings) : sourceData;
-      localStorage.setItem(`weightedSettings${i}`, JSON.stringify(updatedObj));
-    }
-
-    // Build the entire UI
-    buildUI(JSON.parse(results[1]), JSON.parse(results[2]));
-
-    // Populate the UI and add event listeners
-    populateSettings();
-    document.getElementById('preset-number').addEventListener('change', populateSettings);
-    gameSettings.addEventListener('change', handleOptionChange);
-    gameSettings.addEventListener('keyup', handleOptionChange);
-
-    document.getElementById('export-button').addEventListener('click', exportSettings);
-    document.getElementById('reset-to-default').addEventListener('click', resetToDefaults);
-    adjustHeaderWidth();
-
-    if (localStorage.getItem('wsVersion') !== wsVersion) {
-      const userWarning = document.getElementById('user-warning');
-      const messageSpan = document.createElement('span');
-      messageSpan.innerHTML = "A new version of the weighted settings file is available. Click here to update!" +
-        "<br />Be aware this will also reset your presets, so you should export them now if you want to save them.";
-      userWarning.appendChild(messageSpan);
-      userWarning.style.display = 'block';
-      userWarning.addEventListener('click', resetToDefaults);
-    }
-  }).catch((error) => {
-    console.error(error);
-    gameSettings.innerHTML = `
-            <h2>Something went wrong while loading your game settings page.</h2>
-            <h2>${error}</h2>
-            <h2><a href="${window.location.origin}">Click here to return to safety!</a></h2>
-            `
-  });
-  document.getElementById('generate-game').addEventListener('click', () => generateGame());
-  document.getElementById('generate-race').addEventListener('click', () => generateGame(true));
-});
-
-const fetchWeightedSettingsYaml = () => new Promise((resolve, reject) => {
-  const ajax = new XMLHttpRequest();
-  ajax.onreadystatechange = () => {
-    if (ajax.readyState !== 4) { return; }
-    if (ajax.status !== 200) {
-      reject("Unable to fetch source yaml file.");
-      return;
-    }
-    resolve(ajax.responseText);
-  };
-  ajax.open('GET', `${window.location.origin}/static/static/weightedSettings.yaml` ,true);
-  ajax.send();
-});
-
-const fetchWeightedSettingsJson = () => new Promise((resolve, reject) => {
-  const ajax = new XMLHttpRequest();
-  ajax.onreadystatechange = () => {
-    if (ajax.readyState !== 4) { return; }
-    if (ajax.status !== 200) {
-      reject('Unable to fetch JSON schema file');
-      return;
-    }
-    resolve(ajax.responseText);
-  };
-  ajax.open('GET', `${window.location.origin}/static/static/weightedSettings.json`, true);
-  ajax.send();
-});
-
-const fetchSpriteData = () => new Promise((resolve, reject) => {
-  const ajax = new XMLHttpRequest();
-  ajax.onreadystatechange = () => {
-    if (ajax.readyState !== 4) { return; }
-    if (ajax.status !== 200) {
-      reject('Unable to fetch sprite data.');
-      return;
-    }
-    resolve(ajax.responseText);
-  };
-  ajax.open('GET', `${window.location.origin}/static/static/spriteData.json`, true);
-  ajax.send();
-});
-
-const handleOptionChange = (event) => {
-  if(!event.target.matches('.setting')) { return; }
-  const presetNumber = document.getElementById('preset-number').value;
-  const settings = JSON.parse(localStorage.getItem(`weightedSettings${presetNumber}`))
-  const settingString = event.target.getAttribute('data-setting');
-  document.getElementById(settingString).innerText = event.target.value;
-  if(getSettingValue(settings, settingString) !== false){
-    const keys = settingString.split('.');
-    switch (keys.length) {
-      case 1:
-        settings[keys[0]] = isNaN(event.target.value) ?
-          event.target.value : parseInt(event.target.value, 10);
-        break;
-      case 2:
-        settings[keys[0]][keys[1]] = isNaN(event.target.value) ?
-          event.target.value : parseInt(event.target.value, 10);
-        break;
-      case 3:
-        settings[keys[0]][keys[1]][keys[2]] = isNaN(event.target.value) ?
-          event.target.value : parseInt(event.target.value, 10);
-        break;
-      default:
-        console.warn(`Unknown setting string received: ${settingString}`)
-        return;
-    }
-
-    // Save the updated settings object bask to localStorage
-    localStorage.setItem(`weightedSettings${presetNumber}`, JSON.stringify(settings));
-  }else{
-    console.warn(`Unknown setting string received: ${settingString}`)
-  }
-};
-
-const populateSettings = () => {
-  buildSpriteOptions();
-  const presetNumber = document.getElementById('preset-number').value;
-  const settings = JSON.parse(localStorage.getItem(`weightedSettings${presetNumber}`))
-  const settingsInputs = Array.from(document.querySelectorAll('.setting'));
-  settingsInputs.forEach((input) => {
-    const settingString = input.getAttribute('data-setting');
-    const settingValue = getSettingValue(settings, settingString);
-    if(settingValue !== false){
-      input.value = settingValue;
-      document.getElementById(settingString).innerText = settingValue;
-    }
-  });
-};
-
-/**
- * Returns the value of the settings object, or false if the settings object does not exist
- * @param settings
- * @param keyString
- * @returns {string} | bool
- */
-const getSettingValue = (settings, keyString) => {
-  const keys = keyString.split('.');
-  let currentVal = settings;
-  keys.forEach((key) => {
-    if(typeof(key) === 'string' && currentVal.hasOwnProperty(key)){
-      currentVal = currentVal[key];
-    }else{
-      currentVal = false;
-    }
-  });
-  return currentVal;
-};
-
-const exportSettings = () => {
-  const presetNumber = document.getElementById('preset-number').value;
-  const settings = JSON.parse(localStorage.getItem(`weightedSettings${presetNumber}`));
-  const yamlText = jsyaml.safeDump(settings, { noCompatMode: true }).replaceAll(/'(\d+)':/g, (x, y) => `${y}:`);
-  download(`${settings.description}.yaml`, yamlText);
-};
-
-const resetToDefaults = () => {
-  [1, 2, 3].forEach((presetNumber) => localStorage.removeItem(`weightedSettings${presetNumber}`));
-  location.reload();
-};
-
-/** Create an anchor and trigger a download of a text file. */
-const download = (filename, text) => {
-  const downloadLink = document.createElement('a');
-  downloadLink.setAttribute('href','data:text/yaml;charset=utf-8,'+ encodeURIComponent(text))
-  downloadLink.setAttribute('download', filename);
-  downloadLink.style.display = 'none';
-  document.body.appendChild(downloadLink);
-  downloadLink.click();
-  document.body.removeChild(downloadLink);
-};
-
-const buildUI = (settings, spriteData) => {
-  const settingsWrapper = document.getElementById('settings-wrapper');
-  const settingTypes = {
-    gameOptions: 'Game Options',
-    romOptions: 'ROM Options',
-  }
-
-  Object.keys(settingTypes).forEach((settingTypeKey) => {
-    const sectionHeader = document.createElement('h2');
-    sectionHeader.innerText = settingTypes[settingTypeKey];
-    settingsWrapper.appendChild(sectionHeader);
-
-    Object.values(settings[settingTypeKey]).forEach((setting) => {
-      if (typeof(setting.inputType) === 'undefined' || !setting.inputType){
-        console.error(setting);
-        throw new Error('Setting with no inputType specified.');
-      }
-
-      switch(setting.inputType){
-        case 'text':
-          // Currently, all text input is handled manually because there is very little of it
-          return;
-        case 'range':
-          buildRangeSettings(settingsWrapper, setting);
-          return;
-        default:
-          console.error(setting);
-          throw new Error('Unhandled inputType specified.');
-      }
-    });
-  });
-
-  // Build sprite options
-  const spriteOptionsHeader = document.createElement('h2');
-  spriteOptionsHeader.innerText = 'Sprite Options';
-  settingsWrapper.appendChild(spriteOptionsHeader);
-
-  const spriteOptionsWrapper = document.createElement('div');
-  spriteOptionsWrapper.setAttribute('id', 'sprite-options-wrapper');
-  spriteOptionsWrapper.className = 'setting-wrapper';
-  settingsWrapper.appendChild(spriteOptionsWrapper);
-
-  // Append sprite picker
-  settingsWrapper.appendChild(buildSpritePicker(spriteData));
-};
-
-const buildSpriteOptions = () => {
-  const spriteOptionsWrapper = document.getElementById('sprite-options-wrapper');
-
-  // Clear the contents of the wrapper div
-  while(spriteOptionsWrapper.firstChild){
-    spriteOptionsWrapper.removeChild(spriteOptionsWrapper.lastChild);
-  }
-
-  const spriteOptionsTitle = document.createElement('span');
-  spriteOptionsTitle.className = 'title-span';
-  spriteOptionsTitle.innerText = 'Alternate Sprites';
-  spriteOptionsWrapper.appendChild(spriteOptionsTitle);
-
-  const spriteOptionsDescription = document.createElement('span');
-  spriteOptionsDescription.className = 'description-span';
-  spriteOptionsDescription.innerHTML = 'Choose an alternate sprite to play the game with. Additional randomization ' +
-    'options are documented in the ' +
-    '<a href="https://github.com/Berserker66/MultiWorld-Utilities/blob/main/playerSettings.yaml#L374">settings file</a>.';
-  spriteOptionsWrapper.appendChild(spriteOptionsDescription);
-
-  const spriteOptionsTable = document.createElement('table');
-  spriteOptionsTable.setAttribute('id', 'sprite-options-table');
-  spriteOptionsTable.className = 'option-set';
-  const tbody = document.createElement('tbody');
-  tbody.setAttribute('id', 'sprites-tbody');
-
-  const currentPreset = document.getElementById('preset-number').value;
-  const playerSettings = JSON.parse(localStorage.getItem(`weightedSettings${currentPreset}`));
-
-  // Manually add a row for random sprites
-  addSpriteRow(tbody, playerSettings, 'random');
-
-  // Add a row for each sprite currently present in the player's settings
-  Object.keys(playerSettings.rom.sprite).forEach((spriteName) => {
-    if(['random'].indexOf(spriteName) > -1) return;
-    addSpriteRow(tbody, playerSettings, spriteName)
-  });
-
-  spriteOptionsTable.appendChild(tbody);
-  spriteOptionsWrapper.appendChild(spriteOptionsTable);
-};
-
-const buildRangeSettings = (parentElement, settings) => {
-  // Ensure we are operating on a range-specific setting
-  if(typeof(settings.inputType) === 'undefined' || settings.inputType !== 'range'){
-    throw new Error('Invalid input type provided to buildRangeSettings func.');
-  }
-
-  const settingWrapper = document.createElement('div');
-  settingWrapper.className = 'setting-wrapper';
-
-  if(typeof(settings.friendlyName) !== 'undefined' && settings.friendlyName){
-    const sectionTitle = document.createElement('span');
-    sectionTitle.className = 'title-span';
-    sectionTitle.innerText = settings.friendlyName;
-    settingWrapper.appendChild(sectionTitle);
-  }
-
-  if(settings.description){
-    const description = document.createElement('span');
-    description.className = 'description-span';
-    description.innerText = settings.description;
-    settingWrapper.appendChild(description);
-  }
-
-  // Create table
-  const optionSetTable = document.createElement('table');
-  optionSetTable.className = 'option-set';
-
-  // Create table body
-  const tbody = document.createElement('tbody');
-  Object.keys(settings.subOptions).forEach((setting) => {
-    // Overwrite setting key name with real object
-    setting = settings.subOptions[setting];
-    const settingId = (Math.random() * 1000000).toString();
-
-    // Create rows for each option
-    const optionRow = document.createElement('tr');
-
-    // Option name td
-    const optionName = document.createElement('td');
-    optionName.className = 'option-name';
-    const optionLabel = document.createElement('label');
-    optionLabel.setAttribute('for', settingId);
-    optionLabel.setAttribute('data-tooltip', setting.description);
-    optionLabel.innerText = setting.friendlyName;
-    optionName.appendChild(optionLabel);
-    optionRow.appendChild(optionName);
-
-    // Option value td
-    const optionValue = document.createElement('td');
-    optionValue.className = 'option-value';
-    const input = document.createElement('input');
-    input.className = 'setting';
-    input.setAttribute('id', settingId);
-    input.setAttribute('type', 'range');
-    input.setAttribute('min', '0');
-    input.setAttribute('max', '100');
-    input.setAttribute('data-setting', setting.keyString);
-    input.value = setting.defaultValue;
-    optionValue.appendChild(input);
-    const valueDisplay = document.createElement('span');
-    valueDisplay.setAttribute('id', setting.keyString);
-    valueDisplay.innerText = setting.defaultValue;
-    optionValue.appendChild(valueDisplay);
-    optionRow.appendChild(optionValue);
-    tbody.appendChild(optionRow);
-  });
-
-  optionSetTable.appendChild(tbody);
-  settingWrapper.appendChild(optionSetTable);
-  parentElement.appendChild(settingWrapper);
-};
-
-const addSpriteRow = (tbody, playerSettings, spriteName) => {
-  const rowId = (Math.random() * 1000000).toString();
-  const optionId = (Math.random() * 1000000).toString();
-  const tr = document.createElement('tr');
-  tr.setAttribute('id', rowId);
-
-  // Option Name
-  const optionName = document.createElement('td');
-  optionName.className = 'option-name';
-  const label = document.createElement('label');
-  label.htmlFor = optionId;
-  label.innerText = spriteName;
-  optionName.appendChild(label);
-
-  if(['random', 'random_sprite_on_event'].indexOf(spriteName) === -1) {
-    const deleteButton = document.createElement('span');
-    deleteButton.setAttribute('data-sprite', spriteName);
-    deleteButton.setAttribute('data-row-id', rowId);
-    deleteButton.innerText = ' (❌)';
-    deleteButton.className = 'delete-button';
-    optionName.appendChild(deleteButton);
-    deleteButton.addEventListener('click', removeSpriteOption);
-  }
-
-  tr.appendChild(optionName);
-
-  // Option Value
-  const optionValue = document.createElement('td');
-  optionValue.className = 'option-value';
-  const input = document.createElement('input');
-  input.className = 'setting';
-  input.setAttribute('id', optionId);
-  input.setAttribute('type', 'range');
-  input.setAttribute('min', '0');
-  input.setAttribute('max', '100');
-  input.setAttribute('data-setting', `rom.sprite.${spriteName}`);
-  input.value = "50";
-  optionValue.appendChild(input);
-
-  // Value display
-  const valueDisplay = document.createElement('span');
-  valueDisplay.setAttribute('id', `rom.sprite.${spriteName}`);
-  valueDisplay.innerText = playerSettings.rom.sprite.hasOwnProperty(spriteName) ?
-    playerSettings.rom.sprite[spriteName] : '0';
-  optionValue.appendChild(valueDisplay);
-
-  tr.appendChild(optionValue);
-  tbody.appendChild(tr);
-};
-
-const addSpriteOption = (event) => {
-  const presetNumber = document.getElementById('preset-number').value;
-  const playerSettings = JSON.parse(localStorage.getItem(`weightedSettings${presetNumber}`));
-  const spriteName = event.target.getAttribute('data-sprite');
-
-  if (Object.keys(playerSettings.rom.sprite).indexOf(spriteName) !== -1) {
-    // Do not add the same sprite twice
-    return;
-  }
-
-  // Add option to playerSettings object
-  playerSettings.rom.sprite[event.target.getAttribute('data-sprite')] = 50;
-  localStorage.setItem(`weightedSettings${presetNumber}`, JSON.stringify(playerSettings));
-
-  // Add <tr> to #sprite-options-table
-  const tbody = document.getElementById('sprites-tbody');
-  addSpriteRow(tbody, playerSettings, spriteName);
-};
-
-const removeSpriteOption = (event) => {
-  const presetNumber = document.getElementById('preset-number').value;
-  const playerSettings = JSON.parse(localStorage.getItem(`weightedSettings${presetNumber}`));
-  const spriteName = event.target.getAttribute('data-sprite');
-
-  // Remove option from playerSettings object
-  delete playerSettings.rom.sprite[spriteName];
-  localStorage.setItem(`weightedSettings${presetNumber}`, JSON.stringify(playerSettings));
-
-  // Remove <tr> from #sprite-options-table
-  const tr = document.getElementById(event.target.getAttribute('data-row-id'));
-  tr.parentNode.removeChild(tr);
-};
-
-const buildSpritePicker = (spriteData) => {
-  const spritePicker = document.createElement('div');
-  spritePicker.setAttribute('id', 'sprite-picker');
-
-  // Build description
-  const description = document.createElement('span');
-  description.innerText = 'To add a sprite to your playable list, click the one you want below.';
-  spritePicker.appendChild(description);
-
-  const sprites = document.createElement('div');
-  sprites.setAttribute('id', 'sprite-picker-sprites');
-  spriteData.sprites.forEach((sprite) => {
-    const spriteImg = document.createElement('img');
-    let spriteGifFile = sprite.file.split('.');
-    spriteGifFile.pop();
-    spriteGifFile = spriteGifFile.join('.') + '.gif';
-    spriteImg.setAttribute('src', `static/static/sprites/${spriteGifFile}`);
-    spriteImg.setAttribute('data-sprite', sprite.file.split('.')[0]);
-    spriteImg.setAttribute('alt', sprite.name);
-
-    // Wrap the image in a span to allow for tooltip presence
-    const imgWrapper = document.createElement('span');
-    imgWrapper.className = 'sprite-img-wrapper';
-    imgWrapper.setAttribute('data-tooltip', `${sprite.name}${sprite.author ? `, by ${sprite.author}` : ''}`);
-    imgWrapper.appendChild(spriteImg);
-    imgWrapper.setAttribute('data-sprite', sprite.name);
-    sprites.appendChild(imgWrapper);
-    imgWrapper.addEventListener('click', addSpriteOption);
-  });
-
-  spritePicker.appendChild(sprites);
-  return spritePicker;
-};
-
-const generateGame = (raceMode = false) => {
-  const presetNumber = document.getElementById('preset-number').value;
-  axios.post('/api/generate', {
-    weights: { player: localStorage.getItem(`weightedSettings${presetNumber}`) },
-    presetData: { player: localStorage.getItem(`weightedSettings${presetNumber}`) },
-    playerCount: 1,
-    race: raceMode ? '1' : '0',
-  }).then((response) => {
-    window.location.href = response.data.url;
-  }).catch((error) => {
-    const userMessage = document.getElementById('user-message');
-    userMessage.innerText = 'Something went wrong and your game could not be generated.';
-    userMessage.classList.add('visible');
-    window.scrollTo(0, 0);
-    console.error(error);
-  });
-};

WebHostLib/static/static/backgrounds/LICENSE

@@ -1,4 +1,3 @@
-Copyright 2020 Berserker66 (Fabian Dill)
-Copyright 2020 LegendaryLinux (Chris Wilson)
+Copyright 2022 LegendaryLinux (Chris Wilson)
 
 All rights reserved.