Death link default true/false values for super metroid.

List assembled for use in competitive Zelda restreams.  Permission sought and granted by author Amarith via DM.

.github/workflows/lint.yml

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

.github/workflows/unittests.yml

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

.gitignore

@@ -4,6 +4,7 @@
 *_Spoiler.txt
 *.bmbp
 *.apbp
+*.apm3
 *.apmc
 *.apz5
 *.pyc
@@ -151,3 +152,7 @@ dmypy.json
 cython_debug/
 
 Archipelago.zip
+
+#minecraft server stuff
+jdk*/
+minecraft*/

BaseClasses.py

@@ -10,6 +10,9 @@ from typing import List, Dict, Optional, Set, Iterable, Union, Any, Tuple
 import secrets
 import random
 
+import Options
+import Utils
+
 
 class MultiWorld():
     debug_types = False
@@ -22,9 +25,9 @@ class MultiWorld():
     plando_texts: List[Dict[str, str]]
     plando_items: List
     plando_connections: List
-    er_seeds: Dict[int, str]
     worlds: Dict[int, Any]
     is_race: bool = False
+    precollected_items: Dict[int, List[Item]]
 
     class AttributeProxy():
         def __init__(self, rule):
@@ -44,7 +47,7 @@ class MultiWorld():
         self.itempool = []
         self.seed = None
         self.seed_name: str = "Unavailable"
-        self.precollected_items = []
+        self.precollected_items = {player: [] for player in self.player_ids}
         self.state = CollectionState(self)
         self._cached_entrances = None
         self._cached_locations = None
@@ -63,28 +66,29 @@ class MultiWorld():
         self.dynamic_regions = []
         self.dynamic_locations = []
         self.spoiler = Spoiler(self)
-        self.fix_trock_doors = self.AttributeProxy(lambda player: self.shuffle[player] != 'vanilla' or self.mode[player] == 'inverted')
-        self.fix_skullwoods_exit = self.AttributeProxy(lambda player: self.shuffle[player] not in ['vanilla', 'simple', 'restricted', 'dungeonssimple'])
-        self.fix_palaceofdarkness_exit = self.AttributeProxy(lambda player: self.shuffle[player] not in ['vanilla', 'simple', 'restricted', 'dungeonssimple'])
-        self.fix_trock_exit = self.AttributeProxy(lambda player: self.shuffle[player] not in ['vanilla', 'simple', 'restricted', 'dungeonssimple'])
+        self.fix_trock_doors = self.AttributeProxy(
+            lambda player: self.shuffle[player] != 'vanilla' or self.mode[player] == 'inverted')
+        self.fix_skullwoods_exit = self.AttributeProxy(
+            lambda player: self.shuffle[player] not in ['vanilla', 'simple', 'restricted', 'dungeonssimple'])
+        self.fix_palaceofdarkness_exit = self.AttributeProxy(
+            lambda player: self.shuffle[player] not in ['vanilla', 'simple', 'restricted', 'dungeonssimple'])
+        self.fix_trock_exit = self.AttributeProxy(
+            lambda player: self.shuffle[player] not in ['vanilla', 'simple', 'restricted', 'dungeonssimple'])
         self.NOTCURSED = self.AttributeProxy(lambda player: not self.CURSED[player])
 
         for player in range(1, players + 1):
             def set_player_attr(attr, val):
                 self.__dict__.setdefault(attr, {})[player] = val
+
             set_player_attr('tech_tree_layout_prerequisites', {})
             set_player_attr('_region_cache', {})
             set_player_attr('shuffle', "vanilla")
             set_player_attr('logic', "noglitches")
             set_player_attr('mode', 'open')
-            set_player_attr('swordless', False)
             set_player_attr('difficulty', 'normal')
             set_player_attr('item_functionality', 'normal')
             set_player_attr('timer', False)
             set_player_attr('goal', 'ganon')
-            set_player_attr('accessibility', 'items')
-            set_player_attr('retro', False)
-            set_player_attr('hints', True)
             set_player_attr('required_medallions', ['Ether', 'Quake'])
             set_player_attr('swamp_patch_required', False)
             set_player_attr('powder_patch_required', False)
@@ -97,13 +101,10 @@ class MultiWorld():
             set_player_attr('fix_fake_world', True)
             set_player_attr('difficulty_requirements', None)
             set_player_attr('boss_shuffle', 'none')
-            set_player_attr('enemy_shuffle', False)
             set_player_attr('enemy_health', 'default')
             set_player_attr('enemy_damage', 'default')
-            set_player_attr('killable_thieves', False)
-            set_player_attr('tile_shuffle', False)
-            set_player_attr('bush_shuffle', False)
-            set_player_attr('beemizer', 0)
+            set_player_attr('beemizer_total_chance', 0)
+            set_player_attr('beemizer_trap_chance', 0)
             set_player_attr('escape_assist', [])
             set_player_attr('open_pyramid', False)
             set_player_attr('treasure_hunt_icon', 'Triforce Piece')
@@ -114,16 +115,12 @@ class MultiWorld():
             set_player_attr('blue_clock_time', 2)
             set_player_attr('green_clock_time', 4)
             set_player_attr('can_take_damage', True)
-            set_player_attr('progression_balancing', True)
-            set_player_attr('local_items', set())
-            set_player_attr('non_local_items', set())
             set_player_attr('triforce_pieces_available', 30)
             set_player_attr('triforce_pieces_required', 20)
             set_player_attr('shop_shuffle', 'off')
             set_player_attr('shuffle_prizes', "g")
             set_player_attr('sprite_pool', [])
             set_player_attr('dark_room_logic', "lamp")
-            set_player_attr('restrict_dungeon_item_on_boss', False)
             set_player_attr('plando_items', [])
             set_player_attr('plando_texts', {})
             set_player_attr('plando_connections', [])
@@ -131,16 +128,38 @@ class MultiWorld():
             set_player_attr('completion_condition', lambda state: True)
         self.custom_data = {}
         self.worlds = {}
+        self.slot_seeds = {}
+
+    def set_seed(self, seed: Optional[int] = None, secure: bool = False, name: Optional[str] = None):
+        self.seed = get_seed(seed)
+        if secure:
+            self.secure()
+        else:
+            self.random.seed(self.seed)
+        self.seed_name = name if name else str(self.seed)
+        self.slot_seeds = {player: random.Random(self.random.getrandbits(64)) for player in
+                           range(1, self.players + 1)}
 
     def set_options(self, args):
         from worlds import AutoWorld
         for player in self.player_ids:
             self.custom_data[player] = {}
             world_type = AutoWorld.AutoWorldRegister.world_types[self.game[player]]
-            for option in world_type.options:
-                setattr(self, option, getattr(args, option, {}))
+            for option_key in world_type.options:
+                setattr(self, option_key, getattr(args, option_key, {}))
+            for option_key in Options.common_options:
+                setattr(self, option_key, getattr(args, option_key, {}))
+            for option_key in Options.per_game_common_options:
+                setattr(self, option_key, getattr(args, option_key, {}))
             self.worlds[player] = world_type(self, player)
 
+    # 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})
+
     def secure(self):
         self.random = secrets.SystemRandom()
         self.is_race = True
@@ -228,7 +247,7 @@ class MultiWorld():
             if item.name in subworld.dungeon_local_item_names:
                 subworld.collect(ret, item)
         ret.sweep_for_events()
-        
+
         if use_cache:
             self._all_state = ret
         return ret
@@ -236,20 +255,24 @@ class MultiWorld():
     def get_items(self) -> list:
         return [loc.item for loc in self.get_filled_locations()] + self.itempool
 
-    def find_items(self, item, player: int) -> List[Location]:
+    def find_item_locations(self, item, player: int) -> List[Location]:
         return [location for location in self.get_locations() if
-                location.item is not None and location.item.name == item and location.item.player == player]
+                location.item and location.item.name == item and location.item.player == player]
 
     def find_item(self, item, player: int) -> Location:
         return next(location for location in self.get_locations() if
                     location.item and location.item.name == item and location.item.player == player)
 
+    def find_items_in_locations(self, items: Set[str], player: int) -> List[Location]:
+        return [location for location in self.get_locations() if
+                location.item and location.item.name in items and location.item.player == player]
+
     def create_item(self, item_name: str, player: int) -> Item:
         return self.worlds[player].create_item(item_name)
 
     def push_precollected(self, item: Item):
         item.world = self
-        self.precollected_items.append(item)
+        self.precollected_items[item.player].append(item)
         self.state.collect(item, True)
 
     def push_item(self, location: Location, item: Item, collect: bool = True):
@@ -268,7 +291,7 @@ class MultiWorld():
         else:
             raise RuntimeError('Cannot assign item %s to location %s.' % (item, location))
 
-    def get_entrances(self) -> list:
+    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
@@ -276,7 +299,7 @@ class MultiWorld():
     def clear_entrance_cache(self):
         self._cached_entrances = None
 
-    def get_locations(self) -> list:
+    def get_locations(self) -> List[Location]:
         if self._cached_locations is None:
             self._cached_locations = [location for region in self.regions for location in region.locations]
         return self._cached_locations
@@ -284,7 +307,7 @@ class MultiWorld():
     def clear_location_cache(self):
         self._cached_locations = None
 
-    def get_unfilled_locations(self, player=None) -> list:
+    def get_unfilled_locations(self, player=None) -> List[Location]:
         if player is not None:
             return [location for location in self.get_locations() if
                     location.player == player and not location.item]
@@ -293,19 +316,19 @@ class MultiWorld():
     def get_unfilled_dungeon_locations(self):
         return [location for location in self.get_locations() if not location.item and location.parent_region.dungeon]
 
-    def get_filled_locations(self, player=None) -> list:
+    def get_filled_locations(self, player=None) -> List[Location]:
         if player is not None:
             return [location for location in self.get_locations() if
                     location.player == player and location.item is not None]
         return [location for location in self.get_locations() if location.item is not None]
 
-    def get_reachable_locations(self, state=None, player=None) -> list:
+    def get_reachable_locations(self, state=None, player=None) -> List[Location]:
         if state is None:
             state = self.state
         return [location for location in self.get_locations() if
                 (player is None or location.player == player) and location.can_reach(state)]
 
-    def get_placeable_locations(self, state=None, player=None) -> list:
+    def get_placeable_locations(self, state=None, player=None) -> List[Location]:
         if state is None:
             state = self.state
         return [location for location in self.get_locations() if
@@ -333,7 +356,7 @@ class MultiWorld():
         else:
             return all((self.has_beaten_game(state, p) for p in range(1, self.players + 1)))
 
-    def can_beat_game(self, starting_state : Optional[CollectionState]=None):
+    def can_beat_game(self, starting_state: Optional[CollectionState] = None):
         if starting_state:
             if self.has_beaten_game(starting_state):
                 return True
@@ -390,21 +413,21 @@ class MultiWorld():
         """Check if accessibility rules are fulfilled with current or supplied state."""
         if not state:
             state = CollectionState(self)
-        players = {"none" : set(),
+        players = {"minimal": set(),
                    "items": set(),
                    "locations": set()}
         for player, access in self.accessibility.items():
-            players[access].add(player)
+            players[access.current_key].add(player)
 
         beatable_fulfilled = False
 
-        def location_conditition(location : Location):
+        def location_conditition(location: Location):
             """Determine if this location has to be accessible, location is already filtered by location_relevant"""
-            if location.player in players["none"]:
+            if location.player in players["minimal"]:
                 return False
             return True
 
-        def location_relevant(location : Location):
+        def location_relevant(location: Location):
             """Determine if this location is relevant to sweep."""
             if location.player in players["locations"] or location.event or \
                     (location.item and location.item.advancement):
@@ -456,8 +479,9 @@ class CollectionState(object):
         self.path = {}
         self.locations_checked = set()
         self.stale = {player: True for player in range(1, parent.players + 1)}
-        for item in parent.precollected_items:
-            self.collect(item, True)
+        for items in parent.precollected_items.values():
+            for item in items:
+                self.collect(item, True)
 
     def update_reachable_regions(self, player: int):
         from worlds.alttp.EntranceShuffle import indirect_connections
@@ -497,7 +521,8 @@ class CollectionState(object):
         ret.prog_items = self.prog_items.copy()
         ret.reachable_regions = {player: copy.copy(self.reachable_regions[player]) for player in
                                  range(1, self.world.players + 1)}
-        ret.blocked_connections = {player: copy.copy(self.blocked_connections[player]) for player in range(1, self.world.players + 1)}
+        ret.blocked_connections = {player: copy.copy(self.blocked_connections[player]) for player in
+                                   range(1, self.world.players + 1)}
         ret.events = copy.copy(self.events)
         ret.path = copy.copy(self.path)
         ret.locations_checked = copy.copy(self.locations_checked)
@@ -533,10 +558,10 @@ class CollectionState(object):
     def has(self, item, player: int, count: int = 1):
         return self.prog_items[item, player] >= count
 
-    def has_all(self, items: Set[str], player:int):
+    def has_all(self, items: Set[str], player: int):
         return all(self.prog_items[item, player] for item in items)
 
-    def has_any(self, items: Set[str], player:int):
+    def has_any(self, items: Set[str], player: int):
         return any(self.prog_items[item, player] for item in items)
 
     def has_group(self, item_name_group: str, player: int, count: int = 1):
@@ -561,7 +586,7 @@ class CollectionState(object):
         return any(shop.region.player == player and shop.has(item) and shop.region.can_reach(self) for
                    shop in self.world.shops)
 
-    def item_count(self, item, player: int) -> int:
+    def item_count(self, item: str, player: int) -> int:
         return self.prog_items[item, player]
 
     def has_triforce_pieces(self, count: int, player: int) -> bool:
@@ -636,10 +661,10 @@ class CollectionState(object):
                 self.is_not_bunny(cave, player)
         )
 
-    def can_retrieve_tablet(self, player:int) -> bool:
+    def can_retrieve_tablet(self, player: int) -> bool:
         return self.has('Book of Mudora', player) and (self.has_beam_sword(player) or
-               (self.world.swordless[player] and
-                self.has("Hammer", player)))
+                                                       (self.world.swordless[player] and
+                                                        self.has("Hammer", player)))
 
     def has_sword(self, player: int) -> bool:
         return self.has('Fighter Sword', player) \
@@ -648,7 +673,8 @@ class CollectionState(object):
                or self.has('Golden Sword', player)
 
     def has_beam_sword(self, player: int) -> bool:
-        return self.has('Master Sword', player) or self.has('Tempered Sword', player) or self.has('Golden Sword', player)
+        return self.has('Master Sword', player) or self.has('Tempered Sword', player) or self.has('Golden Sword',
+                                                                                                  player)
 
     def has_melee_weapon(self, player: int) -> bool:
         return self.has_sword(player) or self.has('Hammer', player)
@@ -687,23 +713,23 @@ class CollectionState(object):
     def has_turtle_rock_medallion(self, player: int) -> bool:
         return self.has(self.world.required_medallions[player][1], player)
 
-    def can_boots_clip_lw(self, player):
+    def can_boots_clip_lw(self, player: int):
         if self.world.mode[player] == 'inverted':
             return self.has('Pegasus Boots', player) and self.has('Moon Pearl', player)
         return self.has('Pegasus Boots', player)
 
-    def can_boots_clip_dw(self, player):
+    def can_boots_clip_dw(self, player: int):
         if self.world.mode[player] != 'inverted':
             return self.has('Pegasus Boots', player) and self.has('Moon Pearl', player)
         return self.has('Pegasus Boots', player)
 
-    def can_get_glitched_speed_lw(self, player):
+    def can_get_glitched_speed_lw(self, player: int):
         rules = [self.has('Pegasus Boots', player), any([self.has('Hookshot', player), self.has_sword(player)])]
         if self.world.mode[player] == 'inverted':
             rules.append(self.has('Moon Pearl', player))
         return all(rules)
 
-    def can_superbunny_mirror_with_sword(self, player):
+    def can_superbunny_mirror_with_sword(self, player: int):
         return self.has('Magic Mirror', player) and self.has_sword(player)
 
     def can_get_glitched_speed_dw(self, player: int):
@@ -712,7 +738,7 @@ class CollectionState(object):
             rules.append(self.has('Moon Pearl', player))
         return all(rules)
 
-    def can_bomb_clip(self, region: Region, player: int) -> bool: 
+    def can_bomb_clip(self, region: Region, player: int) -> bool:
         return self.is_not_bunny(region, player) and self.has('Pegasus Boots', player)
 
     def collect(self, item: Item, event: bool = False, location: Location = None) -> bool:
@@ -732,7 +758,7 @@ class CollectionState(object):
 
         return changed
 
-    def remove(self, item):
+    def remove(self, item: Item):
         changed = self.world.worlds[item.player].remove(self, item)
         if changed:
             # invalidate caches, nothing can be trusted anymore now
@@ -740,23 +766,24 @@ class CollectionState(object):
             self.blocked_connections[item.player] = set()
             self.stale[item.player] = True
 
+
 @unique
 class RegionType(int, Enum):
     Generic = 0
     LightWorld = 1
     DarkWorld = 2
-    Cave = 3 # Also includes Houses
+    Cave = 3  # Also includes Houses
     Dungeon = 4
 
     @property
-    def is_indoors(self):
+    def is_indoors(self) -> bool:
         """Shorthand for checking if Cave or Dungeon"""
         return self in (RegionType.Cave, RegionType.Dungeon)
 
 
 class Region(object):
 
-    def __init__(self, name: str, type, hint, player: int, world: Optional[MultiWorld] = None):
+    def __init__(self, name: str, type: str, hint, player: int, world: Optional[MultiWorld] = None):
         self.name = name
         self.type = type
         self.entrances = []
@@ -771,12 +798,12 @@ class Region(object):
         self.hint_text = hint
         self.player = player
 
-    def can_reach(self, state: CollectionState):
+    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):
+    def can_reach_private(self, state: CollectionState) -> bool:
         for entrance in self.entrances:
             if entrance.can_reach(state):
                 if not self in state.path:
@@ -804,7 +831,7 @@ class Entrance(object):
         self.player = player
         self.hide_path = False
 
-    def can_reach(self, state):
+    def can_reach(self, state: CollectionState) -> bool:
         if self.parent_region.can_reach(state) and self.access_rule(state):
             if not self.hide_path and not self in state.path:
                 state.path[self] = (self.name, state.path.get(self.parent_region, (self.parent_region.name, None)))
@@ -812,7 +839,7 @@ class Entrance(object):
 
         return False
 
-    def connect(self, region, addresses=None, target=None):
+    def connect(self, region: Region, addresses=None, target = None):
         self.connected_region = region
         self.target = target
         self.addresses = addresses
@@ -838,11 +865,11 @@ class Dungeon(object):
         self.world = None
 
     @property
-    def boss(self):
+    def boss(self) -> Optional[Boss]:
         return self.bosses.get(None, None)
 
     @boss.setter
-    def boss(self, value):
+    def boss(self, value: Optional[Boss]):
         self.bosses[None] = value
 
     @property
@@ -867,8 +894,9 @@ class Dungeon(object):
     def __str__(self):
         return self.world.get_name_string_for_object(self) if self.world else f'{self.name} (Player {self.player})'
 
+
 class Boss():
-    def __init__(self, name, enemizer_name, defeat_rule, player: int):
+    def __init__(self, name: str, enemizer_name: str, defeat_rule, player: int):
         self.name = name
         self.enemizer_name = enemizer_name
         self.defeat_rule = defeat_rule
@@ -880,6 +908,7 @@ class Boss():
     def __repr__(self):
         return f"Boss({self.name})"
 
+
 class Location():
     # If given as integer, then this is the shop's inventory index
     shop_slot: Optional[int] = None
@@ -895,7 +924,7 @@ class Location():
     access_rule = staticmethod(lambda state: True)
     item_rule = staticmethod(lambda item: True)
 
-    def __init__(self, player: int, name: str = '', address:int = None, parent=None):
+    def __init__(self, player: int, name: str = '', address: int = None, parent=None):
         self.name: str = name
         self.address: Optional[int] = address
         self.parent_region: Region = parent
@@ -948,9 +977,12 @@ class Location():
 class Item():
     location: Optional[Location] = None
     world: Optional[MultiWorld] = None
-    code: Optional[str] = None  # an item with ID None is called an Event, and does not get written to multidata
+    code: Optional[int] = None  # an item with ID None is called an Event, and does not get written to multidata
+    name: str
     game: str = "Generic"
     type: str = None
+    # indicates if this is a negative impact item. Causes these to be handled differently by various games.
+    trap: bool = False
     # change manually to ensure that a specific non-progression item never goes on an excluded location
     never_exclude = False
 
@@ -1009,67 +1041,87 @@ class Spoiler():
         self.medallions = {}
         self.playthrough = {}
         self.unreachables = []
-        self.startinventory = []
         self.locations = {}
         self.paths = {}
-        self.metadata = {}
         self.shops = []
         self.bosses = OrderedDict()
 
     def set_entrance(self, entrance, exit, direction, player):
         if self.world.players == 1:
-            self.entrances[(entrance, direction, player)] = OrderedDict([('entrance', entrance), ('exit', exit), ('direction', direction)])
+            self.entrances[(entrance, direction, player)] = OrderedDict(
+                [('entrance', entrance), ('exit', exit), ('direction', direction)])
         else:
-            self.entrances[(entrance, direction, player)] = OrderedDict([('player', player), ('entrance', entrance), ('exit', exit), ('direction', direction)])
+            self.entrances[(entrance, direction, player)] = OrderedDict(
+                [('player', player), ('entrance', entrance), ('exit', exit), ('direction', direction)])
 
     def parse_data(self):
         self.medallions = OrderedDict()
         for player in self.world.get_game_players("A Link to the Past"):
-            self.medallions[f'Misery Mire ({self.world.get_player_name(player)})'] = self.world.required_medallions[player][0]
-            self.medallions[f'Turtle Rock ({self.world.get_player_name(player)})'] = self.world.required_medallions[player][1]
-
-        self.startinventory = list(map(str, self.world.precollected_items))
+            self.medallions[f'Misery Mire ({self.world.get_player_name(player)})'] = \
+                self.world.required_medallions[player][0]
+            self.medallions[f'Turtle Rock ({self.world.get_player_name(player)})'] = \
+                self.world.required_medallions[player][1]
 
         self.locations = OrderedDict()
         listed_locations = set()
 
-        lw_locations = [loc for loc in self.world.get_locations() if loc not in listed_locations and loc.parent_region and loc.parent_region.type == RegionType.LightWorld and loc.show_in_spoiler]
-        self.locations['Light World'] = OrderedDict([(str(location), str(location.item) if location.item is not None else 'Nothing') for location in lw_locations])
+        lw_locations = [loc for loc in self.world.get_locations() if
+                        loc not in listed_locations and loc.parent_region and loc.parent_region.type == RegionType.LightWorld and loc.show_in_spoiler]
+        self.locations['Light World'] = OrderedDict(
+            [(str(location), str(location.item) if location.item is not None else 'Nothing') for location in
+             lw_locations])
         listed_locations.update(lw_locations)
 
-        dw_locations = [loc for loc in self.world.get_locations() if loc not in listed_locations and loc.parent_region and loc.parent_region.type == RegionType.DarkWorld and loc.show_in_spoiler]
-        self.locations['Dark World'] = OrderedDict([(str(location), str(location.item) if location.item is not None else 'Nothing') for location in dw_locations])
+        dw_locations = [loc for loc in self.world.get_locations() if
+                        loc not in listed_locations and loc.parent_region and loc.parent_region.type == RegionType.DarkWorld and loc.show_in_spoiler]
+        self.locations['Dark World'] = OrderedDict(
+            [(str(location), str(location.item) if location.item is not None else 'Nothing') for location in
+             dw_locations])
         listed_locations.update(dw_locations)
 
-        cave_locations = [loc for loc in self.world.get_locations() if loc not in listed_locations and loc.parent_region and loc.parent_region.type == RegionType.Cave and loc.show_in_spoiler]
-        self.locations['Caves'] = OrderedDict([(str(location), str(location.item) if location.item is not None else 'Nothing') for location in cave_locations])
+        cave_locations = [loc for loc in self.world.get_locations() if
+                          loc not in listed_locations and loc.parent_region and loc.parent_region.type == RegionType.Cave and loc.show_in_spoiler]
+        self.locations['Caves'] = OrderedDict(
+            [(str(location), str(location.item) if location.item is not None else 'Nothing') for location in
+             cave_locations])
         listed_locations.update(cave_locations)
 
         for dungeon in self.world.dungeons.values():
-            dungeon_locations = [loc for loc in self.world.get_locations() if loc not in listed_locations and loc.parent_region and loc.parent_region.dungeon == dungeon and loc.show_in_spoiler]
-            self.locations[str(dungeon)] = OrderedDict([(str(location), str(location.item) if location.item is not None else 'Nothing') for location in dungeon_locations])
+            dungeon_locations = [loc for loc in self.world.get_locations() if
+                                 loc not in listed_locations and loc.parent_region and loc.parent_region.dungeon == dungeon and loc.show_in_spoiler]
+            self.locations[str(dungeon)] = OrderedDict(
+                [(str(location), str(location.item) if location.item is not None else 'Nothing') for location in
+                 dungeon_locations])
             listed_locations.update(dungeon_locations)
 
-        other_locations = [loc for loc in self.world.get_locations() if loc not in listed_locations and loc.show_in_spoiler]
+        other_locations = [loc for loc in self.world.get_locations() if
+                           loc not in listed_locations and loc.show_in_spoiler]
         if other_locations:
-            self.locations['Other Locations'] = OrderedDict([(str(location), str(location.item) if location.item is not None else 'Nothing') for location in other_locations])
+            self.locations['Other Locations'] = OrderedDict(
+                [(str(location), str(location.item) if location.item is not None else 'Nothing') for location in
+                 other_locations])
             listed_locations.update(other_locations)
 
         self.shops = []
-        from worlds.alttp.Shops import ShopType
+        from worlds.alttp.Shops import ShopType, price_type_display_name, price_rate_display
         for shop in self.world.shops:
             if not shop.custom:
                 continue
-            shopdata = {'location': str(shop.region),
-                        'type': 'Take Any' if shop.type == ShopType.TakeAny else 'Shop'
-                       }
+            shopdata = {
+                'location': str(shop.region),
+                'type': 'Take Any' if shop.type == ShopType.TakeAny else 'Shop'
+            }
             for index, item in enumerate(shop.inventory):
                 if item is None:
                     continue
-                shopdata['item_{}'.format(index)] = "{} — {}".format(item['item'], item['price']) if item['price'] else item['item']
+                my_price = item['price'] // price_rate_display.get(item['price_type'], 1)
+                shopdata['item_{}'.format(
+                    index)] = f"{item['item']} — {my_price} {price_type_display_name[item['price_type']]}"
 
                 if item['player'] > 0:
-                    shopdata['item_{}'.format(index)] = shopdata['item_{}'.format(index)].replace('—', '(Player {}) — '.format(item['player']))
+                    shopdata['item_{}'.format(index)] = shopdata['item_{}'.format(index)].replace('—',
+                                                                                                  '(Player {}) — '.format(
+                                                                                                      item['player']))
 
                 if item['max'] == 0:
                     continue
@@ -1077,7 +1129,8 @@ class Spoiler():
 
                 if item['replacement'] is None:
                     continue
-                shopdata['item_{}'.format(index)] += ", {} - {}".format(item['replacement'], item['replacement_price']) if item['replacement_price'] else item['replacement']
+                shopdata['item_{}'.format(
+                    index)] += f", {item['replacement']} - {item['replacement_price']} {price_type_display_name[item['replacement_price_type']]}"
             self.shops.append(shopdata)
 
         for player in self.world.get_game_players("A Link to the Past"):
@@ -1086,7 +1139,8 @@ class Spoiler():
             self.bosses[str(player)]["Desert Palace"] = self.world.get_dungeon("Desert Palace", player).boss.name
             self.bosses[str(player)]["Tower Of Hera"] = self.world.get_dungeon("Tower of Hera", player).boss.name
             self.bosses[str(player)]["Hyrule Castle"] = "Agahnim"
-            self.bosses[str(player)]["Palace Of Darkness"] = self.world.get_dungeon("Palace of Darkness", player).boss.name
+            self.bosses[str(player)]["Palace Of Darkness"] = self.world.get_dungeon("Palace of Darkness",
+                                                                                    player).boss.name
             self.bosses[str(player)]["Swamp Palace"] = self.world.get_dungeon("Swamp Palace", player).boss.name
             self.bosses[str(player)]["Skull Woods"] = self.world.get_dungeon("Skull Woods", player).boss.name
             self.bosses[str(player)]["Thieves Town"] = self.world.get_dungeon("Thieves Town", player).boss.name
@@ -1094,58 +1148,28 @@ class Spoiler():
             self.bosses[str(player)]["Misery Mire"] = self.world.get_dungeon("Misery Mire", player).boss.name
             self.bosses[str(player)]["Turtle Rock"] = self.world.get_dungeon("Turtle Rock", player).boss.name
             if self.world.mode[player] != 'inverted':
-                self.bosses[str(player)]["Ganons Tower Basement"] = self.world.get_dungeon('Ganons Tower', player).bosses['bottom'].name
-                self.bosses[str(player)]["Ganons Tower Middle"] = self.world.get_dungeon('Ganons Tower', player).bosses['middle'].name
-                self.bosses[str(player)]["Ganons Tower Top"] = self.world.get_dungeon('Ganons Tower', player).bosses['top'].name
+                self.bosses[str(player)]["Ganons Tower Basement"] = \
+                    self.world.get_dungeon('Ganons Tower', player).bosses['bottom'].name
+                self.bosses[str(player)]["Ganons Tower Middle"] = self.world.get_dungeon('Ganons Tower', player).bosses[
+                    'middle'].name
+                self.bosses[str(player)]["Ganons Tower Top"] = self.world.get_dungeon('Ganons Tower', player).bosses[
+                    'top'].name
             else:
-                self.bosses[str(player)]["Ganons Tower Basement"] = self.world.get_dungeon('Inverted Ganons Tower', player).bosses['bottom'].name
-                self.bosses[str(player)]["Ganons Tower Middle"] = self.world.get_dungeon('Inverted Ganons Tower', player).bosses['middle'].name
-                self.bosses[str(player)]["Ganons Tower Top"] = self.world.get_dungeon('Inverted Ganons Tower', player).bosses['top'].name
+                self.bosses[str(player)]["Ganons Tower Basement"] = \
+                    self.world.get_dungeon('Inverted Ganons Tower', player).bosses['bottom'].name
+                self.bosses[str(player)]["Ganons Tower Middle"] = \
+                    self.world.get_dungeon('Inverted Ganons Tower', player).bosses['middle'].name
+                self.bosses[str(player)]["Ganons Tower Top"] = \
+                    self.world.get_dungeon('Inverted Ganons Tower', player).bosses['top'].name
 
             self.bosses[str(player)]["Ganons Tower"] = "Agahnim 2"
             self.bosses[str(player)]["Ganon"] = "Ganon"
 
-        from Utils import __version__ as APVersion
-        self.metadata = {'version': APVersion,
-                         'logic': self.world.logic,
-                         'dark_room_logic': self.world.dark_room_logic,
-                         'mode': self.world.mode,
-                         'retro': self.world.retro,
-                         'swordless': self.world.swordless,
-                         'goal': self.world.goal,
-                         'shuffle': self.world.shuffle,
-                         'item_pool': self.world.difficulty,
-                         'item_functionality': self.world.item_functionality,
-                         'open_pyramid': self.world.open_pyramid,
-                         'accessibility': self.world.accessibility,
-                         'hints': self.world.hints,
-                         'boss_shuffle': self.world.boss_shuffle,
-                         'enemy_shuffle': self.world.enemy_shuffle,
-                         'enemy_health': self.world.enemy_health,
-                         'enemy_damage': self.world.enemy_damage,
-                         'killable_thieves': self.world.killable_thieves,
-                         'tile_shuffle': self.world.tile_shuffle,
-                         'bush_shuffle': self.world.bush_shuffle,
-                         'beemizer': self.world.beemizer,
-                         'shufflepots': self.world.shufflepots,
-                         'players': self.world.players,
-                         'progression_balancing': self.world.progression_balancing,
-                         'triforce_pieces_available': self.world.triforce_pieces_available,
-                         'triforce_pieces_required': self.world.triforce_pieces_required,
-                         'shop_shuffle': self.world.shop_shuffle,
-                         'shuffle_prizes': self.world.shuffle_prizes,
-                         'sprite_pool': self.world.sprite_pool,
-                         'restrict_dungeon_item_on_boss': self.world.restrict_dungeon_item_on_boss,
-                         'game': self.world.game,
-                         'er_seeds': self.world.er_seeds
-                         }
-
     def to_json(self):
         self.parse_data()
         out = OrderedDict()
         out['Entrances'] = list(self.entrances.values())
         out.update(self.locations)
-        out['Starting Inventory'] = self.startinventory
         out['Special'] = self.medallions
         if self.hashes:
             out['Hashes'] = self.hashes
@@ -1154,11 +1178,11 @@ class Spoiler():
         out['playthrough'] = self.playthrough
         out['paths'] = self.paths
         out['Bosses'] = self.bosses
-        out['meta'] = self.metadata
 
         return json.dumps(out)
 
     def to_file(self, filename):
+        from worlds.AutoWorld import call_all, call_single, call_stage
         self.parse_data()
 
         def bool_to_text(variable: Union[bool, str]) -> str:
@@ -1166,79 +1190,71 @@ class Spoiler():
                 return variable
             return 'Yes' if variable else 'No'
 
+        def write_option(option_key: str, option_obj: type(Options.Option)):
+            res = getattr(self.world, option_key)[player]
+            displayname = getattr(option_obj, "displayname", option_key)
+            try:
+                outfile.write(f'{displayname + ":":33}{res.get_current_option_name()}\n')
+            except:
+                raise Exception
+
         with open(filename, 'w', encoding="utf-8-sig") as outfile:
             outfile.write(
                 'Archipelago Version %s  -  Seed: %s\n\n' % (
-                    self.metadata['version'], self.world.seed))
+                    Utils.__version__, self.world.seed))
             outfile.write('Filling Algorithm:               %s\n' % self.world.algorithm)
             outfile.write('Players:                         %d\n' % self.world.players)
+            call_stage(self.world, "write_spoiler_header", outfile)
 
             for player in range(1, self.world.players + 1):
                 if self.world.players > 1:
                     outfile.write('\nPlayer %d: %s\n' % (player, self.world.get_player_name(player)))
                 outfile.write('Game:                            %s\n' % self.world.game[player])
-                if self.world.players > 1:
-                    outfile.write('Progression Balanced:            %s\n' % (
-                        'Yes' if self.metadata['progression_balancing'][player] else 'No'))
-                outfile.write('Accessibility:                   %s\n' % self.metadata['accessibility'][player])
+                for f_option, option in Options.common_options.items():
+                    write_option(f_option, option)
+                for f_option, option in Options.per_game_common_options.items():
+                    write_option(f_option, option)
                 options = self.world.worlds[player].options
                 if options:
                     for f_option, option in options.items():
-                        res = getattr(self.world, f_option)[player]
-                        displayname = getattr(option, "displayname", f_option)
-                        outfile.write(f'{displayname + ":":33}{res.get_current_option_name()}\n')
+                        write_option(f_option, option)
+                call_single(self.world, "write_spoiler_header", player, outfile)
 
                 if player in self.world.get_game_players("A Link to the Past"):
                     outfile.write('%s%s\n' % ('Hash: ', self.hashes[player]))
 
-                    outfile.write('Logic:                           %s\n' % self.metadata['logic'][player])
-                    outfile.write('Dark Room Logic:                 %s\n' % self.metadata['dark_room_logic'][player])
-                    outfile.write('Restricted Boss Drops:           %s\n' %
-                                  bool_to_text(self.metadata['restrict_dungeon_item_on_boss'][player]))
-
-                    outfile.write('Mode:                            %s\n' % self.metadata['mode'][player])
-                    outfile.write('Retro:                           %s\n' %
-                                  ('Yes' if self.metadata['retro'][player] else 'No'))
-                    outfile.write('Swordless:                       %s\n' % ('Yes' if self.metadata['swordless'][player] else 'No'))
-                    outfile.write('Goal:                            %s\n' % self.metadata['goal'][player])
-                    if "triforce" in self.metadata["goal"][player]:  # triforce hunt
+                    outfile.write('Logic:                           %s\n' % self.world.logic[player])
+                    outfile.write('Dark Room Logic:                 %s\n' % self.world.dark_room_logic[player])
+                    outfile.write('Mode:                            %s\n' % self.world.mode[player])
+                    outfile.write('Goal:                            %s\n' % self.world.goal[player])
+                    if "triforce" in self.world.goal[player]:  # triforce hunt
                         outfile.write("Pieces available for Triforce:   %s\n" %
-                                      self.metadata['triforce_pieces_available'][player])
+                                      self.world.triforce_pieces_available[player])
                         outfile.write("Pieces required for Triforce:    %s\n" %
-                                      self.metadata["triforce_pieces_required"][player])
-                    outfile.write('Difficulty:                      %s\n' % self.metadata['item_pool'][player])
-                    outfile.write('Item Functionality:              %s\n' % self.metadata['item_functionality'][player])
-                    outfile.write('Entrance Shuffle:                %s\n' % self.metadata['shuffle'][player])
-                    if self.metadata['shuffle'][player] != "vanilla":
-                        outfile.write('Entrance Shuffle Seed            %s\n' % self.metadata['er_seeds'][player])
+                                      self.world.triforce_pieces_required[player])
+                    outfile.write('Difficulty:                      %s\n' % self.world.difficulty[player])
+                    outfile.write('Item Functionality:              %s\n' % self.world.item_functionality[player])
+                    outfile.write('Entrance Shuffle:                %s\n' % self.world.shuffle[player])
+                    if self.world.shuffle[player] != "vanilla":
+                        outfile.write('Entrance Shuffle Seed            %s\n' % self.world.worlds[player].er_seed)
                     outfile.write('Pyramid hole pre-opened:         %s\n' % (
-                        'Yes' if self.metadata['open_pyramid'][player] else 'No'))
+                        'Yes' if self.world.open_pyramid[player] else 'No'))
                     outfile.write('Shop inventory shuffle:          %s\n' %
-                                  bool_to_text("i" in self.metadata["shop_shuffle"][player]))
+                                  bool_to_text("i" in self.world.shop_shuffle[player]))
                     outfile.write('Shop price shuffle:              %s\n' %
-                                  bool_to_text("p" in self.metadata["shop_shuffle"][player]))
+                                  bool_to_text("p" in self.world.shop_shuffle[player]))
                     outfile.write('Shop upgrade shuffle:            %s\n' %
-                                  bool_to_text("u" in self.metadata["shop_shuffle"][player]))
+                                  bool_to_text("u" in self.world.shop_shuffle[player]))
                     outfile.write('New Shop inventory:              %s\n' %
-                                  bool_to_text("g" in self.metadata["shop_shuffle"][player] or
-                                               "f" in self.metadata["shop_shuffle"][player]))
+                                  bool_to_text("g" in self.world.shop_shuffle[player] or
+                                               "f" in self.world.shop_shuffle[player]))
                     outfile.write('Custom Potion Shop:              %s\n' %
-                                  bool_to_text("w" in self.metadata["shop_shuffle"][player]))
-                    outfile.write('Boss shuffle:                    %s\n' % self.metadata['boss_shuffle'][player])
-                    outfile.write(
-                        'Enemy shuffle:                   %s\n' % bool_to_text(self.metadata['enemy_shuffle'][player]))
-                    outfile.write('Enemy health:                    %s\n' % self.metadata['enemy_health'][player])
-                    outfile.write('Enemy damage:                    %s\n' % self.metadata['enemy_damage'][player])
-                    outfile.write(f'Killable thieves:                {bool_to_text(self.metadata["killable_thieves"][player])}\n')
-                    outfile.write(f'Shuffled tiles:                  {bool_to_text(self.metadata["tile_shuffle"][player])}\n')
-                    outfile.write(f'Shuffled bushes:                 {bool_to_text(self.metadata["bush_shuffle"][player])}\n')
-                    outfile.write(
-                        'Hints:                           %s\n' % ('Yes' if self.metadata['hints'][player] else 'No'))
-                    outfile.write('Beemizer:                        %s\n' % self.metadata['beemizer'][player])
-                    outfile.write('Pot shuffle                      %s\n'
-                                  % ('Yes' if self.metadata['shufflepots'][player] else 'No'))
+                                  bool_to_text("w" in self.world.shop_shuffle[player]))
+                    outfile.write('Boss shuffle:                    %s\n' % self.world.boss_shuffle[player])
+                    outfile.write('Enemy health:                    %s\n' % self.world.enemy_health[player])
+                    outfile.write('Enemy damage:                    %s\n' % self.world.enemy_damage[player])
                     outfile.write('Prize shuffle                    %s\n' %
-                                  self.metadata['shuffle_prizes'][player])
+                                  self.world.shuffle_prizes[player])
             if self.entrances:
                 outfile.write('\n\nEntrances:\n\n')
                 outfile.write('\n'.join(['%s%s %s %s' % (f'{self.world.get_player_name(entry["player"])}: '
@@ -1251,35 +1267,34 @@ class Spoiler():
                 outfile.write('\n\nMedallions:\n')
                 for dungeon, medallion in self.medallions.items():
                     outfile.write(f'\n{dungeon}: {medallion}')
-            factorio_players = self.world.get_game_players("Factorio")
-            if factorio_players:
-                outfile.write('\n\nRecipes:\n')
-                for player in factorio_players:
-                    name = self.world.get_player_name(player)
-                    for recipe in self.world.worlds[player].custom_recipes.values():
-                        outfile.write(f"\n{recipe.name} ({name}): {recipe.ingredients} -> {recipe.products}")
 
-            if self.startinventory:
-                outfile.write('\n\nStarting Inventory:\n\n')
-                outfile.write('\n'.join(self.startinventory))
+            call_all(self.world, "write_spoiler", outfile)
 
             outfile.write('\n\nLocations:\n\n')
-            outfile.write('\n'.join(['%s: %s' % (location, item) for grouping in self.locations.values() for (location, item) in grouping.items()]))
+            outfile.write('\n'.join(
+                ['%s: %s' % (location, item) for grouping in self.locations.values() for (location, item) in
+                 grouping.items()]))
 
             if self.shops:
                 outfile.write('\n\nShops:\n\n')
-                outfile.write('\n'.join("{} [{}]\n    {}".format(shop['location'], shop['type'], "\n    ".join(item for item in [shop.get('item_0', None), shop.get('item_1', None), shop.get('item_2', None)] if item)) for shop in self.shops))
+                outfile.write('\n'.join("{} [{}]\n    {}".format(shop['location'], shop['type'], "\n    ".join(
+                    item for item in [shop.get('item_0', None), shop.get('item_1', None), shop.get('item_2', None)] if
+                    item)) for shop in self.shops))
 
             for player in self.world.get_game_players("A Link to the Past"):
                 if self.world.boss_shuffle[player] != 'none':
                     bossmap = self.bosses[str(player)] if self.world.players > 1 else self.bosses
-                    outfile.write(f'\n\nBosses{(f" ({self.world.get_player_name(player)})" if self.world.players > 1 else "")}:\n')
-                    outfile.write('    '+'\n    '.join([f'{x}: {y}' for x, y in bossmap.items()]))
+                    outfile.write(
+                        f'\n\nBosses{(f" ({self.world.get_player_name(player)})" if self.world.players > 1 else "")}:\n')
+                    outfile.write('    ' + '\n    '.join([f'{x}: {y}' for x, y in bossmap.items()]))
             outfile.write('\n\nPlaythrough:\n\n')
-            outfile.write('\n'.join(['%s: {\n%s\n}' % (sphere_nr, '\n'.join(['  %s: %s' % (location, item) for (location, item) in sphere.items()] if sphere_nr != '0' else [f'  {item}' for item in sphere])) for (sphere_nr, sphere) in self.playthrough.items()]))
+            outfile.write('\n'.join(['%s: {\n%s\n}' % (sphere_nr, '\n'.join(
+                ['  %s: %s' % (location, item) for (location, item) in sphere.items()] if sphere_nr != '0' else [
+                    f'  {item}' for item in sphere])) for (sphere_nr, sphere) in self.playthrough.items()]))
             if self.unreachables:
                 outfile.write('\n\nUnreachable Items:\n\n')
-                outfile.write('\n'.join(['%s: %s' % (unreachable.item, unreachable) for unreachable in self.unreachables]))
+                outfile.write(
+                    '\n'.join(['%s: %s' % (unreachable.item, unreachable) for unreachable in self.unreachables]))
 
             if self.paths:
                 outfile.write('\n\nPaths:\n\n')
@@ -1294,3 +1309,14 @@ class Spoiler():
                     path_listings.append("{}\n        {}".format(location, "\n   =>   ".join(path_lines)))
 
                 outfile.write('\n'.join(path_listings))
+            call_all(self.world, "write_spoiler_end", outfile)
+
+
+seeddigits = 20
+
+
+def get_seed(seed=None):
+    if seed is None:
+        random.seed(None)
+        return random.randint(0, pow(10, seeddigits) - 1)
+    return seed

CommonClient.py

@@ -1,21 +1,28 @@
 from __future__ import annotations
 import logging
-import typing
 import asyncio
 import urllib.parse
 import sys
+import typing
+import time
 
 import websockets
 
 import Utils
+
+if __name__ == "__main__":
+    Utils.init_logging("TextClient", exception_logger="Client")
+
 from MultiServer import CommandProcessor
-from NetUtils import Endpoint, decode, NetworkItem, encode, JSONtoTextParser, color, ClientStatus
-from Utils import Version
+from NetUtils import Endpoint, decode, NetworkItem, encode, JSONtoTextParser, ClientStatus, Permission
+from Utils import Version, stream_input
 from worlds import network_data_package, AutoWorldRegister
 
 logger = logging.getLogger("Client")
 
-gui_enabled = Utils.is_frozen() or "--nogui" not in sys.argv
+# without terminal we have to use gui mode
+gui_enabled = not sys.stdout or "--nogui" not in sys.argv
+
 
 class ClientCommandProcessor(CommandProcessor):
     def __init__(self, ctx: CommonContext):
@@ -32,13 +39,13 @@ class ClientCommandProcessor(CommandProcessor):
     def _cmd_connect(self, address: str = "") -> bool:
         """Connect to a MultiWorld Server"""
         self.ctx.server_address = None
-        asyncio.create_task(self.ctx.connect(address if address else None))
+        asyncio.create_task(self.ctx.connect(address if address else None), name="connecting")
         return True
 
     def _cmd_disconnect(self) -> bool:
         """Disconnect from a MultiWorld Server"""
         self.ctx.server_address = None
-        asyncio.create_task(self.ctx.disconnect())
+        asyncio.create_task(self.ctx.disconnect(), name="disconnecting")
         return True
 
     def _cmd_received(self) -> bool:
@@ -50,6 +57,9 @@ class ClientCommandProcessor(CommandProcessor):
 
     def _cmd_missing(self) -> bool:
         """List all missing location checks, from your local game state"""
+        if not self.ctx.game:
+            self.output("No game set, cannot determine missing checks.")
+            return False
         count = 0
         checked_count = 0
         for location, location_id in AutoWorldRegister.world_types[self.ctx.game].location_name_to_id.items():
@@ -71,7 +81,20 @@ class ClientCommandProcessor(CommandProcessor):
             self.output("No missing location checks found.")
         return True
 
+    def _cmd_items(self):
+        """List all item names for the currently running game."""
+        self.output(f"Item Names for {self.ctx.game}")
+        for item_name in AutoWorldRegister.world_types[self.ctx.game].item_name_to_id:
+            self.output(item_name)
+
+    def _cmd_locations(self):
+        """List all location names for the currently running game."""
+        self.output(f"Location Names for {self.ctx.game}")
+        for location_name in AutoWorldRegister.world_types[self.ctx.game].location_name_to_id:
+            self.output(location_name)
+
     def _cmd_ready(self):
+        """Send ready status to server."""
         self.ctx.ready = not self.ctx.ready
         if self.ctx.ready:
             state = ClientStatus.CLIENT_READY
@@ -79,18 +102,22 @@ class ClientCommandProcessor(CommandProcessor):
         else:
             state = ClientStatus.CLIENT_CONNECTED
             self.output("Unreadied.")
-        asyncio.create_task(self.ctx.send_msgs([{"cmd": "StatusUpdate", "status": state}]))
+        asyncio.create_task(self.ctx.send_msgs([{"cmd": "StatusUpdate", "status": state}]), name="send StatusUpdate")
 
     def default(self, raw: str):
-        asyncio.create_task(self.ctx.send_msgs([{"cmd": "Say", "text": raw}]))
+        raw = self.ctx.on_user_say(raw)
+        if raw:
+            asyncio.create_task(self.ctx.send_msgs([{"cmd": "Say", "text": raw}]), name="send Say")
 
 
 class CommonContext():
-    starting_reconnect_delay = 5
-    current_reconnect_delay = starting_reconnect_delay
-    command_processor = ClientCommandProcessor
-    game: None
-    ui: None
+    tags: typing.Set[str] = {"AP"}
+    starting_reconnect_delay: int = 5
+    current_reconnect_delay: int = starting_reconnect_delay
+    command_processor: int = ClientCommandProcessor
+    game = None
+    ui = None
+    keep_alive_task = None
 
     def __init__(self, server_address, password):
         # server state
@@ -99,6 +126,13 @@ class CommonContext():
         self.server_task = None
         self.server: typing.Optional[Endpoint] = None
         self.server_version = Version(0, 0, 0)
+        self.hint_cost: typing.Optional[int] = None
+        self.games: typing.Dict[int, str] = {}
+        self.permissions = {
+            "forfeit": "disabled",
+            "collect": "disabled",
+            "remaining": "disabled",
+        }
 
         # own state
         self.finished_game = False
@@ -108,16 +142,18 @@ class CommonContext():
         self.auth = None
         self.seed_name = None
 
-        self.locations_checked: typing.Set[int] = set()
+        self.locations_checked: typing.Set[int] = set()  # local state
         self.locations_scouted: typing.Set[int] = set()
         self.items_received = []
-        self.missing_locations: typing.List[int] = []
-        self.checked_locations: typing.List[int] = []
+        self.missing_locations: typing.Set[int] = set()
+        self.checked_locations: typing.Set[int] = set()  # server state
         self.locations_info = {}
 
         self.input_queue = asyncio.Queue()
         self.input_requests = 0
 
+        self.last_death_link: float = time.time()  # last send/received death link on AP layer
+
         # game state
         self.player_names: typing.Dict[int: str] = {0: "Archipelago"}
         self.exit_event = asyncio.Event()
@@ -127,6 +163,15 @@ class CommonContext():
         self.jsontotextparser = JSONtoTextParser(self)
         self.set_getters(network_data_package)
 
+        # execution
+        self.keep_alive_task = asyncio.create_task(keep_alive(self), name="Bouncy")
+
+    @property
+    def total_locations(self) -> typing.Optional[int]:
+        """Will return None until connected."""
+        if self.checked_locations or self.missing_locations:
+            return len(self.checked_locations | self.missing_locations)
+
     async def connection_closed(self):
         self.auth = None
         self.items_received = []
@@ -137,6 +182,7 @@ class CommonContext():
         self.server = None
         self.server_task = None
 
+    # noinspection PyAttributeOutsideInit
     def set_getters(self, data_package: dict, network=False):
         if not network:  # local data; check if newer data was already downloaded
             local_package = Utils.persistent_load().get("datapackage", {}).get("latest", {})
@@ -190,19 +236,33 @@ class CommonContext():
     def event_invalid_slot(self):
         raise Exception('Invalid Slot; please verify that you have connected to the correct world.')
 
-    async def server_auth(self, password_requested):
+    def event_invalid_game(self):
+        raise Exception('Invalid Game; please verify that you connected with the right game to the correct world.')
+
+    async def server_auth(self, password_requested: bool = False):
         if password_requested and not self.password:
             logger.info('Enter the password required to join this game:')
             self.password = await self.console_input()
             return self.password
 
+    async def send_connect(self, **kwargs):
+        payload = {
+            "cmd": 'Connect',
+            'password': self.password, 'name': self.auth, 'version': Utils.version_tuple,
+            'tags': self.tags,
+            'uuid': Utils.get_unique_identifier(), 'game': self.game
+        }
+        if kwargs:
+            payload.update(kwargs)
+        await self.send_msgs([payload])
+
     async def console_input(self):
         self.input_requests += 1
         return await self.input_queue.get()
 
     async def connect(self, address=None):
         await self.disconnect()
-        self.server_task = asyncio.create_task(server_loop(self, address))
+        self.server_task = asyncio.create_task(server_loop(self, address), name="server loop")
 
     def on_print(self, args: dict):
         logger.info(args["text"])
@@ -218,6 +278,77 @@ class CommonContext():
         """For custom package handling in subclasses."""
         pass
 
+    def on_user_say(self, text: str) -> typing.Optional[str]:
+        """Gets called before sending a Say to the server from the user.
+        Returned text is sent, or sending is aborted if None is returned."""
+        return text
+
+    def update_permissions(self, permissions: typing.Dict[str, int]):
+        for permission_name, permission_flag in permissions.items():
+            try:
+                flag = Permission(permission_flag)
+                logger.info(f"{permission_name.capitalize()} permission: {flag.name}")
+                self.permissions[permission_name] = flag.name
+            except Exception as e:  # safeguard against permissions that may be implemented in the future
+                logger.exception(e)
+
+    async def shutdown(self):
+        self.server_address = None
+        if self.server and not self.server.socket.closed:
+            await self.server.socket.close()
+        if self.server_task:
+            await self.server_task
+
+        while self.input_requests > 0:
+            self.input_queue.put_nowait(None)
+            self.input_requests -= 1
+        self.keep_alive_task.cancel()
+
+    # DeathLink hooks
+
+    def on_deathlink(self, data: dict):
+        """Gets dispatched when a new DeathLink is triggered by another linked player."""
+        self.last_death_link = max(data["time"], self.last_death_link)
+        text = data.get("cause", "")
+        if text:
+            logger.info(f"DeathLink: {text}")
+        else:
+            logger.info(f"DeathLink: Received from {data['source']}")
+
+    async def send_death(self, death_text: str = ""):
+        logger.info("DeathLink: Sending death to your friends...")
+        self.last_death_link = time.time()
+        await self.send_msgs([{
+            "cmd": "Bounce", "tags": ["DeathLink"],
+            "data": {
+                "time": self.last_death_link,
+                "source": self.player_names[self.slot],
+                "cause": death_text
+            }
+        }])
+
+    async def update_death_link(self, death_link):
+        old_tags = self.tags.copy()
+        if death_link:
+            self.tags.add("DeathLink")
+        else:
+            self.tags -= {"DeathLink"}
+        if old_tags != self.tags and self.server and not self.server.socket.closed:
+            await self.send_msgs([{"cmd": "ConnectUpdate", "tags": self.tags}])
+
+
+async def keep_alive(ctx: CommonContext, seconds_between_checks=100):
+    """some ISPs/network configurations drop TCP connections if no payload is sent (ignore TCP-keep-alive)
+     so we send a payload to prevent drop and if we were dropped anyway this will cause an auto-reconnect."""
+    seconds_elapsed = 0
+    while not ctx.exit_event.is_set():
+        await asyncio.sleep(1)  # short sleep to not block program shutdown
+        if ctx.server and ctx.slot:
+            seconds_elapsed += 1
+            if seconds_elapsed > seconds_between_checks:
+                await ctx.send_msgs([{"cmd": "Bounce", "slots": [ctx.slot]}])
+                seconds_elapsed = 0
+
 
 async def server_loop(ctx: CommonContext, address=None):
     cached_address = None
@@ -252,25 +383,25 @@ async def server_loop(ctx: CommonContext, address=None):
             logger.error('Unable to connect to multiworld server at cached address. '
                          'Please use the connect button above.')
         else:
-            logger.error('Connection refused by the multiworld server')
+            logger.exception('Connection refused by the multiworld server')
+    except websockets.InvalidURI:
+        logger.exception('Failed to connect to the multiworld server (invalid URI)')
     except (OSError, websockets.InvalidURI):
-        logger.error('Failed to connect to the multiworld server')
+        logger.exception('Failed to connect to the multiworld server')
     except Exception as e:
-        logger.error('Lost connection to the multiworld server, type /connect to reconnect')
-        if not isinstance(e, websockets.WebSocketException):
-            logger.exception(e)
+        logger.exception('Lost connection to the multiworld server, type /connect to reconnect')
     finally:
         await ctx.connection_closed()
         if ctx.server_address:
             logger.info(f"... reconnecting in {ctx.current_reconnect_delay}s")
-            asyncio.create_task(server_autoreconnect(ctx))
+            asyncio.create_task(server_autoreconnect(ctx), name="server auto reconnect")
         ctx.current_reconnect_delay *= 2
 
 
 async def server_autoreconnect(ctx: CommonContext):
     await asyncio.sleep(ctx.current_reconnect_delay)
     if ctx.server_address and ctx.server_task is None:
-        ctx.server_task = asyncio.create_task(server_loop(ctx))
+        ctx.server_task = asyncio.create_task(server_loop(ctx), name="server loop")
 
 
 async def process_server_cmd(ctx: CommonContext, args: dict):
@@ -294,16 +425,16 @@ async def process_server_cmd(ctx: CommonContext, args: dict):
             logger.info("Server protocol tags: " + ", ".join(args["tags"]))
             if args['password']:
                 logger.info('Password required')
-            logger.info(f"Forfeit setting: {args['forfeit_mode']}")
-            logger.info(f"Remaining setting: {args['remaining_mode']}")
+            ctx.update_permissions(args.get("permissions", {}))
+            if "games" in args:
+                ctx.games = {x: game for x, game in enumerate(args["games"], start=1)}
             logger.info(
                 f"A !hint costs {args['hint_cost']}% of your total location count as points"
                 f" and you get {args['location_check_points']}"
                 f" for each location checked. Use !hint for more information.")
             ctx.hint_cost = int(args['hint_cost'])
             ctx.check_points = int(args['location_check_points'])
-            ctx.forfeit_mode = args['forfeit_mode']
-            ctx.remaining_mode = args['remaining_mode']
+
             if len(args['players']) < 1:
                 logger.info('No player connected')
             else:
@@ -327,7 +458,8 @@ async def process_server_cmd(ctx: CommonContext, args: dict):
         errors = args["errors"]
         if 'InvalidSlot' in errors:
             ctx.event_invalid_slot()
-
+        elif 'InvalidGame' in errors:
+            ctx.event_invalid_game()
         elif 'SlotAlreadyTaken' in errors:
             raise Exception('Player slot already in use for that team')
         elif 'IncompatibleVersion' in errors:
@@ -362,8 +494,8 @@ async def process_server_cmd(ctx: CommonContext, args: dict):
         # This list is used to only send to the server what is reported as ACTUALLY Missing.
         # This also serves to allow an easy visual of what locations were already checked previously
         # when /missing is used for the client side view of what is missing.
-        ctx.missing_locations = args["missing_locations"]
-        ctx.checked_locations = args["checked_locations"]
+        ctx.missing_locations = set(args["missing_locations"])
+        ctx.checked_locations = set(args["checked_locations"])
 
     elif cmd == 'ReceivedItems':
         start_index = args["index"]
@@ -392,6 +524,12 @@ async def process_server_cmd(ctx: CommonContext, args: dict):
             ctx.consume_players_package(args["players"])
         if "hint_points" in args:
             ctx.hint_points = args['hint_points']
+        if "checked_locations" in args:
+            checked = set(args["checked_locations"])
+            ctx.checked_locations |= checked
+            ctx.missing_locations -= checked
+        if "permissions" in args:
+            ctx.update_permissions(args["permissions"])
 
     elif cmd == 'Print':
         ctx.on_print(args)
@@ -403,7 +541,10 @@ async def process_server_cmd(ctx: CommonContext, args: dict):
         logger.warning(f"Invalid Packet of {args['type']}: {args['text']}")
 
     elif cmd == "Bounced":
-        pass
+        tags = args.get("tags", [])
+        # we can skip checking "DeathLink" in ctx.tags, as otherwise we wouldn't have been send this
+        if "DeathLink" in tags and ctx.last_death_link != args["data"]["time"]:
+            ctx.on_deathlink(args["data"])
 
     else:
         logger.debug(f"unknown command {cmd}")
@@ -414,12 +555,12 @@ async def process_server_cmd(ctx: CommonContext, args: dict):
 async def console_loop(ctx: CommonContext):
     import sys
     commandprocessor = ctx.command_processor(ctx)
+    queue = asyncio.Queue()
+    stream_input(sys.stdin, queue)
     while not ctx.exit_event.is_set():
         try:
-            input_text = await asyncio.get_event_loop().run_in_executor(
-                None, sys.stdin.readline
-            )
-            input_text = input_text.strip()
+            input_text = await queue.get()
+            queue.task_done()
 
             if ctx.input_requests > 0:
                 ctx.input_requests -= 1
@@ -430,3 +571,68 @@ async def console_loop(ctx: CommonContext):
                 commandprocessor(input_text)
         except Exception as e:
             logger.exception(e)
+
+
+def get_base_parser(description=None):
+    import argparse
+    parser = argparse.ArgumentParser(description=description)
+    parser.add_argument('--connect', default=None, help='Address of the multiworld host.')
+    parser.add_argument('--password', default=None, help='Password of the multiworld host.')
+    if sys.stdout:  # If terminal output exists, offer gui-less mode
+        parser.add_argument('--nogui', default=False, action='store_true', help="Turns off Client GUI.")
+    return parser
+
+
+if __name__ == '__main__':
+    # Text Mode to use !hint and such with games that have no text entry
+
+    class TextContext(CommonContext):
+        tags = {"AP", "IgnoreGame"}
+        game = "Archipelago"
+
+        async def server_auth(self, password_requested: bool = False):
+            if password_requested and not self.password:
+                await super(TextContext, self).server_auth(password_requested)
+            if not self.auth:
+                logger.info('Enter slot name:')
+                self.auth = await self.console_input()
+
+            await self.send_connect()
+
+        def on_package(self, cmd: str, args: dict):
+            if cmd == "Connected":
+                self.game = self.games.get(self.slot, None)
+
+
+    async def main(args):
+        ctx = TextContext(args.connect, args.password)
+        ctx.server_task = asyncio.create_task(server_loop(ctx), name="server loop")
+        input_task = None
+        if gui_enabled:
+            from kvui import TextManager
+            ctx.ui = TextManager(ctx)
+            ui_task = asyncio.create_task(ctx.ui.async_run(), name="UI")
+        else:
+            ui_task = None
+        if sys.stdin:
+            input_task = asyncio.create_task(console_loop(ctx), name="Input")
+        await ctx.exit_event.wait()
+
+        await ctx.shutdown()
+        if ui_task:
+            await ui_task
+
+        if input_task:
+            input_task.cancel()
+
+    import colorama
+
+    parser = get_base_parser(description="Gameless Archipelago Client, for text interfacing.")
+
+    args, rest = parser.parse_known_args()
+    colorama.init()
+
+    loop = asyncio.get_event_loop()
+    loop.run_until_complete(main(args))
+    loop.close()
+    colorama.deinit()

FF1Client.py

@@ -0,0 +1,255 @@
+import asyncio
+import json
+import time
+from asyncio import StreamReader, StreamWriter
+from typing import List
+
+
+import Utils
+from CommonClient import CommonContext, server_loop, gui_enabled, console_loop, ClientCommandProcessor, logger, \
+    get_base_parser
+
+SYSTEM_MESSAGE_ID = 0
+
+CONNECTION_TIMING_OUT_STATUS = "Connection timing out. Please restart your emulator, then restart ff1_connector.lua"
+CONNECTION_REFUSED_STATUS = "Connection Refused. Please start your emulator and make sure ff1_connector.lua is running"
+CONNECTION_RESET_STATUS = "Connection was reset. Please restart your emulator, then restart ff1_connector.lua"
+CONNECTION_TENTATIVE_STATUS = "Initial Connection Made"
+CONNECTION_CONNECTED_STATUS = "Connected"
+CONNECTION_INITIAL_STATUS = "Connection has not been initiated"
+
+
+class FF1CommandProcessor(ClientCommandProcessor):
+    def __init__(self, ctx: CommonContext):
+        super().__init__(ctx)
+
+    def _cmd_nes(self):
+        """Check NES Connection State"""
+        if isinstance(self.ctx, FF1Context):
+            logger.info(f"NES Status: {self.ctx.nes_status}")
+
+
+class FF1Context(CommonContext):
+    def __init__(self, server_address, password):
+        super().__init__(server_address, password)
+        self.nes_streams: (StreamReader, StreamWriter) = None
+        self.nes_sync_task = None
+        self.messages = {}
+        self.locations_array = None
+        self.nes_status = CONNECTION_INITIAL_STATUS
+        self.game = 'Final Fantasy'
+        self.awaiting_rom = False
+
+    command_processor = FF1CommandProcessor
+
+    async def server_auth(self, password_requested: bool = False):
+        if password_requested and not self.password:
+            await super(FF1Context, self).server_auth(password_requested)
+        if not self.auth:
+            self.awaiting_rom = True
+            logger.info('Awaiting connection to NES to get Player information')
+            return
+
+        await self.send_connect()
+
+    def _set_message(self, msg: str, msg_id: int):
+        self.messages[(time.time(), msg_id)] = msg
+
+    def on_package(self, cmd: str, args: dict):
+        if cmd == 'Connected':
+            self.game = self.games.get(self.slot, None)
+            asyncio.create_task(parse_locations(self.locations_array, self, True))
+        elif cmd == 'Print':
+            msg = args['text']
+            if ': !' not in msg:
+                self._set_message(msg, SYSTEM_MESSAGE_ID)
+        elif cmd == "ReceivedItems":
+            msg = f"Received {', '.join([self.item_name_getter(item.item) for item in args['items']])}"
+            self._set_message(msg, SYSTEM_MESSAGE_ID)
+        elif cmd == 'PrintJSON':
+            print_type = args['type']
+            item = args['item']
+            receiving_player_id = args['receiving']
+            receiving_player_name = self.player_names[receiving_player_id]
+            sending_player_id = item.player
+            sending_player_name = self.player_names[item.player]
+            if print_type == 'Hint':
+                msg = f"Hint: Your {self.item_name_getter(item.item)} is at" \
+                      f" {self.player_names[item.player]}'s {self.location_name_getter(item.location)}"
+                self._set_message(msg, item.item)
+            elif print_type == 'ItemSend' and receiving_player_id != self.slot:
+                if sending_player_id == self.slot:
+                    if receiving_player_id == self.slot:
+                        msg = f"You found your own {self.item_name_getter(item.item)}"
+                    else:
+                        msg = f"You sent {self.item_name_getter(item.item)} to {receiving_player_name}"
+                else:
+                    if receiving_player_id == sending_player_id:
+                        msg = f"{sending_player_name} found their {self.item_name_getter(item.item)}"
+                    else:
+                        msg = f"{sending_player_name} sent {self.item_name_getter(item.item)} to " \
+                              f"{receiving_player_name}"
+                self._set_message(msg, item.item)
+
+
+def get_payload(ctx: FF1Context):
+    current_time = time.time()
+    return json.dumps(
+        {
+            "items": [item.item for item in ctx.items_received],
+            "messages": {f'{key[0]}:{key[1]}': value for key, value in ctx.messages.items()
+                         if key[0] > current_time - 10}
+        }
+    )
+
+
+async def parse_locations(locations_array: List[int], ctx: FF1Context, force: bool):
+    if locations_array == ctx.locations_array and not force:
+        return
+    else:
+        # print("New values")
+        ctx.locations_array = locations_array
+        locations_checked = []
+        if len(locations_array) > 0xFE and locations_array[0xFE] & 0x02 != 0 and not ctx.finished_game:
+            await ctx.send_msgs([
+                {"cmd": "StatusUpdate",
+                 "status": 30}
+            ])
+            ctx.finished_game = True
+        for location in ctx.missing_locations:
+            # index will be - 0x100 or 0x200
+            index = location
+            if location < 0x200:
+                # Location is a chest
+                index -= 0x100
+                flag = 0x04
+            else:
+                # Location is an NPC
+                index -= 0x200
+                flag = 0x02
+
+            # print(f"Location: {ctx.location_name_getter(location)}")
+            # print(f"Index: {str(hex(index))}")
+            # print(f"value: {locations_array[index] & flag != 0}")
+            if locations_array[index] & flag != 0:
+                locations_checked.append(location)
+        if locations_checked:
+            # print([ctx.location_name_getter(location) for location in locations_checked])
+            await ctx.send_msgs([
+                {"cmd": "LocationChecks",
+                 "locations": locations_checked}
+            ])
+
+
+async def nes_sync_task(ctx: FF1Context):
+    logger.info("Starting nes connector. Use /nes for status information")
+    while not ctx.exit_event.is_set():
+        error_status = None
+        if ctx.nes_streams:
+            (reader, writer) = ctx.nes_streams
+            msg = get_payload(ctx).encode()
+            writer.write(msg)
+            writer.write(b'\n')
+            try:
+                await asyncio.wait_for(writer.drain(), timeout=1.5)
+                try:
+                    # Data will return a dict with up to two fields:
+                    # 1. A keepalive response of the Players Name (always)
+                    # 2. An array representing the memory values of the locations area (if in game)
+                    data = await asyncio.wait_for(reader.readline(), timeout=5)
+                    data_decoded = json.loads(data.decode())
+                    # print(data_decoded)
+                    if ctx.game is not None and 'locations' in data_decoded:
+                        # Not just a keep alive ping, parse
+                        asyncio.create_task(parse_locations(data_decoded['locations'], ctx, False))
+                    if not ctx.auth:
+                        ctx.auth = ''.join([chr(i) for i in data_decoded['playerName'] if i != 0])
+                        if ctx.awaiting_rom:
+                            await ctx.server_auth(False)
+                except asyncio.TimeoutError:
+                    logger.debug("Read Timed Out, Reconnecting")
+                    error_status = CONNECTION_TIMING_OUT_STATUS
+                    writer.close()
+                    ctx.nes_streams = None
+                except ConnectionResetError as e:
+                    logger.debug("Read failed due to Connection Lost, Reconnecting")
+                    error_status = CONNECTION_RESET_STATUS
+                    writer.close()
+                    ctx.nes_streams = None
+            except TimeoutError:
+                logger.debug("Connection Timed Out, Reconnecting")
+                error_status = CONNECTION_TIMING_OUT_STATUS
+                writer.close()
+                ctx.nes_streams = None
+            except ConnectionResetError:
+                logger.debug("Connection Lost, Reconnecting")
+                error_status = CONNECTION_RESET_STATUS
+                writer.close()
+                ctx.nes_streams = None
+            if ctx.nes_status == CONNECTION_TENTATIVE_STATUS:
+                if not error_status:
+                    logger.info("Successfully Connected to NES")
+                    ctx.nes_status = CONNECTION_CONNECTED_STATUS
+                else:
+                    ctx.nes_status = f"Was tentatively connected but error occured: {error_status}"
+            elif error_status:
+                ctx.nes_status = error_status
+                logger.info("Lost connection to nes and attempting to reconnect. Use /nes for status updates")
+        else:
+            try:
+                logger.debug("Attempting to connect to NES")
+                ctx.nes_streams = await asyncio.wait_for(asyncio.open_connection("localhost", 52980), timeout=10)
+                ctx.nes_status = CONNECTION_TENTATIVE_STATUS
+            except TimeoutError:
+                logger.debug("Connection Timed Out, Trying Again")
+                ctx.nes_status = CONNECTION_TIMING_OUT_STATUS
+                continue
+            except ConnectionRefusedError:
+                logger.debug("Connection Refused, Trying Again")
+                ctx.nes_status = CONNECTION_REFUSED_STATUS
+                continue
+
+
+if __name__ == '__main__':
+    # Text Mode to use !hint and such with games that have no text entry
+    Utils.init_logging("FF1Client")
+
+    async def main(args):
+        ctx = FF1Context(args.connect, args.password)
+        ctx.server_task = asyncio.create_task(server_loop(ctx), name="ServerLoop")
+        if gui_enabled:
+            input_task = None
+            from kvui import FF1Manager
+            ctx.ui = FF1Manager(ctx)
+            ui_task = asyncio.create_task(ctx.ui.async_run(), name="UI")
+        else:
+            input_task = asyncio.create_task(console_loop(ctx), name="Input")
+            ui_task = None
+
+        ctx.nes_sync_task = asyncio.create_task(nes_sync_task(ctx), name="NES Sync")
+
+        await ctx.exit_event.wait()
+        ctx.server_address = None
+
+        await ctx.shutdown()
+
+        if ctx.nes_sync_task:
+            await ctx.nes_sync_task
+
+        if ui_task:
+            await ui_task
+
+        if input_task:
+            input_task.cancel()
+
+
+    import colorama
+
+    parser = get_base_parser()
+    args, rest = parser.parse_known_args()
+    colorama.init()
+
+    loop = asyncio.get_event_loop()
+    loop.run_until_complete(main(args))
+    loop.close()
+    colorama.deinit()

FactorioClient.py

@@ -5,32 +5,26 @@ import json
 import string
 import copy
 import subprocess
-import factorio_rcon
+import sys
+import time
+import random
 
+import factorio_rcon
 import colorama
 import asyncio
 from queue import Queue
-from CommonClient import CommonContext, server_loop, console_loop, ClientCommandProcessor, logger, gui_enabled
-from MultiServer import mark_raw
-
 import Utils
-import random
+
+if __name__ == "__main__":
+    Utils.init_logging("FactorioClient", exception_logger="Client")
+
+from CommonClient import CommonContext, server_loop, console_loop, ClientCommandProcessor, logger, gui_enabled, \
+     get_base_parser
+from MultiServer import mark_raw
 from NetUtils import NetworkItem, ClientStatus, JSONtoTextParser, JSONMessagePart
 
 from worlds.factorio import Factorio
 
-log_folder = Utils.local_path("logs")
-
-os.makedirs(log_folder, exist_ok=True)
-
-
-if gui_enabled:
-    logging.basicConfig(format='[%(name)s]: %(message)s', level=logging.INFO,
-                        filename=os.path.join(log_folder, "FactorioClient.txt"), filemode="w", force=True)
-else:
-    logging.basicConfig(format='[%(name)s]: %(message)s', level=logging.INFO, force=True)
-    logging.getLogger().addHandler(logging.FileHandler(os.path.join(log_folder, "FactorioClient.txt"), "w"))
-
 
 class FactorioCommandProcessor(ClientCommandProcessor):
     ctx: FactorioContext
@@ -61,30 +55,27 @@ class FactorioContext(CommonContext):
 
     def __init__(self, server_address, password):
         super(FactorioContext, self).__init__(server_address, password)
-        self.send_index = 0
+        self.send_index: int = 0
         self.rcon_client = None
         self.awaiting_bridge = False
+        self.write_data_path = None
+        self.death_link_tick: int = 0  # last send death link on Factorio layer
         self.factorio_json_text_parser = FactorioJSONtoTextParser(self)
 
-    async def server_auth(self, password_requested):
+    async def server_auth(self, password_requested: bool = False):
         if password_requested and not self.password:
             await super(FactorioContext, self).server_auth(password_requested)
 
-        if not self.auth:
-            if self.rcon_client:
-                get_info(self, self.rcon_client)  # retrieve current auth code
-            else:
-                raise Exception("Cannot connect to a server with unknown own identity, "
-                                "bridge to Factorio first.")
+        if self.rcon_client:
+            await get_info(self, self.rcon_client)  # retrieve current auth code
+        else:
+            raise Exception("Cannot connect to a server with unknown own identity, "
+                            "bridge to Factorio first.")
 
-        await self.send_msgs([{"cmd": 'Connect',
-                               'password': self.password, 'name': self.auth, 'version': Utils.version_tuple,
-                               'tags': ['AP'],
-                               'uuid': Utils.get_unique_identifier(), 'game': "Factorio"
-                               }])
+        await self.send_connect()
 
     def on_print(self, args: dict):
-        logger.info(args["text"])
+        super(FactorioContext, self).on_print(args)
         if self.rcon_client:
             self.print_to_game(args['text'])
 
@@ -96,22 +87,21 @@ class FactorioContext(CommonContext):
 
     @property
     def savegame_name(self) -> str:
-        return f"AP_{self.seed_name}_{self.auth}.zip"
+        return f"AP_{self.seed_name}_{self.auth}_Save.zip"
 
     def print_to_game(self, text):
-        # TODO: remove around version 0.2
-        if self.mod_version < Utils.Version(0, 1, 6):
-            text = text.replace('"', '')
-            self.rcon_client.send_command(f"/sc game.print(\"[font=default-large-bold]Archipelago:[/font] "
-                                          f"{text}\")")
-        else:
-            self.rcon_client.send_command(f"/ap-print [font=default-large-bold]Archipelago:[/font] "
-                                          f"{text}")
+        self.rcon_client.send_command(f"/ap-print [font=default-large-bold]Archipelago:[/font] "
+                                      f"{text}")
+
+    def on_deathlink(self, data: dict):
+        if self.rcon_client:
+            self.rcon_client.send_command(f"/ap-deathlink {data['source']}")
+        super(FactorioContext, self).on_deathlink(data)
 
     def on_package(self, cmd: str, args: dict):
-        if cmd == "Connected":
+        if cmd in {"Connected", "RoomUpdate"}:
             # catch up sync anything that is already cleared.
-            if args["checked_locations"]:
+            if "checked_locations" in args and args["checked_locations"]:
                 self.rcon_client.send_commands({item_name: f'/ap-get-technology ap-{item_name}-\t-1' for
                                                 item_name in args["checked_locations"]})
 
@@ -119,9 +109,11 @@ class FactorioContext(CommonContext):
 async def game_watcher(ctx: FactorioContext):
     bridge_logger = logging.getLogger("FactorioWatcher")
     from worlds.factorio.Technologies import lookup_id_to_name
+    next_bridge = time.perf_counter() + 1
     try:
         while not ctx.exit_event.is_set():
-            if ctx.awaiting_bridge and ctx.rcon_client:
+            if ctx.awaiting_bridge and ctx.rcon_client and time.perf_counter() > next_bridge:
+                next_bridge = time.perf_counter() + 1
                 ctx.awaiting_bridge = False
                 data = json.loads(ctx.rcon_client.send_command("/ap-sync"))
                 if data["slot_name"] != ctx.auth:
@@ -134,18 +126,26 @@ async def game_watcher(ctx: FactorioContext):
                     research_data = data["research_done"]
                     research_data = {int(tech_name.split("-")[1]) for tech_name in research_data}
                     victory = data["victory"]
+                    if "death_link" in data:    # TODO: Remove this if statement around version 0.2.4 or so
+                        await ctx.update_death_link(data["death_link"])
 
                     if not ctx.finished_game and victory:
                         await ctx.send_msgs([{"cmd": "StatusUpdate", "status": ClientStatus.CLIENT_GOAL}])
                         ctx.finished_game = True
 
                     if ctx.locations_checked != research_data:
-                        bridge_logger.info(
+                        bridge_logger.debug(
                             f"New researches done: "
                             f"{[lookup_id_to_name[rid] for rid in research_data - ctx.locations_checked]}")
                         ctx.locations_checked = research_data
                         await ctx.send_msgs([{"cmd": 'LocationChecks', "locations": tuple(research_data)}])
-            await asyncio.sleep(1)
+                    death_link_tick = data.get("death_link_tick", 0)
+                    if death_link_tick != ctx.death_link_tick:
+                        ctx.death_link_tick = death_link_tick
+                        if "DeathLink" in ctx.tags:
+                            await ctx.send_death()
+
+            await asyncio.sleep(0.1)
 
     except Exception as e:
         logging.exception(e)
@@ -191,20 +191,19 @@ async def factorio_server_watcher(ctx: FactorioContext):
 
             while not factorio_queue.empty():
                 msg = factorio_queue.get()
-                factorio_server_logger.info(msg)
+                factorio_queue.task_done()
+
                 if not ctx.rcon_client and "Starting RCON interface at IP ADDR:" in msg:
                     ctx.rcon_client = factorio_rcon.RCONClient("localhost", rcon_port, rcon_password)
-                    # TODO: remove around version 0.2
-                    if ctx.mod_version < Utils.Version(0, 1, 6):
-                        ctx.rcon_client.send_command("/sc game.print('Starting Archipelago Bridge')")
-                        ctx.rcon_client.send_command("/sc game.print('Starting Archipelago Bridge')")
                     if not ctx.server:
                         logger.info("Established bridge to Factorio Server. "
                                     "Ready to connect to Archipelago via /connect")
 
                 if not ctx.awaiting_bridge and "Archipelago Bridge Data available for game tick " in msg:
                     ctx.awaiting_bridge = True
-
+                    factorio_server_logger.debug(msg)
+                else:
+                    factorio_server_logger.info(msg)
             if ctx.rcon_client:
                 commands = {}
                 while ctx.send_index < len(ctx.items_received):
@@ -233,13 +232,16 @@ async def factorio_server_watcher(ctx: FactorioContext):
         factorio_process.wait(5)
 
 
-def get_info(ctx, rcon_client):
+async def get_info(ctx, rcon_client):
     info = json.loads(rcon_client.send_command("/ap-rcon-info"))
     ctx.auth = info["slot_name"]
     ctx.seed_name = info["seed_name"]
+    # 0.2.0 addition, not present earlier
+    death_link = bool(info.get("death_link", False))
+    await ctx.update_death_link(death_link)
 
 
-async def factorio_spinup_server(ctx: FactorioContext):
+async def factorio_spinup_server(ctx: FactorioContext) -> bool:
     savegame_name = os.path.abspath("Archipelago.zip")
     if not os.path.exists(savegame_name):
         logger.info(f"Creating savegame {savegame_name}")
@@ -265,58 +267,60 @@ async def factorio_spinup_server(ctx: FactorioContext):
                 if "Loading mod AP-" in msg and msg.endswith("(data.lua)"):
                     parts = msg.split()
                     ctx.mod_version = Utils.Version(*(int(number) for number in parts[-2].split(".")))
+                elif "Write data path: " in msg:
+                    ctx.write_data_path = Utils.get_text_between(msg, "Write data path: ", " [")
+                    if "AppData" in ctx.write_data_path:
+                        logger.warning("It appears your mods are loaded from Appdata, "
+                                       "this can lead to problems with multiple Factorio instances. "
+                                       "If this is the case, you will get a file locked error running Factorio.")
                 if not rcon_client and "Starting RCON interface at IP ADDR:" in msg:
                     rcon_client = factorio_rcon.RCONClient("localhost", rcon_port, rcon_password)
-                    get_info(ctx, rcon_client)
+                    if ctx.mod_version == ctx.__class__.mod_version:
+                        raise Exception("No Archipelago mod was loaded. Aborting.")
+                    await get_info(ctx, rcon_client)
             await asyncio.sleep(0.01)
 
-        if ctx.mod_version == ctx.__class__.mod_version:
-            raise Exception("No Archipelago mod was loaded. Aborting.")
-
     except Exception as e:
-        logging.exception(e)
-        logging.error("Aborted Factorio Server Bridge")
+        logger.exception(e)
+        logger.error("Aborted Factorio Server Bridge")
         ctx.exit_event.set()
 
     else:
-        logger.info(f"Got World Information from AP Mod {tuple(ctx.mod_version)} for seed {ctx.seed_name} in slot {ctx.auth}")
-
+        logger.info(
+            f"Got World Information from AP Mod {tuple(ctx.mod_version)} for seed {ctx.seed_name} in slot {ctx.auth}")
+        return True
     finally:
         factorio_process.terminate()
         factorio_process.wait(5)
+    return False
 
 
 async def main(args):
     ctx = FactorioContext(args.connect, args.password)
     ctx.server_task = asyncio.create_task(server_loop(ctx), name="ServerLoop")
+    input_task = None
     if gui_enabled:
-        input_task = None
         from kvui import FactorioManager
         ctx.ui = FactorioManager(ctx)
         ui_task = asyncio.create_task(ctx.ui.async_run(), name="UI")
     else:
-        input_task = asyncio.create_task(console_loop(ctx), name="Input")
         ui_task = None
+    if sys.stdin:
+        input_task = asyncio.create_task(console_loop(ctx), name="Input")
     factorio_server_task = asyncio.create_task(factorio_spinup_server(ctx), name="FactorioSpinupServer")
-    await factorio_server_task
-    factorio_server_task = asyncio.create_task(factorio_server_watcher(ctx), name="FactorioServer")
-    progression_watcher = asyncio.create_task(
-        game_watcher(ctx), name="FactorioProgressionWatcher")
+    succesful_launch = await factorio_server_task
+    if succesful_launch:
+        factorio_server_task = asyncio.create_task(factorio_server_watcher(ctx), name="FactorioServer")
+        progression_watcher = asyncio.create_task(
+            game_watcher(ctx), name="FactorioProgressionWatcher")
 
-    await ctx.exit_event.wait()
-    ctx.server_address = None
+        await ctx.exit_event.wait()
+        ctx.server_address = None
 
-    await progression_watcher
-    await factorio_server_task
+        await progression_watcher
+        await factorio_server_task
 
-    if ctx.server and not ctx.server.socket.closed:
-        await ctx.server.socket.close()
-    if ctx.server_task:
-        await ctx.server_task
-
-    while ctx.input_requests > 0:
-        ctx.input_queue.put_nowait(None)
-        ctx.input_requests -= 1
+    await ctx.shutdown()
 
     if ui_task:
         await ui_task
@@ -340,22 +344,17 @@ class FactorioJSONtoTextParser(JSONtoTextParser):
 
 
 if __name__ == '__main__':
-    import argparse
-
-    parser = argparse.ArgumentParser(description="Optional arguments to FactorioClient follow. "
-                                                 "Remaining arguments get passed into bound Factorio instance."
-                                                 "Refer to Factorio --help for those.")
+    parser = get_base_parser(description="Optional arguments to FactorioClient follow. "
+                                         "Remaining arguments get passed into bound Factorio instance."
+                                         "Refer to Factorio --help for those.")
     parser.add_argument('--rcon-port', default='24242', type=int, help='Port to use to communicate with Factorio')
     parser.add_argument('--rcon-password', help='Password to authenticate with RCON.')
-    parser.add_argument('--connect', default=None, help='Address of the multiworld host.')
-    parser.add_argument('--password', default=None, help='Password of the multiworld host.')
-    if not Utils.is_frozen():  # Frozen state has no cmd window in the first place
-        parser.add_argument('--nogui', default=False, action='store_true', help="Turns off Client GUI.")
 
     args, rest = parser.parse_known_args()
     colorama.init()
     rcon_port = args.rcon_port
-    rcon_password = args.rcon_password if args.rcon_password else ''.join(random.choice(string.ascii_letters) for x in range(32))
+    rcon_password = args.rcon_password if args.rcon_password else ''.join(
+        random.choice(string.ascii_letters) for x in range(32))
 
     factorio_server_logger = logging.getLogger("FactorioServer")
     options = Utils.get_options()

Fill.py

@@ -36,7 +36,7 @@ def fill_restrictive(world: MultiWorld, base_state: CollectionState, locations,
         has_beaten_game = world.has_beaten_game(maximum_exploration_state)
 
         for item_to_place in items_to_place:
-            if world.accessibility[item_to_place.player] == 'none':
+            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
             else:
@@ -52,11 +52,10 @@ def fill_restrictive(world: MultiWorld, base_state: CollectionState, locations,
             else:
                 # we filled all reachable spots. Maybe the game can be beaten anyway?
                 unplaced_items.append(item_to_place)
-                if world.accessibility[item_to_place.player] != 'none' and world.can_beat_game():
+                if world.accessibility[item_to_place.player] != 'minimal' and world.can_beat_game():
                     logging.warning(
                         f'Not all items placed. Game beatable anyway. (Could not place {item_to_place})')
                     continue
-
                 raise FillError(f'No more spots to place {item_to_place}, locations {locations} are invalid. '
                                 f'Already placed {len(placements)}: {", ".join(str(place) for place in placements)}')
 
@@ -87,9 +86,9 @@ def distribute_items_restrictive(world: MultiWorld, fill_locations=None):
             progitempool.append(item)
         elif item.never_exclude:  # this only gets nonprogression items which should not appear in excluded locations
             nonexcludeditempool.append(item)
-        elif item.name in world.local_items[item.player]:
+        elif item.name in world.local_items[item.player].value:
             localrestitempool[item.player].append(item)
-        elif item.name in world.non_local_items[item.player]:
+        elif item.name in world.non_local_items[item.player].value:
             nonlocalrestitempool.append(item)
         else:
             restitempool.append(item)

Generate.py

@@ -12,17 +12,16 @@ import ModuleUpdate
 
 ModuleUpdate.update()
 
+import Utils
 from worlds.alttp import Options as LttPOptions
 from worlds.generic import PlandoItem, PlandoConnection
 from Utils import parse_yaml, version_tuple, __version__, tuplize_version, get_options
 from worlds.alttp.EntranceRandomizer import parse_arguments
 from Main import main as ERmain
-from Main import get_seed, seeddigits
+from BaseClasses import seeddigits, get_seed
 import Options
-from worlds.alttp.Items import item_table
 from worlds.alttp import Bosses
 from worlds.alttp.Text import TextTable
-from worlds.alttp.Regions import location_table, key_drop_data
 from worlds.AutoWorld import AutoWorldRegister
 
 categories = set(AutoWorldRegister.world_types)
@@ -39,16 +38,16 @@ def mystery_argparse():
     parser.add_argument('--player_files_path', default=defaults["player_files_path"],
                         help="Input directory for player files.")
     parser.add_argument('--seed', help='Define seed number to generate.', type=int)
-    parser.add_argument('--multi', default=defaults["players"], type=lambda value: min(max(int(value), 1), 255))
+    parser.add_argument('--multi', default=defaults["players"], type=lambda value: max(int(value), 1))
     parser.add_argument('--spoiler', type=int, default=defaults["spoiler"])
-    parser.add_argument('--rom', default=options["lttp_options"]["rom_file"], help="Path to the 1.0 JP LttP Baserom.")
+    parser.add_argument('--lttp_rom', default=options["lttp_options"]["rom_file"], help="Path to the 1.0 JP LttP Baserom.")
+    parser.add_argument('--sm_rom', default=options["sm_options"]["rom_file"], help="Path to the 1.0 JP SM Baserom.")
     parser.add_argument('--enemizercli', default=defaults["enemizer_path"])
     parser.add_argument('--outputpath', default=options["general_options"]["output_path"])
     parser.add_argument('--race', action='store_true', default=defaults["race"])
     parser.add_argument('--meta_file_path', default=defaults["meta_file_path"])
-    parser.add_argument('--log_output_path', help='Path to store output log')
     parser.add_argument('--log_level', default='info', help='Sets log level')
-    parser.add_argument('--yaml_output', default=0, type=lambda value: min(max(int(value), 0), 255),
+    parser.add_argument('--yaml_output', default=0, type=lambda value: max(int(value), 0),
                         help='Output rolled mystery results to yaml up to specified number (made for async multiworld)')
     parser.add_argument('--plando', default=defaults["plando_options"],
                         help='List of options that can be set manually. Can be combined, for example "bosses, items"')
@@ -91,7 +90,8 @@ def main(args=None, callback=ERmain):
         except Exception as e:
             raise ValueError(f"File {args.meta_file_path} is destroyed. Please fix your yaml.") from e
         meta_weights = weights_cache[args.meta_file_path]
-        print(f"Meta: {args.meta_file_path} >> {get_choice('meta_description', meta_weights, 'No description specified')}")
+        print(f"Meta: {args.meta_file_path} >> {get_choice('meta_description', meta_weights)}")
+        del(meta_weights["meta_description"])
         if args.samesettings:
             raise Exception("Cannot mix --samesettings with --meta")
     else:
@@ -113,34 +113,24 @@ def main(args=None, callback=ERmain):
                 player_id += 1
 
     args.multi = max(player_id-1, args.multi)
-    print(f"Generating for {args.multi} player{'s' if args.multi > 1 else ''}, {seed_name} Seed {seed}")
+    print(f"Generating for {args.multi} player{'s' if args.multi > 1 else ''}, {seed_name} Seed {seed} with plando: "
+          f"{', '.join(args.plando)}")
 
     if not weights_cache:
         raise Exception(f"No weights found. Provide a general weights file ({args.weights_file_path}) or individual player files. "
                         f"A mix is also permitted.")
     erargs = parse_arguments(['--multi', str(args.multi)])
     erargs.seed = seed
-    erargs.create_spoiler = args.spoiler > 0
     erargs.glitch_triforce = options["generator"]["glitch_triforce_room"]
+    erargs.spoiler = args.spoiler
     erargs.race = args.race
-    erargs.skip_playthrough = args.spoiler < 2
     erargs.outputname = seed_name
     erargs.outputpath = args.outputpath
 
-    # set up logger
-    if args.log_level:
-        erargs.loglevel = args.log_level
-    loglevel = {'error': logging.ERROR, 'info': logging.INFO, 'warning': logging.WARNING, 'debug': logging.DEBUG}[
-        erargs.loglevel]
+    Utils.init_logging(f"Generate_{seed}", loglevel=args.log_level)
 
-    if args.log_output_path:
-        os.makedirs(args.log_output_path, exist_ok=True)
-        logging.basicConfig(format='%(message)s', level=loglevel, force=True,
-                            filename=os.path.join(args.log_output_path, f"{seed}.log"))
-    else:
-        logging.basicConfig(format='%(message)s', level=loglevel, force=True)
-
-    erargs.rom = args.rom
+    erargs.lttp_rom = args.lttp_rom
+    erargs.sm_rom = args.sm_rom
     erargs.enemizercli = args.enemizercli
 
     settings_cache = {k: (roll_settings(v, args.plando) if args.samesettings else None)
@@ -150,17 +140,17 @@ def main(args=None, callback=ERmain):
         player_path_cache[player] = player_files.get(player, args.weights_file_path)
 
     if meta_weights:
-        for player, path in player_path_cache.items():
-            weights_cache[path].setdefault("meta_ignore", [])
-        for key in meta_weights:
-            option = get_choice(key, meta_weights)
-            if option is not None:
-                for player, path in player_path_cache.items():
-                    players_meta = weights_cache[path].get("meta_ignore", [])
-                    if key not in players_meta:
-                        weights_cache[path][key] = option
-                    elif type(players_meta) == dict and players_meta[key] and option not in players_meta[key]:
-                        weights_cache[path][key] = option
+        for category_name, category_dict in meta_weights.items():
+            for key in category_dict:
+                option = get_choice(key, category_dict)
+                if option is not None:
+                    for player, path in player_path_cache.items():
+                        if category_name is None:
+                            weights_cache[path][key] = option
+                        elif category_name not in weights_cache[path]:
+                            raise Exception(f"Meta: Category {category_name} is not present in {path}.")
+                        else:
+                            weights_cache[path][category_name][key] = option
 
     name_counter = Counter()
     erargs.player_settings = {}
@@ -361,10 +351,10 @@ def roll_linked_options(weights: dict) -> dict:
     return weights
 
 
-def roll_triggers(weights: dict) -> dict:
+def roll_triggers(weights: dict, triggers: list) -> dict:
     weights = weights.copy()  # make sure we don't write back to other weights sets in same_settings
-    weights["_Generator_Version"] = "Archipelago"  # Some means for triggers to know if the seed is on main or doors.
-    for i, option_set in enumerate(weights["triggers"]):
+    weights["_Generator_Version"] = Utils.__version__
+    for i, option_set in enumerate(triggers):
         try:
             currently_targeted_weights = weights
             category = option_set.get("option_category", None)
@@ -426,12 +416,38 @@ def get_plando_bosses(boss_shuffle: str, plando_options: typing.Set[str]) -> str
         raise Exception(f"Boss Shuffle {boss_shuffle} is unknown and boss plando is turned off.")
 
 
+def handle_option(ret: argparse.Namespace, game_weights: dict, option_key: str, option: type(Options.Option)):
+    if option_key in game_weights:
+        try:
+            if not option.supports_weighting:
+                player_option = option.from_any(game_weights[option_key])
+            else:
+                player_option = option.from_any(get_choice(option_key, game_weights))
+            setattr(ret, option_key, player_option)
+        except Exception as e:
+            raise Exception(f"Error generating option {option_key} in {ret.game}") from e
+        else:
+            # verify item names existing
+            if getattr(player_option, "verify_item_name", False):
+                for item_name in player_option.value:
+                    if item_name not in AutoWorldRegister.world_types[ret.game].item_names:
+                        raise Exception(f"Item {item_name} from option {player_option} "
+                                        f"is not a valid item name from {ret.game}")
+            elif getattr(player_option, "verify_location_name", False):
+                for location_name in player_option.value:
+                    if location_name not in AutoWorldRegister.world_types[ret.game].location_names:
+                        raise Exception(f"Location {location_name} from option {player_option} "
+                                        f"is not a valid location name from {ret.game}")
+    else:
+        setattr(ret, option_key, option(option.default))
+
+
 def roll_settings(weights: dict, plando_options: typing.Set[str] = frozenset(("bosses",))):
     if "linked_options" in weights:
         weights = roll_linked_options(weights)
 
     if "triggers" in weights:
-        weights = roll_triggers(weights)
+        weights = roll_triggers(weights, weights["triggers"])
 
     requirements = weights.get("requires", {})
     if requirements:
@@ -452,64 +468,33 @@ def roll_settings(weights: dict, plando_options: typing.Set[str] = frozenset(("b
                                     f"which are not enabled.")
 
     ret = argparse.Namespace()
-    ret.name = get_choice('name', weights)
-    ret.accessibility = get_choice('accessibility', weights)
-    ret.progression_balancing = get_choice('progression_balancing', weights, True)
+    for option_key in Options.per_game_common_options:
+        if option_key in weights:
+            raise Exception(f"Option {option_key} has to be in a game's section, not on its own.")
+
     ret.game = get_choice("game", weights)
     if ret.game not in weights:
         raise Exception(f"No game options for selected game \"{ret.game}\" found.")
+
     world_type = AutoWorldRegister.world_types[ret.game]
     game_weights = weights[ret.game]
-    ret.local_items = set()
-    for item_name in game_weights.get('local_items', []):
-        items = world_type.item_name_groups.get(item_name, {item_name})
-        for item in items:
-            if item in world_type.item_names:
-                ret.local_items.add(item)
-            else:
-                raise Exception(f"Could not force item {item} to be world-local, as it was not recognized.")
 
-    ret.non_local_items = set()
-    for item_name in game_weights.get('non_local_items', []):
-        items = world_type.item_name_groups.get(item_name, {item_name})
-        for item in items:
-            if item in world_type.item_names:
-                ret.non_local_items.add(item)
-            else:
-                raise Exception(f"Could not force item {item} to be world-non-local, as it was not recognized.")
+    if "triggers" in game_weights:
+        weights = roll_triggers(weights, game_weights["triggers"])
+        game_weights = weights[ret.game]
 
-    inventoryweights = game_weights.get('start_inventory', {})
-    startitems = []
-    for item in inventoryweights.keys():
-        itemvalue = get_choice_legacy(item, inventoryweights)
-        if isinstance(itemvalue, int):
-            for i in range(int(itemvalue)):
-                startitems.append(item)
-        elif itemvalue:
-            startitems.append(item)
-    ret.startinventory = startitems
-    ret.start_hints = set(game_weights.get('start_hints', []))
-
-    ret.excluded_locations = set()
-    for location in game_weights.get('exclude_locations', []):
-        if location in world_type.location_names: 
-            ret.excluded_locations.add(location)
-        else:
-            raise Exception(f"Could not exclude location {location}, as it was not recognized.")
+    ret.name = get_choice('name', weights)
+    for option_key, option in Options.common_options.items():
+        setattr(ret, option_key, option.from_any(get_choice(option_key, weights, option.default)))
 
     if ret.game in AutoWorldRegister.world_types:
-        for option_name, option in AutoWorldRegister.world_types[ret.game].options.items():
-            if option_name in game_weights:
-                try:
-                    if issubclass(option, Options.OptionDict) or issubclass(option, Options.OptionList):
-                        setattr(ret, option_name, option.from_any(game_weights[option_name]))
-                    else:
-                        setattr(ret, option_name, option.from_any(get_choice(option_name, game_weights)))
-                except Exception as e:
-                    raise Exception(f"Error generating option {option_name} in {ret.game}") from e
-            else:
-                setattr(ret, option_name, option(option.default))
-        if ret.game == "Minecraft":
+        for option_key, option in world_type.options.items():
+            handle_option(ret, game_weights, option_key, option)
+        for option_key, option in Options.per_game_common_options.items():
+            handle_option(ret, game_weights, option_key, option)
+        if "items" in plando_options:
+            ret.plando_items = roll_item_plando(world_type, game_weights)
+        if ret.game == "Minecraft" or ret.game == "Ocarina of Time":
             # bad hardcoded behavior to make this work for now
             ret.plando_connections = []
             if "connections" in plando_options:
@@ -519,7 +504,7 @@ def roll_settings(weights: dict, plando_options: typing.Set[str] = frozenset(("b
                         ret.plando_connections.append(PlandoConnection(
                             get_choice("entrance", placement),
                             get_choice("exit", placement),
-                            get_choice("direction", placement, "both")
+                            get_choice("direction", placement)
                         ))
         elif ret.game == "A Link to the Past":
             roll_alttp_settings(ret, game_weights, plando_options)
@@ -528,6 +513,44 @@ def roll_settings(weights: dict, plando_options: typing.Set[str] = frozenset(("b
     return ret
 
 
+def roll_item_plando(world_type, weights):
+    plando_items = []
+
+    def add_plando_item(item: str, location: str):
+        if item not in world_type.item_name_to_id:
+            raise Exception(f"Could not plando item {item} as the item was not recognized")
+        if location not in world_type.location_name_to_id:
+            raise Exception(
+                f"Could not plando item {item} at location {location} as the location was not recognized")
+        plando_items.append(PlandoItem(item, location, location_world, from_pool, force))
+
+    options = weights.get("plando_items", [])
+    for placement in options:
+        if roll_percentage(get_choice_legacy("percentage", placement, 100)):
+            from_pool = get_choice_legacy("from_pool", placement, PlandoItem._field_defaults["from_pool"])
+            location_world = get_choice_legacy("world", placement, PlandoItem._field_defaults["world"])
+            force = str(get_choice_legacy("force", placement, PlandoItem._field_defaults["force"])).lower()
+            if "items" in placement and "locations" in placement:
+                items = placement["items"]
+                locations = placement["locations"]
+                if isinstance(items, dict):
+                    item_list = []
+                    for key, value in items.items():
+                        item_list += [key] * value
+                    items = item_list
+                if not items or not locations:
+                    raise Exception("You must specify at least one item and one location to place items.")
+                random.shuffle(items)
+                random.shuffle(locations)
+                for item, location in zip(items, locations):
+                    add_plando_item(item, location)
+            else:
+                item = get_choice_legacy("item", placement, get_choice_legacy("items", placement))
+                location = get_choice_legacy("location", placement)
+                add_plando_item(item, location)
+    return plando_items
+
+
 def roll_alttp_settings(ret: argparse.Namespace, weights, plando_options):
     if "dungeon_items" in weights and get_choice_legacy('dungeon_items', weights, "none") != "none":
         raise Exception(f"dungeon_items key in A Link to the Past was removed, but is present in these weights as {get_choice_legacy('dungeon_items', weights, False)}.")
@@ -547,8 +570,6 @@ def roll_alttp_settings(ret: argparse.Namespace, weights, plando_options):
     if ret.dark_room_logic not in {"lamp", "torches", "none"}:
         raise ValueError(f"Unknown Dark Room Logic: \"{ret.dark_room_logic}\"")
 
-    ret.restrict_dungeon_item_on_boss = get_choice_legacy('restrict_dungeon_item_on_boss', weights, False)
-
     entrance_shuffle = get_choice_legacy('entrance_shuffle', weights, 'vanilla')
     if entrance_shuffle.startswith('none-'):
         ret.shuffle = 'vanilla'
@@ -588,11 +609,6 @@ def roll_alttp_settings(ret: argparse.Namespace, weights, plando_options):
         ret.shop_shuffle = ''
 
     ret.mode = get_choice_legacy("mode", weights)
-    ret.retro = get_choice_legacy("retro", weights)
-
-    ret.hints = get_choice_legacy('hints', weights)
-
-    ret.swordless = get_choice_legacy('swordless', weights, False)
 
     ret.difficulty = get_choice_legacy('item_pool', weights)
 
@@ -601,12 +617,6 @@ def roll_alttp_settings(ret: argparse.Namespace, weights, plando_options):
     boss_shuffle = get_choice_legacy('boss_shuffle', weights)
     ret.shufflebosses = get_plando_bosses(boss_shuffle, plando_options)
 
-    ret.enemy_shuffle = bool(get_choice_legacy('enemy_shuffle', weights, False))
-
-    ret.killable_thieves = get_choice_legacy('killable_thieves', weights, False)
-    ret.tile_shuffle = get_choice_legacy('tile_shuffle', weights, False)
-    ret.bush_shuffle = get_choice_legacy('bush_shuffle', weights, False)
-
     ret.enemy_damage = {None: 'default',
                         'default': 'default',
                         'shuffled': 'shuffled',
@@ -616,10 +626,6 @@ def roll_alttp_settings(ret: argparse.Namespace, weights, plando_options):
 
     ret.enemy_health = get_choice_legacy('enemy_health', weights)
 
-    ret.shufflepots = get_choice_legacy('pot_shuffle', weights)
-
-    ret.beemizer = int(get_choice_legacy('beemizer', weights, 0))
-
     ret.timer = {'none': False,
                  None: False,
                  False: False,
@@ -647,42 +653,6 @@ def roll_alttp_settings(ret: argparse.Namespace, weights, plando_options):
         if not ret.required_medallions[index]:
             raise Exception(f"unknown Medallion {medallion} for {'misery mire' if index == 0 else 'turtle rock'}")
 
-    ret.plando_items = []
-    if "items" in plando_options:
-
-        def add_plando_item(item: str, location: str):
-            if item not in item_table:
-                raise Exception(f"Could not plando item {item} as the item was not recognized")
-            if location not in location_table and location not in key_drop_data:
-                raise Exception(
-                    f"Could not plando item {item} at location {location} as the location was not recognized")
-            ret.plando_items.append(PlandoItem(item, location, location_world, from_pool, force))
-
-        options = weights.get("plando_items", [])
-        for placement in options:
-            if roll_percentage(get_choice_legacy("percentage", placement, 100)):
-                from_pool = get_choice_legacy("from_pool", placement, PlandoItem._field_defaults["from_pool"])
-                location_world = get_choice_legacy("world", placement, PlandoItem._field_defaults["world"])
-                force = str(get_choice_legacy("force", placement, PlandoItem._field_defaults["force"])).lower()
-                if "items" in placement and "locations" in placement:
-                    items = placement["items"]
-                    locations = placement["locations"]
-                    if isinstance(items, dict):
-                        item_list = []
-                        for key, value in items.items():
-                            item_list += [key] * value
-                        items = item_list
-                    if not items or not locations:
-                        raise Exception("You must specify at least one item and one location to place items.")
-                    random.shuffle(items)
-                    random.shuffle(locations)
-                    for item, location in zip(items, locations):
-                        add_plando_item(item, location)
-                else:
-                    item = get_choice_legacy("item", placement, get_choice_legacy("items", placement))
-                    location = get_choice_legacy("location", placement)
-                    add_plando_item(item, location)
-
     ret.plando_texts = {}
     if "texts" in plando_options:
         tt = TextTable()

LttPAdjuster.py

@@ -15,7 +15,7 @@ from argparse import Namespace
 from concurrent.futures import as_completed, ThreadPoolExecutor
 from glob import glob
 from tkinter import Tk, Frame, Label, StringVar, Entry, filedialog, messagebox, Button, LEFT, X, TOP, LabelFrame, \
-    IntVar, Checkbutton, E, OptionMenu, Toplevel, BOTTOM, RIGHT, font as font, PhotoImage
+    IntVar, Checkbutton, E, W, OptionMenu, Toplevel, BOTTOM, RIGHT, font as font, PhotoImage
 from urllib.parse import urlparse
 from urllib.request import urlopen
 
@@ -51,6 +51,7 @@ def main():
                              (default: %(default)s)
                              ''')
     parser.add_argument('--quickswap', help='Enable quick item swapping with L and R.', action='store_true')
+    parser.add_argument('--deathlink', help='Enable DeathLink system.', action='store_true')
     parser.add_argument('--disablemusic', help='Disables game music.', action='store_true')
     parser.add_argument('--triforcehud', default='hide_goal', const='hide_goal', nargs='?',
                         choices=['normal', 'hide_goal', 'hide_required', 'hide_both'],
@@ -152,7 +153,8 @@ def adjust(args):
         world = getattr(args, "world")
 
     apply_rom_settings(rom, args.heartbeep, args.heartcolor, args.quickswap, args.menuspeed, args.music,
-                       args.sprite, palettes_options, reduceflashing=args.reduceflashing or racerom, world=world)
+                       args.sprite, palettes_options, reduceflashing=args.reduceflashing or racerom, world=world,
+                       deathlink=args.deathlink)
     path = output_path(f'{os.path.basename(args.rom)[:-4]}_adjusted.sfc')
     rom.write_to_file(path)
 
@@ -205,6 +207,7 @@ def adjustGUI():
         guiargs.quickswap = bool(rom_vars.quickSwapVar.get())
         guiargs.music = bool(rom_vars.MusicVar.get())
         guiargs.reduceflashing = bool(rom_vars.disableFlashingVar.get())
+        guiargs.deathlink = bool(rom_vars.DeathLinkVar.get())
         guiargs.rom = romVar2.get()
         guiargs.baserom = romVar.get()
         guiargs.sprite = rom_vars.sprite
@@ -272,17 +275,18 @@ def update_sprites(task, on_finish=None):
         current_sprites = [os.path.basename(file) for file in glob(sprite_dir + '/*')]
         alttpr_sprites = [(sprite['file'], os.path.basename(urlparse(sprite['file']).path))
                           for sprite in sprites_arr if sprite["author"] != "Nintendo"]
-        needed_sprites = [(sprite_url, filename) for (sprite_url, filename) in alttpr_sprites if filename not in current_sprites]
+        needed_sprites = [(sprite_url, filename) for (sprite_url, filename) in alttpr_sprites if
+                          filename not in current_sprites]
 
         alttpr_filenames = [filename for (_, filename) in alttpr_sprites]
         obsolete_sprites = [sprite for sprite in current_sprites if sprite not in alttpr_filenames]
     except Exception as e:
-        resultmessage = "Error Determining which sprites to update. Sprites not updated.\n\n%s: %s" % (type(e).__name__, e)
+        resultmessage = "Error Determining which sprites to update. Sprites not updated.\n\n%s: %s" % (
+        type(e).__name__, e)
         successful = False
         task.queue_event(finished)
         return
 
-
     def dl(sprite_url, filename):
         target = os.path.join(sprite_dir, filename)
         with urlopen(sprite_url) as response, open(target, 'wb') as out:
@@ -291,7 +295,6 @@ def update_sprites(task, on_finish=None):
     def rem(sprite):
         os.remove(os.path.join(sprite_dir, sprite))
 
-
     with ThreadPoolExecutor() as pool:
         dl_tasks = []
         rem_tasks = []
@@ -313,7 +316,7 @@ def update_sprites(task, on_finish=None):
             except Exception as e:
                 logging.exception(e)
                 resultmessage = "Error downloading sprite. Not all sprites updated.\n\n%s: %s" % (
-                type(e).__name__, e)
+                    type(e).__name__, e)
                 successful = False
 
         for rem_task in as_completed(rem_tasks):
@@ -324,7 +327,7 @@ def update_sprites(task, on_finish=None):
             except Exception as e:
                 logging.exception(e)
                 resultmessage = "Error removing obsolete sprite. Not all sprites updated.\n\n%s: %s" % (
-                type(e).__name__, e)
+                    type(e).__name__, e)
                 successful = False
 
     if successful:
@@ -362,7 +365,7 @@ class BackgroundTask(object):
                 event = self.queue.get_nowait()
                 event()
                 if self.running:
-                    #if self is no longer running self.window may no longer be valid
+                    # if self is no longer running self.window may no longer be valid
                     self.window.update_idletasks()
         except queue.Empty:
             pass
@@ -420,6 +423,7 @@ def get_rom_frame(parent=None):
             romVar.set(rom)
             romSelectButton['state'] = "disabled"
             romSelectButton["text"] = "ROM verified"
+
     romSelectButton = Button(romFrame, text='Select Rom', command=RomSelect)
 
     baseRomLabel.pack(side=LEFT)
@@ -444,17 +448,21 @@ def get_rom_options_frame(parent=None):
     MusicCheckbutton.grid(row=0, column=0, sticky=E)
 
     vars.disableFlashingVar = IntVar(value=1)
-    disableFlashingCheckbutton = Checkbutton(romOptionsFrame, text="Disable flashing (anti-epilepsy)", variable=vars.disableFlashingVar)
-    disableFlashingCheckbutton.grid(row=6, column=0, sticky=E)
+    disableFlashingCheckbutton = Checkbutton(romOptionsFrame, text="Disable flashing (anti-epilepsy)",
+                                             variable=vars.disableFlashingVar)
+    disableFlashingCheckbutton.grid(row=6, column=0, sticky=W)
+
+    vars.DeathLinkVar = IntVar(value=0)
+    DeathLinkCheckbutton = Checkbutton(romOptionsFrame, text="DeathLink (Team Deaths)", variable=vars.DeathLinkVar)
+    DeathLinkCheckbutton.grid(row=7, column=0, sticky=W)
 
     spriteDialogFrame = Frame(romOptionsFrame)
     spriteDialogFrame.grid(row=0, column=1)
     baseSpriteLabel = Label(spriteDialogFrame, text='Sprite:')
 
-
-
     vars.spriteNameVar = StringVar()
     vars.sprite = None
+
     def set_sprite(sprite_param):
         nonlocal vars
         if isinstance(sprite_param, str):
@@ -491,7 +499,8 @@ def get_rom_options_frame(parent=None):
     menuspeedLabel.pack(side=LEFT)
     vars.menuspeedVar = StringVar()
     vars.menuspeedVar.set('normal')
-    menuspeedOptionMenu = OptionMenu(menuspeedFrame, vars.menuspeedVar, 'normal', 'instant', 'double', 'triple', 'quadruple', 'half')
+    menuspeedOptionMenu = OptionMenu(menuspeedFrame, vars.menuspeedVar, 'normal', 'instant', 'double', 'triple',
+                                     'quadruple', 'half')
     menuspeedOptionMenu.pack(side=LEFT)
 
     heartcolorFrame = Frame(romOptionsFrame)
@@ -518,7 +527,8 @@ def get_rom_options_frame(parent=None):
     owPalettesLabel.pack(side=LEFT)
     vars.owPalettesVar = StringVar()
     vars.owPalettesVar.set('default')
-    owPalettesOptionMenu = OptionMenu(owPalettesFrame, vars.owPalettesVar, 'default', 'good', 'blackout', 'grayscale', 'negative', 'classic', 'dizzy', 'sick', 'puke')
+    owPalettesOptionMenu = OptionMenu(owPalettesFrame, vars.owPalettesVar, 'default', 'good', 'blackout', 'grayscale',
+                                      'negative', 'classic', 'dizzy', 'sick', 'puke')
     owPalettesOptionMenu.pack(side=LEFT)
 
     uwPalettesFrame = Frame(romOptionsFrame)
@@ -527,7 +537,8 @@ def get_rom_options_frame(parent=None):
     uwPalettesLabel.pack(side=LEFT)
     vars.uwPalettesVar = StringVar()
     vars.uwPalettesVar.set('default')
-    uwPalettesOptionMenu = OptionMenu(uwPalettesFrame, vars.uwPalettesVar, 'default', 'good', 'blackout', 'grayscale', 'negative', 'classic', 'dizzy', 'sick', 'puke')
+    uwPalettesOptionMenu = OptionMenu(uwPalettesFrame, vars.uwPalettesVar, 'default', 'good', 'blackout', 'grayscale',
+                                      'negative', 'classic', 'dizzy', 'sick', 'puke')
     uwPalettesOptionMenu.pack(side=LEFT)
 
     hudPalettesFrame = Frame(romOptionsFrame)
@@ -536,7 +547,8 @@ def get_rom_options_frame(parent=None):
     hudPalettesLabel.pack(side=LEFT)
     vars.hudPalettesVar = StringVar()
     vars.hudPalettesVar.set('default')
-    hudPalettesOptionMenu = OptionMenu(hudPalettesFrame, vars.hudPalettesVar, 'default', 'good', 'blackout', 'grayscale', 'negative', 'classic', 'dizzy', 'sick', 'puke')
+    hudPalettesOptionMenu = OptionMenu(hudPalettesFrame, vars.hudPalettesVar, 'default', 'good', 'blackout',
+                                       'grayscale', 'negative', 'classic', 'dizzy', 'sick', 'puke')
     hudPalettesOptionMenu.pack(side=LEFT)
 
     swordPalettesFrame = Frame(romOptionsFrame)
@@ -545,7 +557,8 @@ def get_rom_options_frame(parent=None):
     swordPalettesLabel.pack(side=LEFT)
     vars.swordPalettesVar = StringVar()
     vars.swordPalettesVar.set('default')
-    swordPalettesOptionMenu = OptionMenu(swordPalettesFrame, vars.swordPalettesVar, 'default', 'good', 'blackout', 'grayscale', 'negative', 'classic', 'dizzy', 'sick', 'puke')
+    swordPalettesOptionMenu = OptionMenu(swordPalettesFrame, vars.swordPalettesVar, 'default', 'good', 'blackout',
+                                         'grayscale', 'negative', 'classic', 'dizzy', 'sick', 'puke')
     swordPalettesOptionMenu.pack(side=LEFT)
 
     shieldPalettesFrame = Frame(romOptionsFrame)
@@ -554,7 +567,8 @@ def get_rom_options_frame(parent=None):
     shieldPalettesLabel.pack(side=LEFT)
     vars.shieldPalettesVar = StringVar()
     vars.shieldPalettesVar.set('default')
-    shieldPalettesOptionMenu = OptionMenu(shieldPalettesFrame, vars.shieldPalettesVar, 'default', 'good', 'blackout', 'grayscale', 'negative', 'classic', 'dizzy', 'sick', 'puke')
+    shieldPalettesOptionMenu = OptionMenu(shieldPalettesFrame, vars.shieldPalettesVar, 'default', 'good', 'blackout',
+                                          'grayscale', 'negative', 'classic', 'dizzy', 'sick', 'puke')
     shieldPalettesOptionMenu.pack(side=LEFT)
 
     spritePoolFrame = Frame(romOptionsFrame)
@@ -563,6 +577,7 @@ def get_rom_options_frame(parent=None):
 
     vars.spritePoolCountVar = StringVar()
     vars.sprite_pool = []
+
     def set_sprite_pool(sprite_param):
         nonlocal vars
         operation = "add"
@@ -632,8 +647,10 @@ class SpriteSelector():
         title_link.pack(side=LEFT)
         title_link.bind("<Button-1>", open_custom_sprite_dir)
 
-        self.icon_section(alttpr_frametitle, self.alttpr_sprite_dir, 'ALTTPR sprites not found. Click "Update alttpr sprites" to download them.')
-        self.icon_section(custom_frametitle, self.custom_sprite_dir, 'Put sprites in the custom sprites folder (see open link above) to have them appear here.')
+        self.icon_section(alttpr_frametitle, self.alttpr_sprite_dir,
+                          'ALTTPR sprites not found. Click "Update alttpr sprites" to download them.')
+        self.icon_section(custom_frametitle, self.custom_sprite_dir,
+                          'Put sprites in the custom sprites folder (see open link above) to have them appear here.')
         if not randomOnEvent:
             self.sprite_pool_section(spritePool)
 
@@ -683,7 +700,8 @@ class SpriteSelector():
             button = Checkbutton(frame, text="Bonk", command=self.update_random_button, variable=self.randomOnBonkVar)
             button.pack(side=LEFT, padx=(0, 5))
 
-            button = Checkbutton(frame, text="Random", command=self.update_random_button, variable=self.randomOnRandomVar)
+            button = Checkbutton(frame, text="Random", command=self.update_random_button,
+                                 variable=self.randomOnRandomVar)
             button.pack(side=LEFT, padx=(0, 5))
 
         if adjuster:
@@ -805,7 +823,6 @@ class SpriteSelector():
 
         BackgroundTaskProgress(self.parent, update_sprites, "Updating Sprites", on_finish)
 
-
     def browse_for_sprite(self):
         sprite = filedialog.askopenfilename(
             filetypes=[("All Sprite Sources", (".zspr", ".spr", ".sfc", ".smc")),
@@ -819,7 +836,6 @@ class SpriteSelector():
             self.callback(None)
         self.window.destroy()
 
-
     def use_default_sprite(self):
         self.callback(None)
         self.window.destroy()
@@ -923,7 +939,8 @@ def get_image_for_sprite(sprite, gif_only: bool = False):
         gif_lsd = bytearray(7)
         gif_lsd[0] = width
         gif_lsd[2] = height
-        gif_lsd[4] = 0xF4  # 32 color palette follows.  transparant + 15 for sprite + 1 for shadow=17 which rounds up to 32 as nearest power of 2
+        gif_lsd[
+            4] = 0xF4  # 32 color palette follows.  transparant + 15 for sprite + 1 for shadow=17 which rounds up to 32 as nearest power of 2
         gif_lsd[5] = 0  # background color is zero
         gif_lsd[6] = 0  # aspect raio not specified
         gif_gct = bytearray(3 * 32)
@@ -943,7 +960,8 @@ def get_image_for_sprite(sprite, gif_only: bool = False):
         gif_id[7] = height
         gif_id[9] = 0  # no local color table
 
-        gif_img_minimum_code_size = bytes([7])  # we choose 7 bits, so that each pixel is represented by a byte, for conviennce.
+        gif_img_minimum_code_size = bytes(
+            [7])  # we choose 7 bits, so that each pixel is represented by a byte, for conviennce.
 
         clear = 0x80
         stop = 0x81
@@ -1100,5 +1118,6 @@ class ToolTips(object):
             widget.after_cancel(cls.after_id)
             cls.after_id = None
 
+
 if __name__ == '__main__':
-    main()
+    main()

Main.py

@@ -1,14 +1,13 @@
-from itertools import zip_longest
+from itertools import zip_longest, chain
 import logging
 import os
-import random
 import time
 import zlib
 import concurrent.futures
 import pickle
 import tempfile
 import zipfile
-from typing import Dict, Tuple
+from typing import Dict, Tuple, Optional
 
 from BaseClasses import MultiWorld, CollectionState, Region, RegionType
 from worlds.alttp.Items import item_name_groups
@@ -19,93 +18,71 @@ from Utils import output_path, get_options, __version__, version_tuple
 from worlds.generic.Rules import locality_rules, exclusion_rules
 from worlds import AutoWorld
 
-seeddigits = 20
+
+ordered_areas = (
+    'Light World', 'Dark World', 'Hyrule Castle', 'Agahnims Tower', 'Eastern Palace', 'Desert Palace',
+    'Tower of Hera', 'Palace of Darkness', 'Swamp Palace', 'Skull Woods', 'Thieves Town', 'Ice Palace',
+    'Misery Mire', 'Turtle Rock', 'Ganons Tower', "Total"
+)
 
 
-def get_seed(seed=None):
-    if seed is None:
-        random.seed(None)
-        return random.randint(0, pow(10, seeddigits) - 1)
-    return seed
-
-
-def main(args, seed=None):
+def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = None):
+    if not baked_server_options:
+        baked_server_options = get_options()["server_options"]
     if args.outputpath:
         os.makedirs(args.outputpath, exist_ok=True)
         output_path.cached_path = args.outputpath
 
     start = time.perf_counter()
-
     # initialize the world
     world = MultiWorld(args.multi)
 
-    logger = logging.getLogger('')
-    world.seed = get_seed(seed)
-    if args.race:
-        world.secure()
-    else:
-        world.random.seed(world.seed)
-    world.seed_name = str(args.outputname if args.outputname else world.seed)
+    logger = logging.getLogger()
+    world.set_seed(seed, args.race, str(args.outputname if args.outputname else world.seed))
 
     world.shuffle = args.shuffle.copy()
     world.logic = args.logic.copy()
     world.mode = args.mode.copy()
-    world.swordless = args.swordless.copy()
     world.difficulty = args.difficulty.copy()
     world.item_functionality = args.item_functionality.copy()
     world.timer = args.timer.copy()
     world.goal = args.goal.copy()
-    world.local_items = args.local_items.copy()
+
     if hasattr(args, "algorithm"):  # current GUI options
         world.algorithm = args.algorithm
         world.shuffleganon = args.shuffleganon
         world.custom = args.custom
         world.customitemarray = args.customitemarray
 
-    world.accessibility = args.accessibility.copy()
-    world.retro = args.retro.copy()
-
-    world.hints = args.hints.copy()
     world.open_pyramid = args.open_pyramid.copy()
     world.boss_shuffle = args.shufflebosses.copy()
-    world.enemy_shuffle = args.enemy_shuffle.copy()
     world.enemy_health = args.enemy_health.copy()
     world.enemy_damage = args.enemy_damage.copy()
-    world.killable_thieves = args.killable_thieves.copy()
-    world.bush_shuffle = args.bush_shuffle.copy()
-    world.tile_shuffle = args.tile_shuffle.copy()
-    world.beemizer = args.beemizer.copy()
+    world.beemizer_total_chance = args.beemizer_total_chance.copy()
+    world.beemizer_trap_chance = args.beemizer_trap_chance.copy()
     world.timer = args.timer.copy()
     world.countdown_start_time = args.countdown_start_time.copy()
     world.red_clock_time = args.red_clock_time.copy()
     world.blue_clock_time = args.blue_clock_time.copy()
     world.green_clock_time = args.green_clock_time.copy()
-    world.shufflepots = args.shufflepots.copy()
     world.dungeon_counters = args.dungeon_counters.copy()
     world.triforce_pieces_available = args.triforce_pieces_available.copy()
     world.triforce_pieces_required = args.triforce_pieces_required.copy()
     world.shop_shuffle = args.shop_shuffle.copy()
-    world.progression_balancing = args.progression_balancing.copy()
     world.shuffle_prizes = args.shuffle_prizes.copy()
     world.sprite_pool = args.sprite_pool.copy()
     world.dark_room_logic = args.dark_room_logic.copy()
     world.plando_items = args.plando_items.copy()
     world.plando_texts = args.plando_texts.copy()
     world.plando_connections = args.plando_connections.copy()
-    world.er_seeds = getattr(args, "er_seeds", {})
-    world.restrict_dungeon_item_on_boss = args.restrict_dungeon_item_on_boss.copy()
     world.required_medallions = args.required_medallions.copy()
     world.game = args.game.copy()
     world.set_options(args)
     world.player_name = args.name.copy()
-    world.alttp_rom = args.rom
     world.enemizer = args.enemizercli
     world.sprite = args.sprite.copy()
     world.glitch_triforce = args.glitch_triforce  # This is enabled/disabled globally, no per player option.
 
-    world.slot_seeds = {player: random.Random(world.random.getrandbits(64)) for player in
-                        range(1, world.players + 1)}
-
     logger.info('Archipelago Version %s  -  Seed: %s\n', __version__, world.seed)
 
     logger.info("Found World Types:")
@@ -115,7 +92,7 @@ def main(args, seed=None):
         if not cls.hidden:
             logger.info(f"  {name:{longest_name}}: {len(cls.item_names):3} Items | "
                         f"{len(cls.location_names):3} Locations")
-            logger.info(f"  Item IDs: {min(cls.item_id_to_name):{numlength}} - "
+            logger.info(f"   Item IDs: {min(cls.item_id_to_name):{numlength}} - "
                         f"{max(cls.item_id_to_name):{numlength}} | "
                         f"Location IDs: {min(cls.location_id_to_name):{numlength}} - "
                         f"{max(cls.location_id_to_name):{numlength}}")
@@ -125,21 +102,22 @@ def main(args, seed=None):
     logger.info('')
 
     for player in world.player_ids:
-        for item_name in args.startinventory[player]:
-            world.push_precollected(world.create_item(item_name, player))
+        for item_name, count in world.start_inventory[player].value.items():
+            for _ in range(count):
+                world.push_precollected(world.create_item(item_name, player))
 
     for player in world.player_ids:
         if player in world.get_game_players("A Link to the Past"):
             # enforce pre-defined local items.
             if world.goal[player] in ["localtriforcehunt", "localganontriforcehunt"]:
-                world.local_items[player].add('Triforce Piece')
+                world.local_items[player].value.add('Triforce Piece')
 
             # Not possible to place pendants/crystals out side of boss prizes yet.
-            world.non_local_items[player] -= item_name_groups['Pendants']
-            world.non_local_items[player] -= item_name_groups['Crystals']
+            world.non_local_items[player].value -= item_name_groups['Pendants']
+            world.non_local_items[player].value -= item_name_groups['Crystals']
 
         # items can't be both local and non-local, prefer local
-        world.non_local_items[player] -= world.local_items[player]
+        world.non_local_items[player].value -= world.local_items[player].value
 
     logger.info('Creating World.')
     AutoWorld.call_all(world, "create_regions")
@@ -151,11 +129,14 @@ def main(args, seed=None):
     if world.players > 1:
         for player in world.player_ids:
             locality_rules(world, player)
+    else:
+        world.non_local_items[1].value = set()
+        world.local_items[1].value = set()
 
     AutoWorld.call_all(world, "set_rules")
 
     for player in world.player_ids:
-        exclusion_rules(world, player, args.excluded_locations[player])
+        exclusion_rules(world, player, world.exclude_locations[player].value)
 
     AutoWorld.call_all(world, "generate_basic")
 
@@ -170,7 +151,7 @@ def main(args, seed=None):
 
     AutoWorld.call_all(world, "pre_fill")
 
-    logger.info('Fill the world.')
+    logger.info(f'Filling the world with {len(world.itempool)} items.')
 
     if world.algorithm == 'flood':
         flood_items(world)  # different algo, biased towards early game progress items
@@ -187,16 +168,15 @@ def main(args, seed=None):
 
     output = tempfile.TemporaryDirectory()
     with output as temp_dir:
-        with concurrent.futures.ThreadPoolExecutor() as pool:
+        with concurrent.futures.ThreadPoolExecutor(world.players + 2) as pool:
             check_accessibility_task = pool.submit(world.fulfills_accessibility)
 
-            output_file_futures = []
-
+            output_file_futures = [pool.submit(AutoWorld.call_stage, world, "generate_output", temp_dir)]
             for player in world.player_ids:
                 # skip starting a thread for methods that say "pass".
                 if AutoWorld.World.generate_output.__code__ is not world.worlds[player].generate_output.__code__:
-                    output_file_futures.append(pool.submit(AutoWorld.call_single, world, "generate_output", player, temp_dir))
-            output_file_futures.append(pool.submit(AutoWorld.call_stage, world, "generate_output", temp_dir))
+                    output_file_futures.append(
+                        pool.submit(AutoWorld.call_single, world, "generate_output", player, temp_dir))
 
             def get_entrance_to_region(region: Region):
                 for entrance in region.entrances:
@@ -217,10 +197,6 @@ def main(args, seed=None):
                             if lookup_vanilla_location_to_entrance[location.address] != main_entrance.name:
                                 er_hint_data[region.player][location.address] = main_entrance.name
 
-            ordered_areas = ('Light World', 'Dark World', 'Hyrule Castle', 'Agahnims Tower', 'Eastern Palace', 'Desert Palace',
-                             'Tower of Hera', 'Palace of Darkness', 'Swamp Palace', 'Skull Woods', 'Thieves Town', 'Ice Palace',
-                             'Misery Mire', 'Turtle Rock', 'Ganons Tower', "Total")
-
             checks_in_area = {player: {area: list() for area in ordered_areas}
                               for player in range(1, world.players + 1)}
 
@@ -237,6 +213,10 @@ def main(args, seed=None):
                                        'Inverted Ganons Tower': 'Ganons Tower'} \
                             .get(location.parent_region.dungeon.name, location.parent_region.dungeon.name)
                         checks_in_area[location.player][dungeonname].append(location.address)
+                    elif location.parent_region.type == RegionType.LightWorld:
+                        checks_in_area[location.player]["Light World"].append(location.address)
+                    elif location.parent_region.type == RegionType.DarkWorld:
+                        checks_in_area[location.player]["Dark World"].append(location.address)
                     elif main_entrance.parent_region.type == RegionType.LightWorld:
                         checks_in_area[location.player]["Light World"].append(location.address)
                     elif main_entrance.parent_region.type == RegionType.DarkWorld:
@@ -246,10 +226,11 @@ def main(args, seed=None):
             oldmancaves = []
             takeanyregions = ["Old Man Sword Cave", "Take-Any #1", "Take-Any #2", "Take-Any #3", "Take-Any #4"]
             for index, take_any in enumerate(takeanyregions):
-                for region in [world.get_region(take_any, player) for player in range(1, world.players + 1) if
-                               world.retro[player]]:
-                    item = world.create_item(region.shop.inventory[(0 if take_any == "Old Man Sword Cave" else 1)]['item'],
-                                             region.player)
+                for region in [world.get_region(take_any, player) for player in
+                               world.get_game_players("A Link to the Past") if world.retro[player]]:
+                    item = world.create_item(
+                        region.shop.inventory[(0 if take_any == "Old Man Sword Cave" else 1)]['item'],
+                        region.player)
                     player = region.player
                     location_id = SHOP_ID_START + total_shop_slots + index
 
@@ -269,23 +250,27 @@ def main(args, seed=None):
                 import NetUtils
                 slot_data = {}
                 client_versions = {}
-                minimum_versions = {"server": (0, 1, 1), "clients": client_versions}
+                minimum_versions = {"server": (0, 1, 8), "clients": client_versions}
                 games = {}
                 for slot in world.player_ids:
                     client_versions[slot] = world.worlds[slot].get_required_client_version()
                     games[slot] = world.game[slot]
-                precollected_items = {player: [] for player in range(1, world.players + 1)}
-                for item in world.precollected_items:
-                    precollected_items[item.player].append(item.code)
+                precollected_items = {player: [item.code for item in world_precollected]
+                                      for player, world_precollected in world.precollected_items.items()}
                 precollected_hints = {player: set() for player in range(1, world.players + 1)}
                 # for now special case Factorio tech_tree_information
                 sending_visible_players = set()
-                for player in world.get_game_players("Factorio"):
-                    if world.tech_tree_information[player].value == 2:
-                        sending_visible_players.add(player)
 
                 for slot in world.player_ids:
                     slot_data[slot] = world.worlds[slot].fill_slot_data()
+                    if world.worlds[slot].sending_visible:
+                        sending_visible_players.add(slot)
+
+                def precollect_hint(location):
+                    hint = NetUtils.Hint(location.item.player, location.player, location.address,
+                                         location.item.code, False)
+                    precollected_hints[location.player].add(hint)
+                    precollected_hints[location.item.player].add(hint)
 
                 locations_data: Dict[int, Dict[int, Tuple[int, int]]] = {player: {} for player in world.player_ids}
                 for location in world.get_filled_locations():
@@ -293,17 +278,12 @@ def main(args, seed=None):
                         # item code None should be event, location.address should then also be None
                         assert location.item.code is not None
                         locations_data[location.player][location.address] = location.item.code, location.item.player
-                        if location.player in sending_visible_players and location.item.player != location.player:
-                            hint = NetUtils.Hint(location.item.player, location.player, location.address,
-                                                 location.item.code, False)
-                            precollected_hints[location.player].add(hint)
-                            precollected_hints[location.item.player].add(hint)
-                        elif location.item.name in args.start_hints[location.item.player]:
-                            hint = NetUtils.Hint(location.item.player, location.player, location.address,
-                                                 location.item.code, False,
-                                                 er_hint_data.get(location.player, {}).get(location.address, ""))
-                            precollected_hints[location.player].add(hint)
-                            precollected_hints[location.item.player].add(hint)
+                        if location.player in sending_visible_players:
+                            precollect_hint(location)
+                        elif location.name in world.start_location_hints[location.player]:
+                            precollect_hint(location)
+                        elif location.item.name in world.start_hints[location.item.player]:
+                            precollect_hint(location)
 
                 multidata = {
                     "slot_data": slot_data,
@@ -312,9 +292,11 @@ def main(args, seed=None):
                     "connect_names": {name: (0, player) for player, name in world.player_name.items()},
                     "remote_items": {player for player in world.player_ids if
                                      world.worlds[player].remote_items},
+                    "remote_start_inventory": {player for player in world.player_ids if
+                                               world.worlds[player].remote_start_inventory},
                     "locations": locations_data,
                     "checks_in_area": checks_in_area,
-                    "server_options": get_options()["server_options"],
+                    "server_options": baked_server_options,
                     "er_hint_data": er_hint_data,
                     "precollected_items": precollected_items,
                     "precollected_hints": precollected_hints,
@@ -339,18 +321,17 @@ def main(args, seed=None):
                     logger.warning("Location Accessibility requirements not fulfilled.")
 
             # retrieve exceptions via .result() if they occured.
-            if multidata_task:
-                multidata_task.result()
-            for i, future in enumerate(concurrent.futures.as_completed(output_file_futures)):
-                if i % 10 == 0:
+            multidata_task.result()
+            for i, future in enumerate(concurrent.futures.as_completed(output_file_futures), start=1):
+                if i % 10 == 0 or i == len(output_file_futures):
                     logger.info(f'Generating output files ({i}/{len(output_file_futures)}).')
                 future.result()
 
-        if not args.skip_playthrough:
+        if args.spoiler > 1:
             logger.info('Calculating playthrough.')
             create_playthrough(world)
 
-        if args.create_spoiler:
+        if args.spoiler:
             world.spoiler.to_file(os.path.join(temp_dir, '%s_Spoiler.txt' % outfilebase))
 
         zipfilename = output_path(f"AP_{world.seed_name}.zip")
@@ -393,7 +374,7 @@ def create_playthrough(world):
             logging.debug('The following items could not be reached: %s', ['%s (Player %d) at %s (Player %d)' % (
                 location.item.name, location.item.player, location.name, location.player) for location in
                                                                            sphere_candidates])
-            if any([world.accessibility[location.item.player] != 'none' for location in sphere_candidates]):
+            if any([world.accessibility[location.item.player] != 'minimal' for location in sphere_candidates]):
                 raise RuntimeError(f'Not all progression items reachable ({sphere_candidates}). '
                                    f'Something went terribly wrong here.')
             else:
@@ -423,9 +404,9 @@ def create_playthrough(world):
 
     # second phase, sphere 0
     removed_precollected = []
-    for item in (i for i in world.precollected_items if i.advancement):
+    for item in (i for i in chain.from_iterable(world.precollected_items.values()) if i.advancement):
         logging.debug('Checking if %s (Player %d) is required to beat the game.', item.name, item.player)
-        world.precollected_items.remove(item)
+        world.precollected_items[item.player].remove(item)
         world.state.remove(item)
         if not world.can_beat_game():
             world.push_precollected(item)
@@ -489,7 +470,9 @@ def create_playthrough(world):
                         get_path(state, world.get_region('Inverted Big Bomb Shop', player))
 
     # we can finally output our playthrough
-    world.spoiler.playthrough = {"0": sorted([str(item) for item in world.precollected_items if item.advancement])}
+    world.spoiler.playthrough = {"0": sorted([str(item) for item in
+                                              chain.from_iterable(world.precollected_items.values())
+                                              if item.advancement])}
 
     for i, sphere in enumerate(collection_spheres):
         world.spoiler.playthrough[str(i + 1)] = {str(location): str(location.item) for location in sorted(sphere)}

MinecraftClient.py

@@ -4,8 +4,8 @@ import re
 import atexit
 from subprocess import Popen
 from shutil import copyfile
-from base64 import b64decode
 from time import strftime
+import logging
 
 import requests
 
@@ -15,6 +15,7 @@ atexit.register(input, "Press enter to exit.")
 
 # 1 or more digits followed by m or g, then optional b
 max_heap_re = re.compile(r"^\d+[mMgG][bB]?$")
+forge_version = "1.17.1-37.0.109"
 
 
 def prompt_yes_no(prompt):
@@ -30,15 +31,6 @@ def prompt_yes_no(prompt):
             print('Please respond with "y" or "n".')
 
 
-# Find Forge jar file; raise error if not found 
-def find_forge_jar(forge_dir):
-    for entry in os.scandir(forge_dir):
-        if ".jar" in entry.name and "forge" in entry.name:
-            print(f"Found forge .jar: {entry.name}")
-            return entry.name
-    raise FileNotFoundError(f"Could not find forge .jar in {forge_dir}.")
-
-
 # Create mods folder if needed; find AP randomizer jar; return None if not found.
 def find_ap_randomizer_jar(forge_dir):
     mods_dir = os.path.join(forge_dir, 'mods')
@@ -47,12 +39,12 @@ def find_ap_randomizer_jar(forge_dir):
         for entry in os.scandir(mods_dir):
             match = ap_mod_re.match(entry.name)
             if match:
-                print(f"Found AP randomizer mod: {match.group()}")
+                logging.info(f"Found AP randomizer mod: {match.group()}")
                 return match.group()
         return None
     else:
         os.mkdir(mods_dir)
-        print(f"Created mods folder in {forge_dir}")
+        logging.info(f"Created mods folder in {forge_dir}")
         return None
 
 
@@ -64,52 +56,73 @@ def replace_apmc_files(forge_dir, apmc_file):
     copy_apmc = True
     if not os.path.isdir(apdata_dir):
         os.mkdir(apdata_dir)
-        print(f"Created APData folder in {forge_dir}")
+        logging.info(f"Created APData folder in {forge_dir}")
     for entry in os.scandir(apdata_dir):
         if entry.name.endswith(".apmc") and entry.is_file():
             if not os.path.samefile(apmc_file, entry.path):
                 os.remove(entry.path)
-                print(f"Removed {entry.name} in {apdata_dir}")
+                logging.info(f"Removed {entry.name} in {apdata_dir}")
             else: # apmc already in apdata
                 copy_apmc = False
     if copy_apmc:
         copyfile(apmc_file, os.path.join(apdata_dir, os.path.basename(apmc_file)))
-        print(f"Copied {os.path.basename(apmc_file)} to {apdata_dir}")
+        logging.info(f"Copied {os.path.basename(apmc_file)} to {apdata_dir}")
+
+
+def read_apmc_file(apmc_file):
+    from base64 import b64decode
+    import json
+
+    with open(apmc_file, 'r') as f:
+        data = json.loads(b64decode(f.read()))
+    return data
 
 
 # Check mod version, download new mod from GitHub releases page if needed. 
-def update_mod(forge_dir):
+def update_mod(forge_dir, apmc_file, get_prereleases=False):
     ap_randomizer = find_ap_randomizer_jar(forge_dir)
 
+    if apmc_file is not None:
+        data = read_apmc_file(apmc_file)
+        minecraft_version = data.get('minecraft_version', '')
+
     client_releases_endpoint = "https://api.github.com/repos/KonoTyran/Minecraft_AP_Randomizer/releases"
     resp = requests.get(client_releases_endpoint)
     if resp.status_code == 200:  # OK
-        latest_release = resp.json()[0]
-        if ap_randomizer != latest_release['assets'][0]['name']:
-            print(f"A new release of the Minecraft AP randomizer mod was found: {latest_release['assets'][0]['name']}")
-            if ap_randomizer is not None:
-                print(f"Your current mod is {ap_randomizer}.")
-            else:
-                print(f"You do not have the AP randomizer mod installed.")
-            if prompt_yes_no("Would you like to update?"):
-                old_ap_mod = os.path.join(forge_dir, 'mods', ap_randomizer) if ap_randomizer is not None else None
-                new_ap_mod = os.path.join(forge_dir, 'mods', latest_release['assets'][0]['name'])
-                print("Downloading AP randomizer mod. This may take a moment...")
-                apmod_resp = requests.get(latest_release['assets'][0]['browser_download_url'])
-                if apmod_resp.status_code == 200: 
-                    with open(new_ap_mod, 'wb') as f:
-                        f.write(apmod_resp.content)
-                        print(f"Wrote new mod file to {new_ap_mod}")
-                    if old_ap_mod is not None:
-                        os.remove(old_ap_mod)
-                        print(f"Removed old mod file from {old_ap_mod}")
+        try:
+            latest_release = next(filter(lambda release: (not release['prerelease'] or get_prereleases) and 
+                (apmc_file is None or minecraft_version in release['assets'][0]['name']), 
+                resp.json()))
+            if ap_randomizer != latest_release['assets'][0]['name']:
+                logging.info(f"A new release of the Minecraft AP randomizer mod was found: "
+                             f"{latest_release['assets'][0]['name']}")
+                if ap_randomizer is not None:
+                    logging.info(f"Your current mod is {ap_randomizer}.")
                 else:
-                    print(f"Error retrieving the randomizer mod (status code {apmod_resp.status_code}).")
-                    print(f"Please report this issue on the Archipelago Discord server.")
-                    sys.exit(1)
+                    logging.info(f"You do not have the AP randomizer mod installed.")
+                if prompt_yes_no("Would you like to update?"):
+                    old_ap_mod = os.path.join(forge_dir, 'mods', ap_randomizer) if ap_randomizer is not None else None
+                    new_ap_mod = os.path.join(forge_dir, 'mods', latest_release['assets'][0]['name'])
+                    logging.info("Downloading AP randomizer mod. This may take a moment...")
+                    apmod_resp = requests.get(latest_release['assets'][0]['browser_download_url'])
+                    if apmod_resp.status_code == 200: 
+                        with open(new_ap_mod, 'wb') as f:
+                            f.write(apmod_resp.content)
+                            logging.info(f"Wrote new mod file to {new_ap_mod}")
+                        if old_ap_mod is not None:
+                            os.remove(old_ap_mod)
+                            logging.info(f"Removed old mod file from {old_ap_mod}")
+                    else:
+                        logging.error(f"Error retrieving the randomizer mod (status code {apmod_resp.status_code}).")
+                        logging.error(f"Please report this issue on the Archipelago Discord server.")
+                        sys.exit(1)
+        except StopIteration:
+            logging.warning(f"No compatible mod version found for {minecraft_version}.")
+            if not prompt_yes_no("Run server anyway?"):
+                sys.exit(0)
     else:
-        print(f"Error checking for randomizer mod updates (status code {resp.status_code}).")
-        print(f"If this was not expected, please report this issue on the Archipelago Discord server.")
+        logging.error(f"Error checking for randomizer mod updates (status code {resp.status_code}).")
+        logging.error(f"If this was not expected, please report this issue on the Archipelago Discord server.")
         if not prompt_yes_no("Continue anyways?"):
             sys.exit(0)
 
@@ -127,22 +140,80 @@ def check_eula(forge_dir):
         text = f.read()
         if 'false' in text:
             # Prompt user to agree to the EULA
-            print("You need to agree to the Minecraft EULA in order to run the server.")
-            print("The EULA can be found at https://account.mojang.com/documents/minecraft_eula")
+            logging.info("You need to agree to the Minecraft EULA in order to run the server.")
+            logging.info("The EULA can be found at https://account.mojang.com/documents/minecraft_eula")
             if prompt_yes_no("Do you agree to the EULA?"):
                 f.seek(0)
                 f.write(text.replace('false', 'true'))
                 f.truncate()
-                print(f"Set {eula_path} to true")
+                logging.info(f"Set {eula_path} to true")
             else:
                 sys.exit(0)
 
 
-# Run the Forge server. Return process object
-def run_forge_server(forge_dir, heap_arg):
-    forge_server = find_forge_jar(forge_dir)
+# get the current JDK16
+def find_jdk_dir() -> str:
+    for entry in os.listdir():
+        if os.path.isdir(entry) and entry.startswith("jdk16"):
+            return os.path.abspath(entry)
 
-    java_exe = os.path.abspath(os.path.join('jre8', 'bin', 'java.exe'))
+
+# get the java exe location
+def find_jdk() -> str:
+    jdk = find_jdk_dir()
+    jdk_exe = os.path.join(jdk, "bin", "java.exe")
+    if os.path.isfile(jdk_exe):
+        return jdk_exe
+
+
+# Download Corretto 16 (Amazon JDK)
+def download_java():
+    jdk = find_jdk_dir()
+    if jdk is not None:
+        print(f"Removing old JDK...")
+        from shutil import rmtree
+        rmtree(jdk)
+
+    print(f"Downloading Java...")
+    jdk_url = "https://corretto.aws/downloads/latest/amazon-corretto-16-x64-windows-jdk.zip"
+    resp = requests.get(jdk_url)
+    if resp.status_code == 200:  # OK
+        print(f"Extracting...")
+        import zipfile
+        from io import BytesIO
+        with zipfile.ZipFile(BytesIO(resp.content)) as zf:
+            zf.extractall()
+    else:
+        print(f"Error downloading Java (status code {resp.status_code}).")
+        print(f"If this was not expected, please report this issue on the Archipelago Discord server.")
+        if not prompt_yes_no("Continue anyways?"):
+            sys.exit(0)
+
+
+# download and install forge
+def install_forge(directory: str):
+    jdk = find_jdk()
+    if jdk is not None:
+        print(f"Downloading Forge {forge_version}...")
+        forge_url = f"https://maven.minecraftforge.net/net/minecraftforge/forge/{forge_version}/forge-{forge_version}-installer.jar"
+        resp = requests.get(forge_url)
+        if resp.status_code == 200:  # OK
+            forge_install_jar = os.path.join(directory, "forge_install.jar")
+            if not os.path.exists(directory):
+                os.mkdir(directory)
+            with open(forge_install_jar, 'wb') as f:
+                f.write(resp.content)
+            print(f"Installing Forge...")
+            argstring = ' '.join([jdk, "-jar", "\"" + forge_install_jar+ "\"", "--installServer", "\"" + directory + "\""])
+            install_process = Popen(argstring)
+            install_process.wait()
+            os.remove(forge_install_jar)
+
+
+# Run the Forge server. Return process object
+def run_forge_server(forge_dir: str, heap_arg):
+
+    java_exe = find_jdk()
     if not os.path.isfile(java_exe):
         java_exe = "java"  # try to fall back on java in the PATH
 
@@ -151,15 +222,26 @@ def run_forge_server(forge_dir, heap_arg):
         heap_arg = heap_arg[:-1]
     heap_arg = "-Xmx" + heap_arg
 
-    argstring = ' '.join([java_exe, heap_arg, "-jar", forge_server, "-nogui"])
-    print(f"Running Forge server: {argstring}")
+    args_file = os.path.join(forge_dir, "libraries", "net", "minecraftforge", "forge", forge_version, "win_args.txt")
+    win_args = []
+    with open(args_file) as argfile:
+        for line in argfile:
+            win_args.append(line.strip())
+
+    argstring = ' '.join([java_exe, heap_arg] + win_args + ["-nogui"])
+    logging.info(f"Running Forge server: {argstring}")
     os.chdir(forge_dir)
     return Popen(argstring)
 
 
 if __name__ == '__main__':
+    Utils.init_logging("MinecraftClient")
     parser = argparse.ArgumentParser()
     parser.add_argument("apmc_file", default=None, nargs='?', help="Path to an Archipelago Minecraft data file (.apmc)")
+    parser.add_argument('--install', '-i', dest='install', default=False, action='store_true', 
+        help="Download and install Java and the Forge server. Does not launch the client afterwards.")
+    parser.add_argument('--prerelease', default=False, action='store_true',
+        help="Auto-update prerelease versions.")
 
     args = parser.parse_args()
     apmc_file = os.path.abspath(args.apmc_file) if args.apmc_file else None
@@ -171,6 +253,12 @@ if __name__ == '__main__':
     forge_dir = options["minecraft_options"]["forge_directory"]
     max_heap = options["minecraft_options"]["max_heap_size"]
 
+    if args.install:
+        print("Installing Java and Minecraft Forge")
+        download_java()
+        install_forge(forge_dir)
+        sys.exit(0)
+
     if apmc_file is not None and not os.path.isfile(apmc_file):
         raise FileNotFoundError(f"Path {apmc_file} does not exist or could not be accessed.")
     if not os.path.isdir(forge_dir):
@@ -178,7 +266,7 @@ if __name__ == '__main__':
     if not max_heap_re.match(max_heap):
         raise Exception(f"Max heap size {max_heap} in incorrect format. Use a number followed by M or G, e.g. 512M or 2G.")
 
-    update_mod(forge_dir)
+    update_mod(forge_dir, apmc_file, args.prerelease)
     replace_apmc_files(forge_dir, apmc_file)
     check_eula(forge_dir)
     server_process = run_forge_server(forge_dir, max_heap)

ModuleUpdate.py

@@ -35,18 +35,25 @@ def update(yes = False, force = False):
             if not os.path.exists(path):
                 path = os.path.join(os.path.dirname(__file__), req_file)
             with open(path) as requirementsfile:
-                requirements = pkg_resources.parse_requirements(requirementsfile)
-                for requirement in requirements:
-                    requirement = str(requirement)
-                    try:
-                        pkg_resources.require(requirement)
-                    except pkg_resources.ResolutionError:
-                        if not yes:
-                            import traceback
-                            traceback.print_exc()
-                            input(f'Requirement {requirement} is not satisfied, press enter to install it')
-                        update_command()
-                        return
+                for line in requirementsfile:
+                    if line.startswith('https://'):
+                        # extract name and version from url
+                        url = line.split(';')[0]
+                        wheel = line.split('/')[-1]
+                        name, version, _ = wheel.split('-',2)
+                        line = f'{name}=={version}'
+                    requirements = pkg_resources.parse_requirements(line)
+                    for requirement in requirements:
+                        requirement = str(requirement)
+                        try:
+                            pkg_resources.require(requirement)
+                        except pkg_resources.ResolutionError:
+                            if not yes:
+                                import traceback
+                                traceback.print_exc()
+                                input(f'Requirement {requirement} is not satisfied, press enter to install it')
+                            update_command()
+                            return
 
 
 if __name__ == "__main__":

MultiServer.py

@@ -13,25 +13,27 @@ import datetime
 import threading
 import random
 import pickle
+import itertools
+import time
 
 import ModuleUpdate
-import NetUtils
 
 ModuleUpdate.update()
 
 import websockets
 import colorama
-import prompt_toolkit
-from prompt_toolkit.patch_stdout import patch_stdout
+
 from fuzzywuzzy import process as fuzzy_process
 
+import NetUtils
 from worlds.AutoWorld import AutoWorldRegister
+
 proxy_worlds = {name: world(None, 0) for name, world in AutoWorldRegister.world_types.items()}
 from worlds import network_data_package, lookup_any_item_id_to_name, lookup_any_location_id_to_name
 import Utils
 from Utils import get_item_name_from_id, get_location_name_from_id, \
     version_tuple, restricted_loads, Version
-from NetUtils import Endpoint, ClientStatus, NetworkItem, decode, encode, NetworkPlayer
+from NetUtils import Endpoint, ClientStatus, NetworkItem, decode, encode, NetworkPlayer, Permission
 
 colorama.init()
 
@@ -43,7 +45,6 @@ class Client(Endpoint):
     def __init__(self, socket: websockets.WebSocketServerProtocol, ctx: Context):
         super().__init__(socket)
         self.auth = False
-        self.name = None
         self.team = None
         self.slot = None
         self.send_index = 0
@@ -51,6 +52,13 @@ class Client(Endpoint):
         self.messageprocessor = client_message_processor(ctx, self)
         self.ctx = weakref.ref(ctx)
 
+    @property
+    def name(self) -> str:
+        ctx = self.ctx()
+        if ctx:
+            return ctx.player_names[self.team, self.slot]
+        return "Deallocated"
+
 
 team_slot = typing.Tuple[int, int]
 
@@ -65,15 +73,21 @@ class Context:
                       "password": str,
                       "forfeit_mode": str,
                       "remaining_mode": str,
+                      "collect_mode": str,
                       "item_cheat": bool,
                       "compatibility": int}
+    # team -> slot id -> list of clients authenticated to slot.
+    clients: typing.Dict[int, typing.Dict[int, typing.List[Client]]]
+    locations: typing.Dict[int, typing.Dict[int, typing.Tuple[int, int]]]
 
     def __init__(self, host: str, port: int, server_password: str, password: str, location_check_points: int,
-                 hint_cost: int, item_cheat: bool, forfeit_mode: str = "disabled", remaining_mode: str = "disabled",
-                 auto_shutdown: typing.SupportsFloat = 0, compatibility: int = 2, log_network: bool = False):
+                 hint_cost: int, item_cheat: bool, forfeit_mode: str = "disabled", collect_mode="disabled",
+                 remaining_mode: str = "disabled", auto_shutdown: typing.SupportsFloat = 0, compatibility: int = 2,
+                 log_network: bool = False):
         super(Context, self).__init__()
         self.log_network = log_network
         self.endpoints = []
+        self.clients = {}
         self.compatibility: int = compatibility
         self.shutdown_task = None
         self.data_filename = None
@@ -84,7 +98,9 @@ class Context:
         self.connect_names = {}  # names of slots clients can connect to
         self.allow_forfeits = {}
         self.remote_items = set()
-        self.locations: typing.Dict[int, typing.Dict[int, typing.Tuple[int, int]]] = {}
+        self.remote_start_inventory = set()
+        #                          player          location_id     item_id  target_player_id
+        self.locations = {}
         self.host = host
         self.port = port
         self.server_password = server_password
@@ -100,8 +116,9 @@ class Context:
         self.hints: typing.Dict[team_slot, typing.Set[NetUtils.Hint]] = collections.defaultdict(set)
         self.forfeit_mode: str = forfeit_mode
         self.remaining_mode: str = remaining_mode
+        self.collect_mode: str = collect_mode
         self.item_cheat = item_cheat
-        self.running = True
+        self.exit_event = asyncio.Event()
         self.client_activity_timers: typing.Dict[
             team_slot, datetime.datetime] = {}  # datetime of last new item check
         self.client_connection_timers: typing.Dict[
@@ -150,21 +167,39 @@ class Context:
                 logging.info(f"Outgoing message: {msg}")
             return True
 
-    def broadcast_all(self, msgs):
-        msgs = self.dumper(msgs)
-        for endpoint in self.endpoints:
-            if endpoint.auth:
-                asyncio.create_task(self.send_encoded_msgs(endpoint, msgs))
+    async def broadcast_send_encoded_msgs(self, endpoints: typing.Iterable[Endpoint], msg: str) -> bool:
+        sockets = []
+        for endpoint in endpoints:
+            if endpoint.socket and endpoint.socket.open:
+                sockets.append(endpoint.socket)
+        try:
+            websockets.broadcast(sockets, msg)
+        except RuntimeError:
+            logging.exception("Exception during broadcast_send_encoded_msgs")
+        else:
+            if self.log_network:
+                logging.info(f"Outgoing broadcast: {msg}")
+            return True
 
-    def broadcast_team(self, team, msgs):
+    def broadcast_all(self, msgs: typing.List[dict]):
         msgs = self.dumper(msgs)
-        for client in self.endpoints:
-            if client.auth and client.team == team:
-                asyncio.create_task(self.send_encoded_msgs(client, msgs))
+        endpoints = (endpoint for endpoint in self.endpoints if endpoint.auth)
+        asyncio.create_task(self.broadcast_send_encoded_msgs(endpoints, msgs))
 
-    async def disconnect(self, endpoint):
+    def broadcast_team(self, team: int, msgs: typing.List[dict]):
+        msgs = self.dumper(msgs)
+        endpoints = (endpoint for endpoint in itertools.chain.from_iterable(self.clients[team].values()))
+        asyncio.create_task(self.broadcast_send_encoded_msgs(endpoints, msgs))
+
+    def broadcast(self, endpoints: typing.Iterable[Client], msgs: typing.List[dict]):
+        msgs = self.dumper(msgs)
+        asyncio.create_task(self.broadcast_send_encoded_msgs(endpoints, msgs))
+
+    async def disconnect(self, endpoint: Client):
         if endpoint in self.endpoints:
             self.endpoints.remove(endpoint)
+        if endpoint.slot and endpoint in self.clients[endpoint.team][endpoint.slot]:
+            self.clients[endpoint.team][endpoint.slot].remove(endpoint)
         await on_client_disconnected(self, endpoint)
 
     # text
@@ -221,14 +256,18 @@ class Context:
         for player, version in clients_ver.items():
             self.minimum_client_versions[player] = Utils.Version(*version)
 
+        self.clients = {}
         for team, names in enumerate(decoded_obj['names']):
+            self.clients[team] = {}
             for player, name in enumerate(names, 1):
+                self.clients[team][player] = []
                 self.player_names[team, player] = name
                 self.player_name_lookup[name] = team, player
         self.seed_name = decoded_obj["seed_name"]
         self.random.seed(self.seed_name)
         self.connect_names = decoded_obj['connect_names']
         self.remote_items = decoded_obj['remote_items']
+        self.remote_start_inventory = decoded_obj.get('remote_start_inventory', decoded_obj['remote_items'])
         self.locations = decoded_obj['locations']
         self.slot_data = decoded_obj['slot_data']
         self.er_hint_data = {int(player): {int(address): name for address, name in loc_data.items()}
@@ -237,10 +276,15 @@ class Context:
         # award remote-items start inventory:
         for team in range(len(decoded_obj['names'])):
             for slot, item_codes in decoded_obj["precollected_items"].items():
-                if slot in self.remote_items:
+                if slot in self.remote_start_inventory:
                     self.received_items[team, slot] = [NetworkItem(item_code, -2, 0) for item_code in item_codes]
             for slot, hints in decoded_obj["precollected_hints"].items():
                 self.hints[team, slot].update(hints)
+        # declare slots without checks as done, as they're assumed to be spectators
+        for slot, locations in self.locations.items():
+            if not locations:
+                for team in self.clients:
+                    self.client_game_state[team, slot] = ClientStatus.CLIENT_GOAL
         if use_embedded_server_options:
             server_options = decoded_obj.get("server_options", {})
             self._set_options(server_options)
@@ -275,7 +319,7 @@ class Context:
             if not self.save_filename:
                 import os
                 name, ext = os.path.splitext(self.data_filename)
-                self.save_filename = name + '.apsave' if ext.lower() in ('.archipelago','.zip') \
+                self.save_filename = name + '.apsave' if ext.lower() in ('.archipelago', '.zip') \
                     else self.data_filename + '_' + 'apsave'
             try:
                 with open(self.save_filename, 'rb') as f:
@@ -291,7 +335,7 @@ class Context:
         if not self.auto_saver_thread:
             def save_regularly():
                 import time
-                while self.running:
+                while not self.exit_event.is_set():
                     time.sleep(self.auto_save_interval)
                     if self.save_dirty:
                         logging.debug("Saving via thread.")
@@ -386,6 +430,17 @@ class Context:
         else:
             return self.player_names[team, slot]
 
+    def on_goal_achieved(self, client: Client):
+        finished_msg = f'{self.get_aliased_name(client.team, client.slot)} (Team #{client.team + 1})' \
+                       f' has completed their goal.'
+        self.notify_all(finished_msg)
+        if "auto" in self.forfeit_mode:
+            forfeit_player(self, client.team, client.slot)
+        elif proxy_worlds[self.games[client.slot]].forced_auto_forfeit:
+            forfeit_player(self, client.team, client.slot)
+        if "auto" in self.collect_mode:
+            collect_player(self, client.team, client.slot)
+
 
 def notify_hints(ctx: Context, team: int, hints: typing.List[NetUtils.Hint]):
     concerns = collections.defaultdict(list)
@@ -397,25 +452,23 @@ def notify_hints(ctx: Context, team: int, hints: typing.List[NetUtils.Hint]):
     for text in (format_hint(ctx, team, hint) for hint in hints):
         logging.info("Notice (Team #%d): %s" % (team + 1, text))
 
-    for client in ctx.endpoints:
-        if client.auth and client.team == team:
-            client_hints = concerns[client.slot]
-            if client_hints:
+    for slot, clients in ctx.clients[team].items():
+        client_hints = concerns[slot]
+        if client_hints:
+            for client in clients:
                 asyncio.create_task(ctx.send_msgs(client, client_hints))
 
 
-def update_aliases(ctx: Context, team: int, client: typing.Optional[Client] = None):
+def update_aliases(ctx: Context, team: int):
     cmd = ctx.dumper([{"cmd": "RoomUpdate",
                        "players": ctx.get_players_package()}])
-    if client is None:
-        for client in ctx.endpoints:
-            if client.team == team and client.auth:
-                asyncio.create_task(ctx.send_encoded_msgs(client, cmd))
-    else:
-        asyncio.create_task(ctx.send_encoded_msgs(client, cmd))
+
+    for clients in ctx.clients[team].values():
+        for client in clients:
+            asyncio.create_task(ctx.send_encoded_msgs(client, cmd))
 
 
-async def server(websocket, path, ctx: Context):
+async def server(websocket, path: str = "/", ctx: Context = None):
     client = Client(websocket, ctx)
     ctx.endpoints.append(client)
 
@@ -440,28 +493,43 @@ async def server(websocket, path, ctx: Context):
 
 
 async def on_client_connected(ctx: Context, client: Client):
+    players = []
+    for team, clients in ctx.clients.items():
+        for slot, connected_clients in clients.items():
+            if connected_clients:
+                name = ctx.player_names[team, slot]
+                players.append(
+                    NetworkPlayer(team, slot,
+                                  ctx.name_aliases.get((team, slot), name), name)
+                )
     await ctx.send_msgs(client, [{
         'cmd': 'RoomInfo',
-        'password': ctx.password is not None,
-        'players': [
-            NetworkPlayer(client.team, client.slot, ctx.name_aliases.get((client.team, client.slot), client.name),
-                          client.name) for client
-            in ctx.endpoints if client.auth],
+        'password': bool(ctx.password),
+        'players': players,
+        'games': [ctx.games[x] for x in range(1, len(ctx.games) + 1)],
         # tags are for additional features in the communication.
         # Name them by feature or fork, as you feel is appropriate.
         'tags': ctx.tags,
         'version': Utils.version_tuple,
-        'forfeit_mode': ctx.forfeit_mode,
-        'remaining_mode': ctx.remaining_mode,
+        'permissions': get_permissions(ctx),
         'hint_cost': ctx.hint_cost,
         'location_check_points': ctx.location_check_points,
         'datapackage_version': network_data_package["version"],
         'datapackage_versions': {game: game_data["version"] for game, game_data
                                  in network_data_package["games"].items()},
-        'seed_name': ctx.seed_name
+        'seed_name': ctx.seed_name,
+        'time': time.time(),
     }])
 
 
+def get_permissions(ctx) -> typing.Dict[str, Permission]:
+    return {
+        "forfeit": Permission.from_text(ctx.forfeit_mode),
+        "remaining": Permission.from_text(ctx.remaining_mode),
+        "collect": Permission.from_text(ctx.collect_mode)
+    }
+
+
 async def on_client_disconnected(ctx: Context, client: Client):
     if client.auth:
         await on_client_left(ctx, client)
@@ -470,9 +538,10 @@ async def on_client_disconnected(ctx: Context, client: Client):
 async def on_client_joined(ctx: Context, client: Client):
     update_client_status(ctx, client, ClientStatus.CLIENT_CONNECTED)
     version_str = '.'.join(str(x) for x in client.version)
+    verb = "tracking" if "Tracker" in client.tags else "playing"
     ctx.notify_all(
         f"{ctx.get_aliased_name(client.team, client.slot)} (Team #{client.team + 1}) "
-        f"playing {ctx.games[client.slot]} has joined. "
+        f"{verb} {ctx.games[client.slot]} has joined. "
         f"Client({version_str}), {client.tags}).")
 
     ctx.client_connection_timers[client.team, client.slot] = datetime.datetime.now(datetime.timezone.utc)
@@ -517,27 +586,61 @@ def get_players_string(ctx: Context):
     return f'{len(auth_clients)} players of {len(ctx.player_names)} connected ' + text[:-1]
 
 
+def get_status_string(ctx: Context, team: int):
+    text = "Player Status on your team:"
+    for slot in ctx.locations:
+        connected = len(ctx.clients[team][slot])
+        death_link = len([client for client in ctx.clients[team][slot] if "DeathLink" in client.tags])
+        completion_text = f"({len(ctx.location_checks[team, slot])}/{len(ctx.locations[slot])})"
+        death_text = f" {death_link} of which are death link" if connected else ""
+        goal_text = " and has finished." if ctx.client_game_state[team, slot] == ClientStatus.CLIENT_GOAL else "."
+        text += f"\n{ctx.get_aliased_name(team, slot)} has {connected} connection{'' if connected == 1 else 's'}" \
+                f"{death_text}{goal_text} {completion_text}"
+    return text
+
+
 def get_received_items(ctx: Context, team: int, player: int) -> typing.List[NetworkItem]:
     return ctx.received_items.setdefault((team, player), [])
 
 
 def send_new_items(ctx: Context):
-    for client in ctx.endpoints:
-        if client.auth:  # can't send to disconnected client
-            items = get_received_items(ctx, client.team, client.slot)
-            if len(items) > client.send_index:
-                asyncio.create_task(ctx.send_msgs(client, [{
-                    "cmd": "ReceivedItems",
-                    "index": client.send_index,
-                    "items": items[client.send_index:]}]))
-                client.send_index = len(items)
+    for team, clients in ctx.clients.items():
+        for slot, clients in clients.items():
+            items = get_received_items(ctx, team, slot)
+            for client in clients:
+                if len(items) > client.send_index:
+                    asyncio.create_task(ctx.send_msgs(client, [{
+                        "cmd": "ReceivedItems",
+                        "index": client.send_index,
+                        "items": items[client.send_index:]}]))
+                    client.send_index = len(items)
+
+
+def update_checked_locations(ctx: Context, team: int, slot: int):
+    ctx.broadcast(ctx.clients[team][slot],
+                  [{"cmd": "RoomUpdate", "checked_locations": get_checked_checks(ctx, team, slot)}])
 
 
 def forfeit_player(ctx: Context, team: int, slot: int):
-    # register any locations that are in the multidata
+    """register any locations that are in the multidata"""
     all_locations = set(ctx.locations[slot])
     ctx.notify_all("%s (Team #%d) has forfeited" % (ctx.player_names[(team, slot)], team + 1))
     register_location_checks(ctx, team, slot, all_locations)
+    update_checked_locations(ctx, team, slot)
+
+
+def collect_player(ctx: Context, team: int, slot: int):
+    """register any locations that are in the multidata, pointing towards this player"""
+    all_locations = collections.defaultdict(set)
+    for source_slot, location_data in ctx.locations.items():
+        for location_id, (item_id, target_player_id) in location_data.items():
+            if target_player_id == slot:
+                all_locations[source_slot].add(location_id)
+
+    ctx.notify_all("%s (Team #%d) has collected" % (ctx.player_names[(team, slot)], team + 1))
+    for source_player, location_ids in all_locations.items():
+        register_location_checks(ctx, team, source_player, location_ids)
+        update_checked_locations(ctx, team, source_player)
 
 
 def get_remaining(ctx: Context, team: int, slot: int) -> typing.List[int]:
@@ -550,27 +653,28 @@ def get_remaining(ctx: Context, team: int, slot: int) -> typing.List[int]:
 
 def register_location_checks(ctx: Context, team: int, slot: int, locations: typing.Iterable[int]):
     new_locations = set(locations) - ctx.location_checks[team, slot]
+    new_locations.intersection_update(ctx.locations[slot])  # ignore location IDs unknown to this multidata
     if new_locations:
         ctx.client_activity_timers[team, slot] = datetime.datetime.now(datetime.timezone.utc)
         for location in new_locations:
-            if location in ctx.locations[slot]:
-                item_id, target_player = ctx.locations[slot][location]
-                new_item = NetworkItem(item_id, location, slot)
-                if target_player != slot or slot in ctx.remote_items:
-                    get_received_items(ctx, team, target_player).append(new_item)
+            item_id, target_player = ctx.locations[slot][location]
+            new_item = NetworkItem(item_id, location, slot)
+            if target_player != slot or slot in ctx.remote_items:
+                get_received_items(ctx, team, target_player).append(new_item)
 
-                logging.info('(Team #%d) %s sent %s to %s (%s)' % (
-                    team + 1, ctx.player_names[(team, slot)], get_item_name_from_id(item_id),
-                    ctx.player_names[(team, target_player)], get_location_name_from_id(location)))
-                info_text = json_format_send_event(new_item, target_player)
-                ctx.broadcast_team(team, [info_text])
+            logging.info('(Team #%d) %s sent %s to %s (%s)' % (
+                team + 1, ctx.player_names[(team, slot)], get_item_name_from_id(item_id),
+                ctx.player_names[(team, target_player)], get_location_name_from_id(location)))
+            info_text = json_format_send_event(new_item, target_player)
+            ctx.broadcast_team(team, [info_text])
 
         ctx.location_checks[team, slot] |= new_locations
         send_new_items(ctx)
-        for client in ctx.endpoints:
-            if client.team == team and client.slot == slot:
-                asyncio.create_task(ctx.send_msgs(client, [{"cmd": "RoomUpdate",
-                                                            "hint_points": get_client_points(ctx, client)}]))
+        ctx.broadcast(ctx.clients[team][slot], [{
+            "cmd": "RoomUpdate",
+            "hint_points": get_slot_points(ctx, team, slot),
+            "checked_locations": new_locations,  # send back new checks only
+        }])
 
         ctx.save()
 
@@ -620,15 +724,15 @@ def json_format_send_event(net_item: NetworkItem, receiving_player: int):
     NetUtils.add_json_text(parts, net_item.player, type=NetUtils.JSONTypes.player_id)
     if net_item.player == receiving_player:
         NetUtils.add_json_text(parts, " found their ")
-        NetUtils.add_json_text(parts, net_item.item, type=NetUtils.JSONTypes.item_id)
+        NetUtils.add_json_item(parts, net_item.item, net_item.player)
     else:
         NetUtils.add_json_text(parts, " sent ")
-        NetUtils.add_json_text(parts, net_item.item, type=NetUtils.JSONTypes.item_id)
+        NetUtils.add_json_item(parts, net_item.item, receiving_player)
         NetUtils.add_json_text(parts, " to ")
         NetUtils.add_json_text(parts, receiving_player, type=NetUtils.JSONTypes.player_id)
 
     NetUtils.add_json_text(parts, " (")
-    NetUtils.add_json_text(parts, net_item.location, type=NetUtils.JSONTypes.location_id)
+    NetUtils.add_json_location(parts, net_item.location, net_item.player)
     NetUtils.add_json_text(parts, ")")
 
     return {"cmd": "PrintJSON", "data": parts, "type": "ItemSend",
@@ -842,6 +946,11 @@ class ClientMessageProcessor(CommonCommandProcessor):
             self.output(get_players_string(self.ctx))
         return True
 
+    def _cmd_status(self) -> bool:
+        """Get status information about your team."""
+        self.output(get_status_string(self.ctx, self.client.team))
+        return True
+
     def _cmd_forfeit(self) -> bool:
         """Surrender and send your remaining items out to their recipients"""
         if self.ctx.allow_forfeits.get((self.client.team, self.client.slot), False):
@@ -864,6 +973,25 @@ class ClientMessageProcessor(CommonCommandProcessor):
                     " You can ask the server admin for a /forfeit")
                 return False
 
+    def _cmd_collect(self) -> bool:
+        """Send your remaining items to yourself"""
+        if "enabled" in self.ctx.collect_mode:
+            collect_player(self.ctx, self.client.team, self.client.slot)
+            return True
+        elif "disabled" in self.ctx.collect_mode:
+            self.output(
+                "Sorry, client collecting has been disabled on this server. You can ask the server admin for a /collect")
+            return False
+        else:  # is auto or goal
+            if self.ctx.client_game_state[self.client.team, self.client.slot] == ClientStatus.CLIENT_GOAL:
+                collect_player(self.ctx, self.client.team, self.client.slot)
+                return True
+            else:
+                self.output(
+                    "Sorry, client collecting requires you to have beaten the game on this server."
+                    " You can ask the server admin for a /collect")
+                return False
+
     def _cmd_remaining(self) -> bool:
         """List remaining items in your game, but not their location or recipient"""
         if self.ctx.remaining_mode == "enabled":
@@ -895,7 +1023,7 @@ class ClientMessageProcessor(CommonCommandProcessor):
     def _cmd_missing(self) -> bool:
         """List all missing location checks from the server's perspective"""
 
-        locations = get_missing_checks(self.ctx, self.client)
+        locations = get_missing_checks(self.ctx, self.client.team, self.client.slot)
 
         if locations:
             texts = [f'Missing: {get_location_name_from_id(location)}' for location in locations]
@@ -905,6 +1033,19 @@ class ClientMessageProcessor(CommonCommandProcessor):
             self.output("No missing location checks found.")
         return True
 
+    def _cmd_checked(self) -> bool:
+        """List all done location checks from the server's perspective"""
+
+        locations = get_checked_checks(self.ctx, self.client.team, self.client.slot)
+
+        if locations:
+            texts = [f'Checked: {get_location_name_from_id(location)}' for location in locations]
+            texts.append(f"Found {len(locations)} done location checks")
+            self.ctx.notify_client_multiple(self.client, texts)
+        else:
+            self.output("No done location checks found.")
+        return True
+
     @mark_raw
     def _cmd_alias(self, alias_name: str = ""):
         """Set your alias to the passed name."""
@@ -945,14 +1086,9 @@ class ClientMessageProcessor(CommonCommandProcessor):
             self.output("Cheating is disabled.")
             return False
 
-    @mark_raw
-    def _cmd_hint(self, item_or_location: str = "") -> bool:
-        """Use !hint {item_name/location_name},
-        for example !hint Lamp or !hint Link's House to get a spoiler peek for that location or item.
-        If hint costs are on, this will only give you one new result,
-        you can rerun the command to get more in that case."""
+    def get_hints(self, input_text: str, explicit_location: bool = False) -> bool:
         points_available = get_client_points(self.ctx, self.client)
-        if not item_or_location:
+        if not input_text:
             hints = {hint.re_check(self.ctx, self.client.team) for hint in
                      self.ctx.hints[self.client.team, self.client.slot]}
             self.ctx.hints[self.client.team, self.client.slot] = hints
@@ -962,16 +1098,17 @@ class ClientMessageProcessor(CommonCommandProcessor):
             return True
         else:
             world = proxy_worlds[self.ctx.games[self.client.slot]]
-            item_name, usable, response = get_intended_text(item_or_location, world.all_names)
+            item_name, usable, response = get_intended_text(input_text,
+                                                            world.all_names if not explicit_location else world.location_names)
             if usable:
                 if item_name in world.hint_blacklist:
                     self.output(f"Sorry, \"{item_name}\" is marked as non-hintable.")
                     hints = []
-                elif item_name in world.item_name_groups:
+                elif item_name in world.item_name_groups and not explicit_location:
                     hints = []
                     for item in world.item_name_groups[item_name]:
                         hints.extend(collect_hints(self.ctx, self.client.team, self.client.slot, item))
-                elif item_name in world.item_names:  # item name
+                elif item_name in world.item_names and not explicit_location:  # item name
                     hints = collect_hints(self.ctx, self.client.team, self.client.slot, item_name)
                 else:  # location name
                     hints = collect_hints_location(self.ctx, self.client.team, self.client.slot, item_name)
@@ -1004,19 +1141,25 @@ class ClientMessageProcessor(CommonCommandProcessor):
                             hints.append(hint)
                             can_pay -= 1
                             self.ctx.hints_used[self.client.team, self.client.slot] += 1
+                            points_available = get_client_points(self.ctx, self.client)
 
                             if not hint.found:
                                 self.ctx.hints[self.client.team, hint.finding_player].add(hint)
                                 self.ctx.hints[self.client.team, hint.receiving_player].add(hint)
 
                         if not_found_hints:
-                            if hints:
+                            if hints and cost and int((points_available // cost) == 0):
+                                self.output(
+                                    f"There may be more hintables, however, you cannot afford to pay for any more. "
+                                    f" You have {points_available} and need at least "
+                                    f"{self.ctx.get_hint_cost(self.client.slot)}.")
+                            elif hints:
                                 self.output(
                                     "There may be more hintables, you can rerun the command to find more.")
                             else:
                                 self.output(f"You can't afford the hint. "
                                             f"You have {points_available} points and need at least "
-                                            f"{self.ctx.get_hint_cost(self.client.slot)}")
+                                            f"{self.ctx.get_hint_cost(self.client.slot)}.")
                         notify_hints(self.ctx, self.client.team, hints)
                         self.ctx.save()
                         return True
@@ -1028,17 +1171,33 @@ class ClientMessageProcessor(CommonCommandProcessor):
                 self.output(response)
                 return False
 
+    @mark_raw
+    def _cmd_hint(self, item_or_location: str = "") -> bool:
+        """Use !hint {item_name/location_name},
+        for example !hint Lamp or !hint Link's House to get a spoiler peek for that location or item.
+        If hint costs are on, this will only give you one new result,
+        you can rerun the command to get more in that case."""
+        return self.get_hints(item_or_location)
 
-def get_checked_checks(ctx: Context, client: Client) -> typing.List[int]:
+    @mark_raw
+    def _cmd_hint_location(self, location: str = "") -> bool:
+        """Use !hint_location {location_name},
+        for example !hint_location atomic-bomb to get a spoiler peek for that location.
+        (In the case of factorio, or any other game where item names and location names are identical,
+        this command must be used explicitly.)"""
+        return self.get_hints(location, True)
+
+
+def get_checked_checks(ctx: Context, team: int, slot: int) -> typing.List[int]:
     return [location_id for
-            location_id in ctx.locations[client.slot] if
-            location_id in ctx.location_checks[client.team, client.slot]]
+            location_id in ctx.locations[slot] if
+            location_id in ctx.location_checks[team, slot]]
 
 
-def get_missing_checks(ctx: Context, client: Client) -> typing.List[int]:
+def get_missing_checks(ctx: Context, team: int, slot: int) -> typing.List[int]:
     return [location_id for
-            location_id in ctx.locations[client.slot] if
-            location_id not in ctx.location_checks[client.team, client.slot]]
+            location_id in ctx.locations[slot] if
+            location_id not in ctx.location_checks[team, slot]]
 
 
 def get_client_points(ctx: Context, client: Client) -> int:
@@ -1046,24 +1205,30 @@ def get_client_points(ctx: Context, client: Client) -> int:
             ctx.get_hint_cost(client.slot) * ctx.hints_used[client.team, client.slot])
 
 
+def get_slot_points(ctx: Context, team: int, slot: int) -> int:
+    return (ctx.location_check_points * len(ctx.location_checks[team, slot]) -
+            ctx.get_hint_cost(slot) * ctx.hints_used[team, slot])
+
+
 async def process_client_cmd(ctx: Context, client: Client, args: dict):
     try:
         cmd: str = args["cmd"]
     except:
         logging.exception(f"Could not get command from {args}")
-        await ctx.send_msgs(client, [{'cmd': 'InvalidPacket', "type": "cmd",
+        await ctx.send_msgs(client, [{'cmd': 'InvalidPacket', "type": "cmd", "original_cmd": None,
                                       "text": f"Could not get command from {args} at `cmd`"}])
         raise
 
     if type(cmd) is not str:
-        await ctx.send_msgs(client, [{'cmd': 'InvalidPacket', "type": "cmd",
+        await ctx.send_msgs(client, [{'cmd': 'InvalidPacket', "type": "cmd", "original_cmd": None,
                                       "text": f"Command should be str, got {type(cmd)}"}])
         return
 
     if cmd == 'Connect':
         if not args or 'password' not in args or type(args['password']) not in [str, type(None)] or \
                 'game' not in args:
-            await ctx.send_msgs(client, [{'cmd': 'InvalidPacket', "type": "arguments", 'text': 'Connect'}])
+            await ctx.send_msgs(client, [{'cmd': 'InvalidPacket', "type": "arguments", 'text': 'Connect',
+                                          "original_cmd": cmd}])
             return
 
         errors = set()
@@ -1076,28 +1241,11 @@ async def process_client_cmd(ctx: Context, client: Client, args: dict):
         else:
             team, slot = ctx.connect_names[args['name']]
             game = ctx.games[slot]
-            if args['game'] != game:
-                errors.add('InvalidSlot')
-            # this can only ever be 0 or 1 elements
-            clients = [c for c in ctx.endpoints if c.auth and c.slot == slot and c.team == team]
-            if clients:
-                # likely same player with a "ghosted" slot. We bust the ghost.
-                if "uuid" in args and ctx.client_ids[team, slot] == args["uuid"]:
-                    await ctx.send_msgs(clients[0], [{"cmd": "Print", "text": "You are getting kicked "
-                                                                              "by yourself reconnecting."}])
-                    await clients[0].socket.close()  # we have to await the DC of the ghost, so not to create data pasta
-                    client.name = ctx.player_names[(team, slot)]
-                    client.team = team
-                    client.slot = slot
-                else:
-                    errors.add('SlotAlreadyTaken')
-            else:
-                client.name = ctx.player_names[(team, slot)]
-                client.team = team
-                client.slot = slot
-                minver = ctx.minimum_client_versions[slot]
-                if minver > args['version']:
-                    errors.add('IncompatibleVersion')
+            if "IgnoreGame" not in args["tags"] and args['game'] != game:
+                errors.add('InvalidGame')
+            minver = ctx.minimum_client_versions[slot]
+            if minver > args['version']:
+                errors.add('IncompatibleVersion')
 
         # only exact version match allowed
         if ctx.compatibility == 0 and args['version'] != version_tuple:
@@ -1106,30 +1254,40 @@ async def process_client_cmd(ctx: Context, client: Client, args: dict):
             logging.info(f"A client connection was refused due to: {errors}, the sent connect information was {args}.")
             await ctx.send_msgs(client, [{"cmd": "ConnectionRefused", "errors": list(errors)}])
         else:
+            team, slot = ctx.connect_names[args['name']]
+            if client.auth and client.team is not None and client.slot in ctx.clients[client.team]:
+                ctx.clients[team][slot].remove(client)  # re-auth, remove old entry
+                if client.team != team or client.slot != slot:
+                    client.auth = False  # swapping Team/Slot
+            client.team = team
+            client.slot = slot
+
             ctx.client_ids[client.team, client.slot] = args["uuid"]
-            client.auth = True
+            ctx.clients[team][slot].append(client)
             client.version = args['version']
             client.tags = args['tags']
             reply = [{
                 "cmd": "Connected",
                 "team": client.team, "slot": client.slot,
                 "players": ctx.get_players_package(),
-                "missing_locations": get_missing_checks(ctx, client),
-                "checked_locations": get_checked_checks(ctx, client),
-                # get is needed for old multidata that was sparsely populated
-                "slot_data": ctx.slot_data.get(client.slot, {})
+                "missing_locations": get_missing_checks(ctx, team, slot),
+                "checked_locations": get_checked_checks(ctx, team, slot),
+                "slot_data": ctx.slot_data[client.slot]
             }]
             items = get_received_items(ctx, client.team, client.slot)
             if items:
                 reply.append({"cmd": 'ReceivedItems', "index": 0, "items": items})
                 client.send_index = len(items)
+            if not client.auth:  # if this was a Re-Connect, don't print to console
+                client.auth = True
+                await on_client_joined(ctx, client)
 
             await ctx.send_msgs(client, reply)
-            await on_client_joined(ctx, client)
 
     elif cmd == "GetDataPackage":
-        exclusions = set(args.get("exclusions", []))
+        exclusions = args.get("exclusions", [])
         if exclusions:
+            exclusions = set(exclusions)
             games = {name: game_data for name, game_data in network_data_package["games"].items()
                      if name not in exclusions}
             package = network_data_package.copy()
@@ -1139,8 +1297,23 @@ async def process_client_cmd(ctx: Context, client: Client, args: dict):
         else:
             await ctx.send_msgs(client, [{"cmd": "DataPackage",
                                           "data": network_data_package}])
+
     elif client.auth:
-        if cmd == 'Sync':
+        if cmd == "ConnectUpdate":
+            if not args:
+                await ctx.send_msgs(client, [{'cmd': 'InvalidPacket', "type": "arguments", 'text': cmd,
+                                              "original_cmd": cmd}])
+                return
+
+            if "tags" in args:
+                old_tags = client.tags
+                client.tags = args["tags"]
+                if set(old_tags) != set(client.tags):
+                    ctx.notify_all(
+                        f"{ctx.get_aliased_name(client.team, client.slot)} (Team #{client.team + 1}) has changed tags "
+                        f"from {old_tags} to {client.tags}.")
+
+        elif cmd == 'Sync':
             items = get_received_items(ctx, client.team, client.slot)
             if items:
                 client.send_index = len(items)
@@ -1148,13 +1321,20 @@ async def process_client_cmd(ctx: Context, client: Client, args: dict):
                                               "items": items}])
 
         elif cmd == 'LocationChecks':
-            register_location_checks(ctx, client.team, client.slot, args["locations"])
+            if "Tracker" in client.tags:
+                await ctx.send_msgs(client, [{'cmd': 'InvalidPacket', "type": "cmd",
+                                              "text": "Trackers can't register new Location Checks",
+                                              "original_cmd": cmd}])
+            else:
+                register_location_checks(ctx, client.team, client.slot, args["locations"])
 
         elif cmd == 'LocationScouts':
             locs = []
             for location in args["locations"]:
                 if type(location) is not int or location not in lookup_any_location_id_to_name:
-                    await ctx.send_msgs(client, [{'cmd': 'InvalidPacket', "type": "arguments", "text": 'LocationScouts'}])
+                    await ctx.send_msgs(client,
+                                        [{'cmd': 'InvalidPacket', "type": "arguments", "text": 'LocationScouts',
+                                          "original_cmd": cmd}])
                     return
                 target_item, target_player = ctx.locations[client.slot][location]
                 locs.append(NetworkItem(target_item, location, target_player))
@@ -1166,7 +1346,8 @@ async def process_client_cmd(ctx: Context, client: Client, args: dict):
 
         elif cmd == 'Say':
             if "text" not in args or type(args["text"]) is not str or not args["text"].isprintable():
-                await ctx.send_msgs(client, [{'cmd': 'InvalidPacket', "type": "arguments", "text": 'Say'}])
+                await ctx.send_msgs(client, [{'cmd': 'InvalidPacket', "type": "arguments", "text": 'Say',
+                                              "original_cmd": cmd}])
                 return
 
             client.messageprocessor(args["text"])
@@ -1189,12 +1370,7 @@ def update_client_status(ctx: Context, client: Client, new_status: ClientStatus)
     current = ctx.client_game_state[client.team, client.slot]
     if current != ClientStatus.CLIENT_GOAL:  # can't undo goal completion
         if new_status == ClientStatus.CLIENT_GOAL:
-            finished_msg = f'{ctx.get_aliased_name(client.team, client.slot)} (Team #{client.team + 1}) has completed their goal.'
-            ctx.notify_all(finished_msg)
-            if "auto" in ctx.forfeit_mode:
-                forfeit_player(ctx, client.team, client.slot)
-            elif proxy_worlds[ctx.games[client.slot]].forced_auto_forfeit:
-                forfeit_player(ctx, client.team, client.slot)
+            ctx.on_goal_achieved(client)
 
         ctx.client_game_state[client.team, client.slot] = new_status
 
@@ -1212,20 +1388,6 @@ class ServerCommandProcessor(CommonCommandProcessor):
     def default(self, raw: str):
         self.ctx.notify_all('[Server]: ' + raw)
 
-    @mark_raw
-    def _cmd_kick(self, player_name: str) -> bool:
-        """Kick specified player from the server"""
-        for client in self.ctx.endpoints:
-            if client.auth and client.name.lower() == player_name.lower() and client.socket and not client.socket.closed:
-                asyncio.create_task(client.socket.close())
-                self.output(f"Kicked {self.ctx.get_aliased_name(client.team, client.slot)}")
-                if self.ctx.commandprocessor.client == client:
-                    self.ctx.commandprocessor.client = None
-                return True
-
-        self.output(f"Could not find player {player_name} to kick")
-        return False
-
     def _cmd_save(self) -> bool:
         """Save current state to multidata"""
         if self.ctx.saving:
@@ -1246,7 +1408,7 @@ class ServerCommandProcessor(CommonCommandProcessor):
         asyncio.create_task(self.ctx.server.ws_server._close())
         if self.ctx.shutdown_task:
             self.ctx.shutdown_task.cancel()
-        self.ctx.running = False
+        self.ctx.exit_event.set()
         return True
 
     @mark_raw
@@ -1274,9 +1436,21 @@ class ServerCommandProcessor(CommonCommandProcessor):
             self.output(response)
             return False
 
+    @mark_raw
+    def _cmd_collect(self, player_name: str) -> bool:
+        """Send out the remaining items to player."""
+        seeked_player = player_name.lower()
+        for (team, slot), name in self.ctx.player_names.items():
+            if name.lower() == seeked_player:
+                collect_player(self.ctx, team, slot)
+                return True
+
+        self.output(f"Could not find player {player_name} to collect")
+        return False
+
     @mark_raw
     def _cmd_forfeit(self, player_name: str) -> bool:
-        """Send out the remaining items from a player's game to their intended recipients"""
+        """Send out the remaining items from a player to their intended recipients"""
         seeked_player = player_name.lower()
         for (team, slot), name in self.ctx.player_names.items():
             if name.lower() == seeked_player:
@@ -1380,6 +1554,8 @@ class ServerCommandProcessor(CommonCommandProcessor):
                     return input_text
             setattr(self.ctx, option_name, attrtype(option))
             self.output(f"Set option {option_name} to {getattr(self.ctx, option_name)}")
+            if option_name in {"forfeit_mode", "remaining_mode", "collect_mode"}:
+                self.ctx.broadcast_all([{"cmd": "RoomUpdate", 'permissions': get_permissions(self.ctx)}])
             return True
         else:
             known = (f"{option}:{otype}" for option, otype in self.ctx.simple_options.items())
@@ -1389,11 +1565,17 @@ class ServerCommandProcessor(CommonCommandProcessor):
 
 
 async def console(ctx: Context):
-    session = prompt_toolkit.PromptSession()
-    while ctx.running:
-        with patch_stdout():
-            input_text = await session.prompt_async()
+    import sys
+    queue = asyncio.Queue()
+    Utils.stream_input(sys.stdin, queue)
+    while not ctx.exit_event.is_set():
         try:
+            # I don't get why this while loop is needed. Works fine without it on clients,
+            # but the queue.get() for server never fulfills if the queue is empty when entering the await.
+            while queue.qsize() == 0:
+                await asyncio.sleep(0.05)
+            input_text = await queue.get()
+            queue.task_done()
             ctx.commandprocessor(input_text)
         except:
             import traceback
@@ -1424,6 +1606,15 @@ def parse_args() -> argparse.Namespace:
                              goal:     !forfeit can be used after goal completion
                              auto-enabled: !forfeit is available and automatically triggered on goal completion
                              ''')
+    parser.add_argument('--collect_mode', default=defaults["collect_mode"], nargs='?',
+                        choices=['auto', 'enabled', 'disabled', "goal", "auto-enabled"], help='''\
+                             Select !collect Accessibility. (default: %(default)s)
+                             auto:     Automatic "collect" on goal completion
+                             enabled:  !collect is always available
+                             disabled: !collect is never available
+                             goal:     !collect can be used after goal completion
+                             auto-enabled: !collect is available and automatically triggered on goal completion
+                             ''')
     parser.add_argument('--remaining_mode', default=defaults["remaining_mode"], nargs='?',
                         choices=['enabled', 'disabled', "goal"], help='''\
                              Select !remaining Accessibility. (default: %(default)s)
@@ -1450,10 +1641,10 @@ def parse_args() -> argparse.Namespace:
 
 async def auto_shutdown(ctx, to_cancel=None):
     await asyncio.sleep(ctx.auto_shutdown)
-    while ctx.running:
+    while not ctx.exit_event.is_set():
         if not ctx.client_activity_timers.values():
             asyncio.create_task(ctx.server.ws_server._close())
-            ctx.running = False
+            ctx.exit_event.set()
             if to_cancel:
                 for task in to_cancel:
                     task.cancel()
@@ -1464,7 +1655,7 @@ async def auto_shutdown(ctx, to_cancel=None):
             seconds = ctx.auto_shutdown - delta.total_seconds()
             if seconds < 0:
                 asyncio.create_task(ctx.server.ws_server._close())
-                ctx.running = False
+                ctx.exit_event.set()
                 if to_cancel:
                     for task in to_cancel:
                         task.cancel()
@@ -1474,11 +1665,11 @@ async def auto_shutdown(ctx, to_cancel=None):
 
 
 async def main(args: argparse.Namespace):
-    logging.basicConfig(force=True,
-                        format='[%(asctime)s] %(message)s', level=getattr(logging, args.loglevel.upper(), logging.INFO))
+    Utils.init_logging("Server", loglevel=args.loglevel.lower())
 
     ctx = Context(args.host, args.port, args.server_password, args.password, args.location_check_points,
-                  args.hint_cost, not args.disable_item_cheat, args.forfeit_mode, args.remaining_mode,
+                  args.hint_cost, not args.disable_item_cheat, args.forfeit_mode, args.collect_mode,
+                  args.remaining_mode,
                   args.auto_shutdown, args.compatibility, args.log_network)
     data_filename = args.multidata
 
@@ -1498,7 +1689,7 @@ async def main(args: argparse.Namespace):
 
     ctx.init_save(not args.disable_save)
 
-    ctx.server = websockets.serve(functools.partial(server, ctx=ctx), ctx.host, ctx.port, ping_timeout=None,
+    ctx.server = websockets.serve(functools.partial(server, ctx=ctx), host=ctx.host, port=ctx.port, ping_timeout=None,
                                   ping_interval=None)
     ip = args.host if args.host else Utils.get_public_ipv4()
     logging.info('Hosting game at %s:%d (%s)' % (ip, ctx.port,
@@ -1508,7 +1699,8 @@ async def main(args: argparse.Namespace):
     console_task = asyncio.create_task(console(ctx))
     if ctx.auto_shutdown:
         ctx.shutdown_task = asyncio.create_task(auto_shutdown(ctx, [console_task]))
-    await console_task
+    await ctx.exit_event.wait()
+    console_task.cancel()
     if ctx.shutdown_task:
         await ctx.shutdown_task
 

NetUtils.py

@@ -1,4 +1,6 @@
 from __future__ import annotations
+
+import logging
 import typing
 import enum
 from json import JSONEncoder, JSONDecoder
@@ -13,8 +15,8 @@ class JSONMessagePart(typing.TypedDict, total=False):
     # optional
     type: str
     color: str
-    # mainly for items, optional
-    found: bool
+    # owning player for location/item
+    player: int
 
 
 class ClientStatus(enum.IntEnum):
@@ -25,6 +27,25 @@ class ClientStatus(enum.IntEnum):
     CLIENT_GOAL = 30
 
 
+class Permission(enum.IntEnum):
+    disabled = 0b000  # 0, completely disables access
+    enabled = 0b001  # 1, allows manual use
+    goal = 0b010  # 2, allows manual use after goal completion
+    auto = 0b110  # 6, forces use after goal completion, only works for forfeit
+    auto_enabled = 0b111  # 7, forces use after goal completion, allows manual use any time
+
+    @staticmethod
+    def from_text(text: str):
+        data = 0
+        if "auto" in text:
+            data |= 0b110
+        elif "goal" in text:
+            data |= 0b010
+        if "enabled" in text:
+            data |= 0b001
+        return Permission(data)
+
+
 class NetworkPlayer(typing.NamedTuple):
     team: int
     slot: int
@@ -43,7 +64,7 @@ def _scan_for_TypedTuples(obj: typing.Any) -> typing.Any:
         data = obj._asdict()
         data["class"] = obj.__class__.__name__
         return data
-    if isinstance(obj, (tuple, list)):
+    if isinstance(obj, (tuple, list, set)):
         return tuple(_scan_for_TypedTuples(o) for o in obj)
     if isinstance(obj, dict):
         return {key: _scan_for_TypedTuples(value) for key, value in obj.items()}
@@ -92,7 +113,6 @@ def _object_hook(o: typing.Any) -> typing.Any:
 decode = JSONDecoder(object_hook=_object_hook).decode
 
 
-
 class Endpoint:
     socket: websockets.WebSocketServerProtocol
 
@@ -120,11 +140,11 @@ class HandlerMeta(type):
                     break
 
         def __init__(self, *args, **kwargs):
+            if orig_init:
+                orig_init(self, *args, **kwargs)
             # turn functions into bound methods
             self.handlers = {name: method.__get__(self, type(self)) for name, method in
                              handlers.items()}
-            if orig_init:
-                orig_init(self, *args, **kwargs)
 
         attrs['__init__'] = __init__
         return super(HandlerMeta, mcs).__new__(mcs, name, bases, attrs)
@@ -150,8 +170,8 @@ class JSONtoTextParser(metaclass=HandlerMeta):
         return "".join(self.handle_node(section) for section in input_object)
 
     def handle_node(self, node: JSONMessagePart):
-        type = node.get("type", None)
-        handler = self.handlers.get(type, self.handlers["text"])
+        node_type = node.get("type", None)
+        handler = self.handlers.get(node_type, self.handlers["text"])
         return handler(node)
 
     def _handle_color(self, node: JSONMessagePart):
@@ -174,11 +194,7 @@ class JSONtoTextParser(metaclass=HandlerMeta):
         return self._handle_color(node)
 
     def _handle_item_name(self, node: JSONMessagePart):
-        # todo: use a better info source
-        from worlds.alttp.Items import progression_items
-        node["color"] = 'green' if node.get("found", False) else 'cyan'
-        if node["text"] in progression_items:
-            node["color"] += ";white_bg"
+        node["color"] = 'cyan'
         return self._handle_color(node)
 
     def _handle_item_id(self, node: JSONMessagePart):
@@ -187,13 +203,13 @@ class JSONtoTextParser(metaclass=HandlerMeta):
         return self._handle_item_name(node)
 
     def _handle_location_name(self, node: JSONMessagePart):
-        node["color"] = 'blue_bg;white'
+        node["color"] = 'green'
         return self._handle_color(node)
 
     def _handle_location_id(self, node: JSONMessagePart):
         item_id = int(node["text"])
         node["text"] = self.ctx.location_name_getter(item_id)
-        return self._handle_item_name(node)
+        return self._handle_location_name(node)
 
     def _handle_entrance_name(self, node: JSONMessagePart):
         node["color"] = 'blue'
@@ -222,6 +238,14 @@ def add_json_text(parts: list, text: typing.Any, **kwargs) -> None:
     parts.append({"text": str(text), **kwargs})
 
 
+def add_json_item(parts: list, item_id: int, player: int = 0, **kwargs) -> None:
+    parts.append({"text": str(item_id), "player": player, "type": JSONTypes.item_id, **kwargs})
+
+
+def add_json_location(parts: list, item_id: int, player: int = 0, **kwargs) -> None:
+    parts.append({"text": str(item_id), "player": player, "type": JSONTypes.location_id, **kwargs})
+
+
 class Hint(typing.NamedTuple):
     receiving_player: int
     finding_player: int
@@ -246,9 +270,9 @@ class Hint(typing.NamedTuple):
         add_json_text(parts, "[Hint]: ")
         add_json_text(parts, self.receiving_player, type="player_id")
         add_json_text(parts, "'s ")
-        add_json_text(parts, self.item, type="item_id", found=self.found)
+        add_json_item(parts, self.item, self.receiving_player)
         add_json_text(parts, " is at ")
-        add_json_text(parts, self.location, type="location_id")
+        add_json_location(parts, self.location, self.finding_player)
         add_json_text(parts, " in ")
         add_json_text(parts, self.finding_player, type="player_id")
         if self.entrance:
@@ -256,14 +280,16 @@ class Hint(typing.NamedTuple):
             add_json_text(parts, self.entrance, type="entrance_name")
         else:
             add_json_text(parts, "'s World")
+        add_json_text(parts, ". ")
         if self.found:
-            add_json_text(parts, ". (found)")
+            add_json_text(parts, "(found)", type="color", color="green")
         else:
-            add_json_text(parts, ".")
+            add_json_text(parts, "(not found)", type="color", color="red")
 
         return {"cmd": "PrintJSON", "data": parts, "type": "Hint",
                 "receiving": self.receiving_player,
-                "item": NetworkItem(self.item, self.location, self.finding_player)}
+                "item": NetworkItem(self.item, self.location, self.finding_player),
+                "found": self.found}
 
     @property
     def local(self):

OoTAdjuster.py

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

Options.py

@@ -29,7 +29,9 @@ class AssembleOptions(type):
                 def validate(self, *args, **kwargs):
                     func(self, *args, **kwargs)
                     self.value = self.schema.validate(self.value)
+
                 return validate
+
             attrs["__init__"] = validate_decorator(attrs["__init__"])
         return super(AssembleOptions, mcs).__new__(mcs, name, bases, attrs)
 
@@ -43,6 +45,9 @@ class Option(metaclass=AssembleOptions):
     # Handled in get_option_name()
     autodisplayname = False
 
+    # can be weighted between selections
+    supports_weighting = True
+
     def __repr__(self) -> str:
         return f"{self.__class__.__name__}({self.get_current_option_name()})"
 
@@ -81,6 +86,7 @@ class Toggle(Option):
     default = 0
 
     def __init__(self, value: int):
+        assert value == 0 or value == 1
         self.value = value
 
     @classmethod
@@ -119,6 +125,7 @@ class Toggle(Option):
     def get_option_name(cls, value):
         return ["No", "Yes"][int(value)]
 
+
 class DefaultOnToggle(Toggle):
     default = 1
 
@@ -132,10 +139,8 @@ class Choice(Option):
     @classmethod
     def from_text(cls, text: str) -> Choice:
         text = text.lower()
-        # TODO: turn on after most people have adjusted their yamls to no longer have suboptions with "random" in them
-        # maybe in 0.2?
-        # if text == "random":
-        #     return cls(random.choice(list(cls.options.values())))
+        if text == "random":
+            return cls(random.choice(list(cls.name_lookup)))
         for optionname, value in cls.options.items():
             if optionname == text:
                 return cls(value)
@@ -150,19 +155,23 @@ class Choice(Option):
         return cls.from_text(str(data))
 
     def __eq__(self, other):
-        if isinstance(other, str):
+        if isinstance(other, self.__class__):
+            return other.value == self.value
+        elif isinstance(other, str):
             assert other in self.options
             return other == self.current_key
         elif isinstance(other, int):
             assert other in self.name_lookup
             return other == self.value
-        elif isinstance(other,  bool):
+        elif isinstance(other, bool):
             return other == bool(self.value)
         else:
             raise TypeError(f"Can't compare {self.__class__.__name__} with {other.__class__.__name__}")
 
     def __ne__(self, other):
-        if isinstance(other,  str):
+        if isinstance(other, self.__class__):
+            return other.value != self.value
+        elif isinstance(other, str):
             assert other in self.options
             return other != self.current_key
         elif isinstance(other, int):
@@ -170,9 +179,12 @@ class Choice(Option):
             return other != self.value
         elif isinstance(other, bool):
             return other != bool(self.value)
+        elif other is None:
+            return False
         else:
             raise TypeError(f"Can't compare {self.__class__.__name__} with {other.__class__.__name__}")
 
+
 class Range(Option, int):
     range_start = 0
     range_end = 1
@@ -205,7 +217,7 @@ class Range(Option, int):
         return cls.from_text(str(data))
 
     def get_option_name(self, value):
-        return str(self.value)
+        return str(value)
 
     def __str__(self):
         return str(self.value)
@@ -230,9 +242,11 @@ class OptionNameSet(Option):
 
 class OptionDict(Option):
     default = {}
+    supports_weighting = False
+    value: typing.Dict[str, typing.Any]
 
     def __init__(self, value: typing.Dict[str, typing.Any]):
-        self.value: typing.Dict[str, typing.Any] = value
+        self.value = value
 
     @classmethod
     def from_any(cls, data: typing.Dict[str, typing.Any]) -> OptionDict:
@@ -242,14 +256,30 @@ class OptionDict(Option):
             raise NotImplementedError(f"Cannot Convert from non-dictionary, got {type(data)}")
 
     def get_option_name(self, value):
-        return str(value)
+        return ", ".join(f"{key}: {v}" for key, v in value.items())
+
+    def __contains__(self, item):
+        return item in self.value
 
 
-class OptionList(Option): 
+class ItemDict(OptionDict):
+    # implemented by Generate
+    verify_item_name = True
+
+    def __init__(self, value: typing.Dict[str, int]):
+        if any(item_count < 1 for item_count in value.values()):
+            raise Exception("Cannot have non-positive item counts.")
+        super(ItemDict, self).__init__(value)
+
+
+class OptionList(Option):
     default = []
+    supports_weighting = False
+    value: list
 
-    def __init__(self, value: typing.List[str, typing.Any]):
-        self.value = value
+    def __init__(self, value: typing.List[typing.Any]):
+        self.value = value or []
+        super(OptionList, self).__init__()
 
     @classmethod
     def from_text(cls, text: str):
@@ -262,23 +292,122 @@ class OptionList(Option):
         return cls.from_text(str(data))
 
     def get_option_name(self, value):
-        return str(value)
+        return ", ".join(map(str, value))
 
+    def __contains__(self, item):
+        return item in self.value
+
+
+class OptionSet(Option):
+    default = frozenset()
+    supports_weighting = False
+    value: set
+
+    def __init__(self, value: typing.Union[typing.Set[str, typing.Any], typing.List[str, typing.Any]]):
+        self.value = set(value)
+        super(OptionSet, self).__init__()
+
+    @classmethod
+    def from_text(cls, text: str):
+        return cls([option.strip() for option in text.split(",")])
+
+    @classmethod
+    def from_any(cls, data: typing.Any):
+        if type(data) == list:
+            return cls(data)
+        elif type(data) == set:
+            return cls(data)
+        return cls.from_text(str(data))
+
+    def get_option_name(self, value):
+        return ", ".join(value)
+
+    def __contains__(self, item):
+        return item in self.value
 
 
 local_objective = Toggle  # local triforce pieces, local dungeon prizes etc.
 
 
 class Accessibility(Choice):
+    """Set rules for reachability of your items/locations.
+    Locations: ensure everything can be reached and acquired.
+    Items: ensure all logically relevant items can be acquired.
+    Minimal: ensure what is needed to reach your goal can be acquired."""
+
     option_locations = 0
     option_items = 1
-    option_beatable = 2
+    option_minimal = 2
+    alias_none = 2
+    default = 1
 
 
+class ProgressionBalancing(DefaultOnToggle):
+    """A system that moves progression earlier, to try and prevent the player from getting stuck and bored early."""
+
+
+common_options = {
+    "progression_balancing": ProgressionBalancing,
+    "accessibility": Accessibility
+}
+
+
+class ItemSet(OptionSet):
+    # implemented by Generate
+    verify_item_name = True
+
+
+class LocalItems(ItemSet):
+    """Forces these items to be in their native world."""
+    displayname = "Local Items"
+
+
+class NonLocalItems(ItemSet):
+    """Forces these items to be outside their native world."""
+    displayname = "Not Local Items"
+
+
+class StartInventory(ItemDict):
+    """Start with these items."""
+    verify_item_name = True
+    displayname = "Start Inventory"
+
+
+class StartHints(ItemSet):
+    """Start with these item's locations prefilled into the !hint command."""
+    displayname = "Start Hints"
+
+
+class StartLocationHints(OptionSet):
+    """Start with these locations and their item prefilled into the !hint command"""
+    displayname = "Start Location Hints"
+
+
+class ExcludeLocations(OptionSet):
+    """Prevent these locations from having an important item"""
+    displayname = "Excluded Locations"
+    verify_location_name = True
+
+
+class DeathLink(Toggle):
+    """When you die, everyone dies. Of course the reverse is true too."""
+    displayname = "Death Link"
+
+
+per_game_common_options = {
+    "local_items": LocalItems,
+    "non_local_items": NonLocalItems,
+    "start_inventory": StartInventory,
+    "start_hints": StartHints,
+    "start_location_hints": StartLocationHints,
+    "exclude_locations": ExcludeLocations
+}
+
 if __name__ == "__main__":
 
     from worlds.alttp.Options import Logic
     import argparse
+
     map_shuffle = Toggle
     compass_shuffle = Toggle
     keyshuffle = Toggle

Patch.py

@@ -1,3 +1,5 @@
+# TODO: convert this into a system like AutoWorld
+
 import bsdiff4
 import yaml
 import os
@@ -10,54 +12,88 @@ from typing import Tuple, Optional
 
 import Utils
 
+current_patch_version = 3
 
-current_patch_version = 2
+GAME_ALTTP = "A Link to the Past"
+GAME_SM = "Super Metroid"
+GAME_SOE = "Secret of Evermore"
+supported_games = {"A Link to the Past", "Super Metroid", "Secret of Evermore"}
+
+preferred_endings = {
+    GAME_ALTTP: "apbp",
+    GAME_SM: "apm3",
+    GAME_SOE: "apsoe"
+}
 
 
-def generate_yaml(patch: bytes, metadata: Optional[dict] = None) -> bytes:
-    from worlds.alttp.Rom import JAP10HASH
+def generate_yaml(patch: bytes, metadata: Optional[dict] = None, game: str = GAME_ALTTP) -> bytes:
+    if game == GAME_ALTTP:
+        from worlds.alttp.Rom import JAP10HASH as HASH
+    elif game == GAME_SM:
+        from worlds.sm.Rom import JAP10HASH as HASH
+    elif game == GAME_SOE:
+        from worlds.soe.Patch import USHASH as HASH
+    else:
+        raise RuntimeError(f"Selected game {game} for base rom not found.")
+
     patch = yaml.dump({"meta": metadata,
                        "patch": patch,
-                       "game": "A Link to the Past",
+                       "game": game,
                        # minimum version of patch system expected for patching to be successful
-                       "compatible_version": 1,
+                       "compatible_version": 3,
                        "version": current_patch_version,
-                       "base_checksum": JAP10HASH})
+                       "base_checksum": HASH})
     return patch.encode(encoding="utf-8-sig")
 
 
-def generate_patch(rom: bytes, metadata: Optional[dict] = None) -> bytes:
-    from worlds.alttp.Rom import get_base_rom_bytes
+def generate_patch(rom: bytes, metadata: Optional[dict] = None, game: str = GAME_ALTTP) -> bytes:
     if metadata is None:
         metadata = {}
-    patch = bsdiff4.diff(get_base_rom_bytes(), rom)
-    return generate_yaml(patch, metadata)
+    patch = bsdiff4.diff(get_base_rom_data(game), rom)
+    return generate_yaml(patch, metadata, game)
 
 
 def create_patch_file(rom_file_to_patch: str, server: str = "", destination: str = None,
-                      player: int = 0, player_name: str = "") -> str:
-    meta = {"server": server, # allow immediate connection to server in multiworld. Empty string otherwise
+                      player: int = 0, player_name: str = "", game: str = GAME_ALTTP) -> str:
+    meta = {"server": server,  # allow immediate connection to server in multiworld. Empty string otherwise
             "player_id": player,
             "player_name": player_name}
     bytes = generate_patch(load_bytes(rom_file_to_patch),
-                           meta)
-    target = destination if destination else os.path.splitext(rom_file_to_patch)[0] + ".apbp"
+                           meta,
+                           game)
+    target = destination if destination else os.path.splitext(rom_file_to_patch)[0] + (
+        ".apbp" if game == GAME_ALTTP else ".apm3")
     write_lzma(bytes, target)
     return target
 
 
 def create_rom_bytes(patch_file: str, ignore_version: bool = False) -> Tuple[dict, str, bytearray]:
-    from worlds.alttp.Rom import get_base_rom_bytes
     data = Utils.parse_yaml(lzma.decompress(load_bytes(patch_file)).decode("utf-8-sig"))
+    game_name = data["game"]
     if not ignore_version and data["compatible_version"] > current_patch_version:
         raise RuntimeError("Patch file is incompatible with this patcher, likely an update is required.")
-    patched_data = bsdiff4.patch(get_base_rom_bytes(), data["patch"])
+    patched_data = bsdiff4.patch(get_base_rom_data(game_name), data["patch"])
     rom_hash = patched_data[int(0x7FC0):int(0x7FD5)]
     data["meta"]["hash"] = "".join(chr(x) for x in rom_hash)
     target = os.path.splitext(patch_file)[0] + ".sfc"
     return data["meta"], target, patched_data
 
 
+def get_base_rom_data(game: str):
+    if game == GAME_ALTTP:
+        from worlds.alttp.Rom import get_base_rom_bytes
+    elif game == "alttp":  # old version for A Link to the Past
+        from worlds.alttp.Rom import get_base_rom_bytes
+    elif game == GAME_SM:
+        from worlds.sm.Rom import get_base_rom_bytes
+    elif game == GAME_SOE:
+        file_name = Utils.get_options()["soe_options"]["rom_file"]
+        get_base_rom_bytes = lambda: bytes(read_rom(open(file_name, "rb")))
+    else:
+        raise RuntimeError("Selected game for base rom not found.")
+    return get_base_rom_bytes()
+
+
 def create_rom_file(patch_file: str) -> Tuple[dict, str]:
     data, target, patched_data = create_rom_bytes(patch_file)
     with open(target, "wb") as f:
@@ -68,7 +104,7 @@ def create_rom_file(patch_file: str) -> Tuple[dict, str]:
 def update_patch_data(patch_data: bytes, server: str = "") -> bytes:
     data = Utils.parse_yaml(lzma.decompress(patch_data).decode("utf-8-sig"))
     data["meta"]["server"] = server
-    bytes = generate_yaml(data["patch"], data["meta"])
+    bytes = generate_yaml(data["patch"], data["meta"], data["game"])
     return lzma.compress(bytes)
 
 
@@ -82,6 +118,14 @@ def write_lzma(data: bytes, path: str):
         f.write(data)
 
 
+def read_rom(stream, strip_header=True) -> bytearray:
+    """Reads rom into bytearray and optionally strips off any smc header"""
+    buffer = bytearray(stream.read())
+    if strip_header and len(buffer) % 0x400 == 0x200:
+        return buffer[0x200:]
+    return buffer
+
+
 if __name__ == "__main__":
     host = Utils.get_public_ipv4()
     options = Utils.get_options()['server_options']
@@ -113,7 +157,13 @@ if __name__ == "__main__":
                     if 'server' in data:
                         Utils.persistent_store("servers", data['hash'], data['server'])
                         print(f"Host is {data['server']}")
-
+                elif rom.endswith(".apm3"):
+                    print(f"Applying patch {rom}")
+                    data, target = create_rom_file(rom)
+                    print(f"Created rom {target}.")
+                    if 'server' in data:
+                        Utils.persistent_store("servers", data['hash'], data['server'])
+                        print(f"Host is {data['server']}")
                 elif rom.endswith(".archipelago"):
                     import json
                     import zlib
@@ -139,7 +189,7 @@ if __name__ == "__main__":
 
                     def _handle_zip_file_entry(zfinfo: zipfile.ZipInfo, server: str):
                         data = zfr.read(zfinfo)
-                        if zfinfo.filename.endswith(".apbp"):
+                        if zfinfo.filename.endswith(".apbp") or zfinfo.filename.endswith(".apm3"):
                             data = update_patch_data(data, server)
                         with ziplock:
                             zfw.writestr(zfinfo, data)
@@ -160,12 +210,4 @@ if __name__ == "__main__":
                 import traceback
 
                 traceback.print_exc()
-                input("Press enter to close.")
-
-
-def read_rom(stream, strip_header=True) -> bytearray:
-    """Reads rom into bytearray and optionally strips off any smc header"""
-    buffer = bytearray(stream.read())
-    if strip_header and len(buffer) % 0x400 == 0x200:
-        return buffer[0x200:]
-    return buffer
+                input("Press enter to close.")

README.md

@@ -10,8 +10,11 @@ Currently, the following games are supported:
 * Slay the Spire
 * Risk of Rain 2
 * The Legend of Zelda: Ocarina of Time
+* Timespinner
+* Super Metroid
+* Secret of Evermore
 
-For setup and instructions check out our [tutorials page](http://archipelago.gg:48484/tutorial).
+For setup and instructions check out our [tutorials page](https://archipelago.gg/tutorial/).
 Downloads can be found at [Releases](https://github.com/ArchipelagoMW/Archipelago/releases), including compiled
 windows binaries.
 
@@ -33,12 +36,12 @@ Archipelago was directly forked from bonta0's `multiworld_31` branch of ALttPEnt
 ## Running Archipelago
 For most people all you need to do is head over to the [releases](https://github.com/ArchipelagoMW/Archipelago/releases) page then download and run the appropriate installer. The installers function on Windows only.
 
-If you are running Archipelago from a non-Windows system then the likely scenario is that you are comfortable running source code directly. Please see our wiki page on [running Archipelago from source](https://github.com/Berserker66/MultiWorld-Utilities/wiki/Running-from-source).
+If you are running Archipelago from a non-Windows system then the likely scenario is that you are comfortable running source code directly. Please see our wiki page on [running Archipelago from source](https://github.com/ArchipelagoMW/Archipelago/wiki/Running-from-source).
 
 ## Related Repositories
 This project makes use of multiple other projects. We wouldn't be here without these other repositories and the contributions of their developers, past and present.
 
-* [z3randomizer](https://github.com/CaitSith2/z3randomizer)
+* [z3randomizer](https://github.com/ArchipelagoMW/z3randomizer)
 * [Enemizer](https://github.com/Ijwu/Enemizer)
 * [Ocarina of Time Randomizer](https://github.com/TestRunnerSRL/OoT-Randomizer)
 

SNIClient.py

@@ -1,6 +1,6 @@
-import argparse
-import atexit
-exit_func = atexit.register(input, "Press enter to close.")
+from __future__ import annotations
+
+import sys
 import threading
 import time
 import multiprocessing
@@ -12,39 +12,37 @@ import logging
 import asyncio
 from json import loads, dumps
 
-from Utils import get_item_name_from_id
+from Utils import get_item_name_from_id, init_logging
 
-
-import ModuleUpdate
-
-ModuleUpdate.update()
+if __name__ == "__main__":
+    init_logging("SNIClient", exception_logger="Client")
 
 import colorama
 
 from NetUtils import *
-
 from worlds.alttp import Regions, Shops
 from worlds.alttp import Items
+from worlds.alttp.Rom import ROM_PLAYER_LIMIT
+from worlds.sm.Rom import ROM_PLAYER_LIMIT as SM_ROM_PLAYER_LIMIT
 import Utils
-from CommonClient import CommonContext, server_loop, console_loop, ClientCommandProcessor, gui_enabled
+from CommonClient import CommonContext, server_loop, console_loop, ClientCommandProcessor, gui_enabled, get_base_parser
+from Patch import GAME_ALTTP, GAME_SM
+
 
 snes_logger = logging.getLogger("SNES")
 
 from MultiServer import mark_raw
 
-log_folder = Utils.local_path("logs")
-os.makedirs(log_folder, exist_ok=True)
 
-# Log to file in gui case
-if gui_enabled:
-    logging.basicConfig(format='[%(name)s]: %(message)s', level=logging.INFO,
-                        filename=os.path.join(log_folder, "LttPClient.txt"), filemode="w", force=True)
-else:
-    logging.basicConfig(format='[%(name)s]: %(message)s', level=logging.INFO, force=True)
-    logging.getLogger().addHandler(logging.FileHandler(os.path.join(log_folder, "LttPClient.txt"), "w"))
+class DeathState(enum.IntEnum):
+    killing_player = 1
+    alive = 2
+    dead = 3
 
 
 class LttPCommandProcessor(ClientCommandProcessor):
+    ctx: Context
+
     def _cmd_slow_mode(self, toggle: str = ""):
         """Toggle slow mode, which limits how fast you send / receive items."""
         if toggle:
@@ -56,17 +54,18 @@ class LttPCommandProcessor(ClientCommandProcessor):
 
     @mark_raw
     def _cmd_snes(self, snes_options: str = "") -> bool:
-        """Connect to a snes. Optionally include network address of a snes to connect to, otherwise show available devices; and a SNES device number if more than one SNES is detected"""
-        
+        """Connect to a snes. Optionally include network address of a snes to connect to,
+        otherwise show available devices; and a SNES device number if more than one SNES is detected"""
+
         snes_address = self.ctx.snes_address
         snes_device_number = -1
-        
+
         options = snes_options.split()
         num_options = len(options)
-        
+
         if num_options > 0:
             snes_address = options[0]
-            
+
         if num_options > 1:
             try:
                 snes_device_number = int(options[1])
@@ -74,7 +73,7 @@ class LttPCommandProcessor(ClientCommandProcessor):
                 pass
 
         self.ctx.snes_reconnect_address = None
-        asyncio.create_task(snes_connect(self.ctx, snes_address, snes_device_number))
+        asyncio.create_task(snes_connect(self.ctx, snes_address, snes_device_number), name="SNES Connect")
         return True
 
     def _cmd_snes_close(self) -> bool:
@@ -86,6 +85,19 @@ class LttPCommandProcessor(ClientCommandProcessor):
         else:
             return False
 
+    # Left here for quick re-addition for debugging.
+    # def _cmd_snes_write(self, address, data):
+    #     """Write the specified byte (base10) to the SNES' memory address (base16)."""
+    #     if self.ctx.snes_state != SNESState.SNES_ATTACHED:
+    #         self.output("No attached SNES Device.")
+    #         return False
+    #
+    #     snes_buffered_write(self.ctx, int(address, 16), bytes([int(data)]))
+    #     asyncio.create_task(snes_flush_writes(self.ctx))
+    #     self.output("Data Sent")
+    #     return True
+
+
 class Context(CommonContext):
     command_processor = LttPCommandProcessor
     game = "A Link to the Past"
@@ -103,6 +115,8 @@ class Context(CommonContext):
         self.snes_request_lock = asyncio.Lock()
         self.snes_write_buffer = []
         self.snes_connector_lock = threading.Lock()
+        self.death_state = DeathState.alive  # for death link flop behaviour
+        self.killing_player_task = None
 
         self.awaiting_rom = False
         self.rom = None
@@ -118,7 +132,7 @@ class Context(CommonContext):
         raise Exception('Invalid ROM detected, '
                         'please verify that you have loaded the correct rom and reconnect your snes (/snes)')
 
-    async def server_auth(self, password_requested):
+    async def server_auth(self, password_requested: bool = False):
         if password_requested and not self.password:
             await super(Context, self).server_auth(password_requested)
         if self.rom is None:
@@ -129,11 +143,55 @@ class Context(CommonContext):
         self.awaiting_rom = False
         self.auth = self.rom
         auth = base64.b64encode(self.rom).decode()
-        await self.send_msgs([{"cmd": 'Connect',
-                              'password': self.password, 'name': auth, 'version': Utils.version_tuple,
-                              'tags': get_tags(self),
-                              'uuid': Utils.get_unique_identifier(), 'game': "A Link to the Past"
-                              }])
+        await self.send_connect(name=auth)
+
+    def on_deathlink(self, data: dict):
+        if not self.killing_player_task or self.killing_player_task.done():
+            self.killing_player_task = asyncio.create_task(deathlink_kill_player(self))
+        super(Context, self).on_deathlink(data)
+
+    async def handle_deathlink_state(self, currently_dead: bool):
+        # 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()
+        # 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
+            pass
+        # in this state we wait until the player is alive again
+        elif self.death_state == DeathState.dead:
+            if not currently_dead:
+                self.death_state = DeathState.alive
+
+
+async def deathlink_kill_player(ctx: Context):
+    ctx.death_state = DeathState.killing_player
+    while ctx.death_state == DeathState.killing_player and \
+            ctx.snes_state == SNESState.SNES_ATTACHED:
+        if ctx.game == GAME_ALTTP:
+            snes_buffered_write(ctx, WRAM_START + 0xF36D, bytes([0]))  # set current health to 0
+            snes_buffered_write(ctx, WRAM_START + 0x0373, bytes([8]))  # deal 1 full heart of damage at next opportunity
+        elif ctx.game == GAME_SM:
+            snes_buffered_write(ctx, WRAM_START + 0x09C2, bytes([0, 0]))  # set current health to 0
+            if not ctx.death_link_allow_survive:
+                snes_buffered_write(ctx, WRAM_START + 0x09D6, bytes([0, 0]))  # set current reserve to 0
+        await snes_flush_writes(ctx)
+        await asyncio.sleep(1)
+        gamemode = None
+        if ctx.game == GAME_ALTTP:
+            gamemode = await snes_read(ctx, WRAM_START + 0x10, 1)
+            if not gamemode or gamemode[0] in DEATH_MODES:
+                ctx.death_state = DeathState.dead
+        elif ctx.game == GAME_SM:
+            gamemode = await snes_read(ctx, WRAM_START + 0x0998, 1)
+            health = await snes_read(ctx, WRAM_START + 0x09C2, 2)
+            if health is not None:
+                health = health[0] | (health[1] << 8)
+            if not gamemode or gamemode[0] in SM_DEATH_MODES or (ctx.death_link_allow_survive and health is not None and health > 0):
+                ctx.death_state = DeathState.dead
+        ctx.last_death_link = time.time()
 
 
 def color_item(item_id: int, green: bool = False) -> str:
@@ -146,6 +204,7 @@ def color_item(item_id: int, green: bool = False) -> str:
 
 SNES_RECONNECT_DELAY = 5
 
+# LttP
 ROM_START = 0x000000
 WRAM_START = 0xF50000
 WRAM_SIZE = 0x20000
@@ -156,6 +215,7 @@ ROMNAME_SIZE = 0x15
 
 INGAME_MODES = {0x07, 0x09, 0x0b}
 ENDGAME_MODES = {0x19, 0x1a}
+DEATH_MODES = {0x12}
 
 SAVEDATA_START = WRAM_START + 0xF000
 SAVEDATA_SIZE = 0x500
@@ -171,6 +231,21 @@ SCOUTREPLY_ITEM_ADDR = SAVEDATA_START + 0x4D9       # 1 byte
 SCOUTREPLY_PLAYER_ADDR = SAVEDATA_START + 0x4DA     # 1 byte
 SHOP_ADDR = SAVEDATA_START + 0x302                  # 2 bytes
 
+DEATH_LINK_ACTIVE_ADDR = ROMNAME_START + 0x15       # 1 byte
+
+# SM
+SM_ROMNAME_START = 0x1C4F00
+
+SM_INGAME_MODES = {0x07, 0x09, 0x0b}
+SM_ENDGAME_MODES = {0x26, 0x27}
+SM_DEATH_MODES = {0x15, 0x17, 0x18, 0x19, 0x1A}
+
+SM_RECV_PROGRESS_ADDR = SRAM_START + 0x2000         # 2 bytes
+SM_RECV_ITEM_ADDR = SAVEDATA_START + 0x4D2          # 1 byte
+SM_RECV_ITEM_PLAYER_ADDR = SAVEDATA_START + 0x4D3   # 1 byte
+
+SM_DEATH_LINK_ACTIVE_ADDR = ROM_START + 0x277f04    # 1 byte
+
 location_shop_ids = set([info[0] for name, info in Shops.shop_table.items()])
 
 location_table_uw = {"Blind's Hideout - Top": (0x11d, 0x10),
@@ -394,7 +469,7 @@ location_table_uw = {"Blind's Hideout - Top": (0x11d, 0x10),
                      'Ganons Tower - Pre-Moldorm Chest': (0x3d, 0x40),
                      'Ganons Tower - Validation Chest': (0x4d, 0x10)}
 
-location_table_uw_id = {Regions.lookup_name_to_id[name] : data for name, data in location_table_uw.items()}
+location_table_uw_id = {Regions.lookup_name_to_id[name]: data for name, data in location_table_uw.items()}
 
 location_table_npc = {'Mushroom': 0x1000,
                       'King Zora': 0x2,
@@ -410,7 +485,7 @@ location_table_npc = {'Mushroom': 0x1000,
                       'Stumpy': 0x8,
                       'Bombos Tablet': 0x200}
 
-location_table_npc_id = {Regions.lookup_name_to_id[name] : data for name, data in location_table_npc.items()}
+location_table_npc_id = {Regions.lookup_name_to_id[name]: data for name, data in location_table_npc.items()}
 
 location_table_ow = {'Flute Spot': 0x2a,
                      'Sunken Treasure': 0x3b,
@@ -425,14 +500,15 @@ location_table_ow = {'Flute Spot': 0x2a,
                      'Bumper Cave Ledge': 0x4a,
                      'Floating Island': 0x5}
 
-location_table_ow_id = {Regions.lookup_name_to_id[name] : data for name, data in location_table_ow.items()}
+location_table_ow_id = {Regions.lookup_name_to_id[name]: data for name, data in location_table_ow.items()}
 
 location_table_misc = {'Bottle Merchant': (0x3c9, 0x2),
                        'Purple Chest': (0x3c9, 0x10),
                        "Link's Uncle": (0x3c6, 0x1),
                        'Hobo': (0x3c9, 0x1)}
 
-location_table_misc_id = {Regions.lookup_name_to_id[name] : data for name, data in location_table_misc.items()}
+location_table_misc_id = {Regions.lookup_name_to_id[name]: data for name, data in location_table_misc.items()}
+
 
 class SNESState(enum.IntEnum):
     SNES_DISCONNECTED = 0
@@ -448,16 +524,18 @@ def launch_sni(ctx: Context):
         sni_path = Utils.local_path(sni_path)
     if os.path.isdir(sni_path):
         for file in os.listdir(sni_path):
-            if file.startswith("sni.") and not file.endswith(".proto"):
+            lower_file = file.lower()
+            if (lower_file.startswith("sni.") and not lower_file.endswith(".proto")) or lower_file == "sni":
                 sni_path = os.path.join(sni_path, file)
 
     if os.path.isfile(sni_path):
         snes_logger.info(f"Attempting to start {sni_path}")
-        import subprocess
-        if Utils.is_frozen(): # if it spawns a visible console, may as well populate it
+        import sys
+        if not sys.stdout:  # if it spawns a visible console, may as well populate it
             subprocess.Popen(sni_path, cwd=os.path.dirname(sni_path))
         else:
-            subprocess.Popen(sni_path, cwd=os.path.dirname(sni_path), stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+            subprocess.Popen(sni_path, cwd=os.path.dirname(sni_path), stdout=subprocess.DEVNULL,
+                             stderr=subprocess.DEVNULL)
     else:
         snes_logger.info(
             f"Attempt to start SNI was aborted as path {sni_path} was not found, "
@@ -507,13 +585,23 @@ async def get_snes_devices(ctx: Context):
             await socket.send(dumps(DeviceList_Request))
             reply = loads(await socket.recv())
             devices = reply['Results'] if 'Results' in reply and len(reply['Results']) > 0 else None
-
-
+    await verify_snes_app(socket)
     await socket.close()
     return devices
 
 
-async def snes_connect(ctx: Context, address, deviceIndex = -1):
+async def verify_snes_app(socket):
+    AppVersion_Request = {
+        "Opcode": "AppVersion",
+    }
+    await socket.send(dumps(AppVersion_Request))
+
+    app: str = loads(await socket.recv())["Results"][0]
+    if "SNI" not in app:
+        snes_logger.warning(f"Warning: Did not find SNI as the endpoint, instead {app} was found.")
+
+
+async def snes_connect(ctx: Context, address, deviceIndex=-1):
     global SNES_RECONNECT_DELAY
     if ctx.snes_socket is not None and ctx.snes_state == SNESState.SNES_CONNECTED:
         if ctx.rom:
@@ -542,7 +630,8 @@ async def snes_connect(ctx: Context, address, deviceIndex = -1):
                 device = devices[ctx.snes_attached_device[0]]
         elif numDevices > 1:
             if deviceIndex == -1:
-                snes_logger.info("Found " + str(numDevices) + " SNES devices; connect to one with /snes <address> <device number>:")
+                snes_logger.info(
+                    "Found " + str(numDevices) + " SNES devices; connect to one with /snes <address> <device number>:")
 
                 for idx, availableDevice in enumerate(devices):
                     snes_logger.info(str(idx + 1) + ": " + availableDevice)
@@ -552,7 +641,7 @@ async def snes_connect(ctx: Context, address, deviceIndex = -1):
 
             else:
                 device = devices[deviceIndex - 1]
-            
+
         if device is None:
             await snes_disconnect(ctx)
             return
@@ -598,11 +687,6 @@ async def snes_disconnect(ctx: Context):
 
 
 async def snes_autoreconnect(ctx: Context):
-    # unfortunately currently broken. See: https://github.com/prompt-toolkit/python-prompt-toolkit/issues/1033
-    # with prompt_toolkit.shortcuts.ProgressBar() as pb:
-    #    for _ in pb(range(100)):
-    #        await asyncio.sleep(RECONNECT_DELAY/100)
-
     await asyncio.sleep(SNES_RECONNECT_DELAY)
     if ctx.snes_reconnect_address and ctx.snes_socket is None:
         await snes_connect(ctx, ctx.snes_reconnect_address)
@@ -713,12 +797,6 @@ async def snes_flush_writes(ctx: Context):
     await snes_write(ctx, writes)
 
 
-# kept as function for easier wrapping by plugins
-def get_tags(ctx: Context):
-    tags = ['AP']
-    return tags
-
-
 async def track_locations(ctx: Context, roomid, roomdata):
     new_locations = []
 
@@ -726,7 +804,8 @@ async def track_locations(ctx: Context, roomid, roomdata):
         new_locations.append(location_id)
         ctx.locations_checked.add(location_id)
         location = ctx.location_name_getter(location_id)
-        snes_logger.info(f'New Check: {location} ({len(ctx.locations_checked)}/{len(ctx.missing_locations) + len(ctx.checked_locations)})')
+        snes_logger.info(
+            f'New Check: {location} ({len(ctx.locations_checked)}/{len(ctx.missing_locations) + len(ctx.checked_locations)})')
 
     try:
         if roomid in location_shop_ids:
@@ -796,7 +875,6 @@ async def track_locations(ctx: Context, roomid, roomdata):
                 if misc_data[offset - 0x3c6] & mask != 0 and location_id not in ctx.locations_checked:
                     new_check(location_id)
 
-
     if new_locations:
         await ctx.send_msgs([{"cmd": 'LocationChecks', "locations": new_locations}])
 
@@ -813,11 +891,25 @@ async def game_watcher(ctx: Context):
 
         if not ctx.rom:
             ctx.finished_game = False
-            rom = await snes_read(ctx, ROMNAME_START, ROMNAME_SIZE)
+            ctx.death_link_allow_survive = False
+            game_name = await snes_read(ctx, SM_ROMNAME_START, 2)
+            if game_name is None:
+                continue
+            elif game_name == b"SM":
+                ctx.game = GAME_SM
+            else:
+                ctx.game = GAME_ALTTP
+
+            rom = await snes_read(ctx, SM_ROMNAME_START if ctx.game == GAME_SM else ROMNAME_START, ROMNAME_SIZE)
             if rom is None or rom == bytes([0] * ROMNAME_SIZE):
                 continue
 
             ctx.rom = rom
+            death_link = await snes_read(ctx, DEATH_LINK_ACTIVE_ADDR if ctx.game == GAME_ALTTP else
+                                         SM_DEATH_LINK_ACTIVE_ADDR, 1)
+            if death_link:
+                ctx.death_link_allow_survive = bool(death_link[0] & 0b10)
+                await ctx.update_death_link(bool(death_link[0] & 0b1))
             if not ctx.prev_rom or ctx.prev_rom != ctx.rom:
                 ctx.locations_checked = set()
                 ctx.locations_scouted = set()
@@ -830,65 +922,131 @@ async def game_watcher(ctx: Context):
             snes_logger.warning("ROM change detected, please reconnect to the multiworld server")
             await ctx.disconnect()
 
-        gamemode = await snes_read(ctx, WRAM_START + 0x10, 1)
-        gameend = await snes_read(ctx, SAVEDATA_START + 0x443, 1)
-        game_timer = await snes_read(ctx, SAVEDATA_START + 0x42E, 4)
-        if gamemode is None or gameend is None or game_timer is None or \
-                (gamemode[0] not in INGAME_MODES and gamemode[0] not in ENDGAME_MODES):
-            continue
+        if ctx.game == GAME_ALTTP:
+            gamemode = await snes_read(ctx, WRAM_START + 0x10, 1)
+            if "DeathLink" in ctx.tags and gamemode and ctx.last_death_link + 1 < time.time():
+                currently_dead = gamemode[0] in DEATH_MODES
+                await ctx.handle_deathlink_state(currently_dead)
 
-        delay = 7 if ctx.slow_mode else 2
-        if gameend[0]:
-            if not ctx.finished_game:
-                await ctx.send_msgs([{"cmd": "StatusUpdate", "status": ClientStatus.CLIENT_GOAL}])
-                ctx.finished_game = True
-
-            if time.perf_counter() - perf_counter < delay:
+            gameend = await snes_read(ctx, SAVEDATA_START + 0x443, 1)
+            game_timer = await snes_read(ctx, SAVEDATA_START + 0x42E, 4)
+            if gamemode is None or gameend is None or game_timer is None or \
+                    (gamemode[0] not in INGAME_MODES and gamemode[0] not in ENDGAME_MODES):
                 continue
+
+            delay = 7 if ctx.slow_mode else 2
+            if gameend[0]:
+                if not ctx.finished_game:
+                    await ctx.send_msgs([{"cmd": "StatusUpdate", "status": ClientStatus.CLIENT_GOAL}])
+                    ctx.finished_game = True
+
+                if time.perf_counter() - perf_counter < delay:
+                    continue
+                else:
+                    perf_counter = time.perf_counter()
             else:
-                perf_counter = time.perf_counter()
-        else:
-            game_timer = game_timer[0] | (game_timer[1] << 8) | (game_timer[2] << 16) | (game_timer[3] << 24)
-            if abs(game_timer - prev_game_timer) < (delay * 60):
+                game_timer = game_timer[0] | (game_timer[1] << 8) | (game_timer[2] << 16) | (game_timer[3] << 24)
+                if abs(game_timer - prev_game_timer) < (delay * 60):
+                    continue
+                else:
+                    prev_game_timer = game_timer
+
+            if gamemode in ENDGAME_MODES:  # triforce room and credits
                 continue
-            else:
-                prev_game_timer = game_timer
 
-        if gamemode in ENDGAME_MODES:  # triforce room and credits
-            continue
+            data = await snes_read(ctx, RECV_PROGRESS_ADDR, 8)
+            if data is None:
+                continue
 
-        data = await snes_read(ctx, RECV_PROGRESS_ADDR, 8)
-        if data is None:
-            continue
+            recv_index = data[0] | (data[1] << 8)
+            recv_item = data[2]
+            roomid = data[4] | (data[5] << 8)
+            roomdata = data[6]
+            scout_location = data[7]
 
-        recv_index = data[0] | (data[1] << 8)
-        recv_item = data[2]
-        roomid = data[4] | (data[5] << 8)
-        roomdata = data[6]
-        scout_location = data[7]
+            if recv_index < len(ctx.items_received) and recv_item == 0:
+                item = ctx.items_received[recv_index]
+                recv_index += 1
+                logging.info('Received %s from %s (%s) (%d/%d in list)' % (
+                    color(ctx.item_name_getter(item.item), 'red', 'bold'), color(ctx.player_names[item.player], 'yellow'),
+                    ctx.location_name_getter(item.location), recv_index, len(ctx.items_received)))
 
-        if recv_index < len(ctx.items_received) and recv_item == 0:
-            item = ctx.items_received[recv_index]
-            recv_index += 1
-            logging.info('Received %s from %s (%s) (%d/%d in list)' % (
-                color(ctx.item_name_getter(item.item), 'red', 'bold'), color(ctx.player_names[item.player], 'yellow'),
-                ctx.location_name_getter(item.location), recv_index, len(ctx.items_received)))
+                snes_buffered_write(ctx, RECV_PROGRESS_ADDR,
+                                    bytes([recv_index & 0xFF, (recv_index >> 8) & 0xFF]))
+                snes_buffered_write(ctx, RECV_ITEM_ADDR,
+                                    bytes([item.item]))
+                snes_buffered_write(ctx, RECV_ITEM_PLAYER_ADDR,
+                                    bytes([min(ROM_PLAYER_LIMIT, item.player) if item.player != ctx.slot else 0]))
+            if scout_location > 0 and scout_location in ctx.locations_info:
+                snes_buffered_write(ctx, SCOUTREPLY_LOCATION_ADDR,
+                                    bytes([scout_location]))
+                snes_buffered_write(ctx, SCOUTREPLY_ITEM_ADDR,
+                                    bytes([ctx.locations_info[scout_location][0]]))
+                snes_buffered_write(ctx, SCOUTREPLY_PLAYER_ADDR,
+                                    bytes([min(ROM_PLAYER_LIMIT, ctx.locations_info[scout_location][1])]))
 
-            snes_buffered_write(ctx, RECV_PROGRESS_ADDR, bytes([recv_index & 0xFF, (recv_index >> 8) & 0xFF]))
-            snes_buffered_write(ctx, RECV_ITEM_ADDR, bytes([item.item]))
-            snes_buffered_write(ctx, RECV_ITEM_PLAYER_ADDR, bytes([item.player if item.player != ctx.slot else 0]))
-        if scout_location > 0 and scout_location in ctx.locations_info:
-            snes_buffered_write(ctx, SCOUTREPLY_LOCATION_ADDR, bytes([scout_location]))
-            snes_buffered_write(ctx, SCOUTREPLY_ITEM_ADDR, bytes([ctx.locations_info[scout_location][0]]))
-            snes_buffered_write(ctx, SCOUTREPLY_PLAYER_ADDR, bytes([ctx.locations_info[scout_location][1]]))
+            await snes_flush_writes(ctx)
 
-        await snes_flush_writes(ctx)
+            if scout_location > 0 and scout_location not in ctx.locations_scouted:
+                ctx.locations_scouted.add(scout_location)
+                await ctx.send_msgs([{"cmd": "LocationScouts", "locations": [scout_location]}])
+            await track_locations(ctx, roomid, roomdata)        
+        elif ctx.game == GAME_SM:
+            gamemode = await snes_read(ctx, WRAM_START + 0x0998, 1)
+            if "DeathLink" in ctx.tags and gamemode and ctx.last_death_link + 1 < time.time():
+                currently_dead = gamemode[0] in SM_DEATH_MODES
+                await ctx.handle_deathlink_state(currently_dead)
+            if gamemode is not None and gamemode[0] in SM_ENDGAME_MODES:
+                if not ctx.finished_game:
+                    await ctx.send_msgs([{"cmd": "StatusUpdate", "status": ClientStatus.CLIENT_GOAL}])
+                    ctx.finished_game = True
+                continue
 
-        if scout_location > 0 and scout_location not in ctx.locations_scouted:
-            ctx.locations_scouted.add(scout_location)
-            await ctx.send_msgs([{"cmd": "LocationScouts", "locations": [scout_location]}])
-        await track_locations(ctx, roomid, roomdata)
+            data = await snes_read(ctx, SM_RECV_PROGRESS_ADDR + 0x680, 4)
+            if data is None:
+                continue
 
+            recv_index = data[0] | (data[1] << 8)
+            recv_item = data[2] | (data[3] << 8)
+
+            while (recv_index < recv_item):
+                itemAdress = recv_index * 8
+                message = await snes_read(ctx, SM_RECV_PROGRESS_ADDR + 0x700 + itemAdress, 8)
+                # worldId = message[0] | (message[1] << 8)  # unused
+                # itemId = message[2] | (message[3] << 8)  # unused
+                itemIndex = (message[4] | (message[5] << 8)) >> 3
+
+                recv_index += 1
+                snes_buffered_write(ctx, SM_RECV_PROGRESS_ADDR + 0x680, bytes([recv_index & 0xFF, (recv_index >> 8) & 0xFF]))
+
+                from worlds.sm.Locations import locations_start_id
+                location_id = locations_start_id + itemIndex
+
+                ctx.locations_checked.add(location_id)
+                location = ctx.location_name_getter(location_id)
+                snes_logger.info(f'New Check: {location} ({len(ctx.locations_checked)}/{len(ctx.missing_locations) + len(ctx.checked_locations)})')
+                await ctx.send_msgs([{"cmd": 'LocationChecks', "locations": [location_id]}])
+
+            data = await snes_read(ctx, SM_RECV_PROGRESS_ADDR + 0x600, 4)
+            if data is None:
+                continue
+
+            # recv_itemOutPtr = data[0] | (data[1] << 8) # unused
+            itemOutPtr = data[2] | (data[3] << 8)
+
+            from worlds.sm.Items import items_start_id
+            if itemOutPtr < len(ctx.items_received):
+                item = ctx.items_received[itemOutPtr]
+                itemId = item.item - items_start_id
+
+                playerID = item.player if item.player <= SM_ROM_PLAYER_LIMIT else 0
+                snes_buffered_write(ctx, SM_RECV_PROGRESS_ADDR + itemOutPtr * 4, bytes([playerID & 0xFF, (playerID >> 8) & 0xFF, itemId & 0xFF, (itemId >> 8) & 0xFF]))
+                itemOutPtr += 1
+                snes_buffered_write(ctx, SM_RECV_PROGRESS_ADDR + 0x602, bytes([itemOutPtr & 0xFF, (itemOutPtr >> 8) & 0xFF]))
+                logging.info('Received %s from %s (%s) (%d/%d in list)' % (
+                    color(ctx.item_name_getter(item.item), 'red', 'bold'), color(ctx.player_names[item.player], 'yellow'),
+                    ctx.location_name_getter(item.location), itemOutPtr, len(ctx.items_received)))
+            await snes_flush_writes(ctx)
 
 async def run_game(romfile):
     auto_start = Utils.get_options()["lttp_options"].get("rom_start", True)
@@ -899,71 +1057,69 @@ async def run_game(romfile):
         subprocess.Popen([auto_start, romfile],
                          stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
 
+
 async def main():
     multiprocessing.freeze_support()
-    parser = argparse.ArgumentParser()
+    parser = get_base_parser()
     parser.add_argument('diff_file', default="", type=str, nargs="?",
                         help='Path to a Archipelago Binary Patch file')
     parser.add_argument('--snes', default='localhost:8080', help='Address of the SNI server.')
-    parser.add_argument('--connect', default=None, help='Address of the multiworld host.')
-    parser.add_argument('--password', default=None, help='Password of the multiworld host.')
     parser.add_argument('--loglevel', default='info', choices=['debug', 'info', 'warning', 'error', 'critical'])
-    parser.add_argument('--founditems', default=False, action='store_true',
-                        help='Show items found by other players for themselves.')
-    if not Utils.is_frozen():  # Frozen state has no cmd window in the first place
-        parser.add_argument('--nogui', default=False, action='store_true', help="Turns off Client GUI.")
     args = parser.parse_args()
-    logging.basicConfig(format='%(message)s', level=getattr(logging, args.loglevel.upper(), logging.INFO))
+
     if args.diff_file:
         import Patch
         logging.info("Patch file was supplied. Creating sfc rom..")
         meta, romfile = Patch.create_rom_file(args.diff_file)
-        args.connect = meta["server"]
+        if "server" in meta:
+            args.connect = meta["server"]
         logging.info(f"Wrote rom file to {romfile}")
-        adjustedromfile, adjusted = Utils.get_adjuster_settings(romfile, gui_enabled)
-        if adjusted:
-            try:
-                shutil.move(adjustedromfile, romfile)
-                adjustedromfile = romfile
-            except Exception as e:
-                logging.exception(e)
-        asyncio.create_task(run_game(adjustedromfile if adjusted else romfile))
+        if args.diff_file.endswith(".apsoe"):
+            import webbrowser
+            webbrowser.open("http://www.evermizer.com/apclient/" +
+                            (f"#server={meta['server']}" if "server" in meta else ""))
+            logging.info("Starting Evermizer Client in your Browser...")
+            import time
+            time.sleep(3)
+            sys.exit()
+        elif args.diff_file.endswith((".apbp", "apz3")):
+            adjustedromfile, adjusted = Utils.get_adjuster_settings(romfile, gui_enabled)
+            if adjusted:
+                try:
+                    shutil.move(adjustedromfile, romfile)
+                    adjustedromfile = romfile
+                except Exception as e:
+                    logging.exception(e)
+            asyncio.create_task(run_game(adjustedromfile if adjusted else romfile))
+        else:
+            asyncio.create_task(run_game(romfile))
 
     ctx = Context(args.snes, args.connect, args.password)
     if ctx.server_task is None:
         ctx.server_task = asyncio.create_task(server_loop(ctx), name="ServerLoop")
-
+    input_task = None
     if gui_enabled:
-        input_task = None
-        from kvui import LttPManager
-        ctx.ui = LttPManager(ctx)
+        from kvui import SNIManager
+        ctx.ui = SNIManager(ctx)
         ui_task = asyncio.create_task(ctx.ui.async_run(), name="UI")
     else:
-        input_task = asyncio.create_task(console_loop(ctx), name="Input")
         ui_task = None
+    if sys.stdin:
+        input_task = asyncio.create_task(console_loop(ctx), name="Input")
 
-    snes_connect_task = asyncio.create_task(snes_connect(ctx, ctx.snes_address))
+    snes_connect_task = asyncio.create_task(snes_connect(ctx, ctx.snes_address), name="SNES Connect")
     watcher_task = asyncio.create_task(game_watcher(ctx), name="GameWatcher")
 
     await ctx.exit_event.wait()
-    if snes_connect_task:
-        snes_connect_task.cancel()
+
     ctx.server_address = None
     ctx.snes_reconnect_address = None
-
-    await watcher_task
-
-    if ctx.server and not ctx.server.socket.closed:
-        await ctx.server.socket.close()
-    if ctx.server_task:
-        await ctx.server_task
-
     if ctx.snes_socket is not None and not ctx.snes_socket.closed:
         await ctx.snes_socket.close()
-
-    while ctx.input_requests > 0:
-        ctx.input_queue.put_nowait(None)
-        ctx.input_requests -= 1
+    if snes_connect_task:
+        snes_connect_task.cancel()
+    await watcher_task
+    await ctx.shutdown()
 
     if ui_task:
         await ui_task
@@ -978,4 +1134,3 @@ if __name__ == '__main__':
     loop.run_until_complete(main())
     loop.close()
     colorama.deinit()
-    atexit.unregister(exit_func)

Utils.py

@@ -1,6 +1,16 @@
 from __future__ import annotations
 
 import typing
+import builtins
+import os
+import subprocess
+import sys
+import pickle
+import functools
+import io
+import collections
+import importlib
+import logging
 
 
 def tuplize_version(version: str) -> Version:
@@ -13,18 +23,9 @@ class Version(typing.NamedTuple):
     build: int
 
 
-__version__ = "0.1.7"
+__version__ = "0.2.1"
 version_tuple = tuplize_version(__version__)
 
-import builtins
-import os
-import subprocess
-import sys
-import pickle
-import functools
-import io
-import collections
-
 from yaml import load, dump, safe_load
 
 try:
@@ -120,17 +121,25 @@ parse_yaml = safe_load
 unsafe_parse_yaml = functools.partial(load, Loader=Loader)
 
 
+def get_cert_none_ssl_context():
+    import ssl
+    ctx = ssl.create_default_context()
+    ctx.check_hostname = False
+    ctx.verify_mode = ssl.CERT_NONE
+    return ctx
+
+
 @cache_argsless
 def get_public_ipv4() -> str:
     import socket
     import urllib.request
-    import logging
     ip = socket.gethostbyname(socket.gethostname())
+    ctx = get_cert_none_ssl_context()
     try:
-        ip = urllib.request.urlopen('https://checkip.amazonaws.com/').read().decode('utf8').strip()
+        ip = urllib.request.urlopen('https://checkip.amazonaws.com/', context=ctx).read().decode('utf8').strip()
     except Exception as e:
         try:
-            ip = urllib.request.urlopen('https://v4.ident.me').read().decode('utf8').strip()
+            ip = urllib.request.urlopen('https://v4.ident.me', context=ctx).read().decode('utf8').strip()
         except:
             logging.exception(e)
             pass  # we could be offline, in a local game, so no point in erroring out
@@ -141,10 +150,10 @@ def get_public_ipv4() -> str:
 def get_public_ipv6() -> str:
     import socket
     import urllib.request
-    import logging
     ip = socket.gethostbyname(socket.gethostname())
+    ctx = get_cert_none_ssl_context()
     try:
-        ip = urllib.request.urlopen('https://v6.ident.me').read().decode('utf8').strip()
+        ip = urllib.request.urlopen('https://v6.ident.me', context=ctx).read().decode('utf8').strip()
     except Exception as e:
         logging.exception(e)
         pass  # we could be offline, in a local game, or ipv6 may not be available
@@ -161,6 +170,14 @@ def get_default_options() -> dict:
         "factorio_options": {
             "executable": "factorio\\bin\\x64\\factorio",
         },
+        "sm_options": {
+            "rom_file": "Super Metroid (JU).sfc",
+            "sni": "SNI",
+            "rom_start": True,
+        },
+        "soe_options": {
+            "rom_file": "Secret of Evermore (USA).sfc",
+        },
         "lttp_options": {
             "rom_file": "Zelda no Densetsu - Kamigami no Triforce (Japan).sfc",
             "sni": "SNI",
@@ -180,6 +197,7 @@ def get_default_options() -> dict:
             "location_check_points": 1,
             "hint_cost": 10,
             "forfeit_mode": "goal",
+            "collect_mode": "disabled",
             "remaining_mode": "goal",
             "auto_shutdown": 0,
             "compatibility": 2,
@@ -210,7 +228,6 @@ def get_default_options() -> dict:
 
 
 def update_options(src: dict, dest: dict, filename: str, keys: list) -> dict:
-    import logging
     for key, value in src.items():
         new_keys = keys.copy()
         new_keys.append(key)
@@ -277,7 +294,6 @@ def persistent_load() -> typing.Dict[dict]:
             with open(path, "r") as f:
                 storage = unsafe_parse_yaml(f.read())
         except Exception as e:
-            import logging
             logging.debug(f"Could not read store: {e}")
     if storage is None:
         storage = {}
@@ -310,7 +326,6 @@ def get_adjuster_settings(romfile: str, skip_questions: bool = False) -> typing.
             if sprite_pool:
                 printed_options["sprite_pool"] = sprite_pool
 
-
         if hasattr(get_adjuster_settings, "adjust_wanted"):
             adjust_wanted = getattr(get_adjuster_settings, "adjust_wanted")
         elif persistent_load().get("adjuster", {}).get("never_adjust", False):  # never adjust, per user request
@@ -337,7 +352,6 @@ def get_adjuster_settings(romfile: str, skip_questions: bool = False) -> typing.
             return romfile, False
         else:
             adjusted = False
-            import logging
             if not hasattr(get_adjuster_settings, "adjust_wanted"):
                 logging.info(f"Skipping post-patch adjustment")
         get_adjuster_settings.adjuster_settings = adjuster_settings
@@ -365,16 +379,28 @@ safe_builtins = {
 
 
 class RestrictedUnpickler(pickle.Unpickler):
+    def __init__(self, *args, **kwargs):
+        super(RestrictedUnpickler, self).__init__(*args, **kwargs)
+        self.options_module = importlib.import_module("Options")
+        self.net_utils_module = importlib.import_module("NetUtils")
+        self.generic_properties_module = importlib.import_module("worlds.generic")
+
     def find_class(self, module, name):
         if module == "builtins" and name in safe_builtins:
             return getattr(builtins, name)
+        # used by MultiServer -> savegame/multidata
         if module == "NetUtils" and name in {"NetworkItem", "ClientStatus", "Hint"}:
-            import NetUtils
-            return getattr(NetUtils, name)
-        if module == "Options":
-            import Options
-            obj = getattr(Options, name)
-            if issubclass(obj, Options.Option):
+            return getattr(self.net_utils_module, name)
+        # Options and Plando are unpickled by WebHost -> Generate
+        if module == "worlds.generic" and name in {"PlandoItem", "PlandoConnection"}:
+            return getattr(self.generic_properties_module, name)
+        if module.endswith("Options"):
+            if module == "Options":
+                mod = self.options_module
+            else:
+                mod = importlib.import_module(module)
+            obj = getattr(mod, name)
+            if issubclass(obj, self.options_module.Option):
                 return obj
         # Forbid everything else.
         raise pickle.UnpicklingError("global '%s.%s' is forbidden" %
@@ -389,4 +415,62 @@ def restricted_loads(s):
 class KeyedDefaultDict(collections.defaultdict):
     def __missing__(self, key):
         self[key] = value = self.default_factory(key)
-        return value
+        return value
+
+
+def get_text_between(text: str, start: str, end: str) -> str:
+    return text[text.index(start) + len(start): text.rindex(end)]
+
+
+loglevel_mapping = {'error': logging.ERROR, 'info': logging.INFO, 'warning': logging.WARNING, 'debug': logging.DEBUG}
+
+
+def init_logging(name: str, loglevel: typing.Union[str, int] = logging.INFO, write_mode: str = "w",
+                 log_format: str = "[%(name)s]: %(message)s", exception_logger: str = ""):
+    loglevel: int = loglevel_mapping.get(loglevel, loglevel)
+    log_folder = local_path("logs")
+    os.makedirs(log_folder, exist_ok=True)
+    root_logger = logging.getLogger()
+    for handler in root_logger.handlers[:]:
+        root_logger.removeHandler(handler)
+        handler.close()
+    root_logger.setLevel(loglevel)
+    file_handler = logging.FileHandler(
+        os.path.join(log_folder, f"{name}.txt"),
+        write_mode,
+        encoding="utf-8-sig")
+    file_handler.setFormatter(logging.Formatter(log_format))
+    root_logger.addHandler(file_handler)
+    if sys.stdout:
+        root_logger.addHandler(
+            logging.StreamHandler(sys.stdout)
+        )
+
+    # Relay unhandled exceptions to logger.
+    if not getattr(sys.excepthook, "_wrapped", False):  # skip if already modified
+        orig_hook = sys.excepthook
+
+        def handle_exception(exc_type, exc_value, exc_traceback):
+            if issubclass(exc_type, KeyboardInterrupt):
+                sys.__excepthook__(exc_type, exc_value, exc_traceback)
+                return
+            logging.getLogger(exception_logger).exception("Uncaught exception",
+                                                          exc_info=(exc_type, exc_value, exc_traceback))
+            return orig_hook(exc_type, exc_value, exc_traceback)
+
+        handle_exception._wrapped = True
+
+        sys.excepthook = handle_exception
+
+
+def stream_input(stream, queue):
+    def queuer():
+        while 1:
+            text = stream.readline().strip()
+            if text:
+                queue.put_nowait(text)
+
+    from threading import Thread
+    thread = Thread(target=queuer, name=f"Stream handler for {stream.name}", daemon=True)
+    thread.start()
+    return thread

WebHost.py

@@ -36,7 +36,11 @@ if __name__ == "__main__":
     multiprocessing.freeze_support()
     multiprocessing.set_start_method('spawn')
     logging.basicConfig(format='[%(asctime)s] %(message)s', level=logging.INFO)
-    update_sprites_lttp()
+    try:
+        update_sprites_lttp()
+    except Exception as e:
+        logging.exception(e)
+        logging.warning("Could not update LttP sprites.")
     app = get_app()
     create_options_files()
     if app.config["SELFLAUNCH"]:

WebHostLib/__init__.py

@@ -28,7 +28,7 @@ app.config["SELFLAUNCH"] = True
 app.config["DEBUG"] = False
 app.config["PORT"] = 80
 app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
-app.config['MAX_CONTENT_LENGTH'] = 4 * 1024 * 1024  # 4 megabyte limit
+app.config['MAX_CONTENT_LENGTH'] = 64 * 1024 * 1024  # 64 megabyte limit
 # if you want to deploy, make sure you have a non-guessable secret key
 app.config["SECRET_KEY"] = bytes(socket.gethostname(), encoding="utf-8")
 # at what amount of worlds should scheduling be used, instead of rolling in the webthread
@@ -82,22 +82,22 @@ def page_not_found(err):
     return render_template('404.html'), 404
 
 
+# Start Playing Page
+@app.route('/start-playing')
+def start_playing():
+    return render_template(f"startPlaying.html")
+
+
 # Player settings pages
 @app.route('/games/<string:game>/player-settings')
 def player_settings(game):
     return render_template(f"player-settings.html", game=game)
 
 
-# Game sub-pages
-@app.route('/games/<string:game>/<string:page>')
-def game_pages(game, page):
-    return render_template(f"/games/{game}/{page}.html")
-
-
-# Game landing pages
-@app.route('/games/<game>')
-def game_page(game):
-    return render_template(f"/games/{game}/{game}.html")
+# Game Info Pages
+@app.route('/games/<string:game>/info/<string:lang>')
+def game_info(game, lang):
+    return render_template('gameInfo.html', game=game, lang=lang)
 
 
 # List of supported games
@@ -107,7 +107,7 @@ def games():
     for game, world in AutoWorldRegister.world_types.items():
         if not world.hidden:
             worlds[game] = world.__doc__ if world.__doc__ else "No description provided."
-    return render_template("games/games.html", worlds=worlds)
+    return render_template("supportedGames.html", worlds=worlds)
 
 
 @app.route('/tutorial/<string:game>/<string:file>/<string:lang>')
@@ -126,7 +126,7 @@ def faq(lang):
 
 
 @app.route('/seed/<suuid:seed>')
-def viewSeed(seed: UUID):
+def view_seed(seed: UUID):
     seed = Seed.get(id=seed)
     if not seed:
         abort(404)
@@ -141,7 +141,7 @@ def new_room(seed: UUID):
         abort(404)
     room = Room(seed=seed, owner=session["_id"], tracker=uuid4())
     commit()
-    return redirect(url_for("hostRoom", room=room.id))
+    return redirect(url_for("host_room", room=room.id))
 
 
 def _read_log(path: str):
@@ -155,12 +155,11 @@ def _read_log(path: str):
 
 @app.route('/log/<suuid:room>')
 def display_log(room: UUID):
-    # noinspection PyTypeChecker
     return Response(_read_log(os.path.join("logs", str(room) + ".txt")), mimetype="text/plain;charset=UTF-8")
 
 
 @app.route('/room/<suuid:room>', methods=['GET', 'POST'])
-def hostRoom(room: UUID):
+def host_room(room: UUID):
     room = Room.get(id=room)
     if room is None:
         return abort(404)
@@ -176,17 +175,17 @@ def hostRoom(room: UUID):
     return render_template("hostRoom.html", room=room)
 
 
-@app.route('/hosted/<suuid:room>', methods=['GET', 'POST'])
-def hostRoomRedirect(room: UUID):
-    return redirect(url_for("hostRoom", room=room))
-
-
 @app.route('/favicon.ico')
 def favicon():
     return send_from_directory(os.path.join(app.root_path, 'static/static'),
                                'favicon.ico', mimetype='image/vnd.microsoft.icon')
 
 
+@app.route('/discord')
+def discord():
+    return redirect("https://discord.gg/archipelago")
+
+
 from WebHostLib.customserver import run_server_process
 from . import tracker, upload, landing, check, generate, downloads, api  # to trigger app routing picking up on it
 

WebHostLib/api/generate.py

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

WebHostLib/autolauncher.py

@@ -89,7 +89,7 @@ def launch_generator(pool: multiprocessing.pool.Pool, generation: Generation):
         options = restricted_loads(generation.options)
         logging.info(f"Generating {generation.id} for {len(options)} players")
         pool.apply_async(gen_game, (options,),
-                         {"race": meta["race"],
+                         {"meta": meta,
                           "sid": generation.id,
                           "owner": generation.owner},
                          handle_generation_success, handle_generation_failure)

WebHostLib/check.py

@@ -49,9 +49,7 @@ def get_yaml_data(file) -> Union[Dict[str, str], str]:
                 for file in infolist:
                     if file.filename.endswith(banned_zip_contents):
                         return "Uploaded data contained a rom file, which is likely to contain copyrighted material. Your file was deleted."
-                    elif file.filename.endswith(".yaml"):
-                        options[file.filename] = zfile.open(file, "r").read()
-                    elif file.filename.endswith(".txt"):
+                    elif file.filename.endswith((".yaml", ".json", ".yml", ".txt")):
                         options[file.filename] = zfile.open(file, "r").read()
         else:
             options = {file.filename: file.read()}
@@ -73,7 +71,8 @@ def roll_options(options: Dict[str, Union[dict, str]]) -> Tuple[Dict[str, Union[
             results[filename] = f"Failed to parse YAML data in {filename}: {e}"
         else:
             try:
-                rolled_results[filename] = roll_settings(yaml_data, plando_options={"bosses"})
+                rolled_results[filename] = roll_settings(yaml_data,
+                                                         plando_options={"bosses", "items", "connections", "texts"})
             except Exception as e:
                 results[filename] = f"Failed to generate mystery in {filename}: {e}"
             else:

WebHostLib/customserver.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 import functools
 import logging
-import os
 import websockets
 import asyncio
 import socket
@@ -11,7 +10,7 @@ import time
 import random
 import pickle
 
-
+import Utils
 from .models import *
 
 from MultiServer import Context, server, auto_shutdown, ServerCommandProcessor, ClientMessageProcessor
@@ -20,6 +19,7 @@ from Utils import get_public_ipv4, get_public_ipv6, restricted_loads
 
 class CustomClientMessageProcessor(ClientMessageProcessor):
     ctx: WebHostContext
+
     def _cmd_video(self, platform, user):
         """Set a link for your name in the WebHostLib tracker pointing to a video stream"""
         if platform.lower().startswith("t"):  # twitch
@@ -37,6 +37,7 @@ class CustomClientMessageProcessor(ClientMessageProcessor):
 
 # inject
 import MultiServer
+
 MultiServer.client_message_processor = CustomClientMessageProcessor
 del (MultiServer)
 
@@ -48,7 +49,7 @@ class DBCommandProcessor(ServerCommandProcessor):
 
 class WebHostContext(Context):
     def __init__(self):
-        super(WebHostContext, self).__init__("", 0, "", "", 1, 40, True, "enabled", "enabled", 0, 2)
+        super(WebHostContext, self).__init__("", 0, "", "", 1, 40, True, "enabled", "enabled", "enabled", 0, 2)
         self.main_loop = asyncio.get_running_loop()
         self.video = {}
         self.tags = ["AP", "WebHost"]
@@ -56,7 +57,7 @@ class WebHostContext(Context):
     def listen_to_db_commands(self):
         cmdprocessor = DBCommandProcessor(self)
 
-        while self.running:
+        while not self.exit_event.is_set():
             with db_session:
                 commands = select(command for command in Command if command.room.id == self.room_id)
                 if commands:
@@ -88,11 +89,11 @@ class WebHostContext(Context):
         threading.Thread(target=self.listen_to_db_commands, daemon=True).start()
 
     @db_session
-    def _save(self, exit_save:bool = False) -> bool:
+    def _save(self, exit_save: bool = False) -> bool:
         room = Room.get(id=self.room_id)
         room.multisave = pickle.dumps(self.get_save())
         # saving only occurs on activity, so we can "abuse" this information to mark this as last_activity
-        if not exit_save: # we don't want to count a shutdown as activity, which would restart the server again
+        if not exit_save:  # we don't want to count a shutdown as activity, which would restart the server again
             room.last_activity = datetime.utcnow()
         return True
 
@@ -101,6 +102,7 @@ class WebHostContext(Context):
         d["video"] = [(tuple(playerslot), videodata) for playerslot, videodata in self.video.items()]
         return d
 
+
 def get_random_port():
     return random.randint(49152, 65535)
 
@@ -111,11 +113,7 @@ def run_server_process(room_id, ponyconfig: dict):
     db.generate_mapping(check_tables=False)
 
     async def main():
-
-        logging.basicConfig(format='[%(asctime)s] %(message)s',
-                            level=logging.INFO,
-                            handlers=[
-                                logging.FileHandler(os.path.join(LOGS_FOLDER, f"{room_id}.txt"), 'a', 'utf-8-sig')])
+        Utils.init_logging(str(room_id), write_mode="a")
         ctx = WebHostContext()
         ctx.load(room_id)
         ctx.init_save()

WebHostLib/downloads.py

@@ -1,10 +1,11 @@
 from flask import send_file, Response, render_template
 from pony.orm import select
 
-from Patch import update_patch_data
+from Patch import update_patch_data, preferred_endings
 from WebHostLib import app, Slot, Room, Seed, cache
 import zipfile
 
+
 @app.route("/dl_patch/<suuid:room_id>/<int:patch_id>")
 def download_patch(room_id, patch_id):
     patch = Slot.get(id=patch_id)
@@ -19,7 +20,8 @@ def download_patch(room_id, patch_id):
         patch_data = update_patch_data(patch.data, server=f"{app.config['PATCH_TARGET']}:{last_port}")
         patch_data = io.BytesIO(patch_data)
 
-        fname = f"P{patch.player_id}_{patch.player_name}_{app.jinja_env.filters['suuid'](room_id)}.apbp"
+        fname = f"P{patch.player_id}_{patch.player_name}_{app.jinja_env.filters['suuid'](room_id)}." \
+                f"{preferred_endings[patch.game]}"
         return send_file(patch_data, as_attachment=True, attachment_filename=fname)
 
 
@@ -28,23 +30,6 @@ def download_spoiler(seed_id):
     return Response(Seed.get(id=seed_id).spoiler, mimetype="text/plain")
 
 
-@app.route("/dl_raw_patch/<suuid:seed_id>/<int:player_id>")
-def download_raw_patch(seed_id, player_id: int):
-    seed = Seed.get(id=seed_id)
-    patch = select(patch for patch in seed.slots if
-                   patch.player_id == player_id).first()
-
-    if not patch:
-        return "Patch not found"
-    else:
-        import io
-
-        patch_data = update_patch_data(patch.data, server="")
-        patch_data = io.BytesIO(patch_data)
-
-        fname = f"P{patch.player_id}_{patch.player_name}_{app.jinja_env.filters['suuid'](seed_id)}.apbp"
-        return send_file(patch_data, as_attachment=True, attachment_filename=fname)
-
 @app.route("/slot_file/<suuid:room_id>/<int:player_id>")
 def download_slot_file(room_id, player_id: int):
     room = Room.get(id=room_id)

WebHostLib/generate.py

@@ -2,19 +2,32 @@ import os
 import tempfile
 import random
 import json
+import zipfile
 from collections import Counter
+from typing import Dict, Optional as TypeOptional
 
 from flask import request, flash, redirect, url_for, session, render_template
 
 from worlds.alttp.EntranceRandomizer import parse_arguments
 from Main import main as ERmain
-from Main import get_seed, seeddigits
+from BaseClasses import seeddigits, get_seed
 from Generate import handle_name
 import pickle
 
 from .models import *
 from WebHostLib import app
 from .check import get_yaml_data, roll_options
+from .upload import upload_zip_to_db
+
+
+def get_meta(options_source: dict) -> dict:
+    meta = {
+        "hint_cost": int(options_source.get("hint_cost", 10)),
+        "forfeit_mode": options_source.get("forfeit_mode", "goal"),
+        "remaining_mode": options_source.get("forfeit_mode", "disabled"),
+        "collect_mode": options_source.get("collect_mode", "disabled"),
+    }
+    return meta
 
 
 @app.route('/generate', methods=['GET', 'POST'])
@@ -31,6 +44,14 @@ def generate(race=False):
                 flash(options)
             else:
                 results, gen_options = roll_options(options)
+                # get form data -> server settings
+                meta = get_meta(request.form)
+                meta["race"] = race
+
+                if race:
+                    meta["item_cheat"] = False
+                    meta["remaining"] = False
+
                 if any(type(result) == str for result in results.values()):
                     return render_template("checkResult.html", results=results)
                 elif len(gen_options) > app.config["MAX_ROLL"]:
@@ -40,7 +61,8 @@ def generate(race=False):
                     gen = Generation(
                         options=pickle.dumps({name: vars(options) for name, options in gen_options.items()}),
                         # convert to json compatible
-                        meta=json.dumps({"race": race}), state=STATE_QUEUED,
+                        meta=json.dumps(meta),
+                        state=STATE_QUEUED,
                         owner=session["_id"])
                     commit()
 
@@ -48,18 +70,24 @@ def generate(race=False):
                 else:
                     try:
                         seed_id = gen_game({name: vars(options) for name, options in gen_options.items()},
-                                           race=race, owner=session["_id"].int)
+                                           meta=meta, owner=session["_id"].int)
                     except BaseException as e:
                         from .autolauncher import handle_generation_failure
                         handle_generation_failure(e)
-                        return render_template("seedError.html", seed_error=(e.__class__.__name__ + ": "+ str(e)))
+                        return render_template("seedError.html", seed_error=(e.__class__.__name__ + ": " + str(e)))
 
-                    return redirect(url_for("viewSeed", seed=seed_id))
+                    return redirect(url_for("view_seed", seed=seed_id))
 
     return render_template("generate.html", race=race)
 
 
-def gen_game(gen_options, race=False, owner=None, sid=None):
+def gen_game(gen_options, meta: TypeOptional[Dict[str, object]] = None, owner=None, sid=None):
+    if not meta:
+        meta: Dict[str, object] = {}
+
+    meta.setdefault("hint_cost", 10)
+    race = meta.get("race", False)
+    del (meta["race"])
     try:
         target = tempfile.TemporaryDirectory()
         playercount = len(gen_options)
@@ -69,14 +97,13 @@ def gen_game(gen_options, race=False, owner=None, sid=None):
         if race:
             random.seed()  # reset to time-based random source
 
-        seedname = "M" + (f"{random.randint(0, pow(10, seeddigits) - 1)}".zfill(seeddigits))
+        seedname = "W" + (f"{random.randint(0, pow(10, seeddigits) - 1)}".zfill(seeddigits))
 
         erargs = parse_arguments(['--multi', str(playercount)])
         erargs.seed = seed
         erargs.name = {x: "" for x in range(1, playercount + 1)}  # only so it can be overwrittin in mystery
-        erargs.create_spoiler = not race
+        erargs.spoiler = 0 if race else 2
         erargs.race = race
-        erargs.skip_playthrough = race
         erargs.outputname = seedname
         erargs.outputpath = target.name
         erargs.teams = 1
@@ -85,15 +112,18 @@ def gen_game(gen_options, race=False, owner=None, sid=None):
         for player, (playerfile, settings) in enumerate(gen_options.items(), 1):
             for k, v in settings.items():
                 if v is not None:
-                    getattr(erargs, k)[player] = v
+                    if hasattr(erargs, k):
+                        getattr(erargs, k)[player] = v
+                    else:
+                        setattr(erargs, k, {player: v})
 
             if not erargs.name[player]:
                 erargs.name[player] = os.path.splitext(os.path.split(playerfile)[-1])[0]
             erargs.name[player] = handle_name(erargs.name[player], player, name_counter)
 
-        ERmain(erargs, seed)
+        ERmain(erargs, seed, baked_server_options=meta)
 
-        return upload_to_db(target.name, owner, sid, race)
+        return upload_to_db(target.name, sid, owner, race)
     except BaseException as e:
         if sid:
             with db_session:
@@ -101,7 +131,7 @@ def gen_game(gen_options, race=False, owner=None, sid=None):
                 if gen is not None:
                     gen.state = STATE_ERROR
                     meta = json.loads(gen.meta)
-                    meta["error"] = (e.__class__.__name__ + ": "+ str(e))
+                    meta["error"] = (e.__class__.__name__ + ": " + str(e))
                     gen.meta = json.dumps(meta)
 
                     commit()
@@ -113,7 +143,7 @@ def wait_seed(seed: UUID):
     seed_id = seed
     seed = Seed.get(id=seed_id)
     if seed:
-        return redirect(url_for("viewSeed", seed=seed_id))
+        return redirect(url_for("view_seed", seed=seed_id))
     generation = Generation.get(id=seed_id)
 
     if not generation:
@@ -123,37 +153,19 @@ def wait_seed(seed: UUID):
     return render_template("waitSeed.html", seed_id=seed_id)
 
 
-def upload_to_db(folder, owner, sid, race:bool):
-    slots = set()
-    spoiler = ""
-
-    multidata = None
+def upload_to_db(folder, sid, owner, race):
     for file in os.listdir(folder):
         file = os.path.join(folder, file)
-        if file.endswith(".apbp"):
-            player_text = file.split("_P", 1)[1]
-            player_name = player_text.split("_", 1)[1].split(".", 1)[0]
-            player_id = int(player_text.split(".", 1)[0].split("_", 1)[0])
-            slots.add(Slot(data=open(file, "rb").read(),
-                             player_id=player_id, player_name = player_name, game = "A Link to the Past"))
-        elif file.endswith(".txt"):
-            spoiler = open(file, "rt", encoding="utf-8-sig").read()
-        elif file.endswith(".archipelago"):
-            multidata = open(file, "rb").read()
-    if multidata:
-        with db_session:
-            if sid:
-                seed = Seed(multidata=multidata, spoiler=spoiler, slots=slots, owner=owner,
-                            id=sid, meta=json.dumps({"race": race, "tags": ["generated"]}))
-            else:
-                seed = Seed(multidata=multidata, spoiler=spoiler, slots=slots, owner=owner,
-                            meta=json.dumps({"race": race, "tags": ["generated"]}))
-            for patch in slots:
-                patch.seed = seed
-            if sid:
-                gen = Generation.get(id=sid)
-                if gen is not None:
-                    gen.delete()
-        return seed.id
-    else:
-        raise Exception("Multidata required (.archipelago), but not found.")
+        if file.endswith(".zip"):
+            with db_session:
+                with zipfile.ZipFile(file) as zfile:
+                    res = upload_zip_to_db(zfile, owner, {"race": race}, sid)
+                if type(res) == "str":
+                    raise Exception(res)
+                elif res:
+                    seed = res
+                    gen = Generation.get(id=seed.id)
+                    if gen is not None:
+                        gen.delete()
+                    return seed.id
+    raise Exception("Generation zipfile not found.")

WebHostLib/models.py

@@ -40,7 +40,7 @@ class Seed(db.Entity):
     creation_time = Required(datetime, default=lambda: datetime.utcnow())
     slots = Set(Slot)
     spoiler = Optional(LongStr, lazy=True)
-    meta = Required(str, default=lambda: "{\"race\": false}")  # additional meta information/tags
+    meta = Required(LongStr, default=lambda: "{\"race\": false}")  # additional meta information/tags
 
 
 class Command(db.Entity):
@@ -53,5 +53,5 @@ class Generation(db.Entity):
     id = PrimaryKey(UUID, default=uuid4)
     owner = Required(UUID)
     options = Required(buffer, lazy=True)
-    meta = Required(str, default=lambda: "{\"race\": false}")
+    meta = Required(LongStr, default=lambda: "{\"race\": false}")
     state = Required(int, default=0, index=True)

WebHostLib/options.py

@@ -5,6 +5,7 @@ import yaml
 import json
 
 from worlds.AutoWorld import AutoWorldRegister
+import Options
 
 target_folder = os.path.join("WebHostLib", "static", "generated")
 
@@ -18,19 +19,29 @@ def create():
             option.range_end: "maximum value"
         }
         return data, notes
+
+    def default_converter(default_value):
+        if isinstance(default_value, (set, frozenset)):
+            return list(default_value)
+        return default_value
+
     for game_name, world in AutoWorldRegister.world_types.items():
         res = Template(open(os.path.join("WebHostLib", "templates", "options.yaml")).read()).render(
-            options=world.options, __version__=__version__, game=game_name, yaml_dump=yaml.dump,
-            dictify_range=dictify_range
+            options={**world.options, **Options.per_game_common_options},
+            __version__=__version__, game=game_name, yaml_dump=yaml.dump,
+            dictify_range=dictify_range, default_converter=default_converter,
         )
 
-        with open(os.path.join(target_folder, game_name + ".yaml"), "w") as f:
+        os.makedirs(os.path.join(target_folder, 'configs'), exist_ok=True)
+
+        with open(os.path.join(target_folder, 'configs', game_name + ".yaml"), "w") as f:
             f.write(res)
 
         # Generate JSON files for player-settings pages
         player_settings = {
             "baseOptions": {
                 "description": "Generated by https://archipelago.gg/",
+                "game": game_name,
                 "name": "Player",
             },
         }
@@ -38,7 +49,7 @@ def create():
         game_options = {}
         for option_name, option in world.options.items():
             if option.options:
-                this_option = {
+                game_options[option_name] = this_option = {
                     "type": "select",
                     "displayName": option.displayname if hasattr(option, "displayname") else option_name,
                     "description": option.__doc__ if option.__doc__ else "Please document me!",
@@ -46,7 +57,7 @@ def create():
                     "options": []
                 }
 
-                for sub_option_name, sub_option_id in option.options.items():
+                for sub_option_id, sub_option_name in option.name_lookup.items():
                     this_option["options"].append({
                         "name": option.get_option_name(sub_option_id),
                         "value": sub_option_name,
@@ -55,7 +66,10 @@ def create():
                     if sub_option_id == option.default:
                         this_option["defaultValue"] = sub_option_name
 
-                game_options[option_name] = this_option
+                this_option["options"].append({
+                    "name": "Random",
+                    "value": "random",
+                })
 
             elif hasattr(option, "range_start") and hasattr(option, "range_end"):
                 game_options[option_name] = {
@@ -69,5 +83,7 @@ def create():
 
         player_settings["gameOptions"] = game_options
 
-        with open(os.path.join(target_folder, game_name + ".json"), "w") as f:
+        os.makedirs(os.path.join(target_folder, 'player-settings'), exist_ok=True)
+
+        with open(os.path.join(target_folder, 'player-settings', game_name + ".json"), "w") as f:
             f.write(json.dumps(player_settings, indent=2, separators=(',', ': ')))

WebHostLib/requirements.txt

@@ -1,4 +1,4 @@
-flask>=2.0.1
+flask>=2.0.2
 pony>=0.7.14
 waitress>=2.0.0
 flask-caching>=1.10.1

WebHostLib/static/assets/faq.js

@@ -19,6 +19,9 @@ window.addEventListener('load', () => {
         ajax.send();
     }).then((results) => {
         // Populate page with HTML generated from markdown
+        showdown.setOption('tables', true);
+        showdown.setOption('strikethrough', true);
+        showdown.setOption('literalMidWordUnderscores', true);
         tutorialWrapper.innerHTML += (new showdown.Converter()).makeHtml(results);
         adjustHeaderWidth();
 

WebHostLib/static/assets/faq/faq_en.md

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

WebHostLib/static/assets/gameInfo.js

@@ -0,0 +1,53 @@
+window.addEventListener('load', () => {
+    const gameInfo = document.getElementById('game-info');
+    new Promise((resolve, reject) => {
+        const ajax = new XMLHttpRequest();
+        ajax.onreadystatechange = () => {
+            if (ajax.readyState !== 4) { return; }
+            if (ajax.status === 404) {
+                reject("Sorry, this game's info page is not available in that language yet.");
+                return;
+            }
+            if (ajax.status !== 200) {
+                reject("Something went wrong while loading the info page.");
+                return;
+            }
+            resolve(ajax.responseText);
+        };
+        ajax.open('GET', `${window.location.origin}/static/assets/gameInfo/` +
+          `${gameInfo.getAttribute('data-lang')}_${gameInfo.getAttribute('data-game')}.md`, true);
+        ajax.send();
+    }).then((results) => {
+        // Populate page with HTML generated from markdown
+        showdown.setOption('tables', true);
+        showdown.setOption('strikethrough', true);
+        showdown.setOption('literalMidWordUnderscores', true);
+        gameInfo.innerHTML += (new showdown.Converter()).makeHtml(results);
+        adjustHeaderWidth();
+
+        // Reset the id of all header divs to something nicer
+        const headers = Array.from(document.querySelectorAll('h1, h2, h3, h4, h5, h6'));
+        const scrollTargetIndex = window.location.href.search(/#[A-z0-9-_]*$/);
+        for (let i=0; i < headers.length; i++){
+            const headerId = headers[i].innerText.replace(/[ ]/g,'-').toLowerCase()
+            headers[i].setAttribute('id', headerId);
+            headers[i].addEventListener('click', () =>
+                window.location.href = window.location.href.substring(0, scrollTargetIndex) + `#${headerId}`);
+        }
+
+        // Manually scroll the user to the appropriate header if anchor navigation is used
+        if (scrollTargetIndex > -1) {
+            try{
+                const scrollTarget = window.location.href.substring(scrollTargetIndex + 1);
+                document.getElementById(scrollTarget).scrollIntoView({ behavior: "smooth" });
+            } catch(error) {
+                console.error(error);
+            }
+        }
+    }).catch((error) => {
+        console.error(error);
+        gameInfo.innerHTML =
+            `<h2>This page is out of logic!</h2>
+            <h3>Click <a href="${window.location.origin}">here</a> to return to safety.</h3>`;
+    });
+});

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

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

WebHostLib/static/assets/gameInfo/en_Factorio.md

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

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

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

WebHostLib/static/assets/gameInfo/en_Minecraft.md

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

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

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

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

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

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

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

WebHostLib/static/assets/gameInfo/en_Subnautica.md

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

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

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

WebHostLib/static/assets/gameInfo/en_Timespinner.md

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

WebHostLib/static/assets/md5.min.js

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

WebHostLib/static/assets/ootTracker.js

@@ -0,0 +1,52 @@
+window.addEventListener('load', () => {
+  // Reload tracker every 15 seconds
+  const url = window.location;
+  setInterval(() => {
+    const ajax = new XMLHttpRequest();
+    ajax.onreadystatechange = () => {
+      if (ajax.readyState !== 4) { return; }
+
+      // Create a fake DOM using the returned HTML
+      const domParser = new DOMParser();
+      const fakeDOM = domParser.parseFromString(ajax.responseText, 'text/html');
+
+      // Update item tracker
+      document.getElementById('inventory-table').innerHTML = fakeDOM.getElementById('inventory-table').innerHTML;
+      // Update only counters, small keys, and boss keys in the location-table
+      const types = ['counter', 'smallkeys', 'bosskeys'];
+      for (let j = 0; j < types.length; j++) {
+        let counters = document.getElementsByClassName(types[j]);
+        const fakeCounters = fakeDOM.getElementsByClassName(types[j]);
+        for (let i = 0; i < counters.length; i++) {
+          counters[i].innerHTML = fakeCounters[i].innerHTML;
+        }
+      }
+    };
+    ajax.open('GET', url);
+    ajax.send();
+  }, 15000)
+
+  // Collapsible advancement sections
+  const categories = document.getElementsByClassName("location-category");
+  for (let i = 0; i < categories.length; i++) {
+    let hide_id = categories[i].id.split('-')[0];
+    if (hide_id == 'Total') {
+      continue;
+    }
+    categories[i].addEventListener('click', function() {
+      // Toggle the advancement list
+      document.getElementById(hide_id).classList.toggle("hide");
+      // Change text of the header
+      const tab_header = document.getElementById(hide_id+'-header').children[0];
+      const orig_text = tab_header.innerHTML;
+      let new_text;
+      if (orig_text.includes("▼")) {
+        new_text = orig_text.replace("▼", "▲");
+      }
+      else {
+        new_text = orig_text.replace("▲", "▼");
+      }
+      tab_header.innerHTML = new_text;
+    });
+  }
+});

WebHostLib/static/assets/player-settings.js

@@ -4,9 +4,25 @@ window.addEventListener('load', () => {
   gameName = document.getElementById('player-settings').getAttribute('data-game');
 
   // Update game name on page
-  document.getElementById('game-name').innerHTML = gameName;
+  document.getElementById('game-name').innerText = gameName;
 
   Promise.all([fetchSettingData()]).then((results) => {
+    let settingHash = localStorage.getItem(`${gameName}-hash`);
+    if (!settingHash) {
+      // If no hash data has been set before, set it now
+      localStorage.setItem(`${gameName}-hash`, md5(results[0]));
+      localStorage.removeItem(gameName);
+      settingHash = md5(results[0]);
+    }
+
+    if (settingHash !== md5(results[0])) {
+      const userMessage = document.getElementById('user-message');
+      userMessage.innerText = "Your settings are out of date! Click here to update them! Be aware this will reset " +
+        "them all to default.";
+      userMessage.style.display = "block";
+      userMessage.addEventListener('click', resetSettings);
+    }
+
     // Page setup
     createDefaultSettings(results[0]);
     buildUI(results[0]);
@@ -14,7 +30,7 @@ window.addEventListener('load', () => {
 
     // Event listeners
     document.getElementById('export-settings').addEventListener('click', () => exportSettings());
-    document.getElementById('generate-race').addEventListener('click', () => generateGame(true))
+    document.getElementById('generate-race').addEventListener('click', () => generateGame(true));
     document.getElementById('generate-game').addEventListener('click', () => generateGame());
 
     // Name input field
@@ -28,6 +44,12 @@ window.addEventListener('load', () => {
   })
 });
 
+const resetSettings = () => {
+  localStorage.removeItem(gameName);
+  localStorage.removeItem(`${gameName}-hash`)
+  window.location.reload();
+};
+
 const fetchSettingData = () => new Promise((resolve, reject) => {
   const ajax = new XMLHttpRequest();
   ajax.onreadystatechange = () => {
@@ -39,7 +61,7 @@ const fetchSettingData = () => new Promise((resolve, reject) => {
     try{ resolve(JSON.parse(ajax.responseText)); }
     catch(error){ reject(error); }
   };
-  ajax.open('GET', `${window.location.origin}/static/generated/${gameName}.json`, true);
+  ajax.open('GET', `${window.location.origin}/static/generated/player-settings/${gameName}.json`, true);
   ajax.send();
 });
 

WebHostLib/static/assets/timespinnerTracker.js

@@ -0,0 +1,49 @@
+window.addEventListener('load', () => {
+  // Reload tracker every 15 seconds
+  const url = window.location;
+  setInterval(() => {
+    const ajax = new XMLHttpRequest();
+    ajax.onreadystatechange = () => {
+      if (ajax.readyState !== 4) { return; }
+
+      // Create a fake DOM using the returned HTML
+      const domParser = new DOMParser();
+      const fakeDOM = domParser.parseFromString(ajax.responseText, 'text/html');
+
+      // Update item tracker
+      document.getElementById('inventory-table').innerHTML = fakeDOM.getElementById('inventory-table').innerHTML;
+      // Update only counters in the location-table
+      let counters = document.getElementsByClassName('counter');
+      const fakeCounters = fakeDOM.getElementsByClassName('counter');
+      for (let i = 0; i < counters.length; i++) {
+        counters[i].innerHTML = fakeCounters[i].innerHTML;
+      }
+    };
+    ajax.open('GET', url);
+    ajax.send();
+  }, 15000)
+
+  // Collapsible advancement sections
+  const categories = document.getElementsByClassName("location-category");
+  for (let i = 0; i < categories.length; i++) {
+    let hide_id = categories[i].id.split('-')[0];
+    if (hide_id == 'Total') {
+      continue;
+    }
+    categories[i].addEventListener('click', function() {
+      // Toggle the advancement list
+      document.getElementById(hide_id).classList.toggle("hide");
+      // Change text of the header
+      const tab_header = document.getElementById(hide_id+'-header').children[0];
+      const orig_text = tab_header.innerHTML;
+      let new_text;
+      if (orig_text.includes("▼")) {
+        new_text = orig_text.replace("▼", "▲");
+      }
+      else {
+        new_text = orig_text.replace("▲", "▼");
+      }
+      tab_header.innerHTML = new_text;
+    });
+  }
+});

WebHostLib/static/assets/tutorial.js

@@ -20,6 +20,9 @@ window.addEventListener('load', () => {
         ajax.send();
     }).then((results) => {
         // Populate page with HTML generated from markdown
+        showdown.setOption('tables', true);
+        showdown.setOption('strikethrough', true);
+        showdown.setOption('literalMidWordUnderscores', true);
         tutorialWrapper.innerHTML += (new showdown.Converter()).makeHtml(results);
         adjustHeaderWidth();
 

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

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

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

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

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

@@ -0,0 +1,180 @@
+# Archipelago Plando Guide
+
+## What is Plando?
+The purposes of randomizers is to randomize the items in a game to give a new experience.
+Plando takes this concept and changes it up by allowing you to plan out certain aspects of the game by placing certain 
+items in certain locations, certain bosses in certain rooms, edit text for certain NPCs/signs, or even force certain region
+connections. Each of these options are going to be detailed separately as `item plando`, `boss plando`, `text plando`, 
+and `connection plando`. Every game in archipelago supports item plando but the other plando options are only supported 
+by certain games. Currently, Minecraft and LTTP both support connection plando, but only LTTP supports text and boss plando.
+
+### Enabling Plando
+On the website plando will already be enabled. If you will be generating the game locally plando features must be enabled (opt-in).
+* To opt-in go to the archipelago installation (default: `C:\ProgramData\Archipelago`), open the host.yaml with a text
+editor and find the `plando_options` key. The available plando modules can be enabled by adding them after this such as
+`plando_options: bosses, items, texts, connections`.
+
+## Item Plando
+Item plando allows a player to place an item in a specific location or specific locations, place multiple items into
+a list of specific locations both in their own game or in another player's game. **Note that there's a very good chance that
+cross-game plando could very well be broken i.e. placing on of your items in someone else's world playing a different game.**
+* The options for item plando are `from_pool`, `world`, `percentage`, `force`, and either item and location, or items and locations.
+  * `from_pool` determines if the item should be taken *from* the item pool or *added* to it. This can be true or false
+and defaults to true if omitted.
+  * `world` is the target world to place the item in.
+    * It gets ignored if only one world is generated.
+    * Can be a number, name, true, false, or null. False is the default.
+      * If a number is used it targets that slot or player number in the multiworld.
+      * If a name is used it will target the world with that player name.
+      * If set to true it will be any player's world besides your own.
+      * If set to false it will target your own world.
+      * If set to null it will target a random world in the multiworld.
+  * `force` determines whether the generator will fail if the item can't be placed in the location can be true, false, 
+or silent. Silent is the default.
+    * If set to true the item must be placed and the generator will throw an error if it is unable to do so.
+    * If set to false the generator will log a warning if the placement can't be done but will still generate.
+    * If set to silent and the placement fails it will be ignored entirely.
+  * `percentage` is the percentage chance for the relevant block to trigger. This can be any value from 0 to 100 and if 
+omitted will default to 100.
+  * Single Placement is when you use a plando block to place a single item at a single location.
+    * `item` is the item you would like to place and `location` is the location to place it.
+  * Multi Placement uses a plando block to place multiple items in multiple locations until either list is exhausted.
+    * `items` defines the items to use and a number letting you place multiple of it.
+    * `locations` is a list of possible locations those items can be placed in.
+    * Using the multi placement method, placements are picked randomly.
+
+### Available Items
+* [A Link to the Past](https://github.com/ArchipelagoMW/Archipelago/blob/main/worlds/alttp/Items.py#L52)
+* [Factorio Non-Progressive](https://wiki.factorio.com/Technologies) Note that these use the *internal names*. For example, `advanced-electronics`
+* [Factorio Progressive](https://github.com/ArchipelagoMW/Archipelago/blob/main/worlds/factorio/Technologies.py#L374)
+* [Minecraft](https://github.com/ArchipelagoMW/Archipelago/blob/main/worlds/minecraft/Items.py#L14)
+* [Ocarina of Time](https://github.com/ArchipelagoMW/Archipelago/blob/main/worlds/oot/Items.py#L61)
+* [Risk of Rain 2](https://github.com/ArchipelagoMW/Archipelago/blob/main/worlds/ror2/Items.py#L8)
+* [Slay the Spire](https://github.com/ArchipelagoMW/Archipelago/blob/main/worlds/spire/Items.py#L13)
+* [Subnautica](https://github.com/ArchipelagoMW/Archipelago/blob/main/worlds/subnautica/items.json)
+* [Timespinner](https://github.com/ArchipelagoMW/Archipelago/blob/main/worlds/timespinner/Items.py#L11)
+
+### Available Locations
+* [A Link to the Past](https://github.com/ArchipelagoMW/Archipelago/blob/main/worlds/alttp/Regions.py#L429)
+* [Factorio](https://wiki.factorio.com/Technologies) Same as items
+* [Minecraft](https://github.com/ArchipelagoMW/Archipelago/blob/main/worlds/minecraft/Locations.py#L18)
+* [Ocarina of Time](https://github.com/ArchipelagoMW/Archipelago/blob/main/worlds/oot/LocationList.py#L38)
+* [Risk of Rain 2](https://github.com/ArchipelagoMW/Archipelago/blob/main/worlds/ror2/Locations.py#L17) This is a special
+case. The locations are "ItemPickup[number]" up to the maximum set in the yaml.
+* [Slay the Spire](https://github.com/ArchipelagoMW/Archipelago/blob/main/worlds/spire/Locations.py)
+* [Subnautica](https://github.com/ArchipelagoMW/Archipelago/blob/main/worlds/subnautica/locations.json)
+* [Timespinner](https://github.com/ArchipelagoMW/Archipelago/blob/main/worlds/timespinner/Locations.py#L13)
+
+
+A list of all available items and locations can also be found in the [server's datapackage](/api/datapackage).
+### Examples
+```yaml
+plando_items:
+# example block 1 - Timespinner
+  - item:
+      Empire Orb: 1
+      Radiant Orb: 1
+    location: Starter Chest 1
+    from_pool: true
+    world: true
+    percentage: 50
+    
+# example block 2 - Ocarina of Time
+  - items:
+      Kokiri Sword: 1
+      Biggoron Sword: 1
+      Bow: 1
+      Magic Meter: 1
+      Progressive Strength Upgrade: 3
+      Progressive Hookshot: 2
+    locations:
+      - Deku Tree Slingshot Chest
+      - Dodongos Cavern Bomb Bag Chest
+      - Jabu Jabus Belly Boomerang Chest
+      - Bottom of the Well Lens of Truth Chest
+      - Forest Temple Bow Chest
+      - Fire Temple Megaton Hammer Chest
+      - Water Temple Longshot Chest
+      - Shadow Temple Hover Boots Chest
+      - Spirit Temple Silver Gauntlets Chest
+    world: false
+    
+# example block 3 - Slay the Spire
+  - items:
+      Boss Relic: 3
+    locations:
+      Boss Relic 1
+      Boss Relic 2
+      Boss Relic 3
+
+# example block 4 - Factorio
+  - items:
+      progressive-electric-energy-distribution: 2
+      electric-energy-accumulators: 1
+      progressive-turret: 2
+    locations:
+      military
+      gun-turret
+      logistic-science-pack
+      steel-processing
+    percentage: 80
+    force: true
+```
+1. This block has a 50% chance to occur, and if it does will place either the Empire Orb or Radiant Orb on another player's
+Starter Chest 1 and removes the chosen item from the item pool.
+2. This block will always trigger and will place the player's swords, bow, magic meter, strength upgrades, and hookshots
+in their own dungeon major item chests.
+3. This block will always trigger and will lock boss relics on the bosses.
+4. This block has an 80% chance of occuring and when it does will place all but 1 of the items randomly among the four
+locations chosen here.
+
+## Boss Plando
+As this is currently only supported by A Link to the Past instead of explaining here please refer to the 
+[relevant guide](/tutorial/zelda3/plando/en)
+
+## Text Plando
+As this is currently only supported by A Link to the Past instead of explaining here please refer to the
+[relevant guide](/tutorial/zelda3/plando/en)
+
+## Connections Plando
+This is currently only supported by Minecraft and A Link to the Past. As the way that these games interact with
+their connections is different I will only explain the basics here while more specifics for Link to the Past connection
+plando can be found in its plando guide.
+* The options for connections are `percentage`, `entrance`, `exit`, and `direction`. Each of these options support subweights.
+* `percentage` is the percentage chance for this connection from 0 to 100 and defaults to 100.
+* Every connection has an `entrance` and an `exit`. These can be unlinked like in A Link to the Past insanity entrance shuffle.
+* `direction` can be `both`, `entrance`, or `exit` and determines in which direction this connection will operate.
+
+[Link to the Past connections](https://github.com/ArchipelagoMW/Archipelago/blob/main/worlds/alttp/EntranceShuffle.py#L3852)
+
+[Minecraft connections](https://github.com/ArchipelagoMW/Archipelago/blob/main/worlds/minecraft/Regions.py#L62)
+
+### Examples
+```yaml
+plando_connections:
+# example block 1 - Link to the Past
+  - entrance: Cave Shop (Lake Hylia)
+    exit: Cave 45
+    direction: entrance
+  - entrance: Cave 45
+    exit: Cave Shop (Lake Hylia)
+    direction: entrance
+  - entrance: Agahnims Tower
+    exit: Old Man Cave Exit (West)
+    direction: exit
+    
+# example block 2 - Minecraft
+  - entrance: Overworld Structure 1
+    exit: Nether Fortress
+    direction: both
+  - entrance: Overworld Structure 2
+    exit: Village
+    direction: both
+```
+
+1. These connections are decoupled so going into the lake hylia cave shop will take you to the inside of cave 45 and
+when you leave the interior you will exit to the cave 45 ledge. Going into the cave 45 entrance will then take you to the
+lake hylia cave shop. Walking into the entrance for the old man cave and Agahnim's Tower entrance will both take you to
+their locations as normal but leaving old man cave will exit at Agahnim's Tower.
+2. This will force a nether fortress and a village to be the overworld structures for your game. Note that for the Minecraft
+connection plando to work structure shuffle must be enabled.

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

@@ -0,0 +1,79 @@
+# Archipelago Setup Guide
+
+## Installing the Archipelago software
+The most recent public release of Archipelago can be found [here](https://github.com/ArchipelagoMW/Archipelago/releases).
+Run the exe file, and after accepting the license agreement you will be prompted on which components you would like to install. 
+The generator allows you to generate multiworld games on your computer. The ROM setups are optional but are required if 
+anyone in the game that you generate wants to play any of those games as they are needed to generate the relevant patch 
+files. The server will allow you to host the multiworld on your machine but this also requires you to port forward. The 
+default port for Archipelago is `38281`. If you are unsure how to do this there are plenty of other guides on the internet 
+that will be more suited to your hardware. The `Clients` are what you use to connect your game to the multiworld. If the 
+game/games you plan to play are available here go ahead and install these as well. If the game you choose to play is 
+supported by Archipelago but not listed in the installation check the relevant tutorial.
+
+## Generating a game
+
+### Creating a YAML
+In a multiworld there must be one YAML per world. Any number of players can play on each world using either the game's
+native coop system or using archipelago's coop support. Each world will hold one slot in the multiworld and will have a
+slot name and, if the relevant game requires it, files to associate it with that multiworld. If multiple people plan to
+play in one world cooperatively then they will only need one YAML for their coop world, but if each player is planning on
+playing their own game then they will each need a YAML. These YAML files can be generated by going to the relevant game's
+player settings page, entering the name they want to use for the game, setting the options to what they would like to
+play with and then clicking on the export settings button. This will then download a YAML file that will contain all of
+these options and this can then be given to whoever is going to generate the game.
+
+### Gather all player YAMLS
+All players that wish to play in the generated multiworld must have a YAML file which contains the settings that they wish to play with.
+A YAML is a file which contains human readable markup. In other words, this is a settings file kind of like an INI file or a TOML file. 
+Each player can go to the game's player settings page in order to determine the settings how they want them and then download a YAML file containing these settings.
+After getting the YAML files of each participant for your multiworld game, these can all either be placed together in the 
+`Archipelago\Players` folder or compressed into a ZIP folder to then be uploaded to the [website generator](/generate).
+If rolling locally ensure that the folder is clear of any files you do not wish to include in the game such as the 
+included default player settings files.
+
+#### Changing local host settings for generation
+Sometimes there are various settings that you may want to change before rolling a seed such as enabling race mode, 
+auto-forfeit, plando support, or setting a password. All of these settings plus other options are able to be changed by 
+modifying the `host.yaml` file in the base `Archipelago` folder. The settings chosen here are baked into
+the serverdata file that gets output with the other files after generation so if rolling locally ensure this file is edited
+to your liking *before* rolling the seed.
+
+### Rolling the seed
+
+#### On the Website
+After gathering the YAML files together in one location, select all of the files and compress them into a .zip folder. 
+Next go to the [Start Playing](/start-playing) page and click on `generate a randomized game` to reach the website generator. 
+Here, you can adjust some server settings such as forfeit rules and the cost for a player to use a hint before generation. 
+After adjusting the host settings to your liking click on the Upload File button and using the explorer window that opens, 
+navigate to the location where you zipped the player files and upload this zip. The page will generate your game and refresh
+multiple times to check on completion status. After the generation completes you will be on a Seed Info page that provides
+the seed, the date/time of creation, a link to the spoiler log, if available, and links to any rooms created from this seed.
+To begin playing, click on `Create New Room`, which will take you to the room page. From here you can navigate back to thse
+Seed Info page or to the Tracker page. Sharing the link to this page with your friends will provide them with the
+necessary info and files for them to connect to the multiworld.
+
+#### Rolling using the generation program
+After gathering the YAML files together in the `Archipelago\Players` folder, run the program `ArchipelagoGenerate.exe` 
+in the base `Archipelago` folder. This will then open a console window and either silently close itself or spit out an 
+error. If you receive an error, it is likely due to an error in the YAML file. If the error is unhelpful in figuring 
+out the issue asking in the ***#tech-support*** channel of our Discord for help with finding it is highly recommended. 
+The generator will put a zip folder into your `Archipelago\output` folder with the format `AP_XXXXXXXXX`.zip. 
+This contains the patch files and relevant mods for the players as well as the serverdata for the host.
+
+## Hosting a multiworld
+
+### Uploading the seed to the website
+The easiest and most recommended method is to generate the game on the website which will allow you to create a private
+room with all the necessary files you can share, as well as hosting the game and supporting item trackers for various games. 
+If for some reason the seed was rolled on a machine, then either the resulting zip file or the resulting `AP_XXXXX.archipelago`
+inside the zip file can be uploaded to the [upload page](/uploads). This will give a page with the seed info and have a 
+link to the spoiler if it exists. Click on Create New room and then share the link for the room with the other players 
+so that they can download their patches or mods. The room will also have a link to a Multiworld Tracker and tell you 
+what the players need to connect to from their clients. 
+
+### Hosting a seed locally
+For this we'll assume you have already port forwarding `38281` and have generated a seed that is still in the `outputs` 
+folder. Next, you'll want to run `ArchipelagoServer.exe`. A window will open in order to open the multiworld data for the 
+game. You can either use the generated zip folder or extract the .archipelago file and use it. If everything worked correctly the console window should tell you it's now hosting a game with the IP, port, and password that clients will need in order to connect.
+Extract the patch and mod files then send those to your friends, and you're done!

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

@@ -0,0 +1,69 @@
+# Archipelago Triggers Guide
+
+## What are triggers?
+Triggers allow you to customize your game settings by allowing you to define certain options or even a variety of 
+settings to occur or "trigger" under certain conditions. These are essentially "if, then statements" for options in your game. 
+A good example of what you can do with triggers is the custom 
+[mercenary mode](https://github.com/alwaysintreble/Archipelago-yaml-dump/blob/main/Snippets/Mercenary%20Mode%20Snippet.yaml) 
+that was created using entirely triggers and plando. For more information on plando you can reference 
+[this guide](/tutorial/archipelago/plando/en) or [this guide](/tutorial/zelda3/plando/en).
+
+## Trigger use
+Triggers have to be defined in the root of the yaml file meaning it must be outside of a game section. 
+The best place to do this is the bottom of the yaml.
+- Triggers comprise of the trigger section and then each trigger must have an `option_category`, `option_name`, and 
+`option_result` from which it will react to and then an `options` section where the definition of what will happen.
+- `option_category` is the defining section from which the option is defined in.
+    - Example: `A Link to the Past`
+    - This is the root category the option is located in. If the option you're triggering off of is in root then you 
+would use `null`, otherwise this is the game for which you want this option trigger to activate.
+- `option_name` is the option setting from which the triggered choice is going to react to.
+    - Example: `shop_item_slots` 
+    - This can be any option from any category defined in the yaml file in either root or a game section except for `game`.
+- `option_result` is the result of this option setting from which you would like to react.
+    - Example: `15`
+    - Each trigger must be used for exactly one option result. If you would like the same thing to occur with multiple 
+results you would need multiple triggers for this.
+- `options` is where you define what will happen when this is detected. This can be something as simple as ensuring 
+another option also gets selected or placing an item in a certain location. 
+    - Example: 
+  ```yaml
+  A Link to the Past:
+    start_inventory: 
+      Rupees (300): 2
+  ```
+This format must be:
+
+  ```yaml
+  root option:
+    option to change:
+      desired result
+  ```
+
+### Examples
+The above examples all together will end up looking like this:
+  ```yaml
+  triggers:
+    - option_category: A Link to the Past
+      option_name: shop_item_slots
+      option_result: 15
+      options:
+        A Link to the Past:
+          start_inventory:
+            Rupees(300): 2
+  ```
+
+For this example if the generator happens to roll 15 shuffled in shop item slots for your game you'll be granted 600 rupees at the beginning.
+These can also be used to change other options.
+
+For example:
+  ```yaml
+  triggers:
+    - option_category: Timespinner
+      option_name: SpecificKeycards
+      option_result: true
+      options:
+        Timespinner:
+          Inverted: true
+  ```
+In this example if your world happens to roll SpecificKeycards then your game will also start in inverted.

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

@@ -1,52 +1,128 @@
 # Factorio Randomizer Setup Guide
 
 ## Required Software
+##### Players
+- [Factorio](https://factorio.com) - Needed by Players and Hosts
 
-### Server Host
-- [Factorio](https://factorio.com)
-- [Archipelago](https://github.com/ArchipelagoMW/Archipelago/releases)
+##### Server Hosts
+- [Factorio](https://factorio.com) - Needed by Players and Hosts
+- [Archipelago](https://github.com/ArchipelagoMW/Archipelago/releases) - Needed by Hosts
 
-### Players
-- [Factorio](https://factorio.com)
+## Create a Config (.yaml) File
 
-## General Concept
+### What is a config file and why do I need one?
+Your config file contains a set of configuration options which provide the generator with information about how it
+should generate your game. Each player of a multiworld will provide their own config file. This setup allows each
+player to enjoy an experience customized for their taste, and different players in the same multiworld can all have
+different options. 
 
-One Server Host exists per Factorio World in an Archipelago Multiworld, any number of modded Factorio players can then connect to that world. From the view of Archipelago, this Factorio host is a client.
-## Installation Procedures
+### Where do I get a config file?
+The [Player Settings](/games/Factorio/player-settings) page on the website allows you to configure
+your personal settings and export a config file from them.
+
+### Verifying your config file
+If you would like to validate your config file to make sure it works, you may do so on
+the [YAML Validator](/mysterycheck) page.
+
+## Connecting to Someone Else's Factorio Game
+Connecting to someone else's game is the simplest way to play Factorio with Archipelago. It allows multiple
+people to play in a single world, all contributing to the completion of the seed.
+
+1. Acquire the Archipelago mod for this seed. It should be named `AP_*.zip`, where `*` is the seed number.
+2. Copy the mod file into your Factorio `mods` folder, which by default is located at:  
+`C:\Users\YourName\AppData\Roaming\Factorio\mods`
+3. Get the server address from the person hosting the game you are joining
+4. Launch Factorio
+5. Click on "Multiplayer" in the main menu
+6. Click on "Connect to address"
+7. Enter the address into this box
+8. Click "Connect"
+
+## Prepare to Host Your Own Factorio Game
+
+### Defining Some Terms
+In Archipelago, multiple Factorio worlds may be played simultaneously. Each of these worlds must be hosted by a
+Factorio server, which is connected to the Archipelago Server via middleware.
+
+This guide uses the following terms to refer to the software:
+- **Factorio Client** - The Factorio instance which will be used to play the game.
+- **Factorio Server** - The Factorio instance which will be used to host the Factorio world. Any number of
+Factorio Clients may connect to this server.
+- **Archipelago Client** - The middleware software used to connect the Factorio Server to the Archipelago Server.
+- **Archipelago Server** - The central Archipelago server, which connects all games to each other.
+
+### What a Playable State Looks Like
+- An Archipelago Server
+- The generated Factorio Mod, created as a result of running `ArchipelagoGenerate.exe`
+- One running instance of `ArchipelagoFactorioClient.exe` (the Archipelago Client) per Factorio world
+- A running modded Factorio Server, which should have been started by the Archipelago Client automatically
+- A running modded Factorio Client
 
 ### Dedicated Server Setup
-You need a dedicated isolated Factorio installation that the FactorioClient can take control over. If you intend to both host a world and play on the same device, you will need two separate Factorio installations; one for the FactorioClient to hook into and control, and one for you to play on.
-The easiest and cheapest way to do so is to either buy or register a Factorio key on factorio.com, which allows you to download as many Factorio games as you want. If you own a steam copy already you can link your account on the website.
-1. Download the latest Factorio from https://factorio.com/download for your system, for Windows the recommendation is "win64-manual".
+To play Factorio with Archipelago, a dedicated server setup is required. This dedicated Factorio Server must be
+installed separately from your main Factorio Client installation. The recommended way to install two instances
+of Factorio on your computer is to download the Factorio installer file directly from
+[factorio.com](https://factorio.com/download).
 
-2. Make sure the Factorio you play and the Factorio you use for hosting do not share paths. If you downloaded the "manual" version, this is already the case, otherwise, go into the hosting Factorio's folder and put the following text into its `config-path.cfg`:
-```ini
-config-path=__PATH__executable__/../../config
-use-system-read-write-data-directories=false
-```
-3. In this same folder if there are shortcuts named "mods" and "saves" delete these and replace with folders with the same names.
-4. Navigate to where you installed ArchipelagoFactorioClient and open the host.yaml file as text. Find the entry `executable` under `factorio_options` and set it to point to your hosting Factorio.exe. If you put Factorio into your Archipelago folder, this would already match.<br>
-ex.
+#### If you purchased Factorio on Steam, GOG, etc.
+You can register your copy of Factorio on [factorio.com](https://factorio.com/). You will be required to
+create an account, if you have not done so already. As part of that process, you will be able to enter your
+Factorio product code. This will allow you to download the game directly from their website.
+
+#### Download the Standalone Version
+It is recommended to download the standalone version of Factorio for use as a dedicated server. Doing so prevents
+any potential conflicts with your currently-installed version of Factorio. Download the file by clicking on the
+button appropriate to your operating system, and extract the folder to a convenient location (we recommend
+C:\Factorio or similar).<br />
+<img src="/static/assets/tutorial/factorio/factorio-download.png" />
+
+Next, you should launch your Factorio Server by running `factorio.exe`, which is located at: `bin/x64/factorio.exe`.
+You will be asked to log-in to your Factorio account using the same credentials you used on Factorio's website.
+After you have logged in, you may close the game.
+
+#### Configure your Archipelago Installation
+You must modify your `host.yaml` file inside your Archipelago installation directory so that it points to your
+standalone Factorio executable. Here is an example of the appropriate setup, note the double `\\` are required:
 ```yaml
 factorio_options:
-  executable:  C:\\Program Files\\factorio\\bin\\x64\\factorio"
+  executable:  C:\\factorio\\bin\\x64\\factorio"
 ```
-### Player Setup
-- Manually install the AP mod for the correct world you want to join, then use Factorio's built-in multiplayer. If you're connecting to a FactorioClient on the same system you will connect to localhost
 
-    
-## Joining a MultiWorld Game
+With all that complete, you are now able to...
 
-1. Install the generated Factorio AP Mod (would be in /Mods after step 2 of Setup)
+## Host Your Own Factorio Game
 
-2. Run FactorioClient, it should launch a Factorio server, which you can control with /factorio <original factorio commands>,
+1. Obtain the Factorio mod for this Archipelago seed. It should be named `AP_*.zip`, where `*` is the seed number.
+2. Install the mod into your Factorio Server by copying the zip file into the `mods` folder.
+3. Install the mod into your Factorio Client by copying the zip file into the `mods` folder, which is likely located
+at `C:\Users\YourName\AppData\Roaming\Factorio\mods`.
+4. Obtain the Archipelago Server address from the website's host room, or from the server host.
+5. Run your Archipelago Client, which is named `ArchilepagoFactorioClient.exe`. This was installed along with
+Archipelago if you chose to include it during the installation process.
+6. Enter `/connect [server-address]` into the input box at the bottom of the Archipelago Client and press "Enter"
+<br /><img src="/static/assets/tutorial/factorio/connect-to-ap-server.png" />
+7. Launch your Factorio Client
+8. Click on "Multiplayer" in the main menu
+9. Click on "Connect to address"
+10. Enter `localhost` into the server address box
+11. Click "Connect"
 
-	* It should start up, create a world and become ready for Factorio connections.
-3. In FactorioClient, do /connect <Archipelago Server Address> to join that multiworld. You can find further commands with /help as well as !help once connected.
+For additional client features, issue the `/help` command in the Archipelago Client. Once connected to the AP
+server, you can also issue the `!help` command to learn about additional commands like `!hint`. 
 
-	* / commands are run on your local client, ! commands are requests for the AP server
+## Allowing Other People to Join Your Game
+1. Ensure your Archipelago Client is running.
+2. Ensure port `34197` is forwarded to the computer running the Archipelago Client.
+3. Obtain your IP address by visiting [this website](https://whatismyip.com/).
+4. Provide your IP address to anyone you want to join your game, and have them follow the steps for
+"Connecting to Someone Else's Factorio Game" above.
 
-	* Players should be able to connect to your Factorio Server and begin playing.
-
-4. You can join yourself by connecting to address localhost, other people will need to connect to your IP and you may need to port forward for the Factorio Server for those connections.
+## Troubleshooting
+In case any problems should occur, the Archipelago Client will create a file `FactorioClient.txt` in the `/logs`.
+The contents of this file may help you troubleshoot an issue on your own and is vital for requesting help from other
+people in Archipelago.
 
+## Additional Resources
+- [Alternate Tutorial by Umenen](https://docs.google.com/document/d/1yZPAaXB-QcetD8FJsmsFrenAHO5V6Y2ctMAyIoT9jS4)
+- [Factorio Speedrun Guide](https://www.youtube.com/watch?v=ExLrmK1c7tA)
+- [Factorio Wiki](https://wiki.factorio.com/)

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

@@ -0,0 +1,114 @@
+# Final Fantasy 1 (NES) Multiworld Setup Guide
+
+## Required Software
+- The FF1Client which is bundled with [Archipelago](https://github.com/ArchipelagoMW/Archipelago/releases)
+- The [BizHawk](http://tasvideos.org/BizHawk.html) emulator. Versions 2.3.1 and higher are supported. 
+  Version 2.7 is recommended
+- Your Final Fantasy (USA Edition) ROM file, probably named `Final Fantasy (USA).nes`. Neither Archipelago.gg nor the 
+  Final Fantasy Randomizer Community can supply you with this.
+
+## Installation Procedures
+1. Download and install the latest version of [Archipelago](https://github.com/ArchipelagoMW/Archipelago/releases)
+   1. On Windows, download Setup.Archipelago.<HighestVersion>.exe and run it
+2. Assign Bizhawk version 2.3.1 or higher as your default program for launching `.nes` files.
+    1. Extract your Bizhawk folder to your Desktop, or somewhere you will remember. Below are optional additional
+       steps for loading ROMs more conveniently
+       1. Right-click on a ROM file and select **Open with...**
+       2. Check the box next to **Always use this app to open .nes files**
+       3. Scroll to the bottom of the list and click the grey text **Look for another App on this PC**
+       4. Browse for `EmuHawk.exe` located inside your Bizhawk folder (from step 1) and click **Open**.
+
+## Playing a Multiworld
+Playing a multiworld on Archipelago.gg has 3 key components:
+1. The Server which is hosting a game for all players.
+2. The Client Program. For Final Fantasy 1, it is a standalone program but other randomizers may build it in.
+3. The Game itself, in this case running on Bizhawk, which then connects to the Client running on your computer.
+
+To set this up the following steps are required:
+1. (Each Player) Generate your own yaml file and randomized ROM
+2. (Host Only) Generate a randomized game with you and 0 or more players using Archipelago
+3. (Host Only) Run the Archipelago Server
+4. (Each Player) Run your client program and connect it to the Server
+5. (Each Player) Run your game and connect it to your client program
+6. (Each Player) Play the game and have fun!
+
+### Obtaining your Archipelago yaml file and randomized ROM
+Unlike most other Archipelago.gg games Final Fantasy 1 is randomized by the 
+[main randomizer](https://finalfantasyrandomizer.com/). Generate a game by going to the site and performing the
+following steps:
+1. Select the randomization options (also known as `Flags` in the community) of your choice. If you do not know what 
+you prefer, or it is your first time playing select the "Archipelago" preset on the main page.
+2. Go to the `Beta` tab and ensure `Archipelago` is enabled. Set your player name to any name that represents you.
+3. Upload you `Final Fantasy(USA).nes` (and click `Remember ROM` for the future!)
+4. Press the `NEW` button beside `Seed` a few times
+5. Click `GENERATE ROM`
+
+It should download two files. One is the `*.nes` file which your emulator will run and the other is the yaml file
+required by Archipelago.gg
+
+### Generating the Multiworld and Starting the Server
+The game can be generated locally or by Archipelago.gg.
+
+#### Generating on Archipelago.gg (Recommended)
+1. Gather all yaml files
+2. Create a zip file containing all of the yaml files. Make sure it is a `*.zip` not a `*.7z` or a `*.rar`
+3. Navigate to the [Generate Page](https://archipelago.gg/generate) and click `Upload File`
+   1. For your first game keep `Forfeit Permission` as `Automatic on goal completion`. Forfeiting actually means
+      giving out all of the items remaining in your game in this case so you do not block anyone else.
+   2. For your first game keep `Hint Cost` at 10%
+4. Select your zip file
+
+#### Generating Locally
+1. Navigate to your Archipelago install directory
+2. Empty the `Players` directory then fill it with one yaml per player including your own which you got from the 
+   finalfantasyrandomizer website above
+3. Run `ArchipelagoGenerate.exe` (double-click it in File Explorer)
+4. You will find your generated game in the `output` directory
+
+#### Starting the server
+If you generated on Archipelago.gg click `Create New Room` on the results page to start your server
+If you generated locally simply navigate to the [Host Game Page](https://archipelago.gg/uploads) and upload the file
+in the `output` directory
+
+### Running the Client Program and Connecting to the Server
+1. Navigate to your Archipelago install folder and run `ArchipelagoFF1Client.exe`
+2. Notice the `/connect command` on the server hosting page (It should look like `/connect archipelago.gg:*****` where 
+   ***** are numbers)
+3. Type the connect command into the client OR add the port to the pre-populated address on the top bar (it should
+   already say `archipelago.gg`) and click `connect`
+
+#### Running Your Game and Connecting to the Client Program
+1. Open Bizhawk 2.3.1 or higher and load your ROM OR 
+   click your ROM file if it is already associated with the extension `*.nes`
+2. Click on the Tools menu and click on **Lua Console**
+3. Click the folder button to open a new Lua script. (CTL-O or **Script** -> **Open Script**)
+4. Navigate to the location you installed Archipelago to. Open data/lua/FF1/ff1_connector.lua
+   1. If it gives a `NLua.Exceptions.LuaScriptException: .\socket.lua:13: module 'socket.core' not found:` exception
+   close your emulator entirely, restart it and re-run these steps
+   2. If it says `Must use a version of bizhawk 2.3.1 or higher`, double-check your Bizhawk version by clicking 
+   **Help** -> **About**
+
+### Play the game
+When the client shows both NES and server are connected you are good to go. You can check the connection status of the
+NES at any time by running `/nes`
+
+### Helpful Commands
+Commands are broken into two types: `/` and `!` commands. The difference is that `/commands` are local to your machine
+and game whereas `!` commands ask the server. Most of the time you can use local commands.
+
+#### Local Commands
+- `/connect <address with port number>` connect to the multiworld server
+- `/disconnect` if you accidentally connected to the wrong port run this to disconnect and then reconnect using
+- `/nes` Shows the current status of the NES connection
+- `/received` Displays all the items you have found or been sent
+- `/missing` Displays all the locations along with their current status (checked/missing)
+- Just typing anything will broadcast a message to all players
+
+#### Remote Commands
+- `!hint <item name>` Tells you at which location in whose game your Item is. Note you need to have checked some locations
+to earn a hint. You can check how many you have by just running `!hint`
+- `!forfeit` If you didn't turn on auto-forfeit or you allowed forfeiting prior to goal completion. Remember that
+"forfeiting" actually means sending out your remaining items in your world
+
+#### Host only (on Archipelago.gg)
+`/forfeit <Player Name>` Forfeits someone regardless of settings and game completion status

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

@@ -1,11 +1,9 @@
 # Minecraft Randomizer Setup Guide
 
-#Automatic Hosting Install
-- download and install [Archipelago](https://github.com/ArchipelagoMW/Archipelago/releases) and choose the `Minecraft Client` module
-
 ## Required Software
 
-- [Minecraft Java Edition](https://www.minecraft.net/en-us/store/minecraft-java-edition)
+- [Minecraft Java Edition](https://www.minecraft.net/en-us/store/minecraft-java-edition) (update 1.17.1)
+- [Archipelago](https://github.com/ArchipelagoMW/Archipelago/releases) (select `Minecraft Client` during installation.)
 
 ## Configuring your YAML file
 
@@ -16,73 +14,7 @@ each player to enjoy an experience customized for their taste, and different pla
 can all have different options.
 
 ### Where do I get a YAML file?
-A basic minecraft yaml will look like this.
-```yaml
-description: Basic Minecraft Yaml
-# Your name in-game. Spaces will be replaced with underscores and
-# there is a 16 character limit
-name: YourName
-game: Minecraft
-
-# Shared Options supported by all games:
-accessibility: locations
-progression_balancing: on
-# Minecraft Specific Options
-
-Minecraft:
-  # Number of advancements required (87 max) to spawn the Ender Dragon and complete the game.
-  advancement_goal: 50   
-  
-  # Number of dragon egg shards to collect (30 max) before the Ender Dragon will spawn. 
-  egg_shards_required: 10 
-  
-  # Number of egg shards available in the pool (30 max).
-  egg_shards_available: 15 
-  
-  # Modifies the level of items logically required for
-  # exploring dangerous areas and fighting bosses.
-  combat_difficulty: 
-    easy: 0
-    normal: 1
-    hard: 0
-    
-  # Junk-fills certain RNG-reliant or tedious advancements.
-  include_hard_advancements: 
-    on: 0
-    off: 1
-    
-  # Junk-fills extremely difficult advancements;
-  # this is only How Did We Get Here? and Adventuring Time.
-  include_insane_advancements: 
-    on: 0
-    off: 1
-  
-  # Some advancements require defeating the Ender Dragon;
-  # this will junk-fill them, so you won't have to finish them to send some items.  
-  include_postgame_advancements: 
-    on: 0
-    off: 1
-    
-  # Enables shuffling of villages, outposts, fortresses, bastions, and end cities. 
-  shuffle_structures: 
-    on: 0
-    off: 1
-  
-  # Adds structure compasses to the item pool,
-  # which point to the nearest indicated structure.  
-  structure_compasses: 
-    on: 0
-    off: 1
-  
-  # Replaces a percentage of junk items with bee traps
-  # which spawn multiple angered bees around every player when received.   
-  bee_traps: 
-    0: 1
-    25: 0
-    50: 0
-    75: 0
-    100: 0
-```
+you can customize your settings by visiting the [minecraft player settings](/games/Minecraft/player-settings)
 
 ## Joining a MultiWorld Game
 
@@ -93,38 +25,34 @@ When you join a multiworld game, you will be asked to provide your YAML file to
 is done, the host will provide you with either a link to download your data file, or with a zip file containing
 everyone's data files. Your data file should have a `.apmc` extension.
 
-double click on your `.apmc` file to have the minecraft client auto-launch the installed forge server.
+double-click on your `.apmc` file to have the minecraft client auto-launch the installed forge server.
+make sure to leave this window open as this is your server console.
 
 ### Connect to the MultiServer
-After having placed your data file in the `APData` folder, start the Forge server and make sure you have OP
-status by typing `/op YourMinecraftUsername` in the forge server console then connecting in your Minecraft client.
+Using minecraft 1.17.1 connect to the server `localhost`.
 
 Once in game type `/connect <AP-Address> (Port) (Password)` where `<AP-Address>` is the address of the
 Archipelago server. `(Port)` is only required if the Archipelago server is not using the default port of 38281. `(Password)`
 is only required if the Archipleago server you are using has a password set.
 
 ### Play the game
-When the console tells you that you have joined the room, you're ready to begin playing. Congratulations
+When the console tells you that you have joined the room, you're all set. Congratulations
 on successfully joining a multiworld game! At this point any additional minecraft players may connect to your
-forge server.
+forge server. to star the game once everyone is ready type `/start`. 
 
+### Useful commands
+- `!help` displays a list all server commands
+- `!hint` will display how many hint points you have, along with any hints that have been given that are related to your game.
+- `!hint (item)` will ask the server to tell you where (item) is
+- `!hint_location (location)` will ask the server to tell you what item is on (location)
 
-## Manual Installation Procedures
-this is only required if you wish to set up a forge install yourself, its recommended to just use the Archipelago Installer.
-###Required Software
-- [Minecraft Forge](https://files.minecraftforge.net/net/minecraftforge/forge/index_1.16.5.html)
+## Manual Installation
+it is highly recommended to ues the Archipelago installer to handle the installation of the forge server for you.
+support will not be given for those wishing to manually install forge. but for those of you who know how, and wish to
+do so the following links are the versions of the software we use.
+### Manual install Software links
+- [Minecraft Forge](https://files.minecraftforge.net/net/minecraftforge/forge/index_1.17.1.html)
 - [Minecraft Archipelago Randomizer Mod](https://github.com/KonoTyran/Minecraft_AP_Randomizer/releases)
 **DO NOT INSTALL THIS ON YOUR CLIENT**
-### Dedicated Server Setup
-Only one person has to do this setup and host a dedicated server for everyone else playing to connect to.
-1. Download the 1.16.5 **Minecraft Forge** installer from the link above, making sure to download the most recent recommended version.
+- [Java 16](https://docs.aws.amazon.com/corretto/latest/corretto-16-ug/downloads-list.html)
 
-2. Run the `forge-1.16.5-xx.x.x-installer.jar` file and choose **install server**.
-    - On this page you will also choose where to install the server to remember this directory it's important in the next step.
-
-3. Navigate to where you installed the server and open `forge-1.16.5-xx.x.x.jar`
-    - Upon first launch of the server it will close and ask you to accept Minecraft's EULA. There will be a new file called `eula.txt` that contains a link to Minecraft's EULA, and a line that you need to change to `eula=true` to accept Minecraft's EULA.
-    - This will create the appropriate directories for you to place the files in the following step.
-
-4. Place the `aprandomizer-x.x.x.jar` from the link above file into the `mods` folder of the above installation of your forge server.
-    - Once again run the server, it will load up and generate the required directory `APData` for when you are ready to play a game!

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

@@ -1,52 +1,12 @@
 # Guia instalación de Minecraft Randomizer
 
+#Instalacion automatica para el huesped de partida
+- descarga e instala [Archipelago](https://github.com/ArchipelagoMW/Archipelago/releases) and activa el modulo `Minecraft Client`
+
 ## Software Requerido
 
-### Servidor
-- [Minecraft Forge](https://files.minecraftforge.net/net/minecraftforge/forge/index_1.16.5.html)
-- [Minecraft Archipelago Randomizer Mod](https://github.com/KonoTyran/Minecraft_AP_Randomizer/releases)
-
-### Jugadores
 - [Minecraft Java Edition](https://www.minecraft.net/en-us/store/minecraft-java-edition)
 
-## Procedimiento de instalación
-
-### Instalación de servidor dedicado
-Solo una persona ha de realizar este proceso y hospedar un servidor dedicado para que los demas jueguen conectandose a él.
-1. Descarga el instalador de **Minecraft Forge** 1.16.15 desde el enlace proporcionado, siempre asegurandose de bajar la version mas reciente.
-
-2. Ejecuta el fichero `forge-1.16.5-xx.x.x-installer.jar` y elije **install server**.
-    - En esta pagina elegiras ademas donde instalar el servidor, importante recordar esta localización en el siguiente paso.
-
-3. Navega al directorio donde hayas instalado el servidor y abre `forge-1.16.5-xx.x.x.jar`
-    - La primera vez que lances el servidor se cerrara (o no aparecerá nada en absoluto), debería haber un fichero nuevo en el directorio llamado `eula.txt`, el cual que contiene un enlace al EULA de minecraft, cambia la linea a `eula=true` para aceptar el EULA y poder utilizar el software de servidor.
-    - Esto creara la estructura de directorios apropiada para el siguiente paso
-
-4. Coloca el fichero `aprandomizer-x.x.x.jar` del segundo enlace en el directorio `mods`
-    - Cuando se ejecute el servidor de nuevo, generara el directorio `APData` que se necesitara para jugar
-
-### Instalación basica para jugadores
-- Compra e instala Minecraft a traves del tercer enlace.
-  **Y listo!**.
-  Los jugadores solo necesitan una version no modificada de Minecraft para jugar!
-
-### Instalación avanzada para jugadores
-***Esto no es requerido para jugar a minecraft randomizado.***
-Sin embargo lo recomendamos porque hace la experiencia mas llevadera.
-
-#### Recomended Mods
-- [JourneyMap](https://www.curseforge.com/minecraft/mc-mods/journeymap) (Minimap)
-
-
-1. Instala y ejecuta Minecraft al menos una vez.
-2. Ejecuta el fichero `forge-1.16.5-xx.x.x-installer.jar` y elige **install client**.
-    - Ejecuta Minecraft forge al menos una vez para generar los directorios necesarios para el siguiente paso.
-3. Navega a la carpeta de instalación de Minecraft y colocal los mods que quieras en el directorio `mods`
-    - Los directorios por defecto de instalación son:
-        - Windows `%APPDATA%\.minecraft\mods`
-        - macOS `~/Library/Application Support/minecraft/mods`
-        - Linux `~/.minecraft/mods`
-
 ## Configura tu fichero YAML
 
 ### Que es un fichero YAML y potque necesito uno?
@@ -58,42 +18,71 @@ pueden tener diferentes opciones
 ### Where do I get a YAML file?
 Un fichero basico yaml para minecraft tendra este aspecto.
 ```yaml
-# Usado para describir tu yaml. Util si tienes multiples ficheros
-description: Template Name 
-# Tu nombre en el juego. Los espacios son reemplazados por guiones bajos, limitado a 16 caracteres
-name: YourName 
+description: Basic Minecraft Yaml
+# Tu nombre en el juego. Espacios seran sustituidos por guinoes bajos y
+# hay un limite de 16 caracteres
+name: TuNombre
 game: Minecraft
-accessibility: locations
-# Recomendado no activar esto ya que el pool de objetos de Minecraft es bastante escueto, ademas hay muchas maneras alternativas de obtener los objetivos de Minecraft.
-progression_balancing: off 
-# Cuantos avances se necesitan para hacer aparecer el Ender Dragon y acabar el juego. few = 30, normal = 50 , many = 70
-advancement_goal: 
-  few: 0 
-  normal: 1 
-  many: 0 
-# Modifica el nivel de objetos lógicamente requeridos para explorar areas peligrosas y pelear contra jefes. 
-combat_difficulty: 
-  easy: 0
-  normal: 1
-  hard: 0
-# Avances que sean tediosos o basados en suerte tendran simplemente experiencia o cosas no necesarias
-include_hard_advancements: 
-  on: 0
-  off: 1
-# Los avances extremadamente difíciles no seran requeridos; esto afecta a How Did We Get Here? y Adventuring Time. 
-include_insane_advancements: 
-  on: 0
-  off: 1
-# Los avances posteriores a Ender Dragon no tendrán objetos necesarios para que otros jugadores en el caso de un MW acaben su partida.
-include_postgame_advancements:
-  on: 0
-  off: 1
-# Actualmente desactivado; permite la mezcla de pueblos, puestos, fortalezas, bastiones y cuidades. 
-shuffle_structures: 
-  on: 0
-  off: 1
-```
 
+# Opciones compartidas por todos los juegos:
+accessibility: locations
+progression_balancing: on
+# Opciones Especficicas para Minecraft
+
+Minecraft:
+  # Numero de logros requeridos (87 max) para que aparezca el Ender Dragon y completar el juego.
+  advancement_goal: 50   
+  
+  # Numero de trozos de huevo de dragon a obtener (30 max) antes de que el Ender Dragon aparezca. 
+  egg_shards_required: 10 
+  
+  # Numero de huevos disponibles en la partida (30 max).
+  egg_shards_available: 15 
+  
+  # Modifica el nivel de objetos logicamente requeridos para 
+  # explorar areas peligrosas y luchar contra jefes.
+  combat_difficulty: 
+    easy: 0
+    normal: 1
+    hard: 0
+    
+  # Si off, los logros que dependan de suerte o sean tediosos tendran objetos de apoyo, no necesarios para completar el juego.
+  include_hard_advancements: 
+    on: 0
+    off: 1
+    
+  # Si off, los logros muy dificiles tendran objetos de apoyo, no necesarios para completar el juego.
+  # Solo afecta a How Did We Get Here? and Adventuring Time.
+  include_insane_advancements: 
+    on: 0
+    off: 1
+  
+  # Algunos logros requieren derrotar al Ender Dragon;
+  # Si esto se queda en off, dichos logros no tendran objetos necesarios.
+  include_postgame_advancements: 
+    on: 0
+    off: 1
+    
+  # Permite el mezclado de villas, puesto, fortalezas, bastiones y ciudades de END. 
+  shuffle_structures: 
+    on: 0
+    off: 1
+  
+  # Añade brujulas de estructura al juego,
+  # apuntaran a la estructura correspondiente mas cercana.  
+  structure_compasses: 
+    on: 0
+    off: 1
+  
+  # Reemplaza un porcentaje de objetos innecesarios por trampas abeja
+  # las cuales crearan multiples abejas agresivas alrededor de los jugadores cuando se reciba.   
+  bee_traps: 
+    0: 1
+    25: 0
+    50: 0
+    75: 0
+    100: 0
+```
 
 ## Unirse a un juego MultiWorld
 
@@ -104,18 +93,39 @@ Cuando te unes a un juego multiworld, se te pedirá que entregues tu fichero YAM
 Una vez la generación acabe, el anfitrión te dará un enlace a tu fichero de datos o un zip con los ficheros de todos.
 Tu fichero de datos tiene una extensión `.apmc`.
 
-Pon tu fichero de datos en el directorio `APData` de tu forge server. Asegurate de eliminar los que hubiera anteriormente
-
+Haz doble click en tu fichero `.apmc` para que se arranque el cliente de minecraft y el servidor forge se ejecute.
 
 ### Conectar al multiserver
 Despues de poner tu fichero en el directorio `APData`, arranca el Forge server y asegurate que tienes el estado OP
 tecleando `/op TuUsuarioMinecraft` en la consola del servidor y entonces conectate con tu cliente Minecraft.
 
-Una vez en juego introduce `/connect <AP-Address> (<Password>)` donde `<AP-Address>` es la dirección del servidor
-Archipelago. `(<Password>)`
+Una vez en juego introduce `/connect <AP-Address> (Port) (<Password>)` donde `<AP-Address>` es la dirección del servidor. `(Port)` solo es requerido si el servidor Archipelago no esta usando el puerto por defecto 38281.
+`(<Password>)`
 solo se necesita si el servidor Archipleago tiene un password activo.
 
+
 ### Jugar al juego
 Cuando la consola te diga que te has unido a la sala, estas lista/o para empezar a jugar. Felicidades
 por unirte exitosamente a un juego multiworld! Llegados a este punto cualquier jugador adicional puede conectarse a tu servidor forge.
 
+## Procedimiento de instalación manual
+Solo es requerido si quieres usar una instalacion de forge por ti mismo, recomendamos usar el instalador de Archipelago
+###Software Requerido
+- [Minecraft Forge](https://files.minecraftforge.net/net/minecraftforge/forge/index_1.16.5.html)
+- [Minecraft Archipelago Randomizer Mod](https://github.com/KonoTyran/Minecraft_AP_Randomizer/releases)
+**NO INSTALES ESTO EN TU CLIENTE MINECRAFT**
+
+
+### Instalación de servidor dedicado
+Solo una persona ha de realizar este proceso y hospedar un servidor dedicado para que los demas jueguen conectandose a él.
+1. Descarga el instalador de **Minecraft Forge** 1.16.5 desde el enlace proporcionado, siempre asegurandose de bajar la version mas reciente.
+
+2. Ejecuta el fichero `forge-1.16.5-xx.x.x-installer.jar` y elije **install server**.
+    - En esta pagina elegiras ademas donde instalar el servidor, importante recordar esta localización en el siguiente paso.
+
+3. Navega al directorio donde hayas instalado el servidor y abre `forge-1.16.5-xx.x.x.jar`
+    - La primera vez que lances el servidor se cerrara (o no aparecerá nada en absoluto), debería haber un fichero nuevo en el directorio llamado `eula.txt`, el cual que contiene un enlace al EULA de minecraft, cambia la linea a `eula=true` para aceptar el EULA y poder utilizar el software de servidor.
+    - Esto creara la estructura de directorios apropiada para el siguiente paso
+
+4. Coloca el fichero `aprandomizer-x.x.x.jar` del segundo enlace en el directorio `mods`
+    - Cuando se ejecute el servidor de nuevo, generara el directorio `APData` que se necesitara para jugar

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

@@ -4,13 +4,14 @@
 ### Install r2modman
 Head on over to the r2modman page on Thunderstore and follow the installation instructions.
 
-https://thunderstore.io/package/ebkr/r2modman/
+[https://thunderstore.io/package/ebkr/r2modman/](https://thunderstore.io/package/ebkr/r2modman/)
 
 ### Install Archipelago Mod using r2modman
-You can install the Archipelago mod using r2modman in one of two ways. 
-One, you can use the Thunderstore website and click on the "Install with Mod Manager" link.
+You can install the Archipelago mod using r2modman in one of two ways.
 
-https://thunderstore.io/package/ArchipelagoMW/Archipelago/
+[https://thunderstore.io/package/ArchipelagoMW/Archipelago/](https://thunderstore.io/package/ArchipelagoMW/Archipelago/)
+
+One, you can use the Thunderstore website and click on the "Install with Mod Manager" link.
 
 You can also search for the "Archipelago" mod in the r2modman interface.
 The mod manager should automatically install all necessary dependencies as well.
@@ -46,15 +47,41 @@ Risk of Rain 2:
   start_with_revive: true
   item_pickup_step: 1
   enable_lunar: true
+  item_weights:
+    default: 50
+    new: 0
+    uncommon: 0
+    legendary: 0
+    lunartic: 0
+    chaos: 0
+    no_scraps: 0
+    even: 0
+    scraps_only: 0
+  item_pool_presets: true
+  # custom item weights
+  green_scrap: 16
+  red_scrap: 4
+  yellow_scrap: 1
+  white_scrap: 32
+  common_item: 64
+  uncommon_item: 32
+  legendary_item: 8
+  boss_item: 4
+  lunar_item: 16
+  equipment: 32
 ```
 
 | Name | Description | Allowed values |
 | ---- | ----------- | -------------- |
-| total_locations | The total number of location checks that will be attributed to the Risk of Rain player. This option is ALSO the total number of items in the item pool for the Risk of Rain player. | 10 - 50 |
+| total_locations | The total number of location checks that will be attributed to the Risk of Rain player. This option is ALSO the total number of items in the item pool for the Risk of Rain player. | 10 - 100 |
 | total_revivals | The total number of items in the Risk of Rain player's item pool (items other players pick up for them) replaced with `Dio's Best Friend`. | 0 - 5 |
 | start_with_revive | Starts the player off with a `Dio's Best Friend`. Functionally equivalent to putting a `Dio's Best Friend` in your `starting_inventory`. | true/false |
 | item_pickup_step | The number of item pickups which you are allowed to claim before they become an Archipelago location check. | 0 - 5 |
 | enable_lunar | Allows for lunar items to be shuffled into the item pool on behalf of the Risk of Rain player. | true/false |
+| item_weights | Each option here is a preset item weight that can be used to customize your generate item pool with certain settings. | default, new, uncommon, legendary, lunartic, chaos, no_scraps, even, scraps_only |
+| item_pool_presets | A simple toggle to determine whether the item_weight presets are used or the custom item pool as defined below | true/false |
+| custom item weights | Each defined item here is a single item in the pool that will have a weight against the other items when the item pool gets generated. These values can be modified to adjust how frequently certain items appear | 0-100|
+
 
 Using the example YAML above: the Risk of Rain 2 player will have 15 total items which they can pick up for other players. (total_locations = 15)
 
@@ -66,4 +93,6 @@ They will have 4 of the items which other players can grant them replaced with `
 
 The player will also start with a `Dio's Best Friend`. (start_with_revive = true)
 
-The player will have lunar items shuffled into the item pool on their behalf. (enable_lunar = true)
+The player will have lunar items shuffled into the item pool on their behalf. (enable_lunar = true)
+
+The player will have the default preset generated item pool with the custom item weights being ignored. (item_weights: default and item_pool_presets: true)

WebHostLib/static/assets/tutorial/secret-of-evermore/multiworld_en.md

@@ -0,0 +1,119 @@
+# Secret of Evermore Setup Guide
+
+## Required Software
+- [SNI](https://github.com/alttpo/sni/releases) v0.0.59 or newer (included in Archipelago 0.2.1 setup)
+- Hardware or software capable of loading and playing SNES ROM files
+    - An emulator capable of connecting to SNI with ROM access
+        - [snes9x-rr](https://github.com/gocha/snes9x-rr/releases) or
+        - [BizHawk](http://tasvideos.org/BizHawk.html) or
+        - [bsnes-plus-nwa](https://github.com/black-sliver/bsnes-plus)
+    - Or SD2SNES, [FXPak Pro](https://krikzz.com/store/home/54-fxpak-pro.html), or other compatible hardware
+- Your Secret of Evermore US ROM file, probably named `Secret of Evermore (USA).sfc`
+
+## Create a Config (.yaml) File
+
+### What is a config file and why do I need one?
+Your config file contains a set of configuration options which provide the generator with information about how
+it should generate your game. Each player of a multiworld will provide their own config file. This setup allows
+each player to enjoy an experience customized for their taste, and different players in the same multiworld
+can all have different options.
+
+### Where do I get a config file?
+The [Player Settings](/games/Secret%20of%20Evermore/player-settings) page on the website allows you to configure your
+personal settings and export a config file from them.
+
+### Verifying your config file
+If you would like to validate your config file to make sure it works, you may do so on the
+[YAML Validator](/mysterycheck) page.
+
+## Generating a Single-Player Game
+Stand-alone "Evermizer" has a way of balancing single-player games, but may not always be on par feature-wise.
+Head over to [evermizer.com](https://evermizer.com) if you want to try the official stand-alone, otherwise read below.
+
+1. Navigate to the [Player Settings](/games/Secret%20of%20Evermore/player-settings) page, configure your options, and
+   click the "Generate Game" button.
+2. You will be presented with a "Seed Info" page.
+3. Click the "Create New Room" link.
+4. You will be presented with a server page, from which you can download your patch file.
+5. Run your patch file through [apbpatch](https://evermizer.com/apbpatch) and load it in your emulator or console.
+
+## Joining a MultiWorld Game
+
+### Obtain your patch file and create your ROM
+When you join a multiworld game, you will be asked to provide your config file to whoever is hosting. Once that
+is done, the host will provide you with either a link to download your patch file, or with a zip file containing
+everyone's patch files. Your patch file should have a `.apsoe` extension.
+
+Put your patch file on your desktop or somewhere convenient, open [apbpatch](https://evermizer.com/apbpatch) and
+generate your ROM from it. Load the ROM file in your emulator or console.
+
+### Connect to SNI
+
+#### With an emulator
+Start SNI either from the Archipelago install folder or the stand-alone version.
+If this is its first time launching, you may be prompted to allow it to communicate through the Windows Firewall.
+
+##### snes9x-rr
+1. Load your ROM file if it hasn't already been loaded.
+2. Click on the File menu and hover on **Lua Scripting**
+3. Click on **New Lua Script Window...**
+4. In the new window, click **Browse...**
+5. Select the `Connector.lua` file from your SNI installation:
+    * `SNI/lua/x86/Connector.lua` for 32bit snes9x-rr or
+    * `SNI/lua/x64/Connector.lua` for "x64" snes9x-rr
+6. Leave the Lua window open while you are playing.
+
+* If the script window complains about missing `socket.dll` make sure it is in the lua directory.
+* If the script window complains about "Bad EXE format", use the other Connector above (x86 <-> x64)
+
+##### BizHawk
+1. Ensure you have the BSNES core loaded. You may do this by clicking on the Tools menu in BizHawk and following
+   these menu options:  
+   `Config --> Cores --> SNES --> BSNES`  
+   Once you have changed the loaded core, you must restart BizHawk.
+2. Load your ROM file if it hasn't already been loaded.
+3. Click on the Tools menu and click on **Lua Console**
+4. Click the button to open a new Lua script.
+5. Select any `Connector.lua` file from your SNI installation
+
+##### bsnes-plus-nwa
+This should automatically connect to SNI.
+If this is its first time launching, you may be prompted to allow it to communicate through the Windows Firewall. 
+
+#### With hardware
+This guide assumes you have downloaded the correct firmware for your device. If you have not
+done so already, please do this now. SD2SNES and FXPak Pro users may download the appropriate firmware
+[here](https://github.com/RedGuyyyy/sd2snes/releases). Other hardware may find helpful information
+[on this page](http://usb2snes.com/#supported-platforms).
+
+1. Copy the ROM file to your SD card.
+2. Load the ROM file from the menu.
+
+### Open the client
+Open [ap-soeclient](http://evermizer.com/apclient) in a modern browser. Do not switch tabs, open it in a new window
+if you want to use the browser while playing. Do not minimize the window with the client.
+
+The client should automatically connect to SNI, the "SNES" status should change to green.
+
+### Connect to the Archipelago Server
+Enter `/connect server:port` in the client's command prompt and press enter. You'll find `server:port` on the same page
+that had the patch file.
+
+### Play the game
+When the game is loaded but not yet past the intro cutscene, the "Game" status is yellow. When the client shows "AP" as
+green and "Game" as yellow, you're ready to play. The intro can be skipped pressing the START button and "Game" should
+change to green. Congratulations on successfully joining a multiworld game!
+
+## Hosting a MultiWorld game
+The recommended way to host a game is to use our [hosting service](/generate). The process is relatively simple:
+
+1. Collect config files from your players.
+2. Create a zip file containing your players' config files.
+3. Upload that zip file to the website linked above.
+4. Wait a moment while the seed is generated.
+5. When the seed is generated, you will be redirected to a "Seed Info" page.
+6. Click "Create New Room". This will take you to the server page. Provide the link to this page to your players,
+   so they may download their patch files from there.
+7. Note that a link to a MultiWorld Tracker is at the top of the room page. The tracker shows the progress of all
+   players in the game. Any observers may also be given the link to this page.
+8. Once all players have joined, you may begin playing.

WebHostLib/static/assets/tutorial/super-metroid/multiworld_en.md

@@ -0,0 +1,126 @@
+# Super Metroid Setup Guide
+
+## Required Software
+- [Super Metroid Client](https://github.com/ArchipelagoMW/SuperMetroidClient/releases)
+- **sniConnector.lua** (located on the client download page)
+- [SNI](https://github.com/alttpo/sni/releases) (Included in the Super Metroid Client)
+- Hardware or software capable of loading and playing SNES ROM files
+    - An emulator capable of connecting to SNI
+      ([snes9x Multitroid](https://drive.google.com/drive/folders/1_ej-pwWtCAHYXIrvs5Hro16A1s9Hi3Jz),
+      [BizHawk](http://tasvideos.org/BizHawk.html))
+    - An SD2SNES, [FXPak Pro](https://krikzz.com/store/home/54-fxpak-pro.html), or other compatible hardware
+- Your Super Metroid ROM file, probably named `Super Metroid (Japan, USA).sfc`
+
+## Installation Procedures
+
+### Windows Setup
+1. Download and install the Super Metroid Client from the link above, making sure to install the most recent version.
+**The file is located in the assets section at the bottom of the version information**.
+2. During setup, you will be asked to locate your base ROM file. This is your Super Metroid ROM file.
+3. If you are using an emulator, you should assign your Lua capable emulator as your default program
+for launching ROM files.
+    1. Extract your emulator's folder to your Desktop, or somewhere you will remember. 
+    2. Right-click on a ROM file and select **Open with...**
+    3. Check the box next to **Always use this app to open .sfc files**
+    4. Scroll to the bottom of the list and click the grey text **Look for another App on this PC**
+    5. Browse for your emulator's `.exe` file and click **Open**. This file should be located inside
+       the folder you extracted in step one.
+
+### Macintosh Setup
+- We need volunteers to help fill this section! Please contact **Farrak Kilhn** on Discord if you want to help.
+
+## Create a Config (.yaml) File
+
+### What is a config file and why do I need one?
+Your config file contains a set of configuration options which provide the generator with information about how
+it should generate your game. Each player of a multiworld will provide their own config file. This setup allows
+each player to enjoy an experience customized for their taste, and different players in the same multiworld
+can all have different options.
+
+### Where do I get a config file?
+The [Player Settings](/games/Super%20Metroid/player-settings) page on the website allows you to configure your
+personal settings and export a config file from them.
+
+### Verifying your config file
+If you would like to validate your config file to make sure it works, you may do so on the
+[YAML Validator](/mysterycheck) page.
+
+## Generating a Single-Player Game
+1. Navigate to the [Player Settings](/games/Super%20Metroid/player-settings) page, configure your options, and click
+   the "Generate Game" button.
+2. You will be presented with a "Seed Info" page.
+3. Click the "Create New Room" link.
+4. You will be presented with a server page, from which you can download your patch file.
+5. Double-click on your patch file, and the Super Metroid Client will launch automatically, create your ROM from
+   the patch file, and open your emulator for you.
+6. Since this is a single-player game, you will no longer need the client, so feel free to close it.
+
+## Joining a MultiWorld Game
+
+### Obtain your patch file and create your ROM
+When you join a multiworld game, you will be asked to provide your config file to whoever is hosting. Once that
+is done, the host will provide you with either a link to download your patch file, or with a zip file containing
+everyone's patch files. Your patch file should have a `.apm3` extension.
+
+Put your patch file on your desktop or somewhere convenient, and double click it. This should automatically
+launch the client, and will also create your ROM in the same place as your patch file.
+
+### Connect to the client
+
+#### With an emulator
+When the client launched automatically, SNI should have also automatically launched in the background.
+If this is its first time launching, you may be prompted to allow it to communicate through the Windows
+Firewall.
+
+##### snes9x Multitroid
+1. Load your ROM file if it hasn't already been loaded.
+2. Click on the File menu and hover on **Lua Scripting**
+3. Click on **New Lua Script Window...**
+4. In the new window, click **Browse...**
+5. Select the `sniConnector.lua` file you downloaded above
+
+##### BizHawk
+1. Ensure you have the BSNES core loaded. You may do this by clicking on the Tools menu in BizHawk and following
+   these menu options:  
+   `Config --> Cores --> SNES --> BSNES`  
+   Once you have changed the loaded core, you must restart BizHawk.
+2. Load your ROM file if it hasn't already been loaded.
+3. Click on the Tools menu and click on **Lua Console**
+4. Click the button to open a new Lua script.
+5. Select the `sniConnector.lua` file you downloaded above
+
+#### With hardware
+This guide assumes you have downloaded the correct firmware for your device. If you have not
+done so already, please do this now. SD2SNES and FXPak Pro users may download the appropriate firmware
+[here](https://github.com/RedGuyyyy/sd2snes/releases). Other hardware may find helpful information
+[on this page](http://usb2snes.com/#supported-platforms).
+
+1. Close your emulator, which may have auto-launched.
+2. Power on your device and load the ROM.
+
+### Connect to the Archipelago Server
+The patch file which launched your client should have automatically connected you to the AP Server.
+There are a few reasons this may not happen however, including if the game is hosted on the website but
+was generated elsewhere. If the client window shows "Server Status: Not Connected", simply ask the host
+for the address of the server, and copy/paste it into the "Server" input field then press enter.
+
+The client will attempt to reconnect to the new server address, and should momentarily show "Server
+Status: Connected".
+
+### Play the game
+When the client shows both SNES Device and Server as connected, you're ready to begin playing. Congratulations
+on successfully joining a multiworld game!
+
+## Hosting a MultiWorld game
+The recommended way to host a game is to use our [hosting service](/generate). The process is relatively simple:
+
+1. Collect config files from your players.
+2. Create a zip file containing your players' config files.
+3. Upload that zip file to the website linked above.
+4. Wait a moment while the seed is generated.
+5. When the seed is generated, you will be redirected to a "Seed Info" page.
+6. Click "Create New Room". This will take you to the server page. Provide the link to this page to your players,
+   so they may download their patch files from there.
+7. Note that a link to a MultiWorld Tracker is at the top of the room page. The tracker shows the progress of all
+   players in the game. Any observers may also be given the link to this page.
+8. Once all players have joined, you may begin playing.

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

@@ -0,0 +1,60 @@
+# Timespinner Randomizer Setup Guide
+
+## Required Software
+
+- [Timespinner (steam)](https://store.steampowered.com/app/368620/Timespinner/) or [Timespinner (drm free)](https://www.humblebundle.com/store/timespinner)
+- [Timespinner Randomizer](https://github.com/JarnoWesthof/TsRandomizer)
+
+## General Concept
+
+The timespinner Randomizer loads Timespinner.exe from the same folder, and alters its state in memory to allow for randomization of the items
+
+## Installation Procedures
+
+Download latest version of [Timespinner Randomizer](https://github.com/JarnoWesthof/TsRandomizer) you can find the .zip files on the releases page, download the zip for your current platform. Then extract the zip to the folder where your Timespinner game is installed. Then just run TsRandomizer.exe instead of Timespinner.exe to start the game in randomized mode, for more info see the [readme](https://github.com/JarnoWesthof/TsRandomizer)
+    
+## Joining a MultiWorld Game
+
+1. Run TsRandomizer.exe
+2. Select "New Game"
+3. Switch "<< Select Seed >>" to "<< Archiplago >>" by pressing left on the controller or keyboard 
+4. Select "<< Archiplago >>" to open a new menu where you can enter your Archipelago login credentails
+	* NOTE: the input fields support Ctrl + V pasting of values
+5. Select "Connect"
+6. If all went well you will be taken back the difficulty selection menu and the game will start as soon as you select a difficulty
+
+## YAML Settings
+An example YAML would look like this:
+```yaml
+description: Default Timespinner Template
+name: Lunais{number} # Your name in-game. Spaces will be replaced with underscores and there is a 16 character limit
+game:
+  Timespinner: 1
+requires:
+  version: 0.1.8
+Timespinner:
+  StartWithJewelryBox: # Start with Jewelry Box unlocked
+    false: 50
+    true: 0
+  DownloadableItems: # With the tablet you will be able to download items at terminals
+    false: 50
+    true: 50
+  FacebookMode: # Requires Oculus Rift(ng) to spot the weakspots in walls and floors
+    false: 50
+    true: 0
+  StartWithMeyef: # Start with Meyef, ideal for when you want to play multiplayer
+    false: 50
+    true: 50
+  QuickSeed: # Start with Talaria Attachment, Nyoom!
+    false: 50
+    true: 0
+  SpecificKeycards: # Keycards can only open corresponding doors
+    false: 0
+    true: 50
+  Inverted: # Start in the past
+    false: 50
+    true: 50
+```
+* All Options are either enabled or not, if values are specified for both true & false the generator will select one based on weight
+* The Timespinner Randomizer option "StinkyMaw" is currently always enabled for Archipelago generated seeds
+* The Timespinner Randomizer options "ProgressiveVerticalMovement" & "ProgressiveKeycards" are currently not supported on Archipelago generated seeds

WebHostLib/static/assets/tutorial/tutorials.json

@@ -1,4 +1,65 @@
 [
+  {
+    "gameTitle": "Archipelago",
+    "tutorials": [
+      {
+        "name": "Multiworld Setup Tutorial",
+        "description": "A guide to setting up the Archipelago software to generate and host multiworld games on your computer and using the website.",
+        "files": [
+          {
+            "language": "English",
+            "filename": "archipelago/setup_en.md",
+            "link": "archipelago/setup/en",
+            "authors": [
+              "alwaysintreble"
+            ]
+          }
+        ]
+      },
+      {
+        "name": "Using Advanced Settings",
+        "description": "A guide to reading yaml files and editing them to fully customize your game.",
+        "files": [
+          {
+            "language": "English",
+            "filename": "archipelago/advanced_settings_en.md",
+            "link": "archipelago/advanced_settings/en",
+            "authors": [
+              "alwaysintreble"
+            ]
+          }
+        ]
+      },
+      {
+        "name": "Archipelago Triggers Guide",
+        "description": "A guide to setting up and using triggers in your game settings.",
+        "files": [
+          {
+            "language": "English",
+            "filename": "archipelago/triggers_en.md",
+            "link": "archipelago/triggers/en",
+            "authors": [
+              "alwaysintreble"
+            ]
+          }
+        ]
+      },
+      {
+        "name": "Archipelago Plando Guide",
+        "description": "A guide to understanding and using plando for your game.",
+        "files": [
+          {
+            "language": "English",
+            "filename": "archipelago/plando_en.md",
+            "link": "archipelago/plando/en",
+            "authors": [
+              "alwaysintreble"
+            ]
+          }
+        ]
+      }
+    ]
+  },
   {
     "gameTitle": "The Legend of Zelda: A Link to the Past",
     "tutorials": [
@@ -86,6 +147,33 @@
       }
     ]
   },
+  {
+    "gameTitle": "The Legend of Zelda: Ocarina of Time",
+    "tutorials": [
+      {
+        "name": "Multiworld Setup Tutorial",
+        "description": "A guide to setting up the Archipelago Ocarina of Time software on your computer.",
+        "files": [
+          {
+            "language": "English",
+            "filename": "zelda5/setup_en.md",
+            "link": "zelda5/setup/en",
+            "authors": [
+              "Edos"
+            ]
+          },
+          {
+            "language": "Spanish",
+            "filename": "zelda5/setup_es.md",
+            "link": "zelda5/setup/es",
+            "authors": [
+              "Edos"
+            ]
+          }
+        ]
+      }
+    ]
+  },
   {
     "gameTitle": "Factorio",
     "tutorials": [
@@ -98,7 +186,8 @@
             "filename": "factorio/setup_en.md",
             "link": "factorio/setup/en",
             "authors": [
-              "Berserker"
+              "Berserker",
+              "Farrak Kilhn"
             ]
           }
         ]
@@ -158,5 +247,100 @@
         ]
       }
     ]
+  },
+  {
+    "gameTitle": "Timespinner",
+    "tutorials": [
+      {
+        "name": "Multiworld Setup Guide",
+        "description": "A guide to setting up the Timespinner randomizer connected to an Archipelago Multiworld",
+        "files": [
+          {
+            "language": "English",
+            "filename": "timespinner/setup_en.md",
+            "link": "timespinner/setup/en",
+            "authors": [
+              "Jarno"
+            ]
+          }
+        ]
+      }
+    ]
+  },
+  {
+    "gameTitle": "Subnautica",
+    "tutorials": [
+      {
+        "name": "Multiworld Setup Guide",
+        "description": "A guide to setting up the Subnautica randomizer connected to an Archipelago Multiworld",
+        "files": [
+          {
+            "language": "English",
+            "filename": "Subnautica/setup_en.md",
+            "link": "Subnautica/setup/en",
+            "authors": [
+              "Berserker"
+            ]
+          }
+        ]
+      }
+    ]
+  },
+  {
+    "gameTitle": "Super Metroid",
+    "tutorials": [
+      {
+        "name": "Multiworld Setup Guide",
+        "description": "A guide to setting up the Super Metroid Client on your computer. This guide covers single-player, multiworld, and related software.",
+        "files": [
+          {
+            "language": "English",
+            "filename": "super-metroid/multiworld_en.md",
+            "link": "super-metroid/multiworld/en",
+            "authors": [
+              "Farrak Kilhn"
+            ]
+          }
+        ]
+      }
+    ]
+  },
+  {
+    "gameTitle": "Secret of Evermore",
+    "tutorials": [
+      {
+        "name": "Multiworld Setup Guide",
+        "description": "A guide to playing Secret of Evermore randomizer. This guide covers single-player, multiworld and related software.",
+        "files": [
+          {
+            "language": "English",
+            "filename": "secret-of-evermore/multiworld_en.md",
+            "link": "secret-of-evermore/multiworld/en",
+            "authors": [
+              "Black Sliver"
+            ]
+          }
+        ]
+      }
+    ]
+  },
+  {
+    "gameTitle": "Final Fantasy",
+    "tutorials": [
+      {
+        "name": "Multiworld Setup Guide",
+        "description": "A guide to playing Final Fantasy multiworld. This guide only covers playing multiworld.",
+        "files": [
+          {
+            "language": "English",
+            "filename": "ff1/multiworld_en.md",
+            "link": "ff1/multiworld/en",
+            "authors": [
+              "jat2980"
+            ]
+          }
+        ]
+      }
+    ]
   }
 ]

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

@@ -74,3 +74,4 @@ Below is a list of MSU packs which, so far as we know, are safe to stream. More
 we learn of them. If you know of any we missed, please let us know!
 - Vanilla Game Music
 - [Smooth McGroove](https://drive.google.com/open?id=1JDa1jCKg5hG0Km6xNpmIgf4kDMOxVp3n)
+- Zelda community member Amarith assembled the following list for the purpose of competitive restreams.  While we have not ourselves verified this list, all submissions required VoD proof they were not muted.  Generally speaking, MSU-1 packs are less safe if they contain lyrics at any point.  This list was only tested on Twitch and results for other platforms may vary. [Restream-Safe List](https://tinyurl.com/MSUsApprovedForLeagueChannels)

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

@@ -2,9 +2,9 @@
 
 ## Benötigte Software
 - [Archipelago](https://github.com/ArchipelagoMW/Archipelago/releases)
-- [QUsb2Snes](https://github.com/Skarsnik/QUsb2snes/releases) (Included in the above Utilities)
-- Hardware oder Software zum Laden und Abspielen von SNES Rom-Dateien
-    - Ein Emulator, der lua-scripts abspielen kann
+- [SNI](https://github.com/alttpo/sni/releases) (Integriert in Archipelago)
+- Hardware oder Software zum Laden und Abspielen von SNES Rom-Dateien fähig zu einer Internetverbindung
+    - Ein Emulator, der mit SNI verbinden kann
       ([snes9x Multitroid](https://drive.google.com/drive/folders/1_ej-pwWtCAHYXIrvs5Hro16A1s9Hi3Jz),
       [BizHawk](http://tasvideos.org/BizHawk.html))
     - Ein SD2SNES, [FXPak Pro](https://krikzz.com/store/home/54-fxpak-pro.html), oder andere kompatible Hardware
@@ -42,7 +42,7 @@ jeder Spieler sein Spiel nach seinem eigenen Geschmack gestalten, während ander
 Einstellungen wählen können!
 
 ### Wo bekomme ich so eine YAML-Datei her?
-Die [Player Settings](/player-settings) Seite auf der Website ermöglicht das einfache Erstellen  und Herunterladen
+Die [Player Settings](/games/A Link to the Past/player-settings) Seite auf der Website ermöglicht das einfache Erstellen  und Herunterladen
 deiner eigenen `yaml` Datei. Drei verschiedene Voreinstellungen können dort gespeichert werden.
 
 ### Deine YAML-Datei ist gewichtet!
@@ -74,12 +74,12 @@ bei der [YAML Validator](/mysterycheck) Seite tun.
 ### Erhalte deine Patch-Datei und erstelle dein ROM
 Wenn du an einem MultiWorld-Spiel teilnehmen möchtest, wirst du in der Regel vom Host nach deiner YAML-Datei gefragt.
 Sobald du diese weitergegeben hast, wird der Host einen Link bereitstellen, wo du deinen Patch oder eine .zip-Datei
-mit allen Patches herunterladen kannst. Die Patch-Datei hat immer die Endung `.bmbp`.
+mit allen Patches herunterladen kannst. Die Patch-Datei hat immer die Endung `.apbp`.
 
 ### Mit dem Client verbinden
 
 #### Via Emulator
-Wenn der client den Emulator automatisch gestartet hat, wird QUsb2Snes ebenfalls im Hintergrund gestartet.
+Wenn der client den Emulator automatisch gestartet hat, wird SNI ebenfalls im Hintergrund gestartet.
 Wenn dies das erste Mal ist, wird möglicherweise ein Fenster angezeigt, wo man bestätigen muss, dass das Programm
 durch die Windows Firewall kommunizieren darf.
 
@@ -88,8 +88,9 @@ durch die Windows Firewall kommunizieren darf.
 2. Klicke auf den Reiter "File" oben im Menü und wähle **Lua Scripting**
 3. Klicke auf **New Lua Script Window...**
 4. Im sich neu öffnenden Fenster, klicke auf **Browse...**
-5. Navigiere zum Ort, wo du snes9x Multitroid installiert hast, öffne den `lua`-Ordner und öffne `multibridge.lua`
-6. Schaue im Lua-Fenster nach einem Namen, der dir zugeteilt wird und schaue im Client (WebUI im Browser), ob dort
+5. Navigiere zum Verzeichnis, wo du Archipelago installiert hast und dort in den Unterordner `SNI`.
+6. Wähle dort die `Connector.lua` und klicke auf Öffnen.
+7. Schaue im Lua-Fenster nach einem Namen, der dir zugeteilt wird und schaue im Client (WebUI im Browser), ob dort
    "Snes Device: Connected" mit demselben Namen dort steht (in der oberen linken Ecke).
 
 ##### BizHawk
@@ -99,9 +100,8 @@ durch die Windows Firewall kommunizieren darf.
 2. Lade die entsprechende ROM-Datei, wenn sie nicht schon automatisch geladen wurde.
 3. Klicke auf das Tools-Menü und klicke auf **Lua Console**
 4. Klicke auf den Button um ein neues Lua-Script zu öffnen.
-5. Navigiere zum Verzeichnis, wo du die Multiworld Utilities installiert hast und dort in folgende Ordner:
-   `QUsb2Snes/Qusb2Snes/LuaBridge`
-6. Wähle dort die `luabridge.lua` und klicke auf Öffnen.
+5. Navigiere zum Verzeichnis, wo du Archipelago installiert hast und dort in den Unterordner `SNI`.
+6. Wähle dort die `Connector.lua` und klicke auf Öffnen.
 7. Schaue im Lua-Fenster nach einem Namen, der dir zugeteilt wird und schaue im Client (WebUI im Browser), ob dort
    "Snes Device: Connected" mit demselben Namen dort steht (in der oberen linken Ecke)
 
@@ -111,15 +111,11 @@ das noch nicht getan hast, so tue dies am besten jetzt! SD2SNES und FXPak Pro Nu
 [hier](https://github.com/RedGuyyyy/sd2snes/releases). Nutzer ähnlicher Hardware finden Hilfestellung
 [auf dieser Seite](http://usb2snes.com/#supported-platforms).
 
-**UM MIT HARDWARE ZU VERBINDEN WIRD AKTUELL EINE ALTE VERSION VON QUSB2SNES BENÖTIGT
-([v0.7.16](https://github.com/Skarsnik/QUsb2snes/releases/tag/v0.7.16)).**  
-Neuere Versionen funktionieren möglicherweise nur eingeschränkt, fehlerhaft oder gar nicht!
 
 1. Schließe deinen Emulator, falls er automatisch gestartet haben sollte.
-2. Schließe QUsb2Snes, welches automatisch mit dem Client gestartet wurde (in der Taskleiste zu finden).
-3. Starte die richtige version von QUsb2Snes (v0.7.16).
-4. Starte deine (Original-)Konsole und lade die ROM-Datei.
-5. Schaue auf dein Clientfenster, welches nun "Snes Device: Connected" und den namen deiner Konsole
+2. Start SNI
+3. Starte deine (Original-)Konsole und lade die ROM-Datei.
+4. Schaue auf dein Clientfenster, welches nun "Snes Device: Connected" und den namen deiner Konsole
    zeigen sollte.
 
 ### Mit dem MultiServer verbinden
@@ -137,7 +133,7 @@ können du und deine Freunde loslegen! Glückwunsch zum erfolgreichen Beitritt z
 
 ## Ein Multiworld-Spiel hosten
 Die Empfohlene Art, ein Spiel zu hosten, ist, den Service auf
-[der website](https://berserkermulti.world/generate) zu nutzen. Das Ganze ist recht einfach:
+[der website](/generate) zu nutzen. Das Ganze ist recht einfach:
 
 1. Lasse dir von deinen Mitspielern die YAML-Datei zuschicken.
 2. Erstelle einen Zip-komprimierten Ordner´, in den du alle YAML-Dateien deiner Spieler einfügst.

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

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

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

@@ -43,7 +43,7 @@ Cada jugador en una partida de multiworld proveerá su propio fichero YAML. Esta
 que cada jugador disfrute de una experiencia personalizada a su gusto, y cada jugador dentro de la misma partida de multiworld puede tener diferentes opciones.
 
 ### Donde puedo obtener un fichero YAML?
-La página "[Generate Game](/player-settings)" en el sitio web te permite configurar tu configuración personal y
+La página "[Generate Game](/games/A%20Link%20to%20the%20Past/player-settings)" en el sitio web te permite configurar tu configuración personal y
 descargar un fichero "YAML". 
 
 ### Configuración YAML avanzada
@@ -67,7 +67,7 @@ Si quieres validar que tu fichero YAML para asegurarte que funciona correctament
 [YAML Validator](/mysterycheck).
 
 ## Generar una partida para un jugador
-1. Navega a [la pagina Generate game](/player-settings), configura tus opciones, haz click en el boton "Generate game".
+1. Navega a [la pagina Generate game](/games/A%20Link%20to%20the%20Past/player-settings), configura tus opciones, haz click en el boton "Generate game".
 2. Se te redigirá a una pagina "Seed Info", donde puedes descargar tu archivo de parche.
 3. Haz doble click en tu fichero de parche, y el emulador debería ejecutar tu juego automáticamente. Como el
    Cliente no es necesario para partidas de un jugador, puedes cerrarlo junto a la pagina web (que tiene como titulo "Multiworld WebUI") que se ha abierto automáticamente.

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

@@ -49,7 +49,7 @@ sur comment il devrait générer votre seed. Chaque joueur d'un multiwolrd devra
 joueur d'apprécier une expérience customisée selon ses goûts, et les différents joueurs d'un même multiworld peuvent avoir différentes options.
 
 ### Où est-ce que j'obtiens un fichier YAML ?
-La page [Génération de partie](/player-settings) vous permet de configurer vos paramètres personnels et de les exporter vers un fichier YAML.
+La page [Génération de partie](/games/A%20Link%20to%20the%20Past/player-settings) vous permet de configurer vos paramètres personnels et de les exporter vers un fichier YAML.
 
 ### Configuration avancée du fichier YAML
 Une version plus avancée du fichier YAML peut être créée en utilisant la page des [paramètres de pondération](/weighted-settings), qui vous permet
@@ -71,7 +71,7 @@ Si vous voulez valider votre fichier YAML pour être sûr qu'il fonctionne, vous
 [Validateur de YAML](/mysterycheck).
 
 ## Générer une partie pour un joueur
-1. Aller sur la page [Génération de partie](/player-settings), configurez vos options, et cliquez sur le bouton "Generate Game".
+1. Aller sur la page [Génération de partie](/games/A%20Link%20to%20the%20Past/player-settings), configurez vos options, et cliquez sur le bouton "Generate Game".
 2. Il vous sera alors présenté une page d'informations sur la seed, où vous pourrez télécharger votre patch.
 3. Double-cliquez sur le patch et l'émulateur devrait se lancer automatiquement avec la seed. Etant donné que le client
 n'est pas requis pour les parties à un joueur, vous pouvez le fermer ainsi que l'interface Web (WebUI).

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

@@ -31,8 +31,8 @@
         - Example: `simple`
           - Runs a particular boss shuffle mode to finish construction instead of vanilla placement, typically used as
             a last instruction.
-- [Available Bosses](https://github.com/Berserker66/MultiWorld-Utilities/blob/65fa39df95c90c9b66141aee8b16b7e560d00819/Bosses.py#L135)
-- [Available Arenas](https://github.com/Berserker66/MultiWorld-Utilities/blob/65fa39df95c90c9b66141aee8b16b7e560d00819/Bosses.py#L186)
+- [Available Bosses](https://github.com/ArchipelagoMW/Archipelago/blob/main/worlds/alttp/Bosses.py#L135)
+- [Available Arenas](https://github.com/ArchipelagoMW/Archipelago/blob/main/worlds/alttp/Bosses.py#L150)
 
 #### Examples
 ```yaml
@@ -79,8 +79,8 @@ boss_shuffle:
     - placements are picked randomly, not sorted in any way
 - Warning: Placing non-Dungeon Prizes on Prize locations and 
   Prizes on non-Prize locations will break the game in various ways.
-- [Available Items](https://github.com/Berserker66/MultiWorld-Utilities/blob/3b5ba161dea223b96e9b1fc890e03469d9c6eb59/Items.py#L26)
-- [Available Locations](https://github.com/Berserker66/MultiWorld-Utilities/blob/3b5ba161dea223b96e9b1fc890e03469d9c6eb59/Regions.py#L418)
+- [Available Items](https://github.com/ArchipelagoMW/Archipelago/blob/main/worlds/alttp/Items.py#L52)
+- [Available Locations](https://github.com/ArchipelagoMW/Archipelago/blob/main/worlds/alttp/Regions.py#L434)
 
 #### Examples
 ```yaml
@@ -133,10 +133,10 @@ Link's House and removes the picked item from the item pool.
     - `\n` is a newline. 
     - `@` is the entered player's name.
     - Warning: Text Mapper does not support full unicode.
-    - [Alphabet](https://github.com/Berserker66/MultiWorld-Utilities/blob/65fa39df95c90c9b66141aee8b16b7e560d00819/Text.py#L756)
+    - [Alphabet](https://github.com/ArchipelagoMW/Archipelago/blob/main/worlds/alttp/Text.py#L758)
 - at is the location within the game to attach the text to.
     - can be weighted.
-    - [List of targets](https://github.com/Berserker66/MultiWorld-Utilities/blob/65fa39df95c90c9b66141aee8b16b7e560d00819/Text.py#L1498)
+    - [List of targets](https://github.com/ArchipelagoMW/Archipelago/blob/main/worlds/alttp/Text.py#L1499)
    
 #### Example
 ```yaml
@@ -160,7 +160,7 @@ This has a 50% chance to trigger at all. If it does, it throws a coin between `u
 - entrance is the overworld door
 - exit is the underworld exit
 - direction can be `both`, `entrance` or `exit`
-- doors can be found in [this file](https://github.com/Berserker66/MultiWorld-Utilities/blob/main/EntranceShuffle.py)
+- doors can be found in [this file](https://github.com/ArchipelagoMW/Archipelago/blob/main/worlds/alttp/EntranceShuffle.py#L3852)
 
 
 #### Example

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

@@ -0,0 +1,387 @@
+# Setup Guide for Ocarina of time Archipelago
+
+## Important
+
+As we are using Z5Client and Bizhawk, this guide is only applicable to Windows.
+
+## Required Software
+
+- [bizhawk+script+Z5Client](https://github.com/ArchipelagoMW/Z5Client/releases) We recommend download Z5Client-setup as it makes some steps automatic.
+
+## Install Emulator and client
+
+Download getBizhawk.ps1 from previous link. Place it on the folder where you want your emulator to be installed, right click on it and select "Run with PowerShell". This will download all the needed dependencies used by the emulator. This can take a while.
+
+It is strongly recommended to associate N64 rom extension (\*.n64) to the Bizhawk we've just installed. To do so, we simple have to search any N64 rom we happened to own, right click and select "Open with...", we unfold the list that appears and select the bottom option "Look for another application", we browse to Bizhawk folder and select EmuHawk.exe
+
+Place the ootMulti.lua file from the previous link inside the "lua" folder from the just installed emulator.
+
+Install the Z5Client using its setup.
+
+## Configuring your YAML file
+
+### What is a YAML file and why do I need one?
+Your YAML file contains a set of configuration options which provide the generator with information about how
+it should generate your game. Each player of a multiworld will provide their own YAML file. This setup allows
+each player to enjoy an experience customized for their taste, and different players in the same multiworld
+can all have different options.
+
+### Where do I get a YAML file?
+
+A basic OOT yaml will look like this. There are lots of cosmetic options that have been removed for the sake of this tutorial, if you want to see a complete list, download [Archipelago](https://github.com/ArchipelagoMW/Archipelago/releases) and look for the sample file in the "Players" folder.
+```yaml
+description: Default Ocarina of Time Template # Used to describe your yaml. Useful if you have multiple files
+# Your name in-game. Spaces will be replaced with underscores and there is a 16 character limit
+name: YourName
+game:
+  Ocarina of Time: 1
+requires:
+  version: 0.1.7 # Version of Archipelago required for this yaml to work as expected.
+# Shared Options supported by all games:
+accessibility:
+  items: 0 # Guarantees you will be able to acquire all items, but you may not be able to access all locations
+  locations: 50 # Guarantees you will be able to access all locations, and therefore all items
+  none: 0 # Guarantees only that the game is beatable. You may not be able to access all locations or acquire all items
+progression_balancing:
+  on: 50 # A system to reduce BK, as in times during which you can't do anything by moving your items into an earlier access sphere to make it likely you have stuff to do
+  off: 0 # Turn this off if you don't mind a longer multiworld, or can glitch/sequence break around missing items.
+Ocarina of Time:
+  logic_rules: # Set the logic used for the generator.
+    glitchless: 50
+    glitched: 0
+    no_logic: 0
+  logic_no_night_tokens_without_suns_song: # Nighttime skulltulas will logically require Sun's Song.
+    false: 50
+    true: 0
+  open_forest: # Set the state of Kokiri Forest and the path to Deku Tree.
+    open: 50
+    closed_deku: 0
+    closed: 0
+  open_kakariko: # Set the state of the Kakariko Village gate.
+    open: 50
+    zelda: 0
+    closed: 0
+  open_door_of_time: # Open the Door of Time by default, without the Song of Time.
+    false: 0
+    true: 50
+  zora_fountain: # Set the state of King Zora, blocking the way to Zora's Fountain.
+    open: 0
+    adult: 0
+    closed: 50
+  gerudo_fortress: # Set the requirements for access to Gerudo Fortress.
+    normal: 0
+    fast: 50
+    open: 0
+  bridge: # Set the requirements for the Rainbow Bridge.
+    open: 0
+    vanilla: 0
+    stones: 0
+    medallions: 50
+    dungeons: 0
+    tokens: 0
+  trials: # Set the number of required trials in Ganon's Castle.
+    # you can add additional values between minimum and maximum
+    0: 50 # minimum value
+    6: 0 # maximum value
+    random: 0
+    random-low: 0
+    random-high: 0
+  starting_age: # Choose which age Link will start as.
+    child: 50
+    adult: 0
+  triforce_hunt: # Gather pieces of the Triforce scattered around the world to complete the game.
+    false: 50
+    true: 0
+  triforce_goal: # Number of Triforce pieces required to complete the game. Total number placed determined by the Item Pool setting.
+    # you can add additional values between minimum and maximum
+    1: 0 # minimum value
+    50: 0 # maximum value
+    random: 0
+    random-low: 0
+    random-high: 0
+    20: 50
+  bombchus_in_logic: # Bombchus are properly considered in logic. The first found pack will have 20 chus; Kokiri Shop and Bazaar sell refills; bombchus open Bombchu Bowling.
+    false: 50
+    true: 0
+  bridge_stones: # Set the number of Spiritual Stones required for the rainbow bridge.
+    # you can add additional values between minimum and maximum
+    0: 0 # minimum value
+    3: 50 # maximum value
+    random: 0
+    random-low: 0
+    random-high: 0
+  bridge_medallions: # Set the number of medallions required for the rainbow bridge.
+    # you can add additional values between minimum and maximum
+    0: 0 # minimum value
+    6: 50 # maximum value
+    random: 0
+    random-low: 0
+    random-high: 0
+  bridge_rewards: # Set the number of dungeon rewards required for the rainbow bridge.
+    # you can add additional values between minimum and maximum
+    0: 0 # minimum value
+    9: 50 # maximum value
+    random: 0
+    random-low: 0
+    random-high: 0
+  bridge_tokens: # Set the number of Gold Skulltula Tokens required for the rainbow bridge.
+    # you can add additional values between minimum and maximum
+    0: 0 # minimum value
+    100: 50 # maximum value
+    random: 0
+    random-low: 0
+    random-high: 0
+  shuffle_mapcompass: # Control where to shuffle dungeon maps and compasses.
+    remove: 0
+    startwith: 50
+    vanilla: 0
+    dungeon: 0
+    overworld: 0
+    any_dungeon: 0
+    keysanity: 0
+  shuffle_smallkeys: # Control where to shuffle dungeon small keys.
+    remove: 0
+    vanilla: 0
+    dungeon: 50
+    overworld: 0
+    any_dungeon: 0
+    keysanity: 0
+  shuffle_fortresskeys: # Control where to shuffle the Gerudo Fortress small keys.
+    vanilla: 50
+    overworld: 0
+    any_dungeon: 0
+    keysanity: 0
+  shuffle_bosskeys: # Control where to shuffle boss keys, except the Ganon's Castle Boss Key.
+    remove: 0
+    vanilla: 0
+    dungeon: 50
+    overworld: 0
+    any_dungeon: 0
+    keysanity: 0
+  shuffle_ganon_bosskey: # Control where to shuffle the Ganon's Castle Boss Key.
+    remove: 50
+    vanilla: 0
+    dungeon: 0
+    overworld: 0
+    any_dungeon: 0
+    keysanity: 0
+    on_lacs: 0
+  enhance_map_compass: # Map tells if a dungeon is vanilla or MQ. Compass tells what the dungeon reward is.
+    false: 50
+    true: 0
+  lacs_condition: # Set the requirements for the Light Arrow Cutscene in the Temple of Time.
+    vanilla: 50
+    stones: 0
+    medallions: 0
+    dungeons: 0
+    tokens: 0
+  lacs_stones: # Set the number of Spiritual Stones required for LACS.
+    # you can add additional values between minimum and maximum
+    0: 0 # minimum value
+    3: 50 # maximum value
+    random: 0
+    random-low: 0
+    random-high: 0
+  lacs_medallions: # Set the number of medallions required for LACS.
+    # you can add additional values between minimum and maximum
+    0: 0 # minimum value
+    6: 50 # maximum value
+    random: 0
+    random-low: 0
+    random-high: 0
+  lacs_rewards: # Set the number of dungeon rewards required for LACS.
+    # you can add additional values between minimum and maximum
+    0: 0 # minimum value
+    9: 50 # maximum value
+    random: 0
+    random-low: 0
+    random-high: 0
+  lacs_tokens: # Set the number of Gold Skulltula Tokens required for LACS.
+    # you can add additional values between minimum and maximum
+    0: 0 # minimum value
+    100: 50 # maximum value
+    random: 0
+    random-low: 0
+    random-high: 0
+  shuffle_song_items: # Set where songs can appear.
+    song: 50
+    dungeon: 0
+    any: 0
+  shopsanity: # Randomizes shop contents. Set to "off" to not shuffle shops; "0" shuffles shops but does not allow multiworld items in shops.
+    0: 0
+    1: 0
+    2: 0
+    3: 0
+    4: 0
+    random_value: 0
+    off: 50
+  tokensanity: # Token rewards from Gold Skulltulas are shuffled into the pool.
+    off: 50
+    dungeons: 0
+    overworld: 0
+    all: 0
+  shuffle_scrubs: # Shuffle the items sold by Business Scrubs, and set the prices.
+    off: 50
+    low: 0
+    regular: 0
+    random_prices: 0
+  shuffle_cows: # Cows give items when Epona's Song is played.
+    false: 50
+    true: 0
+  shuffle_kokiri_sword: # Shuffle Kokiri Sword into the item pool.
+    false: 50
+    true: 0
+  shuffle_ocarinas: # Shuffle the Fairy Ocarina and Ocarina of Time into the item pool.
+    false: 50
+    true: 0
+  shuffle_weird_egg: # Shuffle the Weird Egg from Malon at Hyrule Castle.
+    false: 50
+    true: 0
+  shuffle_gerudo_card: # Shuffle the Gerudo Membership Card into the item pool.
+    false: 50
+    true: 0
+  shuffle_beans: # Adds a pack of 10 beans to the item pool and changes the bean salesman to sell one item for 60 rupees.
+    false: 50
+    true: 0
+  shuffle_medigoron_carpet_salesman: # Shuffle the items sold by Medigoron and the Haunted Wasteland Carpet Salesman.
+    false: 50
+    true: 0
+  skip_child_zelda: # Game starts with Zelda's Letter, the item at Zelda's Lullaby, and the relevant events already completed.
+    false: 50
+    true: 0
+  no_escape_sequence: # Skips the tower collapse sequence between the Ganondorf and Ganon fights.
+    false: 0
+    true: 50
+  no_guard_stealth: # The crawlspace into Hyrule Castle skips straight to Zelda.
+    false: 0
+    true: 50
+  no_epona_race: # Epona can always be summoned with Epona's Song.
+    false: 0
+    true: 50
+  skip_some_minigame_phases: # Dampe Race and Horseback Archery give both rewards if the second condition is met on the first attempt.
+    false: 0
+    true: 50
+  complete_mask_quest: # All masks are immediately available to borrow from the Happy Mask Shop.
+    false: 50
+    true: 0
+  useful_cutscenes: # Reenables the Poe cutscene in Forest Temple, Darunia in Fire Temple, and Twinrova introduction. Mostly useful for glitched.
+    false: 50
+    true: 0
+  fast_chests: # All chest animations are fast. If disabled, major items have a slow animation.
+    false: 0
+    true: 50
+  free_scarecrow: # Pulling out the ocarina near a scarecrow spot spawns Pierre without needing the song.
+    false: 50
+    true: 0
+  fast_bunny_hood: # Bunny Hood lets you move 1.5x faster like in Majora's Mask.
+    false: 50
+    true: 0
+  chicken_count: # Controls the number of Cuccos for Anju to give an item as child.
+    \# you can add additional values between minimum and maximum
+    0: 0 # minimum value
+    7: 50 # maximum value
+    random: 0
+    random-low: 0
+    random-high: 0
+  hints: # Gossip Stones can give hints about item locations.
+    none: 0
+    mask: 0
+    agony: 0
+    always: 50
+  hint_dist: # Choose the hint distribution to use. Affects the frequency of strong hints, which items are always hinted, etc.
+    balanced: 50
+    ddr: 0
+    league: 0
+    mw2: 0
+    scrubs: 0
+    strong: 0
+    tournament: 0
+    useless: 0
+    very_strong: 0
+  text_shuffle: # Randomizes text in the game for comedic effect.
+    none: 50
+    except_hints: 0
+    complete: 0
+  damage_multiplier: # Controls the amount of damage Link takes.
+    half: 0
+    normal: 50
+    double: 0
+    quadruple: 0
+    ohko: 0
+  no_collectible_hearts: # Hearts will not drop from enemies or objects.
+    false: 50
+    true: 0
+  starting_tod: # Change the starting time of day.
+    default: 50
+    sunrise: 0
+    morning: 0
+    noon: 0
+    afternoon: 0
+    sunset: 0
+    evening: 0
+    midnight: 0
+    witching_hour: 0
+  start_with_consumables: # Start the game with full Deku Sticks and Deku Nuts.
+    false: 50
+    true: 0
+  start_with_rupees: # Start with a full wallet. Wallet upgrades will also fill your wallet.
+    false: 50
+    true: 0
+  item_pool_value: # Changes the number of items available in the game.
+    plentiful: 0
+    balanced: 50
+    scarce: 0
+    minimal: 0
+  junk_ice_traps: # Adds ice traps to the item pool.
+    off: 0
+    normal: 50
+    on: 0
+    mayhem: 0
+    onslaught: 0
+  ice_trap_appearance: # Changes the appearance of ice traps as freestanding items.
+    major_only: 50
+    junk_only: 0
+    anything: 0
+  logic_earliest_adult_trade: # Earliest item that can appear in the adult trade sequence.
+    pocket_egg: 0
+    pocket_cucco: 0
+    cojiro: 0
+    odd_mushroom: 0
+    poachers_saw: 0
+    broken_sword: 0
+    prescription: 50
+    eyeball_frog: 0
+    eyedrops: 0
+    claim_check: 0
+  logic_latest_adult_trade: # Latest item that can appear in the adult trade sequence.
+    pocket_egg: 0
+    pocket_cucco: 0
+    cojiro: 0
+    odd_mushroom: 0
+    poachers_saw: 0
+    broken_sword: 0
+    prescription: 0
+    eyeball_frog: 0
+    eyedrops: 0
+    claim_check: 50
+
+```
+
+## Joining a MultiWorld Game
+
+### Obtain your OOT patch file
+
+When you join a multiworld game, you will be asked to provide your YAML file to whoever is hosting. Once that
+is done, the host will provide you with either a link to download your data file, or with a zip file containing
+everyone's data files. Your data file should have a `.z5ap` extension.
+
+Double click on your `.z5ap` file to start Z5Client and start the ROM patch process. Once the process is finished (this can take a while), the emulator will be started automatically (If we associated the extension to the emulator as recommended)
+
+### Connect to multiserver
+Once both the Z5Client and the emulator are started we must connect them. Within the emulator we click on the "Tools" menu and select "Lua console". In the new window click on the folder icon and look for the ootMulti.lua file. Once the file is loaded it will connect automatically to Z5Client.
+
+Note: We strongly advise you don't open any emulator menu while it and Z5client are connected, as the script will halt and disconnects can happen. If you get disconnected just double click on the script again.
+
+To connect the client to the multiserver simply put address:port on the textfield on top and press enter (if the server uses password, type on the bottom textfield /connect <address>:<port> [password], to connect) 
+
+Now you are ready to start your adventure in Hyrule.

WebHostLib/static/assets/tutorial/zelda5/setup_es.md

@@ -0,0 +1,372 @@
+# Guia instalación de Ocarina of time Archipelago
+
+## Nota importante
+
+Al usar el cliente y bizhawk, esta guia solo es aplicable en Windows.
+
+## Software Requerido
+
+- [bizhawk+script+Z5Client](https://github.com/ArchipelagoMW/Z5Client/releases) Recomendamos bajar el setup de Z5client ya que automatizara varios pasos mas adelante
+
+## Instala emulador y cliente
+
+Descarga el fichero getBizhawk.ps1 del enlace anterior. Colocalo en la carpeta donde desees instalar el emulador, haz click derecho en él y selecciona "Ejecutar con PowerShell". Esto descargará todas las dependencias necesarias para el emulador. Puede tardar un rato.
+
+Es recomendable asociar la extensión de las roms de N64 (\*.n64) al bizhawk que hemos instalado anteriormente. Para hacerlo simplemente debemos buscar alguna rom de n64 que tengamos, hacer click derecho, seleccionar "Abrir con...", desplegar la lista y buscar la opción "Buscar otra aplicación", navegar hasta el directorio de bizhawk y seleccionar EmuHawk.exe
+
+Situa el fichero ootMulti.lua del enlace anterior en la carpeta "lua" del emulador recien instalado.
+
+Instala el cliente Z5Client.
+
+## Configura tu fichero YAML
+
+### Que es un fichero YAML y por qué necesito uno?
+Tu fichero YAML contiene un numero de opciones que proveen al generador con información sobre como debe generar tu juego.
+Cada jugador de un multiworld entregara u propio fichero YAML.
+Esto permite que cada jugador disfrute de una experiencia personalizada a su gusto y diferentes jugadores dentro del mismo multiworld
+pueden tener diferentes opciones
+
+### Where do I get a YAML file?
+Un fichero basico yaml para OOT tendra este aspecto. (Hay muchas opciones cosméticas que se han ignorado para este tutorial, si quieres ver una lista completa, descarga (Archipelago)[https://github.com/ArchipelagoMW/Archipelago/releases] y buscar el fichero de ejemplo en el directorio "Players"))
+```yaml
+description: Default Ocarina of Time Template # Describe tu fichero yalm
+\# Tu nombre en el juego. Los espacio seran reemplazados por _ y hay un limite de 16 caracteres
+name: YourName{number}
+game:
+  Ocarina of Time: 1
+requires:
+  version: 0.1.7 # Version de archipelago minima.
+\# Opciones compartidas por todos los juegos:
+accessibility:
+  items: 0 # Garantiza que puedes obtener todos los objetos pero no todas las localizaciones
+  locations: 50 # Garantiza que puedes obtener todas las localizaciones
+  none: 0 # Solo garantiza que el juego pueda completarse.
+progression_balancing:
+  on: 50 # Un sistema para reducir tiempos de espera en una partida multiworld
+  off: 0
+Ocarina of Time:
+  logic_rules: # Logica usada por el randomizer.
+    glitchless: 50
+    glitched: 0
+    no_logic: 0
+  logic_no_night_tokens_without_suns_song: # Las skulltulas nocturnas requeriran la cancion del sol por logica
+    false: 50
+    true: 0
+  open_forest: # Indica el estado del bosque Kokiri y el camino al Arbol Deku.
+    open: 50
+    closed_deku: 0
+    closed: 0
+  open_kakariko: # Indica el estado de la puerta de Kakariko hacia la montaña de la muerte.
+    open: 50
+    zelda: 0
+    closed: 0
+  open_door_of_time: # Abre la puerta del tiempo sin la cancion del tiempo.
+    false: 0
+    true: 50
+  zora_fountain: # Indica el estado del rey zora bloqueando el camino a la fuente Zora.
+    open: 0
+    adult: 0
+    closed: 50
+  gerudo_fortress: # Indica los requerimientos para acceder a la fortaleza Gerudo.
+    normal: 0
+    fast: 50
+    open: 0
+  bridge: # Indica los requerimientos para el puente arco iris.
+    open: 0
+    vanilla: 0
+    stones: 0
+    medallions: 50
+    dungeons: 0
+    tokens: 0
+  trials: # Numero de pruebas dentro del castillo de Ganon.
+    0: 50 # minimum value
+    6: 0 # maximum value
+    random: 0
+    random-low: 0
+    random-high: 0
+  starting_age: # Indica la edad con la que empieza link.
+    child: 50
+    adult: 0
+  triforce_hunt: # Reune piezas de trifuerza para completar el juego.
+    false: 50
+    true: 0
+  triforce_goal: # Numero de piezas de trifuerza requeridas. El numero de piezas disponibles es determinado por la opcion "Item pool".
+    1: 0 # minimum value
+    50: 0 # maximum value
+    random: 0
+    random-low: 0
+    random-high: 0
+    20: 50
+  bombchus_in_logic: # Los bombchus son considerados para la logica. El primer pack encontrado da 20 chus y las tiendas kokiri y el bazaar los venden. Bombchus abren la bolera.
+    false: 50
+    true: 0
+  bridge_stones: # Numero de piedras para abrir el puente arco iris.
+    0: 0 # minimum value
+    3: 50 # maximum value
+    random: 0
+    random-low: 0
+    random-high: 0
+  bridge_medallions: # Numero de medallones para abrir el puente arco iris.
+    0: 0 # minimum value
+    6: 50 # maximum value
+    random: 0
+    random-low: 0
+    random-high: 0
+  bridge_rewards: # Numero de mazmorras (cualquier combinacion de medallones y piedras) para abrir el puente arco iris.
+    0: 0 # minimum value
+    9: 50 # maximum value
+    random: 0
+    random-low: 0
+    random-high: 0
+  bridge_tokens: # Numero de skultullas de oro requeridas para el puente arco iris.
+    0: 0 # minimum value
+    100: 50 # maximum value
+    random: 0
+    random-low: 0
+    random-high: 0
+  shuffle_mapcompass: # Controla donde pueden aparecer los mapas y las brujulas.
+    remove: 0
+    startwith: 50
+    vanilla: 0
+    dungeon: 0
+    overworld: 0
+    any_dungeon: 0
+    keysanity: 0
+  shuffle_smallkeys: # Controla donde pueden aparecer las llaves pequeñas.
+    remove: 0
+    vanilla: 0
+    dungeon: 50
+    overworld: 0
+    any_dungeon: 0
+    keysanity: 0
+  shuffle_fortresskeys: # Controla donde pueden aparecer las llaves de la fortaleza Gerudo.
+    vanilla: 50
+    overworld: 0
+    any_dungeon: 0
+    keysanity: 0
+  shuffle_bosskeys: # Controla donde pueden aparecer las llaves de jefe (excepto la llave del castillo de ganon).
+    remove: 0
+    vanilla: 0
+    dungeon: 50
+    overworld: 0
+    any_dungeon: 0
+    keysanity: 0
+  shuffle_ganon_bosskey: # Controla donde puede aparecer la llave del jefe del castillo de Ganon.
+    remove: 50
+    vanilla: 0
+    dungeon: 0
+    overworld: 0
+    any_dungeon: 0
+    keysanity: 0
+    on_lacs: 0
+  enhance_map_compass: # El mapa indica si una dungeon es clasica o Master Quest. Las brujulas indican la recompensa de mazmorra.
+    false: 50
+    true: 0
+  lacs_condition: # Marca el requerimiento para la escena de las flechas de luz (LACS) en el templo del tiempo.
+    vanilla: 50
+    stones: 0
+    medallions: 0
+    dungeons: 0
+    tokens: 0
+  lacs_stones: # Marca el numero de piedras espirituales requeridas para LACS
+    0: 0 # minimum value
+    3: 50 # maximum value
+    random: 0
+    random-low: 0
+    random-high: 0
+  lacs_medallions: # Marca el numero de medallones requeridas para LACS.
+    0: 0 # minimum value
+    6: 50 # maximum value
+    random: 0
+    random-low: 0
+    random-high: 0
+  lacs_rewards: # Marca el numero de recompensas de mazmorra requeridas para LACS.
+    0: 0 # minimum value
+    9: 50 # maximum value
+    random: 0
+    random-low: 0
+    random-high: 0
+  lacs_tokens: # Marca el numero de Skulltulas de oro requeridas para LACS.
+    0: 0 # minimum value
+    100: 50 # maximum value
+    random: 0
+    random-low: 0
+    random-high: 0
+  shuffle_song_items: # Marca donde pueden aparecer las canciones.
+    song: 50
+    dungeon: 0
+    any: 0
+  shopsanity: # Aleatoriza el contenido de las tiendas. "off" para no mezclar las tiendas; "0" mezcla las tiendas pero no permite objetos unicos en ellas.
+    0: 0
+    1: 0
+    2: 0
+    3: 0
+    4: 0
+    random_value: 0
+    off: 50
+  tokensanity: # Indica si las Skulltulas de oro pueden tener objetos que no sean su ficha.
+    off: 50
+    dungeons: 0
+    overworld: 0
+    all: 0
+  shuffle_scrubs: # Aleatoriza los objetos de los Scrubs vendedores y marca su precio.
+    off: 50
+    low: 0
+    regular: 0
+    random_prices: 0
+  shuffle_cows: # Las vacas dan objetos cuando les tocas las cancion de Epona.
+    false: 50
+    true: 0
+  shuffle_kokiri_sword: # Aleatoriza la posicion de la espada Kokiri.
+    false: 50
+    true: 0
+  shuffle_ocarinas: # Aleatoriza la posicion de las ocarinas.
+    false: 50
+    true: 0
+  shuffle_weird_egg: # Aleatoriza la posicion del huevo extraño.
+    false: 50
+    true: 0
+  shuffle_gerudo_card: # Aleatoriza la posicion de la tarjeta de membresia Gerudo.
+    false: 50
+    true: 0
+  shuffle_beans: # Añade un pack de 10 judias magicas al juego y el vendedor vende un solo objeto por 60 rupias.
+    false: 50
+    true: 0
+  shuffle_medigoron_carpet_salesman: # Aleatoriza el objeto que vende Medigoron y el vendedor de la alfombra voladora del paramo maldito.
+    false: 50
+    true: 0
+  skip_child_zelda: # Empieza el juego con la carta de zelda, el objeto que daria impa al enseñar la nana de zelda. Y zelda se considera ya visitada (puedes ir directamente a ver a Saria al bosque y a Malon al rancho)
+    false: 50
+    true: 0
+  no_escape_sequence: # Elimina la huida de link y zelda despues de ganar a Ganondorf.
+    false: 0
+    true: 50
+  no_guard_stealth: # Elimina la escena de sigilo antes de ver a Zelda.
+    false: 0
+    true: 50
+  no_epona_race: # No necesitas hacer la carrera para invocar a Epona.
+    false: 0
+    true: 50
+  skip_some_minigame_phases: # La carrera de Dampe y el minijuego de arco a caballo dan ambras recompensas a la vez si se cumplen las condiciones.
+    false: 0
+    true: 50
+  complete_mask_quest: # Todas las mascaras estan disponibles.
+    false: 50
+    true: 0
+  useful_cutscenes: # Ciertas escenas se mantienen (como los Poes del templo del bosque, Darunia o Twinrova. Principalmente util para modos con Glitches.
+    false: 50
+    true: 0
+  fast_chests: # Los cofres siempre se cogen rapido. Si se desactiva, los objetos importantes tienen animacion lenta. (IMPORTANTE: TODOS LOS OBJETOS QUE VAYAN A OTROS MUNDOS SE CONSIDERAN IMPORTANTES)
+    false: 0
+    true: 50
+  free_scarecrow: # Sacara la ocraina cerca de un punto con espantapajaros invoca a Pierre sin necesidad de la cancion.
+    false: 50
+    true: 0
+  fast_bunny_hood: # La capucha conejo mejora tu velocidad como en Majora's Mask.
+    false: 50
+    true: 0
+  chicken_count: # Numero de Cuccos que Anju necesita en el corral para que te de el objeto.
+    0: 0 # minimum value
+    7: 50 # maximum value
+    random: 0
+    random-low: 0
+    random-high: 0
+  hints: # Marca el requerimiento para que las piedras chivatas den pistas.
+    none: 0
+    mask: 0
+    agony: 0
+    always: 50
+  hint_dist: # Elije la distribucion de pistas
+    balanced: 50
+    ddr: 0
+    league: 0
+    mw2: 0
+    scrubs: 0
+    strong: 0
+    tournament: 0
+    useless: 0
+    very_strong: 0
+  damage_multiplier: # Controla el daño que recibe Link.
+    half: 0
+    normal: 50
+    double: 0
+    quadruple: 0
+    ohko: 0
+  no_collectible_hearts: # No caen corazones de enemigos u objetos.
+    false: 50
+    true: 0
+  starting_tod: # Cambia el momento del dia al empezar el juego.
+    default: 50
+    sunrise: 0
+    morning: 0
+    noon: 0
+    afternoon: 0
+    sunset: 0
+    evening: 0
+    midnight: 0
+    witching_hour: 0
+  start_with_consumables: # Empieza el juego con el maximo de palos y nueves Deku que pueda llevar Link.
+    false: 50
+    true: 0
+  start_with_rupees: # Empieza el juego con la cartera llena. Las mejoras de cartera vienen llenas.
+    false: 50
+    true: 0
+  item_pool_value: # Cambia el numero de objetos disponibles en el juego.
+    plentiful: 0
+    balanced: 50
+    scarce: 0
+    minimal: 0
+  junk_ice_traps: # Añade trampas de hielo.
+    off: 0
+    normal: 50
+    on: 0
+    mayhem: 0
+    onslaught: 0
+  ice_trap_appearance: # Cambia la apariencia de las trampas de hielo cuando aparecen como objetos fuera de cofres.
+    major_only: 50
+    junk_only: 0
+    anything: 0
+  logic_earliest_adult_trade: # Objeto mas bajo que puede aparecer en la secuencia de cambios de Link Adulto.
+    pocket_egg: 0
+    pocket_cucco: 0
+    cojiro: 0
+    odd_mushroom: 0
+    poachers_saw: 0
+    broken_sword: 0
+    prescription: 50
+    eyeball_frog: 0
+    eyedrops: 0
+    claim_check: 0
+  logic_latest_adult_trade: # Objeto mas tardio que puede aparecer en la secuencia de cambios de Link Adulto.
+    pocket_egg: 0
+    pocket_cucco: 0
+    cojiro: 0
+    odd_mushroom: 0
+    poachers_saw: 0
+    broken_sword: 0
+    prescription: 0
+    eyeball_frog: 0
+    eyedrops: 0
+    claim_check: 50
+
+```
+
+## Unirse a un juego MultiWorld
+
+### Obten tu parche
+
+
+Cuando te unes a un juego multiworld, se te pedirá que entregues tu fichero YAML a quien sea que hospede el juego multiworld.
+Una vez la generación acabe, el anfitrión te dará un enlace a tu fichero de datos o un zip con los ficheros de todos.
+Tu fichero de datos tiene una extensión `.z5ap`.
+
+Haz doble click en tu fichero `.z5ap` para que se arranque el Z5Client y realize el parcheado de la ROM. Una vez acabe el parcheado de la rom (esto puede llevar un tiempo) se abrira automaticamente el emulador (Si se ha asociado la extensión al emulador tal como hemos recomendado)
+
+### Conectar al multiserver
+Una vez arrancado tanto el Z5Client como el emulador hay que conectarlo entre ellos, para ello simplemente accede al menú "Tools" y selecciona "Lua console". En la nueva ventana, dale al icono de la carpeta y busca el fichero ootMulti.lua. Al cargar dicho fichero se conectara automaticamente con el cliente.
+
+Nota: Es muy recomendable que no se abra ningún menú del emulador mientras esten emulador y Z5Client conectados, ya que el script de conexión se para en ese caso y pueden provocar desconexiones. Si se pierde la conexion, simplemente haz doble click en el script de nuevo.
+
+Para conectar el cliente con el servidor simplemente pon la direccion_IP:puerto en la caja de texto de arriba y presiona enter (si el servidor tiene contraseña, en la caja de texto de abajo escribir /connect direccion:puerto contraseña, para conectar) 
+
+Y ya estas listo, para emprender tu aventura por Hyrule.

WebHostLib/static/static/weightedSettings.yaml

@@ -1,442 +0,0 @@
-# What is this file?
-# This file contains options which allow you to configure your multiworld experience while allowing others
-# to play how they want as well.
-
-# How do I use it?
-# The options in this file are weighted. This means the higher number you assign to a value, the more
-# chances you have for that option to be chosen. For example, an option like this:
-#
-# map_shuffle:
-#   on: 5
-#   off: 15
-#
-# Means you have 5 chances for map shuffle to occur, and 15 chances for map shuffle to be turned off
-
-# I've never seen a file like this before. What characters am I allowed to use?
-# This is a .yaml file. You are allowed to use most characters.
-# To test if your yaml is valid or not, you can use this website:
-# http://www.yamllint.com/
-
-# For use with the weighted-settings page on the website. Changing this value will cause all users to be prompted
-# to update their settings. The version number should match the current released version number, and the revision
-# should be updated manually by whoever edits this file.
-ws_version: 4.1.1 rev0
-
-description: Template Name # Used to describe your yaml. Useful if you have multiple files
-name: YourName # Your name in-game. Spaces will be replaced with underscores and there is a 16 character limit
-### Logic Section ###
-glitches_required: # Determine the logic required to complete the seed
-  none: 50 # No glitches required
-  minor_glitches: 0 # Puts fake flipper, waterwalk, super bunny shenanigans, and etc into logic
-  overworld_glitches: 0 # Assumes the player has knowledge of both overworld major glitches (boots clips, mirror clips) and minor glitches (fake flipper, super bunny shenanigans, water walk and etc.)
-  no_logic: 0 # Your own items are placed with no regard to any logic; such as your Fire Rod can be on your Trinexx.
-  # Other players items are placed into your world under OWG logic
-dark_room_logic: # Logic for unlit dark rooms
-  lamp: 50 # require the Lamp for these rooms to be considered accessible.
-  torches: 0 # in addition to lamp, allow the fire rod and presence of easily accessible torches for access
-  none: 0 # all dark rooms are always considered doable, meaning this may force completion of rooms in complete darkness
-restrict_dungeon_item_on_boss: # aka ambrosia boss items
-  on: 0 # prevents unshuffled compasses, maps and keys to be boss drops, they can still drop keysanity and other players' items
-  off: 50
-### End of Logic Section ###
-meta_ignore: # Nullify options specified in the meta.yaml file. Adding an option here guarantees it will not occur in your seed, even if the .yaml file specifies it
-  mode:
-    - inverted # Never play inverted seeds
-  retro:
-    - on # Never play retro seeds
-  weapons:
-    - swordless # Never play a swordless seed
-map_shuffle: # Shuffle dungeon maps into the world and other dungeons, including other players' worlds
-  on: 0
-  off: 50
-compass_shuffle: # Shuffle compasses into the world and other dungeons, including other players' worlds
-  on: 0
-  off: 50
-smallkey_shuffle: # Shuffle small keys into the world and other dungeons, including other players' worlds
-  on: 0
-  universal: 0 # allows small keys to be used in any dungeon and adds shops to buy more
-  off: 50
-bigkey_shuffle: # Shuffle big keys into the world and other dungeons, including other players' worlds
-  on: 0
-  off: 50
-local_keys: # Keep small keys and big keys local to your world
-  on: 0
-  off: 50
-dungeon_items: # Alternative to the 4 shuffles and local_keys above this, does nothing until the respective 4 shuffles and local_keys above are deleted
-  mc: 0 # Shuffle maps and compasses
-  none: 50 # Shuffle none of the 4
-  mcsb: 0 # Shuffle all of the 4, any combination of m, c, s and b will shuffle the respective item, or not if it's missing, so you can add more options here
-  lmcsb: 0 # Like mcsb above, but with keys kept local to your world. l is what makes your keys local, or not if it's missing
-  ub: 0 # universal small keys and shuffled big keys
-  # you can add more combos of these letters here
-dungeon_counters:
-  on: 0 # Always display amount of items checked in a dungeon
-  pickup: 50 # Show when compass is picked up
-  default: 0 # Show when compass is picked up if the compass itself is shuffled
-  off: 0 # Never show item count in dungeons
-accessibility:
-  items: 0 # Guarantees you will be able to acquire all items, but you may not be able to access all locations
-  locations: 50 # Guarantees you will be able to access all locations, and therefore all items
-  none: 0 # Guarantees only that the game is beatable. You may not be able to access all locations or acquire all items
-progressive: # Enable or disable progressive items (swords, shields, bow)
-  on: 50 # All items are progressive
-  off: 0 # No items are progressive
-  random: 0 # Randomly decides for all items. Swords could be progressive, shields might not be
-entrance_shuffle: # Documentation: https://alttpr.com/en/options#entrance_shuffle
-  none: 50 # Vanilla game map. All entrances and exits lead to their original locations. You probably want this option
-  dungeonssimple: 0 # Shuffle just dungeons amongst each other, swapping dungeons entirely, so Hyrule Castle is always 1 dungeon
-  dungeonsfull: 0 # Shuffle any dungeon entrance with any dungeon interior, so Hyrule Castle can be 4 different dungeons
-  simple: 0 # Entrances are grouped together before being randomized. Simple uses the most strict grouping rules
-  restricted: 0 # Less strict than simple
-  full: 0 # Less strict than restricted
-  crossed: 0 # Less strict than full
-  insanity: 0 # Very few grouping rules. Good luck
-goals:
-  ganon: 50 # Climb GT, defeat Agahnim 2, and then kill Ganon
-  fast_ganon: 0 # Only killing Ganon is required. The hole is always open. However, items may still be placed in GT
-  dungeons: 0 # Defeat the boss of all dungeons, including Agahnim's tower and GT (Aga 2)
-  pedestal: 0 # Pull the Triforce from the Master Sword pedestal
-  ganon_pedestal: 0 # Pull the Master Sword pedestal, then kill Ganon
-  triforce_hunt: 0 # Collect 20 of 30 Triforce pieces spread throughout the worlds, then turn them in to Murahadala in front of Hyrule Castle
-  local_triforce_hunt: 0 # Collect 20 of 30 Triforce pieces spread throughout your world, then turn them in to Murahadala in front of Hyrule Castle
-  ganon_triforce_hunt: 0 # Collect 20 of 30 Triforce pieces spread throughout the worlds, then kill Ganon
-  local_ganon_triforce_hunt: 0 # Collect 20 of 30 Triforce pieces spread throughout your world, then kill Ganon
-  ice_rod_hunt: 0 # You start with everything needed to 216 the seed. Find the Ice rod, then kill Trinexx at Turtle rock.
-pyramid_open:
-  goal: 50 # Opens the pyramid if the goal requires you to kill Ganon, unless the goal is Slow Ganon or All Dungeons
-  auto: 0 # Same as Goal, but also opens when any non-dungeon entrance shuffle is used
-  yes: 0 # Pyramid hole is always open. Ganon's vulnerable condition is still required before he can he hurt
-  no: 0 # Pyramid hole is always closed until you defeat Agahnim atop Ganon's Tower
-triforce_pieces_mode: #Determine how to calculate the extra available triforce pieces.
-  extra: 0 # available = triforce_pieces_extra + triforce_pieces_required
-  percentage: 0 # available = (triforce_pieces_percentage /100) * triforce_pieces_required
-  available: 50 # available = triforce_pieces_available
-triforce_pieces_extra: # Set to how many extra triforces pieces are available to collect in the world.
-  # Format "pieces: chance"
-  0: 0
-  5: 50
-  10: 50
-  15: 0
-  20: 0
-triforce_pieces_percentage: # Set to how many triforce pieces according to a percentage of the required ones, are available to collect in the world.
-  # Format "pieces: chance"
-  100: 0 #No extra
-  150: 50 #Half the required will be added as extra
-  200: 0 #There are the double of the required ones available.
-triforce_pieces_available: # Set to how many triforces pieces are available to collect in the world. Default is 30. Max is 90, Min is 1
-  # Format "pieces: chance"
-  25: 0
-  30: 50
-  40: 0
-  50: 0
-triforce_pieces_required: # Set to how many out of X triforce pieces you need to win the game in a triforce hunt. Default is 20. Max is 90, Min is 1
-  # Format "pieces: chance"
-  15: 0
-  20: 50
-  30: 0
-  40: 0
-  50: 0
-tower_open: # Crystals required to open GT
-  '0': 80
-  '1': 70
-  '2': 60
-  '3': 50
-  '4': 40
-  '5': 30
-  '6': 20
-  '7': 10
-  random: 0
-ganon_open: # Crystals required to hurt Ganon
-  '0': 80
-  '1': 70
-  '2': 60
-  '3': 50
-  '4': 40
-  '5': 30
-  '6': 20
-  '7': 10
-  random: 0
-mode:
-  standard: 50 # Begin the game by rescuing Zelda from her cell and escorting her to the Sanctuary
-  open: 50 # Begin the game from your choice of Link's House or the Sanctuary
-  inverted: 0 # Begin in the Dark World. The Moon Pearl is required to avoid bunny-state in Light World, and the Light World game map is altered
-retro:
-  on: 0 # you must buy a quiver to use the bow, take-any caves and an old-man cave are added to the world. You may need to find your sword from the old man's cave
-  off: 50
-hints:
-  'on': 50 # Hint tiles sometimes give item location hints
-  'off': 0 # Hint tiles provide gameplay tips
-weapons: # Specifically, swords
-  randomized: 0 # Swords are placed randomly throughout the world
-  assured: 50 # Begin with a sword, the rest are placed randomly throughout the world
-  vanilla: 0 # Swords are placed in vanilla locations in your own game (Uncle, Pyramid Fairy, Smiths, Pedestal)
-  swordless: 0 # Your swords are replaced by rupees. Gameplay changes have been made to accommodate this change
-item_pool:
-  easy: 0 # Doubled upgrades, progressives, and etc
-  normal: 50 # Item availability remains unchanged from vanilla game
-  hard: 0 # Reduced upgrade availability (max: 14 hearts, blue mail, tempered sword, fire shield, no silvers unless swordless)
-  expert: 0 # Minimum upgrade availability (max: 8 hearts, green mail, master sword, fighter shield, no silvers unless swordless)
-item_functionality:
-  easy: 0 # Allow Hammer to damage ganon, Allow Hammer tablet collection, Allow swordless medallion use everywhere.
-  normal: 50 # Vanilla item functionality
-  hard: 0 # Reduced helpfulness of items (potions less effective, can't catch faeries, cape uses double magic, byrna does not grant invulnerability, boomerangs do not stun, silvers disabled outside ganon)
-  expert: 0 # Vastly reduces the helpfulness of items (potions barely effective, can't catch faeries, cape uses double magic, byrna does not grant invulnerability, boomerangs and hookshot do not stun, silvers disabled outside ganon)
-progression_balancing:
-  on: 50 # A system to reduce BK, as in times during which you can't do anything by moving your items into an earlier access sphere to make it likely you have stuff to do
-  off: 0 # Turn this off if you don't mind a longer multiworld, or can glitch around missing items.
-tile_shuffle: # Randomize the tile layouts in flying tile rooms
-  on: 0
-  off: 50
-misery_mire_medallion: # required medallion to open Misery Mire front entrance
-  random: 50
-  ether: 0
-  bombos: 0
-  quake: 0
-turtle_rock_medallion: # required medallion to open Turtle Rock front entrance
-  random: 50
-  ether: 0
-  bombos: 0
-  quake: 0
-### Enemizer Section ###
-boss_shuffle:
-  none: 50 # Vanilla bosses
-  simple: 0 # Existing bosses except Ganon and Agahnim are shuffled throughout dungeons
-  full: 0 # 3 bosses can occur twice
-  random: 0 # Any boss can appear any amount of times
-  singularity: 0 # Picks a boss, tries to put it everywhere that works, if there's spaces remaining it picks a boss to fill those
-enemy_shuffle: # Randomize enemy placement
-  on: 0
-  off: 50
-killable_thieves: # Make thieves killable
-  on: 0 # Usually turned on together with enemy_shuffle to make annoying thief placement more manageable
-  off: 50
-bush_shuffle: # Randomize the chance that bushes have enemies and the enemies under said bush
-  on: 0
-  off: 50
-enemy_damage:
-  default: 50 # Vanilla enemy damage
-  shuffled: 0 # Enemies deal 0 to 4 hearts and armor helps
-  random: 0 # Enemies deal 0 to 8 hearts and armor just reshuffles the damage
-enemy_health:
-  default: 50 # Vanilla enemy HP
-  easy: 0 # Enemies have reduced health
-  hard: 0 # Enemies have increased health
-  expert: 0 # Enemies have greatly increased health
-pot_shuffle:
-  'on': 0 # Keys, items, and buttons hidden under pots in dungeons are shuffled with other pots in their supertile
-  'off': 50 # Default pot item locations
-### End of Enemizer Section ###
-beemizer: # Remove items from the global item pool and replace them with single bees and bee traps
-  0: 50 # No bee traps are placed
-  1: 0 # 25% of rupees, bombs and arrows are replaced with bees, of which 60% are traps and 40% single bees
-  2: 0 # 50% of rupees, bombs and arrows are replaced with bees, of which 70% are traps and 30% single bees
-  3: 0 # 75% of rupees, bombs and arrows are replaced with bees, of which 80% are traps and 20% single bees
-  4: 0 # 100% of rupees, bombs and arrows are replaced with bees, of which 90% are traps and 10% single bees
-### Shop Settings ###
-shop_shuffle_slots: # Maximum amount of shop slots to be filled with regular item pool items (such as Moon Pearl)
-  0: 50
-  10: 0
-  20: 0
-  30: 0
-shop_shuffle:
-  none: 50
-  g: 0 # Generate new default inventories for overworld/underworld shops, and unique shops
-  f: 0 # Generate new default inventories for every shop independently
-  p: 0 # Randomize the prices of the items in shop inventories
-  u: 0 # Shuffle capacity upgrades into the item pool (and allow them to traverse the multiworld)
-  w: 0 # Consider witch's hut like any other shop and shuffle/randomize it too
-  gp: 0 # Shuffle inventories and randomize prices
-  fp: 0 # Randomize items in every shop and their prices
-  ufp: 0 # Randomize items and prices in every shop, and include capacity upgrades in item pool
-  wfp: 0 # Randomize items and prices in every shop, and include potion shop inventory in shuffle
-  ufpw: 0 # Randomize items and prices in every shop, shuffle potion shop inventory, and include capacity upgrades
-  # You can add more combos
-### End of Shop Section ###
-shuffle_prizes: # aka drops
-  none: 0 # do not shuffle prize packs
-  g: 50 # shuffle "general" price packs, as in enemy, tree pull, dig etc.
-  b: 0 # shuffle "bonk" price packs
-  bg: 0 # shuffle both
-timer:
-  none: 50 # No timer will be displayed.
-  timed: 0 # Starts with clock at zero. Green clocks subtract 4 minutes (total 20). Blue clocks subtract 2 minutes (total 10). Red clocks add two minutes (total 10). Winner is the player with the lowest time at the end.
-  timed_ohko: 0 # Starts the clock at ten minutes. Green clocks add five minutes (total 25). As long as the clock as at zero, Link will die in one hit.
-  ohko: 0 # Timer always at zero. Permanent OHKO.
-  timed_countdown: 0 # Starts the clock with forty minutes. Same clocks as timed mode, but if the clock hits zero you lose. You can still keep playing, though.
-  display: 0 # Displays a timer, but otherwise does not affect gameplay or the item pool.
-countdown_start_time: # For timed_ohko and timed_countdown timer modes, the amount of time in minutes to start with
-  0: 0 # For timed_ohko, starts in OHKO mode when starting the game
-  10: 50
-  20: 0
-  30: 0
-  60: 0
-red_clock_time: # For all timer modes, the amount of time in minutes to gain or lose when picking up a red clock
-  -2: 50
-  1: 0
-blue_clock_time: # For all timer modes, the amount of time in minutes to gain or lose when picking up a blue clock
-  1: 0
-  2: 50
-green_clock_time: # For all timer modes, the amount of time in minutes to gain or lose when picking up a green clock
-  4: 50
-  10: 0
-  15: 0
-# Can be uncommented to use it
-# local_items: # Force certain items to appear in your world only, not across the multiworld. Recognizes some group names, like "Swords"
-#  - "Moon Pearl"
-#  - "Small Keys"
-#  - "Big Keys"
-# Can be uncommented to use it
-# startinventory: # Begin the file with the listed items/upgrades
-  # Pegasus Boots: on
-  # Bomb Upgrade (+10): 4
-  # Arrow Upgrade (+10): 4
-glitch_boots:
-  on: 50 # Start with Pegasus Boots in any glitched logic mode that makes use of them
-  off: 0
-linked_options:
-  - name: crosskeys
-    options: # These overwrite earlier options if the percentage chance triggers
-      entrance_shuffle: crossed
-      bigkey_shuffle: true
-      compass_shuffle: true
-      map_shuffle: true
-      smallkey_shuffle: true
-    percentage: 0 # Set this to the percentage chance you want crosskeys
-  - name: localcrosskeys
-    options: # These overwrite earlier options if the percentage chance triggers
-      entrance_shuffle: crossed
-      bigkey_shuffle: true
-      compass_shuffle: true
-      map_shuffle: true
-      smallkey_shuffle: true
-      local_items: # Forces keys to be local to your own world
-        - "Small Keys"
-        - "Big Keys"
-    percentage: 0 # Set this to the percentage chance you want local crosskeys
-  - name: enemizer
-    options:
-      boss_shuffle: # Subchances can be injected too, which then get rolled
-        simple: 1
-        full: 1
-        random: 1
-        singularity: 1
-      enemy_damage:
-        shuffled: 1
-        random: 1
-      enemy_health:
-        easy: 1
-        hard: 1
-        expert: 1
-    percentage: 0 # Set this to the percentage chance you want enemizer
-### door rando only options ###
-door_shuffle: # Only available if the host uses the doors branch, it is ignored otherwise
-  vanilla: 50 # Everything should be like in vanilla
-  basic: 0 # Dungeons are shuffled within themselves
-  crossed: 0 # Dungeons are shuffled across each other
-intensity: # Only available if the host uses the doors branch, it is ignored otherwise
-  1: 50 # Shuffles normal doors and spiral staircases
-  2: 0 # And shuffles open edges and straight staircases
-  3: 0 # And shuffles dungeon lobbies
-  random: 0 # Picks one of those at random
-key_drop_shuffle: # Only available if the host uses the doors branch, it is ignored otherwise
-  on: 0 # Enables the small keys dropped by enemies or under pots, and the big key dropped by the Ball & Chain guard to be shuffled into the pool. This extends the number of checks to 249.
-  off: 50
-experimental: # Only available if the host uses the doors branch, it is ignored otherwise
-  on: 0 # Enables experimental features.
-  off: 50
-debug: # Only available if the host uses the doors branch, it is ignored otherwise
-  on: 0 # Enables debugging features. Currently, these are the Item collection counter. (overwrites total triforce pieces) and Castle Gate closed indicator.
-  off: 50
-### end of door rando only options ###
-rom:
-  #sprite_pool: # When specified, limits the pool of sprites used for randomon-event to the specified pool.  Uncomment to use this.
-  #  - link
-  #  - pride link
-  #  - penguin link
-  #  - random  # You can specify random multiple times for however many potentially unique random sprites you want in your pool.
-  sprite: # Enter the name of your preferred sprite and weight it appropriately
-    random: 0
-    link: 50 # To add other sprites: open the gui/Creator, go to adjust, select a sprite and write down the name the gui calls it
-  disablemusic: # If "on", all in-game music will be disabled
-    on: 0
-    off: 50
-  quickswap: # Enable switching items by pressing the L+R shoulder buttons
-    on: 50
-    off: 0
-  triforcehud: # Disable visibility of the triforce hud unless collecting a piece or speaking to Murahadala
-    normal: 50 # original behavior (always visible)
-    hide_goal: 0 # hide counter until a piece is collected or speaking to Murahadala
-    hide_required: 0 # Always visible, but required amount is invisible until determined by Murahadala
-    hide_both: 0 # Hide both under above circumstances
-  reduceflashing: # Reduces instances of flashing such as lightning attacks, weather, ether and more.
-    on: 50
-    off: 0
-  menuspeed: # Controls how fast the item menu opens and closes
-    normal: 50
-    instant: 0
-    double: 0
-    triple: 0
-    quadruple: 0
-    half: 0
-  heartcolor: # Controls the color of your health hearts
-    red: 50
-    blue: 0
-    green: 0
-    yellow: 0
-    random: 0
-  heartbeep: # Controls the frequency of the low-health beeping
-    double: 0
-    normal: 50
-    half: 0
-    quarter: 0
-    off: 0
-  ow_palettes: # Change the colors of the overworld
-    default: 50 # No changes
-    random: 0 # Shuffle the colors, with harmony in mind
-    blackout: 0 # everything black / blind mode
-    grayscale: 0
-    negative: 0
-    classic: 0
-    dizzy: 0
-    sick: 0
-    puke: 0
-  uw_palettes: # Change the colors of caves and dungeons
-    default: 50 # No changes
-    random: 0 # Shuffle the colors, with harmony in mind
-    blackout: 0 # everything black / blind mode
-    grayscale: 0
-    negative: 0
-    classic: 0
-    dizzy: 0
-    sick: 0
-    puke: 0
-  hud_palettes: # Change the colors of the hud
-    default: 50 # No changes
-    random: 0 # Shuffle the colors, with harmony in mind
-    blackout: 0 # everything black / blind mode
-    grayscale: 0
-    negative: 0
-    classic: 0
-    dizzy: 0
-    sick: 0
-    puke: 0
-  sword_palettes: # Change the colors of swords
-    default: 50 # No changes
-    random: 0 # Shuffle the colors, with harmony in mind
-    blackout: 0 # everything black / blind mode
-    grayscale: 0
-    negative: 0
-    classic: 0
-    dizzy: 0
-    sick: 0
-    puke: 0
-  shield_palettes: # Change the colors of shields
-    default: 50 # No changes
-    random: 0 # Shuffle the colors, with harmony in mind
-    blackout: 0 # everything black / blind mode
-    grayscale: 0
-    negative: 0
-    classic: 0
-    dizzy: 0
-    sick: 0
-    puke: 0

WebHostLib/static/styles/generate.css

@@ -25,6 +25,21 @@
     margin-bottom: 1rem;
 }
 
-#generate-game-form{
+#generate-game-form-wrapper table td{
+    text-align: left;
+    padding-right: 0.5rem;
+}
+
+#generate-form-button-row{
+    display: flex;
+    flex-direction: row;
+    justify-content: center;
+}
+
+#file-input{
     display: none;
 }
+
+.interactive{
+    color: #ffef00;
+}

WebHostLib/static/styles/markdown.css

@@ -80,12 +80,18 @@
     text-shadow: 1px 1px 1px rgba(0, 0, 0, 0.5);
 }
 
-.markdown ul{
+.markdown h4, .markdown h5,.markdown h6{
+    margin-bottom: 0.5rem;
+}
 
+.markdown ul{
+    margin-top: 0.5rem;
+    margin-bottom: 0.5rem;
 }
 
 .markdown ol{
-
+    margin-top: 0.5rem;
+    margin-bottom: 0.5rem;
 }
 
 .markdown li{
@@ -118,3 +124,21 @@
     width: 100%;
     text-align: right;
 }
+
+.markdown table{
+    border-collapse: collapse;
+    margin-bottom: 0.5rem;
+}
+
+.markdown table th{
+    text-align: left;
+    font-weight: bold;
+    border: 1px solid #eeffeb;
+    padding: 0.25rem;
+}
+
+.markdown table td{
+    text-align: left;
+    border: 1px solid #eeffeb;
+    padding: 0.25rem;
+}

WebHostLib/static/styles/ootTracker.css

@@ -0,0 +1,136 @@
+#player-tracker-wrapper{
+    margin: 0;
+}
+
+#inventory-table{
+    border-top: 2px solid #000000;
+    border-left: 2px solid #000000;
+    border-right: 2px solid #000000;
+    border-top-left-radius: 4px;
+    border-top-right-radius: 4px;
+    padding: 3px 3px 10px;
+    width: 448px;
+    background-color: rgb(60, 114, 157);
+}
+
+#inventory-table td{
+    width: 40px;
+    height: 40px;
+    text-align: center;
+    vertical-align: middle;
+}
+
+#inventory-table img{
+    height: 100%;
+    max-width: 40px;
+    max-height: 40px;
+    filter: grayscale(100%) contrast(75%) brightness(30%);
+}
+
+#inventory-table img.acquired{
+    filter: none;
+}
+
+#inventory-table div.counted-item {
+    position: relative;
+}
+
+#inventory-table div.item-count {
+    position: absolute;
+    color: white;
+    font-family: monospace;
+    font-weight: bold;
+    font-size: 1.1em;
+    bottom: 0px;
+    right: 8px;
+}
+
+#location-table{
+    width: 448px;
+    border-left: 2px solid #000000;
+    border-right: 2px solid #000000;
+    border-bottom: 2px solid #000000;
+    border-bottom-left-radius: 4px;
+    border-bottom-right-radius: 4px;
+    background-color: rgb(60, 114, 157);
+    padding: 0 3px 3px;
+    font-family: monospace;
+    font-size: 15px;
+    cursor: default;
+}
+
+#location-table th{
+    vertical-align: middle;
+    text-align: left;
+    padding-right: 10px;
+}
+
+#location-table td{
+    padding-top: 2px;
+    padding-bottom: 2px;
+    line-height: 20px;
+}
+
+#location-table td.counter {
+    text-align: right;
+    font-size: 15px;
+}
+
+#location-table td.toggle-arrow {
+    text-align: right;
+}
+
+#location-table tr#Total-header {
+    font-weight: bold;
+}
+
+#location-table img{
+    height: 100%;
+    max-width: 30px;
+    max-height: 30px;
+}
+
+#location-table tbody.locations {
+    font-size: 13px;
+}
+
+#location-table td.location-name {
+    padding-left: 16px;
+}
+
+.hide {
+    display: none;
+}
+
+.right-align {
+    text-align: right;
+    font-weight: bold;
+}
+
+#location-table td:first-child {
+    width: 272px;
+}
+
+.location-category td:first-child {
+    padding-right: 16px;
+}
+
+#inventory-table img.acquired#lullaby{
+    filter: sepia(100%) hue-rotate(-60deg); /* css trick to hue-shift a static image */
+}
+
+#inventory-table img.acquired#epona{
+    filter: sepia(100%) hue-rotate(-20deg) saturate(250%);
+}
+
+#inventory-table img.acquired#saria{
+    filter: sepia(100%) hue-rotate(60deg) saturate(150%);
+}
+
+#inventory-table img.acquired#sun{
+    filter: sepia(100%) hue-rotate(15deg) saturate(200%) brightness(120%);
+}
+
+#inventory-table img.acquired#time{
+    filter: sepia(100%) hue-rotate(160deg) saturate(150%);
+}

WebHostLib/static/styles/startPlaying.css

@@ -0,0 +1,12 @@
+#start-playing-wrapper{
+    display: flex;
+    flex-direction: row;
+    justify-content: center;
+    flex-wrap: wrap;
+}
+
+#start-playing{
+    width: 700px;
+    min-height: 240px;
+    text-align: center;
+}

WebHostLib/static/styles/timespinnerTracker.css

@@ -0,0 +1,101 @@
+#player-tracker-wrapper{
+    margin: 0;
+}
+
+#inventory-table{
+    border-top: 2px solid #000000;
+    border-left: 2px solid #000000;
+    border-right: 2px solid #000000;
+    border-top-left-radius: 4px;
+    border-top-right-radius: 4px;
+    padding: 3px 3px 10px;
+    width: 384px;
+    background-color: #8d60a7;
+}
+
+#inventory-table td{
+    width: 40px;
+    height: 40px;
+    text-align: center;
+    vertical-align: middle;
+}
+
+#inventory-table img{
+    height: 100%;
+    max-width: 40px;
+    max-height: 40px;
+    filter: grayscale(100%) contrast(75%) brightness(30%);
+}
+
+#inventory-table img.acquired{
+    filter: none;
+}
+
+#inventory-table div.counted-item {
+    position: relative;
+}
+
+#inventory-table div.item-count {
+    position: absolute;
+    color: white;
+    font-family: "Minecraftia", monospace;
+    font-weight: bold;
+    bottom: 0px;
+    right: 0px;
+}
+
+#location-table{
+    width: 384px;
+    border-left: 2px solid #000000;
+    border-right: 2px solid #000000;
+    border-bottom: 2px solid #000000;
+    border-bottom-left-radius: 4px;
+    border-bottom-right-radius: 4px;
+    background-color: #8d60a7;
+    padding: 0 3px 3px;
+    font-size: 14px;
+    cursor: default;
+}
+
+#location-table th{
+    vertical-align: middle;
+    text-align: left;
+    padding-right: 10px;
+}
+
+#location-table td{
+    padding-top: 2px;
+    padding-bottom: 2px;
+    line-height: 20px;
+}
+
+#location-table td.counter {
+    text-align: right;
+    font-size: 14px;
+}
+
+#location-table td.toggle-arrow {
+    text-align: right;
+}
+
+#location-table tr#Total-header {
+    font-weight: bold;
+}
+
+#location-table img{
+    height: 100%;
+    max-width: 30px;
+    max-height: 30px;
+}
+
+#location-table tbody.locations {
+    font-size: 12px;
+}
+
+#location-table td.location-name {
+    padding-left: 16px;
+}
+
+.hide {
+    display: none;
+}

WebHostLib/static/styles/tutorial.css

@@ -1,120 +0,0 @@
-#tutorial-wrapper{
-    display: flex;
-    flex-direction: column;
-    max-width: 70rem;
-    margin-left: auto;
-    margin-right: auto;
-    background-color: rgba(0, 0, 0, 0.15);
-    border-radius: 8px;
-    padding: 1rem 1rem 3rem;
-    color: #eeffeb;
-}
-
-#tutorial-wrapper img{
-    max-width: 100%;
-    border-radius: 6px;
-}
-
-#tutorial-wrapper p{
-    margin-top: 0;
-}
-
-#tutorial-wrapper a{
-    color: #ffef00;
-}
-
-#tutorial-wrapper h1{
-    font-size: 2.5rem;
-    font-weight: normal;
-    border-bottom: 1px solid #ffffff;
-    cursor: pointer;
-    width: 100%;
-    margin-bottom: 0.5rem;
-    color: #ffffff;
-    text-shadow: 1px 1px 4px #000000;
-}
-
-#tutorial-wrapper h2{
-    font-size: 2rem;
-    font-weight: normal;
-    border-bottom: 1px solid #ffffff;
-    cursor: pointer;
-    width: 100%;
-    margin-bottom: 0.5rem;
-    color: #ffe993;
-    text-transform: lowercase;
-    text-shadow: 1px 1px 2px #000000;
-}
-
-#tutorial-wrapper h3{
-    font-size: 1.70rem;
-    font-weight: normal;
-    text-align: left;
-    cursor: pointer;
-    width: 100%;
-    margin-bottom: 0.5rem;
-}
-
-#tutorial-wrapper h4{
-    font-size: 1.5rem;
-    font-weight: normal;
-    cursor: pointer;
-    margin-bottom: 0.5rem;
-}
-
-#tutorial-wrapper h5{
-    font-size: 1.25rem;
-    font-weight: normal;
-    cursor: pointer;
-}
-
-#tutorial-wrapper h6{
-    font-size: 1.25rem;
-    font-weight: normal;
-    cursor: pointer;
-    color: #434343;
-}
-
-#tutorial-wrapper h3, #tutorial-wrapper h4, #tutorial-wrapper h5,#tutorial-wrapper h6{
-    color: #ffffff;
-    text-shadow: 1px 1px 1px rgba(0, 0, 0, 0.5);
-}
-
-#tutorial-wrapper ul{
-
-}
-
-#tutorial-wrapper ol{
-
-}
-
-#tutorial-wrapper li{
-
-}
-
-#tutorial-wrapper pre{
-    margin-top: 0;
-    padding: 0.5rem 0.25rem;
-    background-color: #ffeeab;
-    border: 1px solid #9f916a;
-    border-radius: 6px;
-    color: #000000;
-}
-
-#tutorial-wrapper code{
-    background-color: #ffeeab;
-    border-radius: 4px;
-    padding-left: 0.25rem;
-    padding-right: 0.25rem;
-    color: #000000;
-}
-
-#tutorial-wrapper #tutorial-video-container{
-    width: 100%;
-    text-align: center;
-}
-
-#tutorial-wrapper #language-selector-wrapper{
-    width: 100%;
-    text-align: right;
-}

WebHostLib/templates/gameInfo.html

@@ -0,0 +1,17 @@
+{% extends 'pageWrapper.html' %}
+
+{% block head %}
+    <title>{{ game }} Info</title>
+    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename="styles/markdown.css") }}" />
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/showdown/1.9.1/showdown.min.js"
+            integrity="sha512-L03kznCrNOfVxOUovR6ESfCz9Gfny7gihUX/huVbQB9zjODtYpxaVtIaAkpetoiyV2eqWbvxMH9fiSv5enX7bw=="
+            crossorigin="anonymous"></script>
+    <script type="application/ecmascript" src="{{ url_for('static', filename="assets/gameInfo.js") }}"></script>
+{% endblock %}
+
+{% block body %}
+    {% include 'header/grassHeader.html' %}
+    <div id="game-info" class="markdown" data-lang="{{ lang }}" data-game="{{ game }}">
+        <!-- Populated my JS / MD -->
+    </div>
+{% endblock %}

WebHostLib/templates/games/A Link to the Past/A Link to the Past.html

@@ -1,15 +0,0 @@
-{% extends 'pageWrapper.html' %}
-
-{% block head %}
-    <title>A Link to the Past</title>
-    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename="styles/zelda3/zelda3.css") }}" />
-    <script type="application/ecmascript" src="https://cdn.jsdelivr.net/npm/axios/dist/axios.min.js"></script>
-    <script type="application/ecmascript" src="{{ url_for('static', filename="assets/js-yaml.min.js") }}"></script>
-{% endblock %}
-
-{% block body %}
-    {% include 'header/grassHeader.html' %}
-    <div id="zelda3">
-        Coming Soon™
-    </div>
-{% endblock %}

WebHostLib/templates/games/Factorio/Factorio.html

@@ -1,15 +0,0 @@
-{% extends 'pageWrapper.html' %}
-
-{% block head %}
-    <title>Factorio</title>
-    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename="styles/factorio/factorio.css") }}" />
-    <script type="application/ecmascript" src="https://cdn.jsdelivr.net/npm/axios/dist/axios.min.js"></script>
-    <script type="application/ecmascript" src="{{ url_for('static', filename="assets/js-yaml.min.js") }}"></script>
-{% endblock %}
-
-{% block body %}
-    {% include 'header/grassHeader.html' %}
-    <div id="factorio">
-        Coming Soon™
-    </div>
-{% endblock %}

WebHostLib/templates/games/Minecraft/Minecraft.html

@@ -1,15 +0,0 @@
-{% extends 'pageWrapper.html' %}
-
-{% block head %}
-    <title>Minecraft</title>
-    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename="styles/minecraft/minecraft.css") }}" />
-    <script type="application/ecmascript" src="https://cdn.jsdelivr.net/npm/axios/dist/axios.min.js"></script>
-    <script type="application/ecmascript" src="{{ url_for('static', filename="assets/js-yaml.min.js") }}"></script>
-{% endblock %}
-
-{% block body %}
-    {% include 'header/grassHeader.html' %}
-    <div id="minecraft">
-        Coming Soon™
-    </div>
-{% endblock %}

WebHostLib/templates/games/Subnautica/Subnautica.html

@@ -1,15 +0,0 @@
-{% extends 'pageWrapper.html' %}
-
-{% block head %}
-    <title>Subnautica</title>
-    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename="styles/subnautica/subnautica.css") }}" />
-    <script type="application/ecmascript" src="https://cdn.jsdelivr.net/npm/axios/dist/axios.min.js"></script>
-    <script type="application/ecmascript" src="{{ url_for('static', filename="assets/js-yaml.min.js") }}"></script>
-{% endblock %}
-
-{% block body %}
-    {% include 'header/grassHeader.html' %}
-    <div id="subnautica">
-        Coming Soon™
-    </div>
-{% endblock %}

WebHostLib/templates/generate.html

@@ -11,33 +11,111 @@
     {% include 'header/oceanHeader.html' %}
     <div id="generate-game-wrapper">
         <div id="generate-game" class="grass-island">
-            <h1>Upload Config{% if race %} (Race Mode){% endif %}</h1>
+            <h1>Generate Game{% if race %} (Race Mode){% endif %}</h1>
             <p>
-                This page allows you to generate a game by uploading a yaml file or a zip file containing yaml files.
-                If you do not have a config (yaml) file yet, you may create one on the
-                <a href="/player-settings">Player Settings</a> page.
+                This page allows you to generate a game by uploading a config file or a zip file containing config
+                files. If you do not have a config (.yaml) file yet, you may create one on the game's settings page,
+                which you can find via the <a href="{{ url_for("games") }}">supported games list</a>.
             </p>
             <p>
                 {% if race -%}
-                    This game will be generated in race mode, meaning the spoiler log will be unavailable,
-                    roms will be encrypted, and single-player games will have no multidata files.
+                    This game will be generated in race mode,
+                    meaning the spoiler log will be unavailable and game specific protections will be in place,
+                    like ROM encryption or cheat mode removal.
                 {%- else -%}
                     If you would like to generate a race game,
-                    <a href="{{ url_for("generate", race=True) }}">click here.</a> Race games are generated without
-                    a spoiler log, the ROMs are encrypted, and single-player games will not include a multidata file.
+                    <a href="{{ url_for("generate", race=True) }}">click here.</a><br />
+                    Race games are generated without a spoiler log and game specific protections will be in place,
+                    like ROM encryption or cheat mode removal.
                 {%- endif -%}
             </p>
-            <p>
-                After generation is complete, you will have the option to download a patch file.
-                This patch file can be opened with the
-                <a href="https://github.com/ArchipelagoMW/Archipelago/releases">client</a>, which can be
-                used to to create a rom file. In-browser patching is planned for the future.
-            </p>
             <div id="generate-game-form-wrapper">
                 <form id="generate-game-form" method="post" enctype="multipart/form-data">
-                    <input id="file-input" type="file" name="file">
+                    <table>
+                        <tbody>
+                            <tr>
+                                <td>
+                                    <label for="forfeit_mode">Forfeit Permission:</label>
+                                    <span
+                                            class="interactive"
+                                            data-tooltip="A forfeit releases all remaining items from the locations
+                                            in your world.">(?)
+                                    </span>
+                                </td>
+                                <td>
+                                    <select name="forfeit_mode" id="forfeit_mode">
+                                        <option value="auto">Automatic on goal completion</option>
+                                        <option value="goal">Allow !forfeit after goal completion</option>
+                                        <option value="auto-enabled">Automatic on goal completion and manual !forfeit</option>
+                                        <option value="enabled">Manual !forfeit</option>
+                                        <option value="disabled">Disabled</option>
+                                    </select>
+                                </td>
+                            </tr>
+
+                            <tr>
+                                <td>
+                                    <label for="collect_mode">Collect Permission:</label>
+                                    <span
+                                            class="interactive"
+                                            data-tooltip="A collect releases all of your remaining items to you
+                                            from across the multiworld.">(?)
+                                    </span>
+                                </td>
+                                <td>
+                                    <select name="collect_mode" id="collect_mode">
+                                        <option value="goal">Allow !collect after goal completion</option>
+                                        <option value="auto">Automatic on goal completion</option>
+                                        <option value="auto-enabled">Automatic on goal completion and manual !collect</option>
+                                        <option value="enabled">Manual !collect</option>
+                                        <option value="disabled">Disabled</option>
+                                    </select>
+                                </td>
+                            </tr>
+
+                            <tr>
+                                <td>
+                                    <label for="remaining_mode">Remaining Permission:</label>
+                                    <span
+                                            class="interactive"
+                                            data-tooltip="Remaining lists all items still in your world by name only.">(?)
+                                    </span>
+                                </td>
+                                <td>
+                                    <select name="remaining_mode" id="remaining_mode">
+                                        <option value="disabled">Disabled</option>
+                                        <option value="goal">Allow !remaining after goal completion</option>
+                                        <option value="enabled">Manual !remaining</option>
+                                    </select>
+                                </td>
+                            </tr>
+
+                            <tr>
+                                <td>
+                                    <label for="hint_cost"> Hint Cost:</label>
+                                    <span
+                                            class="interactive"
+                                            data-tooltip="After gathering this many checks, players can !hint <itemname>
+                                            to get the location of that hint item.">(?)
+                                    </span>
+                                </td>
+                                <td>
+                                    <select name="hint_cost" id="hint_cost">
+                                        {% for n in range(0, 110, 5) %}
+                                            <option {% if n == 10 %}selected="selected" {% endif %} value="{{ n }}">
+                                                {% if n > 100 %}Off{% else %}{{ n }}%{% endif %}
+                                            </option>
+                                        {% endfor %}
+                                    </select>
+                                </td>
+                            </tr>
+                        </tbody>
+                    </table>
+                    <div id="generate-form-button-row">
+                        <input id="file-input" type="file" name="file">
+                    </div>
                 </form>
-                <button id="generate-game-button">Upload</button>
+                <button id="generate-game-button">Upload File</button>
             </div>
         </div>
     </div>

WebHostLib/templates/genericTracker.html

@@ -20,6 +20,7 @@
                         <tr>
                             <th>Item</th>
                             <th>Amount</th>
+                            <th>Order Received</th>
                         </tr>
                     </thead>
                     <tbody>
@@ -28,6 +29,7 @@
                     <tr>
                         <td>{{ name | item_name }}</td>
                         <td>{{ count }}</td>
+                        <td>{{received_items[name]}}</td>
                     </tr>
                     {%- endfor -%}
 

WebHostLib/templates/header/baseHeader.html

@@ -13,7 +13,7 @@
         <div id="base-header-right">
             <a href="/games">supported games</a>
             <a href="/tutorial">setup guides</a>
-            <a href="/uploads">start game</a>
+            <a href="/start-playing">start playing</a>
             <a href="/faq/en">f.a.q.</a>
             <a href="https://discord.gg/8Z65BR2" target="_blank">discord</a>
         </div>

WebHostLib/templates/hostGame.html

@@ -15,17 +15,17 @@
             <h1>Host Game</h1>
             <p>
                 This page allows you to host a game which was not generated by the website. For example, if you have
-                generated a doors game on your own computer, you may upload the zip file created by the generator to
-                host the game here. This will also provide the tracker, and the ability for your players to download
+                generated a game on your own computer, you may upload the zip file created by the generator to
+                host the game here. This will also provide a tracker, and the ability for your players to download
                 their patch files.
                 <br /><br />
-                In addition to a zip file created by the generator, you may upload a multidata file here as well.
+                In addition to the zip file created by the generator, you may upload a multidata file here as well.
             </p>
             <div id="host-game-form-wrapper">
                 <form id="host-game-form" method="post" enctype="multipart/form-data">
                     <input id="file-input" type="file" name="file">
                 </form>
-                <button id="host-game-button">Upload</button>
+                <button id="host-game-button">Upload File</button>
             </div>
         </div>
     </div>

WebHostLib/templates/hostRoom.html

@@ -9,7 +9,7 @@
     {% include 'header/grassHeader.html' %}
     <div id="host-room">
         {% if room.owner == session["_id"] %}
-            Room created from <a href="{{ url_for("viewSeed", seed=room.seed.id) }}">Seed #{{ room.seed.id|suuid }}</a>
+            Room created from <a href="{{ url_for("view_seed", seed=room.seed.id) }}">Seed #{{ room.seed.id|suuid }}</a>
             <br>
         {% endif %}
         {% if room.tracker %}
@@ -20,7 +20,7 @@
         later,
         you can simply refresh this page and the server will be started again.<br>
         {% if room.last_port %}
-            You can connect to this room by using '/connect archipelago.gg:{{ room.last_port }}'
+            You can connect to this room by using '/connect {{ config['PATCH_TARGET'] }}:{{ room.last_port }}'
             in the <a href="{{ url_for("tutorial_landing")}}">client</a>.<br>{% endif %}
         {{ macros.list_patches_room(room) }}
         {% if room.owner == session["_id"] %}

WebHostLib/templates/landing.html

@@ -13,7 +13,7 @@
             <h4>multiworld multi-game randomizer</h4>
         </div>
         <div id="landing-links">
-            <a href="/uploads" id="mid-button">start<br />game</a>
+            <a href="/start-playing" id="mid-button">start<br />playing</a>
             <a href="/games" id="far-left-button">supported<br />games</a>
             <a href="/tutorial" id="mid-left-button">setup guides</a>
             <a href="https://discord.gg/8Z65BR2" id="far-right-button" target="_blank">discord</a>
@@ -50,7 +50,7 @@
                 </p>
                 <p>
                     <span class="variable">{{ seeds }}</span>
-                    games were created and
+                    games were generated and
                     <span class="variable">{{ rooms }}</span>
                     were hosted in the last 7 days.
                 </p>

WebHostLib/templates/macros.html

@@ -1,7 +1,7 @@
 {% macro list_rooms(rooms) -%}
     <ul>
         {% for room in rooms %}
-            <li><a href="{{ url_for("hostRoom", room=room.id) }}">Room #{{ room.id|suuid }}</a></li>
+            <li><a href="{{ url_for("host_room", room=room.id) }}">Room #{{ room.id|suuid }}</a></li>
         {% endfor %}
         {{ caller() }}
     </ul>

WebHostLib/templates/minecraftTracker.html

@@ -42,6 +42,7 @@
                 <td><img src="{{ icons['Enchanting Table'] }}" class="{{ 'acquired' if 'Enchanting' in acquired_items }}" title="Enchanting" /></td>
                 <td><img src="{{ icons['Fishing Rod'] }}" class="{{ 'acquired' if 'Fishing Rod' in acquired_items }}" title="Fishing Rod" /></td>
                 <td><img src="{{ icons['Campfire'] }}" class="{{ 'acquired' if 'Campfire' in acquired_items }}" title="Campfire" /></td>
+                <td><img src="{{ icons['Spyglass'] }}" class="{{ 'acquired' if 'Spyglass' in acquired_items }}" title="Spyglass" /></td>
                 <td><img src="{{ icons['Dragon Head'] }}" class="{{ 'acquired' if game_finished }}" title="Ender Dragon" /></td>
             </tr>
         </table>

WebHostLib/templates/ootTracker.html

@@ -0,0 +1,180 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <title>{{ player_name }}&apos;s Tracker</title>
+    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename='styles/ootTracker.css') }}"/>
+    <script type="application/ecmascript" src="{{ url_for('static', filename='assets/ootTracker.js') }}"></script>
+</head>
+
+<body>
+    <div id="player-tracker-wrapper" data-tracker="{{ room.tracker|suuid }}">
+        <table id="inventory-table">
+            <tr>
+                <td><img src="{{ ocarina_url }}" class="{{ 'acquired' if 'Ocarina' in acquired_items }}" title="Ocarina" /></td>
+                <td><img src="{{ icons['Bombs'] }}" class="{{ 'acquired' if 'Bomb Bag' in acquired_items }}" title="Bombs" /></td>
+                <td><img src="{{ icons['Bow'] }}" class="{{ 'acquired' if 'Bow' in acquired_items }}" title="Fairy Bow" /></td>
+                <td><img src="{{ icons['Fire Arrows'] }}" class="{{ 'acquired' if 'Fire Arrows' in acquired_items }}" title="Fire Arrows" /></td>
+                <td><img src="{{ icons['Kokiri Sword'] }}" class="{{ 'acquired' if 'Kokiri Sword' in acquired_items }}" title="Kokiri Sword" /></td>
+                <td><img src="{{ icons['Biggoron Sword'] }}" class="{{ 'acquired' if 'Biggoron Sword' in acquired_items }}" title="Biggoron's Sword" /></td>
+                <td><img src="{{ icons['Mirror Shield'] }}" class="{{ 'acquired' if 'Mirror Shield' in acquired_items }}" title="Mirror Shield" /></td>
+            </tr>
+            <tr>
+                <td><img src="{{ icons['Slingshot'] }}" class="{{ 'acquired' if 'Slingshot' in acquired_items }}" title="Slingshot" /></td>
+                <td><img src="{{ icons['Bombchus'] }}" class="{{ 'acquired' if has_bombchus }}" title="Bombchus" /></td>
+                <td>
+                    <div class="counted-item">
+                        <img src="{{ hookshot_url }}" class="{{ 'acquired' if 'Progressive Hookshot' in acquired_items }}" title="Progressive Hookshot" />
+                        <div class="item-count">{{ hookshot_length }}</div>
+                    </div>
+                </td>
+                <td><img src="{{ icons['Ice Arrows'] }}" class="{{ 'acquired' if 'Ice Arrows' in acquired_items }}" title="Ice Arrows" /></td>
+                <td><img src="{{ strength_upgrade_url }}" class="{{ 'acquired' if 'Progressive Strength Upgrade' in acquired_items }}" title="Progressive Strength Upgrade" /></td>
+                <td><img src="{{ icons['Goron Tunic'] }}" class="{{ 'acquired' if 'Goron Tunic' in acquired_items }}" title="Goron Tunic" /></td>
+                <td><img src="{{ icons['Zora Tunic'] }}" class="{{ 'acquired' if 'Zora Tunic' in acquired_items }}" title="Zora Tunic" /></td>
+            </tr>
+            <tr>
+                <td><img src="{{ icons['Boomerang'] }}" class="{{ 'acquired' if 'Boomerang' in acquired_items }}" title="Boomerang" /></td>
+                <td><img src="{{ icons['Lens of Truth'] }}" class="{{ 'acquired' if 'Lens of Truth' in acquired_items }}" title="Lens of Truth" /></td>
+                <td><img src="{{ icons['Megaton Hammer'] }}" class="{{ 'acquired' if 'Megaton Hammer' in acquired_items }}" title="Megaton Hammer" /></td>
+                <td><img src="{{ icons['Light Arrows'] }}" class="{{ 'acquired' if 'Light Arrows' in acquired_items }}" title="Light Arrows" /></td>
+                <td><img src="{{ scale_url }}" class="{{ 'acquired' if 'Progressive Scale' in acquired_items }}" title="Progressive Scale" /></td>
+                <td><img src="{{ icons['Iron Boots'] }}" class="{{ 'acquired' if 'Iron Boots' in acquired_items }}" title="Iron Boots" /></td>
+                <td><img src="{{ icons['Hover Boots'] }}" class="{{ 'acquired' if 'Hover Boots' in acquired_items }}" title="Hover Boots" /></td>
+            </tr>
+            <tr>
+                <td>
+                    <div class="counted-item">
+                        <img src="{{ bottle_url }}" class="{{ 'acquired' if bottle_count > 0 }}" title="Bottles" />
+                        <div class="item-count">{{ bottle_count if bottle_count > 0 else '' }}</div>
+                    </div>
+                </td>
+                <td><img src="{{ icons['Dins Fire'] }}" class="{{ 'acquired' if 'Dins Fire' in acquired_items }}" title="Din's Fire" /></td>
+                <td><img src="{{ icons['Farores Wind'] }}" class="{{ 'acquired' if 'Farores Wind' in acquired_items }}" title="Farore's Wind" /></td>
+                <td><img src="{{ icons['Nayrus Love'] }}" class="{{ 'acquired' if 'Nayrus Love' in acquired_items }}" title="Nayru's Love" /></td>
+                <td>
+                    <div class="counted-item">
+                        <img src="{{ wallet_url }}" class="{{ 'acquired' if 'Progressive Wallet' in acquired_items }}" title="Progressive Wallet" />
+                        <div class="item-count">{{ wallet_size }}</div>
+                    </div>
+                </td>
+                <td><img src="{{ magic_meter_url }}" class="{{ 'acquired' if 'Magic Meter' in acquired_items }}" title="Magic Meter" /></td>
+                <td><img src="{{ icons['Gerudo Membership Card'] }}" class="{{ 'acquired' if 'Gerudo Membership Card' in acquired_items }}" title="Gerudo Membership Card" /></td>
+            </tr>
+            <tr>
+                <td>
+                    <div class="counted-item">
+                        <img src="{{ icons['Zeldas Lullaby'] }}" class="{{ 'acquired' if 'Zeldas Lullaby' in acquired_items }}" title="Zelda's Lullaby" id="lullaby"/>
+                        <div class="item-count">Zelda</div>
+                    </div>
+                </td>
+                <td>
+                    <div class="counted-item">
+                        <img src="{{ icons['Eponas Song'] }}" class="{{ 'acquired' if 'Eponas Song' in acquired_items }}" title="Epona's Song" id="epona" />
+                        <div class="item-count">Epona</div>
+                    </div>
+                </td>
+                <td>
+                    <div class="counted-item">
+                        <img src="{{ icons['Sarias Song'] }}" class="{{ 'acquired' if 'Sarias Song' in acquired_items }}" title="Saria's Song" id="saria"/>
+                        <div class="item-count">Saria</div>
+                    </div>
+                </td>
+                <td>
+                    <div class="counted-item">
+                        <img src="{{ icons['Suns Song'] }}" class="{{ 'acquired' if 'Suns Song' in acquired_items }}" title="Sun's Song" id="sun"/>
+                        <div class="item-count">Sun</div>
+                    </div>
+                </td>
+                <td>
+                    <div class="counted-item">
+                        <img src="{{ icons['Song of Time'] }}" class="{{ 'acquired' if 'Song of Time' in acquired_items }}" title="Song of Time" id="time"/>
+                        <div class="item-count">Time</div>
+                    </div>
+                </td>
+                <td>
+                    <div class="counted-item">
+                        <img src="{{ icons['Song of Storms'] }}" class="{{ 'acquired' if 'Song of Storms' in acquired_items }}" title="Song of Storms" />
+                        <div class="item-count">Storms</div>
+                    </div>
+                </td>
+                <td>
+                    <div class="counted-item">
+                        <img src="{{ icons['Gold Skulltula Token'] }}" class="{{ 'acquired' if token_count > 0 }}" title="Gold Skulltula Tokens" />
+                        <div class="item-count">{{ token_count }}</div>
+                    </div>
+                </td>
+            </tr>
+            <tr>
+                <td>
+                    <div class="counted-item">
+                        <img src="{{ icons['Minuet of Forest'] }}" class="{{ 'acquired' if 'Minuet of Forest' in acquired_items }}" title="Minuet of Forest" />
+                        <div class="item-count">Min</div>
+                    </div>
+                </td>
+                <td>
+                    <div class="counted-item">
+                        <img src="{{ icons['Bolero of Fire'] }}" class="{{ 'acquired' if 'Bolero of Fire' in acquired_items }}" title="Bolero of Fire" />
+                        <div class="item-count">Bol</div>
+                    </div>
+                </td>
+                <td>
+                    <div class="counted-item">
+                        <img src="{{ icons['Serenade of Water'] }}" class="{{ 'acquired' if 'Serenade of Water' in acquired_items }}" title="Serenade of Water" />
+                        <div class="item-count">Ser</div>
+                    </div>
+                </td>
+                <td>
+                    <div class="counted-item">
+                        <img src="{{ icons['Requiem of Spirit'] }}" class="{{ 'acquired' if 'Requiem of Spirit' in acquired_items }}" title="Requiem of Spirit" />
+                        <div class="item-count">Req</div>
+                    </div>
+                </td>
+                <td>
+                    <div class="counted-item">
+                        <img src="{{ icons['Nocturne of Shadow'] }}" class="{{ 'acquired' if 'Nocturne of Shadow' in acquired_items }}" title="Nocturne of Shadow" />
+                        <div class="item-count">Noc</div>
+                    </div>
+                </td>
+                <td>
+                    <div class="counted-item">
+                        <img src="{{ icons['Prelude of Light'] }}" class="{{ 'acquired' if 'Prelude of Light' in acquired_items }}" title="Prelude of Light" />
+                        <div class="item-count">Pre</div>
+                    </div>
+                </td>
+                <td>
+                    <div class="counted-item">
+                        <img src="{{ icons['Triforce'] if game_finished else icons['Triforce Piece'] }}" class="{{ 'acquired' if game_finished or piece_count > 0 }}" title="{{ 'Triforce' if game_finished else 'Triforce Pieces' }}" id=triforce />
+                        <div class="item-count">{{ piece_count if piece_count > 0 else '' }}</div>
+                    </div>
+                </td>
+            </tr>
+        </table>
+        <table id="location-table">
+            <tr>
+                <td></td>
+                <td><img src="{{ icons['Small Key'] }}" title="Small Keys" /></td>
+                <td><img src="{{ icons['Boss Key'] }}" title="Boss Key" /></td>
+                <td class="right-align">Items</td>
+            </tr>
+            {% for area in checks_done %}
+            <tr class="location-category" id="{{area}}-header">
+                <td>{{ area }} {{'▼' if area != 'Total'}}</td>
+                <td class="smallkeys">{{ small_key_counts.get(area, '-') }}</td>
+                <td class="bosskeys">{{ boss_key_counts.get(area, '-') }}</td>
+                <td class="counter">{{ checks_done[area] }} / {{ checks_in_area[area] }}</td>
+            </tr>
+            <tbody class="locations hide" id="{{area}}">
+                {% for location in location_info[area] %}
+                <tr>
+                    <td class="location-name">{{ location }}</td>
+                    <td></td>
+                    <td></td>
+                    <td class="counter">{{ '✔' if location_info[area][location] else '' }}</td>
+                </tr>
+                {% endfor %}
+            </tbody>
+            {% endfor %}
+        </table>
+    </div>
+</body>
+</html>

WebHostLib/templates/options.yaml

@@ -36,22 +36,7 @@ accessibility:
 progression_balancing:
   on: 50 # A system to reduce BK, as in times during which you can't do anything by moving your items into an earlier access sphere to make it likely you have stuff to do
   off: 0 # Turn this off if you don't mind a longer multiworld, or can glitch/sequence break around missing items.
-  # The following 4 options can be uncommented and moved into a game's section they should affect
-  # start_inventory: # Begin the file with the listed items/upgrades
-  # Please only use items for the correct game, use triggers if need to be have seperated lists.
-  # Pegasus Boots: on
-  # Bomb Upgrade (+10): 4
-  # Arrow Upgrade (+10): 4
-# start_hints: # Begin the game with these items' locations revealed to you at the start of the game. Get the info via !hint in your client.
-#   - Moon Pearl
-# local_items: # Force certain items to appear in your world only, not across the multiworld. Recognizes some group names, like "Swords"
-#  - "Moon Pearl"
-#  - "Small Keys"
-#  - "Big Keys"
-# non_local_items: # Force certain items to appear outside your world only, unless in single-player. Recognizes some group names, like "Swords"
-#  - "Progressive Weapons"
-# exclude_locations: # Force certain locations to never contain progression items, and always be filled with junk.
-#  - "Master Sword Pedestal"
+
 {%- macro range_option(option) %}
     # you can add additional values between minimum and maximum
     {%- set data, notes = dictify_range(option) %}
@@ -62,14 +47,14 @@ progression_balancing:
 {{ game }}:
   {%- for option_key, option in options.items() %}
   {{ option_key }}:{% if option.__doc__ %} # {{ option.__doc__ | replace('\n', '\n#') | indent(4, first=False) }}{% endif %}
-    {%- if option.range_start is defined  %}
+    {%- if option.range_start is defined and option.range_start is number %}
     {{- range_option(option) -}}
     {%- elif option.options -%}
     {%- for suboption_option_id, sub_option_name in option.name_lookup.items() %}
     {{ sub_option_name }}: {% if suboption_option_id == option.default %}50{% else %}0{% endif %}
     {%- endfor -%}
     {%- else %}
-    {{ yaml_dump(option.default) | indent(4, first=False) }}
+    {{ yaml_dump(default_converter(option.default)) | indent(4, first=False) }}
   {%- endif -%}
   {%- endfor %}
   {% if not options %}{}{% endif %}

WebHostLib/templates/player-settings.html

@@ -4,6 +4,7 @@
     <title>{{ game }} Settings</title>
     <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename="styles/player-settings.css") }}" />
     <script type="application/ecmascript" src="https://cdn.jsdelivr.net/npm/axios/dist/axios.min.js"></script>
+    <script type="application/ecmascript" src="{{ url_for('static', filename="assets/md5.min.js") }}"></script>
     <script type="application/ecmascript" src="{{ url_for('static', filename="assets/js-yaml.min.js") }}"></script>
     <script type="application/ecmascript" src="{{ url_for('static', filename="assets/player-settings.js") }}"></script>
 {% endblock %}
@@ -20,7 +21,7 @@
             A list of all games you have generated can be found <a href="/user-content">here</a>.
             <br />
             Advanced users can download a template file for this game
-            <a href="/static/generated/{{ game }}.yaml">here</a>.
+            <a href="/static/generated/configs/{{ game }}.yaml">here</a>.
         </p>
 
         <p><label for="player-name">Please enter your player name. This will appear in-game as you send and receive

WebHostLib/templates/startPlaying.html

@@ -0,0 +1,32 @@
+{% extends 'pageWrapper.html' %}
+
+{% block head %}
+    {{ super() }}
+    <title>Start Playing</title>
+    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename="styles/startPlaying.css") }}" />
+{% endblock %}
+
+{% block body %}
+    {% include 'header/oceanHeader.html' %}
+
+    <div id="start-playing-wrapper">
+        <div id="start-playing" class="grass-island {% if rooms %}wider{% endif %}">
+            <h1>Start Playing</h1>
+            <p>
+                If you're ready to start playing but don't know where to begin, check out the
+                <a href="/tutorial">tutorials</a> page. It has all the resources you need to create a config file
+                and get started. If you already have a config file, or a zip file containing them, read on.
+                <br /><br />
+
+                To start playing a game, you'll first need to <a href="/generate">generate a randomized game</a>.
+                You'll need to upload either a config file or a zip file containing one more more config files.
+                <br /><br />
+
+                If you have already generated a game and just need to host it, this site can<br />
+                <a href="uploads">host a pre-generated game</a> for you.
+            </p>
+        </div>
+    </div>
+
+    {% include 'islandFooter.html' %}
+{% endblock %}

WebHostLib/templates/supportedGames.html

@@ -10,8 +10,12 @@
     <div id="games">
         <h1>Currently Supported Games</h1>
         {% for game, description in worlds.items() %}
-        <h3><a href="{{ url_for("game_page", game=game) }}/player-settings">{{ game }}</a></h3>
-        <p>{{ description }}</p>
+        <h3><a href="{{ url_for("game_info", game=game, lang="en") }}">{{ game }}</a></h3>
+        <p>
+            <a href="{{ url_for("player_settings", game=game) }}">Settings Page</a>
+            <br />
+            {{ description }}
+        </p>
         {% endfor %}
     </div>
 {% endblock %}