[WebHost] Fix /user-content styles (#408)

HK: write sets ordered, to reduce history changes

.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.79/sni-v0.0.79-windows-amd64.zip -OutFile sni.zip
+          Expand-Archive -Path sni.zip -DestinationPath SNI -Force
+          Invoke-WebRequest -Uri https://github.com/Ijwu/Enemizer/releases/download/6.4/win-x64.zip -OutFile enemizer.zip
+          Expand-Archive -Path enemizer.zip -DestinationPath EnemizerCLI -Force
+      - name: Build
+        run: |
+          python -m pip install --upgrade pip setuptools==60.10.0  # 61 does not work with the current layout
+          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/black-sliver/sni/releases/download/v0.0.78-2/sni-v0.0.78-2-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/6.4/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==60.10.0  # setuptools same as windows
+          "${{ 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/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-latest
+    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/black-sliver/sni/releases/download/v0.0.78-2/sni-v0.0.78-2-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/6.4/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,15 +7,29 @@ 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.9
+    - name: Set up Python ${{ matrix.python.version }}
       uses: actions/setup-python@v1
       with:
-        python-version: 3.9
+        python-version: ${{ matrix.python.version }}
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip

.gitignore

@@ -12,6 +12,7 @@
 *.sfc
 *.z64
 *.n64
+*.nes
 *.wixobj
 *.lck
 *.db3
@@ -26,14 +27,9 @@ dist
 README.html
 .vs/
 EnemizerCLI/
-RaceRom.py
-weights/
-/MultiMystery/
 /Players/
-/QUsb2Snes/
 /options.yaml
 /config.yaml
-/uploads/
 /logs/
 _persistent_storage.yaml
 mystery_result_*.yaml
@@ -44,6 +40,10 @@ Output Logs/
 /factorio/
 /Minecraft Forge Server/
 /WebHostLib/static/generated
+/freeze_requirements.txt
+/Archipelago.zip
+/setup.ini
+
 
 # Byte-compiled / optimized / DLL files
 __pycache__/
@@ -151,8 +151,9 @@ dmypy.json
 # Cython debug symbols
 cython_debug/
 
-Archipelago.zip
-
 #minecraft server stuff
 jdk*/
-minecraft*/
+minecraft*/
+
+#pyenv
+.python-version

BaseClasses.py

@@ -6,12 +6,22 @@ import logging
 import json
 import functools
 from collections import OrderedDict, Counter, deque
-from typing import List, Dict, Optional, Set, Iterable, Union, Any, Tuple
+from typing import List, Dict, Optional, Set, Iterable, Union, Any, Tuple, TypedDict, Callable
 import secrets
 import random
 
 import Options
 import Utils
+import NetUtils
+
+
+class Group(TypedDict, total=False):
+    name: str
+    game: str
+    world: auto_world
+    players: Set[int]
+    item_pool: Set[str]
+    replacement_items: Dict[int, Optional[str]]
 
 
 class MultiWorld():
@@ -23,11 +33,19 @@ class MultiWorld():
     dark_room_logic: Dict[int, str]
     restrict_dungeon_item_on_boss: Dict[int, bool]
     plando_texts: List[Dict[str, str]]
-    plando_items: List
+    plando_items: List[List[Dict[str, Any]]]
     plando_connections: List
     worlds: Dict[int, Any]
+    groups: Dict[int, Group]
+    itempool: List[Item]
     is_race: bool = False
     precollected_items: Dict[int, List[Item]]
+    state: CollectionState
+
+    accessibility: Dict[int, Options.Accessibility]
+    local_items: Dict[int, Options.LocalItems]
+    non_local_items: Dict[int, Options.NonLocalItems]
+    progression_balancing: Dict[int, Options.ProgressionBalancing]
 
     class AttributeProxy():
         def __init__(self, rule):
@@ -39,20 +57,21 @@ class MultiWorld():
     def __init__(self, players: int):
         self.random = random.Random()  # world-local random state is saved for multiple generations running concurrently
         self.players = players
+        self.player_types = {player: NetUtils.SlotType.player for player in self.player_ids}
         self.glitch_triforce = False
         self.algorithm = 'balanced'
         self.dungeons: Dict[Tuple[str, int], Dungeon] = {}
+        self.groups = {}
         self.regions = []
         self.shops = []
         self.itempool = []
         self.seed = None
         self.seed_name: str = "Unavailable"
         self.precollected_items = {player: [] for player in self.player_ids}
-        self.state = CollectionState(self)
         self._cached_entrances = None
         self._cached_locations = None
         self._entrance_cache = {}
-        self._location_cache = {}
+        self._location_cache: Dict[Tuple[str, int], Location] = {}
         self.required_locations = []
         self.light_world_light_cone = False
         self.dark_world_light_cone = False
@@ -63,8 +82,6 @@ class MultiWorld():
         self.custom = False
         self.customitemarray = []
         self.shuffle_ganon = True
-        self.dynamic_regions = []
-        self.dynamic_locations = []
         self.spoiler = Spoiler(self)
         self.fix_trock_doors = self.AttributeProxy(
             lambda player: self.shuffle[player] != 'vanilla' or self.mode[player] == 'inverted')
@@ -74,7 +91,6 @@ class MultiWorld():
             lambda player: self.shuffle[player] not in ['vanilla', 'simple', 'restricted', 'dungeonssimple'])
         self.fix_trock_exit = self.AttributeProxy(
             lambda player: self.shuffle[player] not in ['vanilla', 'simple', 'restricted', 'dungeonssimple'])
-        self.NOTCURSED = self.AttributeProxy(lambda player: not self.CURSED[player])
 
         for player in range(1, players + 1):
             def set_player_attr(attr, val):
@@ -130,6 +146,42 @@ class MultiWorld():
         self.worlds = {}
         self.slot_seeds = {}
 
+    def get_all_ids(self):
+        return self.player_ids + tuple(self.groups)
+
+    def add_group(self, name: str, game: str, players: Set[int] = frozenset()) -> Tuple[int, Group]:
+        """Create a group with name and return the assigned player ID and group.
+        If a group of this name already exists, the set of players is extended instead of creating a new one."""
+        for group_id, group in self.groups.items():
+            if group["name"] == name:
+                group["players"] |= players
+                return group_id, group
+        new_id: int = self.players + len(self.groups) + 1
+
+        self.game[new_id] = game
+        self.custom_data[new_id] = {}
+        self.player_types[new_id] = NetUtils.SlotType.group
+        self._region_cache[new_id] = {}
+        world_type = AutoWorld.AutoWorldRegister.world_types[game]
+        for option_key, option in world_type.options.items():
+            getattr(self, option_key)[new_id] = option(option.default)
+        for option_key, option in Options.common_options.items():
+            getattr(self, option_key)[new_id] = option(option.default)
+        for option_key, option in Options.per_game_common_options.items():
+            getattr(self, option_key)[new_id] = option(option.default)
+
+        self.worlds[new_id] = world_type(self, new_id)
+        self.worlds[new_id].collect_item = classmethod(AutoWorld.World.collect_item).__get__(self.worlds[new_id])
+        self.player_name[new_id] = name
+
+        new_group = self.groups[new_id] = Group(name=name, game=game, players=players,
+                                                world=self.worlds[new_id])
+
+        return new_id, new_group
+
+    def get_player_groups(self, player) -> Set[int]:
+        return {group_id for group_id, group in self.groups.items() if player in group["players"]}
+
     def set_seed(self, seed: Optional[int] = None, secure: bool = False, name: Optional[str] = None):
         self.seed = get_seed(seed)
         if secure:
@@ -141,24 +193,58 @@ class MultiWorld():
                            range(1, self.players + 1)}
 
     def set_options(self, args):
-        from worlds import AutoWorld
+        for option_key in Options.common_options:
+            setattr(self, option_key, getattr(args, option_key, {}))
+        for option_key in Options.per_game_common_options:
+            setattr(self, option_key, getattr(args, option_key, {}))
+
         for player in self.player_ids:
             self.custom_data[player] = {}
             world_type = AutoWorld.AutoWorldRegister.world_types[self.game[player]]
             for option_key in world_type.options:
                 setattr(self, option_key, getattr(args, option_key, {}))
-            for option_key in Options.common_options:
-                setattr(self, option_key, getattr(args, option_key, {}))
-            for option_key in Options.per_game_common_options:
-                setattr(self, option_key, getattr(args, option_key, {}))
+
             self.worlds[player] = world_type(self, player)
 
+    def set_item_links(self):
+        item_links = {}
+
+        for player in self.player_ids:
+            for item_link in self.item_links[player].value:
+                if item_link["name"] in item_links:
+                    if item_link["game"] != self.game[player]:
+                        raise Exception(f"Cannot ItemLink across games. Link: {item_link['name']}")
+                    item_links[item_link["name"]]["players"][player] = item_link["replacement_item"]
+                    item_links[item_link["name"]]["item_pool"] &= set(item_link["item_pool"])
+                else:
+                    if item_link["name"] in self.player_name.values():
+                        raise Exception(f"Cannot name a ItemLink group the same as a player ({item_link['name']}) ({self.get_player_name(player)}).")
+                    item_links[item_link["name"]] = {
+                        "players": {player: item_link["replacement_item"]},
+                        "item_pool": set(item_link["item_pool"]),
+                        "game": self.game[player]
+                    }
+
+        for name, item_link in item_links.items():
+            current_item_name_groups = AutoWorld.AutoWorldRegister.world_types[item_link["game"]].item_name_groups
+            pool = set()
+            for item in item_link["item_pool"]:
+                pool |= current_item_name_groups.get(item, {item})
+            item_link["item_pool"] = pool
+
+        for group_name, item_link in item_links.items():
+            game = item_link["game"]
+            group_id, group = self.add_group(group_name, game, set(item_link["players"]))
+            group["item_pool"] = item_link["item_pool"]
+            group["replacement_items"] = item_link["players"]
+
     # intended for unittests
     def set_default_common_options(self):
         for option_key, option in Options.common_options.items():
             setattr(self, option_key, {player_id: option(option.default) for player_id in self.player_ids})
         for option_key, option in Options.per_game_common_options.items():
             setattr(self, option_key, {player_id: option(option.default) for player_id in self.player_ids})
+        self.state = CollectionState(self)
 
     def secure(self):
         self.random = secrets.SystemRandom()
@@ -174,7 +260,8 @@ class MultiWorld():
 
     @functools.lru_cache()
     def get_game_worlds(self, game_name: str):
-        return tuple(world for player, world in self.worlds.items() if self.game[player] == game_name)
+        return tuple(world for player, world in self.worlds.items() if
+                     player not in self.groups and self.game[player] == game_name)
 
     def get_name_string_for_object(self, obj) -> str:
         return obj.name if self.players == 1 else f'{obj.name} ({self.get_player_name(obj.player)})'
@@ -182,6 +269,9 @@ class MultiWorld():
     def get_player_name(self, player: int) -> str:
         return self.player_name[player]
 
+    def get_file_safe_player_name(self, player: int) -> str:
+        return ''.join(c for c in self.get_player_name(player) if c not in '<>:"/\\|?*')
+
     def initialize_regions(self, regions=None):
         for region in regions if regions else self.regions:
             region.world = self
@@ -193,6 +283,7 @@ class MultiWorld():
 
     def _recache(self):
         """Rebuild world cache"""
+        self._cached_locations = None
         for region in self.regions:
             player = region.player
             self._region_cache[player][region.name] = region
@@ -241,10 +332,9 @@ class MultiWorld():
 
         for item in self.itempool:
             self.worlds[item.player].collect(ret, item)
-        from worlds.alttp.Dungeons import get_dungeon_item_pool
-        for item in get_dungeon_item_pool(self):
-            subworld = self.worlds[item.player]
-            if item.name in subworld.dungeon_local_item_names:
+        for player in self.player_ids:
+            subworld = self.worlds[player]
+            for item in subworld.get_pre_fill_items():
                 subworld.collect(ret, item)
         ret.sweep_for_events()
 
@@ -252,7 +342,7 @@ class MultiWorld():
             self._all_state = ret
         return ret
 
-    def get_items(self) -> list:
+    def get_items(self) -> List[Item]:
         return [loc.item for loc in self.get_filled_locations()] + self.itempool
 
     def find_item_locations(self, item, player: int) -> List[Location]:
@@ -307,7 +397,7 @@ class MultiWorld():
     def clear_location_cache(self):
         self._cached_locations = None
 
-    def get_unfilled_locations(self, player=None) -> List[Location]:
+    def get_unfilled_locations(self, player: Optional[int] = None) -> List[Location]:
         if player is not None:
             return [location for location in self.get_locations() if
                     location.player == player and not location.item]
@@ -316,13 +406,13 @@ class MultiWorld():
     def get_unfilled_dungeon_locations(self):
         return [location for location in self.get_locations() if not location.item and location.parent_region.dungeon]
 
-    def get_filled_locations(self, player=None) -> List[Location]:
+    def get_filled_locations(self, player: Optional[int] = None) -> List[Location]:
         if player is not None:
             return [location for location in self.get_locations() if
                     location.player == player and location.item is not None]
         return [location for location in self.get_locations() if location.item is not None]
 
-    def get_reachable_locations(self, state=None, player=None) -> List[Location]:
+    def get_reachable_locations(self, state: Optional[CollectionState] = None, player: Optional[int] = None) -> List[Location]:
         if state is None:
             state = self.state
         return [location for location in self.get_locations() if
@@ -334,13 +424,16 @@ class MultiWorld():
         return [location for location in self.get_locations() if
                 (player is None or location.player == player) and location.item is None and location.can_reach(state)]
 
-    def get_unfilled_locations_for_players(self, location_name: str, players: Iterable[int]):
+    def get_unfilled_locations_for_players(self, locations: List[str], players: Iterable[int]):
         for player in players:
-            location = self.get_location(location_name, player)
-            if location.item is None:
-                yield location
+            if len(locations) == 0:
+                locations = [location.name for location in self.get_unfilled_locations(player)]
+            for location_name in locations:
+                location = self._location_cache.get((location_name, player), None)
+                if location is not None and location.item is None:
+                    yield location
 
-    def unlocks_new_location(self, item) -> bool:
+    def unlocks_new_location(self, item: Item) -> bool:
         temp_state = self.state.copy()
         temp_state.collect(item, True)
 
@@ -350,7 +443,7 @@ class MultiWorld():
 
         return False
 
-    def has_beaten_game(self, state, player: Optional[int] = None):
+    def has_beaten_game(self, state: CollectionState, player: Optional[int] = None) -> bool:
         if player:
             return self.completion_condition[player](state)
         else:
@@ -429,8 +522,9 @@ class MultiWorld():
 
         def location_relevant(location: Location):
             """Determine if this location is relevant to sweep."""
-            if location.player in players["locations"] or location.event or \
-                    (location.item and location.item.advancement):
+            if location.progress_type != LocationProgressType.EXCLUDED \
+                and (location.player in players["locations"] or location.event
+                     or (location.item and location.item.advancement)):
                 return True
             return False
 
@@ -468,17 +562,21 @@ class MultiWorld():
         return False
 
 
-class CollectionState(object):
+class CollectionState():
+    additional_init_functions: List[Callable] = []
+    additional_copy_functions: List[Callable] = []
 
     def __init__(self, parent: MultiWorld):
         self.prog_items = Counter()
         self.world = parent
-        self.reachable_regions = {player: set() for player in range(1, parent.players + 1)}
-        self.blocked_connections = {player: set() for player in range(1, parent.players + 1)}
+        self.reachable_regions = {player: set() for player in parent.get_all_ids()}
+        self.blocked_connections = {player: set() for player in parent.get_all_ids()}
         self.events = set()
         self.path = {}
         self.locations_checked = set()
-        self.stale = {player: True for player in range(1, parent.players + 1)}
+        self.stale = {player: True for player in parent.get_all_ids()}
+        for function in self.additional_init_functions:
+            function(self, parent)
         for items in parent.precollected_items.values():
             for item in items:
                 self.collect(item, True)
@@ -520,16 +618,21 @@ class CollectionState(object):
         ret = CollectionState(self.world)
         ret.prog_items = self.prog_items.copy()
         ret.reachable_regions = {player: copy.copy(self.reachable_regions[player]) for player in
-                                 range(1, self.world.players + 1)}
+                                 self.reachable_regions}
         ret.blocked_connections = {player: copy.copy(self.blocked_connections[player]) for player in
-                                   range(1, self.world.players + 1)}
+                                   self.blocked_connections}
         ret.events = copy.copy(self.events)
         ret.path = copy.copy(self.path)
         ret.locations_checked = copy.copy(self.locations_checked)
+        for function in self.additional_copy_functions:
+            ret = function(self, ret)
         return ret
 
-    def can_reach(self, spot, resolution_hint=None, player=None) -> bool:
-        if not hasattr(spot, "spot_type"):
+    def can_reach(self,
+                  spot: Union[Location, Entrance, Region, str],
+                  resolution_hint: Optional[str] = None,
+                  player: Optional[int] = None) -> bool:
+        if not hasattr(spot, "can_reach"):
             # try to resolve a name
             if resolution_hint == 'Location':
                 spot = self.world.get_location(spot, player)
@@ -540,30 +643,32 @@ class CollectionState(object):
                 spot = self.world.get_region(spot, player)
         return spot.can_reach(self)
 
-    def sweep_for_events(self, key_only: bool = False, locations=None):
+    def sweep_for_events(self, key_only: bool = False, locations: Set[Location] = None):
         if locations is None:
             locations = self.world.get_filled_locations()
         new_locations = True
         # since the loop has a good chance to run more than once, only filter the events once
-        locations = {location for location in locations if location.event}
+        locations = {location for location in locations if location.event and
+                     not key_only or getattr(location.item, "locked_dungeon_item", False)}
         while new_locations:
-            reachable_events = {location for location in locations if
-                                (not key_only or getattr(location.item, "locked_dungeon_item", False))
-                                and location.can_reach(self)}
+            reachable_events = {location for location in locations if location.can_reach(self)}
             new_locations = reachable_events - self.events
             for event in new_locations:
                 self.events.add(event)
                 self.collect(event.item, True, event)
 
-    def has(self, item, player: int, count: int = 1):
+    def has(self, item: str, player: int, count: int = 1) -> bool:
         return self.prog_items[item, player] >= count
 
-    def has_all(self, items: Set[str], player: int):
+    def has_all(self, items: Set[str], player: int) -> bool:
         return all(self.prog_items[item, player] for item in items)
 
-    def has_any(self, items: Set[str], player: int):
+    def has_any(self, items: Set[str], player: int) -> bool:
         return any(self.prog_items[item, player] for item in items)
 
+    def count(self, item: str, player: int) -> int:
+        return self.prog_items[item, player]
+
     def has_group(self, item_name_group: str, player: int, count: int = 1):
         found: int = 0
         for item_name in self.world.worlds[player].item_name_groups[item_name_group]:
@@ -638,7 +743,7 @@ class CollectionState(object):
                 basemagic = basemagic + basemagic * self.bottle_count(player)
         return basemagic >= smallmagic
 
-    def can_kill_most_things(self, player: int, enemies=5) -> bool:
+    def can_kill_most_things(self, player: int, enemies: int = 5) -> bool:
         return (self.has_melee_weapon(player)
                 or self.has('Cane of Somaria', player)
                 or (self.has('Cane of Byrna', player) and (enemies < 6 or self.can_extend_magic(player)))
@@ -713,26 +818,26 @@ class CollectionState(object):
     def has_turtle_rock_medallion(self, player: int) -> bool:
         return self.has(self.world.required_medallions[player][1], player)
 
-    def can_boots_clip_lw(self, player: int):
+    def can_boots_clip_lw(self, player: int) -> bool:
         if self.world.mode[player] == 'inverted':
             return self.has('Pegasus Boots', player) and self.has('Moon Pearl', player)
         return self.has('Pegasus Boots', player)
 
-    def can_boots_clip_dw(self, player: int):
+    def can_boots_clip_dw(self, player: int) -> bool:
         if self.world.mode[player] != 'inverted':
             return self.has('Pegasus Boots', player) and self.has('Moon Pearl', player)
         return self.has('Pegasus Boots', player)
 
-    def can_get_glitched_speed_lw(self, player: int):
+    def can_get_glitched_speed_lw(self, player: int) -> bool:
         rules = [self.has('Pegasus Boots', player), any([self.has('Hookshot', player), self.has_sword(player)])]
         if self.world.mode[player] == 'inverted':
             rules.append(self.has('Moon Pearl', player))
         return all(rules)
 
-    def can_superbunny_mirror_with_sword(self, player: int):
+    def can_superbunny_mirror_with_sword(self, player: int) -> bool:
         return self.has('Magic Mirror', player) and self.has_sword(player)
 
-    def can_get_glitched_speed_dw(self, player: int):
+    def can_get_glitched_speed_dw(self, player: int) -> bool:
         rules = [self.has('Pegasus Boots', player), any([self.has('Hookshot', player), self.has_sword(player)])]
         if self.world.mode[player] != 'inverted':
             rules.append(self.has('Moon Pearl', player))
@@ -741,7 +846,7 @@ class CollectionState(object):
     def can_bomb_clip(self, region: Region, player: int) -> bool:
         return self.is_not_bunny(region, player) and self.has('Pegasus Boots', player)
 
-    def collect(self, item: Item, event: bool = False, location: Location = None) -> bool:
+    def collect(self, item: Item, event: bool = False, location: Optional[Location] = None) -> bool:
         if location:
             self.locations_checked.add(location)
 
@@ -781,20 +886,30 @@ class RegionType(int, Enum):
         return self in (RegionType.Cave, RegionType.Dungeon)
 
 
-class Region(object):
+class Region:
+    name: str
+    type: RegionType
+    hint_text: str
+    player: int
+    world: Optional[MultiWorld]
+    entrances: List[Entrance]
+    exits: List[Entrance]
+    locations: List[Location]
+    dungeon: Optional[Dungeon] = None
+    shop: Optional = None
 
-    def __init__(self, name: str, type: str, hint, player: int, world: Optional[MultiWorld] = None):
+    # LttP specific. TODO: move to a LttPRegion
+    # will be set after making connections.
+    is_light_world: bool = False
+    is_dark_world: bool = False
+
+    def __init__(self, name: str, type_: RegionType, hint: str, player: int, world: Optional[MultiWorld] = None):
         self.name = name
-        self.type = type
+        self.type = type_
         self.entrances = []
         self.exits = []
         self.locations = []
-        self.dungeon = None
-        self.shop = None
         self.world = world
-        self.is_light_world = False  # will be set after making connections.
-        self.is_dark_world = False
-        self.spot_type = 'Region'
         self.hint_text = hint
         self.player = player
 
@@ -818,18 +933,21 @@ class Region(object):
         return self.world.get_name_string_for_object(self) if self.world else f'{self.name} (Player {self.player})'
 
 
-class Entrance(object):
-    spot_type = 'Entrance'
+class Entrance:
+    access_rule: Callable[[CollectionState], bool] = staticmethod(lambda state: True)
+    hide_path: bool = False
+    player: int
+    name: str
+    parent_region: Optional[Region]
+    connected_region: Optional[Region] = None
+    # LttP specific, TODO: should make a LttPEntrance
+    addresses = None
+    target = None
 
-    def __init__(self, player: int, name: str = '', parent=None):
+    def __init__(self, player: int, name: str = '', parent: Region = None):
         self.name = name
         self.parent_region = parent
-        self.connected_region = None
-        self.target = None
-        self.addresses = None
-        self.access_rule = lambda state: True
         self.player = player
-        self.hide_path = False
 
     def can_reach(self, state: CollectionState) -> bool:
         if self.parent_region.can_reach(state) and self.access_rule(state):
@@ -839,7 +957,7 @@ class Entrance(object):
 
         return False
 
-    def connect(self, region: Region, addresses=None, target = None):
+    def connect(self, region: Region, addresses=None, target=None):
         self.connected_region = region
         self.target = target
         self.addresses = addresses
@@ -854,7 +972,8 @@ class Entrance(object):
 
 
 class Dungeon(object):
-    def __init__(self, name: str, regions, big_key, small_keys, dungeon_items, player: int):
+    def __init__(self, name: str, regions: List[Region], big_key: Item, small_keys: List[Item],
+                 dungeon_items: List[Item], player: int):
         self.name = name
         self.regions = regions
         self.big_key = big_key
@@ -873,11 +992,11 @@ class Dungeon(object):
         self.bosses[None] = value
 
     @property
-    def keys(self):
+    def keys(self) -> List[Item]:
         return self.small_keys + ([self.big_key] if self.big_key else [])
 
     @property
-    def all_items(self):
+    def all_items(self) -> List[Item]:
         return self.dungeon_items + self.keys
 
     def is_dungeon_item(self, item: Item) -> bool:
@@ -896,7 +1015,7 @@ class Dungeon(object):
 
 
 class Boss():
-    def __init__(self, name: str, enemizer_name: str, defeat_rule, player: int):
+    def __init__(self, name: str, enemizer_name: str, defeat_rule: Callable, player: int):
         self.name = name
         self.enemizer_name = enemizer_name
         self.defeat_rule = defeat_rule
@@ -909,27 +1028,33 @@ class Boss():
         return f"Boss({self.name})"
 
 
-class Location():
+class LocationProgressType(Enum):
+    DEFAULT = 1
+    PRIORITY = 2
+    EXCLUDED = 3
+
+
+class Location:
     # If given as integer, then this is the shop's inventory index
     shop_slot: Optional[int] = None
     shop_slot_disabled: bool = False
     event: bool = False
     locked: bool = False
-    spot_type = 'Location'
     game: str = "Generic"
     show_in_spoiler: bool = True
-    excluded: bool = False
     crystal: bool = False
+    progress_type: LocationProgressType = LocationProgressType.DEFAULT
     always_allow = staticmethod(lambda item, state: False)
     access_rule = staticmethod(lambda state: True)
     item_rule = staticmethod(lambda item: True)
+    item: Optional[Item] = None
+    parent_region: Optional[Region]
 
     def __init__(self, player: int, name: str = '', address: int = None, parent=None):
         self.name: str = name
         self.address: Optional[int] = address
-        self.parent_region: Region = parent
+        self.parent_region = parent
         self.player: int = player
-        self.item: Optional[Item] = None
 
     def can_fill(self, state: CollectionState, item: Item, check_access=True) -> bool:
         return self.always_allow(state, item) or (self.item_rule(item) and (not check_access or self.can_reach(state)))
@@ -944,6 +1069,7 @@ class Location():
         if self.item:
             raise Exception(f"Location {self} already filled.")
         self.item = item
+        item.location = self
         self.event = item.advancement
         self.item.world = self.parent_region.world
         self.locked = True
@@ -958,7 +1084,7 @@ class Location():
     def __hash__(self):
         return hash((self.name, self.player))
 
-    def __lt__(self, other):
+    def __lt__(self, other: Location):
         return (self.player, self.name) < (other.player, other.name)
 
     @property
@@ -967,7 +1093,7 @@ class Location():
         return self.item and self.item.game == self.game
 
     @property
-    def hint_text(self):
+    def hint_text(self) -> str:
         hint_text = getattr(self, "_hint_text", None)
         if hint_text:
             return hint_text
@@ -985,6 +1111,8 @@ class Item():
     trap: bool = False
     # change manually to ensure that a specific non-progression item never goes on an excluded location
     never_exclude = False
+    # item is not considered by progression balancing despite being progression
+    skip_in_prog_balancing: bool = False
 
     # need to find a decent place for these to live and to allow other games to register texts if they want.
     pedestal_credit_text: str = "and the Unknown Item"
@@ -1013,10 +1141,14 @@ class Item():
     def pedestal_hint_text(self):
         return getattr(self, "_pedestal_hint_text", self.name.replace("_", " ").replace("-", " "))
 
+    @property
+    def flags(self) -> int:
+        return self.advancement + (self.never_exclude << 1) + (self.trap << 2)
+
     def __eq__(self, other):
         return self.name == other.name and self.player == other.player
 
-    def __lt__(self, other):
+    def __lt__(self, other: Item):
         if other.player != self.player:
             return other.player < self.player
         return self.name < other.name
@@ -1033,6 +1165,7 @@ class Item():
 
 class Spoiler():
     world: MultiWorld
+    unreachables: Set[Location]
 
     def __init__(self, world):
         self.world = world
@@ -1040,19 +1173,19 @@ class Spoiler():
         self.entrances = OrderedDict()
         self.medallions = {}
         self.playthrough = {}
-        self.unreachables = []
+        self.unreachables = set()
         self.locations = {}
         self.paths = {}
         self.shops = []
         self.bosses = OrderedDict()
 
-    def set_entrance(self, entrance, exit, direction, player):
+    def set_entrance(self, entrance: str, exit_: str, direction: str, player: int):
         if self.world.players == 1:
             self.entrances[(entrance, direction, player)] = OrderedDict(
-                [('entrance', entrance), ('exit', exit), ('direction', direction)])
+                [('entrance', entrance), ('exit', exit_), ('direction', direction)])
         else:
             self.entrances[(entrance, direction, player)] = OrderedDict(
-                [('player', player), ('entrance', entrance), ('exit', exit), ('direction', direction)])
+                [('player', player), ('entrance', entrance), ('exit', exit_), ('direction', direction)])
 
     def parse_data(self):
         self.medallions = OrderedDict()
@@ -1181,8 +1314,7 @@ class Spoiler():
 
         return json.dumps(out)
 
-    def to_file(self, filename):
-        from worlds.AutoWorld import call_all, call_single, call_stage
+    def to_file(self, filename: str):
         self.parse_data()
 
         def bool_to_text(variable: Union[bool, str]) -> str:
@@ -1192,9 +1324,9 @@ class Spoiler():
 
         def write_option(option_key: str, option_obj: type(Options.Option)):
             res = getattr(self.world, option_key)[player]
-            displayname = getattr(option_obj, "displayname", option_key)
+            display_name = getattr(option_obj, "display_name", option_key)
             try:
-                outfile.write(f'{displayname + ":":33}{res.get_current_option_name()}\n')
+                outfile.write(f'{display_name + ":":33}{res.get_current_option_name()}\n')
             except:
                 raise Exception
 
@@ -1204,21 +1336,19 @@ class Spoiler():
                     Utils.__version__, self.world.seed))
             outfile.write('Filling Algorithm:               %s\n' % self.world.algorithm)
             outfile.write('Players:                         %d\n' % self.world.players)
-            call_stage(self.world, "write_spoiler_header", outfile)
+            AutoWorld.call_stage(self.world, "write_spoiler_header", outfile)
 
             for player in range(1, self.world.players + 1):
                 if self.world.players > 1:
                     outfile.write('\nPlayer %d: %s\n' % (player, self.world.get_player_name(player)))
                 outfile.write('Game:                            %s\n' % self.world.game[player])
-                for f_option, option in Options.common_options.items():
-                    write_option(f_option, option)
                 for f_option, option in Options.per_game_common_options.items():
                     write_option(f_option, option)
                 options = self.world.worlds[player].options
                 if options:
                     for f_option, option in options.items():
                         write_option(f_option, option)
-                call_single(self.world, "write_spoiler_header", player, outfile)
+                AutoWorld.call_single(self.world, "write_spoiler_header", player, outfile)
 
                 if player in self.world.get_game_players("A Link to the Past"):
                     outfile.write('%s%s\n' % ('Hash: ', self.hashes[player]))
@@ -1268,7 +1398,7 @@ class Spoiler():
                 for dungeon, medallion in self.medallions.items():
                     outfile.write(f'\n{dungeon}: {medallion}')
 
-            call_all(self.world, "write_spoiler", outfile)
+            AutoWorld.call_all(self.world, "write_spoiler", outfile)
 
             outfile.write('\n\nLocations:\n\n')
             outfile.write('\n'.join(
@@ -1309,14 +1439,19 @@ class Spoiler():
                     path_listings.append("{}\n        {}".format(location, "\n   =>   ".join(path_lines)))
 
                 outfile.write('\n'.join(path_listings))
-            call_all(self.world, "write_spoiler_end", outfile)
+            AutoWorld.call_all(self.world, "write_spoiler_end", outfile)
 
 
 seeddigits = 20
 
 
-def get_seed(seed=None):
+def get_seed(seed=None) -> int:
     if seed is None:
         random.seed(None)
         return random.randint(0, pow(10, seeddigits) - 1)
     return seed
+
+
+from worlds import AutoWorld
+
+auto_world = AutoWorld.World

ChecksFinderClient.py

@@ -0,0 +1,660 @@
+from __future__ import annotations
+import os
+import logging
+import asyncio
+import urllib.parse
+import sys
+import typing
+import time
+
+import websockets
+
+import Utils
+
+if __name__ == "__main__":
+    Utils.init_logging("ChecksFinderClient", exception_logger="Client")
+
+from MultiServer import CommandProcessor
+from NetUtils import Endpoint, decode, NetworkItem, encode, JSONtoTextParser, ClientStatus, Permission
+from Utils import Version, stream_input
+from worlds import network_data_package, AutoWorldRegister
+from CommonClient import gui_enabled, console_loop, logger, server_autoreconnect, get_base_parser, \
+    keep_alive
+from worlds.checksfinder import ChecksFinderWorld
+
+
+class ClientCommandProcessor(CommandProcessor):
+    def __init__(self, ctx: CommonContext):
+        self.ctx = ctx
+
+    def output(self, text: str):
+        logger.info(text)
+
+    def _cmd_exit(self) -> bool:
+        """Close connections and client"""
+        self.ctx.exit_event.set()
+        return True
+
+    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), 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(), name="disconnecting")
+        return True
+
+    def _cmd_received(self) -> bool:
+        """List all received items"""
+        logger.info(f'{len(self.ctx.items_received)} received items:')
+        for index, item in enumerate(self.ctx.items_received, 1):
+            self.output(f"{self.ctx.item_name_getter(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 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:
+                if location_id in self.ctx.missing_locations:
+                    self.output('Missing: ' + location)
+                    count += 1
+                elif location_id in self.ctx.checked_locations:
+                    self.output('Checked: ' + location)
+                    count += 1
+                    checked_count += 1
+
+        if count:
+            self.output(
+                f"Found {count} missing location checks{f'. {checked_count} location checks previously visited.' if checked_count else ''}")
+        else:
+            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_resync(self):
+        """Manually trigger a resync."""
+        self.output(f"Syncing items.")
+        self.ctx.syncing = True
+
+    def _cmd_ready(self):
+        """Send ready status to server."""
+        self.ctx.ready = not self.ctx.ready
+        if self.ctx.ready:
+            state = ClientStatus.CLIENT_READY
+            self.output("Readied up.")
+        else:
+            state = ClientStatus.CLIENT_CONNECTED
+            self.output("Unreadied.")
+        asyncio.create_task(self.ctx.send_msgs([{"cmd": "StatusUpdate", "status": state}]), name="send StatusUpdate")
+
+    def default(self, raw: str):
+        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():
+    tags: typing.Set[str] = {"AP"}
+    starting_reconnect_delay: int = 5
+    current_reconnect_delay: int = starting_reconnect_delay
+    command_processor: int = ClientCommandProcessor
+    game = None
+    ui = None
+    keep_alive_task = None
+    items_handling: typing.Optional[int] = None
+    current_energy_link_value = 0  # to display in UI, gets set by server
+
+    def __init__(self, server_address, password):
+        # server state
+        self.send_index: int = 0
+        self.server_address = server_address
+        self.password = password
+        self.syncing = False
+        self.awaiting_bridge = False
+        self.server_task = None
+        self.server: typing.Optional[Endpoint] = None
+        self.server_version = Version(0, 0, 0)
+        self.hint_cost: typing.Optional[int] = None
+        self.games: typing.Dict[int, str] = {}
+        self.permissions = {
+            "forfeit": "disabled",
+            "collect": "disabled",
+            "remaining": "disabled",
+        }
+
+        # own state
+        self.finished_game = False
+        self.ready = False
+        self.team = None
+        self.slot = None
+        self.auth = None
+        self.seed_name = None
+
+        self.locations_checked: typing.Set[int] = set()  # local state
+        self.locations_scouted: typing.Set[int] = set()
+        self.items_received = []
+        self.missing_locations: typing.Set[int] = set()
+        self.checked_locations: typing.Set[int] = set()  # server state
+        self.locations_info = {}
+
+        self.input_queue = asyncio.Queue()
+        self.input_requests = 0
+
+        self.last_death_link: float = time.time()  # last send/received death link on AP layer
+
+        # game state
+        self.player_names: typing.Dict[int: str] = {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)
+
+        # 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.auth = 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
+        path = os.path.expandvars(r"%localappdata%/ChecksFinder")
+        for root, dirs, files in os.walk(path):
+            for file in files:
+                if file.find("obtain") <= -1:
+                    os.remove(root+"/"+file)
+
+    # noinspection PyAttributeOutsideInit
+    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
+
+            if data_package["version"] > network_data_package["version"]:
+                Utils.persistent_store("datapackage", "latest", network_data_package)
+
+        item_lookup: dict = {}
+        locations_lookup: dict = {}
+        for game, gamedata in data_package["games"].items():
+            for item_name, item_id in gamedata["item_name_to_id"].items():
+                item_lookup[item_id] = item_name
+            for location_name, location_id in gamedata["location_name_to_id"].items():
+                locations_lookup[location_id] = location_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 []
+
+    async def disconnect(self):
+        if self.server and not self.server.socket.closed:
+            await self.server.socket.close()
+        if self.server_task is not None:
+            await self.server_task
+
+    async def send_msgs(self, msgs):
+        if not self.server or not self.server.socket.open or self.server.socket.closed:
+            return
+        await self.server.socket.send(encode(msgs))
+
+    def consume_players_package(self, package: typing.List[tuple]):
+        self.player_names = {slot: name for team, slot, name, orig_name in package if self.team == team}
+        self.player_names[0] = "Archipelago"
+
+    def event_invalid_slot(self):
+        raise Exception('Invalid Slot; please verify that you have connected to the correct world.')
+
+    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 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):
+        await self.disconnect()
+        self.server_task = asyncio.create_task(server_loop(self, address), name="server loop")
+
+    def on_print(self, args: dict):
+        logger.info(args["text"])
+
+    def on_print_json(self, args: dict):
+        if self.ui:
+            self.ui.print_json(args["data"])
+        else:
+            text = self.jsontotextparser(args["data"])
+            logger.info(text)
+
+    def on_package(self, cmd: str, args: dict):
+        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 = 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()
+        path = os.path.expandvars(r"%localappdata%/ChecksFinder")
+        for root, dirs, files in os.walk(path):
+            for file in files:
+                if file.find("obtain") <= -1:
+                    os.remove(root+"/"+file)
+
+    # 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):
+        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}])
+
+
+async def server_loop(ctx: CommonContext, address=None):
+    cached_address = None
+    if ctx.server and ctx.server.socket:
+        logger.error('Already connected')
+        return
+
+    if address is None:  # set through CLI or APBP
+        address = ctx.server_address
+
+    # Wait for the user to provide a multiworld server address
+    if not address:
+        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
+    logger.info(f'Connecting to Archipelago server at {address}')
+    try:
+        socket = await websockets.connect(address, port=port, ping_timeout=None, ping_interval=None)
+        ctx.server = Endpoint(socket)
+        logger.info('Connected')
+        ctx.server_address = address
+        ctx.current_reconnect_delay = ctx.starting_reconnect_delay
+        async for data in ctx.server.socket:
+            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.exception('Connection refused by the multiworld server')
+    except websockets.InvalidURI:
+        logger.exception('Failed to connect to the multiworld server (invalid URI)')
+    except (OSError, websockets.InvalidURI):
+        logger.exception('Failed to connect to the multiworld server')
+    except Exception as e:
+        logger.exception('Lost connection to the multiworld server, type /connect to reconnect')
+    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), name="server auto reconnect")
+        ctx.current_reconnect_delay *= 2
+
+
+async def process_server_cmd(ctx: CommonContext, args: dict):
+    try:
+        cmd = args["cmd"]
+    except:
+        logger.exception(f"Could not get command from {args}")
+        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)")
+        else:
+            logger.info('--------------------------------')
+            logger.info('Room Information:')
+            logger.info('--------------------------------')
+            version = args["version"]
+            ctx.server_version = tuple(version)
+            version = ".".join(str(item) for item in version)
+
+            logger.info(f'Server protocol version: {version}')
+            logger.info("Server protocol tags: " + ", ".join(args["tags"]))
+            if args['password']:
+                logger.info('Password required')
+            ctx.update_permissions(args.get("permissions", {}))
+            if "games" in args:
+                ctx.games = {x: game for x, game in enumerate(args["games"], start=1)}
+            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'])
+
+            if len(args['players']) < 1:
+                logger.info('No player connected')
+            else:
+                args['players'].sort()
+                current_team = -1
+                logger.info('Connected Players:')
+                for network_player in args['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"}])
+            await ctx.server_auth(args['password'])
+
+    elif cmd == 'DataPackage':
+        logger.info("Got new ID/Name Datapackage")
+        ctx.set_getters(args['data'], network=True)
+
+    elif cmd == 'ConnectionRefused':
+        errors = args["errors"]
+        if 'InvalidSlot' in errors:
+            ctx.event_invalid_slot()
+        elif 'InvalidGame' in errors:
+            ctx.event_invalid_game()
+        elif 'SlotAlreadyTaken' in errors:
+            raise Exception('Player slot already in use for that team')
+        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)
+        elif errors:
+            raise Exception("Unknown connection errors: " + str(errors))
+        else:
+            raise Exception('Connection refused by the multiworld host, no reason provided')
+
+    elif cmd == 'Connected':
+        if not os.path.exists(os.path.expandvars(r"%localappdata%/ChecksFinder")):
+            os.mkdir(os.path.expandvars(r"%localappdata%/ChecksFinder"))
+        ctx.team = args["team"]
+        ctx.slot = args["slot"]
+        ctx.consume_players_package(args["players"])
+        msgs = []
+        if ctx.locations_checked:
+            msgs.append({"cmd": "LocationChecks",
+                         "locations": list(ctx.locations_checked)})
+        if ctx.locations_scouted:
+            msgs.append({"cmd": "LocationScouts",
+                         "locations": list(ctx.locations_scouted)})
+        if msgs:
+            await ctx.send_msgs(msgs)
+        if ctx.finished_game:
+            await ctx.send_msgs([{"cmd": "StatusUpdate", "status": ClientStatus.CLIENT_GOAL}])
+
+        # Get the server side view of missing as of time of connecting.
+        # 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 = set(args["missing_locations"])
+        ctx.checked_locations = set(args["checked_locations"])
+        for ss in ctx.checked_locations:
+            filename = f"send{ss}"
+            with open(os.path.expandvars(r"%localappdata%/ChecksFinder/"+filename), 'w') as f:
+                f.close()
+
+    elif cmd == 'ReceivedItems':
+        start_index = args["index"]
+
+        if start_index == 0:
+            ctx.items_received = []
+        elif start_index != len(ctx.items_received):
+            sync_msg = [{'cmd': 'Sync'}]
+            if ctx.locations_checked:
+                sync_msg.append({"cmd": "LocationChecks",
+                                 "locations": list(ctx.locations_checked)})
+            await ctx.send_msgs(sync_msg)
+        if start_index == len(ctx.items_received):
+            for item in args['items']:
+                filename = f"AP_{str(NetworkItem(*item).location)}PLR{str(NetworkItem(*item).player)}.item"
+                with open(os.path.expandvars(r"%localappdata%/ChecksFinder/"+filename), 'w') as f:
+                    f.write(str(NetworkItem(*item).item))
+                    f.close()
+                ctx.items_received.append(NetworkItem(*item))
+        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)
+        ctx.watcher_event.set()
+
+    elif cmd == "RoomUpdate":
+        if "players" in args:
+            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
+            for ss in ctx.checked_locations:
+                filename = f"send{ss}"
+                with open(os.path.expandvars(r"%localappdata%/ChecksFinder/"+filename), 'w') as f:
+                    f.close()
+        if "permissions" in args:
+            ctx.update_permissions(args["permissions"])
+
+    elif cmd == 'Print':
+        ctx.on_print(args)
+
+    elif cmd == 'PrintJSON':
+        ctx.on_print_json(args)
+
+    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 game_watcher(ctx: CommonContext):
+    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
+        path = os.path.expandvars(r"%localappdata%/ChecksFinder")
+        sending = []
+        victory = False
+        for root, dirs, files in os.walk(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__':
+    # Text Mode to use !hint and such with games that have no text entry
+
+    class TextContext(CommonContext):
+        game = "ChecksFinder"
+        items_handling = 0b111  # full remote
+
+        async def server_auth(self, password_requested: bool = False):
+            if password_requested and not self.password:
+                await super(TextContext, self).server_auth(password_requested)
+            if not self.auth:
+                logger.info('Enter slot name:')
+                self.auth = await self.console_input()
+
+            await self.send_connect()
+
+        def on_package(self, cmd: str, args: dict):
+            if cmd == "Connected":
+                self.game = self.games.get(self.slot, None)
+
+
+    async def main(args):
+        ctx = TextContext(args.connect, args.password)
+        ctx.server_task = asyncio.create_task(server_loop(ctx), name="server loop")
+        input_task = None
+        if gui_enabled:
+            from kvui import ChecksFinderManager
+            ctx.ui = ChecksFinderManager(ctx)
+            ui_task = asyncio.create_task(ctx.ui.async_run(), name="UI")
+        else:
+            ui_task = None
+        if sys.stdin:
+            input_task = asyncio.create_task(console_loop(ctx), name="Input")
+        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()
+        if ui_task:
+            await ui_task
+
+        if input_task:
+            input_task.cancel()
+
+    import colorama
+
+    parser = get_base_parser(description="ChecksFinder Client, for text interfacing.")
+
+    args, rest = parser.parse_known_args()
+    colorama.init()
+
+    loop = asyncio.get_event_loop()
+    loop.run_until_complete(main(args))
+    loop.close()
+    colorama.deinit()

CommonClient.py

@@ -118,6 +118,8 @@ class CommonContext():
     game = None
     ui = None
     keep_alive_task = None
+    items_handling: typing.Optional[int] = None
+    current_energy_link_value = 0  # to display in UI, gets set by server
 
     def __init__(self, server_address, password):
         # server state
@@ -147,7 +149,7 @@ class CommonContext():
         self.items_received = []
         self.missing_locations: typing.Set[int] = set()
         self.checked_locations: typing.Set[int] = set()  # server state
-        self.locations_info = {}
+        self.locations_info: typing.Dict[int, NetworkItem] = {}
 
         self.input_queue = asyncio.Queue()
         self.input_requests = 0
@@ -247,9 +249,9 @@ class CommonContext():
 
     async def send_connect(self, **kwargs):
         payload = {
-            "cmd": 'Connect',
+            'cmd': 'Connect',
             'password': self.password, 'name': self.auth, 'version': Utils.version_tuple,
-            'tags': self.tags,
+            'tags': self.tags, 'items_handling': self.items_handling,
             'uuid': Utils.get_unique_identifier(), 'game': self.game
         }
         if kwargs:
@@ -316,16 +318,17 @@ class CommonContext():
             logger.info(f"DeathLink: Received from {data['source']}")
 
     async def send_death(self, death_text: str = ""):
-        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
-            }
-        }])
+        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):
         old_tags = self.tags.copy()
@@ -440,7 +443,7 @@ async def process_server_cmd(ctx: CommonContext, args: dict):
             else:
                 args['players'].sort()
                 current_team = -1
-                logger.info('Players:')
+                logger.info('Connected Players:')
                 for network_player in args['players']:
                     if network_player.team != current_team:
                         logger.info(f'  Team #{network_player.team + 1}')
@@ -464,6 +467,8 @@ async def process_server_cmd(ctx: CommonContext, args: dict):
             raise Exception('Player slot already in use for that team')
         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')
@@ -514,9 +519,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":
@@ -545,7 +549,11 @@ async def process_server_cmd(ctx: CommonContext, args: dict):
         # we can skip checking "DeathLink" in ctx.tags, as otherwise we wouldn't have been send this
         if "DeathLink" in tags and ctx.last_death_link != args["data"]["time"]:
             ctx.on_deathlink(args["data"])
-
+    elif cmd == "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}")
 
@@ -587,8 +595,9 @@ if __name__ == '__main__':
     # Text Mode to use !hint and such with games that have no text entry
 
     class TextContext(CommonContext):
-        tags = {"AP", "IgnoreGame"}
+        tags = {"AP", "IgnoreGame", "TextOnly"}
         game = "Archipelago"
+        items_handling = 0  # don't receive any NetworkItems
 
         async def server_auth(self, password_requested: bool = False):
             if password_requested and not self.password:

FF1Client.py

@@ -18,6 +18,8 @@ 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):
@@ -28,8 +30,17 @@ class FF1CommandProcessor(ClientCommandProcessor):
         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
+    items_handling = 0b111  # full remote
+
     def __init__(self, server_address, password):
         super().__init__(server_address, password)
         self.nes_streams: (StreamReader, StreamWriter) = None
@@ -39,8 +50,7 @@ class FF1Context(CommonContext):
         self.nes_status = CONNECTION_INITIAL_STATUS
         self.game = 'Final Fantasy'
         self.awaiting_rom = False
-
-    command_processor = FF1CommandProcessor
+        self.display_msgs = True
 
     async def server_auth(self, password_requested: bool = False):
         if password_requested and not self.password:
@@ -53,7 +63,8 @@ class FF1Context(CommonContext):
         await self.send_connect()
 
     def _set_message(self, msg: str, msg_id: int):
-        self.messages[(time.time(), msg_id)] = msg
+        if DISPLAY_MSGS:
+            self.messages[(time.time(), msg_id)] = msg
 
     def on_package(self, cmd: str, args: dict):
         if cmd == 'Connected':
@@ -214,6 +225,9 @@ 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")

FactorioClient.py

@@ -19,7 +19,7 @@ if __name__ == "__main__":
     Utils.init_logging("FactorioClient", exception_logger="Client")
 
 from CommonClient import CommonContext, server_loop, console_loop, ClientCommandProcessor, logger, gui_enabled, \
-     get_base_parser
+    get_base_parser
 from MultiServer import mark_raw
 from NetUtils import NetworkItem, ClientStatus, JSONtoTextParser, JSONMessagePart
 
@@ -49,6 +49,7 @@ class FactorioCommandProcessor(ClientCommandProcessor):
 class FactorioContext(CommonContext):
     command_processor = FactorioCommandProcessor
     game = "Factorio"
+    items_handling = 0b111  # full remote
 
     # updated by spinup server
     mod_version: Utils.Version = Utils.Version(0, 0, 0)
@@ -61,6 +62,8 @@ class FactorioContext(CommonContext):
         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: bool = False):
         if password_requested and not self.password:
@@ -104,6 +107,20 @@ class FactorioContext(CommonContext):
             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.info(f"EnergyLink: Received {gained_text}. "
+                                    f"{Utils.format_SI_prefix(args['value'])}J remaining.")
+                        self.rcon_client.send_command(f"/ap-energylink {gained}")
 
 
 async def game_watcher(ctx: FactorioContext):
@@ -112,7 +129,8 @@ async def game_watcher(ctx: FactorioContext):
     next_bridge = time.perf_counter() + 1
     try:
         while not ctx.exit_event.is_set():
-            if ctx.awaiting_bridge and ctx.rcon_client and time.perf_counter() > next_bridge:
+            # 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"))
@@ -126,8 +144,7 @@ async def game_watcher(ctx: FactorioContext):
                     research_data = data["research_done"]
                     research_data = {int(tech_name.split("-")[1]) for tech_name in research_data}
                     victory = data["victory"]
-                    if "death_link" in data:    # TODO: Remove this if statement around version 0.2.4 or so
-                        await ctx.update_death_link(data["death_link"])
+                    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}])
@@ -143,7 +160,31 @@ async def game_watcher(ctx: FactorioContext):
                     if death_link_tick != ctx.death_link_tick:
                         ctx.death_link_tick = death_link_tick
                         if "DeathLink" in ctx.tags:
-                            await ctx.send_death()
+                            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.info(f"EnergyLink: Sent {Utils.format_SI_prefix(value)}J")
 
             await asyncio.sleep(0.1)
 
@@ -232,12 +273,16 @@ async def factorio_server_watcher(ctx: FactorioContext):
         factorio_process.wait(5)
 
 
-async def get_info(ctx, rcon_client):
+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)
 
 
@@ -308,8 +353,8 @@ async def main(args):
     if sys.stdin:
         input_task = asyncio.create_task(console_loop(ctx), name="Input")
     factorio_server_task = asyncio.create_task(factorio_spinup_server(ctx), name="FactorioSpinupServer")
-    succesful_launch = await factorio_server_task
-    if succesful_launch:
+    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")
@@ -333,12 +378,8 @@ 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)
 

Fill.py

@@ -2,9 +2,10 @@ import logging
 import typing
 import collections
 import itertools
+from collections import Counter, deque
+
+from BaseClasses import CollectionState, Location, LocationProgressType, MultiWorld, Item
 
-from BaseClasses import CollectionState, Location, MultiWorld
-from worlds.generic import PlandoItem
 from worlds.AutoWorld import call_all
 
 
@@ -12,76 +13,135 @@ class FillError(RuntimeError):
     pass
 
 
-def fill_restrictive(world: MultiWorld, 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:
+            spot_to_fill: typing.Optional[Location] = None
             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,
+                    # poping 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] != 'minimal' and world.can_beat_game():
-                    logging.warning(
-                        f'Not all items placed. Game beatable anyway. (Could not place {item_to_place})')
+                # 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
+
+                    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
-                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)}')
 
             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: MultiWorld, 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 = []
-    nonexcludeditempool = []
-    localrestitempool = {player: [] for player in range(1, world.players + 1)}
-    nonlocalrestitempool = []
-    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.never_exclude:  # this only gets nonprogression items which should not appear in excluded locations
@@ -93,21 +153,47 @@ def distribute_items_restrictive(world: MultiWorld, fill_locations=None):
         else:
             restitempool.append(item)
 
-    world.random.shuffle(fill_locations)
-    call_all(world, "fill_hook", progitempool, nonexcludeditempool, localrestitempool, nonlocalrestitempool, restitempool, fill_locations)
+    call_all(world, "fill_hook", progitempool, nonexcludeditempool,
+             localrestitempool, nonlocalrestitempool, restitempool, fill_locations)
 
-    fill_restrictive(world, world.state, fill_locations, progitempool)
+    locations: typing.Dict[LocationProgressType, typing.List[Location]] = {
+        loc_type: [] for loc_type in LocationProgressType}
+
+    for loc in fill_locations:
+        locations[loc.progress_type].append(loc)
+
+    prioritylocations = locations[LocationProgressType.PRIORITY]
+    defaultlocations = locations[LocationProgressType.DEFAULT]
+    excludedlocations = locations[LocationProgressType.EXCLUDED]
+
+    fill_restrictive(world, world.state, prioritylocations, progitempool)
+    if prioritylocations:
+        defaultlocations = prioritylocations + defaultlocations
+
+    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')
 
     if nonexcludeditempool:
-        world.random.shuffle(fill_locations)
-        fill_restrictive(world, world.state, fill_locations, nonexcludeditempool)  # needs logical fill to not conflict with local items
+        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]
@@ -118,34 +204,45 @@ def distribute_items_restrictive(world: MultiWorld, 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)
 
     for item_to_place in nonlocalrestitempool:
-        for i, location in enumerate(fill_locations):
+        for i, location in enumerate(defaultlocations):
             if location.player != item_to_place.player:
-                world.push_item(fill_locations.pop(i), item_to_place, False)
+                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 {fill_locations}, tossing.")
+            logging.warning(
+                f"Could not place non_local_item {item_to_place} among {defaultlocations}, tossing.")
 
-    world.random.shuffle(fill_locations)
+    world.random.shuffle(defaultlocations)
 
-    restitempool, fill_locations = fast_fill(world, restitempool, fill_locations)
+    restitempool, defaultlocations = fast_fill(
+        world, restitempool, defaultlocations)
     unplaced = progitempool + restitempool
-    unfilled = [location.name for location in fill_locations]
+    unfilled = [location.name for location in 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: MultiWorld, 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: MultiWorld):
+def flood_items(world: MultiWorld) -> None:
     # get items to distribute
     world.random.shuffle(world.itempool)
     itempool = world.itempool
@@ -184,7 +281,8 @@ def flood_items(world: MultiWorld):
                     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
@@ -205,68 +303,113 @@ def flood_items(world: MultiWorld):
                 break
 
 
-def balance_multiworld_progression(world: MultiWorld):
-    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 = {player for player in world.player_ids if world.progression_balancing[player]}
     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()
+        checked_locations: typing.Set[Location] = set()
         unchecked_locations = set(world.get_locations())
 
-        reachable_locations_count = {player: 0 for player in world.player_ids}
+        reachable_locations_count = {
+            player: 0
+            for player in world.player_ids
+            if len(world.get_filled_locations(player)) != 0
+        }
+        total_locations_count = Counter(location.player for location in world.get_locations() if not location.locked)
+        balanceable_players = {player for player in balanceable_players if total_locations_count[player]}
+        sphere_num = 1
+        moved_item_count = 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
+                # The 10% threshold can be modified for "progression balancing strength"
+                # right now it approximates the old 20/216 bound.
+                threshold_percentage = max(map(lambda p: item_percentage(p, reachable_locations_count[p]),
+                                               reachable_locations_count)) - 0.10
+                logging.debug(f"Threshold: {threshold_percentage}")
                 balancing_players = {player for player, reachables in reachable_locations_count.items() if
-                                     reachables < threshold and player in balanceable_players}
+                                     item_percentage(player, reachables) < threshold_percentage and player in balanceable_players}
                 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_percentage 
+                                for player, reachables in balancing_reachables.items()):
                             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]
                         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)
@@ -276,7 +419,8 @@ def balance_multiworld_progression(world: MultiWorld):
                                     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_percentage:
                                     items_to_replace.append(testing)
 
                     replaced_items = False
@@ -288,6 +432,7 @@ def balance_multiworld_progression(world: MultiWorld):
                     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:
@@ -297,6 +442,7 @@ def balance_multiworld_progression(world: MultiWorld):
                                 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
@@ -304,10 +450,12 @@ def balance_multiworld_progression(world: MultiWorld):
                             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:
@@ -322,7 +470,7 @@ def balance_multiworld_progression(world: MultiWorld):
                 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:
@@ -335,78 +483,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: MultiWorld):
+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:
+    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
+            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
+
+            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]
+
+            if isinstance(locations, dict):
+                location_list = []
+                for key, value in locations.items():
+                    location_list += [key] * value
+                locations = location_list
+            block['locations'] = locations
+
+            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'])
+
+            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:
-            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.")
+            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):
+                    failed(
+                        f"Cannot place item in world {target_world} as it is not in range of (1, {world.players})",
+                        placement['force'])
                     continue
-                item = world.worlds[player].create_item(placement.item)
-                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
-
-                    target_world = world.random.choice(unfilled).player
-
-                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
-
-                    target_world = world.random.choice(unfilled).player
-
-                elif type(target_world) == int:  # target world by player id
-                    if target_world not in range(1, world.players + 1):
-                        placement.failed(
-                            f"Cannot place item in world {target_world} as it is not in range of (1, {world.players})",
-                            ValueError)
-                        continue
-                else:  # find world by 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)
-                        continue
-                    target_world = 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}.")
+                worlds = {target_world}
+            else:  # target world by slot name
+                if target_world not in world_name_lookup:
+                    failed(f"Cannot place item to {target_world}'s world as that world does not exist.",
+                           placement['force'])
                     continue
+                worlds = {world_name_lookup[target_world]}
 
-                if location.can_fill(world.state, item, False):
-                    world.push_item(location, item, collect=False)
-                    location.event = True  # flag location to be checked during fill
-                    location.locked = True
-                    logging.debug(f"Plando placed {item} at {location}")
-                else:
-                    placement.failed(f"Can't place {item} at {location} due to fill condition not met.")
-                    continue
-
-                if placement.from_pool:  # Should happen AFTER the item is placed, in case it was allowed to skip failed placement.
+            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}")
+                if from_pool:
                     try:
                         world.itempool.remove(item)
                     except ValueError:
-                        placement.warn(f"Could not remove {item} from pool as it's already missing from it.")
+                        warn(
+                            f"Could not remove {item} from pool for {world.player_name[player]} as it's already missing from it.",
+                            placement['force'])
+
         except Exception as e:
-            raise Exception(f"Error running plando for player {player} ({world.player_name[player]})") from e
+            raise Exception(
+                f"Error running plando for player {player} ({world.player_name[player]})") from e

Generate.py

@@ -14,8 +14,8 @@ ModuleUpdate.update()
 
 import Utils
 from worlds.alttp import Options as LttPOptions
-from worlds.generic import PlandoItem, PlandoConnection
-from Utils import parse_yaml, version_tuple, __version__, tuplize_version, get_options
+from worlds.generic import PlandoConnection
+from Utils import parse_yaml, 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
@@ -23,27 +23,35 @@ import Options
 from worlds.alttp import Bosses
 from worlds.alttp.Text import TextTable
 from worlds.AutoWorld import AutoWorldRegister
+import copy
 
 categories = set(AutoWorldRegister.world_types)
 
+
 def mystery_argparse():
     options = get_options()
     defaults = options["generator"]
 
+    def resolve_path(path: str, resolver: typing.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"],
+    parser.add_argument('--weights_file_path', default=defaults["weights_file_path"],
                         help='Path to the weights file to use for rolling game settings, urls are also valid')
     parser.add_argument('--samesettings', help='Rolls settings per weights file rather than per player',
                         action='store_true')
-    parser.add_argument('--player_files_path', default=defaults["player_files_path"],
+    parser.add_argument('--player_files_path', default=resolve_path(defaults["player_files_path"], user_path),
                         help="Input directory for player files.")
     parser.add_argument('--seed', help='Define seed number to generate.', type=int)
     parser.add_argument('--multi', default=defaults["players"], type=lambda value: max(int(value), 1))
     parser.add_argument('--spoiler', type=int, default=defaults["spoiler"])
-    parser.add_argument('--lttp_rom', default=options["lttp_options"]["rom_file"], help="Path to the 1.0 JP LttP Baserom.")
-    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=defaults["enemizer_path"])
-    parser.add_argument('--outputpath', default=options["general_options"]["output_path"])
+    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')
@@ -60,8 +68,8 @@ def mystery_argparse():
     return args, options
 
 
-def get_seed_name(random):
-    return f"{random.randint(0, pow(10, seeddigits) - 1)}".zfill(seeddigits)
+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):
@@ -148,7 +156,7 @@ def main(args=None, callback=ERmain):
                         if category_name is None:
                             weights_cache[path][key] = option
                         elif category_name not in weights_cache[path]:
-                            raise Exception(f"Meta: Category {category_name} is not present in {path}.")
+                            logging.warning(f"Meta: Category {category_name} is not present in {path}.")
                         else:
                             weights_cache[path][category_name][key] = option
 
@@ -179,7 +187,7 @@ def main(args=None, callback=ERmain):
         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: {erargs.name}")
+        raise Exception(f"Names have to be unique. Names: {Counter(erargs.name.values())}")
 
     if args.yaml_output:
         import yaml
@@ -190,8 +198,6 @@ def main(args=None, callback=ERmain):
                     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}'")
 
@@ -210,22 +216,22 @@ def main(args=None, callback=ERmain):
 
 def read_weights_yaml(path):
     try:
-        if urllib.parse.urlparse(path).scheme:
-            yaml = str(urllib.request.urlopen(path).read(), "utf-8")
+        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")
+                yaml = str(f.read(), "utf-8-sig")
     except Exception as e:
         raise Exception(f"Failed to read weights ({path})") from e
 
     return parse_yaml(yaml)
 
 
-def interpret_on_off(value):
+def interpret_on_off(value) -> bool:
     return {"on": True, "off": False}.get(value, value)
 
 
-def convert_to_on_off(value):
+def convert_to_on_off(value) -> str:
     return {True: "on", False: "off"}.get(value, value)
 
 
@@ -330,7 +336,7 @@ def update_weights(weights: dict, new_weights: dict, type: str, name: str) -> di
 
 
 def roll_linked_options(weights: dict) -> dict:
-    weights = weights.copy()  # make sure we don't write back to other weights sets in same_settings
+    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.")
@@ -352,7 +358,7 @@ def roll_linked_options(weights: dict) -> dict:
 
 
 def roll_triggers(weights: dict, triggers: list) -> dict:
-    weights = weights.copy()  # make sure we don't write back to other weights sets in same_settings
+    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:
@@ -427,17 +433,8 @@ def handle_option(ret: argparse.Namespace, game_weights: dict, option_key: str,
         except Exception as e:
             raise Exception(f"Error generating option {option_key} in {ret.game}") from e
         else:
-            # verify item names existing
-            if getattr(player_option, "verify_item_name", False):
-                for item_name in player_option.value:
-                    if item_name not in AutoWorldRegister.world_types[ret.game].item_names:
-                        raise Exception(f"Item {item_name} from option {player_option} "
-                                        f"is not a valid item name from {ret.game}")
-            elif getattr(player_option, "verify_location_name", False):
-                for location_name in player_option.value:
-                    if location_name not in AutoWorldRegister.world_types[ret.game].location_names:
-                        raise Exception(f"Location {location_name} from option {player_option} "
-                                        f"is not a valid location name from {ret.game}")
+            if hasattr(player_option, "verify"):
+                player_option.verify(AutoWorldRegister.world_types[ret.game])
     else:
         setattr(ret, option_key, option(option.default))
 
@@ -469,7 +466,7 @@ def roll_settings(weights: dict, plando_options: typing.Set[str] = frozenset(("b
 
     ret = argparse.Namespace()
     for option_key in Options.per_game_common_options:
-        if option_key in weights:
+        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)
@@ -491,9 +488,11 @@ def roll_settings(weights: dict, plando_options: typing.Set[str] = frozenset(("b
         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():
-            handle_option(ret, game_weights, option_key, option)
+            # 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 "items" in plando_options:
-            ret.plando_items = roll_item_plando(world_type, game_weights)
+            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 = []
@@ -510,47 +509,10 @@ def roll_settings(weights: dict, plando_options: typing.Set[str] = frozenset(("b
             roll_alttp_settings(ret, game_weights, plando_options)
     else:
         raise Exception(f"Unsupported game {ret.game}")
+
     return ret
 
 
-def roll_item_plando(world_type, weights):
-    plando_items = []
-
-    def add_plando_item(item: str, location: str):
-        if item not in world_type.item_name_to_id:
-            raise Exception(f"Could not plando item {item} as the item was not recognized")
-        if location not in world_type.location_name_to_id:
-            raise Exception(
-                f"Could not plando item {item} at location {location} as the location was not recognized")
-        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_legacy("percentage", placement, 100)):
-            from_pool = get_choice_legacy("from_pool", placement, PlandoItem._field_defaults["from_pool"])
-            location_world = get_choice_legacy("world", placement, PlandoItem._field_defaults["world"])
-            force = str(get_choice_legacy("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_legacy("item", placement, get_choice_legacy("items", placement))
-                location = get_choice_legacy("location", placement)
-                add_plando_item(item, location)
-    return plando_items
-
-
 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)}.")

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,307 @@
+"""
+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
+from shutil import which
+import shlex
+from enum import Enum, auto
+import logging
+
+
+is_linux = sys.platform.startswith('linux')
+is_macos = sys.platform == 'darwin'
+is_windows = sys.platform in ("win32", "cygwin", "msys")
+
+
+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():
+    try:
+        import tkinter
+        import tkinter.filedialog
+    except Exception as e:
+        logging.error("Could not load tkinter, which is likely not installed. "
+                      "This attempt was made because Launcher.open_patch was used.")
+        raise e
+    else:
+        root = tkinter.Tk()
+        root.withdraw()
+        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 []
+        filename = tkinter.filedialog.askopenfilename(filetypes=(('Patches', ' '.join(suffixes)),))
+        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')),
+    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'),
+    # 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():
+    if not sys.stdout:
+        from kvui import App, ContainerLayout, GridLayout, Button, Label  # this kills stdout
+    else:
+        from kivy.app import App
+        from kivy.uix.button import Button
+        from kivy.uix.floatlayout import FloatLayout as ContainerLayout
+        from kivy.uix.gridlayout import GridLayout
+        from kivy.uix.label import 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())

LttPAdjuster.py

@@ -14,14 +14,15 @@ import tkinter as tk
 from argparse import Namespace
 from concurrent.futures import as_completed, ThreadPoolExecutor
 from glob import glob
-from tkinter import Tk, Frame, Label, StringVar, Entry, filedialog, messagebox, Button, LEFT, X, TOP, LabelFrame, \
+from tkinter import Tk, Frame, Label, StringVar, Entry, filedialog, messagebox, Button, Radiobutton, LEFT, X, TOP, LabelFrame, \
     IntVar, Checkbutton, E, W, OptionMenu, Toplevel, BOTTOM, RIGHT, font as font, PhotoImage
+from tkinter.constants import DISABLED, NORMAL
 from urllib.parse import urlparse
 from urllib.request import urlopen
 
 from worlds.alttp.Rom import Sprite, LocalRom, apply_rom_settings, get_base_rom_bytes
-from Utils import output_path, local_path, open_file, get_cert_none_ssl_context, persistent_store
-
+from Utils import output_path, local_path, user_path, open_file, get_cert_none_ssl_context, persistent_store, get_adjuster_settings, tkinter_center_window
+from Patch import GAME_ALTTP
 
 class AdjusterWorld(object):
     def __init__(self, sprite_pool):
@@ -121,7 +122,7 @@ def main():
         args, path = adjust(args=args)
         if isinstance(args.sprite, Sprite):
             args.sprite = args.sprite.name
-        persistent_store("adjuster", "last_settings_3", args)
+        persistent_store("adjuster", GAME_ALTTP, args)
 
 
 def adjust(args):
@@ -129,7 +130,7 @@ def adjust(args):
     logger = logging.getLogger('Adjuster')
     logger.info('Patching ROM.')
     vanillaRom = args.baserom
-    if os.path.splitext(args.rom)[-1].lower() == '.apbp':
+    if os.path.splitext(args.rom)[-1].lower() in {'.apbp', '.aplttp'}:
         import Patch
         meta, args.rom = Patch.create_rom_file(args.rom)
 
@@ -196,6 +197,7 @@ def adjustGUI():
 
     def adjustRom():
         guiargs = Namespace()
+        guiargs.auto_apply = rom_vars.auto_apply.get()
         guiargs.heartbeep = rom_vars.heartbeepVar.get()
         guiargs.heartcolor = rom_vars.heartcolorVar.get()
         guiargs.menuspeed = rom_vars.menuspeedVar.get()
@@ -226,14 +228,43 @@ def adjustGUI():
             messagebox.showinfo(title="Success", message=f"Rom patched successfully to {path}")
             if isinstance(guiargs.sprite, Sprite):
                 guiargs.sprite = guiargs.sprite.name
-            persistent_store("adjuster", "last_settings_3", guiargs)
+            delattr(guiargs, "rom")
+            persistent_store("adjuster", GAME_ALTTP, guiargs)
+
+    def saveGUISettings():
+        guiargs = Namespace()
+        guiargs.auto_apply = rom_vars.auto_apply.get()
+        guiargs.heartbeep = rom_vars.heartbeepVar.get()
+        guiargs.heartcolor = rom_vars.heartcolorVar.get()
+        guiargs.menuspeed = rom_vars.menuspeedVar.get()
+        guiargs.ow_palettes = rom_vars.owPalettesVar.get()
+        guiargs.uw_palettes = rom_vars.uwPalettesVar.get()
+        guiargs.hud_palettes = rom_vars.hudPalettesVar.get()
+        guiargs.sword_palettes = rom_vars.swordPalettesVar.get()
+        guiargs.shield_palettes = rom_vars.shieldPalettesVar.get()
+        guiargs.quickswap = bool(rom_vars.quickSwapVar.get())
+        guiargs.music = bool(rom_vars.MusicVar.get())
+        guiargs.reduceflashing = bool(rom_vars.disableFlashingVar.get())
+        guiargs.deathlink = bool(rom_vars.DeathLinkVar.get())
+        guiargs.baserom = romVar.get()
+        if isinstance(rom_vars.sprite, Sprite):
+            guiargs.sprite = rom_vars.sprite.name
+        else:
+            guiargs.sprite = rom_vars.sprite
+        guiargs.sprite_pool = rom_vars.sprite_pool
+        persistent_store("adjuster", GAME_ALTTP, guiargs)
+        messagebox.showinfo(title="Success", message="Settings saved to persistent storage")
 
     adjustButton = Button(bottomFrame2, text='Adjust Rom', command=adjustRom)
     rom_options_frame.pack(side=TOP)
-    adjustButton.pack(side=BOTTOM, padx=(5, 5))
+    adjustButton.pack(side=LEFT, padx=(5,5))
 
-    bottomFrame2.pack(side=BOTTOM, pady=(5, 5))
+    saveButton = Button(bottomFrame2, text='Save Settings', command=saveGUISettings)
+    saveButton.pack(side=LEFT, padx=(5,5))
 
+    bottomFrame2.pack(side=TOP, pady=(5,5))
+
+    tkinter_center_window(adjustWindow)
     adjustWindow.mainloop()
 
 
@@ -255,7 +286,7 @@ def run_sprite_update():
 def update_sprites(task, on_finish=None):
     resultmessage = ""
     successful = True
-    sprite_dir = local_path("data", "sprites", "alttpr")
+    sprite_dir = user_path("data", "sprites", "alttpr")
     os.makedirs(sprite_dir, exist_ok=True)
     ctx = get_cert_none_ssl_context()
     def finished():
@@ -437,9 +468,14 @@ class BackgroundTaskProgressNullWindow(BackgroundTask):
 
 
 def get_rom_frame(parent=None):
+    adjuster_settings = get_adjuster_settings(GAME_ALTTP)
+    if not adjuster_settings:
+        adjuster_settings = Namespace()
+        adjuster_settings.baserom = "Zelda no Densetsu - Kamigami no Triforce (Japan).sfc"
+
     romFrame = Frame(parent)
     baseRomLabel = Label(romFrame, text='LttP Base Rom: ')
-    romVar = StringVar(value="Zelda no Densetsu - Kamigami no Triforce (Japan).sfc")
+    romVar = StringVar(value=adjuster_settings.baserom)
     romEntry = Entry(romFrame, textvariable=romVar)
 
     def RomSelect():
@@ -465,6 +501,26 @@ def get_rom_frame(parent=None):
 
 
 def get_rom_options_frame(parent=None):
+    adjuster_settings = get_adjuster_settings(GAME_ALTTP)
+    if not adjuster_settings:
+        adjuster_settings = Namespace()
+        adjuster_settings.auto_apply = 'ask'
+        adjuster_settings.music = True
+        adjuster_settings.reduceflashing = True
+        adjuster_settings.deathlink = False
+        adjuster_settings.sprite = None
+        adjuster_settings.quickswap = True
+        adjuster_settings.menuspeed = 'normal'
+        adjuster_settings.heartcolor = 'red'
+        adjuster_settings.heartbeep = 'normal'
+        adjuster_settings.ow_palettes = 'default'
+        adjuster_settings.uw_palettes = 'default'
+        adjuster_settings.hud_palettes = 'default'
+        adjuster_settings.sword_palettes = 'default'
+        adjuster_settings.shield_palettes = 'default'
+    if not hasattr(adjuster_settings, 'sprite_pool'):
+        adjuster_settings.sprite_pool = []
+
     romOptionsFrame = LabelFrame(parent, text="Rom options")
     romOptionsFrame.columnconfigure(0, weight=1)
     romOptionsFrame.columnconfigure(1, weight=1)
@@ -473,16 +529,16 @@ def get_rom_options_frame(parent=None):
     vars = Namespace()
 
     vars.MusicVar = IntVar()
-    vars.MusicVar.set(1)
+    vars.MusicVar.set(adjuster_settings.music)
     MusicCheckbutton = Checkbutton(romOptionsFrame, text="Music", variable=vars.MusicVar)
     MusicCheckbutton.grid(row=0, column=0, sticky=E)
 
-    vars.disableFlashingVar = IntVar(value=1)
+    vars.disableFlashingVar = IntVar(value=adjuster_settings.reduceflashing)
     disableFlashingCheckbutton = Checkbutton(romOptionsFrame, text="Disable flashing (anti-epilepsy)",
                                              variable=vars.disableFlashingVar)
     disableFlashingCheckbutton.grid(row=6, column=0, sticky=W)
 
-    vars.DeathLinkVar = IntVar(value=0)
+    vars.DeathLinkVar = IntVar(value=adjuster_settings.deathlink)
     DeathLinkCheckbutton = Checkbutton(romOptionsFrame, text="DeathLink (Team Deaths)", variable=vars.DeathLinkVar)
     DeathLinkCheckbutton.grid(row=7, column=0, sticky=W)
 
@@ -491,7 +547,7 @@ def get_rom_options_frame(parent=None):
     baseSpriteLabel = Label(spriteDialogFrame, text='Sprite:')
 
     vars.spriteNameVar = StringVar()
-    vars.sprite = None
+    vars.sprite = adjuster_settings.sprite
 
     def set_sprite(sprite_param):
         nonlocal vars
@@ -505,8 +561,8 @@ def get_rom_options_frame(parent=None):
             vars.sprite = sprite_param
             vars.spriteNameVar.set(vars.sprite.name)
 
-    set_sprite(None)
-    vars.spriteNameVar.set('(unchanged)')
+    set_sprite(adjuster_settings.sprite)
+    #vars.spriteNameVar.set(adjuster_settings.sprite)
     spriteEntry = Label(spriteDialogFrame, textvariable=vars.spriteNameVar)
 
     def SpriteSelect():
@@ -519,7 +575,7 @@ def get_rom_options_frame(parent=None):
     spriteEntry.pack(side=LEFT)
     spriteSelectButton.pack(side=LEFT)
 
-    vars.quickSwapVar = IntVar(value=1)
+    vars.quickSwapVar = IntVar(value=adjuster_settings.quickswap)
     quickSwapCheckbutton = Checkbutton(romOptionsFrame, text="L/R Quickswapping", variable=vars.quickSwapVar)
     quickSwapCheckbutton.grid(row=1, column=0, sticky=E)
 
@@ -528,7 +584,7 @@ def get_rom_options_frame(parent=None):
     menuspeedLabel = Label(menuspeedFrame, text='Menu speed')
     menuspeedLabel.pack(side=LEFT)
     vars.menuspeedVar = StringVar()
-    vars.menuspeedVar.set('normal')
+    vars.menuspeedVar.set(adjuster_settings.menuspeed)
     menuspeedOptionMenu = OptionMenu(menuspeedFrame, vars.menuspeedVar, 'normal', 'instant', 'double', 'triple',
                                      'quadruple', 'half')
     menuspeedOptionMenu.pack(side=LEFT)
@@ -538,7 +594,7 @@ def get_rom_options_frame(parent=None):
     heartcolorLabel = Label(heartcolorFrame, text='Heart color')
     heartcolorLabel.pack(side=LEFT)
     vars.heartcolorVar = StringVar()
-    vars.heartcolorVar.set('red')
+    vars.heartcolorVar.set(adjuster_settings.heartcolor)
     heartcolorOptionMenu = OptionMenu(heartcolorFrame, vars.heartcolorVar, 'red', 'blue', 'green', 'yellow', 'random')
     heartcolorOptionMenu.pack(side=LEFT)
 
@@ -547,7 +603,7 @@ def get_rom_options_frame(parent=None):
     heartbeepLabel = Label(heartbeepFrame, text='Heartbeep')
     heartbeepLabel.pack(side=LEFT)
     vars.heartbeepVar = StringVar()
-    vars.heartbeepVar.set('normal')
+    vars.heartbeepVar.set(adjuster_settings.heartbeep)
     heartbeepOptionMenu = OptionMenu(heartbeepFrame, vars.heartbeepVar, 'double', 'normal', 'half', 'quarter', 'off')
     heartbeepOptionMenu.pack(side=LEFT)
 
@@ -556,7 +612,7 @@ def get_rom_options_frame(parent=None):
     owPalettesLabel = Label(owPalettesFrame, text='Overworld palettes')
     owPalettesLabel.pack(side=LEFT)
     vars.owPalettesVar = StringVar()
-    vars.owPalettesVar.set('default')
+    vars.owPalettesVar.set(adjuster_settings.ow_palettes)
     owPalettesOptionMenu = OptionMenu(owPalettesFrame, vars.owPalettesVar, 'default', 'good', 'blackout', 'grayscale',
                                       'negative', 'classic', 'dizzy', 'sick', 'puke')
     owPalettesOptionMenu.pack(side=LEFT)
@@ -566,7 +622,7 @@ def get_rom_options_frame(parent=None):
     uwPalettesLabel = Label(uwPalettesFrame, text='Dungeon palettes')
     uwPalettesLabel.pack(side=LEFT)
     vars.uwPalettesVar = StringVar()
-    vars.uwPalettesVar.set('default')
+    vars.uwPalettesVar.set(adjuster_settings.uw_palettes)
     uwPalettesOptionMenu = OptionMenu(uwPalettesFrame, vars.uwPalettesVar, 'default', 'good', 'blackout', 'grayscale',
                                       'negative', 'classic', 'dizzy', 'sick', 'puke')
     uwPalettesOptionMenu.pack(side=LEFT)
@@ -576,7 +632,7 @@ def get_rom_options_frame(parent=None):
     hudPalettesLabel = Label(hudPalettesFrame, text='HUD palettes')
     hudPalettesLabel.pack(side=LEFT)
     vars.hudPalettesVar = StringVar()
-    vars.hudPalettesVar.set('default')
+    vars.hudPalettesVar.set(adjuster_settings.hud_palettes)
     hudPalettesOptionMenu = OptionMenu(hudPalettesFrame, vars.hudPalettesVar, 'default', 'good', 'blackout',
                                        'grayscale', 'negative', 'classic', 'dizzy', 'sick', 'puke')
     hudPalettesOptionMenu.pack(side=LEFT)
@@ -586,7 +642,7 @@ def get_rom_options_frame(parent=None):
     swordPalettesLabel = Label(swordPalettesFrame, text='Sword palettes')
     swordPalettesLabel.pack(side=LEFT)
     vars.swordPalettesVar = StringVar()
-    vars.swordPalettesVar.set('default')
+    vars.swordPalettesVar.set(adjuster_settings.sword_palettes)
     swordPalettesOptionMenu = OptionMenu(swordPalettesFrame, vars.swordPalettesVar, 'default', 'good', 'blackout',
                                          'grayscale', 'negative', 'classic', 'dizzy', 'sick', 'puke')
     swordPalettesOptionMenu.pack(side=LEFT)
@@ -596,7 +652,7 @@ def get_rom_options_frame(parent=None):
     shieldPalettesLabel = Label(shieldPalettesFrame, text='Shield palettes')
     shieldPalettesLabel.pack(side=LEFT)
     vars.shieldPalettesVar = StringVar()
-    vars.shieldPalettesVar.set('default')
+    vars.shieldPalettesVar.set(adjuster_settings.shield_palettes)
     shieldPalettesOptionMenu = OptionMenu(shieldPalettesFrame, vars.shieldPalettesVar, 'default', 'good', 'blackout',
                                           'grayscale', 'negative', 'classic', 'dizzy', 'sick', 'puke')
     shieldPalettesOptionMenu.pack(side=LEFT)
@@ -606,7 +662,7 @@ def get_rom_options_frame(parent=None):
     baseSpritePoolLabel = Label(spritePoolFrame, text='Sprite Pool:')
 
     vars.spritePoolCountVar = StringVar()
-    vars.sprite_pool = []
+    vars.sprite_pool = adjuster_settings.sprite_pool
 
     def set_sprite_pool(sprite_param):
         nonlocal vars
@@ -625,7 +681,7 @@ def get_rom_options_frame(parent=None):
         vars.spritePoolCountVar.set(str(len(vars.sprite_pool)))
 
     set_sprite_pool(None)
-    vars.spritePoolCountVar.set('0')
+    vars.spritePoolCountVar.set(len(adjuster_settings.sprite_pool))
     spritePoolEntry = Label(spritePoolFrame, textvariable=vars.spritePoolCountVar)
 
     def SpritePoolSelect():
@@ -645,6 +701,18 @@ def get_rom_options_frame(parent=None):
     spritePoolSelectButton.pack(side=LEFT)
     spritePoolClearButton.pack(side=LEFT)
 
+    vars.auto_apply = StringVar(value=adjuster_settings.auto_apply)
+    autoApplyFrame = Frame(romOptionsFrame)
+    autoApplyFrame.grid(row=8, column=0, columnspan=2, sticky=W)
+    filler = Label(autoApplyFrame, text="Automatically apply last used settings on opening .apbp files")
+    filler.pack(side=TOP, expand=True, fill=X)
+    askRadio = Radiobutton(autoApplyFrame, text='Ask', variable=vars.auto_apply, value='ask')
+    askRadio.pack(side=LEFT, padx=5, pady=5)
+    alwaysRadio = Radiobutton(autoApplyFrame, text='Always', variable=vars.auto_apply, value='always')
+    alwaysRadio.pack(side=LEFT, padx=5, pady=5)
+    neverRadio = Radiobutton(autoApplyFrame, text='Never', variable=vars.auto_apply, value='never')
+    neverRadio.pack(side=LEFT, padx=5, pady=5)
+
     return romOptionsFrame, vars, set_sprite
 
 
@@ -693,6 +761,9 @@ class SpriteSelector():
 
         button = Button(frame, text="Update alttpr sprites", command=self.update_alttpr_sprites)
         button.pack(side=RIGHT, padx=(5, 0))
+        
+        button = Button(frame, text="Do not adjust sprite",command=self.use_default_sprite)
+        button.pack(side=LEFT,padx=(0,5))
 
         button = Button(frame, text="Default Link sprite", command=self.use_default_link_sprite)
         button.pack(side=LEFT, padx=(0, 5))
@@ -710,36 +781,36 @@ class SpriteSelector():
         self.randomOnItemVar = IntVar()
         self.randomOnBonkVar = IntVar()
         self.randomOnRandomVar = IntVar()
+        self.randomOnAllVar = IntVar()
 
         if self.randomOnEvent:
-            button = Checkbutton(frame, text="Hit", command=self.update_random_button, variable=self.randomOnHitVar)
-            button.pack(side=LEFT, padx=(0, 5))
+            self.buttonHit = Checkbutton(frame, text="Hit", command=self.update_random_button, variable=self.randomOnHitVar)
+            self.buttonHit.pack(side=LEFT, padx=(0, 5))
 
-            button = Checkbutton(frame, text="Enter", command=self.update_random_button, variable=self.randomOnEnterVar)
-            button.pack(side=LEFT, padx=(0, 5))
+            self.buttonEnter = Checkbutton(frame, text="Enter", command=self.update_random_button, variable=self.randomOnEnterVar)
+            self.buttonEnter.pack(side=LEFT, padx=(0, 5))
 
-            button = Checkbutton(frame, text="Exit", command=self.update_random_button, variable=self.randomOnExitVar)
-            button.pack(side=LEFT, padx=(0, 5))
+            self.buttonExit = Checkbutton(frame, text="Exit", command=self.update_random_button, variable=self.randomOnExitVar)
+            self.buttonExit.pack(side=LEFT, padx=(0, 5))
 
-            button = Checkbutton(frame, text="Slash", command=self.update_random_button, variable=self.randomOnSlashVar)
-            button.pack(side=LEFT, padx=(0, 5))
+            self.buttonSlash = Checkbutton(frame, text="Slash", command=self.update_random_button, variable=self.randomOnSlashVar)
+            self.buttonSlash.pack(side=LEFT, padx=(0, 5))
 
-            button = Checkbutton(frame, text="Item", command=self.update_random_button, variable=self.randomOnItemVar)
-            button.pack(side=LEFT, padx=(0, 5))
+            self.buttonItem = Checkbutton(frame, text="Item", command=self.update_random_button, variable=self.randomOnItemVar)
+            self.buttonItem.pack(side=LEFT, padx=(0, 5))
 
-            button = Checkbutton(frame, text="Bonk", command=self.update_random_button, variable=self.randomOnBonkVar)
-            button.pack(side=LEFT, padx=(0, 5))
+            self.buttonBonk = Checkbutton(frame, text="Bonk", command=self.update_random_button, variable=self.randomOnBonkVar)
+            self.buttonBonk.pack(side=LEFT, padx=(0, 5))
 
-            button = Checkbutton(frame, text="Random", command=self.update_random_button,
-                                 variable=self.randomOnRandomVar)
-            button.pack(side=LEFT, padx=(0, 5))
+            self.buttonRandom = Checkbutton(frame, text="Random", command=self.update_random_button, variable=self.randomOnRandomVar)
+            self.buttonRandom.pack(side=LEFT, padx=(0, 5))
 
-        if adjuster:
-            button = Button(frame, text="Current sprite from rom", command=self.use_default_sprite)
-            button.pack(side=LEFT, padx=(0, 5))
+            self.buttonAll = Checkbutton(frame, text="All", command=self.update_random_button, variable=self.randomOnAllVar)
+            self.buttonAll.pack(side=LEFT, padx=(0, 5))
 
         set_icon(self.window)
         self.window.focus()
+        tkinter_center_window(self.window)
 
     def remove_from_sprite_pool(self, button, spritename):
         self.callback(("remove", spritename))
@@ -879,9 +950,31 @@ class SpriteSelector():
             self.add_to_sprite_pool("link")
 
     def update_random_button(self):
-        if self.randomOnRandomVar.get():
+        if self.randomOnAllVar.get():
+            randomon = "all"
+            self.buttonHit.config(state=DISABLED)
+            self.buttonEnter.config(state=DISABLED)
+            self.buttonExit.config(state=DISABLED)
+            self.buttonSlash.config(state=DISABLED)
+            self.buttonItem.config(state=DISABLED)
+            self.buttonBonk.config(state=DISABLED)
+            self.buttonRandom.config(state=DISABLED)
+        elif self.randomOnRandomVar.get():
             randomon = "random"
+            self.buttonHit.config(state=DISABLED)
+            self.buttonEnter.config(state=DISABLED)
+            self.buttonExit.config(state=DISABLED)
+            self.buttonSlash.config(state=DISABLED)
+            self.buttonItem.config(state=DISABLED)
+            self.buttonBonk.config(state=DISABLED)
         else:
+            self.buttonHit.config(state=NORMAL)
+            self.buttonEnter.config(state=NORMAL)
+            self.buttonExit.config(state=NORMAL)
+            self.buttonSlash.config(state=NORMAL)
+            self.buttonItem.config(state=NORMAL)
+            self.buttonBonk.config(state=NORMAL)
+            self.buttonRandom.config(state=NORMAL)
             randomon = "-hit" if self.randomOnHitVar.get() else ""
             randomon += "-enter" if self.randomOnEnterVar.get() else ""
             randomon += "-exit" if self.randomOnExitVar.get() else ""
@@ -920,11 +1013,11 @@ class SpriteSelector():
 
     @property
     def alttpr_sprite_dir(self):
-        return local_path("data", "sprites", "alttpr")
+        return user_path("data", "sprites", "alttpr")
 
     @property
     def custom_sprite_dir(self):
-        return local_path("data", "sprites", "custom")
+        return user_path("data", "sprites", "custom")
 
 
 def get_image_for_sprite(sprite, gif_only: bool = False):
@@ -1150,4 +1243,4 @@ class ToolTips(object):
 
 
 if __name__ == '__main__':
-    main()
+    main()

Main.py

@@ -1,3 +1,5 @@
+import copy
+import collections
 from itertools import zip_longest, chain
 import logging
 import os
@@ -7,9 +9,9 @@ import concurrent.futures
 import pickle
 import tempfile
 import zipfile
-from typing import Dict, Tuple, Optional
+from typing import Dict, Tuple, Optional, Set
 
-from BaseClasses import MultiWorld, CollectionState, Region, RegionType
+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
@@ -18,7 +20,6 @@ from Utils import output_path, get_options, __version__, version_tuple
 from worlds.generic.Rules import locality_rules, exclusion_rules
 from worlds import AutoWorld
 
-
 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',
@@ -47,13 +48,6 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
     world.item_functionality = args.item_functionality.copy()
     world.timer = args.timer.copy()
     world.goal = args.goal.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.open_pyramid = args.open_pyramid.copy()
     world.boss_shuffle = args.shufflebosses.copy()
     world.enemy_health = args.enemy_health.copy()
@@ -77,12 +71,14 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
     world.plando_connections = args.plando_connections.copy()
     world.required_medallions = args.required_medallions.copy()
     world.game = args.game.copy()
-    world.set_options(args)
     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.set_options(args)
+    world.set_item_links()
+    world.state = CollectionState(world)
     logger.info('Archipelago Version %s  -  Seed: %s\n', __version__, world.seed)
 
     logger.info("Found World Types:")
@@ -137,9 +133,88 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
 
     for player in world.player_ids:
         exclusion_rules(world, player, world.exclude_locations[player].value)
+        world.priority_locations[player].value -= world.exclude_locations[player].value
+        for location_name in world.priority_locations[player].value:
+            world.get_location(location_name, player).progress_type = LocationProgressType.PRIORITY
 
     AutoWorld.call_all(world, "generate_basic")
 
+    # temporary home for item links, should be moved out of Main
+    for group_id, group in world.groups.items():
+        def find_common_pool(players: Set[int], shared_pool: Set[str]):
+            advancement = set()
+            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
+                    if item.advancement:
+                        advancement.add(item.name)
+
+            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, advancement
+
+        common_item_count, common_advancement_items = 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():
+            advancement = item_name in common_advancement_items
+            for _ in range(item_count):
+                new_item = group["world"].create_item(item_name)
+                new_item.advancement = advancement
+                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")
 
     for item in world.itempool:
@@ -250,45 +325,58 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
                 import NetUtils
                 slot_data = {}
                 client_versions = {}
-                minimum_versions = {"server": (0, 1, 8), "clients": client_versions}
                 games = {}
+                minimum_versions = {"server": (0, 2, 4), "clients": client_versions}
+                slot_info = {}
+                names = [[name for player, name in sorted(world.player_name.items())]]
                 for slot in world.player_ids:
                     client_versions[slot] = world.worlds[slot].get_required_client_version()
                     games[slot] = world.game[slot]
-                precollected_items = {player: [item.code for item in world_precollected]
+                    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)}
-                # for now special case Factorio tech_tree_information
-                sending_visible_players = set()
+                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()
-                    if world.worlds[slot].sending_visible:
-                        sending_visible_players.add(slot)
 
                 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)
+                    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)
 
-                locations_data: Dict[int, Dict[int, Tuple[int, int]]] = {player: {} for player in world.player_ids}
+                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:
-                        # item code None should be event, location.address should then also be None
-                        assert location.item.code is not None
-                        locations_data[location.player][location.address] = location.item.code, location.item.player
-                        if location.player in sending_visible_players:
-                            precollect_hint(location)
-                        elif location.name in world.start_location_hints[location.player]:
+                        assert location.item.code is not None, "item code None should be event, " \
+                                                               "location.address should then also be None"
+                        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)
 
                 multidata = {
                     "slot_data": slot_data,
-                    "games": games,
-                    "names": [[name for player, name in sorted(world.player_name.items())]],
+                    "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},
@@ -310,7 +398,7 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
                 multidata = zlib.compress(pickle.dumps(multidata), 9)
 
                 with open(os.path.join(temp_dir, f'{outfilebase}.archipelago'), 'wb') as f:
-                    f.write(bytes([1]))  # version of format
+                    f.write(bytes([3]))  # version of format
                     f.write(multidata)
 
             multidata_task = pool.submit(write_multidata)
@@ -320,7 +408,7 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
                 else:
                     logger.warning("Location Accessibility requirements not fulfilled.")
 
-            # retrieve exceptions via .result() if they occured.
+            # 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):

MinecraftClient.py

@@ -2,6 +2,7 @@ import argparse
 import os, sys
 import re
 import atexit
+import shutil
 from subprocess import Popen
 from shutil import copyfile
 from time import strftime
@@ -16,6 +17,7 @@ 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]?$")
 forge_version = "1.17.1-37.1.1"
+is_windows = sys.platform in ("win32", "cygwin", "msys")
 
 
 def prompt_yes_no(prompt):
@@ -158,9 +160,15 @@ def find_jdk_dir() -> str:
 
 # get the java exe location
 def find_jdk() -> str:
-    jdk = find_jdk_dir()
-    jdk_exe = os.path.join(jdk, "bin", "java.exe")
-    if os.path.isfile(jdk_exe):
+    if is_windows:
+        jdk = find_jdk_dir()
+        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
 
 
@@ -203,7 +211,7 @@ def install_forge(directory: str):
                 f.write(resp.content)
             print(f"Installing Forge...")
             argstring = ' '.join([jdk, "-jar", "\"" + forge_install_jar+ "\"", "--installServer", "\"" + directory + "\""])
-            install_process = Popen(argstring)
+            install_process = Popen(argstring, shell=not is_windows)
             install_process.wait()
             os.remove(forge_install_jar)
 
@@ -220,7 +228,8 @@ def run_forge_server(forge_dir: str, heap_arg):
         heap_arg = heap_arg[:-1]
     heap_arg = "-Xmx" + heap_arg
 
-    args_file = os.path.join(forge_dir, "libraries", "net", "minecraftforge", "forge", forge_version, "win_args.txt")
+    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)
     win_args = []
     with open(args_file) as argfile:
         for line in argfile:
@@ -229,7 +238,7 @@ def run_forge_server(forge_dir: str, heap_arg):
     argstring = ' '.join([java_exe, heap_arg] + win_args + ["-nogui"])
     logging.info(f"Running Forge server: {argstring}")
     os.chdir(forge_dir)
-    return Popen(argstring)
+    return Popen(argstring, shell=not is_windows)
 
 
 if __name__ == '__main__':
@@ -252,15 +261,21 @@ if __name__ == '__main__':
     max_heap = options["minecraft_options"]["max_heap_size"]
 
     if args.install:
-        print("Installing Java and Minecraft Forge")
-        download_java()
+        if is_windows:
+            print("Installing Java and Minecraft Forge")
+            download_java()
+        else:
+            print("Installing Minecraft Forge")
         install_forge(forge_dir)
         sys.exit(0)
 
     if apmc_file is not None and not os.path.isfile(apmc_file):
         raise FileNotFoundError(f"Path {apmc_file} does not exist or could not be accessed.")
     if not os.path.isdir(forge_dir):
-        raise NotADirectoryError(f"Path {forge_dir} does not exist or could not be accessed.")
+        if prompt_yes_no("Did not find forge directory. Download and install forge now?"):
+            install_forge(forge_dir)
+        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.")
 

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,7 +24,7 @@ def update_command():
         subprocess.call([sys.executable, '-m', 'pip', 'install', '-r', file, '--upgrade'])
 
 
-def update(yes = False, force = False):
+def update(yes=False, force=False):
     global update_ran
     if not update_ran:
         update_ran = True
@@ -38,9 +39,8 @@ def update(yes = False, force = False):
                 for line in requirementsfile:
                     if line.startswith('https://'):
                         # extract name and version from url
-                        url = line.split(';')[0]
                         wheel = line.split('/')[-1]
-                        name, version, _ = wheel.split('-',2)
+                        name, version, _ = wheel.split('-', 2)
                         line = f'{name}=={version}'
                     requirements = pkg_resources.parse_requirements(line)
                     for requirement in requirements:
@@ -58,6 +58,7 @@ def update(yes = False, force = False):
 
 if __name__ == "__main__":
     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')

MultiServer.py

@@ -15,6 +15,7 @@ import random
 import pickle
 import itertools
 import time
+import operator
 
 import ModuleUpdate
 
@@ -23,7 +24,7 @@ ModuleUpdate.update()
 import websockets
 import colorama
 
-from fuzzywuzzy import process as fuzzy_process
+from thefuzz import process as fuzzy_process
 
 import NetUtils
 from worlds.AutoWorld import AutoWorldRegister
@@ -33,14 +34,37 @@ from worlds import network_data_package, lookup_any_item_id_to_name, lookup_any_
 import Utils
 from Utils import get_item_name_from_id, get_location_name_from_id, \
     version_tuple, restricted_loads, Version
-from NetUtils import Endpoint, ClientStatus, NetworkItem, decode, encode, NetworkPlayer, Permission
+from NetUtils import Endpoint, ClientStatus, NetworkItem, decode, encode, NetworkPlayer, Permission, NetworkSlot, \
+    SlotType
 
 colorama.init()
 
+# functions callable on storable data on the server by clients
+modify_functions = {
+    "add": operator.add,  # add together two objects, using python's "+" operator (works on strings and lists as append)
+    "mul": operator.mul,
+    "mod": operator.mod,
+    "max": max,
+    "min": min,
+    "replace": lambda old, new: new,
+    "default": lambda old, new: old,
+    "pow": operator.pow,
+    # bitwise:
+    "xor": operator.xor,
+    "or": operator.or_,
+    "and": operator.and_,
+    "left_shift": operator.lshift,
+    "right_shift": operator.rshift,
+}
+
 
 class Client(Endpoint):
     version = Version(0, 0, 0)
     tags: typing.List[str] = []
+    remote_items: bool
+    remote_start_inventory: bool
+    no_items: bool
+    no_locations: bool
 
     def __init__(self, socket: websockets.WebSocketServerProtocol, ctx: Context):
         super().__init__(socket)
@@ -52,6 +76,20 @@ class Client(Endpoint):
         self.messageprocessor = client_message_processor(ctx, self)
         self.ctx = weakref.ref(ctx)
 
+    @property
+    def items_handling(self):
+        if self.no_items:
+            return 0
+        return 1 + (self.remote_items << 1) + (self.remote_start_inventory << 2)
+
+    @items_handling.setter
+    def items_handling(self, value: int):
+        if not (value & 0b001) and (value & 0b110):
+            raise ValueError("Invalid flag combination")
+        self.no_items = not (value & 0b001)
+        self.remote_items = bool(value & 0b010)
+        self.remote_start_inventory = bool(value & 0b100)
+
     @property
     def name(self) -> str:
         ctx = self.ctx()
@@ -78,13 +116,18 @@ class Context:
                       "compatibility": int}
     # team -> slot id -> list of clients authenticated to slot.
     clients: typing.Dict[int, typing.Dict[int, typing.List[Client]]]
-    locations: typing.Dict[int, typing.Dict[int, typing.Tuple[int, int]]]
+    locations: typing.Dict[int, typing.Dict[int, typing.Tuple[int, int, int]]]
+    groups: typing.Dict[int, typing.Set[int]]
+    save_version = 2
+    stored_data: typing.Dict[str, object]
+    stored_data_notification_clients: typing.Dict[str, typing.Set[Client]]
 
     def __init__(self, host: str, port: int, server_password: str, password: str, location_check_points: int,
                  hint_cost: int, item_cheat: bool, forfeit_mode: str = "disabled", collect_mode="disabled",
                  remaining_mode: str = "disabled", auto_shutdown: typing.SupportsFloat = 0, compatibility: int = 2,
                  log_network: bool = False):
         super(Context, self).__init__()
+        self.slot_info: typing.Dict[int, NetworkSlot] = {}
         self.log_network = log_network
         self.endpoints = []
         self.clients = {}
@@ -108,6 +151,7 @@ class Context:
         self.server = None
         self.countdown_timer = 0
         self.received_items = {}
+        self.start_inventory = {}
         self.name_aliases: typing.Dict[team_slot, str] = {}
         self.location_checks = collections.defaultdict(set)
         self.hint_cost = hint_cost
@@ -136,7 +180,10 @@ class Context:
         self.games: typing.Dict[int, str] = {}
         self.minimum_client_versions: typing.Dict[int, Utils.Version] = {}
         self.seed_name = ""
+        self.groups = {}
         self.random = random.Random()
+        self.stored_data = {}
+        self.stored_data_notification_clients = collections.defaultdict(weakref.WeakSet)
 
     # General networking
 
@@ -235,14 +282,14 @@ class Context:
             with open(multidatapath, 'rb') as f:
                 data = f.read()
 
-        self._load(self._decompress(data), use_embedded_server_options)
+        self._load(self.decompress(data), use_embedded_server_options)
         self.data_filename = multidatapath
 
     @staticmethod
-    def _decompress(data: bytes) -> dict:
+    def decompress(data: bytes) -> dict:
         format_version = data[0]
-        if format_version != 1:
-            raise Exception("Incompatible multidata.")
+        if format_version > 3:
+            raise Utils.VersionException("Incompatible multidata.")
         return restricted_loads(zlib.decompress(data[1:]))
 
     def _load(self, decoded_obj: dict, use_embedded_server_options: bool):
@@ -272,19 +319,40 @@ class Context:
         self.slot_data = decoded_obj['slot_data']
         self.er_hint_data = {int(player): {int(address): name for address, name in loc_data.items()}
                              for player, loc_data in decoded_obj["er_hint_data"].items()}
-        self.games = decoded_obj["games"]
-        # award remote-items start inventory:
+
+        # load start inventory:
+        for slot, item_codes in decoded_obj["precollected_items"].items():
+            self.start_inventory[slot] = [NetworkItem(item_code, -2, 0) for item_code in item_codes]
+
         for team in range(len(decoded_obj['names'])):
-            for slot, item_codes in decoded_obj["precollected_items"].items():
-                if slot in self.remote_start_inventory:
-                    self.received_items[team, slot] = [NetworkItem(item_code, -2, 0) for item_code in item_codes]
             for slot, hints in decoded_obj["precollected_hints"].items():
                 self.hints[team, slot].update(hints)
-        # declare slots without checks as done, as they're assumed to be spectators
-        for slot, locations in self.locations.items():
-            if not locations:
+        if "slot_info" in decoded_obj:
+            self.slot_info = decoded_obj["slot_info"]
+            self.games = {slot: slot_info.game for slot, slot_info in self.slot_info.items()}
+            self.groups = {slot: slot_info.group_members for slot, slot_info in self.slot_info.items()
+                           if slot_info.type == SlotType.group}
+        else:
+            self.games = decoded_obj["games"]
+            self.groups = {}
+            self.slot_info = {
+                slot: NetworkSlot(
+                    self.player_names[0, slot],
+                    self.games[slot],
+                    SlotType(int(bool(locations))))
+                for slot, locations in self.locations.items()
+            }
+            # locations may need converting
+            for slot, locations in self.locations.items():
+                for location, item_data in locations.items():
+                    if len(item_data) < 3:
+                        locations[location] = (*item_data, 0)
+        # declare slots that aren't players as done
+        for slot, slot_info in self.slot_info.items():
+            if slot_info.type.always_goal:
                 for team in self.clients:
                     self.client_game_state[team, slot] = ClientStatus.CLIENT_GOAL
+
         if use_embedded_server_options:
             server_options = decoded_obj.get("server_options", {})
             self._set_options(server_options)
@@ -351,6 +419,7 @@ class Context:
     def get_save(self) -> dict:
         self.recheck_hints()
         d = {
+            "version": self.save_version,
             "connect_names": self.connect_names,
             "received_items": self.received_items,
             "hints_used": dict(self.hints_used),
@@ -362,7 +431,13 @@ class Context:
                 (key, value.timestamp()) for key, value in self.client_activity_timers.items()),
             "client_connection_timers": tuple(
                 (key, value.timestamp()) for key, value in self.client_connection_timers.items()),
-            "random_state": self.random.getstate()
+            "random_state": self.random.getstate(),
+            "stored_data": self.stored_data,
+            "game_options": {"hint_cost": self.hint_cost, "location_check_points": self.location_check_points,
+                             "server_password": self.server_password, "password": self.password, "forfeit_mode":
+                             self.forfeit_mode, "remaining_mode": self.remaining_mode, "collect_mode":
+                             self.collect_mode, "item_cheat": self.item_cheat, "compatibility": self.compatibility}
+
         }
 
         return d
@@ -370,7 +445,22 @@ class Context:
     def set_save(self, savedata: dict):
         if self.connect_names != savedata["connect_names"]:
             raise Exception("This savegame does not appear to match the loaded multiworld.")
-        self.received_items = savedata["received_items"]
+        if "version" not in savedata:
+            # upgrade from version 1
+            # this is not perfect but good enough for old games to continue
+            for old, items in savedata["received_items"].items():
+                self.received_items[(*old, True)] = items
+                self.received_items[(*old, False)] = items.copy()
+            for (team, slot, remote) in self.received_items:
+                # remove start inventory from items, since this is separate now
+                start_inventory = get_start_inventory(self, slot, slot in self.remote_start_inventory)
+                if start_inventory:
+                    del self.received_items[team, slot, remote][:len(start_inventory)]
+            logging.info("Upgraded save data")
+        elif savedata["version"] > self.save_version:
+            raise Exception("This savegame is newer than the server.")
+        else:
+            self.received_items = savedata["received_items"]
         self.hints_used.update(savedata["hints_used"])
         self.hints.update(savedata["hints"])
 
@@ -383,10 +473,25 @@ class Context:
             {tuple(key): datetime.datetime.fromtimestamp(value, datetime.timezone.utc) for key, value
              in savedata["client_activity_timers"]})
         self.location_checks.update(savedata["location_checks"])
-        if "random_state" in savedata:
-            self.random.setstate(savedata["random_state"])
-        logging.info(f'Loaded save file with {sum([len(p) for p in self.received_items.values()])} received items '
-                     f'for {len(self.received_items)} players')
+        self.random.setstate(savedata["random_state"])
+
+        if "game_options" in savedata:
+            self.hint_cost = savedata["game_options"]["hint_cost"]
+            self.location_check_points = savedata["game_options"]["location_check_points"]
+            self.server_password = savedata["game_options"]["server_password"]
+            self.password = savedata["game_options"]["password"]
+            self.forfeit_mode = savedata["game_options"]["forfeit_mode"]
+            self.remaining_mode = savedata["game_options"]["remaining_mode"]
+            self.collect_mode = savedata["game_options"]["collect_mode"]
+            self.item_cheat = savedata["game_options"]["item_cheat"]
+            self.compatibility = savedata["game_options"]["compatibility"]
+
+        if "stored_data" in savedata:
+            self.stored_data = savedata["stored_data"]
+        # count items and slots from lists for item_handling = remote
+        logging.info(
+            f'Loaded save file with {sum([len(v) for k, v in self.received_items.items() if k[2]])} received items '
+            f'for {sum(k[2] for k in self.received_items)} players')
 
     # rest
 
@@ -443,20 +548,34 @@ class Context:
 
 
 def notify_hints(ctx: Context, team: int, hints: typing.List[NetUtils.Hint]):
+    """Send and remember hints"""
     concerns = collections.defaultdict(list)
     for hint in hints:
         net_msg = hint.as_network_message()
-        concerns[hint.receiving_player].append(net_msg)
-        if not hint.local:
+        if hint.receiving_player in ctx.groups:
+            for player in ctx.groups[hint.receiving_player]:
+                concerns[player].append(net_msg)
+        else:
+            concerns[hint.receiving_player].append(net_msg)
+        if not hint.local and net_msg not in concerns[hint.finding_player]:
             concerns[hint.finding_player].append(net_msg)
+        # remember hints in all cases
+        if not hint.found:
+            ctx.hints[team, hint.finding_player].add(hint)
+            if hint.receiving_player in ctx.groups:
+                for player in ctx.groups[hint.receiving_player]:
+                    ctx.hints[team, player].add(hint)
+            else:
+                ctx.hints[team, hint.receiving_player].add(hint)
     for text in (format_hint(ctx, team, hint) for hint in hints):
         logging.info("Notice (Team #%d): %s" % (team + 1, text))
 
-    for slot, clients in ctx.clients[team].items():
-        client_hints = concerns[slot]
-        if client_hints:
-            for client in clients:
-                asyncio.create_task(ctx.send_msgs(client, client_hints))
+    if hints:
+        for slot, clients in ctx.clients[team].items():
+            client_hints = concerns[slot]
+            if client_hints:
+                for client in clients:
+                    asyncio.create_task(ctx.send_msgs(client, client_hints))
 
 
 def update_aliases(ctx: Context, team: int):
@@ -506,6 +625,8 @@ async def on_client_connected(ctx: Context, client: Client):
         'cmd': 'RoomInfo',
         'password': bool(ctx.password),
         'players': players,
+        # TODO remove around 0.2.5 in favor of slot_info ?
+        #  Maybe convert into a list of games that are present to fetch relevant datapackage entries before Connect?
         'games': [ctx.games[x] for x in range(1, len(ctx.games) + 1)],
         # tags are for additional features in the communication.
         # Name them by feature or fork, as you feel is appropriate.
@@ -543,7 +664,10 @@ async def on_client_joined(ctx: Context, client: Client):
         f"{ctx.get_aliased_name(client.team, client.slot)} (Team #{client.team + 1}) "
         f"{verb} {ctx.games[client.slot]} has joined. "
         f"Client({version_str}), {client.tags}).")
-
+    ctx.notify_client(client, "Now that you are connected, "
+                              "you can use !help to list commands to run via the server. "
+                              "If your client supports it, "
+                              "you may have additional local commands you can list with /help.")
     ctx.client_connection_timers[client.team, client.slot] = datetime.datetime.now(datetime.timezone.utc)
 
 
@@ -574,16 +698,19 @@ def get_players_string(ctx: Context):
     player_names = sorted(ctx.player_names.keys())
     current_team = -1
     text = ''
+    total = 0
     for team, slot in player_names:
-        player_name = ctx.player_names[team, slot]
-        if team != current_team:
-            text += f':: Team #{team + 1}: '
-            current_team = team
-        if (team, slot) in auth_clients:
-            text += f'{player_name} '
-        else:
-            text += f'({player_name}) '
-    return f'{len(auth_clients)} players of {len(ctx.player_names)} connected ' + text[:-1]
+        if ctx.slot_info[slot].type == SlotType.player:
+            total += 1
+            player_name = ctx.player_names[team, slot]
+            if team != current_team:
+                text += f':: Team #{team + 1}: '
+                current_team = team
+            if (team, slot) in auth_clients:
+                text += f'{player_name} '
+            else:
+                text += f'({player_name}) '
+    return f'{len(auth_clients)} players of {total} connected ' + text[:-1]
 
 
 def get_status_string(ctx: Context, team: int):
@@ -599,21 +726,29 @@ def get_status_string(ctx: Context, team: int):
     return text
 
 
-def get_received_items(ctx: Context, team: int, player: int) -> typing.List[NetworkItem]:
-    return ctx.received_items.setdefault((team, player), [])
+def get_received_items(ctx: Context, team: int, player: int, remote_items: bool) -> typing.List[NetworkItem]:
+    return ctx.received_items.setdefault((team, player, remote_items), [])
+
+
+def get_start_inventory(ctx: Context, player: int, remote_start_inventory: bool) -> typing.List[NetworkItem]:
+    return ctx.start_inventory.setdefault(player, []) if remote_start_inventory else []
 
 
 def send_new_items(ctx: Context):
     for team, clients in ctx.clients.items():
         for slot, clients in clients.items():
-            items = get_received_items(ctx, team, slot)
             for client in clients:
-                if len(items) > client.send_index:
+                if client.no_items:
+                    continue
+                start_inventory = get_start_inventory(ctx, slot, client.remote_start_inventory)
+                items = get_received_items(ctx, team, slot, client.remote_items)
+                if len(start_inventory) + len(items) > client.send_index:
+                    first_new_item = max(0, client.send_index - len(start_inventory))
                     asyncio.create_task(ctx.send_msgs(client, [{
                         "cmd": "ReceivedItems",
                         "index": client.send_index,
-                        "items": items[client.send_index:]}]))
-                    client.send_index = len(items)
+                        "items": start_inventory[client.send_index:] + items[first_new_item:]}]))
+                    client.send_index = len(start_inventory) + len(items)
 
 
 def update_checked_locations(ctx: Context, team: int, slot: int):
@@ -633,13 +768,13 @@ def collect_player(ctx: Context, team: int, slot: int):
     """register any locations that are in the multidata, pointing towards this player"""
     all_locations = collections.defaultdict(set)
     for source_slot, location_data in ctx.locations.items():
-        for location_id, (item_id, target_player_id) in location_data.items():
-            if target_player_id == slot:
+        for location_id, values in location_data.items():
+            if values[1] == slot:
                 all_locations[source_slot].add(location_id)
 
     ctx.notify_all("%s (Team #%d) has collected" % (ctx.player_names[(team, slot)], team + 1))
     for source_player, location_ids in all_locations.items():
-        register_location_checks(ctx, team, source_player, location_ids)
+        register_location_checks(ctx, team, source_player, location_ids, count_activity=False)
         update_checked_locations(ctx, team, source_player)
 
 
@@ -651,16 +786,26 @@ def get_remaining(ctx: Context, team: int, slot: int) -> typing.List[int]:
     return sorted(items)
 
 
-def register_location_checks(ctx: Context, team: int, slot: int, locations: typing.Iterable[int]):
+def send_items_to(ctx: Context, team: int, target_slot: int, *items: NetworkItem):
+    targets = ctx.groups.get(target_slot, [target_slot])
+    for target in targets:
+        for item in items:
+            if item.player != target_slot:
+                get_received_items(ctx, team, target, False).append(item)
+            get_received_items(ctx, team, target, True).append(item)
+
+
+def register_location_checks(ctx: Context, team: int, slot: int, locations: typing.Iterable[int],
+                             count_activity: bool = True):
     new_locations = set(locations) - ctx.location_checks[team, slot]
     new_locations.intersection_update(ctx.locations[slot])  # ignore location IDs unknown to this multidata
     if new_locations:
-        ctx.client_activity_timers[team, slot] = datetime.datetime.now(datetime.timezone.utc)
+        if count_activity:
+            ctx.client_activity_timers[team, slot] = datetime.datetime.now(datetime.timezone.utc)
         for location in new_locations:
-            item_id, target_player = ctx.locations[slot][location]
-            new_item = NetworkItem(item_id, location, slot)
-            if target_player != slot or slot in ctx.remote_items:
-                get_received_items(ctx, team, target_player).append(new_item)
+            item_id, target_player, flags = ctx.locations[slot][location]
+            new_item = NetworkItem(item_id, location, slot, flags)
+            send_items_to(ctx, team, target_player, new_item)
 
             logging.info('(Team #%d) %s sent %s to %s (%s)' % (
                 team + 1, ctx.player_names[(team, slot)], get_item_name_from_id(item_id),
@@ -679,32 +824,39 @@ def register_location_checks(ctx: Context, team: int, slot: int, locations: typi
         ctx.save()
 
 
-def notify_team(ctx: Context, team: int, text: str):
-    logging.info("Notice (Team #%d): %s" % (team + 1, text))
-    ctx.broadcast_team(team, [['Print', {"text": text}]])
-
-
 def collect_hints(ctx: Context, team: int, slot: int, item: str) -> typing.List[NetUtils.Hint]:
     hints = []
+    slots = []
+    for group_id, group in ctx.groups.items():
+        if slot in group:
+            slots.append(group_id)
     seeked_item_id = proxy_worlds[ctx.games[slot]].item_name_to_id[item]
     for finding_player, check_data in ctx.locations.items():
         for location_id, result in check_data.items():
-            item_id, receiving_player = result
-            if receiving_player == slot and item_id == seeked_item_id:
+            item_id, receiving_player, item_flags = result
+
+            if (receiving_player == slot or receiving_player in slots) and item_id == seeked_item_id:
                 found = location_id in ctx.location_checks[team, finding_player]
                 entrance = ctx.er_hint_data.get(finding_player, {}).get(location_id, "")
-                hints.append(NetUtils.Hint(receiving_player, finding_player, location_id, item_id, found, entrance))
+                hints.append(NetUtils.Hint(receiving_player, finding_player, location_id, item_id, found, entrance,
+                                           item_flags))
 
     return hints
 
 
-def collect_hints_location(ctx: Context, team: int, slot: int, location: str) -> typing.List[NetUtils.Hint]:
+def collect_hint_location_name(ctx: Context, team: int, slot: int, location: str) -> typing.List[NetUtils.Hint]:
     seeked_location: int = proxy_worlds[ctx.games[slot]].location_name_to_id[location]
-    item_id, receiving_player = ctx.locations[slot].get(seeked_location, (None, None))
-    if item_id:
+    return collect_hint_location_id(ctx, team, slot, seeked_location)
+
+
+def collect_hint_location_id(ctx: Context, team: int, slot: int, seeked_location: int) -> typing.List[NetUtils.Hint]:
+    result = ctx.locations[slot].get(seeked_location, (None, None, None))
+    if any(result):
+        item_id, receiving_player, item_flags = result
+
         found = seeked_location in ctx.location_checks[team, slot]
         entrance = ctx.er_hint_data.get(slot, {}).get(seeked_location, "")
-        return [NetUtils.Hint(receiving_player, slot, seeked_location, item_id, found, entrance)]
+        return [NetUtils.Hint(receiving_player, slot, seeked_location, item_id, found, entrance, item_flags)]
     return []
 
 
@@ -724,10 +876,10 @@ def json_format_send_event(net_item: NetworkItem, receiving_player: int):
     NetUtils.add_json_text(parts, net_item.player, type=NetUtils.JSONTypes.player_id)
     if net_item.player == receiving_player:
         NetUtils.add_json_text(parts, " found their ")
-        NetUtils.add_json_item(parts, net_item.item, net_item.player)
+        NetUtils.add_json_item(parts, net_item.item, net_item.player, net_item.flags)
     else:
         NetUtils.add_json_text(parts, " sent ")
-        NetUtils.add_json_item(parts, net_item.item, receiving_player)
+        NetUtils.add_json_item(parts, net_item.item, receiving_player, net_item.flags)
         NetUtils.add_json_text(parts, " to ")
         NetUtils.add_json_text(parts, receiving_player, type=NetUtils.JSONTypes.player_id)
 
@@ -1073,7 +1225,8 @@ class ClientMessageProcessor(CommonCommandProcessor):
                                                             world.item_names)
             if usable:
                 new_item = NetworkItem(world.create_item(item_name).code, -1, self.client.slot)
-                get_received_items(self.ctx, self.client.team, self.client.slot).append(new_item)
+                get_received_items(self.ctx, self.client.team, self.client.slot, False).append(new_item)
+                get_received_items(self.ctx, self.client.team, self.client.slot, True).append(new_item)
                 self.ctx.notify_all(
                     'Cheat console: sending "' + item_name + '" to ' + self.ctx.get_aliased_name(self.client.team,
                                                                                                  self.client.slot))
@@ -1086,7 +1239,7 @@ class ClientMessageProcessor(CommonCommandProcessor):
             self.output("Cheating is disabled.")
             return False
 
-    def get_hints(self, input_text: str, explicit_location: bool = False) -> bool:
+    def get_hints(self, input_text: str, for_location: bool = False) -> bool:
         points_available = get_client_points(self.ctx, self.client)
         if not input_text:
             hints = {hint.re_check(self.ctx, self.client.team) for hint in
@@ -1098,20 +1251,21 @@ class ClientMessageProcessor(CommonCommandProcessor):
             return True
         else:
             world = proxy_worlds[self.ctx.games[self.client.slot]]
-            item_name, usable, response = get_intended_text(input_text,
-                                                            world.all_names if not explicit_location else world.location_names)
+            names = world.location_names if for_location else world.all_item_and_group_names
+            hint_name, usable, response = get_intended_text(input_text,
+                                                            names)
             if usable:
-                if item_name in world.hint_blacklist:
-                    self.output(f"Sorry, \"{item_name}\" is marked as non-hintable.")
+                if hint_name in world.hint_blacklist:
+                    self.output(f"Sorry, \"{hint_name}\" is marked as non-hintable.")
                     hints = []
-                elif item_name in world.item_name_groups and not explicit_location:
+                elif not for_location and hint_name in world.item_name_groups:  # item group name
                     hints = []
-                    for item in world.item_name_groups[item_name]:
+                    for item in world.item_name_groups[hint_name]:
                         hints.extend(collect_hints(self.ctx, self.client.team, self.client.slot, item))
-                elif item_name in world.item_names and not explicit_location:  # item name
-                    hints = collect_hints(self.ctx, self.client.team, self.client.slot, item_name)
+                elif not for_location and hint_name in world.item_names:  # item name
+                    hints = collect_hints(self.ctx, self.client.team, self.client.slot, hint_name)
                 else:  # location name
-                    hints = collect_hints_location(self.ctx, self.client.team, self.client.slot, item_name)
+                    hints = collect_hint_location_name(self.ctx, self.client.team, self.client.slot, hint_name)
                 cost = self.ctx.get_hint_cost(self.client.slot)
                 if hints:
                     new_hints = set(hints) - self.ctx.hints[self.client.team, self.client.slot]
@@ -1143,10 +1297,6 @@ class ClientMessageProcessor(CommonCommandProcessor):
                             self.ctx.hints_used[self.client.team, self.client.slot] += 1
                             points_available = get_client_points(self.ctx, self.client)
 
-                            if not hint.found:
-                                self.ctx.hints[self.client.team, hint.finding_player].add(hint)
-                                self.ctx.hints[self.client.team, hint.receiving_player].add(hint)
-
                         if not_found_hints:
                             if hints and cost and int((points_available // cost) == 0):
                                 self.output(
@@ -1172,19 +1322,17 @@ class ClientMessageProcessor(CommonCommandProcessor):
                 return False
 
     @mark_raw
-    def _cmd_hint(self, item_or_location: str = "") -> bool:
-        """Use !hint {item_name/location_name},
-        for example !hint Lamp or !hint Link's House to get a spoiler peek for that location or item.
+    def _cmd_hint(self, item: str = "") -> bool:
+        """Use !hint {item_name},
+        for example !hint Lamp to get a spoiler peek for that item.
         If hint costs are on, this will only give you one new result,
         you can rerun the command to get more in that case."""
-        return self.get_hints(item_or_location)
+        return self.get_hints(item)
 
     @mark_raw
     def _cmd_hint_location(self, location: str = "") -> bool:
         """Use !hint_location {location_name},
-        for example !hint_location atomic-bomb to get a spoiler peek for that location.
-        (In the case of factorio, or any other game where item names and location names are identical,
-        this command must be used explicitly.)"""
+        for example !hint_location atomic-bomb to get a spoiler peek for that location."""
         return self.get_hints(location, True)
 
 
@@ -1236,7 +1384,6 @@ async def process_client_cmd(ctx: Context, client: Client, args: dict):
             errors.add('InvalidPassword')
 
         if args['name'] not in ctx.connect_names:
-            logging.info((args["name"], ctx.connect_names))
             errors.add('InvalidSlot')
         else:
             team, slot = ctx.connect_names[args['name']]
@@ -1246,6 +1393,20 @@ async def process_client_cmd(ctx: Context, client: Client, args: dict):
             minver = ctx.minimum_client_versions[slot]
             if minver > args['version']:
                 errors.add('IncompatibleVersion')
+            if args.get('items_handling', None) is None:
+                # fall back to load from multidata
+                client.no_items = False
+                client.remote_items = slot in ctx.remote_items
+                client.remote_start_inventory = slot in ctx.remote_start_inventory
+                await ctx.send_msgs(client, [{
+                    "cmd": "Print", "text":
+                        "Warning: Client is not sending items_handling flags, "
+                        "which will not be supported in the future."}])
+            else:
+                try:
+                    client.items_handling = args['items_handling']
+                except (ValueError, TypeError):
+                    errors.add('InvalidItemsHandling')
 
         # only exact version match allowed
         if ctx.compatibility == 0 and args['version'] != version_tuple:
@@ -1266,18 +1427,21 @@ async def process_client_cmd(ctx: Context, client: Client, args: dict):
             ctx.clients[team][slot].append(client)
             client.version = args['version']
             client.tags = args['tags']
+            client.no_locations = 'TextOnly' in client.tags or 'Tracker' in client.tags
             reply = [{
                 "cmd": "Connected",
                 "team": client.team, "slot": client.slot,
                 "players": ctx.get_players_package(),
                 "missing_locations": get_missing_checks(ctx, team, slot),
                 "checked_locations": get_checked_checks(ctx, team, slot),
-                "slot_data": ctx.slot_data[client.slot]
+                "slot_data": ctx.slot_data[client.slot],
+                "slot_info": ctx.slot_info
             }]
-            items = get_received_items(ctx, client.team, client.slot)
-            if items:
-                reply.append({"cmd": 'ReceivedItems', "index": 0, "items": items})
-                client.send_index = len(items)
+            start_inventory = get_start_inventory(ctx, slot, client.remote_start_inventory)
+            items = get_received_items(ctx, client.team, client.slot, client.remote_items)
+            if (start_inventory or items) and not client.no_items:
+                reply.append({"cmd": 'ReceivedItems', "index": 0, "items": start_inventory + items})
+                client.send_index = len(start_inventory) + len(items)
             if not client.auth:  # if this was a Re-Connect, don't print to console
                 client.auth = True
                 await on_client_joined(ctx, client)
@@ -1305,23 +1469,42 @@ async def process_client_cmd(ctx: Context, client: Client, args: dict):
                                               "original_cmd": cmd}])
                 return
 
+            if args.get('items_handling', None) is not None and client.items_handling != args['items_handling']:
+                try:
+                    client.items_handling = args['items_handling']
+                    start_inventory = get_start_inventory(ctx, client.slot, client.remote_start_inventory)
+                    items = get_received_items(ctx, client.team, client.slot, client.remote_items)
+                    if (items or start_inventory) and not client.no_items:
+                        client.send_index = len(start_inventory) + len(items)
+                        await ctx.send_msgs(client, [{"cmd": "ReceivedItems", "index": 0,
+                                                      "items": start_inventory + items}])
+                    else:
+                        client.send_index = 0
+                except (ValueError, TypeError) as err:
+                    await ctx.send_msgs(client, [{'cmd': 'InvalidPacket', 'type': 'arguments',
+                                                  'text': f'Invalid items_handling: {err}',
+                                                  'original_cmd': cmd}])
+                    return
+
             if "tags" in args:
                 old_tags = client.tags
                 client.tags = args["tags"]
                 if set(old_tags) != set(client.tags):
+                    client.no_locations = 'TextOnly' in client.tags or 'Tracker' in client.tags
                     ctx.notify_all(
                         f"{ctx.get_aliased_name(client.team, client.slot)} (Team #{client.team + 1}) has changed tags "
                         f"from {old_tags} to {client.tags}.")
 
         elif cmd == 'Sync':
-            items = get_received_items(ctx, client.team, client.slot)
-            if items:
-                client.send_index = len(items)
+            start_inventory = get_start_inventory(ctx, client.slot, client.remote_start_inventory)
+            items = get_received_items(ctx, client.team, client.slot, client.remote_items)
+            if (start_inventory or items) and not client.no_items:
+                client.send_index = len(start_inventory) + len(items)
                 await ctx.send_msgs(client, [{"cmd": "ReceivedItems", "index": 0,
-                                              "items": items}])
+                                              "items": start_inventory + items}])
 
         elif cmd == 'LocationChecks':
-            if "Tracker" in client.tags:
+            if client.no_locations:
                 await ctx.send_msgs(client, [{'cmd': 'InvalidPacket', "type": "cmd",
                                               "text": "Trackers can't register new Location Checks",
                                               "original_cmd": cmd}])
@@ -1330,15 +1513,20 @@ async def process_client_cmd(ctx: Context, client: Client, args: dict):
 
         elif cmd == 'LocationScouts':
             locs = []
+            create_as_hint = args.get("create_as_hint", False)
+            hints = []
             for location in args["locations"]:
                 if type(location) is not int or location not in lookup_any_location_id_to_name:
                     await ctx.send_msgs(client,
                                         [{'cmd': 'InvalidPacket', "type": "arguments", "text": 'LocationScouts',
                                           "original_cmd": cmd}])
                     return
-                target_item, target_player = ctx.locations[client.slot][location]
-                locs.append(NetworkItem(target_item, location, target_player))
 
+                target_item, target_player, flags = ctx.locations[client.slot][location]
+                if create_as_hint:
+                    hints.extend(collect_hint_location_id(ctx, client.team, client.slot, location))
+                locs.append(NetworkItem(target_item, location, target_player, flags))
+            notify_hints(ctx, client.team, hints)
             await ctx.send_msgs(client, [{'cmd': 'LocationInfo', 'locations': locs}])
 
         elif cmd == 'StatusUpdate':
@@ -1365,6 +1553,43 @@ async def process_client_cmd(ctx: Context, client: Client, args: dict):
                                                          bounceclient.slot in slots):
                     await ctx.send_encoded_msgs(bounceclient, msg)
 
+        elif cmd == "Get":
+            if "keys" not in args or type(args["keys"]) != list:
+                await ctx.send_msgs(client, [{'cmd': 'InvalidPacket', "type": "arguments",
+                                              "text": 'Retrieve', "original_cmd": cmd}])
+                return
+            args["cmd"] = "Retrieved"
+            keys = args["keys"]
+            args["keys"] = {key: ctx.stored_data.get(key, None) for key in keys}
+            await ctx.send_msgs(client, [args])
+
+        elif cmd == "Set":
+            if "key" not in args or \
+                    "operations" not in args or not type(args["operations"]) == list:
+                await ctx.send_msgs(client, [{'cmd': 'InvalidPacket', "type": "arguments",
+                                              "text": 'Set', "original_cmd": cmd}])
+                return
+            args["cmd"] = "SetReply"
+            value = ctx.stored_data.get(args["key"], args.get("default", 0))
+            args["original_value"] = value
+            for operation in args["operations"]:
+                func = modify_functions[operation["operation"]]
+                value = func(value, operation["value"])
+            ctx.stored_data[args["key"]] = args["value"] = value
+            targets = set(ctx.stored_data_notification_clients[args["key"]])
+            if args.get("want_reply", True):
+                targets.add(client)
+            if targets:
+                ctx.broadcast(targets, [args])
+
+        elif cmd == "SetNotify":
+            if "keys" not in args or type(args["keys"]) != list:
+                await ctx.send_msgs(client, [{'cmd': 'InvalidPacket', "type": "arguments",
+                                              "text": 'SetNotify', "original_cmd": cmd}])
+                return
+            for key in args["keys"]:
+                ctx.stored_data_notification_clients[key].add(client)
+
 
 def update_client_status(ctx: Context, client: Client, new_status: ClientStatus):
     current = ctx.client_game_state[client.team, client.slot]
@@ -1487,8 +1712,8 @@ class ServerCommandProcessor(CommonCommandProcessor):
         self.output(f"Could not find player {player_name} to forbid the !forfeit command for.")
         return False
 
-    def _cmd_send(self, player_name: str, *item_name: str) -> bool:
-        """Sends an item to the specified player"""
+    def _cmd_send_multiple(self, amount: typing.Union[int, str], player_name: str, *item_name: str) -> bool:
+        """Sends multiples of an item to the specified player"""
         seeked_player, usable, response = get_intended_text(player_name, self.ctx.player_names.values())
         if usable:
             team, slot = self.ctx.player_name_lookup[seeked_player]
@@ -1496,11 +1721,14 @@ class ServerCommandProcessor(CommonCommandProcessor):
             world = proxy_worlds[self.ctx.games[slot]]
             item, usable, response = get_intended_text(item, world.item_names)
             if usable:
-                new_item = NetworkItem(world.item_name_to_id[item], -1, 0)
-                get_received_items(self.ctx, team, slot).append(new_item)
-                self.ctx.notify_all('Cheat console: sending "' + item + '" to ' +
-                                    self.ctx.get_aliased_name(team, slot))
+                amount: int = int(amount)
+                new_items = [NetworkItem(world.item_name_to_id[item], -1, 0) for i in range(int(amount))]
+                send_items_to(self.ctx, team, slot, *new_items)
+
                 send_new_items(self.ctx)
+                self.ctx.notify_all(
+                    'Cheat console: sending ' + ('' if amount == 1 else f'{amount} of ') +
+                    f'"{item}" to {self.ctx.get_aliased_name(team, slot)}')
                 return True
             else:
                 self.output(response)
@@ -1509,23 +1737,50 @@ class ServerCommandProcessor(CommonCommandProcessor):
             self.output(response)
             return False
 
-    def _cmd_hint(self, player_name: str, *item_or_location: str) -> bool:
-        """Send out a hint for a player's item or location to their team"""
+    def _cmd_send(self, player_name: str, *item_name: str) -> bool:
+        """Sends an item to the specified player"""
+        return self._cmd_send_multiple(1, player_name, *item_name)
+
+    def _cmd_hint(self, player_name: str, *item: str) -> bool:
+        """Send out a hint for a player's item to their team"""
         seeked_player, usable, response = get_intended_text(player_name, self.ctx.player_names.values())
         if usable:
             team, slot = self.ctx.player_name_lookup[seeked_player]
-            item = " ".join(item_or_location)
+            item = " ".join(item)
             world = proxy_worlds[self.ctx.games[slot]]
-            item, usable, response = get_intended_text(item, world.all_names)
+            item, usable, response = get_intended_text(item, world.all_item_and_group_names)
             if usable:
                 if item in world.item_name_groups:
                     hints = []
                     for item in world.item_name_groups[item]:
                         hints.extend(collect_hints(self.ctx, team, slot, item))
-                elif item in world.item_names:  # item name
+                else:  # item name
                     hints = collect_hints(self.ctx, team, slot, item)
-                else:  # location name
-                    hints = collect_hints_location(self.ctx, team, slot, item)
+
+                if hints:
+                    notify_hints(self.ctx, team, hints)
+
+                else:
+                    self.output("No hints found.")
+                return True
+            else:
+                self.output(response)
+                return False
+
+        else:
+            self.output(response)
+            return False
+
+    def _cmd_hint_location(self, player_name: str, *location: str) -> bool:
+        """Send out a hint for a player's location to their team"""
+        seeked_player, usable, response = get_intended_text(player_name, self.ctx.player_names.values())
+        if usable:
+            team, slot = self.ctx.player_name_lookup[seeked_player]
+            item = " ".join(location)
+            world = proxy_worlds[self.ctx.games[slot]]
+            item, usable, response = get_intended_text(item, world.location_names)
+            if usable:
+                hints = collect_hint_location_name(self.ctx, team, slot, item)
                 if hints:
                     notify_hints(self.ctx, team, hints)
                 else:
@@ -1556,6 +1811,8 @@ class ServerCommandProcessor(CommonCommandProcessor):
             self.output(f"Set option {option_name} to {getattr(self.ctx, option_name)}")
             if option_name in {"forfeit_mode", "remaining_mode", "collect_mode"}:
                 self.ctx.broadcast_all([{"cmd": "RoomUpdate", 'permissions': get_permissions(self.ctx)}])
+            elif option_name in {"hint_cost", "location_check_points"}:
+                self.ctx.broadcast_all([{"cmd": "RoomUpdate", option_name: getattr(self.ctx, option_name)}])
             return True
         else:
             known = (f"{option}:{otype}" for option, otype in self.ctx.simple_options.items())
@@ -1675,11 +1932,18 @@ async def main(args: argparse.Namespace):
 
     try:
         if not data_filename:
-            import tkinter
-            import tkinter.filedialog
-            root = tkinter.Tk()
-            root.withdraw()
-            data_filename = tkinter.filedialog.askopenfilename(filetypes=(("Multiworld data", "*.archipelago *.zip"),))
+            try:
+                import tkinter
+                import tkinter.filedialog
+            except Exception as e:
+                logging.error("Could not load tkinter, which is likely not installed. "
+                              "This attempt was made because no .archipelago file was provided as argument. "
+                              "Either provide a file or ensure the tkinter package is installed.")
+                raise e
+            else:
+                root = tkinter.Tk()
+                root.withdraw()
+                data_filename = tkinter.filedialog.askopenfilename(filetypes=(("Multiworld data", "*.archipelago *.zip"),))
 
         ctx.load(data_filename, args.use_embedded_options)
 

NetUtils.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import logging
 import typing
 import enum
 from json import JSONEncoder, JSONDecoder
@@ -17,6 +16,8 @@ class JSONMessagePart(typing.TypedDict, total=False):
     color: str
     # owning player for location/item
     player: int
+    # if type == item indicates item flags
+    flags: int
 
 
 class ClientStatus(enum.IntEnum):
@@ -27,7 +28,18 @@ class ClientStatus(enum.IntEnum):
     CLIENT_GOAL = 30
 
 
-class Permission(enum.IntEnum):
+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
@@ -47,16 +59,26 @@ class Permission(enum.IntEnum):
 
 
 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:
@@ -86,9 +108,10 @@ 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,
+}
 
 custom_hooks = {
     "Version": get_any_version
@@ -119,9 +142,6 @@ class Endpoint:
     def __init__(self, socket):
         self.socket = socket
 
-    async def disconnect(self):
-        raise NotImplementedError
-
 
 class HandlerMeta(type):
     def __new__(mcs, name, bases, attrs):
@@ -163,6 +183,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
 
@@ -176,7 +211,7 @@ class JSONtoTextParser(metaclass=HandlerMeta):
 
     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):
@@ -194,7 +229,17 @@ class JSONtoTextParser(metaclass=HandlerMeta):
         return self._handle_color(node)
 
     def _handle_item_name(self, node: JSONMessagePart):
-        node["color"] = 'cyan'
+        flags = node.get("flags", 0)
+        if flags == 0:
+            node["color"] = 'cyan'
+        elif flags & 0b001:  # advancement
+            node["color"] = 'plum'
+        elif flags & 0b010:  # never_exclude
+            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):
@@ -238,8 +283,8 @@ 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, **kwargs) -> None:
-    parts.append({"text": str(item_id), "player": player, "type": JSONTypes.item_id, **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:
@@ -253,13 +298,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):
@@ -270,7 +317,7 @@ 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_item(parts, self.item, self.receiving_player)
+        add_json_item(parts, self.item, self.receiving_player, self.item_flags)
         add_json_text(parts, " is at ")
         add_json_location(parts, self.location, self.finding_player)
         add_json_text(parts, " in ")
@@ -288,7 +335,7 @@ class Hint(typing.NamedTuple):
 
         return {"cmd": "PrintJSON", "data": parts, "type": "Hint",
                 "receiving": self.receiving_player,
-                "item": NetworkItem(self.item, self.location, self.finding_player),
+                "item": NetworkItem(self.item, self.location, self.finding_player, self.item_flags),
                 "found": self.found}
 
     @property

OoTAdjuster.py

@@ -12,6 +12,7 @@ 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')
@@ -86,7 +87,7 @@ def adjustGUI():
             option = sfx_options[option_name]
         optionFrame = Frame(romSettingsFrame)
         optionFrame.grid(row=row, column=column, sticky=E)
-        optionLabel = Label(optionFrame, text=option.displayname)
+        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])
@@ -142,7 +143,7 @@ def adjustGUI():
     option = cosmetic_options['sword_trail_duration']
     optionFrame = Frame(romSettingsFrame)
     optionFrame.grid(row=8, column=2, sticky=E)
-    optionLabel = Label(optionFrame, text=option.displayname)
+    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)
@@ -211,9 +212,11 @@ def adjust(args):
     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)
@@ -222,15 +225,21 @@ def adjust(args):
     else:
         raise Exception("Invalid file extension; requires .n64, .z64, .apz5")
     # Call patch_cosmetics
-    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)
-    compress_rom_file(decomp_path, comp_path)
-    os.remove(decomp_path)
+    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__':

OoTClient.py

@@ -0,0 +1,287 @@
+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"]
+
+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}")
+
+
+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
+
+    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 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
+    if payload['deathlinkActive'] and not ctx.deathlink_enabled:
+        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 five fields:
+                    # 1. str: player name (always)
+                    # 2. bool: deathlink active (always)
+                    # 3. dict[str, bool]: checked locations
+                    # 4. bool: whether Link is currently at 0 HP
+                    # 5. bool: whether the game currently registers as complete
+                    data = await asyncio.wait_for(reader.readline(), timeout=10)
+                    data_decoded = json.loads(data.decode())
+                    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)
+                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:
+            input_task = None
+            from kvui import OoTManager
+            ctx.ui = OoTManager(ctx)
+            ui_task = asyncio.create_task(ctx.ui.async_run(), name="UI")
+        else:
+            input_task = asyncio.create_task(console_loop(ctx), name="Input")
+            ui_task = None
+
+        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
+
+        if ui_task:
+            await ui_task
+
+        if input_task:
+            input_task.cancel()
+
+    import colorama
+
+    colorama.init()
+
+    loop = asyncio.get_event_loop()
+    loop.run_until_complete(main())
+    loop.close()
+    colorama.deinit()

Options.py

@@ -2,6 +2,8 @@ from __future__ import annotations
 import typing
 import random
 
+from schema import Schema, And, Or
+
 
 class AssembleOptions(type):
     def __new__(mcs, name, bases, attrs):
@@ -14,8 +16,10 @@ class AssembleOptions(type):
                 name_lookup.update(base.name_lookup)
         new_options = {name[7:].lower(): option_id for name, option_id in attrs.items() if
                        name.startswith("option_")}
-        if "random" in new_options:
-            raise Exception("Choice option 'random' cannot be manually assigned.")
+
+        assert "random" not in new_options, "Choice option 'random' cannot be manually assigned."
+        assert len(new_options) == len(set(new_options.values())), "same ID cannot be used twice. Try alias?"
+
         attrs["name_lookup"].update({option_id: name for name, option_id in new_options.items()})
         options.update(new_options)
 
@@ -25,29 +29,50 @@ class AssembleOptions(type):
 
         # auto-validate schema on __init__
         if "schema" in attrs.keys():
-            def validate_decorator(func):
-                def validate(self, *args, **kwargs):
-                    func(self, *args, **kwargs)
+
+            if "__init__" in attrs:
+                def validate_decorator(func):
+                    def validate(self, *args, **kwargs):
+                        ret = func(self, *args, **kwargs)
+                        self.value = self.schema.validate(self.value)
+                        return ret
+
+                    return validate
+
+                attrs["__init__"] = validate_decorator(attrs["__init__"])
+            else:
+                # construct an __init__ that calls parent __init__
+
+                cls = super(AssembleOptions, mcs).__new__(mcs, name, bases, attrs)
+
+                def meta__init__(self, *args, **kwargs):
+                    super(cls, self).__init__(*args, **kwargs)
                     self.value = self.schema.validate(self.value)
 
-                return validate
+                cls.__init__ = meta__init__
+                return cls
 
-            attrs["__init__"] = validate_decorator(attrs["__init__"])
         return super(AssembleOptions, mcs).__new__(mcs, name, bases, attrs)
 
 
-class Option(metaclass=AssembleOptions):
-    value: int
-    name_lookup: typing.Dict[int, str]
+T = typing.TypeVar('T')
+
+
+class Option(typing.Generic[T], metaclass=AssembleOptions):
+    value: T
     default = 0
 
-    # convert option_name_long into Name Long as displayname, otherwise name_long is the result.
+    # convert option_name_long into Name Long as display_name, otherwise name_long is the result.
     # Handled in get_option_name()
-    autodisplayname = False
+    auto_display_name = False
 
     # can be weighted between selections
     supports_weighting = True
 
+    # filled by AssembleOptions:
+    name_lookup: typing.Dict[int, str]
+    options: typing.Dict[str, int]
+
     def __repr__(self) -> str:
         return f"{self.__class__.__name__}({self.get_current_option_name()})"
 
@@ -63,13 +88,13 @@ class Option(metaclass=AssembleOptions):
         return self.get_option_name(self.value)
 
     @classmethod
-    def get_option_name(cls, value: typing.Any) -> str:
-        if cls.autodisplayname:
+    def get_option_name(cls, value: T) -> str:
+        if cls.auto_display_name:
             return cls.name_lookup[value].replace("_", " ").title()
         else:
             return cls.name_lookup[value]
 
-    def __int__(self) -> int:
+    def __int__(self) -> T:
         return self.value
 
     def __bool__(self) -> bool:
@@ -80,18 +105,20 @@ class Option(metaclass=AssembleOptions):
         raise NotImplementedError
 
 
-class Toggle(Option):
+class Toggle(Option[int]):
     option_false = 0
     option_true = 1
     default = 0
 
     def __init__(self, value: int):
-        assert value == 0 or value == 1
+        assert value == 0 or value == 1, "value of Toggle can only be 0 or 1"
         self.value = value
 
     @classmethod
     def from_text(cls, text: str) -> Toggle:
-        if text.lower() in {"off", "0", "false", "none", "null", "no"}:
+        if text == "random":
+            return cls(random.choice(list(cls.name_lookup)))
+        elif text.lower() in {"off", "0", "false", "none", "null", "no"}:
             return cls(0)
         else:
             return cls(1)
@@ -125,13 +152,15 @@ class Toggle(Option):
     def get_option_name(cls, value):
         return ["No", "Yes"][int(value)]
 
+    __hash__ = Option.__hash__  # see https://docs.python.org/3/reference/datamodel.html#object.__hash__
+
 
 class DefaultOnToggle(Toggle):
     default = 1
 
 
-class Choice(Option):
-    autodisplayname = True
+class Choice(Option[int]):
+    auto_display_name = True
 
     def __init__(self, value: int):
         self.value: int = value
@@ -141,8 +170,8 @@ class Choice(Option):
         text = text.lower()
         if text == "random":
             return cls(random.choice(list(cls.name_lookup)))
-        for optionname, value in cls.options.items():
-            if optionname == text:
+        for option_name, value in cls.options.items():
+            if option_name == text:
                 return cls(value)
         raise KeyError(
             f'Could not find option "{text}" for "{cls.__name__}", '
@@ -158,10 +187,10 @@ class Choice(Option):
         if isinstance(other, self.__class__):
             return other.value == self.value
         elif isinstance(other, str):
-            assert other in self.options
+            assert other in self.options, f"compared against a str that could never be equal. {self} == {other}"
             return other == self.current_key
         elif isinstance(other, int):
-            assert other in self.name_lookup
+            assert other in self.name_lookup, f"compared against an int that could never be equal. {self} == {other}"
             return other == self.value
         elif isinstance(other, bool):
             return other == bool(self.value)
@@ -172,10 +201,10 @@ class Choice(Option):
         if isinstance(other, self.__class__):
             return other.value != self.value
         elif isinstance(other, str):
-            assert other in self.options
+            assert other in self.options, f"compared against a str that could never be equal. {self} != {other}"
             return other != self.current_key
         elif isinstance(other, int):
-            assert other in self.name_lookup
+            assert other in self.name_lookup, f"compared against am int that could never be equal. {self} != {other}"
             return other != self.value
         elif isinstance(other, bool):
             return other != bool(self.value)
@@ -184,8 +213,10 @@ class Choice(Option):
         else:
             raise TypeError(f"Can't compare {self.__class__.__name__} with {other.__class__.__name__}")
 
+    __hash__ = Option.__hash__  # see https://docs.python.org/3/reference/datamodel.html#object.__hash__
 
-class Range(Option, int):
+
+class Range(Option[int], int):
     range_start = 0
     range_end = 1
 
@@ -206,8 +237,29 @@ class Range(Option, int):
                 return cls(int(round(random.triangular(cls.range_start, cls.range_end, cls.range_end), 0)))
             elif text == "random-middle":
                 return cls(int(round(random.triangular(cls.range_start, cls.range_end), 0)))
-            else:
+            elif text.startswith("random-range-"):
+                textsplit = text.split("-")
+                try:
+                    random_range = [int(textsplit[len(textsplit) - 2]), int(textsplit[len(textsplit) - 1])]
+                except ValueError:
+                    raise ValueError(f"Invalid random range {text} for option {cls.__name__}")
+                random_range.sort()
+                if random_range[0] < cls.range_start or random_range[1] > cls.range_end:
+                    raise Exception(
+                        f"{random_range[0]}-{random_range[1]} is outside allowed range "
+                        f"{cls.range_start}-{cls.range_end} for option {cls.__name__}")
+                if text.startswith("random-range-low"):
+                    return cls(int(round(random.triangular(random_range[0], random_range[1], random_range[0]))))
+                elif text.startswith("random-range-middle"):
+                    return cls(int(round(random.triangular(random_range[0], random_range[1]))))
+                elif text.startswith("random-range-high"):
+                    return cls(int(round(random.triangular(random_range[0], random_range[1], random_range[1]))))
+                else:
+                    return cls(int(round(random.randint(random_range[0], random_range[1]))))
+            elif text == "random":
                 return cls(random.randint(cls.range_start, cls.range_end))
+            else:
+                raise Exception(f"random text \"{text}\" did not resolve to a recognized pattern. Acceptable values are: random, random-high, random-middle, random-low, random-range-low-<min>-<max>, random-range-middle-<min>-<max>, random-range-high-<min>-<max>, or random-range-<min>-<max>.")
         return cls(int(text))
 
     @classmethod
@@ -223,27 +275,45 @@ class Range(Option, int):
         return str(self.value)
 
 
-class OptionNameSet(Option):
-    default = frozenset()
-
-    def __init__(self, value: typing.Set[str]):
-        self.value: typing.Set[str] = value
+class VerifyKeys:
+    valid_keys = frozenset()
+    valid_keys_casefold: bool = False
+    convert_name_groups: bool = False
+    verify_item_name: bool = False
+    verify_location_name: bool = False
+    value: typing.Any
 
     @classmethod
-    def from_text(cls, text: str) -> OptionNameSet:
-        return cls({option.strip() for option in text.split(",")})
+    def verify_keys(cls, data):
+        if cls.valid_keys:
+            data = set(data)
+            dataset = set(word.casefold() for word in data) if cls.valid_keys_casefold else set(data)
+            extra = dataset - cls.valid_keys
+            if extra:
+                raise Exception(f"Found unexpected key {', '.join(extra)} in {cls}. "
+                                f"Allowed keys: {cls.valid_keys}.")
 
-    @classmethod
-    def from_any(cls, data: typing.Any) -> OptionNameSet:
-        if type(data) == set:
-            return cls(data)
-        return cls.from_text(str(data))
+    def verify(self, world):
+        if self.convert_name_groups and self.verify_item_name:
+            new_value = type(self.value)()  # empty container of whatever value is
+            for item_name in self.value:
+                new_value |= world.item_name_groups.get(item_name, {item_name})
+            self.value = new_value
+        if self.verify_item_name:
+            for item_name in self.value:
+                if item_name not in world.item_names:
+                    raise Exception(f"Item {item_name} from option {self} "
+                                    f"is not a valid item name from {world.game}")
+        elif self.verify_location_name:
+            for location_name in self.value:
+                if location_name not in world.location_names:
+                    raise Exception(f"Location {location_name} from option {self} "
+                                    f"is not a valid location name from {world.game}")
 
 
-class OptionDict(Option):
+class OptionDict(Option[typing.Dict[str, typing.Any]], VerifyKeys):
     default = {}
     supports_weighting = False
-    value: typing.Dict[str, typing.Any]
 
     def __init__(self, value: typing.Dict[str, typing.Any]):
         self.value = value
@@ -251,6 +321,7 @@ class OptionDict(Option):
     @classmethod
     def from_any(cls, data: typing.Dict[str, typing.Any]) -> OptionDict:
         if type(data) == dict:
+            cls.verify_keys(data)
             return cls(data)
         else:
             raise NotImplementedError(f"Cannot Convert from non-dictionary, got {type(data)}")
@@ -263,7 +334,6 @@ class OptionDict(Option):
 
 
 class ItemDict(OptionDict):
-    # implemented by Generate
     verify_item_name = True
 
     def __init__(self, value: typing.Dict[str, int]):
@@ -272,10 +342,9 @@ class ItemDict(OptionDict):
         super(ItemDict, self).__init__(value)
 
 
-class OptionList(Option):
+class OptionList(Option[typing.List[typing.Any]], VerifyKeys):
     default = []
     supports_weighting = False
-    value: list
 
     def __init__(self, value: typing.List[typing.Any]):
         self.value = value or []
@@ -288,6 +357,7 @@ class OptionList(Option):
     @classmethod
     def from_any(cls, data: typing.Any):
         if type(data) == list:
+            cls.verify_keys(data)
             return cls(data)
         return cls.from_text(str(data))
 
@@ -298,10 +368,9 @@ class OptionList(Option):
         return item in self.value
 
 
-class OptionSet(Option):
+class OptionSet(Option[typing.Set[str]], VerifyKeys):
     default = frozenset()
     supports_weighting = False
-    value: set
 
     def __init__(self, value: typing.Union[typing.Set[str, typing.Any], typing.List[str, typing.Any]]):
         self.value = set(value)
@@ -314,13 +383,15 @@ class OptionSet(Option):
     @classmethod
     def from_any(cls, data: typing.Any):
         if type(data) == list:
+            cls.verify_keys(data)
             return cls(data)
         elif type(data) == set:
+            cls.verify_keys(data)
             return cls(data)
         return cls.from_text(str(data))
 
     def get_option_name(self, value):
-        return ", ".join(value)
+        return ", ".join(sorted(value))
 
     def __contains__(self, item):
         return item in self.value
@@ -334,7 +405,7 @@ class Accessibility(Choice):
     Locations: ensure everything can be reached and acquired.
     Items: ensure all logically relevant items can be acquired.
     Minimal: ensure what is needed to reach your goal can be acquired."""
-
+    display_name = "Accessibility"
     option_locations = 0
     option_items = 1
     option_minimal = 2
@@ -344,6 +415,7 @@ class Accessibility(Choice):
 
 class ProgressionBalancing(DefaultOnToggle):
     """A system that moves progression earlier, to try and prevent the player from getting stuck and bored early."""
+    display_name = "Progression Balancing"
 
 
 common_options = {
@@ -353,54 +425,90 @@ common_options = {
 
 
 class ItemSet(OptionSet):
-    # implemented by Generate
     verify_item_name = True
+    convert_name_groups = True
 
 
 class LocalItems(ItemSet):
     """Forces these items to be in their native world."""
-    displayname = "Local Items"
+    display_name = "Local Items"
 
 
 class NonLocalItems(ItemSet):
     """Forces these items to be outside their native world."""
-    displayname = "Not Local Items"
+    display_name = "Not Local Items"
 
 
 class StartInventory(ItemDict):
     """Start with these items."""
     verify_item_name = True
-    displayname = "Start Inventory"
+    display_name = "Start Inventory"
 
 
 class StartHints(ItemSet):
     """Start with these item's locations prefilled into the !hint command."""
-    displayname = "Start Hints"
+    display_name = "Start Hints"
 
 
 class StartLocationHints(OptionSet):
     """Start with these locations and their item prefilled into the !hint command"""
-    displayname = "Start Location Hints"
+    display_name = "Start Location Hints"
 
 
 class ExcludeLocations(OptionSet):
     """Prevent these locations from having an important item"""
-    displayname = "Excluded Locations"
+    display_name = "Excluded Locations"
+    verify_location_name = True
+
+
+class PriorityLocations(OptionSet):
+    """Prevent these locations from having an unimportant item"""
+    display_name = "Priority Locations"
     verify_location_name = True
 
 
 class DeathLink(Toggle):
     """When you die, everyone dies. Of course the reverse is true too."""
-    displayname = "Death Link"
+    display_name = "Death Link"
+
+
+class ItemLinks(OptionList):
+    """Share part of your item pool with other players."""
+    default = []
+    schema = Schema([
+        {
+            "name": And(str, len),
+            "item_pool": [And(str, len)],
+            "replacement_item": Or(And(str, len), None)
+        }
+    ])
+
+    def verify(self, world):
+        super(ItemLinks, self).verify(world)
+        existing_links = set()
+        for link in self.value:
+            if link["name"] in existing_links:
+                raise Exception(f"You cannot have more than one link named {link['name']}.")
+            existing_links.add(link["name"])
+            for item_name in link["item_pool"]:
+                if item_name not in world.item_names and item_name not in world.item_name_groups:
+                    raise Exception(f"Item {item_name} from item link {link} "
+                                    f"is not a valid item name from {world.game}")
+            if link["replacement_item"] and link["replacement_item"] not in world.item_names:
+                raise Exception(f"Item {link['replacement_item']} from item link {link} "
+                                f"is not a valid item name from {world.game}")
 
 
 per_game_common_options = {
+    **common_options,  # can be overwritten per-game
     "local_items": LocalItems,
     "non_local_items": NonLocalItems,
     "start_inventory": StartInventory,
     "start_hints": StartHints,
     "start_location_hints": StartLocationHints,
-    "exclude_locations": ExcludeLocations
+    "exclude_locations": ExcludeLocations,
+    "priority_locations": PriorityLocations,
+    "item_links": ItemLinks
 }
 
 if __name__ == "__main__":
@@ -410,8 +518,8 @@ if __name__ == "__main__":
 
     map_shuffle = Toggle
     compass_shuffle = Toggle
-    keyshuffle = Toggle
-    bigkey_shuffle = Toggle
+    key_shuffle = Toggle
+    big_key_shuffle = Toggle
     hints = Toggle
     test = argparse.Namespace()
     test.logic = Logic.from_text("no_logic")

Patch.py

@@ -1,5 +1,7 @@
-# TODO: convert this into a system like AutoWorld
+from __future__ import annotations
 
+import shutil
+import json
 import bsdiff4
 import yaml
 import os
@@ -8,21 +10,166 @@ import threading
 import concurrent.futures
 import zipfile
 import sys
-from typing import Tuple, Optional
+from typing import Tuple, Optional, Dict, Any, Union, BinaryIO
 
 import Utils
 
-current_patch_version = 3
+current_patch_version = 4
 
+
+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
+
+
+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
+
+    # 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,
+        }
+
+
+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"
-supported_games = {"A Link to the Past", "Super Metroid", "Secret of Evermore"}
+GAME_SMZ3 = "SMZ3"
+supported_games = {"A Link to the Past", "Super Metroid", "Secret of Evermore", "SMZ3"}
 
 preferred_endings = {
     GAME_ALTTP: "apbp",
     GAME_SM: "apm3",
-    GAME_SOE: "apsoe"
+    GAME_SOE: "apsoe",
+    GAME_SMZ3: "apsmz"
 }
 
 
@@ -33,6 +180,10 @@ def generate_yaml(patch: bytes, metadata: Optional[dict] = None, game: str = GAM
         from worlds.sm.Rom import JAP10HASH as HASH
     elif game == GAME_SOE:
         from worlds.soe.Patch import USHASH as HASH
+    elif game == GAME_SMZ3:
+        from worlds.alttp.Rom import JAP10HASH as ALTTPHASH
+        from worlds.sm.Rom import JAP10HASH as SMHASH
+        HASH = ALTTPHASH + SMHASH
     else:
         raise RuntimeError(f"Selected game {game} for base rom not found.")
 
@@ -62,7 +213,7 @@ def create_patch_file(rom_file_to_patch: str, server: str = "", destination: str
                            meta,
                            game)
     target = destination if destination else os.path.splitext(rom_file_to_patch)[0] + (
-        ".apbp" if game == GAME_ALTTP else ".apm3")
+        ".apbp" if game == GAME_ALTTP else ".apsmz" if game == GAME_SMZ3 else ".apm3")
     write_lzma(bytes, target)
     return target
 
@@ -87,18 +238,29 @@ def get_base_rom_data(game: str):
     elif game == GAME_SM:
         from worlds.sm.Rom import get_base_rom_bytes
     elif game == GAME_SOE:
-        file_name = Utils.get_options()["soe_options"]["rom_file"]
-        get_base_rom_bytes = lambda: bytes(read_rom(open(file_name, "rb")))
+        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
     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:
@@ -146,10 +308,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)
@@ -164,24 +379,13 @@ 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(".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(".zip"):
                     print(f"Updating host in patch files contained in {rom}")
@@ -210,4 +414,4 @@ if __name__ == "__main__":
                 import traceback
 
                 traceback.print_exc()
-                input("Press enter to close.")
+                input("Press enter to close.")

README.md

@@ -14,6 +14,15 @@ Currently, the following games are supported:
 * 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
 
 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
@@ -54,6 +63,8 @@ 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 please see the docs folder for the relevant information and feel free to ask any questions in the #archipelago-dev channel in our discord.
+
 ## 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:
 

SNIClient.py

@@ -12,7 +12,7 @@ import logging
 import asyncio
 from json import loads, dumps
 
-from Utils import get_item_name_from_id, init_logging
+from Utils import init_logging
 
 if __name__ == "__main__":
     init_logging("SNIClient", exception_logger="Client")
@@ -21,13 +21,12 @@ import colorama
 
 from NetUtils import *
 from worlds.alttp import Regions, Shops
-from worlds.alttp import Items
 from worlds.alttp.Rom import ROM_PLAYER_LIMIT
 from worlds.sm.Rom import ROM_PLAYER_LIMIT as SM_ROM_PLAYER_LIMIT
+from worlds.smz3.Rom import ROM_PLAYER_LIMIT as SMZ3_ROM_PLAYER_LIMIT
 import Utils
 from CommonClient import CommonContext, server_loop, console_loop, ClientCommandProcessor, gui_enabled, get_base_parser
-from Patch import GAME_ALTTP, GAME_SM
-
+from Patch import GAME_ALTTP, GAME_SM, GAME_SMZ3
 
 snes_logger = logging.getLogger("SNES")
 
@@ -40,7 +39,7 @@ class DeathState(enum.IntEnum):
     dead = 3
 
 
-class LttPCommandProcessor(ClientCommandProcessor):
+class SNIClientCommandProcessor(ClientCommandProcessor):
     ctx: Context
 
     def _cmd_slow_mode(self, toggle: str = ""):
@@ -55,7 +54,8 @@ class LttPCommandProcessor(ClientCommandProcessor):
     @mark_raw
     def _cmd_snes(self, snes_options: str = "") -> bool:
         """Connect to a snes. Optionally include network address of a snes to connect to,
-        otherwise show available devices; and a SNES device number if more than one SNES is detected"""
+        otherwise show available devices; and a SNES device number if more than one SNES is detected.
+        Examples: "/snes", "/snes 1", "/snes localhost:8080 1" """
 
         snes_address = self.ctx.snes_address
         snes_device_number = -1
@@ -64,13 +64,11 @@ class LttPCommandProcessor(ClientCommandProcessor):
         num_options = len(options)
 
         if num_options > 0:
-            snes_address = options[0]
+            snes_device_number = int(options[0])
 
         if num_options > 1:
-            try:
-                snes_device_number = int(options[1])
-            except:
-                pass
+            snes_address = options[0]
+            snes_device_number = int(options[1])
 
         self.ctx.snes_reconnect_address = None
         asyncio.create_task(snes_connect(self.ctx, snes_address, snes_device_number), name="SNES Connect")
@@ -91,16 +89,25 @@ class LttPCommandProcessor(ClientCommandProcessor):
     #     if self.ctx.snes_state != SNESState.SNES_ATTACHED:
     #         self.output("No attached SNES Device.")
     #         return False
-    #
     #     snes_buffered_write(self.ctx, int(address, 16), bytes([int(data)]))
     #     asyncio.create_task(snes_flush_writes(self.ctx))
     #     self.output("Data Sent")
     #     return True
 
+    # def _cmd_snes_read(self, address, size=1):
+    #     """Read the SNES' memory address (base16)."""
+    #     if self.ctx.snes_state != SNESState.SNES_ATTACHED:
+    #         self.output("No attached SNES Device.")
+    #         return False
+    #     data = await snes_read(self.ctx, int(address, 16), size)
+    #     self.output(f"Data Read: {data}")
+    #     return True
+
 
 class Context(CommonContext):
-    command_processor = LttPCommandProcessor
+    command_processor = SNIClientCommandProcessor
     game = "A Link to the Past"
+    items_handling = None  # set in game_watcher
 
     def __init__(self, snes_address, server_address, password):
         super(Context, self).__init__(server_address, password)
@@ -165,21 +172,42 @@ class Context(CommonContext):
             if not currently_dead:
                 self.death_state = DeathState.alive
 
+    def on_package(self, cmd: str, args: dict):
+        if cmd in {"Connected", "RoomUpdate"}:
+            if "checked_locations" in args and args["checked_locations"]:
+                new_locations = set(args["checked_locations"])
+                self.checked_locations |= new_locations
+                self.locations_scouted |= new_locations
+                # Items belonging to the player should not be marked as checked in game, since the player will likely need that item.
+                # Once the games handled by SNIClient gets made to be remote items, this will no longer be needed.
+                asyncio.create_task(self.send_msgs([{"cmd": "LocationScouts", "locations": list(new_locations)}]))
+
 
 async def deathlink_kill_player(ctx: Context):
     ctx.death_state = DeathState.killing_player
     while ctx.death_state == DeathState.killing_player and \
             ctx.snes_state == SNESState.SNES_ATTACHED:
         if ctx.game == GAME_ALTTP:
-            snes_buffered_write(ctx, WRAM_START + 0xF36D, bytes([0]))  # set current health to 0
-            snes_buffered_write(ctx, WRAM_START + 0x0373, bytes([8]))  # deal 1 full heart of damage at next opportunity
+            invincible = await snes_read(ctx, WRAM_START + 0x037B, 1)
+            last_health = await snes_read(ctx, WRAM_START + 0xF36D, 1)
+            await asyncio.sleep(0.25)
+            health = await snes_read(ctx, WRAM_START + 0xF36D, 1)
+            if not invincible or not last_health or not health:
+                ctx.death_state = DeathState.dead
+                ctx.last_death_link = time.time()
+                continue
+            if not invincible[0] and last_health[0] == health[0]:
+                snes_buffered_write(ctx, WRAM_START + 0xF36D, bytes([0]))  # set current health to 0
+                snes_buffered_write(ctx, WRAM_START + 0x0373,
+                                    bytes([8]))  # deal 1 full heart of damage at next opportunity
         elif ctx.game == GAME_SM:
-            snes_buffered_write(ctx, WRAM_START + 0x09C2, bytes([0, 0]))  # set current health to 0
+            snes_buffered_write(ctx, WRAM_START + 0x09C2, bytes([1, 0]))  # set current health to 1 (to prevent saving with 0 energy)
+            snes_buffered_write(ctx, WRAM_START + 0x0A50, bytes([255])) # deal 255 of damage at next opportunity
             if not ctx.death_link_allow_survive:
                 snes_buffered_write(ctx, WRAM_START + 0x09D6, bytes([0, 0]))  # set current reserve to 0
         await snes_flush_writes(ctx)
         await asyncio.sleep(1)
-        gamemode = None
+
         if ctx.game == GAME_ALTTP:
             gamemode = await snes_read(ctx, WRAM_START + 0x10, 1)
             if not gamemode or gamemode[0] in DEATH_MODES:
@@ -189,19 +217,12 @@ async def deathlink_kill_player(ctx: Context):
             health = await snes_read(ctx, WRAM_START + 0x09C2, 2)
             if health is not None:
                 health = health[0] | (health[1] << 8)
-            if not gamemode or gamemode[0] in SM_DEATH_MODES or (ctx.death_link_allow_survive and health is not None and health > 0):
+            if not gamemode or gamemode[0] in SM_DEATH_MODES or (
+                    ctx.death_link_allow_survive and health is not None and health > 0):
                 ctx.death_state = DeathState.dead
         ctx.last_death_link = time.time()
 
 
-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
 
 # LttP
@@ -230,11 +251,12 @@ 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
+SHOP_LEN = (len(Shops.shop_table) * 3) + 5
 
 DEATH_LINK_ACTIVE_ADDR = ROMNAME_START + 0x15       # 1 byte
 
 # SM
-SM_ROMNAME_START = 0x1C4F00
+SM_ROMNAME_START = 0x007FC0
 
 SM_INGAME_MODES = {0x07, 0x09, 0x0b}
 SM_ENDGAME_MODES = {0x26, 0x27}
@@ -245,6 +267,19 @@ SM_RECV_ITEM_ADDR = SAVEDATA_START + 0x4D2          # 1 byte
 SM_RECV_ITEM_PLAYER_ADDR = SAVEDATA_START + 0x4D3   # 1 byte
 
 SM_DEATH_LINK_ACTIVE_ADDR = ROM_START + 0x277f04    # 1 byte
+SM_REMOTE_ITEM_FLAG_ADDR = ROM_START + 0x277f06    # 1 byte
+
+# SMZ3
+SMZ3_ROMNAME_START = 0x00FFC0
+
+SMZ3_INGAME_MODES = {0x07, 0x09, 0x0b}
+SMZ3_ENDGAME_MODES = {0x26, 0x27}
+SMZ3_DEATH_MODES = {0x15, 0x17, 0x18, 0x19, 0x1A}
+
+SMZ3_RECV_PROGRESS_ADDR = SRAM_START + 0x4000         # 2 bytes
+SMZ3_RECV_ITEM_ADDR = SAVEDATA_START + 0x4D2          # 1 byte
+SMZ3_RECV_ITEM_PLAYER_ADDR = SAVEDATA_START + 0x4D3   # 1 byte
+
 
 location_shop_ids = set([info[0] for name, info in Shops.shop_table.items()])
 
@@ -469,6 +504,17 @@ location_table_uw = {"Blind's Hideout - Top": (0x11d, 0x10),
                      'Ganons Tower - Pre-Moldorm Chest': (0x3d, 0x40),
                      'Ganons Tower - Validation Chest': (0x4d, 0x10)}
 
+boss_locations = {Regions.lookup_name_to_id[name] for name in {'Eastern Palace - Boss',
+                                                                           'Desert Palace - Boss',
+                                                                           'Tower of Hera - Boss',
+                                                                           'Palace of Darkness - Boss',
+                                                                           'Swamp Palace - Boss',
+                                                                           'Skull Woods - Boss',
+                                                                           "Thieves' Town - Boss",
+                                                                           'Ice Palace - Boss',
+                                                                           'Misery Mire - Boss',
+                                                                           'Turtle Rock - Boss'}}
+
 location_table_uw_id = {Regions.lookup_name_to_id[name]: data for name, data in location_table_uw.items()}
 
 location_table_npc = {'Mushroom': 0x1000,
@@ -523,19 +569,28 @@ def launch_sni(ctx: Context):
     if not os.path.isdir(sni_path):
         sni_path = Utils.local_path(sni_path)
     if os.path.isdir(sni_path):
-        for file in os.listdir(sni_path):
-            lower_file = file.lower()
-            if (lower_file.startswith("sni.") and not lower_file.endswith(".proto")) or lower_file == "sni":
-                sni_path = os.path.join(sni_path, file)
+        dir_entry: os.DirEntry
+        for dir_entry in os.scandir(sni_path):
+            if dir_entry.is_file():
+                lower_file = dir_entry.name.lower()
+                if (lower_file.startswith("sni.") and not lower_file.endswith(".proto")) or (lower_file == "sni"):
+                    sni_path = dir_entry.path
+                    break
 
     if os.path.isfile(sni_path):
         snes_logger.info(f"Attempting to start {sni_path}")
         import sys
         if not sys.stdout:  # if it spawns a visible console, may as well populate it
-            subprocess.Popen(sni_path, cwd=os.path.dirname(sni_path))
+            subprocess.Popen(os.path.abspath(sni_path), cwd=os.path.dirname(sni_path))
         else:
-            subprocess.Popen(sni_path, cwd=os.path.dirname(sni_path), stdout=subprocess.DEVNULL,
-                             stderr=subprocess.DEVNULL)
+            proc = subprocess.Popen(os.path.abspath(sni_path), cwd=os.path.dirname(sni_path),
+                                    stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+            try:
+                proc.wait(.1)  # wait a bit to see if startup fails (missing dependencies)
+                snes_logger.info('Failed to start SNI. Try running it externally for error output.')
+            except subprocess.TimeoutExpired:
+                pass  # seems to be running
+
     else:
         snes_logger.info(
             f"Attempt to start SNI was aborted as path {sni_path} was not found, "
@@ -619,24 +674,24 @@ async def snes_connect(ctx: Context, address, deviceIndex=-1):
 
     try:
         devices = await get_snes_devices(ctx)
-        numDevices = len(devices)
+        device_count = len(devices)
 
-        if numDevices == 1:
+        if device_count == 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]]
-        elif numDevices > 1:
+        elif device_count > 1:
             if deviceIndex == -1:
-                snes_logger.info(
-                    "Found " + str(numDevices) + " SNES devices; connect to one with /snes <address> <device number>:")
+                snes_logger.info(f"Found {device_count} SNES devices. "
+                                 f"Connect to one with /snes <address> <device number>. For example /snes {address} 1")
 
                 for idx, availableDevice in enumerate(devices):
                     snes_logger.info(str(idx + 1) + ": " + availableDevice)
 
-            elif (deviceIndex < 0) or (deviceIndex - 1) > numDevices:
+            elif (deviceIndex < 0) or (deviceIndex - 1) > device_count:
                 snes_logger.warning("SNES device number out of range")
 
             else:
@@ -658,8 +713,6 @@ async def snes_connect(ctx: Context, address, deviceIndex=-1):
         ctx.snes_attached_device = (devices.index(device), device)
         ctx.snes_reconnect_address = address
         recv_task = asyncio.create_task(snes_recv_loop(ctx))
-        SNES_RECONNECT_DELAY = ctx.starting_reconnect_delay
-        snes_logger.info(f"Attached to {device}")
 
     except Exception as e:
         if recv_task is not None:
@@ -678,6 +731,10 @@ async def snes_connect(ctx: Context, address, deviceIndex=-1):
             asyncio.create_task(snes_autoreconnect(ctx))
         SNES_RECONNECT_DELAY *= 2
 
+    else:
+        SNES_RECONNECT_DELAY = ctx.starting_reconnect_delay
+        snes_logger.info(f"Attached to {device}")
+
 
 async def snes_disconnect(ctx: Context):
     if ctx.snes_socket:
@@ -808,19 +865,27 @@ async def track_locations(ctx: Context, roomid, roomdata):
             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(Shops.shop_table) * 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)
+        shop_data = await snes_read(ctx, SHOP_ADDR, SHOP_LEN)
+        shop_data_changed = False
+        shop_data = list(shop_data)
+        for cnt, b in enumerate(shop_data):
+            location = Shops.SHOP_ID_START + cnt
+            if int(b) and location not in ctx.locations_checked:
+                new_check(location)
+            if location in ctx.checked_locations and location not in ctx.locations_checked \
+                    and location in ctx.locations_info and ctx.locations_info[location].player != ctx.slot:
+                if not int(b):
+                    shop_data[cnt] += 1
+                    shop_data_changed = True
+        if shop_data_changed:
+            snes_buffered_write(ctx, SHOP_ADDR, bytes(shop_data))
     except Exception as e:
         snes_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:
+            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:
             snes_logger.exception(f"Exception: {e}")
@@ -828,12 +893,19 @@ async def track_locations(ctx: Context, roomid, roomdata):
     uw_begin = 0x129
     ow_end = uw_end = 0
     uw_unchecked = {}
+    uw_checked = {}
     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 location_id in ctx.checked_locations and location_id not in ctx.locations_checked and \
+                location_id in ctx.locations_info and ctx.locations_info[location_id].player != ctx.slot and \
+                location_id not in boss_locations:
+            uw_begin = min(uw_begin, roomid)
+            uw_end = max(uw_end, roomid + 1)
+            uw_checked[location_id] = (roomid, mask)
 
     if uw_begin < uw_end:
         uw_data = await snes_read(ctx, SAVEDATA_START + (uw_begin * 2), (uw_end - uw_begin) * 2)
@@ -843,14 +915,27 @@ async def track_locations(ctx: Context, roomid, roomdata):
                 roomdata = uw_data[offset] | (uw_data[offset + 1] << 8)
                 if roomdata & mask != 0:
                     new_check(location_id)
+            if uw_checked:
+                uw_data = list(uw_data)
+                for location_id, (roomid, mask) in uw_checked.items():
+                    offset = (roomid - uw_begin) * 2
+                    roomdata = uw_data[offset] | (uw_data[offset + 1] << 8)
+                    roomdata |= mask
+                    uw_data[offset] = roomdata & 0xFF
+                    uw_data[offset + 1] = roomdata >> 8
+                snes_buffered_write(ctx, SAVEDATA_START + (uw_begin * 2), bytes(uw_data))
 
     ow_begin = 0x82
     ow_unchecked = {}
+    ow_checked = {}
     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 location_id in ctx.checked_locations and location_id in ctx.locations_info \
+                    and ctx.locations_info[location_id].player != ctx.slot:
+                ow_checked[location_id] = screenid
 
     if ow_begin < ow_end:
         ow_data = await snes_read(ctx, SAVEDATA_START + 0x280 + ow_begin, ow_end - ow_begin)
@@ -858,25 +943,48 @@ async def track_locations(ctx: Context, roomid, roomdata):
             for location_id, screenid in ow_unchecked.items():
                 if ow_data[screenid - ow_begin] & 0x40 != 0:
                     new_check(location_id)
+            if ow_checked:
+                ow_data = list(ow_data)
+                for location_id, screenid in ow_checked.items():
+                    ow_data[screenid - ow_begin] |= 0x40
+                snes_buffered_write(ctx, SAVEDATA_START + 0x280 + ow_begin, bytes(ow_data))
 
     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_changed = False
             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 location_id in ctx.checked_locations and location_id not in ctx.locations_checked \
+                        and location_id in ctx.locations_info and ctx.locations_info[location_id].player != ctx.slot:
+                    npc_value |= mask
+                    npc_value_changed = True
+            if npc_value_changed:
+                npc_data = bytes([npc_value & 0xFF, npc_value >> 8])
+                snes_buffered_write(ctx, SAVEDATA_START + 0x410, npc_data)
 
     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:
+            misc_data = list(misc_data)
+            misc_data_changed = False
             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 location_id in ctx.checked_locations and location_id not in ctx.locations_checked \
+                        and location_id in ctx.locations_info and ctx.locations_info[location_id].player != ctx.slot:
+                    misc_data_changed = True
+                    misc_data[offset - 0x3c6] |= mask
+            if misc_data_changed:
+                snes_buffered_write(ctx, SAVEDATA_START + 0x3c6, bytes(misc_data))
+
 
     if new_locations:
         await ctx.send_msgs([{"cmd": 'LocationChecks', "locations": new_locations}])
+    await snes_flush_writes(ctx)
 
 
 async def game_watcher(ctx: Context):
@@ -892,27 +1000,42 @@ async def game_watcher(ctx: Context):
         if not ctx.rom:
             ctx.finished_game = False
             ctx.death_link_allow_survive = False
-            game_name = await snes_read(ctx, SM_ROMNAME_START, 2)
+            game_name = await snes_read(ctx, SM_ROMNAME_START, 5)
             if game_name is None:
                 continue
-            elif game_name == b"SM":
+            elif game_name[:2] == b"SM":
                 ctx.game = GAME_SM
+                # versions lower than 0.3.0 dont have item handling flag nor remote item support
+                romVersion = int(game_name[2:5].decode('UTF-8'))
+                if romVersion < 30:
+                    ctx.items_handling = 0b001 # full local 
+                else:
+                    item_handling = await snes_read(ctx, SM_REMOTE_ITEM_FLAG_ADDR, 1)
+                    ctx.items_handling = 0b001 if item_handling is None else item_handling[0]
             else:
-                ctx.game = GAME_ALTTP
+                game_name = await snes_read(ctx, SMZ3_ROMNAME_START, 3)
+                if game_name == b"ZSM":
+                    ctx.game = GAME_SMZ3
+                    ctx.items_handling = 0b101  # local items and remote start inventory
+                else:
+                    ctx.game = GAME_ALTTP
+                    ctx.items_handling = 0b001  # full local
 
-            rom = await snes_read(ctx, SM_ROMNAME_START if ctx.game == GAME_SM else ROMNAME_START, ROMNAME_SIZE)
+            rom = await snes_read(ctx, SM_ROMNAME_START if ctx.game == GAME_SM else SMZ3_ROMNAME_START if ctx.game == GAME_SMZ3 else ROMNAME_START, ROMNAME_SIZE)
             if rom is None or rom == bytes([0] * ROMNAME_SIZE):
                 continue
 
             ctx.rom = rom
-            death_link = await snes_read(ctx, DEATH_LINK_ACTIVE_ADDR if ctx.game == GAME_ALTTP else
-                                         SM_DEATH_LINK_ACTIVE_ADDR, 1)
-            if death_link:
-                ctx.death_link_allow_survive = bool(death_link[0] & 0b10)
-                await ctx.update_death_link(bool(death_link[0] & 0b1))
+            if ctx.game != GAME_SMZ3:
+                death_link = await snes_read(ctx, DEATH_LINK_ACTIVE_ADDR if ctx.game == GAME_ALTTP else
+                                             SM_DEATH_LINK_ACTIVE_ADDR, 1)
+                if death_link:
+                    ctx.death_link_allow_survive = bool(death_link[0] & 0b10)
+                    await ctx.update_death_link(bool(death_link[0] & 0b1))
             if not ctx.prev_rom or ctx.prev_rom != ctx.rom:
                 ctx.locations_checked = set()
                 ctx.locations_scouted = set()
+                ctx.locations_info = {}
             ctx.prev_rom = ctx.rom
 
             if ctx.awaiting_rom:
@@ -968,7 +1091,8 @@ async def game_watcher(ctx: Context):
                 item = ctx.items_received[recv_index]
                 recv_index += 1
                 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'),
+                    color(ctx.item_name_getter(item.item), 'red', 'bold'),
+                    color(ctx.player_names[item.player], 'yellow'),
                     ctx.location_name_getter(item.location), recv_index, len(ctx.items_received)))
 
                 snes_buffered_write(ctx, RECV_PROGRESS_ADDR,
@@ -981,16 +1105,16 @@ async def game_watcher(ctx: Context):
                 snes_buffered_write(ctx, SCOUTREPLY_LOCATION_ADDR,
                                     bytes([scout_location]))
                 snes_buffered_write(ctx, SCOUTREPLY_ITEM_ADDR,
-                                    bytes([ctx.locations_info[scout_location][0]]))
+                                    bytes([ctx.locations_info[scout_location].item]))
                 snes_buffered_write(ctx, SCOUTREPLY_PLAYER_ADDR,
-                                    bytes([min(ROM_PLAYER_LIMIT, ctx.locations_info[scout_location][1])]))
+                                    bytes([min(ROM_PLAYER_LIMIT, ctx.locations_info[scout_location].player)]))
 
             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)        
+            await track_locations(ctx, roomid, roomdata)
         elif ctx.game == GAME_SM:
             gamemode = await snes_read(ctx, WRAM_START + 0x0998, 1)
             if "DeathLink" in ctx.tags and gamemode and ctx.last_death_link + 1 < time.time():
@@ -1017,14 +1141,16 @@ async def game_watcher(ctx: Context):
                 itemIndex = (message[4] | (message[5] << 8)) >> 3
 
                 recv_index += 1
-                snes_buffered_write(ctx, SM_RECV_PROGRESS_ADDR + 0x680, bytes([recv_index & 0xFF, (recv_index >> 8) & 0xFF]))
+                snes_buffered_write(ctx, SM_RECV_PROGRESS_ADDR + 0x680,
+                                    bytes([recv_index & 0xFF, (recv_index >> 8) & 0xFF]))
 
                 from worlds.sm.Locations import locations_start_id
                 location_id = locations_start_id + itemIndex
 
                 ctx.locations_checked.add(location_id)
                 location = ctx.location_name_getter(location_id)
-                snes_logger.info(f'New Check: {location} ({len(ctx.locations_checked)}/{len(ctx.missing_locations) + len(ctx.checked_locations)})')
+                snes_logger.info(
+                    f'New Check: {location} ({len(ctx.locations_checked)}/{len(ctx.missing_locations) + len(ctx.checked_locations)})')
                 await ctx.send_msgs([{"cmd": 'LocationChecks', "locations": [location_id]}])
 
             data = await snes_read(ctx, SM_RECV_PROGRESS_ADDR + 0x600, 4)
@@ -1035,14 +1161,82 @@ async def game_watcher(ctx: Context):
             itemOutPtr = data[2] | (data[3] << 8)
 
             from worlds.sm.Items import items_start_id
+            from worlds.sm.Locations import locations_start_id
+            if itemOutPtr < len(ctx.items_received):
+                item = ctx.items_received[itemOutPtr]
+                itemId = item.item - items_start_id
+                locationId = (item.location - locations_start_id) if item.location >= 0 and bool(ctx.items_handling & 0b010) else 0x00
+
+                playerID = item.player if item.player <= SM_ROM_PLAYER_LIMIT else 0
+                snes_buffered_write(ctx, SM_RECV_PROGRESS_ADDR + itemOutPtr * 4, bytes(
+                	[playerID & 0xFF, (playerID >> 8) & 0xFF, itemId & 0xFF, locationId & 0xFF]))
+                itemOutPtr += 1
+                snes_buffered_write(ctx, SM_RECV_PROGRESS_ADDR + 0x602,
+                                    bytes([itemOutPtr & 0xFF, (itemOutPtr >> 8) & 0xFF]))
+                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), itemOutPtr, len(ctx.items_received)))
+            await snes_flush_writes(ctx)
+        elif ctx.game == GAME_SMZ3:
+            currentGame = await snes_read(ctx, SRAM_START + 0x33FE, 2)
+            if (currentGame is not None):
+                if (currentGame[0] != 0):
+                    gamemode = await snes_read(ctx, WRAM_START + 0x0998, 1)
+                    endGameModes = SM_ENDGAME_MODES
+                else:
+                    gamemode = await snes_read(ctx, WRAM_START + 0x10, 1)
+                    endGameModes = ENDGAME_MODES
+
+            if gamemode is not None and (gamemode[0] in endGameModes):
+                if not ctx.finished_game:
+                    await ctx.send_msgs([{"cmd": "StatusUpdate", "status": ClientStatus.CLIENT_GOAL}])
+                    ctx.finished_game = True
+                continue
+
+            data = await snes_read(ctx, SMZ3_RECV_PROGRESS_ADDR + 0x680, 4)
+            if data is None:
+                continue
+
+            recv_index = data[0] | (data[1] << 8)
+            recv_item = data[2] | (data[3] << 8)
+
+            while (recv_index < recv_item):
+                itemAdress = recv_index * 8
+                message = await snes_read(ctx, SMZ3_RECV_PROGRESS_ADDR + 0x700 + itemAdress, 8)
+                # worldId = message[0] | (message[1] << 8)  # unused
+                # itemId = message[2] | (message[3] << 8)  # unused
+                isZ3Item = ((message[5] & 0x80) != 0)
+                maskedPart = (message[5] & 0x7F) if isZ3Item else message[5]
+                itemIndex = ((message[4] | (maskedPart << 8)) >> 3) + (256 if isZ3Item else 0)
+
+                recv_index += 1
+                snes_buffered_write(ctx, SMZ3_RECV_PROGRESS_ADDR + 0x680, bytes([recv_index & 0xFF, (recv_index >> 8) & 0xFF]))
+
+                from worlds.smz3.TotalSMZ3.Location import locations_start_id
+                location_id = locations_start_id + itemIndex
+
+                ctx.locations_checked.add(location_id)
+                location = ctx.location_name_getter(location_id)
+                snes_logger.info(f'New Check: {location} ({len(ctx.locations_checked)}/{len(ctx.missing_locations) + len(ctx.checked_locations)})')
+                await ctx.send_msgs([{"cmd": 'LocationChecks', "locations": [location_id]}])
+
+            data = await snes_read(ctx, SMZ3_RECV_PROGRESS_ADDR + 0x600, 4)
+            if data is None:
+                continue
+
+            # recv_itemOutPtr = data[0] | (data[1] << 8) # unused
+            itemOutPtr = data[2] | (data[3] << 8)
+
+            from worlds.smz3.TotalSMZ3.Item import items_start_id
             if itemOutPtr < len(ctx.items_received):
                 item = ctx.items_received[itemOutPtr]
                 itemId = item.item - items_start_id
 
-                playerID = item.player if item.player <= SM_ROM_PLAYER_LIMIT else 0
-                snes_buffered_write(ctx, SM_RECV_PROGRESS_ADDR + itemOutPtr * 4, bytes([playerID & 0xFF, (playerID >> 8) & 0xFF, itemId & 0xFF, (itemId >> 8) & 0xFF]))
+                playerID = item.player if item.player <= SMZ3_ROM_PLAYER_LIMIT else 0
+                snes_buffered_write(ctx, SMZ3_RECV_PROGRESS_ADDR + itemOutPtr * 4, bytes([playerID & 0xFF, (playerID >> 8) & 0xFF, itemId & 0xFF, (itemId >> 8) & 0xFF]))
                 itemOutPtr += 1
-                snes_buffered_write(ctx, SM_RECV_PROGRESS_ADDR + 0x602, bytes([itemOutPtr & 0xFF, (itemOutPtr >> 8) & 0xFF]))
+                snes_buffered_write(ctx, SMZ3_RECV_PROGRESS_ADDR + 0x602, bytes([itemOutPtr & 0xFF, (itemOutPtr >> 8) & 0xFF]))
                 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), itemOutPtr, len(ctx.items_received)))
@@ -1084,13 +1278,7 @@ async def main():
             time.sleep(3)
             sys.exit()
         elif args.diff_file.endswith((".apbp", "apz3")):
-            adjustedromfile, adjusted = Utils.get_adjuster_settings(romfile, gui_enabled)
-            if adjusted:
-                try:
-                    shutil.move(adjustedromfile, romfile)
-                    adjustedromfile = romfile
-                except Exception as e:
-                    logging.exception(e)
+            adjustedromfile, adjusted = get_alttp_settings(romfile)
             asyncio.create_task(run_game(adjustedromfile if adjusted else romfile))
         else:
             asyncio.create_task(run_game(romfile))
@@ -1129,6 +1317,128 @@ async def main():
         input_task.cancel()
 
 
+def get_alttp_settings(romfile: str):
+    lastSettings = Utils.get_adjuster_settings(GAME_ALTTP)
+    adjusted = False
+    adjustedromfile = ''
+    if lastSettings:
+        choice = 'no'
+        if not hasattr(lastSettings, 'auto_apply') or 'ask' in lastSettings.auto_apply:
+
+            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(lastSettings).items() if name in whitelist}
+            if hasattr(lastSettings, "sprite_pool"):
+                sprite_pool = {}
+                for sprite in lastSettings.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
+            import pprint
+
+            if gui_enabled:
+
+                from tkinter import Tk, PhotoImage, Label, LabelFrame, Frame, Button
+                applyPromptWindow = Tk()
+                applyPromptWindow.resizable(False, False)
+                applyPromptWindow.protocol('WM_DELETE_WINDOW', lambda: onButtonClick())
+                logo = PhotoImage(file=Utils.local_path('data', 'icon.png'))
+                applyPromptWindow.tk.call('wm', 'iconphoto', applyPromptWindow._w, logo)
+                applyPromptWindow.wm_title("Last adjuster settings LttP")
+
+                label = LabelFrame(applyPromptWindow,
+                                   text='Last used adjuster settings were found. Would you like to apply these?')
+                label.grid(column=0, row=0, padx=5, pady=5, ipadx=5, ipady=5)
+                label.grid_columnconfigure(0, weight=1)
+                label.grid_columnconfigure(1, weight=1)
+                label.grid_columnconfigure(2, weight=1)
+                label.grid_columnconfigure(3, weight=1)
+
+                def onButtonClick(answer: str = 'no'):
+                    setattr(onButtonClick, 'choice', answer)
+                    applyPromptWindow.destroy()
+
+                framedOptions = Frame(label)
+                framedOptions.grid(column=0, columnspan=4, row=0)
+                framedOptions.grid_columnconfigure(0, weight=1)
+                framedOptions.grid_columnconfigure(1, weight=1)
+                framedOptions.grid_columnconfigure(2, weight=1)
+                curRow = 0
+                curCol = 0
+                for name, value in printed_options.items():
+                    Label(framedOptions, text=name + ": " + str(value)).grid(column=curCol, row=curRow, padx=5)
+                    if (curCol == 2):
+                        curRow += 1
+                        curCol = 0
+                    else:
+                        curCol += 1
+
+                yesButton = Button(label, text='Yes', command=lambda: onButtonClick('yes'), width=10)
+                yesButton.grid(column=0, row=1)
+                noButton = Button(label, text='No', command=lambda: onButtonClick('no'), width=10)
+                noButton.grid(column=1, row=1)
+                alwaysButton = Button(label, text='Always', command=lambda: onButtonClick('always'), width=10)
+                alwaysButton.grid(column=2, row=1)
+                neverButton = Button(label, text='Never', command=lambda: onButtonClick('never'), width=10)
+                neverButton.grid(column=3, row=1)
+
+                Utils.tkinter_center_window(applyPromptWindow)
+                applyPromptWindow.mainloop()
+                choice = getattr(onButtonClick, 'choice')
+            else:
+                choice = 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 choice and choice.startswith("y"):
+                choice = 'yes'
+            elif choice and "never" in choice:
+                choice = 'no'
+                lastSettings.auto_apply = 'never'
+                Utils.persistent_store("adjuster", GAME_ALTTP, lastSettings)
+            elif choice and "always" in choice:
+                choice = 'yes'
+                lastSettings.auto_apply = 'always'
+                Utils.persistent_store("adjuster", GAME_ALTTP, lastSettings)
+            else:
+                choice = 'no'
+        elif 'never' in lastSettings.auto_apply:
+            choice = 'no'
+        elif 'always' in lastSettings.auto_apply:
+            choice = 'yes'
+
+        if 'yes' in choice:
+            from worlds.alttp.Rom import get_base_rom_path
+            lastSettings.rom = romfile
+            lastSettings.baserom = get_base_rom_path()
+            lastSettings.world = None
+
+            if hasattr(lastSettings, "sprite_pool"):
+                from LttPAdjuster import AdjusterWorld
+                lastSettings.world = AdjusterWorld(getattr(lastSettings, "sprite_pool"))
+
+            adjusted = True
+            import LttPAdjuster
+            _, adjustedromfile = LttPAdjuster.adjust(lastSettings)
+
+            if hasattr(lastSettings, "world"):
+                delattr(lastSettings, "world")
+        else:
+            adjusted = False;
+        if adjusted:
+            try:
+                shutil.move(adjustedromfile, romfile)
+                adjustedromfile = romfile
+            except Exception as e:
+                logging.exception(e)
+    else:
+        adjusted = False
+    return adjustedromfile, adjusted
+
+
 if __name__ == '__main__':
     colorama.init()
     loop = asyncio.get_event_loop()

Utils.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import shutil
 import typing
 import builtins
 import os
@@ -11,6 +12,7 @@ import io
 import collections
 import importlib
 import logging
+from tkinter import Tk
 
 
 def tuplize_version(version: str) -> Version:
@@ -23,10 +25,10 @@ class Version(typing.NamedTuple):
     build: int
 
 
-__version__ = "0.2.2"
+__version__ = "0.3.1"
 version_tuple = tuplize_version(__version__)
 
-from yaml import load, dump, safe_load
+from yaml import load, dump, SafeLoader
 
 try:
     from yaml import CLoader as Loader
@@ -71,10 +73,10 @@ def is_frozen() -> bool:
     return getattr(sys, 'frozen', False)
 
 
-def local_path(*path):
-    if local_path.cached_path:
-        return os.path.join(local_path.cached_path, *path)
-
+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
@@ -94,21 +96,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)
@@ -117,7 +145,20 @@ def open_file(filename):
         subprocess.call([open_command, filename])
 
 
-parse_yaml = safe_load
+# 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 = functools.partial(load, Loader=UniqueKeyLoader)
 unsafe_parse_yaml = functools.partial(load, Loader=Loader)
 
 
@@ -168,7 +209,7 @@ def get_default_options() -> dict:
             "output_path": "output",
         },
         "factorio_options": {
-            "executable": "factorio\\bin\\x64\\factorio",
+            "executable": os.path.join("factorio", "bin", "x64", "factorio"),
         },
         "sm_options": {
             "rom_file": "Super Metroid (JU).sfc",
@@ -205,7 +246,7 @@ def get_default_options() -> dict:
         },
         "generator": {
             "teams": 1,
-            "enemizer_path": "EnemizerCLI/EnemizerCLI.Core.exe",
+            "enemizer_path": os.path.join("EnemizerCLI", "EnemizerCLI.Core.exe"),
             "player_files_path": "Players",
             "players": 0,
             "weights_file_path": "weights.yaml",
@@ -249,8 +290,11 @@ def update_options(src: dict, dest: dict, filename: str, keys: list) -> dict:
 @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):
@@ -260,7 +304,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
 
 
@@ -275,7 +319,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
@@ -287,7 +331,7 @@ 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:
@@ -301,63 +345,9 @@ def persistent_load() -> typing.Dict[dict]:
     return storage
 
 
-def get_adjuster_settings(romfile: str, skip_questions: bool = False) -> 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
-        from worlds.alttp.Rom import get_base_rom_path
-        adjuster_settings.rom = romfile
-        adjuster_settings.baserom = get_base_rom_path()
-        adjuster_settings.world = None
-        whitelist = {"music", "menuspeed", "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
-        elif skip_questions:
-            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
-            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
@@ -389,7 +379,7 @@ class RestrictedUnpickler(pickle.Unpickler):
         if module == "builtins" and name in safe_builtins:
             return getattr(builtins, name)
         # used by MultiServer -> savegame/multidata
-        if module == "NetUtils" and name in {"NetworkItem", "ClientStatus", "Hint"}:
+        if module == "NetUtils" and name in {"NetworkItem", "ClientStatus", "Hint", "SlotType", "NetworkSlot"}:
             return getattr(self.net_utils_module, name)
         # Options and Plando are unpickled by WebHost -> Generate
         if module == "worlds.generic" and name in {"PlandoItem", "PlandoConnection"}:
@@ -428,7 +418,7 @@ loglevel_mapping = {'error': logging.ERROR, 'info': logging.INFO, 'warning': log
 def init_logging(name: str, loglevel: typing.Union[str, int] = logging.INFO, write_mode: str = "w",
                  log_format: str = "[%(name)s]: %(message)s", exception_logger: str = ""):
     loglevel: int = loglevel_mapping.get(loglevel, loglevel)
-    log_folder = local_path("logs")
+    log_folder = user_path("logs")
     os.makedirs(log_folder, exist_ok=True)
     root_logger = logging.getLogger()
     for handler in root_logger.handlers[:]:
@@ -474,3 +464,26 @@ def stream_input(stream, queue):
     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 format_SI_prefix(value, power=1000, power_labels=('', 'k', 'M', 'G', 'T', "P", "E", "Z", "Y")):
+    n = 0
+
+    while value > power:
+        value /= power
+        n += 1
+    if type(value) == int:
+        return f"{value} {power_labels[n]}"
+    else:
+        return f"{value:0.3f} {power_labels[n]}"

WebHost.py

@@ -3,11 +3,13 @@ import multiprocessing
 import logging
 
 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
@@ -19,6 +21,8 @@ from WebHostLib.lttpsprites import update_sprites_lttp
 from WebHostLib.options import create as create_options_files
 
 configpath = os.path.abspath("config.yaml")
+if not os.path.exists(configpath):  # fall back to config.yaml in home
+    configpath = os.path.abspath(Utils.user_path('config.yaml'))
 
 
 def get_app():
@@ -32,6 +36,15 @@ def get_app():
     return app
 
 
+def create_ordered_tutorials_file():
+    import json
+    with open(os.path.join("WebHostLib", "static", "assets", "tutorial", "tutorials.json")) as source:
+        data = json.load(source)
+    data = sorted(data, key=lambda entry: entry["gameTitle"].lower())
+    with open(os.path.join("WebHostLib", "static", "generated", "tutorials.json"), "w") as target:
+        json.dump(data, target)
+
+
 if __name__ == "__main__":
     multiprocessing.freeze_support()
     multiprocessing.set_start_method('spawn')
@@ -43,6 +56,7 @@ if __name__ == "__main__":
         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"]:

WebHostLib/__init__.py

@@ -70,6 +70,12 @@ app.url_map.converters["suuid"] = B64UUIDConverter
 app.jinja_env.filters['suuid'] = lambda value: base64.urlsafe_b64encode(value.bytes).rstrip(b'=').decode('ascii')
 
 
+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():
     session.permanent = True  # technically 31 days after the last visit
@@ -89,16 +95,21 @@ def start_playing():
     return render_template(f"startPlaying.html")
 
 
+@app.route('/weighted-settings')
+def weighted_settings():
+    return render_template(f"weighted-settings.html")
+
+
 # Player settings pages
 @app.route('/games/<string:game>/player-settings')
 def player_settings(game):
-    return render_template(f"player-settings.html", game=game)
+    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)
+    return render_template('gameInfo.html', game=game, lang=lang, theme=get_world_theme(game))
 
 
 # List of supported games
@@ -107,13 +118,13 @@ def games():
     worlds = {}
     for game, world in AutoWorldRegister.world_types.items():
         if not world.hidden:
-            worlds[game] = world.__doc__ if world.__doc__ else "No description provided."
+            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)
+    return render_template("tutorial.html", game=game, file=file, lang=lang, theme=get_world_theme(game))
 
 
 @app.route('/tutorial/')
@@ -131,8 +142,7 @@ 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>')
@@ -188,6 +198,15 @@ 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")
+
+
 from WebHostLib.customserver import run_server_process
 from . import tracker, upload, landing, check, generate, downloads, api  # to trigger app routing picking up on it
 

WebHostLib/api/__init__.py

@@ -1,28 +1,33 @@
 """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')
@@ -31,6 +36,7 @@ def get_datapackge():
     from worlds import network_data_package
     return network_data_package
 
+
 @api_endpoints.route('/datapackage_version')
 @cache.cached()
 def get_datapackge_versions():
@@ -38,3 +44,6 @@ def get_datapackge_versions():
     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

@@ -65,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/customserver.py

@@ -76,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):

WebHostLib/downloads.py

@@ -1,9 +1,12 @@
+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, preferred_endings
+from Patch import update_patch_data, preferred_endings, AutoPatchRegister
 from WebHostLib import app, Slot, Room, Seed, cache
-import zipfile
 
 
 @app.route("/dl_patch/<suuid:room_id>/<int:patch_id>")
@@ -12,16 +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}"
+                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)}." \
-                f"{preferred_endings[patch.game]}"
+            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)
 
 
@@ -53,6 +74,10 @@ def download_slot_file(room_id, player_id: int):
                         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"
         else:
             return "Game download not supported."
         return send_file(io.BytesIO(slot_data.data), as_attachment=True, attachment_filename=fname)

WebHostLib/generate.py

@@ -5,6 +5,7 @@ import json
 import zipfile
 from collections import Counter
 from typing import Dict, Optional as TypeOptional
+from Utils import __version__
 
 from flask import request, flash, redirect, url_for, session, render_template
 
@@ -78,7 +79,7 @@ def generate(race=False):
 
                     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, meta: TypeOptional[Dict[str, object]] = None, owner=None, sid=None):
@@ -120,7 +121,8 @@ def gen_game(gen_options, meta: TypeOptional[Dict[str, object]] = None, owner=No
             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)
 
         return upload_to_db(target.name, sid, owner, race)

WebHostLib/lttpsprites.py

@@ -2,7 +2,7 @@ import os
 import threading
 import json
 
-from Utils import local_path
+from Utils import local_path, user_path
 from worlds.alttp.Rom import Sprite
 
 
@@ -14,8 +14,8 @@ def update_sprites_lttp():
     from LttPAdjuster import update_sprites
 
     # Target directories
-    input_dir = local_path("data", "sprites", "alttpr")
-    output_dir = local_path("WebHostLib", "static", "generated")
+    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

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)

WebHostLib/options.py

@@ -1,3 +1,4 @@
+import logging
 import os
 from Utils import __version__
 from jinja2 import Template
@@ -9,8 +10,13 @@ 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):
         data = {option.range_start: 0, option.range_end: 0, "random": 0, "random-low": 0, "random-high": 0,
                 option.default: 50}
@@ -25,15 +31,24 @@ def create():
             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 = {**world.options, **Options.per_game_common_options}
         res = Template(open(os.path.join("WebHostLib", "templates", "options.yaml")).read()).render(
-            options={**world.options, **Options.per_game_common_options},
+            options=all_options,
             __version__=__version__, game=game_name, yaml_dump=yaml.dump,
             dictify_range=dictify_range, default_converter=default_converter,
         )
 
-        os.makedirs(os.path.join(target_folder, 'configs'), exist_ok=True)
-
         with open(os.path.join(target_folder, 'configs', game_name + ".yaml"), "w") as f:
             f.write(res)
 
@@ -47,11 +62,14 @@ def create():
         }
 
         game_options = {}
-        for option_name, option in world.options.items():
-            if option.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.displayname if hasattr(option, "displayname") else option_name,
+                    "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": []
@@ -74,16 +92,52 @@ def create():
             elif hasattr(option, "range_start") and hasattr(option, "range_end"):
                 game_options[option_name] = {
                     "type": "range",
-                    "displayName": option.displayname if hasattr(option, "displayname") else option_name,
+                    "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") else option.range_start,
                     "min": option.range_start,
                     "max": option.range_end,
                 }
 
+            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:
-            f.write(json.dumps(player_settings, indent=2, separators=(',', ': ')))
+            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,6 @@
-flask>=2.0.2
-pony>=0.7.14
-waitress>=2.0.0
+flask>=2.0.3
+pony>=0.7.16
+waitress>=2.1.0
 flask-caching>=1.10.1
-Flask-Compress>=1.10.1
-Flask-Limiter>=1.4
+Flask-Compress>=1.11
+Flask-Limiter>=2.2.0

WebHostLib/static/assets/faq/faq_en.md

@@ -1,52 +1,63 @@
 # 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.
+
+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.
+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.
+
+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.
+
+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.
+
+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.
+
+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](https://discord.gg/8Z65BR2). There are always people ready to answer any questions
-you might have.
+
+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.
 
 ## 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](https://github.com/ArchipelagoMW/Archipelago).
-There, you will find examples of games in the [worlds](https://github.com/ArchipelagoMW/Archipelago/tree/main/worlds)
-folder, as well as some [documentation](https://github.com/ArchipelagoMW/Archipelago/tree/main/docs) on our
-network interfaces.
+
+The best way to get started is to take a look at our code on GitHub
+at [Archipelago GitHub Page](https://github.com/ArchipelagoMW/Archipelago).
+
+There you will find examples of games in the worlds folder
+at [/worlds Folder in Archipelago Code](https://github.com/ArchipelagoMW/Archipelago/tree/main/worlds).
+
+You may also find developer documentation in the docs folder
+at [/docs Folder in Archipelago Code](https://github.com/ArchipelagoMW/Archipelago/tree/main/docs).
 
 If you have more questions, feel free to ask in the **#archipelago-dev** channel on our Discord.

WebHostLib/static/assets/gameInfo/en_A Link to the Past.md

@@ -1,26 +1,32 @@
 # A Link to the Past
 
 ## Where is the settings page?
-The player settings page for this game is located <a href="../player-settings">here</a>. It contains all the options
-you need to configure and export a config file.
+
+The [player settings page for this game](../player-settings) contains all the options you need to configure and export a
+config file.
 
 ## What does randomization do to this game?
-Items which the player would normally acquire throughout the game have been moved around. Logic remains, so the game
-is always able to be completed, but because of the item shuffle the player may need to access certain areas before
-they would in the vanilla game.
+
+Items which the player would normally acquire throughout the game have been moved around. Logic remains, so the game is
+always able to be completed, but because of the item shuffle the player may need to access certain areas before they
+would in the vanilla game.
 
 ## What items and locations get shuffled?
+
 All main inventory items, collectables, and ammunition can be shuffled, and all locations in the game which could
 contain any of those items may have their contents changed.
 
 ## Which items can be in another player's world?
-Any of the items which can be shuffled may also be placed into another player's world. It is possible to choose to
-limit certain items to your own world.
+
+Any of the items which can be shuffled may also be placed into another player's world. It is possible to choose to limit
+certain items to your own world.
 
 ## What does another world's item look like in LttP?
+
 Items belonging to other worlds are represented by a Power Star from Super Mario World.
 
 ## When the player receives an item, what happens?
+
 When the player receives an item, Link will hold the item above his head and display it to the world. It's good for
 business!
 

WebHostLib/static/assets/gameInfo/en_ArchipIDLE.md

@@ -0,0 +1,12 @@
+# ArchipIDLE
+
+## What is this game?
+
+ArchipIDLE is the 2022 Archipelago April Fools' Day joke. It is an idle game that sends a location check every
+thirty seconds, up to one hundred checks.
+
+## Where is the settings page?
+
+The [player settings page for this game](../player-settings) contains all the options you need to configure
+and export a config file.
+

WebHostLib/static/assets/gameInfo/en_ChecksFinder.md

@@ -0,0 +1,24 @@
+# ChecksFinder
+
+## Where is the settings page?
+
+The [player settings page for this game](../player-settings) contains all the options you need to configure and export a
+config file.
+
+## What is considered a location check in ChecksFinder?
+
+Location checks in are completed when the player finds a spot on a board that has the archipelago logo. The bottom of
+the screen has a number next to the archipelago logo, that number is how many you can find so far. You can only get as 
+many checks as you have gained items, plus five to start with being available.
+
+## When the player receives an item, what happens?
+
+When the player receives an item in ChecksFinder, it either can make the future boards they play be bigger in width or
+height, or add a new bomb to the future boards, with a limit to having up to one fifth of the _current_ board being 
+bombs. The items you have gained _before_ the current board was made will be said at the bottom of the screen as a number
+next to an icon, the number is how many you have gotten and the icon represents which item it is.
+
+## What is the victory condition?
+
+Victory is achieved when the player wins a board they were given after they have received all of their Map Width, Map
+Height, and Map Bomb items. The game will say at the bottom of the screen how many of each you have received.

WebHostLib/static/assets/gameInfo/en_Factorio.md

@@ -1,29 +1,34 @@
 # Factorio
 
 ## Where is the settings page?
-The player settings page for this game is located <a href="../player-settings">here</a>. It contains all the options
-you need to configure and export a config file.
+
+The [player settings page for this game](../player-settings) contains all the options you need to configure and export a
+config file.
 
 ## What does randomization do to this game?
-In Factorio, the research tree is shuffled, causing certain technologies to be obtained in a non-standard order.
-Recipe costs, technology requirements, and science pack requirements may also be shuffled at the player's discretion.
+
+In Factorio, the research tree is shuffled, causing certain technologies to be obtained in a non-standard order. Recipe
+costs, technology requirements, and science pack requirements may also be shuffled at the player's discretion.
 
 ## What Factorio items can appear in other players' worlds?
+
 Factorio's technologies are removed from its tech tree and placed into other players' worlds. When those technologies
 are found, they are sent back to Factorio along with, optionally, free samples of those technologies.
 
 ## What is a free sample?
+
 A free sample is a single or stack of items in Factorio, granted by a technology received from another world. For
-example, receiving the technology  
-`Portable Solar Panel` may also grant the player a stack of portable solar panels,
-and place them directly into the player's inventory.
+example, receiving the technology `Portable Solar Panel` may also grant the player a stack of portable solar panels, and
+place them directly into the player's inventory.
 
 ## What does another world's item look like in Factorio?
+
 In Factorio, items which need to be sent to other worlds appear in the tech tree as new research items. They are
 represented by the Archipelago icon, and must be researched as if it were a normal technology. Upon successful
 completion of research, the item will be sent to its home world.
 
 ## When the engineer receives an item, what happens?
-When the player receives a technology, it is instantly learned and able to be crafted. A message will appear in the
-chat log to notify the player, and if free samples are enabled the player may also receive some items directly to
-their inventory.
+
+When the player receives a technology, it is instantly learned and able to be crafted. A message will appear in the chat
+log to notify the player, and if free samples are enabled the player may also receive some items directly to their
+inventory.

WebHostLib/static/assets/gameInfo/en_Final Fantasy.md

@@ -1,21 +1,26 @@
 # Final Fantasy 1 (NES)
 
 ## Where is the settings page?
-Unlike most games on Archipelago.gg, Final Fantasy 1's settings are controlled entirely by the original randomzier.
-You can find an exhaustive list of documented settings [here](https://finalfantasyrandomizer.com/)
+
+Unlike most games on Archipelago.gg, Final Fantasy 1's settings are controlled entirely by the original randomzier. You
+can find an exhaustive list of documented settings on the FFR
+website: [FF1R Website](https://finalfantasyrandomizer.com/)
 
 ## What does randomization do to this game?
-A better questions is what isn't randomized at this point. Enemies stats and spell, character spells, shop inventory
-and boss stats and spells are all commonly randomized. Unlike most other randomizers it is also most standard to shuffle
-progression items and non-progression items into separate pools and then redistribute them to their respective 
-locations. So ,for example, Princess Sarah may have the CANOE instead of the LUTE; however, she will never have a Heal 
-Pot or some armor. There are plenty of other things that can be randomized on our 
-[main randomizer site](https://finalfantasyrandomizer.com/)
+
+A better questions is what isn't randomized at this point. Enemies stats and spell, character spells, shop inventory and
+boss stats and spells are all commonly randomized. Unlike most other randomizers it is also most standard to shuffle
+progression items and non-progression items into separate pools and then redistribute them to their respective
+locations. So, for example, Princess Sarah may have the CANOE instead of the LUTE; however, she will never have a Heal
+Pot or some armor. There are plenty of other things that can be randomized on the main randomizer
+site: [FF1R Website](https://finalfantasyrandomizer.com/)
 
 ## What Final Fantasy items can appear in other players' worlds?
-All items can appear in other players worlds. This includes consumables, shards, weapons, armor and, of course,
-key items.
+
+All items can appear in other players worlds. This includes consumables, shards, weapons, armor and, of course, key
+items.
 
 ## What does another world's item look like in Final Fantasy
-All local and remote items appear the same. It will say that you received an item and then BOTH the client log and
-the emulator will display what was found external to the in-game text box.
+
+All local and remote items appear the same. It will say that you received an item and then BOTH the client log and the
+emulator will display what was found external to the in-game text box.

WebHostLib/static/assets/gameInfo/en_Hollow Knight.md

@@ -0,0 +1,22 @@
+# Hollow Knight
+
+## Where is the settings page?
+
+The [player settings page for this game](../player-settings) contains all the options you need to configure and export a
+config file.
+
+## What does randomization do to this game?
+
+Randomization swaps around the locations of items. The items being swapped around are chosen within your YAML.
+Shop costs are presently always randomized.
+
+## What Hollow Knight items can appear in other players' worlds?
+
+This is dependent entirely upon your YAML settings. Some examples include: charms, grubs, lifeblood cocoons, geo, etc.
+
+## What does another world's item look like in Hollow Knight?
+
+When the Hollow Knight player picks up an item from a location and it is an item for another game it will appear in that
+player's recent items display as an item being sent to another player. If the item is for another Hollow Knight player
+then the sprite will be that of the item's original sprite. If the item belongs to a player that is not playing Hollow
+Knight then the sprite will be the Archipelago logo.

WebHostLib/static/assets/gameInfo/en_Meritous.md

@@ -0,0 +1,25 @@
+# Meritous
+
+## Where is the settings page?
+The [player settings page for Meritous](../player-settings) contains all the options you need to configure and export a config file.
+
+## What does randomization do to this game?
+The PSI Enhancement Tiles have become general-purpose Item Caches, and all upgrades and artifacts are added to the multiworld item pool. Optionally, the progression-critical PSI Keys can also be added to the pool, as well as monster evolution traps which (in vanilla) trigger when bosses are defeated.
+
+## What is the goal of Meritous when randomized?
+At minimum, you will need to get the PSI Keys, defeat the three bosses, retrieve the Cursed Seal, and return it to the entrance. Depending on your selected goal, you may also have to defeat the final boss, or you may also need to explore every last room of the Atlas Dome and retrieve the Agate Knife before getting the Cursed Seal and defeating the final boss' true form.
+
+## Which items can be in another player's world?
+Every item added to the multiworld pool (as outlined above) can be distributed to other players' worlds.
+
+## What is considered a location check in Meritous?
+The Alpha, Beta, and Gamma item caches each have 24 checks to buy, increasing in cost each time. Reward chests obtained from clearing ambush rooms will contain up to 24 location checks, thereafter always awarding a cache of PSI Crystals. If enabled, PSI Key Pedestals will contain checks, which must be unlocked by eliminating a certain percentage of monsters. If enabled, defeating bosses will result in an automatic check.
+
+## Which notable items are not randomized?
+The Cursed Seal and Agate Knife will always be in the farthest-away room from the Entrance and the final room explored, respectively.
+
+## What does another world's item look like in Meritous?
+There is no visual representation of other players' items in Meritous. You will be buying checks from item caches and opening chests in ambush rooms blindly.
+
+## When the player receives an item, what happens?
+A sound will play, and a notification will briefly appear on the lower half of the screen informing you of what you have received.

WebHostLib/static/assets/gameInfo/en_Minecraft.md

@@ -1,22 +1,27 @@
 # Minecraft
 
 ## Where is the settings page?
-The player settings page for this game is located <a href="../player-settings">here</a>. It contains all the options
-you need to configure and export a config file.
+
+The [player settings page for this game](../player-settings) contains all the options you need to configure and export a
+config file.
 
 ## What does randomization do to this game?
+
 Recipes are removed from the crafting book and shuffled into the item pool. It can also optionally change which
-structures appear in each dimension. Crafting recipes are re-learned when they are received from other players as
-item checks, and occasionally when completing your own achievements.
+structures appear in each dimension. Crafting recipes are re-learned when they are received from other players as item
+checks, and occasionally when completing your own achievements.
 
 ## What is considered a location check in minecraft?
-Location checks in are completed when the player completes various Minecraft achievements. Opening the advancements
-menu in-game by pressing "L" will display outstanding achievements.
+
+Location checks in are completed when the player completes various Minecraft achievements. Opening the advancements menu
+in-game by pressing "L" will display outstanding achievements.
 
 ## When the player receives an item, what happens?
+
 When the player receives an item in Minecraft, it either unlocks crafting recipes or puts items into the player's
 inventory directly.
 
 ## What is the victory condition?
+
 Victory is achieved when the player kills the Ender Dragon, enters the portal in The End, and completes the credits
 sequence either by skipping it or watching hit play out.

WebHostLib/static/assets/gameInfo/en_Ocarina of Time.md

@@ -1,26 +1,32 @@
 # Ocarina of Time
 
 ## Where is the settings page?
-The player settings page for this game is located <a href="../player-settings">here</a>. It contains all the options
-you need to configure and export a config file.
+
+The [player settings page for this game](../player-settings) contains all the options you need to configure and export a
+config file.
 
 ## What does randomization do to this game?
-Items which the player would normally acquire throughout the game have been moved around. Logic remains, so the game
-is always able to be completed, but because of the item shuffle the player may need to access certain areas before
-they would in the vanilla game.
+
+Items which the player would normally acquire throughout the game have been moved around. Logic remains, so the game is
+always able to be completed, but because of the item shuffle the player may need to access certain areas before they
+would in the vanilla game.
 
 ## What items and locations get shuffled?
+
 All main inventory items, collectables, and ammunition can be shuffled, and all locations in the game which could
 contain any of those items may have their contents changed. Gold Skultulla locations may also be included as necessary
 checks at the user's discretion.
 
 ## Which items can be in another player's world?
-Any of the items which can be shuffled may also be placed into another player's world. It is possible to choose to
-limit certain items to your own world.
+
+Any of the items which can be shuffled may also be placed into another player's world. It is possible to choose to limit
+certain items to your own world.
 
 ## What does another world's item look like in OoT?
-Items belonging to other worlds are represented by an Ocarina of Time.
+
+Items belonging to other worlds are represented by the Zelda's Letter item.
 
 ## When the player receives an item, what happens?
+
 When the player receives an item, Link will hold the item above his head and display it to the world. It's good for
 business!

WebHostLib/static/assets/gameInfo/en_Raft.md

@@ -0,0 +1,31 @@
+# Raft
+
+## Where is the settings page?
+The player settings page for this game is located <a href="../player-settings">here</a>. It contains all the options
+you need to configure and export a config file.
+
+## What does randomization do to this game?
+All of the items from the Research Table, as well as all the note/blueprint pickups from story islands, are changed to location checks. Blueprint items themselves are never given. The Research Table recipes will *remove* the researched items for that recipe once learned, meaning many more resources must be put into the Research Table to get all the unlocks from it.
+
+## What is the goal of Raft when randomized?
+The goal remains the same: To pick up the note that has the frequency for the next unreleased story island from Tangaroa.
+
+## Which items can be in another player's world?
+All of the craftable items from the Research Table and Blueprints, as well as frequencies. Since there are more locations in Raft than there are items to receive, Resource Packs with basic earlygame materials and/or duplicate items may be added to the item pool (configurable).
+
+## Which notable unlocks are not randomized?
+Most of the story island quests (actions that unlock new areas on the island) remain unchanged. There are three exceptions: The Balboa Island Relay Station quest, the Caravan Island zipline parts quest, and the Caravan Island battery charger quest have all been changed to an Archipelago unlock, as the rewards from these are craftable items or frequencies.
+Craftable items like the Machete are mixed into the Archipelago item pool, however quest items like Tape or Berries will function the same.
+Decoration Packages are unchanged.
+
+## What does another world's item look like in Raft?
+Researches and pickups remain visually unchanged, regardless of what the unlock is.
+
+## When the player receives an item, what happens?
+A Raft notification will appear with the item information. The unlock will also appear in the chat. Unlocks that would normally give you the item (eg Machete) will NOT give it to you, but must instead be crafted.
+
+## Are there any limitations compared to vanilla Raft?
+- Mods that add new researchable technologies, modify story islands, or give items like blueprints are likely incompatible with Raftipelago.
+    - Some mods that add items that are always craftable (eg don't add them to the Research Table) may be compatible.
+    - Mods that do not affect items, notes, blueprints, or story islands have a good chance of being compatible with Raftipelago
+    - No mods have been comprehensively tested or verified to work with Raftipelago. Use at your own risk.

WebHostLib/static/assets/gameInfo/en_Risk of Rain 2.md

@@ -1,17 +1,21 @@
 # Risk of Rain 2
 
 ## Where is the settings page?
-The player settings page for this game is located <a href="../player-settings">here</a>. It contains all the options
-you need to configure and export a config file.
+
+The [player settings page for this game](../player-settings) contains all the options you need to configure and export a
+config file.
 
 ## What does randomization do to this game?
+
 Risk of Rain is already a random game, by virtue of being a roguelite. The Archipelago mod implements pure multiworld
 functionality in which certain chests (made clear via a location check progress bar) will send an item out to the
-multiworld. The items that _would have been_ in those chests will be returned to the Risk of Rain player via grants
-by other players in other worlds.
+multiworld. The items that _would have been_ in those chests will be returned to the Risk of Rain player via grants by
+other players in other worlds.
 
 ## What Risk of Rain items can appear in other players' worlds?
+
 The Risk of Rain items are:
+
 * `Common Item`    (White items)
 * `Uncommon Item`  (Green items)
 * `Boss Item`      (Yellow items)
@@ -23,14 +27,17 @@ The Risk of Rain items are:
 Each item grants you a random in-game item from the category it belongs to.
 
 When an item is granted by another world to the Risk of Rain player (one of the items listed above) then a random
-in-game item of that tier will appear in the Risk of Rain player's inventory. If the item grant is an `Equipment`
-and the player already has an equipment item equipped then the _item that was equipped_ will be dropped on the ground
-and _the new equipment_ will take it's place. (If you want the old one back, pick it up.)
+in-game item of that tier will appear in the Risk of Rain player's inventory. If the item grant is an `Equipment` and
+the player already has an equipment item equipped then the _item that was equipped_ will be dropped on the ground and _
+the new equipment_ will take it's place. (If you want the old one back, pick it up.)
 
 ## What does another world's item look like in Risk of Rain?
-When the Risk of Rain player fills up their location check bar then the next spawned item will become an item grant for another
-player's world. The item in Risk of Rain will disappear in a poof of smoke and the grant will automatically go out to the multiworld.
+
+When the Risk of Rain player fills up their location check bar then the next spawned item will become an item grant for
+another player's world. The item in Risk of Rain will disappear in a poof of smoke and the grant will automatically go
+out to the multiworld.
 
 ## What is the item pickup step?
-The item pickup step is a YAML setting which allows you to set how many items you need to spawn before the _next_
-item that is spawned disappears (in a poof of smoke) and goes out to the multiworld.
+
+The item pickup step is a YAML setting which allows you to set how many items you need to spawn before the _next_ item
+that is spawned disappears (in a poof of smoke) and goes out to the multiworld.

WebHostLib/static/assets/gameInfo/en_Rogue Legacy.md

@@ -0,0 +1,27 @@
+# Rogue Legacy (PC)
+
+## Where is the settings page?
+
+The [player settings page for this game](../player-settings) is located contains all the options you need to configure
+and export a config file.
+
+## What does randomization do to this game?
+
+You are not able to buy skill upgrades in the manor upgrade screen, and instead, need to find them in order to level up
+your character to make fighting the 5 bosses easier.
+
+## What items and locations get shuffled?
+
+All the skill upgrades, class upgrades, runes packs, and equipment packs are shuffled in the manor upgrade screen, diary
+checks, chests and fairy chests, and boss rewards. Skill upgrades are also grouped in packs of 5 to make the finding of
+stats less of a chore. Runes and Equipment are also grouped together.
+
+## Which items can be in another player's world?
+
+Any of the items which can be shuffled may also be placed into another player's world. It is possible to choose to limit
+certain items to your own world.
+
+## When the player receives an item, what happens?
+
+When the player receives an item, your character will hold the item above their head and display it to the world. It's
+good for business!

WebHostLib/static/assets/gameInfo/en_SMZ3.md

@@ -0,0 +1,35 @@
+# SMZ3
+
+## Where is the settings page?
+
+The [player settings page for this game](../player-settings) contains all the options you need to configure and export a
+config file.
+
+## What does randomization do to this game?
+
+Items which the player would normally acquire throughout the game have been moved around. Logic remains, so the game is
+always able to be completed, but because of the item shuffle the player may need to access certain areas before they
+would in the vanilla game.
+
+## What items and locations get shuffled?
+
+All main inventory items, collectables, power-ups and ammunition can be shuffled, and all locations in the game which 
+could contain any of those items may have their contents changed.
+
+## Which items can be in another player's world?
+
+Any of the items which can be shuffled may also be placed into another player's world. It is possible to choose to limit
+certain items to your own world.
+
+## What does another world's item look like in Super Metroid?
+
+A unique item sprite has been added to the game to represent items belonging to another world.
+
+## What does another world's item look like in LttP?
+
+Items belonging to other worlds are represented by a Power Star from Super Mario World.
+
+## When the player receives an item, what happens?
+
+When the player receives an item, a text box will appear to show which item was received, and from whom.
+

WebHostLib/static/assets/gameInfo/en_Secret of Evermore.md

@@ -1,29 +1,35 @@
 # Secret of Evermore
 
 ## Where is the settings page?
-The player settings page for this game is located <a href="../player-settings">here</a>. It contains all options
-necessary to configure and export a config file.
+
+The [player settings page for this game](../player-settings) contains all the options you need to configure and export a
+config file.
 
 ## What does randomization do to this game?
-Items which would normally be acquired throughout the game have been moved around! Progression logic remains,
-so the game is always able to be completed. However, because of the item shuffle, the player may need to access certain
-areas before they would in the vanilla game. For example, the Windwalker (flying machine) is accessible as soon as any
-weapon is obtained.
 
-Additional help can be found in the [guide](https://github.com/black-sliver/evermizer/blob/master/guide.md).
+Items which would normally be acquired throughout the game have been moved around! Progression logic remains, so the
+game is always able to be completed. However, because of the item shuffle, the player may need to access certain areas
+before they would in the vanilla game. For example, the Windwalker (flying machine) is accessible as soon as any weapon
+is obtained.
+
+Additional help can be found in the [Evermizer guide](https://github.com/black-sliver/evermizer/blob/master/guide.md).
 
 ## What items and locations get shuffled?
+
 All gourds/chests/pots, boss drops and alchemists are shuffled. Alchemy ingredients, sniff spot items, call bead spells
 and the dog can be randomized using yaml options.
 
 ## Which items can be in another player's world?
-Any of the items which can be shuffled may also be placed in another player's world.
-Specific items can be limited to your own world using plando.
+
+Any of the items which can be shuffled may also be placed in another player's world. Specific items can be limited to
+your own world using plando.
 
 ## What does another world's item look like in Secret of Evermore?
+
 Secret of Evermore will display "Sent an Item". Check the client output if you want to know which.
 
 ## What happens when the player receives an item?
+
 When the player receives an item, a popup will appear to show which item was received. Items won't be received while a
 script is active such as when visiting Nobilia Market or during most Boss Fights. Once all scripts have ended, items
 will be received.

WebHostLib/static/assets/gameInfo/en_Slay the Spire.md

@@ -0,0 +1,35 @@
+# Slay the Spire (PC)
+
+## Where is the settings page?
+
+The [player settings page for this game](../player-settings) contains all the options you need to configure and export a
+config file.
+
+## What does randomization do to this game?
+
+Every non-boss relic drop, every boss relic and rare card drop, and every other card draw is replaced with an
+archipelago item. In heart runs, the blue key is also disconnected from the Archipelago item, so you can gather both.
+
+## What items and locations get shuffled?
+
+15 card packs, 10 relics, and 3 boss relics and rare card drops are shuffled into the item pool and can be found at any
+location that would normally give you these items, except for card packs, which are found at every other normal enemy
+encounter.
+
+## Which items can be in another player's world?
+
+Any of the items which can be shuffled may also be placed into another player's world. It is possible to choose to limit
+certain items to your own world.
+
+## When the player receives an item, what happens?
+
+When the player receives an item, you will see the counter in the top right corner with the Archipelago symbol increment
+by one. By clicking on this icon, it'll open a menu that lists all the items you received, but have not yet accepted.
+You can take any relics and card packs sent to you and add them to your current run. It is advised that you do not open
+this menu until you are outside an encounter or event to prevent the game from soft-locking.
+
+## What happens if a player dies in a run?
+
+When a player dies, they will be taken back to the main menu and will need to reconnect to start climbing the spire from
+the beginning, but they will have access to all the items ever sent to them in the Archipelago menu in the top right.
+Any items found in an earlier run will not be sent again if you encounter them in the same location.

WebHostLib/static/assets/gameInfo/en_Subnautica.md

@@ -1,27 +1,34 @@
 # Subnautica
 
 ## Where is the settings page?
-The player settings page for this game is located <a href="../player-settings">here</a>. It contains all the options
-you need to configure and export a config file.
+
+The [player settings page for this game](../player-settings) contains all the options you need to configure and export a
+config file.
 
 ## What does randomization do to this game?
+
 The most noticeable change is the complete removal of freestanding technologies. The technology blueprints normally
 awarded from scanning those items have been shuffled into location checks throughout the AP item pool.
 
 ## What is the goal of Subnautica when randomized?
+
 The goal remains unchanged. Cure the plague, build the Neptune Escape Rocket, and escape into space.
 
 ## What items and locations get shuffled?
+
 Most of the technologies the player will need throughout the game will be shuffled. Location checks in Subnautica are
 data pads and technology lockers.
 
 ## Which items can be in another player's world?
+
 Most technologies may be shuffled into another player's world.
 
 ## What does another world's item look like in Subnautica?
-Location checks in Subnautica are data pads and technology lockers. Opening one of these will send an item to
-another player's world.
+
+Location checks in Subnautica are data pads and technology lockers. Opening one of these will send an item to another
+player's world.
 
 ## When the player receives a technology, what happens?
+
 When the player receives a technology, the chat log displays a notification the technology has been received.
 

WebHostLib/static/assets/gameInfo/en_Super Mario 64.md

@@ -0,0 +1,28 @@
+# Super Mario 64 EX
+
+## Where is the settings page?
+
+The player settings page for this game contains all the options you need to configure and export a config file. Player
+settings page link: [SM64EX Player Settings Page](../player-settings).
+
+## What does randomization do to this game?
+All 120 Stars, the 3 Cap Switches, the Basement and Secound Floor Key are now Location Checks and may contain Items for different games as well
+as different Items from within SM64.
+
+
+## What is the goal of SM64EX when randomized?
+As in most Mario Games, save the Princess!
+
+## Which items can be in another player's world?
+Any of the 120 Stars, and the two Caste Keys. Additionally, Cap Switches are also considered "Items" and the "!"-Boxes will only be active
+when someone collects the corresponding Cap Switch Item.
+
+## What does another world's item look like in SM64EX?
+The Items are visually unchanged, though after collecting a Message will pop up to inform you what you collected,
+and who will receive it.
+
+## When the player receives an item, what happens?
+When you receive an Item, a Message will pop up to inform you where you received the Item from,
+and which one it is.
+
+NOTE: The Secret Star count in the Menu is broken.

WebHostLib/static/assets/gameInfo/en_Super Metroid.md

@@ -1,25 +1,31 @@
 # Super Metroid
 
 ## Where is the settings page?
-The player settings page for this game is located <a href="../player-settings">here</a>. It contains all the options
-you need to configure and export a config file.
+
+The [player settings page for this game](../player-settings) contains all the options you need to configure and export a
+config file.
 
 ## What does randomization do to this game?
-Items which the player would normally acquire throughout the game have been moved around. Logic remains, so the game
-is always able to be completed, but because of the item shuffle the player may need to access certain areas before
-they would in the vanilla game.
+
+Items which the player would normally acquire throughout the game have been moved around. Logic remains, so the game is
+always able to be completed, but because of the item shuffle the player may need to access certain areas before they
+would in the vanilla game.
 
 ## What items and locations get shuffled?
-All power-ups and ammunition can be shuffled, and all locations in the game which could contain any of those items
-may have their contents changed.
+
+All power-ups and ammunition can be shuffled, and all locations in the game which could contain any of those items may
+have their contents changed.
 
 ## Which items can be in another player's world?
-Any of the items which can be shuffled may also be placed into another player's world. It is possible to choose to
-limit certain items to your own world.
+
+Any of the items which can be shuffled may also be placed into another player's world. It is possible to choose to limit
+certain items to your own world.
 
 ## What does another world's item look like in Super Metroid?
+
 A unique item sprite has been added to the game to represent items belonging to another world.
 
 ## When the player receives an item, what happens?
+
 When the player receives an item, a text box will appear to show which item was received, and from whom.
 

WebHostLib/static/assets/gameInfo/en_Timespinner.md

@@ -1,28 +1,38 @@
 # Timespinner
 
 ## Where is the settings page?
-The player settings page for this game is located <a href="../player-settings">here</a>. It contains all the options
-you need to configure and export a config file.
+
+The [player settings page for this game](../player-settings) contains all the options you need to configure and export a
+config file.
 
 ## What does randomization do to this game?
-Items which the player would normally acquire throughout the game have been moved around. Logic remains, so the game
-is always able to be completed, but because of the item shuffle the player may need to access certain areas before
-they would in the vanilla game. All rings and spells are also randomized into those item locations, therefor you can no longer craft them at the alchemist
+
+Items which the player would normally acquire throughout the game have been moved around. Logic remains, so the game is
+always able to be completed, but because of the item shuffle the player may need to access certain areas before they
+would in the vanilla game. All rings and spells are also randomized into those item locations, therefore you can no
+longer craft them at the alchemist
 
 ## What is the goal of Timespinner when randomized?
+
 The goal remains unchanged. Kill the Sandman\Nightmare!
 
 ## What items and locations get shuffled?
-All main inventory items, orbs, collectables, and familiers can be shuffled, and all locations in the game which could
+
+All main inventory items, orbs, collectables, and familiars can be shuffled, and all locations in the game which could
 contain any of those items may have their contents changed.
 
 ## Which items can be in another player's world?
-Any of the items which can be shuffled may also be placed into another player's world. It is possible to choose to
-limit certain items to your own world.
+
+Any of the items which can be shuffled may also be placed into another player's world. It is possible to choose to limit
+certain items to your own world.
 
 ## What does another world's item look like in Timespinner?
-Items belonging to other worlds are represented by the vanilla item [Elemental Beads](https://timespinnerwiki.com/Use_Items), Elemental Beads have no use in the randomizer
+
+Items belonging to other worlds are represented by the vanilla item Elemental
+Beads ([Elemental Beads Wiki Page](https://timespinnerwiki.com/Use_Items)), Elemental Beads have no use in the
+randomizer.
 
 ## When the player receives an item, what happens?
-When the player receives an item, the same items popup will be displayed as when you would normally obtain the item
+
+When the player receives an item, the same items popup will be displayed as when you would normally obtain the item.
 

WebHostLib/static/assets/gameInfo/en_VVVVVV.md

@@ -0,0 +1,36 @@
+# VVVVVV
+
+## Where is the settings page?
+
+The player settings page for this game contains all the options you need to configure and export a config file. Player
+settings page link: [VVVVVV Player Settings Page](../player-settings).
+
+## What does randomization do to this game?
+All 20 Trinkets are now Location Checks and may not actually contain Trinkets, but Items for different games.
+
+Optionally, you may enable DoorCost, which will gate away some areas:
+- Laboratory
+- The Tower
+- Space Station 2 and
+- Warp Zone
+until you've collected some Trinkets.
+Examples:
+- If you set DoorCost at 2, then to enter Laboratory you will need Trinkets 1-2, for The Tower 3-4, etc.
+- If you set DoorCost at 3, then to enter Laboratory you will need Trinkets 1-3, for The Tower 4-6, etc.
+
+## What is the goal of VVVVVV when randomized?
+Save all crew members, and finish the story.
+
+## Which items can be in another player's world?
+Any of the 20 Trinkets.
+
+## What does another world's item look like in VVVVVV?
+The Trinkets are visually unchanged, though after collecting a textbox will pop up to inform you what you collected,
+and who will receive it.
+
+## When the player receives an item, what happens?
+When you receive a Trinket, the standard Animation will play. Afterwards a textbox will inform you where
+you received the Trinket from, and which one it is.
+
+NOTE: You can't check your trinkets in the Spaceship. Instead, you can check them in the pause menu under 'Stats'.
+This is especially useful if you have DoorCost enabled.

WebHostLib/static/assets/player-settings.js

@@ -16,11 +16,9 @@ window.addEventListener('load', () => {
     }
 
     if (settingHash !== md5(results[0])) {
-      const userMessage = document.getElementById('user-message');
-      userMessage.innerText = "Your settings are out of date! Click here to update them! Be aware this will reset " +
-        "them all to default.";
-      userMessage.style.display = "block";
-      userMessage.addEventListener('click', resetSettings);
+      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
@@ -191,7 +189,9 @@ const updateGameSetting = (event) => {
 
 const exportSettings = () => {
   const settings = JSON.parse(localStorage.getItem(gameName));
-  if (!settings.name || settings.name.trim().length === 0) { settings.name = "noname"; }
+  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);
 };
@@ -208,21 +208,41 @@ const download = (filename, text) => {
 };
 
 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: localStorage.getItem(gameName) },
-    presetData: { player: localStorage.getItem(gameName) },
+    weights: { player: settings },
+    presetData: { player: settings },
     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.';
+    let userMessage = 'Something went wrong and your game could not be generated.';
     if (error.response.data.text) {
-      userMessage.innerText += ' ' + error.response.data.text;
+      userMessage += ' ' + error.response.data.text;
     }
-    userMessage.classList.add('visible');
-    window.scrollTo(0, 0);
+    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/tutorial.js

@@ -23,6 +23,7 @@ window.addEventListener('load', () => {
         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/A Link to the Past/msu1_en.md

@@ -0,0 +1,78 @@
+# MSU-1 Setup Guide
+
+## What is MSU-1?
+
+MSU-1 allows for the use of custom in-game music. It works on original hardware, the SuperNT, and certain emulators.
+This guide will explain how to find custom music packages, often called MSU packs, and how to configure them for use
+with original hardware, the SuperNT, and the snes9x emulator.
+
+## Where to find MSU Packs
+
+MSU packs are constantly in development. We won't link to any packs as most include ripped music from other media.
+
+## What an MSU pack should look like
+
+MSU packs contain many files, most of which are the music files which will be used when playing the game. These files
+should be named similarly, with a hyphenated number at the end, and with a `.pcm` extension. It does not matter what
+each music file is named, so long as they all follow the same pattern. The most popular filename you will find
+is `alttp_msu-X.pcm`, where X is replaced by a number.
+
+There is one other type of file you should find inside an MSU pack's folder. This file indicates to the hardware or to
+the emulator that MSU should be enabled for this game. This file should be named similarly to the other files in the
+folder, but will have a `.msu` extension and be 0 KB in size.
+
+A short example of the contents of an MSU pack folder are as follows:
+
+```
+List of files inside an MSU pack folder:
+alttp_msu.msu
+alttp_msu-1.pcm
+alttp_msu-2.pcm
+...
+alttp_msu-34.pcm
+```
+
+## How to use an MSU Pack
+
+In all cases, you must rename your ROM file to match the pattern of names inside your MSU pack's folder, then place your
+ROM file inside that folder.
+
+This will cause the folder contents to look like the following:
+
+```
+List of files inside an MSU pack folder:
+alttp_msu.msu
+alttp_msu.sfc    <-- Add your ROM file
+alttp_msu-1.pcm
+alttp_msu-2.pcm
+...
+alttp_msu-34.pcm
+```
+
+### With snes9x
+
+1. Load the ROM file from snes9x.
+
+### With SD2SNES / FXPak on original hardware
+
+1. Load the MSU pack folder onto your SD2SNES / FXPak.
+2. Navigate into the MSU pack folder and load your ROM.
+
+### With SD2SNES / FXPak on SuperNT
+
+1. Load the MSU pack folder onto your SD2SNES / FXPak.
+2. Power on your SuperNT and navigate to the `Settings` menu.
+3. Enter the `Audio` settings.
+4. Check the box marked `Cartridge Audio Enable.`
+5. Navigate back to the previous menu.
+6. Choose `Save/Clear Settings`.
+7. Choose `Save Settings`.
+8. Choose `Run Cartridge` from the main menu.
+9. Navigate into your MSU pack folder and load your ROM.
+
+## A word of caution to streamers
+
+Many MSU packs use copyrighted music which is not permitted for use on platforms like Twitch and YouTube. If you choose
+to stream music from an MSU pack, please ensure you have permission to do so. If you stream music which has not been
+licensed to you, or licensed for use in a stream in general, your VOD may be muted. In the worst case, you may receive a
+DMCA take-down notice. Please be careful to only stream music for which you have the rights to do so.

WebHostLib/static/assets/tutorial/A Link to the Past/msu1_es.md

@@ -1,24 +1,31 @@
 # MSU-1 Guía de instalación
 
 ## Que es MSU-1?
-MSU-1 permite el uso de música personalizada durante el juego. Funciona en hardware original, la SuperNT, y algunos emuladores.
-Esta guiá explicará como encontrar los packs de música personalizada, comúnmente llamados pack MSU, y como configurarlos
-para su uso en hardware original, la SuperNT, and el emulador snes9x.
+
+MSU-1 permite el uso de música personalizada durante el juego. Funciona en hardware original, la SuperNT, y algunos
+emuladores. Esta guiá explicará como encontrar los packs de música personalizada, comúnmente llamados pack MSU, y como
+configurarlos para su uso en hardware original, la SuperNT, and el emulador snes9x.
 
 ## Donde encontrar packs MSU
-Los packs MSU están constantemente en desarrollo. Puedes encontrar una lista de pack completos, al igual que packs en desarrollo en
+
+Los packs MSU están constantemente en desarrollo. Puedes encontrar una lista de pack completos, al igual que packs en
+desarrollo en
 [esta hoja de calculo Google](https://docs.google.com/spreadsheets/d/1XRkR4Xy6S24UzYkYBAOv-VYWPKZIoUKgX04RbjF128Q).
 
 ## Que pinta debe tener un pack MSU
-Los packs MSU contienen muchos ficheros, la mayoria de los cuales son los archivos de música que se usaran durante el juego. Estos ficheros
-deben tener un nombre similar, con un guión seguido por un número al final, y tienen extensión`.pcm`. No importa como se llame
-cada archivo de música, siempre y cuando todos sigan el mismo patrón. El nombre más popular es
+
+Los packs MSU contienen muchos ficheros, la mayoria de los cuales son los archivos de música que se usaran durante el
+juego. Estos ficheros deben tener un nombre similar, con un guión seguido por un número al final, y tienen
+extensión`.pcm`. No importa como se llame cada archivo de música, siempre y cuando todos sigan el mismo patrón. El
+nombre más popular es
 `alttp_msu-X.pcm`, donde X es un número.
 
-Hay otro tipo de fichero que deberias encontrar en el directorio de un pack MSU. Este archivo indica al hardware o 
-emulador que MSU debe ser activado para este juego. El fichero tiene un nombre similar al resto, pero tiene como extensión `.msu` y su tamaño es 0 KB.
+Hay otro tipo de fichero que deberias encontrar en el directorio de un pack MSU. Este archivo indica al hardware o
+emulador que MSU debe ser activado para este juego. El fichero tiene un nombre similar al resto, pero tiene como
+extensión `.msu` y su tamaño es 0 KB.
 
 Un pequeño ejemplo de los contenidos de un directorio que contiene un pack MSU:
+
 ```
 Lista de ficheros dentro de un directorio de pack MSU:
 alttp_msu.msu
@@ -29,10 +36,12 @@ alttp_msu-34.pcm
 ```
 
 ## Como usar un pack MSU
-En todos los casos, debes renombrar tu fichero de ROM para que coincida con el resto de nombres de fichero del directorio, y copiar/pegar tu fichero rom
-dentro de dicho directorio.
+
+En todos los casos, debes renombrar tu fichero de ROM para que coincida con el resto de nombres de fichero del
+directorio, y copiar/pegar tu fichero rom dentro de dicho directorio.
 
 Esto hara que los contenidos del directorio sean los siguientes:
+
 ```
 Lista de ficheros dentro del directorio de pack MSU:
 alttp_msu.msu
@@ -44,13 +53,16 @@ alttp_msu-34.pcm
 ```
 
 ### Con snes9x
+
 1. Carga el fichero de rom en snes9x.
 
 ### Con SD2SNES / FXPak en hardware original
+
 1. Carga tu directorio de pack MSU en tu SD2SNES / FXPak.
 2. Navega hasta el directorio de pack MSU y carga la ROM
 
 ### Con SD2SNES / FXPak en SuperNT
+
 1. Carga tu directorio de pack MSU en tu SD2SNES / FXPak.
 2. Enciende tu SuperNT y navega al menú `Settings`.
 3. Entra en la opcion `Audio`.
@@ -62,13 +74,17 @@ alttp_msu-34.pcm
 9. Navega hasta el directorio de pack MSU y carga la ROM
 
 ## Aviso a streamers
-Muchos packs MSU usan música con derechos de autor la cual no esta permitido su uso en plataformas como Twitch o YouTube.
-Si elijes hacer stream de dicha música, tu VOD puede ser silenciado. En el peor caso, puedes recibir una orden de eliminación DMCA.
-Por favor, tened cuidado y solo streamear música para la cual tengas los derechos para hacerlo.
+
+Muchos packs MSU usan música con derechos de autor la cual no esta permitido su uso en plataformas como Twitch o
+YouTube. Si elijes hacer stream de dicha música, tu VOD puede ser silenciado. En el peor caso, puedes recibir una orden
+de eliminación DMCA. Por favor, tened cuidado y solo streamear música para la cual tengas los derechos para hacerlo.
 
 ##### Packs MSU seguros para Stream
-A continuación enumeramos los packs MSU que,  packs which, por lo que sabemos, son seguros para vuestras retransmisiones. Se iran añadiendo mas conforme
-vayamos enterandonos. Si sabes alguno que podamos haber olvidado, por favor haznoslo saber!
+
+A continuación enumeramos los packs MSU que, packs which, por lo que sabemos, son seguros para vuestras retransmisiones.
+Se iran añadiendo mas conforme vayamos enterandonos. Si sabes alguno que podamos haber olvidado, por favor haznoslo
+saber!
+
 - Musica del juego original
 - [Smooth McGroove](https://drive.google.com/open?id=1JDa1jCKg5hG0Km6xNpmIgf4kDMOxVp3n)
 

WebHostLib/static/assets/tutorial/A Link to the Past/msu1_fr.md

@@ -1,25 +1,31 @@
 # Guide d'installation de MSU-1
 
 ## Qu'est-ce que MSU-1 ?
-MSU-1 permet l'utilisation de musiques en jeu personnalisées. Cela fonctionne sur une console originale, sur SuperNT, et sur certains émulateurs.
-Ce guide explique comment trouver des packs de musiques personnalisées, couremment appelées packs MSU, et comment les configurer
-pour les utiliser sur console, sur SuperNT et sur l'émulateur snes9x.
+
+MSU-1 permet l'utilisation de musiques en jeu personnalisées. Cela fonctionne sur une console originale, sur SuperNT, et
+sur certains émulateurs. Ce guide explique comment trouver des packs de musiques personnalisées, couremment appelées
+packs MSU, et comment les configurer pour les utiliser sur console, sur SuperNT et sur l'émulateur snes9x.
 
 ## Où trouver des packs MSU
-Les packs MSU sont constamment en développement. Vous pouvez trouver une liste de packs complétés, ainsi que des packs en développement sur
+
+Les packs MSU sont constamment en développement. Vous pouvez trouver une liste de packs complétés, ainsi que des packs
+en développement sur
 [cette feuille de calcul Google](https://docs.google.com/spreadsheets/d/1XRkR4Xy6S24UzYkYBAOv-VYWPKZIoUKgX04RbjF128Q).
 
 ## A quoi ressemble un pack MSU
-Les packs MSU contiennent beaucoup de fichiers, la plupart étant des fichiers musicaux qui seront utilisés en cours de jeu. Ces fichiers
-doivent être nommés de façon similaire, avec un nombre derrière le tiret, puis l'extension `.pcm`. Le nom de chaque fichier
-n'importe pas, du moment qu'ils suivent tous le même motif. Le nom le plus populaire que vous verrez est
+
+Les packs MSU contiennent beaucoup de fichiers, la plupart étant des fichiers musicaux qui seront utilisés en cours de
+jeu. Ces fichiers doivent être nommés de façon similaire, avec un nombre derrière le tiret, puis l'extension `.pcm`. Le
+nom de chaque fichier n'importe pas, du moment qu'ils suivent tous le même motif. Le nom le plus populaire que vous
+verrez est
 `alttp_msu-X.pcm`, où X est remplacé par un nombre.
 
-Il existe un autre type de fichier que vous devriez trouver dans le dossier d'un pack MSU. Ce fichier indique au matériel
-ou à l'émulateur que MSU doit être activé pour ce jeu. Ce fichier doit être nommé de façon similaires aux autres dans
-le dossier, mais il aura une extension `.msu` et pèsera 0 KB.
+Il existe un autre type de fichier que vous devriez trouver dans le dossier d'un pack MSU. Ce fichier indique au
+matériel ou à l'émulateur que MSU doit être activé pour ce jeu. Ce fichier doit être nommé de façon similaires aux
+autres dans le dossier, mais il aura une extension `.msu` et pèsera 0 KB.
 
 Voici un exemple de ce à quoi ressemble le dossier d'un pack MSU :
+
 ```
 Liste des fichiers dans le dossier d'un pack MSU :
 alttp_msu.msu
@@ -30,10 +36,12 @@ alttp_msu-34.pcm
 ```
 
 ## Comment utiliser un pack MSU
-Dans tous les cas, vosu devez renommer votre fichier ROM pour qu'il corresponde au même motif que les autres fichiers dans le dossier du pack MSU,
-ensuite vous placez votre fichier ROM dans ce dossier.
+
+Dans tous les cas, vosu devez renommer votre fichier ROM pour qu'il corresponde au même motif que les autres fichiers
+dans le dossier du pack MSU, ensuite vous placez votre fichier ROM dans ce dossier.
 
 Le contenu du dossier ressemblera alors à ceci :
+
 ```
 Liste des fichiers dans le dossier d'un pack MSU :
 alttp_msu.msu
@@ -45,13 +53,16 @@ alttp_msu-34.pcm
 ```
 
 ### Avec snes9x
+
 1. Chargez le fichier ROM depuis snes9x.
 
 ### Avec un SD2SNES / FXPak sur une console originale
+
 1. Mettez le dossier du pack MSU avec la ROM sur votre SD2SNES / FXPak.
 2. Naviguez vers ce dossier et chargez votre ROM.
 
 ### Avec un SD2SNES / FXPak sur SuperNT
+
 1. Mettez le dossier du pack MSU avec la ROM sur votre SD2SNES / FXPak.
 2. Allumez votre SuperNT et naviguez vers le menu `Settings` (paramètres).
 3. Entrez dans les paramètres `Audio`.
@@ -63,6 +74,8 @@ alttp_msu-34.pcm
 9. Naviguez vers le dossier du pack MSU et chargez votre ROM.
 
 ## Avertissement pour les streamers
-Beaucoup de packs MSU utilisent des musiques copyrightées ce qui n'est pas permis sur des plateformes comme Twitch et YouTube.
-Si vous choisissez de streamer des musiques copyrightées, votre VOD sera peut-être rendue muette. Dans le pire des cas, vous pourriez recevoir
-une plainte DMCA pour faire retirer la vidéo. Faites attention à streamer uniquement des musiques pour lesquelles vous avez le droit.
+
+Beaucoup de packs MSU utilisent des musiques copyrightées ce qui n'est pas permis sur des plateformes comme Twitch et
+YouTube. Si vous choisissez de streamer des musiques copyrightées, votre VOD sera peut-être rendue muette. Dans le pire
+des cas, vous pourriez recevoir une plainte DMCA pour faire retirer la vidéo. Faites attention à streamer uniquement des
+musiques pour lesquelles vous avez le droit.

WebHostLib/static/assets/tutorial/A Link to the Past/multiworld_de.md

@@ -1,6 +1,7 @@
 # A Link to the Past Randomizer Setup Guide
 
 ## Benötigte Software
+
 - [Archipelago](https://github.com/ArchipelagoMW/Archipelago/releases)
 - [SNI](https://github.com/alttpo/sni/releases) (Integriert in Archipelago)
 - Hardware oder Software zum Laden und Abspielen von SNES Rom-Dateien fähig zu einer Internetverbindung
@@ -13,44 +14,49 @@
 ## Installation Schritt für Schritt
 
 ### Windows
-1. Lade die Multiworld Utilities herunter und führe die Installation aus. Sei sicher, dass du immer die
-aktuellste Version installiert hast.**Die Datei befindet sich im "assets"-Kasten unter der jeweiligen Versionsinfo!**.
-Für normale Multiworld-Spiele lädst du die `Setup.Archipelago.exe` herunter.
-    - Für den Doorrandomizer muss die alternative doors-Variante geladen werden. 
-    - Während der Installation fragt dich das Programm nach der japanischen 1.0 ROM-Datei. Wenn du die Software	
-      bereits installiert hast und einfach nur updaten willst, wirst du nicht nochmal danach gefragt.
-    - Es kann auch sein,dass der Installer Microsoft Visual C++ installieren möchte.
-      Wenn du das bereits installiert hast (durch Steam oder andere Programme), wirst du nicht nochmal danach gefragt.
+
+1. Lade die Multiworld Utilities herunter und führe die Installation aus. Sei sicher, dass du immer die aktuellste
+   Version installiert hast.**Die Datei befindet sich im "assets"-Kasten unter der jeweiligen Versionsinfo!**. Für
+   normale Multiworld-Spiele lädst du die `Setup.Archipelago.exe` herunter.
+    - Für den Doorrandomizer muss die alternative doors-Variante geladen werden.
+    - Während der Installation fragt dich das Programm nach der japanischen 1.0 ROM-Datei. Wenn du die Software bereits
+      installiert hast und einfach nur updaten willst, wirst du nicht nochmal danach gefragt.
+    - Es kann auch sein,dass der Installer Microsoft Visual C++ installieren möchte. Wenn du das bereits installiert
+      hast (durch Steam oder andere Programme), wirst du nicht nochmal danach gefragt.
 
 2. Wenn du einen Emulator benutzt, so ist es sinnvoll, ihn als Standard zum Abspielen für .sfc-dateien einzustellen.
     1. Entpacke oder Installiere deinen Emulator(-Ordner) an einen Ort, den du auch wiederfindest
     2. Rechtsklicke auf eine .sfc-Datei und wähle **Öffnen mit...**
     3. Mache einen Haken in die Box bei **Immer diese App zum Öffnen von .sfc Dateien benutzen **.
     4. Scrolle zum Ende und wähle **Weitere Apps** und nochmal am Ende **Andere App auf diesem PC suchen** auswählen.
-    5. Suche nach der .exe-Datei des Emulators deiner Wahl und wähle **Öffnen**.
-       Diese Datei befindet sich dort, wo den Emulator in Schritt 1 enpackt/installiert hast.
+    5. Suche nach der .exe-Datei des Emulators deiner Wahl und wähle **Öffnen**. Diese Datei befindet sich dort, wo den
+       Emulator in Schritt 1 enpackt/installiert hast.
+
+### Macintosh
 
-### Macintosh 
 - Es werden freiwillige Helfer gesucht! Meldet euch doch bei **Farrak Kilhn** auf Discord, wenn ihr helfen wollt!
 
 ## Erstellen deiner YAML-Datei
 
 ### Was ist eine YAML-Datei und wofür brauche ich die?
-Deine persönliche YAML-Datei beinhaltet eine Reihe von Einstellungen, die der Zufallsgenerator zum Erstellen
-von deinem Spiel benötigt. Jeder Spieler einer Multiworld stellt seine eigene YAML-Datei zur Verfügung. Dadurch kann
-jeder Spieler sein Spiel nach seinem eigenen Geschmack gestalten, während andere Spieler unabhängig davon ihre eigenen
-Einstellungen wählen können!
+
+Deine persönliche YAML-Datei beinhaltet eine Reihe von Einstellungen, die der Zufallsgenerator zum Erstellen von deinem
+Spiel benötigt. Jeder Spieler einer Multiworld stellt seine eigene YAML-Datei zur Verfügung. Dadurch kann jeder Spieler
+sein Spiel nach seinem eigenen Geschmack gestalten, während andere Spieler unabhängig davon ihre eigenen Einstellungen
+wählen können!
 
 ### Wo bekomme ich so eine YAML-Datei her?
-Die [Player Settings](/games/A Link to the Past/player-settings) Seite auf der Website ermöglicht das einfache Erstellen  und Herunterladen
-deiner eigenen `yaml` Datei. Drei verschiedene Voreinstellungen können dort gespeichert werden.
+
+Die [Player Settings](/games/A Link to the Past/player-settings) Seite auf der Website ermöglicht das einfache Erstellen
+und Herunterladen deiner eigenen `yaml` Datei. Drei verschiedene Voreinstellungen können dort gespeichert werden.
 
 ### Deine YAML-Datei ist gewichtet!
-Die **Player Settings** Seite hat eine Menge Optionen, die man per Schieber einstellen kann. Das ermöglicht es,
-verschiedene Optionen mit unterschiedlichen Wahrscheinlichkeiten in einer Kategorie ausgewürfelt zu werden 
 
-Als Beispiel kann man sich die Option "Map Shuffle" als einen Eimer mit Zetteln zur Abstimmung Vorstellen.
-So kann man beispielsweise für die Option "On" 20 Zettel mit dieser Option einwerfen und 40 Zettel mit "Off".
+Die **Player Settings** Seite hat eine Menge Optionen, die man per Schieber einstellen kann. Das ermöglicht es,
+verschiedene Optionen mit unterschiedlichen Wahrscheinlichkeiten in einer Kategorie ausgewürfelt zu werden
+
+Als Beispiel kann man sich die Option "Map Shuffle" als einen Eimer mit Zetteln zur Abstimmung Vorstellen. So kann man
+beispielsweise für die Option "On" 20 Zettel mit dieser Option einwerfen und 40 Zettel mit "Off".
 
 Entsprechend in diesem Beispiel liegen dann 60 Zettel im Eimer. 20 für "On" und 40 für "Off". Um die Option
 festzulegen, "greift" der Generator in den Eimer und holt sich zufällig einen Zettel heraus. Entsprechend ist die
@@ -60,30 +66,35 @@ Wenn du eine Option nicht gewählt haben möchtest, setze ihren Wert einfach auf
 (Es muss aber mindestens eine Option pro Kategorie einen Wert größer Null besitzen, sonst funktioniert die yaml nicht!)
 
 ### Überprüfung deiner YAML-Datei
-Wenn man sichergehen will, ob die YAML-Datei funktioniert, kann man dies
-bei der [YAML Validator](/mysterycheck) Seite tun. 
+
+Wenn man sichergehen will, ob die YAML-Datei funktioniert, kann man dies bei der [YAML Validator](/mysterycheck) Seite
+tun.
 
 ## ein Einzelspielerspiel erstellen
+
 1. Navigiere zur [Generator Seite](/generate) und lade dort deine YAML-Datei hoch.
-2. Dir wird eine "Seed Info"-Seite  angezeigt, wo du deine Patch-Datei herunterladen kannst.
-3. Doppelklicke die Patchdatei und der Emulator sollte nach kurzer Verzögerung mit dem gepatchten Rom starten.
-   Der Client ist soweit unnötig für Einzelspielerspiele, also kannst diesen und das WebUI einfach schließen.
+2. Dir wird eine "Seed Info"-Seite angezeigt, wo du deine Patch-Datei herunterladen kannst.
+3. Doppelklicke die Patchdatei und der Emulator sollte nach kurzer Verzögerung mit dem gepatchten Rom starten. Der
+   Client ist soweit unnötig für Einzelspielerspiele, also kannst diesen und das WebUI einfach schließen.
 
 ## Einem MultiWorld-Spiel beitreten
 
 ### Erhalte deine Patch-Datei und erstelle dein ROM
+
 Wenn du an einem MultiWorld-Spiel teilnehmen möchtest, wirst du in der Regel vom Host nach deiner YAML-Datei gefragt.
-Sobald du diese weitergegeben hast, wird der Host einen Link bereitstellen, wo du deinen Patch oder eine .zip-Datei
-mit allen Patches herunterladen kannst. Die Patch-Datei hat immer die Endung `.apbp`.
+Sobald du diese weitergegeben hast, wird der Host einen Link bereitstellen, wo du deinen Patch oder eine .zip-Datei mit
+allen Patches herunterladen kannst. Die Patch-Datei hat immer die Endung `.apbp`.
 
 ### Mit dem Client verbinden
 
 #### Via Emulator
-Wenn der client den Emulator automatisch gestartet hat, wird SNI ebenfalls im Hintergrund gestartet.
-Wenn dies das erste Mal ist, wird möglicherweise ein Fenster angezeigt, wo man bestätigen muss, dass das Programm
-durch die Windows Firewall kommunizieren darf.
+
+Wenn der client den Emulator automatisch gestartet hat, wird SNI ebenfalls im Hintergrund gestartet. Wenn dies das erste
+Mal ist, wird möglicherweise ein Fenster angezeigt, wo man bestätigen muss, dass das Programm durch die Windows Firewall
+kommunizieren darf.
 
 ##### snes9x Multitroid
+
 1. Lade die Entsprechende ROM-Datei, wenn sie nicht schon automatisch geladen wurde.
 2. Klicke auf den Reiter "File" oben im Menü und wähle **Lua Scripting**
 3. Klicke auf **New Lua Script Window...**
@@ -94,8 +105,9 @@ durch die Windows Firewall kommunizieren darf.
    "Snes Device: Connected" mit demselben Namen dort steht (in der oberen linken Ecke).
 
 ##### BizHawk
-1. Stelle sicher, dass der BSNES-Core in Bizhawk geladen wird. Dazu musst du auf das Tools-Menü in Bizhawk klicken
-   und folgende Optionen wählen:
+
+1. Stelle sicher, dass der BSNES-Core in Bizhawk geladen wird. Dazu musst du auf das Tools-Menü in Bizhawk klicken und
+   folgende Optionen wählen:
    `Config --> Cores --> SNES --> BSNES`
 2. Lade die entsprechende ROM-Datei, wenn sie nicht schon automatisch geladen wurde.
 3. Klicke auf das Tools-Menü und klicke auf **Lua Console**
@@ -106,32 +118,34 @@ durch die Windows Firewall kommunizieren darf.
    "Snes Device: Connected" mit demselben Namen dort steht (in der oberen linken Ecke)
 
 #### Mit (Original-)Hardware
-Dieser Guide setzt voraus, dass du schon die entsprechende Firmware für dein Gerät heruntergeladen hast! Wenn du
-das noch nicht getan hast, so tue dies am besten jetzt! SD2SNES und FXPak Pro Nutzer finden die passende Firmware
+
+Dieser Guide setzt voraus, dass du schon die entsprechende Firmware für dein Gerät heruntergeladen hast! Wenn du das
+noch nicht getan hast, so tue dies am besten jetzt! SD2SNES und FXPak Pro Nutzer finden die passende Firmware
 [hier](https://github.com/RedGuyyyy/sd2snes/releases). Nutzer ähnlicher Hardware finden Hilfestellung
 [auf dieser Seite](http://usb2snes.com/#supported-platforms).
 
-
 1. Schließe deinen Emulator, falls er automatisch gestartet haben sollte.
 2. Start SNI
 3. Starte deine (Original-)Konsole und lade die ROM-Datei.
-4. Schaue auf dein Clientfenster, welches nun "Snes Device: Connected" und den namen deiner Konsole
-   zeigen sollte.
+4. Schaue auf dein Clientfenster, welches nun "Snes Device: Connected" und den namen deiner Konsole zeigen sollte.
 
 ### Mit dem MultiServer verbinden
+
 Die Patch-Datei, welche auch den Client gestartet hat, sollte dich automatisch mit dem MultiServer verbunden haben.
-Manchmal ist dies nicht der Fall, auch wenn das Spiel auf der Webseite gehostet wird, aber woanders erstellt wurde.
-Wenn die WebUI vom Client "Server Status: Not Connected" zeigt, frag deinen Host nach der passenden Adresse
-und trage sie einfach in das Textfeld neben "Server" ein und drücke Enter.
+Manchmal ist dies nicht der Fall, auch wenn das Spiel auf der Webseite gehostet wird, aber woanders erstellt wurde. Wenn
+die WebUI vom Client "Server Status: Not Connected" zeigt, frag deinen Host nach der passenden Adresse und trage sie
+einfach in das Textfeld neben "Server" ein und drücke Enter.
 
 Der Client wird versuchen auf die neue Adresse zu verbinden und nach einer Weile "Server Status: Connected" zeigen.
 Sollte nach einer Weile der Client sich nicht verbunden haben, lade die Seite neu.
 
 ### Spiele das Spiel!
-Wenn der Client anzeigt, dass sowohl das SNES-Gerät (oder Emulator) und der Server verbunden sind,
-können du und deine Freunde loslegen! Glückwunsch zum erfolgreichen Beitritt zu einem Multiworld-Spiel ;)
+
+Wenn der Client anzeigt, dass sowohl das SNES-Gerät (oder Emulator) und der Server verbunden sind, können du und deine
+Freunde loslegen! Glückwunsch zum erfolgreichen Beitritt zu einem Multiworld-Spiel ;)
 
 ## Ein Multiworld-Spiel hosten
+
 Die Empfohlene Art, ein Spiel zu hosten, ist, den Service auf
 [der website](/generate) zu nutzen. Das Ganze ist recht einfach:
 
@@ -140,11 +154,11 @@ Die Empfohlene Art, ein Spiel zu hosten, ist, den Service auf
 3. Lade diesen Zip-Ordner auf der oben genannten Website hoch.
 4. Warte einen Moment, wenn das Spiel erstellt wird.
 5. Wenn das Spiel erstellt wurde, wirst du auf eine "Seed Info"-Seite weitergeleitet.
-6. Klicke auf "Create New Room". Du wirst auf die Serverseite gebracht. Gib diesen Link deinen Mitspielern, 
-   sodass sie ihre Patch-Dateien von dort herunterladen können.
-   **Anmerkung:** Die Patch-Dateien von dieser Seite ermöglichen es den Spielern,
-   automatisch auf den Server zu verbinden. Die Patch-Dateien von der "Seed Info"-Seite tun dies nicht!
-7. Oben auf der Serverseite ist ein Link zum MultiWorld-Tracker zum aktuellen Spiel zu finden. Gib diesen Link
-   ebenfalls deinen Mitspielern, so dass ihr alle den Fortschritt eures Spiels verfolgen könnt! Ihr könnt ihn
-   auch an Zuschauer weitergeben, so dass sie auf dem Laufenden bleiben.
+6. Klicke auf "Create New Room". Du wirst auf die Serverseite gebracht. Gib diesen Link deinen Mitspielern, sodass sie
+   ihre Patch-Dateien von dort herunterladen können.
+   **Anmerkung:** Die Patch-Dateien von dieser Seite ermöglichen es den Spielern, automatisch auf den Server zu
+   verbinden. Die Patch-Dateien von der "Seed Info"-Seite tun dies nicht!
+7. Oben auf der Serverseite ist ein Link zum MultiWorld-Tracker zum aktuellen Spiel zu finden. Gib diesen Link ebenfalls
+   deinen Mitspielern, so dass ihr alle den Fortschritt eures Spiels verfolgen könnt! Ihr könnt ihn auch an Zuschauer
+   weitergeben, so dass sie auf dem Laufenden bleiben.
 8. Wenn alle Spieler verbunden sind, könnt ihr mit dem Spiel loslegen! Viel Spaß!

WebHostLib/static/assets/tutorial/A Link to the Past/multiworld_en.md

@@ -1,99 +1,127 @@
 # A Link to the Past Randomizer Setup Guide
 
 ## Required Software
-- [Z3Client](https://github.com/ArchipelagoMW/Z3Client/releases) or the SNIClient included with
-[Archipelago](https://github.com/ArchipelagoMW/Archipelago/releases)
-    - If installing Archipelago, make sure to check the box for SNIClient -> A Link to the Past Patch Setup during install, or SNI will not be included
-- [SNI](https://github.com/alttpo/sni/releases) (Included in both Z3Client and SNIClient)
+
+- One of the client programs:
+  - [SNIClient](https://github.com/ArchipelagoMW/Archipelago/releases), included with the main 
+  Archipelago install. Make sure to check the box for `SNI Client - A Link to the Past Patch Setup`
+  - [SuperNintendoClient](https://github.com/ArchipelagoMW/SuperNintendoClient/releases), an alternate standalone
+  client for Super Nintendo games
 - Hardware or software capable of loading and playing SNES ROM files
     - An emulator capable of connecting to SNI
-      ([snes9x Multitroid](https://drive.google.com/drive/folders/1_ej-pwWtCAHYXIrvs5Hro16A1s9Hi3Jz),
-      [BizHawk](http://tasvideos.org/BizHawk.html))
+      ([snes9x rr](https://github.com/gocha/snes9x-rr/releases),
+       [BizHawk](http://tasvideos.org/BizHawk.html), or
+       [RetroArch](https://retroarch.com?page=platforms) 1.10.1 or newer). Or,
     - 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
+
 1. Download and install your preferred client from the link above, making sure to install the most recent version.
-**The installer file is located in the assets section at the bottom of the version information**.
+   **The installer file is located in the assets section at the bottom of the version information**.
     - During setup, you will be asked to locate your base ROM file. This is your Japanese Link to the Past ROM file.
 
-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. 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.
+    5. Browse for your emulator's `.exe` file and click **Open**. This file should be located inside the folder you
+       extracted in step one.
 
 ## Create a Config (.yaml) File
 
 ### What is a config file and why do I need one?
-Your config 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 config 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.
+
+Your config 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 config 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 config file?
+
 The [Player Settings](/games/A%20Link%20to%20the%20Past/player-settings) page on the website allows you to configure
 your personal settings and export a config file from them.
 
 ### Verifying your config file
+
 If you would like to validate your config 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 [Player Settings](/games/A%20Link%20to%20the%20Past/player-settings) page, configure your options,
    and click the "Generate Game" button.
 2. You will be presented with a "Seed Info" page.
 3. Click the "Create New Room" link.
 4. You will be presented with a server page, from which you can download your patch file.
-5. Double-click on your patch file, and the Z3Client will launch automatically, create your ROM from
-   the patch file, and open your emulator for you.
+5. Double-click on your patch file, and the Z3Client will launch automatically, create your ROM from the patch file, and
+   open your emulator for you.
 6. Since this is a single-player game, you will no longer need the client, so feel free to close it.
 
 ## 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 config 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 `.apbp` 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 in the same place as your patch file.
+When you join a multiworld game, you will be asked to provide your config 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 `.apbp` 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 in the same place as your patch file.
 
 ### Connect to the client
 
 #### With an emulator
-When the client launched automatically, SNI 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.
+
+When the client launched automatically, SNI 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. Select the connector lua file included with your client
-     - Z3Client users should download `sniConnector.lua` from the client download page
-     - SNIClient users should look in their Archipelago folder for `/sni/lua`
+    - SuperNintendoClient users should download `sniConnector.lua` from the client download page
+    - SNIClient users should look in their Archipelago folder for `/SNI/lua/x64` or `/SNI/lua/x86` depending on if the
+      emulator is 64-bit or 32-bit.
 
 ##### 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:  
+
+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 Script -> Open Script...
 5. Select the `Connector.lua` file you downloaded above
-     - Z3Client users should download `sniConnector.lua` from the client download page
-     - SNIClient users should look in their Archipelago folder for `/sni/lua`
-6. Run the script by double-clicking it in the listing
+    - SuperNintendoClient users should download `sniConnector.lua` from the client download page
+    - SNIClient users should look in their Archipelago folder for `/SNI/lua/x64` or `/SNI/lua/x86` depending on if the
+      emulator is 64-bit or 32-bit.
+
+##### RetroArch 1.10.1 or newer
+
+You only have to do these steps once.
+
+1. Enter the RetroArch main menu screen.
+2. Go to Settings --> User Interface. Set "Show Advanced Settings" to ON.
+3. Go to Settings --> Network. Set "Network Commands" to ON. (It is found below Request Device 16.) Leave the default
+   Network Command Port at 55355.
+![Screenshot of Network Commands setting](/static/assets/tutorial/retroarch-network-commands-en.png)
+4. Go to Main Menu --> Online Updater --> Core Downloader. Scroll down and select "Nintendo - SNES / SFC (bsnes-mercury
+   Performance)".
+
+When loading a ROM, be sure to select a **bsnes-mercury** core. These are the only cores that allow external tools to
+read ROM data.
 
 #### 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
+
+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).
 
@@ -101,19 +129,22 @@ done so already, please do this now. SD2SNES and FXPak Pro users may download th
 2. Power on your device and load the ROM.
 
 ### Connect to the Archipelago Server
-The patch file which launched your client should have automatically connected you to the AP Server.
-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".
+The patch file which launched your client should have automatically connected you to the AP Server. 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".
 
 ### 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!
+
+When the client shows both SNES Device and Server as connected, you're ready to begin playing. Congratulations on
+successfully joining a multiworld game! You can execute various commands in your client. For more information regarding
+these commands you can use `/help` for local client commands and `!help` for server commands.
 
 ## Hosting a MultiWorld game
+
 The recommended way to host a game is to use our [hosting service](/generate). The process is relatively simple:
 
 1. Collect config files from your players.
@@ -121,8 +152,8 @@ The recommended way to host a game is to use our [hosting service](/generate). T
 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.
+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.
 7. Note that a link to a MultiWorld Tracker is at the top of the room page. The tracker shows the progress of all
    players in the game. Any observers may also be given the link to this page.
 8. Once all players have joined, you may begin playing.

WebHostLib/static/assets/tutorial/A Link to the Past/multiworld_es.md

@@ -7,97 +7,123 @@
 </div>
 
 ## Software requerido
+
 - [Archipelago](https://github.com/ArchipelagoMW/Archipelago/releases)
 - [QUsb2Snes](https://github.com/Skarsnik/QUsb2snes/releases) (Incluido en Multiworld Utilities)
 - Hardware o software capaz de cargar y ejecutar archivos de ROM de SNES
     - Un emulador capaz de ejecutar scripts Lua
       ([snes9x Multitroid](https://drive.google.com/drive/folders/1_ej-pwWtCAHYXIrvs5Hro16A1s9Hi3Jz),
-      [BizHawk](http://tasvideos.org/BizHawk.html))
+       [BizHawk](http://tasvideos.org/BizHawk.html), o
+       [RetroArch](https://retroarch.com?page=platforms) 1.10.1 o más nuevo). O,
     - Un flashcart SD2SNES, [FXPak Pro](https://krikzz.com/store/home/54-fxpak-pro.html), o otro hardware compatible
 - Tu archivo ROM japones v1.0, probablemente se llame `Zelda no Densetsu - Kamigami no Triforce (Japan).sfc`
 
 ## Procedimiento de instalación
 
 ### Instalación en Windows
-1. Descarga e instala MultiWorld Utilities desde el enlace anterior, asegurando que instalamos la versión más reciente.
-**El archivo esta localizado en la sección "assets" en la parte inferior de la información de versión**. Si tu intención es jugar la versión normal de multiworld, necesitarás el archivo `Setup.Archipelago.exe`
-    - Si estas interesado en jugar la variante que aleatoriza las puertas internas de las mazmorras, necesitaras bajar 'Setup.BerserkerMultiWorld.Doors.exe'
-    - Durante el proceso de instalación, se te pedirá donde esta situado tu archivo ROM japonés v1.0. Si ya habías instalado este software con anterioridad y simplemente estas actualizando, no se te pedirá la localización del archivo una segunda vez.
-    - Puede ser que el programa pida la instalación de Microsoft Visual C++. Si ya lo tienes en tu ordenador (posiblemente por que un juego de Steam ya lo haya instalado), el instalador no te pedirá su instalación.
 
-2. Si estas usando un emulador, deberías asignar la versión capaz de ejecutar scripts Lua como programa por defecto para lanzar ficheros de ROM de SNES.
+1. Descarga e instala MultiWorld Utilities desde el enlace anterior, asegurando que instalamos la versión más reciente.
+   **El archivo esta localizado en la sección "assets" en la parte inferior de la información de versión**. Si tu
+   intención es jugar la versión normal de multiworld, necesitarás el archivo `Setup.Archipelago.exe`
+    - Si estas interesado en jugar la variante que aleatoriza las puertas internas de las mazmorras, necesitaras bajar '
+      Setup.BerserkerMultiWorld.Doors.exe'
+    - Durante el proceso de instalación, se te pedirá donde esta situado tu archivo ROM japonés v1.0. Si ya habías
+      instalado este software con anterioridad y simplemente estas actualizando, no se te pedirá la localización del
+      archivo una segunda vez.
+    - Puede ser que el programa pida la instalación de Microsoft Visual C++. Si ya lo tienes en tu ordenador (
+      posiblemente por que un juego de Steam ya lo haya instalado), el instalador no te pedirá su instalación.
+
+2. Si estas usando un emulador, deberías asignar la versión capaz de ejecutar scripts Lua como programa por defecto para
+   lanzar ficheros de ROM de SNES.
     1. Extrae tu emulador al escritorio, o cualquier sitio que después recuerdes.
     2. Haz click derecho en un fichero de ROM (ha de tener la extensión sfc) y selecciona **Abrir con...**
     3. Marca la opción **Usar siempre esta aplicación para abrir los archivos .sfc**
-    4. Baja hasta el final de la lista y haz click en la opción **Buscar otra aplicación en el equipo** (Si usas Windows 10 es posible que debas hacer click en **Más aplicaciones**)
-    5. Busca el archivo .exe de tu emulador y haz click en **Abrir**. Este archivo debe estar en el directorio donde extrajiste en el paso 1.
+    4. Baja hasta el final de la lista y haz click en la opción **Buscar otra aplicación en el equipo** (Si usas Windows
+       10 es posible que debas hacer click en **Más aplicaciones**)
+    5. Busca el archivo .exe de tu emulador y haz click en **Abrir**. Este archivo debe estar en el directorio donde
+       extrajiste en el paso 1.
 
 ### Instalación en Macintosh
-- ¡Necesitamos voluntarios para rellenar esta seccion! Contactad con **Farrak Kilhn** (en inglés) en Discord si queréis ayudar.
+
+- ¡Necesitamos voluntarios para rellenar esta seccion! Contactad con **Farrak Kilhn** (en inglés) en Discord si queréis
+  ayudar.
 
 ## Configurar tu archivo YAML
 
 ### Que es un archivo YAML y por qué necesito uno?
-Tu archivo YAML contiene un conjunto de opciones de configuración que proveen al generador con información sobre como debe generar tu juego.
-Cada jugador en una partida de multiworld proveerá su propio fichero YAML. Esta configuración permite
-que cada jugador disfrute de una experiencia personalizada a su gusto, y cada jugador dentro de la misma partida de multiworld puede tener diferentes opciones.
+
+Tu archivo YAML contiene un conjunto de opciones de configuración que proveen al generador con información sobre como
+debe generar tu juego. Cada jugador en una partida de multiworld proveerá su propio fichero YAML. Esta configuración
+permite que cada jugador disfrute de una experiencia personalizada a su gusto, y cada jugador dentro de la misma partida
+de multiworld puede tener diferentes opciones.
 
 ### Donde puedo obtener un fichero YAML?
-La página "[Generate Game](/games/A%20Link%20to%20the%20Past/player-settings)" en el sitio web te permite configurar tu configuración personal y
-descargar un fichero "YAML". 
+
+La página "[Generate Game](/games/A%20Link%20to%20the%20Past/player-settings)" en el sitio web te permite configurar tu
+configuración personal y descargar un fichero "YAML".
 
 ### Configuración YAML avanzada
+
 Una version mas avanzada del fichero Yaml puede ser creada usando la pagina ["Weighted settings"](/weighted-settings),
-la cual te permite tener almacenadas hasta 3 preajustes. La pagina "Weighted Settings" tiene muchas opciones representadas con controles deslizantes. Esto permite
-elegir cuan probable los valores de una categoría pueden ser elegidos sobre otros de la misma.
+la cual te permite tener almacenadas hasta 3 preajustes. La pagina "Weighted Settings" tiene muchas opciones
+representadas con controles deslizantes. Esto permite elegir cuan probable los valores de una categoría pueden ser
+elegidos sobre otros de la misma.
 
-Por ejemplo, imagina que el generador crea un cubo llamado "map_shuffle", y pone trozos de papel doblado en él por cada sub-opción.
-Ademas imaginemos que tu valor elegido para "on" es 20 y el elegido para "off" es 40.
+Por ejemplo, imagina que el generador crea un cubo llamado "map_shuffle", y pone trozos de papel doblado en él por cada
+sub-opción. Ademas imaginemos que tu valor elegido para "on" es 20 y el elegido para "off" es 40.
 
-Por tanto, en este ejemplo, habrán 60 trozos de papel. 20 para "on" y 40 para "off".
-Cuando el generador esta decidiendo si activar o no "map shuffle" para tu partida, 
-meterá la mano en el cubo y sacara un trozo de papel al azar. En este ejemplo,
-es mucho mas probable (2 de cada 3 veces (40/60)) que "map shuffle" esté desactivado. 
+Por tanto, en este ejemplo, habrán 60 trozos de papel. 20 para "on" y 40 para "off". Cuando el generador esta decidiendo
+si activar o no "map shuffle" para tu partida, meterá la mano en el cubo y sacara un trozo de papel al azar. En este
+ejemplo, es mucho mas probable (2 de cada 3 veces (40/60)) que "map shuffle" esté desactivado.
 
-Si quieres que una opción no pueda ser escogida, simplemente asigna el valor 0 a dicha opción. Recuerda que cada opción debe tener
- al menos un valor mayor que cero, si no la generación fallará.
+Si quieres que una opción no pueda ser escogida, simplemente asigna el valor 0 a dicha opción. Recuerda que cada opción
+debe tener al menos un valor mayor que cero, si no la generación fallará.
 
 ### Verificando tu archivo YAML
+
 Si quieres validar que tu fichero YAML para asegurarte que funciona correctamente, puedes hacerlo en la pagina
 [YAML Validator](/mysterycheck).
 
 ## Generar una partida para un jugador
-1. Navega a [la pagina Generate game](/games/A%20Link%20to%20the%20Past/player-settings), configura tus opciones, haz click en el boton "Generate game".
+
+1. Navega a [la pagina Generate game](/games/A%20Link%20to%20the%20Past/player-settings), configura tus opciones, haz
+   click en el boton "Generate game".
 2. Se te redigirá a una pagina "Seed Info", donde puedes descargar tu archivo de parche.
-3. Haz doble click en tu fichero de parche, y el emulador debería ejecutar tu juego automáticamente. Como el
-   Cliente no es necesario para partidas de un jugador, puedes cerrarlo junto a la pagina web (que tiene como titulo "Multiworld WebUI") que se ha abierto automáticamente.
+3. Haz doble click en tu fichero de parche, y el emulador debería ejecutar tu juego automáticamente. Como el Cliente no
+   es necesario para partidas de un jugador, puedes cerrarlo junto a la pagina web (que tiene como titulo "Multiworld
+   WebUI") que se ha abierto automáticamente.
 
 ## Unirse a una partida MultiWorld
 
 ### Obtener el fichero de parche y crea tu ROM
-Cuando te unes a una partida multiworld, debes proveer tu fichero YAML a quien sea el creador de la partida. Una vez
-este hecho, el creador te devolverá un enlace para descargar el parche o un fichero zip conteniendo todos los ficheros de parche de la partida
-Tu fichero de parche debe tener la extensión `.bmbp`.
 
-Pon tu fichero de parche en el escritorio o en algún sitio conveniente, y haz doble click. Esto debería ejecutar automáticamente
-el cliente, y ademas creara la rom en el mismo directorio donde este el fichero de parche.
+Cuando te unes a una partida multiworld, debes proveer tu fichero YAML a quien sea el creador de la partida. Una vez
+este hecho, el creador te devolverá un enlace para descargar el parche o un fichero zip conteniendo todos los ficheros
+de parche de la partida Tu fichero de parche debe tener la extensión `.bmbp`.
+
+Pon tu fichero de parche en el escritorio o en algún sitio conveniente, y haz doble click. Esto debería ejecutar
+automáticamente el cliente, y ademas creara la rom en el mismo directorio donde este el fichero de parche.
 
 ### Conectar al cliente
 
 #### Con emulador
-Cuando el cliente se lance automáticamente, QUsb2Snes debería haberse ejecutado también.
-Si es la primera vez que lo ejecutas, puedes ser que el firewall de Windows te pregunte si le permites la comunicación.
+
+Cuando el cliente se lance automáticamente, QUsb2Snes debería haberse ejecutado también. Si es la primera vez que lo
+ejecutas, puedes ser que el firewall de Windows te pregunte si le permites la comunicación.
 
 ##### snes9x Multitroid
+
 1. Carga tu fichero de ROM, si no lo has hecho ya
 2. Abre el menu "File" y situa el raton en **Lua Scripting**
 3. Haz click en **New Lua Script Window...**
 4. En la nueva ventana, haz click en **Browse...**
-5. Navega hacia el directorio donde este situado snes9x Multitroid, entra en el directorio `lua`, y escoge `multibridge.lua`
-6. Observa que se ha asignado un nombre al dispositivo, y el cliente muestra "SNES Device: Connected", con el mismo nombre
-   en la esquina superior izquierda.
+5. Navega hacia el directorio donde este situado snes9x Multitroid, entra en el directorio `lua`, y
+   escoge `multibridge.lua`
+6. Observa que se ha asignado un nombre al dispositivo, y el cliente muestra "SNES Device: Connected", con el mismo
+   nombre en la esquina superior izquierda.
 
 ##### BizHawk
+
 1. Asegurate que se ha cargado el nucleo BSNES. Debes hacer esto en el menu Tools y siguiento estas opciones:
    `Config --> Cores --> SNES --> BSNES`  
    Una vez cambiado el nucleo cargado, Bizhawk ha de ser reiniciado.
@@ -107,14 +133,31 @@ Si es la primera vez que lo ejecutas, puedes ser que el firewall de Windows te p
 5. Navega al directorio de instalación de MultiWorld Utilities, y en los siguiente directorios:  
    `QUsb2Snes/Qusb2Snes/LuaBridge`
 6. Selecciona `luabridge.lua` y haz click en Abrir.
-7. Observa que se ha asignado un nombre al dispositivo, y el cliente muestra "SNES Device: Connected", con el mismo nombre
-   en la esquina superior izquierda.
+7. Observa que se ha asignado un nombre al dispositivo, y el cliente muestra "SNES Device: Connected", con el mismo
+   nombre en la esquina superior izquierda.
+
+##### RetroArch 1.10.1 o más nuevo
+
+Sólo hay que segiur estos pasos una vez.
+
+1. Comienza en la pantalla del menú principal de RetroArch.
+2. Ve a Ajustes --> Interfaz de usario. Configura "Mostrar ajustes avanzados" en ON.
+3. Ve a Ajustes --> Red. Configura "Comandos de red" en ON. (Se encuentra bajo Request Device 16.) Deja en 55355 (el
+   default) el Puerto de comandos de red.
+![Captura de pantalla del ajuste Comandos de red](/static/assets/tutorial/retroarch-network-commands-en.png)
+4. Ve a Menú principal --> Actualizador en línea --> Descargador de núcleos. Desplázate y selecciona "Nintendo - SNES /
+   SFC (bsnes-mercury Performance)".
+
+Cuando cargas un ROM, asegúrate de seleccionar un núcleo **bsnes-mercury**. Estos son los sólos núcleos que permiten
+que herramientas externas lean datos del ROM.
 
 #### Con Hardware
-Esta guía asume que ya has descargado el firmware correcto para tu dispositivo. Si no lo has hecho ya, hazlo ahora.
-Los usuarios de SD2SNES y FXPak Pro pueden descargar el firmware apropiado 
+
+Esta guía asume que ya has descargado el firmware correcto para tu dispositivo. Si no lo has hecho ya, hazlo ahora. Los
+usuarios de SD2SNES y FXPak Pro pueden descargar el firmware apropiado
 [aqui](https://github.com/RedGuyyyy/sd2snes/releases). Los usuarios de otros dispositivos pueden encontrar información
 [en esta página](http://usb2snes.com/#supported-platforms).
+
 1. Cierra tu emulador, el cual debe haberse autoejecutado.
 2. Cierra QUsb2Snes, el cual fue ejecutado junto al cliente.
 3. Ejecuta la version correcta de QUsb2Snes (v0.7.16).
@@ -122,19 +165,22 @@ Los usuarios de SD2SNES y FXPak Pro pueden descargar el firmware apropiado
 5. Observa en el cliente que ahora muestra "SNES Device: Connected", y aparece el nombre del dispositivo.
 
 ### Conecta al MultiServer
-El fichero de parche que ha lanzado el cliente debe haberte conectado automaticamente al MultiServer.
-Hay algunas razonas por las que esto puede que no pase, incluyendo que el juego este hospedado en el sitio web pero 
-se genero en algún otro sitio. Si el cliente muestra "Server Status: Not Connected", preguntale al creador de la partida
-la dirección del servidor, copiala en el campo "Server" y presiona Enter.
 
-El cliente intentara conectarse a esta nueva dirección, y debería mostrar "Server
-Status: Connected" en algún momento. Si el cliente no se conecta al cabo de un rato, puede ser que necesites refrescar la pagina web.
+El fichero de parche que ha lanzado el cliente debe haberte conectado automaticamente al MultiServer. Hay algunas
+razonas por las que esto puede que no pase, incluyendo que el juego este hospedado en el sitio web pero se genero en
+algún otro sitio. Si el cliente muestra "Server Status: Not Connected", preguntale al creador de la partida la dirección
+del servidor, copiala en el campo "Server" y presiona Enter.
+
+El cliente intentara conectarse a esta nueva dirección, y debería mostrar "Server Status: Connected" en algún momento.
+Si el cliente no se conecta al cabo de un rato, puede ser que necesites refrescar la pagina web.
 
 ### Jugando
-Cuando ambos SNES Device and Server aparezcan como "connected", estas listo para empezar a jugar. Felicidades
-por unirte satisfactoriamente a una partida de multiworld!
+
+Cuando ambos SNES Device and Server aparezcan como "connected", estas listo para empezar a jugar. Felicidades por unirte
+satisfactoriamente a una partida de multiworld!
 
 ## Hospedando una partida de multiworld
+
 La manera recomendad para hospedar una partida es usar el servicio proveído en
 [el sitio web](/generate). El proceso es relativamente sencillo:
 
@@ -143,28 +189,34 @@ La manera recomendad para hospedar una partida es usar el servicio proveído en
 3. Carga el fichero zip en el sitio web enlazado anteriormente.
 4. Espera a que la seed sea generada.
 5. Cuando esto acabe, se te redigirá a una pagina titulada "Seed Info".
-6. Haz click en "Create New Room". Esto te llevara a la pagina del servidor. Pasa el enlace a esta pagina a los jugadores
-   para que puedan descargar los ficheros de parche de ahi.  
+6. Haz click en "Create New Room". Esto te llevara a la pagina del servidor. Pasa el enlace a esta pagina a los
+   jugadores para que puedan descargar los ficheros de parche de ahi.  
    **Nota:** Los ficheros de parche de esta pagina permiten a los jugadores conectarse al servidor automaticamente,
    mientras que los de la pagina "Seed info" no.
-7. Hay un enlace a un MultiWorld Tracker en la parte superior de la pagina de la sala. Deberías pasar también este enlace
-   a los jugadores para que puedan ver el progreso de la partida. A los observadores también se les puede pasar este enlace.
+7. Hay un enlace a un MultiWorld Tracker en la parte superior de la pagina de la sala. Deberías pasar también este
+   enlace a los jugadores para que puedan ver el progreso de la partida. A los observadores también se les puede pasar
+   este enlace.
 8. Una vez todos los jugadores se han unido, podeis empezar a jugar.
 
 ## Auto-Tracking
+
 Si deseas usar auto-tracking para tu partida, varios programas ofrecen esta funcionalidad.  
 El programa recomentdado actualmente es:
 [OpenTracker](https://github.com/trippsc2/OpenTracker/releases).
 
 ### Instalación
+
 1. Descarga el fichero de instalacion apropiado para tu ordenador (Usuarios de windows quieren el fichero ".msi").
-2. Durante el proceso de insatalación, puede que se te pida instalar Microsoft Visual Studio Build Tools. Un enlace
-   este programa se muestra durante la proceso, y debe ser ejecutado manualmente.
+2. Durante el proceso de insatalación, puede que se te pida instalar Microsoft Visual Studio Build Tools. Un enlace este
+   programa se muestra durante la proceso, y debe ser ejecutado manualmente.
 
 ### Activar auto-tracking
-1. Con OpenTracker ejecutado, haz click en el menu Tracking en la parte superior de la ventana, y elige **AutoTracker...**
+
+1. Con OpenTracker ejecutado, haz click en el menu Tracking en la parte superior de la ventana, y elige **
+   AutoTracker...**
 2. Click the **Get Devices** button
 3. Selecciona tu "SNES device" de la lista
-4. Si quieres que las llaves y los objetos de mazmorra tambien sean marcados, activa la caja con nombre **Race Illegal Tracking**
+4. Si quieres que las llaves y los objetos de mazmorra tambien sean marcados, activa la caja con nombre **Race Illegal
+   Tracking**
 5. Haz click en el boton **Start Autotracking**
-6. Cierra la ventana AutoTracker, ya que deja de ser necesaria
+6. Cierra la ventana AutoTracker, ya que deja de ser necesaria

WebHostLib/static/assets/tutorial/A Link to the Past/multiworld_fr.md

@@ -7,102 +7,126 @@
 </div>
 
 ## Logiciels requis
+
 - [Archipelago](https://github.com/ArchipelagoMW/Archipelago/releases)
 - [QUsb2Snes](https://github.com/Skarsnik/QUsb2snes/releases) (Inclus dans les utilitaires précédents)
 - Une solution logicielle ou matérielle capable de charger et de lancer des fichiers ROM de SNES
     - Un émulateur capable d'éxécuter des scripts Lua
       ([snes9x Multitroid](https://drive.google.com/drive/folders/1_ej-pwWtCAHYXIrvs5Hro16A1s9Hi3Jz),
       [BizHawk](http://tasvideos.org/BizHawk.html))
-    - Un SD2SNES, [FXPak Pro](https://krikzz.com/store/home/54-fxpak-pro.html), ou une autre solution matérielle compatible
+    - Un SD2SNES, [FXPak Pro](https://krikzz.com/store/home/54-fxpak-pro.html), ou une autre solution matérielle
+      compatible
 - Le fichier ROM de la v1.0 japonaise, sûrement nommé `Zelda no Densetsu - Kamigami no Triforce (Japan).sfc`
 
 ## Procédure d'installation
 
 ### Installation sur Windows
-1. Téléchargez et installez les utilitaires du MultiWorld à l'aide du lien au-dessus, faites attention à bien installer la version la plus récente.
-**Le fichier se situe dans la section "assets" en bas des informations de version**. Si vous voulez jouer des parties classiques de multiworld,
-téléchargez `Setup.BerserkerMultiWorld.exe`
-    - Si vous voulez jouer à la version alternative avec le mélangeur de portes dans les donjons, vous téléchargez le fichier
-	`Setup.BerserkerMultiWorld.Doors.exe`.
-    - Durant le processus d'installation, il vous sera demandé de localiser votre ROM v1.0 japonaise. Si vous avez déjà installé le logiciel
-	auparavant et qu'il s'agit simplement d'une mise à jour, la localisation de la ROM originale ne sera pas requise.
-    - Il vous sera peut-être également demandé d'installer Microsoft Visual C++. Si vous le possédez déjà (possiblement parce qu'un
-	jeu Steam l'a déjà installé), l'installateur ne reproposera pas de l'installer.
 
-2. Si vous utilisez un émulateur, il est recommandé d'assigner votre émulateur capable d'éxécuter des scripts Lua comme programme
-par défaut pour ouvrir vos ROMs.
-    1. Extrayez votre dossier d'émulateur sur votre Bureau, ou à un endroit dont vous vous souviendrez. 
+1. Téléchargez et installez les utilitaires du MultiWorld à l'aide du lien au-dessus, faites attention à bien installer
+   la version la plus récente.
+   **Le fichier se situe dans la section "assets" en bas des informations de version**. Si vous voulez jouer des parties
+   classiques de multiworld, téléchargez `Setup.BerserkerMultiWorld.exe`
+    - Si vous voulez jouer à la version alternative avec le mélangeur de portes dans les donjons, vous téléchargez le
+      fichier
+      `Setup.BerserkerMultiWorld.Doors.exe`.
+    - Durant le processus d'installation, il vous sera demandé de localiser votre ROM v1.0 japonaise. Si vous avez déjà
+      installé le logiciel auparavant et qu'il s'agit simplement d'une mise à jour, la localisation de la ROM originale
+      ne sera pas requise.
+    - Il vous sera peut-être également demandé d'installer Microsoft Visual C++. Si vous le possédez déjà (possiblement
+      parce qu'un jeu Steam l'a déjà installé), l'installateur ne reproposera pas de l'installer.
+
+2. Si vous utilisez un émulateur, il est recommandé d'assigner votre émulateur capable d'éxécuter des scripts Lua comme
+   programme par défaut pour ouvrir vos ROMs.
+    1. Extrayez votre dossier d'émulateur sur votre Bureau, ou à un endroit dont vous vous souviendrez.
     2. Faites un clic droit sur un fichier ROM et sélectionnez **Ouvrir avec...**
     3. Cochez la case à côté de **Toujours utiliser cette application pour ouvrir les fichiers .sfc**
     4. Descendez jusqu'en bas de la liste et sélectionnez **Rechercher une autre application sur ce PC**
-    5. Naviguez dans les dossiers jusqu'au fichier `.exe` de votre émulateur et choisissez **Ouvrir**. Ce fichier devrait
-	se trouver dans le dossier que vous avez extrait à la première étape.
+    5. Naviguez dans les dossiers jusqu'au fichier `.exe` de votre émulateur et choisissez **Ouvrir**. Ce fichier
+       devrait se trouver dans le dossier que vous avez extrait à la première étape.
 
 ### Installation sur Mac
-- Des volontaires sont recherchés pour remplir cette section ! Contactez **Farrak Kilhn** sur Discord si vous voulez aider.
+
+- Des volontaires sont recherchés pour remplir cette section ! Contactez **Farrak Kilhn** sur Discord si vous voulez
+  aider.
 
 ## Configurer son fichier YAML
 
 ### Qu'est-ce qu'un fichier YAML et pourquoi en ai-je besoin ?
-Votre fichier YAML contient un ensemble d'options de configuration qui fournissent au générateur des informations
-sur comment il devrait générer votre seed. Chaque joueur d'un multiwolrd devra fournir son propre fichier YAML. Cela permet à chaque 
-joueur d'apprécier une expérience customisée selon ses goûts, et les différents joueurs d'un même multiworld peuvent avoir différentes options.
+
+Votre fichier YAML contient un ensemble d'options de configuration qui fournissent au générateur des informations sur
+comment il devrait générer votre seed. Chaque joueur d'un multiwolrd devra fournir son propre fichier YAML. Cela permet
+à chaque joueur d'apprécier une expérience customisée selon ses goûts, et les différents joueurs d'un même multiworld
+peuvent avoir différentes options.
 
 ### Où est-ce que j'obtiens un fichier YAML ?
-La page [Génération de partie](/games/A%20Link%20to%20the%20Past/player-settings) vous permet de configurer vos paramètres personnels et de les exporter vers un fichier YAML.
+
+La page [Génération de partie](/games/A%20Link%20to%20the%20Past/player-settings) vous permet de configurer vos
+paramètres personnels et de les exporter vers un fichier YAML.
 
 ### Configuration avancée du fichier YAML
-Une version plus avancée du fichier YAML peut être créée en utilisant la page des [paramètres de pondération](/weighted-settings), qui vous permet
-de configurer jusqu'à trois préréglages. Cette page a de nombreuses options qui sont essentiellement représentées avec des curseurs glissants.
-Cela vous permet de choisir quelles sont les chances qu'une certaine option apparaisse par rapport aux autres disponibles dans une même catégorie.
+
+Une version plus avancée du fichier YAML peut être créée en utilisant la page
+des [paramètres de pondération](/weighted-settings), qui vous permet de configurer jusqu'à trois préréglages. Cette page
+a de nombreuses options qui sont essentiellement représentées avec des curseurs glissants. Cela vous permet de choisir
+quelles sont les chances qu'une certaine option apparaisse par rapport aux autres disponibles dans une même catégorie.
 
 Par exemple, imaginez que le générateur crée un seau étiqueté "Mélange des cartes", et qu'il place un morceau de papier
 pour chaque sous-option. Imaginez également que la valeur pour "On" est 20 et la valeur pour "Off" est 40.
 
-Dans cet exemple, il y a soixante morceaux de papier dans le seau : vingt pour "On" et quarante pour "Off". Quand le générateur
-décide s'il doit oui ou non activer le mélange des cartes pour votre partie, , il tire aléatoirement un papier dans le seau. 
-Dans cet exemple, il y a de plus grandes chances d'avoir le mélange de cartes désactivé.
+Dans cet exemple, il y a soixante morceaux de papier dans le seau : vingt pour "On" et quarante pour "Off". Quand le
+générateur décide s'il doit oui ou non activer le mélange des cartes pour votre partie, , il tire aléatoirement un
+papier dans le seau. Dans cet exemple, il y a de plus grandes chances d'avoir le mélange de cartes désactivé.
 
-S'il y a une option dont vous ne voulez jamais, mettez simplement sa valeur à zéro. N'oubliez pas qu'il faut que pour chaque paramètre il faut
-au moins une option qui soit paramétrée sur un nombre strictement positif.
+S'il y a une option dont vous ne voulez jamais, mettez simplement sa valeur à zéro. N'oubliez pas qu'il faut que pour
+chaque paramètre il faut au moins une option qui soit paramétrée sur un nombre strictement positif.
 
 ### Vérifier son fichier YAML
+
 Si vous voulez valider votre fichier YAML pour être sûr qu'il fonctionne, vous pouvez le vérifier sur la page du
 [Validateur de YAML](/mysterycheck).
 
 ## Générer une partie pour un joueur
-1. Aller sur la page [Génération de partie](/games/A%20Link%20to%20the%20Past/player-settings), configurez vos options, et cliquez sur le bouton "Generate Game".
+
+1. Aller sur la page [Génération de partie](/games/A%20Link%20to%20the%20Past/player-settings), configurez vos options,
+   et cliquez sur le bouton "Generate Game".
 2. Il vous sera alors présenté une page d'informations sur la seed, où vous pourrez télécharger votre patch.
 3. Double-cliquez sur le patch et l'émulateur devrait se lancer automatiquement avec la seed. Etant donné que le client
-n'est pas requis pour les parties à un joueur, vous pouvez le fermer ainsi que l'interface Web (WebUI).
+   n'est pas requis pour les parties à un joueur, vous pouvez le fermer ainsi que l'interface Web (WebUI).
 
 ## Rejoindre un MultiWorld
 
 ### Obtenir son patch et créer sa ROM
-Quand vous rejoignez un multiworld, il vous sera demandé de fournir votre fichier YAML à celui qui héberge la partie
-ou s'occupe de la génération. Une fois cela fait, l'hôte vous fournira soit un lien pour télécharger votre patch, soit un fichier `.zip` contenant
-les patchs de tous les joueurs. Votre patch devrait avoir l'extension `.bmbp`.
 
-Placez votre patch sur votre bureau ou dans un dossier simple d'accès, et double-cliquez dessus. Cela devrait lancer automatiquement
-le client, et devrait créer la ROM dans le même dossier que votre patch.
+Quand vous rejoignez un multiworld, il vous sera demandé de fournir votre fichier YAML à celui qui héberge la partie ou
+s'occupe de la génération. Une fois cela fait, l'hôte vous fournira soit un lien pour télécharger votre patch, soit un
+fichier `.zip` contenant les patchs de tous les joueurs. Votre patch devrait avoir l'extension `.bmbp`.
+
+Placez votre patch sur votre bureau ou dans un dossier simple d'accès, et double-cliquez dessus. Cela devrait lancer
+automatiquement le client, et devrait créer la ROM dans le même dossier que votre patch.
 
 ### Se connecter au client
 
 #### Avec un émulateur
-Quand le client se lance automatiquement, QUsb2Snes devrait se lancer automatiquement également en arrière-plan.
-Si c'est la première fois qu'il démarre, il vous sera peut-être demandé de l'autoriser à communiquer
-à travers le pare-feu Windows.
+
+Quand le client se lance automatiquement, QUsb2Snes devrait se lancer automatiquement également en arrière-plan. Si
+c'est la première fois qu'il démarre, il vous sera peut-être demandé de l'autoriser à communiquer à travers le pare-feu
+Windows.
 
 ##### snes9x Multitroid
+
 1. Chargez votre ROM si ce n'est pas déjà fait.
 2. Cliquez sur le menu "File" et survolez l'option **Lua Scripting**
 3. Cliquez alors sur **New Lua Script Window...**
 4. Dans la nouvelle fenêtre, sélectionnez **Browse...**
-5. Dirigez vous vers le dossier où vous avez extrait snes9x Multitroid, allez dans le dossier `lua`, puis choisissez `multibridge.lua`
-6. Remarquez qu'un nom vous a été assigné, et que l'interface Web affiche "SNES Device: Connected", avec ce même nom dans le coin en haut à gauche.
+5. Dirigez vous vers le dossier où vous avez extrait snes9x Multitroid, allez dans le dossier `lua`, puis
+   choisissez `multibridge.lua`
+6. Remarquez qu'un nom vous a été assigné, et que l'interface Web affiche "SNES Device: Connected", avec ce même nom
+   dans le coin en haut à gauche.
 
 ##### BizHawk
-1. Assurez vous d'avoir le coeur BSNES chargé. Cela est possible en cliquant sur le menu "Tools" de BizHawk et suivant ces options de menu :
+
+1. Assurez vous d'avoir le coeur BSNES chargé. Cela est possible en cliquant sur le menu "Tools" de BizHawk et suivant
+   ces options de menu :
    `Config --> Cores --> SNES --> BSNES`  
    Une fois le coeur changé, vous devez redémarrer BizHawk.
 2. Chargez votre ROM si ce n'est pas déjà fait.
@@ -111,11 +135,13 @@ Si c'est la première fois qu'il démarre, il vous sera peut-être demandé de l
 5. Dirigez vous vers le dossier d'installation des utilitaires du MultiWorld, puis dans les dossiers suivants :  
    `QUsb2Snes/Qusb2Snes/LuaBridge`
 6. Sélectionnez `luabridge.lua` et cliquez sur "Open".
-7. Remarquez qu'un nom vous a été assigné, et que l'interface Web affiche "SNES Device: Connected", avec ce même nom dans le coin en haut à gauche.
+7. Remarquez qu'un nom vous a été assigné, et que l'interface Web affiche "SNES Device: Connected", avec ce même nom
+   dans le coin en haut à gauche.
 
 #### Avec une solution matérielle
-Ce guide suppose que vous avez télchargé le bon micro-logiciel pour votre appareil. Si ce n'est pas déjà le cas, faites le maintenant.
-Les utilisateurs de SD2SNES et de FXPak Pro peuvent télécharger le micro-logiciel approprié 
+
+Ce guide suppose que vous avez télchargé le bon micro-logiciel pour votre appareil. Si ce n'est pas déjà le cas, faites
+le maintenant. Les utilisateurs de SD2SNES et de FXPak Pro peuvent télécharger le micro-logiciel approprié
 [ici](https://github.com/RedGuyyyy/sd2snes/releases). Pour les autres solutions, de l'aide peut être trouvée
 [sur cette page](http://usb2snes.com/#supported-platforms).
 
@@ -126,20 +152,24 @@ Les utilisateurs de SD2SNES et de FXPak Pro peuvent télécharger le micro-logic
 5. Remarquez que l'interface Web affiche "SNES Device: Connected", avec le nom de votre appareil.
 
 ### Se connecter au MultiServer
-Le patch qui a lancé le client devrait vous avoir connecté automatiquement au MultiServer.
-Il y a cependant quelques cas où cela peut ne pas se produire, notamment si le multiworld est hébergé sur ce site, mais a été généré ailleurs.
-Si l'interface Web affiche "Server Status: Not Connected", demandez simplement à l'hôte l'adresse du serveur,
-et copiez/collez la dans le champ "Server" puis appuyez sur Entrée.
 
-Le client essaiera de vous reconnecter à la nouvelle adresse du serveur, et devrait mentionner "Server
-Status: Connected". Si le client ne se connecte pas après quelques instants, il faudra peut-être rafraîchir la page de l'interface Web.
+Le patch qui a lancé le client devrait vous avoir connecté automatiquement au MultiServer. Il y a cependant quelques cas
+où cela peut ne pas se produire, notamment si le multiworld est hébergé sur ce site, mais a été généré ailleurs. Si
+l'interface Web affiche "Server Status: Not Connected", demandez simplement à l'hôte l'adresse du serveur, et
+copiez/collez la dans le champ "Server" puis appuyez sur Entrée.
+
+Le client essaiera de vous reconnecter à la nouvelle adresse du serveur, et devrait mentionner "Server Status:
+Connected". Si le client ne se connecte pas après quelques instants, il faudra peut-être rafraîchir la page de
+l'interface Web.
 
 ### Jouer au jeu
+
 Une fois que l'interface Web affiche que la SNES et le serveur sont connectés, vous êtes prêt à jouer. Félicitations
 pour avoir rejoint un multiworld !
 
 ## Héberger un MultiWorld
-La méthode recommandée pour héberger une partie est d'utiliser le service d'hébergement fourni par 
+
+La méthode recommandée pour héberger une partie est d'utiliser le service d'hébergement fourni par
 [le site](https://berserkermulti.world/generate). Le processus est relativement simple :
 
 1. Récupérez les fichiers YAML des joueurs.
@@ -147,26 +177,32 @@ La méthode recommandée pour héberger une partie est d'utiliser le service d'h
 3. Téléversez l'archive zip sur le lien ci-dessus.
 4. Attendez un moment que les seed soient générées.
 5. Lorsque les seeds sont générées, vous serez redirigé vers une page d'informations "Seed Info".
-6. Cliquez sur "Create New Room". Cela vous amènera à la page du serveur. Fournissez le lien de cette page aux autres joueurs
-   afin qu'ils puissent récupérer leurs patchs.  
+6. Cliquez sur "Create New Room". Cela vous amènera à la page du serveur. Fournissez le lien de cette page aux autres
+   joueurs afin qu'ils puissent récupérer leurs patchs.  
    **Note:** Les patchs fournis sur cette page permettront aux joueurs de se connecteur automatiquement au serveur,
    tandis que ceux de la page "Seed Info" non.
-7. Remarquez qu'un lien vers le traqueur du MultiWorld est en haut de la page de la salle. Vous devriez également fournir ce lien aux joueurs
-   pour qu'ils puissent suivre la progression de la partie. N'importe quel personne voulant observer devrait avoir accès à ce lien.
+7. Remarquez qu'un lien vers le traqueur du MultiWorld est en haut de la page de la salle. Vous devriez également
+   fournir ce lien aux joueurs pour qu'ils puissent suivre la progression de la partie. N'importe quel personne voulant
+   observer devrait avoir accès à ce lien.
 8. Une fois que tous les joueurs ont rejoint, vous pouvez commencer à jouer.
 
 ## Auto-tracking
+
 Si vous voulez utiliser l'auto-tracking, plusieurs logiciels offrent cette possibilité.  
 Le logiciel recommandé pour l'auto-tracking actuellement est
 [OpenTracker](https://github.com/trippsc2/OpenTracker/releases).
 
 ### Installation
-1. Téléchargez le fichier d'installation approprié pour votre ordinateur (Les utilisateurs Windows voudront le fichier `.msi`).
-2. Durant le processus d'installation, il vous sera peut-être demandé d'installer les outils "Microsoft Visual Studio Build Tools". Un
-lien est fourni durant l'installation d'OpenTracker, et celle des outils doit se faire manuellement.
-   
+
+1. Téléchargez le fichier d'installation approprié pour votre ordinateur (Les utilisateurs Windows voudront le
+   fichier `.msi`).
+2. Durant le processus d'installation, il vous sera peut-être demandé d'installer les outils "Microsoft Visual Studio
+   Build Tools". Un lien est fourni durant l'installation d'OpenTracker, et celle des outils doit se faire manuellement.
+
 ### Activer l'auto-tracking
-1. Une fois OpenTracker démarré, cliquez sur le menu "Tracking" en haut de la fenêtre, puis choisissez **AutoTracker...**
+
+1. Une fois OpenTracker démarré, cliquez sur le menu "Tracking" en haut de la fenêtre, puis choisissez **
+   AutoTracker...**
 2. Appuyez sur le bouton **Get Devices**
 3. Sélectionnez votre appareil SNES dans la liste déroulante.
 4. Si vous voulez tracquer les petites clés ainsi que les objets des donjons, cochez la case **Race Illegal Tracking**

WebHostLib/static/assets/tutorial/A Link to the Past/plando_en.md

@@ -1,25 +1,24 @@
 # A Link to the Past Randomizer Plando Guide
 
 ## Configuration
+
 1. Plando features have to be enabled first, before they can be used (opt-in).
-2. To do so, go to your installation directory (Windows default: `C:\ProgramData\Archipelago`), 
-   then open the host.yaml file with a text editor.
-3. In it, you're looking for the option key `plando_options`. To enable all plando modules you can set the
-   value to  
-   `bosses, items, texts, connections`
+2. To do so, go to your installation directory (Windows default: `C:\ProgramData\Archipelago`), then open the host.yaml
+   file with a text editor.
+3. In it, you're looking for the option key `plando_options`. To enable all plando modules you can set the value
+   to `bosses, items, texts, connections`
 
 ## Modules
 
 ### Bosses
 
-- This module is enabled by default and available to be used on 
-  [https://archipelago.gg/generate](/generate)
+- This module is enabled by default and available to be used on [https://archipelago.gg/generate](/generate)
 - Plando versions of boss shuffles can be added like any other boss shuffle option in a yaml and weighted.
-- Boss Plando works as a list of instructions from left to right, if any arenas are empty at the end, 
-  it defaults to vanilla
-- Instructions are separated by a semicolon
+- Boss Plando works as a list of instructions from left to right, if any arenas are empty at the end, it defaults to
+  vanilla.
+- Instructions are separated by a semicolon.
 - Available Instructions:
-    -  Direct Placement:
+    - Direct Placement:
         - Example: `Eastern Palace-Trinexx`
         - Takes a particular Arena and particular boss, then places that boss into that arena
         - Ganons Tower has 3 placements, `Ganons Tower Top`, `Ganons Tower Middle` and `Ganons Tower Bottom`
@@ -29,12 +28,13 @@
         - In this example, it would fill Desert Palace, but not Tower of Hera.
     - Boss Shuffle:
         - Example: `simple`
-          - Runs a particular boss shuffle mode to finish construction instead of vanilla placement, typically used as
-            a last instruction.
+            - Runs a particular boss shuffle mode to finish construction instead of vanilla placement, typically used as
+              a last instruction.
 - [Available Bosses](https://github.com/ArchipelagoMW/Archipelago/blob/main/worlds/alttp/Bosses.py#L135)
 - [Available Arenas](https://github.com/ArchipelagoMW/Archipelago/blob/main/worlds/alttp/Bosses.py#L150)
 
 #### Examples
+
 ```yaml
 boss_shuffle:
   Turtle Rock-Trinexx;basic: 1
@@ -42,14 +42,15 @@ boss_shuffle:
   Mothula: 3
   Ganons Tower Bottom-Kholdstare;Trinexx;Kholdstare: 4
 ```
-1. Would be basic boss shuffle but prevent Trinexx from appearing outside of Turtle Rock, 
-   as there's only one Trinexx in the pool
+
+1. Would be basic boss shuffle but prevent Trinexx from appearing outside of Turtle Rock, as there's only one Trinexx in
+   the pool
 2. Regular full boss shuffle. With a 2 in 10 chance to occur.
 3. A Mothula Singularity, as Mothula works in any arena.
 4. A Trinexx -> Kholdstare Singularity that prevents ice Trinexx in GT
 
-
 ### Items
+
 - This module is disabled by default.
 - Has the options from_pool, world, percentage, force and either item and location or items and locations
 - All of these options support subweights
@@ -77,12 +78,13 @@ boss_shuffle:
     - items denotes the items to use, can be given a number to have multiple of that item
     - locations lists the possible locations those items can be placed in
     - placements are picked randomly, not sorted in any way
-- Warning: Placing non-Dungeon Prizes on Prize locations and 
-  Prizes on non-Prize locations will break the game in various ways.
+- Warning: Placing non-Dungeon Prizes on Prize locations and Prizes on non-Prize locations will break the game in
+  various ways.
 - [Available Items](https://github.com/ArchipelagoMW/Archipelago/blob/main/worlds/alttp/Items.py#L52)
 - [Available Locations](https://github.com/ArchipelagoMW/Archipelago/blob/main/worlds/alttp/Regions.py#L434)
 
 #### Examples
+
 ```yaml
 plando_items:
   - item: # 1
@@ -119,26 +121,28 @@ plando_items:
     from_pool: true
 ```
 
-1. has a 50% chance to occur, which if it does places either the Lamp or Fire Rod in one's own 
-Link's House and removes the picked item from the item pool.
+1. has a 50% chance to occur, which if it does places either the Lamp or Fire Rod in one's own Link's House and removes
+   the picked item from the item pool.
 2. Always triggers and places the Swords and Bows into one's own Big Chests
 3. Locks Pendants to The Light World and therefore Crystals to dark world
 
 ### Texts
+
 - This module is disabled by default.
 - Has the options `text`, `at`, and `percentage`
 - percentage is the percentage chance for this text to be placed, can be omitted entirely for 100%
 - text is the text to be placed.
     - can be weighted.
-    - `\n` is a newline. 
+    - `\n` is a newline.
     - `@` is the entered player's name.
     - Warning: Text Mapper does not support full unicode.
     - [Alphabet](https://github.com/ArchipelagoMW/Archipelago/blob/main/worlds/alttp/Text.py#L758)
 - at is the location within the game to attach the text to.
     - can be weighted.
     - [List of targets](https://github.com/ArchipelagoMW/Archipelago/blob/main/worlds/alttp/Text.py#L1499)
-   
+
 #### Example
+
 ```yaml
 plando_texts:
   - text: "This is a plando.\nYou've been warned."
@@ -147,11 +151,13 @@ plando_texts:
       uncle_dying_sewer: 1
     percentage: 50
 ```
-![Uncle Example](https://cdn.discordapp.com/attachments/731214280439103580/794953870903083058/unknown.png)
-This has a 50% chance to trigger at all. If it does, it throws a coin between `uncle_leaving_text` and
-`uncle_dying_sewer`, then places the text "This is a plando. You've been warned." at that location.
+
+![Example plando text at Uncle](https://cdn.discordapp.com/attachments/731214280439103580/794953870903083058/unknown.png)
+This has a 50% chance to trigger at all. If it does, it throws a coin between `uncle_leaving_text`
+and `uncle_dying_sewer`, then places the text "This is a plando. You've been warned." at that location.
 
 ### Connections
+
 - This module is disabled by default.
 - Has the options `percentage`, `entrance`, `exit` and `direction`.
 - All options support subweights
@@ -160,10 +166,11 @@ This has a 50% chance to trigger at all. If it does, it throws a coin between `u
 - entrance is the overworld door
 - exit is the underworld exit
 - direction can be `both`, `entrance` or `exit`
-- doors can be found in [this file](https://github.com/ArchipelagoMW/Archipelago/blob/main/worlds/alttp/EntranceShuffle.py#L3852)
-
+- doors can be found
+  in [this file](https://github.com/ArchipelagoMW/Archipelago/blob/main/worlds/alttp/EntranceShuffle.py#L3852)
 
 #### Example
+
 ```yaml
 plando_connections:
   - entrance: Links House
@@ -174,8 +181,8 @@ plando_connections:
     direction: both
 ```
 
-The first block connects the overworld entrance that normally leads to Link's House
-to put you into the HC West Wing instead, exiting from within there will put you at the Overworld exiting Link's House.
+The first block connects the overworld entrance that normally leads to Link's House to put you into the HC West Wing
+instead, exiting from within there will put you at the Overworld exiting Link's House.
 
-Without the second block, you'd still exit from within Link's House to outside Link's House and the left side 
-Balcony Entrance would still lead into HC West Wing
+Without the second block, you'd still exit from within Link's House to outside Link's House and the left side Balcony
+Entrance would still lead into HC West Wing

WebHostLib/static/assets/tutorial/ArchipIDLE/guide_en.md

@@ -0,0 +1,12 @@
+# ArchipIdle Setup Guide
+
+## Joining a MultiWorld Game
+1. Generate a `.yaml` file from the [ArchipIDLE Player Settings Page](/games/ArchipIDLE/player-settings)
+2. Open the ArchipIDLE Client in your web browser by either:
+    - Navigate to the [ArchipIDLE Client](http://idle.multiworld.link)
+    - Download the client and run it locally from the
+      [ArchipIDLE GitHub Releases Page](https://github.com/ArchipelagoMW/archipidle/releases)
+3. Enter the server address in the `Server Address` field and press enter
+4. Enter your slot name when prompted. This should be the same as the `name` you entered on the
+   setting page above, or the `name` field in your yaml file.
+5. Click the "Begin!" button.

WebHostLib/static/assets/tutorial/Archipelago/advanced_settings_en.md

@@ -0,0 +1,221 @@
+# Advanced YAML Guide
+
+This guide covers more the more advanced options available in YAML files. This guide is intended for the user who is intent on editing their YAML file manually. This guide should take about 10 minutes to read.
+
+If you would like to generate a basic, fully playable, YAML without editing a file then visit the settings page for the game you intend to play. The weighted settings page can also handle most of the advanced settings discussed here.
+
+The settings page can be found on the supported games page, just click the "Settings Page" link under the name of the game you would like. 
+* Supported games page: [Archipelago Games List](/games)
+* Weighted settings page: [Archipelago Weighted Settings](/weighted-settings)
+
+Clicking on the "Export Settings" button at the bottom-left will provide you with a pre-filled YAML with your options.
+The player settings page also has a link to download a full template file for that game which will have every option possible for the game including some that don't display correctly on the site.
+
+## YAML Overview
+
+The Archipelago system generates games using player configuration files as input. These are going to be YAML files and
+each world will have one of these containing their custom settings for the game that world will play.
+
+## YAML Formatting
+
+YAML files are a format of human-readable config files. The basic syntax of a yaml file will have a `root` node and then
+different levels of `nested` nodes that the generator reads in order to determine your settings.
+
+To nest text, the correct syntax is to indent **two spaces over** from its root option. A YAML file can be edited with
+whatever text editor you choose to use though I personally recommend that you use Sublime Text. Sublime text
+website: [SublimeText Website](https://www.sublimetext.com)
+
+This program out of the box supports the correct formatting for the YAML file, so you will be able to use the tab key
+and get proper highlighting for any potential errors made while editing the file. If using any other text editor you
+should ensure your indentation is done correctly with two spaces.
+
+A typical YAML file will look like:
+
+```yaml
+root_option:
+  nested_option_one:
+    option_one_setting_one: 1
+    option_one_setting_two: 0
+  nested_option_two:
+    option_two_setting_one: 14
+    option_two_setting_two: 43
+```
+
+In Archipelago, YAML options are always written out in full lowercase with underscores separating any words. The numbers
+following the colons here are weights. The generator will read the weight of every option the roll that option that many
+times, the next option as many times as its numbered and so forth.
+
+For the above example `nested_option_one` will have `option_one_setting_one` 1 time and `option_one_setting_two` 0 times
+so `option_one_setting_one` is guaranteed to occur.
+
+For `nested_option_two`, `option_two_setting_one` will be rolled 14 times and `option_two_setting_two` will be rolled 43
+times against each other. This means `option_two_setting_two` will be more likely to occur, but it isn't guaranteed,
+adding more randomness and "mystery" to your settings. Every configurable setting supports weights.
+
+### Root Options
+
+Currently, there are only a few options that are root options. Everything else should be nested within one of these root
+options or in some cases nested within other nested options. The only options that should exist in root
+are `description`, `name`, `game`, `requires`, `accessibility`, `progression_balancing`, `triggers`, and the name of the
+games you want settings for.
+
+* `description` is ignored by the generator and is simply a good way for you to organize if you have multiple files
+  using this to detail the intention of the file.
+
+* `name` is the player name you would like to use and is used for your slot data to connect with most games. This can
+  also be filled with multiple names each having a weight to it.
+
+* `game` is where either your chosen game goes or if you would like can be filled with multiple games each with
+  different weights.
+
+* `requires` details different requirements from the generator for the YAML to work as you expect it to. Generally this
+  is good for detailing the version of Archipelago this YAML was prepared for as if it is rolled on an older version may
+  be missing settings and as such will not work as expected. If any plando is used in the file then requiring it here to
+  ensure it will be used is good practice.
+
+* `accessibility` determines the level of access to the game the generation will expect you to have in order to reach
+  your completion goal. This supports `items`, `locations`, and `none` and is set to `locations` by default.
+    * `locations` will guarantee all locations are accessible in your world.
+    * `items` will guarantee you can acquire all items in your world but may not be able to access all locations. This
+      mostly comes into play if there is any entrance shuffle in the seed as locations without items in them can be
+      placed in areas that make them unreachable.
+    * `none` will only guarantee that the seed is beatable. You will be guaranteed able to finish the seed logically but
+      may not be able to access all locations or acquire all items. A good example of this is having a big key in the
+      big chest in a dungeon in ALTTP making it impossible to get and finish the dungeon.
+
+* `progression_balancing` is a system the Archipelago generator uses to try and reduce "BK mode" as much as possible.
+  This primarily involves moving necessary progression items into earlier logic spheres to make the games more
+  accessible so that players almost always have something to do. This can be turned `on` or `off` and is `on` by
+  default.
+
+    * `triggers` is one of the more advanced options that allows you to create conditional adjustments. You can read
+      more triggers in the triggers guide. Triggers
+      guide: [Archipelago Triggers Guide](/tutorial/archipelago/triggers/en)
+
+### Game Options
+
+One of your root settings will be the name of the game you would like to populate with settings. Since it is possible to
+give a weight to any option it is possible to have one file that can generate a seed for you where you don't know which
+game you'll play. For these cases you'll want to fill the game options for every game that can be rolled by these
+settings. If a game can be rolled it **must** have a settings section even if it is empty.
+
+#### Universal Game Options
+
+Some options in Archipelago can be used by every game but must still be placed within the relevant game's section.
+
+Currently, these options are `start_inventory`, `start_hints`, `local_items`, `non_local_items`, `start_location_hints`
+, `exclude_locations`, and various plando options.
+
+See the plando guide for more info on plando options. Plando
+guide: [Archipelago Plando Guide](/tutorial/archipelago/plando/en)
+
+* `start_inventory` will give any items defined here to you at the beginning of your game. The format for this must be
+  the name as it appears in the game files and the amount you would like to start with. For example `Rupees(5): 6` which
+  will give you 30 rupees.
+* `start_hints` gives you free server hints for the defined item/s at the beginning of the game allowing you to hint for
+  the location without using any hint points.
+* `local_items` will force any items you want to be in your world instead of being in another world.
+* `non_local_items` is the inverse of `local_items` forcing any items you want to be in another world and won't be
+  located in your own.
+* `start_location_hints` allows you to define a location which you can then hint for to find out what item is located in
+  it to see how important the location is.
+
+* `exclude_locations` lets you define any locations that you don't want to do and during generation will force a "junk"
+  item which isn't necessary for progression to go in these locations.
+
+### Random numbers
+
+Options taking a choice of a number can also use a variety of `random` options to choose a number randomly.
+
+* `random` will choose a number allowed for the setting at random
+* `random-low` will choose a number allowed for the setting at random, but will be weighted towards lower numbers
+* `random-middle` will choose a number allowed for the setting at random, but will be weighted towards the middle of the
+  range
+* `random-high` will choose a number allowed for the setting at random, but will be weighted towards higher numbers
+* `random-range-#-#` will choose a number at random from between the specified numbers. For example `random-range-40-60`
+  will choose a number between 40 and 60
+* `random-range-low-#-#`, `random-range-middle-#-#`, and `random-range-high-#-#` will choose a number at random from the
+  specified numbers, but with the specified weights
+
+### Example
+
+```yaml
+
+description: An example using various advanced options
+name: Example Player
+game: A Link to the Past
+requires: 
+  version: 0.2.0
+accessibility: none
+progression_balancing: on
+A Link to the Past:
+  smallkey_shuffle:
+    original_dungeon: 1
+    any_world: 1
+  crystals_needed_for_gt:
+    random-low: 1
+  crystals_needed_for_ganon:
+    random-range-high-1-7: 1
+  start_inventory:
+    Pegasus Boots: 1
+    Bombs (3): 2
+  start_hints:
+    - Hammer
+  local_items:
+    - Bombos
+    - Ether
+    - Quake
+  non_local_items:
+    - Moon Pearl
+  start_location_hints:
+    - Spike Cave
+  exclude_locations:
+    - Cave 45
+triggers:
+  - option_category: A Link to the Past
+    option_name: smallkey_shuffle
+    option_result: any_world
+    options:
+      A Link to the Past:
+        bigkey_shuffle: any_world
+        map_shuffle: any_world
+        compass_shuffle: any_world
+```
+
+#### This is a fully functional yaml file that will do all the following things:
+
+* `description` gives us a general overview so if we pull up this file later we can understand the intent.
+* `name` is `Example Player` and this will be used in the server console when sending and receiving items.
+* `game` is set to `A Link to the Past` meaning that is what game we will play with this file.
+* `requires` is set to require release version 0.2.0 or higher.
+* `accesibility` is set to `none` which will set this seed to beatable only meaning some locations and items may be
+  completely inaccessible but the seed will still be completable.
+* `progression_balancing` is set on meaning we will likely receive important items earlier increasing the chance of
+  having things to do.
+* `A Link to the Past` defines a location for us to nest all the game options we would like to use for our
+  game `A Link to the Past`.
+* `smallkey_shuffle` is an option for A Link to the Past which determines how dungeon small keys are shuffled. In this
+  example we have a 1/2 chance for them to either be placed in their original dungeon and a 1/2 chance for them to be
+  placed anywhere amongst the multiworld.
+* `crystals_needed_for_gt` determines the number of crystals required to enter the Ganon's Tower entrance. In this
+  example a random number will be chosen from the allowed range for this setting (0 through 7) but will be weighted
+  towards a lower number.
+* `crystals_needed_for_ganon` determines the number of crystals required to beat Ganon. In this example a number between
+  1 and 7 will be chosen at random, weighted towards a high number.
+* `start_inventory` defines an area for us to determine what items we would like to start the seed with. For this
+  example we have:
+    * `Pegasus Boots: 1` which gives us 1 copy of the Pegasus Boots
+    * `Bombs (3)` gives us 2 packs of 3 bombs or 6 total bombs
+* `start_hints` gives us a starting hint for the hammer available at the beginning of the multiworld which we can use
+  with no cost.
+* `local_items` forces the `Bombos`, `Ether`, and `Quake` medallions to all be placed within our own world, meaning we
+  have to find it ourselves.
+* `non_local_items` forces the `Moon Pearl` to be placed in someone else's world, meaning we won't be able to find it.
+* `start_location_hints` gives us a starting hint for the `Spike Cave` location available at the beginning of the
+  multiworld that can be used for no cost.
+* `exclude_locations` forces a not important item to be placed on the `Cave 45` location.
+
+* `triggers` allows us to define a trigger such that if our `smallkey_shuffle` option happens to roll the `any_world`
+  result it will also ensure that `bigkey_shuffle`, `map_shuffle`, and `compass_shuffle` are also forced to
+  the `any_world`
+  result.

WebHostLib/static/assets/tutorial/Archipelago/commands_en.md

@@ -0,0 +1,96 @@
+### Helpful Commands
+
+Commands are split into two types: client commands and server commands. Client commands are commands which are executed
+by the client and do not affect the Archipelago remote session. Server commands are commands which are executed by the
+Archipelago server and affect the Archipelago session or otherwise provide feedback from the server.
+
+In clients which have their own commands the commands are typically prepended by a forward slash:`/`. Remote commands
+are always submitted to the server prepended with an exclamation point: `!`.
+
+#### Local Commands
+
+The following list is a list of client commands which may be available to you through your Archipelago client. You
+execute these commands in your client window.
+
+The following commands are available in these clients: SNIClient, FactorioClient, FF1Client.
+
+- `/connect <address:port>` Connect to the multiworld server.
+- `/disconnect` Disconnects you from your current session.
+- `/received` Displays all the items you have found or been sent.
+- `/missing` Displays all the locations along with their current status (checked/missing).
+- `/items` Lists all the item names for the current game.
+- `/locations` Lists all the location names for the current game.
+- `/ready` Sends ready status to the server.
+- `/help` Returns a list of available commands.
+- `/license` Returns the software licensing information.
+- Just typing anything will broadcast a message to all players
+
+##### FF1Client Only
+
+The following command is only available when using the FF1Client for the Final Fantasy Randomizer.
+
+- `/nes` Shows the current status of the NES connection.
+
+##### SNIClient Only
+
+The following command is only available when using the SNIClient for SNES based games.
+
+- `/snes` Attempts to connect to your SNES device via SNI.
+- `/snes_close` Closes the current SNES connection.
+- `/slow_mode` Toggles on or off slow mode, which limits the rate in which you receive items.
+
+##### FactorioClient Only
+
+The following command is only available when using the FactorioClient to play Factorio with Archipelago.
+
+- `/factorio <command text>` Sends the command argument to the Factorio server as a command.
+
+#### Remote Commands
+
+Remote commands may be executed by any client which allows for sending text chat to the Archipelago server. If your
+client does not allow for sending chat then you may connect to your game slot with the TextClient which comes with the
+Archipelago installation. In order to execute the command you need to merely send a text message with the command,
+including the exclamation point.
+
+- `!help` Returns a listing of available remote commands.
+- `!license` Returns the software licensing information.
+- `!countdown <countdown in seconds>` Starts a countdown using the given seconds value. Useful for synchronizing starts.
+  Defaults to 10 seconds if no argument is provided.
+- `!options` Returns the current server options, including password in plaintext.
+- `!admin <command>` Executes a command as if you typed it into the server console. Remote administration must be
+  enabled.
+- `!players` Returns info about the currently connected and non-connected players.
+- `!status` Returns information about your team. (Currently all players as teams are unimplemented.)
+- `!remaining` Lists the items remaining in your game, but not where they are or who they go to.
+- `!missing` Lists the location checks you are missing from the server's perspective.
+- `!checked` Lists all the location checks you've done from the server's perspective.
+- `!alias <alias>` Sets your alias.
+- `!getitem <item>` Cheats an item, if it is enabled in the server.
+- `!hint_location <location>` Hints for a location specifically. Useful in games where item names may match location
+  names such as Factorio.
+- `!hint <item name>` Tells you at which location in whose game your Item is. Note you need to have checked some
+  locations to earn a hint. You can check how many you have by just running `!hint`
+- `!forfeit` If you didn't turn on auto-forfeit or if you allowed forfeiting prior to goal completion. Remember that "
+  forfeiting" actually means sending out your remaining items in your world.
+- `!collect` Grants you all the remaining checks in your world. Can only be used after your goal is complete or when you
+  have forfeited.
+
+#### Host only (on Archipelago.gg or in your server console)
+
+- `/help` Returns a list of commands available in the console.
+- `/license` Returns the software licensing information.
+- `/countdown <seconds>` Starts a countdown which is sent to all players via text chat. Defaults to 10 seconds if no
+  argument is provided.
+- `/options` Lists the server's current options, including password in plaintext.
+- `/save` Saves the state of the current multiworld. Note that the server autosaves on a minute basis.
+- `/players` List currently connected players.
+- `/exit` Shutdown the server
+- `/alias <player name> <alias name>` Assign a player an alias.
+- `/collect <player name>` Send out any items remaining in the multiworld belonging to the given player.
+- `/forfeit <player name>` Forfeits someone regardless of settings and game completion status
+- `/allow_forfeit <player name>` Allows the given player to use the `!forfeit` command.
+- `/forbid_forfeit <player name>` Bars the given player from using the `!forfeit` command.
+- `/send <player name> <item name>` Grants the given player the specified item.
+- `/send_multiple <amount> <player name> <item name>` Grants the given player the stated amount of the specified item.
+- `/hint <player name> <item or location name>` Send out a hint for the given item or location for the specified player.
+- `/option <option name> <option value>` Set a server option. For a list of options, use the `/options` command.

WebHostLib/static/assets/tutorial/Archipelago/plando_en.md

@@ -0,0 +1,215 @@
+# Archipelago Plando Guide
+
+## What is Plando?
+
+The purposes of randomizers is to randomize the items in a game to give a new experience. Plando takes this concept and
+changes it up by allowing you to plan out certain aspects of the game by placing certain items in certain locations,
+certain bosses in certain rooms, edit text for certain NPCs/signs, or even force certain region connections. Each of
+these options are going to be detailed separately as `item plando`, `boss plando`, `text plando`,
+and `connection plando`. Every game in archipelago supports item plando but the other plando options are only supported
+by certain games. Currently, Minecraft and LTTP both support connection plando, but only LTTP supports text and boss
+plando.
+
+### Enabling Plando
+
+On the website plando will already be enabled. If you will be generating the game locally plando features must be
+enabled (opt-in).
+
+* To opt-in go to the archipelago installation (default: `C:\ProgramData\Archipelago`), open the host.yaml with a text
+  editor and find the `plando_options` key. The available plando modules can be enabled by adding them after this such
+  as
+  `plando_options: bosses, items, texts, connections`.
+* You can add the necessary plando modules for your settings to the `requires` section of your yaml. Doing so will throw an error if the options that you need to generate properly are not enabled to ensure you will get the results you desire. Only enter in the plando modules that you are using here but it should look like:
+
+```yaml
+  requires: 
+    version: current.version.number
+    plando: bosses, items, texts, connections
+``` 
+
+## Item Plando
+Item plando allows a player to place an item in a specific location or specific locations, place multiple items into a
+list of specific locations both in their own game or in another player's game.
+
+* The options for item plando are `from_pool`, `world`, `percentage`, `force`, `count`, and either item and location, or items
+  and locations.
+    * `from_pool` determines if the item should be taken *from* the item pool or *added* to it. This can be true or
+      false and defaults to true if omitted.
+    * `world` is the target world to place the item in.
+        * It gets ignored if only one world is generated.
+        * Can be a number, name, true, false, null, or a list. False is the default.
+            * If a number is used it targets that slot or player number in the multiworld.
+            * If a name is used it will target the world with that player name.
+            * If set to true it will be any player's world besides your own.
+            * If set to false it will target your own world.
+            * If set to null it will target a random world in the multiworld.
+            * If a list of names is used, it will target the games with the player names specified.
+    * `force` determines whether the generator will fail if the item can't be placed in the location can be true, false,
+      or silent. Silent is the default.
+        * If set to true the item must be placed and the generator will throw an error if it is unable to do so.
+        * If set to false the generator will log a warning if the placement can't be done but will still generate.
+        * If set to silent and the placement fails it will be ignored entirely.
+    * `percentage` is the percentage chance for the relevant block to trigger. This can be any value from 0 to 100 and
+      if omitted will default to 100.
+    * Single Placement is when you use a plando block to place a single item at a single location.
+        * `item` is the item you would like to place and `location` is the location to place it.
+    * Multi Placement uses a plando block to place multiple items in multiple locations until either list is exhausted.
+        * `items` defines the items to use and a number letting you place multiple of it. You can use true instead of a number to have it use however many of that item are in your item pool.
+        * `locations` is a list of possible locations those items can be placed in.
+        * Using the multi placement method, placements are picked randomly.
+        * Instead of a number, you can use true 
+    * `count` can be used to set the maximum number of items placed from the block. The default is 1 if using `item` and False if using `items`
+        * If a number is used it will try to place this number of items.
+        * If set to false it will try to place as many items from the block as it can.
+        * If `min` and `max` are defined, it will try to place a number of items between these two numbers at random
+
+
+### Available Items and Locations
+
+A list of all available items and locations can be found in the [website's datapackage](/datapackage). The items and locations will be in the `"item_name_to_id"` and `"location_name_to_id"` sections of the relevant game. You do not need the quotes but the name must be entered in the same as it appears on that page and is caps-sensitive.
+
+### Examples
+
+```yaml
+plando_items:
+  # example block 1 - Timespinner
+  - item:
+      Empire Orb: 1
+      Radiant Orb: 1
+    location: Starter Chest 1
+    from_pool: true
+    world: true
+    percentage: 50
+
+  # example block 2 - Ocarina of Time
+  - items:
+      Kokiri Sword: 1
+      Biggoron Sword: 1
+      Bow: 1
+      Magic Meter: 1
+      Progressive Strength Upgrade: 3
+      Progressive Hookshot: 2
+    locations:
+      - Deku Tree Slingshot Chest
+      - Dodongos Cavern Bomb Bag Chest
+      - Jabu Jabus Belly Boomerang Chest
+      - Bottom of the Well Lens of Truth Chest
+      - Forest Temple Bow Chest
+      - Fire Temple Megaton Hammer Chest
+      - Water Temple Longshot Chest
+      - Shadow Temple Hover Boots Chest
+      - Spirit Temple Silver Gauntlets Chest
+    world: false
+
+  # example block 3 - Slay the Spire
+  - items:
+      Boss Relic: 3
+    locations:
+      - Boss Relic 1
+      - Boss Relic 2
+      - Boss Relic 3
+
+  # example block 4 - Factorio
+  - items:
+      progressive-electric-energy-distribution: 2
+      electric-energy-accumulators: 1
+      progressive-turret: 2
+    locations:
+      - military
+      - gun-turret
+      - logistic-science-pack
+      - steel-processing
+    percentage: 80
+    force: true
+
+# example block 5 - Secret of Evermore
+  - items:
+      Levitate: 1
+      Revealer: 1
+      Energize: 1
+    locations:
+      - Master Sword Pedestal
+      - Boss Relic 1
+    world: true
+    count: 2
+
+# example block 6 - A Link to the Past
+  - items:
+      Progressive Sword: 4
+    world:
+      - BobsSlaytheSpire
+      - BobsRogueLegacy
+    count:
+      min: 1
+      max: 4
+```
+1. This block has a 50% chance to occur, and if it does will place either the Empire Orb or Radiant Orb on another player's
+Starter Chest 1 and removes the chosen item from the item pool.
+2. This block will always trigger and will place the player's swords, bow, magic meter, strength upgrades, and hookshots
+in their own dungeon major item chests.
+3. This block will always trigger and will lock boss relics on the bosses.
+4. This block has an 80% chance of occurring and when it does will place all but 1 of the items randomly among the four
+locations chosen here.
+5. This block will always trigger and will attempt to place a random 2 of Levitate, Revealer and Energize into
+other players' Master Sword Pedestals or Boss Relic 1 locations.
+6. This block will always trigger and will attempt to place a random number, between 1 and 4, of progressive swords
+into any locations within the game slots named BobsSlaytheSpire and BobsRogueLegacy
+
+
+## Boss Plando
+
+As this is currently only supported by A Link to the Past instead of explaining here please refer to the
+[relevant guide](/tutorial/zelda3/plando/en)
+
+## Text Plando
+
+As this is currently only supported by A Link to the Past instead of explaining here please refer to the
+[relevant guide](/tutorial/zelda3/plando/en)
+
+## Connections Plando
+
+This is currently only supported by Minecraft and A Link to the Past. As the way that these games interact with their
+connections is different I will only explain the basics here while more specifics for Link to the Past connection plando
+can be found in its plando guide.
+
+* The options for connections are `percentage`, `entrance`, `exit`, and `direction`. Each of these options support
+  subweights.
+* `percentage` is the percentage chance for this connection from 0 to 100 and defaults to 100.
+* Every connection has an `entrance` and an `exit`. These can be unlinked like in A Link to the Past insanity entrance
+  shuffle.
+* `direction` can be `both`, `entrance`, or `exit` and determines in which direction this connection will operate.
+
+[Link to the Past connections](https://github.com/ArchipelagoMW/Archipelago/blob/main/worlds/alttp/EntranceShuffle.py#L3852)
+
+[Minecraft connections](https://github.com/ArchipelagoMW/Archipelago/blob/main/worlds/minecraft/Regions.py#L62)
+
+### Examples
+
+```yaml
+plando_connections:
+  # example block 1 - Link to the Past
+  - entrance: Cave Shop (Lake Hylia)
+    exit: Cave 45
+    direction: entrance
+  - entrance: Cave 45
+    exit: Cave Shop (Lake Hylia)
+    direction: entrance
+  - entrance: Agahnims Tower
+    exit: Old Man Cave Exit (West)
+    direction: exit
+
+  # example block 2 - Minecraft
+  - entrance: Overworld Structure 1
+    exit: Nether Fortress
+    direction: both
+  - entrance: Overworld Structure 2
+    exit: Village
+    direction: both
+```
+
+1. These connections are decoupled so going into the lake hylia cave shop will take you to the inside of cave 45 and
+   when you leave the interior you will exit to the cave 45 ledge. Going into the cave 45 entrance will then take you to
+   the lake hylia cave shop. Walking into the entrance for the old man cave and Agahnim's Tower entrance will both take
+   you to their locations as normal but leaving old man cave will exit at Agahnim's Tower.
+2. This will force a nether fortress and a village to be the overworld structures for your game. Note that for the
+   Minecraft connection plando to work structure shuffle must be enabled.

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

@@ -0,0 +1,85 @@
+# Archipelago Setup Guide
+
+This guide is intended to provide an overview of how to install, set up, and run the Archipelago multiworld software.
+This guide should take about 5 minutes to read.
+
+## Installing the Archipelago software
+
+The most recent public release of Archipelago can be found on the GitHub Releases page. GitHub Releases
+page: [Archipelago Releases Page](https://github.com/ArchipelagoMW/Archipelago/releases).
+
+Run the exe file, and after accepting the license agreement you will be prompted on which components you would like to
+install.
+
+The generator allows you to generate multiworld games on your computer. The ROM setups are required if anyone in the
+game that you generate wants to play any of those games as they are needed to generate the relevant patch files.
+
+The server will allow you to host the multiworld on your machine. Hosting on your machine requires forwarding the port
+you are hosting on. The default port for Archipelago is `38281`. If you are unsure how to do this there are plenty of
+other guides on the internet that will be more suited to your hardware.
+
+The `Clients` are what are used to connect your game to the multiworld. If the game/games you plan to play are available
+here go ahead and install these as well. If the game you choose to play is supported by Archipelago but not listed in
+the installation check the setup guide for that game. Installing a client for a ROM based game requires you to have a
+legally obtained ROM for that game as well.
+
+## Generating a game
+
+### What is a YAML?
+
+YAML is the file format which Archipelago uses in order to configure a player's world. It allows you to dictate which
+game you will be playing as well as the settings you would like for that game.
+
+YAML is a format very similar to JSON however it is made to be more human-readable. If you are ever unsure of the
+validity of your YAML file you may check the file by uploading it to the check page on the Archipelago website. Check
+page: [YAML Validation Page](/mysterycheck)
+
+### Creating a YAML
+
+YAML files may be generated on the Archipelago website by visiting the games page and clicking the "Settings Page" link
+under any game. Clicking "Export Settings" in a game's settings page will download the YAML to your system. Games
+page: [Archipelago Games List](/games)
+
+In a multiworld there must be one YAML per world. Any number of players can play on each world using either the game's
+native coop system or using Archipelago's coop support. Each world will hold one slot in the multiworld and will have a
+slot name and, if the relevant game requires it, files to associate it with that multiworld.
+
+If multiple people plan to play in one world cooperatively then they will only need one YAML for their coop world. If
+each player is planning on playing their own game then they will each need a YAML.
+
+### Gather All Player YAMLs
+
+All players that wish to play in the generated multiworld must have a YAML file which contains the settings that they
+wish to play with.
+
+Typically, a single participant of the multiworld will gather the YAML files from all other players. After getting the
+YAML files of each participant for your multiworld game they can be compressed into a ZIP folder to then be uploaded to
+the multiworld generator page. Multiworld generator
+page: [Archipelago Seed Generator Page](https://archipelago.gg/generate)
+
+#### Rolling a YAML Locally
+
+It is possible to roll the multiworld locally, using a local Archipelago installation. This is done by entering the
+installation directory of the Archipelago installation and placing each YAML file in the `Players` folder. If the folder
+does not exist then it can be created manually.
+
+After filling the `Players` folder the `ArchipelagoGenerate.exe` program should be run in order to generate a
+multiworld. The output of this process is placed in the `output` folder.
+
+#### Changing local host settings for generation
+
+Sometimes there are various settings that you may want to change before rolling a seed such as enabling race mode,
+auto-forfeit, plando support, or setting a password.
+
+All of these settings plus other options are able to be changed by modifying the `host.yaml` file in the Archipelago
+installation folder. The settings chosen here are baked into the `.archipelago` file that gets output with the other
+files after generation so if rolling locally ensure this file is edited to your liking *before* rolling the seed.
+
+## Hosting an Archipelago Server
+
+The output of rolling a YAML will be a `.archipelago` file which can be subsequently uploaded to the Archipelago host
+game page. Archipelago host game page: [Archipelago Seed Upload Page](https://archipelago.gg/uploads)
+
+The `.archipelago` file may be run locally in order to host the multiworld on the local machine. This is done by
+running `ArchipelagoServer.exe` and pointing the resulting file selection prompt to the `.archipelago` file that was
+generated.

WebHostLib/static/assets/tutorial/Archipelago/triggers_en.md

@@ -0,0 +1,129 @@
+# Archipelago Triggers Guide
+
+This guide details the use of the Archipelago YAML trigger system. This guide is intended for a more advanced user with
+more in-depth knowledge of Archipelago YAML options as well as experience editing YAML files. This guide should take
+about 5 minutes to read.
+
+## What are triggers?
+
+Triggers allow you to customize your game settings by allowing you to define one or many options which only occur under
+specific conditions. These are essentially "if, then" statements for options in your game. A good example of what you
+can do with triggers is the custom mercenary mode YAML that was created using entirely triggers and plando.
+
+Mercenary mode
+YAML: [Mercenary Mode YAML on GitHub](https://github.com/alwaysintreble/Archipelago-yaml-dump/blob/main/Snippets/Mercenary%20Mode%20Snippet.yaml)
+
+For more information on plando you can reference the general plando guide or the Link to the Past plando guide.
+
+General plando guide: [Archipelago Plando Guide](/tutorial/archipelago/plando/en)
+
+Link to the Past plando guide: [LttP Plando Guide](/tutorial/zelda3/plando/en)
+
+## Trigger use
+
+Triggers may be defined in either the root or in the relevant game sections. Generally, The best place to do this is the
+bottom of the yaml for clear organization.
+
+- Triggers comprise the trigger section and then each trigger must have an `option_category`, `option_name`, and
+  `option_result` from which it will react to and then an `options` section for the definition of what will happen.
+- `option_category` is the defining section from which the option is defined in.
+    - Example: `A Link to the Past`
+    - This is the root category the option is located in. If the option you're triggering off of is in root then you
+      would use `null`, otherwise this is the game for which you want this option trigger to activate.
+- `option_name` is the option setting from which the triggered choice is going to react to.
+    - Example: `shop_item_slots`
+    - This can be any option from any category defined in the yaml file in either root or a game section.
+- `option_result` is the result of this option setting from which you would like to react.
+    - Example: `15`
+    - Each trigger must be used for exactly one option result. If you would like the same thing to occur with multiple
+      results you would need multiple triggers for this.
+- `options` is where you define what will happen when this is detected. This can be something as simple as ensuring
+  another option also gets selected or placing an item in a certain location. It is possible to have multiple things
+  happen in this section.
+    - Example:
+  ```yaml
+  A Link to the Past:
+    start_inventory: 
+      Rupees (300): 2
+  ```
+
+This format must be:
+
+  ```yaml
+  root option:
+    option to change:
+      desired result
+  ```
+
+### Examples
+
+The above examples all together will end up looking like this:
+
+  ```yaml
+  triggers:
+    - option_category: A Link to the Past
+      option_name: shop_item_slots
+      option_result: 15
+      options:
+        A Link to the Past:
+          start_inventory:
+            Rupees(300): 2
+  ```
+
+For this example if the generator happens to roll 15 shuffled in shop item slots for your game you'll be granted 600
+rupees at the beginning. These can also be used to change other options.
+
+For example:
+
+  ```yaml
+  triggers:
+    - option_category: Timespinner
+      option_name: SpecificKeycards
+      option_result: true
+      options:
+        Timespinner:
+          Inverted: true
+  ```
+
+In this example if your world happens to roll SpecificKeycards then your game will also start in inverted.
+
+It is also possible to use imaginary names in options to trigger specific settings. You can use these made up names in
+either your main options or to trigger from another trigger. Currently, this is the only way to trigger on "setting 1
+AND setting 2".
+
+For example:
+
+  ```yaml
+  triggers:
+    - option_category: Secret of Evermore
+      option_name: doggomizer
+        option_result: pupdunk
+        options:
+          Secret of Evermore:
+            difficulty:
+              normal: 50
+              pupdunk_hard: 25
+              pupdunk_mystery: 25
+            exp_modifier:
+              150: 50
+              200: 50
+      - option_category: Secret of Evermore
+        option_name: difficulty
+        option_result: pupdunk_hard
+        options:
+          Secret of Evermore:
+            fix_wings_glitch: false
+            difficulty: hard
+      - option_category: Secret of Evermore
+        option_name: difficulty
+        option_result: pupdunk_mystery
+        options:
+          Secret of Evermore:
+            fix_wings_glitch: false
+            difficulty: mystery
+  ```
+
+In this example (thanks to @Black-Sliver) if the `pupdunk` option is rolled then the difficulty values will be rolled
+again using the new options `normal`, `pupdunk_hard`, and `pupdunk_mystery`, and the exp modifier will be rerolled using
+new weights for 150 and 200. This allows for two more triggers that will only be used for the new `pupdunk_hard`
+and `pupdunk_mystery` options so that they will only be triggered on "pupdunk AND hard/mystery".

WebHostLib/static/assets/tutorial/Archipelago/using_website_en.md

@@ -0,0 +1,33 @@
+# Using the Archipelago Website
+
+This guide encompasses the use cases for rolling and hosting multiworld games on the Archipelago website. This guide
+should only take a couple of minutes to read.
+
+## Rolling the Seed On the Website
+
+1. After gathering the YAML files together in one location, select all the files and compress them into a `.ZIP` file.
+2. Next go to the "Generate Game" page. Generate game
+   page: [Archipelago Seed Generation Page](https://archipelago.gg/generate). Here, you can adjust some server settings
+   such as forfeit rules and the cost for a player to use a hint before generation.
+3. After adjusting the host settings to your liking click on the Upload File button and using the explorer window that
+   opens, navigate to the location where you zipped the player files and upload this zip. The page will generate your
+   game and refresh multiple times to check on completion status.
+4. After the generation completes you will be on a Seed Info page that provides the seed, the date/time of creation, a
+   link to the spoiler log, if available, and links to any rooms created from this seed.
+5. To begin playing, click on "Create New Room", which will take you to the room page. From here you can navigate back
+   to the Seed Info page or to the Tracker page. Sharing the link to the room page with your friends will provide them
+   with the necessary info and files for them to connect to the multiworld.
+
+## Hosting a Pre-Generated Multiworld on the Website
+
+The easiest and most recommended method is to generate the game on the website which will allow you to create a private
+room with all the necessary files you can share, as well as hosting the game and supporting item trackers for various
+games.
+
+If for some reason the seed was rolled on a machine, then either the resulting zip file or the
+resulting `AP_XXXXX.archipelago` inside the zip file can be uploaded to the host game page. Host game
+page: [Archipelago Seed Upload Page](https://archipelago.gg/uploads)
+
+This will give a page with the seed info and a link to the spoiler log, if it exists. Click on "Create New Room" and
+then share the link to the resulting page the other players so that they can download their patches or mods. The room
+will also have a link to a Multiworld Tracker and tell you what the players need to connect to from their clients.

WebHostLib/static/assets/tutorial/ChecksFinder/checksfinder_en.md

@@ -0,0 +1,45 @@
+# ChecksFinder Randomizer Setup Guide
+
+## Required Software
+
+- ChecksFinder from
+  the [Github releases Page for the game](https://github.com/jonloveslegos/ChecksFinder/releases) (latest version)
+- Archipelago from the [Archipelago Releases Page](https://github.com/ArchipelagoMW/Archipelago/releases)
+    - (select `ChecksFinder Client` during installation.)
+
+## Configuring your YAML file
+
+### What is a YAML file and why do I need one?
+
+See the guide on setting up a basic YAML at the Archipelago setup
+guide: [Basic Multiworld Setup Guide](/tutorial/archipelago/setup/en)
+
+### Where do I get a YAML file?
+
+You can customize your settings by visiting the [ChecksFinder Player Settings Page](/games/ChecksFinder/player-settings)
+
+### Generating a ChecksFinder game
+
+**ChecksFinder is meant to be played _alongside_ another game! You may not be playing it for long periods of time if 
+you play it by itself with another person!**
+
+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. You do not have a file inside that zip though!
+
+You need to start ChecksFinder client yourself, it is located within the Archipelago folder.
+
+### Connect to the MultiServer
+
+First start ChecksFinder.
+
+Once both ChecksFinder and the client are started. In the client at the top type in the spot labeled `Server` type the 
+`Ip Address` and `Port` separated with a `:` symbol.
+
+The client will then ask for the username you chose, input that in the text box at the bottom of the client.
+
+### Play the game
+
+When the console tells you that you have joined the room, you're all set. Congratulations on successfully joining a
+multiworld game!
+

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

@@ -1,37 +1,47 @@
 # Factorio Randomizer Setup Guide
 
 ## Required Software
+
 ##### Players
-- [Factorio](https://factorio.com) - Needed by Players and Hosts
+
+- Factorio: [Factorio Official Website](https://factorio.com)
+    - Needed by Players and Hosts
 
 ##### Server Hosts
-- [Factorio](https://factorio.com) - Needed by Players and Hosts
-- [Archipelago](https://github.com/ArchipelagoMW/Archipelago/releases) - Needed by Hosts
+
+- Factorio: [Factorio Official Website](https://factorio.com)
+    - Needed by Players and Hosts
+- Archipelago: [Archipelago Releases Page](https://github.com/ArchipelagoMW/Archipelago/releases)
+    - Needed by Hosts
 
 ## Create a Config (.yaml) File
 
 ### What is a config file and why do I need one?
+
 Your config 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 config 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. 
+should generate your game. Each player of a multiworld will provide their own config 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 config file?
-The [Player Settings](/games/Factorio/player-settings) page on the website allows you to configure
-your personal settings and export a config file from them.
+
+The Player Settings page on the website allows you to configure your personal settings and export a config file from
+them. Factorio player settings page: [Factorio Settings Page](/games/Factorio/player-settings)
 
 ### Verifying your config file
-If you would like to validate your config file to make sure it works, you may do so on
-the [YAML Validator](/mysterycheck) page.
+
+If you would like to validate your config file to make sure it works, you may do so on the YAML Validator page. YAML
+Validator page: [Yaml Validation Page](/mysterycheck)
 
 ## Connecting to Someone Else's Factorio Game
-Connecting to someone else's game is the simplest way to play Factorio with Archipelago. It allows multiple
-people to play in a single world, all contributing to the completion of the seed.
+
+Connecting to someone else's game is the simplest way to play Factorio with Archipelago. It allows multiple people to
+play in a single world, all contributing to the completion of the seed.
 
 1. Acquire the Archipelago mod for this seed. It should be named `AP_*.zip`, where `*` is the seed number.
 2. Copy the mod file into your Factorio `mods` folder, which by default is located at:  
-`C:\Users\YourName\AppData\Roaming\Factorio\mods`
-3. Get the server address from the person hosting the game you are joining
+   `C:\Users\<YourUserName>\AppData\Roaming\Factorio\mods`
+3. Get the server address from the person hosting the game you are joining.
 4. Launch Factorio
 5. Click on "Multiplayer" in the main menu
 6. Click on "Connect to address"
@@ -41,17 +51,20 @@ people to play in a single world, all contributing to the completion of the seed
 ## Prepare to Host Your Own Factorio Game
 
 ### Defining Some Terms
-In Archipelago, multiple Factorio worlds may be played simultaneously. Each of these worlds must be hosted by a
-Factorio server, which is connected to the Archipelago Server via middleware.
+
+In Archipelago, multiple Factorio worlds may be played simultaneously. Each of these worlds must be hosted by a Factorio
+server, which is connected to the Archipelago Server via middleware.
 
 This guide uses the following terms to refer to the software:
+
 - **Factorio Client** - The Factorio instance which will be used to play the game.
-- **Factorio Server** - The Factorio instance which will be used to host the Factorio world. Any number of
-Factorio Clients may connect to this server.
+- **Factorio Server** - The Factorio instance which will be used to host the Factorio world. Any number of Factorio
+  Clients may connect to this server.
 - **Archipelago Client** - The middleware software used to connect the Factorio Server to the Archipelago Server.
 - **Archipelago Server** - The central Archipelago server, which connects all games to each other.
 
 ### What a Playable State Looks Like
+
 - An Archipelago Server
 - The generated Factorio Mod, created as a result of running `ArchipelagoGenerate.exe`
 - One running instance of `ArchipelagoFactorioClient.exe` (the Archipelago Client) per Factorio world
@@ -59,70 +72,82 @@ Factorio Clients may connect to this server.
 - A running modded Factorio Client
 
 ### Dedicated Server Setup
+
 To play Factorio with Archipelago, a dedicated server setup is required. This dedicated Factorio Server must be
-installed separately from your main Factorio Client installation. The recommended way to install two instances
-of Factorio on your computer is to download the Factorio installer file directly from
-[factorio.com](https://factorio.com/download).
+installed separately from your main Factorio Client installation. The recommended way to install two instances of
+Factorio on your computer is to download the Factorio installer file directly from
+factorio.com: [Factorio Official Website Download Page](https://factorio.com/download).
 
 #### If you purchased Factorio on Steam, GOG, etc.
-You can register your copy of Factorio on [factorio.com](https://factorio.com/). You will be required to
-create an account, if you have not done so already. As part of that process, you will be able to enter your
+
+You can register your copy of Factorio on factorio.com: [Factorio Official Website](https://factorio.com/). You will be
+required to create an account, if you have not done so already. As part of that process, you will be able to enter your
 Factorio product code. This will allow you to download the game directly from their website.
 
 #### Download the Standalone Version
-It is recommended to download the standalone version of Factorio for use as a dedicated server. Doing so prevents
-any potential conflicts with your currently-installed version of Factorio. Download the file by clicking on the
-button appropriate to your operating system, and extract the folder to a convenient location (we recommend
-C:\Factorio or similar).<br />
-<img src="/static/assets/tutorial/factorio/factorio-download.png" />
 
-Next, you should launch your Factorio Server by running `factorio.exe`, which is located at: `bin/x64/factorio.exe`.
-You will be asked to log-in to your Factorio account using the same credentials you used on Factorio's website.
-After you have logged in, you may close the game.
+It is recommended to download the standalone version of Factorio for use as a dedicated server. Doing so prevents any
+potential conflicts with your currently-installed version of Factorio. Download the file by clicking on the button
+appropriate to your operating system, and extract the folder to a convenient location (we recommend `C:\Factorio` or
+similar).
+
+![Factorio Download Options](/static/assets/tutorial/factorio/factorio-download.png)
+
+Next, you should launch your Factorio Server by running `factorio.exe`, which is located at: `bin/x64/factorio.exe`. You
+will be asked to log in to your Factorio account using the same credentials you used on Factorio's website. After you
+have logged in, you may close the game.
 
 #### Configure your Archipelago Installation
+
 You must modify your `host.yaml` file inside your Archipelago installation directory so that it points to your
 standalone Factorio executable. Here is an example of the appropriate setup, note the double `\\` are required:
+
 ```yaml
 factorio_options:
-  executable:  C:\\factorio\\bin\\x64\\factorio"
+  executable: C:\\factorio\\bin\\x64\\factorio"
 ```
 
-With all that complete, you are now able to...
+This allows you to host your own Factorio game.
 
-## Host Your Own Factorio Game
+## Hosting Your Own Factorio Game
 
 1. Obtain the Factorio mod for this Archipelago seed. It should be named `AP_*.zip`, where `*` is the seed number.
 2. Install the mod into your Factorio Server by copying the zip file into the `mods` folder.
 3. Install the mod into your Factorio Client by copying the zip file into the `mods` folder, which is likely located
-at `C:\Users\YourName\AppData\Roaming\Factorio\mods`.
+   at `C:\Users\YourName\AppData\Roaming\Factorio\mods`.
 4. Obtain the Archipelago Server address from the website's host room, or from the server host.
 5. Run your Archipelago Client, which is named `ArchilepagoFactorioClient.exe`. This was installed along with
-Archipelago if you chose to include it during the installation process.
+   Archipelago if you chose to include it during the installation process.
 6. Enter `/connect [server-address]` into the input box at the bottom of the Archipelago Client and press "Enter"
-<br /><img src="/static/assets/tutorial/factorio/connect-to-ap-server.png" />
+
+![Factorio Client for Archipelago Connection Command](/static/assets/tutorial/factorio/connect-to-ap-server.png)
+
 7. Launch your Factorio Client
 8. Click on "Multiplayer" in the main menu
 9. Click on "Connect to address"
 10. Enter `localhost` into the server address box
 11. Click "Connect"
 
-For additional client features, issue the `/help` command in the Archipelago Client. Once connected to the AP
-server, you can also issue the `!help` command to learn about additional commands like `!hint`. 
+For additional client features, issue the `/help` command in the Archipelago Client. Once connected to the AP server,
+you can also issue the `!help` command to learn about additional commands like `!hint`.
 
 ## Allowing Other People to Join Your Game
+
 1. Ensure your Archipelago Client is running.
 2. Ensure port `34197` is forwarded to the computer running the Archipelago Client.
-3. Obtain your IP address by visiting [this website](https://whatismyip.com/).
+3. Obtain your IP address by visiting whatismyip.com: [WhatIsMyIP Website](https://whatismyip.com/).
 4. Provide your IP address to anyone you want to join your game, and have them follow the steps for
-"Connecting to Someone Else's Factorio Game" above.
+   "Connecting to Someone Else's Factorio Game" above.
 
 ## Troubleshooting
-In case any problems should occur, the Archipelago Client will create a file `FactorioClient.txt` in the `/logs`.
-The contents of this file may help you troubleshoot an issue on your own and is vital for requesting help from other
-people in Archipelago.
+
+In case any problems should occur, the Archipelago Client will create a file `FactorioClient.txt` in the `/logs`. The
+contents of this file may help you troubleshoot an issue on your own and is vital for requesting help from other people
+in Archipelago.
 
 ## Additional Resources
-- [Alternate Tutorial by Umenen](https://docs.google.com/document/d/1yZPAaXB-QcetD8FJsmsFrenAHO5V6Y2ctMAyIoT9jS4)
-- [Factorio Speedrun Guide](https://www.youtube.com/watch?v=ExLrmK1c7tA)
-- [Factorio Wiki](https://wiki.factorio.com/)
+
+- Alternate Tutorial by
+  Umenen: [Factorio (Steam) Archipelago Setup Guide for Windows](https://docs.google.com/document/d/1yZPAaXB-QcetD8FJsmsFrenAHO5V6Y2ctMAyIoT9jS4)
+- Factorio Speedrun Guide: [Factorio Speedrun Guide by Nefrums](https://www.youtube.com/watch?v=ExLrmK1c7tA)
+- Factorio Wiki: [Factorio Official Wiki](https://wiki.factorio.com/)

WebHostLib/static/assets/tutorial/Final Fantasy/multiworld_en.md

@@ -0,0 +1,74 @@
+# Final Fantasy 1 (NES) Multiworld Setup Guide
+
+## Required Software
+
+- The FF1Client
+    - Bundled with Archipelago: [Archipelago Releases Page](https://github.com/ArchipelagoMW/Archipelago/releases)
+- The BizHawk emulator. Versions 2.3.1 and higher are supported. Version 2.7 is recommended
+    - [BizHawk Official Website](http://tasvideos.org/BizHawk.html)
+- Your legally obtained Final Fantasy (USA Edition) ROM file, probably named `Final Fantasy (USA).nes`. Neither
+  Archipelago.gg nor the Final Fantasy Randomizer Community can supply you with this.
+
+## Installation Procedures
+
+1. Download and install the latest version of Archipelago.
+    1. On Windows, download Setup.Archipelago.<HighestVersion\>.exe and run it
+2. Assign Bizhawk version 2.3.1 or higher as your default program for launching `.nes` files.
+    1. Extract your Bizhawk folder to your Desktop, or somewhere you will remember. Below are optional additional steps
+       for loading ROMs more conveniently
+        1. Right-click on a ROM file and select **Open with...**
+        2. Check the box next to **Always use this app to open .nes files**
+        3. Scroll to the bottom of the list and click the grey text **Look for another App on this PC**
+        4. Browse for `EmuHawk.exe` located inside your Bizhawk folder (from step 1) and click **Open**.
+
+## Obtaining your Archipelago yaml file and randomized ROM
+
+Unlike most other Archipelago.gg games Final Fantasy 1 is randomized by the main randomizer at
+the [Final Fantasy Randomizer Homepage](https://finalfantasyrandomizer.com/).
+
+Generate a game by going to the site and performing the following steps:
+
+1. Select the randomization options (also known as `Flags` in the community) of your choice. If you do not know what you
+   prefer, or it is your first time playing select the "Archipelago" preset on the main page.
+2. Go to the `Beta` tab and ensure `Archipelago` is enabled. Set your player name to any name that represents you.
+3. Upload you `Final Fantasy(USA).nes` (and click `Remember ROM` for the future!)
+4. Press the `NEW` button beside `Seed` a few times
+5. Click `GENERATE ROM`
+
+It should download two files. One is the `*.nes` file which your emulator will run and the other is the yaml file
+required by Archipelago.gg
+
+At this point you are ready to join the multiworld. If you are uncertain on how to generate, host or join a multiworld
+please refer to the [game agnostic setup guide](/tutorial/archipelago/setup/en).
+
+## Running the Client Program and Connecting to the Server
+
+Once the Archipelago server has been hosted:
+
+1. Navigate to your Archipelago install folder and run `ArchipelagoFF1Client.exe`
+2. Notice the `/connect command` on the server hosting page (It should look like `/connect archipelago.gg:*****`
+   where ***** are numbers)
+3. Type the connect command into the client OR add the port to the pre-populated address on the top bar (it should
+   already say `archipelago.gg`) and click `connect`
+
+### Running Your Game and Connecting to the Client Program
+
+1. Open Bizhawk 2.3.1 or higher and load your ROM OR click your ROM file if it is already associated with the
+   extension `*.nes`
+2. Click on the Tools menu and click on **Lua Console**
+3. Click the folder button to open a new Lua script. (CTL-O or **Script** -> **Open Script**)
+4. Navigate to the location you installed Archipelago to. Open data/lua/FF1/ff1_connector.lua
+    1. If it gives a `NLua.Exceptions.LuaScriptException: .\socket.lua:13: module 'socket.core' not found:` exception
+       close your emulator entirely, restart it and re-run these steps
+    2. If it says `Must use a version of bizhawk 2.3.1 or higher`, double-check your Bizhawk version by clicking **
+       Help** -> **About**
+
+## Play the game
+
+When the client shows both NES and server are connected you are good to go. You can check the connection status of the
+NES at any time by running `/nes`
+
+### Other Client Commands
+
+All other commands may be found on the [Archipelago Server and Client Commands Guide](/tutorial/archipelago/commands/en)
+.

WebHostLib/static/assets/tutorial/Hollow Knight/setup_en.md

@@ -0,0 +1,30 @@
+# Hollow Knight for Archipelago Setup Guide
+
+## Required Software
+* Download and unzip the Scarab Mod Manager from the [Scarab GitHub Releases page](https://github.com/fifty-six/Scarab/releases).
+* A legal copy of Hollow Knight, not purchased or played through XBox Game Pass.
+    * Unfortunately, the Game Pass version is not currently compatible with mods.
+
+## Installing the Archipelago Mod using Scarab
+1. Launch Scarab and ensure it locates your Hollow Knight installation directory.
+2. Click the "Install" checkbox near the "Archipelago" mod entry.
+3. Launch the game, you're all set!
+
+## Configuring your YAML File
+### What is a YAML and why do I need one?
+You can see the [basic multiworld setup guide](/tutorial/Archipelago/setup/en) here on the Archipelago website to learn 
+about why Archipelago uses YAML files and what they're for.
+
+### Where do I get a YAML?
+You can use the [game settings page for Hollow Knight](/games/Hollow%20Knight/player-settings) here on the Archipelago 
+website to generate a YAML using a graphical interface.
+
+### Joining an Archipelago Game in Hollow Knight
+1. Start the game after installing all necessary mods.
+2. Create a **new save game.**
+3. Select the **Archipelago** game mode from the mode selection screen.
+4. Enter the correct settings for your Archipelago server.
+5. Hit **Start** to begin the game. The game will stall for a few seconds while it does all item placements.
+6. The game will immediately drop you into the randomized game. 
+   * If you are waiting for a countdown then wait for it to lapse before hitting Start.
+   * Or hit Start then pause the game once you're in it.

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

@@ -0,0 +1,64 @@
+# Meritous Randomizer Setup Guide
+
+## Required Software
+
+Download the game from the [Meritous Gaiden GitHub releases page](https://github.com/FelicitusNeko/meritous-ap/releases)
+
+## Installation Procedures
+
+Simply download the latest version of Meritous Gaiden from the link above, and extract it wherever you like.
+
+- ⚠️ Do not extract Meritous Gaiden to Program Files, as this will cause file access issues.
+
+## Joining a Multiworld Game
+
+1. Modify the `meritous-ap.json` file with your server details, as outlined in the next section.
+2. Run `meritous.exe`. If the AP settings file is detected, you will see "AP Enabled" show up in the bottom left of the menu screen.
+3. Start a new game. If it is able to successfully connect to the AP server, "Connected" will show up in the bottom left of the game screen for a few seconds.
+
+## AP Settings File
+
+The format of `meritous-ap.json` should be as follows:
+
+```json
+{
+    "ap-enable": true,
+    "server": "archipelago.gg",
+    "port": 38281,
+    "password": null,
+    "slotname": "YourName"
+}
+```
+
+- `ap-enable`: Enables the game to connect to the Archipelago server. If this is `false` or missing, it will generate a local item randomizer.
+- `server`: The server to which to connect. This can be a domain name (such as archipelago.gg) or an IP address (such as 127.0.0.1). If this is missing, the game will assume archipelago.gg.
+- `port`: The port number to which to connect. By default, Archipelago will use port 38281 to host, unless the game is hosted on the Archipelago webhost. If this is missing, the game will assume 38281.
+- `password`: The password to use for this game, if any. This can be omitted or set to `null` if there is no password.
+- `slotname`: The slot name to use for this game. This is required, and must match the name provided on your YAML file.
+
+Eventually, this process will be moved to in-game menus for better ease of use.
+
+## Finishing the Game
+
+Your initial goal is to find all three PSI Keys. Depending on your YAML settings, these may be located on pedestals in special rooms in the Atlas Dome, or they may be scattered across other players' worlds. These PSI Keys are then brought to their respective locations in the Dome, where you will be subjected to a boss battle. Once all three bosses are defeated, this unlocks the Cursed Seal, hidden in the farthest-away location from the Entrance. The Compass tiles can help you find your way to these locations.
+
+At minimum, every seed will require you to find the Cursed Seal and bring it back to the Entrance. The goal can then vary based on your `goal` YAML setting:
+
+- `return_the_cursed_seal`: You will fight the final boss, but win or lose, a victory will be posted.
+- `any_ending`: You must defeat the final boss.
+- `true_ending`: You must first explore all 3000 rooms of the Atlas Dome and find the Agate Knife, then fight the final boss' true form.
+
+Once the goal has been completed, you may press F to send a forfeit, sending out all of your world's remaining items to their respective players, and C to send a collect, which gathers up all of your world's items from their shuffled locations in other player's worlds. You may also press S to view your statistics, if you're a fan of numbers.
+
+More in-depth information about the game can be found in the game's help file, accessed by pressing H while playing.
+
+## Game Troubleshooting
+
+### An error message shows up at the bottom-left
+
+- `Disconnected`: If the game does not reconnect automatically, you may need to save, quit, and reload the game to reconnect. Keep in mind that the game does not auto-save, and it is only possible to save the game at Save Tiles.
+- `InvalidSlot`, `InvalidGame`: Make sure the `slotname` in `meritous-ap.json` matches the name provided in your Meritous YAML file.
+- `SlotAlreadyTaken`: Make sure Meritous Gaiden is not already running and connected to the server.
+- `IncompatibleVersion`: Make sure Meritous Gaiden has been updated to the latest version.
+- `InvalidPassword`: Make sure the `password` in `meritous-ap.json` matches the password for your game. If there is no password, either set this to `null` (no quotes) or omit/remove it completely.
+- `InvalidItemsHandling`: This is a bug and shouldn't happen if you downloaded a precompiled copy of the game. If you downloaded a precompiled copy, please let KewlioMZX know over GitHub or the AP Discord.

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

@@ -0,0 +1,61 @@
+# Minecraft Randomizer Setup Guide
+
+## Required Software
+
+- Minecraft Java Edition from
+  the [Minecraft Java Edition Store Page](https://www.minecraft.net/en-us/store/minecraft-java-edition) (update 1.17.1)
+- Archipelago from the [Archipelago Releases Page](https://github.com/ArchipelagoMW/Archipelago/releases)
+    - (select `Minecraft Client` during installation.)
+
+## Configuring your YAML file
+
+### What is a YAML file and why do I need one?
+
+See the guide on setting up a basic YAML at the Archipelago setup
+guide: [Basic Multiworld Setup Guide](/tutorial/archipelago/setup/en)
+
+### Where do I get a YAML file?
+
+You can customize your settings by visiting the [Minecraft Player Settings Page](/games/Minecraft/player-settings)
+
+## 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.
+
+Double-click on your `.apmc` file to have the Minecraft client auto-launch the installed forge server. Make sure to
+leave this window open as this is your server console.
+
+### Connect to the MultiServer
+
+Using minecraft 1.17.1 connect to the server `localhost`.
+
+Once you are 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 Archipelago server you are using has a password set.
+
+### Play the game
+
+When the console tells you that you have joined the room, you're all set. Congratulations on successfully joining a
+multiworld game! At this point any additional minecraft players may connect to your forge server. To start the game once
+everyone is ready use the command `/start`.
+
+## Manual Installation
+
+It is highly recommended to ues the Archipelago installer to handle the installation of the forge server for you.
+support will not be given for those wishing to manually install forge. For those of you who know how, and wish to do so,
+the following links are the versions of the software we use.
+
+### Manual install Software links
+
+- [Minecraft Forge Download Page](https://files.minecraftforge.net/net/minecraftforge/forge/index_1.17.1.html)
+- [Minecraft Archipelago Randomizer Mod Releases Page](https://github.com/KonoTyran/Minecraft_AP_Randomizer/releases)
+    - **DO NOT INSTALL THIS ON YOUR CLIENT**
+- [Java 16 Download Page](https://docs.aws.amazon.com/corretto/latest/corretto-16-ug/downloads-list.html)
+

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

@@ -1,7 +1,9 @@
 # Guia instalación de Minecraft Randomizer
 
-#Instalacion automatica para el huesped de partida
-- descarga e instala [Archipelago](https://github.com/ArchipelagoMW/Archipelago/releases) and activa el modulo `Minecraft Client`
+# Instalacion automatica para el huesped de partida
+
+- descarga e instala [Archipelago](https://github.com/ArchipelagoMW/Archipelago/releases) and activa el
+  modulo `Minecraft Client`
 
 ## Software Requerido
 
@@ -10,13 +12,15 @@
 ## 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
+
+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
 description: Basic Minecraft Yaml
 # Tu nombre en el juego. Espacios seran sustituidos por guinoes bajos y
@@ -31,52 +35,52 @@ progression_balancing: on
 
 Minecraft:
   # Numero de logros requeridos (87 max) para que aparezca el Ender Dragon y completar el juego.
-  advancement_goal: 50   
-  
+  advancement_goal: 50
+
   # Numero de trozos de huevo de dragon a obtener (30 max) antes de que el Ender Dragon aparezca. 
-  egg_shards_required: 10 
-  
+  egg_shards_required: 10
+
   # Numero de huevos disponibles en la partida (30 max).
-  egg_shards_available: 15 
-  
+  egg_shards_available: 15
+
   # Modifica el nivel de objetos logicamente requeridos para 
   # explorar areas peligrosas y luchar contra jefes.
-  combat_difficulty: 
+  combat_difficulty:
     easy: 0
     normal: 1
     hard: 0
-    
+
   # Si off, los logros que dependan de suerte o sean tediosos tendran objetos de apoyo, no necesarios para completar el juego.
-  include_hard_advancements: 
+  include_hard_advancements:
     on: 0
     off: 1
-    
+
   # Si off, los logros muy dificiles tendran objetos de apoyo, no necesarios para completar el juego.
   # Solo afecta a How Did We Get Here? and Adventuring Time.
-  include_insane_advancements: 
+  include_insane_advancements:
     on: 0
     off: 1
-  
+
   # Algunos logros requieren derrotar al Ender Dragon;
   # Si esto se queda en off, dichos logros no tendran objetos necesarios.
-  include_postgame_advancements: 
+  include_postgame_advancements:
     on: 0
     off: 1
-    
+
   # Permite el mezclado de villas, puesto, fortalezas, bastiones y ciudades de END. 
-  shuffle_structures: 
+  shuffle_structures:
     on: 0
     off: 1
-  
+
   # Añade brujulas de estructura al juego,
   # apuntaran a la estructura correspondiente mas cercana.  
-  structure_compasses: 
+  structure_compasses:
     on: 0
     off: 1
-  
+
   # Reemplaza un porcentaje de objetos innecesarios por trampas abeja
   # las cuales crearan multiples abejas agresivas alrededor de los jugadores cuando se reciba.   
-  bee_traps: 
+  bee_traps:
     0: 1
     25: 0
     50: 0
@@ -87,44 +91,57 @@ Minecraft:
 ## 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`.
+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`.
 
 Haz doble click en tu fichero `.apmc` para que se arranque el cliente de minecraft y el servidor forge se ejecute.
 
 ### 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> (Port) (<Password>)` donde `<AP-Address>` es la dirección del servidor. `(Port)` solo es requerido si el servidor Archipelago no esta usando el puerto por defecto 38281.
+Una vez en juego introduce `/connect <AP-Address> (Port) (<Password>)` donde `<AP-Address>` es la dirección del
+servidor. `(Port)` solo es requerido si el servidor Archipelago no esta usando el puerto por defecto 38281.
 `(<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.
+
+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.
 
 ## Procedimiento de instalación manual
+
 Solo es requerido si quieres usar una instalacion de forge por ti mismo, recomendamos usar el instalador de Archipelago
-###Software Requerido
+
+### Software Requerido
+
 - [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)
-**NO INSTALES ESTO EN TU CLIENTE MINECRAFT**
-
+  **NO INSTALES ESTO EN TU CLIENTE MINECRAFT**
 
 ### 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.5 desde el enlace proporcionado, siempre asegurandose de bajar la version mas reciente.
+
+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.5 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.
+    - 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.
+    - 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`

WebHostLib/static/assets/tutorial/Minecraft/minecraft_sv.md

@@ -3,29 +3,39 @@
 ## Nödvändig Mjukvara
 
 ### Server Värd
+
 - [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)
 
 ### Spelare
+
 - [Minecraft Java Edition](https://www.minecraft.net/en-us/store/minecraft-java-edition)
 
 ## Installationsprocedurer
 
 ### Tillägnad
+
 Bara en person behöver göra denna uppsättning och vara värd för en server för alla andra spelare att koppla till.
-1. Ladda ner 1.16.5 **Minecraft Forge** installeraren från länken ovanför och se till att ladda ner den senaste rekommenderade versionen.
+
+1. Ladda ner 1.16.5 **Minecraft Forge** installeraren från länken ovanför och se till att ladda ner den senaste
+   rekommenderade versionen.
 
 2. Kör `forge-1.16.5-xx.x.x-installer.jar` filen och välj **installera server**.
-    - På denna sida kommer du också välja vart du ska installera servern för att komma ihåg denna katalog. Detta är viktigt för nästa steg.
+    - På denna sida kommer du också välja vart du ska installera servern för att komma ihåg denna katalog. Detta är
+      viktigt för nästa steg.
 
 3. Navigera till vart du har installerat servern och öppna `forge-1.16.5-xx.x.x-installer.jar`
-    - Under första serverstart så kommer den att stängas ner och fråga dig att acceptera Minecrafts EULA. En ny fil kommer skapas vid namn `eula.txt` som har en länk till Minecrafts EULA, och en linje som du behöver byta till `eula=true` för att acceptera Minecrafts EULA.
+    - Under första serverstart så kommer den att stängas ner och fråga dig att acceptera Minecrafts EULA. En ny fil
+      kommer skapas vid namn `eula.txt` som har en länk till Minecrafts EULA, och en linje som du behöver byta
+      till `eula=true` för att acceptera Minecrafts EULA.
     - Detta kommer skapa de lämpliga katalogerna för dig att placera filerna i de följande steget.
 
-4. Placera `aprandomizer-x.x.x.jar` länken ovanför i `mods` mappen som ligger ovanför installationen av din forge server.
+4. Placera `aprandomizer-x.x.x.jar` länken ovanför i `mods` mappen som ligger ovanför installationen av din forge
+   server.
     - Kör servern igen. Den kommer ladda up och generera den nödvändiga katalogen `APData` för när du är redo att spela!
 
 ### Grundläggande Spelaruppsättning
+
 - Köp och installera Minecraft från länken ovanför.
 
   **Du är klar**.
@@ -33,10 +43,12 @@ Bara en person behöver göra denna uppsättning och vara värd för en server f
   Andra spelare behöver endast ha en 'Vanilla' omodifierad version av Minecraft för att kunna spela!
 
 ### Avancerad Spelaruppsättning
+
 ***Detta är inte nödvändigt för att spela ett slumpmässigt Minecraftspel.***
 Dock så är det rekommenderat eftersom det hjälper att göra upplevelsen mer trevligt.
 
 #### Rekommenderade Moddar
+
 - [JourneyMap](https://www.curseforge.com/minecraft/mc-mods/journeymap) (Minimap)
 
 
@@ -52,17 +64,20 @@ Dock så är det rekommenderat eftersom det hjälper att göra upplevelsen mer t
 ## Konfigurera Din YAML-fil
 
 ### Vad är en YAML-fil och varför behöver jag en?
-Din YAML-fil behåller en uppsättning av konfigurationsalternativ som ger generatorn med information om hur
-den borde generera ditt spel. Varje spelare i en multivärld kommer behöva ge deras egen YAML-fil. Denna uppsättning tillåter
-varje spelare att an njuta av en upplevelse anpassade för deras smaker, och olika spelare i samma multivärld
-kan ha helt olika alternativ.
+
+Din YAML-fil behåller en uppsättning av konfigurationsalternativ som ger generatorn med information om hur den borde
+generera ditt spel. Varje spelare i en multivärld kommer behöva ge deras egen YAML-fil. Denna uppsättning tillåter varje
+spelare att an njuta av en upplevelse anpassade för deras smaker, och olika spelare i samma multivärld kan ha helt olika
+alternativ.
 
 ### Vart kan jag få tag i en YAML-fil?
+
 En grundläggande Minecraft YAML kommer se ut så här.
+
 ```yaml
 description: Template Name
 # Ditt spelnamn. Mellanslag kommer bli omplacerad med understräck och det är en 16-karaktärsgräns.
-name: YourName 
+name: YourName
 game: Minecraft
 accessibility: locations
 progression_balancing: off
@@ -88,27 +103,32 @@ shuffle_structures:
   off: 0
 ```
 
-För mer detaljer om vad varje inställning gör, kolla standardinställningen `PlayerSettings.yaml` som kommer med Archipelago-installationen.
+För mer detaljer om vad varje inställning gör, kolla standardinställningen `PlayerSettings.yaml` som kommer med
+Archipelago-installationen.
 
 ## Gå med i ett Multivärld-spel
 
 ### Skaffa din Minecraft data-fil
+
 **Endast en YAML-fil behöver användats per Minecraft-värld oavsett hur många spelare det är som spelar.**
 
-När du går med it ett Multivärld spel så kommer du bli ombedd att lämna in din YAML-fil till personen som värdar. När detta
-är klart så kommer värden att ge dig antingen en länk till att ladda ner din data-fil,  eller mer en zip-fil som innehåller allas data-filer.
-Din data-fil borde ha en `.apmc` -extension.
+När du går med it ett Multivärld spel så kommer du bli ombedd att lämna in din YAML-fil till personen som värdar. När
+detta är klart så kommer värden att ge dig antingen en länk till att ladda ner din data-fil, eller mer en zip-fil som
+innehåller allas data-filer. Din data-fil borde ha en `.apmc` -extension.
 
 Lägg din data-fil i dina forge-servrar `APData` -mapp. Se till att ta bort alla tidigare data-filer som var i där förut.
 
 ### Koppla till Multiservern
-Efter du har placerat din data-fil i `APData` -mappen, starta forge-servern och se till att you har OP-status
-genom att skriva `/op DittAnvändarnamn` i forger-serverns konsol innan du kopplar dig till din Minecraft klient.
-När du är inne i spelet, skriv `/connect <AP-Address> (<Lösenord>)` där `<AP-Address>` är addressen av
-Archipelago-servern. `(<Lösenord>)` är endast nödvändigt om Archipelago-servern som du använder har ett tillsatt lösenord.
+
+Efter du har placerat din data-fil i `APData` -mappen, starta forge-servern och se till att you har OP-status genom att
+skriva `/op DittAnvändarnamn` i forger-serverns konsol innan du kopplar dig till din Minecraft klient. När du är inne i
+spelet, skriv `/connect <AP-Address> (<Lösenord>)` där `<AP-Address>` är addressen av
+Archipelago-servern. `(<Lösenord>)` är endast nödvändigt om Archipelago-servern som du använder har ett tillsatt
+lösenord.
 
 ### Spela spelet
-När konsolen har informerat att du har gått med i rummet så är du redo att börja spela. Grattis
-att du har lykats med att gått med i ett Multivärld-spel! Vid detta tillfälle, alla ytterligare Minecraft-spelare må koppla
-in till din forge-server.
+
+När konsolen har informerat att du har gått med i rummet så är du redo att börja spela. Grattis att du har lykats med
+att gått med i ett Multivärld-spel! Vid detta tillfälle, alla ytterligare Minecraft-spelare må koppla in till din
+forge-server.
 

WebHostLib/static/assets/tutorial/Ocarina of Time/setup_en.md

@@ -1,34 +1,54 @@
-# Setup Guide for Ocarina of time Archipelago
+# Setup Guide for Ocarina of Time Archipelago
 
 ## Important
 
-As we are using Z5Client and Bizhawk, this guide is only applicable to Windows.
+As we are using Bizhawk, this guide is only applicable to Windows and Linux systems.
 
 ## Required Software
 
-- [bizhawk+script+Z5Client](https://github.com/ArchipelagoMW/Z5Client/releases) We recommend download Z5Client-setup as it makes some steps automatic.
+- Bizhawk: [Bizhawk Releases from TASVideos](https://tasvideos.org/BizHawk/ReleaseHistory)
+  - Version 2.3.1 and later are supported. Version 2.7 is recommended for stability.
+  - Detailed installation instructions for Bizhawk can be found at the above link.
+  - Windows users must run the prereq installer first, which can also be found at the above link.
+- The built-in Archipelago client, which can be installed [here](https://github.com/ArchipelagoMW/Archipelago/releases)
+  (select `Ocarina of Time Client` during installation).
+- An Ocarina of Time v1.0 ROM.
 
-## Install Emulator and client
+## Configuring Bizhawk
 
-Download getBizhawk.ps1 from previous link. Place it on the folder where you want your emulator to be installed, right click on it and select "Run with PowerShell". This will download all the needed dependencies used by the emulator. This can take a while.
+Once Bizhawk has been installed, open Bizhawk and change the following settings:
 
-It is strongly recommended to associate N64 rom extension (\*.n64) to the Bizhawk we've just installed. To do so, we simple have to search any N64 rom we happened to own, right click and select "Open with...", we unfold the list that appears and select the bottom option "Look for another application", we browse to Bizhawk folder and select EmuHawk.exe
+- Go to Config > Customize. Switch to the Advanced tab, then switch the Lua Core from "NLua+KopiLua" to
+  "Lua+LuaInterface". This is required for the Lua script to function correctly.
+- Under Config > Customize > Advanced, make sure the box for AutoSaveRAM is checked, and click the 5s button.
+  This reduces the possibility of losing save data in emulator crashes.
+- Under Config > Customize, check the "Run in background" and "Accept background input" boxes. This will allow you to
+  continue playing in the background, even if another window is selected.
+- Under Config > Hotkeys, many hotkeys are listed, with many bound to common keys on the keyboard. You will likely want
+  to disable most of these, which you can do quickly using `Esc`.
+- If playing with a controller, when you bind controls, disable "P1 A Up", "P1 A Down", "P1 A Left", and "P1 A Right"
+  as these interfere with aiming if bound. Set directional input using the Analog tab instead.
 
-Place the ootMulti.lua file from the previous link inside the "lua" folder from the just installed emulator.
-
-Install the Z5Client using its setup.
+It is strongly recommended to associate N64 rom extensions (\*.n64, \*.z64) to the Bizhawk we've just installed.
+To do so, we simply have to search any N64 rom we happened to own, right click and select "Open with...", unfold
+the list that appears and select the bottom option "Look for another application", then browse to the Bizhawk folder
+and select EmuHawk.exe.
 
 ## 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.
+
+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 OOT yaml will look like this. There are lots of cosmetic options that have been removed for the sake of this tutorial, if you want to see a complete list, download [Archipelago](https://github.com/ArchipelagoMW/Archipelago/releases) and look for the sample file in the "Players" folder.
+A basic OoT yaml will look like this. There are lots of cosmetic options that have been removed for the sake of this
+tutorial, if you want to see a complete list, download Archipelago from
+the [Archipelago Releases Page](https://github.com/ArchipelagoMW/Archipelago/releases) and look for the sample file in
+the "Players" folder.
+
 ```yaml
 description: Default Ocarina of Time Template # Used to describe your yaml. Useful if you have multiple files
 # Your name in-game. Spaces will be replaced with underscores and there is a 16 character limit
@@ -371,17 +391,22 @@ Ocarina of Time:
 
 ### Obtain your OOT patch file
 
-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 `.z5ap` extension.
+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 `.apz5` extension.
 
-Double click on your `.z5ap` file to start Z5Client and start the ROM patch process. Once the process is finished (this can take a while), the emulator will be started automatically (If we associated the extension to the emulator as recommended)
+Double-click on your `.apz5` file to start your client and start the ROM patch process. Once the process is finished
+(this can take a while), the client and the emulator will be started automatically (if you associated the extension
+to the emulator as recommended).
 
-### Connect to multiserver
-Once both the Z5Client and the emulator are started we must connect them. Within the emulator we click on the "Tools" menu and select "Lua console". In the new window click on the folder icon and look for the ootMulti.lua file. Once the file is loaded it will connect automatically to Z5Client.
+### Connect to the Multiserver
 
-Note: We strongly advise you don't open any emulator menu while it and Z5client are connected, as the script will halt and disconnects can happen. If you get disconnected just double click on the script again.
+Once both the client and the emulator are started, you must connect them. Within the emulator click on the "Tools"
+menu and select "Lua Console". Click the folder button or press Ctrl+O to open a Lua script.
 
-To connect the client to the multiserver simply put address:port on the textfield on top and press enter (if the server uses password, type on the bottom textfield /connect <address>:<port> [password], to connect) 
+Navigate to your Archipelago install folder and open `data/lua/OOT/oot_connector.lua`.
 
-Now you are ready to start your adventure in Hyrule.
+To connect the client to the multiserver simply put `<address>:<port>` on the textfield on top and press enter (if the
+server uses password, type in the bottom textfield `/connect <address>:<port> [password]`)
+
+Now you are ready to start your adventure in Hyrule.

WebHostLib/static/assets/tutorial/Ocarina of Time/setup_es.md

@@ -6,13 +6,19 @@ Al usar el cliente y bizhawk, esta guia solo es aplicable en Windows.
 
 ## Software Requerido
 
-- [bizhawk+script+Z5Client](https://github.com/ArchipelagoMW/Z5Client/releases) Recomendamos bajar el setup de Z5client ya que automatizara varios pasos mas adelante
+- [bizhawk+script+Z5Client](https://github.com/ArchipelagoMW/Z5Client/releases) Recomendamos bajar el setup de Z5client
+  ya que automatizara varios pasos mas adelante
 
 ## Instala emulador y cliente
 
-Descarga el fichero getBizhawk.ps1 del enlace anterior. Colocalo en la carpeta donde desees instalar el emulador, haz click derecho en él y selecciona "Ejecutar con PowerShell". Esto descargará todas las dependencias necesarias para el emulador. Puede tardar un rato.
+Descarga el fichero getBizhawk.ps1 del enlace anterior. Colocalo en la carpeta donde desees instalar el emulador, haz
+click derecho en él y selecciona "Ejecutar con PowerShell". Esto descargará todas las dependencias necesarias para el
+emulador. Puede tardar un rato.
 
-Es recomendable asociar la extensión de las roms de N64 (\*.n64) al bizhawk que hemos instalado anteriormente. Para hacerlo simplemente debemos buscar alguna rom de n64 que tengamos, hacer click derecho, seleccionar "Abrir con...", desplegar la lista y buscar la opción "Buscar otra aplicación", navegar hasta el directorio de bizhawk y seleccionar EmuHawk.exe
+Es recomendable asociar la extensión de las roms de N64 (\*.n64) al bizhawk que hemos instalado anteriormente. Para
+hacerlo simplemente debemos buscar alguna rom de n64 que tengamos, hacer click derecho, seleccionar "Abrir con...",
+desplegar la lista y buscar la opción "Buscar otra aplicación", navegar hasta el directorio de bizhawk y seleccionar
+EmuHawk.exe
 
 Situa el fichero ootMulti.lua del enlace anterior en la carpeta "lua" del emulador recien instalado.
 
@@ -21,16 +27,21 @@ Instala el cliente Z5Client.
 ## Configura tu fichero YAML
 
 ### Que es un fichero YAML y por qué necesito uno?
-Tu fichero YAML contiene un numero de opciones que proveen al generador con información 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
+
+Tu fichero YAML contiene un numero de opciones que proveen al generador con información 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 OOT tendra este aspecto. (Hay muchas opciones cosméticas que se han ignorado para este tutorial, si quieres ver una lista completa, descarga (Archipelago)[https://github.com/ArchipelagoMW/Archipelago/releases] y buscar el fichero de ejemplo en el directorio "Players"))
+
+Un fichero basico yaml para OOT tendra este aspecto. (Hay muchas opciones cosméticas que se han ignorado para este
+tutorial, si quieres ver una lista completa, descarga (
+Archipelago)[https://github.com/ArchipelagoMW/Archipelago/releases] y buscar el fichero de ejemplo en el directorio "
+Players"))
+
 ```yaml
 description: Default Ocarina of Time Template # Describe tu fichero yalm
-\# Tu nombre en el juego. Los espacio seran reemplazados por _ y hay un limite de 16 caracteres
+  \# Tu nombre en el juego. Los espacio seran reemplazados por _ y hay un limite de 16 caracteres
 name: YourName{number}
 game:
   Ocarina of Time: 1
@@ -355,18 +366,26 @@ Ocarina of Time:
 
 ### Obten tu parche
 
+Cuando te unes a un juego multiworld, se te pedirá que entregues tu fichero YAML a quien sea que hospede el juego
+multiworld. 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 `.z5ap`.
 
-Cuando te unes a un juego multiworld, se te pedirá que entregues tu fichero YAML a quien sea que hospede el juego multiworld.
-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 `.z5ap`.
-
-Haz doble click en tu fichero `.z5ap` para que se arranque el Z5Client y realize el parcheado de la ROM. Una vez acabe el parcheado de la rom (esto puede llevar un tiempo) se abrira automaticamente el emulador (Si se ha asociado la extensión al emulador tal como hemos recomendado)
+Haz doble click en tu fichero `.z5ap` para que se arranque el Z5Client y realize el parcheado de la ROM. Una vez acabe
+el parcheado de la rom (esto puede llevar un tiempo) se abrira automaticamente el emulador (Si se ha asociado la
+extensión al emulador tal como hemos recomendado)
 
 ### Conectar al multiserver
-Una vez arrancado tanto el Z5Client como el emulador hay que conectarlo entre ellos, para ello simplemente accede al menú "Tools" y selecciona "Lua console". En la nueva ventana, dale al icono de la carpeta y busca el fichero ootMulti.lua. Al cargar dicho fichero se conectara automaticamente con el cliente.
 
-Nota: Es muy recomendable que no se abra ningún menú del emulador mientras esten emulador y Z5Client conectados, ya que el script de conexión se para en ese caso y pueden provocar desconexiones. Si se pierde la conexion, simplemente haz doble click en el script de nuevo.
+Una vez arrancado tanto el Z5Client como el emulador hay que conectarlo entre ellos, para ello simplemente accede al
+menú "Tools" y selecciona "Lua console". En la nueva ventana, dale al icono de la carpeta y busca el fichero
+ootMulti.lua. Al cargar dicho fichero se conectara automaticamente con el cliente.
 
-Para conectar el cliente con el servidor simplemente pon la direccion_IP:puerto en la caja de texto de arriba y presiona enter (si el servidor tiene contraseña, en la caja de texto de abajo escribir /connect direccion:puerto contraseña, para conectar) 
+Nota: Es muy recomendable que no se abra ningún menú del emulador mientras esten emulador y Z5Client conectados, ya que
+el script de conexión se para en ese caso y pueden provocar desconexiones. Si se pierde la conexion, simplemente haz
+doble click en el script de nuevo.
+
+Para conectar el cliente con el servidor simplemente pon la direccion_IP:puerto en la caja de texto de arriba y presiona
+enter (si el servidor tiene contraseña, en la caja de texto de abajo escribir /connect direccion:puerto contraseña, para
+conectar)
 
 Y ya estas listo, para emprender tu aventura por Hyrule.

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

@@ -0,0 +1,89 @@
+# Raft Randomizer Setup Guide
+
+## Required Software
+
+- [Raft](https://store.steampowered.com/app/648800/Raft/)
+- [Raft Mod Loader](https://www.raftmodding.com/loader) ("*RML*")
+- [Raftipelago mod](https://www.raftmodding.com/mods/raftipelago)
+
+## Installation Procedures
+
+1. Install Raft. The currently-supported Raft version is Update 13: The Renovation Update. If you plan on playing Raft mainly with Archipelago, it's recommended to disable Raft auto-updating through Steam, as there is no beta channel to get old builds.
+
+2. Install RML.
+
+3. Install the Raftipelago mod from the Raft Modding website. You should open the auto-installation link on the webpage through RML. Alternatively, you can download the .rmod file and place it in the Mods folder manually.
+
+4. Open RML and click Play. If you've already installed it, the shortcut in the Start Menu is called "RMLLauncher.exe". Raft should start.
+
+5. Open the RML menu. This should open automatically when Raft first loads. If it does not, and you see RML information in the top center of the Raft main menu, press F9 to open it.
+
+6. Navigate to the "Mod manager" tab in the left-hand menu.
+
+7. Click on the plug icon for Raftipelago to load the mod.
+
+## Installation Troubleshooting
+
+You can press F10 to open the console to view any errors when loading the mod.
+
+### DLL/Reflection/Image errors
+
+Restart Raft and try again. These should be ephemeral errors.
+
+### RML says to start Raft through Steam
+
+If this happens, then RML is configured to only inject into an existing instance of Raft, rather than try and start a new one.
+
+You can either:
+- Click "Play" after Raft has loaded into the main menu
+- Uncheck the box next to the "Disable Automatic Game Start" setting in the Settings menu then click Play.
+
+### RML doesn't do anything when I click Play
+
+If this happens, then RML is configured to only start a new instance of Raft, then inject into that specific instance. This also means that RML has detected an instance of Raft is already running, and will not start a new one.
+
+You can either:
+- Close the existing instance of Raft then click Play
+- Check the box next to the "Disable Automatic Game Start" setting in the Settings menu then click Play.
+    
+## Joining a MultiWorld Game
+
+1. Ensure you're on the Main Menu with Raftipelago loaded.
+
+2. Open the Debug Console by pressing F10.
+
+3. Type */connect {serverAddress} {username} {password}* into the console and hit Enter.
+    - Example: */connect archipelago.gg:12345 SunnyBat*
+    - serverAddress must not contain spaces.
+    - If your username or password contains spaces, surround that value with quotation marks ("). Adding quotation marks even when not necessary (eg "SunnyBat") is fine.
+    - If your username or password starts with a quotation mark, surround the value with an additional set of quotation marks (eg the value *"myP@s$w0rD* would be entered as *""myP@s$w0rD"*).
+
+4. Start a new game or load an existing one.
+    - Raftipelago save games are marked as *incompatible* with vanilla Raft. This means when Raftipelago is not loaded, saves made with Raftipelago will show as corrupt/unselectable.
+    - Avoid using an existing game that was not created with your current run of Raftipelago (either vanilla or a different Raftipelago run). It will work, but if anything is unlocked, it will be automatically registered with Archipelago once the world is loaded. This is irreversible.
+
+5. You can disconnect from an Archipelago server by typing */disconnect confirmDisconnect* into the console and hitting Enter.
+
+## Multiplayer Raft
+
+You're able to have multiple Raft players on a single Raftipelago world. This will work, with a few notes:
+- Only the player that creates/loads the world can connect to Archipelago (this is the "host" of the Raft world). Other players do not need to connect; everything will be routed through the the host.
+- Resource Packs are only received by the host and any other players connected to the Raft world when the resource pack is received.
+- Players other than the host will be labeled as a "Raft Player (Steam name)" when using ingame chat, which will be routed through Archipelago chat.
+- Ingame chat will only work when the host is connected to the Archipelago server.
+
+## Game Troubleshooting
+
+### The "Load game" button is disabled for my world / my world is corrupt
+
+Be sure that you click the "Load game" button **after** you load Raftipelago. You can click the Load Game button again to reload all of the saves in your folder (there is no need to restart Raft if the mod loaded successfully).
+
+### I'm certain I'm doing things correctly, but the world is still not loadable
+
+You can bypass Raftipelago world verification checks by loading a backup of the world. If the backup is not loadable, the world is corrupted.
+
+In the future, be sure that when you save the game, the Raftipelago mod is loaded.
+
+### I disconnected from the server! What do I do to reconnect?
+
+Open the console with F10 and type the */connect* command with your server/username/password in again. You do not need to save+quit to the main menu beforehand.

WebHostLib/static/assets/tutorial/Risk of Rain 2/setup_en.md

@@ -1,39 +1,46 @@
 # Risk of Rain 2 Setup Guide
 
 ## Install using r2modman
+
 ### Install r2modman
+
 Head on over to the r2modman page on Thunderstore and follow the installation instructions.
 
-[https://thunderstore.io/package/ebkr/r2modman/](https://thunderstore.io/package/ebkr/r2modman/)
+[r2modman Page](https://thunderstore.io/package/ebkr/r2modman/)
 
 ### Install Archipelago Mod using r2modman
+
 You can install the Archipelago mod using r2modman in one of two ways.
 
-[https://thunderstore.io/package/ArchipelagoMW/Archipelago/](https://thunderstore.io/package/ArchipelagoMW/Archipelago/)
+[Archipelago Mod Download Page](https://thunderstore.io/package/ArchipelagoMW/Archipelago/)
 
 One, you can use the Thunderstore website and click on the "Install with Mod Manager" link.
 
-You can also search for the "Archipelago" mod in the r2modman interface.
-The mod manager should automatically install all necessary dependencies as well.
+You can also search for the "Archipelago" mod in the r2modman interface. The mod manager should automatically install
+all necessary dependencies as well.
 
 ### Running the Modded Game
-Click on the "Start modded" button in the top left in r2modman to start the game with the
-Archipelago mod installed.
+
+Click on the "Start modded" button in the top left in r2modman to start the game with the Archipelago mod installed.
 
 ## Joining an Archipelago Session
-There will be a menu button on the right side of the screen in the character select menu. 
-Click it in order to bring up the in lobby mod config. 
-From here you can expand the Archipelago sections and fill in the relevant info.
-Keep password blank if there is no password on the server.
+
+There will be a menu button on the right side of the screen in the character select menu. Click it in order to bring up
+the in lobby mod config. From here you can expand the Archipelago sections and fill in the relevant info. Keep password
+blank if there is no password on the server.
 
 Simply check `Enable Archipelago?` and when you start the run it will automatically connect.
 
 ## Gameplay
-The Risk of Rain 2 players send checks by causing items to spawn in-game. That means opening chests or killing bosses, generally. 
-An item check is only sent out after a certain number of items are picked up. This count is configurable in the player's YAML.
+
+The Risk of Rain 2 players send checks by causing items to spawn in-game. That means opening chests or killing bosses,
+generally. An item check is only sent out after a certain number of items are picked up. This count is configurable in
+the player's YAML.
 
 ## YAML Settings
+
 An example YAML would look like this:
+
 ```yaml
 description: Ijwu-ror2
 name: Ijwu
@@ -82,10 +89,11 @@ Risk of Rain 2:
 | item_pool_presets | A simple toggle to determine whether the item_weight presets are used or the custom item pool as defined below | true/false |
 | custom item weights | Each defined item here is a single item in the pool that will have a weight against the other items when the item pool gets generated. These values can be modified to adjust how frequently certain items appear | 0-100|
 
+Using the example YAML above: the Risk of Rain 2 player will have 15 total items which they can pick up for other
+players. (total_locations = 15)
 
-Using the example YAML above: the Risk of Rain 2 player will have 15 total items which they can pick up for other players. (total_locations = 15)
-
-They will have 15 items waiting for them in the item pool which will be distributed out to the multiworld. (total_locations = 15)
+They will have 15 items waiting for them in the item pool which will be distributed out to the multiworld. (
+total_locations = 15)
 
 They will complete a location check every second item. (item_pickup_step = 1)
 
@@ -95,4 +103,5 @@ The player will also start with a `Dio's Best Friend`. (start_with_revive = true
 
 The player will have lunar items shuffled into the item pool on their behalf. (enable_lunar = true)
 
-The player will have the default preset generated item pool with the custom item weights being ignored. (item_weights: default and item_pool_presets: true)
+The player will have the default preset generated item pool with the custom item weights being ignored. (item_weights:
+default and item_pool_presets: true)

WebHostLib/static/assets/tutorial/Rogue Legacy/rogue-legacy_en.md

@@ -0,0 +1,52 @@
+# Rogue Legacy Randomizer Setup Guide
+
+## Required Software
+
+- Rogue Legacy Randomizer from
+  the [Rogue Legacy Randomizer Releases Page](https://github.com/ThePhar/RogueLegacyRandomizer/releases)
+
+## 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?
+
+you can customize your settings by visiting the [Rogue Legacy Settings Page](/games/Rogue%20Legacy/player-settings).
+
+### Connect to the MultiServer
+
+Once in game, press the start button and the AP connection screen should appear. You will fill out the hostname, port,
+slot name, and password (if applicable). You should only need to fill out hostname, port, and password if the server
+provides an alternative one to the default values.
+
+### Play the game
+
+Once you have entered the required values, you go to Connect and then select Confirm on the "Ready to Start" screen. Now
+you're off to start your legacy!
+
+## Manual Installation
+
+In order to run Rogue Legacy Randomizer you will need to have Rogue Legacy installed on your local machine. Extract the
+Randomizer release into a desired folder **outside** of your Rogue Legacy install. Copy the following files from your
+Rogue Legacy install into the main directory of your Rogue Legacy Randomizer install:
+
+- DS2DEngine.dll
+- InputSystem.dll
+- Nuclex.Input.dll
+- SpriteSystem.dll
+- Tweener.dll
+
+And copy the directory from your Rogue Legacy install as well into the main directory of your Rogue Legacy Randomizer
+install:
+
+- Content/
+
+Then copy the contents of the CustomContent directory in your Rogue Legacy Randomizer into the newly copied Content
+directory and overwrite all files.
+
+**BE SURE YOU ARE REPLACING THE COPIED FILES IN YOUR ROGUE LEGACY RANDOMIZER DIRECTORY AND NOT REPLACING YOUR ROGUE
+LEGACY FILES!**

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

@@ -0,0 +1,163 @@
+# SMZ3 Setup Guide
+
+## Required Software
+
+- One of the client programs:
+  - [SNIClient](https://github.com/ArchipelagoMW/Archipelago/releases), included with the main 
+  Archipelago install. Make sure to check the box for `SNI Client - Super Metroid Patch Setup` and 
+  `SNI Client - A Link to the Past Patch Setup`
+- Hardware or software capable of loading and playing SNES ROM files
+    - An emulator capable of connecting to SNI such as:
+        - snes9x Multitroid
+          from: [snes9x Multitroid Download](https://drive.google.com/drive/folders/1_ej-pwWtCAHYXIrvs5Hro16A1s9Hi3Jz),
+        - BizHawk from: [BizHawk Website](http://tasvideos.org/BizHawk.html)
+        - RetroArch 1.10.3 or newer from: [RetroArch BuildBot Website](https://buildbot.libretro.com/) - nightly builds
+          are required until 1.10.3 is released. Or,
+    - An SD2SNES, FXPak Pro ([FXPak Pro Store Page](https://krikzz.com/store/home/54-fxpak-pro.html)), or other
+      compatible hardware
+- Your legally obtained Super Metroid ROM file, probably named `Super Metroid (Japan, USA).sfc` and
+  Your Japanese Zelda3 v1.0 ROM file, probably named `Zelda no Densetsu - Kamigami no Triforce (Japan).sfc`
+
+## Installation Procedures
+
+### Windows Setup
+
+1. During the installation of Archipelago, you will have been asked to install the SNI Client. If you did not do this,
+   or you are on an older version, you may run the installer again to install the SNI Client.
+2. During setup, you will be asked to locate your base ROM files. This is your Super Metroid and Zelda3 ROM files.
+3. 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.
+
+## Create a Config (.yaml) File
+
+### What is a config file and why do I need one?
+
+See the guide on setting up a basic YAML at the Archipelago setup
+guide: [Basic Multiworld Setup Guide](/tutorial/archipelago/setup/en)
+
+### Where do I get a config file?
+
+The Player Settings page on the website allows you to configure your personal settings and export a config file from
+them. Player settings page: [SMZ3 Player Settings Page](/games/SMZ3/player-settings)
+
+### Verifying your config file
+
+If you would like to validate your config file to make sure it works, you may do so on the YAML Validator page. YAML
+validator page: [YAML Validation page](/mysterycheck)
+
+## Generating a Single-Player Game
+
+1. Navigate to the Player Settings page, configure your options, and click the "Generate Game" button.
+    - Player Settings page: [SMZ3 Player Settings Page](/games/SMZ3/player-settings)
+2. You will be presented with a "Seed Info" page.
+3. Click the "Create New Room" link.
+4. You will be presented with a server page, from which you can download your patch file.
+5. Double-click on your patch file, and the SMZ3 Client will launch automatically, create your ROM from the
+   patch file, and open your emulator for you.
+6. Since this is a single-player game, you will no longer need the client, so feel free to close it.
+
+## 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 config 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 `.apsmz` 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 in the same place as your patch file.
+
+### Connect to the client
+
+#### With an emulator
+
+When the client launched automatically, SNI 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. Select the connector lua file included with your client
+    - SuperNintendoClient users should download `sniConnector.lua` from the client download page
+    - SNIClient users should look in their Archipelago folder for `/SNI/lua/x64` or `/SNI/lua/x86` depending on if the
+      emulator is 64-bit or 32-bit.
+
+##### 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. Select the `Connector.lua` file included with your client
+    - SuperNintendoClient users should download `sniConnector.lua` from the client download page
+    - SNIClient users should look in their Archipelago folder for `/SNI/lua/x64` or `/SNI/lua/x86` depending on if the
+      emulator is 64-bit or 32-bit. Please note the most recent versions of BizHawk are 64-bit only.
+
+##### RetroArch 1.10.3 or newer
+
+You only have to do these steps once. Note, RetroArch 1.9.x will not work as it is older than 1.10.3.
+
+1. Enter the RetroArch main menu screen.
+2. Go to Settings --> User Interface. Set "Show Advanced Settings" to ON.
+3. Go to Settings --> Network. Set "Network Commands" to ON. (It is found below Request Device 16.) Leave the default
+   Network Command Port at 55355.
+![Screenshot of Network Commands setting](/static/assets/tutorial/retroarch-network-commands-en.png)
+4. Go to Main Menu --> Online Updater --> Core Downloader. Scroll down and select "Nintendo - SNES / SFC (bsnes-mercury
+   Performance)".
+
+When loading a ROM, be sure to select a **bsnes-mercury** core. These are the only cores that allow external tools to
+read ROM data.
+
+#### 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 on the SD2SNES releases page. SD2SNES
+releases page: [SD2SNES Releases Page](https://github.com/RedGuyyyy/sd2snes/releases)
+
+Other hardware may find helpful information on the usb2snes platforms
+page: [usb2snes Supported Platforms Page](http://usb2snes.com/#supported-platforms)
+
+1. Close your emulator, which may have auto-launched.
+2. Power on your device and load the ROM.
+
+### Connect to the Archipelago Server
+
+The patch file which launched your client should have automatically connected you to the AP Server. 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".
+
+### 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 our hosting service. The process is relatively simple:
+
+1. Collect config files from your players.
+2. Create a zip file containing your players' config files.
+3. Upload that zip file to the Generate page above.
+    - Generate page: [WebHost Seed Generation Page](/generate)
+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.
+7. Note that a link to a MultiWorld Tracker is at the top of the room page. The tracker shows the progress of all
+   players in the game. Any observers may also be given the link to this page.
+8. Once all players have joined, you may begin playing.

WebHostLib/static/assets/tutorial/Secret of Evermore/multiworld_en.md

@@ -0,0 +1,145 @@
+# Secret of Evermore Setup Guide
+
+## Required Software
+
+- SNI from: [SNI Releases Page](https://github.com/alttpo/sni/releases)
+    - v0.0.59 or newer (included in Archipelago 0.2.1 setup)
+- Hardware or software capable of loading and playing SNES ROM files
+    - An emulator capable of connecting to SNI with ROM access. Any one of the following will work:
+        - snes9x-rr from: [snes9x-rr Releases Page](https://github.com/gocha/snes9x-rr/releases)
+        - BizHawk from: [BizHawk Website](http://tasvideos.org/BizHawk.html)
+        - bsnes-plus-nwa from: [bsnes-plus GitHub](https://github.com/black-sliver/bsnes-plus)
+        - RetroArch from: [RetroArch Website](https://retroarch.com?page=platforms). Or,
+    - Or SD2SNES, FXPak Pro ([FXPak Pro Store Page](https://krikzz.com/store/home/54-fxpak-pro.html)), or other
+      compatible hardware.
+- Your legally obtained Secret of Evermore US ROM file, probably named `Secret of Evermore (USA).sfc`
+
+## Create a Config (.yaml) File
+
+### What is a config file and why do I need one?
+
+See the guide on setting up a basic YAML at the Archipelago setup
+guide: [Basic Multiworld Setup Guide](/tutorial/archipelago/setup/en)
+
+### Where do I get a config file?
+
+The Player Settings page on the website allows you to configure your personal settings and export a config file from
+them. Player settings page: [Secret of Evermore Player Settings PAge](/games/Secret%20of%20Evermore/player-settings)
+
+### Verifying your config file
+
+If you would like to validate your config file to make sure it works, you may do so on the YAML Validator
+page: [YAML Validation page](/mysterycheck)
+
+## Generating a Single-Player Game
+
+Stand-alone "Evermizer" has a way of balancing single-player games, but may not always be on par feature-wise. Head over
+to the [Evermizer Website](https://evermizer.com) if you want to try the official stand-alone, otherwise read below.
+
+1. Navigate to the Player Settings page, configure your options, and click the "Generate Game" button.
+    - Player Settings page: [Secret of Evermore Player Settings Page](/games/Secret%20of%20Evermore/player-settings)
+2. You will be presented with a "Seed Info" page.
+3. Click the "Create New Room" link.
+4. You will be presented with a server page, from which you can download your patch file.
+5. Run your patch file through the apbpatch on evermizer.com and load it in your emulator or console.
+    * apbpatch page: [Evermizer apbpatch Page](https://evermizer.com/apbpatch)
+
+## 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 config 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 `.apsoe` extension.
+
+Put your patch file on your desktop or somewhere convenient, open the apbpatch page on evermizer.com and generate your
+ROM from it. Load the ROM file in your emulator or console. apbpatch
+page: [Evermizer apbpatch Page](https://evermizer.com/apbpatch)
+
+### Connect to SNI
+
+#### With an emulator
+
+Start SNI either from the Archipelago install folder or the stand-alone version. If this is its first time launching,
+you may be prompted to allow it to communicate through the Windows Firewall.
+
+##### snes9x-rr
+
+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. Select the `Connector.lua` file from your SNI installation:
+    * `SNI/lua/x86/Connector.lua` for 32bit snes9x-rr or
+    * `SNI/lua/x64/Connector.lua` for "x64" snes9x-rr
+6. Leave the Lua window open while you are playing.
+
+* If the script window complains about missing `socket.dll` make sure it is in the lua directory.
+* If the script window complains about "Bad EXE format", use the other Connector above (x86 <-> x64)
+
+##### 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. Select any `Connector.lua` file from your SNI installation
+
+##### bsnes-plus-nwa
+
+This should automatically connect to SNI. If this is its first time launching, you may be prompted to allow it to
+communicate through the Windows Firewall.
+
+##### RetroArch
+
+You only have to do these steps once.
+
+1. Enter the RetroArch main menu screen.
+2. Go to Settings --> User Interface. Set "Show Advanced Settings" to ON.
+3. Go to Settings --> Network. Set "Network Commands" to ON. (It is found below Request Device 16.) Leave the default
+   Network Command Port at 55355.
+![Screenshot of Network Commands setting](/static/assets/tutorial/retroarch-network-commands-en.png)
+4. Go to Main Menu --> Online Updater --> Core Downloader. Scroll down and select "Nintendo - SNES / SFC (bsnes-mercury
+   Performance)".
+
+When loading a ROM, be sure to select a **bsnes-mercury** core. These are the only cores that allow external tools to
+read ROM data.
+
+#### 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 on the SD2SNES releases page. SD2SNES
+releases page: [SD2SNES Releases Page](https://github.com/RedGuyyyy/sd2snes/releases)
+
+Other hardware may find helpful information on the usb2snes platforms
+page: [usb2snes Supported Platforms Page](http://usb2snes.com/#supported-platforms)
+
+1. Copy the ROM file to your SD card.
+2. Load the ROM file from the menu.
+
+### Open the client
+
+Open ap-soeclient ([Evermizer Archipelago Client Page](http://evermizer.com/apclient)) in a modern browser. Do not
+switch tabs, open it in a new window if you want to use the browser while playing. Do not minimize the window with the
+client.
+
+The client should automatically connect to SNI, the "SNES" status should change to green.
+
+### Connect to the Archipelago Server
+
+Enter `/connect server:port` in the client's command prompt and press enter. You'll find `server:port` on the same page
+that had the patch file.
+
+### Play the game
+
+When the game is loaded but not yet past the intro cutscene, the "Game" status is yellow. When the client shows "AP" as
+green and "Game" as yellow, you're ready to play. The intro can be skipped pressing the START button and "Game" should
+change to green. Congratulations on successfully joining a multiworld game!
+
+## Hosting a MultiWorld game
+
+The recommended way to host a game is to use our hosting service on the [seed generation page](/generate). Or check out
+the Archipelago website guide for more information: [Archipelago Website Guide](/tutorial/archipelago/using_website/en)

WebHostLib/static/assets/tutorial/Slay the Spire/slay-the-spire_en.md

@@ -0,0 +1,36 @@
+# Slay the Spire Setup Guide
+
+## Required Software
+
+For steam-based installation, subscribe to the following mods:
+
+- ModTheSpire from the [Slay the Spire Workshop](https://steamcommunity.com/sharedfiles/filedetails/?id=1605060445)
+- BaseMod from the [Slay the Spire Workshop](https://steamcommunity.com/workshop/filedetails/?id=1605833019)
+- Archipelago Multiworld Randomizer Mod from
+  the [Slay the Spire Workshop](https://steamcommunity.com/sharedfiles/filedetails/?id=2596397288)
+
+## 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?
+
+you can customize your settings by visiting
+the [Slay the Spire Settings Page](/games/Slay%20the%20Spire/player-settings).
+
+### Connect to the MultiServer
+
+For Steam-based installations, if you are subscribed to ModTheSpire, when you launch the game, you should have the
+option to launch the game with mods. On the mod loader screen, ensure you only have the following mods enabled and then
+start the game:
+
+- BaseMod
+- Archipelago Multiworld Randomizer
+
+Once you are in-game, you will be able to click the **Archipelago** menu option and enter the ip and port (separated by
+a colon) in the hostname field and enter your player slot name in the Slot Name field. Then click connect, and now you
+are ready to climb the spire!

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

@@ -2,31 +2,36 @@
 
 ## Required Software
 
-- [Subnautica](https://store.steampowered.com/app/264710/Subnautica/)
-- [QModManager4](https://www.nexusmods.com/subnautica/mods/201)
-- [Archipelago Mod for Subnautica](https://github.com/Berserker66/ArchipelagoSubnauticaModSrc/releases)
-
+- Subnautica from: [Subnautica Steam Store Page](https://store.steampowered.com/app/264710/Subnautica/)
+- QModManager4 from: [QModManager4 Nexus Mods Page](https://www.nexusmods.com/subnautica/mods/201)
+- Archipelago Mod for Subnautica
+  from: [Subnautica Archipelago Mod Releases Page](https://github.com/Berserker66/ArchipelagoSubnauticaModSrc/releases)
 
 ## Installation Procedures
 
 1. Install QModManager4 as per its instructions.
 
-2. The folder you installed QModManager4 into will now have a /QMods directory. It might appear after a start of Subnautica. You can also create this folder yourself.
+2. The folder you installed QModManager4 into will now have a /QMods directory. It might appear after a start of
+   Subnautica. You can also create this folder yourself.
 
 3. Unpack the Archipelago Mod into this folder, so that Subnautica/QMods/Archipelago/ is a valid path.
 
-4. Start Subnautica. You should see a Connect Menu in the topleft of your main Menu. 
+4. Start Subnautica. You should see a Connect Menu in the topleft of your main Menu.
 
 ## Troubleshooting
 
-If you don't see the connect window check that you see a qmodmanager_log-Subnautica.txt in Subnautica, if not QModManager4 is not correctly installed, otherwise open it and look for `[Info   :   BepInEx] Loading [Archipelago 1.0.0.0]`, version number doesn't matter. If it doesn't show this, then QModManager4 didn't find the Archipelago mod, so check your paths.
-    
+If you don't see the connect window check that you see a qmodmanager_log-Subnautica.txt in Subnautica, if not
+QModManager4 is not correctly installed, otherwise open it and look
+for `[Info   :   BepInEx] Loading [Archipelago 1.0.0.0]`, version number doesn't matter. If it doesn't show this, then
+QModManager4 didn't find the Archipelago mod, so check your paths.
+
 ## Joining a MultiWorld Game
 
-1. In Host, enter the address of the server, such as archipelago.gg:38281, your server host should be able to tell you this.
+1. In Host, enter the address of the server, such as archipelago.gg:38281, your server host should be able to tell you
+   this.
 
 2. In Password enter the server password if one exists, otherwise leave blank.
 
 3. In PlayerName enter your "name" field from the yaml, or website config.
 
-4. Hit Connect. If it says succesfully authenticated you can now create a new savegame or resume the correct savegame.
+4. Hit Connect. If it says successfully authenticated you can now create a new savegame or resume the correct savegame.

WebHostLib/static/assets/tutorial/Super Mario 64/setup_en.md

@@ -0,0 +1,88 @@
+# Super Mario 64 EX MultiWorld Setup Guide
+
+## Required Software
+
+- Super Mario 64 US Rom (Japanese may work also. Europe and Shindou not supported)
+- Either of [sm64pclauncher](https://github.com/N00byKing/sm64pclauncher/releases) or
+- Cloning and building [sm64ex](https://github.com/N00byKing/sm64ex) manually.
+
+NOTE: The above linked sm64pclauncher is a special version designed to work with the Archipelago build of sm64ex.
+You can use other sm64-port based builds with it, but you can't use a different launcher with the Archipelago build of sm64ex.
+
+## Installation and Game Start Procedures
+
+# Installation via sm64pclauncher (For Windows)
+
+First, install [MSYS](https://www.msys2.org/) as described on the page. DO NOT INSTALL INTO A FOLDER PATH WITH SPACES.
+Do all steps up to including step 6.
+Best use default install directory.
+Then follow the steps below
+
+1. Go to the page linked for sm64pclauncher, and press on the topmost entry
+3. Scroll down, and download the zip file
+4. Unpack the zip file in an empty folder
+5. Run the Launcher and press build.
+6. Set the location where you installed MSYS when prompted. Check the "Install Dependencies" Checkbox
+7. Set the Repo link to `https://github.com/N00byKing/sm64ex` and the Branch to `archipelago` (Top two boxes). You can choose the folder (Secound Box) at will, as long as it does not exist yet
+8. Point the Launcher to your Super Mario 64 US/JP Rom, and set the Region correspondingly
+9. Set Build Options. Recommended: `-jn` where `n` is the Number of CPU Cores, to build faster.
+10. SM64EX will now be compiled. The Launcher will appear to have crashed, but this is not likely the case. Best wait a bit, but there may be a problem if it takes longer than 10 Minutes
+
+After it's done, the Build list should have another entry titled with what you named the folder in step 7.
+
+NOTE: For some reason first start of the game always crashes the launcher. Just restart it.
+If it still crashes, recheck if you typed the launch options correctly (Described in "Joining a MultiWorld Game")
+
+# Manual Compilation (Linux/Windows)
+
+Dependencies for Linux: `sdl2 glew cmake python make`.
+Dependencies for Windows: `mingw-w64-x86_64-gcc mingw-w64-x86_64-glew mingw-w64-x86_64-SDL2 git make python3 cmake`
+SM64EX will link `jsoncpp` dynamic if installed. If not, it will compile and link statically.
+
+1. Clone `https://github.com/N00byKing/sm64ex` recursively
+2. Enter `sm64ex` and copy your Rom to `baserom.REGION.z64` where `REGION` is either `us` or `jp` respectively.
+3. Compile with `make`. For faster compilation set the parameter `-jn` where `n` is the Number of CPU Cores.
+
+The Compiled binary will be in `build/REGION_pc/`.
+
+# Joining a MultiWorld Game
+
+To join, set the following launch options: `--sm64ap_name YourName --sm64ap_ip ServerIP:Port`.
+Optionally, add `--sm64ap_passwd "YourPassword"` if the room you are using requires a password.
+The Name in this case is the one specified in your generated .yaml file.
+In case you are using the Archipelago Website, the IP should be `archipelago.gg`.
+
+If everything worked out, you will see a textbox informing you the connection has been established after the story intro.
+
+# Playing offline
+
+To play offline, first generate a seed on the game's settings page.
+Create a room and download the `.apsm64ex` file, and start the game with the `--sm64ap_file FileName` launch argument.
+
+## Installation Troubleshooting
+
+Start the game from the command line to view helpful messages regarding SM64EX.
+
+### Game doesn't start after compiling
+
+Most likely you forgot to set the launch options. `--sm64ap_name YourName` and `--sm64ap_ip ServerIP:Port` are required for startup for Multiworlds, and
+`--sm64ap_file FileName` is required for (offline) singleplayer.
+If your Name or Password have spaces in them, surround them in quotes.
+
+## Game Troubleshooting
+
+### Known Issues
+
+When using a US Rom, the In-Game messages are missing some letters: `J Q V X Z` and `?`.
+The Japanese Version should have no problem displaying these.
+
+### What happens if I lose connection?
+
+SM64EX tries to reconnect a few times, so be patient.
+Should the problem still be there after about a minute or two, just save and restart the game.
+
+### How do I update the Game to a new Build?
+
+When manually compiling just pull in changes and run `make` again. Sometimes it helps to run `make clean` before.
+
+When using the Launcher follow the normal build steps, but when choosing a folder name use the same as before. Then continue as normal.

WebHostLib/static/assets/tutorial/Super Metroid/multiworld_en.md

@@ -0,0 +1,166 @@
+# Super Metroid Setup Guide
+
+## Required Software
+
+- One of the client programs:
+  - [SNIClient](https://github.com/ArchipelagoMW/Archipelago/releases), included with the main 
+  Archipelago install. Make sure to check the box for `SNI Client - Super Metroid Patch Setup`
+  - [SuperNintendoClient](https://github.com/ArchipelagoMW/SuperNintendoClient/releases), an alternate standalone
+  client for Super Nintendo games
+- Hardware or software capable of loading and playing SNES ROM files
+    - An emulator capable of connecting to SNI such as:
+        - snes9x Multitroid
+          from: [snes9x Multitroid Download](https://drive.google.com/drive/folders/1_ej-pwWtCAHYXIrvs5Hro16A1s9Hi3Jz),
+        - BizHawk from: [BizHawk Website](http://tasvideos.org/BizHawk.html)
+        - RetroArch 1.10.1 or newer from: [RetroArch Website](https://retroarch.com?page=platforms). Or,
+    - An SD2SNES, FXPak Pro ([FXPak Pro Store Page](https://krikzz.com/store/home/54-fxpak-pro.html)), or other
+      compatible hardware
+- Your legally obtained Super Metroid ROM file, probably named `Super Metroid (Japan, USA).sfc`
+
+## Installation Procedures
+
+### Windows Setup
+
+1. During the installation of Archipelago, you will have been asked to install the SNI Client. If you did not do this,
+   or you are on an older version, you may run the installer again to install the SNI Client.
+2. During setup, you will be asked to locate your base ROM file. This is your Super Metroid ROM file.
+3. 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.
+
+## Create a Config (.yaml) File
+
+### What is a config file and why do I need one?
+
+See the guide on setting up a basic YAML at the Archipelago setup
+guide: [Basic Multiworld Setup Guide](/tutorial/archipelago/setup/en)
+
+### Where do I get a config file?
+
+The Player Settings page on the website allows you to configure your personal settings and export a config file from
+them. Player settings page: [Super Metroid Player Settings Page](/games/Super%20Metroid/player-settings)
+
+### Verifying your config file
+
+If you would like to validate your config file to make sure it works, you may do so on the YAML Validator page. YAML
+validator page: [YAML Validation page](/mysterycheck)
+
+## Generating a Single-Player Game
+
+1. Navigate to the Player Settings page, configure your options, and click the "Generate Game" button.
+    - Player Settings page: [Super Metroid Player Settings Page](/games/Super%20Metroid/player-settings)
+2. You will be presented with a "Seed Info" page.
+3. Click the "Create New Room" link.
+4. You will be presented with a server page, from which you can download your patch file.
+5. Double-click on your patch file, and the Super Metroid Client will launch automatically, create your ROM from the
+   patch file, and open your emulator for you.
+6. Since this is a single-player game, you will no longer need the client, so feel free to close it.
+
+## 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 config 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 `.apm3` 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 in the same place as your patch file.
+
+### Connect to the client
+
+#### With an emulator
+
+When the client launched automatically, SNI 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. Select the connector lua file included with your client
+    - SuperNintendoClient users should download `sniConnector.lua` from the client download page
+    - SNIClient users should look in their Archipelago folder for `/SNI/lua/x64` or `/SNI/lua/x86` depending on if the
+      emulator is 64-bit or 32-bit.
+
+##### 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. Select the `Connector.lua` file included with your client
+    - SuperNintendoClient users should download `sniConnector.lua` from the client download page
+    - SNIClient users should look in their Archipelago folder for `/SNI/lua/x64` or `/SNI/lua/x86` depending on if the
+      emulator is 64-bit or 32-bit. Please note the most recent versions of BizHawk are 64-bit only.
+
+##### RetroArch 1.10.1 or newer
+
+You only have to do these steps once. Note, RetroArch 1.9.x will not work as it is older than 1.10.1.
+
+1. Enter the RetroArch main menu screen.
+2. Go to Settings --> User Interface. Set "Show Advanced Settings" to ON.
+3. Go to Settings --> Network. Set "Network Commands" to ON. (It is found below Request Device 16.) Leave the default
+   Network Command Port at 55355.
+![Screenshot of Network Commands setting](/static/assets/tutorial/retroarch-network-commands-en.png)
+4. Go to Main Menu --> Online Updater --> Core Downloader. Scroll down and select "Nintendo - SNES / SFC (bsnes-mercury
+   Performance)".
+
+When loading a ROM, be sure to select a **bsnes-mercury** core. These are the only cores that allow external tools to
+read ROM data.
+
+#### 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 on the SD2SNES releases page. SD2SNES
+releases page: [SD2SNES Releases Page](https://github.com/RedGuyyyy/sd2snes/releases)
+
+Other hardware may find helpful information on the usb2snes platforms
+page: [usb2snes Supported Platforms Page](http://usb2snes.com/#supported-platforms)
+
+1. Close your emulator, which may have auto-launched.
+2. Power on your device and load the ROM.
+
+### Connect to the Archipelago Server
+
+The patch file which launched your client should have automatically connected you to the AP Server. 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".
+
+### 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 our hosting service. The process is relatively simple:
+
+1. Collect config files from your players.
+2. Create a zip file containing your players' config files.
+3. Upload that zip file to the Generate page above.
+    - Generate page: [WebHost Seed Generation Page](/generate)
+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.
+7. Note that a link to a MultiWorld Tracker is at the top of the room page. The tracker shows the progress of all
+   players in the game. Any observers may also be given the link to this page.
+8. Once all players have joined, you may begin playing.

WebHostLib/static/assets/tutorial/Timespinner/setup_de.md

@@ -0,0 +1,50 @@
+# Timespinner Randomizer Installationsanweisungen
+
+## Benötigte Software
+
+- [Timespinner (Steam)](https://store.steampowered.com/app/368620/Timespinner/)
+  , [Timespinner (Humble)](https://www.humblebundle.com/store/timespinner)
+  oder [Timespinner (GOG)](https://www.gog.com/game/timespinner) (andere Versionen werden nicht unterstützt)
+- [Timespinner Randomizer](https://github.com/JarnoWesthof/TsRandomizer)
+
+## Wie funktioniert's?
+
+Der Timespinner Randomizer lädt die Timespinner.exe im gleichen Verzeichnis und verändert seine Speicherinformationen um
+die Randomisierung der Gegenstände zu erlauben
+
+## Installationsanweisungen
+
+1. Die aktuellsten Dateien des Randomizers findest du ganz oben auf dieser
+   Webseite: [Timespinner Randomizer Releases](https://github.com/JarnoWesthof/TsRandomizer/releases). Lade dir unter '
+   Assets' die .zip Datei für dein Betriebssystem herunter
+2. Entpacke die .zip Datei im Ordner, in dem das Spiel Timespinner installiert ist
+
+## Den Randomizer starten
+
+- auf Windows: Starte die Datei TsRandomizer.exe
+- auf Linux: Starte die Datei TsRandomizer.bin.x86_64
+- auf Mac: Starte die Datei TsRandomizer.bin.osx
+
+... im Ordner in dem die Inhalte aus der .zip Datei entpackt wurden
+
+Weitere Informationen zum Randomizer findest du hier: [ReadMe](https://github.com/JarnoWesthof/TsRandomizer)
+
+## An einer Multiworld teilnehmen
+
+1. Starte den Randomizer wie unter [Den Randomizer starten](#Den-Randomizer-starten) beschrieben
+2. Wähle "New Game"
+3. Wechsle "<< Select Seed >>" zu "<< Archiplago >>" indem du "links" auf deinem Controller oder der Tastatur drückst
+4. Wähle "<< Archipelago >>" um ein neues Menu zu öffnen, wo du deine Logininformationen für Archipelago eingeben kannst
+    * ANMERKUNG: Die Eingabefelder unterstützen das Einfügen von Informationen mittels 'Ctrl + V'
+5. Wähle "Connect"
+6. Wenn alles funktioniert hat, wechselt das Spiel zurück zur Auswahl des Schwierigkeitsgrads und das Spiel startet,
+   sobald du einen davon ausgewählt hast
+
+## Woher bekomme ich eine Konfigurationsdatei?
+
+Die [Player Settings](https://archipelago.gg/games/Timespinner/player-settings) Seite auf der Website erlaubt dir,
+persönliche Einstellungen zu definieren und diese in eine Konfigurationsdatei zu exportieren
+
+* Die Timespinner Randomizer Option "StinkyMaw" ist in Archipelago Seeds aktuell immer an
+* Die Timespinner Randomizer Optionen "ProgressiveVerticalMovement" & "ProgressiveKeycards" werden in Archipelago Seeds
+  aktuell nicht unterstützt

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

@@ -0,0 +1,41 @@
+# Timespinner Randomizer Setup Guide
+
+## Required Software
+
+- [Timespinner (Steam)](https://store.steampowered.com/app/368620/Timespinner/)
+  , [Timespinner (Humble)](https://www.humblebundle.com/store/timespinner)
+  or [Timespinner (GOG)](https://www.gog.com/game/timespinner) (other versions are not supported)
+- [Timespinner Randomizer](https://github.com/JarnoWesthof/TsRandomizer)
+
+## General Concept
+
+The Timespinner Randomizer loads Timespinner.exe from the same folder, and alters its state in memory to allow for
+randomization of the items
+
+## Installation Procedures
+
+Download latest release on [Timespinner Randomizer Releases](https://github.com/JarnoWesthof/TsRandomizer/releases) you
+can find the .zip files on the releases page. Download the zip for your current platform. Then extract the zip to the
+folder where your Timespinner game is installed. Then just run TsRandomizer.exe (on Windows) or
+TsRandomizer.bin.x86_64 (on Linux) or TsRandomizer.bin.osx (on Mac) instead of Timespinner.exe to start the game in
+randomized mode. For more info see the [ReadMe](https://github.com/JarnoWesthof/TsRandomizer)
+
+## Joining a MultiWorld Game
+
+1. Run TsRandomizer.exe
+2. Select "New Game"
+3. Switch "<< Select Seed >>" to "<< Archipelago >>" by pressing left on your controller or keyboard
+4. Select "<< Archipelago >>" to open a new menu where you can enter your Archipelago login credentials
+    * NOTE: the input fields support Ctrl + V pasting of values
+5. Select "Connect"
+6. If all went well you will be taken back to the difficulty selection menu and the game will start as soon as you
+   select a difficulty
+
+## Where do I get a config file?
+
+The [Player Settings](https://archipelago.gg/games/Timespinner/player-settings) page on the website allows you to
+configure your personal settings and export them into a config file
+
+* The Timespinner Randomizer option "StinkyMaw" is currently always enabled for Archipelago generated seeds
+* The Timespinner Randomizer options "ProgressiveVerticalMovement" & "ProgressiveKeycards" are currently not supported
+  on Archipelago generated seeds