Merge branch 'main' into player-tracker

* Factorio: Add explicit support for factory-levels mod.

* Fix inconsistent space/tabs

.github/ISSUE_TEMPLATE/bug_report.yaml

@@ -0,0 +1,35 @@
+name: Bug Report
+description: File a bug report.
+title: "Bug: "
+labels:
+  - bug / fix
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thanks for taking the time to fill out this bug report! If this bug occurred during local generation check your 
+        Archipelago install for a log (probably `C:\ProgramData\Archipelago\logs`)
+        and upload it with this report, as well as all yaml files used.
+  - type: textarea
+    id: what-happened
+    attributes:
+      label: What happened?
+    validations:
+      required: true
+  - type: textarea
+    id: expected-results
+    attributes:
+      label: What were the expected results?
+    validations:
+      required: true
+  - type: dropdown
+    id: version
+    attributes:
+      label: Software
+      description: Where did this bug occur?
+      options:
+        - Website
+        - Local generation
+        - While playing
+    validations:
+      required: true

.github/ISSUE_TEMPLATE/feature_request.yaml

@@ -0,0 +1,17 @@
+name: Feature Request
+description: Request a feature!
+title: "Category: "
+labels:
+  - enhancement
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Please replace `Category` in the title with what this feature will be targeting, such as Core generation,
+        website, documentation, or a game.
+        Note: this is not for requesting new games to be added. If you would like to request a game, the best place to
+        ask is about it is in the [discord](https://archipelago.gg/discord).
+  - type: textarea
+    id: feature
+    attributes:
+      label: What feature would you like to see?

.github/ISSUE_TEMPLATE/task.yaml

@@ -0,0 +1,10 @@
+name: Task
+description: Submit a task to be done. If this is not targeting core, it should likely be elsewhere.
+title: "Core: "
+labels:
+  - core
+  - enhancement
+body:
+  - type: textarea
+    attributes:
+      label: What task needs to be completed?

.github/pull_request_template.md

@@ -0,0 +1,12 @@
+Please format your title with what portion of the project this pull request is
+targeting and what it's changing.
+
+ex. "MyGame4: implement new game" or "Docs: add new guide for customizing MyGame3"
+
+## What is this fixing or adding?
+
+
+## How was this tested?
+
+
+## If this makes graphical changes, please attach screenshots.

.github/workflows/build.yml

@@ -4,6 +4,11 @@ name: Build
 
 on: workflow_dispatch
 
+env:
+  SNI_VERSION: v0.0.84
+  ENEMIZER_VERSION: 7.1
+  APPIMAGETOOL_VERSION: 13
+
 jobs:
   # build-release-macos: # LF volunteer
 
@@ -17,9 +22,9 @@ jobs:
           python-version: '3.8'
       - name: Download run-time dependencies
         run: |
-          Invoke-WebRequest -Uri https://github.com/alttpo/sni/releases/download/v0.0.82/sni-v0.0.82-windows-amd64.zip -OutFile sni.zip
+          Invoke-WebRequest -Uri https://github.com/alttpo/sni/releases/download/${Env:SNI_VERSION}/sni-${Env:SNI_VERSION}-windows-amd64.zip -OutFile sni.zip
           Expand-Archive -Path sni.zip -DestinationPath SNI -Force
-          Invoke-WebRequest -Uri https://github.com/Ijwu/Enemizer/releases/download/7.0.1/win-x64.zip -OutFile enemizer.zip
+          Invoke-WebRequest -Uri https://github.com/Ijwu/Enemizer/releases/download/${Env:ENEMIZER_VERSION}/win-x64.zip -OutFile enemizer.zip
           Expand-Archive -Path enemizer.zip -DestinationPath EnemizerCLI -Force
       - name: Build
         run: |
@@ -43,6 +48,7 @@ jobs:
   build-ubuntu1804:
     runs-on: ubuntu-18.04
     steps:
+      # - copy code below to release.yml -
       - uses: actions/checkout@v2
       - name: Install base dependencies
         run: |
@@ -56,18 +62,18 @@ jobs:
       - 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
+          wget -nv https://github.com/AppImage/AppImageKit/releases/download/$APPIMAGETOOL_VERSION/appimagetool-x86_64.AppImage
           chmod a+rx appimagetool-x86_64.AppImage
           ./appimagetool-x86_64.AppImage --appimage-extract
           echo -e '#/bin/sh\n./squashfs-root/AppRun "$@"' > appimagetool
           chmod a+rx appimagetool
       - name: Download run-time dependencies
         run: |
-          wget -nv https://github.com/alttpo/sni/releases/download/v0.0.82/sni-v0.0.82-manylinux2014-amd64.tar.xz
+          wget -nv https://github.com/alttpo/sni/releases/download/$SNI_VERSION/sni-$SNI_VERSION-manylinux2014-amd64.tar.xz
           tar xf sni-*.tar.xz
           rm sni-*.tar.xz
           mv sni-* SNI
-          wget -nv https://github.com/Ijwu/Enemizer/releases/download/7.0.1/ubuntu.16.04-x64.7z
+          wget -nv https://github.com/Ijwu/Enemizer/releases/download/$ENEMIZER_VERSION/ubuntu.16.04-x64.7z
           7za x -oEnemizerCLI/ ubuntu.16.04-x64.7z
       - name: Build
         run: |
@@ -84,6 +90,7 @@ jobs:
           (cd build && DIR_NAME="`ls | grep exe`" && mv "$DIR_NAME" Archipelago && tar -czvf ../dist/$TAR_NAME Archipelago && mv Archipelago "$DIR_NAME")
           echo "APPIMAGE_NAME=$APPIMAGE_NAME" >> $GITHUB_ENV
           echo "TAR_NAME=$TAR_NAME" >> $GITHUB_ENV
+      # - copy code above to release.yml -
       - name: Store AppImage
         uses: actions/upload-artifact@v2
         with:

.github/workflows/lint.yml

@@ -18,8 +18,8 @@ jobs:
         python-version: 3.9
     - name: Install dependencies
       run: |
-        python -m pip install --upgrade pip
+        python -m pip install --upgrade pip wheel
-        pip install flake8 pytest
+        pip install flake8 pytest pytest-subtests
         if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
     - name: Lint with flake8
       run: |

.github/workflows/release.yml

@@ -7,6 +7,11 @@ on:
     tags:
       - '*.*.*'
 
+env:
+  SNI_VERSION: v0.0.84
+  ENEMIZER_VERSION: 7.1
+  APPIMAGETOOL_VERSION: 13
+
 jobs:
   create-release:
     runs-on: ubuntu-latest
@@ -44,22 +49,23 @@ jobs:
       - 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
+          wget -nv https://github.com/AppImage/AppImageKit/releases/download/$APPIMAGETOOL_VERSION/appimagetool-x86_64.AppImage
           chmod a+rx appimagetool-x86_64.AppImage
           ./appimagetool-x86_64.AppImage --appimage-extract
           echo -e '#/bin/sh\n./squashfs-root/AppRun "$@"' > appimagetool
           chmod a+rx appimagetool
       - name: Download run-time dependencies
         run: |
-          wget -nv https://github.com/alttpo/sni/releases/download/v0.0.82/sni-v0.0.82-manylinux2014-amd64.tar.xz
+          wget -nv https://github.com/alttpo/sni/releases/download/$SNI_VERSION/sni-$SNI_VERSION-manylinux2014-amd64.tar.xz
           tar xf sni-*.tar.xz
           rm sni-*.tar.xz
           mv sni-* SNI
-          wget -nv https://github.com/Ijwu/Enemizer/releases/download/7.0.1/ubuntu.16.04-x64.7z
+          wget -nv https://github.com/Ijwu/Enemizer/releases/download/$ENEMIZER_VERSION/ubuntu.16.04-x64.7z
           7za x -oEnemizerCLI/ ubuntu.16.04-x64.7z
       - name: Build
         run: |
-          "${{ env.PYTHON }}" -m pip install --upgrade pip setuptools virtualenv PyGObject  # pygobject should probably move to requirements
+          # pygobject is an optional dependency for kivy that's not in requirements
+          "${{ env.PYTHON }}" -m pip install --upgrade pip virtualenv PyGObject setuptools
           "${{ env.PYTHON }}" -m venv venv
           source venv/bin/activate
           pip install -r requirements.txt

.github/workflows/unittests.yml

@@ -32,8 +32,8 @@ jobs:
         python-version: ${{ matrix.python.version }}
     - name: Install dependencies
       run: |
-        python -m pip install --upgrade pip
+        python -m pip install --upgrade pip wheel
-        pip install flake8 pytest
+        pip install flake8 pytest pytest-subtests
         python ModuleUpdate.py --yes --force --append "WebHostLib/requirements.txt"
     - name: Unittests
       run: |

.gitignore

@@ -28,6 +28,7 @@ README.html
 .vs/
 EnemizerCLI/
 /Players/
+/SNI/
 /options.yaml
 /config.yaml
 /logs/

BaseClasses.py

@@ -166,7 +166,7 @@ class MultiWorld():
         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():
+        for option_key, option in world_type.option_definitions.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)
@@ -204,7 +204,7 @@ class MultiWorld():
         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:
+            for option_key in world_type.option_definitions:
                 setattr(self, option_key, getattr(args, option_key, {}))
 
             self.worlds[player] = world_type(self, player)
@@ -384,7 +384,6 @@ class MultiWorld():
         return self.worlds[player].create_item(item_name)
 
     def push_precollected(self, item: Item):
-        item.world = self
         self.precollected_items[item.player].append(item)
         self.state.collect(item, True)
 
@@ -392,7 +391,6 @@ class MultiWorld():
         assert location.can_fill(self.state, item, False), f"Cannot place {item} into {location}."
         location.item = item
         item.location = location
-        item.world = self  # try to not have this here anymore and create it with item?
         if collect:
             self.state.collect(item, location.event, location)
 
@@ -957,6 +955,13 @@ class Region:
                 return True
         return False
 
+    def get_connecting_entrance(self, is_main_entrance: typing.Callable[[Entrance], bool]) -> Entrance:
+        for entrance in self.entrances:
+            if is_main_entrance(entrance):
+                return entrance
+        for entrance in self.entrances:  # BFS might be better here, trying DFS for now.
+            return entrance.parent_region.get_connecting_entrance(is_main_entrance)
+
     def __repr__(self):
         return self.__str__()
 
@@ -1066,26 +1071,25 @@ class LocationProgressType(IntEnum):
 
 
 class Location:
-    # If given as integer, then this is the shop's inventory index
+    game: str = "Generic"
-    shop_slot: Optional[int] = None
+    player: int
-    shop_slot_disabled: bool = False
+    name: str
+    address: Optional[int]
+    parent_region: Optional[Region]
     event: bool = False
     locked: bool = False
-    game: str = "Generic"
     show_in_spoiler: bool = True
-    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):
+    def __init__(self, player: int, name: str = '', address: Optional[int] = None, parent: Optional[Region] = None):
-        self.name: str = name
+        self.player = player
-        self.address: Optional[int] = address
+        self.name = name
+        self.address = address
         self.parent_region = parent
-        self.player: int = player
 
     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)))
@@ -1102,7 +1106,6 @@ class Location:
         self.item = item
         item.location = self
         self.event = item.advancement
-        self.item.world = self.parent_region.world
         self.locked = True
 
     def __repr__(self):
@@ -1147,39 +1150,28 @@ class ItemClassification(IntFlag):
 
 
 class Item:
-    location: Optional[Location] = None
-    world: Optional[MultiWorld] = None
-    code: Optional[int] = None  # an item with ID None is called an Event, and does not get written to multidata
-    name: str
     game: str = "Generic"
-    type: str = None
+    __slots__ = ("name", "classification", "code", "player", "location")
+    name: str
     classification: ItemClassification
-
+    code: Optional[int]
-    # need to find a decent place for these to live and to allow other games to register texts if they want.
+    """an item with code None is called an Event, and does not get written to multidata"""
-    pedestal_credit_text: str = "and the Unknown Item"
+    player: int
-    sickkid_credit_text: Optional[str] = None
+    location: Optional[Location]
-    magicshop_credit_text: Optional[str] = None
-    zora_credit_text: Optional[str] = None
-    fluteboy_credit_text: Optional[str] = None
-
-    # hopefully temporary attributes to satisfy legacy LttP code, proper implementation in subclass ALttPItem
-    smallkey: bool = False
-    bigkey: bool = False
-    map: bool = False
-    compass: bool = False
 
     def __init__(self, name: str, classification: ItemClassification, code: Optional[int], player: int):
         self.name = name
         self.classification = classification
         self.player = player
         self.code = code
+        self.location = None
 
     @property
-    def hint_text(self):
+    def hint_text(self) -> str:
         return getattr(self, "_hint_text", self.name.replace("_", " ").replace("-", " "))
 
     @property
-    def pedestal_hint_text(self):
+    def pedestal_hint_text(self) -> str:
         return getattr(self, "_pedestal_hint_text", self.name.replace("_", " ").replace("-", " "))
 
     @property
@@ -1205,7 +1197,7 @@ class Item:
     def __eq__(self, other):
         return self.name == other.name and self.player == other.player
 
-    def __lt__(self, other: Item):
+    def __lt__(self, other: Item) -> bool:
         if other.player != self.player:
             return other.player < self.player
         return self.name < other.name
@@ -1213,11 +1205,13 @@ class Item:
     def __hash__(self):
         return hash((self.name, self.player))
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return self.__str__()
 
-    def __str__(self):
+    def __str__(self) -> str:
-        return self.world.get_name_string_for_object(self) if self.world else f'{self.name} (Player {self.player})'
+        if self.location and self.location.parent_region and self.location.parent_region.world:
+            return self.location.parent_region.world.get_name_string_for_object(self)
+        return f"{self.name} (Player {self.player})"
 
 
 class Spoiler():
@@ -1401,7 +1395,7 @@ class Spoiler():
                 outfile.write('Game:                            %s\n' % self.world.game[player])
                 for f_option, option in Options.per_game_common_options.items():
                     write_option(f_option, option)
-                options = self.world.worlds[player].options
+                options = self.world.worlds[player].option_definitions
                 if options:
                     for f_option, option in options.items():
                         write_option(f_option, option)
@@ -1435,7 +1429,6 @@ class Spoiler():
                                                "f" in self.world.shop_shuffle[player]))
                     outfile.write('Custom Potion Shop:              %s\n' %
                                   bool_to_text("w" in self.world.shop_shuffle[player]))
-                    outfile.write('Boss shuffle:                    %s\n' % self.world.boss_shuffle[player])
                     outfile.write('Enemy health:                    %s\n' % self.world.enemy_health[player])
                     outfile.write('Enemy damage:                    %s\n' % self.world.enemy_damage[player])
                     outfile.write('Prize shuffle                    %s\n' %

CommonClient.py

@@ -5,6 +5,7 @@ import urllib.parse
 import sys
 import typing
 import time
+import functools
 
 import ModuleUpdate
 ModuleUpdate.update()
@@ -17,7 +18,8 @@ if __name__ == "__main__":
     Utils.init_logging("TextClient", exception_logger="Client")
 
 from MultiServer import CommandProcessor
-from NetUtils import Endpoint, decode, NetworkItem, encode, JSONtoTextParser, ClientStatus, Permission, NetworkSlot
+from NetUtils import Endpoint, decode, NetworkItem, encode, JSONtoTextParser, \
+    ClientStatus, Permission, NetworkSlot, RawJSONtoTextParser
 from Utils import Version, stream_input
 from worlds import network_data_package, AutoWorldRegister
 import os
@@ -152,8 +154,9 @@ class CommonContext:
     # locations
     locations_checked: typing.Set[int]  # local state
     locations_scouted: typing.Set[int]
-    missing_locations: typing.Set[int]
+    missing_locations: typing.Set[int]  # server state
     checked_locations: typing.Set[int]  # server state
+    server_locations: typing.Set[int]  # all locations the server knows of, missing_location | checked_locations
     locations_info: typing.Dict[int, NetworkItem]
 
     # internals
@@ -184,8 +187,9 @@ class CommonContext:
         self.locations_checked = set()  # local state
         self.locations_scouted = set()
         self.items_received = []
-        self.missing_locations = set()
+        self.missing_locations = set()  # server state
         self.checked_locations = set()  # server state
+        self.server_locations = set()  # all locations the server knows of, missing_location | checked_locations
         self.locations_info = {}
 
         self.input_queue = asyncio.Queue()
@@ -202,6 +206,10 @@ class CommonContext:
         # execution
         self.keep_alive_task = asyncio.create_task(keep_alive(self), name="Bouncy")
 
+    @functools.cached_property
+    def raw_text_parser(self) -> RawJSONtoTextParser:
+        return RawJSONtoTextParser(self)
+
     @property
     def total_locations(self) -> typing.Optional[int]:
         """Will return None until connected."""
@@ -345,6 +353,8 @@ class CommonContext:
         cache_package = Utils.persistent_load().get("datapackage", {}).get("games", {})
         needed_updates: typing.Set[str] = set()
         for game in relevant_games:
+            if game not in remote_datepackage_versions:
+                continue
             remote_version: int = remote_datepackage_versions[game]
 
             if remote_version == 0:  # custom datapackage for this game
@@ -493,7 +503,8 @@ async def server_loop(ctx: CommonContext, address=None):
     logger.info(f'Connecting to Archipelago server at {address}')
     try:
         socket = await websockets.connect(address, port=port, ping_timeout=None, ping_interval=None)
-        ctx.ui.update_address_bar(server_url.netloc)
+        if ctx.ui is not None:
+            ctx.ui.update_address_bar(server_url.netloc)
         ctx.server = Endpoint(socket)
         logger.info('Connected')
         ctx.server_address = address
@@ -562,18 +573,21 @@ async def process_server_cmd(ctx: CommonContext, args: dict):
                 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'])
-            players = args.get("players", [])
+
-            if len(players) < 1:
+            if "players" in args:  # TODO remove when servers sending this are outdated
-                logger.info('No player connected')
+                players = args.get("players", [])
-            else:
+                if len(players) < 1:
-                players.sort()
+                    logger.info('No player connected')
-                current_team = -1
+                else:
-                logger.info('Connected Players:')
+                    players.sort()
-                for network_player in players:
+                    current_team = -1
-                    if network_player.team != current_team:
+                    logger.info('Connected Players:')
-                        logger.info(f'  Team #{network_player.team + 1}')
+                    for network_player in players:
-                        current_team = network_player.team
+                        if network_player.team != current_team:
-                    logger.info('    %s (Player %d)' % (network_player.alias, network_player.slot))
+                            logger.info(f'  Team #{network_player.team + 1}')
+                            current_team = network_player.team
+                        logger.info('    %s (Player %d)' % (network_player.alias, network_player.slot))
+
             # update datapackage
             await ctx.prepare_datapackage(set(args["games"]), args["datapackage_versions"])
 
@@ -628,6 +642,7 @@ async def process_server_cmd(ctx: CommonContext, args: dict):
         # 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"])
+        ctx.server_locations = ctx.missing_locations | ctx. checked_locations
 
     elif cmd == 'ReceivedItems':
         start_index = args["index"]
@@ -723,7 +738,7 @@ if __name__ == '__main__':
     class TextContext(CommonContext):
         tags = {"AP", "IgnoreGame", "TextOnly"}
         game = ""  # empty matches any game since 0.3.2
-        items_handling = 0  # don't receive any NetworkItems
+        items_handling = 0b111  # receive all items for /received
 
         async def server_auth(self, password_requested: bool = False):
             if password_requested and not self.password:

FF1Client.py

@@ -1,4 +1,5 @@
 import asyncio
+import copy
 import json
 import time
 from asyncio import StreamReader, StreamWriter
@@ -6,7 +7,7 @@ from typing import List
 
 
 import Utils
-from CommonClient import CommonContext, server_loop, gui_enabled, console_loop, ClientCommandProcessor, logger, \
+from CommonClient import CommonContext, server_loop, gui_enabled, ClientCommandProcessor, logger, \
     get_base_parser
 
 SYSTEM_MESSAGE_ID = 0
@@ -64,7 +65,7 @@ class FF1Context(CommonContext):
 
     def _set_message(self, msg: str, msg_id: int):
         if DISPLAY_MSGS:
-            self.messages[(time.time(), msg_id)] = msg
+            self.messages[time.time(), msg_id] = msg
 
     def on_package(self, cmd: str, args: dict):
         if cmd == 'Connected':
@@ -73,32 +74,28 @@ class FF1Context(CommonContext):
             msg = args['text']
             if ': !' not in msg:
                 self._set_message(msg, SYSTEM_MESSAGE_ID)
-        elif cmd == "ReceivedItems":
+
-            msg = f"Received {', '.join([self.item_names[item.item] for item in args['items']])}"
+    def on_print_json(self, args: dict):
-            self._set_message(msg, SYSTEM_MESSAGE_ID)
+        if self.ui:
-        elif cmd == 'PrintJSON':
+            self.ui.print_json(copy.deepcopy(args["data"]))
-            print_type = args['type']
+        else:
-            item = args['item']
+            text = self.jsontotextparser(copy.deepcopy(args["data"]))
-            receiving_player_id = args['receiving']
+            logger.info(text)
-            receiving_player_name = self.player_names[receiving_player_id]
+        relevant = args.get("type", None) in {"Hint", "ItemSend"}
-            sending_player_id = item.player
+        if relevant:
-            sending_player_name = self.player_names[item.player]
+            item = args["item"]
-            if print_type == 'Hint':
+            # goes to this world
-                msg = f"Hint: Your {self.item_names[item.item]} is at" \
+            if self.slot_concerns_self(args["receiving"]):
-                      f" {self.player_names[item.player]}'s {self.location_names[item.location]}"
+                relevant = True
-                self._set_message(msg, item.item)
+            # found in this world
-            elif print_type == 'ItemSend' and receiving_player_id != self.slot:
+            elif self.slot_concerns_self(item.player):
-                if sending_player_id == self.slot:
+                relevant = True
-                    if receiving_player_id == self.slot:
+            # not related
-                        msg = f"You found your own {self.item_names[item.item]}"
+            else:
-                    else:
+                relevant = False
-                        msg = f"You sent {self.item_names[item.item]} to {receiving_player_name}"
+            if relevant:
-                else:
+                item = args["item"]
-                    if receiving_player_id == sending_player_id:
+                msg = self.raw_text_parser(copy.deepcopy(args["data"]))
-                        msg = f"{sending_player_name} found their {self.item_names[item.item]}"
-                    else:
-                        msg = f"{sending_player_name} sent {self.item_names[item.item]} to " \
-                              f"{receiving_player_name}"
                 self._set_message(msg, item.item)
 
     def run_gui(self):

FactorioClient.py

@@ -20,8 +20,7 @@ import Utils
 if __name__ == "__main__":
     Utils.init_logging("FactorioClient", exception_logger="Client")
 
-from CommonClient import CommonContext, server_loop, console_loop, ClientCommandProcessor, logger, gui_enabled, \
+from CommonClient import CommonContext, server_loop, ClientCommandProcessor, logger, gui_enabled, get_base_parser
-    get_base_parser
 from MultiServer import mark_raw
 from NetUtils import NetworkItem, ClientStatus, JSONtoTextParser, JSONMessagePart
 

Fill.py

@@ -136,33 +136,98 @@ def fill_restrictive(world: MultiWorld, base_state: CollectionState, locations:
     itempool.extend(unplaced_items)
 
 
+def remaining_fill(world: MultiWorld,
+                   locations: typing.List[Location],
+                   itempool: typing.List[Item]) -> None:
+    unplaced_items: typing.List[Item] = []
+    placements: typing.List[Location] = []
+    swapped_items: typing.Counter[typing.Tuple[int, str]] = Counter()
+    while locations and itempool:
+        item_to_place = itempool.pop()
+        spot_to_fill: typing.Optional[Location] = None
+
+        for i, location in enumerate(locations):
+            if location.item_rule(item_to_place):
+                # popping by index is faster than removing by content,
+                spot_to_fill = locations.pop(i)
+                # skipping a scan for the element
+                break
+
+        else:
+            # 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
+
+                if swapped_items[placed_item.player,
+                                 placed_item.name] > 1:
+                    continue
+
+                location.item = None
+                placed_item.location = None
+                if location.item_rule(item_to_place):
+                    # Add this item to the existing placement, and
+                    # add the old item to the back of the queue
+                    spot_to_fill = placements.pop(i)
+
+                    swapped_items[placed_item.player,
+                                  placed_item.name] += 1
+
+                    itempool.append(placed_item)
+
+                    break
+
+                # Item can't be placed here, restore original item
+                location.item = placed_item
+                placed_item.location = location
+
+            if spot_to_fill is None:
+                # Can't place this item, move on to the next
+                unplaced_items.append(item_to_place)
+                continue
+
+        world.push_item(spot_to_fill, item_to_place, False)
+        placements.append(spot_to_fill)
+
+    if unplaced_items and locations:
+        # There are leftover unplaceable items and locations that won't accept them
+        raise FillError(f'No more spots to place {unplaced_items}, locations {locations} are invalid. '
+                        f'Already placed {len(placements)}: {", ".join(str(place) for place in placements)}')
+
+    itempool.extend(unplaced_items)
+
+
+def fast_fill(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 distribute_items_restrictive(world: MultiWorld) -> None:
     fill_locations = sorted(world.get_unfilled_locations())
     world.random.shuffle(fill_locations)
-
     # get items to distribute
     itempool = sorted(world.itempool)
     world.random.shuffle(itempool)
     progitempool: typing.List[Item] = []
-    nonexcludeditempool: typing.List[Item] = []
+    usefulitempool: typing.List[Item] = []
-    localrestitempool: typing.Dict[int, typing.List[Item]] = {player: [] for player in range(1, world.players + 1)}
+    filleritempool: typing.List[Item] = []
-    nonlocalrestitempool: typing.List[Item] = []
-    restitempool: typing.List[Item] = []
 
     for item in itempool:
         if item.advancement:
             progitempool.append(item)
-        elif item.useful:  # this only gets nonprogression items which should not appear in excluded locations
+        elif item.useful:
-            nonexcludeditempool.append(item)
+            usefulitempool.append(item)
-        elif item.name in world.local_items[item.player].value:
-            localrestitempool[item.player].append(item)
-        elif item.name in world.non_local_items[item.player].value:
-            nonlocalrestitempool.append(item)
         else:
-            restitempool.append(item)
+            filleritempool.append(item)
 
-    call_all(world, "fill_hook", progitempool, nonexcludeditempool,
+    call_all(world, "fill_hook", progitempool, usefulitempool, filleritempool, fill_locations)
-             localrestitempool, nonlocalrestitempool, restitempool, fill_locations)
 
     locations: typing.Dict[LocationProgressType, typing.List[Location]] = {
         loc_type: [] for loc_type in LocationProgressType}
@@ -184,50 +249,16 @@ def distribute_items_restrictive(world: MultiWorld) -> None:
             raise FillError(
                 f'Not enough locations for progress items. There are {len(progitempool)} more items than locations')
 
-    if nonexcludeditempool:
+    remaining_fill(world, excludedlocations, filleritempool)
-        world.random.shuffle(defaultlocations)
+    if excludedlocations:
-        # needs logical fill to not conflict with local items
+        raise FillError(
-        fill_restrictive(
+            f"Not enough filler items for excluded locations. There are {len(excludedlocations)} more locations than items")
-            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
+    restitempool = usefulitempool + filleritempool
-    world.random.shuffle(defaultlocations)
 
-    if any(localrestitempool.values()):  # we need to make sure some fills are limited to certain worlds
+    remaining_fill(world, defaultlocations, restitempool)
-        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 player_locations in local_locations.values():
-            world.random.shuffle(player_locations)
 
-        for player, items in localrestitempool.items():  # items already shuffled
+    unplaced = restitempool
-            player_local_locations = local_locations[player]
-            for item_to_place in items:
-                if not player_local_locations:
-                    logging.warning(f"Ran out of local locations for player {player}, "
-                                    f"cannot place {item_to_place}.")
-                    break
-                spot_to_fill = player_local_locations.pop()
-                world.push_item(spot_to_fill, item_to_place, False)
-                defaultlocations.remove(spot_to_fill)
-
-    for item_to_place in nonlocalrestitempool:
-        for i, location in enumerate(defaultlocations):
-            if location.player != item_to_place.player:
-                world.push_item(defaultlocations.pop(i), item_to_place, False)
-                break
-        else:
-            logging.warning(
-                f"Could not place non_local_item {item_to_place} among {defaultlocations}, tossing.")
-
-    world.random.shuffle(defaultlocations)
-
-    restitempool, defaultlocations = fast_fill(
-        world, restitempool, defaultlocations)
-    unplaced = progitempool + restitempool
     unfilled = defaultlocations
 
     if unplaced or unfilled:
@@ -241,15 +272,6 @@ def distribute_items_restrictive(world: MultiWorld) -> None:
         logging.info(f'Per-Player counts: {print_data})')
 
 
-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) -> None:
     # get items to distribute
     world.random.shuffle(world.itempool)

Generate.py

@@ -7,7 +7,7 @@ import urllib.request
 import urllib.parse
 from typing import Set, Dict, Tuple, Callable, Any, Union
 import os
-from collections import Counter
+from collections import Counter, ChainMap
 import string
 import enum
 
@@ -23,7 +23,6 @@ from worlds.alttp.EntranceRandomizer import parse_arguments
 from Main import main as ERmain
 from BaseClasses import seeddigits, get_seed
 import Options
-from worlds.alttp import Bosses
 from worlds.alttp.Text import TextTable
 from worlds.AutoWorld import AutoWorldRegister
 import copy
@@ -63,7 +62,7 @@ class PlandoSettings(enum.IntFlag):
 
     def __str__(self) -> str:
         if self.value:
-            return ", ".join((flag.name for flag in PlandoSettings if self.value & flag.value))
+            return ", ".join(flag.name for flag in PlandoSettings if self.value & flag.value)
         return "Off"
 
 
@@ -84,11 +83,6 @@ def mystery_argparse():
     parser.add_argument('--seed', help='Define seed number to generate.', type=int)
     parser.add_argument('--multi', default=defaults["players"], type=lambda value: max(int(value), 1))
     parser.add_argument('--spoiler', type=int, default=defaults["spoiler"])
-    parser.add_argument('--lttp_rom', default=options["lttp_options"]["rom_file"],
-                        help="Path to the 1.0 JP LttP Baserom.")  # absolute, relative to cwd or relative to app path
-    parser.add_argument('--sm_rom', default=options["sm_options"]["rom_file"],
-                        help="Path to the 1.0 JP SM Baserom.")
-    parser.add_argument('--enemizercli', default=resolve_path(defaults["enemizer_path"], local_path))
     parser.add_argument('--outputpath', default=resolve_path(options["general_options"]["output_path"], user_path),
                         help="Path to output folder. Absolute or relative to cwd.")  # absolute or relative to cwd
     parser.add_argument('--race', action='store_true', default=defaults["race"])
@@ -133,12 +127,14 @@ def main(args=None, callback=ERmain):
 
     if args.meta_file_path and os.path.exists(args.meta_file_path):
         try:
-            weights_cache[args.meta_file_path] = read_weights_yamls(args.meta_file_path)
+            meta_weights = read_weights_yamls(args.meta_file_path)[-1]
         except Exception as e:
             raise ValueError(f"File {args.meta_file_path} is destroyed. Please fix your yaml.") from e
-        meta_weights = weights_cache[args.meta_file_path][-1]
         print(f"Meta: {args.meta_file_path} >> {get_choice('meta_description', meta_weights)}")
-        del(meta_weights["meta_description"])
+        try:  # meta description allows us to verify that the file named meta.yaml is intentionally a meta file
+            del(meta_weights["meta_description"])
+        except Exception as e:
+            raise ValueError("No meta description found for meta.yaml. Unable to verify.") from e
         if args.samesettings:
             raise Exception("Cannot mix --samesettings with --meta")
     else:
@@ -164,7 +160,7 @@ def main(args=None, callback=ERmain):
             player_files[player_id] = filename
             player_id += 1
 
-    args.multi = max(player_id-1, args.multi)
+    args.multi = max(player_id - 1, args.multi)
     print(f"Generating for {args.multi} player{'s' if args.multi > 1 else ''}, {seed_name} Seed {seed} with plando: "
           f"{args.plando}")
 
@@ -181,31 +177,29 @@ def main(args=None, callback=ERmain):
 
     Utils.init_logging(f"Generate_{seed}", loglevel=args.log_level)
 
-    erargs.lttp_rom = args.lttp_rom
-    erargs.sm_rom = args.sm_rom
-    erargs.enemizercli = args.enemizercli
-
     settings_cache: Dict[str, Tuple[argparse.Namespace, ...]] = \
-        {fname: ( tuple(roll_settings(yaml, args.plando) for yaml in yamls) if args.samesettings else None)
+        {fname: (tuple(roll_settings(yaml, args.plando) for yaml in yamls) if args.samesettings else None)
-                for fname, yamls in weights_cache.items()}
+         for fname, yamls in weights_cache.items()}
-    player_path_cache = {}
-    for player in range(1, args.multi + 1):
-        player_path_cache[player] = player_files.get(player, args.weights_file_path)
 
     if meta_weights:
         for category_name, category_dict in meta_weights.items():
             for key in category_dict:
-                option = get_choice(key, category_dict)
+                option = roll_meta_option(key, category_name, category_dict)
                 if option is not None:
-                    for player, path in player_path_cache.items():
+                    for path in weights_cache:
                         for yaml in weights_cache[path]:
                             if category_name is None:
-                                yaml[key] = option
+                                for category in yaml:
+                                    if category in AutoWorldRegister.world_types and key in Options.common_options:
+                                        yaml[category][key] = option
                             elif category_name not in yaml:
                                 logging.warning(f"Meta: Category {category_name} is not present in {path}.")
                             else:
-                               yaml[category_name][key] = option
+                                yaml[category_name][key] = option
 
+    player_path_cache = {}
+    for player in range(1, args.multi + 1):
+        player_path_cache[player] = player_files.get(player, args.weights_file_path)
     name_counter = Counter()
     erargs.player_settings = {}
 
@@ -342,19 +336,6 @@ def prefer_int(input_data: str) -> Union[str, int]:
         return input_data
 
 
-available_boss_names: Set[str] = {boss.lower() for boss in Bosses.boss_table if boss not in
-                                         {'Agahnim', 'Agahnim2', 'Ganon'}}
-available_boss_locations: Set[str] = {f"{loc.lower()}{f' {level}' if level else ''}" for loc, level in
-                                             Bosses.boss_location_table}
-
-boss_shuffle_options = {None: 'none',
-                        'none': 'none',
-                        'basic': 'basic',
-                        'full': 'full',
-                        'chaos': 'chaos',
-                        'singularity': 'singularity'
-                        }
-
 goals = {
     'ganon': 'ganon',
     'crystals': 'crystals',
@@ -387,6 +368,28 @@ def update_weights(weights: dict, new_weights: dict, type: str, name: str) -> di
     return weights
 
 
+def roll_meta_option(option_key, game: str, category_dict: Dict) -> Any:
+    if not game:
+        return get_choice(option_key, category_dict)
+    if game in AutoWorldRegister.world_types:
+        game_world = AutoWorldRegister.world_types[game]
+        options = ChainMap(game_world.option_definitions, Options.per_game_common_options)
+        if option_key in options:
+            if options[option_key].supports_weighting:
+                return get_choice(option_key, category_dict)
+            return options[option_key]
+    if game == "A Link to the Past":  # TODO wow i hate this
+        if option_key in {"glitches_required", "dark_room_logic", "entrance_shuffle", "goals", "triforce_pieces_mode",
+                          "triforce_pieces_percentage", "triforce_pieces_available", "triforce_pieces_extra",
+                          "triforce_pieces_required", "shop_shuffle", "mode", "item_pool", "item_functionality",
+                          "boss_shuffle", "enemy_damage", "enemy_health", "timer", "countdown_start_time",
+                          "red_clock_time", "blue_clock_time", "green_clock_time", "dungeon_counters", "shuffle_prizes",
+                          "misery_mire_medallion", "turtle_rock_medallion", "sprite_pool", "sprite",
+                          "random_sprite_on_event"}:
+            return get_choice(option_key, category_dict)
+    raise Exception(f"Error generating meta option {option_key} for {game}.")
+
+
 def roll_linked_options(weights: dict) -> dict:
     weights = copy.deepcopy(weights)  # make sure we don't write back to other weights sets in same_settings
     for option_set in weights["linked_options"]:
@@ -439,42 +442,7 @@ def roll_triggers(weights: dict, triggers: list) -> dict:
     return weights
 
 
-def get_plando_bosses(boss_shuffle: str, plando_options: Set[str]) -> str:
+def handle_option(ret: argparse.Namespace, game_weights: dict, option_key: str, option: type(Options.Option), plando_options: PlandoSettings):
-    if boss_shuffle in boss_shuffle_options:
-        return boss_shuffle_options[boss_shuffle]
-    elif PlandoSettings.bosses in plando_options:
-        options = boss_shuffle.lower().split(";")
-        remainder_shuffle = "none"  # vanilla
-        bosses = []
-        for boss in options:
-            if boss in boss_shuffle_options:
-                remainder_shuffle = boss_shuffle_options[boss]
-            elif "-" in boss:
-                loc, boss_name = boss.split("-")
-                if boss_name not in available_boss_names:
-                    raise ValueError(f"Unknown Boss name {boss_name}")
-                if loc not in available_boss_locations:
-                    raise ValueError(f"Unknown Boss Location {loc}")
-                level = ''
-                if loc.split(" ")[-1] in {"top", "middle", "bottom"}:
-                    # split off level
-                    loc = loc.split(" ")
-                    level = f" {loc[-1]}"
-                    loc = " ".join(loc[:-1])
-                loc = loc.title().replace("Of", "of")
-                if not Bosses.can_place_boss(boss_name.title(), loc, level):
-                    raise ValueError(f"Cannot place {boss_name} at {loc}{level}")
-                bosses.append(boss)
-            elif boss not in available_boss_names:
-                raise ValueError(f"Unknown Boss name or Boss shuffle option {boss}.")
-            else:
-                bosses.append(boss)
-        return ";".join(bosses + [remainder_shuffle])
-    else:
-        raise Exception(f"Boss Shuffle {boss_shuffle} is unknown and boss plando is turned off.")
-
-
-def handle_option(ret: argparse.Namespace, game_weights: dict, option_key: str, option: type(Options.Option)):
     if option_key in game_weights:
         try:
             if not option.supports_weighting:
@@ -485,10 +453,9 @@ 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:
-            if hasattr(player_option, "verify"):
+            player_option.verify(AutoWorldRegister.world_types[ret.game], ret.name, plando_options)
-                player_option.verify(AutoWorldRegister.world_types[ret.game])
     else:
-        setattr(ret, option_key, option(option.default))
+        setattr(ret, option_key, option.from_any(option.default))  # call the from_any here to support default "random"
 
 
 def roll_settings(weights: dict, plando_options: PlandoSettings = PlandoSettings.bosses):
@@ -531,12 +498,12 @@ def roll_settings(weights: dict, plando_options: PlandoSettings = PlandoSettings
         setattr(ret, option_key, option.from_any(get_choice(option_key, weights, option.default)))
 
     if ret.game in AutoWorldRegister.world_types:
-        for option_key, option in world_type.options.items():
+        for option_key, option in world_type.option_definitions.items():
-            handle_option(ret, game_weights, option_key, option)
+            handle_option(ret, game_weights, option_key, option, plando_options)
         for option_key, option in Options.per_game_common_options.items():
             # skip setting this option if already set from common_options, defaulting to root option
             if not (option_key in Options.common_options and option_key not in game_weights):
-                handle_option(ret, game_weights, option_key, option)
+                handle_option(ret, game_weights, option_key, option, plando_options)
         if PlandoSettings.items in plando_options:
             ret.plando_items = game_weights.get("plando_items", [])
         if ret.game == "Minecraft" or ret.game == "Ocarina of Time":
@@ -619,8 +586,6 @@ def roll_alttp_settings(ret: argparse.Namespace, weights, plando_options):
 
     ret.item_functionality = get_choice_legacy('item_functionality', weights)
 
-    boss_shuffle = get_choice_legacy('boss_shuffle', weights)
-    ret.shufflebosses = get_plando_bosses(boss_shuffle, plando_options)
 
     ret.enemy_damage = {None: 'default',
                         'default': 'default',

Launcher.py

@@ -10,16 +10,21 @@ Scroll down to components= to add components to the launcher as well as setup.py
 
 
 import argparse
-from os.path import isfile
-import sys
-from typing import Iterable, Sequence, Callable, Union, Optional
-import subprocess
 import itertools
-from Utils import is_frozen, user_path, local_path, init_logging, open_filename, messagebox,\
-    is_windows, is_macos, is_linux
-from shutil import which
 import shlex
+import subprocess
+import sys
 from enum import Enum, auto
+from os.path import isfile
+from shutil import which
+from typing import Iterable, Sequence, Callable, Union, Optional
+
+if __name__ == "__main__":
+    import ModuleUpdate
+    ModuleUpdate.update()
+
+from Utils import is_frozen, user_path, local_path, init_logging, open_filename, messagebox, \
+    is_windows, is_macos, is_linux
 
 
 def open_host_yaml():
@@ -65,6 +70,7 @@ def browse_files():
         webbrowser.open(file)
 
 
+# noinspection PyArgumentList
 class Type(Enum):
     TOOL = auto()
     FUNC = auto()  # not a real component

LttPAdjuster.py

@@ -83,9 +83,9 @@ def main():
     parser.add_argument('--ow_palettes', default='default',
                         choices=['default', 'random', 'blackout', 'puke', 'classic', 'grayscale', 'negative', 'dizzy',
                                  'sick'])
-    parser.add_argument('--link_palettes', default='default',
+    # parser.add_argument('--link_palettes', default='default',
-                        choices=['default', 'random', 'blackout', 'puke', 'classic', 'grayscale', 'negative', 'dizzy',
+    #                     choices=['default', 'random', 'blackout', 'puke', 'classic', 'grayscale', 'negative', 'dizzy',
-                                 'sick'])
+    #                              'sick'])
     parser.add_argument('--shield_palettes', default='default',
                         choices=['default', 'random', 'blackout', 'puke', 'classic', 'grayscale', 'negative', 'dizzy',
                                  'sick'])
@@ -752,6 +752,7 @@ class SpriteSelector():
         self.window['pady'] = 5
         self.spritesPerRow = 32
         self.all_sprites = []
+        self.invalid_sprites = []
         self.sprite_pool = spritePool
 
         def open_custom_sprite_dir(_evt):
@@ -833,6 +834,13 @@ class SpriteSelector():
         self.window.focus()
         tkinter_center_window(self.window)
 
+        if self.invalid_sprites:
+            invalid = sorted(self.invalid_sprites)
+            logging.warning(f"The following sprites are invalid: {', '.join(invalid)}")
+            msg = f"{invalid[0]} "
+            msg += f"and {len(invalid)-1} more are invalid" if len(invalid) > 1 else "is invalid"
+            messagebox.showerror("Invalid sprites detected", msg, parent=self.window)
+
     def remove_from_sprite_pool(self, button, spritename):
         self.callback(("remove", spritename))
         self.spritePoolButtons.buttons.remove(button)
@@ -897,7 +905,13 @@ class SpriteSelector():
         sprites = []
 
         for file in os.listdir(path):
-            sprites.append((file, Sprite(os.path.join(path, file))))
+            if file == '.gitignore':
+                continue
+            sprite = Sprite(os.path.join(path, file))
+            if sprite.valid:
+                sprites.append((file, sprite))
+            else:
+                self.invalid_sprites.append(file)
 
         sprites.sort(key=lambda s: str.lower(s[1].name or "").strip())
 

Main.py

@@ -12,7 +12,7 @@ from typing import Dict, Tuple, Optional, Set
 
 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 worlds.alttp.Regions import is_main_entrance
 from Fill import distribute_items_restrictive, flood_items, balance_multiworld_progression, distribute_planned
 from worlds.alttp.Shops import SHOP_ID_START, total_shop_slots, FillDisabledShopSlots
 from Utils import output_path, get_options, __version__, version_tuple
@@ -70,7 +70,6 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
     world.required_medallions = args.required_medallions.copy()
     world.game = args.game.copy()
     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.
 
@@ -217,9 +216,6 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
 
     logger.info("Running Item Plando")
 
-    for item in world.itempool:
-        item.world = world
-
     distribute_planned(world)
 
     logger.info('Running Pre Main Fill.')
@@ -253,24 +249,9 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
                     output_file_futures.append(
                         pool.submit(AutoWorld.call_single, world, "generate_output", player, temp_dir))
 
-            def get_entrance_to_region(region: Region):
-                for entrance in region.entrances:
-                    if entrance.parent_region.type in (RegionType.DarkWorld, RegionType.LightWorld, RegionType.Generic):
-                        return entrance
-                for entrance in region.entrances:  # BFS might be better here, trying DFS for now.
-                    return get_entrance_to_region(entrance.parent_region)
-
             # collect ER hint info
-            er_hint_data = {player: {} for player in world.get_game_players("A Link to the Past") if
+            er_hint_data: Dict[int, Dict[int, str]] = {}
-                            world.shuffle[player] != "vanilla" or world.retro_caves[player]}
+            AutoWorld.call_all(world, 'extend_hint_information', er_hint_data)
-
-            for region in world.regions:
-                if region.player in er_hint_data and region.locations:
-                    main_entrance = get_entrance_to_region(region)
-                    for location in region.locations:
-                        if type(location.address) == int:  # skips events and crystals
-                            if lookup_vanilla_location_to_entrance[location.address] != main_entrance.name:
-                                er_hint_data[region.player][location.address] = main_entrance.name
 
             checks_in_area = {player: {area: list() for area in ordered_areas}
                               for player in range(1, world.players + 1)}
@@ -280,22 +261,23 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
 
             for location in world.get_filled_locations():
                 if type(location.address) is int:
-                    main_entrance = get_entrance_to_region(location.parent_region)
                     if location.game != "A Link to the Past":
                         checks_in_area[location.player]["Light World"].append(location.address)
-                    elif location.parent_region.dungeon:
+                    else:
-                        dungeonname = {'Inverted Agahnims Tower': 'Agahnims Tower',
+                        main_entrance = location.parent_region.get_connecting_entrance(is_main_entrance)
-                                       'Inverted Ganons Tower': 'Ganons Tower'} \
+                        if location.parent_region.dungeon:
-                            .get(location.parent_region.dungeon.name, location.parent_region.dungeon.name)
+                            dungeonname = {'Inverted Agahnims Tower': 'Agahnims Tower',
-                        checks_in_area[location.player][dungeonname].append(location.address)
+                                           'Inverted Ganons Tower': 'Ganons Tower'} \
-                    elif location.parent_region.type == RegionType.LightWorld:
+                                .get(location.parent_region.dungeon.name, location.parent_region.dungeon.name)
-                        checks_in_area[location.player]["Light World"].append(location.address)
+                            checks_in_area[location.player][dungeonname].append(location.address)
-                    elif location.parent_region.type == RegionType.DarkWorld:
+                        elif location.parent_region.type == RegionType.LightWorld:
-                        checks_in_area[location.player]["Dark World"].append(location.address)
+                            checks_in_area[location.player]["Light World"].append(location.address)
-                    elif main_entrance.parent_region.type == RegionType.LightWorld:
+                        elif location.parent_region.type == RegionType.DarkWorld:
-                        checks_in_area[location.player]["Light World"].append(location.address)
+                            checks_in_area[location.player]["Dark World"].append(location.address)
-                    elif main_entrance.parent_region.type == RegionType.DarkWorld:
+                        elif main_entrance.parent_region.type == RegionType.LightWorld:
-                        checks_in_area[location.player]["Dark World"].append(location.address)
+                            checks_in_area[location.player]["Light World"].append(location.address)
+                        elif main_entrance.parent_region.type == RegionType.DarkWorld:
+                            checks_in_area[location.player]["Dark World"].append(location.address)
                     checks_in_area[location.player]["Total"] += 1
 
             oldmancaves = []
@@ -309,7 +291,7 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
                     player = region.player
                     location_id = SHOP_ID_START + total_shop_slots + index
 
-                    main_entrance = get_entrance_to_region(region)
+                    main_entrance = region.get_connecting_entrance(is_main_entrance)
                     if main_entrance.parent_region.type == RegionType.LightWorld:
                         checks_in_area[player]["Light World"].append(location_id)
                     else:
@@ -344,7 +326,6 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
                                       for player, world_precollected in world.precollected_items.items()}
                 precollected_hints = {player: set() for player in range(1, world.players + 1 + len(world.groups))}
 
-
                 for slot in world.player_ids:
                     slot_data[slot] = world.worlds[slot].fill_slot_data()
 
@@ -426,7 +407,7 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
             world.spoiler.to_file(os.path.join(temp_dir, '%s_Spoiler.txt' % outfilebase))
 
         zipfilename = output_path(f"AP_{world.seed_name}.zip")
-        logger.info(f'Creating final archive at {zipfilename}.')
+        logger.info(f"Creating final archive at {zipfilename}")
         with zipfile.ZipFile(zipfilename, mode="w", compression=zipfile.ZIP_DEFLATED,
                              compresslevel=9) as zf:
             for file in os.scandir(temp_dir):

MultiServer.py

@@ -30,17 +30,13 @@ except ImportError:
     OperationalError = ConnectionError
 
 import NetUtils
-from worlds.AutoWorld import AutoWorldRegister
-
-proxy_worlds = {name: world(None, 0) for name, world in AutoWorldRegister.world_types.items()}
-from worlds import network_data_package, lookup_any_item_id_to_name, lookup_any_location_id_to_name
 import Utils
-from Utils import get_item_name_from_id, get_location_name_from_id, \
+from Utils import version_tuple, restricted_loads, Version
-    version_tuple, restricted_loads, Version
 from NetUtils import Endpoint, ClientStatus, NetworkItem, decode, encode, NetworkPlayer, Permission, NetworkSlot, \
     SlotType
 
 min_client_version = Version(0, 1, 6)
+print_command_compatability_threshold = Version(0, 3, 5) # Remove backwards compatibility around 0.3.7
 colorama.init()
 
 # functions callable on storable data on the server by clients
@@ -126,6 +122,12 @@ class Context:
     stored_data: typing.Dict[str, object]
     stored_data_notification_clients: typing.Dict[str, typing.Set[Client]]
 
+    item_names: typing.Dict[int, str] = Utils.KeyedDefaultDict(lambda code: f'Unknown item (ID:{code})')
+    location_names: typing.Dict[int, str] = Utils.KeyedDefaultDict(lambda code: f'Unknown location (ID:{code})')
+    all_item_and_group_names: typing.Dict[str, typing.Set[str]]
+    forced_auto_forfeits: typing.Dict[str, bool]
+    non_hintable_names: typing.Dict[str, typing.Set[str]]
+
     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,
@@ -190,8 +192,43 @@ class Context:
         self.stored_data = {}
         self.stored_data_notification_clients = collections.defaultdict(weakref.WeakSet)
 
-    # General networking
+        # init empty to satisfy linter, I suppose
+        self.gamespackage = {}
+        self.item_name_groups = {}
+        self.all_item_and_group_names = {}
+        self.forced_auto_forfeits = collections.defaultdict(lambda: False)
+        self.non_hintable_names = collections.defaultdict(frozenset)
 
+        self._load_game_data()
+        self._init_game_data()
+
+    # Datapackage retrieval
+    def _load_game_data(self):
+        import worlds
+        self.gamespackage = worlds.network_data_package["games"]
+
+        self.item_name_groups = {world_name: world.item_name_groups for world_name, world in
+                                 worlds.AutoWorldRegister.world_types.items()}
+        for world_name, world in worlds.AutoWorldRegister.world_types.items():
+            self.forced_auto_forfeits[world_name] = world.forced_auto_forfeit
+            self.non_hintable_names[world_name] = world.hint_blacklist
+
+    def _init_game_data(self):
+        for game_name, game_package in self.gamespackage.items():
+            for item_name, item_id in game_package["item_name_to_id"].items():
+                self.item_names[item_id] = item_name
+            for location_name, location_id in game_package["location_name_to_id"].items():
+                self.location_names[location_id] = location_name
+            self.all_item_and_group_names[game_name] = \
+                set(game_package["item_name_to_id"]) | set(self.item_name_groups[game_name])
+
+    def item_names_for_game(self, game: str) -> typing.Optional[typing.Dict[str, int]]:
+        return self.gamespackage[game]["item_name_to_id"] if game in self.gamespackage else None
+
+    def location_names_for_game(self, game: str) -> typing.Optional[typing.Dict[str, int]]:
+        return self.gamespackage[game]["location_name_to_id"] if game in self.gamespackage else None
+
+    # General networking
     async def send_msgs(self, endpoint: Endpoint, msgs: typing.Iterable[dict]) -> bool:
         if not endpoint.socket or not endpoint.socket.open:
             return False
@@ -256,20 +293,27 @@ class Context:
 
     # text
 
-    def notify_all(self, text):
+    def notify_all(self, text: str):
         logging.info("Notice (all): %s" % text)
-        self.broadcast_all([{"cmd": "Print", "text": text}])
+        broadcast_text_all(self, text)
 
     def notify_client(self, client: Client, text: str):
         if not client.auth:
             return
         logging.info("Notice (Player %s in team %d): %s" % (client.name, client.team + 1, text))
-        asyncio.create_task(self.send_msgs(client, [{"cmd": "Print", "text": text}]))
+        if client.version >= print_command_compatability_threshold:
+            asyncio.create_task(self.send_msgs(client, [{"cmd": "PrintJSON", "data": [{ "text": text }]}]))
+        else:
+            asyncio.create_task(self.send_msgs(client, [{"cmd": "Print", "text": text}]))
 
     def notify_client_multiple(self, client: Client, texts: typing.List[str]):
         if not client.auth:
             return
-        asyncio.create_task(self.send_msgs(client, [{"cmd": "Print", "text": text} for text in texts]))
+        if client.version >= print_command_compatability_threshold:
+            asyncio.create_task(self.send_msgs(client, 
+                [{"cmd": "PrintJSON", "data": [{ "text": text }]} for text in texts]))
+        else:
+            asyncio.create_task(self.send_msgs(client, [{"cmd": "Print", "text": text} for text in texts]))
 
     # loading
 
@@ -544,12 +588,13 @@ class Context:
         finished_msg = f'{self.get_aliased_name(client.team, client.slot)} (Team #{client.team + 1})' \
                        f' has completed their goal.'
         self.notify_all(finished_msg)
-        if "auto" in self.forfeit_mode:
-            forfeit_player(self, client.team, client.slot)
-        elif proxy_worlds[self.games[client.slot]].forced_auto_forfeit:
-            forfeit_player(self, client.team, client.slot)
         if "auto" in self.collect_mode:
             collect_player(self, client.team, client.slot)
+        if "auto" in self.forfeit_mode:
+            forfeit_player(self, client.team, client.slot)
+        elif self.forced_auto_forfeits[self.games[client.slot]]:
+            forfeit_player(self, client.team, client.slot)
+        self.save()  # save goal completion flag
 
 
 def notify_hints(ctx: Context, team: int, hints: typing.List[NetUtils.Hint], only_new: bool = False):
@@ -642,9 +687,10 @@ async def on_client_connected(ctx: Context, client: Client):
         'permissions': get_permissions(ctx),
         'hint_cost': ctx.hint_cost,
         'location_check_points': ctx.location_check_points,
-        'datapackage_version': network_data_package["version"],
+        'datapackage_version': sum(game_data["version"] for game_data in ctx.gamespackage.values())
+        if all(game_data["version"] for game_data in ctx.gamespackage.values()) else 0,
         'datapackage_versions': {game: game_data["version"] for game, game_data
-                                 in network_data_package["games"].items()},
+                                 in ctx.gamespackage.items()},
         'seed_name': ctx.seed_name,
         'time': time.time(),
     }])
@@ -685,20 +731,37 @@ async def on_client_left(ctx: Context, client: Client):
     ctx.client_connection_timers[client.team, client.slot] = datetime.datetime.now(datetime.timezone.utc)
 
 
-async def countdown(ctx: Context, timer):
+async def countdown(ctx: Context, timer: int):
-    ctx.notify_all(f'[Server]: Starting countdown of {timer}s')
+    broadcast_countdown(ctx, timer, f"[Server]: Starting countdown of {timer}s")
     if ctx.countdown_timer:
         ctx.countdown_timer = timer  # timer is already running, set it to a different time
     else:
         ctx.countdown_timer = timer
         while ctx.countdown_timer > 0:
-            ctx.notify_all(f'[Server]: {ctx.countdown_timer}')
+            broadcast_countdown(ctx, ctx.countdown_timer, f"[Server]: {ctx.countdown_timer}")
             ctx.countdown_timer -= 1
             await asyncio.sleep(1)
-        ctx.notify_all(f'[Server]: GO')
+        broadcast_countdown(ctx, 0, f"[Server]: GO")
         ctx.countdown_timer = 0
 
 
+def broadcast_text_all(ctx: Context, text: str, additional_arguments: dict = {}):
+    old_clients, new_clients = [], []
+
+    for teams in ctx.clients.values():
+        for clients in teams.values():
+            for client in clients:
+                new_clients.append(client) if client.version >= print_command_compatability_threshold \
+                    else old_clients.append(client)
+
+    ctx.broadcast(old_clients, [{"cmd": "Print", "text": text }])
+    ctx.broadcast(new_clients, [{**{"cmd": "PrintJSON", "data": [{ "text": text }]}, **additional_arguments}])
+
+
+def broadcast_countdown(ctx: Context, timer: int, message: str):
+    broadcast_text_all(ctx, message, {"type": "Countdown", "countdown": timer})
+
+
 def get_players_string(ctx: Context):
     auth_clients = {(c.team, c.slot) for c in ctx.endpoints if c.auth}
 
@@ -822,8 +885,8 @@ def register_location_checks(ctx: Context, team: int, slot: int, locations: typi
             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),
+                team + 1, ctx.player_names[(team, slot)], ctx.item_names[item_id],
-                ctx.player_names[(team, target_player)], get_location_name_from_id(location)))
+                ctx.player_names[(team, target_player)], ctx.location_names[location]))
             info_text = json_format_send_event(new_item, target_player)
             ctx.broadcast_team(team, [info_text])
 
@@ -838,13 +901,14 @@ def register_location_checks(ctx: Context, team: int, slot: int, locations: typi
         ctx.save()
 
 
-def collect_hints(ctx: Context, team: int, slot: int, item: str) -> typing.List[NetUtils.Hint]:
+def collect_hints(ctx: Context, team: int, slot: int, item: typing.Union[int, str]) -> typing.List[NetUtils.Hint]:
     hints = []
     slots: typing.Set[int] = {slot}
     for group_id, group in ctx.groups.items():
         if slot in group:
             slots.add(group_id)
-    seeked_item_id = proxy_worlds[ctx.games[slot]].item_name_to_id[item]
+
+    seeked_item_id = item if isinstance(item, int) else ctx.item_names_for_game(ctx.games[slot])[item]
     for finding_player, check_data in ctx.locations.items():
         for location_id, (item_id, receiving_player, item_flags) in check_data.items():
             if receiving_player in slots and item_id == seeked_item_id:
@@ -857,7 +921,7 @@ def collect_hints(ctx: Context, team: int, slot: int, item: str) -> typing.List[
 
 
 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]
+    seeked_location: int = ctx.location_names_for_game(ctx.games[slot])[location]
     return collect_hint_location_id(ctx, team, slot, seeked_location)
 
 
@@ -874,8 +938,8 @@ def collect_hint_location_id(ctx: Context, team: int, slot: int, seeked_location
 
 def format_hint(ctx: Context, team: int, hint: NetUtils.Hint) -> str:
     text = f"[Hint]: {ctx.player_names[team, hint.receiving_player]}'s " \
-           f"{lookup_any_item_id_to_name[hint.item]} is " \
+           f"{ctx.item_names[hint.item]} is " \
-           f"at {get_location_name_from_id(hint.location)} " \
+           f"at {ctx.location_names[hint.location]} " \
            f"in {ctx.player_names[team, hint.finding_player]}'s World"
 
     if hint.entrance:
@@ -1133,8 +1197,8 @@ class ClientMessageProcessor(CommonCommandProcessor):
             forfeit_player(self.ctx, self.client.team, self.client.slot)
             return True
         elif "disabled" in self.ctx.forfeit_mode:
-            self.output(
+            self.output("Sorry, client item releasing has been disabled on this server. "
-                "Sorry, client item releasing has been disabled on this server. You can ask the server admin for a /release")
+                        "You can ask the server admin for a /release")
             return False
         else:  # is auto or goal
             if self.ctx.client_game_state[self.client.team, self.client.slot] == ClientStatus.CLIENT_GOAL:
@@ -1170,7 +1234,7 @@ class ClientMessageProcessor(CommonCommandProcessor):
         if self.ctx.remaining_mode == "enabled":
             remaining_item_ids = get_remaining(self.ctx, self.client.team, self.client.slot)
             if remaining_item_ids:
-                self.output("Remaining items: " + ", ".join(lookup_any_item_id_to_name.get(item_id, "unknown item")
+                self.output("Remaining items: " + ", ".join(self.ctx.item_names[item_id]
                                                             for item_id in remaining_item_ids))
             else:
                 self.output("No remaining items found.")
@@ -1183,7 +1247,7 @@ class ClientMessageProcessor(CommonCommandProcessor):
             if self.ctx.client_game_state[self.client.team, self.client.slot] == ClientStatus.CLIENT_GOAL:
                 remaining_item_ids = get_remaining(self.ctx, self.client.team, self.client.slot)
                 if remaining_item_ids:
-                    self.output("Remaining items: " + ", ".join(lookup_any_item_id_to_name.get(item_id, "unknown item")
+                    self.output("Remaining items: " + ", ".join(self.ctx.item_names[item_id]
                                                                 for item_id in remaining_item_ids))
                 else:
                     self.output("No remaining items found.")
@@ -1199,7 +1263,7 @@ class ClientMessageProcessor(CommonCommandProcessor):
         locations = get_missing_checks(self.ctx, self.client.team, self.client.slot)
 
         if locations:
-            texts = [f'Missing: {get_location_name_from_id(location)}' for location in locations]
+            texts = [f'Missing: {self.ctx.location_names[location]}' for location in locations]
             texts.append(f"Found {len(locations)} missing location checks")
             self.ctx.notify_client_multiple(self.client, texts)
         else:
@@ -1212,7 +1276,7 @@ class ClientMessageProcessor(CommonCommandProcessor):
         locations = get_checked_checks(self.ctx, self.client.team, self.client.slot)
 
         if locations:
-            texts = [f'Checked: {get_location_name_from_id(location)}' for location in locations]
+            texts = [f'Checked: {self.ctx.location_names[location]}' for location in locations]
             texts.append(f"Found {len(locations)} done location checks")
             self.ctx.notify_client_multiple(self.client, texts)
         else:
@@ -1241,11 +1305,13 @@ class ClientMessageProcessor(CommonCommandProcessor):
     def _cmd_getitem(self, item_name: str) -> bool:
         """Cheat in an item, if it is enabled on this server"""
         if self.ctx.item_cheat:
-            world = proxy_worlds[self.ctx.games[self.client.slot]]
+            names = self.ctx.item_names_for_game(self.ctx.games[self.client.slot])
-            item_name, usable, response = get_intended_text(item_name,
+            item_name, usable, response = get_intended_text(
-                                                            world.item_names)
+                item_name,
+                names
+            )
             if usable:
-                new_item = NetworkItem(world.create_item(item_name).code, -1, self.client.slot)
+                new_item = NetworkItem(names[item_name], -1, self.client.slot)
                 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(
@@ -1270,88 +1336,112 @@ class ClientMessageProcessor(CommonCommandProcessor):
             self.output(f"A hint costs {self.ctx.get_hint_cost(self.client.slot)} points. "
                         f"You have {points_available} points.")
             return True
+
+        elif input_text.isnumeric():
+            game = self.ctx.games[self.client.slot]
+            hint_id = int(input_text)
+            hint_name = self.ctx.item_names[hint_id] \
+                if not for_location and hint_id in self.ctx.item_names \
+                else self.ctx.location_names[hint_id] \
+                if for_location and hint_id in self.ctx.location_names \
+                else None
+            if hint_name in self.ctx.non_hintable_names[game]:
+                self.output(f"Sorry, \"{hint_name}\" is marked as non-hintable.")
+                hints = []
+            elif not for_location:
+                hints = collect_hints(self.ctx, self.client.team, self.client.slot, hint_id)
+            else:
+                hints = collect_hint_location_id(self.ctx, self.client.team, self.client.slot, hint_id)
+
         else:
-            world = proxy_worlds[self.ctx.games[self.client.slot]]
+            game = self.ctx.games[self.client.slot]
-            names = world.location_names if for_location else world.all_item_and_group_names
+            if game not in self.ctx.all_item_and_group_names:
-            hint_name, usable, response = get_intended_text(input_text,
+                self.output("Can't look up item/location for unknown game. Hint for ID instead.")
-                                                            names)
+                return False
+            names = self.ctx.location_names_for_game(game) \
+                if for_location else \
+                self.ctx.all_item_and_group_names[game]
+            hint_name, usable, response = get_intended_text(input_text, names)
+
             if usable:
-                if hint_name in world.hint_blacklist:
+                if hint_name in self.ctx.non_hintable_names[game]:
                     self.output(f"Sorry, \"{hint_name}\" is marked as non-hintable.")
                     hints = []
-                elif not for_location and hint_name in world.item_name_groups:  # item group name
+                elif not for_location and hint_name in self.ctx.item_name_groups[game]:  # item group name
                     hints = []
-                    for item in world.item_name_groups[hint_name]:
+                    for item_name in self.ctx.item_name_groups[game][hint_name]:
-                        if item in world.item_name_to_id:  # ensure item has an ID
+                        if item_name in self.ctx.item_names_for_game(game):  # ensure item has an ID
-                            hints.extend(collect_hints(self.ctx, self.client.team, self.client.slot, item))
+                            hints.extend(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
+                elif not for_location and hint_name in self.ctx.item_names_for_game(game):  # item name
                     hints = collect_hints(self.ctx, self.client.team, self.client.slot, hint_name)
                 else:  # location 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]
-                    old_hints = set(hints) - new_hints
-                    if old_hints:
-                        notify_hints(self.ctx, self.client.team, list(old_hints))
-                        if not new_hints:
-                            self.output("Hint was previously used, no points deducted.")
-                    if new_hints:
-                        found_hints = [hint for hint in new_hints if hint.found]
-                        not_found_hints = [hint for hint in new_hints if not hint.found]
 
-                        if not not_found_hints:  # everything's been found, no need to pay
-                            can_pay = 1000
-                        elif cost:
-                            can_pay = int((points_available // cost) > 0)  # limit to 1 new hint per call
-                        else:
-                            can_pay = 1000
-
-                        self.ctx.random.shuffle(not_found_hints)
-                        # By popular vote, make hints prefer non-local placements
-                        not_found_hints.sort(key=lambda hint: int(hint.receiving_player != hint.finding_player))
-
-                        hints = found_hints
-                        while can_pay > 0:
-                            if not not_found_hints:
-                                break
-                            hint = not_found_hints.pop()
-                            hints.append(hint)
-                            can_pay -= 1
-                            self.ctx.hints_used[self.client.team, self.client.slot] += 1
-                            points_available = get_client_points(self.ctx, self.client)
-
-                        if not_found_hints:
-                            if hints and cost and int((points_available // cost) == 0):
-                                self.output(
-                                    f"There may be more hintables, however, you cannot afford to pay for any more. "
-                                    f" You have {points_available} and need at least "
-                                    f"{self.ctx.get_hint_cost(self.client.slot)}.")
-                            elif hints:
-                                self.output(
-                                    "There may be more hintables, you can rerun the command to find more.")
-                            else:
-                                self.output(f"You can't afford the hint. "
-                                            f"You have {points_available} points and need at least "
-                                            f"{self.ctx.get_hint_cost(self.client.slot)}.")
-                        notify_hints(self.ctx, self.client.team, hints)
-                        self.ctx.save()
-                        return True
-
-                else:
-                    self.output("Nothing found. Item/Location may not exist.")
-                    return False
             else:
                 self.output(response)
                 return False
 
+        if hints:
+            cost = self.ctx.get_hint_cost(self.client.slot)
+            new_hints = set(hints) - self.ctx.hints[self.client.team, self.client.slot]
+            old_hints = set(hints) - new_hints
+            if old_hints:
+                notify_hints(self.ctx, self.client.team, list(old_hints))
+                if not new_hints:
+                    self.output("Hint was previously used, no points deducted.")
+            if new_hints:
+                found_hints = [hint for hint in new_hints if hint.found]
+                not_found_hints = [hint for hint in new_hints if not hint.found]
+
+                if not not_found_hints:  # everything's been found, no need to pay
+                    can_pay = 1000
+                elif cost:
+                    can_pay = int((points_available // cost) > 0)  # limit to 1 new hint per call
+                else:
+                    can_pay = 1000
+
+                self.ctx.random.shuffle(not_found_hints)
+                # By popular vote, make hints prefer non-local placements
+                not_found_hints.sort(key=lambda hint: int(hint.receiving_player != hint.finding_player))
+
+                hints = found_hints
+                while can_pay > 0:
+                    if not not_found_hints:
+                        break
+                    hint = not_found_hints.pop()
+                    hints.append(hint)
+                    can_pay -= 1
+                    self.ctx.hints_used[self.client.team, self.client.slot] += 1
+                    points_available = get_client_points(self.ctx, self.client)
+
+                if not_found_hints:
+                    if hints and cost and int((points_available // cost) == 0):
+                        self.output(
+                            f"There may be more hintables, however, you cannot afford to pay for any more. "
+                            f" You have {points_available} and need at least "
+                            f"{self.ctx.get_hint_cost(self.client.slot)}.")
+                    elif hints:
+                        self.output(
+                            "There may be more hintables, you can rerun the command to find more.")
+                    else:
+                        self.output(f"You can't afford the hint. "
+                                    f"You have {points_available} points and need at least "
+                                    f"{self.ctx.get_hint_cost(self.client.slot)}.")
+                notify_hints(self.ctx, self.client.team, hints)
+                self.ctx.save()
+                return True
+
+        else:
+            self.output("Nothing found. Item/Location may not exist.")
+            return False
+
     @mark_raw
-    def _cmd_hint(self, item: str = "") -> bool:
+    def _cmd_hint(self, item_name: 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)
+        return self.get_hints(item_name)
 
     @mark_raw
     def _cmd_hint_location(self, location: str = "") -> bool:
@@ -1477,23 +1567,23 @@ async def process_client_cmd(ctx: Context, client: Client, args: dict):
     elif cmd == "GetDataPackage":
         exclusions = args.get("exclusions", [])
         if "games" in args:
-            games = {name: game_data for name, game_data in network_data_package["games"].items()
+            games = {name: game_data for name, game_data in ctx.gamespackage.items()
                      if name in set(args.get("games", []))}
             await ctx.send_msgs(client, [{"cmd": "DataPackage",
                                           "data": {"games": games}}])
         # TODO: remove exclusions behaviour around 0.5.0
         elif exclusions:
             exclusions = set(exclusions)
-            games = {name: game_data for name, game_data in network_data_package["games"].items()
+            games = {name: game_data for name, game_data in ctx.gamespackage.items()
                      if name not in exclusions}
-            package = network_data_package.copy()
+
-            package["games"] = games
+            package = {"games": games}
             await ctx.send_msgs(client, [{"cmd": "DataPackage",
                                           "data": package}])
 
         else:
             await ctx.send_msgs(client, [{"cmd": "DataPackage",
-                                          "data": network_data_package}])
+                                          "data": {"games": ctx.gamespackage}}])
 
     elif client.auth:
         if cmd == "ConnectUpdate":
@@ -1549,7 +1639,7 @@ async def process_client_cmd(ctx: Context, client: Client, args: dict):
             create_as_hint: int = int(args.get("create_as_hint", 0))
             hints = []
             for location in args["locations"]:
-                if type(location) is not int or location not in lookup_any_location_id_to_name:
+                if type(location) is not int:
                     await ctx.send_msgs(client,
                                         [{'cmd': 'InvalidPacket', "type": "arguments", "text": 'LocationScouts',
                                           "original_cmd": cmd}])
@@ -1763,18 +1853,18 @@ class ServerCommandProcessor(CommonCommandProcessor):
         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_name)
+            item_name = " ".join(item_name)
-            world = proxy_worlds[self.ctx.games[slot]]
+            names = self.ctx.item_names_for_game(self.ctx.games[slot])
-            item, usable, response = get_intended_text(item, world.item_names)
+            item_name, usable, response = get_intended_text(item_name, names)
             if usable:
                 amount: int = int(amount)
-                new_items = [NetworkItem(world.item_name_to_id[item], -1, 0) for i in range(int(amount))]
+                new_items = [NetworkItem(names[item_name], -1, 0) for _ 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)}')
+                    f'"{item_name}" to {self.ctx.get_aliased_name(team, slot)}')
                 return True
             else:
                 self.output(response)
@@ -1787,21 +1877,29 @@ class ServerCommandProcessor(CommonCommandProcessor):
         """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:
+    def _cmd_hint(self, player_name: str, *item_name: 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)
+            game = self.ctx.games[slot]
-            world = proxy_worlds[self.ctx.games[slot]]
+            full_name = " ".join(item_name)
-            item, usable, response = get_intended_text(item, world.all_item_and_group_names)
+
+            if full_name.isnumeric():
+                item, usable, response = int(full_name), True, None
+            elif game in self.ctx.all_item_and_group_names:
+                item, usable, response = get_intended_text(full_name, self.ctx.all_item_and_group_names[game])
+            else:
+                self.output("Can't look up item for unknown game. Hint for ID instead.")
+                return False
+
             if usable:
-                if item in world.item_name_groups:
+                if game in self.ctx.item_name_groups and item in self.ctx.item_name_groups[game]:
                     hints = []
-                    for item in world.item_name_groups[item]:
+                    for item_name_from_group in self.ctx.item_name_groups[game][item]:
-                        if item in world.item_name_to_id:  # ensure item has an ID
+                        if item_name_from_group in self.ctx.item_names_for_game(game):  # ensure item has an ID
-                            hints.extend(collect_hints(self.ctx, team, slot, item))
+                            hints.extend(collect_hints(self.ctx, team, slot, item_name_from_group))
-                else:  # item name
+                else:  # item name or id
                     hints = collect_hints(self.ctx, team, slot, item)
 
                 if hints:
@@ -1818,16 +1916,27 @@ class ServerCommandProcessor(CommonCommandProcessor):
             self.output(response)
             return False
 
-    def _cmd_hint_location(self, player_name: str, *location: str) -> bool:
+    def _cmd_hint_location(self, player_name: str, *location_name: 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)
+            game = self.ctx.games[slot]
-            world = proxy_worlds[self.ctx.games[slot]]
+            full_name = " ".join(location_name)
-            item, usable, response = get_intended_text(item, world.location_names)
+
+            if full_name.isnumeric():
+                location, usable, response = int(full_name), True, None
+            elif self.ctx.location_names_for_game(game) is not None:
+                location, usable, response = get_intended_text(full_name, self.ctx.location_names_for_game(game))
+            else:
+                self.output("Can't look up location for unknown game. Hint for ID instead.")
+                return False
+
             if usable:
-                hints = collect_hint_location_name(self.ctx, team, slot, item)
+                if isinstance(location, int):
+                    hints = collect_hint_location_id(self.ctx, team, slot, location)
+                else:
+                    hints = collect_hint_location_name(self.ctx, team, slot, location)
                 if hints:
                     notify_hints(self.ctx, team, hints)
                 else:
@@ -1977,15 +2086,28 @@ async def main(args: argparse.Namespace):
                   args.auto_shutdown, args.compatibility, args.log_network)
     data_filename = args.multidata
 
-    try:
+    if not data_filename:
-        if not data_filename:
+        try:
             filetypes = (("Multiworld data", (".archipelago", ".zip")),)
             data_filename = Utils.open_filename("Select multiworld data", filetypes)
 
+        except Exception as e:
+            if isinstance(e, ImportError) or (e.__class__.__name__ == "TclError" and "no display" in str(e)):
+                if not isinstance(e, ImportError):
+                    logging.error(f"Failed to load tkinter ({e})")
+                logging.info("Pass a multidata filename on command line to run headless.")
+                exit(1)
+            raise
+
+        if not data_filename:
+            logging.info("No file selected. Exiting.")
+            exit(1)
+
+    try:
         ctx.load(data_filename, args.use_embedded_options)
 
     except Exception as e:
-        logging.exception('Failed to read multiworld data (%s)' % e)
+        logging.exception(f"Failed to read multiworld data ({e})")
         raise
 
     ctx.init_save(not args.disable_save)

NetUtils.py

@@ -270,7 +270,7 @@ class RawJSONtoTextParser(JSONtoTextParser):
 
 color_codes = {'reset': 0, 'bold': 1, 'underline': 4, 'black': 30, 'red': 31, 'green': 32, 'yellow': 33, 'blue': 34,
                'magenta': 35, 'cyan': 36, 'white': 37, 'black_bg': 40, 'red_bg': 41, 'green_bg': 42, 'yellow_bg': 43,
-               'blue_bg': 44, 'purple_bg': 45, 'cyan_bg': 46, 'white_bg': 47}
+               'blue_bg': 44, 'magenta_bg': 45, 'cyan_bg': 46, 'white_bg': 47}
 
 
 def color_code(*args):

Options.py

@@ -26,15 +26,31 @@ class AssembleOptions(abc.ABCMeta):
 
         attrs["name_lookup"].update({option_id: name for name, option_id in new_options.items()})
         options.update(new_options)
-
         # apply aliases, without name_lookup
         aliases = {name[6:].lower(): option_id for name, option_id in attrs.items() if
                    name.startswith("alias_")}
 
         assert "random" not in aliases, "Choice option 'random' cannot be manually assigned."
 
+        # auto-alias Off and On being parsed as True and False
+        if "off" in options:
+            options["false"] = options["off"]
+        if "on" in options:
+            options["true"] = options["on"]
+
         options.update(aliases)
 
+        if "verify" not in attrs:
+            # not overridden by class -> look up bases
+            verifiers = [f for f in (getattr(base, "verify", None) for base in bases) if f]
+            if len(verifiers) > 1:  # verify multiple bases/mixins
+                def verify(self, *args, **kwargs) -> None:
+                    for f in verifiers:
+                        f(self, *args, **kwargs)
+                attrs["verify"] = verify
+            else:
+                assert verifiers, "class Option is supposed to implement def verify"
+
         # auto-validate schema on __init__
         if "schema" in attrs.keys():
 
@@ -112,6 +128,41 @@ class Option(typing.Generic[T], metaclass=AssembleOptions):
     def from_any(cls, data: typing.Any) -> Option[T]:
         raise NotImplementedError
 
+    if typing.TYPE_CHECKING:
+        from Generate import PlandoSettings
+        from worlds.AutoWorld import World
+
+        def verify(self, world: World, player_name: str, plando_options: PlandoSettings) -> None:
+            pass
+    else:
+        def verify(self, *args, **kwargs) -> None:
+            pass
+
+
+class FreeText(Option):
+    """Text option that allows users to enter strings.
+    Needs to be validated by the world or option definition."""
+
+    def __init__(self, value: str):
+        assert isinstance(value, str), "value of FreeText must be a string"
+        self.value = value
+
+    @property
+    def current_key(self) -> str:
+        return self.value
+
+    @classmethod
+    def from_text(cls, text: str) -> FreeText:
+        return cls(text)
+
+    @classmethod
+    def from_any(cls, data: typing.Any) -> FreeText:
+        return cls.from_text(str(data))
+
+    @classmethod
+    def get_option_name(cls, value: T) -> str:
+        return value
+
 
 class NumericOption(Option[int], numbers.Integral):
     # note: some of the `typing.Any`` here is a result of unresolved issue in python standards
@@ -298,7 +349,7 @@ class Toggle(NumericOption):
         if type(data) == str:
             return cls.from_text(data)
         else:
-            return cls(data)
+            return cls(int(data))
 
     @classmethod
     def get_option_name(cls, value):
@@ -368,6 +419,53 @@ class Choice(NumericOption):
     __hash__ = Option.__hash__  # see https://docs.python.org/3/reference/datamodel.html#object.__hash__
 
 
+class TextChoice(Choice):
+    """Allows custom string input and offers choices. Choices will resolve to int and text will resolve to string"""
+
+    def __init__(self, value: typing.Union[str, int]):
+        assert isinstance(value, str) or isinstance(value, int), \
+            f"{value} is not a valid option for {self.__class__.__name__}"
+        self.value = value
+        super(TextChoice, self).__init__()
+
+    @property
+    def current_key(self) -> str:
+        if isinstance(self.value, str):
+            return self.value
+        else:
+            return self.name_lookup[self.value]
+
+    @classmethod
+    def from_text(cls, text: str) -> TextChoice:
+        if text.lower() == "random":  # chooses a random defined option but won't use any free text options
+            return cls(random.choice(list(cls.name_lookup)))
+        for option_name, value in cls.options.items():
+            if option_name.lower() == text.lower():
+                return cls(value)
+        return cls(text)
+
+    @classmethod
+    def get_option_name(cls, value: T) -> str:
+        if isinstance(value, str):
+            return value
+        return cls.name_lookup[value]
+
+    def __eq__(self, other: typing.Any):
+        if isinstance(other, self.__class__):
+            return other.value == self.value
+        elif isinstance(other, str):
+            if other in self.options:
+                return other == self.current_key
+            return other == self.value
+        elif isinstance(other, int):
+            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)
+        else:
+            raise TypeError(f"Can't compare {self.__class__.__name__} with {other.__class__.__name__}")
+
+
 class Range(NumericOption):
     range_start = 0
     range_end = 1
@@ -385,7 +483,7 @@ class Range(NumericOption):
         if text.startswith("random"):
             return cls.weighted_range(text)
         elif text == "default" and hasattr(cls, "default"):
-            return cls(cls.default)
+            return cls.from_any(cls.default)
         elif text == "high":
             return cls(cls.range_end)
         elif text == "low":
@@ -396,7 +494,7 @@ class Range(NumericOption):
                 and text in ("true", "false"):
             # these are the conditions where "true" and "false" make sense
             if text == "true":
-                return cls(cls.default)
+                return cls.from_any(cls.default)
             else:  # "false"
                 return cls(0)
         return cls(int(text))
@@ -507,7 +605,7 @@ class VerifyKeys:
                 raise Exception(f"Found unexpected key {', '.join(extra)} in {cls}. "
                                 f"Allowed keys: {cls.valid_keys}.")
 
-    def verify(self, world):
+    def verify(self, world, player_name: str, plando_options) -> None:
         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:
@@ -600,10 +698,7 @@ class OptionSet(Option[typing.Set[str]], VerifyKeys):
 
     @classmethod
     def from_any(cls, data: typing.Any):
-        if type(data) == list:
+        if isinstance(data, (list, set, frozenset)):
-            cls.verify_keys(data)
-            return cls(data)
-        elif type(data) == set:
             cls.verify_keys(data)
             return cls(data)
         return cls.from_text(str(data))
@@ -732,8 +827,8 @@ class ItemLinks(OptionList):
                 pool |= {item_name}
         return pool
 
-    def verify(self, world):
+    def verify(self, world, player_name: str, plando_options) -> None:
-        super(ItemLinks, self).verify(world)
+        super(ItemLinks, self).verify(world, player_name, plando_options)
         existing_links = set()
         for link in self.value:
             if link["name"] in existing_links:

Patch.py

@@ -17,7 +17,7 @@ ModuleUpdate.update()
 
 import Utils
 
-current_patch_version = 4
+current_patch_version = 5
 
 
 class AutoPatchRegister(type):
@@ -128,6 +128,7 @@ class APDeltaPatch(APContainer, metaclass=AutoPatchRegister):
         manifest = super(APDeltaPatch, self).get_manifest()
         manifest["base_checksum"] = self.hash
         manifest["result_file_ending"] = self.result_file_ending
+        manifest["patch_file_ending"] = self.patch_file_ending
         return manifest
 
     @classmethod

README.md

@@ -61,26 +61,10 @@ This project makes use of multiple other projects. We wouldn't be here without t
 * [Ocarina of Time Randomizer](https://github.com/TestRunnerSRL/OoT-Randomizer)
 
 ## Contributing
-Contributions are welcome. We have a few asks of any new contributors.
+For contribution guidelines, please see our [Contributing doc.](/docs/contributing.md)
-
-* Ensure that all changes which affect logic are covered by unit tests. 
-* Do not introduce any unit test failures/regressions.
-
-Otherwise, we tend to judge code on a case to case basis. It is a generally good idea to stick to PEP-8 guidelines to ensure consistency with existing code. (And to make the linter happy.)
-
-For adding a new game to Archipelago and other documentation on how Archipelago functions, please see [the docs folder](docs/) for the relevant information and feel free to ask any questions in the #archipelago-dev channel in our discord.
 
 ## FAQ
-For frequently asked questions see the website's [FAQ Page](https://archipelago.gg/faq/en/)
+For Frequently asked questions, please see the website's [FAQ Page.](https://archipelago.gg/faq/en/)
 
 ## Code of Conduct
-We conduct ourselves openly and inclusively here. Please do not contribute to an environment which makes other people uncomfortable. This means that we expect all contributors or participants here to:
+Please refer to our [code of conduct.](/docs/code_of_conduct.md)
-
-* Be welcoming and inclusive in tone and language.
-* Be respectful of others and their abilities.
-* Show empathy when speaking with others.
-* Be gracious and accept feedback and constructive criticism.
-
-These guidelines apply to all channels of communication within this GitHub repository. Please be respectful in both public channels, such as issues, and private, such as private messaging or emails.
-
-Any incidents of abuse may be reported directly to Ijwu at hmfarran@gmail.com.

SNIClient.py

@@ -15,9 +15,6 @@ import typing
 
 from json import loads, dumps
 
-import ModuleUpdate
-ModuleUpdate.update()
-
 from Utils import init_logging, messagebox
 
 if __name__ == "__main__":
@@ -149,8 +146,8 @@ class Context(CommonContext):
     def event_invalid_slot(self):
         if self.snes_socket is not None and not self.snes_socket.closed:
             asyncio.create_task(self.snes_socket.close())
-        raise Exception('Invalid ROM detected, '
+        raise Exception("Invalid ROM detected, "
-                        'please verify that you have loaded the correct rom and reconnect your snes (/snes)')
+                        "please verify that you have loaded the correct rom and reconnect your snes (/snes)")
 
     async def server_auth(self, password_requested: bool = False):
         if password_requested and not self.password:
@@ -158,7 +155,7 @@ class Context(CommonContext):
         if self.rom is None:
             self.awaiting_rom = True
             snes_logger.info(
-                'No ROM detected, awaiting snes connection to authenticate to the multiworld server (/snes)')
+                "No ROM detected, awaiting snes connection to authenticate to the multiworld server (/snes)")
             return
         self.awaiting_rom = False
         self.auth = self.rom
@@ -262,7 +259,7 @@ async def deathlink_kill_player(ctx: Context):
 
 SNES_RECONNECT_DELAY = 5
 
-# LttP
+# FXPAK Pro protocol memory mapping used by SNI
 ROM_START = 0x000000
 WRAM_START = 0xF50000
 WRAM_SIZE = 0x20000
@@ -293,21 +290,24 @@ SHOP_LEN = (len(Shops.shop_table) * 3) + 5
 DEATH_LINK_ACTIVE_ADDR = ROMNAME_START + 0x15       # 1 byte
 
 # SM
-SM_ROMNAME_START = 0x007FC0
+SM_ROMNAME_START = ROM_START + 0x007FC0
 
 SM_INGAME_MODES = {0x07, 0x09, 0x0b}
 SM_ENDGAME_MODES = {0x26, 0x27}
 SM_DEATH_MODES = {0x15, 0x17, 0x18, 0x19, 0x1A}
 
-SM_RECV_PROGRESS_ADDR = SRAM_START + 0x2000         # 2 bytes
+# RECV and SEND are from the gameplay's perspective: SNIClient writes to RECV queue and reads from SEND queue
-SM_RECV_ITEM_ADDR = SAVEDATA_START + 0x4D2          # 1 byte
+SM_RECV_QUEUE_START  = SRAM_START + 0x2000
-SM_RECV_ITEM_PLAYER_ADDR = SAVEDATA_START + 0x4D3   # 1 byte
+SM_RECV_QUEUE_WCOUNT = SRAM_START + 0x2602
+SM_SEND_QUEUE_START  = SRAM_START + 0x2700
+SM_SEND_QUEUE_RCOUNT = SRAM_START + 0x2680
+SM_SEND_QUEUE_WCOUNT = SRAM_START + 0x2682
 
 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_ROMNAME_START = ROM_START + 0x00FFC0
 
 SMZ3_INGAME_MODES = {0x07, 0x09, 0x0b}
 SMZ3_ENDGAME_MODES = {0x26, 0x27}
@@ -1083,6 +1083,9 @@ async def game_watcher(ctx: Context):
 
             if ctx.awaiting_rom:
                 await ctx.server_auth(False)
+            elif ctx.server is None:
+                snes_logger.warning("ROM detected but no active multiworld server connection. " +
+                                    "Connect using command: /connect server:port")
 
         if ctx.auth and ctx.auth != ctx.rom:
             snes_logger.warning("ROM change detected, please reconnect to the multiworld server")
@@ -1159,6 +1162,9 @@ async def game_watcher(ctx: Context):
                 await ctx.send_msgs([{"cmd": "LocationScouts", "locations": [scout_location]}])
             await track_locations(ctx, roomid, roomdata)
         elif ctx.game == GAME_SM:
+            if ctx.server is None or ctx.slot is None:
+                # not successfully connected to a multiworld server, cannot process the game sending items
+                continue
             gamemode = await snes_read(ctx, WRAM_START + 0x0998, 1)
             if "DeathLink" in ctx.tags and gamemode and ctx.last_death_link + 1 < time.time():
                 currently_dead = gamemode[0] in SM_DEATH_MODES
@@ -1169,25 +1175,25 @@ async def game_watcher(ctx: Context):
                     ctx.finished_game = True
                 continue
 
-            data = await snes_read(ctx, SM_RECV_PROGRESS_ADDR + 0x680, 4)
+            data = await snes_read(ctx, SM_SEND_QUEUE_RCOUNT, 4)
             if data is None:
                 continue
 
             recv_index = data[0] | (data[1] << 8)
-            recv_item = data[2] | (data[3] << 8)
+            recv_item = data[2] | (data[3] << 8) # this is actually SM_SEND_QUEUE_WCOUNT
 
             while (recv_index < recv_item):
                 itemAdress = recv_index * 8
-                message = await snes_read(ctx, SM_RECV_PROGRESS_ADDR + 0x700 + itemAdress, 8)
+                message = await snes_read(ctx, SM_SEND_QUEUE_START + itemAdress, 8)
                 # worldId = message[0] | (message[1] << 8)  # unused
                 # itemId = message[2] | (message[3] << 8)  # unused
                 itemIndex = (message[4] | (message[5] << 8)) >> 3
 
                 recv_index += 1
-                snes_buffered_write(ctx, SM_RECV_PROGRESS_ADDR + 0x680,
+                snes_buffered_write(ctx, SM_SEND_QUEUE_RCOUNT,
                                     bytes([recv_index & 0xFF, (recv_index >> 8) & 0xFF]))
 
-                from worlds.sm.Locations import locations_start_id
+                from worlds.sm import locations_start_id
                 location_id = locations_start_id + itemIndex
 
                 ctx.locations_checked.add(location_id)
@@ -1196,15 +1202,14 @@ async def game_watcher(ctx: Context):
                     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)
+            data = await snes_read(ctx, SM_RECV_QUEUE_WCOUNT, 2)
             if data is None:
                 continue
 
-            # recv_itemOutPtr = data[0] | (data[1] << 8) # unused
+            itemOutPtr = data[0] | (data[1] << 8)
-            itemOutPtr = data[2] | (data[3] << 8)
 
-            from worlds.sm.Items import items_start_id
+            from worlds.sm import items_start_id
-            from worlds.sm.Locations import locations_start_id
+            from worlds.sm import locations_start_id
             if itemOutPtr < len(ctx.items_received):
                 item = ctx.items_received[itemOutPtr]
                 itemId = item.item - items_start_id
@@ -1214,10 +1219,10 @@ async def game_watcher(ctx: Context):
                     locationId = 0x00 #backward compat
 
                 playerID = item.player if item.player <= SM_ROM_PLAYER_LIMIT else 0
-                snes_buffered_write(ctx, SM_RECV_PROGRESS_ADDR + itemOutPtr * 4, bytes(
+                snes_buffered_write(ctx, SM_RECV_QUEUE_START + itemOutPtr * 4, bytes(
                 	[playerID & 0xFF, (playerID >> 8) & 0xFF, itemId & 0xFF, locationId & 0xFF]))
                 itemOutPtr += 1
-                snes_buffered_write(ctx, SM_RECV_PROGRESS_ADDR + 0x602,
+                snes_buffered_write(ctx, SM_RECV_QUEUE_WCOUNT,
                                     bytes([itemOutPtr & 0xFF, (itemOutPtr >> 8) & 0xFF]))
                 logging.info('Received %s from %s (%s) (%d/%d in list)' % (
                     color(ctx.item_names[item.item], 'red', 'bold'),
@@ -1225,6 +1230,9 @@ async def game_watcher(ctx: Context):
                     ctx.location_names[item.location], itemOutPtr, len(ctx.items_received)))
             await snes_flush_writes(ctx)
         elif ctx.game == GAME_SMZ3:
+            if ctx.server is None or ctx.slot is None:
+                # not successfully connected to a multiworld server, cannot process the game sending items
+                continue
             currentGame = await snes_read(ctx, SRAM_START + 0x33FE, 2)
             if (currentGame is not None):
                 if (currentGame[0] != 0):
@@ -1260,7 +1268,8 @@ async def game_watcher(ctx: Context):
                 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
+                from worlds.smz3 import convertLocSMZ3IDToAPID
+                location_id = locations_start_id + convertLocSMZ3IDToAPID(itemIndex)
 
                 ctx.locations_checked.add(location_id)
                 location = ctx.location_names[location_id]

Starcraft2Client.py

@@ -1,31 +1,32 @@
 from __future__ import annotations
 
-import multiprocessing
-import logging
 import asyncio
+import copy
+import ctypes
+import logging
+import multiprocessing
 import os.path
+import re
+import sys
+import typing
+import queue
+from pathlib import Path
 
 import nest_asyncio
 import sc2
-
-from sc2.main import run_game
-from sc2.data import Race
 from sc2.bot_ai import BotAI
+from sc2.data import Race
+from sc2.main import run_game
 from sc2.player import Bot
 
-from worlds.sc2wol.Regions import MissionInfo
+import NetUtils
-from worlds.sc2wol.MissionTables import lookup_id_to_mission
-from worlds.sc2wol.Items import lookup_id_to_name, item_table
-from worlds.sc2wol.Locations import SC2WOL_LOC_ID_OFFSET
-from worlds.sc2wol import SC2WoLWorld
-
-from pathlib import Path
-import re
 from MultiServer import mark_raw
-import ctypes
-import sys
-
 from Utils import init_logging, is_windows
+from worlds.sc2wol import SC2WoLWorld
+from worlds.sc2wol.Items import lookup_id_to_name, item_table, ItemData, type_flaggroups
+from worlds.sc2wol.Locations import SC2WOL_LOC_ID_OFFSET
+from worlds.sc2wol.MissionTables import lookup_id_to_mission
+from worlds.sc2wol.Regions import MissionInfo
 
 if __name__ == "__main__":
     init_logging("SC2Client", exception_logger="Client")
@@ -35,20 +36,49 @@ sc2_logger = logging.getLogger("Starcraft2")
 
 import colorama
 
-from NetUtils import *
+from NetUtils import ClientStatus, RawJSONtoTextParser
 from CommonClient import CommonContext, server_loop, ClientCommandProcessor, gui_enabled, get_base_parser
 
 nest_asyncio.apply()
+max_bonus: int = 8
+victory_modulo: int = 100
 
 
 class StarcraftClientProcessor(ClientCommandProcessor):
     ctx: SC2Context
 
+    def _cmd_difficulty(self, difficulty: str = "") -> bool:
+        """Overrides the current difficulty set for the seed.  Takes the argument casual, normal, hard, or brutal"""
+        options = difficulty.split()
+        num_options = len(options)
+        difficulty_choice = options[0].lower()
+
+        if num_options > 0:
+            if difficulty_choice == "casual":
+                self.ctx.difficulty_override = 0
+            elif difficulty_choice == "normal":
+                self.ctx.difficulty_override = 1
+            elif difficulty_choice == "hard":
+                self.ctx.difficulty_override = 2
+            elif difficulty_choice == "brutal":
+                self.ctx.difficulty_override = 3
+            else:
+                self.output("Unable to parse difficulty '" + options[0] + "'")
+                return False
+
+            self.output("Difficulty set to " + options[0])
+            return True
+
+        else:
+            self.output("Difficulty needs to be specified in the command.")
+            return False
+
     def _cmd_disable_mission_check(self) -> bool:
         """Disables the check to see if a mission is available to play.  Meant for co-op runs where one player can play
         the next mission in a chain the other player is doing."""
         self.ctx.missions_unlocked = True
         sc2_logger.info("Mission check has been disabled")
+        return True
 
     def _cmd_play(self, mission_id: str = "") -> bool:
         """Start a Starcraft 2 mission"""
@@ -64,19 +94,20 @@ class StarcraftClientProcessor(ClientCommandProcessor):
         else:
             sc2_logger.info(
                 "Mission ID needs to be specified.  Use /unfinished or /available to view ids for available missions.")
+            return False
 
         return True
 
     def _cmd_available(self) -> bool:
         """Get what missions are currently available to play"""
 
-        request_available_missions(self.ctx.checked_locations, self.ctx.mission_req_table, self.ctx.ui)
+        request_available_missions(self.ctx)
         return True
 
     def _cmd_unfinished(self) -> bool:
         """Get what missions are currently available to play and have not had all locations checked"""
 
-        request_unfinished_missions(self.ctx.checked_locations, self.ctx.mission_req_table, self.ctx.ui, self.ctx)
+        request_unfinished_missions(self.ctx)
         return True
 
     @mark_raw
@@ -97,17 +128,19 @@ class SC2Context(CommonContext):
     items_handling = 0b111
     difficulty = -1
     all_in_choice = 0
-    mission_req_table = None
+    mission_req_table: typing.Dict[str, MissionInfo] = {}
-    items_rec_to_announce = []
+    announcements = queue.Queue()
-    rec_announce_pos = 0
-    items_sent_to_announce = []
-    sent_announce_pos = 0
-    announcements = []
-    announcement_pos = 0
     sc2_run_task: typing.Optional[asyncio.Task] = None
-    missions_unlocked = False
+    missions_unlocked: bool = False  # allow launching missions ignoring requirements
     current_tooltip = None
     last_loc_list = None
+    difficulty_override = -1
+    mission_id_to_location_ids: typing.Dict[int, typing.List[int]] = {}
+    last_bot: typing.Optional[ArchipelagoBot] = None
+
+    def __init__(self, *args, **kwargs):
+        super(SC2Context, self).__init__(*args, **kwargs)
+        self.raw_text_parser = RawJSONtoTextParser(self)
 
     async def server_auth(self, password_requested: bool = False):
         if password_requested and not self.password:
@@ -120,30 +153,35 @@ class SC2Context(CommonContext):
             self.difficulty = args["slot_data"]["game_difficulty"]
             self.all_in_choice = args["slot_data"]["all_in_map"]
             slot_req_table = args["slot_data"]["mission_req"]
-            self.mission_req_table = {}
+            self.mission_req_table = {
-            # Compatibility for 0.3.2 server data.
+                mission: MissionInfo(**slot_req_table[mission]) for mission in slot_req_table
-            if "category" not in next(iter(slot_req_table)):
+            }
-                for i, mission_data in enumerate(slot_req_table.values()):
+
-                    mission_data["category"] = wol_default_categories[i]
+            self.build_location_to_mission_mapping()
-            for mission in slot_req_table:
-                self.mission_req_table[mission] = MissionInfo(**slot_req_table[mission])
 
             # Look for and set SC2PATH.
             # check_game_install_path() returns True if and only if it finds + sets SC2PATH.
             if "SC2PATH" not in os.environ and check_game_install_path():
                 check_mod_install()
 
-        if cmd in {"PrintJSON"}:
+    def on_print_json(self, args: dict):
-            if "receiving" in args:
+        # goes to this world
-                if self.slot_concerns_self(args["receiving"]):
+        if "receiving" in args and self.slot_concerns_self(args["receiving"]):
-                    self.announcements.append(args["data"])
+            relevant = True
-                    return
+        # found in this world
-            if "item" in args:
+        elif "item" in args and self.slot_concerns_self(args["item"].player):
-                if self.slot_concerns_self(args["item"].player):
+            relevant = True
-                    self.announcements.append(args["data"])
+        # not related
+        else:
+            relevant = False
+
+        if relevant:
+            self.announcements.put(self.raw_text_parser(copy.deepcopy(args["data"])))
+
+        super(SC2Context, self).on_print_json(args)
 
     def run_gui(self):
-        from kvui import GameManager, HoverBehavior, ServerToolTip, fade_in_animation
+        from kvui import GameManager, HoverBehavior, ServerToolTip
         from kivy.app import App
         from kivy.clock import Clock
         from kivy.uix.tabbedpanel import TabbedPanelItem
@@ -161,6 +199,7 @@ class SC2Context(CommonContext):
 
         class MissionButton(HoverableButton):
             tooltip_text = StringProperty("Test")
+            ctx: SC2Context
 
             def __init__(self, *args, **kwargs):
                 super(HoverableButton, self).__init__(*args, **kwargs)
@@ -181,10 +220,7 @@ class SC2Context(CommonContext):
                     self.ctx.current_tooltip = self.layout
 
             def on_leave(self):
-                if self.ctx.current_tooltip:
+                self.ctx.ui.clear_tooltip()
-                    App.get_running_app().root.remove_widget(self.ctx.current_tooltip)
-
-                self.ctx.current_tooltip = None
 
             @property
             def ctx(self) -> CommonContext:
@@ -206,13 +242,20 @@ class SC2Context(CommonContext):
             mission_panel = None
             last_checked_locations = {}
             mission_id_to_button = {}
-            launching = False
+            launching: typing.Union[bool, int] = False  # if int -> mission ID
             refresh_from_launching = True
             first_check = True
+            ctx: SC2Context
 
             def __init__(self, ctx):
                 super().__init__(ctx)
 
+            def clear_tooltip(self):
+                if self.ctx.current_tooltip:
+                    App.get_running_app().root.remove_widget(self.ctx.current_tooltip)
+
+                self.ctx.current_tooltip = None
+
             def build(self):
                 container = super().build()
 
@@ -227,7 +270,7 @@ class SC2Context(CommonContext):
 
             def build_mission_table(self, dt):
                 if (not self.launching and (not self.last_checked_locations == self.ctx.checked_locations or
-                                           not self.refresh_from_launching)) or self.first_check:
+                                            not self.refresh_from_launching)) or self.first_check:
                     self.refresh_from_launching = True
 
                     self.mission_panel.clear_widgets()
@@ -238,12 +281,7 @@ class SC2Context(CommonContext):
 
                         self.mission_id_to_button = {}
                         categories = {}
-                        available_missions = []
+                        available_missions, unfinished_missions = calc_unfinished_missions(self.ctx)
-                        unfinished_locations = initialize_blank_mission_dict(self.ctx.mission_req_table)
-                        unfinished_missions = calc_unfinished_missions(self.ctx.checked_locations,
-                                                                       self.ctx.mission_req_table,
-                                                                       self.ctx, available_missions=available_missions,
-                                                                       unfinished_locations=unfinished_locations)
 
                         # separate missions into categories
                         for mission in self.ctx.mission_req_table:
@@ -254,34 +292,40 @@ class SC2Context(CommonContext):
 
                         for category in categories:
                             category_panel = MissionCategory()
-                            category_panel.add_widget(Label(text=category, size_hint_y=None, height=50, outline_width=1))
+                            category_panel.add_widget(
+                                Label(text=category, size_hint_y=None, height=50, outline_width=1))
 
-                            # Map is completed
                             for mission in categories[category]:
-                                text = mission
+                                text: str = mission
-                                tooltip = ""
+                                tooltip: str = ""
 
                                 # Map has uncollected locations
                                 if mission in unfinished_missions:
                                     text = f"[color=6495ED]{text}[/color]"
 
-                                    tooltip = f"Uncollected locations:\n"
-                                    tooltip += "\n".join(location for location in unfinished_locations[mission])
                                 elif mission in available_missions:
                                     text = f"[color=FFFFFF]{text}[/color]"
                                 # Map requirements not met
                                 else:
                                     text = f"[color=a9a9a9]{text}[/color]"
                                     tooltip = f"Requires: "
-                                    if len(self.ctx.mission_req_table[mission].required_world) > 0:
+                                    if self.ctx.mission_req_table[mission].required_world:
-                                        tooltip += ", ".join(list(self.ctx.mission_req_table)[req_mission-1] for
+                                        tooltip += ", ".join(list(self.ctx.mission_req_table)[req_mission - 1] for
                                                              req_mission in
                                                              self.ctx.mission_req_table[mission].required_world)
 
-                                        if self.ctx.mission_req_table[mission].number > 0:
+                                        if self.ctx.mission_req_table[mission].number:
                                             tooltip += " and "
-                                    if self.ctx.mission_req_table[mission].number > 0:
+                                    if self.ctx.mission_req_table[mission].number:
                                         tooltip += f"{self.ctx.mission_req_table[mission].number} missions completed"
+                                remaining_location_names: typing.List[str] = [
+                                    self.ctx.location_names[loc] for loc in self.ctx.locations_for_mission(mission)
+                                    if loc in self.ctx.missing_locations]
+                                if remaining_location_names:
+                                    if tooltip:
+                                        tooltip += "\n"
+                                    tooltip += f"Uncollected locations:\n"
+                                    tooltip += "\n".join(remaining_location_names)
 
                                 mission_button = MissionButton(text=text, size_hint_y=None, height=50)
                                 mission_button.tooltip_text = tooltip
@@ -296,13 +340,16 @@ class SC2Context(CommonContext):
                     self.refresh_from_launching = False
 
                     self.mission_panel.clear_widgets()
-                    self.mission_panel.add_widget(Label(text="Launching Mission"))
+                    self.mission_panel.add_widget(Label(text="Launching Mission: " +
+                                                             lookup_id_to_mission[self.launching]))
+                    if self.ctx.ui:
+                        self.ctx.ui.clear_tooltip()
 
             def mission_callback(self, button):
                 if not self.launching:
-                    self.ctx.play_mission(list(self.mission_id_to_button.keys())
+                    mission_id: int = next(k for k, v in self.mission_id_to_button.items() if v == button)
-                                          [list(self.mission_id_to_button.values()).index(button)])
+                    self.ctx.play_mission(mission_id)
-                    self.launching = True
+                    self.launching = mission_id
                     Clock.schedule_once(self.finish_launching, 10)
 
             def finish_launching(self, dt):
@@ -315,12 +362,14 @@ class SC2Context(CommonContext):
 
     async def shutdown(self):
         await super(SC2Context, self).shutdown()
+        if self.last_bot:
+            self.last_bot.want_close = True
         if self.sc2_run_task:
             self.sc2_run_task.cancel()
 
-    def play_mission(self, mission_id):
+    def play_mission(self, mission_id: int):
         if self.missions_unlocked or \
-                is_mission_available(mission_id, self.checked_locations, self.mission_req_table):
+                is_mission_available(self, mission_id):
             if self.sc2_run_task:
                 if not self.sc2_run_task.done():
                     sc2_logger.warning("Starcraft 2 Client is still running!")
@@ -329,12 +378,29 @@ class SC2Context(CommonContext):
                 sc2_logger.warning("Launching Mission without Archipelago authentication, "
                                    "checks will not be registered to server.")
             self.sc2_run_task = asyncio.create_task(starcraft_launch(self, mission_id),
-                                                        name="Starcraft 2 Launch")
+                                                    name="Starcraft 2 Launch")
         else:
             sc2_logger.info(
                 f"{lookup_id_to_mission[mission_id]} is not currently unlocked.  "
                 f"Use /unfinished or /available to see what is available.")
 
+    def build_location_to_mission_mapping(self):
+        mission_id_to_location_ids: typing.Dict[int, typing.Set[int]] = {
+            mission_info.id: set() for mission_info in self.mission_req_table.values()
+        }
+
+        for loc in self.server_locations:
+            mission_id, objective = divmod(loc - SC2WOL_LOC_ID_OFFSET, victory_modulo)
+            mission_id_to_location_ids[mission_id].add(objective)
+        self.mission_id_to_location_ids = {mission_id: sorted(objectives) for mission_id, objectives in
+                                           mission_id_to_location_ids.items()}
+
+    def locations_for_mission(self, mission: str):
+        mission_id: int = self.mission_req_table[mission].id
+        objectives = self.mission_id_to_location_ids[self.mission_req_table[mission].id]
+        for objective in objectives:
+            yield SC2WOL_LOC_ID_OFFSET + mission_id * 100 + objective
+
 
 async def main():
     multiprocessing.freeze_support()
@@ -374,47 +440,27 @@ wol_default_categories = [
 ]
 
 
-def calculate_items(items):
+def calculate_items(items: typing.List[NetUtils.NetworkItem]) -> typing.List[int]:
-    unit_unlocks = 0
+    network_item: NetUtils.NetworkItem
-    armory1_unlocks = 0
+    accumulators: typing.List[int] = [0 for _ in type_flaggroups]
-    armory2_unlocks = 0
-    upgrade_unlocks = 0
-    building_unlocks = 0
-    merc_unlocks = 0
-    lab_unlocks = 0
-    protoss_unlock = 0
-    minerals = 0
-    vespene = 0
-    supply = 0
 
-    for item in items:
+    for network_item in items:
-        data = lookup_id_to_name[item.item]
+        name: str = lookup_id_to_name[network_item.item]
+        item_data: ItemData = item_table[name]
 
-        if item_table[data].type == "Unit":
+        # exists exactly once
-            unit_unlocks += (1 << item_table[data].number)
+        if item_data.quantity == 1:
-        elif item_table[data].type == "Upgrade":
+            accumulators[type_flaggroups[item_data.type]] |= 1 << item_data.number
-            upgrade_unlocks += (1 << item_table[data].number)
-        elif item_table[data].type == "Armory 1":
-            armory1_unlocks += (1 << item_table[data].number)
-        elif item_table[data].type == "Armory 2":
-            armory2_unlocks += (1 << item_table[data].number)
-        elif item_table[data].type == "Building":
-            building_unlocks += (1 << item_table[data].number)
-        elif item_table[data].type == "Mercenary":
-            merc_unlocks += (1 << item_table[data].number)
-        elif item_table[data].type == "Laboratory":
-            lab_unlocks += (1 << item_table[data].number)
-        elif item_table[data].type == "Protoss":
-            protoss_unlock += (1 << item_table[data].number)
-        elif item_table[data].type == "Minerals":
-            minerals += item_table[data].number
-        elif item_table[data].type == "Vespene":
-            vespene += item_table[data].number
-        elif item_table[data].type == "Supply":
-            supply += item_table[data].number
 
-    return [unit_unlocks, upgrade_unlocks, armory1_unlocks, armory2_unlocks, building_unlocks, merc_unlocks,
+        # exists multiple times
-            lab_unlocks, protoss_unlock, minerals, vespene, supply]
+        elif item_data.type == "Upgrade":
+            accumulators[type_flaggroups[item_data.type]] += 1 << item_data.number
+
+        # sum
+        else:
+            accumulators[type_flaggroups[item_data.type]] += item_data.number
+
+    return accumulators
 
 
 def calc_difficulty(difficulty):
@@ -430,11 +476,7 @@ def calc_difficulty(difficulty):
     return 'X'
 
 
-async def starcraft_launch(ctx: SC2Context, mission_id):
+async def starcraft_launch(ctx: SC2Context, mission_id: int):
-    ctx.rec_announce_pos = len(ctx.items_rec_to_announce)
-    ctx.sent_announce_pos = len(ctx.items_sent_to_announce)
-    ctx.announcements_pos = len(ctx.announcements)
-
     sc2_logger.info(f"Launching {lookup_id_to_mission[mission_id]}. If game does not launch check log file for errors.")
 
     with DllDirectory(None):
@@ -443,34 +485,39 @@ async def starcraft_launch(ctx: SC2Context, mission_id):
 
 
 class ArchipelagoBot(sc2.bot_ai.BotAI):
-    game_running = False
+    game_running: bool = False
-    mission_completed = False
+    mission_completed: bool = False
-    first_bonus = False
+    boni: typing.List[bool]
-    second_bonus = False
+    setup_done: bool
-    third_bonus = False
+    ctx: SC2Context
-    fourth_bonus = False
+    mission_id: int
-    fifth_bonus = False
+    want_close: bool = False
-    sixth_bonus = False
-    seventh_bonus = False
-    eight_bonus = False
-    ctx: SC2Context = None
-    mission_id = 0
-
     can_read_game = False
 
-    last_received_update = 0
+    last_received_update: int = 0
 
     def __init__(self, ctx: SC2Context, mission_id):
+        self.setup_done = False
         self.ctx = ctx
+        self.ctx.last_bot = self
         self.mission_id = mission_id
+        self.boni = [False for _ in range(max_bonus)]
 
         super(ArchipelagoBot, self).__init__()
 
     async def on_step(self, iteration: int):
+        if self.want_close:
+            self.want_close = False
+            await self._client.leave()
+            return
         game_state = 0
-        if iteration == 0:
+        if not self.setup_done:
+            self.setup_done = True
             start_items = calculate_items(self.ctx.items_received)
-            difficulty = calc_difficulty(self.ctx.difficulty)
+            if self.ctx.difficulty_override >= 0:
+                difficulty = calc_difficulty(self.ctx.difficulty_override)
+            else:
+                difficulty = calc_difficulty(self.ctx.difficulty)
             await self.chat_send("ArchipelagoLoad {} {} {} {} {} {} {} {} {} {} {} {} {}".format(
                 difficulty,
                 start_items[0], start_items[1], start_items[2], start_items[3], start_items[4],
@@ -479,36 +526,10 @@ class ArchipelagoBot(sc2.bot_ai.BotAI):
             self.last_received_update = len(self.ctx.items_received)
 
         else:
-            if self.ctx.announcement_pos < len(self.ctx.announcements):
+            if not self.ctx.announcements.empty():
-                index = 0
+                message = self.ctx.announcements.get(timeout=1)
-                message = ""
-                while index < len(self.ctx.announcements[self.ctx.announcement_pos]):
-                    message += self.ctx.announcements[self.ctx.announcement_pos][index]["text"]
-                    index += 1
-
-                index = 0
-                start_rem_pos = -1
-                # Remove unneeded [Color] tags
-                while index < len(message):
-                    if message[index] == '[':
-                        start_rem_pos = index
-                        index += 1
-                    elif message[index] == ']' and start_rem_pos > -1:
-                        temp_msg = ""
-
-                        if start_rem_pos > 0:
-                            temp_msg = message[:start_rem_pos]
-                        if index < len(message) - 1:
-                            temp_msg += message[index + 1:]
-
-                        message = temp_msg
-                        index += start_rem_pos - index
-                        start_rem_pos = -1
-                    else:
-                        index += 1
-
                 await self.chat_send("SendMessage " + message)
-                self.ctx.announcement_pos += 1
+                self.ctx.announcements.task_done()
 
             # Archipelago reads the health
             for unit in self.all_own_units():
@@ -536,169 +557,97 @@ class ArchipelagoBot(sc2.bot_ai.BotAI):
                     if game_state & (1 << 1) and not self.mission_completed:
                         if self.mission_id != 29:
                             print("Mission Completed")
-                            await self.ctx.send_msgs([
+                            await self.ctx.send_msgs(
-                                {"cmd": 'LocationChecks', "locations": [SC2WOL_LOC_ID_OFFSET + 100 * self.mission_id]}])
+                                [{"cmd": 'LocationChecks',
+                                  "locations": [SC2WOL_LOC_ID_OFFSET + victory_modulo * self.mission_id]}])
                             self.mission_completed = True
                         else:
                             print("Game Complete")
                             await self.ctx.send_msgs([{"cmd": 'StatusUpdate', "status": ClientStatus.CLIENT_GOAL}])
                             self.mission_completed = True
 
-                    if game_state & (1 << 2) and not self.first_bonus:
+                    for x, completed in enumerate(self.boni):
-                        print("1st Bonus Collected")
+                        if not completed and game_state & (1 << (x + 2)):
-                        await self.ctx.send_msgs(
+                            await self.ctx.send_msgs(
-                            [{"cmd": 'LocationChecks',
+                                [{"cmd": 'LocationChecks',
-                              "locations": [SC2WOL_LOC_ID_OFFSET + 100 * self.mission_id + 1]}])
+                                  "locations": [SC2WOL_LOC_ID_OFFSET + victory_modulo * self.mission_id + x + 1]}])
-                        self.first_bonus = True
+                            self.boni[x] = True
-
-                    if not self.second_bonus and game_state & (1 << 3):
-                        print("2nd Bonus Collected")
-                        await self.ctx.send_msgs(
-                            [{"cmd": 'LocationChecks',
-                              "locations": [SC2WOL_LOC_ID_OFFSET + 100 * self.mission_id + 2]}])
-                        self.second_bonus = True
-
-                    if not self.third_bonus and game_state & (1 << 4):
-                        print("3rd Bonus Collected")
-                        await self.ctx.send_msgs(
-                            [{"cmd": 'LocationChecks',
-                              "locations": [SC2WOL_LOC_ID_OFFSET + 100 * self.mission_id + 3]}])
-                        self.third_bonus = True
-
-                    if not self.fourth_bonus and game_state & (1 << 5):
-                        print("4th Bonus Collected")
-                        await self.ctx.send_msgs(
-                            [{"cmd": 'LocationChecks',
-                              "locations": [SC2WOL_LOC_ID_OFFSET + 100 * self.mission_id + 4]}])
-                        self.fourth_bonus = True
-
-                    if not self.fifth_bonus and game_state & (1 << 6):
-                        print("5th Bonus Collected")
-                        await self.ctx.send_msgs(
-                            [{"cmd": 'LocationChecks',
-                              "locations": [SC2WOL_LOC_ID_OFFSET + 100 * self.mission_id + 5]}])
-                        self.fifth_bonus = True
-
-                    if not self.sixth_bonus and game_state & (1 << 7):
-                        print("6th Bonus Collected")
-                        await self.ctx.send_msgs(
-                            [{"cmd": 'LocationChecks',
-                              "locations": [SC2WOL_LOC_ID_OFFSET + 100 * self.mission_id + 6]}])
-                        self.sixth_bonus = True
-
-                    if not self.seventh_bonus and game_state & (1 << 8):
-                        print("6th Bonus Collected")
-                        await self.ctx.send_msgs(
-                            [{"cmd": 'LocationChecks',
-                              "locations": [SC2WOL_LOC_ID_OFFSET + 100 * self.mission_id + 7]}])
-                        self.seventh_bonus = True
-
-                    if not self.eight_bonus and game_state & (1 << 9):
-                        print("6th Bonus Collected")
-                        await self.ctx.send_msgs(
-                            [{"cmd": 'LocationChecks',
-                              "locations": [SC2WOL_LOC_ID_OFFSET + 100 * self.mission_id + 8]}])
-                        self.eight_bonus = True
 
                 else:
                     await self.chat_send("LostConnection - Lost connection to game.")
 
 
-def calc_objectives_completed(mission, missions_info, locations_done, unfinished_locations, ctx):
+def request_unfinished_missions(ctx: SC2Context):
-    objectives_complete = 0
+    if ctx.mission_req_table:
-
-    if missions_info[mission].extra_locations > 0:
-        for i in range(missions_info[mission].extra_locations):
-            if (missions_info[mission].id * 100 + SC2WOL_LOC_ID_OFFSET + i) in locations_done:
-                objectives_complete += 1
-            else:
-                unfinished_locations[mission].append(ctx.location_names[
-                    missions_info[mission].id * 100 + SC2WOL_LOC_ID_OFFSET + i])
-
-        return objectives_complete
-
-    else:
-        return -1
-
-
-def request_unfinished_missions(locations_done, location_table, ui, ctx):
-    if location_table:
         message = "Unfinished Missions: "
-        unlocks = initialize_blank_mission_dict(location_table)
+        unlocks = initialize_blank_mission_dict(ctx.mission_req_table)
-        unfinished_locations = initialize_blank_mission_dict(location_table)
+        unfinished_locations = initialize_blank_mission_dict(ctx.mission_req_table)
 
-        unfinished_missions = calc_unfinished_missions(locations_done, location_table, ctx, unlocks=unlocks,
+        _, unfinished_missions = calc_unfinished_missions(ctx, unlocks=unlocks)
-                                                       unfinished_locations=unfinished_locations)
 
-        message += ", ".join(f"{mark_up_mission_name(mission, location_table, ui,unlocks)}[{location_table[mission].id}] " +
+        message += ", ".join(f"{mark_up_mission_name(ctx, mission, unlocks)}[{ctx.mission_req_table[mission].id}] " +
                              mark_up_objectives(
-                                 f"[{unfinished_missions[mission]}/{location_table[mission].extra_locations}]",
+                                 f"[{len(unfinished_missions[mission])}/"
+                                 f"{sum(1 for _ in ctx.locations_for_mission(mission))}]",
                                  ctx, unfinished_locations, mission)
                              for mission in unfinished_missions)
 
-        if ui:
+        if ctx.ui:
-            ui.log_panels['All'].on_message_markup(message)
+            ctx.ui.log_panels['All'].on_message_markup(message)
-            ui.log_panels['Starcraft2'].on_message_markup(message)
+            ctx.ui.log_panels['Starcraft2'].on_message_markup(message)
         else:
             sc2_logger.info(message)
     else:
         sc2_logger.warning("No mission table found, you are likely not connected to a server.")
 
 
-def calc_unfinished_missions(locations_done, locations, ctx, unlocks=None, unfinished_locations=None,
+def calc_unfinished_missions(ctx: SC2Context, unlocks=None):
-                             available_missions=[]):
     unfinished_missions = []
     locations_completed = []
 
     if not unlocks:
-        unlocks = initialize_blank_mission_dict(locations)
+        unlocks = initialize_blank_mission_dict(ctx.mission_req_table)
 
-    if not unfinished_locations:
+    available_missions = calc_available_missions(ctx, unlocks)
-        unfinished_locations = initialize_blank_mission_dict(locations)
-
-    if len(available_missions) > 0:
-        available_missions = []
-
-    available_missions.extend(calc_available_missions(locations_done, locations, unlocks))
 
     for name in available_missions:
-        if not locations[name].extra_locations == -1:
+        objectives = set(ctx.locations_for_mission(name))
-            objectives_completed = calc_objectives_completed(name, locations, locations_done, unfinished_locations, ctx)
+        if objectives:
-
+            objectives_completed = ctx.checked_locations & objectives
-            if objectives_completed < locations[name].extra_locations:
+            if len(objectives_completed) < len(objectives):
                 unfinished_missions.append(name)
                 locations_completed.append(objectives_completed)
 
-        else:
+        else:  # infer that this is the final mission as it has no objectives
             unfinished_missions.append(name)
             locations_completed.append(-1)
 
-    return {unfinished_missions[i]: locations_completed[i] for i in range(len(unfinished_missions))}
+    return available_missions, dict(zip(unfinished_missions, locations_completed))
 
 
-def is_mission_available(mission_id_to_check, locations_done, locations):
+def is_mission_available(ctx: SC2Context, mission_id_to_check):
-    unfinished_missions = calc_available_missions(locations_done, locations)
+    unfinished_missions = calc_available_missions(ctx)
 
-    return any(mission_id_to_check == locations[mission].id for mission in unfinished_missions)
+    return any(mission_id_to_check == ctx.mission_req_table[mission].id for mission in unfinished_missions)
 
 
-def mark_up_mission_name(mission, location_table, ui, unlock_table):
+def mark_up_mission_name(ctx: SC2Context, mission, unlock_table):
     """Checks if the mission is required for game completion and adds '*' to the name to mark that."""
 
-    if location_table[mission].completion_critical:
+    if ctx.mission_req_table[mission].completion_critical:
-        if ui:
+        if ctx.ui:
             message = "[color=AF99EF]" + mission + "[/color]"
         else:
             message = "*" + mission + "*"
     else:
         message = mission
 
-    if ui:
+    if ctx.ui:
         unlocks = unlock_table[mission]
 
         if len(unlocks) > 0:
-            pre_message = f"[ref={list(location_table).index(mission)}|Unlocks: "
+            pre_message = f"[ref={list(ctx.mission_req_table).index(mission)}|Unlocks: "
-            pre_message += ", ".join(f"{unlock}({location_table[unlock].id})" for unlock in unlocks)
+            pre_message += ", ".join(f"{unlock}({ctx.mission_req_table[unlock].id})" for unlock in unlocks)
             pre_message += f"]"
             message = pre_message + message + "[/ref]"
 
@@ -711,7 +660,7 @@ def mark_up_objectives(message, ctx, unfinished_locations, mission):
     if ctx.ui:
         locations = unfinished_locations[mission]
 
-        pre_message = f"[ref={list(ctx.mission_req_table).index(mission)+30}|"
+        pre_message = f"[ref={list(ctx.mission_req_table).index(mission) + 30}|"
         pre_message += "<br>".join(location for location in locations)
         pre_message += f"]"
         formatted_message = pre_message + message + "[/ref]"
@@ -719,90 +668,91 @@ def mark_up_objectives(message, ctx, unfinished_locations, mission):
     return formatted_message
 
 
-def request_available_missions(locations_done, location_table, ui):
+def request_available_missions(ctx: SC2Context):
-    if location_table:
+    if ctx.mission_req_table:
         message = "Available Missions: "
 
         # Initialize mission unlock table
-        unlocks = initialize_blank_mission_dict(location_table)
+        unlocks = initialize_blank_mission_dict(ctx.mission_req_table)
 
-        missions = calc_available_missions(locations_done, location_table, unlocks)
+        missions = calc_available_missions(ctx, unlocks)
         message += \
-            ", ".join(f"{mark_up_mission_name(mission, location_table, ui, unlocks)}[{location_table[mission].id}]"
+            ", ".join(f"{mark_up_mission_name(ctx, mission, unlocks)}"
+                      f"[{ctx.mission_req_table[mission].id}]"
                       for mission in missions)
 
-        if ui:
+        if ctx.ui:
-            ui.log_panels['All'].on_message_markup(message)
+            ctx.ui.log_panels['All'].on_message_markup(message)
-            ui.log_panels['Starcraft2'].on_message_markup(message)
+            ctx.ui.log_panels['Starcraft2'].on_message_markup(message)
         else:
             sc2_logger.info(message)
     else:
         sc2_logger.warning("No mission table found, you are likely not connected to a server.")
 
 
-def calc_available_missions(locations_done, locations, unlocks=None):
+def calc_available_missions(ctx: SC2Context, unlocks=None):
     available_missions = []
     missions_complete = 0
 
     # Get number of missions completed
-    for loc in locations_done:
+    for loc in ctx.checked_locations:
-        if loc % 100 == 0:
+        if loc % victory_modulo == 0:
             missions_complete += 1
 
-    for name in locations:
+    for name in ctx.mission_req_table:
         # Go through the required missions for each mission and fill up unlock table used later for hover-over tooltips
         if unlocks:
-            for unlock in locations[name].required_world:
+            for unlock in ctx.mission_req_table[name].required_world:
-                unlocks[list(locations)[unlock-1]].append(name)
+                unlocks[list(ctx.mission_req_table)[unlock - 1]].append(name)
 
-        if mission_reqs_completed(name, missions_complete, locations_done, locations):
+        if mission_reqs_completed(ctx, name, missions_complete):
             available_missions.append(name)
 
     return available_missions
 
 
-def mission_reqs_completed(location_to_check, missions_complete, locations_done, locations):
+def mission_reqs_completed(ctx: SC2Context, mission_name: str, missions_complete):
     """Returns a bool signifying if the mission has all requirements complete and can be done
 
-    Keyword arguments:
+    Arguments:
+    ctx -- instance of SC2Context
     locations_to_check -- the mission string name to check
     missions_complete -- an int of how many missions have been completed
-    locations_done -- a list of the location ids that have been complete
+"""
-    locations -- a dict of MissionInfo for mission requirements for this world"""
+    if len(ctx.mission_req_table[mission_name].required_world) >= 1:
-    if len(locations[location_to_check].required_world) >= 1:
         # A check for when the requirements are being or'd
         or_success = False
 
         # Loop through required missions
-        for req_mission in locations[location_to_check].required_world:
+        for req_mission in ctx.mission_req_table[mission_name].required_world:
             req_success = True
 
             # Check if required mission has been completed
-            if not (locations[list(locations)[req_mission-1]].id * 100 + SC2WOL_LOC_ID_OFFSET) in locations_done:
+            if not (ctx.mission_req_table[list(ctx.mission_req_table)[req_mission - 1]].id *
-                if not locations[location_to_check].or_requirements:
+                    victory_modulo + SC2WOL_LOC_ID_OFFSET) in ctx.checked_locations:
+                if not ctx.mission_req_table[mission_name].or_requirements:
                     return False
                 else:
                     req_success = False
 
             # Recursively check required mission to see if it's requirements are met, in case !collect has been done
-            if not mission_reqs_completed(list(locations)[req_mission-1], missions_complete, locations_done,
+            if not mission_reqs_completed(ctx, list(ctx.mission_req_table)[req_mission - 1], missions_complete):
-                                          locations):
+                if not ctx.mission_req_table[mission_name].or_requirements:
-                if not locations[location_to_check].or_requirements:
                     return False
                 else:
                     req_success = False
 
             # If requirement check succeeded mark or as satisfied
-            if locations[location_to_check].or_requirements and req_success:
+            if ctx.mission_req_table[mission_name].or_requirements and req_success:
                 or_success = True
 
-        if locations[location_to_check].or_requirements:
+        if ctx.mission_req_table[mission_name].or_requirements:
             # Return false if or requirements not met
             if not or_success:
                 return False
 
         # Check number of missions
-        if missions_complete >= locations[location_to_check].number:
+        if missions_complete >= ctx.mission_req_table[mission_name].number:
             return True
         else:
             return False
@@ -843,7 +793,12 @@ def check_game_install_path() -> bool:
         with open(einfo) as f:
             content = f.read()
         if content:
-            base = re.search(r" = (.*)Versions", content).group(1)
+            try:
+                base = re.search(r" = (.*)Versions", content).group(1)
+            except AttributeError:
+                sc2_logger.warning(f"Found {einfo}, but it was empty. Run SC2 through the Blizzard launcher, then "
+                                   f"try again.")
+                return False
             if os.path.exists(base):
                 executable = sc2.paths.latest_executeble(Path(base).expanduser() / "Versions")
 
@@ -860,7 +815,8 @@ def check_game_install_path() -> bool:
             else:
                 sc2_logger.warning(f"{einfo} pointed to {base}, but we could not find an SC2 install there.")
     else:
-        sc2_logger.warning(f"Couldn't find {einfo}. Please run /set_path with your SC2 install directory.")
+        sc2_logger.warning(f"Couldn't find {einfo}. Run SC2 through the Blizzard launcher, then try again. "
+                           f"If that fails, please run /set_path with your SC2 install directory.")
     return False
 
 
@@ -897,7 +853,7 @@ class DllDirectory:
             self.set(self._old)
 
     @staticmethod
-    def get() -> str:
+    def get() -> typing.Optional[str]:
         if sys.platform == "win32":
             n = ctypes.windll.kernel32.GetDllDirectoryW(0, None)
             buf = ctypes.create_unicode_buffer(n)

Utils.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import shutil
 import typing
 import builtins
 import os
@@ -12,12 +11,18 @@ import io
 import collections
 import importlib
 import logging
-import decimal
+from yaml import load, load_all, dump, SafeLoader
+
+try:
+    from yaml import CLoader as UnsafeLoader
+    from yaml import CDumper as Dumper
+except ImportError:
+    from yaml import Loader as UnsafeLoader
+    from yaml import Dumper
 
 if typing.TYPE_CHECKING:
-    from tkinter import Tk
+    import tkinter
-else:
+    import pathlib
-    Tk = typing.Any
 
 
 def tuplize_version(version: str) -> Version:
@@ -30,21 +35,13 @@ class Version(typing.NamedTuple):
     build: int
 
 
-__version__ = "0.3.4"
+__version__ = "0.3.5"
 version_tuple = tuplize_version(__version__)
 
-is_linux = sys.platform.startswith('linux')
+is_linux = sys.platform.startswith("linux")
-is_macos = sys.platform == 'darwin'
+is_macos = sys.platform == "darwin"
 is_windows = sys.platform in ("win32", "cygwin", "msys")
 
-import jellyfish
-from yaml import load, load_all, dump, SafeLoader
-
-try:
-    from yaml import CLoader as Loader
-except ImportError:
-    from yaml import Loader
-
 
 def int16_as_bytes(value: int) -> typing.List[int]:
     value = value & 0xFFFF
@@ -125,17 +122,18 @@ def home_path(*path: str) -> str:
 
 def user_path(*path: str) -> str:
     """Returns either local_path or home_path based on write permissions."""
-    if hasattr(user_path, 'cached_path'):
+    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')):
+        if user_path.cached_path != local_path() and not os.path.exists(user_path("host.yaml")):
-            for dn in ('Players', 'data/sprites'):
+            import shutil
+            for dn in ("Players", "data/sprites"):
                 shutil.copytree(local_path(dn), user_path(dn), dirs_exist_ok=True)
-            for fn in ('manifest.json', 'host.yaml'):
+            for fn in ("manifest.json", "host.yaml"):
                 shutil.copy2(local_path(fn), user_path(fn))
 
     return os.path.join(user_path.cached_path, *path)
@@ -150,11 +148,12 @@ def output_path(*path: str):
     return path
 
 
-def open_file(filename):
+def open_file(filename: typing.Union[str, "pathlib.Path"]) -> None:
-    if sys.platform == 'win32':
+    if is_windows:
         os.startfile(filename)
     else:
-        open_command = 'open' if sys.platform == 'darwin' else 'xdg-open'
+        from shutil import which
+        open_command = which("open") if is_macos else (which("xdg-open") or which("gnome-open") or which("kde-open"))
         subprocess.call([open_command, filename])
 
 
@@ -173,7 +172,9 @@ class UniqueKeyLoader(SafeLoader):
 
 parse_yaml = functools.partial(load, Loader=UniqueKeyLoader)
 parse_yamls = functools.partial(load_all, Loader=UniqueKeyLoader)
-unsafe_parse_yaml = functools.partial(load, Loader=Loader)
+unsafe_parse_yaml = functools.partial(load, Loader=UnsafeLoader)
+
+del load, load_all  # should not be used. don't leak their names
 
 
 def get_cert_none_ssl_context():
@@ -191,11 +192,12 @@ def get_public_ipv4() -> str:
     ip = socket.gethostbyname(socket.gethostname())
     ctx = get_cert_none_ssl_context()
     try:
-        ip = urllib.request.urlopen('https://checkip.amazonaws.com/', context=ctx).read().decode('utf8').strip()
+        ip = urllib.request.urlopen("https://checkip.amazonaws.com/", context=ctx).read().decode("utf8").strip()
     except Exception as e:
+        # noinspection PyBroadException
         try:
-            ip = urllib.request.urlopen('https://v4.ident.me', context=ctx).read().decode('utf8').strip()
+            ip = urllib.request.urlopen("https://v4.ident.me", context=ctx).read().decode("utf8").strip()
-        except:
+        except Exception:
             logging.exception(e)
             pass  # we could be offline, in a local game, so no point in erroring out
     return ip
@@ -208,7 +210,7 @@ def get_public_ipv6() -> str:
     ip = socket.gethostbyname(socket.gethostname())
     ctx = get_cert_none_ssl_context()
     try:
-        ip = urllib.request.urlopen('https://v6.ident.me', context=ctx).read().decode('utf8').strip()
+        ip = urllib.request.urlopen("https://v6.ident.me", context=ctx).read().decode("utf8").strip()
     except Exception as e:
         logging.exception(e)
         pass  # we could be offline, in a local game, or ipv6 may not be available
@@ -309,33 +311,19 @@ def update_options(src: dict, dest: dict, filename: str, keys: list) -> dict:
 
 @cache_argsless
 def get_options() -> dict:
-    if not hasattr(get_options, "options"):
+    filenames = ("options.yaml", "host.yaml")
-        filenames = ("options.yaml", "host.yaml")
+    locations = []
-        locations = []
+    if os.path.join(os.getcwd()) != local_path():
-        if os.path.join(os.getcwd()) != local_path():
+        locations += filenames  # use files from cwd only if it's not the local_path
-            locations += filenames  # use files from cwd only if it's not the local_path
+    locations += [user_path(filename) for filename in filenames]
-        locations += [user_path(filename) for filename in filenames]
 
-        for location in locations:
+    for location in locations:
-            if os.path.exists(location):
+        if os.path.exists(location):
-                with open(location) as f:
+            with open(location) as f:
-                    options = parse_yaml(f.read())
+                options = parse_yaml(f.read())
+            return update_options(get_default_options(), options, location, list())
 
-                get_options.options = update_options(get_default_options(), options, location, list())
+    raise FileNotFoundError(f"Could not find {filenames[1]} to load options.")
-                break
-        else:
-            raise FileNotFoundError(f"Could not find {filenames[1]} to load options.")
-    return get_options.options
-
-
-def get_item_name_from_id(code: int) -> str:
-    from worlds import lookup_any_item_id_to_name
-    return lookup_any_item_id_to_name.get(code, f'Unknown item (ID:{code})')
-
-
-def get_location_name_from_id(code: int) -> str:
-    from worlds import lookup_any_location_id_to_name
-    return lookup_any_location_id_to_name.get(code, f'Unknown location (ID:{code})')
 
 
 def persistent_store(category: str, key: typing.Any, value: typing.Any):
@@ -344,10 +332,10 @@ def persistent_store(category: str, key: typing.Any, value: typing.Any):
     category = storage.setdefault(category, {})
     category[key] = value
     with open(path, "wt") as f:
-        f.write(dump(storage))
+        f.write(dump(storage, Dumper=Dumper))
 
 
-def persistent_load() -> typing.Dict[dict]:
+def persistent_load() -> typing.Dict[str, dict]:
     storage = getattr(persistent_load, "storage", None)
     if storage:
         return storage
@@ -365,8 +353,8 @@ def persistent_load() -> typing.Dict[dict]:
     return storage
 
 
-def get_adjuster_settings(gameName: str):
+def get_adjuster_settings(game_name: str):
-    adjuster_settings = persistent_load().get("adjuster", {}).get(gameName, {})
+    adjuster_settings = persistent_load().get("adjuster", {}).get(game_name, {})
     return adjuster_settings
 
 
@@ -382,10 +370,10 @@ def get_unique_identifier():
     return uuid
 
 
-safe_builtins = {
+safe_builtins = frozenset((
     'set',
     'frozenset',
-}
+))
 
 
 class RestrictedUnpickler(pickle.Unpickler):
@@ -413,8 +401,7 @@ class RestrictedUnpickler(pickle.Unpickler):
             if issubclass(obj, self.options_module.Option):
                 return obj
         # Forbid everything else.
-        raise pickle.UnpicklingError("global '%s.%s' is forbidden" %
+        raise pickle.UnpicklingError(f"global '{module}.{name}' is forbidden")
-                                     (module, name))
 
 
 def restricted_loads(s):
@@ -423,6 +410,9 @@ def restricted_loads(s):
 
 
 class KeyedDefaultDict(collections.defaultdict):
+    """defaultdict variant that uses the missing key as argument to default_factory"""
+    default_factory: typing.Callable[[typing.Any], typing.Any]
+
     def __missing__(self, key):
         self[key] = value = self.default_factory(key)
         return value
@@ -432,6 +422,10 @@ def get_text_between(text: str, start: str, end: str) -> str:
     return text[text.index(start) + len(start): text.rindex(end)]
 
 
+def get_text_after(text: str, start: str) -> str:
+    return text[text.index(start) + len(start):]
+
+
 loglevel_mapping = {'error': logging.ERROR, 'info': logging.INFO, 'warning': logging.WARNING, 'debug': logging.DEBUG}
 
 
@@ -493,11 +487,11 @@ def stream_input(stream, queue):
     return thread
 
 
-def tkinter_center_window(window: Tk):
+def tkinter_center_window(window: "tkinter.Tk") -> None:
     window.update()
-    xPos = int(window.winfo_screenwidth() / 2 - window.winfo_reqwidth() / 2)
+    x = int(window.winfo_screenwidth() / 2 - window.winfo_reqwidth() / 2)
-    yPos = int(window.winfo_screenheight() / 2 - window.winfo_reqheight() / 2)
+    y = int(window.winfo_screenheight() / 2 - window.winfo_reqheight() / 2)
-    window.geometry("+{}+{}".format(xPos, yPos))
+    window.geometry(f"+{x}+{y}")
 
 
 class VersionException(Exception):
@@ -514,24 +508,27 @@ def chaining_prefix(index: int, labels: typing.Tuple[str]) -> str:
 
 
 # noinspection PyPep8Naming
-def format_SI_prefix(value, power=1000, power_labels=('', 'k', 'M', 'G', 'T', "P", "E", "Z", "Y")) -> str:
+def format_SI_prefix(value, power=1000, power_labels=("", "k", "M", "G", "T", "P", "E", "Z", "Y")) -> str:
     """Formats a value into a value + metric/si prefix. More info at https://en.wikipedia.org/wiki/Metric_prefix"""
+    import decimal
     n = 0
     value = decimal.Decimal(value)
-    while value >= power:
+    limit = power - decimal.Decimal("0.005")
+    while value >= limit:
         value /= power
         n += 1
 
     return f"{value.quantize(decimal.Decimal('1.00'))} {chaining_prefix(n, power_labels)}"
 
 
-def get_fuzzy_ratio(word1: str, word2: str) -> float:
-    return (1 - jellyfish.damerau_levenshtein_distance(word1.lower(), word2.lower())
-            / max(len(word1), len(word2)))
-
-
 def get_fuzzy_results(input_word: str, wordlist: typing.Sequence[str], limit: typing.Optional[int] = None) \
         -> typing.List[typing.Tuple[str, int]]:
+    import jellyfish
+
+    def get_fuzzy_ratio(word1: str, word2: str) -> float:
+        return (1 - jellyfish.damerau_levenshtein_distance(word1.lower(), word2.lower())
+                / max(len(word1), len(word2)))
+
     limit: int = limit if limit else len(wordlist)
     return list(
         map(
@@ -549,18 +546,19 @@ def get_fuzzy_results(input_word: str, wordlist: typing.Sequence[str], limit: ty
 def open_filename(title: str, filetypes: typing.Sequence[typing.Tuple[str, typing.Sequence[str]]]) \
         -> typing.Optional[str]:
     def run(*args: str):
-        return subprocess.run(args, capture_output=True, text=True).stdout.split('\n', 1)[0] or None
+        return subprocess.run(args, capture_output=True, text=True).stdout.split("\n", 1)[0] or None
 
     if is_linux:
         # prefer native dialog
-        kdialog = shutil.which('kdialog')
+        from shutil import which
+        kdialog = which("kdialog")
         if kdialog:
             k_filters = '|'.join((f'{text} (*{" *".join(ext)})' for (text, ext) in filetypes))
-            return run(kdialog, f'--title={title}', '--getopenfilename', '.', k_filters)
+            return run(kdialog, f"--title={title}", "--getopenfilename", ".", k_filters)
-        zenity = shutil.which('zenity')
+        zenity = which("zenity")
         if zenity:
             z_filters = (f'--file-filter={text} ({", ".join(ext)}) | *{" *".join(ext)}' for (text, ext) in filetypes)
-            return run(zenity, f'--title={title}', '--file-selection', *z_filters)
+            return run(zenity, f"--title={title}", "--file-selection", *z_filters)
 
     # fall back to tk
     try:
@@ -578,10 +576,10 @@ def open_filename(title: str, filetypes: typing.Sequence[typing.Tuple[str, typin
 
 def messagebox(title: str, text: str, error: bool = False) -> None:
     def run(*args: str):
-        return subprocess.run(args, capture_output=True, text=True).stdout.split('\n', 1)[0] or None
+        return subprocess.run(args, capture_output=True, text=True).stdout.split("\n", 1)[0] or None
 
     def is_kivy_running():
-        if 'kivy' in sys.modules:
+        if "kivy" in sys.modules:
             from kivy.app import App
             return App.get_running_app() is not None
         return False
@@ -591,14 +589,15 @@ def messagebox(title: str, text: str, error: bool = False) -> None:
         MessageBox(title, text, error).open()
         return
 
-    if is_linux and not 'tkinter' in sys.modules:
+    if is_linux and "tkinter" not in sys.modules:
         # prefer native dialog
-        kdialog = shutil.which('kdialog')
+        from shutil import which
+        kdialog = which("kdialog")
         if kdialog:
-            return run(kdialog, f'--title={title}', '--error' if error else '--msgbox', text)
+            return run(kdialog, f"--title={title}", "--error" if error else "--msgbox", text)
-        zenity = shutil.which('zenity')
+        zenity = which("zenity")
         if zenity:
-            return run(zenity, f'--title={title}', f'--text={text}', '--error' if error else '--info')
+            return run(zenity, f"--title={title}", f"--text={text}", "--error" if error else "--info")
 
     # fall back to tk
     try:
@@ -613,3 +612,14 @@ def messagebox(title: str, text: str, error: bool = False) -> None:
         root.withdraw()
         showerror(title, text) if error else showinfo(title, text)
         root.update()
+
+
+def title_sorted(data: typing.Sequence, key=None, ignore: typing.Set = frozenset(("a", "the"))):
+    """Sorts a sequence of text ignoring typical articles like "a" or "the" in the beginning."""
+    def sorter(element: str) -> str:
+        parts = element.split(maxsplit=1)
+        if parts[0].lower() in ignore:
+            return parts[1].lower()
+        else:
+            return element.lower()
+    return sorted(data, key=lambda i: sorter(key(i)) if key else sorter(i))

WebHost.py

@@ -12,9 +12,9 @@ ModuleUpdate.update()
 # in case app gets imported by something like gunicorn
 import Utils
 
-Utils.local_path.cached_path = os.path.dirname(__file__)
+Utils.local_path.cached_path = os.path.dirname(__file__) or "."  # py3.8 is not abs. remove "." when dropping 3.8
 
-from WebHostLib import app as raw_app
+from WebHostLib import register, app as raw_app
 from waitress import serve
 
 from WebHostLib.models import db
@@ -22,14 +22,13 @@ from WebHostLib.autolauncher import autohost, autogen
 from WebHostLib.lttpsprites import update_sprites_lttp
 from WebHostLib.options import create as create_options_files
 
-from worlds.AutoWorld import AutoWorldRegister
-
 configpath = os.path.abspath("config.yaml")
 if not os.path.exists(configpath):  # fall back to config.yaml in home
     configpath = os.path.abspath(Utils.user_path('config.yaml'))
 
 
 def get_app():
+    register()
     app = raw_app
     if os.path.exists(configpath):
         import yaml
@@ -43,19 +42,39 @@ def get_app():
 def create_ordered_tutorials_file() -> typing.List[typing.Dict[str, typing.Any]]:
     import json
     import shutil
+    import zipfile
+
+    zfile: zipfile.ZipInfo
+
+    from worlds.AutoWorld import AutoWorldRegister
     worlds = {}
     data = []
     for game, world in AutoWorldRegister.world_types.items():
         if hasattr(world.web, 'tutorials') and (not world.hidden or game == 'Archipelago'):
             worlds[game] = world
+
+    base_target_path = Utils.local_path("WebHostLib", "static", "generated", "docs")
     for game, world in worlds.items():
         # copy files from world's docs folder to the generated folder
-        source_path = Utils.local_path(os.path.dirname(sys.modules[world.__module__].__file__), 'docs')
+        target_path = os.path.join(base_target_path, game)
-        target_path = Utils.local_path("WebHostLib", "static", "generated", "docs", game)
+        os.makedirs(target_path, exist_ok=True)
-        files = os.listdir(source_path)
+
-        for file in files:
+        if world.zip_path:
-            os.makedirs(os.path.dirname(Utils.local_path(target_path, file)), exist_ok=True)
+            zipfile_path = world.zip_path
-            shutil.copyfile(Utils.local_path(source_path, file), Utils.local_path(target_path, file))
+
+            assert os.path.isfile(zipfile_path), f"{zipfile_path} is not a valid file(path)."
+            assert zipfile.is_zipfile(zipfile_path), f"{zipfile_path} is not a valid zipfile."
+
+            with zipfile.ZipFile(zipfile_path) as zf:
+                for zfile in zf.infolist():
+                    if not zfile.is_dir() and "/docs/" in zfile.filename:
+                        zf.extract(zfile, target_path)
+        else:
+            source_path = Utils.local_path(os.path.dirname(world.__file__), "docs")
+            files = os.listdir(source_path)
+            for file in files:
+                shutil.copyfile(Utils.local_path(source_path, file), Utils.local_path(target_path, file))
+
         # build a json tutorial dict per game
         game_data = {'gameTitle': game, 'tutorials': []}
         for tutorial in world.web.tutorials:
@@ -85,7 +104,7 @@ def create_ordered_tutorials_file() -> typing.List[typing.Dict[str, typing.Any]]
         for games in data:
             if 'Archipelago' in games['gameTitle']:
                 generic_data = data.pop(data.index(games))
-        sorted_data = [generic_data] + sorted(data, key=lambda entry: entry["gameTitle"].lower())
+        sorted_data = [generic_data] + Utils.title_sorted(data, key=lambda entry: entry["gameTitle"])
         json.dump(sorted_data, json_target, indent=2, ensure_ascii=False)
     return sorted_data
 

WebHostLib/README.md

@@ -0,0 +1,46 @@
+# WebHost
+
+## Contribution Guidelines
+**Thank you for your interest in contributing to the Archipelago website!**  
+Much of the content on the website is generated automatically, but there are some things
+that need a personal touch. For those things, we rely on contributions from both the core
+team and the community. The current primary maintainer of the website is Farrak Kilhn.
+He may be found on Discord as `Farrak Kilhn#0418`, or on GitHub as `LegendaryLinux`.
+
+### Small Changes
+Little changes like adding a button or a couple new select elements are perfectly fine.
+Tweaks to style specific to a PR's content are also probably not a problem. For example, if
+you build a new page which needs two side by side tables, and you need to write a CSS file
+specific to your page, that is perfectly reasonable.
+
+### Content Additions
+Once you develop a new feature or add new content the website, make a pull request. It will
+be reviewed by the community and there will probably be some discussion around it. Depending
+on the size of the feature, and if new styles are required, there may be an additional step
+before the PR is accepted wherein Farrak works with the designer to implement styles.
+
+### Restrictions on Style Changes
+A professional designer is paid to develop the styles and assets for the Archipelago website.
+In an effort to maintain a consistent look and feel, pull requests which *exclusively*
+change site styles are rejected. Please note this applies to code which changes the overall
+look and feel of the site, not to small tweaks to CSS for your custom page. The intention
+behind these restrictions is to maintain a curated feel for the design of the site. If
+any PR affects the overall feel of the site but includes additive changes, there will
+likely be a conversation about how to implement those changes without compromising the
+curated site style. It is therefore worth noting there are a couple files which, if
+changed in your pull request, will cause it to draw additional scrutiny.
+
+These closely guarded files are:
+- `globalStyles.css`
+- `islandFooter.css`
+- `landing.css`
+- `markdown.css`
+- `tooltip.css`
+
+### Site Themes
+There are several themes available for game pages. It is possible to request a new theme in
+the `#art-and-design` channel on Discord. Because themes are created by the designer, they
+are not free, and take some time to create. Farrak works closely with the designer to implement
+these themes, and pays for the assets out of pocket. Therefore, only a couple themes per year
+are added. If a proposed theme seems like a cool idea and the community likes it, there is a
+good chance it will become a reality.

WebHostLib/__init__.py

@@ -3,13 +3,13 @@ import uuid
 import base64
 import socket
 
-import jinja2.exceptions
 from pony.flask import Pony
-from flask import Flask, request, redirect, url_for, render_template, Response, session, abort, send_from_directory
+from flask import Flask
 from flask_caching import Cache
 from flask_compress import Compress
-from worlds.AutoWorld import AutoWorldRegister
+from werkzeug.routing import BaseConverter
 
+from Utils import title_sorted
 from .models import *
 
 UPLOAD_FOLDER = os.path.relpath('uploads')
@@ -53,8 +53,6 @@ app.config["PATCH_TARGET"] = "archipelago.gg"
 cache = Cache(app)
 Compress(app)
 
-from werkzeug.routing import BaseConverter
-
 
 class B64UUIDConverter(BaseConverter):
 
@@ -68,174 +66,18 @@ class B64UUIDConverter(BaseConverter):
 # short UUID
 app.url_map.converters["suuid"] = B64UUIDConverter
 app.jinja_env.filters['suuid'] = lambda value: base64.urlsafe_b64encode(value.bytes).rstrip(b'=').decode('ascii')
-
+app.jinja_env.filters["title_sorted"] = title_sorted
-# has automatic patch integration
-import Patch
-app.jinja_env.filters['supports_apdeltapatch'] = lambda game_name: game_name in Patch.AutoPatchRegister.patch_types
 
 
-def get_world_theme(game_name: str):
+def register():
-    if game_name in AutoWorldRegister.world_types:
+    """Import submodules, triggering their registering on flask routing.
-        return AutoWorldRegister.world_types[game_name].web.theme
+    Note: initializes worlds subsystem."""
-    return 'grass'
+    # has automatic patch integration
+    import Patch
+    app.jinja_env.filters['supports_apdeltapatch'] = lambda game_name: game_name in Patch.AutoPatchRegister.patch_types
 
+    from WebHostLib.customserver import run_server_process
+    # to trigger app routing picking up on it
+    from . import tracker, upload, landing, check, generate, downloads, api, stats, misc
 
-@app.before_request
+    app.register_blueprint(api.api_endpoints)
-def register_session():
-    session.permanent = True  # technically 31 days after the last visit
-    if not session.get("_id", None):
-        session["_id"] = uuid4()  # uniquely identify each session without needing a login
-
-
-@app.errorhandler(404)
-@app.errorhandler(jinja2.exceptions.TemplateNotFound)
-def page_not_found(err):
-    return render_template('404.html'), 404
-
-
-# Start Playing Page
-@app.route('/start-playing')
-def start_playing():
-    return render_template(f"startPlaying.html")
-
-
-@app.route('/weighted-settings')
-def weighted_settings():
-    return render_template(f"weighted-settings.html")
-
-
-# Player settings pages
-@app.route('/games/<string:game>/player-settings')
-def player_settings(game):
-    return render_template(f"player-settings.html", game=game, theme=get_world_theme(game))
-
-
-# Game Info Pages
-@app.route('/games/<string:game>/info/<string:lang>')
-def game_info(game, lang):
-    return render_template('gameInfo.html', game=game, lang=lang, theme=get_world_theme(game))
-
-
-# List of supported games
-@app.route('/games')
-def games():
-    worlds = {}
-    for game, world in AutoWorldRegister.world_types.items():
-        if not world.hidden:
-            worlds[game] = world
-    return render_template("supportedGames.html", worlds=worlds)
-
-
-@app.route('/tutorial/<string:game>/<string:file>/<string:lang>')
-def tutorial(game, file, lang):
-    return render_template("tutorial.html", game=game, file=file, lang=lang, theme=get_world_theme(game))
-
-
-@app.route('/tutorial/')
-def tutorial_landing():
-    worlds = {}
-    for game, world in AutoWorldRegister.world_types.items():
-        if not world.hidden:
-            worlds[game] = world
-    return render_template("tutorialLanding.html")
-
-
-@app.route('/faq/<string:lang>/')
-def faq(lang):
-    return render_template("faq.html", lang=lang)
-
-
-@app.route('/glossary/<string:lang>/')
-def terms(lang):
-    return render_template("glossary.html", lang=lang)
-
-
-@app.route('/seed/<suuid:seed>')
-def view_seed(seed: UUID):
-    seed = Seed.get(id=seed)
-    if not seed:
-        abort(404)
-    return render_template("viewSeed.html", seed=seed, slot_count=count(seed.slots))
-
-
-@app.route('/new_room/<suuid:seed>')
-def new_room(seed: UUID):
-    seed = Seed.get(id=seed)
-    if not seed:
-        abort(404)
-    room = Room(seed=seed, owner=session["_id"], tracker=uuid4())
-    commit()
-    return redirect(url_for("host_room", room=room.id))
-
-
-def _read_log(path: str):
-    if os.path.exists(path):
-        with open(path, encoding="utf-8-sig") as log:
-            yield from log
-    else:
-        yield f"Logfile {path} does not exist. " \
-              f"Likely a crash during spinup of multiworld instance or it is still spinning up."
-
-
-@app.route('/log/<suuid:room>')
-def display_log(room: UUID):
-    room = Room.get(id=room)
-    if room is None:
-        return abort(404)
-    if room.owner == session["_id"]:
-        return Response(_read_log(os.path.join("logs", str(room.id) + ".txt")), mimetype="text/plain;charset=UTF-8")
-    return "Access Denied", 403
-
-
-@app.route('/room/<suuid:room>', methods=['GET', 'POST'])
-def host_room(room: UUID):
-    room = Room.get(id=room)
-    if room is None:
-        return abort(404)
-    if request.method == "POST":
-        if room.owner == session["_id"]:
-            cmd = request.form["cmd"]
-            if cmd:
-                Command(room=room, commandtext=cmd)
-                commit()
-
-    with db_session:
-        room.last_activity = datetime.utcnow()  # will trigger a spinup, if it's not already running
-
-    return render_template("hostRoom.html", room=room)
-
-
-@app.route('/favicon.ico')
-def favicon():
-    return send_from_directory(os.path.join(app.root_path, 'static/static'),
-                               'favicon.ico', mimetype='image/vnd.microsoft.icon')
-
-
-@app.route('/discord')
-def discord():
-    return redirect("https://discord.gg/archipelago")
-
-
-@app.route('/datapackage')
-@cache.cached()
-def get_datapackge():
-    """A pretty print version of /api/datapackage"""
-    from worlds import network_data_package
-    import json
-    return Response(json.dumps(network_data_package, indent=4), mimetype="text/plain")
-
-
-@app.route('/index')
-@app.route('/sitemap')
-def get_sitemap():
-    available_games = []
-    for game, world in AutoWorldRegister.world_types.items():
-        if not world.hidden:
-            available_games.append(game)
-    return render_template("siteMap.html", games=available_games)
-
-
-from WebHostLib.customserver import run_server_process
-from . import tracker, upload, landing, check, generate, downloads, api, stats  # to trigger app routing picking up on it
-
-app.register_blueprint(api.api_endpoints)

WebHostLib/api/__init__.py

@@ -32,18 +32,18 @@ def room_info(room: UUID):
 
 @api_endpoints.route('/datapackage')
 @cache.cached()
-def get_datapackge():
+def get_datapackage():
     from worlds import network_data_package
     return network_data_package
 
 
 @api_endpoints.route('/datapackage_version')
 @cache.cached()
-def get_datapackge_versions():
+def get_datapackage_versions():
     from worlds import network_data_package, AutoWorldRegister
     version_package = {game: world.data_version for game, world in AutoWorldRegister.world_types.items()}
     version_package["version"] = network_data_package["version"]
     return version_package
 
 
-from . import generate, user  # trigger registration
+from . import generate, user, tracker  # trigger registration

WebHostLib/api/tracker.py

@@ -0,0 +1,50 @@
+import collections
+
+from flask import jsonify
+from typing import Optional, Dict, Any, Tuple, List
+from Utils import restricted_loads
+from uuid import UUID
+
+from ..models import Room
+from . import api_endpoints
+from ..tracker import fill_tracker_data, get_static_room_data
+from worlds import lookup_any_item_id_to_name, lookup_any_location_id_to_name
+from WebHostLib import cache
+
+
+@api_endpoints.route('/tracker/<suuid:tracker>/<int:tracked_team>/<int:tracked_player>')
+@cache.memoize(timeout=60)
+def update_player_tracker(tracker: UUID, tracked_team: int, tracked_player: int):
+
+    room: Optional[Room] = Room.get(tracker=tracker)
+    locations = get_static_room_data(room)[0]
+    items_counter: Dict[int, collections.Counter] = get_item_names_counter(locations)
+    player_tracker, multisave, inventory, seed_checks_in_area, lttp_checks_done, \
+    slot_data, games, player_name, display_icons = fill_tracker_data(room, tracked_team, tracked_player)
+
+    # convert numbers to string
+    for item in player_tracker.items_received:
+        if items_counter[tracked_player][item] == 1:
+            player_tracker.items_received[item] = '✔'
+        else:
+            player_tracker.items_received[item] = str(player_tracker.items_received[item])
+
+    return jsonify({
+        "items_received": player_tracker.items_received,
+        "checked_locations": list(sorted(player_tracker.checked_locations)),
+        "icons": display_icons,
+        "progressive_names": player_tracker.progressive_names
+    })
+
+
+@cache.cached()
+def get_item_names_counter(locations: Dict[int, Dict[int, Tuple[int, int, int]]]):
+    # create and fill dictionary of all progression items for players
+    items_counters: Dict[int, collections.Counter] = {}
+    for player in locations:
+        for location in locations[player]:
+            item, recipient, flags = locations[player][location]
+            item_name = lookup_any_item_id_to_name[item]
+            items_counters.setdefault(recipient, collections.Counter())[item_name] += 1
+
+    return items_counters

WebHostLib/autolauncher.py

@@ -184,7 +184,7 @@ class MultiworldInstance():
 
         logging.info(f"Spinning up {self.room_id}")
         process = multiprocessing.Process(group=None, target=run_server_process,
-                                          args=(self.room_id, self.ponyconfig),
+                                          args=(self.room_id, self.ponyconfig, get_static_server_data()),
                                           name="MultiHost")
         process.start()
         # bind after start to prevent thread sync issues with guardian.
@@ -238,5 +238,5 @@ def run_guardian():
 
 
 from .models import Room, Generation, STATE_QUEUED, STATE_STARTED, STATE_ERROR, db, Seed
-from .customserver import run_server_process
+from .customserver import run_server_process, get_static_server_data
 from .generate import gen_game

WebHostLib/customserver.py

@@ -1,20 +1,22 @@
 from __future__ import annotations
 
-import functools
-import websockets
 import asyncio
+import collections
+import datetime
+import functools
+import logging
+import pickle
+import random
 import socket
 import threading
 import time
-import random
+import websockets
-import pickle
-import logging
 
 import Utils
-from .models import *
+from .models import db_session, Room, select, commit, Command, db
 
 from MultiServer import Context, server, auto_shutdown, ServerCommandProcessor, ClientMessageProcessor
-from Utils import get_public_ipv4, get_public_ipv6, restricted_loads
+from Utils import get_public_ipv4, get_public_ipv6, restricted_loads, cache_argsless
 
 
 class CustomClientMessageProcessor(ClientMessageProcessor):
@@ -39,7 +41,7 @@ class CustomClientMessageProcessor(ClientMessageProcessor):
 import MultiServer
 
 MultiServer.client_message_processor = CustomClientMessageProcessor
-del (MultiServer)
+del MultiServer
 
 
 class DBCommandProcessor(ServerCommandProcessor):
@@ -48,12 +50,24 @@ class DBCommandProcessor(ServerCommandProcessor):
 
 
 class WebHostContext(Context):
-    def __init__(self):
+    room_id: int
+
+    def __init__(self, static_server_data: dict):
+        # static server data is used during _load_game_data to load required data,
+        # without needing to import worlds system, which takes quite a bit of memory
+        self.static_server_data = static_server_data
         super(WebHostContext, self).__init__("", 0, "", "", 1, 40, True, "enabled", "enabled", "enabled", 0, 2)
+        del self.static_server_data
         self.main_loop = asyncio.get_running_loop()
         self.video = {}
         self.tags = ["AP", "WebHost"]
 
+    def _load_game_data(self):
+        for key, value in self.static_server_data.items():
+            setattr(self, key, value)
+        self.forced_auto_forfeits = collections.defaultdict(lambda: False, self.forced_auto_forfeits)
+        self.non_hintable_names = collections.defaultdict(frozenset, self.non_hintable_names)
+
     def listen_to_db_commands(self):
         cmdprocessor = DBCommandProcessor(self)
 
@@ -94,7 +108,7 @@ class WebHostContext(Context):
         room.multisave = pickle.dumps(self.get_save())
         # saving only occurs on activity, so we can "abuse" this information to mark this as last_activity
         if not exit_save:  # we don't want to count a shutdown as activity, which would restart the server again
-            room.last_activity = datetime.utcnow()
+            room.last_activity = datetime.datetime.utcnow()
         return True
 
     def get_save(self) -> dict:
@@ -107,14 +121,32 @@ def get_random_port():
     return random.randint(49152, 65535)
 
 
-def run_server_process(room_id, ponyconfig: dict):
+@cache_argsless
+def get_static_server_data() -> dict:
+    import worlds
+    data = {
+        "forced_auto_forfeits": {},
+        "non_hintable_names": {},
+        "gamespackage": worlds.network_data_package["games"],
+        "item_name_groups": {world_name: world.item_name_groups for world_name, world in
+                             worlds.AutoWorldRegister.world_types.items()},
+    }
+
+    for world_name, world in worlds.AutoWorldRegister.world_types.items():
+        data["forced_auto_forfeits"][world_name] = world.forced_auto_forfeit
+        data["non_hintable_names"][world_name] = world.hint_blacklist
+
+    return data
+
+
+def run_server_process(room_id, ponyconfig: dict, static_server_data: dict):
     # establish DB connection for multidata and multisave
     db.bind(**ponyconfig)
     db.generate_mapping(check_tables=False)
 
     async def main():
         Utils.init_logging(str(room_id), write_mode="a")
-        ctx = WebHostContext()
+        ctx = WebHostContext(static_server_data)
         ctx.load(room_id)
         ctx.init_save()
 

WebHostLib/downloads.py

@@ -32,18 +32,21 @@ def download_patch(room_id, patch_id):
                             new_zip.writestr("archipelago.json", json.dumps(manifest))
                         else:
                             new_zip.writestr(file.filename, zf.read(file), file.compress_type, 9)
-
+            if "patch_file_ending" in manifest:
+                patch_file_ending = manifest["patch_file_ending"]
+            else:
+                patch_file_ending = AutoPatchRegister.patch_types[patch.game].patch_file_ending
             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}"
+                    f"{patch_file_ending}"
             new_file.seek(0)
-            return send_file(new_file, as_attachment=True, attachment_filename=fname)
+            return send_file(new_file, as_attachment=True, download_name=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]}"
-        return send_file(patch_data, as_attachment=True, attachment_filename=fname)
+        return send_file(patch_data, as_attachment=True, download_name=fname)
 
 
 @app.route("/dl_spoiler/<suuid:seed_id>")
@@ -66,7 +69,7 @@ def download_slot_file(room_id, player_id: int):
             from worlds.minecraft import mc_update_output
             fname = f"AP_{app.jinja_env.filters['suuid'](room_id)}_P{slot_data.player_id}_{slot_data.player_name}.apmc"
             data = mc_update_output(slot_data.data, server=app.config['PATCH_TARGET'], port=room.last_port)
-            return send_file(io.BytesIO(data), as_attachment=True, attachment_filename=fname)
+            return send_file(io.BytesIO(data), as_attachment=True, download_name=fname)
         elif slot_data.game == "Factorio":
             with zipfile.ZipFile(io.BytesIO(slot_data.data)) as zf:
                 for name in zf.namelist():
@@ -82,7 +85,7 @@ def download_slot_file(room_id, player_id: int):
             fname = f"AP_{app.jinja_env.filters['suuid'](room_id)}.json"
         else:
             return "Game download not supported."
-        return send_file(io.BytesIO(slot_data.data), as_attachment=True, attachment_filename=fname)
+        return send_file(io.BytesIO(slot_data.data), as_attachment=True, download_name=fname)
 
 
 @app.route("/templates")

WebHostLib/misc.py

@@ -0,0 +1,173 @@
+import datetime
+import os
+
+import jinja2.exceptions
+from flask import request, redirect, url_for, render_template, Response, session, abort, send_from_directory
+
+from .models import count, Seed, commit, Room, db_session, Command, UUID, uuid4
+from worlds.AutoWorld import AutoWorldRegister
+from . import app, cache
+
+
+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
+    if not session.get("_id", None):
+        session["_id"] = uuid4()  # uniquely identify each session without needing a login
+
+
+@app.errorhandler(404)
+@app.errorhandler(jinja2.exceptions.TemplateNotFound)
+def page_not_found(err):
+    return render_template('404.html'), 404
+
+
+# Start Playing Page
+@app.route('/start-playing')
+def start_playing():
+    return render_template(f"startPlaying.html")
+
+
+@app.route('/weighted-settings')
+def weighted_settings():
+    return render_template(f"weighted-settings.html")
+
+
+# Player settings pages
+@app.route('/games/<string:game>/player-settings')
+def player_settings(game):
+    return render_template(f"player-settings.html", game=game, theme=get_world_theme(game))
+
+
+# Game Info Pages
+@app.route('/games/<string:game>/info/<string:lang>')
+def game_info(game, lang):
+    return render_template('gameInfo.html', game=game, lang=lang, theme=get_world_theme(game))
+
+
+# List of supported games
+@app.route('/games')
+def games():
+    worlds = {}
+    for game, world in AutoWorldRegister.world_types.items():
+        if not world.hidden:
+            worlds[game] = world
+    return render_template("supportedGames.html", worlds=worlds)
+
+
+@app.route('/tutorial/<string:game>/<string:file>/<string:lang>')
+def tutorial(game, file, lang):
+    return render_template("tutorial.html", game=game, file=file, lang=lang, theme=get_world_theme(game))
+
+
+@app.route('/tutorial/')
+def tutorial_landing():
+    worlds = {}
+    for game, world in AutoWorldRegister.world_types.items():
+        if not world.hidden:
+            worlds[game] = world
+    return render_template("tutorialLanding.html")
+
+
+@app.route('/faq/<string:lang>/')
+def faq(lang):
+    return render_template("faq.html", lang=lang)
+
+
+@app.route('/glossary/<string:lang>/')
+def terms(lang):
+    return render_template("glossary.html", lang=lang)
+
+
+@app.route('/seed/<suuid:seed>')
+def view_seed(seed: UUID):
+    seed = Seed.get(id=seed)
+    if not seed:
+        abort(404)
+    return render_template("viewSeed.html", seed=seed, slot_count=count(seed.slots))
+
+
+@app.route('/new_room/<suuid:seed>')
+def new_room(seed: UUID):
+    seed = Seed.get(id=seed)
+    if not seed:
+        abort(404)
+    room = Room(seed=seed, owner=session["_id"], tracker=uuid4())
+    commit()
+    return redirect(url_for("host_room", room=room.id))
+
+
+def _read_log(path: str):
+    if os.path.exists(path):
+        with open(path, encoding="utf-8-sig") as log:
+            yield from log
+    else:
+        yield f"Logfile {path} does not exist. " \
+              f"Likely a crash during spinup of multiworld instance or it is still spinning up."
+
+
+@app.route('/log/<suuid:room>')
+def display_log(room: UUID):
+    room = Room.get(id=room)
+    if room is None:
+        return abort(404)
+    if room.owner == session["_id"]:
+        return Response(_read_log(os.path.join("logs", str(room.id) + ".txt")), mimetype="text/plain;charset=UTF-8")
+    return "Access Denied", 403
+
+
+@app.route('/room/<suuid:room>', methods=['GET', 'POST'])
+def host_room(room: UUID):
+    room: Room = Room.get(id=room)
+    if room is None:
+        return abort(404)
+    if request.method == "POST":
+        if room.owner == session["_id"]:
+            cmd = request.form["cmd"]
+            if cmd:
+                Command(room=room, commandtext=cmd)
+                commit()
+
+    now = datetime.datetime.utcnow()
+    # indicate that the page should reload to get the assigned port
+    should_refresh = not room.last_port and now - room.creation_time < datetime.timedelta(seconds=3)
+    with db_session:
+        room.last_activity = now  # will trigger a spinup, if it's not already running
+
+    return render_template("hostRoom.html", room=room, should_refresh=should_refresh)
+
+
+@app.route('/favicon.ico')
+def favicon():
+    return send_from_directory(os.path.join(app.root_path, 'static/static'),
+                               'favicon.ico', mimetype='image/vnd.microsoft.icon')
+
+
+@app.route('/discord')
+def discord():
+    return redirect("https://discord.gg/archipelago")
+
+
+@app.route('/datapackage')
+@cache.cached()
+def get_datapackage():
+    """A pretty print version of /api/datapackage"""
+    from worlds import network_data_package
+    import json
+    return Response(json.dumps(network_data_package, indent=4), mimetype="text/plain")
+
+
+@app.route('/index')
+@app.route('/sitemap')
+def get_sitemap():
+    available_games = []
+    for game, world in AutoWorldRegister.world_types.items():
+        if not world.hidden:
+            available_games.append(game)
+    return render_template("siteMap.html", games=available_games)

WebHostLib/options.py

@@ -1,6 +1,6 @@
 import logging
 import os
-from Utils import __version__
+from Utils import __version__, local_path
 from jinja2 import Template
 import yaml
 import json
@@ -9,14 +9,13 @@ import typing
 from worlds.AutoWorld import AutoWorldRegister
 import Options
 
-target_folder = os.path.join("WebHostLib", "static", "generated")
-
 handled_in_js = {"start_inventory", "local_items", "non_local_items", "start_hints", "start_location_hints",
                  "exclude_locations"}
 
 
 def create():
-    os.makedirs(os.path.join(target_folder, 'configs'), exist_ok=True)
+    target_folder = local_path("WebHostLib", "static", "generated")
+    os.makedirs(os.path.join(target_folder, "configs"), exist_ok=True)
 
     def dictify_range(option: typing.Union[Options.Range, Options.SpecialRange]):
         data = {}
@@ -49,6 +48,11 @@ def create():
             return list(default_value)
         return default_value
 
+    def get_html_doc(option_type: type(Options.Option)) -> str:
+        if not option_type.__doc__:
+            return "Please document me!"
+        return "\n".join(line.strip() for line in option_type.__doc__.split("\n")).strip()
+
     weighted_settings = {
         "baseOptions": {
             "description": "Generated by https://archipelago.gg/",
@@ -60,13 +64,17 @@ def create():
 
     for game_name, world in AutoWorldRegister.world_types.items():
 
-        all_options = {**Options.per_game_common_options, **world.options}
+        all_options = {**Options.per_game_common_options, **world.option_definitions}
-        res = Template(open(os.path.join("WebHostLib", "templates", "options.yaml")).read()).render(
+        with open(local_path("WebHostLib", "templates", "options.yaml")) as f:
+            file_data = f.read()
+        res = Template(file_data).render(
             options=all_options,
             __version__=__version__, game=game_name, yaml_dump=yaml.dump,
             dictify_range=dictify_range, default_converter=default_converter,
         )
 
+        del file_data
+
         with open(os.path.join(target_folder, 'configs', game_name + ".yaml"), "w") as f:
             f.write(res)
 
@@ -88,7 +96,7 @@ def create():
                 game_options[option_name] = this_option = {
                     "type": "select",
                     "displayName": option.display_name if hasattr(option, "display_name") else option_name,
-                    "description": option.__doc__ if option.__doc__ else "Please document me!",
+                    "description": get_html_doc(option),
                     "defaultValue": None,
                     "options": []
                 }
@@ -110,18 +118,18 @@ def create():
                 if option.default == "random":
                     this_option["defaultValue"] = "random"
 
-            elif hasattr(option, "range_start") and hasattr(option, "range_end"):
+            elif issubclass(option, Options.Range):
                 game_options[option_name] = {
                     "type": "range",
                     "displayName": option.display_name if hasattr(option, "display_name") else option_name,
-                    "description": option.__doc__ if option.__doc__ else "Please document me!",
+                    "description": get_html_doc(option),
                     "defaultValue": option.default if hasattr(
                         option, "default") and option.default != "random" else option.range_start,
                     "min": option.range_start,
                     "max": option.range_end,
                 }
 
-                if hasattr(option, "special_range_names"):
+                if issubclass(option, Options.SpecialRange):
                     game_options[option_name]["type"] = 'special_range'
                     game_options[option_name]["value_names"] = {}
                     for key, val in option.special_range_names.items():
@@ -131,22 +139,22 @@ def create():
                 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!",
+                    "description": get_html_doc(option),
                 }
 
             elif getattr(option, "verify_location_name", False):
                 game_options[option_name] = {
                     "type": "locations-list",
                     "displayName": option.display_name if hasattr(option, "display_name") else option_name,
-                    "description": option.__doc__ if option.__doc__ else "Please document me!",
+                    "description": get_html_doc(option),
                 }
 
-            elif hasattr(option, "valid_keys"):
+            elif issubclass(option, Options.OptionList) or issubclass(option, Options.OptionSet):
                 if option.valid_keys:
                     game_options[option_name] = {
                         "type": "custom-list",
                         "displayName": option.display_name if hasattr(option, "display_name") else option_name,
-                        "description": option.__doc__ if option.__doc__ else "Please document me!",
+                        "description": get_html_doc(option),
                         "options": list(option.valid_keys),
                     }
 

WebHostLib/requirements.txt

@@ -1,7 +1,7 @@
-flask>=2.1.3
+flask>=2.2.2
 pony>=0.7.16
-waitress>=2.1.1
+waitress>=2.1.2
 Flask-Caching>=2.0.1
 Flask-Compress>=1.12
-Flask-Limiter>=2.5.0
+Flask-Limiter>=2.6.2
 bokeh>=2.4.3

WebHostLib/static/assets/lttp-tracker.js

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

WebHostLib/static/assets/player-settings.js

@@ -102,9 +102,15 @@ const buildOptionsTable = (settings, romOpts = false) => {
     // td Left
     const tdl = document.createElement('td');
     const label = document.createElement('label');
+    label.textContent = `${settings[setting].displayName}: `;
     label.setAttribute('for', setting);
-    label.setAttribute('data-tooltip', settings[setting].description);
+
-    label.innerText = `${settings[setting].displayName}:`;
+    const questionSpan = document.createElement('span');
+    questionSpan.classList.add('interactive');
+    questionSpan.setAttribute('data-tooltip', settings[setting].description);
+    questionSpan.innerText = '(?)';
+
+    label.appendChild(questionSpan);
     tdl.appendChild(label);
     tr.appendChild(tdl);
 

WebHostLib/static/assets/trackers/playerTracker.js

@@ -0,0 +1,82 @@
+window.addEventListener('load', () => {
+  // Reload tracker
+  const update = () => {
+    const room = document.getElementById('tracker-wrapper').getAttribute('data-tracker');
+
+    const request = new Request('/api/tracker/' + room);
+
+    fetch(request)
+    .then(response => response.json())
+    .then(data => {
+        // update locations blocks
+        for (const location of data.checked_locations) {
+            document.getElementById(location).classList.add('acquired');
+        }
+        // update totals checks done
+        let total_checks_ele = document.getElementById('total-checks');
+        const total_checks = document.getElementsByClassName('location').length;
+        let checks_done = data.checked_locations.length;
+        total_checks_ele.innerText = 'Total Checks Done: ' + checks_done + '/' + total_checks;
+        // update item and icons blocks
+        // update icons block
+        if (data.icons.length > 0) {
+            for (let item in data.icons) {
+                if (data.progressive_names.length > 0) {
+                    for (let item_category in data.progressive_names) {
+                        let i = 0;
+                        for (let current_item in current_name) {
+                            if (current_item === item) {
+                                let doc_item = document.getElementById(item_category)
+                                doc_item.children[0].src = data.icons[item];
+                                if (item in data.items_received) {
+                                    doc_item.children[0].classList.add('acquired');
+                                    doc_item.children[1].innerText = item_category;
+                                }
+                            }
+                        }
+                    }
+                } else {
+                    if (item in data.items_received) {
+                        let current_item = document.getElementById(item);
+                        current_item.children[0].classList.add('acquired');
+                        current_item.children[0].src = data.icons[item];
+                        current_item.children[1].innerText = item;
+                    }
+                }
+            }
+        } else {
+            for (const item in data.items_received) {
+                if (document.getElementById(item)) {
+                    let current_item = document.getElementById(item);
+                    current_item.innerText = item + data.items_received[item];
+                }
+            }
+        }
+    });
+    }
+
+    update()
+    setInterval(update, 30000);
+
+
+  // Collapsible regions section
+  const regions = document.getElementsByClassName('regions-column');
+  for (let i = 0; i < regions.length; i++) {
+    let region_name = regions[i].id;
+
+    const tab_header = document.getElementById(region_name+'-header');
+    const locations = document.getElementById(region_name+'-locations');
+    // toggle locations display
+    regions[i].addEventListener('click', function(event) {
+      if (tab_header.innerHTML.includes("▼")) {
+          locations.classList.remove('hidden');
+          // change header text
+          tab_header.innerHTML = tab_header.innerHTML.replace('▼', '▲');
+      } else {
+          locations.classList.add('hidden');
+          // change header text
+          tab_header.innerHTML = tab_header.innerHTML.replace('▲', '▼');
+      }
+    });
+  }
+});

WebHostLib/static/assets/trackers/zeldaKeysTracker.js

@@ -0,0 +1,82 @@
+window.addEventListener('load', () => {
+  // Reload tracker
+  const update = () => {
+    const room = document.getElementById('tracker-wrapper').getAttribute('data-tracker');
+
+    const request = new Request('/api/tracker/' + room);
+
+    fetch(request)
+    .then(response => response.json())
+    .then(data => {
+        // update locations blocks
+        for (const location of data.checked_locations) {
+            document.getElementById(location).classList.add('acquired');
+        }
+        // update totals checks done
+        let total_checks_ele = document.getElementById('total-checks');
+        const total_checks = document.getElementsByClassName('location').length;
+        let checks_done = data.checked_locations.length;
+        total_checks_ele.innerText = 'Total Checks Done: ' + checks_done + '/' + total_checks;
+        // update item and icons blocks
+        // update icons block
+        if (data.icons.length > 0) {
+            for (let item in data.icons) {
+                if (data.progressive_names.length > 0) {
+                    for (let item_category in data.progressive_names) {
+                        let i = 0;
+                        for (let current_item in current_name) {
+                            if (current_item === item) {
+                                let doc_item = document.getElementById(item_category)
+                                doc_item.children[0].src = data.icons[item];
+                                if (item in data.items_received) {
+                                    doc_item.children[0].classList.add('acquired');
+                                    doc_item.children[1].innerText = item_category;
+                                }
+                            }
+                        }
+                    }
+                } else {
+                    if (item in data.items_received) {
+                        let current_item = document.getElementById(item);
+                        current_item.children[0].classList.add('acquired');
+                        current_item.children[0].src = data.icons[item];
+                        current_item.children[1].innerText = item;
+                    }
+                }
+            }
+        } else {
+            for (const item in data.items_received) {
+                if (document.getElementById(item)) {
+                    let current_item = document.getElementById(item);
+                    current_item.innerText = item + data.items_received[item];
+                }
+            }
+        }
+    });
+    }
+
+    update()
+    setInterval(update, 30000);
+
+
+  // Collapsible regions section
+  const regions = document.getElementsByClassName('regions-column');
+  for (let i = 0; i < regions.length; i++) {
+    let region_name = regions[i].id;
+
+    const tab_header = document.getElementById(region_name+'-header');
+    const locations = document.getElementById(region_name+'-locations');
+    // toggle locations display
+    regions[i].addEventListener('click', function(event) {
+      if (tab_header.innerHTML.includes("▼")) {
+          locations.classList.remove('hidden');
+          // change header text
+          tab_header.innerHTML = tab_header.innerHTML.replace('▼', '▲');
+      } else {
+          locations.classList.add('hidden');
+          // change header text
+          tab_header.innerHTML = tab_header.innerHTML.replace('▲', '▼');
+      }
+    });
+  }
+});

WebHostLib/static/styles/generate.css

@@ -56,7 +56,3 @@
 #file-input{
     display: none;
 }
-
-.interactive{
-    color: #ffef00;
-}

WebHostLib/static/styles/globalStyles.css

@@ -105,3 +105,7 @@ h5, h6{
     margin-bottom: 20px;
     background-color: #ffff00;
 }
+
+.interactive{
+    color: #ffef00;
+}

WebHostLib/static/styles/tooltip.css

@@ -14,7 +14,6 @@ give it one of the following classes: tooltip-left, tooltip-right, tooltip-top,
 /* Base styles for the element that has a tooltip */
 [data-tooltip], .tooltip {
 	position: relative;
-	cursor: pointer;
 }
 
 /* Base styles for the entire tooltip */
@@ -55,14 +54,15 @@ give it one of the following classes: tooltip-left, tooltip-right, tooltip-top,
 
 /** Content styles */
 .tooltip:after, [data-tooltip]:after {
+	width: 260px;
 	z-index: 10000;
 	padding: 8px;
-	width: 160px;
     border-radius: 4px;
 	background-color: #000;
 	background-color: hsla(0, 0%, 20%, 0.9);
 	color: #fff;
 	content: attr(data-tooltip);
+	white-space: pre-wrap;
 	font-size: 14px;
 	line-height: 1.2;
 }

WebHostLib/static/styles/trackers/playerTracker.css

@@ -0,0 +1,150 @@
+/* CSS Overrides */
+.dirt-wrapper{
+    background-color: #897249;
+}
+
+.dirt-wrapper h1{}
+
+.grass-wrapper{
+    background-color: #3fb24a;
+}
+
+.grass-wrapper h1{}
+
+.grassFlowers-wrapper{
+    background-color: #3fb24a;
+}
+
+.grassFlowers-wrapper h1{}
+
+.ice-wrapper{
+    background-color: #afe0ef;
+}
+
+.ice-wrapper h1{}
+
+.jungle-wrapper{
+    background-color: #2a7808;
+}
+
+.jungle-wrapper h1{}
+
+.ocean-wrapper{
+    background-color: #3667b1;
+}
+
+.ocean-wrapper h1{}
+
+.partyTime-wrapper{
+    background-color: #3a0f69;
+    color: #ffffff;
+}
+
+.partyTime-wrapper h1{}
+
+
+/* Actual Styles */
+h1 {
+    font-size: 20px;
+    color: #ffffff;
+    padding: 5px;
+    text-align: center;
+    text-shadow: 1px 1px black;
+}
+
+h2 {
+    padding: 8px;
+}
+
+#player-keys-tracker{
+    width: 600px;
+}
+
+#items-container{
+    display: flex;
+    flex-direction: row;
+    flex-wrap: wrap;
+    justify-content: space-evenly;
+    padding: 5px;
+}
+
+#items-container div{
+    margin: 0;
+    padding: 0;
+}
+
+.image-container{
+    display: absolute;
+    height: 75px;
+    width: 75px;
+}
+
+.bottom-text{
+    position: relative;
+    align-items: bottom;
+    text-align: center;
+}
+
+.icon{
+    height: 100%;
+    position: relative;
+    left: 15px;
+    max-width: 45px;
+    max-height: 45px;
+    filter: grayscale(100%) contrast(75%) brightness(40%);
+}
+
+.icon.acquired{
+    filter: none;
+}
+
+.total-checks{
+    text-align: center;
+    padding: 5px;
+    font-size: 18px;
+}
+
+.locations-container{
+    display: grid;
+    grid-template-columns: repeat(2, 1fr);
+    gap: 5px;
+    margin-left: 50px;
+    margin-right: 50px;
+}
+
+.location.acquired{
+    text-decoration: line-through;
+    filter: none;
+}
+
+.regions-container{
+    display: flex;
+    flex-direction: column;
+    flex-wrap: wrap;
+    justify-content: space-evenly;
+    padding: 5px;
+    text-align: center;
+}
+
+.regions-header{
+    font-size: 18px;
+    padding: 15px;
+    cursor: pointer;
+    text-align: center;
+}
+
+.hidden{
+    display: none;
+}
+
+.button-link{
+    display: block;
+    width: 100%;
+    height: 30px;
+    text-align: center;
+    text-decoration: none;
+    line-height: 30px;
+    background-color: lightgrey;
+    cursor: pointer;
+    color: inherit;
+}

WebHostLib/static/styles/trackers/tracker.css

@@ -51,6 +51,17 @@ table.dataTable{
     color: #000000;
 }
 
+table.dataTable img.icon{
+    height: 100%;
+    max-width: 60px;
+    max-height: 60px;
+    filter: grayscale(100%) contrast(75%) brightness(50%);
+}
+
+table.dataTable img.acquired{
+    filter: none;
+}
+
 table.dataTable thead{
     font-family: LexendDeca-Regular, sans-serif;
 }

WebHostLib/stats.py

@@ -18,15 +18,16 @@ from .models import Room
 PLOT_WIDTH = 600
 
 
-def get_db_data() -> typing.Tuple[typing.Dict[str, int], typing.Dict[datetime.date, typing.Dict[str, int]]]:
+def get_db_data(known_games: str) -> typing.Tuple[typing.Dict[str, int], typing.Dict[datetime.date, typing.Dict[str, int]]]:
     games_played = defaultdict(Counter)
     total_games = Counter()
     cutoff = date.today()-timedelta(days=30)
     room: Room
     for room in select(room for room in Room if room.creation_time >= cutoff):
         for slot in room.seed.slots:
-            total_games[slot.game] += 1
+            if slot.game in known_games:
-            games_played[room.creation_time.date()][slot.game] += 1
+                total_games[slot.game] += 1
+                games_played[room.creation_time.date()][slot.game] += 1
     return total_games, games_played
 
 
@@ -73,10 +74,12 @@ def create_game_played_figure(all_games_data: typing.Dict[datetime.date, typing.
 @app.route('/stats')
 @cache.memoize(timeout=60 * 60)  # regen once per hour should be plenty
 def stats():
+    from worlds import network_data_package
+    known_games = set(network_data_package["games"])
     plot = figure(title="Games Played Per Day", x_axis_type='datetime', x_axis_label="Date",
                   y_axis_label="Games Played", sizing_mode="scale_both", width=PLOT_WIDTH, height=500)
 
-    total_games, games_played = get_db_data()
+    total_games, games_played = get_db_data(known_games)
     days = sorted(games_played)
 
     color_palette = get_color_palette(len(total_games))

WebHostLib/templates/generate.html

@@ -41,12 +41,11 @@
                             <tbody>
                                 <tr>
                                     <td>
-                                        <label for="forfeit_mode">Forfeit Permission:</label>
+                                        <label for="forfeit_mode">Forfeit Permission:
-                                        <span
+                                            <span class="interactive" data-tooltip="A forfeit releases all remaining items from the locations in your world.">
-                                                class="interactive"
+                                                (?)
-                                                data-tooltip="A forfeit releases all remaining items from the locations
+                                            </span>
-                                                in your world.">(?)
+                                        </label>
-                                        </span>
                                     </td>
                                     <td>
                                         <select name="forfeit_mode" id="forfeit_mode">
@@ -63,12 +62,11 @@
 
                                 <tr>
                                     <td>
-                                        <label for="collect_mode">Collect Permission:</label>
+                                        <label for="collect_mode">Collect Permission:
-                                        <span
+                                            <span class="interactive" data-tooltip="A collect releases all of your remaining items to you from across the multiworld.">
-                                                class="interactive"
+                                                (?)
-                                                data-tooltip="A collect releases all of your remaining items to you
+                                            </span>
-                                                from across the multiworld.">(?)
+                                        </label>
-                                        </span>
                                     </td>
                                     <td>
                                         <select name="collect_mode" id="collect_mode">
@@ -85,12 +83,11 @@
 
                                 <tr>
                                     <td>
-                                        <label for="remaining_mode">Remaining Permission:</label>
+                                        <label for="remaining_mode">Remaining Permission:
-                                        <span
+                                            <span class="interactive" data-tooltip="Remaining lists all items still in your world by name only.">
-                                            class="interactive"
+                                                (?)
-                                            data-tooltip="Remaining lists all items still in your world by name only."
+                                            </span>
-                                        >(?)
+                                        </label>
-                                        </span>
                                     </td>
                                     <td>
                                         <select name="remaining_mode" id="remaining_mode">
@@ -106,11 +103,11 @@
                                 </tr>
                                 <tr>
                                     <td>
-                                        <label for="item_cheat">Item Cheat:</label>
+                                        <label for="item_cheat">Item Cheat:
-                                        <span
+                                            <span class="interactive" data-tooltip="Allows players to use the !getitem command.">
-                                                class="interactive"
+                                                (?)
-                                                data-tooltip="Allows players to use the !getitem command.">(?)
+                                            </span>
-                                        </span>
+                                        </label>
                                     </td>
                                     <td>
                                         <select name="item_cheat" id="item_cheat">
@@ -131,12 +128,11 @@
                                 <tbody>
                                     <tr>
                                         <td>
-                                            <label for="hint_cost"> Hint Cost:</label>
+                                            <label for="hint_cost"> Hint Cost:
-                                            <span
+                                                <span class="interactive" data-tooltip="After gathering this many checks, players can !hint <itemname> to get the location of that hint item.">
-                                                class="interactive"
+                                                    (?)
-                                                data-tooltip="After gathering this many checks, players can !hint <itemname>
+                                                </span>
-                                                to get the location of that hint item.">(?)
+                                            </label>
-                                            </span>
                                         </td>
                                         <td>
                                             <select name="hint_cost" id="hint_cost">
@@ -150,11 +146,11 @@
                                     </tr>
                                     <tr>
                                         <td>
-                                            <label for="server_password">Server Password:</label>
+                                            <label for="server_password">Server Password:
-                                            <span
+                                                <span class="interactive" data-tooltip="Allows for issuing of server console commands from any text client or in-game client using the !admin command.">
-                                                class="interactive"
+                                                    (?)
-                                                data-tooltip="Allows for issuing of server console commands from any text client or in-game client using the !admin command.">(?)
+                                                </span>
-                                            </span>
+                                            </label>
                                         </td>
                                         <td>
                                             <input id="server_password" name="server_password">
@@ -162,23 +158,22 @@
                                     </tr>
                                     <tr>
                                         <td>
-                                            <label for="plando_options">Plando Options:</label>
+                                            Plando Options:
-                                            <span
+                                            <span class="interactive" data-tooltip="Allows players to plan some of the randomization. See the 'Archipelago Plando Guide' in 'Setup Guides' for more information.">
-                                                class="interactive"
+                                                (?)
-                                                data-tooltip="Allows players to plan some of the randomization. See the 'Archipelago Plando Guide' in 'Setup Guides' for more information.">(?)
                                             </span>
                                         </td>
                                         <td>
-                                            <input type="checkbox" name="plando_bosses" value="bosses" checked>
+                                            <input type="checkbox" id="plando_bosses" name="plando_bosses" value="bosses" checked>
                                             <label for="plando_bosses">Bosses</label><br>
 
-                                            <input type="checkbox" name="plando_items" value="items" checked>
+                                            <input type="checkbox" id="plando_items" name="plando_items" value="items" checked>
                                             <label for="plando_items">Items</label><br>
 
-                                            <input type="checkbox" name="plando_connections" value="connections" checked>
+                                            <input type="checkbox" id="plando_connections" name="plando_connections" value="connections" checked>
                                             <label for="plando_connections">Connections</label><br>
 
-                                            <input type="checkbox" name="plando_texts" value="texts" checked>
+                                            <input type="checkbox" id="plando_texts" name="plando_texts" value="texts" checked>
                                             <label for="plando_texts">Text</label>
                                         </td>
                                     </tr>

WebHostLib/templates/hostRoom.html

@@ -2,6 +2,7 @@
 {% import "macros.html" as macros %}
 {% block head %}
     <title>Multiworld {{ room.id|suuid }}</title>
+    {% if should_refresh %}<meta http-equiv="refresh" content="2">{% endif %}
     <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename="styles/hostRoom.css") }}"/>
 {% endblock %}
 

WebHostLib/templates/islandFooter.html

@@ -6,8 +6,6 @@
             -
             <a href="https://github.com/ArchipelagoMW/Archipelago">Source Code</a>
             -
-            <a href="https://github.com/ArchipelagoMW/Archipelago/wiki">Wiki</a>
-            -
             <a href="https://github.com/ArchipelagoMW/Archipelago/graphs/contributors">Contributors</a>
             -
             <a href="https://github.com/ArchipelagoMW/Archipelago/issues">Bug Report</a>

WebHostLib/templates/lttpTracker.html

@@ -1,86 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <title>{{ player_name }}&apos;s Tracker</title>
-    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename="styles/globalStyles.css") }}"/>
-    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename="styles/lttp-tracker.css") }}"/>
-    <script type="application/ecmascript" src="{{ url_for('static', filename="assets/lttp-tracker.js") }}"></script>
-</head>
-
-<body>
-    <div id="player-tracker-wrapper" data-tracker="{{ room.tracker|suuid }}">
-        <table id="inventory-table">
-            <tr>
-                <td><img src="{{ bow_url }}" class="{{ 'acquired' if bow_acquired }}" /></td>
-                <td><img src="{{ icons["Blue Boomerang"] }}" class="{{ 'acquired' if 'Blue Boomerang' in acquired_items }}" /></td>
-                <td><img src="{{ icons["Red Boomerang"] }}" class="{{ 'acquired' if 'Red Boomerang' in acquired_items }}" /></td>
-                <td><img src="{{ icons["Hookshot"] }}" class="{{ 'acquired' if 'Hookshot' in acquired_items }}" /></td>
-                <td><img src="{{ icons["Magic Powder"] }}" class="powder-fix {{ 'acquired' if 'Magic Powder' in acquired_items }}" /></td>
-            </tr>
-            <tr>
-                <td><img src="{{ icons["Fire Rod"] }}" class="{{ 'acquired' if "Fire Rod" in acquired_items }}" /></td>
-                <td><img src="{{ icons["Ice Rod"] }}" class="{{ 'acquired' if "Ice Rod" in acquired_items }}" /></td>
-                <td><img src="{{ icons["Bombos"] }}" class="{{ 'acquired' if "Bombos" in acquired_items }}" /></td>
-                <td><img src="{{ icons["Ether"] }}" class="{{ 'acquired' if "Ether" in acquired_items }}" /></td>
-                <td><img src="{{ icons["Quake"] }}" class="{{ 'acquired' if "Quake" in acquired_items }}" /></td>
-            </tr>
-            <tr>
-                <td><img src="{{ icons["Lamp"] }}" class="{{ 'acquired' if "Lamp" in acquired_items }}" /></td>
-                <td><img src="{{ icons["Hammer"] }}" class="{{ 'acquired' if "Hammer" in acquired_items }}" /></td>
-                <td><img src="{{ icons["Flute"] }}" class="{{ 'acquired' if "Flute" in acquired_items }}" /></td>
-                <td><img src="{{ icons["Bug Catching Net"] }}" class="{{ 'acquired' if "Bug Catching Net" in acquired_items }}" /></td>
-                <td><img src="{{ icons["Book of Mudora"] }}" class="{{ 'acquired' if "Book of Mudora" in acquired_items }}" /></td>
-            </tr>
-            <tr>
-                <td><img src="{{ icons["Bottle"] }}" class="{{ 'acquired' if "Bottle" in acquired_items }}" /></td>
-                <td><img src="{{ icons["Cane of Somaria"] }}" class="{{ 'acquired' if "Cane of Somaria" in acquired_items }}" /></td>
-                <td><img src="{{ icons["Cane of Byrna"] }}" class="{{ 'acquired' if "Cane of Byrna" in acquired_items }}" /></td>
-                <td><img src="{{ icons["Cape"] }}" class="{{ 'acquired' if "Cape" in acquired_items }}" /></td>
-                <td><img src="{{ icons["Magic Mirror"] }}" class="{{ 'acquired' if "Magic Mirror" in acquired_items }}" /></td>
-            </tr>
-            <tr>
-                <td><img src="{{ icons["Pegasus Boots"] }}" class="{{ 'acquired' if "Pegasus Boots" in acquired_items }}" /></td>
-                <td><img src="{{ glove_url }}" class="{{ 'acquired' if glove_acquired }}" /></td>
-                <td><img src="{{ icons["Flippers"] }}" class="{{ 'acquired' if "Flippers" in acquired_items }}" /></td>
-                <td><img src="{{ icons["Moon Pearl"] }}" class="{{ 'acquired' if "Moon Pearl" in acquired_items }}" /></td>
-                <td><img src="{{ icons["Mushroom"] }}" class="{{ 'acquired' if "Mushroom" in acquired_items }}" /></td>
-            </tr>
-            <tr>
-                <td><img src="{{ sword_url }}" class="{{ 'acquired' if sword_acquired }}" /></td>
-                <td><img src="{{ shield_url }}" class="{{ 'acquired' if shield_acquired }}" /></td>
-                <td><img src="{{ mail_url }}" class="acquired" /></td>
-                <td><img src="{{ icons["Shovel"] }}" class="{{ 'acquired' if "Shovel" in acquired_items }}" /></td>
-                <td><img src="{{ icons["Triforce"] }}" class="{{ 'acquired' if "Triforce" in acquired_items }}" /></td>
-            </tr>
-        </table>
-        <table id="location-table">
-            <tr>
-                <th></th>
-                <th class="counter"><img src="{{ icons["Chest"] }}" /></th>
-                {% if key_locations and "Universal" not in key_locations %}
-                    <th class="counter"><img src="{{ icons["Small Key"] }}" /></th>
-                {% endif %}
-                {% if big_key_locations %}
-                    <th><img src="{{ icons["Big Key"] }}" /></th>
-                {% endif %}
-            </tr>
-            {% for area in sp_areas %}
-                <tr>
-                    <td>{{ area }}</td>
-                    <td class="counter">{{ checks_done[area] }} / {{ checks_in_area[area] }}</td>
-                    {% if key_locations and "Universal" not in key_locations %}
-                        <td class="counter">
-                            {{ inventory[small_key_ids[area]] if area in key_locations else '—' }}
-                        </td>
-                    {% endif %}
-                    {% if big_key_locations %}
-                        <td>
-                            {{ '✔' if area in big_key_locations and inventory[big_key_ids[area]] else ('—' if area not in big_key_locations else '') }}
-                        </td>
-                    {% endif %}
-                </tr>
-            {% endfor %}
-        </table>
-    </div>
-</body>
-</html>

WebHostLib/templates/macros.html

@@ -50,7 +50,7 @@
                             No file to download for this game.
                         {% endif %}
                     </td>
-                    <td><a href="{{ url_for("getPlayerTracker", tracker=room.tracker, tracked_team=0, tracked_player=patch.player_id) }}">Tracker</a></td>
+                    <td><a href="{{ url_for("get_player_tracker", tracker=room.tracker, tracked_team=0, tracked_player=patch.player_id) }}">Tracker</a></td>
                 </tr>
             {% endfor %}
             </tbody>

WebHostLib/templates/supportedGames.html

@@ -1,7 +1,7 @@
 {% extends 'pageWrapper.html' %}
 
 {% block head %}
-    <title>Player Settings</title>
+    <title>Supported Games</title>
     <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename="styles/markdown.css") }}" />
     <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename="styles/supportedGames.css") }}" />
 {% endblock %}
@@ -10,7 +10,8 @@
     {% include 'header/oceanHeader.html' %}
     <div id="games" class="markdown">
         <h1>Currently Supported Games</h1>
-        {% for game_name, world in worlds.items() | sort(attribute=0) %}
+        {% for game_name in worlds | title_sorted %}
+        {% set world = worlds[game_name] %}
         <h2>{{ game_name }}</h2>
         <p>
             {{ world.__doc__ | default("No description provided.", true) }}<br />

WebHostLib/templates/trackers/genericTracker.html

@@ -2,9 +2,9 @@
 {% block head %}
     {{ super() }}
     <title>{{ player_name }}&apos;s Tracker</title>
-    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename="styles/tracker.css") }}"/>
+    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename="styles/trackers/tracker.css") }}"/>
     <script type="application/ecmascript" src="{{ url_for('static', filename="assets/jquery.scrollsync.js") }}"></script>
-    <script type="application/ecmascript" src="{{ url_for('static', filename="assets/tracker.js") }}"></script>
+    <script type="application/ecmascript" src="{{ url_for('static', filename="assets/trackers/tracker.js") }}"></script>
 {% endblock %}
 
 {% block body %}
@@ -13,6 +13,9 @@
         <div id="tracker-header-bar">
             <input placeholder="Search" id="search"/>
             <span class="info">This tracker will automatically update itself periodically.</span>
+            <a href="/tracker/{{ room.tracker|suuid }}/{{ team }}/{{ player }}" class="button-link">
+                Go to Styled Tracker
+            </a>
         </div>
             <div class="table-wrapper">
                 <table class="table non-unique-item-table">

WebHostLib/templates/trackers/minecraftTracker.html

@@ -2,8 +2,8 @@
 <html lang="en">
 <head>
     <title>{{ player_name }}&apos;s Tracker</title>
-    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename='styles/minecraftTracker.css') }}"/>
+    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename='styles/trackers/minecraftTracker.css') }}"/>
-    <script type="application/ecmascript" src="{{ url_for('static', filename='assets/minecraftTracker.js') }}"></script>
+    <script type="application/ecmascript" src="{{ url_for('static', filename='assets/trackers/minecraftTracker.js') }}"></script>
     <link rel="stylesheet" media="screen" href="https://fontlibrary.org//face/minecraftia" type="text/css"/>
 </head>
 

WebHostLib/templates/trackers/multiworldTracker.html

@@ -2,9 +2,9 @@
 {% block head %}
     {{ super() }}
     <title>Multiworld Tracker</title>
-    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename="styles/tracker.css") }}"/>
+    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename="styles/trackers/tracker.css") }}"/>
     <script type="application/ecmascript" src="{{ url_for('static', filename="assets/jquery.scrollsync.js") }}"></script>
-    <script type="application/ecmascript" src="{{ url_for('static', filename="assets/tracker.js") }}"></script>
+    <script type="application/ecmascript" src="{{ url_for('static', filename="assets/trackers/tracker.js") }}"></script>
 {% endblock %}
 
 {% block body %}
@@ -44,7 +44,7 @@
                         <tbody>
                             {%- for player, items in players.items() -%}
                                 <tr>
-                                    <td><a href="{{ url_for("getPlayerTracker", tracker=room.tracker,
+                                    <td><a href="{{ url_for("get_player_tracker", tracker=room.tracker,
                                     tracked_team=team, tracked_player=player)}}">{{ loop.index }}</a></td>
                                     {%- if (team, loop.index) in video -%}
                                         {%- if video[(team, loop.index)][0] == "Twitch" -%}
@@ -121,7 +121,7 @@
                         <tbody>
                             {%- for player, checks in players.items() -%}
                                 <tr>
-                                    <td><a href="{{ url_for("getPlayerTracker", tracker=room.tracker,
+                                    <td><a href="{{ url_for("get_player_tracker", tracker=room.tracker,
                                     tracked_team=team, tracked_player=player)}}">{{ loop.index }}</a></td>
                                     <td>{{ player_names[(team, loop.index)]|e }}</td>
                                     {%- for area in ordered_areas -%}

WebHostLib/templates/trackers/playerTracker.html

@@ -0,0 +1,99 @@
+{% block head %}
+    <!--suppress XmlDuplicatedId -->
+<title>{{ player_name }}&apos;s Tracker</title>
+    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename='styles/trackers/playerTracker.css') }}"/>
+    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename='styles/tooltip.css') }}"/>
+    <script type="application/ecmascript" src="{{ url_for('static', filename='assets/trackers/playerTracker.js') }}"></script>
+{% endblock %}
+
+{% block body %}
+
+<div id="tracker-wrapper" class="{{ theme }}-wrapper" data-tracker="{{ room.tracker|suuid }}/{{ team }}/{{ player }}">
+    <a href="/generic_tracker/{{ room.tracker|suuid }}/{{ team }}/{{ player }}" class="button-link">
+        Go to Generic Tracker
+    </a>
+
+    {% if icons %}
+
+    {% block icons_render %}
+
+    <h1>Items</h1>
+    <div id="items-container">
+        {%- for item in icons %}
+        <div class="image-container tooltip" id="{{ item }}" data-tooltip="{{ item }}">
+            <img
+                src="{{ icons[item] }}"
+                class="icon tooltip {{ 'acquired' if item in received_items }}"
+            />
+        </div>
+        {%- endfor %}
+    </div>
+
+    {% endblock %}
+
+    {% else %}
+
+    {% block item_names_render %}
+    <h1 class="items-header">Items</h1>
+    <div class="items-container">
+        {%- for item in received_items|sort -%}
+        <div class="item" id="{{ item }}">
+            {{ item }}
+            {% if all_progression_items[item] > 1 %}
+            {{ received_items[item] }}
+            {% else %}
+            ✔
+            {% endif %}
+        </div>
+        {%- endfor -%}
+    </div>
+
+    {% endblock %}
+
+    {% endif %}
+
+
+{# div for total checks done as percentage. Probably needs to be put somewhere else but I liked how it looked here #}
+    <div class="total-checks" id="total-checks">
+        Total Checks Done: {{ checked_locations|length }}/{{ locations|length }}
+    </div>
+
+
+    {% if regions %}
+
+    {% block regions_render %}
+
+    <div class="regions-container">
+        {% for region in regions %}
+        <div class="regions-column" id="{{ region }}">
+            <h1 class="regions-header" id="{{ region }}-header">{{ region }} ▼ {{ checks_done[region]|length }} / {{ regions[region]|length }}</h1>
+                <div class="location-column hidden" id="{{ region }}-locations">
+                    {%- for location in regions[region] %}
+                        <div class="location {{ 'acquired' if location in checked_locations }}" id="{{ location }}">{{ location }}</div>
+                    {%- endfor %}
+                </div>
+        </div>
+        {% endfor %}
+    </div>
+
+    {% endblock %}
+
+    {% else %}
+
+    {% block locations_render %}
+
+    <h1>Locations</h1>
+    <div class="locations-container" id="locations-container">
+        {% for location in locations %}
+        <div class="location {{ 'acquired' if name in checked_locations }}" id="{{ location }}">
+            {{ location }}
+        </div>
+        {% endfor %}
+    </div>
+
+    {% endblock %}
+
+    {% endif %}
+</div>
+
+{% endblock %}

WebHostLib/templates/trackers/supermetroidTracker.html

@@ -2,8 +2,8 @@
 <html lang="en">
 <head>
     <title>{{ player_name }}&apos;s Tracker</title>
-    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename='styles/supermetroidTracker.css') }}"/>
+    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename='styles/trackers/supermetroidTracker.css') }}"/>
-    <script type="application/ecmascript" src="{{ url_for('static', filename='assets/supermetroidTracker.js') }}"></script>
+    <script type="application/ecmascript" src="{{ url_for('static', filename='assets/trackers/supermetroidTracker.js') }}"></script>
 </head>
 
 <body>

WebHostLib/templates/trackers/timespinnerTracker.html

@@ -2,8 +2,8 @@
 <html lang="en">
 <head>
     <title>{{ player_name }}&apos;s Tracker</title>
-    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename='styles/timespinnerTracker.css') }}"/>
+    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename='styles/trackers/timespinnerTracker.css') }}"/>
-    <script type="application/ecmascript" src="{{ url_for('static', filename='assets/timespinnerTracker.js') }}"></script>
+    <script type="application/ecmascript" src="{{ url_for('static', filename='assets/trackers/timespinnerTracker.js') }}"></script>
 </head>
 
 <body>

WebHostLib/templates/trackers/zeldaKeysTracker.html

@@ -0,0 +1,77 @@
+{% block head %}
+    <!--suppress XmlDuplicatedId -->
+    <title>{{ player_name }}&apos;s Keys Tracker</title>
+    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename='styles/trackers/playerTracker.css') }}"/>
+    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename='styles/tooltip.css') }}" />
+    <script type="application/ecmascript" src="{{ url_for('static', filename='assets/trackers/zeldaKeysTracker.js') }}"/></script>
+{% endblock %}
+
+{# this tracker is mostly similar to the generic player tracker but
+also adds a table with the key and checks counts for each region in the middle #}
+
+{% block body %}
+
+<div id="tracker-wrapper" class="{{ theme }}-wrapper" data-tracker="{{ room.tracker|suuid }}/{{ team }}/{{ player }}">
+    <a href="/generic_tracker/{{ room.tracker|suuid }}/{{ team }}/{{ player }}" class="button-link">
+        Go to Generic Tracker
+    </a>
+    <h1>Items</h1>
+    <div id="items-container">
+        {% for item in icons %}
+            {% if item not in ['Small Key', 'Big Key'] %}
+                <div class="image-container tooltip" id="{{ item }}" data-tooltip="{{ item }}">
+                    <img
+                        src="{{ icons[item] }}"
+                        class="icon tooltip {{ 'acquired' if item in received_items }}"
+                    />
+                </div>
+            {% endif %}
+        {% endfor %}
+    </div>
+
+        <div class="total-checks" id="total-checks">
+            Total Checks Done: {{ checked_locations|length }}/{{ locations|length }}
+        </div>
+
+        <table id="regions-column">
+            <tr class="keys-icons">
+                <td><img src="{{icons['Small Key']}}" class="icon tooltip acquired" id="small-key-icon"/></td>
+                <td><img src="{{icons['Big Key']}}" class="icon tooltip acquired" id="big-key-icon"/></td>
+                <td class="right-align">Total</td>
+            </tr>
+        {% for region in regions %}
+            <tr class="regions-column" id="{{ region }}">
+                <td id="{{ region }}-header">{{ region }} ▼</td>
+                {% if region in region_keys %}
+                    {%- if region_keys[region]|length > 1 %}
+                    <td class="smallkeys">{{ received_items[region_keys[region][0]] if region_keys[region][0] in received_items else '-' }}</td>
+                    <td class="bigkeys">{{ received_items[region_keys[region][1]] if region_keys[region][1] in received_items else '-' }}</td>
+                    {%- else %}
+                        {% if 'Small Key' in region_keys[region][0] %}
+                    <td class="smallkeys">{{ received_items[region_keys[region][0]] if region_keys[region][0] in received_items else '-' }}</td>
+                    <td class="bigkeys">-</td>
+                        {% else %}
+                    <td class="smallkeys">-</td>
+                    <td class="bigkeys">{{ received_items[region_keys[region][0]] if region_keys[region][0] in received_items else '-' }}</td>
+                        {% endif %}
+                    {%- endif%}
+                {% else %}
+                <td class="smallkeys">-</td>
+                <td class="bigkeys">-</td>
+                {% endif %}
+                <td class="counter">{{ checks_done[region]|length }} / {{ regions[region]|length }}</td>
+            </tr>
+            <tbody class="locations hidden" id="{{ region }}-locations">
+            {% for location in regions[region] %}
+                <tr>
+                    <td class="location {{ 'acquired' if location in checked_locations }}" id="{{ location }}">
+                    {{ location }}
+                    </td>
+                </tr>
+            {% endfor %}
+            </tbody>
+        {% endfor %}
+    </div>
+</div>
+
+{% endblock %}

WebHostLib/tracker.py

@@ -1,6 +1,6 @@
 import collections
 import typing
-from typing import Counter, Optional, Dict, Any, Tuple
+from typing import Counter, Optional, Dict, Any, Tuple, Set, List, TYPE_CHECKING
 
 from flask import render_template
 from werkzeug.exceptions import abort
@@ -11,9 +11,53 @@ from worlds.alttp import Items
 from WebHostLib import app, cache, Room
 from Utils import restricted_loads
 from worlds import lookup_any_item_id_to_name, lookup_any_location_id_to_name
+from worlds.AutoWorld import AutoWorldRegister
 from MultiServer import get_item_name_from_id, Context
 from NetUtils import SlotType
 
+
+class PlayerTracker:
+    """This class will create a basic 'prettier' tracker for each world using their themes automatically. This
+            can be overridden to customize how it will appear. Can provide icons and custom regions. The html used is also
+            a jinja template that can be overridden if you want your tracker to look different in certain aspects. To render
+            icons and regions add dictionaries to the relevant attributes of the tracker_info. To customize the layout of
+            your icons you can create a new html in your world and extend playerTracker.html and overwrite the icons_render
+            block then change the tracker_info template attribute to your template."""
+
+    template: str = 'playerTracker.html'
+    icons: Dict[str, str] = {}
+    progressive_items: List[str] = []
+    progressive_names: Dict[str, List[str]] = {}
+    regions: Dict[str, List[str]] = {}
+    checks_done: Dict[str, Set[str]] = {}
+    room: Any
+    team: int
+    player: int
+    name: str
+    all_locations: Set[str]
+    checked_locations: Set[str]
+    all_prog_items: Counter[str]
+    items_received: Counter[str]
+    received_prog_items: Counter[str]
+    slot_data: Dict[any, any]
+    theme: str
+
+    region_keys: Dict[str, str] = {}
+
+    def __init__(self, room: Any, team: int, player: int, name: str, all_locations: Set[str],
+                 checked_locations: set, all_progression_items: Counter[str], items_received: Counter[str],
+                 slot_data: Dict[any, any]):
+        self.room = room
+        self.team = team
+        self.player = player
+        self.name = name
+        self.all_locations = all_locations
+        self.checked_locations = checked_locations
+        self.all_prog_items = all_progression_items
+        self.items_received = items_received
+        self.slot_data = slot_data
+
+
 alttp_icons = {
     "Blue Shield": r"https://www.zeldadungeon.net/wiki/images/8/85/Fighters-Shield.png",
     "Red Shield": r"https://www.zeldadungeon.net/wiki/images/5/55/Fire-Shield.png",
@@ -288,7 +332,7 @@ def get_static_room_data(room: Room):
 
 @app.route('/tracker/<suuid:tracker>/<int:tracked_team>/<int:tracked_player>')
 @cache.memoize(timeout=60)  # multisave is currently created at most every minute
-def getPlayerTracker(tracker: UUID, tracked_team: int, tracked_player: int, want_generic: bool = False):
+def get_player_tracker(tracker: UUID, tracked_team: int, tracked_player: int, want_generic: bool = False):
     # Team and player must be positive and greater than zero
     if tracked_team < 0 or tracked_player < 1:
         abort(404)
@@ -297,13 +341,78 @@ def getPlayerTracker(tracker: UUID, tracked_team: int, tracked_player: int, want
     if not room:
         abort(404)
 
-    # Collect seed information and pare it down to a single player
+    player_tracker, multisave, inventory, seed_checks_in_area, lttp_checks_done, \
+        slot_data, games, player_name, display_icons = fill_tracker_data(room, tracked_team, tracked_player)
+
+    game_name = games[tracked_player]
+    # TODO move all games in game_specific_trackers to new system
+    if game_name in game_specific_trackers and not want_generic:
+        specific_tracker = game_specific_trackers.get(game_name, None)
+        return specific_tracker(multisave, room, player_tracker.all_locations, inventory, tracked_team, tracked_player,
+                                player_name, seed_checks_in_area, lttp_checks_done, slot_data[tracked_player])
+    elif game_name in AutoWorldRegister.world_types and not want_generic:
+        return render_template(
+            "trackers/" + player_tracker.template,
+            all_progression_items=player_tracker.all_prog_items,
+            player=tracked_player,
+            team=tracked_team,
+            room=player_tracker.room,
+            player_name=player_tracker.name,
+            checked_locations=sorted(player_tracker.checked_locations),
+            locations=sorted(player_tracker.all_locations),
+            theme=player_tracker.theme,
+            icons=display_icons,
+            regions=player_tracker.regions,
+            checks_done=player_tracker.checks_done,
+            region_keys=player_tracker.region_keys
+        )
+    else:
+        return __renderGenericTracker(multisave, room, player_tracker.all_locations, inventory, tracked_team, tracked_player, player_name, seed_checks_in_area, lttp_checks_done)
+
+
+@app.route('/generic_tracker/<suuid:tracker>/<int:tracked_team>/<int:tracked_player>')
+@cache.memoize(timeout=60)
+def get_generic_tracker(tracker: UUID, tracked_team: int, tracked_player: int):
+    return get_player_tracker(tracker, tracked_team, tracked_player, True)
+
+
+def get_tracker_icons_and_regions(player_tracker: PlayerTracker) -> Dict[str, str]:
+    """this function allows multiple icons to be used for the same item but it does require the world to submit both
+    a progressive_items list and the icons dict together"""
+    display_icons: Dict[str, str] = {}
+    if player_tracker.progressive_names and player_tracker.icons:
+        for item in player_tracker.progressive_items:
+            if item in player_tracker.progressive_names:
+                level = min(player_tracker.items_received[item], len(player_tracker.progressive_names[item]) - 1)
+                display_name = player_tracker.progressive_names[item][level]
+                if display_name in player_tracker.icons:
+                    display_icons[item] = player_tracker.icons[display_name]
+                else:
+                    display_icons[item] = player_tracker.icons[item]
+            else:
+                display_icons[item] = player_tracker.icons[item]
+    else:
+        if player_tracker.progressive_items and player_tracker.icons:
+            for item in player_tracker.progressive_items:
+                display_icons[item] = player_tracker.icons[item]
+
+    if player_tracker.regions:
+        for region in player_tracker.regions:
+            for location in region:
+                if location in player_tracker.checked_locations:
+                    player_tracker.checks_done.setdefault(region, set()).add(location)
+
+    return display_icons
+
+
+def fill_tracker_data(room: Room, tracked_team: int, tracked_player: int) -> Tuple:
+    """Collect seed information and pare it down to a single player"""
     locations, names, use_door_tracker, seed_checks_in_area, player_location_to_area, \
         precollected_items, games, slot_data, groups = get_static_room_data(room)
     player_name = names[tracked_team][tracked_player - 1]
     location_to_area = player_location_to_area[tracked_player]
     inventory = collections.Counter()
-    checks_done = {loc_name: 0 for loc_name in default_locations}
+    lttp_checks_done = {loc_name: 0 for loc_name in default_locations}
 
     # Add starting items to inventory
     starting_items = precollected_items[tracked_player]
@@ -321,6 +430,7 @@ def getPlayerTracker(tracker: UUID, tracked_team: int, tracked_player: int, want
         if tracked_player in group_members:
             slots_aimed_at_player.add(group_id)
 
+    checked_locations = set()
     # Add items to player inventory
     for (ms_team, ms_player), locations_checked in multisave.get("location_checks", {}).items():
         # Skip teams and players not matching the request
@@ -332,383 +442,52 @@ def getPlayerTracker(tracker: UUID, tracked_team: int, tracked_player: int, want
                     item, recipient, flags = player_locations[location]
                     if recipient in slots_aimed_at_player:  # a check done for the tracked player
                         attribute_item_solo(inventory, item)
+
                     if ms_player == tracked_player:  # a check done by the tracked player
-                        checks_done[location_to_area[location]] += 1
+                        lttp_checks_done[location_to_area[location]] += 1
-                        checks_done["Total"] += 1
+                        lttp_checks_done["Total"] += 1
-    specific_tracker = game_specific_trackers.get(games[tracked_player], None)
+                        checked_locations.add(lookup_any_location_id_to_name[location])
-    if specific_tracker and not want_generic:
+
-        return specific_tracker(multisave, room, locations, inventory, tracked_team, tracked_player, player_name,
+    prog_items = collections.Counter
-                                seed_checks_in_area, checks_done, slot_data[tracked_player])
+    all_location_names = set()
-    else:
+
-        return __renderGenericTracker(multisave, room, locations, inventory, tracked_team, tracked_player, player_name,
+    all_location_names = {lookup_any_location_id_to_name[id] for id in locations[tracked_player]}
-                                      seed_checks_in_area, checks_done)
+    prog_items = collections.Counter()
+    for player in locations:
+        for location in locations[player]:
+            item, recipient, flags = locations[player][location]
+            if recipient == player:
+                if flags & 1:
+                    item_name = lookup_any_item_id_to_name[item]
+                    prog_items[item_name] += 1
+
+    items_received = collections.Counter()
+    for id in inventory:
+        items_received[lookup_any_item_id_to_name[id]] = inventory[id]
+
+    player_tracker = PlayerTracker(
+        room,
+        tracked_team,
+        tracked_player,
+        player_name,
+        all_location_names,
+        checked_locations,
+        prog_items,
+        items_received,
+        slot_data[tracked_player]
+    )
+
+    # grab webworld and apply its theme to the tracker
+    webworld = AutoWorldRegister.world_types[games[tracked_player]].web
+    player_tracker.theme = webworld.theme
+    # allow the world to add information to the tracker class
+    webworld.modify_tracker(player_tracker)
+    display_icons = get_tracker_icons_and_regions(player_tracker)
+
+    return player_tracker, multisave, inventory, seed_checks_in_area, lttp_checks_done, slot_data, games, player_name, display_icons
 
 
-@app.route('/generic_tracker/<suuid:tracker>/<int:tracked_team>/<int:tracked_player>')
+def __renderTimespinnerTracker(multisave: Dict[str, Any], room: Room, locations: set,
-def get_generic_tracker(tracker: UUID, tracked_team: int, tracked_player: int):
-    return getPlayerTracker(tracker, tracked_team, tracked_player, True)
-
-
-def __renderAlttpTracker(multisave: Dict[str, Any], room: Room, locations: Dict[int, Dict[int, Tuple[int, int, int]]],
-                         inventory: Counter, team: int, player: int, player_name: str,
-                         seed_checks_in_area: Dict[int, Dict[str, int]], checks_done: Dict[str, int], slot_data: Dict) -> str:
-
-    # Note the presence of the triforce item
-    game_state = multisave.get("client_game_state", {}).get((team, player), 0)
-    if game_state == 30:
-        inventory[106] = 1  # Triforce
-
-    # Progressive items need special handling for icons and class
-    progressive_items = {
-        "Progressive Sword": 94,
-        "Progressive Glove": 97,
-        "Progressive Bow": 100,
-        "Progressive Mail": 96,
-        "Progressive Shield": 95,
-    }
-    progressive_names = {
-        "Progressive Sword": [None, 'Fighter Sword', 'Master Sword', 'Tempered Sword', 'Golden Sword'],
-        "Progressive Glove": [None, 'Power Glove', 'Titan Mitts'],
-        "Progressive Bow": [None, "Bow", "Silver Bow"],
-        "Progressive Mail": ["Green Mail", "Blue Mail", "Red Mail"],
-        "Progressive Shield": [None, "Blue Shield", "Red Shield", "Mirror Shield"]
-    }
-
-    # Determine which icon to use
-    display_data = {}
-    for item_name, item_id in progressive_items.items():
-        level = min(inventory[item_id], len(progressive_names[item_name]) - 1)
-        display_name = progressive_names[item_name][level]
-        acquired = True
-        if not display_name:
-            acquired = False
-            display_name = progressive_names[item_name][level + 1]
-        base_name = item_name.split(maxsplit=1)[1].lower()
-        display_data[base_name + "_acquired"] = acquired
-        display_data[base_name + "_url"] = alttp_icons[display_name]
-
-    # The single player tracker doesn't care about overworld, underworld, and total checks. Maybe it should?
-    sp_areas = ordered_areas[2:15]
-
-    player_big_key_locations = set()
-    player_small_key_locations = set()
-    for loc_data in locations.values():
-        for values in loc_data.values():
-            item_id, item_player, flags = values
-            if item_player == player:
-                if item_id in ids_big_key:
-                    player_big_key_locations.add(ids_big_key[item_id])
-                elif item_id in ids_small_key:
-                    player_small_key_locations.add(ids_small_key[item_id])
-
-    return render_template("lttpTracker.html", inventory=inventory,
-                            player_name=player_name, room=room, icons=alttp_icons, checks_done=checks_done,
-                            checks_in_area=seed_checks_in_area[player],
-                            acquired_items={lookup_any_item_id_to_name[id] for id in inventory},
-                            small_key_ids=small_key_ids, big_key_ids=big_key_ids, sp_areas=sp_areas,
-                            key_locations=player_small_key_locations,
-                            big_key_locations=player_big_key_locations,
-                            **display_data)
-
-
-def __renderMinecraftTracker(multisave: Dict[str, Any], room: Room, locations: Dict[int, Dict[int, Tuple[int, int, int]]],
-                             inventory: Counter, team: int, player: int, playerName: str,
-                             seed_checks_in_area: Dict[int, Dict[str, int]], checks_done: Dict[str, int], slot_data: Dict) -> str:
-
-    icons = {
-        "Wooden Pickaxe": "https://static.wikia.nocookie.net/minecraft_gamepedia/images/d/d2/Wooden_Pickaxe_JE3_BE3.png",
-        "Stone Pickaxe": "https://static.wikia.nocookie.net/minecraft_gamepedia/images/c/c4/Stone_Pickaxe_JE2_BE2.png",
-        "Iron Pickaxe": "https://static.wikia.nocookie.net/minecraft_gamepedia/images/d/d1/Iron_Pickaxe_JE3_BE2.png",
-        "Diamond Pickaxe": "https://static.wikia.nocookie.net/minecraft_gamepedia/images/e/e7/Diamond_Pickaxe_JE3_BE3.png",
-        "Wooden Sword": "https://static.wikia.nocookie.net/minecraft_gamepedia/images/d/d5/Wooden_Sword_JE2_BE2.png",
-        "Stone Sword": "https://static.wikia.nocookie.net/minecraft_gamepedia/images/b/b1/Stone_Sword_JE2_BE2.png",
-        "Iron Sword": "https://static.wikia.nocookie.net/minecraft_gamepedia/images/8/8e/Iron_Sword_JE2_BE2.png",
-        "Diamond Sword": "https://static.wikia.nocookie.net/minecraft_gamepedia/images/4/44/Diamond_Sword_JE3_BE3.png",
-        "Leather Tunic": "https://static.wikia.nocookie.net/minecraft_gamepedia/images/b/b7/Leather_Tunic_JE4_BE2.png",
-        "Iron Chestplate": "https://static.wikia.nocookie.net/minecraft_gamepedia/images/3/31/Iron_Chestplate_JE2_BE2.png",
-        "Diamond Chestplate": "https://static.wikia.nocookie.net/minecraft_gamepedia/images/e/e0/Diamond_Chestplate_JE3_BE2.png",
-        "Iron Ingot": "https://static.wikia.nocookie.net/minecraft_gamepedia/images/f/fc/Iron_Ingot_JE3_BE2.png",
-        "Block of Iron": "https://static.wikia.nocookie.net/minecraft_gamepedia/images/7/7e/Block_of_Iron_JE4_BE3.png",
-        "Brewing Stand": "https://static.wikia.nocookie.net/minecraft_gamepedia/images/b/b3/Brewing_Stand_%28empty%29_JE10.png",
-        "Ender Pearl": "https://static.wikia.nocookie.net/minecraft_gamepedia/images/f/f6/Ender_Pearl_JE3_BE2.png",
-        "Bucket": "https://static.wikia.nocookie.net/minecraft_gamepedia/images/f/fc/Bucket_JE2_BE2.png",
-        "Bow": "https://static.wikia.nocookie.net/minecraft_gamepedia/images/a/ab/Bow_%28Pull_2%29_JE1_BE1.png",
-        "Shield": "https://static.wikia.nocookie.net/minecraft_gamepedia/images/c/c6/Shield_JE2_BE1.png",
-        "Red Bed": "https://static.wikia.nocookie.net/minecraft_gamepedia/images/6/6a/Red_Bed_%28N%29.png",
-        "Netherite Scrap": "https://static.wikia.nocookie.net/minecraft_gamepedia/images/3/33/Netherite_Scrap_JE2_BE1.png",
-        "Flint and Steel": "https://static.wikia.nocookie.net/minecraft_gamepedia/images/9/94/Flint_and_Steel_JE4_BE2.png",
-        "Enchanting Table": "https://static.wikia.nocookie.net/minecraft_gamepedia/images/3/31/Enchanting_Table.gif",
-        "Fishing Rod": "https://static.wikia.nocookie.net/minecraft_gamepedia/images/7/7f/Fishing_Rod_JE2_BE2.png",
-        "Campfire": "https://static.wikia.nocookie.net/minecraft_gamepedia/images/9/91/Campfire_JE2_BE2.gif",
-        "Water Bottle": "https://static.wikia.nocookie.net/minecraft_gamepedia/images/7/75/Water_Bottle_JE2_BE2.png",
-        "Spyglass": "https://static.wikia.nocookie.net/minecraft_gamepedia/images/c/c1/Spyglass_JE2_BE1.png",
-    }
-
-    minecraft_location_ids = {
-        "Story": [42073, 42023, 42027, 42039, 42002, 42009, 42010, 42070, 
-                  42041, 42049, 42004, 42031, 42025, 42029, 42051, 42077],
-        "Nether": [42017, 42044, 42069, 42058, 42034, 42060, 42066, 42076, 42064, 42071, 42021,
-                   42062, 42008, 42061, 42033, 42011, 42006, 42019, 42000, 42040, 42001, 42015, 42014],
-        "The End": [42052, 42005, 42012, 42032, 42030, 42042, 42018, 42038, 42046],
-        "Adventure": [42047, 42050, 42096, 42097, 42098, 42059, 42055, 42072, 42003, 42035, 42016, 42020,
-                      42048, 42054, 42068, 42043, 42074, 42075, 42024, 42026, 42037, 42045, 42056, 42099, 42100],
-        "Husbandry": [42065, 42067, 42078, 42022, 42007, 42079, 42013, 42028, 42036, 
-                      42057, 42063, 42053, 42102, 42101, 42092, 42093, 42094, 42095],
-        "Archipelago": [42080, 42081, 42082, 42083, 42084, 42085, 42086, 42087, 42088, 42089, 42090, 42091],
-    }
-
-    display_data = {}
-
-    # Determine display for progressive items
-    progressive_items = {
-        "Progressive Tools": 45013,
-        "Progressive Weapons": 45012,
-        "Progressive Armor": 45014,
-        "Progressive Resource Crafting": 45001
-    }
-    progressive_names = {
-        "Progressive Tools": ["Wooden Pickaxe", "Stone Pickaxe", "Iron Pickaxe", "Diamond Pickaxe"],
-        "Progressive Weapons": ["Wooden Sword", "Stone Sword", "Iron Sword", "Diamond Sword"],
-        "Progressive Armor": ["Leather Tunic", "Iron Chestplate", "Diamond Chestplate"],
-        "Progressive Resource Crafting": ["Iron Ingot", "Iron Ingot", "Block of Iron"]
-    }
-    for item_name, item_id in progressive_items.items():
-        level = min(inventory[item_id], len(progressive_names[item_name]) - 1)
-        display_name = progressive_names[item_name][level]
-        base_name = item_name.split(maxsplit=1)[1].lower().replace(' ', '_')
-        display_data[base_name + "_url"] = icons[display_name]
-
-    # Multi-items
-    multi_items = {
-        "3 Ender Pearls": 45029,
-        "8 Netherite Scrap": 45015
-    }
-    for item_name, item_id in multi_items.items():
-        base_name = item_name.split()[-1].lower()
-        count = inventory[item_id]
-        if count >= 0:
-            display_data[base_name + "_count"] = count
-
-    # Victory condition
-    game_state = multisave.get("client_game_state", {}).get((team, player), 0)
-    display_data['game_finished'] = game_state == 30
-
-    # Turn location IDs into advancement tab counts
-    checked_locations = multisave.get("location_checks", {}).get((team, player), set())
-    lookup_name = lambda id: lookup_any_location_id_to_name[id]
-    location_info = {tab_name: {lookup_name(id): (id in checked_locations) for id in tab_locations}
-                        for tab_name, tab_locations in minecraft_location_ids.items()}
-    checks_done = {tab_name: len([id for id in tab_locations if id in checked_locations])
-                    for tab_name, tab_locations in minecraft_location_ids.items()}
-    checks_done['Total'] = len(checked_locations)
-    checks_in_area = {tab_name: len(tab_locations) for tab_name, tab_locations in minecraft_location_ids.items()}
-    checks_in_area['Total'] = sum(checks_in_area.values())
-
-    return render_template("minecraftTracker.html",
-                            inventory=inventory, icons=icons,
-                            acquired_items={lookup_any_item_id_to_name[id] for id in inventory if
-                                            id in lookup_any_item_id_to_name},
-                            player=player, team=team, room=room, player_name=playerName,
-                            checks_done=checks_done, checks_in_area=checks_in_area, location_info=location_info,
-                            **display_data)
-
-
-def __renderOoTTracker(multisave: Dict[str, Any], room: Room, locations: Dict[int, Dict[int, Tuple[int, int, int]]],
-                       inventory: Counter, team: int, player: int, playerName: str,
-                       seed_checks_in_area: Dict[int, Dict[str, int]], checks_done: Dict[str, int], slot_data: Dict) -> str:
-
-    icons = {
-        "Fairy Ocarina":            "https://static.wikia.nocookie.net/zelda_gamepedia_en/images/9/97/OoT_Fairy_Ocarina_Icon.png",
-        "Ocarina of Time":          "https://static.wikia.nocookie.net/zelda_gamepedia_en/images/4/4e/OoT_Ocarina_of_Time_Icon.png",
-        "Slingshot":                "https://static.wikia.nocookie.net/zelda_gamepedia_en/images/3/32/OoT_Fairy_Slingshot_Icon.png",
-        "Boomerang":                "https://static.wikia.nocookie.net/zelda_gamepedia_en/images/d/d5/OoT_Boomerang_Icon.png",
-        "Bottle":                   "https://static.wikia.nocookie.net/zelda_gamepedia_en/images/f/fc/OoT_Bottle_Icon.png",
-        "Rutos Letter":             "https://static.wikia.nocookie.net/zelda_gamepedia_en/images/2/21/OoT_Letter_Icon.png",
-        "Bombs":                    "https://static.wikia.nocookie.net/zelda_gamepedia_en/images/1/11/OoT_Bomb_Icon.png",
-        "Bombchus":                 "https://static.wikia.nocookie.net/zelda_gamepedia_en/images/3/36/OoT_Bombchu_Icon.png",
-        "Lens of Truth":            "https://static.wikia.nocookie.net/zelda_gamepedia_en/images/0/05/OoT_Lens_of_Truth_Icon.png",
-        "Bow":                      "https://static.wikia.nocookie.net/zelda_gamepedia_en/images/9/9a/OoT_Fairy_Bow_Icon.png",
-        "Hookshot":                 "https://static.wikia.nocookie.net/zelda_gamepedia_en/images/7/77/OoT_Hookshot_Icon.png",
-        "Longshot":                 "https://static.wikia.nocookie.net/zelda_gamepedia_en/images/a/a4/OoT_Longshot_Icon.png",
-        "Megaton Hammer":           "https://static.wikia.nocookie.net/zelda_gamepedia_en/images/9/93/OoT_Megaton_Hammer_Icon.png",
-        "Fire Arrows":              "https://static.wikia.nocookie.net/zelda_gamepedia_en/images/1/1e/OoT_Fire_Arrow_Icon.png",
-        "Ice Arrows":               "https://static.wikia.nocookie.net/zelda_gamepedia_en/images/3/3c/OoT_Ice_Arrow_Icon.png",
-        "Light Arrows":             "https://static.wikia.nocookie.net/zelda_gamepedia_en/images/7/76/OoT_Light_Arrow_Icon.png",
-        "Dins Fire":                r"https://static.wikia.nocookie.net/zelda_gamepedia_en/images/d/da/OoT_Din%27s_Fire_Icon.png",
-        "Farores Wind":             r"https://static.wikia.nocookie.net/zelda_gamepedia_en/images/7/7a/OoT_Farore%27s_Wind_Icon.png",
-        "Nayrus Love":              r"https://static.wikia.nocookie.net/zelda_gamepedia_en/images/b/be/OoT_Nayru%27s_Love_Icon.png",
-        "Kokiri Sword":             "https://static.wikia.nocookie.net/zelda_gamepedia_en/images/5/53/OoT_Kokiri_Sword_Icon.png",
-        "Biggoron Sword":           r"https://static.wikia.nocookie.net/zelda_gamepedia_en/images/2/2e/OoT_Giant%27s_Knife_Icon.png",
-        "Mirror Shield":            "https://static.wikia.nocookie.net/zelda_gamepedia_en/images/b/b0/OoT_Mirror_Shield_Icon_2.png",
-        "Goron Bracelet":           r"https://static.wikia.nocookie.net/zelda_gamepedia_en/images/b/b7/OoT_Goron%27s_Bracelet_Icon.png",
-        "Silver Gauntlets":         "https://static.wikia.nocookie.net/zelda_gamepedia_en/images/b/b9/OoT_Silver_Gauntlets_Icon.png",
-        "Golden Gauntlets":         "https://static.wikia.nocookie.net/zelda_gamepedia_en/images/6/6a/OoT_Golden_Gauntlets_Icon.png",
-        "Goron Tunic":              "https://static.wikia.nocookie.net/zelda_gamepedia_en/images/1/1c/OoT_Goron_Tunic_Icon.png",
-        "Zora Tunic":               "https://static.wikia.nocookie.net/zelda_gamepedia_en/images/2/2c/OoT_Zora_Tunic_Icon.png",
-        "Silver Scale":             "https://static.wikia.nocookie.net/zelda_gamepedia_en/images/4/4e/OoT_Silver_Scale_Icon.png",
-        "Gold Scale":               "https://static.wikia.nocookie.net/zelda_gamepedia_en/images/9/95/OoT_Golden_Scale_Icon.png",
-        "Iron Boots":               "https://static.wikia.nocookie.net/zelda_gamepedia_en/images/3/34/OoT_Iron_Boots_Icon.png",
-        "Hover Boots":              "https://static.wikia.nocookie.net/zelda_gamepedia_en/images/2/22/OoT_Hover_Boots_Icon.png",
-        "Adults Wallet":            r"https://static.wikia.nocookie.net/zelda_gamepedia_en/images/f/f9/OoT_Adult%27s_Wallet_Icon.png",
-        "Giants Wallet":            r"https://static.wikia.nocookie.net/zelda_gamepedia_en/images/8/87/OoT_Giant%27s_Wallet_Icon.png",
-        "Small Magic":              "https://static.wikia.nocookie.net/zelda_gamepedia_en/images/9/9f/OoT3D_Magic_Jar_Icon.png",
-        "Large Magic":              "https://static.wikia.nocookie.net/zelda_gamepedia_en/images/3/3e/OoT3D_Large_Magic_Jar_Icon.png",
-        "Gerudo Membership Card":   "https://static.wikia.nocookie.net/zelda_gamepedia_en/images/4/4e/OoT_Gerudo_Token_Icon.png",
-        "Gold Skulltula Token":     "https://static.wikia.nocookie.net/zelda_gamepedia_en/images/4/47/OoT_Token_Icon.png",
-        "Triforce Piece":           "https://static.wikia.nocookie.net/zelda_gamepedia_en/images/0/0b/SS_Triforce_Piece_Icon.png",
-        "Triforce":                 "https://static.wikia.nocookie.net/zelda_gamepedia_en/images/6/68/ALttP_Triforce_Title_Sprite.png",
-        "Zeldas Lullaby":           "https://static.wikia.nocookie.net/zelda_gamepedia_en/images/2/21/Grey_Note.png",
-        "Eponas Song":              "https://static.wikia.nocookie.net/zelda_gamepedia_en/images/2/21/Grey_Note.png",
-        "Sarias Song":              "https://static.wikia.nocookie.net/zelda_gamepedia_en/images/2/21/Grey_Note.png",
-        "Suns Song":                "https://static.wikia.nocookie.net/zelda_gamepedia_en/images/2/21/Grey_Note.png",
-        "Song of Time":             "https://static.wikia.nocookie.net/zelda_gamepedia_en/images/2/21/Grey_Note.png",
-        "Song of Storms":           "https://static.wikia.nocookie.net/zelda_gamepedia_en/images/2/21/Grey_Note.png",
-        "Minuet of Forest":         "https://static.wikia.nocookie.net/zelda_gamepedia_en/images/e/e4/Green_Note.png",
-        "Bolero of Fire":           "https://static.wikia.nocookie.net/zelda_gamepedia_en/images/f/f0/Red_Note.png",
-        "Serenade of Water":        "https://static.wikia.nocookie.net/zelda_gamepedia_en/images/0/0f/Blue_Note.png",
-        "Requiem of Spirit":        "https://static.wikia.nocookie.net/zelda_gamepedia_en/images/a/a4/Orange_Note.png",
-        "Nocturne of Shadow":       "https://static.wikia.nocookie.net/zelda_gamepedia_en/images/9/97/Purple_Note.png",
-        "Prelude of Light":         "https://static.wikia.nocookie.net/zelda_gamepedia_en/images/9/90/Yellow_Note.png",
-        "Small Key":                "https://static.wikia.nocookie.net/zelda_gamepedia_en/images/e/e5/OoT_Small_Key_Icon.png",
-        "Boss Key":                 "https://static.wikia.nocookie.net/zelda_gamepedia_en/images/4/40/OoT_Boss_Key_Icon.png",
-    }
-
-    display_data = {}
-
-    # Determine display for progressive items
-    progressive_items = {
-        "Progressive Hookshot": 66128,
-        "Progressive Strength Upgrade": 66129,
-        "Progressive Wallet": 66133,
-        "Progressive Scale": 66134,
-        "Magic Meter": 66138,
-        "Ocarina": 66139,
-    }
-
-    progressive_names = {
-        "Progressive Hookshot": ["Hookshot", "Hookshot", "Longshot"],
-        "Progressive Strength Upgrade": ["Goron Bracelet", "Goron Bracelet", "Silver Gauntlets", "Golden Gauntlets"],
-        "Progressive Wallet": ["Adults Wallet", "Adults Wallet", "Giants Wallet", "Giants Wallet"],
-        "Progressive Scale": ["Silver Scale", "Silver Scale", "Gold Scale"],
-        "Magic Meter": ["Small Magic", "Small Magic", "Large Magic"],
-        "Ocarina": ["Fairy Ocarina", "Fairy Ocarina", "Ocarina of Time"]
-    }
-
-    for item_name, item_id in progressive_items.items():
-        level = min(inventory[item_id], len(progressive_names[item_name])-1)
-        display_name = progressive_names[item_name][level]
-        if item_name.startswith("Progressive"):
-            base_name = item_name.split(maxsplit=1)[1].lower().replace(' ', '_')
-        else:
-            base_name = item_name.lower().replace(' ', '_')
-        display_data[base_name+"_url"] = icons[display_name]
-
-        if base_name == "hookshot":
-            display_data['hookshot_length'] = {0: '', 1: 'H', 2: 'L'}.get(level)
-        if base_name == "wallet": 
-            display_data['wallet_size'] = {0: '99', 1: '200', 2: '500', 3: '999'}.get(level)
-
-    # Determine display for bottles. Show letter if it's obtained, determine bottle count
-    bottle_ids = [66015, 66020, 66021, 66140, 66141, 66142, 66143, 66144, 66145, 66146, 66147, 66148]
-    display_data['bottle_count'] = min(sum(map(lambda item_id: inventory[item_id], bottle_ids)), 4)
-    display_data['bottle_url'] = icons['Rutos Letter'] if inventory[66021] > 0 else icons['Bottle']
-
-    # Determine bombchu display
-    display_data['has_bombchus'] = any(map(lambda item_id: inventory[item_id] > 0, [66003, 66106, 66107, 66137]))
-
-    # Multi-items
-    multi_items = {
-        "Gold Skulltula Token": 66091,
-        "Triforce Piece": 66202,
-    }
-    for item_name, item_id in multi_items.items():
-        base_name = item_name.split()[-1].lower()
-        count = inventory[item_id]
-        display_data[base_name+"_count"] = inventory[item_id]
-
-    # Gather dungeon locations
-    area_id_ranges = {
-        "Overworld":                (67000, 67280),
-        "Deku Tree":                (67281, 67303),
-        "Dodongo's Cavern":         (67304, 67334),
-        "Jabu Jabu's Belly":        (67335, 67359),
-        "Bottom of the Well":       (67360, 67384),
-        "Forest Temple":            (67385, 67420),
-        "Fire Temple":              (67421, 67457),
-        "Water Temple":             (67458, 67484),
-        "Shadow Temple":            (67485, 67532),
-        "Spirit Temple":            (67533, 67582),
-        "Ice Cavern":               (67583, 67596),
-        "Gerudo Training Ground":   (67597, 67635),
-        "Thieves' Hideout":         (67259, 67263),
-        "Ganon's Castle":           (67636, 67673),
-    }
-
-    def lookup_and_trim(id, area):
-        full_name = lookup_any_location_id_to_name[id]
-        if id == 67673:
-            return full_name[13:]  # Ganons Tower Boss Key Chest
-        if area not in ["Overworld", "Thieves' Hideout"]:
-            # trim dungeon name. leaves an extra space that doesn't display, or trims fully for DC/Jabu/GC
-            return full_name[len(area):]
-        return full_name
-
-    checked_locations = multisave.get("location_checks", {}).get((team, player), set()).intersection(set(locations[player]))
-    location_info = {area: {lookup_and_trim(id, area): id in checked_locations for id in range(min_id, max_id+1) if id in locations[player]} 
-        for area, (min_id, max_id) in area_id_ranges.items()}
-    checks_done = {area: len(list(filter(lambda x: x, location_info[area].values()))) for area in area_id_ranges}
-    checks_in_area = {area: len([id for id in range(min_id, max_id+1) if id in locations[player]]) 
-        for area, (min_id, max_id) in area_id_ranges.items()}
-
-    # Remove Thieves' Hideout checks from Overworld, since it's in the middle of the range
-    checks_in_area["Overworld"] -= checks_in_area["Thieves' Hideout"]
-    checks_done["Overworld"] -= checks_done["Thieves' Hideout"]
-    for loc in location_info["Thieves' Hideout"]:
-        del location_info["Overworld"][loc]
-
-    checks_done['Total'] = sum(checks_done.values())
-    checks_in_area['Total'] = sum(checks_in_area.values())
-
-    # Give skulltulas on non-tracked locations
-    non_tracked_locations = multisave.get("location_checks", {}).get((team, player), set()).difference(set(locations[player]))
-    for id in non_tracked_locations:
-        if "GS" in lookup_and_trim(id, ''):
-            display_data["token_count"] += 1
-
-    # Gather small and boss key info
-    small_key_counts = {
-        "Forest Temple":            inventory[66175],
-        "Fire Temple":              inventory[66176],
-        "Water Temple":             inventory[66177],
-        "Spirit Temple":            inventory[66178],
-        "Shadow Temple":            inventory[66179],
-        "Bottom of the Well":       inventory[66180],
-        "Gerudo Training Ground":   inventory[66181],
-        "Thieves' Hideout":         inventory[66182],
-        "Ganon's Castle":           inventory[66183],
-    }
-    boss_key_counts = {
-        "Forest Temple":            '✔' if inventory[66149] else '✕',
-        "Fire Temple":              '✔' if inventory[66150] else '✕',
-        "Water Temple":             '✔' if inventory[66151] else '✕',
-        "Spirit Temple":            '✔' if inventory[66152] else '✕',
-        "Shadow Temple":            '✔' if inventory[66153] else '✕',
-        "Ganon's Castle":           '✔' if inventory[66154] else '✕',
-    }
-
-    # Victory condition
-    game_state = multisave.get("client_game_state", {}).get((team, player), 0)
-    display_data['game_finished'] = game_state == 30
-
-    return render_template("ootTracker.html",
-                           inventory=inventory, player=player, team=team, room=room, player_name=playerName,
-                           icons=icons, acquired_items={lookup_any_item_id_to_name[id] for id in inventory},
-                           checks_done=checks_done, checks_in_area=checks_in_area, location_info=location_info,
-                           small_key_counts=small_key_counts, boss_key_counts=boss_key_counts,
-                           **display_data)
-
-
-def __renderTimespinnerTracker(multisave: Dict[str, Any], room: Room, locations: Dict[int, Dict[int, Tuple[int, int, int]]],
                                inventory: Counter, team: int, player: int, playerName: str,
                                seed_checks_in_area: Dict[int, Dict[str, int]], checks_done: Dict[str, int], slot_data: Dict[str, Any]) -> str:
 
@@ -745,7 +524,7 @@ def __renderTimespinnerTracker(multisave: Dict[str, Any], room: Room, locations:
     }
 
     timespinner_location_ids = {
-        "Present": [ 
+        "Present": [
             1337000, 1337001, 1337002, 1337003, 1337004, 1337005, 1337006, 1337007, 1337008, 1337009,
             1337010, 1337011, 1337012, 1337013, 1337014, 1337015, 1337016, 1337017, 1337018, 1337019,
             1337020, 1337021, 1337022, 1337023, 1337024, 1337025, 1337026, 1337027, 1337028, 1337029,
@@ -766,20 +545,20 @@ def __renderTimespinnerTracker(multisave: Dict[str, Any], room: Room, locations:
             1337150, 1337151, 1337152, 1337153, 1337154, 1337155,
                      1337171, 1337172, 1337173, 1337174, 1337175],
         "Ancient Pyramid": [
-                                                                  1337236, 
+                                                                  1337236,
                                                                   1337246, 1337247, 1337248, 1337249]
     }
 
     if(slot_data["DownloadableItems"]):
         timespinner_location_ids["Present"] += [
                                                                   1337156, 1337157,          1337159,
-            1337160, 1337161, 1337162, 1337163, 1337164, 1337165, 1337166, 1337167, 1337168, 1337169, 
+            1337160, 1337161, 1337162, 1337163, 1337164, 1337165, 1337166, 1337167, 1337168, 1337169,
             1337170]
     if(slot_data["Cantoran"]):
         timespinner_location_ids["Past"].append(1337176)
     if(slot_data["LoreChecks"]):
         timespinner_location_ids["Present"] += [
-                                                                           1337177, 1337178, 1337179, 
+                                                                           1337177, 1337178, 1337179,
             1337180, 1337181, 1337182, 1337183, 1337184, 1337185, 1337186, 1337187]
         timespinner_location_ids["Past"] += [
                                                                                     1337188, 1337189,
@@ -808,13 +587,13 @@ def __renderTimespinnerTracker(multisave: Dict[str, Any], room: Room, locations:
     acquired_items = {lookup_any_item_id_to_name[id] for id in inventory if id in lookup_any_item_id_to_name}
     options = {k for k, v in slot_data.items() if v}
 
-    return render_template("timespinnerTracker.html",
+    return render_template("trackers/" + "timespinnerTracker.html",
                             inventory=inventory, icons=icons, acquired_items=acquired_items,
                             player=player, team=team, room=room, player_name=playerName,
                             checks_done=checks_done, checks_in_area=checks_in_area, location_info=location_info,
                             options=options, **display_data)
 
-def __renderSuperMetroidTracker(multisave: Dict[str, Any], room: Room, locations: Dict[int, Dict[int, Tuple[int, int, int]]],
+def __renderSuperMetroidTracker(multisave: Dict[str, Any], room: Room, locations: set,
                                 inventory: Counter, team: int, player: int, playerName: str,
                                 seed_checks_in_area: Dict[int, Dict[str, int]], checks_done: Dict[str, int], slot_data: Dict) -> str:
 
@@ -889,6 +668,7 @@ def __renderSuperMetroidTracker(multisave: Dict[str, Any], room: Room, locations
 
     for item_name, item_id in multi_items.items():
         base_name = item_name.split()[0].lower()
+        count = inventory[item_id]
         display_data[base_name+"_count"] = inventory[item_id]
 
     # Victory condition
@@ -906,7 +686,7 @@ def __renderSuperMetroidTracker(multisave: Dict[str, Any], room: Room, locations
     checks_in_area = {tab_name: len(tab_locations) for tab_name, tab_locations in supermetroid_location_ids.items()}
     checks_in_area['Total'] = sum(checks_in_area.values())
 
-    return render_template("supermetroidTracker.html",
+    return render_template("trackers/" + "supermetroidTracker.html",
                             inventory=inventory, icons=icons,
                             acquired_items={lookup_any_item_id_to_name[id] for id in inventory if
                                             id in lookup_any_item_id_to_name},
@@ -914,7 +694,8 @@ def __renderSuperMetroidTracker(multisave: Dict[str, Any], room: Room, locations
                             checks_done=checks_done, checks_in_area=checks_in_area, location_info=location_info,
                             **display_data)
 
-def __renderGenericTracker(multisave: Dict[str, Any], room: Room, locations: Dict[int, Dict[int, Tuple[int, int, int]]],
+
+def __renderGenericTracker(multisave: Dict[str, Any], room: Room, locations: set,
                            inventory: Counter, team: int, player: int, playerName: str,
                            seed_checks_in_area: Dict[int, Dict[str, int]], checks_done: Dict[str, int]) -> str:
 
@@ -929,11 +710,11 @@ def __renderGenericTracker(multisave: Dict[str, Any], room: Room, locations: Dic
     for order_index, networkItem in enumerate(ordered_items, start=1):
         player_received_items[networkItem.item] = order_index
 
-    return render_template("genericTracker.html",
+    return render_template("trackers/" + "genericTracker.html",
                             inventory=inventory,
                             player=player, team=team, room=room, player_name=playerName,
                             checked_locations=checked_locations,
-                            not_checked_locations=set(locations[player]) - checked_locations,
+                            not_checked_locations=locations - checked_locations,
                             received_items=player_received_items)
 
 
@@ -975,9 +756,9 @@ def getTracker(tracker: UUID):
                 continue
 
             item, recipient, flags = player_locations[location]
-
             if recipient in names:
                 attribute_item(inventory, team, recipient, item)
+
             checks_done[team][player][player_location_to_area[player][location]] += 1
             checks_done[team][player]["Total"] += 1
 
@@ -987,10 +768,10 @@ def getTracker(tracker: UUID):
         if game_state == 30:
             inventory[team][player][106] = 1  # Triforce
 
-    player_big_key_locations = {playernumber: set() for playernumber in range(1, len(names[0]) + 1) if playernumber not in groups}
+    player_big_key_locations = {playernumber: set() for playernumber in range(1, len(names[0]) + 1)}
-    player_small_key_locations = {playernumber: set() for playernumber in range(1, len(names[0]) + 1) if playernumber not in groups}
+    player_small_key_locations = {playernumber: set() for playernumber in range(1, len(names[0]) + 1)}
     for loc_data in locations.values():
-         for values in loc_data.values():
+        for values in loc_data.values():
             item_id, item_player, flags = values
 
             if item_id in ids_big_key:
@@ -1021,7 +802,7 @@ def getTracker(tracker: UUID):
     for (team, player), data in multisave.get("video", []):
         video[(team, player)] = data
 
-    return render_template("tracker.html", inventory=inventory, get_item_name_from_id=get_item_name_from_id,
+    return render_template("trackers/" + "multiworldTracker.html", inventory=inventory, get_item_name_from_id=lookup_any_item_id_to_name,
                            lookup_id_to_name=Items.lookup_id_to_name, player_names=player_names,
                            tracking_names=tracking_names, tracking_ids=tracking_ids, room=room, icons=alttp_icons,
                            multi_items=multi_items, checks_done=checks_done, ordered_areas=ordered_areas,
@@ -1032,9 +813,6 @@ def getTracker(tracker: UUID):
 
 
 game_specific_trackers: typing.Dict[str, typing.Callable] = {
-    "Minecraft": __renderMinecraftTracker,
-    "Ocarina of Time": __renderOoTTracker,
     "Timespinner": __renderTimespinnerTracker,
-    "A Link to the Past": __renderAlttpTracker,
     "Super Metroid": __renderSuperMetroidTracker
-}
+}

data/lua/FF1/ff1_connector.lua

@@ -97,6 +97,11 @@ local extensionConsumableLookup = {
     [443] = 0x3F
 }
 
+local noOverworldItemsLookup = {
+    [499] = 0x2B,
+    [500] = 0x12,
+}
+
 local itemMessages = {}
 local consumableStacks = nil
 local prevstate = ""
@@ -341,7 +346,7 @@ function processBlock(block)
                 -- This is a key item
                 memoryLocation = memoryLocation - 0x0E0
                 wU8(memoryLocation, 0x01)
-            elseif v >= 0x1E0 then
+            elseif v >= 0x1E0 and v <= 0x1F2 then
                 -- This is a movement item
                 -- Minus Offset (0x100) - movement offset (0xE0)
                 memoryLocation = memoryLocation - 0x1E0
@@ -351,7 +356,10 @@ function processBlock(block)
                 else
                     wU8(memoryLocation, 0x01)
                 end
-
+            elseif v >= 0x1F3 and v <= 0x1F4 then
+                -- NoOverworld special items
+                memoryLocation = noOverworldItemsLookup[v]
+                wU8(memoryLocation, 0x01)
             elseif v >= 0x16C and v <= 0x1AF then
                 -- This is a gold item
                 amountToAdd = goldLookup[v]

docs/apworld specification.md

@@ -0,0 +1,32 @@
+# apworld Specification
+
+Archipelago depends on worlds to provide game-specific details like items, locations and output generation.
+Those are located in the `worlds/` folder (source) or  `<insall dir>/lib/worlds/` (when installed).
+See [world api.md](world api.md) for details.
+
+apworld provides a way to package and ship a world that is not part of the main distribution by placing a `*.apworld`
+file into the worlds folder.
+
+
+## File Format
+
+apworld files are zip archives with the case-sensitive file ending `.apworld`.
+The zip has to contain a folder with the same name as the zip, case-sensitive, that contains what would normally be in
+the world's folder in `worlds/`. I.e. `worlds/ror2.apworld` containing `ror2/__init__.py`.
+
+
+## Metadata
+
+No metadata is specified yet.
+
+
+## Extra Data
+
+The zip can contain arbitrary files in addition what was specified above.
+
+
+## Caveats
+
+Imports from other files inside the apworld have to use relative imports.
+
+Imports from AP base have to use absolute imports, e.g. Options.py and worlds/AutoWorld.py.

docs/code_of_conduct.md

@@ -0,0 +1,11 @@
+# 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:
+
+* Be welcoming and inclusive in tone and language.
+* Be respectful of others and their abilities.
+* Show empathy when speaking with others.
+* Be gracious and accept feedback and constructive criticism.
+
+These guidelines apply to all channels of communication within this GitHub repository. Please be respectful in both public channels, such as issues, and private ones, such as private messaging or emails.
+
+Any incidents of abuse may be reported directly to ijwu at hmfarran@gmail.com.

docs/contributing.md

@@ -0,0 +1,12 @@
+# Contributing
+Contributions are welcome. We have a few requests of any new contributors.
+
+* Ensure that all changes which affect logic are covered by unit tests. 
+* Do not introduce any unit test failures/regressions.
+* Follow styling as designated in our [styling documentation](/docs/style.md).
+
+Otherwise, we tend to judge code on a case to case basis.
+
+For adding a new game to Archipelago and other documentation on how Archipelago functions, please see 
+[the docs folder](docs/) for the relevant information and feel free to ask any questions in the #archipelago-dev 
+channel in our [Discord](https://archipelago.gg/discord).

docs/network diagram/network diagram.md

@@ -69,6 +69,12 @@ flowchart LR
     end
     SNI <-- Various, depending on SNES device --> SMZ
 
+    %% Donkey Kong Country 3
+    subgraph Donkey Kong Country 3
+        DK3[SNES]
+    end
+    SNI <-- Various, depending on SNES device --> DK3
+
     %% Native Clients or Games
     %% Games or clients which compile to native or which the client is integrated in the game.
     subgraph "Native"
@@ -82,10 +88,12 @@ flowchart LR
         MT[Meritous]
         TW[The Witness]
         SA2B[Sonic Adventure 2: Battle]
+        DS3[Dark Souls 3]
 
         APCLIENTPP <--> SOE
         APCLIENTPP <--> MT
         APCLIENTPP <-- The Witness Randomizer --> TW
+        APCLIENTPP <--> DS3
         APCPP <--> SM64
         APCPP <--> V6
         APCPP <--> SA2B

docs/network protocol.md

@@ -13,9 +13,18 @@ These steps should be followed in order to establish a gameplay connection with
 
 In the case that the client does not authenticate properly and receives a [ConnectionRefused](#ConnectionRefused) then the server will maintain the connection and allow for follow-up [Connect](#Connect) packet.
 
-There are libraries available that implement this network protocol in [Python](https://github.com/ArchipelagoMW/Archipelago/blob/main/CommonClient.py), [Java](https://github.com/ArchipelagoMW/Archipelago.MultiClient.Java), [.Net](https://github.com/ArchipelagoMW/Archipelago.MultiClient.Net) and [C++](https://github.com/black-sliver/apclientpp)
+There are also a number of community-supported libraries available that implement this network protocol to make integrating with Archipelago easier.
 
-For Super Nintendo games there are clients available in either [Node](https://github.com/ArchipelagoMW/SuperNintendoClient) or [Python](https://github.com/ArchipelagoMW/Archipelago/blob/main/SNIClient.py), There are also game specific clients available for [The Legend of Zelda: Ocarina of Time](https://github.com/ArchipelagoMW/Z5Client) or [Final Fantasy 1](https://github.com/ArchipelagoMW/Archipelago/blob/main/FF1Client.py)
+| Language/Runtime              | Project                                                                                            | Remarks                                                                         |
+|-------------------------------|----------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------|
+| Python                        | [Archipelago CommonClient](https://github.com/ArchipelagoMW/Archipelago/blob/main/CommonClient.py) |                                                                                 |
+|                               | [Archipelago SNIClient](https://github.com/ArchipelagoMW/Archipelago/blob/main/SNIClient.py)       | For Super Nintendo Game Support; Utilizes [SNI](https://github.com/alttpo/sni). |
+| JVM (Java / Kotlin)           | [Archipelago.MultiClient.Java](https://github.com/ArchipelagoMW/Archipelago.MultiClient.Java)      |                                                                                 |
+| .NET (C# / C++ / F# / VB.NET) | [Archipelago.MultiClient.Net](https://www.nuget.org/packages/Archipelago.MultiClient.Net)          |                                                                                 |
+| C++                           | [apclientpp](https://github.com/black-sliver/apclientpp)                                           | almost-header-only                                                              |
+|                               | [APCpp](https://github.com/N00byKing/APCpp)                                                        | CMake                                                                           |
+| JavaScript / TypeScript       | [archipelago.js](https://www.npmjs.com/package/archipelago.js)                                     | Browser and Node.js Supported                                                   |
+| Haxe                          | [hxArchipelago](https://lib.haxe.org/p/hxArchipelago)                                              |                                                                                 |
 
 ## Synchronizing Items
 When the client receives a [ReceivedItems](#ReceivedItems) packet, if the `index` argument does not match the next index that the client expects then it is expected that the client will re-sync items with the server. This can be accomplished by sending the server a [Sync](#Sync) packet and then a [LocationChecks](#LocationChecks) packet.
@@ -152,7 +161,8 @@ The arguments for RoomUpdate are identical to [RoomInfo](#RoomInfo) barring:
 All arguments for this packet are optional, only changes are sent.
 
 ### Print
-Sent to clients purely to display a message to the player.
+Sent to clients purely to display a message to the player. 
+* *Deprecation warning: clients that connect with version 0.3.5 or higher will nolonger recieve Print packets, instead all messsages are send as [PrintJSON](#PrintJSON)*
 #### Arguments
 | Name | Type | Notes |
 | ---- | ---- | ----- |
@@ -164,10 +174,21 @@ Sent to clients purely to display a message to the player. This packet differs f
 | Name | Type | Notes |
 | ---- | ---- | ----- |
 | data | list\[[JSONMessagePart](#JSONMessagePart)\] | Type of this part of the message. |
-| type | str | May be present to indicate the nature of this message. Known types are Hint and ItemSend. |
+| type | str | May be present to indicate the [PrintJsonType](#PrintJsonType) of this message. |
 | receiving | int | Is present if type is Hint or ItemSend and marks the destination player's ID. |
 | item | [NetworkItem](#NetworkItem) | Is present if type is Hint or ItemSend and marks the source player id, location id, item id and item flags. |
 | found | bool | Is present if type is Hint, denotes whether the location hinted for was checked. |
+| countdown | int | Is present if type is `Countdown`, denotes the amount of seconds remaining on the countdown. |
+
+##### PrintJsonType
+PrintJsonType indicates the type of [PrintJson](#PrintJson) packet, different types can be handled differently by the client and can also contain additional arguments. When receiving an unknown type the data's list\[[JSONMessagePart](#JSONMessagePart)\] should still be printed as normal. 
+
+Currently defined types are:
+| Type | Notes |
+| ---- | ----- |
+| ItemSend | The message is in response to a player receiving an item. |
+| Hint | The message is in response to a player hinting. |
+| Countdown | The message contains information about the current server Countdown. |
 
 ### DataPackage
 Sent to clients to provide what is known as a 'data package' which contains information to enable a client to most easily communicate with the Archipelago server. Contents include things like location id to name mappings, among others; see [Data Package Contents](#Data-Package-Contents) for more info.
@@ -501,7 +522,7 @@ Color options:
 * green_bg
 * yellow_bg
 * blue_bg
-* purple_bg
+* magenta_bg
 * cyan_bg
 * white_bg
 

docs/running from source.md

@@ -56,3 +56,8 @@ SNI is required to use SNIClient. If not integrated into the project, it has to
 You can get the latest SNI release at [SNI Github releases](https://github.com/alttpo/sni/releases).
 It should be dropped as "SNI" into the root folder of the project. Alternatively, you can point the sni setting in
 host.yaml at your SNI folder.
+
+
+## Running tests
+
+Run `pip install pytest pytest-subtests`, then use your IDE to run tests or run `pytest` from the source folder.

docs/world api.md

@@ -86,7 +86,7 @@ inside a World object.
 
 Players provide customized settings for their World in the form of yamls.
 Those are accessible through `self.world.<option_name>[self.player]`. A dict
-of valid options has to be provided in `self.options`. Options are automatically
+of valid options has to be provided in `self.option_definitions`. Options are automatically
 added to the `World` object for easy access.
 
 ### World Options
@@ -103,8 +103,9 @@ or boss drops for RPG-like games but could also be progress in a research tree.
 
 Each location has a `name` and an `id` (a.k.a. "code" or "address"), is placed
 in a Region and has access rules.
-The name needs to be unique in each game, the ID needs to be unique across all
+The name needs to be unique in each game and must not be numeric (has to
-games and is best in the same range as the item IDs.
+contain least 1 letter or symbol). The ID needs to be unique across all games
+and is best in the same range as the item IDs.
 World-specific IDs are 1 to 2<sup>53</sup>-1, IDs ≤ 0 are global and reserved.
 
 Special locations with ID `None` can hold events.
@@ -121,6 +122,9 @@ their world. Progression items will be assigned to locations with higher
 priority and moved around to meet defined rules and accomplish progression
 balancing.
 
+The name needs to be unique in each game, meaning a duplicate item has the
+same ID. Name must not be numeric (has to contain at least 1 letter or symbol).
+
 Special items with ID `None` can mark events (read below).
 
 Other classifications include
@@ -188,15 +192,17 @@ the `/worlds` directory. The starting point for the package is `__init.py__`.
 Conventionally, your world class is placed in that file.
 
 World classes must inherit from the `World` class in `/worlds/AutoWorld.py`,
-which can be imported as `..AutoWorld.World` from your package.
+which can be imported as `worlds.AutoWorld.World` from your package.
 
 AP will pick up your world automatically due to the `AutoWorld` implementation.
 
 ### Requirements
 
 If your world needs specific python packages, they can be listed in
-`world/[world_name]/requirements.txt`.
+`world/[world_name]/requirements.txt`. ModuleUpdate.py will automatically
-See [pip documentation](https://pip.pypa.io/en/stable/cli/pip_install/#requirements-file-format)
+pick up and install them.
+
+See [pip documentation](https://pip.pypa.io/en/stable/cli/pip_install/#requirements-file-format).
 
 ### Relative Imports
 
@@ -209,6 +215,10 @@ e.g. `from .Options import mygame_options` from your `__init__.py` will load
 When imported names pile up it may be easier to use `from . import Options`
 and access the variable as `Options.mygame_options`.
 
+Imports from directories outside your world should use absolute imports.
+Correct use of relative / absolute imports is required for zipped worlds to
+function, see [apworld specification.md](apworld%20specification.md).
+
 ### Your Item Type
 
 Each world uses its own subclass of `BaseClasses.Item`. The constuctor can be
@@ -252,7 +262,7 @@ to describe it and a `display_name` property for display on the website and in
 spoiler logs.
 
 The actual name as used in the yaml is defined in a `dict[str, Option]`, that is
-assigned to the world under `self.options`.
+assigned to the world under `self.option_definitions`.
 
 Common option types are `Toggle`, `DefaultOnToggle`, `Choice`, `Range`.
 For more see `Options.py` in AP's base directory.
@@ -274,14 +284,12 @@ Define a property `option_<name> = <number>` per selectable value and
 `default = <number>` to set the default selection. Aliases can be set by
 defining a property `alias_<name> = <same number>`.
 
-One special case where aliases are required is when option name is `yes`, `no`,
-`on` or `off` because they parse to `True` or `False`:
 ```python
 option_off = 0
 option_on = 1
 option_some = 2
-alias_false = 0
+alias_disabled = 0
-alias_true = 1
+alias_enabled = 1
 default = 0
 ```
 
@@ -323,12 +331,12 @@ mygame_options: typing.Dict[str, type(Option)] = {
 ```python
 # __init__.py
 
-from ..AutoWorld import World
+from worlds.AutoWorld import World
 from .Options import mygame_options  # import the options dict
 
 class MyGameWorld(World):
     #...
-    options = mygame_options  # assign the options dict to the world
+    option_definitions = mygame_options  # assign the options dict to the world
     #...
 ```
     
@@ -352,7 +360,7 @@ more natural. These games typically have been edited to 'bake in' the items.
 from .Options import mygame_options  # the options we defined earlier
 from .Items import mygame_items  # data used below to add items to the World
 from .Locations import mygame_locations  # same as above
-from ..AutoWorld import World
+from worlds.AutoWorld import World
 from BaseClasses import Region, Location, Entrance, Item, RegionType, ItemClassification
 from Utils import get_options, output_path
 
@@ -365,7 +373,7 @@ class MyGameLocation(Location):  # or from Locations import MyGameLocation
 class MyGameWorld(World):
     """Insert description of the world/game here."""
     game: str = "My Game"  # name of the game/world
-    options = mygame_options  # options the player can set
+    option_definitions = mygame_options  # options the player can set
     topology_present: bool = True  # show path to required location checks in spoiler
     remote_items: bool = False  # True if all items come from the server
     remote_start_inventory: bool = False  # True if start inventory comes from the server
@@ -553,7 +561,7 @@ def generate_basic(self) -> None:
 ### Setting Rules
 
 ```python
-from ..generic.Rules import add_rule, set_rule, forbid_item
+from worlds.generic.Rules import add_rule, set_rule, forbid_item
 from Items import get_item_type
 
 def set_rules(self) -> None:
@@ -603,7 +611,7 @@ implement more complex logic in logic mixins, even if there is no need to add
 properties to the `BaseClasses.CollectionState` state object.
 
 When importing a file that defines a class that inherits from
-`..AutoWorld.LogicMixin` the state object's class is automatically extended by
+`worlds.AutoWorld.LogicMixin` the state object's class is automatically extended by
 the mixin's members. These members should be prefixed with underscore following
 the name of the implementing world. This is due to sharing a namespace with all
 other logic mixins.
@@ -622,7 +630,7 @@ Please do this with caution and only when neccessary.
 ```python
 # Logic.py
 
-from ..AutoWorld import LogicMixin
+from worlds.AutoWorld import LogicMixin
 
 class MyGameLogic(LogicMixin):
     def _mygame_has_key(self, world: MultiWorld, player: int):
@@ -633,7 +641,7 @@ class MyGameLogic(LogicMixin):
 ```python
 # __init__.py
 
-from ..generic.Rules import set_rule
+from worlds.generic.Rules import set_rule
 import .Logic  # apply the mixin by importing its file
 
 class MyGameWorld(World):

inno_setup.iss

@@ -196,7 +196,7 @@ begin
   begin
     // Is the installed version at least the packaged one ?
     Log('VC Redist x64 Version : found ' + strVersion);
-    Result := (CompareStr(strVersion, 'v14.29.30037') < 0);
+    Result := (CompareStr(strVersion, 'v14.32.31332') < 0);
   end
   else
   begin

requirements.txt

@@ -3,6 +3,6 @@ websockets>=10.3
 PyYAML>=6.0
 jellyfish>=0.9.0
 jinja2>=3.1.2
-schema>=0.7.4
+schema>=0.7.5
 kivy>=2.1.0
 bsdiff4>=1.2.2

test/dungeons/TestDungeon.py

@@ -16,7 +16,7 @@ class TestDungeon(unittest.TestCase):
     def setUp(self):
         self.world = MultiWorld(1)
         args = Namespace()
-        for name, option in AutoWorld.AutoWorldRegister.world_types["A Link to the Past"].options.items():
+        for name, option in AutoWorld.AutoWorldRegister.world_types["A Link to the Past"].option_definitions.items():
             setattr(args, name, {1: option.from_any(option.default)})
         self.world.set_options(args)
         self.world.set_default_common_options()

test/general/TestFill.py

@@ -49,8 +49,7 @@ class PlayerDefinition(object):
         region_name = "player" + str(self.id) + region_tag
         region = Region("player" + str(self.id) + region_tag, RegionType.Generic,
                         "Region Hint", self.id, self.world)
-        self.locations += generate_locations(size,
+        self.locations += generate_locations(size, self.id, None, region, region_tag)
-                                             self.id, None, region, region_tag)
 
         entrance = Entrance(self.id, region_name + "_entrance", parent)
         parent.exits.append(entrance)
@@ -372,13 +371,13 @@ class TestDistributeItemsRestrictive(unittest.TestCase):
 
         distribute_items_restrictive(multi_world)
 
-        self.assertEqual(locations[0].item, basic_items[0])
+        self.assertEqual(locations[0].item, basic_items[1])
         self.assertFalse(locations[0].event)
         self.assertEqual(locations[1].item, prog_items[0])
         self.assertTrue(locations[1].event)
         self.assertEqual(locations[2].item, prog_items[1])
         self.assertTrue(locations[2].event)
-        self.assertEqual(locations[3].item, basic_items[1])
+        self.assertEqual(locations[3].item, basic_items[0])
         self.assertFalse(locations[3].event)
 
     def test_excluded_distribute(self):
@@ -501,8 +500,8 @@ class TestDistributeItemsRestrictive(unittest.TestCase):
         removed_item: list[Item] = []
         removed_location: list[Location] = []
 
-        def fill_hook(progitempool, nonexcludeditempool, localrestitempool, nonlocalrestitempool, restitempool, fill_locations):
+        def fill_hook(progitempool, usefulitempool, filleritempool, fill_locations):
-            removed_item.append(restitempool.pop(0))
+            removed_item.append(filleritempool.pop(0))
             removed_location.append(fill_locations.pop(0))
 
         multi_world.worlds[player1.id].fill_hook = fill_hook

test/general/TestIDs.py

@@ -52,3 +52,13 @@ class TestIDs(unittest.TestCase):
                 else:
                     for location_id in world_type.location_id_to_name:
                         self.assertGreater(location_id, 0)
+
+    def testDuplicateItemIDs(self):
+        for gamename, world_type in AutoWorldRegister.world_types.items():
+            with self.subTest(game=gamename):
+                self.assertEqual(len(world_type.item_id_to_name), len(world_type.item_name_to_id))
+
+    def testDuplicateLocationIDs(self):
+        for gamename, world_type in AutoWorldRegister.world_types.items():
+            with self.subTest(game=gamename):
+                self.assertEqual(len(world_type.location_id_to_name), len(world_type.location_name_to_id))

test/general/TestItems.py

@@ -1,5 +1,6 @@
 import unittest
 from worlds.AutoWorld import AutoWorldRegister
+from . import setup_default_world
 
 
 class TestBase(unittest.TestCase):
@@ -29,3 +30,17 @@ class TestBase(unittest.TestCase):
                         with self.subTest(group_name, group_name=group_name):
                             for item in items:
                                 self.assertIn(item, world_type.item_name_to_id)
+
+    def testItemCountGreaterEqualLocations(self):
+        for game_name, world_type in AutoWorldRegister.world_types.items():
+
+            if game_name in {"Final Fantasy"}:
+                continue
+            with self.subTest("Game", game=game_name):
+                world = setup_default_world(world_type)
+                location_count = sum(0 if location.event or location.item else 1 for location in world.get_locations())
+                self.assertGreaterEqual(
+                    len(world.itempool),
+                    location_count,
+                    f"{game_name} Item count MUST meet or exceede the number of locations",
+                )

test/general/TestNames.py

@@ -0,0 +1,20 @@
+import unittest
+from worlds.AutoWorld import AutoWorldRegister
+
+
+class TestNames(unittest.TestCase):
+    def testItemNamesFormat(self):
+        """Item names must not be all numeric in order to differentiate between ID and name in !hint"""
+        for gamename, world_type in AutoWorldRegister.world_types.items():
+            with self.subTest(game=gamename):
+                for item_name in world_type.item_name_to_id:
+                    self.assertFalse(item_name.isnumeric(),
+                                     f"Item name \"{item_name}\" is invalid. It must not be numeric.")
+
+    def testLocationNameFormat(self):
+        """Location names must not be all numeric in order to differentiate between ID and name in !hint_location"""
+        for gamename, world_type in AutoWorldRegister.world_types.items():
+            with self.subTest(game=gamename):
+                for location_name in world_type.location_name_to_id:
+                    self.assertFalse(location_name.isnumeric(),
+                                     f"Location name \"{location_name}\" is invalid. It must not be numeric.")

test/general/__init__.py

@@ -12,7 +12,7 @@ def setup_default_world(world_type) -> MultiWorld:
     world.player_name = {1: "Tester"}
     world.set_seed()
     args = Namespace()
-    for name, option in world_type.options.items():
+    for name, option in world_type.option_definitions.items():
         setattr(args, name, {1: option.from_any(option.default)})
     world.set_options(args)
     world.set_default_common_options()

test/inverted/TestInverted.py

@@ -16,7 +16,7 @@ class TestInverted(TestBase):
     def setUp(self):
         self.world = MultiWorld(1)
         args = Namespace()
-        for name, option in AutoWorld.AutoWorldRegister.world_types["A Link to the Past"].options.items():
+        for name, option in AutoWorld.AutoWorldRegister.world_types["A Link to the Past"].option_definitions.items():
             setattr(args, name, {1: option.from_any(option.default)})
         self.world.set_options(args)
         self.world.set_default_common_options()

test/inverted/TestInvertedBombRules.py

@@ -17,7 +17,7 @@ class TestInvertedBombRules(unittest.TestCase):
         self.world = MultiWorld(1)
         self.world.mode[1] = "inverted"
         args = Namespace
-        for name, option in AutoWorld.AutoWorldRegister.world_types["A Link to the Past"].options.items():
+        for name, option in AutoWorld.AutoWorldRegister.world_types["A Link to the Past"].option_definitions.items():
             setattr(args, name, {1: option.from_any(option.default)})
             self.world.set_options(args)
         self.world.set_default_common_options()

test/inverted_minor_glitches/TestInvertedMinor.py

@@ -17,7 +17,7 @@ class TestInvertedMinor(TestBase):
     def setUp(self):
         self.world = MultiWorld(1)
         args = Namespace()
-        for name, option in AutoWorld.AutoWorldRegister.world_types["A Link to the Past"].options.items():
+        for name, option in AutoWorld.AutoWorldRegister.world_types["A Link to the Past"].option_definitions.items():
             setattr(args, name, {1: option.from_any(option.default)})
         self.world.set_options(args)
         self.world.set_default_common_options()

test/inverted_owg/TestInvertedOWG.py

@@ -18,7 +18,7 @@ class TestInvertedOWG(TestBase):
     def setUp(self):
         self.world = MultiWorld(1)
         args = Namespace()
-        for name, option in AutoWorld.AutoWorldRegister.world_types["A Link to the Past"].options.items():
+        for name, option in AutoWorld.AutoWorldRegister.world_types["A Link to the Past"].option_definitions.items():
             setattr(args, name, {1: option.from_any(option.default)})
         self.world.set_options(args)
         self.world.set_default_common_options()

test/minor_glitches/TestMinor.py

@@ -17,7 +17,7 @@ class TestMinor(TestBase):
     def setUp(self):
         self.world = MultiWorld(1)
         args = Namespace()
-        for name, option in AutoWorld.AutoWorldRegister.world_types["A Link to the Past"].options.items():
+        for name, option in AutoWorld.AutoWorldRegister.world_types["A Link to the Past"].option_definitions.items():
             setattr(args, name, {1: option.from_any(option.default)})
         self.world.set_options(args)
         self.world.set_default_common_options()

test/owg/TestVanillaOWG.py

@@ -18,7 +18,7 @@ class TestVanillaOWG(TestBase):
     def setUp(self):
         self.world = MultiWorld(1)
         args = Namespace()
-        for name, option in AutoWorld.AutoWorldRegister.world_types["A Link to the Past"].options.items():
+        for name, option in AutoWorld.AutoWorldRegister.world_types["A Link to the Past"].option_definitions.items():
             setattr(args, name, {1: option.from_any(option.default)})
         self.world.set_options(args)
         self.world.set_default_common_options()

test/utils/TestSIPrefix.py

@@ -0,0 +1,44 @@
+# Tests for SI prefix in Utils.py
+
+import unittest
+from decimal import Decimal
+from Utils import format_SI_prefix
+
+
+class TestGenerateMain(unittest.TestCase):
+    """This tests SI prefix formatting in Utils.py"""
+    def assertEqual(self, first, second, msg=None):
+        # we strip spaces everywhere because that is an undefined implementation detail
+        super().assertEqual(first.replace(" ", ""), second.replace(" ", ""), msg)
+
+    def test_rounding(self):
+        # we don't care if float(999.995) would fail due to error in precision
+        self.assertEqual(format_SI_prefix(999.999), "1.00k")
+        self.assertEqual(format_SI_prefix(1000.001), "1.00k")
+        self.assertEqual(format_SI_prefix(Decimal("999.995")), "1.00k")
+        self.assertEqual(format_SI_prefix(Decimal("1000.004")), "1.00k")
+
+    def test_letters(self):
+        self.assertEqual(format_SI_prefix(0e0), "0.00")
+        self.assertEqual(format_SI_prefix(1e3), "1.00k")
+        self.assertEqual(format_SI_prefix(2e6), "2.00M")
+        self.assertEqual(format_SI_prefix(3e9), "3.00G")
+        self.assertEqual(format_SI_prefix(4e12), "4.00T")
+        self.assertEqual(format_SI_prefix(5e15), "5.00P")
+        self.assertEqual(format_SI_prefix(6e18), "6.00E")
+        self.assertEqual(format_SI_prefix(7e21), "7.00Z")
+        self.assertEqual(format_SI_prefix(8e24), "8.00Y")
+
+    def test_multiple_letters(self):
+        self.assertEqual(format_SI_prefix(9e27), "9.00kY")
+
+    def test_custom_power(self):
+        self.assertEqual(format_SI_prefix(1023.99, 1024), "1023.99")
+        self.assertEqual(format_SI_prefix(1034.24, 1024), "1.01k")
+
+    def test_custom_labels(self):
+        labels = ("E", "da", "h", "k")
+        self.assertEqual(format_SI_prefix(1, 10, labels), "1.00E")
+        self.assertEqual(format_SI_prefix(10, 10, labels), "1.00da")
+        self.assertEqual(format_SI_prefix(100, 10, labels), "1.00h")
+        self.assertEqual(format_SI_prefix(1000, 10, labels), "1.00k")

test/vanilla/TestVanilla.py

@@ -16,7 +16,7 @@ class TestVanilla(TestBase):
     def setUp(self):
         self.world = MultiWorld(1)
         args = Namespace()
-        for name, option in AutoWorld.AutoWorldRegister.world_types["A Link to the Past"].options.items():
+        for name, option in AutoWorld.AutoWorldRegister.world_types["A Link to the Past"].option_definitions.items():
             setattr(args, name, {1: option.from_any(option.default)})
         self.world.set_options(args)
         self.world.set_default_common_options()