WebHost: invert multitracker control back to webhost

.github/workflows/unittests.yml

@@ -54,9 +54,9 @@ jobs:
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip
-        pip install pytest pytest-subtests pytest-xdist
+        pip install pytest pytest-subtests
         python ModuleUpdate.py --yes --force --append "WebHostLib/requirements.txt"
         python Launcher.py --update_settings  # make sure host.yaml exists for tests
     - name: Unittests
       run: |
-        pytest -n auto
+        pytest

.gitignore

@@ -27,20 +27,16 @@
 *.archipelago
 *.apsave
 *.BIN
-*.puml
 
 setups
 build
 bundle/components.wxs
 dist
-/prof/
 README.html
 .vs/
 EnemizerCLI/
 /Players/
 /SNI/
-/sni-*/
-/appimagetool*
 /host.yaml
 /options.yaml
 /config.yaml
@@ -143,7 +139,6 @@ ipython_config.py
 .venv*
 env/
 venv/
-/venv*/
 ENV/
 env.bak/
 venv.bak/

BaseClasses.py

@@ -1,15 +1,13 @@
 from __future__ import annotations
 
 import copy
-import itertools
 import functools
 import logging
 import random
 import secrets
 import typing  # this can go away when Python 3.8 support is dropped
 from argparse import Namespace
-from collections import Counter, deque
-from collections.abc import Collection, MutableSequence
+from collections import ChainMap, Counter, deque
 from enum import IntEnum, IntFlag
 from typing import Any, Callable, Dict, Iterable, Iterator, List, NamedTuple, Optional, Set, Tuple, TypedDict, Union, \
     Type, ClassVar
@@ -48,6 +46,7 @@ class ThreadBarrierProxy:
 class MultiWorld():
     debug_types = False
     player_name: Dict[int, str]
+    _region_cache: Dict[int, Dict[str, Region]]
     difficulty_requirements: dict
     required_medallions: dict
     dark_room_logic: Dict[int, str]
@@ -57,7 +56,7 @@ class MultiWorld():
     plando_connections: List
     worlds: Dict[int, auto_world]
     groups: Dict[int, Group]
-    regions: RegionManager
+    regions: List[Region]
     itempool: List[Item]
     is_race: bool = False
     precollected_items: Dict[int, List[Item]]
@@ -92,34 +91,6 @@ class MultiWorld():
         def __getitem__(self, player) -> bool:
             return self.rule(player)
 
-    class RegionManager:
-        region_cache: Dict[int, Dict[str, Region]]
-        entrance_cache: Dict[int, Dict[str, Entrance]]
-        location_cache: Dict[int, Dict[str, Location]]
-
-        def __init__(self, players: int):
-            self.region_cache = {player: {} for player in range(1, players+1)}
-            self.entrance_cache = {player: {} for player in range(1, players+1)}
-            self.location_cache = {player: {} for player in range(1, players+1)}
-
-        def __iadd__(self, other: Iterable[Region]):
-            self.extend(other)
-            return self
-
-        def append(self, region: Region):
-            self.region_cache[region.player][region.name] = region
-
-        def extend(self, regions: Iterable[Region]):
-            for region in regions:
-                self.region_cache[region.player][region.name] = region
-
-        def __iter__(self) -> Iterator[Region]:
-            for regions in self.region_cache.values():
-                yield from regions.values()
-
-        def __len__(self):
-            return sum(len(regions) for regions in self.region_cache.values())
-
     def __init__(self, players: int):
         # world-local random state is saved for multiple generations running concurrently
         self.random = ThreadBarrierProxy(random.Random())
@@ -128,12 +99,16 @@ class MultiWorld():
         self.glitch_triforce = False
         self.algorithm = 'balanced'
         self.groups = {}
-        self.regions = self.RegionManager(players)
+        self.regions = []
         self.shops = []
         self.itempool = []
         self.seed = None
         self.seed_name: str = "Unavailable"
         self.precollected_items = {player: [] for player in self.player_ids}
+        self._cached_entrances = None
+        self._cached_locations = None
+        self._entrance_cache = {}
+        self._location_cache: Dict[Tuple[str, int], Location] = {}
         self.required_locations = []
         self.light_world_light_cone = False
         self.dark_world_light_cone = False
@@ -161,6 +136,7 @@ class MultiWorld():
             def set_player_attr(attr, val):
                 self.__dict__.setdefault(attr, {})[player] = val
 
+            set_player_attr('_region_cache', {})
             set_player_attr('shuffle', "vanilla")
             set_player_attr('logic', "noglitches")
             set_player_attr('mode', 'open')
@@ -204,6 +180,7 @@ class MultiWorld():
             set_player_attr('plando_connections', [])
             set_player_attr('game', "A Link to the Past")
             set_player_attr('completion_condition', lambda state: True)
+        self.custom_data = {}
         self.worlds = {}
         self.per_slot_randoms = {}
         self.plando_options = PlandoOptions.none
@@ -221,9 +198,18 @@ class MultiWorld():
         new_id: int = self.players + len(self.groups) + 1
 
         self.game[new_id] = game
+        self.custom_data[new_id] = {}
         self.player_types[new_id] = NetUtils.SlotType.group
+        self._region_cache[new_id] = {}
         world_type = AutoWorld.AutoWorldRegister.world_types[game]
-        self.worlds[new_id] = world_type.create_group(self, new_id, players)
+        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)
+        for option_key, option in Options.per_game_common_options.items():
+            getattr(self, option_key)[new_id] = option(option.default)
+
+        self.worlds[new_id] = world_type(self, new_id)
         self.worlds[new_id].collect_item = classmethod(AutoWorld.World.collect_item).__get__(self.worlds[new_id])
         self.player_name[new_id] = name
 
@@ -246,23 +232,25 @@ class MultiWorld():
                                  range(1, self.players + 1)}
 
     def set_options(self, args: Namespace) -> None:
+        for option_key in Options.common_options:
+            setattr(self, option_key, getattr(args, option_key, {}))
+        for option_key in Options.per_game_common_options:
+            setattr(self, option_key, getattr(args, option_key, {}))
+
         for player in self.player_ids:
+            self.custom_data[player] = {}
             world_type = AutoWorld.AutoWorldRegister.world_types[self.game[player]]
+            for option_key in world_type.option_definitions:
+                setattr(self, option_key, getattr(args, option_key, {}))
+
             self.worlds[player] = world_type(self, player)
             self.worlds[player].random = self.per_slot_randoms[player]
-            for option_key in world_type.options_dataclass.type_hints:
-                option_values = getattr(args, option_key, {})
-                setattr(self, option_key, option_values)
-                # TODO - remove this loop once all worlds use options dataclasses
-            options_dataclass: typing.Type[Options.PerGameCommonOptions] = self.worlds[player].options_dataclass
-            self.worlds[player].options = options_dataclass(**{option_key: getattr(args, option_key)[player]
-                                                               for option_key in options_dataclass.type_hints})
 
     def set_item_links(self):
         item_links = {}
         replacement_prio = [False, True, None]
         for player in self.player_ids:
-            for item_link in self.worlds[player].options.item_links.value:
+            for item_link in self.item_links[player].value:
                 if item_link["name"] in item_links:
                     if item_links[item_link["name"]]["game"] != self.game[player]:
                         raise Exception(f"Cannot ItemLink across games. Link: {item_link['name']}")
@@ -317,6 +305,14 @@ class MultiWorld():
             group["non_local_items"] = item_link["non_local_items"]
             group["link_replacement"] = replacement_prio[item_link["link_replacement"]]
 
+    # intended for unittests
+    def set_default_common_options(self):
+        for option_key, option in Options.common_options.items():
+            setattr(self, option_key, {player_id: option(option.default) for player_id in self.player_ids})
+        for option_key, option in Options.per_game_common_options.items():
+            setattr(self, option_key, {player_id: option(option.default) for player_id in self.player_ids})
+        self.state = CollectionState(self)
+
     def secure(self):
         self.random = ThreadBarrierProxy(secrets.SystemRandom())
         self.is_race = True
@@ -325,15 +321,11 @@ class MultiWorld():
     def player_ids(self) -> Tuple[int, ...]:
         return tuple(range(1, self.players + 1))
 
-    @Utils.cache_self1
+    @functools.lru_cache()
     def get_game_players(self, game_name: str) -> Tuple[int, ...]:
         return tuple(player for player in self.player_ids if self.game[player] == game_name)
 
-    @Utils.cache_self1
-    def get_game_groups(self, game_name: str) -> Tuple[int, ...]:
-        return tuple(group_id for group_id in self.groups if self.game[group_id] == game_name)
-
-    @Utils.cache_self1
+    @functools.lru_cache()
     def get_game_worlds(self, game_name: str):
         return tuple(world for player, world in self.worlds.items() if
                      player not in self.groups and self.game[player] == game_name)
@@ -351,21 +343,50 @@ class MultiWorld():
         """ the base name (without file extension) for each player's output file for a seed """
         return f"AP_{self.seed_name}_P{player}_{self.get_file_safe_player_name(player).replace(' ', '_')}"
 
+    def initialize_regions(self, regions=None):
+        for region in regions if regions else self.regions:
+            region.multiworld = self
+            self._region_cache[region.player][region.name] = region
+
     @functools.cached_property
     def world_name_lookup(self):
         return {self.player_name[player_id]: player_id for player_id in self.player_ids}
 
-    def get_regions(self, player: Optional[int] = None) -> Collection[Region]:
-        return self.regions if player is None else self.regions.region_cache[player].values()
+    def _recache(self):
+        """Rebuild world cache"""
+        self._cached_locations = None
+        for region in self.regions:
+            player = region.player
+            self._region_cache[player][region.name] = region
+            for exit in region.exits:
+                self._entrance_cache[exit.name, player] = exit
 
-    def get_region(self, region_name: str, player: int) -> Region:
-        return self.regions.region_cache[player][region_name]
+            for r_location in region.locations:
+                self._location_cache[r_location.name, player] = r_location
 
-    def get_entrance(self, entrance_name: str, player: int) -> Entrance:
-        return self.regions.entrance_cache[player][entrance_name]
+    def get_regions(self, player=None):
+        return self.regions if player is None else self._region_cache[player].values()
 
-    def get_location(self, location_name: str, player: int) -> Location:
-        return self.regions.location_cache[player][location_name]
+    def get_region(self, regionname: str, player: int) -> Region:
+        try:
+            return self._region_cache[player][regionname]
+        except KeyError:
+            self._recache()
+            return self._region_cache[player][regionname]
+
+    def get_entrance(self, entrance: str, player: int) -> Entrance:
+        try:
+            return self._entrance_cache[entrance, player]
+        except KeyError:
+            self._recache()
+            return self._entrance_cache[entrance, player]
+
+    def get_location(self, location: str, player: int) -> Location:
+        try:
+            return self._location_cache[location, player]
+        except KeyError:
+            self._recache()
+            return self._location_cache[location, player]
 
     def get_all_state(self, use_cache: bool) -> CollectionState:
         cached = getattr(self, "_all_state", None)
@@ -426,22 +447,28 @@ class MultiWorld():
 
         logging.debug('Placed %s at %s', item, location)
 
-    def get_entrances(self, player: Optional[int] = None) -> Iterable[Entrance]:
-        if player is not None:
-            return self.regions.entrance_cache[player].values()
-        return Utils.RepeatableChain(tuple(self.regions.entrance_cache[player].values()
-                                           for player in self.regions.entrance_cache))
+    def get_entrances(self) -> List[Entrance]:
+        if self._cached_entrances is None:
+            self._cached_entrances = [entrance for region in self.regions for entrance in region.entrances]
+        return self._cached_entrances
+
+    def clear_entrance_cache(self):
+        self._cached_entrances = None
 
     def register_indirect_condition(self, region: Region, entrance: Entrance):
         """Report that access to this Region can result in unlocking this Entrance,
         state.can_reach(Region) in the Entrance's traversal condition, as opposed to pure transition logic."""
         self.indirect_connections.setdefault(region, set()).add(entrance)
 
-    def get_locations(self, player: Optional[int] = None) -> Iterable[Location]:
+    def get_locations(self, player: Optional[int] = None) -> List[Location]:
+        if self._cached_locations is None:
+            self._cached_locations = [location for region in self.regions for location in region.locations]
         if player is not None:
-            return self.regions.location_cache[player].values()
-        return Utils.RepeatableChain(tuple(self.regions.location_cache[player].values()
-                                           for player in self.regions.location_cache))
+            return [location for location in self._cached_locations if location.player == player]
+        return self._cached_locations
+
+    def clear_location_cache(self):
+        self._cached_locations = None
 
     def get_unfilled_locations(self, player: Optional[int] = None) -> List[Location]:
         return [location for location in self.get_locations(player) if location.item is None]
@@ -463,17 +490,16 @@ class MultiWorld():
                 valid_locations = [location.name for location in self.get_unfilled_locations(player)]
             else:
                 valid_locations = location_names
-            relevant_cache = self.regions.location_cache[player]
             for location_name in valid_locations:
-                location = relevant_cache.get(location_name, None)
-                if location and location.item is None:
+                location = self._location_cache.get((location_name, player), None)
+                if location is not None and location.item is None:
                     yield location
 
     def unlocks_new_location(self, item: Item) -> bool:
         temp_state = self.state.copy()
         temp_state.collect(item, True)
 
-        for location in self.get_unfilled_locations(item.player):
+        for location in self.get_unfilled_locations():
             if temp_state.can_reach(location) and not self.state.can_reach(location):
                 return True
 
@@ -605,7 +631,7 @@ PathValue = Tuple[str, Optional["PathValue"]]
 
 
 class CollectionState():
-    prog_items: Dict[int, Counter[str]]
+    prog_items: typing.Counter[Tuple[str, int]]
     multiworld: MultiWorld
     reachable_regions: Dict[int, Set[Region]]
     blocked_connections: Dict[int, Set[Entrance]]
@@ -617,7 +643,7 @@ class CollectionState():
     additional_copy_functions: List[Callable[[CollectionState, CollectionState], CollectionState]] = []
 
     def __init__(self, parent: MultiWorld):
-        self.prog_items = {player: Counter() for player in parent.player_ids}
+        self.prog_items = Counter()
         self.multiworld = parent
         self.reachable_regions = {player: set() for player in parent.get_all_ids()}
         self.blocked_connections = {player: set() for player in parent.get_all_ids()}
@@ -665,7 +691,7 @@ class CollectionState():
 
     def copy(self) -> CollectionState:
         ret = CollectionState(self.multiworld)
-        ret.prog_items = copy.deepcopy(self.prog_items)
+        ret.prog_items = self.prog_items.copy()
         ret.reachable_regions = {player: copy.copy(self.reachable_regions[player]) for player in
                                  self.reachable_regions}
         ret.blocked_connections = {player: copy.copy(self.blocked_connections[player]) for player in
@@ -709,23 +735,23 @@ class CollectionState():
                 self.collect(event.item, True, event)
 
     def has(self, item: str, player: int, count: int = 1) -> bool:
-        return self.prog_items[player][item] >= count
+        return self.prog_items[item, player] >= count
 
     def has_all(self, items: Set[str], player: int) -> bool:
         """Returns True if each item name of items is in state at least once."""
-        return all(self.prog_items[player][item] for item in items)
+        return all(self.prog_items[item, player] for item in items)
 
     def has_any(self, items: Set[str], player: int) -> bool:
         """Returns True if at least one item name of items is in state at least once."""
-        return any(self.prog_items[player][item] for item in items)
+        return any(self.prog_items[item, player] for item in items)
 
     def count(self, item: str, player: int) -> int:
-        return self.prog_items[player][item]
+        return self.prog_items[item, player]
 
     def has_group(self, item_name_group: str, player: int, count: int = 1) -> bool:
         found: int = 0
         for item_name in self.multiworld.worlds[player].item_name_groups[item_name_group]:
-            found += self.prog_items[player][item_name]
+            found += self.prog_items[item_name, player]
             if found >= count:
                 return True
         return False
@@ -733,11 +759,11 @@ class CollectionState():
     def count_group(self, item_name_group: str, player: int) -> int:
         found: int = 0
         for item_name in self.multiworld.worlds[player].item_name_groups[item_name_group]:
-            found += self.prog_items[player][item_name]
+            found += self.prog_items[item_name, player]
         return found
 
     def item_count(self, item: str, player: int) -> int:
-        return self.prog_items[player][item]
+        return self.prog_items[item, player]
 
     def collect(self, item: Item, event: bool = False, location: Optional[Location] = None) -> bool:
         if location:
@@ -746,7 +772,7 @@ class CollectionState():
         changed = self.multiworld.worlds[item.player].collect(self, item)
 
         if not changed and event:
-            self.prog_items[item.player][item.name] += 1
+            self.prog_items[item.name, item.player] += 1
             changed = True
 
         self.stale[item.player] = True
@@ -813,88 +839,28 @@ class Region:
     locations: List[Location]
     entrance_type: ClassVar[Type[Entrance]] = Entrance
 
-    class Register(MutableSequence):
-        region_manager: MultiWorld.RegionManager
-
-        def __init__(self, region_manager: MultiWorld.RegionManager):
-            self._list = []
-            self.region_manager = region_manager
-
-        def __getitem__(self, index: int) -> Location:
-            return self._list.__getitem__(index)
-
-        def __setitem__(self, index: int, value: Location) -> None:
-            raise NotImplementedError()
-
-        def __len__(self) -> int:
-            return self._list.__len__()
-
-        # This seems to not be needed, but that's a bit suspicious.
-        # def __del__(self):
-        #     self.clear()
-
-        def copy(self):
-            return self._list.copy()
-
-    class LocationRegister(Register):
-        def __delitem__(self, index: int) -> None:
-            location: Location = self._list.__getitem__(index)
-            self._list.__delitem__(index)
-            del(self.region_manager.location_cache[location.player][location.name])
-
-        def insert(self, index: int, value: Location) -> None:
-            self._list.insert(index, value)
-            self.region_manager.location_cache[value.player][value.name] = value
-
-    class EntranceRegister(Register):
-        def __delitem__(self, index: int) -> None:
-            entrance: Entrance = self._list.__getitem__(index)
-            self._list.__delitem__(index)
-            del(self.region_manager.entrance_cache[entrance.player][entrance.name])
-
-        def insert(self, index: int, value: Entrance) -> None:
-            self._list.insert(index, value)
-            self.region_manager.entrance_cache[value.player][value.name] = value
-
-    _locations: LocationRegister[Location]
-    _exits: EntranceRegister[Entrance]
-
     def __init__(self, name: str, player: int, multiworld: MultiWorld, hint: Optional[str] = None):
         self.name = name
         self.entrances = []
-        self._exits = self.EntranceRegister(multiworld.regions)
-        self._locations = self.LocationRegister(multiworld.regions)
+        self.exits = []
+        self.locations = []
         self.multiworld = multiworld
         self._hint_text = hint
         self.player = player
 
-    def get_locations(self):
-        return self._locations
-
-    def set_locations(self, new):
-        if new is self._locations:
-            return
-        self._locations.clear()
-        self._locations.extend(new)
-
-    locations = property(get_locations, set_locations)
-
-    def get_exits(self):
-        return self._exits
-
-    def set_exits(self, new):
-        if new is self._exits:
-            return
-        self._exits.clear()
-        self._exits.extend(new)
-
-    exits = property(get_exits, set_exits)
-
     def can_reach(self, state: CollectionState) -> bool:
         if state.stale[self.player]:
             state.update_reachable_regions(self.player)
         return self in state.reachable_regions[self.player]
 
+    def can_reach_private(self, state: CollectionState) -> bool:
+        for entrance in self.entrances:
+            if entrance.can_reach(state):
+                if not self in state.path:
+                    state.path[self] = (self.name, state.path.get(entrance, None))
+                return True
+        return False
+
     @property
     def hint_text(self) -> str:
         return self._hint_text if self._hint_text else self.name
@@ -911,19 +877,19 @@ class Region:
         """
         Adds locations to the Region object, where location_type is your Location class and locations is a dict of
         location names to address.
-
+        
         :param locations: dictionary of locations to be created and added to this Region `{name: ID}`
         :param location_type: Location class to be used to create the locations with"""
         if location_type is None:
             location_type = Location
         for location, address in locations.items():
             self.locations.append(location_type(self.player, location, address, self))
-
+    
     def connect(self, connecting_region: Region, name: Optional[str] = None,
-                rule: Optional[Callable[[CollectionState], bool]] = None) -> entrance_type:
+                rule: Optional[Callable[[CollectionState], bool]] = None) -> None:
         """
         Connects this Region to another Region, placing the provided rule on the connection.
-
+        
         :param connecting_region: Region object to connect to path is `self -> exiting_region`
         :param name: name of the connection being created
         :param rule: callable to determine access of this connection to go from self to the exiting_region"""
@@ -931,12 +897,11 @@ class Region:
         if rule:
             exit_.access_rule = rule
         exit_.connect(connecting_region)
-        return exit_
-
+    
     def create_exit(self, name: str) -> Entrance:
         """
         Creates and returns an Entrance object as an exit of this region.
-
+        
         :param name: name of the Entrance being created
         """
         exit_ = self.entrance_type(self.player, name, self)
@@ -1306,7 +1271,7 @@ class Spoiler:
 
     def to_file(self, filename: str) -> None:
         def write_option(option_key: str, option_obj: Options.AssembleOptions) -> None:
-            res = getattr(self.multiworld.worlds[player].options, option_key)
+            res = getattr(self.multiworld, option_key)[player]
             display_name = getattr(option_obj, "display_name", option_key)
             outfile.write(f"{display_name + ':':33}{res.current_option_name}\n")
 
@@ -1324,7 +1289,8 @@ class Spoiler:
                     outfile.write('\nPlayer %d: %s\n' % (player, self.multiworld.get_player_name(player)))
                 outfile.write('Game:                            %s\n' % self.multiworld.game[player])
 
-                for f_option, option in self.multiworld.worlds[player].options_dataclass.type_hints.items():
+                options = ChainMap(Options.per_game_common_options, self.multiworld.worlds[player].option_definitions)
+                for f_option, option in options.items():
                     write_option(f_option, option)
 
                 AutoWorld.call_single(self.multiworld, "write_spoiler_header", player, outfile)

BizHawkClient.py

@@ -1,9 +0,0 @@
-from __future__ import annotations
-
-import ModuleUpdate
-ModuleUpdate.update()
-
-from worlds._bizhawk.context import launch
-
-if __name__ == "__main__":
-    launch()

CommonClient.py

@@ -1,6 +1,4 @@
 from __future__ import annotations
-
-import copy
 import logging
 import asyncio
 import urllib.parse
@@ -244,7 +242,6 @@ class CommonContext:
         self.watcher_event = asyncio.Event()
 
         self.jsontotextparser = JSONtoTextParser(self)
-        self.rawjsontotextparser = RawJSONtoTextParser(self)
         self.update_data_package(network_data_package)
 
         # execution
@@ -380,13 +377,10 @@ class CommonContext:
 
     def on_print_json(self, args: dict):
         if self.ui:
-            # send copy to UI
-            self.ui.print_json(copy.deepcopy(args["data"]))
-
-        logging.getLogger("FileLog").info(self.rawjsontotextparser(copy.deepcopy(args["data"])),
-                                          extra={"NoStream": True})
-        logging.getLogger("StreamLog").info(self.jsontotextparser(copy.deepcopy(args["data"])),
-                                            extra={"NoFile": True})
+            self.ui.print_json(args["data"])
+        else:
+            text = self.jsontotextparser(args["data"])
+            logger.info(text)
 
     def on_package(self, cmd: str, args: dict):
         """For custom package handling in subclasses."""
@@ -882,7 +876,7 @@ def get_base_parser(description: typing.Optional[str] = None):
 def run_as_textclient():
     class TextContext(CommonContext):
         # Text Mode to use !hint and such with games that have no text entry
-        tags = CommonContext.tags | {"TextOnly"}
+        tags = {"AP", "TextOnly"}
         game = ""  # empty matches any game since 0.3.2
         items_handling = 0b111  # receive all items for /received
         want_slot_data = False  # Can't use game specific slot_data

Fill.py

@@ -5,8 +5,6 @@ import typing
 from collections import Counter, deque
 
 from BaseClasses import CollectionState, Item, Location, LocationProgressType, MultiWorld
-from Options import Accessibility
-
 from worlds.AutoWorld import call_all
 from worlds.generic.Rules import add_item_rule
 
@@ -15,10 +13,6 @@ class FillError(RuntimeError):
     pass
 
 
-def _log_fill_progress(name: str, placed: int, total_items: int) -> None:
-    logging.info(f"Current fill step ({name}) at {placed}/{total_items} items placed.")
-
-
 def sweep_from_pool(base_state: CollectionState, itempool: typing.Sequence[Item] = tuple()) -> CollectionState:
     new_state = base_state.copy()
     for item in itempool:
@@ -30,7 +24,7 @@ def sweep_from_pool(base_state: CollectionState, itempool: typing.Sequence[Item]
 def fill_restrictive(world: MultiWorld, base_state: CollectionState, locations: typing.List[Location],
                      item_pool: typing.List[Item], single_player_placement: bool = False, lock: bool = False,
                      swap: bool = True, on_place: typing.Optional[typing.Callable[[Location], None]] = None,
-                     allow_partial: bool = False, allow_excluded: bool = False, name: str = "Unknown") -> None:
+                     allow_partial: bool = False, allow_excluded: bool = False) -> None:
     """
     :param world: Multiworld to be filled.
     :param base_state: State assumed before fill.
@@ -42,20 +36,16 @@ def fill_restrictive(world: MultiWorld, base_state: CollectionState, locations:
     :param on_place: callback that is called when a placement happens
     :param allow_partial: only place what is possible. Remaining items will be in the item_pool list.
     :param allow_excluded: if true and placement fails, it is re-attempted while ignoring excluded on Locations
-    :param name: name of this fill step for progress logging purposes
     """
     unplaced_items: typing.List[Item] = []
     placements: typing.List[Location] = []
     cleanup_required = False
+
     swapped_items: typing.Counter[typing.Tuple[int, str, bool]] = Counter()
     reachable_items: typing.Dict[int, typing.Deque[Item]] = {}
     for item in item_pool:
         reachable_items.setdefault(item.player, deque()).append(item)
 
-    # for progress logging
-    total = min(len(item_pool), len(locations))
-    placed = 0
-
     while any(reachable_items.values()) and locations:
         # grab one item per player
         items_to_place = [items.pop()
@@ -80,7 +70,7 @@ def fill_restrictive(world: MultiWorld, base_state: CollectionState, locations:
             spot_to_fill: typing.Optional[Location] = None
 
             # if minimal accessibility, only check whether location is reachable if game not beatable
-            if world.worlds[item_to_place.player].options.accessibility == Accessibility.option_minimal:
+            if world.accessibility[item_to_place.player] == 'minimal':
                 perform_access_check = not world.has_beaten_game(maximum_exploration_state,
                                                                  item_to_place.player) \
                     if single_player_placement else not has_beaten_game
@@ -160,15 +150,9 @@ def fill_restrictive(world: MultiWorld, base_state: CollectionState, locations:
             spot_to_fill.locked = lock
             placements.append(spot_to_fill)
             spot_to_fill.event = item_to_place.advancement
-            placed += 1
-            if not placed % 1000:
-                _log_fill_progress(name, placed, total)
             if on_place:
                 on_place(spot_to_fill)
 
-    if total > 1000:
-        _log_fill_progress(name, placed, total)
-
     if cleanup_required:
         # validate all placements and remove invalid ones
         state = sweep_from_pool(base_state, [])
@@ -212,8 +196,6 @@ def remaining_fill(world: MultiWorld,
     unplaced_items: typing.List[Item] = []
     placements: typing.List[Location] = []
     swapped_items: typing.Counter[typing.Tuple[int, str]] = Counter()
-    total = min(len(itempool),  len(locations))
-    placed = 0
     while locations and itempool:
         item_to_place = itempool.pop()
         spot_to_fill: typing.Optional[Location] = None
@@ -263,12 +245,6 @@ def remaining_fill(world: MultiWorld,
 
         world.push_item(spot_to_fill, item_to_place, False)
         placements.append(spot_to_fill)
-        placed += 1
-        if not placed % 1000:
-            _log_fill_progress("Remaining", placed, total)
-
-    if total > 1000:
-        _log_fill_progress("Remaining", placed, total)
 
     if unplaced_items and locations:
         # There are leftover unplaceable items and locations that won't accept them
@@ -289,7 +265,7 @@ def fast_fill(world: MultiWorld,
 
 def accessibility_corrections(world: MultiWorld, state: CollectionState, locations, pool=[]):
     maximum_exploration_state = sweep_from_pool(state, pool)
-    minimal_players = {player for player in world.player_ids if world.worlds[player].options.accessibility == "minimal"}
+    minimal_players = {player for player in world.player_ids if world.accessibility[player] == "minimal"}
     unreachable_locations = [location for location in world.get_locations() if location.player in minimal_players and
                              not location.can_reach(maximum_exploration_state)]
     for location in unreachable_locations:
@@ -304,7 +280,7 @@ def accessibility_corrections(world: MultiWorld, state: CollectionState, locatio
             locations.append(location)
     if pool and locations:
         locations.sort(key=lambda loc: loc.progress_type != LocationProgressType.PRIORITY)
-        fill_restrictive(world, state, locations, pool, name="Accessibility Corrections")
+        fill_restrictive(world, state, locations, pool)
 
 
 def inaccessible_location_rules(world: MultiWorld, state: CollectionState, locations):
@@ -312,7 +288,7 @@ def inaccessible_location_rules(world: MultiWorld, state: CollectionState, locat
     unreachable_locations = [location for location in locations if not location.can_reach(maximum_exploration_state)]
     if unreachable_locations:
         def forbid_important_item_rule(item: Item):
-            return not ((item.classification & 0b0011) and world.worlds[item.player].options.accessibility != 'minimal')
+            return not ((item.classification & 0b0011) and world.accessibility[item.player] != 'minimal')
 
         for location in unreachable_locations:
             add_item_rule(location, forbid_important_item_rule)
@@ -374,25 +350,23 @@ def distribute_early_items(world: MultiWorld,
             player_local = early_local_rest_items[player]
             fill_restrictive(world, base_state,
                              [loc for loc in early_locations if loc.player == player],
-                             player_local, lock=True, allow_partial=True, name=f"Local Early Items P{player}")
+                             player_local, lock=True, allow_partial=True)
             if player_local:
                 logging.warning(f"Could not fulfill rules of early items: {player_local}")
                 early_rest_items.extend(early_local_rest_items[player])
         early_locations = [loc for loc in early_locations if not loc.item]
-        fill_restrictive(world, base_state, early_locations, early_rest_items, lock=True, allow_partial=True,
-                         name="Early Items")
+        fill_restrictive(world, base_state, early_locations, early_rest_items, lock=True, allow_partial=True)
         early_locations += early_priority_locations
         for player in world.player_ids:
             player_local = early_local_prog_items[player]
             fill_restrictive(world, base_state,
                              [loc for loc in early_locations if loc.player == player],
-                             player_local, lock=True, allow_partial=True, name=f"Local Early Progression P{player}")
+                             player_local, lock=True, allow_partial=True)
             if player_local:
                 logging.warning(f"Could not fulfill rules of early items: {player_local}")
                 early_prog_items.extend(player_local)
         early_locations = [loc for loc in early_locations if not loc.item]
-        fill_restrictive(world, base_state, early_locations, early_prog_items, lock=True, allow_partial=True,
-                         name="Early Progression")
+        fill_restrictive(world, base_state, early_locations, early_prog_items, lock=True, allow_partial=True)
         unplaced_early_items = early_rest_items + early_prog_items
         if unplaced_early_items:
             logging.warning("Ran out of early locations for early items. Failed to place "
@@ -446,14 +420,13 @@ def distribute_items_restrictive(world: MultiWorld) -> None:
 
     if prioritylocations:
         # "priority fill"
-        fill_restrictive(world, world.state, prioritylocations, progitempool, swap=False, on_place=mark_for_locking,
-                         name="Priority")
+        fill_restrictive(world, world.state, prioritylocations, progitempool, swap=False, on_place=mark_for_locking)
         accessibility_corrections(world, world.state, prioritylocations, progitempool)
         defaultlocations = prioritylocations + defaultlocations
 
     if progitempool:
-        # "advancement/progression fill"
-        fill_restrictive(world, world.state, defaultlocations, progitempool, name="Progression")
+        # "progression fill"
+        fill_restrictive(world, world.state, defaultlocations, progitempool)
         if progitempool:
             raise FillError(
                 f'Not enough locations for progress items. There are {len(progitempool)} more items than locations')
@@ -558,9 +531,9 @@ def balance_multiworld_progression(world: MultiWorld) -> None:
     # If other players are below the threshold value, swap progression in this sphere into earlier spheres,
     #   which gives more locations available by this sphere.
     balanceable_players: typing.Dict[int, float] = {
-        player: world.worlds[player].options.progression_balancing / 100
+        player: world.progression_balancing[player] / 100
         for player in world.player_ids
-        if world.worlds[player].options.progression_balancing > 0
+        if world.progression_balancing[player] > 0
     }
     if not balanceable_players:
         logging.info('Skipping multiworld progression balancing.')
@@ -780,6 +753,8 @@ def distribute_planned(world: MultiWorld) -> None:
         else:  # not reachable with swept state
             non_early_locations[loc.player].append(loc.name)
 
+    # TODO: remove. Preferably by implementing key drop
+    from worlds.alttp.Regions import key_drop_data
     world_name_lookup = world.world_name_lookup
 
     block_value = typing.Union[typing.List[str], typing.Dict[str, typing.Any], str]
@@ -865,14 +840,14 @@ def distribute_planned(world: MultiWorld) -> None:
 
             if "early_locations" in locations:
                 locations.remove("early_locations")
-                for target_player in worlds:
-                    locations += early_locations[target_player]
+                for player in worlds:
+                    locations += early_locations[player]
             if "non_early_locations" in locations:
                 locations.remove("non_early_locations")
-                for target_player in worlds:
-                    locations += non_early_locations[target_player]
+                for player in worlds:
+                    locations += non_early_locations[player]
 
-            block['locations'] = list(dict.fromkeys(locations))
+            block['locations'] = locations
 
             if not block['count']:
                 block['count'] = (min(len(block['items']), len(block['locations'])) if
@@ -922,22 +897,23 @@ def distribute_planned(world: MultiWorld) -> None:
             for item_name in items:
                 item = world.worlds[player].create_item(item_name)
                 for location in reversed(candidates):
-                    if (location.address is None) == (item.code is None):  # either both None or both not None
-                        if not location.item:
-                            if location.item_rule(item):
-                                if location.can_fill(world.state, item, False):
-                                    successful_pairs.append((item, location))
-                                    candidates.remove(location)
-                                    count = count + 1
-                                    break
-                                else:
-                                    err.append(f"Can't place item at {location} due to fill condition not met.")
+                    if location in key_drop_data:
+                        warn(
+                            f"Can't place '{item_name}' at '{placement.location}', as key drop shuffle locations are not supported yet.")
+                        continue
+                    if not location.item:
+                        if location.item_rule(item):
+                            if location.can_fill(world.state, item, False):
+                                successful_pairs.append((item, location))
+                                candidates.remove(location)
+                                count = count + 1
+                                break
                             else:
-                                err.append(f"{item_name} not allowed at {location}.")
+                                err.append(f"Can't place item at {location} due to fill condition not met.")
                         else:
-                            err.append(f"Cannot place {item_name} into already filled location {location}.")
+                            err.append(f"{item_name} not allowed at {location}.")
                     else:
-                        err.append(f"Mismatch between {item_name} and {location}, only one is an event.")
+                        err.append(f"Cannot place {item_name} into already filled location {location}.")
                 if count == maxcount:
                     break
             if count < placement['count']['min']:

Generate.py

@@ -7,8 +7,8 @@ import random
 import string
 import urllib.parse
 import urllib.request
-from collections import Counter
-from typing import Any, Dict, Tuple, Union
+from collections import ChainMap, Counter
+from typing import Any, Callable, Dict, Tuple, Union
 
 import ModuleUpdate
 
@@ -157,8 +157,7 @@ def main(args=None, callback=ERmain):
                         for yaml in weights_cache[path]:
                             if category_name is None:
                                 for category in yaml:
-                                    if category in AutoWorldRegister.world_types and \
-                                            key in Options.CommonOptions.type_hints:
+                                    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}.")
@@ -169,7 +168,7 @@ def main(args=None, callback=ERmain):
     for player in range(1, args.multi + 1):
         player_path_cache[player] = player_files.get(player, args.weights_file_path)
     name_counter = Counter()
-    erargs.player_options = {}
+    erargs.player_settings = {}
 
     player = 1
     while player <= args.multi:
@@ -225,7 +224,7 @@ def main(args=None, callback=ERmain):
         with open(os.path.join(args.outputpath if args.outputpath else ".", f"generate_{seed_name}.yaml"), "wt") as f:
             yaml.dump(important, f)
 
-    return callback(erargs, seed)
+    callback(erargs, seed)
 
 
 def read_weights_yamls(path) -> Tuple[Any, ...]:
@@ -341,7 +340,7 @@ def roll_meta_option(option_key, game: str, category_dict: Dict) -> Any:
         return get_choice(option_key, category_dict)
     if game in AutoWorldRegister.world_types:
         game_world = AutoWorldRegister.world_types[game]
-        options = game_world.options_dataclass.type_hints
+        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)
@@ -446,8 +445,8 @@ def roll_settings(weights: dict, plando_options: PlandoOptions = PlandoOptions.b
                                 f"which is not enabled.")
 
     ret = argparse.Namespace()
-    for option_key in Options.PerGameCommonOptions.type_hints:
-        if option_key in weights and option_key not in Options.CommonOptions.type_hints:
+    for option_key in Options.per_game_common_options:
+        if option_key in weights and option_key not in Options.common_options:
             raise Exception(f"Option {option_key} has to be in a game's section, not on its own.")
 
     ret.game = get_choice("game", weights)
@@ -467,11 +466,16 @@ def roll_settings(weights: dict, plando_options: PlandoOptions = PlandoOptions.b
         game_weights = weights[ret.game]
 
     ret.name = get_choice('name', weights)
-    for option_key, option in Options.CommonOptions.type_hints.items():
+    for option_key, option in Options.common_options.items():
         setattr(ret, option_key, option.from_any(get_choice(option_key, weights, option.default)))
 
-    for option_key, option in world_type.options_dataclass.type_hints.items():
+    for option_key, option in world_type.option_definitions.items():
         handle_option(ret, game_weights, option_key, option, plando_options)
+    for option_key, option in Options.per_game_common_options.items():
+        # skip setting this option if already set from common_options, defaulting to root option
+        if option_key not in world_type.option_definitions and \
+                (option_key not in Options.common_options or option_key in game_weights):
+            handle_option(ret, game_weights, option_key, option, plando_options)
     if PlandoOptions.items in plando_options:
         ret.plando_items = game_weights.get("plando_items", [])
     if ret.game == "Minecraft" or ret.game == "Ocarina of Time":
@@ -639,15 +643,6 @@ def roll_alttp_settings(ret: argparse.Namespace, weights, plando_options):
 if __name__ == '__main__':
     import atexit
     confirmation = atexit.register(input, "Press enter to close.")
-    multiworld = main()
-    if __debug__:
-        import gc
-        import sys
-        import weakref
-        weak = weakref.ref(multiworld)
-        del multiworld
-        gc.collect()  # need to collect to deref all hard references
-        assert not weak(), f"MultiWorld object was not de-allocated, it's referenced {sys.getrefcount(weak())} times." \
-                           " This would be a memory leak."
+    main()
     # in case of error-free exit should not need confirmation
     atexit.unregister(confirmation)

Launcher.py

@@ -50,22 +50,17 @@ def open_host_yaml():
 def open_patch():
     suffixes = []
     for c in components:
-        if c.type == Type.CLIENT and \
-                isinstance(c.file_identifier, SuffixIdentifier) and \
-                (c.script_name is None or isfile(get_exe(c)[-1])):
-            suffixes += c.file_identifier.suffixes
+        if isfile(get_exe(c)[-1]):
+            suffixes += c.file_identifier.suffixes if c.type == Type.CLIENT and \
+                                                      isinstance(c.file_identifier, SuffixIdentifier) else []
     try:
-        filename = open_filename("Select patch", (("Patches", suffixes),))
+        filename = open_filename('Select patch', (('Patches', suffixes),))
     except Exception as e:
-        messagebox("Error", str(e), error=True)
+        messagebox('Error', str(e), error=True)
     else:
         file, component = identify(filename)
         if file and component:
-            exe = get_exe(component)
-            if exe is None or not isfile(exe[-1]):
-                exe = get_exe("Launcher")
-
-            launch([*exe, file], component.cli)
+            launch([*get_exe(component), file], component.cli)
 
 
 def generate_yamls():
@@ -112,7 +107,7 @@ def identify(path: Union[None, str]):
         return None, None
     for component in components:
         if component.handles_file(path):
-            return path, component
+            return path,  component
         elif path == component.display_name or path == component.script_name:
             return None, component
     return None, None
@@ -122,25 +117,25 @@ def get_exe(component: Union[str, Component]) -> Optional[Sequence[str]]:
     if isinstance(component, str):
         name = component
         component = None
-        if name.startswith("Archipelago"):
+        if name.startswith('Archipelago'):
             name = name[11:]
-        if name.endswith(".exe"):
+        if name.endswith('.exe'):
             name = name[:-4]
-        if name.endswith(".py"):
+        if name.endswith('.py'):
             name = name[:-3]
         if not name:
             return None
         for c in components:
-            if c.script_name == name or c.frozen_name == f"Archipelago{name}":
+            if c.script_name == name or c.frozen_name == f'Archipelago{name}':
                 component = c
                 break
         if not component:
             return None
     if is_frozen():
-        suffix = ".exe" if is_windows else ""
-        return [local_path(f"{component.frozen_name}{suffix}")] if component.frozen_name else None
+        suffix = '.exe' if is_windows else ''
+        return [local_path(f'{component.frozen_name}{suffix}')]
     else:
-        return [sys.executable, local_path(f"{component.script_name}.py")] if component.script_name else None
+        return [sys.executable, local_path(f'{component.script_name}.py')]
 
 
 def launch(exe, in_terminal=False):

LttPAdjuster.py

@@ -23,7 +23,8 @@ from urllib.request import urlopen
 import ModuleUpdate
 ModuleUpdate.update()
 
-from worlds.alttp.Rom import Sprite, LocalRom, apply_rom_settings, get_base_rom_bytes
+from worlds.alttp.Rom import LocalRom, apply_rom_settings, get_base_rom_bytes
+from worlds.alttp.Sprites import Sprite
 from Utils import output_path, local_path, user_path, open_file, get_cert_none_ssl_context, persistent_store, \
     get_adjuster_settings, get_adjuster_settings_no_defaults, tkinter_center_window, init_logging
 
@@ -1004,7 +1005,6 @@ class SpriteSelector():
                 self.add_to_sprite_pool(sprite)
 
     def icon_section(self, frame_label, path, no_results_label):
-        os.makedirs(path, exist_ok=True)
         frame = LabelFrame(self.window, labelwidget=frame_label, padx=5, pady=5)
         frame.pack(side=TOP, fill=X)
 

Main.py

@@ -108,7 +108,7 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
     logger.info('')
 
     for player in world.player_ids:
-        for item_name, count in world.worlds[player].options.start_inventory.value.items():
+        for item_name, count in world.start_inventory[player].value.items():
             for _ in range(count):
                 world.push_precollected(world.create_item(item_name, player))
 
@@ -122,33 +122,31 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
     logger.info('Creating Items.')
     AutoWorld.call_all(world, "create_items")
 
+    # All worlds should have finished creating all regions, locations, and entrances.
+    # Recache to ensure that they are all visible for locality rules.
+    world._recache()
+
     logger.info('Calculating Access Rules.')
 
     for player in world.player_ids:
         # items can't be both local and non-local, prefer local
-        world.worlds[player].options.non_local_items.value -= world.worlds[player].options.local_items.value
-        world.worlds[player].options.non_local_items.value -= set(world.local_early_items[player])
+        world.non_local_items[player].value -= world.local_items[player].value
+        world.non_local_items[player].value -= set(world.local_early_items[player])
 
     AutoWorld.call_all(world, "set_rules")
 
     for player in world.player_ids:
-        exclusion_rules(world, player, world.worlds[player].options.exclude_locations.value)
-        world.worlds[player].options.priority_locations.value -= world.worlds[player].options.exclude_locations.value
-        for location_name in world.worlds[player].options.priority_locations.value:
-            try:
-                location = world.get_location(location_name, player)
-            except KeyError as e:  # failed to find the given location. Check if it's a legitimate location
-                if location_name not in world.worlds[player].location_name_to_id:
-                    raise Exception(f"Unable to prioritize location {location_name} in player {player}'s world.") from e
-            else:
-                location.progress_type = LocationProgressType.PRIORITY
+        exclusion_rules(world, player, world.exclude_locations[player].value)
+        world.priority_locations[player].value -= world.exclude_locations[player].value
+        for location_name in world.priority_locations[player].value:
+            world.get_location(location_name, player).progress_type = LocationProgressType.PRIORITY
 
     # Set local and non-local item rules.
     if world.players > 1:
         locality_rules(world)
     else:
-        world.worlds[1].options.non_local_items.value = set()
-        world.worlds[1].options.local_items.value = set()
+        world.non_local_items[1].value = set()
+        world.local_items[1].value = set()
     
     AutoWorld.call_all(world, "generate_basic")
 
@@ -161,8 +159,7 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
         for player, items in depletion_pool.items():
             player_world: AutoWorld.World = world.worlds[player]
             for count in items.values():
-                for _ in range(count):
-                    new_items.append(player_world.create_filler())
+                new_items.append(player_world.create_filler())
         target: int = sum(sum(items.values()) for items in depletion_pool.values())
         for i, item in enumerate(world.itempool):
             if depletion_pool[item.player].get(item.name, 0):
@@ -182,7 +179,6 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
                 if remaining_items:
                     raise Exception(f"{world.get_player_name(player)}"
                                     f" is trying to remove items from their pool that don't exist: {remaining_items}")
-        assert len(world.itempool) == len(new_items), "Item Pool amounts should not change."
         world.itempool[:] = new_items
 
     # temporary home for item links, should be moved out of Main
@@ -229,7 +225,7 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
 
         region = Region("Menu", group_id, world, "ItemLink")
         world.regions.append(region)
-        locations = region.locations
+        locations = region.locations = []
         for item in world.itempool:
             count = common_item_count.get(item.player, {}).get(item.name, 0)
             if count:
@@ -263,9 +259,10 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
             world.itempool.extend(items_to_add[:itemcount - len(world.itempool)])
 
     if any(world.item_links.values()):
+        world._recache()
         world._all_state = None
 
-    logger.info("Running Item Plando.")
+    logger.info("Running Item Plando")
 
     distribute_planned(world)
 
@@ -296,16 +293,15 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
 
     output = tempfile.TemporaryDirectory()
     with output as temp_dir:
-        output_players = [player for player in world.player_ids if AutoWorld.World.generate_output.__code__
-                          is not world.worlds[player].generate_output.__code__]
-        with concurrent.futures.ThreadPoolExecutor(len(output_players) + 2) as pool:
+        with concurrent.futures.ThreadPoolExecutor(world.players + 2) as pool:
             check_accessibility_task = pool.submit(world.fulfills_accessibility)
 
             output_file_futures = [pool.submit(AutoWorld.call_stage, world, "generate_output", temp_dir)]
-            for player in output_players:
+            for player in world.player_ids:
                 # skip starting a thread for methods that say "pass".
-                output_file_futures.append(
-                    pool.submit(AutoWorld.call_single, world, "generate_output", player, temp_dir))
+                if AutoWorld.World.generate_output.__code__ is not world.worlds[player].generate_output.__code__:
+                    output_file_futures.append(
+                        pool.submit(AutoWorld.call_single, world, "generate_output", player, temp_dir))
 
             # collect ER hint info
             er_hint_data: Dict[int, Dict[int, str]] = {}
@@ -356,16 +352,13 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
                                                                f" {location}"
                         locations_data[location.player][location.address] = \
                             location.item.code, location.item.player, location.item.flags
-                        if location.name in world.worlds[location.player].options.start_location_hints:
+                        if location.name in world.start_location_hints[location.player]:
                             precollect_hint(location)
-                        elif location.item.name in world.worlds[location.item.player].options.start_hints:
+                        elif location.item.name in world.start_hints[location.item.player]:
                             precollect_hint(location)
-                        elif any([location.item.name in world.worlds[player].options.start_hints
+                        elif any([location.item.name in world.start_hints[player]
                                   for player in world.groups.get(location.item.player, {}).get("players", [])]):
                             precollect_hint(location)
-                    elif __debug__ and location.item.code is not None:
-                        raise Exception(f"Intended to be sendable item {location.item}, "
-                                        f"was placed on never sendable location {location} of {location.game}.")
 
                 # embedded data package
                 data_package = {
@@ -399,7 +392,7 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
                     f.write(bytes([3]))  # version of format
                     f.write(multidata)
 
-            output_file_futures.append(pool.submit(write_multidata))
+            multidata_task = pool.submit(write_multidata)
             if not check_accessibility_task.result():
                 if not world.can_beat_game():
                     raise Exception("Game appears as unbeatable. Aborting.")
@@ -407,6 +400,7 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
                     logger.warning("Location Accessibility requirements not fulfilled.")
 
             # retrieve exceptions via .result() if they occurred.
+            multidata_task.result()
             for i, future in enumerate(concurrent.futures.as_completed(output_file_futures), start=1):
                 if i % 10 == 0 or i == len(output_file_futures):
                     logger.info(f'Generating output files ({i}/{len(output_file_futures)}).')

ModuleUpdate.py

@@ -67,23 +67,14 @@ def update(yes=False, force=False):
         install_pkg_resources(yes=yes)
         import pkg_resources
 
-        prev = ""  # if a line ends in \ we store here and merge later
         for req_file in requirements_files:
             path = os.path.join(os.path.dirname(sys.argv[0]), req_file)
             if not os.path.exists(path):
                 path = os.path.join(os.path.dirname(__file__), req_file)
             with open(path) as requirementsfile:
                 for line in requirementsfile:
-                    if not line or line.lstrip(" \t")[0] == "#":
-                        if not prev:
-                            continue  # ignore comments
-                        line = ""
-                    elif line.rstrip("\r\n").endswith("\\"):
-                        prev = prev + line.rstrip("\r\n")[:-1] + " "  # continue on next line
-                        continue
-                    line = prev + line
-                    line = line.split("--hash=")[0]  # remove hashes from requirement for version checking
-                    prev = ""
+                    if not line or line[0] == "#":
+                        continue  # ignore comments
                     if line.startswith(("https://", "git+https://")):
                         # extract name and version for url
                         rest = line.split('/')[-1]

NetUtils.py

@@ -408,21 +408,13 @@ if typing.TYPE_CHECKING:  # type-check with pure python implementation until we
     LocationStore = _LocationStore
 else:
     try:
-        from _speedups import LocationStore
-        import _speedups
-        import os.path
-        if os.path.isfile("_speedups.pyx") and os.path.getctime(_speedups.__file__) < os.path.getctime("_speedups.pyx"):
-            warnings.warn(f"{_speedups.__file__} outdated! "
-                          f"Please rebuild with `cythonize -b -i _speedups.pyx` or delete it!")
+        import pyximport
+        pyximport.install()
     except ImportError:
-        try:
-            import pyximport
-            pyximport.install()
-        except ImportError:
-            pyximport = None
-        try:
-            from _speedups import LocationStore
-        except ImportError:
-            warnings.warn("_speedups not available. Falling back to pure python LocationStore. "
-                          "Install a matching C++ compiler for your platform to compile _speedups.")
-            LocationStore = _LocationStore
+        pyximport = None
+    try:
+        from _speedups import LocationStore
+    except ImportError:
+        warnings.warn("_speedups not available. Falling back to pure python LocationStore. "
+                      "Install a matching C++ compiler for your platform to compile _speedups.")
+        LocationStore = _LocationStore

Options.py

@@ -2,9 +2,6 @@ from __future__ import annotations
 
 import abc
 import logging
-from copy import deepcopy
-from dataclasses import dataclass
-import functools
 import math
 import numbers
 import random
@@ -214,12 +211,6 @@ class NumericOption(Option[int], numbers.Integral, abc.ABC):
         else:
             return self.value > other
 
-    def __ge__(self, other: typing.Union[int, NumericOption]) -> bool:
-        if isinstance(other, NumericOption):
-            return self.value >= other.value
-        else:
-            return self.value >= other
-
     def __bool__(self) -> bool:
         return bool(self.value)
 
@@ -905,58 +896,10 @@ class ProgressionBalancing(SpecialRange):
     }
 
 
-class OptionsMetaProperty(type):
-    def __new__(mcs,
-                name: str,
-                bases: typing.Tuple[type, ...],
-                attrs: typing.Dict[str, typing.Any]) -> "OptionsMetaProperty":
-        for attr_type in attrs.values():
-            assert not isinstance(attr_type, AssembleOptions),\
-                f"Options for {name} should be type hinted on the class, not assigned"
-        return super().__new__(mcs, name, bases, attrs)
-
-    @property
-    @functools.lru_cache(maxsize=None)
-    def type_hints(cls) -> typing.Dict[str, typing.Type[Option[typing.Any]]]:
-        """Returns type hints of the class as a dictionary."""
-        return typing.get_type_hints(cls)
-
-
-@dataclass
-class CommonOptions(metaclass=OptionsMetaProperty):
-    progression_balancing: ProgressionBalancing
-    accessibility: Accessibility
-
-    def as_dict(self, *option_names: str, casing: str = "snake") -> typing.Dict[str, typing.Any]:
-        """
-        Returns a dictionary of [str, Option.value]
-        
-        :param option_names: names of the options to return
-        :param casing: case of the keys to return. Supports `snake`, `camel`, `pascal`, `kebab`
-        """
-        option_results = {}
-        for option_name in option_names:
-            if option_name in type(self).type_hints:
-                if casing == "snake":
-                    display_name = option_name
-                elif casing == "camel":
-                    split_name = [name.title() for name in option_name.split("_")]
-                    split_name[0] = split_name[0].lower()
-                    display_name = "".join(split_name)
-                elif casing == "pascal":
-                    display_name = "".join([name.title() for name in option_name.split("_")])
-                elif casing == "kebab":
-                    display_name = option_name.replace("_", "-")
-                else:
-                    raise ValueError(f"{casing} is invalid casing for as_dict. "
-                                     "Valid names are 'snake', 'camel', 'pascal', 'kebab'.")
-                value = getattr(self, option_name).value
-                if isinstance(value, set):
-                    value = sorted(value)
-                option_results[display_name] = value
-            else:
-                raise ValueError(f"{option_name} not found in {tuple(type(self).type_hints)}")
-        return option_results
+common_options = {
+    "progression_balancing": ProgressionBalancing,
+    "accessibility": Accessibility
+}
 
 
 class LocalItems(ItemSet):
@@ -1077,16 +1020,17 @@ class ItemLinks(OptionList):
             link.setdefault("link_replacement", None)
 
 
-@dataclass
-class PerGameCommonOptions(CommonOptions):
-    local_items: LocalItems
-    non_local_items: NonLocalItems
-    start_inventory: StartInventory
-    start_hints: StartHints
-    start_location_hints: StartLocationHints
-    exclude_locations: ExcludeLocations
-    priority_locations: PriorityLocations
-    item_links: ItemLinks
+per_game_common_options = {
+    **common_options,  # can be overwritten per-game
+    "local_items": LocalItems,
+    "non_local_items": NonLocalItems,
+    "start_inventory": StartInventory,
+    "start_hints": StartHints,
+    "start_location_hints": StartLocationHints,
+    "exclude_locations": ExcludeLocations,
+    "priority_locations": PriorityLocations,
+    "item_links": ItemLinks
+}
 
 
 def generate_yaml_templates(target_folder: typing.Union[str, "pathlib.Path"], generate_hidden: bool = True):
@@ -1127,7 +1071,10 @@ def generate_yaml_templates(target_folder: typing.Union[str, "pathlib.Path"], ge
 
     for game_name, world in AutoWorldRegister.world_types.items():
         if not world.hidden or generate_hidden:
-            all_options: typing.Dict[str, AssembleOptions] = world.options_dataclass.type_hints
+            all_options: typing.Dict[str, AssembleOptions] = {
+                **per_game_common_options,
+                **world.option_definitions
+            }
 
             with open(local_path("data", "options.yaml")) as f:
                 file_data = f.read()

SNIClient.py

@@ -68,11 +68,12 @@ class SNIClientCommandProcessor(ClientCommandProcessor):
         options = snes_options.split()
         num_options = len(options)
 
+        if num_options > 0:
+            snes_device_number = int(options[0])
+
         if num_options > 1:
             snes_address = options[0]
             snes_device_number = int(options[1])
-        elif num_options > 0:
-            snes_device_number = int(options[0])
 
         self.ctx.snes_reconnect_address = None
         if self.ctx.snes_connect_task:
@@ -207,12 +208,12 @@ class SNIContext(CommonContext):
             self.killing_player_task = asyncio.create_task(deathlink_kill_player(self))
         super(SNIContext, self).on_deathlink(data)
 
-    async def handle_deathlink_state(self, currently_dead: bool, death_text: str = "") -> None:
+    async def handle_deathlink_state(self, currently_dead: bool) -> None:
         # in this state we only care about triggering a death send
         if self.death_state == DeathState.alive:
             if currently_dead:
                 self.death_state = DeathState.dead
-                await self.send_death(death_text)
+                await self.send_death()
         # in this state we care about confirming a kill, to move state to dead
         elif self.death_state == DeathState.killing_player:
             # this is being handled in deathlink_kill_player(ctx) already
@@ -564,16 +565,14 @@ async def snes_write(ctx: SNIContext, write_list: typing.List[typing.Tuple[int,
         PutAddress_Request: SNESRequest = {"Opcode": "PutAddress", "Operands": [], 'Space': 'SNES'}
         try:
             for address, data in write_list:
-                while data:
-                    # Divide the write into packets of 256 bytes.
-                    PutAddress_Request['Operands'] = [hex(address)[2:], hex(min(len(data), 256))[2:]]
-                    if ctx.snes_socket is not None:
-                        await ctx.snes_socket.send(dumps(PutAddress_Request))
-                        await ctx.snes_socket.send(data[:256])
-                        address += 256
-                        data = data[256:]
-                    else:
-                        snes_logger.warning(f"Could not send data to SNES: {data}")
+                PutAddress_Request['Operands'] = [hex(address)[2:], hex(len(data))[2:]]
+                # REVIEW: above: `if snes_socket is None: return False`
+                # Does it need to be checked again?
+                if ctx.snes_socket is not None:
+                    await ctx.snes_socket.send(dumps(PutAddress_Request))
+                    await ctx.snes_socket.send(data)
+                else:
+                    snes_logger.warning(f"Could not send data to SNES: {data}")
         except ConnectionClosed:
             return False
 

UndertaleClient.py

@@ -29,31 +29,31 @@ class UndertaleCommandProcessor(ClientCommandProcessor):
     def _cmd_patch(self):
         """Patch the game."""
         if isinstance(self.ctx, UndertaleContext):
-            os.makedirs(name=os.path.join(os.getcwd(), "Undertale"), exist_ok=True)
+            os.makedirs(name=os.getcwd() + "\\Undertale", exist_ok=True)
             self.ctx.patch_game()
             self.output("Patched.")
 
     def _cmd_savepath(self, directory: str):
         """Redirect to proper save data folder. (Use before connecting!)"""
         if isinstance(self.ctx, UndertaleContext):
-            self.ctx.save_game_folder = directory
-            self.output("Changed to the following directory: " + self.ctx.save_game_folder)
+            UndertaleContext.save_game_folder = directory
+            self.output("Changed to the following directory: " + directory)
 
     @mark_raw
     def _cmd_auto_patch(self, steaminstall: typing.Optional[str] = None):
         """Patch the game automatically."""
         if isinstance(self.ctx, UndertaleContext):
-            os.makedirs(name=os.path.join(os.getcwd(), "Undertale"), exist_ok=True)
+            os.makedirs(name=os.getcwd() + "\\Undertale", exist_ok=True)
             tempInstall = steaminstall
             if not os.path.isfile(os.path.join(tempInstall, "data.win")):
                 tempInstall = None
             if tempInstall is None:
                 tempInstall = "C:\\Program Files (x86)\\Steam\\steamapps\\common\\Undertale"
-                if not os.path.exists(tempInstall):
+                if not os.path.exists("C:\\Program Files (x86)\\Steam\\steamapps\\common\\Undertale"):
                     tempInstall = "C:\\Program Files\\Steam\\steamapps\\common\\Undertale"
             elif not os.path.exists(tempInstall):
                 tempInstall = "C:\\Program Files (x86)\\Steam\\steamapps\\common\\Undertale"
-                if not os.path.exists(tempInstall):
+                if not os.path.exists("C:\\Program Files (x86)\\Steam\\steamapps\\common\\Undertale"):
                     tempInstall = "C:\\Program Files\\Steam\\steamapps\\common\\Undertale"
             if not os.path.exists(tempInstall) or not os.path.exists(tempInstall) or not os.path.isfile(os.path.join(tempInstall, "data.win")):
                 self.output("ERROR: Cannot find Undertale. Please rerun the command with the correct folder."
@@ -61,8 +61,8 @@ class UndertaleCommandProcessor(ClientCommandProcessor):
             else:
                 for file_name in os.listdir(tempInstall):
                     if file_name != "steam_api.dll":
-                        shutil.copy(os.path.join(tempInstall, file_name),
-                               os.path.join(os.getcwd(), "Undertale", file_name))
+                        shutil.copy(tempInstall+"\\"+file_name,
+                               os.getcwd() + "\\Undertale\\" + file_name)
                 self.ctx.patch_game()
                 self.output("Patching successful!")
 
@@ -111,13 +111,13 @@ class UndertaleContext(CommonContext):
         self.save_game_folder = os.path.expandvars(r"%localappdata%/UNDERTALE")
 
     def patch_game(self):
-        with open(os.path.join(os.getcwd(), "Undertale", "data.win"), "rb") as f:
+        with open(os.getcwd() + "/Undertale/data.win", "rb") as f:
             patchedFile = bsdiff4.patch(f.read(), undertale.data_path("patch.bsdiff"))
-        with open(os.path.join(os.getcwd(), "Undertale", "data.win"), "wb") as f:
+        with open(os.getcwd() + "/Undertale/data.win", "wb") as f:
             f.write(patchedFile)
-        os.makedirs(name=os.path.join(os.getcwd(), "Undertale", "Custom Sprites"), exist_ok=True)
-        with open(os.path.expandvars(os.path.join(os.getcwd(), "Undertale", "Custom Sprites",
-                                     "Which Character.txt")), "w") as f:
+        os.makedirs(name=os.getcwd() + "\\Undertale\\" + "Custom Sprites", exist_ok=True)
+        with open(os.path.expandvars(os.getcwd() + "\\Undertale\\" + "Custom Sprites\\" +
+                                     "Which Character.txt"), "w") as f:
             f.writelines(["// Put the folder name of the sprites you want to play as, make sure it is the only "
                           "line other than this one.\n", "frisk"])
             f.close()
@@ -385,7 +385,7 @@ async def multi_watcher(ctx: UndertaleContext):
         for root, dirs, files in os.walk(path):
             for file in files:
                 if "spots.mine" in file and "Online" in ctx.tags:
-                    with open(os.path.join(root, file), "r") as mine:
+                    with open(root + "/" + file, "r") as mine:
                         this_x = mine.readline()
                         this_y = mine.readline()
                         this_room = mine.readline()
@@ -408,7 +408,7 @@ async def game_watcher(ctx: UndertaleContext):
             for root, dirs, files in os.walk(path):
                 for file in files:
                     if ".item" in file:
-                        os.remove(os.path.join(root, file))
+                        os.remove(root+"/"+file)
             sync_msg = [{"cmd": "Sync"}]
             if ctx.locations_checked:
                 sync_msg.append({"cmd": "LocationChecks", "locations": list(ctx.locations_checked)})
@@ -424,13 +424,13 @@ async def game_watcher(ctx: UndertaleContext):
         for root, dirs, files in os.walk(path):
             for file in files:
                 if "DontBeMad.mad" in file:
-                    os.remove(os.path.join(root, file))
+                    os.remove(root+"/"+file)
                     if "DeathLink" in ctx.tags:
                         await ctx.send_death()
                 if "scout" == file:
                     sending = []
                     try:
-                        with open(os.path.join(root, file), "r") as f:
+                        with open(root+"/"+file, "r") as f:
                             lines = f.readlines()
                         for l in lines:
                             if ctx.server_locations.__contains__(int(l)+12000):
@@ -438,11 +438,11 @@ async def game_watcher(ctx: UndertaleContext):
                     finally:
                         await ctx.send_msgs([{"cmd": "LocationScouts", "locations": sending,
                                                           "create_as_hint": int(2)}])
-                        os.remove(os.path.join(root, file))
+                        os.remove(root+"/"+file)
                 if "check.spot" in file:
                     sending = []
                     try:
-                        with open(os.path.join(root, file), "r") as f:
+                        with open(root+"/"+file, "r") as f:
                             lines = f.readlines()
                         for l in lines:
                             sending = sending+[(int(l.rstrip('\n')))+12000]
@@ -451,7 +451,7 @@ async def game_watcher(ctx: UndertaleContext):
                 if "victory" in file and str(ctx.route) in file:
                     victory = True
                 if ".playerspot" in file and "Online" not in ctx.tags:
-                    os.remove(os.path.join(root, file))
+                    os.remove(root+"/"+file)
                 if "victory" in file:
                     if str(ctx.route) == "all_routes":
                         if "neutral" in file and ctx.completed_routes["neutral"] != 1:

Utils.py

@@ -5,7 +5,6 @@ import json
 import typing
 import builtins
 import os
-import itertools
 import subprocess
 import sys
 import pickle
@@ -14,7 +13,6 @@ import io
 import collections
 import importlib
 import logging
-import warnings
 
 from argparse import Namespace
 from settings import Settings, get_settings
@@ -31,7 +29,6 @@ except ImportError:
 if typing.TYPE_CHECKING:
     import tkinter
     import pathlib
-    from BaseClasses import Region
 
 
 def tuplize_version(version: str) -> Version:
@@ -47,7 +44,7 @@ class Version(typing.NamedTuple):
         return ".".join(str(item) for item in self)
 
 
-__version__ = "0.4.3"
+__version__ = "0.4.2"
 version_tuple = tuplize_version(__version__)
 
 is_linux = sys.platform.startswith("linux")
@@ -74,8 +71,6 @@ def snes_to_pc(value: int) -> int:
 
 
 RetType = typing.TypeVar("RetType")
-S = typing.TypeVar("S")
-T = typing.TypeVar("T")
 
 
 def cache_argsless(function: typing.Callable[[], RetType]) -> typing.Callable[[], RetType]:
@@ -93,31 +88,6 @@ def cache_argsless(function: typing.Callable[[], RetType]) -> typing.Callable[[]
     return _wrap
 
 
-def cache_self1(function: typing.Callable[[S, T], RetType]) -> typing.Callable[[S, T], RetType]:
-    """Specialized cache for self + 1 arg. Does not keep global ref to self and skips building a dict key tuple."""
-
-    assert function.__code__.co_argcount == 2, "Can only cache 2 argument functions with this cache."
-
-    cache_name = f"__cache_{function.__name__}__"
-
-    @functools.wraps(function)
-    def wrap(self: S, arg: T) -> RetType:
-        cache: Optional[Dict[T, RetType]] = typing.cast(Optional[Dict[T, RetType]],
-                                                        getattr(self, cache_name, None))
-        if cache is None:
-            res = function(self, arg)
-            setattr(self, cache_name, {arg: res})
-            return res
-        try:
-            return cache[arg]
-        except KeyError:
-            res = function(self, arg)
-            cache[arg] = res
-            return res
-
-    return wrap
-
-
 def is_frozen() -> bool:
     return typing.cast(bool, getattr(sys, 'frozen', False))
 
@@ -174,16 +144,12 @@ def user_path(*path: str) -> str:
         if user_path.cached_path != local_path():
             import filecmp
             if not os.path.exists(user_path("manifest.json")) or \
-                    not os.path.exists(local_path("manifest.json")) or \
                     not filecmp.cmp(local_path("manifest.json"), user_path("manifest.json"), shallow=True):
                 import shutil
-                for dn in ("Players", "data/sprites", "data/lua"):
+                for dn in ("Players", "data/sprites"):
                     shutil.copytree(local_path(dn), user_path(dn), dirs_exist_ok=True)
-                if not os.path.exists(local_path("manifest.json")):
-                    warnings.warn(f"Upgrading {user_path()} from something that is not a proper install")
-                else:
-                    shutil.copy2(local_path("manifest.json"), user_path("manifest.json"))
-            os.makedirs(user_path("worlds"), exist_ok=True)
+                for fn in ("manifest.json",):
+                    shutil.copy2(local_path(fn), user_path(fn))
 
     return os.path.join(user_path.cached_path, *path)
 
@@ -249,13 +215,7 @@ def get_cert_none_ssl_context():
 def get_public_ipv4() -> str:
     import socket
     import urllib.request
-    try:
-        ip = socket.gethostbyname(socket.gethostname())
-    except socket.gaierror:
-        # if hostname or resolvconf is not set up properly, this may fail
-        warnings.warn("Could not resolve own hostname, falling back to 127.0.0.1")
-        ip = "127.0.0.1"
-
+    ip = socket.gethostbyname(socket.gethostname())
     ctx = get_cert_none_ssl_context()
     try:
         ip = urllib.request.urlopen("https://checkip.amazonaws.com/", context=ctx, timeout=10).read().decode("utf8").strip()
@@ -273,13 +233,7 @@ def get_public_ipv4() -> str:
 def get_public_ipv6() -> str:
     import socket
     import urllib.request
-    try:
-        ip = socket.gethostbyname(socket.gethostname())
-    except socket.gaierror:
-        # if hostname or resolvconf is not set up properly, this may fail
-        warnings.warn("Could not resolve own hostname, falling back to ::1")
-        ip = "::1"
-
+    ip = socket.gethostbyname(socket.gethostname())
     ctx = get_cert_none_ssl_context()
     try:
         ip = urllib.request.urlopen("https://v6.ident.me", context=ctx, timeout=10).read().decode("utf8").strip()
@@ -289,13 +243,15 @@ def get_public_ipv6() -> str:
     return ip
 
 
-OptionsType = Settings  # TODO: remove when removing get_options
+OptionsType = Settings  # TODO: remove ~2 versions after 0.4.1
 
 
-def get_options() -> Settings:
-    # TODO: switch to Utils.deprecate after 0.4.4
-    warnings.warn("Utils.get_options() is deprecated. Use the settings API instead.", DeprecationWarning)
-    return get_settings()
+@cache_argsless
+def get_default_options() -> Settings:  # TODO: remove ~2 versions after 0.4.1
+    return Settings(None)
+
+
+get_options = get_settings  # TODO: add a warning ~2 versions after 0.4.1 and remove once all games are ported
 
 
 def persistent_store(category: str, key: typing.Any, value: typing.Any):
@@ -403,13 +359,11 @@ safe_builtins = frozenset((
 
 
 class RestrictedUnpickler(pickle.Unpickler):
-    generic_properties_module: Optional[object]
-
     def __init__(self, *args, **kwargs):
         super(RestrictedUnpickler, self).__init__(*args, **kwargs)
         self.options_module = importlib.import_module("Options")
         self.net_utils_module = importlib.import_module("NetUtils")
-        self.generic_properties_module = None
+        self.generic_properties_module = importlib.import_module("worlds.generic")
 
     def find_class(self, module, name):
         if module == "builtins" and name in safe_builtins:
@@ -419,8 +373,6 @@ class RestrictedUnpickler(pickle.Unpickler):
             return getattr(self.net_utils_module, name)
         # Options and Plando are unpickled by WebHost -> Generate
         if module == "worlds.generic" and name in {"PlandoItem", "PlandoConnection"}:
-            if not self.generic_properties_module:
-                self.generic_properties_module = importlib.import_module("worlds.generic")
             return getattr(self.generic_properties_module, name)
         # pep 8 specifies that modules should have "all-lowercase names" (options, not Options)
         if module.lower().endswith("options"):
@@ -489,21 +441,11 @@ def init_logging(name: str, loglevel: typing.Union[str, int] = logging.INFO, wri
         write_mode,
         encoding="utf-8-sig")
     file_handler.setFormatter(logging.Formatter(log_format))
-
-    class Filter(logging.Filter):
-        def __init__(self, filter_name, condition):
-            super().__init__(filter_name)
-            self.condition = condition
-
-        def filter(self, record: logging.LogRecord) -> bool:
-            return self.condition(record)
-
-    file_handler.addFilter(Filter("NoStream", lambda record: not getattr(record,  "NoFile", False)))
     root_logger.addHandler(file_handler)
     if sys.stdout:
-        stream_handler = logging.StreamHandler(sys.stdout)
-        stream_handler.addFilter(Filter("NoFile", lambda record: not getattr(record, "NoStream", False)))
-        root_logger.addHandler(stream_handler)
+        root_logger.addHandler(
+            logging.StreamHandler(sys.stdout)
+        )
 
     # Relay unhandled exceptions to logger.
     if not getattr(sys.excepthook, "_wrapped", False):  # skip if already modified
@@ -630,7 +572,7 @@ def open_filename(title: str, filetypes: typing.Sequence[typing.Tuple[str, typin
         zenity = which("zenity")
         if zenity:
             z_filters = (f'--file-filter={text} ({", ".join(ext)}) | *{" *".join(ext)}' for (text, ext) in filetypes)
-            selection = (f"--filename={suggest}",) if suggest else ()
+            selection = (f'--filename="{suggest}',) if suggest else ()
             return run(zenity, f"--title={title}", "--file-selection", *z_filters, *selection)
 
     # fall back to tk
@@ -642,10 +584,7 @@ def open_filename(title: str, filetypes: typing.Sequence[typing.Tuple[str, typin
                       f'This attempt was made because open_filename was used for "{title}".')
         raise e
     else:
-        try:
-            root = tkinter.Tk()
-        except tkinter.TclError:
-            return None  # GUI not available. None is the same as a user clicking "cancel"
+        root = tkinter.Tk()
         root.withdraw()
         return tkinter.filedialog.askopenfilename(title=title, filetypes=((t[0], ' '.join(t[1])) for t in filetypes),
                                                   initialfile=suggest or None)
@@ -658,14 +597,13 @@ def open_directory(title: str, suggest: str = "") -> typing.Optional[str]:
     if is_linux:
         # prefer native dialog
         from shutil import which
-        kdialog = which("kdialog")
+        kdialog = None#which("kdialog")
         if kdialog:
-            return run(kdialog, f"--title={title}", "--getexistingdirectory",
-                       os.path.abspath(suggest) if suggest else ".")
-        zenity = which("zenity")
+            return run(kdialog, f"--title={title}", "--getexistingdirectory", suggest or ".")
+        zenity = None#which("zenity")
         if zenity:
             z_filters = ("--directory",)
-            selection = (f"--filename={os.path.abspath(suggest)}/",) if suggest else ()
+            selection = (f'--filename="{suggest}',) if suggest else ()
             return run(zenity, f"--title={title}", "--file-selection", *z_filters, *selection)
 
     # fall back to tk
@@ -677,10 +615,7 @@ def open_directory(title: str, suggest: str = "") -> typing.Optional[str]:
                       f'This attempt was made because open_filename was used for "{title}".')
         raise e
     else:
-        try:
-            root = tkinter.Tk()
-        except tkinter.TclError:
-            return None  # GUI not available. None is the same as a user clicking "cancel"
+        root = tkinter.Tk()
         root.withdraw()
         return tkinter.filedialog.askdirectory(title=title, mustexist=True, initialdir=suggest or None)
 
@@ -710,11 +645,6 @@ def messagebox(title: str, text: str, error: bool = False) -> None:
         if zenity:
             return run(zenity, f"--title={title}", f"--text={text}", "--error" if error else "--info")
 
-    elif is_windows:
-        import ctypes
-        style = 0x10 if error else 0x0
-        return ctypes.windll.user32.MessageBoxW(0, text, title, style)
-    
     # fall back to tk
     try:
         import tkinter
@@ -825,127 +755,3 @@ def freeze_support() -> None:
     import multiprocessing
     _extend_freeze_support()
     multiprocessing.freeze_support()
-
-
-def visualize_regions(root_region: Region, file_name: str, *,
-                      show_entrance_names: bool = False, show_locations: bool = True, show_other_regions: bool = True,
-                      linetype_ortho: bool = True) -> None:
-    """Visualize the layout of a world as a PlantUML diagram.
-
-    :param root_region: The region from which to start the diagram from. (Usually the "Menu" region of your world.)
-    :param file_name: The name of the destination .puml file.
-    :param show_entrance_names: (default False) If enabled, the name of the entrance will be shown near each connection.
-    :param show_locations: (default True) If enabled, the locations will be listed inside each region.
-            Priority locations will be shown in bold.
-            Excluded locations will be stricken out.
-            Locations without ID will be shown in italics.
-            Locked locations will be shown with a padlock icon.
-            For filled locations, the item name will be shown after the location name.
-            Progression items will be shown in bold.
-            Items without ID will be shown in italics.
-    :param show_other_regions: (default True) If enabled, regions that can't be reached by traversing exits are shown.
-    :param linetype_ortho: (default True) If enabled, orthogonal straight line parts will be used; otherwise polylines.
-
-    Example usage in World code:
-    from Utils import visualize_regions
-    visualize_regions(self.multiworld.get_region("Menu", self.player), "my_world.puml")
-
-    Example usage in Main code:
-    from Utils import visualize_regions
-    for player in world.player_ids:
-        visualize_regions(world.get_region("Menu", player), f"{world.get_out_file_name_base(player)}.puml")
-    """
-    assert root_region.multiworld, "The multiworld attribute of root_region has to be filled"
-    from BaseClasses import Entrance, Item, Location, LocationProgressType, MultiWorld, Region
-    from collections import deque
-    import re
-
-    uml: typing.List[str] = list()
-    seen: typing.Set[Region] = set()
-    regions: typing.Deque[Region] = deque((root_region,))
-    multiworld: MultiWorld = root_region.multiworld
-
-    def fmt(obj: Union[Entrance, Item, Location, Region]) -> str:
-        name = obj.name
-        if isinstance(obj, Item):
-            name = multiworld.get_name_string_for_object(obj)
-            if obj.advancement:
-                name = f"**{name}**"
-            if obj.code is None:
-                name = f"//{name}//"
-        if isinstance(obj, Location):
-            if obj.progress_type == LocationProgressType.PRIORITY:
-                name = f"**{name}**"
-            elif obj.progress_type == LocationProgressType.EXCLUDED:
-                name = f"--{name}--"
-            if obj.address is None:
-                name = f"//{name}//"
-        return re.sub("[\".:]", "", name)
-
-    def visualize_exits(region: Region) -> None:
-        for exit_ in region.exits:
-            if exit_.connected_region:
-                if show_entrance_names:
-                    uml.append(f"\"{fmt(region)}\" --> \"{fmt(exit_.connected_region)}\" : \"{fmt(exit_)}\"")
-                else:
-                    try:
-                        uml.remove(f"\"{fmt(exit_.connected_region)}\" --> \"{fmt(region)}\"")
-                        uml.append(f"\"{fmt(exit_.connected_region)}\" <--> \"{fmt(region)}\"")
-                    except ValueError:
-                        uml.append(f"\"{fmt(region)}\" --> \"{fmt(exit_.connected_region)}\"")
-            else:
-                uml.append(f"circle \"unconnected exit:\\n{fmt(exit_)}\"")
-                uml.append(f"\"{fmt(region)}\" --> \"unconnected exit:\\n{fmt(exit_)}\"")
-
-    def visualize_locations(region: Region) -> None:
-        any_lock = any(location.locked for location in region.locations)
-        for location in region.locations:
-            lock = "<&lock-locked> " if location.locked else "<&lock-unlocked,color=transparent> " if any_lock else ""
-            if location.item:
-                uml.append(f"\"{fmt(region)}\" : {{method}} {lock}{fmt(location)}: {fmt(location.item)}")
-            else:
-                uml.append(f"\"{fmt(region)}\" : {{field}} {lock}{fmt(location)}")
-
-    def visualize_region(region: Region) -> None:
-        uml.append(f"class \"{fmt(region)}\"")
-        if show_locations:
-            visualize_locations(region)
-        visualize_exits(region)
-
-    def visualize_other_regions() -> None:
-        if other_regions := [region for region in multiworld.get_regions(root_region.player) if region not in seen]:
-            uml.append("package \"other regions\" <<Cloud>> {")
-            for region in other_regions:
-                uml.append(f"class \"{fmt(region)}\"")
-            uml.append("}")
-
-    uml.append("@startuml")
-    uml.append("hide circle")
-    uml.append("hide empty members")
-    if linetype_ortho:
-        uml.append("skinparam linetype ortho")
-    while regions:
-        if (current_region := regions.popleft()) not in seen:
-            seen.add(current_region)
-            visualize_region(current_region)
-            regions.extend(exit_.connected_region for exit_ in current_region.exits if exit_.connected_region)
-    if show_other_regions:
-        visualize_other_regions()
-    uml.append("@enduml")
-
-    with open(file_name, "wt", encoding="utf-8") as f:
-        f.write("\n".join(uml))
-
-
-class RepeatableChain:
-    def __init__(self, iterable: typing.Iterable):
-        self.iterable = iterable
-
-    def __iter__(self):
-        return itertools.chain.from_iterable(self.iterable)
-
-    def __bool__(self):
-        return any(sub_iterable for sub_iterable in self.iterable)
-
-    def __len__(self):
-        return sum(len(iterable) for iterable in self.iterable)

WebHost.py

@@ -13,6 +13,15 @@ import Utils
 import settings
 
 Utils.local_path.cached_path = os.path.dirname(__file__) or "."  # py3.8 is not abs. remove "." when dropping 3.8
+
+from WebHostLib import register, app as raw_app
+from waitress import serve
+
+from WebHostLib.models import db
+from WebHostLib.autolauncher import autohost, autogen
+from WebHostLib.options import create as create_options_files
+import worlds
+
 settings.no_gui = True
 configpath = os.path.abspath("config.yaml")
 if not os.path.exists(configpath):  # fall back to config.yaml in home
@@ -20,9 +29,6 @@ if not os.path.exists(configpath):  # fall back to config.yaml in home
 
 
 def get_app():
-    from WebHostLib import register, cache, app as raw_app
-    from WebHostLib.models import db
-
     register()
     app = raw_app
     if os.path.exists(configpath) and not app.config["TESTING"]:
@@ -34,9 +40,15 @@ def get_app():
         app.config["HOST_ADDRESS"] = Utils.get_public_ipv4()
         logging.info(f"HOST_ADDRESS was set to {app.config['HOST_ADDRESS']}")
 
-    cache.init_app(app)
     db.bind(**app.config["PONY"])
     db.generate_mapping(create_tables=True)
+
+    for world in worlds.AutoWorldRegister.world_types.values():
+        try:
+            world.web.run_webhost_app_setup(app)
+        except Exception as e:
+            logging.exception(e)
+
     return app
 
 
@@ -116,16 +128,16 @@ if __name__ == "__main__":
     multiprocessing.set_start_method('spawn')
     logging.basicConfig(format='[%(asctime)s] %(message)s', level=logging.INFO)
 
-    from WebHostLib.lttpsprites import update_sprites_lttp
-    from WebHostLib.autolauncher import autohost, autogen
-    from WebHostLib.options import create as create_options_files
+    for world in worlds.AutoWorldRegister.world_types.values():
+        try:
+            world.web.run_webhost_setup()
+        except Exception as e:
+            logging.exception(e)
 
-    try:
-        update_sprites_lttp()
-    except Exception as e:
-        logging.exception(e)
-        logging.warning("Could not update LttP sprites.")
     app = get_app()
+
+    del world, worlds
+
     create_options_files()
     create_ordered_tutorials_file()
     if app.config["SELFLAUNCH"]:
@@ -136,5 +148,4 @@ if __name__ == "__main__":
         if app.config["DEBUG"]:
             app.run(debug=True, port=app.config["PORT"])
         else:
-            from waitress import serve
             serve(app, port=app.config["PORT"], threads=app.config["WAITRESS_THREADS"])

WebHostLib/__init__.py

@@ -49,10 +49,11 @@ app.config["PONY"] = {
     'create_db': True
 }
 app.config["MAX_ROLL"] = 20
-app.config["CACHE_TYPE"] = "SimpleCache"
+app.config["CACHE_TYPE"] = "flask_caching.backends.SimpleCache"
+app.config["JSON_AS_ASCII"] = False
 app.config["HOST_ADDRESS"] = ""
 
-cache = Cache()
+cache = Cache(app)
 Compress(app)
 
 

WebHostLib/autolauncher.py

@@ -3,6 +3,8 @@ from __future__ import annotations
 import json
 import logging
 import multiprocessing
+import os
+import sys
 import threading
 import time
 import typing
@@ -11,7 +13,55 @@ from datetime import timedelta, datetime
 from pony.orm import db_session, select, commit
 
 from Utils import restricted_loads
-from .locker import Locker, AlreadyRunningException
+
+
+class CommonLocker():
+    """Uses a file lock to signal that something is already running"""
+    lock_folder = "file_locks"
+
+    def __init__(self, lockname: str, folder=None):
+        if folder:
+            self.lock_folder = folder
+        os.makedirs(self.lock_folder, exist_ok=True)
+        self.lockname = lockname
+        self.lockfile = os.path.join(self.lock_folder, f"{self.lockname}.lck")
+
+
+class AlreadyRunningException(Exception):
+    pass
+
+
+if sys.platform == 'win32':
+    class Locker(CommonLocker):
+        def __enter__(self):
+            try:
+                if os.path.exists(self.lockfile):
+                    os.unlink(self.lockfile)
+                self.fp = os.open(
+                    self.lockfile, os.O_CREAT | os.O_EXCL | os.O_RDWR)
+            except OSError as e:
+                raise AlreadyRunningException() from e
+
+        def __exit__(self, _type, value, tb):
+            fp = getattr(self, "fp", None)
+            if fp:
+                os.close(self.fp)
+                os.unlink(self.lockfile)
+else:  # unix
+    import fcntl
+
+
+    class Locker(CommonLocker):
+        def __enter__(self):
+            try:
+                self.fp = open(self.lockfile, "wb")
+                fcntl.flock(self.fp.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
+            except OSError as e:
+                raise AlreadyRunningException() from e
+
+        def __exit__(self, _type, value, tb):
+            fcntl.flock(self.fp.fileno(), fcntl.LOCK_UN)
+            self.fp.close()
 
 
 def launch_room(room: Room, config: dict):

WebHostLib/check.py

@@ -1,6 +1,5 @@
 import zipfile
-import base64
-from typing import Union, Dict, Set, Tuple
+from typing import *
 
 from flask import request, flash, redirect, url_for, render_template
 from markupsafe import Markup
@@ -25,21 +24,13 @@ def check():
         if 'file' not in request.files:
             flash('No file part')
         else:
-            files = request.files.getlist('file')
-            options = get_yaml_data(files)
+            file = request.files['file']
+            options = get_yaml_data(file)
             if isinstance(options, str):
                 flash(options)
             else:
                 results, _ = roll_options(options)
-                if len(options) > 1:
-                    # offer combined file back
-                    combined_yaml = "---\n".join(f"# original filename: {file_name}\n{file_content.decode('utf-8-sig')}"
-                                                 for file_name, file_content in options.items())
-                    combined_yaml = base64.b64encode(combined_yaml.encode("utf-8-sig")).decode()
-                else:
-                    combined_yaml = ""
-                return render_template("checkResult.html",
-                                       results=results, combined_yaml=combined_yaml)
+                return render_template("checkResult.html", results=results)
     return render_template("check.html")
 
 
@@ -48,34 +39,30 @@ def mysterycheck():
     return redirect(url_for("check"), 301)
 
 
-def get_yaml_data(files) -> Union[Dict[str, str], str, Markup]:
+def get_yaml_data(file) -> Union[Dict[str, str], str, Markup]:
     options = {}
-    for uploaded_file in files:
-        # if user does not select file, browser also
-        # submit an empty part without filename
-        if uploaded_file.filename == '':
-            return 'No selected file'
-        elif uploaded_file.filename in options:
-            return f'Conflicting files named {uploaded_file.filename} submitted'
-        elif uploaded_file and allowed_file(uploaded_file.filename):
-            if uploaded_file.filename.endswith(".zip"):
+    # if user does not select file, browser also
+    # submit an empty part without filename
+    if file.filename == '':
+        return 'No selected file'
+    elif file and allowed_file(file.filename):
+        if file.filename.endswith(".zip"):
 
-                with zipfile.ZipFile(uploaded_file, 'r') as zfile:
-                    infolist = zfile.infolist()
+            with zipfile.ZipFile(file, 'r') as zfile:
+                infolist = zfile.infolist()
 
-                    if any(file.filename.endswith(".archipelago") for file in infolist):
-                        return Markup("Error: Your .zip file contains an .archipelago file. "
-                                      'Did you mean to <a href="/uploads">host a game</a>?')
+                if any(file.filename.endswith(".archipelago") for file in infolist):
+                    return Markup("Error: Your .zip file contains an .archipelago file. "
+                                  'Did you mean to <a href="/uploads">host a game</a>?')
 
-                    for file in infolist:
-                        if file.filename.endswith(banned_zip_contents):
-                            return ("Uploaded data contained a rom file, "
-                                    "which is likely to contain copyrighted material. "
-                                    "Your file was deleted.")
-                        elif file.filename.endswith((".yaml", ".json", ".yml", ".txt")):
-                            options[file.filename] = zfile.open(file, "r").read()
-            else:
-                options[uploaded_file.filename] = uploaded_file.read()
+                for file in infolist:
+                    if file.filename.endswith(banned_zip_contents):
+                        return "Uploaded data contained a rom file, which is likely to contain copyrighted material. " \
+                               "Your file was deleted."
+                    elif file.filename.endswith((".yaml", ".json", ".yml", ".txt")):
+                        options[file.filename] = zfile.open(file, "r").read()
+        else:
+            options = {file.filename: file.read()}
     if not options:
         return "Did not find a .yaml file to process."
     return options

WebHostLib/customserver.py

@@ -11,7 +11,6 @@ import socket
 import threading
 import time
 import typing
-import sys
 
 import websockets
 from pony.orm import commit, db_session, select
@@ -20,7 +19,6 @@ import Utils
 
 from MultiServer import Context, server, auto_shutdown, ServerCommandProcessor, ClientMessageProcessor, load_server_cert
 from Utils import restricted_loads, cache_argsless
-from .locker import Locker
 from .models import Command, GameDataPackage, Room, db
 
 
@@ -165,21 +163,16 @@ def run_server_process(room_id, ponyconfig: dict, static_server_data: dict,
     db.generate_mapping(check_tables=False)
 
     async def main():
-        if "worlds" in sys.modules:
-            raise Exception("Worlds system should not be loaded in the custom server.")
-
-        import gc
         Utils.init_logging(str(room_id), write_mode="a")
         ctx = WebHostContext(static_server_data)
         ctx.load(room_id)
         ctx.init_save()
         ssl_context = load_server_cert(cert_file, cert_key_file) if cert_file else None
-        gc.collect()  # free intermediate objects used during setup
         try:
             ctx.server = websockets.serve(functools.partial(server, ctx=ctx), ctx.host, ctx.port, ssl=ssl_context)
 
             await ctx.server
-        except OSError:  # likely port in use
+        except Exception:  # likely port in use - in windows this is OSError, but I didn't check the others
             ctx.server = websockets.serve(functools.partial(server, ctx=ctx), ctx.host, 0, ssl=ssl_context)
 
             await ctx.server
@@ -205,15 +198,16 @@ def run_server_process(room_id, ponyconfig: dict, static_server_data: dict,
         await ctx.shutdown_task
         logging.info("Shutting down")
 
+    from .autolauncher import Locker
     with Locker(room_id):
         try:
             asyncio.run(main())
-        except (KeyboardInterrupt, SystemExit):
+        except KeyboardInterrupt:
             with db_session:
                 room = Room.get(id=room_id)
                 # ensure the Room does not spin up again on its own, minute of safety buffer
                 room.last_activity = datetime.datetime.utcnow() - datetime.timedelta(minutes=1, seconds=room.timeout)
-        except Exception:
+        except:
             with db_session:
                 room = Room.get(id=room_id)
                 room.last_port = -1

WebHostLib/generate.py

@@ -64,8 +64,8 @@ def generate(race=False):
         if 'file' not in request.files:
             flash('No file part')
         else:
-            files = request.files.getlist('file')
-            options = get_yaml_data(files)
+            file = request.files['file']
+            options = get_yaml_data(file)
             if isinstance(options, str):
                 flash(options)
             else:

WebHostLib/locker.py

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

WebHostLib/lttpsprites.py

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

WebHostLib/misc.py

@@ -32,46 +32,29 @@ def page_not_found(err):
 
 # Start Playing Page
 @app.route('/start-playing')
-@cache.cached()
 def start_playing():
     return render_template(f"startPlaying.html")
 
 
-# TODO for back compat. remove around 0.4.5
-@app.route("/weighted-settings")
+@app.route('/weighted-settings')
 def weighted_settings():
-    return redirect("weighted-options", 301)
+    return render_template(f"weighted-settings.html")
 
 
-@app.route("/weighted-options")
-@cache.cached()
-def weighted_options():
-    return render_template("weighted-options.html")
-
-
-# TODO for back compat. remove around 0.4.5
-@app.route("/games/<string:game>/player-settings")
-def player_settings(game: str):
-    return redirect(url_for("player_options", game=game), 301)
-
-
-# Player options pages
-@app.route("/games/<string:game>/player-options")
-@cache.cached()
-def player_options(game: str):
-    return render_template("player-options.html", game=game, theme=get_world_theme(game))
+# Player settings pages
+@app.route('/games/<string:game>/player-settings')
+def player_settings(game):
+    return render_template(f"player-settings.html", game=game, theme=get_world_theme(game))
 
 
 # Game Info Pages
 @app.route('/games/<string:game>/info/<string:lang>')
-@cache.cached()
 def game_info(game, lang):
     return render_template('gameInfo.html', game=game, lang=lang, theme=get_world_theme(game))
 
 
 # List of supported games
 @app.route('/games')
-@cache.cached()
 def games():
     worlds = {}
     for game, world in AutoWorldRegister.world_types.items():
@@ -81,25 +64,21 @@ def games():
 
 
 @app.route('/tutorial/<string:game>/<string:file>/<string:lang>')
-@cache.cached()
 def tutorial(game, file, lang):
     return render_template("tutorial.html", game=game, file=file, lang=lang, theme=get_world_theme(game))
 
 
 @app.route('/tutorial/')
-@cache.cached()
 def tutorial_landing():
     return render_template("tutorialLanding.html")
 
 
 @app.route('/faq/<string:lang>/')
-@cache.cached()
 def faq(lang):
     return render_template("faq.html", lang=lang)
 
 
 @app.route('/glossary/<string:lang>/')
-@cache.cached()
 def terms(lang):
     return render_template("glossary.html", lang=lang)
 
@@ -168,7 +147,7 @@ def host_room(room: UUID):
 
 @app.route('/favicon.ico')
 def favicon():
-    return send_from_directory(os.path.join(app.root_path, "static", "static"),
+    return send_from_directory(os.path.join(app.root_path, 'static/static'),
                                'favicon.ico', mimetype='image/vnd.microsoft.icon')
 
 
@@ -188,11 +167,10 @@ def get_datapackage():
 
 @app.route('/index')
 @app.route('/sitemap')
-@cache.cached()
 def get_sitemap():
     available_games: List[Dict[str, Union[str, bool]]] = []
     for game, world in AutoWorldRegister.world_types.items():
         if not world.hidden:
-            has_settings: bool = isinstance(world.web.options_page, bool) and world.web.options_page
+            has_settings: bool = isinstance(world.web.settings_page, bool) and world.web.settings_page
             available_games.append({ 'title': game, 'has_settings': has_settings })
     return render_template("siteMap.html", games=available_games)

WebHostLib/options.py

@@ -25,7 +25,7 @@ def create():
             return "Please document me!"
         return "\n".join(line.strip() for line in option_type.__doc__.split("\n")).strip()
 
-    weighted_options = {
+    weighted_settings = {
         "baseOptions": {
             "description": "Generated by https://archipelago.gg/",
             "name": "Player",
@@ -36,10 +36,13 @@ def create():
 
     for game_name, world in AutoWorldRegister.world_types.items():
 
-        all_options: typing.Dict[str, Options.AssembleOptions] = world.options_dataclass.type_hints
+        all_options: typing.Dict[str, Options.AssembleOptions] = {
+            **Options.per_game_common_options,
+            **world.option_definitions
+        }
 
-        # Generate JSON files for player-options pages
-        player_options = {
+        # Generate JSON files for player-settings pages
+        player_settings = {
             "baseOptions": {
                 "description": f"Generated by https://archipelago.gg/ for {game_name}",
                 "game": game_name,
@@ -117,17 +120,17 @@ def create():
                     }
 
             else:
-                logging.debug(f"{option} not exported to Web options.")
+                logging.debug(f"{option} not exported to Web Settings.")
 
-        player_options["gameOptions"] = game_options
+        player_settings["gameOptions"] = game_options
 
-        os.makedirs(os.path.join(target_folder, 'player-options'), exist_ok=True)
+        os.makedirs(os.path.join(target_folder, 'player-settings'), exist_ok=True)
 
-        with open(os.path.join(target_folder, 'player-options', game_name + ".json"), "w") as f:
-            json.dump(player_options, f, indent=2, separators=(',', ': '))
+        with open(os.path.join(target_folder, 'player-settings', game_name + ".json"), "w") as f:
+            json.dump(player_settings, f, indent=2, separators=(',', ': '))
 
-        if not world.hidden and world.web.options_page is True:
-            # Add the random option to Choice, TextChoice, and Toggle options
+        if not world.hidden and world.web.settings_page is True:
+            # Add the random option to Choice, TextChoice, and Toggle settings
             for option in game_options.values():
                 if option["type"] == "select":
                     option["options"].append({"name": "Random", "value": "random"})
@@ -135,17 +138,11 @@ def create():
                     if not option["defaultValue"]:
                         option["defaultValue"] = "random"
 
-            weighted_options["baseOptions"]["game"][game_name] = 0
-            weighted_options["games"][game_name] = {}
-            weighted_options["games"][game_name]["gameSettings"] = game_options
-            weighted_options["games"][game_name]["gameItems"] = tuple(world.item_names)
-            weighted_options["games"][game_name]["gameItemGroups"] = [
-                group for group in world.item_name_groups.keys() if group != "Everything"
-            ]
-            weighted_options["games"][game_name]["gameLocations"] = tuple(world.location_names)
-            weighted_options["games"][game_name]["gameLocationGroups"] = [
-                group for group in world.location_name_groups.keys() if group != "Everywhere"
-            ]
+            weighted_settings["baseOptions"]["game"][game_name] = 0
+            weighted_settings["games"][game_name] = {}
+            weighted_settings["games"][game_name]["gameSettings"] = game_options
+            weighted_settings["games"][game_name]["gameItems"] = tuple(world.item_names)
+            weighted_settings["games"][game_name]["gameLocations"] = tuple(world.location_names)
 
-    with open(os.path.join(target_folder, 'weighted-options.json'), "w") as f:
-        json.dump(weighted_options, f, indent=2, separators=(',', ': '))
+    with open(os.path.join(target_folder, 'weighted-settings.json'), "w") as f:
+        json.dump(weighted_settings, f, indent=2, separators=(',', ': '))

WebHostLib/requirements.txt

@@ -1,9 +1,9 @@
-flask>=3.0.0
-pony>=0.7.17
+flask>=2.2.3
+pony>=0.7.16; python_version <= '3.10'
+pony @ https://github.com/Berserker66/pony/releases/download/v0.7.16/pony-0.7.16-py3-none-any.whl#0.7.16 ; python_version >= '3.11'
 waitress>=2.1.2
-Flask-Caching>=2.1.0
-Flask-Compress>=1.14
-Flask-Limiter>=3.5.0
-bokeh>=3.1.1; python_version <= '3.8'
-bokeh>=3.2.2; python_version >= '3.9'
+Flask-Caching>=2.0.2
+Flask-Compress>=1.13
+Flask-Limiter>=3.3.0
+bokeh>=3.1.1
 markupsafe>=2.1.3

WebHostLib/static/assets/faq/faq_en.md

@@ -2,62 +2,13 @@
 
 ## What is a randomizer?
 
-A randomizer is a modification of a game which reorganizes the items required to progress through that game. A
-normal play-through might require you to use item A to unlock item B, then C, and so forth. In a randomized
+A randomizer is a modification of a video game which reorganizes the items required to progress through the game. A
+normal play-through of a game might require you to use item A to unlock item B, then C, and so forth. In a randomized
 game, you might first find item C, then A, then B.
 
-This transforms the game from a linear experience into a puzzle, presenting players with a new challenge each time they
-play. Putting items in non-standard locations can require the player to think about the game world and the items they
-encounter in new and interesting ways.
-
-## What is a multiworld?
-
-While a randomizer shuffles a game, a multiworld randomizer shuffles that game for multiple players. For example, in a
-two player multiworld, players A and B each get their own randomized version of a game, called a world. In each
-player's game, they may find items which belong to the other player. If player A finds an item which belongs to
-player B, the item will be sent to player B's world over the internet. This creates a cooperative experience, requiring
-players to rely upon each other to complete their game.
-
-## What does multi-game mean?
-
-While a multiworld game traditionally requires all players to be playing the same game, a multi-game multiworld allows
-players to randomize any of the supported games, and send items between them. This allows players of different
-games to interact with one another in a single multiplayer environment.  Archipelago supports multi-game multiworld.
-Here is a list of our [Supported Games](https://archipelago.gg/games).
-
-## Can I generate a single-player game with Archipelago?
-
-Yes. All of our supported games can be generated as single-player experiences both on the website and by installing 
-the Archipelago generator software. The fastest way to do this is on the website. Find the Supported Game you wish to
-play, open the Settings Page, pick your settings, and click Generate Game.
-
-## How do I get started?
-
-We have a [Getting Started](https://archipelago.gg/tutorial/Archipelago/setup/en) guide that will help you get the
-software set up. You can use that guide to learn how to generate multiworlds. There are also basic instructions for
-including multiple games, and hosting multiworlds on the website for ease and convenience.
-
-If you are ready to start randomizing games, or want to start playing your favorite randomizer with others, please join
-our discord server at the [Archipelago Discord](https://discord.gg/8Z65BR2). There are always people ready to answer
-any questions you might have.
-
-## What are some common terms I should know?
-
-As randomizers and multiworld randomizers have been around for a while now, there are quite a few common terms used
-by the communities surrounding them. A list of Archipelago jargon and terms commonly used by the community can be
-found in the [Glossary](/glossary/en).
-
-## Does everyone need to be connected at the same time?
-
-There are two different play-styles that are common for Archipelago multiworld sessions. These sessions can either
-be considered synchronous (or "sync"), where everyone connects and plays at the same time, or asynchronous (or "async"),
-where players connect and play at their own pace. The setup for both is identical. The difference in play-style is how
-you and your friends choose to organize and play your multiworld. Most groups decide on the format before creating
-their multiworld.
-
-If a player must leave early, they can use Archipelago's release system. When a player releases their game, all items
-in that game belonging to other players are sent out automatically. This allows other players to continue to play
-uninterrupted. Here is a list of all of our [Server Commands](https://archipelago.gg/tutorial/Archipelago/commands/en).
+This transforms games from a linear experience into a puzzle, presenting players with a new challenge each time they
+play a randomized game. Putting items in non-standard locations can require the player to think about the game world and
+the items they encounter in new and interesting ways.
 
 ## What happens if an item is placed somewhere it is impossible to get?
 
@@ -66,15 +17,53 @@ is to ensure items necessary to complete the game will be accessible to the play
 rules allowing certain items to be placed in normally unreachable locations, provided the player has indicated they are
 comfortable exploiting certain glitches in the game.
 
+## What is a multi-world?
+
+While a randomizer shuffles a game, a multi-world randomizer shuffles that game for multiple players. For example, in a
+two player multi-world, players A and B each get their own randomized version of a game, called a world. In each player's
+game, they may find items which belong to the other player. If player A finds an item which belongs to player B, the
+item will be sent to player B's world over the internet.
+
+This creates a cooperative experience during multi-world games, requiring players to rely upon each other to complete
+their game.
+
+## What happens if a person has to leave early?
+
+If a player must leave early, they can use Archipelago's release system. When a player releases their game, all the
+items in that game which belong to other players are sent out automatically, so other players can continue to play.
+
+## What does multi-game mean?
+
+While a multi-world game traditionally requires all players to be playing the same game, a multi-game multi-world allows
+players to randomize any of a number of supported games, and send items between them. This allows players of different
+games to interact with one another in a single multiplayer environment.
+
+## Can I generate a single-player game with Archipelago?
+
+Yes. All our supported games can be generated as single-player experiences, and so long as you download the software,
+the website is not required to generate them.
+
+## How do I get started?
+
+If you are ready to start randomizing games, or want to start playing your favorite randomizer with others, please join
+our discord server at the [Archipelago Discord](https://discord.gg/8Z65BR2). There are always people ready to answer
+any questions you might have.
+
+## What are some common terms I should know?
+
+As randomizers and multiworld randomizers have been around for a while now there are quite a lot of common terms
+and jargon that is used in conjunction by the communities surrounding them. For a lot of the terms that are more common
+to Archipelago and its specific systems please see the [Glossary](/glossary/en).
+
 ## I want to add a game to the Archipelago randomizer. How do I do that?
 
-The best way to get started is to take a look at our code on GitHub:  
-[Archipelago GitHub Page](https://github.com/ArchipelagoMW/Archipelago).
+The best way to get started is to take a look at our code on GitHub
+at [Archipelago GitHub Page](https://github.com/ArchipelagoMW/Archipelago).
 
-There, you will find examples of games in the `worlds` folder:  
-[/worlds Folder in Archipelago Code](https://github.com/ArchipelagoMW/Archipelago/tree/main/worlds).
+There you will find examples of games in the worlds folder
+at [/worlds Folder in Archipelago Code](https://github.com/ArchipelagoMW/Archipelago/tree/main/worlds).
 
-You may also find developer documentation in the `docs` folder:  
-[/docs Folder in Archipelago Code](https://github.com/ArchipelagoMW/Archipelago/tree/main/docs).
+You may also find developer documentation in the docs folder
+at [/docs Folder in Archipelago Code](https://github.com/ArchipelagoMW/Archipelago/tree/main/docs).
 
 If you have more questions, feel free to ask in the **#archipelago-dev** channel on our Discord.

WebHostLib/static/assets/player-settings.js

@@ -1,41 +1,41 @@
 let gameName = null;
 
 window.addEventListener('load', () => {
-  gameName = document.getElementById('player-options').getAttribute('data-game');
+  gameName = document.getElementById('player-settings').getAttribute('data-game');
 
   // Update game name on page
   document.getElementById('game-name').innerText = gameName;
 
-  fetchOptionData().then((results) => {
-    let optionHash = localStorage.getItem(`${gameName}-hash`);
-    if (!optionHash) {
+  fetchSettingData().then((results) => {
+    let settingHash = localStorage.getItem(`${gameName}-hash`);
+    if (!settingHash) {
       // If no hash data has been set before, set it now
-      optionHash = md5(JSON.stringify(results));
-      localStorage.setItem(`${gameName}-hash`, optionHash);
+      settingHash = md5(JSON.stringify(results));
+      localStorage.setItem(`${gameName}-hash`, settingHash);
       localStorage.removeItem(gameName);
     }
 
-    if (optionHash !== md5(JSON.stringify(results))) {
-      showUserMessage("Your options are out of date! Click here to update them! Be aware this will reset " +
+    if (settingHash !== md5(JSON.stringify(results))) {
+      showUserMessage("Your settings are out of date! Click here to update them! Be aware this will reset " +
         "them all to default.");
-      document.getElementById('user-message').addEventListener('click', resetOptions);
+      document.getElementById('user-message').addEventListener('click', resetSettings);
     }
 
     // Page setup
-    createDefaultOptions(results);
+    createDefaultSettings(results);
     buildUI(results);
     adjustHeaderWidth();
 
     // Event listeners
-    document.getElementById('export-options').addEventListener('click', () => exportOptions());
+    document.getElementById('export-settings').addEventListener('click', () => exportSettings());
     document.getElementById('generate-race').addEventListener('click', () => generateGame(true));
     document.getElementById('generate-game').addEventListener('click', () => generateGame());
 
     // Name input field
-    const playerOptions = JSON.parse(localStorage.getItem(gameName));
+    const playerSettings = JSON.parse(localStorage.getItem(gameName));
     const nameInput = document.getElementById('player-name');
-    nameInput.addEventListener('keyup', (event) => updateBaseOption(event));
-    nameInput.value = playerOptions.name;
+    nameInput.addEventListener('keyup', (event) => updateBaseSetting(event));
+    nameInput.value = playerSettings.name;
   }).catch((e) => {
     console.error(e);
     const url = new URL(window.location.href);
@@ -43,13 +43,13 @@ window.addEventListener('load', () => {
   })
 });
 
-const resetOptions = () => {
+const resetSettings = () => {
   localStorage.removeItem(gameName);
   localStorage.removeItem(`${gameName}-hash`)
   window.location.reload();
 };
 
-const fetchOptionData = () => new Promise((resolve, reject) => {
+const fetchSettingData = () => new Promise((resolve, reject) => {
   const ajax = new XMLHttpRequest();
   ajax.onreadystatechange = () => {
     if (ajax.readyState !== 4) { return; }
@@ -60,54 +60,54 @@ const fetchOptionData = () => new Promise((resolve, reject) => {
     try{ resolve(JSON.parse(ajax.responseText)); }
     catch(error){ reject(error); }
   };
-  ajax.open('GET', `${window.location.origin}/static/generated/player-options/${gameName}.json`, true);
+  ajax.open('GET', `${window.location.origin}/static/generated/player-settings/${gameName}.json`, true);
   ajax.send();
 });
 
-const createDefaultOptions = (optionData) => {
+const createDefaultSettings = (settingData) => {
   if (!localStorage.getItem(gameName)) {
-    const newOptions = {
+    const newSettings = {
       [gameName]: {},
     };
-    for (let baseOption of Object.keys(optionData.baseOptions)){
-      newOptions[baseOption] = optionData.baseOptions[baseOption];
+    for (let baseOption of Object.keys(settingData.baseOptions)){
+      newSettings[baseOption] = settingData.baseOptions[baseOption];
     }
-    for (let gameOption of Object.keys(optionData.gameOptions)){
-      newOptions[gameName][gameOption] = optionData.gameOptions[gameOption].defaultValue;
+    for (let gameOption of Object.keys(settingData.gameOptions)){
+      newSettings[gameName][gameOption] = settingData.gameOptions[gameOption].defaultValue;
     }
-    localStorage.setItem(gameName, JSON.stringify(newOptions));
+    localStorage.setItem(gameName, JSON.stringify(newSettings));
   }
 };
 
-const buildUI = (optionData) => {
+const buildUI = (settingData) => {
   // Game Options
   const leftGameOpts = {};
   const rightGameOpts = {};
-  Object.keys(optionData.gameOptions).forEach((key, index) => {
-    if (index < Object.keys(optionData.gameOptions).length / 2) { leftGameOpts[key] = optionData.gameOptions[key]; }
-    else { rightGameOpts[key] = optionData.gameOptions[key]; }
+  Object.keys(settingData.gameOptions).forEach((key, index) => {
+    if (index < Object.keys(settingData.gameOptions).length / 2) { leftGameOpts[key] = settingData.gameOptions[key]; }
+    else { rightGameOpts[key] = settingData.gameOptions[key]; }
   });
   document.getElementById('game-options-left').appendChild(buildOptionsTable(leftGameOpts));
   document.getElementById('game-options-right').appendChild(buildOptionsTable(rightGameOpts));
 };
 
-const buildOptionsTable = (options, romOpts = false) => {
-  const currentOptions = JSON.parse(localStorage.getItem(gameName));
+const buildOptionsTable = (settings, romOpts = false) => {
+  const currentSettings = JSON.parse(localStorage.getItem(gameName));
   const table = document.createElement('table');
   const tbody = document.createElement('tbody');
 
-  Object.keys(options).forEach((option) => {
+  Object.keys(settings).forEach((setting) => {
     const tr = document.createElement('tr');
 
     // td Left
     const tdl = document.createElement('td');
     const label = document.createElement('label');
-    label.textContent = `${options[option].displayName}: `;
-    label.setAttribute('for', option);
+    label.textContent = `${settings[setting].displayName}: `;
+    label.setAttribute('for', setting);
 
     const questionSpan = document.createElement('span');
     questionSpan.classList.add('interactive');
-    questionSpan.setAttribute('data-tooltip', options[option].description);
+    questionSpan.setAttribute('data-tooltip', settings[setting].description);
     questionSpan.innerText = '(?)';
 
     label.appendChild(questionSpan);
@@ -120,36 +120,36 @@ const buildOptionsTable = (options, romOpts = false) => {
 
     const randomButton = document.createElement('button');
 
-    switch(options[option].type){
+    switch(settings[setting].type){
       case 'select':
         element = document.createElement('div');
         element.classList.add('select-container');
         let select = document.createElement('select');
-        select.setAttribute('id', option);
-        select.setAttribute('data-key', option);
+        select.setAttribute('id', setting);
+        select.setAttribute('data-key', setting);
         if (romOpts) { select.setAttribute('data-romOpt', '1'); }
-        options[option].options.forEach((opt) => {
+        settings[setting].options.forEach((opt) => {
           const option = document.createElement('option');
           option.setAttribute('value', opt.value);
           option.innerText = opt.name;
-          if ((isNaN(currentOptions[gameName][option]) &&
-            (parseInt(opt.value, 10) === parseInt(currentOptions[gameName][option]))) ||
-            (opt.value === currentOptions[gameName][option]))
+          if ((isNaN(currentSettings[gameName][setting]) &&
+            (parseInt(opt.value, 10) === parseInt(currentSettings[gameName][setting]))) ||
+            (opt.value === currentSettings[gameName][setting]))
           {
             option.selected = true;
           }
           select.appendChild(option);
         });
-        select.addEventListener('change', (event) => updateGameOption(event.target));
+        select.addEventListener('change', (event) => updateGameSetting(event.target));
         element.appendChild(select);
 
         // Randomize button
         randomButton.innerText = '🎲';
         randomButton.classList.add('randomize-button');
-        randomButton.setAttribute('data-key', option);
+        randomButton.setAttribute('data-key', setting);
         randomButton.setAttribute('data-tooltip', 'Toggle randomization for this option!');
         randomButton.addEventListener('click', (event) => toggleRandomize(event, select));
-        if (currentOptions[gameName][option] === 'random') {
+        if (currentSettings[gameName][setting] === 'random') {
           randomButton.classList.add('active');
           select.disabled = true;
         }
@@ -163,30 +163,30 @@ const buildOptionsTable = (options, romOpts = false) => {
 
         let range = document.createElement('input');
         range.setAttribute('type', 'range');
-        range.setAttribute('data-key', option);
-        range.setAttribute('min', options[option].min);
-        range.setAttribute('max', options[option].max);
-        range.value = currentOptions[gameName][option];
+        range.setAttribute('data-key', setting);
+        range.setAttribute('min', settings[setting].min);
+        range.setAttribute('max', settings[setting].max);
+        range.value = currentSettings[gameName][setting];
         range.addEventListener('change', (event) => {
-          document.getElementById(`${option}-value`).innerText = event.target.value;
-          updateGameOption(event.target);
+          document.getElementById(`${setting}-value`).innerText = event.target.value;
+          updateGameSetting(event.target);
         });
         element.appendChild(range);
 
         let rangeVal = document.createElement('span');
         rangeVal.classList.add('range-value');
-        rangeVal.setAttribute('id', `${option}-value`);
-        rangeVal.innerText = currentOptions[gameName][option] !== 'random' ?
-          currentOptions[gameName][option] : options[option].defaultValue;
+        rangeVal.setAttribute('id', `${setting}-value`);
+        rangeVal.innerText = currentSettings[gameName][setting] !== 'random' ?
+          currentSettings[gameName][setting] : settings[setting].defaultValue;
         element.appendChild(rangeVal);
 
         // Randomize button
         randomButton.innerText = '🎲';
         randomButton.classList.add('randomize-button');
-        randomButton.setAttribute('data-key', option);
+        randomButton.setAttribute('data-key', setting);
         randomButton.setAttribute('data-tooltip', 'Toggle randomization for this option!');
         randomButton.addEventListener('click', (event) => toggleRandomize(event, range));
-        if (currentOptions[gameName][option] === 'random') {
+        if (currentSettings[gameName][setting] === 'random') {
           randomButton.classList.add('active');
           range.disabled = true;
         }
@@ -200,11 +200,11 @@ const buildOptionsTable = (options, romOpts = false) => {
 
         // Build the select element
         let specialRangeSelect = document.createElement('select');
-        specialRangeSelect.setAttribute('data-key', option);
-        Object.keys(options[option].value_names).forEach((presetName) => {
+        specialRangeSelect.setAttribute('data-key', setting);
+        Object.keys(settings[setting].value_names).forEach((presetName) => {
           let presetOption = document.createElement('option');
           presetOption.innerText = presetName;
-          presetOption.value = options[option].value_names[presetName];
+          presetOption.value = settings[setting].value_names[presetName];
           const words = presetOption.innerText.split("_");
           for (let i = 0; i < words.length; i++) {
             words[i] = words[i][0].toUpperCase() + words[i].substring(1);
@@ -217,8 +217,8 @@ const buildOptionsTable = (options, romOpts = false) => {
         customOption.value = 'custom';
         customOption.selected = true;
         specialRangeSelect.appendChild(customOption);
-        if (Object.values(options[option].value_names).includes(Number(currentOptions[gameName][option]))) {
-          specialRangeSelect.value = Number(currentOptions[gameName][option]);
+        if (Object.values(settings[setting].value_names).includes(Number(currentSettings[gameName][setting]))) {
+          specialRangeSelect.value = Number(currentSettings[gameName][setting]);
         }
 
         // Build range element
@@ -226,17 +226,17 @@ const buildOptionsTable = (options, romOpts = false) => {
         specialRangeWrapper.classList.add('special-range-wrapper');
         let specialRange = document.createElement('input');
         specialRange.setAttribute('type', 'range');
-        specialRange.setAttribute('data-key', option);
-        specialRange.setAttribute('min', options[option].min);
-        specialRange.setAttribute('max', options[option].max);
-        specialRange.value = currentOptions[gameName][option];
+        specialRange.setAttribute('data-key', setting);
+        specialRange.setAttribute('min', settings[setting].min);
+        specialRange.setAttribute('max', settings[setting].max);
+        specialRange.value = currentSettings[gameName][setting];
 
         // Build rage value element
         let specialRangeVal = document.createElement('span');
         specialRangeVal.classList.add('range-value');
-        specialRangeVal.setAttribute('id', `${option}-value`);
-        specialRangeVal.innerText = currentOptions[gameName][option] !== 'random' ?
-          currentOptions[gameName][option] : options[option].defaultValue;
+        specialRangeVal.setAttribute('id', `${setting}-value`);
+        specialRangeVal.innerText = currentSettings[gameName][setting] !== 'random' ?
+          currentSettings[gameName][setting] : settings[setting].defaultValue;
 
         // Configure select event listener
         specialRangeSelect.addEventListener('change', (event) => {
@@ -244,18 +244,18 @@ const buildOptionsTable = (options, romOpts = false) => {
 
           // Update range slider
           specialRange.value = event.target.value;
-          document.getElementById(`${option}-value`).innerText = event.target.value;
-          updateGameOption(event.target);
+          document.getElementById(`${setting}-value`).innerText = event.target.value;
+          updateGameSetting(event.target);
         });
 
         // Configure range event handler
         specialRange.addEventListener('change', (event) => {
           // Update select element
           specialRangeSelect.value =
-            (Object.values(options[option].value_names).includes(parseInt(event.target.value))) ?
+            (Object.values(settings[setting].value_names).includes(parseInt(event.target.value))) ?
             parseInt(event.target.value) : 'custom';
-          document.getElementById(`${option}-value`).innerText = event.target.value;
-          updateGameOption(event.target);
+          document.getElementById(`${setting}-value`).innerText = event.target.value;
+          updateGameSetting(event.target);
         });
 
         element.appendChild(specialRangeSelect);
@@ -266,12 +266,12 @@ const buildOptionsTable = (options, romOpts = false) => {
         // Randomize button
         randomButton.innerText = '🎲';
         randomButton.classList.add('randomize-button');
-        randomButton.setAttribute('data-key', option);
+        randomButton.setAttribute('data-key', setting);
         randomButton.setAttribute('data-tooltip', 'Toggle randomization for this option!');
         randomButton.addEventListener('click', (event) => toggleRandomize(
             event, specialRange, specialRangeSelect)
         );
-        if (currentOptions[gameName][option] === 'random') {
+        if (currentSettings[gameName][setting] === 'random') {
           randomButton.classList.add('active');
           specialRange.disabled = true;
           specialRangeSelect.disabled = true;
@@ -281,7 +281,7 @@ const buildOptionsTable = (options, romOpts = false) => {
         break;
 
       default:
-        console.error(`Ignoring unknown option type: ${options[option].type} with name ${option}`);
+        console.error(`Ignoring unknown setting type: ${settings[setting].type} with name ${setting}`);
         return;
     }
 
@@ -311,35 +311,37 @@ const toggleRandomize = (event, inputElement, optionalSelectElement = null) => {
       optionalSelectElement.disabled = true;
     }
   }
-    updateGameOption(active ? inputElement : randomButton);
+
+  updateGameSetting(randomButton);
 };
 
-const updateBaseOption = (event) => {
+const updateBaseSetting = (event) => {
   const options = JSON.parse(localStorage.getItem(gameName));
   options[event.target.getAttribute('data-key')] = isNaN(event.target.value) ?
     event.target.value : parseInt(event.target.value);
   localStorage.setItem(gameName, JSON.stringify(options));
 };
 
-const updateGameOption = (optionElement) => {
+const updateGameSetting = (settingElement) => {
   const options = JSON.parse(localStorage.getItem(gameName));
-  if (optionElement.classList.contains('randomize-button')) {
+
+  if (settingElement.classList.contains('randomize-button')) {
     // If the event passed in is the randomize button, then we know what we must do.
-    options[gameName][optionElement.getAttribute('data-key')] = 'random';
+    options[gameName][settingElement.getAttribute('data-key')] = 'random';
   } else {
-    options[gameName][optionElement.getAttribute('data-key')] = isNaN(optionElement.value) ?
-      optionElement.value : parseInt(optionElement.value, 10);
+    options[gameName][settingElement.getAttribute('data-key')] = isNaN(settingElement.value) ?
+      settingElement.value : parseInt(settingElement.value, 10);
   }
 
   localStorage.setItem(gameName, JSON.stringify(options));
 };
 
-const exportOptions = () => {
-  const options = JSON.parse(localStorage.getItem(gameName));
-  if (!options.name || options.name.toLowerCase() === 'player' || options.name.trim().length === 0) {
+const exportSettings = () => {
+  const settings = JSON.parse(localStorage.getItem(gameName));
+  if (!settings.name || settings.name.toLowerCase() === 'player' || settings.name.trim().length === 0) {
     return showUserMessage('You must enter a player name!');
   }
-  const yamlText = jsyaml.safeDump(options, { noCompatMode: true }).replaceAll(/'(\d+)':/g, (x, y) => `${y}:`);
+  const yamlText = jsyaml.safeDump(settings, { noCompatMode: true }).replaceAll(/'(\d+)':/g, (x, y) => `${y}:`);
   download(`${document.getElementById('player-name').value}.yaml`, yamlText);
 };
 
@@ -355,14 +357,14 @@ const download = (filename, text) => {
 };
 
 const generateGame = (raceMode = false) => {
-  const options = JSON.parse(localStorage.getItem(gameName));
-  if (!options.name || options.name.toLowerCase() === 'player' || options.name.trim().length === 0) {
+  const settings = JSON.parse(localStorage.getItem(gameName));
+  if (!settings.name || settings.name.toLowerCase() === 'player' || settings.name.trim().length === 0) {
     return showUserMessage('You must enter a player name!');
   }
 
   axios.post('/api/generate', {
-    weights: { player: options },
-    presetData: { player: options },
+    weights: { player: settings },
+    presetData: { player: settings },
     playerCount: 1,
     spoiler: 3,
     race: raceMode ? '1' : '0',

WebHostLib/static/assets/supportedGames.js

@@ -1,64 +0,0 @@
-window.addEventListener('load', () => {
-  // Add toggle listener to all elements with .collapse-toggle
-  const toggleButtons = document.querySelectorAll('.collapse-toggle');
-  toggleButtons.forEach((e) => e.addEventListener('click', toggleCollapse));
-
-  // Handle game filter input
-  const gameSearch = document.getElementById('game-search');
-  gameSearch.value = '';
-  gameSearch.addEventListener('input', (evt) => {
-    if (!evt.target.value.trim()) {
-      // If input is empty, display all collapsed games
-      return toggleButtons.forEach((header) => {
-        header.style.display = null;
-        header.firstElementChild.innerText = '▶';
-        header.nextElementSibling.classList.add('collapsed');
-      });
-    }
-
-    // Loop over all the games
-    toggleButtons.forEach((header) => {
-      // If the game name includes the search string, display the game. If not, hide it
-      if (header.getAttribute('data-game').toLowerCase().includes(evt.target.value.toLowerCase())) {
-        header.style.display = null;
-        header.firstElementChild.innerText = '▼';
-        header.nextElementSibling.classList.remove('collapsed');
-      } else {
-        header.style.display = 'none';
-        header.firstElementChild.innerText = '▶';
-        header.nextElementSibling.classList.add('collapsed');
-      }
-    });
-  });
-
-  document.getElementById('expand-all').addEventListener('click', expandAll);
-  document.getElementById('collapse-all').addEventListener('click', collapseAll);
-});
-
-const toggleCollapse = (evt) => {
-  const gameArrow = evt.target.firstElementChild;
-  const gameInfo = evt.target.nextElementSibling;
-  if (gameInfo.classList.contains('collapsed')) {
-    gameArrow.innerText = '▼';
-    gameInfo.classList.remove('collapsed');
-  } else {
-    gameArrow.innerText = '▶';
-    gameInfo.classList.add('collapsed');
-  }
-};
-
-const expandAll = () => {
-  document.querySelectorAll('.collapse-toggle').forEach((header) => {
-    if (header.style.display === 'none') { return; }
-    header.firstElementChild.innerText = '▼';
-    header.nextElementSibling.classList.remove('collapsed');
-  });
-};
-
-const collapseAll = () => {
-  document.querySelectorAll('.collapse-toggle').forEach((header) => {
-    if (header.style.display === 'none') { return; }
-    header.firstElementChild.innerText = '▶';
-    header.nextElementSibling.classList.add('collapsed');
-  });
-};

WebHostLib/static/assets/trackerCommon.js

@@ -14,17 +14,6 @@ const adjustTableHeight = () => {
     }
 };
 
-/**
- * Convert an integer number of seconds into a human readable HH:MM format
- * @param {Number} seconds
- * @returns {string}
- */
-const secondsToHours = (seconds) => {
-    let hours   = Math.floor(seconds / 3600);
-    let minutes = Math.floor((seconds - (hours * 3600)) / 60).toString().padStart(2, '0');
-    return `${hours}:${minutes}`;
-};
-
 window.addEventListener('load', () => {
     const tables = $(".table").DataTable({
         paging: false,
@@ -38,18 +27,7 @@ window.addEventListener('load', () => {
         stateLoadCallback: function(settings) {
             return JSON.parse(localStorage.getItem(`DataTables_${settings.sInstance}_/tracker`));
         },
-        footerCallback: function(tfoot, data, start, end, display) {
-            if (tfoot) {
-                const activityData = this.api().column('lastActivity:name').data().toArray().filter(x => !isNaN(x));
-                Array.from(tfoot?.children).find(td => td.classList.contains('last-activity')).innerText =
-                  (activityData.length) ? secondsToHours(Math.min(...activityData)) : 'None';
-            }
-        },
         columnDefs: [
-            {
-                targets: 'last-activity',
-                name: 'lastActivity'
-            },
             {
                 targets: 'hours',
                 render: function (data, type, row) {
@@ -62,7 +40,11 @@ window.addEventListener('load', () => {
                     if (data === "None")
                         return data;
 
-                    return secondsToHours(data);
+                    let hours   = Math.floor(data / 3600);
+                    let minutes = Math.floor((data - (hours * 3600)) / 60);
+
+                    if (minutes < 10) {minutes = "0"+minutes;}
+                    return hours+':'+minutes;
                 }
             },
             {
@@ -132,16 +114,11 @@ window.addEventListener('load', () => {
             if (status === "success") {
                 target.find(".table").each(function (i, new_table) {
                     const new_trs = $(new_table).find("tbody>tr");
-                    const footer_tr = $(new_table).find("tfoot>tr");
                     const old_table = tables.eq(i);
                     const topscroll = $(old_table.settings()[0].nScrollBody).scrollTop();
                     const leftscroll = $(old_table.settings()[0].nScrollBody).scrollLeft();
                     old_table.clear();
-                    if (footer_tr.length) {
-                        $(old_table.table).find("tfoot").html(footer_tr);
-                    }
-                    old_table.rows.add(new_trs);
-                    old_table.draw();
+                    old_table.rows.add(new_trs).draw();
                     $(old_table.settings()[0].nScrollBody).scrollTop(topscroll);
                     $(old_table.settings()[0].nScrollBody).scrollLeft(leftscroll);
                 });

WebHostLib/static/styles/landing.css

@@ -235,6 +235,9 @@ html{
     line-height: 30px;
 }
 
+#landing .variable{
+    color: #ffff00;
+}
 
 .landing-deco{
     position: absolute;

WebHostLib/static/styles/player-settings.css

@@ -4,7 +4,7 @@ html{
     background-size: 650px 650px;
 }
 
-#player-options{
+#player-settings{
     box-sizing: border-box;
     max-width: 1024px;
     margin-left: auto;
@@ -15,14 +15,14 @@ html{
     color: #eeffeb;
 }
 
-#player-options #player-options-button-row{
+#player-settings #player-settings-button-row{
     display: flex;
     flex-direction: row;
     justify-content: space-between;
     margin-top: 15px;
 }
 
-#player-options code{
+#player-settings code{
     background-color: #d9cd8e;
     border-radius: 4px;
     padding-left: 0.25rem;
@@ -30,7 +30,7 @@ html{
     color: #000000;
 }
 
-#player-options #user-message{
+#player-settings #user-message{
     display: none;
     width: calc(100% - 8px);
     background-color: #ffe86b;
@@ -40,12 +40,12 @@ html{
     text-align: center;
 }
 
-#player-options #user-message.visible{
+#player-settings #user-message.visible{
     display: block;
     cursor: pointer;
 }
 
-#player-options h1{
+#player-settings h1{
     font-size: 2.5rem;
     font-weight: normal;
     width: 100%;
@@ -53,7 +53,7 @@ html{
     text-shadow: 1px 1px 4px #000000;
 }
 
-#player-options h2{
+#player-settings h2{
     font-size: 40px;
     font-weight: normal;
     width: 100%;
@@ -62,22 +62,22 @@ html{
     text-shadow: 1px 1px 2px #000000;
 }
 
-#player-options h3, #player-options h4, #player-options h5, #player-options h6{
+#player-settings h3, #player-settings h4, #player-settings h5, #player-settings h6{
     text-shadow: 1px 1px 1px rgba(0, 0, 0, 0.5);
 }
 
-#player-options input:not([type]){
+#player-settings input:not([type]){
     border: 1px solid #000000;
     padding: 3px;
     border-radius: 3px;
     min-width: 150px;
 }
 
-#player-options input:not([type]):focus{
+#player-settings input:not([type]):focus{
     border: 1px solid #ffffff;
 }
 
-#player-options select{
+#player-settings select{
     border: 1px solid #000000;
     padding: 3px;
     border-radius: 3px;
@@ -85,72 +85,72 @@ html{
     background-color: #ffffff;
 }
 
-#player-options #game-options, #player-options #rom-options{
+#player-settings #game-options, #player-settings #rom-options{
     display: flex;
     flex-direction: row;
 }
 
-#player-options .left, #player-options .right{
+#player-settings .left, #player-settings .right{
     flex-grow: 1;
 }
 
-#player-options .left{
+#player-settings .left{
     margin-right: 10px;
 }
 
-#player-options .right{
+#player-settings .right{
     margin-left: 10px;
 }
 
-#player-options table{
+#player-settings table{
     margin-bottom: 30px;
     width: 100%;
 }
 
-#player-options table .select-container{
+#player-settings table .select-container{
     display: flex;
     flex-direction: row;
 }
 
-#player-options table .select-container select{
+#player-settings table .select-container select{
     min-width: 200px;
     flex-grow: 1;
 }
 
-#player-options table select:disabled{
+#player-settings table select:disabled{
     background-color: lightgray;
 }
 
-#player-options table .range-container{
+#player-settings table .range-container{
     display: flex;
     flex-direction: row;
 }
 
-#player-options table .range-container input[type=range]{
+#player-settings table .range-container input[type=range]{
     flex-grow: 1;
 }
 
-#player-options table .range-value{
+#player-settings table .range-value{
     min-width: 20px;
     margin-left: 0.25rem;
 }
 
-#player-options table .special-range-container{
+#player-settings table .special-range-container{
     display: flex;
     flex-direction: column;
 }
 
-#player-options table .special-range-wrapper{
+#player-settings table .special-range-wrapper{
     display: flex;
     flex-direction: row;
     margin-top: 0.25rem;
 }
 
-#player-options table .special-range-wrapper input[type=range]{
+#player-settings table .special-range-wrapper input[type=range]{
     flex-grow: 1;
 }
 
-#player-options table .randomize-button {
+#player-settings table .randomize-button {
     max-height: 24px;
     line-height: 16px;
     padding: 2px 8px;
@@ -160,23 +160,23 @@ html{
     border-radius: 3px;
 }
 
-#player-options table .randomize-button.active {
+#player-settings table .randomize-button.active {
     background-color: #ffef00; /* Same as .interactive in globalStyles.css */
 }
 
-#player-options table .randomize-button[data-tooltip]::after {
+#player-settings table .randomize-button[data-tooltip]::after {
     left: unset;
     right: 0;
 }
 
-#player-options table label{
+#player-settings table label{
     display: block;
     min-width: 200px;
     margin-right: 4px;
     cursor: default;
 }
 
-#player-options th, #player-options td{
+#player-settings th, #player-settings td{
     border: none;
     padding: 3px;
     font-size: 17px;
@@ -184,17 +184,17 @@ html{
 }
 
 @media all and (max-width: 1024px) {
-    #player-options {
+    #player-settings {
         border-radius: 0;
     }
 
-    #player-options #game-options{
+    #player-settings #game-options{
         justify-content: flex-start;
         flex-wrap: wrap;
     }
 
-    #player-options .left,
-    #player-options .right {
+    #player-settings .left,
+    #player-settings .right {
         margin: 0;
     }
 

WebHostLib/static/styles/sc2wolTracker.css

@@ -9,7 +9,7 @@
     border-top-left-radius: 4px;
     border-top-right-radius: 4px;
     padding: 3px 3px 10px;
-    width: 710px;
+    width: 500px;
     background-color: #525494;
 }
 
@@ -34,12 +34,10 @@
     max-height: 40px;
     border: 1px solid #000000;
     filter: grayscale(100%) contrast(75%) brightness(20%);
-    background-color: black;
 }
 
 #inventory-table img.acquired{
     filter: none;
-    background-color: black;
 }
 
 #inventory-table div.counted-item {
@@ -54,7 +52,7 @@
 }
 
 #location-table{
-    width: 710px;
+    width: 500px;
     border-left: 2px solid #000000;
     border-right: 2px solid #000000;
     border-bottom: 2px solid #000000;

WebHostLib/static/styles/supportedGames.css

@@ -18,22 +18,6 @@
     margin-bottom: 2px;
 }
 
-#games .collapse-toggle{
-    cursor: pointer;
-}
-
-#games h2 .collapse-arrow{
-    font-size: 20px;
-    display: inline-block; /* make vertical-align work */
-    padding-bottom: 9px;
-    vertical-align: middle;
-    padding-right: 8px;
-}
-
-#games p.collapsed{
-    display: none;
-}
-
 #games a{
     font-size: 16px;
 }
@@ -47,13 +31,3 @@
     line-height: 25px;
     margin-bottom: 7px;
 }
-
-#games .page-controls{
-    display: flex;
-    flex-direction: row;
-    margin-top: 0.25rem;
-}
-
-#games .page-controls button{
-    margin-left: 0.5rem;
-}

WebHostLib/static/styles/tracker.css

@@ -55,16 +55,16 @@ table.dataTable thead{
     font-family: LexendDeca-Regular, sans-serif;
 }
 
-table.dataTable tbody, table.dataTable tfoot{
+table.dataTable tbody{
     background-color: #dce2bd;
     font-family: LexendDeca-Light, sans-serif;
 }
 
-table.dataTable tbody tr:hover, table.dataTable tfoot tr:hover{
+table.dataTable tbody tr:hover{
     background-color: #e2eabb;
 }
 
-table.dataTable tbody td, table.dataTable tfoot td{
+table.dataTable tbody td{
     padding: 4px 6px;
 }
 
@@ -97,14 +97,10 @@ table.dataTable thead th.lower-row{
     top: 46px;
 }
 
-table.dataTable tbody td, table.dataTable tfoot td{
+table.dataTable tbody td{
     border: 1px solid #bba967;
 }
 
-table.dataTable tfoot td{
-    font-weight: bold;
-}
-
 div.dataTables_scrollBody{
     background-color: inherit !important;
 }

WebHostLib/static/styles/weighted-settings.css

@@ -292,12 +292,6 @@ html{
     margin-right: 0.5rem;
 }
 
-#weighted-settings .simple-list hr{
-    width: calc(100% - 2px);
-    margin: 2px auto;
-    border-bottom: 1px solid rgb(255 255 255 / 0.6);
-}
-
 #weighted-settings .invisible{
     display: none;
 }

WebHostLib/templates/check.html

@@ -17,9 +17,9 @@
             </p>
             <div id="check-form-wrapper">
                 <form id="check-form" method="post" enctype="multipart/form-data">
-                    <input id="file-input" type="file" name="file" multiple>
+                    <input id="file-input" type="file" name="file">
                 </form>
-                <button id="check-button">Upload File(s)</button>
+                <button id="check-button">Upload</button>
             </div>
         </div>
     </div>

WebHostLib/templates/checkResult.html

@@ -28,10 +28,6 @@
                     {% endfor %}
                 </tbody>
             </table>
-        {% if combined_yaml %}
-            <h1>Combined File Download</h1>
-            <p><a href="data:text/yaml;base64,{{ combined_yaml }}" download="combined.yaml">Download</a></p>
-        {% endif %}
         </div>
     </div>
 {% endblock %}

WebHostLib/templates/generate.html

@@ -203,10 +203,10 @@ Warning: playthrough can take a significant amount of time for larger multiworld
                         </div>
                     </div>
                     <div id="generate-form-button-row">
-                        <input id="file-input" type="file" name="file" multiple>
+                        <input id="file-input" type="file" name="file">
                     </div>
                 </form>
-                <button id="generate-game-button">Upload File(s)</button>
+                <button id="generate-game-button">Upload File</button>
             </div>
         </div>
     </div>

WebHostLib/templates/landing.html

@@ -49,9 +49,9 @@
                     our crazy idea into a reality.
                 </p>
                 <p>
-                    <a href="{{ url_for("stats") }}">{{ seeds }}</a>
+                    <span class="variable">{{ seeds }}</span>
                     games were generated and
-                    <a href="{{ url_for("stats") }}">{{ rooms }}</a>
+                    <span class="variable">{{ rooms }}</span>
                     were hosted in the last 7 days.
                 </p>
             </div>

WebHostLib/templates/lttpMultiTracker.html

@@ -153,7 +153,7 @@
                                             {%- endif -%}
                                         {% endif %}
                                     {%- endfor -%}
-                                    <td class="center-column">{{ "{0:.2f}".format(percent_total_checks_done[team][player]) }}</td>
+                                    <td class="center-column">{{ percent_total_checks_done[team][player] }}</td>
                                     {%- if activity_timers[(team, player)] -%}
                                         <td class="center-column">{{ activity_timers[(team, player)].total_seconds() }}</td>
                                     {%- else -%}

WebHostLib/templates/multiFactorioTracker.html

@@ -1,42 +0,0 @@
-{% extends "multiTracker.html" %}
-{# establish the to be tracked data. Display Name, factorio/AP internal name, display image #}
-{%- set science_packs = [
-    ("Logistic Science Pack", "logistic-science-pack",
-    "https://wiki.factorio.com/images/thumb/Logistic_science_pack.png/32px-Logistic_science_pack.png"),
-    ("Military Science Pack", "military-science-pack",
-    "https://wiki.factorio.com/images/thumb/Military_science_pack.png/32px-Military_science_pack.png"),
-    ("Chemical Science Pack", "chemical-science-pack",
-    "https://wiki.factorio.com/images/thumb/Chemical_science_pack.png/32px-Chemical_science_pack.png"),
-    ("Production Science Pack", "production-science-pack",
-    "https://wiki.factorio.com/images/thumb/Production_science_pack.png/32px-Production_science_pack.png"),
-    ("Utility Science Pack", "utility-science-pack",
-    "https://wiki.factorio.com/images/thumb/Utility_science_pack.png/32px-Utility_science_pack.png"),
-    ("Space Science Pack", "space-science-pack",
-    "https://wiki.factorio.com/images/thumb/Space_science_pack.png/32px-Space_science_pack.png"),
-] -%}
-{%- block custom_table_headers %}
-{#- macro that creates a table header with display name and image -#}
-{%- macro make_header(name, img_src) %}
-<th class="center-column">
-    <img src="{{ img_src}}"
-         alt="{{ name }}">
-</th>
-{% endmacro -%}
-{#- call the macro to build the table header -#}
-{%- for name, internal_name, img_src in science_packs %}
-    {{ make_header(name, img_src) }}
-{% endfor -%}
-{% endblock %}
-{% block custom_table_row scoped  %}
-{% if games[player] == "Factorio" %}
-    {%- set player_inventory = named_inventory[team][player] -%}
-    {%- set prog_science = player_inventory["progressive-science-pack"] -%}
-    {%- for name, internal_name, img_src in science_packs %}
-        <td class="center-column">{% if player_inventory[internal_name] or prog_science > loop.index0 %}✔{% endif %}</td>
-    {% endfor -%}
-{% else %}
-    {%- for _ in science_packs %}
-        <td class="center-column">❌</td>
-    {% endfor -%}
-{% endif %}
-{% endblock%}

WebHostLib/templates/multiTracker.html

@@ -37,7 +37,7 @@
                                 {% endblock %}
                                 <th class="center-column">Checks</th>
                                 <th class="center-column">&percnt;</th>
-                                <th class="center-column hours last-activity">Last<br>Activity</th>
+                                <th class="center-column hours">Last<br>Activity</th>
                             </tr>
                         </thead>
                         <tbody>
@@ -55,7 +55,7 @@
                                     <td class="center-column" data-sort="{{ checks["Total"] }}">
                                       {{ checks["Total"] }}/{{ locations[player] | length }}
                                     </td>
-                                    <td class="center-column">{{ "{0:.2f}".format(percent_total_checks_done[team][player]) }}</td>
+                                    <td class="center-column">{{ percent_total_checks_done[team][player] }}</td>
                                     {%- if activity_timers[team, player] -%}
                                         <td class="center-column">{{ activity_timers[team, player].total_seconds() }}</td>
                                     {%- else -%}
@@ -64,25 +64,6 @@
                                 </tr>
                             {%- endfor -%}
                         </tbody>
-                        {% if not self.custom_table_headers() | trim %}
-                            <tfoot>
-                                <tr>
-                                    <td></td>
-                                    <td>Total</td>
-                                    <td>All Games</td>
-                                    <td>{{ completed_worlds }}/{{ players|length }} Complete</td>
-                                    <td class="center-column">{{ players.values()|sum(attribute='Total') }}/{{ total_locations[team] }}</td>
-                                    <td class="center-column">
-                                        {% if total_locations[team] == 0 %}
-                                            100
-                                        {% else %}
-                                            {{ "{0:.2f}".format(players.values()|sum(attribute='Total') / total_locations[team] * 100) }}
-                                        {% endif %}
-                                    </td>
-                                    <td class="center-column last-activity"></td>
-                                </tr>
-                            </tfoot>
-                        {% endif %}
                     </table>
                 </div>
             {% endfor %}