diff --git a/BaseClasses.py b/BaseClasses.py
index 0989999d398..818bdc1f4a1 100644
--- a/BaseClasses.py
+++ b/BaseClasses.py
@@ -1,20 +1,20 @@
 from __future__ import annotations
-from argparse import Namespace
 
 import copy
-from enum import unique, IntEnum, IntFlag
-import logging
-import json
 import functools
+import json
+import logging
+import random
+import secrets
+import typing  # this can go away when Python 3.8 support is dropped
+from argparse import Namespace
 from collections import OrderedDict, Counter, deque
+from enum import unique, IntEnum, IntFlag
 from typing import List, Dict, Optional, Set, Iterable, Union, Any, Tuple, TypedDict, Callable, NamedTuple
-import typing  # this can go away when Python 3.8 support is dropped
-import secrets
-import random
 
+import NetUtils
 import Options
 import Utils
-import NetUtils
 
 
 class Group(TypedDict, total=False):
@@ -48,6 +48,7 @@ class MultiWorld():
     precollected_items: Dict[int, List[Item]]
     state: CollectionState
 
+    plando_options: PlandoOptions
     accessibility: Dict[int, Options.Accessibility]
     early_items: Dict[int, Dict[str, int]]
     local_early_items: Dict[int, Dict[str, int]]
@@ -160,6 +161,7 @@ def set_player_attr(attr, val):
         self.custom_data = {}
         self.worlds = {}
         self.slot_seeds = {}
+        self.plando_options = PlandoOptions.none
 
     def get_all_ids(self) -> Tuple[int, ...]:
         return self.player_ids + tuple(self.groups)
@@ -1558,6 +1560,7 @@ def write_option(option_key: str, option_obj: type(Options.Option)):
                     Utils.__version__, self.multiworld.seed))
             outfile.write('Filling Algorithm:               %s\n' % self.multiworld.algorithm)
             outfile.write('Players:                         %d\n' % self.multiworld.players)
+            outfile.write(f'Plando Options:                  {self.multiworld.plando_options}\n')
             AutoWorld.call_stage(self.multiworld, "write_spoiler_header", outfile)
 
             for player in range(1, self.multiworld.players + 1):
@@ -1674,6 +1677,45 @@ class Tutorial(NamedTuple):
     authors: List[str]
 
 
+class PlandoOptions(IntFlag):
+    none = 0b0000
+    items = 0b0001
+    connections = 0b0010
+    texts = 0b0100
+    bosses = 0b1000
+
+    @classmethod
+    def from_option_string(cls, option_string: str) -> PlandoOptions:
+        result = cls(0)
+        for part in option_string.split(","):
+            part = part.strip().lower()
+            if part:
+                result = cls._handle_part(part, result)
+        return result
+
+    @classmethod
+    def from_set(cls, option_set: Set[str]) -> PlandoOptions:
+        result = cls(0)
+        for part in option_set:
+            result = cls._handle_part(part, result)
+        return result
+
+    @classmethod
+    def _handle_part(cls, part: str, base: PlandoOptions) -> PlandoOptions:
+        try:
+            part = cls[part]
+        except Exception as e:
+            raise KeyError(f"{part} is not a recognized name for a plando module. "
+                           f"Known options: {', '.join(flag.name for flag in cls)}") from e
+        else:
+            return base | part
+
+    def __str__(self) -> str:
+        if self.value:
+            return ", ".join(flag.name for flag in PlandoOptions if self.value & flag.value)
+        return "None"
+
+
 seeddigits = 20
 
 
diff --git a/CommonClient.py b/CommonClient.py
index aa11661d5bb..e3c325d2105 100644
--- a/CommonClient.py
+++ b/CommonClient.py
@@ -494,7 +494,7 @@ def gui_error(self, title: str, text: typing.Union[Exception, str]) -> typing.Op
         self._messagebox.open()
         return self._messagebox
 
-    def _handle_connection_loss(self, msg: str) -> None:
+    def handle_connection_loss(self, msg: str) -> None:
         """Helper for logging and displaying a loss of connection. Must be called from an except block."""
         exc_info = sys.exc_info()
         logger.exception(msg, exc_info=exc_info, extra={'compact_gui': True})
@@ -580,14 +580,22 @@ def reconnect_hint() -> str:
             for msg in decode(data):
                 await process_server_cmd(ctx, msg)
         logger.warning(f"Disconnected from multiworld server{reconnect_hint()}")
+    except websockets.InvalidMessage:
+        # probably encrypted
+        if address.startswith("ws://"):
+            await server_loop(ctx, "ws" + address[1:])
+        else:
+            ctx.handle_connection_loss(f"Lost connection to the multiworld server due to InvalidMessage"
+                                       f"{reconnect_hint()}")
     except ConnectionRefusedError:
-        ctx._handle_connection_loss("Connection refused by the server. May not be running Archipelago on that address or port.")
+        ctx.handle_connection_loss("Connection refused by the server. "
+                                   "May not be running Archipelago on that address or port.")
     except websockets.InvalidURI:
-        ctx._handle_connection_loss("Failed to connect to the multiworld server (invalid URI)")
+        ctx.handle_connection_loss("Failed to connect to the multiworld server (invalid URI)")
     except OSError:
-        ctx._handle_connection_loss("Failed to connect to the multiworld server")
+        ctx.handle_connection_loss("Failed to connect to the multiworld server")
     except Exception:
-        ctx._handle_connection_loss(f"Lost connection to the multiworld server{reconnect_hint()}")
+        ctx.handle_connection_loss(f"Lost connection to the multiworld server{reconnect_hint()}")
     finally:
         await ctx.connection_closed()
         if ctx.server_address and ctx.username and not ctx.disconnected_intentionally:
diff --git a/Generate.py b/Generate.py
index 04c081b4ac4..dadabd7ac6e 100644
--- a/Generate.py
+++ b/Generate.py
@@ -2,14 +2,13 @@
 
 import argparse
 import logging
+import os
 import random
-import urllib.request
+import string
 import urllib.parse
-from typing import Set, Dict, Tuple, Callable, Any, Union
-import os
+import urllib.request
 from collections import Counter, ChainMap
-import string
-import enum
+from typing import Dict, Tuple, Callable, Any, Union
 
 import ModuleUpdate
 
@@ -18,52 +17,17 @@
 import Utils
 from worlds.alttp import Options as LttPOptions
 from worlds.generic import PlandoConnection
-from Utils import parse_yamls, version_tuple, __version__, tuplize_version, get_options, local_path, user_path
+from Utils import parse_yamls, version_tuple, __version__, tuplize_version, get_options, user_path
 from worlds.alttp.EntranceRandomizer import parse_arguments
 from Main import main as ERmain
-from BaseClasses import seeddigits, get_seed
+from BaseClasses import seeddigits, get_seed, PlandoOptions
 import Options
 from worlds.alttp.Text import TextTable
 from worlds.AutoWorld import AutoWorldRegister
 import copy
 
 
-class PlandoSettings(enum.IntFlag):
-    items = 0b0001
-    connections = 0b0010
-    texts = 0b0100
-    bosses = 0b1000
-
-    @classmethod
-    def from_option_string(cls, option_string: str) -> PlandoSettings:
-        result = cls(0)
-        for part in option_string.split(","):
-            part = part.strip().lower()
-            if part:
-                result = cls._handle_part(part, result)
-        return result
-
-    @classmethod
-    def from_set(cls, option_set: Set[str]) -> PlandoSettings:
-        result = cls(0)
-        for part in option_set:
-            result = cls._handle_part(part, result)
-        return result
-
-    @classmethod
-    def _handle_part(cls, part: str, base: PlandoSettings) -> PlandoSettings:
-        try:
-            part = cls[part]
-        except Exception as e:
-            raise KeyError(f"{part} is not a recognized name for a plando module. "
-                           f"Known options: {', '.join(flag.name for flag in cls)}") from e
-        else:
-            return base | part
 
-    def __str__(self) -> str:
-        if self.value:
-            return ", ".join(flag.name for flag in PlandoSettings if self.value & flag.value)
-        return "Off"
 
 
 def mystery_argparse():
@@ -97,7 +61,7 @@ def resolve_path(path: str, resolver: Callable[[str], str]) -> str:
         args.weights_file_path = os.path.join(args.player_files_path, args.weights_file_path)
     if not os.path.isabs(args.meta_file_path):
         args.meta_file_path = os.path.join(args.player_files_path, args.meta_file_path)
-    args.plando: PlandoSettings = PlandoSettings.from_option_string(args.plando)
+    args.plando: PlandoOptions = PlandoOptions.from_option_string(args.plando)
     return args, options
 
 
@@ -170,6 +134,7 @@ def main(args=None, callback=ERmain):
                         f"A mix is also permitted.")
     erargs = parse_arguments(['--multi', str(args.multi)])
     erargs.seed = seed
+    erargs.plando_options = args.plando
     erargs.glitch_triforce = options["generator"]["glitch_triforce_room"]
     erargs.spoiler = args.spoiler
     erargs.race = args.race
@@ -226,7 +191,7 @@ def main(args=None, callback=ERmain):
                     elif not erargs.name[player]:  # if name was not specified, generate it from filename
                         erargs.name[player] = os.path.splitext(os.path.split(path)[-1])[0]
                     erargs.name[player] = handle_name(erargs.name[player], player, name_counter)
-                    
+
                     player += 1
             except Exception as e:
                 raise ValueError(f"File {path} is destroyed. Please fix your yaml.") from e
@@ -443,7 +408,7 @@ def roll_triggers(weights: dict, triggers: list) -> dict:
     return weights
 
 
-def handle_option(ret: argparse.Namespace, game_weights: dict, option_key: str, option: type(Options.Option), plando_options: PlandoSettings):
+def handle_option(ret: argparse.Namespace, game_weights: dict, option_key: str, option: type(Options.Option), plando_options: PlandoOptions):
     if option_key in game_weights:
         try:
             if not option.supports_weighting:
@@ -459,7 +424,7 @@ def handle_option(ret: argparse.Namespace, game_weights: dict, option_key: str,
         setattr(ret, option_key, option.from_any(option.default))  # call the from_any here to support default "random"
 
 
-def roll_settings(weights: dict, plando_options: PlandoSettings = PlandoSettings.bosses):
+def roll_settings(weights: dict, plando_options: PlandoOptions = PlandoOptions.bosses):
     if "linked_options" in weights:
         weights = roll_linked_options(weights)
 
@@ -472,7 +437,7 @@ def roll_settings(weights: dict, plando_options: PlandoSettings = PlandoSettings
         if tuplize_version(version) > version_tuple:
             raise Exception(f"Settings reports required version of generator is at least {version}, "
                             f"however generator is of version {__version__}")
-        required_plando_options = PlandoSettings.from_option_string(requirements.get("plando", ""))
+        required_plando_options = PlandoOptions.from_option_string(requirements.get("plando", ""))
         if required_plando_options not in plando_options:
             if required_plando_options:
                 raise Exception(f"Settings reports required plando module {str(required_plando_options)}, "
@@ -506,12 +471,12 @@ def roll_settings(weights: dict, plando_options: PlandoSettings = PlandoSettings
             if option_key not in world_type.option_definitions and \
                     (option_key not in Options.common_options or option_key in game_weights):
                 handle_option(ret, game_weights, option_key, option, plando_options)
-        if PlandoSettings.items in plando_options:
+        if PlandoOptions.items in plando_options:
             ret.plando_items = game_weights.get("plando_items", [])
         if ret.game == "Minecraft" or ret.game == "Ocarina of Time":
             # bad hardcoded behavior to make this work for now
             ret.plando_connections = []
-            if PlandoSettings.connections in plando_options:
+            if PlandoOptions.connections in plando_options:
                 options = game_weights.get("plando_connections", [])
                 for placement in options:
                     if roll_percentage(get_choice("percentage", placement, 100)):
@@ -626,7 +591,7 @@ def roll_alttp_settings(ret: argparse.Namespace, weights, plando_options):
             raise Exception(f"unknown Medallion {medallion} for {'misery mire' if index == 0 else 'turtle rock'}")
 
     ret.plando_texts = {}
-    if PlandoSettings.texts in plando_options:
+    if PlandoOptions.texts in plando_options:
         tt = TextTable()
         tt.removeUnwantedText()
         options = weights.get("plando_texts", [])
@@ -638,7 +603,7 @@ def roll_alttp_settings(ret: argparse.Namespace, weights, plando_options):
                 ret.plando_texts[at] = str(get_choice_legacy("text", placement))
 
     ret.plando_connections = []
-    if PlandoSettings.connections in plando_options:
+    if PlandoOptions.connections in plando_options:
         options = weights.get("plando_connections", [])
         for placement in options:
             if roll_percentage(get_choice_legacy("percentage", placement, 100)):
diff --git a/Main.py b/Main.py
index 78da5285453..cbef89a4747 100644
--- a/Main.py
+++ b/Main.py
@@ -38,6 +38,7 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
 
     logger = logging.getLogger()
     world.set_seed(seed, args.race, str(args.outputname if args.outputname else world.seed))
+    world.plando_options = args.plando_options
 
     world.shuffle = args.shuffle.copy()
     world.logic = args.logic.copy()
@@ -291,27 +292,6 @@ def find_common_pool(players: Set[int], shared_pool: Set[str]) -> Tuple[
                             checks_in_area[location.player]["Dark World"].append(location.address)
                     checks_in_area[location.player]["Total"] += 1
 
-            oldmancaves = []
-            takeanyregions = ["Old Man Sword Cave", "Take-Any #1", "Take-Any #2", "Take-Any #3", "Take-Any #4"]
-            for index, take_any in enumerate(takeanyregions):
-                for region in [world.get_region(take_any, player) for player in
-                               world.get_game_players("A Link to the Past") if world.retro_caves[player]]:
-                    item = world.create_item(
-                        region.shop.inventory[(0 if take_any == "Old Man Sword Cave" else 1)]['item'],
-                        region.player)
-                    player = region.player
-                    location_id = SHOP_ID_START + total_shop_slots + index
-
-                    main_entrance = region.get_connecting_entrance(is_main_entrance)
-                    if main_entrance.parent_region.type == RegionType.LightWorld:
-                        checks_in_area[player]["Light World"].append(location_id)
-                    else:
-                        checks_in_area[player]["Dark World"].append(location_id)
-                    checks_in_area[player]["Total"] += 1
-
-                    er_hint_data[player][location_id] = main_entrance.name
-                    oldmancaves.append(((location_id, player), (item.code, player)))
-
             FillDisabledShopSlots(world)
 
             def write_multidata():
diff --git a/MultiServer.py b/MultiServer.py
index 1bbbed69faa..1c375ee1d54 100644
--- a/MultiServer.py
+++ b/MultiServer.py
@@ -116,7 +116,8 @@ class Context:
                       "location_check_points": int,
                       "server_password": str,
                       "password": str,
-                      "forfeit_mode": str,
+                      "forfeit_mode": str,  # TODO remove around 0.4
+                      "release_mode": str,
                       "remaining_mode": str,
                       "collect_mode": str,
                       "item_cheat": bool,
@@ -134,7 +135,6 @@ class Context:
     item_name_groups: typing.Dict[str, typing.Dict[str, typing.Set[str]]]
     location_names: typing.Dict[int, str] = Utils.KeyedDefaultDict(lambda code: f'Unknown location (ID:{code})')
     all_item_and_group_names: typing.Dict[str, typing.Set[str]]
-    forced_auto_forfeits: typing.Dict[str, bool]
     non_hintable_names: typing.Dict[str, typing.Set[str]]
 
     def __init__(self, host: str, port: int, server_password: str, password: str, location_check_points: int,
@@ -171,7 +171,7 @@ def __init__(self, host: str, port: int, server_password: str, password: str, lo
         self.location_check_points = location_check_points
         self.hints_used = collections.defaultdict(int)
         self.hints: typing.Dict[team_slot, typing.Set[NetUtils.Hint]] = collections.defaultdict(set)
-        self.forfeit_mode: str = forfeit_mode
+        self.release_mode: str = forfeit_mode
         self.remaining_mode: str = remaining_mode
         self.collect_mode: str = collect_mode
         self.item_cheat = item_cheat
@@ -204,7 +204,6 @@ def __init__(self, host: str, port: int, server_password: str, password: str, lo
         self.gamespackage = {}
         self.item_name_groups = {}
         self.all_item_and_group_names = {}
-        self.forced_auto_forfeits = collections.defaultdict(lambda: False)
         self.non_hintable_names = collections.defaultdict(frozenset)
 
         self._load_game_data()
@@ -217,7 +216,6 @@ def _load_game_data(self):
         self.item_name_groups = {world_name: world.item_name_groups for world_name, world in
                                  worlds.AutoWorldRegister.world_types.items()}
         for world_name, world in worlds.AutoWorldRegister.world_types.items():
-            self.forced_auto_forfeits[world_name] = world.forced_auto_forfeit
             self.non_hintable_names[world_name] = world.hint_blacklist
 
     def _init_game_data(self):
@@ -317,7 +315,7 @@ def notify_client_multiple(self, client: Client, texts: typing.List[str]):
         if not client.auth:
             return
         if client.version >= print_command_compatability_threshold:
-            async_start(self.send_msgs(client, 
+            async_start(self.send_msgs(client,
                 [{"cmd": "PrintJSON", "data": [{ "text": text }]} for text in texts]))
         else:
             async_start(self.send_msgs(client, [{"cmd": "Print", "text": text} for text in texts]))
@@ -513,9 +511,10 @@ def get_save(self) -> dict:
             "group_collected": dict(self.group_collected),
             "stored_data": self.stored_data,
             "game_options": {"hint_cost": self.hint_cost, "location_check_points": self.location_check_points,
-                             "server_password": self.server_password, "password": self.password, "forfeit_mode":
-                             self.forfeit_mode, "remaining_mode": self.remaining_mode, "collect_mode":
-                             self.collect_mode, "item_cheat": self.item_cheat, "compatibility": self.compatibility}
+                             "server_password": self.server_password, "password": self.password,
+                             "forfeit_mode": self.release_mode, "release_mode": self.release_mode,  # TODO remove forfeit_mode around 0.4
+                             "remaining_mode": self.remaining_mode, "collect_mode": self.collect_mode,
+                             "item_cheat": self.item_cheat, "compatibility": self.compatibility}
 
         }
 
@@ -546,7 +545,7 @@ def set_save(self, savedata: dict):
             self.location_check_points = savedata["game_options"]["location_check_points"]
             self.server_password = savedata["game_options"]["server_password"]
             self.password = savedata["game_options"]["password"]
-            self.forfeit_mode = savedata["game_options"]["forfeit_mode"]
+            self.release_mode = savedata["game_options"]["release_mode"]
             self.remaining_mode = savedata["game_options"]["remaining_mode"]
             self.collect_mode = savedata["game_options"]["collect_mode"]
             self.item_cheat = savedata["game_options"]["item_cheat"]
@@ -658,10 +657,8 @@ def on_goal_achieved(self, client: Client):
         self.notify_all(finished_msg)
         if "auto" in self.collect_mode:
             collect_player(self, client.team, client.slot)
-        if "auto" in self.forfeit_mode:
-            forfeit_player(self, client.team, client.slot)
-        elif self.forced_auto_forfeits[self.games[client.slot]]:
-            forfeit_player(self, client.team, client.slot)
+        if "auto" in self.release_mode:
+            release_player(self, client.team, client.slot)
         self.save()  # save goal completion flag
 
     def on_new_hint(self, team: int, slot: int):
@@ -734,7 +731,8 @@ async def on_client_connected(ctx: Context, client: Client):
 
 def get_permissions(ctx) -> typing.Dict[str, Permission]:
     return {
-        "forfeit": Permission.from_text(ctx.forfeit_mode),
+        "forfeit": Permission.from_text(ctx.release_mode),  # TODO remove around 0.4
+        "release": Permission.from_text(ctx.release_mode),
         "remaining": Permission.from_text(ctx.remaining_mode),
         "collect": Permission.from_text(ctx.collect_mode)
     }
@@ -862,7 +860,7 @@ def update_checked_locations(ctx: Context, team: int, slot: int):
                   [{"cmd": "RoomUpdate", "checked_locations": get_checked_checks(ctx, team, slot)}])
 
 
-def forfeit_player(ctx: Context, team: int, slot: int):
+def release_player(ctx: Context, team: int, slot: int):
     """register any locations that are in the multidata"""
     all_locations = set(ctx.locations[slot])
     ctx.notify_all("%s (Team #%d) has released all remaining items from their world." % (ctx.player_names[(team, slot)], team + 1))
@@ -1228,23 +1226,19 @@ def _cmd_status(self, tag:str="") -> bool:
 
     def _cmd_release(self) -> bool:
         """Sends remaining items in your world to their recipients."""
-        return self._cmd_forfeit()
-
-    def _cmd_forfeit(self) -> bool:
-        """Surrender and send your remaining items out to their recipients. Use release in the future."""
         if self.ctx.allow_forfeits.get((self.client.team, self.client.slot), False):
-            forfeit_player(self.ctx, self.client.team, self.client.slot)
+            release_player(self.ctx, self.client.team, self.client.slot)
             return True
-        if "enabled" in self.ctx.forfeit_mode:
-            forfeit_player(self.ctx, self.client.team, self.client.slot)
+        if "enabled" in self.ctx.release_mode:
+            release_player(self.ctx, self.client.team, self.client.slot)
             return True
-        elif "disabled" in self.ctx.forfeit_mode:
+        elif "disabled" in self.ctx.release_mode:
             self.output("Sorry, client item releasing has been disabled on this server. "
                         "You can ask the server admin for a /release")
             return False
         else:  # is auto or goal
             if self.ctx.client_game_state[self.client.team, self.client.slot] == ClientStatus.CLIENT_GOAL:
-                forfeit_player(self.ctx, self.client.team, self.client.slot)
+                release_player(self.ctx, self.client.team, self.client.slot)
                 return True
             else:
                 self.output(
@@ -1872,23 +1866,18 @@ def _cmd_collect(self, player_name: str) -> bool:
 
     @mark_raw
     def _cmd_release(self, player_name: str) -> bool:
-        """Send out the remaining items from a player to their intended recipients."""
-        return self._cmd_forfeit(player_name)
-
-    @mark_raw
-    def _cmd_forfeit(self, player_name: str) -> bool:
         """Send out the remaining items from a player to their intended recipients."""
         player = self.resolve_player(player_name)
         if player:
             team, slot, _ = player
-            forfeit_player(self.ctx, team, slot)
+            release_player(self.ctx, team, slot)
             return True
 
         self.output(f"Could not find player {player_name} to release")
         return False
 
     @mark_raw
-    def _cmd_allow_forfeit(self, player_name: str) -> bool:
+    def _cmd_allow_release(self, player_name: str) -> bool:
         """Allow the specified player to use the !release command."""
         player = self.resolve_player(player_name)
         if player:
@@ -1901,7 +1890,7 @@ def _cmd_allow_forfeit(self, player_name: str) -> bool:
         return False
 
     @mark_raw
-    def _cmd_forbid_forfeit(self, player_name: str) -> bool:
+    def _cmd_forbid_release(self, player_name: str) -> bool:
         """"Disallow the specified player from using the !release command."""
         player = self.resolve_player(player_name)
         if player:
@@ -2061,7 +2050,7 @@ def attrtype(input_text: str):
                     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"}:
+            if option_name in {"forfeit_mode", "release_mode", "remaining_mode", "collect_mode"}:  # TODO remove forfeit_mode with 0.4
                 self.ctx.broadcast_all([{"cmd": "RoomUpdate", 'permissions': get_permissions(self.ctx)}])
             elif option_name in {"hint_cost", "location_check_points"}:
                 self.ctx.broadcast_all([{"cmd": "RoomUpdate", option_name: getattr(self.ctx, option_name)}])
@@ -2106,14 +2095,14 @@ def parse_args() -> argparse.Namespace:
     parser.add_argument('--location_check_points', default=defaults["location_check_points"], type=int)
     parser.add_argument('--hint_cost', default=defaults["hint_cost"], type=int)
     parser.add_argument('--disable_item_cheat', default=defaults["disable_item_cheat"], action='store_true')
-    parser.add_argument('--forfeit_mode', default=defaults["forfeit_mode"], nargs='?',
+    parser.add_argument('--release_mode', default=defaults["release_mode"], nargs='?',
                         choices=['auto', 'enabled', 'disabled', "goal", "auto-enabled"], help='''\
-                             Select !forfeit Accessibility. (default: %(default)s)
-                             auto:     Automatic "forfeit" on goal completion
-                             enabled:  !forfeit is always available
-                             disabled: !forfeit is never available
-                             goal:     !forfeit can be used after goal completion
-                             auto-enabled: !forfeit is available and automatically triggered on goal completion
+                             Select !release Accessibility. (default: %(default)s)
+                             auto:     Automatic "release" on goal completion
+                             enabled:  !release is always available
+                             disabled: !release is never available
+                             goal:     !release can be used after goal completion
+                             auto-enabled: !release 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='''\
@@ -2135,7 +2124,7 @@ def parse_args() -> argparse.Namespace:
                         help="automatically shut down the server after this many minutes without new location checks. "
                              "0 to keep running. Not yet implemented.")
     parser.add_argument('--use_embedded_options', action="store_true",
-                        help='retrieve forfeit, remaining and hint options from the multidata file,'
+                        help='retrieve release, remaining and hint options from the multidata file,'
                              ' instead of host.yaml')
     parser.add_argument('--compatibility', default=defaults["compatibility"], type=int,
                         help="""
@@ -2177,7 +2166,7 @@ async def main(args: argparse.Namespace):
     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.collect_mode,
+                  args.hint_cost, not args.disable_item_cheat, args.release_mode, args.collect_mode,
                   args.remaining_mode,
                   args.auto_shutdown, args.compatibility, args.log_network)
     data_filename = args.multidata
diff --git a/NetUtils.py b/NetUtils.py
index 513ab074fc6..d7ab7a43a1a 100644
--- a/NetUtils.py
+++ b/NetUtils.py
@@ -86,7 +86,7 @@ def _scan_for_TypedTuples(obj: typing.Any) -> typing.Any:
         data = obj._asdict()
         data["class"] = obj.__class__.__name__
         return data
-    if isinstance(obj, (tuple, list, set)):
+    if isinstance(obj, (tuple, list, set, frozenset)):
         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()}
@@ -109,7 +109,7 @@ def get_any_version(data: dict) -> Version:
     return Version(int(data["major"]), int(data["minor"]), int(data["build"]))
 
 
-whitelist = {
+allowlist = {
     "NetworkPlayer": NetworkPlayer,
     "NetworkItem": NetworkItem,
     "NetworkSlot": NetworkSlot
@@ -125,7 +125,7 @@ def _object_hook(o: typing.Any) -> typing.Any:
         hook = custom_hooks.get(o.get("class", None), None)
         if hook:
             return hook(o)
-        cls = whitelist.get(o.get("class", None), None)
+        cls = allowlist.get(o.get("class", None), None)
         if cls:
             for key in tuple(o):
                 if key not in cls._fields:
diff --git a/Options.py b/Options.py
index b386eb8e460..53bf3576309 100644
--- a/Options.py
+++ b/Options.py
@@ -133,10 +133,10 @@ def from_any(cls, data: typing.Any) -> Option[T]:
         raise NotImplementedError
 
     if typing.TYPE_CHECKING:
-        from Generate import PlandoSettings
+        from Generate import PlandoOptions
         from worlds.AutoWorld import World
 
-        def verify(self, world: World, player_name: str, plando_options: PlandoSettings) -> None:
+        def verify(self, world: World, player_name: str, plando_options: PlandoOptions) -> None:
             pass
     else:
         def verify(self, *args, **kwargs) -> None:
@@ -578,8 +578,8 @@ def valid_location_name(cls, value: str) -> bool:
     def verify(self, world, player_name: str, plando_options) -> None:
         if isinstance(self.value, int):
             return
-        from Generate import PlandoSettings
-        if not(PlandoSettings.bosses & plando_options):
+        from Generate import PlandoOptions
+        if not(PlandoOptions.bosses & plando_options):
             import logging
             # plando is disabled but plando options were given so pull the option and change it to an int
             option = self.value.split(";")[-1]
diff --git a/Utils.py b/Utils.py
index 5687465142f..51d42551047 100644
--- a/Utils.py
+++ b/Utils.py
@@ -260,7 +260,7 @@ def get_default_options() -> OptionsType:
             "disable_item_cheat": False,
             "location_check_points": 1,
             "hint_cost": 10,
-            "forfeit_mode": "goal",
+            "release_mode": "goal",
             "collect_mode": "disabled",
             "remaining_mode": "goal",
             "auto_shutdown": 0,
diff --git a/WebHost.py b/WebHost.py
index ce8443dbd9b..d098f6e7fbd 100644
--- a/WebHost.py
+++ b/WebHost.py
@@ -29,7 +29,7 @@
 def get_app():
     register()
     app = raw_app
-    if os.path.exists(configpath):
+    if os.path.exists(configpath) and not app.config["TESTING"]:
         import yaml
         app.config.from_file(configpath, yaml.safe_load)
         logging.info(f"Updated config from {configpath}")
diff --git a/WebHostLib/check.py b/WebHostLib/check.py
index 5ca44231270..b7f215da024 100644
--- a/WebHostLib/check.py
+++ b/WebHostLib/check.py
@@ -12,7 +12,7 @@ def allowed_file(filename):
     return filename.endswith(('.txt', ".yaml", ".zip"))
 
 
-from Generate import roll_settings, PlandoSettings
+from Generate import roll_settings, PlandoOptions
 from Utils import parse_yamls
 
 
@@ -69,7 +69,7 @@ def get_yaml_data(file) -> Union[Dict[str, str], str, Markup]:
 def roll_options(options: Dict[str, Union[dict, str]],
                  plando_options: Set[str] = frozenset({"bosses", "items", "connections", "texts"})) -> \
         Tuple[Dict[str, Union[str, bool]], Dict[str, dict]]:
-    plando_options = PlandoSettings.from_set(set(plando_options))
+    plando_options = PlandoOptions.from_set(set(plando_options))
     results = {}
     rolled_results = {}
     for filename, text in options.items():
diff --git a/WebHostLib/customserver.py b/WebHostLib/customserver.py
index 7e886e72a67..c445b413922 100644
--- a/WebHostLib/customserver.py
+++ b/WebHostLib/customserver.py
@@ -12,12 +12,12 @@
 import time
 
 import websockets
-from pony.orm import db_session, commit, select
+from pony.orm import commit, db_session, select
 
 import Utils
-from MultiServer import Context, server, auto_shutdown, ServerCommandProcessor, ClientMessageProcessor
-from Utils import get_public_ipv4, get_public_ipv6, restricted_loads, cache_argsless
-from .models import Room, Command, db
+from MultiServer import ClientMessageProcessor, Context, ServerCommandProcessor, auto_shutdown, server
+from Utils import cache_argsless, get_public_ipv4, get_public_ipv6, restricted_loads
+from .models import Command, Room, db
 
 
 class CustomClientMessageProcessor(ClientMessageProcessor):
@@ -66,7 +66,6 @@ def __init__(self, static_server_data: dict):
     def _load_game_data(self):
         for key, value in self.static_server_data.items():
             setattr(self, key, value)
-        self.forced_auto_forfeits = collections.defaultdict(lambda: False, self.forced_auto_forfeits)
         self.non_hintable_names = collections.defaultdict(frozenset, self.non_hintable_names)
 
     def listen_to_db_commands(self):
@@ -126,7 +125,6 @@ def get_random_port():
 def get_static_server_data() -> dict:
     import worlds
     data = {
-        "forced_auto_forfeits": {},
         "non_hintable_names": {},
         "gamespackage": worlds.network_data_package["games"],
         "item_name_groups": {world_name: world.item_name_groups for world_name, world in
@@ -134,7 +132,6 @@ def get_static_server_data() -> dict:
     }
 
     for world_name, world in worlds.AutoWorldRegister.world_types.items():
-        data["forced_auto_forfeits"][world_name] = world.forced_auto_forfeit
         data["non_hintable_names"][world_name] = world.hint_blacklist
 
     return data
diff --git a/WebHostLib/generate.py b/WebHostLib/generate.py
index 6a2c720a5d5..cbacd5153f9 100644
--- a/WebHostLib/generate.py
+++ b/WebHostLib/generate.py
@@ -12,7 +12,7 @@
 from pony.orm import commit, db_session
 
 from BaseClasses import seeddigits, get_seed
-from Generate import handle_name, PlandoSettings
+from Generate import handle_name, PlandoOptions
 from Main import main as ERmain
 from Utils import __version__
 from WebHostLib import app
@@ -33,7 +33,7 @@ def get_meta(options_source: dict) -> dict:
 
     server_options = {
         "hint_cost": int(options_source.get("hint_cost", 10)),
-        "forfeit_mode": options_source.get("forfeit_mode", "goal"),
+        "release_mode": options_source.get("release_mode", "goal"),
         "remaining_mode": options_source.get("remaining_mode", "disabled"),
         "collect_mode": options_source.get("collect_mode", "disabled"),
         "item_cheat": bool(int(options_source.get("item_cheat", 1))),
@@ -119,7 +119,7 @@ def task():
         erargs.outputname = seedname
         erargs.outputpath = target.name
         erargs.teams = 1
-        erargs.plando_options = PlandoSettings.from_set(meta.setdefault("plando_options",
+        erargs.plando_options = PlandoOptions.from_set(meta.setdefault("plando_options",
                                                                         {"bosses", "items", "connections", "texts"}))
 
         name_counter = Counter()
diff --git a/WebHostLib/misc.py b/WebHostLib/misc.py
index f78ec3926dd..aa5467d6283 100644
--- a/WebHostLib/misc.py
+++ b/WebHostLib/misc.py
@@ -69,10 +69,6 @@ def tutorial(game, file, lang):
 
 @app.route('/tutorial/')
 def tutorial_landing():
-    worlds = {}
-    for game, world in AutoWorldRegister.world_types.items():
-        if not world.hidden:
-            worlds[game] = world
     return render_template("tutorialLanding.html")
 
 
diff --git a/WebHostLib/static/assets/player-settings.js b/WebHostLib/static/assets/player-settings.js
index 0bb0c5b8dd9..5d4aaffa9d4 100644
--- a/WebHostLib/static/assets/player-settings.js
+++ b/WebHostLib/static/assets/player-settings.js
@@ -205,6 +205,11 @@ const buildOptionsTable = (settings, romOpts = false) => {
           let presetOption = document.createElement('option');
           presetOption.innerText = presetName;
           presetOption.value = settings[setting].value_names[presetName];
+          const words = presetOption.innerText.split("_");
+          for (let i = 0; i < words.length; i++) {
+            words[i] = words[i][0].toUpperCase() + words[i].substring(1);
+          }
+          presetOption.innerText = words.join(" ");
           specialRangeSelect.appendChild(presetOption);
         });
         let customOption = document.createElement('option');
diff --git a/WebHostLib/templates/generate.html b/WebHostLib/templates/generate.html
index eff42700a7e..0e5b1984455 100644
--- a/WebHostLib/templates/generate.html
+++ b/WebHostLib/templates/generate.html
@@ -40,20 +40,20 @@ <h1>Generate Game{% if race %} (Race Mode){% endif %}</h1>
                             <tbody>
                                 <tr>
                                     <td>
-                                        <label for="forfeit_mode">Forfeit Permission:
-                                            <span class="interactive" data-tooltip="A forfeit releases all remaining items from the locations in your world.">
+                                        <label for="release_mode">Release Permission:
+                                            <span class="interactive" data-tooltip="Permissions on when players are able to release all remaining items from their world.">
                                                 (?)
                                             </span>
                                         </label>
                                     </td>
                                     <td>
-                                        <select name="forfeit_mode" id="forfeit_mode">
+                                        <select name="release_mode" id="forfeit_mode">
                                             <option value="auto">Automatic on goal completion</option>
-                                            <option value="goal">Allow !forfeit after goal completion</option>
+                                            <option value="goal">Allow !release after goal completion</option>
                                             <option value="auto-enabled">
-                                                Automatic on goal completion and manual !forfeit
+                                                Automatic on goal completion and manual !release
                                             </option>
-                                            <option value="enabled">Manual !forfeit</option>
+                                            <option value="enabled">Manual !release</option>
                                             <option value="disabled">Disabled</option>
                                         </select>
                                     </td>
@@ -62,7 +62,7 @@ <h1>Generate Game{% if race %} (Race Mode){% endif %}</h1>
                                 <tr>
                                     <td>
                                         <label for="collect_mode">Collect Permission:
-                                            <span class="interactive" data-tooltip="A collect releases all of your remaining items to you from across the multiworld.">
+                                            <span class="interactive" data-tooltip="Permissions on when players are able to collect all their remaining items from across the multiworld.">
                                                 (?)
                                             </span>
                                         </label>
diff --git a/WebHostLib/templates/siteMap.html b/WebHostLib/templates/siteMap.html
index 76f1003fd77..6d1816d5fa4 100644
--- a/WebHostLib/templates/siteMap.html
+++ b/WebHostLib/templates/siteMap.html
@@ -31,14 +31,14 @@ <h2>Base Pages</h2>
 
         <h2>Game Info Pages</h2>
         <ul>
-            {% for game in games %}
+            {% for game in games | title_sorted %}
                 <li><a href="{{ url_for('game_info', game=game, lang='en') }}">{{ game }}</a></li>
             {% endfor %}
         </ul>
 
         <h2>Game Settings Pages</h2>
         <ul>
-            {% for game in games %}
+            {% for game in games | title_sorted %}
                 <li><a href="{{ url_for('player_settings', game=game) }}">{{ game }}</a></li>
             {% endfor %}
         </ul>
diff --git a/WebHostLib/tracker.py b/WebHostLib/tracker.py
index dfa17442d4d..68a40a323a0 100644
--- a/WebHostLib/tracker.py
+++ b/WebHostLib/tracker.py
@@ -650,7 +650,7 @@ def __renderOoTTracker(multisave: Dict[str, Any], room: Room, locations: Dict[in
 
     # Gather dungeon locations
     area_id_ranges = {
-        "Overworld":                ((67000, 67258), (67264, 67280), (67747, 68024), (68054, 68062)),
+        "Overworld":                ((67000, 67263), (67269, 67280), (67747, 68024), (68054, 68062)),
         "Deku Tree":                ((67281, 67303), (68063, 68077)),
         "Dodongo's Cavern":         ((67304, 67334), (68078, 68160)),
         "Jabu Jabu's Belly":        ((67335, 67359), (68161, 68188)),
@@ -662,7 +662,7 @@ def __renderOoTTracker(multisave: Dict[str, Any], room: Room, locations: Dict[in
         "Spirit Temple":            ((67533, 67582), (68566, 68625)),
         "Ice Cavern":               ((67583, 67596), (68626, 68649)),
         "Gerudo Training Ground":   ((67597, 67635), (68650, 68656)),
-        "Thieves' Hideout":         ((67259, 67263), (68025, 68053)),
+        "Thieves' Hideout":         ((67264, 67268), (68025, 68053)),
         "Ganon's Castle":           ((67636, 67673), (68657, 68705)),
     }
 
diff --git a/ZillionClient.py b/ZillionClient.py
index 1ace8774896..92585d3168a 100644
--- a/ZillionClient.py
+++ b/ZillionClient.py
@@ -48,6 +48,9 @@ class ZillionContext(CommonContext):
     command_processor: Type[ClientCommandProcessor] = ZillionCommandProcessor
     items_handling = 1  # receive items from other players
 
+    known_name: Optional[str]
+    """ This is almost the same as `auth` except `auth` is reset to `None` when server disconnects, and this isn't. """
+
     from_game: "asyncio.Queue[events.EventFromGame]"
     to_game: "asyncio.Queue[events.EventToGame]"
     ap_local_count: int
@@ -82,6 +85,7 @@ def __init__(self,
                  server_address: str,
                  password: str) -> None:
         super().__init__(server_address, password)
+        self.known_name = None
         self.from_game = asyncio.Queue()
         self.to_game = asyncio.Queue()
         self.got_room_info = asyncio.Event()
@@ -396,7 +400,8 @@ def log_no_spam(msg: str) -> None:
             game_id = memory.get_rom_to_ram_data(ram)
             name, seed_end = name_seed_from_ram(game_id)
             if len(name):
-                if name == ctx.auth:
+                if name == ctx.known_name:
+                    ctx.auth = name
                     # this is the name we know
                     if ctx.server and ctx.server.socket:  # type: ignore
                         if ctx.got_room_info.is_set():
@@ -439,6 +444,7 @@ def log_no_spam(msg: str) -> None:
                     memory.reset_game_state()
 
                     ctx.auth = name
+                    ctx.known_name = name
                     async_start(ctx.connect())
                     await asyncio.wait((
                         ctx.got_room_info.wait(),
diff --git a/docs/code_of_conduct.md b/docs/code_of_conduct.md
index dd3d154a029..d3a5fe2ea2d 100644
--- a/docs/code_of_conduct.md
+++ b/docs/code_of_conduct.md
@@ -8,4 +8,4 @@ We conduct ourselves openly and inclusively here. Please do not contribute to an
 
 These guidelines apply to all channels of communication within this GitHub repository. Please be respectful in both public channels, such as issues, and private ones, such as private messaging or emails.
 
-Any incidents of abuse may be reported directly to ijwu at hmfarran@gmail.com.
+Any incidents of abuse may be reported directly to eudaimonistic at eudaimonistic42@gmail.com
diff --git a/host.yaml b/host.yaml
index d1b0b7865b6..ce242fd4c9b 100644
--- a/host.yaml
+++ b/host.yaml
@@ -22,14 +22,14 @@ server_options:
   # Relative point cost to receive a hint via !hint for players
   # so for example hint_cost: 20 would mean that for every 20% of available checks, you get the ability to hint, for a total of 5
   hint_cost: 10 # Set to 0 if you want free hints
-  # Forfeit modes
-  # A Forfeit sends out the remaining items *from* a world that forfeits
-  # "disabled" -> clients can't forfeit,
-  # "enabled" -> clients can always forfeit
-  # "auto" -> automatic forfeit on goal completion
-  # "auto-enabled" -> automatic forfeit on goal completion and manual forfeit is also enabled
-  # "goal" -> forfeit is allowed after goal completion
-  forfeit_mode: "goal"
+  # Release modes
+  # A Release sends out the remaining items *from* a world that releases
+  # "disabled" -> clients can't release,
+  # "enabled" -> clients can always release
+  # "auto" -> automatic release on goal completion
+  # "auto-enabled" -> automatic release on goal completion and manual release is also enabled
+  # "goal" -> release is allowed after goal completion
+  release_mode: "goal"
   # Collect modes
   # A Collect sends the remaining items *to* a world that collects
   # "disabled" -> clients can't collect,
diff --git a/playerSettings.yaml b/playerSettings.yaml
index ee671862f04..e28963ddb34 100644
--- a/playerSettings.yaml
+++ b/playerSettings.yaml
@@ -27,17 +27,62 @@ game: # Pick a game to play
   A Link to the Past: 1
 requires:
   version: 0.3.3 # 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: # A system to reduce BK, as in times during which you can't do anything, by moving your items into an earlier access sphere
-  0: 0 # Choose a lower number if you don't mind a longer multiworld, or can glitch/sequence break around missing items.
-  25: 0
-  50: 50 # Make it likely you have stuff to do.
-  99: 0 # Get important items early, and stay at the front of the progression.
 A Link to the Past:
+  progression_balancing:
+    # A system that can move progression earlier, to try and prevent the player from getting stuck and bored early.
+    # A lower setting means more getting stuck. A higher setting means less getting stuck.
+    #
+    # You can define additional values between the minimum and maximum values.
+    # Minimum value is 0
+    # Maximum value is 99
+    random: 0
+    random-low: 0
+    random-high: 0
+    disabled: 0 # equivalent to 0
+    normal: 50 # equivalent to 50
+    extreme: 0 # equivalent to 99
+
+  accessibility:
+    # 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.
+    locations: 0
+    items: 50
+    minimal: 0
+
+  local_items:
+    # Forces these items to be in their native world.
+    [ ]
+
+  non_local_items:
+    # Forces these items to be outside their native world.
+    [ ]
+
+  start_inventory:
+    # Start with these items.
+    { }
+
+  start_hints:
+    # Start with these item's locations prefilled into the !hint command.
+    [ ]
+
+  start_location_hints:
+    # Start with these locations and their item prefilled into the !hint command
+    [ ]
+
+  exclude_locations:
+    # Prevent these locations from having an important item
+    [ ]
+
+  priority_locations:
+    # Prevent these locations from having an unimportant item
+    [ ]
+
+  item_links:
+    # Share part of your item pool with other players.
+    [ ]
+
   ### Logic Section ###
   glitches_required: # Determine the logic required to complete the seed
     none: 50 # No glitches required
diff --git a/setup.py b/setup.py
index e60753d2dae..3b3ea56269c 100644
--- a/setup.py
+++ b/setup.py
@@ -16,6 +16,7 @@
 from Launcher import components, icon_paths
 from Utils import version_tuple, is_windows, is_linux
 
+# On  Python < 3.10 LogicMixin is not currently supported.
 apworlds: set = {
     "Subnautica",
     "Factorio",
diff --git a/test/TestBase.py b/test/TestBase.py
index 8a17232bd1f..5ffcb5ce4dc 100644
--- a/test/TestBase.py
+++ b/test/TestBase.py
@@ -169,6 +169,9 @@ def remove(self, items: typing.Union[Item, typing.Iterable[Item]]) -> None:
     def can_reach_location(self, location: str) -> bool:
         return self.multiworld.state.can_reach(location, "Location", 1)
 
+    def can_reach_entrance(self, entrance: str) -> bool:
+        return self.multiworld.state.can_reach(entrance, "Entrance", 1)
+
     def count(self, item_name: str) -> int:
         return self.multiworld.state.count(item_name, 1)
 
diff --git a/test/general/TestItems.py b/test/general/TestItems.py
index cee95b71189..c962d572b35 100644
--- a/test/general/TestItems.py
+++ b/test/general/TestItems.py
@@ -33,6 +33,14 @@ def testItemNameGroupHasValidItem(self):
                             for item in items:
                                 self.assertIn(item, world_type.item_name_to_id)
 
+    def testItemNameGroupConflict(self):
+        """Test that all item name groups aren't also item names."""
+        for game_name, world_type in AutoWorldRegister.world_types.items():
+            with self.subTest(game_name, game_name=game_name):
+                for group_name in world_type.item_name_groups:
+                    with self.subTest(group_name, group_name=group_name):
+                        self.assertNotIn(group_name, world_type.item_name_to_id)
+
     def testItemCountGreaterEqualLocations(self):
         for game_name, world_type in AutoWorldRegister.world_types.items():
 
diff --git a/test/general/TestLocations.py b/test/general/TestLocations.py
new file mode 100644
index 00000000000..f08939bc0c3
--- /dev/null
+++ b/test/general/TestLocations.py
@@ -0,0 +1,16 @@
+import unittest
+from collections import Counter
+from worlds.AutoWorld import AutoWorldRegister
+from . import setup_default_world
+
+
+class TestBase(unittest.TestCase):
+    def testCreateDuplicateLocations(self):
+        for game_name, world_type in AutoWorldRegister.world_types.items():
+            if game_name in {"Final Fantasy"}:
+                continue
+            multiworld = setup_default_world(world_type)
+            locations = Counter(multiworld.get_locations())
+            if locations:
+                self.assertLessEqual(locations.most_common(1)[0][1], 1,
+                                     f"{world_type.game} has duplicate of location {locations.most_common(1)}")
diff --git a/test/webhost/TestAPIGenerate.py b/test/webhost/TestAPIGenerate.py
index e50bf96e19a..5c14373a90e 100644
--- a/test/webhost/TestAPIGenerate.py
+++ b/test/webhost/TestAPIGenerate.py
@@ -11,10 +11,11 @@ def setUpClass(cls) -> None:
             "filename": ":memory:",
             "create_db": True,
         }
-        app = get_app()
-        app.config.update({
+        raw_app.config.update({
             "TESTING": True,
         })
+        app = get_app()
+
         cls.client = app.test_client()
 
     def testCorrectErrorEmptyRequest(self):
diff --git a/worlds/AutoWorld.py b/worlds/AutoWorld.py
index 9064684a211..8d1619b8b59 100644
--- a/worlds/AutoWorld.py
+++ b/worlds/AutoWorld.py
@@ -109,10 +109,10 @@ def call_stage(multiworld: "MultiWorld", method_name: str, *args: Any) -> None:
 
 class WebWorld:
     """Webhost integration"""
-    
+
     settings_page: Union[bool, str] = True
     """display a settings page. Can be a link to a specific page or external tool."""
-    
+
     game_info_languages: List[str] = ['en']
     """docs folder will be scanned for game info pages using this list in the format '{language}_{game_name}.md'"""
 
@@ -160,10 +160,6 @@ class World(metaclass=AutoWorldRegister):
 
     hint_blacklist: ClassVar[FrozenSet[str]] = frozenset()  # any names that should not be hintable
 
-    # For games where after a victory it is impossible to go back in and get additional/remaining Locations checked.
-    # this forces forfeit:  auto for those games.
-    forced_auto_forfeit: bool = False
-
     # Hide World Type from various views. Does not remove functionality.
     hidden: ClassVar[bool] = False
 
diff --git a/worlds/__init__.py b/worlds/__init__.py
index f0a56d4b556..34dece0e40f 100644
--- a/worlds/__init__.py
+++ b/worlds/__init__.py
@@ -52,14 +52,20 @@ class WorldSource(typing.NamedTuple):
 for world_source in world_sources:
     if world_source.is_zip:
         importer = zipimport.zipimporter(os.path.join(folder, world_source.path))
-        spec = importer.find_spec(world_source.path.split(".", 1)[0])
-        mod = importlib.util.module_from_spec(spec)
+        if hasattr(importer, "find_spec"):  # new in Python 3.10
+            spec = importer.find_spec(world_source.path.split(".", 1)[0])
+            mod = importlib.util.module_from_spec(spec)
+        else:  # TODO: remove with 3.8 support
+            mod = importer.load_module(world_source.path.split(".", 1)[0])
+
         mod.__package__ = f"worlds.{mod.__package__}"
         mod.__name__ = f"worlds.{mod.__name__}"
         sys.modules[mod.__name__] = mod
         with warnings.catch_warnings():
             warnings.filterwarnings("ignore", message="__package__ != __spec__.parent")
-            importer.exec_module(mod)
+            # Found no equivalent for < 3.10
+            if hasattr(importer, "exec_module"):
+                importer.exec_module(mod)
     else:
         importlib.import_module(f".{world_source.path}", "worlds")
 
diff --git a/worlds/alttp/Client.py b/worlds/alttp/Client.py
index b3a12a7ff87..3484355db5f 100644
--- a/worlds/alttp/Client.py
+++ b/worlds/alttp/Client.py
@@ -322,7 +322,7 @@
 location_table_misc_id = {Regions.lookup_name_to_id[name]: data for name, data in location_table_misc.items()}
 
 
-async def track_locations(ctx, roomid, roomdata):
+async def track_locations(ctx, roomid, roomdata) -> bool:
     from SNIClient import snes_read, snes_buffered_write, snes_flush_writes
     new_locations = []
 
@@ -451,10 +451,126 @@ def new_check(location_id):
             if misc_data_changed:
                 snes_buffered_write(ctx, SAVEDATA_START + 0x3c6, bytes(misc_data))
 
-
     if new_locations:
-        await ctx.send_msgs([{"cmd": 'LocationChecks', "locations": new_locations}])
+        # verify rom is still the same:
+        rom_name = await snes_read(ctx, ROMNAME_START, ROMNAME_SIZE)
+        if rom_name is None or all(byte == b"\x00" for byte in rom_name) or rom_name[:2] != b"AP" or \
+                rom_name != ctx.rom:
+            snes_logger.info(f"Discarding recent {len(new_locations)} checks as ROM Status has changed.")
+            return False
+        else:
+            await ctx.send_msgs([{"cmd": 'LocationChecks', "locations": new_locations}])
     await snes_flush_writes(ctx)
+    return True
+
+
+class ALTTPSNIClient(SNIClient):
+    game = "A Link to the Past"
+
+    async def deathlink_kill_player(self, ctx):
+        from SNIClient import DeathState, snes_read, snes_buffered_write, snes_flush_writes
+        invincible = await snes_read(ctx, WRAM_START + 0x037B, 1)
+        last_health = await snes_read(ctx, WRAM_START + 0xF36D, 1)
+        await asyncio.sleep(0.25)
+        health = await snes_read(ctx, WRAM_START + 0xF36D, 1)
+        if not invincible or not last_health or not health:
+            ctx.death_state = DeathState.dead
+            ctx.last_death_link = time.time()
+            return
+        if not invincible[0] and last_health[0] == health[0]:
+            snes_buffered_write(ctx, WRAM_START + 0xF36D, bytes([0]))  # set current health to 0
+            snes_buffered_write(ctx, WRAM_START + 0x0373,
+                                bytes([8]))  # deal 1 full heart of damage at next opportunity
+
+        await snes_flush_writes(ctx)
+        await asyncio.sleep(1)
+
+        gamemode = await snes_read(ctx, WRAM_START + 0x10, 1)
+        if not gamemode or gamemode[0] in DEATH_MODES:
+            ctx.death_state = DeathState.dead
+
+    async def validate_rom(self, ctx) -> bool:
+        from SNIClient import snes_read
+
+        rom_name = await snes_read(ctx, ROMNAME_START, ROMNAME_SIZE)
+        if rom_name is None or all(byte == b"\x00" for byte in rom_name) or rom_name[:2] != b"AP":
+            return False
+
+        ctx.game = self.game
+        ctx.items_handling = 0b001  # full local
+
+        ctx.rom = rom_name
+
+        death_link = await snes_read(ctx, DEATH_LINK_ACTIVE_ADDR, 1)
+
+        if death_link:
+            ctx.allow_collect = bool(death_link[0] & 0b100)
+            ctx.death_link_allow_survive = bool(death_link[0] & 0b10)
+            await ctx.update_death_link(bool(death_link[0] & 0b1))
+
+        return True
+
+    async def game_watcher(self, ctx):
+        from SNIClient import snes_read, snes_buffered_write, snes_flush_writes
+        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)
+
+        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):
+            return
+
+        if gameend[0]:
+            if not ctx.finished_game:
+                await ctx.send_msgs([{"cmd": "StatusUpdate", "status": ClientStatus.CLIENT_GOAL}])
+                ctx.finished_game = True
+
+        if gamemode in ENDGAME_MODES:  # triforce room and credits
+            return
+
+        data = await snes_read(ctx, RECV_PROGRESS_ADDR, 8)
+        if data is None:
+            return
+
+        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_names[item.item], 'red', 'bold'),
+                color(ctx.player_names[item.player], 'yellow'),
+                ctx.location_names[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].item]))
+            snes_buffered_write(ctx, SCOUTREPLY_PLAYER_ADDR,
+                                bytes([min(ROM_PLAYER_LIMIT, ctx.locations_info[scout_location].player)]))
+
+        await snes_flush_writes(ctx)
+
+        if scout_location > 0 and scout_location not in ctx.locations_scouted:
+            ctx.locations_scouted.add(scout_location)
+            await ctx.send_msgs([{"cmd": "LocationScouts", "locations": [scout_location]}])
+        same_rom = await track_locations(ctx, roomid, roomdata)
+        if not same_rom:
+            return
 
 
 def get_alttp_settings(romfile: str):
@@ -582,112 +698,3 @@ def onButtonClick(answer: str = 'no'):
     else:
         adjusted = False
     return adjustedromfile, adjusted
-
-
-class ALTTPSNIClient(SNIClient):
-    game = "A Link to the Past"
-
-    async def deathlink_kill_player(self, ctx):
-        from SNIClient import DeathState, snes_read, snes_buffered_write, snes_flush_writes
-        invincible = await snes_read(ctx, WRAM_START + 0x037B, 1)
-        last_health = await snes_read(ctx, WRAM_START + 0xF36D, 1)
-        await asyncio.sleep(0.25)
-        health = await snes_read(ctx, WRAM_START + 0xF36D, 1)
-        if not invincible or not last_health or not health:
-            ctx.death_state = DeathState.dead
-            ctx.last_death_link = time.time()
-            return
-        if not invincible[0] and last_health[0] == health[0]:
-            snes_buffered_write(ctx, WRAM_START + 0xF36D, bytes([0]))  # set current health to 0
-            snes_buffered_write(ctx, WRAM_START + 0x0373,
-                                bytes([8]))  # deal 1 full heart of damage at next opportunity
-
-        await snes_flush_writes(ctx)
-        await asyncio.sleep(1)
-
-        gamemode = await snes_read(ctx, WRAM_START + 0x10, 1)
-        if not gamemode or gamemode[0] in DEATH_MODES:
-            ctx.death_state = DeathState.dead
-
-
-    async def validate_rom(self, ctx):
-        from SNIClient import snes_read, snes_buffered_write, snes_flush_writes
-
-        rom_name = await snes_read(ctx, ROMNAME_START, ROMNAME_SIZE)
-        if rom_name is None or rom_name == bytes([0] * ROMNAME_SIZE) or rom_name[:2] != b"AP":
-            return False
-
-        ctx.game = self.game
-        ctx.items_handling = 0b001  # full local
-
-        ctx.rom = rom_name
-
-        death_link = await snes_read(ctx, DEATH_LINK_ACTIVE_ADDR, 1)
-
-        if death_link:
-            ctx.allow_collect = bool(death_link[0] & 0b100)
-            ctx.death_link_allow_survive = bool(death_link[0] & 0b10)
-            await ctx.update_death_link(bool(death_link[0] & 0b1))
-
-        return True
-
-
-    async def game_watcher(self, ctx):
-        from SNIClient import snes_read, snes_buffered_write, snes_flush_writes
-        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)
-
-        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):
-            return
-
-        if gameend[0]:
-            if not ctx.finished_game:
-                await ctx.send_msgs([{"cmd": "StatusUpdate", "status": ClientStatus.CLIENT_GOAL}])
-                ctx.finished_game = True
-
-        if gamemode in ENDGAME_MODES:  # triforce room and credits
-            return
-
-        data = await snes_read(ctx, RECV_PROGRESS_ADDR, 8)
-        if data is None:
-            return
-
-        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_names[item.item], 'red', 'bold'),
-                color(ctx.player_names[item.player], 'yellow'),
-                ctx.location_names[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].item]))
-            snes_buffered_write(ctx, SCOUTREPLY_PLAYER_ADDR,
-                                bytes([min(ROM_PLAYER_LIMIT, ctx.locations_info[scout_location].player)]))
-
-        await snes_flush_writes(ctx)
-
-        if scout_location > 0 and scout_location not in ctx.locations_scouted:
-            ctx.locations_scouted.add(scout_location)
-            await ctx.send_msgs([{"cmd": "LocationScouts", "locations": [scout_location]}])
-        await track_locations(ctx, roomid, roomdata)
diff --git a/worlds/alttp/ItemPool.py b/worlds/alttp/ItemPool.py
index 724f66dc0cc..bc1ae6fbbe6 100644
--- a/worlds/alttp/ItemPool.py
+++ b/worlds/alttp/ItemPool.py
@@ -3,7 +3,7 @@
 
 from BaseClasses import Region, RegionType, ItemClassification
 from worlds.alttp.SubClasses import ALttPLocation
-from worlds.alttp.Shops import TakeAny, total_shop_slots, set_up_shops, shuffle_shops
+from worlds.alttp.Shops import TakeAny, total_shop_slots, set_up_shops, shuffle_shops, create_dynamic_shop_locations
 from worlds.alttp.Bosses import place_bosses
 from worlds.alttp.Dungeons import get_dungeon_item_pool_player
 from worlds.alttp.EntranceShuffle import connect_entrance
@@ -436,12 +436,13 @@ def generate_itempool(world):
 
     if world.shop_shuffle[player]:
         shuffle_shops(world, nonprogressionitems, player)
-    create_dynamic_shop_locations(world, player)
 
     world.itempool += progressionitems + nonprogressionitems
 
     if world.retro_caves[player]:
         set_up_take_anys(world, player)  # depends on world.itempool to be set
+    # set_up_take_anys needs to run first
+    create_dynamic_shop_locations(world, player)
 
 
 take_any_locations = {
@@ -487,7 +488,7 @@ def set_up_take_anys(world, player):
         world.itempool.append(ItemFactory('Rupees (20)', player))
         old_man_take_any.shop.add_inventory(0, sword.name, 0, 0, create_location=True)
     else:
-        old_man_take_any.shop.add_inventory(0, 'Rupees (300)', 0, 0)
+        old_man_take_any.shop.add_inventory(0, 'Rupees (300)', 0, 0, create_location=True)
 
     for num in range(4):
         take_any = Region("Take-Any #{}".format(num+1), RegionType.Cave, 'a cave of choice', player)
@@ -501,29 +502,11 @@ def set_up_take_anys(world, player):
         take_any.shop = TakeAny(take_any, room_id, 0xE3, True, True, total_shop_slots + num + 1)
         world.shops.append(take_any.shop)
         take_any.shop.add_inventory(0, 'Blue Potion', 0, 0)
-        take_any.shop.add_inventory(1, 'Boss Heart Container', 0, 0)
+        take_any.shop.add_inventory(1, 'Boss Heart Container', 0, 0, create_location=True)
 
     world.initialize_regions()
 
 
-def create_dynamic_shop_locations(world, player):
-    for shop in world.shops:
-        if shop.region.player == player:
-            for i, item in enumerate(shop.inventory):
-                if item is None:
-                    continue
-                if item['create_location']:
-                    loc = ALttPLocation(player, f"{shop.region.name} {shop.slot_names[i]}", parent=shop.region)
-                    shop.region.locations.append(loc)
-
-                    world.clear_location_cache()
-
-                    world.push_item(loc, ItemFactory(item['item'], player), False)
-                    loc.shop_slot = i
-                    loc.event = True
-                    loc.locked = True
-
-
 def get_pool_core(world, player: int):
     shuffle = world.shuffle[player]
     difficulty = world.difficulty[player]
diff --git a/worlds/alttp/Items.py b/worlds/alttp/Items.py
index 3663db5cf4f..caa916ca1da 100644
--- a/worlds/alttp/Items.py
+++ b/worlds/alttp/Items.py
@@ -20,7 +20,7 @@ def GetBeemizerItem(world, player: int, item):
 
 
 # should be replaced with direct world.create_item(item) call in the future
-def ItemFactory(items, player: int):
+def ItemFactory(items: typing.Union[str, typing.Iterable[str]], player: int):
     from worlds.alttp import ALTTPWorld
     world = ALTTPWorld(None, player)
     ret = []
diff --git a/worlds/alttp/Regions.py b/worlds/alttp/Regions.py
index 5f8bd0a43d8..f680c3edb13 100644
--- a/worlds/alttp/Regions.py
+++ b/worlds/alttp/Regions.py
@@ -686,142 +686,296 @@ def mark_light_world_regions(world, player: int):
 lookup_name_to_id = {**lookup_name_to_id, **{name: data[1] for name, data in key_drop_data.items()}}
 lookup_name_to_id.update(shop_table_by_location)
 
-lookup_vanilla_location_to_entrance = {1572883: 'Kings Grave Inner Rocks', 191256: 'Kings Grave Inner Rocks',
-                                       1573194: 'Kings Grave Inner Rocks', 1573189: 'Kings Grave Inner Rocks',
-                                       212328: 'Kings Grave Inner Rocks', 60175: 'Blinds Hideout',
-                                       60178: 'Blinds Hideout', 60181: 'Blinds Hideout', 60184: 'Blinds Hideout',
-                                       60187: 'Blinds Hideout', 188229: 'Hyrule Castle Secret Entrance Drop',
-                                       59761: 'Hyrule Castle Secret Entrance Drop', 975299: 'Zoras River',
-                                       1573193: 'Zoras River', 59824: 'Waterfall of Wishing',
-                                       59857: 'Waterfall of Wishing', 59770: 'Kings Grave', 59788: 'Dam',
-                                       59836: 'Links House', 59854: 'Tavern North', 59881: 'Chicken House',
-                                       59890: 'Aginahs Cave', 60034: 'Sahasrahlas Hut', 60037: 'Sahasrahlas Hut',
-                                       60040: 'Sahasrahlas Hut', 193020: 'Sahasrahlas Hut',
-                                       60046: 'Kakariko Well Drop', 60049: 'Kakariko Well Drop',
-                                       60052: 'Kakariko Well Drop', 60055: 'Kakariko Well Drop',
-                                       60058: 'Kakariko Well Drop', 1572906: 'Blacksmiths Hut',
-                                       1572885: 'Bat Cave Drop', 211407: 'Sick Kids House',
-                                       212605: 'Hobo Bridge', 1572864: 'Lost Woods Hideout Drop',
-                                       1572865: 'Lumberjack Tree Tree', 1572867: 'Cave 45',
-                                       1572868: 'Graveyard Cave', 1572869: 'Checkerboard Cave',
-                                       60226: 'Mini Moldorm Cave', 60229: 'Mini Moldorm Cave',
-                                       60232: 'Mini Moldorm Cave', 60235: 'Mini Moldorm Cave',
-                                       1572880: 'Mini Moldorm Cave', 60238: 'Ice Rod Cave',
-                                       60223: 'Bonk Rock Cave', 1572882: 'Library', 1572884: 'Potion Shop',
-                                       1573188: 'Lake Hylia Island Mirror Spot',
-                                       1573186: 'Maze Race Mirror Spot', 1573187: 'Desert Ledge Return Rocks',
-                                       59791: 'Desert Palace Entrance (West)',
-                                       1573216: 'Desert Palace Entrance (West)',
-                                       59830: 'Desert Palace Entrance (West)',
-                                       59851: 'Desert Palace Entrance (West)',
-                                       59842: 'Desert Palace Entrance (West)',
-                                       1573201: 'Desert Palace Entrance (North)', 59767: 'Eastern Palace',
-                                       59773: 'Eastern Palace', 59827: 'Eastern Palace', 59833: 'Eastern Palace',
-                                       59893: 'Eastern Palace', 1573200: 'Eastern Palace',
-                                       166320: 'Master Sword Meadow', 59764: 'Hyrule Castle Entrance (South)',
-                                       60172: 'Hyrule Castle Entrance (South)',
-                                       60169: 'Hyrule Castle Entrance (South)',
-                                       59758: 'Hyrule Castle Entrance (South)',
-                                       60253: 'Hyrule Castle Entrance (South)',
-                                       60256: 'Hyrule Castle Entrance (South)',
-                                       60259: 'Hyrule Castle Entrance (South)', 60025: 'Sanctuary S&Q',
-                                       60085: 'Agahnims Tower', 60082: 'Agahnims Tower',
-                                       1010170: 'Old Man Cave (West)', 1572866: 'Spectacle Rock Cave',
-                                       60202: 'Paradox Cave (Bottom)', 60205: 'Paradox Cave (Bottom)',
-                                       60208: 'Paradox Cave (Bottom)', 60211: 'Paradox Cave (Bottom)',
-                                       60214: 'Paradox Cave (Bottom)', 60217: 'Paradox Cave (Bottom)',
-                                       60220: 'Paradox Cave (Bottom)', 59839: 'Spiral Cave',
-                                       1572886: 'Death Mountain (Top)', 1573184: 'Spectacle Rock Mirror Spot',
-                                       1573218: 'Tower of Hera', 59821: 'Tower of Hera', 59878: 'Tower of Hera',
-                                       59899: 'Tower of Hera', 59896: 'Tower of Hera', 1573202: 'Tower of Hera',
-                                       1573191: 'Top of Pyramid', 975237: 'Catfish Entrance Rock',
-                                       209095: 'South Dark World Bridge', 1573192: 'South Dark World Bridge',
-                                       1572887: 'Bombos Tablet Mirror Spot', 60190: 'Hype Cave',
-                                       60193: 'Hype Cave', 60196: 'Hype Cave', 60199: 'Hype Cave',
-                                       1572881: 'Hype Cave', 1572870: 'Dark World Hammer Peg Cave',
-                                       59776: 'Pyramid Fairy', 59779: 'Pyramid Fairy', 59884: 'Brewery',
-                                       59887: 'C-Shaped House', 60840: 'Chest Game',
-                                       1573190: 'Bumper Cave (Bottom)', 60019: 'Mire Shed', 60022: 'Mire Shed',
-                                       60028: 'Superbunny Cave (Top)', 60031: 'Superbunny Cave (Top)',
-                                       60043: 'Spike Cave', 60241: 'Hookshot Cave', 60244: 'Hookshot Cave',
-                                       60250: 'Hookshot Cave', 60247: 'Hookshot Cave',
-                                       1573185: 'Floating Island Mirror Spot', 59845: 'Mimic Cave',
-                                       60061: 'Swamp Palace', 59782: 'Swamp Palace', 59785: 'Swamp Palace',
-                                       60064: 'Swamp Palace', 60070: 'Swamp Palace', 60067: 'Swamp Palace',
-                                       60073: 'Swamp Palace', 60076: 'Swamp Palace', 60079: 'Swamp Palace',
-                                       1573204: 'Swamp Palace', 59908: 'Thieves Town', 59905: 'Thieves Town',
-                                       59911: 'Thieves Town', 59914: 'Thieves Town', 59917: 'Thieves Town',
-                                       59920: 'Thieves Town', 59923: 'Thieves Town', 1573206: 'Thieves Town',
-                                       59803: 'Skull Woods First Section Door',
-                                       59848: 'Skull Woods First Section Hole (East)',
-                                       59794: 'Skull Woods First Section Hole (West)',
-                                       59809: 'Skull Woods First Section Hole (West)',
-                                       59800: 'Skull Woods First Section Hole (North)',
-                                       59806: 'Skull Woods Second Section Door (East)',
-                                       59902: 'Skull Woods Final Section', 1573205: 'Skull Woods Final Section',
-                                       59860: 'Ice Palace', 59797: 'Ice Palace', 59818: 'Ice Palace',
-                                       59875: 'Ice Palace', 59872: 'Ice Palace', 59812: 'Ice Palace',
-                                       59869: 'Ice Palace', 1573207: 'Ice Palace', 60007: 'Misery Mire',
-                                       60010: 'Misery Mire', 59998: 'Misery Mire', 60001: 'Misery Mire',
-                                       59866: 'Misery Mire', 60004: 'Misery Mire', 60013: 'Misery Mire',
-                                       1573208: 'Misery Mire', 59938: 'Turtle Rock', 59932: 'Turtle Rock',
-                                       59935: 'Turtle Rock', 59926: 'Turtle Rock',
-                                       59941: 'Dark Death Mountain Ledge (West)',
-                                       59929: 'Dark Death Mountain Ledge (East)',
-                                       59956: 'Dark Death Mountain Ledge (West)',
-                                       59953: 'Turtle Rock Isolated Ledge Entrance',
-                                       59950: 'Turtle Rock Isolated Ledge Entrance',
-                                       59947: 'Turtle Rock Isolated Ledge Entrance',
-                                       59944: 'Turtle Rock Isolated Ledge Entrance',
-                                       1573209: 'Turtle Rock Isolated Ledge Entrance',
-                                       59995: 'Palace of Darkness', 59965: 'Palace of Darkness',
-                                       59977: 'Palace of Darkness', 59959: 'Palace of Darkness',
-                                       59962: 'Palace of Darkness', 59986: 'Palace of Darkness',
-                                       59971: 'Palace of Darkness', 59980: 'Palace of Darkness',
-                                       59983: 'Palace of Darkness', 59989: 'Palace of Darkness',
-                                       59992: 'Palace of Darkness', 59968: 'Palace of Darkness',
-                                       59974: 'Palace of Darkness', 1573203: 'Palace of Darkness',
-                                       1573217: 'Ganons Tower', 60121: 'Ganons Tower', 60124: 'Ganons Tower',
-                                       60130: 'Ganons Tower', 60133: 'Ganons Tower', 60136: 'Ganons Tower',
-                                       60139: 'Ganons Tower', 60142: 'Ganons Tower', 60088: 'Ganons Tower',
-                                       60091: 'Ganons Tower', 60094: 'Ganons Tower', 60097: 'Ganons Tower',
-                                       60115: 'Ganons Tower', 60112: 'Ganons Tower', 60100: 'Ganons Tower',
-                                       60103: 'Ganons Tower', 60106: 'Ganons Tower', 60109: 'Ganons Tower',
-                                       60127: 'Ganons Tower', 60118: 'Ganons Tower', 60148: 'Ganons Tower',
-                                       60151: 'Ganons Tower', 60145: 'Ganons Tower', 60157: 'Ganons Tower',
-                                       60160: 'Ganons Tower', 60163: 'Ganons Tower', 60166: 'Ganons Tower',
-                                       0x140037: 'Hyrule Castle Entrance (South)',
-                                       0x140034: 'Hyrule Castle Entrance (South)',
-                                       0x14000d: 'Hyrule Castle Entrance (South)',
-                                       0x14003d: 'Hyrule Castle Entrance (South)',
-                                       0x14005b: 'Eastern Palace', 0x140049: 'Eastern Palace',
-                                       0x140031: 'Desert Palace Entrance (North)',
-                                       0x14002b: 'Desert Palace Entrance (North)',
-                                       0x140028: 'Desert Palace Entrance (North)',
-                                       0x140061: 'Agahnims Tower', 0x140052: 'Agahnims Tower',
-                                       0x140019: 'Swamp Palace', 0x140016: 'Swamp Palace', 0x140013: 'Swamp Palace',
-                                       0x140010: 'Swamp Palace', 0x14000a: 'Swamp Palace',
-                                       0x14002e: 'Skull Woods Second Section Door (East)',
-                                       0x14001c: 'Skull Woods Final Section',
-                                       0x14005e: 'Thieves Town', 0x14004f: 'Thieves Town',
-                                       0x140004: 'Ice Palace', 0x140022: 'Ice Palace',
-                                       0x140025: 'Ice Palace', 0x140046: 'Ice Palace',
-                                       0x140055: 'Misery Mire', 0x14004c: 'Misery Mire',
-                                       0x140064: 'Misery Mire',
-                                       0x140058: 'Turtle Rock', 0x140007: 'Dark Death Mountain Ledge (West)',
-                                       0x140040: 'Ganons Tower', 0x140043: 'Ganons Tower',
-                                       0x14003a: 'Ganons Tower', 0x14001f: 'Ganons Tower',
-                                       0x400000: 'Cave Shop (Dark Death Mountain)', 0x400001: 'Cave Shop (Dark Death Mountain)', 0x400002: 'Cave Shop (Dark Death Mountain)',
-                                       0x400003: 'Red Shield Shop', 0x400004: 'Red Shield Shop', 0x400005: 'Red Shield Shop',
-                                       0x400006: 'Dark Lake Hylia Shop', 0x400007: 'Dark Lake Hylia Shop', 0x400008: 'Dark Lake Hylia Shop',
-                                       0x400009: 'Dark World Lumberjack Shop', 0x40000a: 'Dark World Lumberjack Shop', 0x40000b: 'Dark World Lumberjack Shop',
-                                       0x40000c: 'Village of Outcasts Shop', 0x40000d: 'Village of Outcasts Shop', 0x40000e: 'Village of Outcasts Shop',
-                                       0x40000f: 'Dark World Potion Shop', 0x400010: 'Dark World Potion Shop', 0x400011: 'Dark World Potion Shop',
-                                       0x400012: 'Light World Death Mountain Shop', 0x400013: 'Light World Death Mountain Shop', 0x400014: 'Light World Death Mountain Shop',
-                                       0x400015: 'Kakariko Shop', 0x400016: 'Kakariko Shop', 0x400017: 'Kakariko Shop',
-                                       0x400018: 'Cave Shop (Lake Hylia)', 0x400019: 'Cave Shop (Lake Hylia)', 0x40001a: 'Cave Shop (Lake Hylia)',
-                                       0x40001b: 'Potion Shop', 0x40001c: 'Potion Shop', 0x40001d: 'Potion Shop',
-                                       0x40001e: 'Capacity Upgrade', 0x40001f: 'Capacity Upgrade', 0x400020: 'Capacity Upgrade'}
+lookup_vanilla_location_to_entrance = {
+    59758: 'Hyrule Castle Entrance (South)',
+    59761: 'Hyrule Castle Secret Entrance Drop',
+    59764: 'Hyrule Castle Entrance (South)',
+    59767: 'Eastern Palace',
+    59770: 'Kings Grave',
+    59773: 'Eastern Palace',
+    59776: 'Pyramid Fairy',
+    59779: 'Pyramid Fairy',
+    59782: 'Swamp Palace',
+    59785: 'Swamp Palace',
+    59788: 'Dam',
+    59791: 'Desert Palace Entrance (West)',
+    59794: 'Skull Woods First Section Hole (West)',
+    59797: 'Ice Palace',
+    59800: 'Skull Woods First Section Hole (North)',
+    59803: 'Skull Woods First Section Door',
+    59806: 'Skull Woods Second Section Door (East)',
+    59809: 'Skull Woods First Section Hole (West)',
+    59812: 'Ice Palace',
+    59818: 'Ice Palace',
+    59821: 'Tower of Hera',
+    59824: 'Waterfall of Wishing',
+    59827: 'Eastern Palace',
+    59830: 'Desert Palace Entrance (West)',
+    59833: 'Eastern Palace',
+    59836: 'Links House',
+    59839: 'Spiral Cave',
+    59842: 'Desert Palace Entrance (West)',
+    59845: 'Mimic Cave',
+    59848: 'Skull Woods First Section Hole (East)',
+    59851: 'Desert Palace Entrance (West)',
+    59854: 'Tavern North',
+    59857: 'Waterfall of Wishing',
+    59860: 'Ice Palace',
+    59866: 'Misery Mire',
+    59869: 'Ice Palace',
+    59872: 'Ice Palace',
+    59875: 'Ice Palace',
+    59878: 'Tower of Hera',
+    59881: 'Chicken House',
+    59884: 'Brewery',
+    59887: 'C-Shaped House',
+    59890: 'Aginahs Cave',
+    59893: 'Eastern Palace',
+    59896: 'Tower of Hera',
+    59899: 'Tower of Hera',
+    59902: 'Skull Woods Final Section',
+    59905: 'Thieves Town',
+    59908: 'Thieves Town',
+    59911: 'Thieves Town',
+    59914: 'Thieves Town',
+    59917: 'Thieves Town',
+    59920: 'Thieves Town',
+    59923: 'Thieves Town',
+    59926: 'Turtle Rock',
+    59929: 'Dark Death Mountain Ledge (East)',
+    59932: 'Turtle Rock',
+    59935: 'Turtle Rock',
+    59938: 'Turtle Rock',
+    59941: 'Dark Death Mountain Ledge (West)',
+    59944: 'Turtle Rock Isolated Ledge Entrance',
+    59947: 'Turtle Rock Isolated Ledge Entrance',
+    59950: 'Turtle Rock Isolated Ledge Entrance',
+    59953: 'Turtle Rock Isolated Ledge Entrance',
+    59956: 'Dark Death Mountain Ledge (West)',
+    59959: 'Palace of Darkness',
+    59962: 'Palace of Darkness',
+    59965: 'Palace of Darkness',
+    59968: 'Palace of Darkness',
+    59971: 'Palace of Darkness',
+    59974: 'Palace of Darkness',
+    59977: 'Palace of Darkness',
+    59980: 'Palace of Darkness',
+    59983: 'Palace of Darkness',
+    59986: 'Palace of Darkness',
+    59989: 'Palace of Darkness',
+    59992: 'Palace of Darkness',
+    59995: 'Palace of Darkness',
+    59998: 'Misery Mire',
+    60001: 'Misery Mire',
+    60004: 'Misery Mire',
+    60007: 'Misery Mire',
+    60010: 'Misery Mire',
+    60013: 'Misery Mire',
+    60019: 'Mire Shed',
+    60022: 'Mire Shed',
+    60025: 'Sanctuary S&Q',
+    60028: 'Superbunny Cave (Top)',
+    60031: 'Superbunny Cave (Top)',
+    60034: 'Sahasrahlas Hut',
+    60037: 'Sahasrahlas Hut',
+    60040: 'Sahasrahlas Hut',
+    60043: 'Spike Cave',
+    60046: 'Kakariko Well Drop',
+    60049: 'Kakariko Well Drop',
+    60052: 'Kakariko Well Drop',
+    60055: 'Kakariko Well Drop',
+    60058: 'Kakariko Well Drop',
+    60061: 'Swamp Palace',
+    60064: 'Swamp Palace',
+    60067: 'Swamp Palace',
+    60070: 'Swamp Palace',
+    60073: 'Swamp Palace',
+    60076: 'Swamp Palace',
+    60079: 'Swamp Palace',
+    60082: 'Agahnims Tower',
+    60085: 'Agahnims Tower',
+    60088: 'Ganons Tower',
+    60091: 'Ganons Tower',
+    60094: 'Ganons Tower',
+    60097: 'Ganons Tower',
+    60100: 'Ganons Tower',
+    60103: 'Ganons Tower',
+    60106: 'Ganons Tower',
+    60109: 'Ganons Tower',
+    60112: 'Ganons Tower',
+    60115: 'Ganons Tower',
+    60118: 'Ganons Tower',
+    60121: 'Ganons Tower',
+    60124: 'Ganons Tower',
+    60127: 'Ganons Tower',
+    60130: 'Ganons Tower',
+    60133: 'Ganons Tower',
+    60136: 'Ganons Tower',
+    60139: 'Ganons Tower',
+    60142: 'Ganons Tower',
+    60145: 'Ganons Tower',
+    60148: 'Ganons Tower',
+    60151: 'Ganons Tower',
+    60157: 'Ganons Tower',
+    60160: 'Ganons Tower',
+    60163: 'Ganons Tower',
+    60166: 'Ganons Tower',
+    60169: 'Hyrule Castle Entrance (South)',
+    60172: 'Hyrule Castle Entrance (South)',
+    60175: 'Blinds Hideout',
+    60178: 'Blinds Hideout',
+    60181: 'Blinds Hideout',
+    60184: 'Blinds Hideout',
+    60187: 'Blinds Hideout',
+    60190: 'Hype Cave',
+    60193: 'Hype Cave',
+    60196: 'Hype Cave',
+    60199: 'Hype Cave',
+    60202: 'Paradox Cave (Bottom)',
+    60205: 'Paradox Cave (Bottom)',
+    60208: 'Paradox Cave (Bottom)',
+    60211: 'Paradox Cave (Bottom)',
+    60214: 'Paradox Cave (Bottom)',
+    60217: 'Paradox Cave (Bottom)',
+    60220: 'Paradox Cave (Bottom)',
+    60223: 'Bonk Rock Cave',
+    60226: 'Mini Moldorm Cave',
+    60229: 'Mini Moldorm Cave',
+    60232: 'Mini Moldorm Cave',
+    60235: 'Mini Moldorm Cave',
+    60238: 'Ice Rod Cave',
+    60241: 'Hookshot Cave',
+    60244: 'Hookshot Cave',
+    60247: 'Hookshot Cave',
+    60250: 'Hookshot Cave',
+    60253: 'Hyrule Castle Entrance (South)',
+    60256: 'Hyrule Castle Entrance (South)',
+    60259: 'Hyrule Castle Entrance (South)',
+    60840: 'Chest Game',
+    166320: 'Master Sword Meadow',
+    188229: 'Hyrule Castle Secret Entrance Drop',
+    191256: 'Kings Grave Inner Rocks',
+    193020: 'Sahasrahlas Hut',
+    209095: 'South Dark World Bridge',
+    211407: 'Sick Kids House',
+    212328: 'Kings Grave Inner Rocks',
+    212605: 'Hobo Bridge',
+    975237: 'Catfish Entrance Rock',
+    975299: 'Zoras River',
+    1010170: 'Old Man Cave (West)',
+    1310724: 'Ice Palace',
+    1310727: 'Dark Death Mountain Ledge (West)',
+    1310730: 'Swamp Palace',
+    1310733: 'Hyrule Castle Entrance (South)',
+    1310736: 'Swamp Palace',
+    1310739: 'Swamp Palace',
+    1310742: 'Swamp Palace',
+    1310745: 'Swamp Palace',
+    1310748: 'Skull Woods Final Section',
+    1310751: 'Ganons Tower',
+    1310754: 'Ice Palace',
+    1310757: 'Ice Palace',
+    1310760: 'Desert Palace Entrance (North)',
+    1310763: 'Desert Palace Entrance (North)',
+    1310766: 'Skull Woods Second Section Door (East)',
+    1310769: 'Desert Palace Entrance (North)',
+    1310772: 'Hyrule Castle Entrance (South)',
+    1310775: 'Hyrule Castle Entrance (South)',
+    1310778: 'Ganons Tower',
+    1310781: 'Hyrule Castle Entrance (South)',
+    1310784: 'Ganons Tower',
+    1310787: 'Ganons Tower',
+    1310790: 'Ice Palace',
+    1310793: 'Eastern Palace',
+    1310796: 'Misery Mire',
+    1310799: 'Thieves Town',
+    1310802: 'Agahnims Tower',
+    1310805: 'Misery Mire',
+    1310808: 'Turtle Rock',
+    1310811: 'Eastern Palace',
+    1310814: 'Thieves Town',
+    1310817: 'Agahnims Tower',
+    1310820: 'Misery Mire',
+    1572864: 'Lost Woods Hideout Drop',
+    1572865: 'Lumberjack Tree Tree',
+    1572866: 'Spectacle Rock Cave',
+    1572867: 'Cave 45',
+    1572868: 'Graveyard Cave',
+    1572869: 'Checkerboard Cave',
+    1572870: 'Dark World Hammer Peg Cave',
+    1572880: 'Mini Moldorm Cave',
+    1572881: 'Hype Cave',
+    1572882: 'Library',
+    1572883: 'Kings Grave Inner Rocks',
+    1572884: 'Potion Shop',
+    1572885: 'Bat Cave Drop',
+    1572886: 'Death Mountain (Top)',
+    1572887: 'Bombos Tablet Mirror Spot',
+    1572906: 'Blacksmiths Hut',
+    1573184: 'Spectacle Rock Mirror Spot',
+    1573185: 'Floating Island Mirror Spot',
+    1573186: 'Maze Race Mirror Spot',
+    1573187: 'Desert Ledge Return Rocks',
+    1573188: 'Lake Hylia Island Mirror Spot',
+    1573189: 'Kings Grave Inner Rocks',
+    1573190: 'Bumper Cave (Bottom)',
+    1573191: 'Top of Pyramid',
+    1573192: 'South Dark World Bridge',
+    1573193: 'Zoras River',
+    1573194: 'Kings Grave Inner Rocks',
+    1573200: 'Eastern Palace',
+    1573201: 'Desert Palace Entrance (North)',
+    1573202: 'Tower of Hera',
+    1573203: 'Palace of Darkness',
+    1573204: 'Swamp Palace',
+    1573205: 'Skull Woods Final Section',
+    1573206: 'Thieves Town',
+    1573207: 'Ice Palace',
+    1573208: 'Misery Mire',
+    1573209: 'Turtle Rock Isolated Ledge Entrance',
+    1573216: 'Desert Palace Entrance (West)',
+    1573217: 'Ganons Tower',
+    1573218: 'Tower of Hera',
+    4194304: 'Cave Shop (Dark Death Mountain)',
+    4194305: 'Cave Shop (Dark Death Mountain)',
+    4194306: 'Cave Shop (Dark Death Mountain)',
+    4194307: 'Red Shield Shop',
+    4194308: 'Red Shield Shop',
+    4194309: 'Red Shield Shop',
+    4194310: 'Dark Lake Hylia Shop',
+    4194311: 'Dark Lake Hylia Shop',
+    4194312: 'Dark Lake Hylia Shop',
+    4194313: 'Dark World Lumberjack Shop',
+    4194314: 'Dark World Lumberjack Shop',
+    4194315: 'Dark World Lumberjack Shop',
+    4194316: 'Village of Outcasts Shop',
+    4194317: 'Village of Outcasts Shop',
+    4194318: 'Village of Outcasts Shop',
+    4194319: 'Dark World Potion Shop',
+    4194320: 'Dark World Potion Shop',
+    4194321: 'Dark World Potion Shop',
+    4194322: 'Light World Death Mountain Shop',
+    4194323: 'Light World Death Mountain Shop',
+    4194324: 'Light World Death Mountain Shop',
+    4194325: 'Kakariko Shop',
+    4194326: 'Kakariko Shop',
+    4194327: 'Kakariko Shop',
+    4194328: 'Cave Shop (Lake Hylia)',
+    4194329: 'Cave Shop (Lake Hylia)',
+    4194330: 'Cave Shop (Lake Hylia)',
+    4194331: 'Potion Shop',
+    4194332: 'Potion Shop',
+    4194333: 'Potion Shop',
+    4194334: 'Capacity Upgrade',
+    4194335: 'Capacity Upgrade',
+    4194336: 'Capacity Upgrade',
+    # have no vanilla entrance
+    4194337: "Old Man Sword Cave",
+    4194338: "Take-Any #1",
+    4194339: "Take-Any #2",
+    4194340: "Take-Any #3",
+    4194341: "Take-Any #4",
+}
 
 lookup_prizes = {location for location in location_table if location.endswith(" - Prize")}
 lookup_boss_drops = {location for location in location_table if location.endswith(" - Boss")}
\ No newline at end of file
diff --git a/worlds/alttp/Rules.py b/worlds/alttp/Rules.py
index d1413e215d4..2cee568e173 100644
--- a/worlds/alttp/Rules.py
+++ b/worlds/alttp/Rules.py
@@ -1,9 +1,12 @@
 import collections
 import logging
+from typing import Iterator, Set
+
 from worlds.alttp import OverworldGlitchRules
 from BaseClasses import RegionType, MultiWorld, Entrance
-from worlds.alttp.Items import ItemFactory, progression_items, item_name_groups
+from worlds.alttp.Items import ItemFactory, progression_items, item_name_groups, item_table
 from worlds.alttp.OverworldGlitchRules import overworld_glitches_rules, no_logic_rules
+from worlds.alttp.Regions import location_table
 from worlds.alttp.UnderworldGlitchRules import underworld_glitches_rules
 from worlds.alttp.Bosses import GanonDefeatRule
 from worlds.generic.Rules import set_rule, add_rule, forbid_item, add_item_rule, item_in_locations, \
@@ -176,6 +179,14 @@ def dungeon_boss_rules(world, player):
 def global_rules(world, player):
     # ganon can only carry triforce
     add_item_rule(world.get_location('Ganon', player), lambda item: item.name == 'Triforce' and item.player == player)
+    # dungeon prizes can only be crystals/pendants
+    crystals_and_pendants: Set[str] = \
+        {item for item, item_data in item_table.items() if item_data.type == "Crystal"}
+    prize_locations: Iterator[str] = \
+        (locations for locations, location_data in location_table.items() if location_data[2] == True)
+    for prize_location in prize_locations:
+        add_item_rule(world.get_location(prize_location, player),
+                      lambda item: item.name in crystals_and_pendants and item.player == player)
     # determines which S&Q locations are available - hide from paths since it isn't an in-game location
     world.get_region('Menu', player).can_reach_private = lambda state: True
     for exit in world.get_region('Menu', player).exits:
@@ -515,7 +526,7 @@ def default_rules(world, player):
     set_rule(world.get_entrance('Floating Island Mirror Spot', player), lambda state: state.has('Magic Mirror', player))
     set_rule(world.get_entrance('Turtle Rock', player), lambda state: state.has('Moon Pearl', player) and state.has_sword(player) and state.has_turtle_rock_medallion(player) and state.can_reach('Turtle Rock (Top)', 'Region', player))  # sword required to cast magic (!)
 
-    set_rule(world.get_entrance('Pyramid Hole', player), lambda state: state.has('Beat Agahnim 2', player) or world.open_pyramid[player])
+    set_rule(world.get_entrance('Pyramid Hole', player), lambda state: state.has('Beat Agahnim 2', player) or world.open_pyramid[player].to_bool(world, player))
 
     if world.swordless[player]:
         swordless_rules(world, player)
diff --git a/worlds/alttp/Shops.py b/worlds/alttp/Shops.py
index f6233286f00..8e183c87a38 100644
--- a/worlds/alttp/Shops.py
+++ b/worlds/alttp/Shops.py
@@ -39,9 +39,9 @@ class Shop():
     blacklist: Set[str] = set()  # items that don't work, todo: actually check against this
     type = ShopType.Shop
     slot_names: Dict[int, str] = {
-        0: "Left",
-        1: "Center",
-        2: "Right"
+        0: " Left",
+        1: " Center",
+        2: " Right"
     }
 
     def __init__(self, region, room_id: int, shopkeeper_config: int, custom: bool, locked: bool, sram_offset: int):
@@ -142,7 +142,11 @@ def can_push_inventory(self, slot: int):
 
 class TakeAny(Shop):
     type = ShopType.TakeAny
-
+    slot_names: Dict[int, str] = {
+        0: "",
+        1: "",
+        2: ""
+    }
 
 class UpgradeShop(Shop):
     type = ShopType.UpgradeShop
@@ -168,8 +172,10 @@ def FillDisabledShopSlots(world):
 
 
 def ShopSlotFill(world):
-    shop_slots: Set[ALttPLocation] = {location for shop_locations in (shop.region.locations for shop in world.shops)
+    shop_slots: Set[ALttPLocation] = {location for shop_locations in
+                                      (shop.region.locations for shop in world.shops if shop.type != ShopType.TakeAny)
                                       for location in shop_locations if location.shop_slot is not None}
+
     removed = set()
     for location in shop_slots:
         shop: Shop = location.parent_region.shop
@@ -318,7 +324,7 @@ def create_shops(world, player: int):
         for index, item in enumerate(inventory):
             shop.add_inventory(index, *item)
             if not locked and num_slots:
-                slot_name = f"{region.name} {shop.slot_names[index]}"
+                slot_name = f"{region.name}{shop.slot_names[index]}"
                 loc = ALttPLocation(player, slot_name, address=shop_table_by_location[slot_name],
                                     parent=region, hint_text="for sale")
                 loc.shop_slot = index
@@ -376,7 +382,7 @@ class ShopData(NamedTuple):
 
 SHOP_ID_START = 0x400000
 shop_table_by_location_id = dict(enumerate(
-    (f"{name} {Shop.slot_names[num]}" for name, shop_data in
+    (f"{name}{Shop.slot_names[num]}" for name, shop_data in
      sorted(shop_table.items(), key=lambda item: item[1].sram_offset)
      for num in range(3)), start=SHOP_ID_START))
 
@@ -591,3 +597,22 @@ def price_to_funny_price(world, item: dict, player: int):
                 item['price'] = min(price_chart[p_type](item['price']), 255)
                 item['price_type'] = p_type
             break
+
+
+def create_dynamic_shop_locations(world, player):
+    for shop in world.shops:
+        if shop.region.player == player:
+            for i, item in enumerate(shop.inventory):
+                if item is None:
+                    continue
+                if item['create_location']:
+                    slot_name = f"{shop.region.name}{shop.slot_names[i]}"
+                    loc = ALttPLocation(player, slot_name,
+                                        address=shop_table_by_location[slot_name], parent=shop.region)
+                    loc.place_locked_item(ItemFactory(item['item'], player))
+                    if shop.type == ShopType.TakeAny:
+                        loc.shop_slot_disabled = True
+                    shop.region.locations.append(loc)
+                    world.clear_location_cache()
+
+                    loc.shop_slot = i
diff --git a/worlds/alttp/test/items/TestPrizes.py b/worlds/alttp/test/items/TestPrizes.py
new file mode 100644
index 00000000000..5e729093f9b
--- /dev/null
+++ b/worlds/alttp/test/items/TestPrizes.py
@@ -0,0 +1,39 @@
+from typing import List
+
+from BaseClasses import Item, Location
+from test.TestBase import WorldTestBase
+
+
+class TestPrizes(WorldTestBase):
+    game = "A Link to the Past"
+
+    def test_item_rules(self):
+        prize_locations: List[Location] = [
+            self.multiworld.get_location("Eastern Palace - Prize", 1),
+            self.multiworld.get_location("Desert Palace - Prize", 1),
+            self.multiworld.get_location("Tower of Hera - Prize", 1),
+            self.multiworld.get_location("Palace of Darkness - Prize", 1),
+            self.multiworld.get_location("Swamp Palace - Prize", 1),
+            self.multiworld.get_location("Thieves\' Town - Prize", 1),
+            self.multiworld.get_location("Skull Woods - Prize", 1),
+            self.multiworld.get_location("Ice Palace - Prize", 1),
+            self.multiworld.get_location("Misery Mire - Prize", 1),
+            self.multiworld.get_location("Turtle Rock - Prize", 1),
+        ]
+        prize_items: List[Item] = [
+            self.get_item_by_name("Green Pendant"),
+            self.get_item_by_name("Blue Pendant"),
+            self.get_item_by_name("Red Pendant"),
+            self.get_item_by_name("Crystal 1"),
+            self.get_item_by_name("Crystal 2"),
+            self.get_item_by_name("Crystal 3"),
+            self.get_item_by_name("Crystal 4"),
+            self.get_item_by_name("Crystal 5"),
+            self.get_item_by_name("Crystal 6"),
+            self.get_item_by_name("Crystal 7"),
+        ]
+
+        for item in self.multiworld.get_items():
+            for prize_location in prize_locations:
+                self.assertEqual(item in prize_items, prize_location.item_rule(item),
+                                 f"{item} must {'' if item in prize_items else 'not '}be allowed in {prize_location}.")
diff --git a/worlds/alttp/test/options/TestOpenPyramid.py b/worlds/alttp/test/options/TestOpenPyramid.py
new file mode 100644
index 00000000000..c66eb2ee98e
--- /dev/null
+++ b/worlds/alttp/test/options/TestOpenPyramid.py
@@ -0,0 +1,37 @@
+from test.TestBase import WorldTestBase
+from ...Items import ItemFactory
+
+
+class PyramidTestBase(WorldTestBase):
+    game = "A Link to the Past"
+
+
+class OpenPyramidTest(PyramidTestBase):
+    options = {
+        "open_pyramid": "open"
+    }
+
+    def testAccess(self):
+        self.assertFalse(self.can_reach_entrance("Pyramid Hole"))
+        self.collect_by_name(["Hammer", "Progressive Glove", "Moon Pearl"])
+        self.assertTrue(self.can_reach_entrance("Pyramid Hole"))
+
+
+class GoalPyramidTest(PyramidTestBase):
+    options = {
+        "open_pyramid": "goal"
+    }
+
+    def testCrystalsGoalAccess(self):
+        self.multiworld.goal[1] = "crystals"
+        self.assertFalse(self.can_reach_entrance("Pyramid Hole"))
+        self.collect_by_name(["Hammer", "Progressive Glove", "Moon Pearl"])
+        self.assertTrue(self.can_reach_entrance("Pyramid Hole"))
+
+    def testGanonGoalAccess(self):
+        self.assertFalse(self.can_reach_entrance("Pyramid Hole"))
+        self.collect_by_name(["Hammer", "Progressive Glove", "Moon Pearl"])
+        self.assertFalse(self.can_reach_entrance("Pyramid Hole"))
+        self.multiworld.state.collect(ItemFactory("Beat Agahnim 2", 1))
+        self.assertTrue(self.can_reach_entrance("Pyramid Hole"))
+
diff --git a/worlds/alttp/test/options/TestPlandoBosses.py b/worlds/alttp/test/options/TestPlandoBosses.py
index 3c218b69aad..a6c3485f60d 100644
--- a/worlds/alttp/test/options/TestPlandoBosses.py
+++ b/worlds/alttp/test/options/TestPlandoBosses.py
@@ -113,8 +113,8 @@ def testSingularity(self):
         """Test automatic singularity mode"""
         self.assertIn(";singularity", MultiBosses.from_any("b2").value)
 
-    def testPlandoSettings(self):
-        """Test that plando settings verification works"""
+    def testPlandoOptions(self):
+        """Test that plando options verification works"""
         plandoed_string = "l1-b2;l2-b1"
         mixed_string = "l1-b2;shuffle"
         regular_string = "shuffle"
@@ -123,14 +123,14 @@ def testPlandoSettings(self):
         regular = MultiBosses.from_any(regular_string)
 
         # plando should work with boss plando
-        plandoed.verify(None, "Player", Generate.PlandoSettings.bosses)
+        plandoed.verify(None, "Player", Generate.PlandoOptions.bosses)
         self.assertTrue(plandoed.value.startswith(plandoed_string))
         # plando should fall back to default without boss plando
-        plandoed.verify(None, "Player", Generate.PlandoSettings.items)
+        plandoed.verify(None, "Player", Generate.PlandoOptions.items)
         self.assertEqual(plandoed, MultiBosses.option_vanilla)
         # mixed should fall back to mode
-        mixed.verify(None, "Player", Generate.PlandoSettings.items)  # should produce a warning and still work
+        mixed.verify(None, "Player", Generate.PlandoOptions.items)  # should produce a warning and still work
         self.assertEqual(mixed, MultiBosses.option_shuffle)
         # mode stuff should just work
-        regular.verify(None, "Player", Generate.PlandoSettings.items)
+        regular.verify(None, "Player", Generate.PlandoOptions.items)
         self.assertEqual(regular, MultiBosses.option_shuffle)
diff --git a/worlds/bk_sudoku/docs/en_Sudoku.md b/worlds/bk_sudoku/docs/en_Sudoku.md
index 0e20bcbcb10..d6951475246 100644
--- a/worlds/bk_sudoku/docs/en_Sudoku.md
+++ b/worlds/bk_sudoku/docs/en_Sudoku.md
@@ -6,7 +6,7 @@ BK Sudoku is not a typical Archipelago game; instead, it is a generic Sudoku cli
 
 ## What hints are unlocked?
 
-After completing a Sudoku puzzle, the game will unlock 1 random hint for an unchecked location in the slot you are connected to. It is possible to hint a location that was previously hinted for using the !hint command.
+After completing a Sudoku puzzle, the game will unlock 1 random hint for an unchecked location in the slot you are connected to.
 
 ## Where is the settings page?
 
diff --git a/worlds/generic/docs/advanced_settings_en.md b/worlds/generic/docs/advanced_settings_en.md
index b96b1d57e42..be2eced7f83 100644
--- a/worlds/generic/docs/advanced_settings_en.md
+++ b/worlds/generic/docs/advanced_settings_en.md
@@ -63,7 +63,14 @@ games you want settings for.
   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.
+  also be filled with multiple names each having a weight to it. Names can also contain certain keywords, surrounded by
+  curly-braces, which will be replaced on generation with a number:
+  
+  * `{player}` will be replaced with the player's slot number.
+  * `{PLAYER}` will be replaced with the player's slot number if that slot number is greater than 1, otherwise blank.
+  * `{number}` will be replaced with the counter value of the name.
+  * `{NUMBER}` will be replaced with the counter value of the name if the counter value is greater than 1, otherwise 
+  blank.
 
 * `game` is where either your chosen game goes or if you would like can be filled with multiple games each with
   different weights.
diff --git a/worlds/hk/Items.py b/worlds/hk/Items.py
index 701a64950ad..a9acbf48f30 100644
--- a/worlds/hk/Items.py
+++ b/worlds/hk/Items.py
@@ -26,7 +26,7 @@ class HKItemData(NamedTuple):
 directionals = ('', 'Left_', 'Right_')
 
 item_name_groups.update({
-    "Dreamer": {"Herrah", "Monomon", "Lurien"},
+    "Dreamers": {"Herrah", "Monomon", "Lurien"},
     "Cloak": {x + 'Mothwing_Cloak' for x in directionals} | {'Shade_Cloak', 'Split_Shade_Cloak'},
     "Claw": {x + 'Mantis_Claw' for x in directionals},
     "CDash": {x + 'Crystal_Heart' for x in directionals},
diff --git a/worlds/oot/EntranceShuffle.py b/worlds/oot/EntranceShuffle.py
index 833d28189a0..eb7e2c3febe 100644
--- a/worlds/oot/EntranceShuffle.py
+++ b/worlds/oot/EntranceShuffle.py
@@ -480,7 +480,7 @@ def shuffle_random_entrances(ootworld):
     if ootworld.shuffle_dungeon_entrances:
         entrance_pools['Dungeon'] = ootworld.get_shufflable_entrances(type='Dungeon', only_primary=True)
         if ootworld.open_forest == 'closed':
-            entrance_pools['Dungeon'].remove(ootworld.get_entrance('KF Outside Deku Tree -> Deku Tree Lobby', player))
+            entrance_pools['Dungeon'].remove(ootworld.get_entrance('KF Outside Deku Tree -> Deku Tree Lobby'))
         if ootworld.shuffle_special_dungeon_entrances:
             entrance_pools['Dungeon'] += ootworld.get_shufflable_entrances(type='DungeonSpecial', only_primary=True)
         if ootworld.decouple_entrances:
@@ -500,7 +500,7 @@ def shuffle_random_entrances(ootworld):
         exclude_overworld_reverse = ootworld.mix_entrance_pools == 'all' and not ootworld.decouple_entrances
         entrance_pools['Overworld'] = ootworld.get_shufflable_entrances(type='Overworld', only_primary=exclude_overworld_reverse)
         if not ootworld.decouple_entrances:
-            entrance_pools['Overworld'].remove(world.get_entrance('GV Lower Stream -> Lake Hylia', player))
+            entrance_pools['Overworld'].remove(ootworld.get_entrance('GV Lower Stream -> Lake Hylia'))
 
     # Mark shuffled entrances
     for entrance in chain(chain.from_iterable(one_way_entrance_pools.values()), chain.from_iterable(entrance_pools.values())):
diff --git a/worlds/oot/Hints.py b/worlds/oot/Hints.py
index d2011279773..dfed0b4d320 100644
--- a/worlds/oot/Hints.py
+++ b/worlds/oot/Hints.py
@@ -1136,14 +1136,14 @@ def buildMiscItemHints(world, messages):
             if world.multiworld.state.has(data['default_item'], world.player) > 0:
                 text = data['default_item_text'].format(area='#your pocket#')
             elif item_locations:
-                location = item_locations[0]
+                location = world.hint_rng.choice(item_locations)
                 player_text = ''
                 if location.player != world.player:
                     player_text = world.multiworld.get_player_name(location.player) + "'s "
                 if location.game == 'Ocarina of Time':
                     area = HintArea.at(location, use_alt_hint=data['use_alt_hint']).text(world.clearer_hints, world=None)
                 else:
-                    area = location.name    
+                    area = location.name
                 text = data['default_item_text'].format(area=(player_text + area))
             elif 'default_item_fallback' in data:
                 text = data['default_item_fallback']
diff --git a/worlds/oot/Items.py b/worlds/oot/Items.py
index 232560026c1..e3ce920d12b 100644
--- a/worlds/oot/Items.py
+++ b/worlds/oot/Items.py
@@ -41,7 +41,7 @@ def __init__(self, name, player, data, event, force_not_advancement):
             classification = ItemClassification.useful
         elif name == "Ice Trap":
             classification = ItemClassification.trap
-        elif name == 'Gold Skulltula Token':
+        elif name in {'Gold Skulltula Token', 'Triforce Piece'}:
             classification = ItemClassification.progression_skip_balancing
         elif advancement:
             classification = ItemClassification.progression
diff --git a/worlds/oot/__init__.py b/worlds/oot/__init__.py
index 815182655d3..3dd5baf7634 100644
--- a/worlds/oot/__init__.py
+++ b/worlds/oot/__init__.py
@@ -109,7 +109,7 @@ class OOTWorld(World):
 
     data_version = 3
 
-    required_client_version = (0, 3, 6)
+    required_client_version = (0, 3, 7)
 
     item_name_groups = {
         # internal groups
@@ -171,12 +171,13 @@ def generate_early(self):
         # ER and glitched logic are not compatible; glitched takes priority
         if self.logic_rules == 'glitched':
             self.shuffle_interior_entrances = 'off'
+            self.shuffle_dungeon_entrances = 'off'
+            self.spawn_positions = 'off'
+            self.shuffle_bosses = 'off'
             self.shuffle_grotto_entrances = False
-            self.shuffle_dungeon_entrances = False
             self.shuffle_overworld_entrances = False
             self.owl_drops = False
             self.warp_songs = False
-            self.spawn_positions = 'off'
 
         # Fix spawn positions option
         new_sp = []
@@ -197,6 +198,17 @@ def generate_early(self):
         if self.triforce_hunt:
             self.shuffle_ganon_bosskey = 'triforce'
 
+        # Force itempool to higher settings if it doesn't have enough hearts
+        max_required_hearts = 3
+        if self.bridge == 'hearts':
+            max_required_hearts = max(max_required_hearts, self.bridge_hearts)
+        if self.shuffle_ganon_bosskey == 'hearts':
+            max_required_hearts = max(max_required_hearts, self.ganon_bosskey_hearts)
+        if max_required_hearts > 3 and self.item_pool_value == 'minimal':
+            self.item_pool_value = 'scarce'
+        if max_required_hearts > 12 and self.item_pool_value == 'scarce':
+            self.item_pool_value = 'balanced'
+
         # If songs/keys locked to own world by settings, add them to local_items
         local_types = []
         if self.shuffle_song_items != 'any':
@@ -283,8 +295,17 @@ def generate_early(self):
         self.shuffle_special_dungeon_entrances = self.shuffle_dungeon_entrances == 'all'
         self.shuffle_dungeon_entrances = self.shuffle_dungeon_entrances != 'off'
         self.ensure_tod_access = (self.shuffle_interior_entrances != 'off') or self.shuffle_overworld_entrances or self.spawn_positions
-        self.entrance_shuffle = (self.shuffle_interior_entrances != 'off') or self.shuffle_grotto_entrances or self.shuffle_dungeon_entrances or \
-                                self.shuffle_overworld_entrances or self.owl_drops or self.warp_songs or self.spawn_positions
+        self.entrance_shuffle = (
+            self.shuffle_interior_entrances != 'off'
+            or self.shuffle_bosses != 'off'
+            or self.shuffle_dungeon_entrances
+            or self.shuffle_special_dungeon_entrances
+            or self.spawn_positions
+            or self.shuffle_grotto_entrances
+            or self.shuffle_overworld_entrances
+            or self.owl_drops
+            or self.warp_songs
+        )
         self.disable_trade_revert = (self.shuffle_interior_entrances != 'off') or self.shuffle_overworld_entrances
         self.shuffle_special_interior_entrances = self.shuffle_interior_entrances == 'all'
 
@@ -317,13 +338,14 @@ def generate_early(self):
 
         # Determine which dungeons are MQ. Not compatible with glitched logic.
         mq_dungeons = set()
+        all_dungeons = [d['name'] for d in dungeon_table]
         if self.logic_rules != 'glitched':
             if self.mq_dungeons_mode == 'mq':
-                mq_dungeons = dungeon_table.keys()
+                mq_dungeons = all_dungeons
             elif self.mq_dungeons_mode == 'specific':
                 mq_dungeons = self.mq_dungeons_specific
             elif self.mq_dungeons_mode == 'count':
-                mq_dungeons = self.multiworld.random.sample(dungeon_table, self.mq_dungeons_count)
+                mq_dungeons = self.multiworld.random.sample(all_dungeons, self.mq_dungeons_count)
         else:
             self.mq_dungeons_mode = 'count'
             self.mq_dungeons_count = 0
@@ -441,6 +463,7 @@ def load_regions_from_json(self, file_path):
                 new_region.scene = region['scene']
             if 'dungeon' in region:
                 new_region.dungeon = region['dungeon']
+                new_region.set_hint_data(region['dungeon'])
             if 'is_boss_room' in region:
                 new_region.is_boss_room = region['is_boss_room']
             if 'hint' in region:
@@ -842,10 +865,13 @@ def pre_fill(self):
         impa = self.multiworld.get_location("Song from Impa", self.player)
         if self.shuffle_child_trade == 'skip_child_zelda':
             if impa.item is None:
-                item_to_place = self.multiworld.random.choice(
-                    list(item for item in self.multiworld.itempool if item.player == self.player))
+                candidate_items = list(item for item in self.multiworld.itempool if item.player == self.player)
+                if candidate_items:
+                    item_to_place = self.multiworld.random.choice(candidate_items)
+                    self.multiworld.itempool.remove(item_to_place)
+                else:
+                    item_to_place = self.create_item("Recovery Heart")
                 impa.place_locked_item(item_to_place)
-                self.multiworld.itempool.remove(item_to_place)
             # Give items to startinventory
             self.multiworld.push_precollected(impa.item)
             self.multiworld.push_precollected(self.create_item("Zeldas Letter"))
@@ -1269,6 +1295,13 @@ def gather_locations(multiworld: MultiWorld,
         'HideoutSmallKey': 'shuffle_hideoutkeys',
         'GanonBossKey': 'shuffle_ganon_bosskey',
     }
+
+    # Special handling for atypical item types
+    if item_type == 'HideoutSmallKey':
+        dungeon = 'Thieves Hideout'
+    elif item_type == 'GanonBossKey':
+        dungeon = 'Ganons Castle'
+
     if isinstance(players, int):
         players = {players}
     fill_opts = {p: getattr(multiworld.worlds[p], type_to_setting[item_type]) for p in players}
diff --git a/worlds/overcooked2/Logic.py b/worlds/overcooked2/Logic.py
index a4f1f0fb86d..0b844fc1894 100644
--- a/worlds/overcooked2/Logic.py
+++ b/worlds/overcooked2/Logic.py
@@ -135,10 +135,10 @@ def level_shuffle_factory(
     shuffle_horde_levels: bool,
 ) -> Dict[int, Overcooked2GenericLevel]:  # return <story_level_id, level>
     # Create a list of all valid levels for selection
-    # (excludes tutorial, throne, kevin and sometimes horde levels)
+    # (excludes tutorial, throne and sometimes horde/prep levels)
     pool = list()
     for dlc in Overcooked2Dlc:
-        for level_id in range(dlc.start_level_id(), dlc.end_level_id()):
+        for level_id in range(dlc.start_level_id, dlc.end_level_id):
             if level_id in dlc.excluded_levels():
                 continue
 
@@ -165,11 +165,12 @@ def level_shuffle_factory(
         rng.shuffle(pool)
 
         # Return the first 44 levels and assign those to each level
-        for level_id in range(story.start_level_id(), story.end_level_id()):
+        for level_id in range(story.start_level_id, story.end_level_id):
             if level_id not in story.excluded_levels():
                 result[level_id] = pool[level_id-1]
-            else:
-                result[level_id] = Overcooked2GenericLevel(level_id)  # This is just 6-6 right now
+            elif level_id == 36:
+                # Level 6-6 is exempt from shuffling
+                result[level_id] = Overcooked2GenericLevel(level_id)
 
     return result
 
@@ -2599,7 +2600,9 @@ def is_completable_no_items(level: Overcooked2GenericLevel) -> bool:
             {  # Exclusive
 
             },
-            horde_logic
+            {  # Additive
+
+            },
         ),
         (  # 2-star
             {  # Exclusive
diff --git a/worlds/overcooked2/Overcooked2Levels.py b/worlds/overcooked2/Overcooked2Levels.py
index 4c14a8f8d27..624e2741963 100644
--- a/worlds/overcooked2/Overcooked2Levels.py
+++ b/worlds/overcooked2/Overcooked2Levels.py
@@ -32,16 +32,16 @@ def __int__(self) -> int:
         assert False
 
     # inclusive
+    @property
     def start_level_id(self) -> int:
-        if self == Overcooked2Dlc.STORY:
-            return 1
         return 0
 
     # exclusive
+    @property
     def end_level_id(self) -> int:
         id = None
         if self == Overcooked2Dlc.STORY:
-            id = 6*6 + 8  # world_count*level_count + kevin count
+            id = 1 + 6*6 + 8 # tutorial + world_count*level_count + kevin count
         if self == Overcooked2Dlc.SURF_N_TURF:
             id = 3*4 + 1
         if self == Overcooked2Dlc.CAMPFIRE_COOK_OFF:
@@ -51,9 +51,9 @@ def end_level_id(self) -> int:
         if self == Overcooked2Dlc.CARNIVAL_OF_CHAOS:
             id = 3*4 + 3
         if self == Overcooked2Dlc.SEASONAL:
-            id = 31
+            id = 31 + 1
 
-        return self.start_level_id() + id
+        return self.start_level_id + id
 
     # Tutorial + Horde Levels + Endgame
     def excluded_levels(self) -> List[int]:
diff --git a/worlds/overcooked2/test/TestOvercooked2.py b/worlds/overcooked2/test/TestOvercooked2.py
index aad712110c1..e5bd55e46cd 100644
--- a/worlds/overcooked2/test/TestOvercooked2.py
+++ b/worlds/overcooked2/test/TestOvercooked2.py
@@ -147,3 +147,26 @@ def testExclusiveItems(self):
 
         for item in ITEMS_TO_EXCLUDE_IF_NO_DLC:
             self.assertIn(item, item_table.keys())
+
+    def testLevelCounts(self):
+        for dlc in Overcooked2Dlc:
+            level_id_range = range(dlc.start_level_id, dlc.end_level_id)
+            
+            for level_id in dlc.excluded_levels():
+                self.assertIn(level_id, level_id_range, f"Excluded level {dlc.name} - {level_id} out of range")
+            
+            for level_id in dlc.horde_levels():
+                self.assertIn(level_id, level_id_range, f"Horde level {dlc.name} - {level_id} out of range")
+            
+            for level_id in dlc.prep_levels():
+                self.assertIn(level_id, level_id_range, f"Prep level {dlc.name} - {level_id} out of range")
+
+            for level_id in level_id_range:
+                self.assertIn((dlc, level_id), level_id_to_shortname, "A valid level is not represented in level directory")
+            
+            count = 0
+            for (dlc_key, _) in level_id_to_shortname:
+                if dlc == dlc_key:
+                    count += 1
+            
+            self.assertEqual(count, len(level_id_range), f"Number of levels in {dlc.name} has discrepancy between level_id range and directory")
diff --git a/worlds/pokemon_rb/__init__.py b/worlds/pokemon_rb/__init__.py
index ca695d99ed7..5a78b63a052 100644
--- a/worlds/pokemon_rb/__init__.py
+++ b/worlds/pokemon_rb/__init__.py
@@ -40,13 +40,11 @@ class PokemonRedBlueWorld(World):
     game = "Pokemon Red and Blue"
     option_definitions = pokemon_rb_options
 
-    data_version = 3
+    data_version = 4
     required_client_version = (0, 3, 7)
 
     topology_present = False
 
-
-
     item_name_to_id = {name: data.id for name, data in item_table.items()}
     location_name_to_id = {location.name: location.address for location in location_data if location.type == "Item"}
     item_name_groups = item_groups
diff --git a/worlds/pokemon_rb/basepatch_blue.bsdiff4 b/worlds/pokemon_rb/basepatch_blue.bsdiff4
index 9e98a2cfcda..6932762f4d5 100644
Binary files a/worlds/pokemon_rb/basepatch_blue.bsdiff4 and b/worlds/pokemon_rb/basepatch_blue.bsdiff4 differ
diff --git a/worlds/pokemon_rb/basepatch_red.bsdiff4 b/worlds/pokemon_rb/basepatch_red.bsdiff4
index 9e39940773a..cd380e1f4f7 100644
Binary files a/worlds/pokemon_rb/basepatch_red.bsdiff4 and b/worlds/pokemon_rb/basepatch_red.bsdiff4 differ
diff --git a/worlds/pokemon_rb/locations.py b/worlds/pokemon_rb/locations.py
index 6b199690f9c..2e526093d4b 100644
--- a/worlds/pokemon_rb/locations.py
+++ b/worlds/pokemon_rb/locations.py
@@ -357,7 +357,7 @@ def __init__(self, flag):
     LocationData("Route 10 South", "Hidden Item Bush", "Max Ether", rom_addresses['Hidden_Item_Route_10_2'], Hidden(8), inclusion=hidden_items),
     LocationData("Rocket Hideout B1F", "Hidden Item Pot Plant", "PP Up", rom_addresses['Hidden_Item_Rocket_Hideout_B1F'], Hidden(9), inclusion=hidden_items),
     LocationData("Rocket Hideout B3F", "Hidden Item Near East Item", "Nugget", rom_addresses['Hidden_Item_Rocket_Hideout_B3F'], Hidden(10), inclusion=hidden_items),
-    LocationData("Rocket Hideout B4F", "Hidden Item Behind Giovanni", "Super Potion", rom_addresses['Hidden_Item_Rocket_Hideout_B4F'], Hidden(11), inclusion=hidden_items),
+    LocationData("Rocket Hideout B4F", "Hidden Item Behind Giovanni (Lift Key)", "Super Potion", rom_addresses['Hidden_Item_Rocket_Hideout_B4F'], Hidden(11), inclusion=hidden_items),
     LocationData("Pokemon Tower 5F", "Hidden Item Near West Staircase", "Elixir", rom_addresses['Hidden_Item_Pokemon_Tower_5F'], Hidden(12), inclusion=hidden_items),
     LocationData("Route 13", "Hidden Item Dead End Bush", "PP Up", rom_addresses['Hidden_Item_Route_13_1'], Hidden(13), inclusion=hidden_items),
     LocationData("Route 13", "Hidden Item Dead End By Water Corner", "Calcium", rom_addresses['Hidden_Item_Route_13_2'], Hidden(14), inclusion=hidden_items),
diff --git a/worlds/pokemon_rb/rom.py b/worlds/pokemon_rb/rom.py
index b48bd3edd02..169388c61fa 100644
--- a/worlds/pokemon_rb/rom.py
+++ b/worlds/pokemon_rb/rom.py
@@ -326,16 +326,20 @@ def process_pokemon_data(self):
         else:
             mon_data["catch rate"] = max(self.multiworld.minimum_catch_rate[self.player], mon_data["catch rate"])
 
-        if mon in poke_data.evolves_from.keys() and mon_data["type1"] == local_poke_data[poke_data.evolves_from[mon]]["type1"] and mon_data["type2"] == local_poke_data[poke_data.evolves_from[mon]]["type2"]:
-            mon_data["tms"] = local_poke_data[poke_data.evolves_from[mon]]["tms"]
-        elif mon != "Mew":
+        if mon != "Mew":
             tms_hms = poke_data.tm_moves + poke_data.hm_moves
             for flag, tm_move in enumerate(tms_hms):
-                if (flag < 50 and self.multiworld.tm_compatibility[self.player].value == 1) or (flag >= 50 and self.multiworld.hm_compatibility[self.player].value == 1):
+                if ((mon in poke_data.evolves_from.keys() and mon_data["type1"] ==
+                     local_poke_data[poke_data.evolves_from[mon]]["type1"] and mon_data["type2"] ==
+                     local_poke_data[poke_data.evolves_from[mon]]["type2"]) and (
+                        (flag < 50 and self.multiworld.tm_compatibility[self.player].value in [1, 2]) or (
+                        flag >= 51 and self.multiworld.hm_compatibility[self.player].value in [1, 2]))):
+                    bit = 1 if local_poke_data[poke_data.evolves_from[mon]]["tms"][int(flag / 8)] & 1 << (flag % 8) else 0
+                elif (flag < 50 and self.multiworld.tm_compatibility[self.player].value == 1) or (flag >= 50 and self.multiworld.hm_compatibility[self.player].value == 1):
                     type_match = poke_data.moves[tm_move]["type"] in [mon_data["type1"], mon_data["type2"]]
                     bit = int(self.multiworld.random.randint(1, 100) < [[90, 50, 25], [100, 75, 25]][flag >= 50][0 if type_match else 1 if poke_data.moves[tm_move]["type"] == "Normal" else 2])
                 elif (flag < 50 and self.multiworld.tm_compatibility[self.player].value == 2) or (flag >= 50 and self.multiworld.hm_compatibility[self.player].value == 2):
-                    bit = [0, 1][self.multiworld.random.randint(0, 1)]
+                    bit = self.multiworld.random.randint(0, 1)
                 elif (flag < 50 and self.multiworld.tm_compatibility[self.player].value == 3) or (flag >= 50 and self.multiworld.hm_compatibility[self.player].value == 3):
                     bit = 1
                 else:
@@ -390,6 +394,8 @@ def generate_output(self, output_directory: str):
     data[rom_addresses["Fossils_Needed_For_Second_Item"]] = (
         self.multiworld.second_fossil_check_condition[self.player].value)
 
+    data[rom_addresses["Option_Lose_Money"]] = int(not self.multiworld.lose_money_on_blackout[self.player].value)
+
     if self.multiworld.extra_key_items[self.player].value:
         data[rom_addresses['Options']] |= 4
     data[rom_addresses["Option_Blind_Trainers"]] = round(self.multiworld.blind_trainers[self.player].value * 2.55)
@@ -505,9 +511,9 @@ def generate_output(self, output_directory: str):
         inventory = ["Poke Ball", "Great Ball", "Ultra Ball"]
         if self.multiworld.better_shops[self.player].value == 2:
             inventory.append("Master Ball")
-        inventory += ["Potion", "Super Potion", "Hyper Potion", "Max Potion", "Full Restore", "Antidote", "Awakening",
-                      "Burn Heal", "Ice Heal", "Paralyze Heal", "Full Heal", "Repel", "Super Repel", "Max Repel",
-                      "Escape Rope"]
+        inventory += ["Potion", "Super Potion", "Hyper Potion", "Max Potion", "Full Restore", "Revive", "Antidote",
+                      "Awakening", "Burn Heal", "Ice Heal", "Paralyze Heal", "Full Heal", "Repel", "Super Repel",
+                      "Max Repel", "Escape Rope"]
         shop_data = bytearray([0xFE, len(inventory)])
         shop_data += bytearray([item_table[item].id - 172000000 for item in inventory])
         shop_data.append(0xFF)
diff --git a/worlds/pokemon_rb/rom_addresses.py b/worlds/pokemon_rb/rom_addresses.py
index b475b58ceec..30c38fa2407 100644
--- a/worlds/pokemon_rb/rom_addresses.py
+++ b/worlds/pokemon_rb/rom_addresses.py
@@ -113,27 +113,27 @@
     "Event_Rocket_Thief": 0x196cc,
     "Option_Cerulean_Cave_Condition": 0x1986c,
     "Event_Stranded_Man": 0x19b1f,
-    "Event_Rivals_Sister": 0x19ced,
-    "Option_Pokemon_League_Badges": 0x19e0a,
-    "Shop10": 0x19ee1,
-    "Trainersanity_EVENT_BEAT_SILPH_CO_4F_TRAINER_0_ITEM": 0x1a035,
-    "Trainersanity_EVENT_BEAT_SILPH_CO_4F_TRAINER_1_ITEM": 0x1a043,
-    "Trainersanity_EVENT_BEAT_SILPH_CO_4F_TRAINER_2_ITEM": 0x1a051,
-    "Missable_Silph_Co_4F_Item_1": 0x1a0f9,
-    "Missable_Silph_Co_4F_Item_2": 0x1a100,
-    "Missable_Silph_Co_4F_Item_3": 0x1a107,
-    "Trainersanity_EVENT_BEAT_SILPH_CO_5F_TRAINER_0_ITEM": 0x1a25f,
-    "Trainersanity_EVENT_BEAT_SILPH_CO_5F_TRAINER_1_ITEM": 0x1a26d,
-    "Trainersanity_EVENT_BEAT_SILPH_CO_5F_TRAINER_2_ITEM": 0x1a27b,
-    "Trainersanity_EVENT_BEAT_SILPH_CO_5F_TRAINER_3_ITEM": 0x1a289,
-    "Missable_Silph_Co_5F_Item_1": 0x1a361,
-    "Missable_Silph_Co_5F_Item_2": 0x1a368,
-    "Missable_Silph_Co_5F_Item_3": 0x1a36f,
-    "Trainersanity_EVENT_BEAT_SILPH_CO_6F_TRAINER_0_ITEM": 0x1a49f,
-    "Trainersanity_EVENT_BEAT_SILPH_CO_6F_TRAINER_1_ITEM": 0x1a4ad,
-    "Trainersanity_EVENT_BEAT_SILPH_CO_6F_TRAINER_2_ITEM": 0x1a4bb,
-    "Missable_Silph_Co_6F_Item_1": 0x1a5dd,
-    "Missable_Silph_Co_6F_Item_2": 0x1a5e4,
+    "Event_Rivals_Sister": 0x19cf2,
+    "Option_Pokemon_League_Badges": 0x19e0f,
+    "Shop10": 0x19ee6,
+    "Trainersanity_EVENT_BEAT_SILPH_CO_4F_TRAINER_0_ITEM": 0x1a03a,
+    "Trainersanity_EVENT_BEAT_SILPH_CO_4F_TRAINER_1_ITEM": 0x1a048,
+    "Trainersanity_EVENT_BEAT_SILPH_CO_4F_TRAINER_2_ITEM": 0x1a056,
+    "Missable_Silph_Co_4F_Item_1": 0x1a0fe,
+    "Missable_Silph_Co_4F_Item_2": 0x1a105,
+    "Missable_Silph_Co_4F_Item_3": 0x1a10c,
+    "Trainersanity_EVENT_BEAT_SILPH_CO_5F_TRAINER_0_ITEM": 0x1a264,
+    "Trainersanity_EVENT_BEAT_SILPH_CO_5F_TRAINER_1_ITEM": 0x1a272,
+    "Trainersanity_EVENT_BEAT_SILPH_CO_5F_TRAINER_2_ITEM": 0x1a280,
+    "Trainersanity_EVENT_BEAT_SILPH_CO_5F_TRAINER_3_ITEM": 0x1a28e,
+    "Missable_Silph_Co_5F_Item_1": 0x1a366,
+    "Missable_Silph_Co_5F_Item_2": 0x1a36d,
+    "Missable_Silph_Co_5F_Item_3": 0x1a374,
+    "Trainersanity_EVENT_BEAT_SILPH_CO_6F_TRAINER_0_ITEM": 0x1a4a4,
+    "Trainersanity_EVENT_BEAT_SILPH_CO_6F_TRAINER_1_ITEM": 0x1a4b2,
+    "Trainersanity_EVENT_BEAT_SILPH_CO_6F_TRAINER_2_ITEM": 0x1a4c0,
+    "Missable_Silph_Co_6F_Item_1": 0x1a5e2,
+    "Missable_Silph_Co_6F_Item_2": 0x1a5e9,
     "Event_Free_Sample": 0x1cad6,
     "Starter1_F": 0x1cca2,
     "Starter2_F": 0x1cca6,
@@ -838,46 +838,46 @@
     "Ghost_Battle2": 0x60c5c,
     "Missable_Pokemon_Tower_6F_Item_1": 0x60cd7,
     "Missable_Pokemon_Tower_6F_Item_2": 0x60cde,
-    "Trainersanity_EVENT_BEAT_POKEMONTOWER_7_TRAINER_0_ITEM": 0x60ea6,
-    "Trainersanity_EVENT_BEAT_POKEMONTOWER_7_TRAINER_1_ITEM": 0x60eb4,
-    "Trainersanity_EVENT_BEAT_POKEMONTOWER_7_TRAINER_2_ITEM": 0x60ec2,
-    "Gift_Aerodactyl": 0x610bc,
-    "Gift_Omanyte": 0x610c0,
-    "Gift_Kabuto": 0x610c4,
-    "Trainersanity_EVENT_BEAT_VIRIDIAN_FOREST_TRAINER_0_ITEM": 0x611a7,
-    "Trainersanity_EVENT_BEAT_VIRIDIAN_FOREST_TRAINER_1_ITEM": 0x611b5,
-    "Trainersanity_EVENT_BEAT_VIRIDIAN_FOREST_TRAINER_2_ITEM": 0x611c3,
-    "Missable_Viridian_Forest_Item_1": 0x6128a,
-    "Missable_Viridian_Forest_Item_2": 0x61291,
-    "Missable_Viridian_Forest_Item_3": 0x61298,
-    "Starter2_M": 0x614ae,
-    "Starter3_M": 0x614b6,
-    "Trainersanity_EVENT_BEAT_SS_ANNE_5_TRAINER_0_ITEM": 0x6173c,
-    "Trainersanity_EVENT_BEAT_SS_ANNE_5_TRAINER_1_ITEM": 0x6174a,
-    "Event_SS_Anne_Captain": 0x61925,
-    "Trainersanity_EVENT_BEAT_SS_ANNE_8_TRAINER_0_ITEM": 0x61a14,
-    "Trainersanity_EVENT_BEAT_SS_ANNE_8_TRAINER_1_ITEM": 0x61a22,
-    "Trainersanity_EVENT_BEAT_SS_ANNE_8_TRAINER_2_ITEM": 0x61a30,
-    "Trainersanity_EVENT_BEAT_SS_ANNE_8_TRAINER_3_ITEM": 0x61a3e,
-    "Missable_SS_Anne_1F_Item": 0x61b2a,
-    "Trainersanity_EVENT_BEAT_SS_ANNE_9_TRAINER_0_ITEM": 0x61bfb,
-    "Trainersanity_EVENT_BEAT_SS_ANNE_9_TRAINER_1_ITEM": 0x61c09,
-    "Trainersanity_EVENT_BEAT_SS_ANNE_9_TRAINER_2_ITEM": 0x61c17,
-    "Trainersanity_EVENT_BEAT_SS_ANNE_9_TRAINER_3_ITEM": 0x61c25,
-    "Missable_SS_Anne_2F_Item_1": 0x61d5f,
-    "Missable_SS_Anne_2F_Item_2": 0x61d72,
-    "Trainersanity_EVENT_BEAT_SS_ANNE_10_TRAINER_0_ITEM": 0x61e03,
-    "Trainersanity_EVENT_BEAT_SS_ANNE_10_TRAINER_1_ITEM": 0x61e11,
-    "Trainersanity_EVENT_BEAT_SS_ANNE_10_TRAINER_2_ITEM": 0x61e1f,
-    "Trainersanity_EVENT_BEAT_SS_ANNE_10_TRAINER_3_ITEM": 0x61e2d,
-    "Trainersanity_EVENT_BEAT_SS_ANNE_10_TRAINER_4_ITEM": 0x61e3b,
-    "Trainersanity_EVENT_BEAT_SS_ANNE_10_TRAINER_5_ITEM": 0x61e49,
-    "Missable_SS_Anne_B1F_Item_1": 0x61f61,
-    "Missable_SS_Anne_B1F_Item_2": 0x61f68,
-    "Missable_SS_Anne_B1F_Item_3": 0x61f6f,
-    "Trainersanity_EVENT_BEAT_SILPH_CO_11F_TRAINER_0_ITEM": 0x62330,
-    "Trainersanity_EVENT_BEAT_SILPH_CO_11F_TRAINER_1_ITEM": 0x6233e,
-    "Event_Silph_Co_President": 0x62351,
+    "Trainersanity_EVENT_BEAT_POKEMONTOWER_7_TRAINER_0_ITEM": 0x60eb2,
+    "Trainersanity_EVENT_BEAT_POKEMONTOWER_7_TRAINER_1_ITEM": 0x60ec0,
+    "Trainersanity_EVENT_BEAT_POKEMONTOWER_7_TRAINER_2_ITEM": 0x60ece,
+    "Gift_Aerodactyl": 0x610c8,
+    "Gift_Omanyte": 0x610cc,
+    "Gift_Kabuto": 0x610d0,
+    "Trainersanity_EVENT_BEAT_VIRIDIAN_FOREST_TRAINER_0_ITEM": 0x611b3,
+    "Trainersanity_EVENT_BEAT_VIRIDIAN_FOREST_TRAINER_1_ITEM": 0x611c1,
+    "Trainersanity_EVENT_BEAT_VIRIDIAN_FOREST_TRAINER_2_ITEM": 0x611cf,
+    "Missable_Viridian_Forest_Item_1": 0x61296,
+    "Missable_Viridian_Forest_Item_2": 0x6129d,
+    "Missable_Viridian_Forest_Item_3": 0x612a4,
+    "Starter2_M": 0x614ba,
+    "Starter3_M": 0x614c2,
+    "Trainersanity_EVENT_BEAT_SS_ANNE_5_TRAINER_0_ITEM": 0x61748,
+    "Trainersanity_EVENT_BEAT_SS_ANNE_5_TRAINER_1_ITEM": 0x61756,
+    "Event_SS_Anne_Captain": 0x61931,
+    "Trainersanity_EVENT_BEAT_SS_ANNE_8_TRAINER_0_ITEM": 0x61a20,
+    "Trainersanity_EVENT_BEAT_SS_ANNE_8_TRAINER_1_ITEM": 0x61a2e,
+    "Trainersanity_EVENT_BEAT_SS_ANNE_8_TRAINER_2_ITEM": 0x61a3c,
+    "Trainersanity_EVENT_BEAT_SS_ANNE_8_TRAINER_3_ITEM": 0x61a4a,
+    "Missable_SS_Anne_1F_Item": 0x61b36,
+    "Trainersanity_EVENT_BEAT_SS_ANNE_9_TRAINER_0_ITEM": 0x61c07,
+    "Trainersanity_EVENT_BEAT_SS_ANNE_9_TRAINER_1_ITEM": 0x61c15,
+    "Trainersanity_EVENT_BEAT_SS_ANNE_9_TRAINER_2_ITEM": 0x61c23,
+    "Trainersanity_EVENT_BEAT_SS_ANNE_9_TRAINER_3_ITEM": 0x61c31,
+    "Missable_SS_Anne_2F_Item_1": 0x61d6b,
+    "Missable_SS_Anne_2F_Item_2": 0x61d7e,
+    "Trainersanity_EVENT_BEAT_SS_ANNE_10_TRAINER_0_ITEM": 0x61e0f,
+    "Trainersanity_EVENT_BEAT_SS_ANNE_10_TRAINER_1_ITEM": 0x61e1d,
+    "Trainersanity_EVENT_BEAT_SS_ANNE_10_TRAINER_2_ITEM": 0x61e2b,
+    "Trainersanity_EVENT_BEAT_SS_ANNE_10_TRAINER_3_ITEM": 0x61e39,
+    "Trainersanity_EVENT_BEAT_SS_ANNE_10_TRAINER_4_ITEM": 0x61e47,
+    "Trainersanity_EVENT_BEAT_SS_ANNE_10_TRAINER_5_ITEM": 0x61e55,
+    "Missable_SS_Anne_B1F_Item_1": 0x61f6d,
+    "Missable_SS_Anne_B1F_Item_2": 0x61f74,
+    "Missable_SS_Anne_B1F_Item_3": 0x61f7b,
+    "Trainersanity_EVENT_BEAT_SILPH_CO_11F_TRAINER_0_ITEM": 0x6233c,
+    "Trainersanity_EVENT_BEAT_SILPH_CO_11F_TRAINER_1_ITEM": 0x6234a,
+    "Event_Silph_Co_President": 0x6235d,
     "Ghost_Battle4": 0x708e1,
     "Badge_Viridian_Gym": 0x749f7,
     "Event_Viridian_Gym": 0x74a0b,
diff --git a/worlds/pokemon_rb/rules.py b/worlds/pokemon_rb/rules.py
index e24eaf5e2ea..493a58e5946 100644
--- a/worlds/pokemon_rb/rules.py
+++ b/worlds/pokemon_rb/rules.py
@@ -119,7 +119,8 @@ def set_rules(world, player):
         "Route 10 - Hidden Item Bush": lambda state: state.pokemon_rb_can_get_hidden_items(player),
         "Rocket Hideout B1F - Hidden Item Pot Plant": lambda state: state.pokemon_rb_can_get_hidden_items(player),
         "Rocket Hideout B3F - Hidden Item Near East Item": lambda state: state.pokemon_rb_can_get_hidden_items(player),
-        "Rocket Hideout B4F - Hidden Item Behind Giovanni": lambda state: state.pokemon_rb_can_get_hidden_items(player),
+        "Rocket Hideout B4F - Hidden Item Behind Giovanni (Lift Key)": lambda state:
+            state.pokemon_rb_can_get_hidden_items(player) and state.has("Lift Key", player),
         "Pokemon Tower 5F - Hidden Item Near West Staircase": lambda state: state.pokemon_rb_can_get_hidden_items(
             player),
         "Route 13 - Hidden Item Dead End Bush": lambda state: state.pokemon_rb_can_get_hidden_items(player),
diff --git a/worlds/rogue_legacy/Rules.py b/worlds/rogue_legacy/Rules.py
index 4ddf24c745f..90f6cc08b1f 100644
--- a/worlds/rogue_legacy/Rules.py
+++ b/worlds/rogue_legacy/Rules.py
@@ -1,4 +1,4 @@
-from BaseClasses import MultiWorld, CollectionState
+from BaseClasses import CollectionState, MultiWorld
 
 
 def get_upgrade_total(multiworld: MultiWorld, player: int) -> int:
@@ -20,7 +20,7 @@ def has_upgrade_amount(state: CollectionState, player: int, amount: int) -> bool
 
 
 def has_upgrades_percentage(state: CollectionState, player: int, percentage: float) -> bool:
-    return has_upgrade_amount(state, player, get_upgrade_total(state.multiworld, player) * (round(percentage) // 100))
+    return has_upgrade_amount(state, player, round(get_upgrade_total(state.multiworld, player) * (percentage / 100)))
 
 
 def has_movement_rune(state: CollectionState, player: int) -> bool:
diff --git a/worlds/ror2/__init__.py b/worlds/ror2/__init__.py
index 0c84f5b1b30..c1b775cfbcf 100644
--- a/worlds/ror2/__init__.py
+++ b/worlds/ror2/__init__.py
@@ -1,13 +1,13 @@
 import string
 from typing import Dict, List
-from .Items import RiskOfRainItem, item_table, item_pool_weights
+
+from BaseClasses import Entrance, Item, ItemClassification, MultiWorld, Region, RegionType, Tutorial
+from worlds.AutoWorld import WebWorld, World
+from .Items import RiskOfRainItem, item_pool_weights, item_table
 from .Locations import RiskOfRainLocation, item_pickups
+from .Options import ItemWeights, ror2_options
 from .Rules import set_rules
 
-from BaseClasses import Region, RegionType, Entrance, Item, ItemClassification, MultiWorld, Tutorial
-from .Options import ror2_options, ItemWeights
-from worlds.AutoWorld import World, WebWorld
-
 client_version = 1
 
 
@@ -36,7 +36,6 @@ class RiskOfRainWorld(World):
     location_name_to_id = item_pickups
 
     data_version = 4
-    forced_auto_forfeit = True
     web = RiskOfWeb()
     total_revivals: int
 
diff --git a/worlds/sa2b/Regions.py b/worlds/sa2b/Regions.py
index 8d3ceb91e29..713d38ea4da 100644
--- a/worlds/sa2b/Regions.py
+++ b/worlds/sa2b/Regions.py
@@ -873,7 +873,7 @@ def connect_regions(world, player, gates: typing.List[LevelGate], cannon_core_em
 
     gates_len = len(gates)
     if gates_len >= 2:
-        connect(world, player, names, 'Menu', LocationName.gate_1_boss_region,
+        connect(world, player, names, LocationName.gate_0_region, LocationName.gate_1_boss_region,
                 lambda state: (state.has(ItemName.emblem, player, gates[1].gate_emblem_count)))
 
         if gate_bosses[1] == all_gate_bosses_table[king_boom_boo]:
@@ -886,7 +886,7 @@ def connect_regions(world, player, gates: typing.List[LevelGate], cannon_core_em
             connect(world, player, names, LocationName.gate_1_region, shuffleable_regions[gates[1].gate_levels[i]])
 
     if gates_len >= 3:
-        connect(world, player, names, 'Menu', LocationName.gate_2_boss_region,
+        connect(world, player, names, LocationName.gate_1_region, LocationName.gate_2_boss_region,
                 lambda state: (state.has(ItemName.emblem, player, gates[2].gate_emblem_count)))
 
         if gate_bosses[2] == all_gate_bosses_table[king_boom_boo]:
@@ -899,7 +899,7 @@ def connect_regions(world, player, gates: typing.List[LevelGate], cannon_core_em
             connect(world, player, names, LocationName.gate_2_region, shuffleable_regions[gates[2].gate_levels[i]])
 
     if gates_len >= 4:
-        connect(world, player, names, 'Menu', LocationName.gate_3_boss_region,
+        connect(world, player, names, LocationName.gate_2_region, LocationName.gate_3_boss_region,
                 lambda state: (state.has(ItemName.emblem, player, gates[3].gate_emblem_count)))
 
         if gate_bosses[3] == all_gate_bosses_table[king_boom_boo]:
@@ -912,7 +912,7 @@ def connect_regions(world, player, gates: typing.List[LevelGate], cannon_core_em
             connect(world, player, names, LocationName.gate_3_region, shuffleable_regions[gates[3].gate_levels[i]])
 
     if gates_len >= 5:
-        connect(world, player, names, 'Menu', LocationName.gate_4_boss_region,
+        connect(world, player, names, LocationName.gate_3_region, LocationName.gate_4_boss_region,
                 lambda state: (state.has(ItemName.emblem, player, gates[4].gate_emblem_count)))
 
         if gate_bosses[4] == all_gate_bosses_table[king_boom_boo]:
@@ -925,7 +925,7 @@ def connect_regions(world, player, gates: typing.List[LevelGate], cannon_core_em
             connect(world, player, names, LocationName.gate_4_region, shuffleable_regions[gates[4].gate_levels[i]])
 
     if gates_len >= 6:
-        connect(world, player, names, 'Menu', LocationName.gate_5_boss_region,
+        connect(world, player, names, LocationName.gate_4_region, LocationName.gate_5_boss_region,
                 lambda state: (state.has(ItemName.emblem, player, gates[5].gate_emblem_count)))
 
         if gate_bosses[5] == all_gate_bosses_table[king_boom_boo]:
diff --git a/worlds/sa2b/__init__.py b/worlds/sa2b/__init__.py
index 95e85ee36db..dad7503e0ee 100644
--- a/worlds/sa2b/__init__.py
+++ b/worlds/sa2b/__init__.py
@@ -24,7 +24,7 @@ class SA2BWeb(WebWorld):
         "English",
         "setup_en.md",
         "setup/en",
-        ["RaspberrySpaceJam", "PoryGone"]
+        ["RaspberrySpaceJam", "PoryGone", "Entiss"]
     )
     
     tutorials = [setup_en]
diff --git a/worlds/sa2b/docs/setup_en.md b/worlds/sa2b/docs/setup_en.md
index 41a48e66aef..2ac00a3fb83 100644
--- a/worlds/sa2b/docs/setup_en.md
+++ b/worlds/sa2b/docs/setup_en.md
@@ -16,7 +16,7 @@
 - Quality of life mods
 	- SA2 Volume Controls from: [SA2 Volume Controls Release Page] (https://gamebanana.com/mods/381193)
 
-## Installation Procedures
+## Installation Procedures (Windows)
 
 1. Install Sonic Adventure 2: Battle from Steam.
 
@@ -32,6 +32,26 @@
 
 7. Launch the `SA2ModManager.exe` and make sure the SA2B_Archipelago mod is listed and enabled.
 
+## Installation Procedures (Linux and Steam Deck)
+
+1. Install Sonic Adventure 2: Battle from Steam.
+
+2. In the properties for Sonic Adventure 2 on Steam, force the use of Proton Experimental as the compatibility tool.
+
+3. Launch the game at least once without mods.
+
+4. Install Sonic Adventure 2 Mod Loader as per its instructions. To launch it, add ``SA2ModManager.exe`` as a non-Steam game. In the properties on Steam for Sonic Adventure 2 Mod Loader, set it to use Proton as the compatibility tool.
+
+5. The folder you installed the Sonic Adventure 2 Mod Loader into will now have a `/mods` directory.
+
+6. Unpack the Archipelago Mod into this folder, so that `/mods/SA2B_Archipelago` is a valid path.
+
+7. In the SA2B_Archipelago folder, copy the `APCpp.dll` file and paste it in the Sonic Adventure 2 install folder (where `SA2ModManager.exe` is).
+
+8. Launch the `SA2ModManager.exe` from Steam and make sure the SA2B_Archipelago mod is listed and enabled.
+
+Note: Ensure that you launch Sonic Adventure 2 from Steam directly on Linux, rather than launching using the `Save & Play` button in Sonic Adventure 2 Mod Loader.
+
 ## Joining a MultiWorld Game
 
 1. Before launching the game, run the `SA2ModManager.exe`, select the SA2B_Archipelago mod, and hit the `Configure...` button.
@@ -42,7 +62,7 @@
 
 4. For the `Password` field under `AP Settings`, enter the server password if one exists, otherwise leave blank.
 
-5. Click The `Save` button then hit `Save & Play` to launch the game.
+5. Click The `Save` button then hit `Save & Play` to launch the game. On Linux, launch Sonic Adventure 2 from Steam directly rather than using `Save & Play`.
 
 6. Create a new save to connect to the MultiWorld game. A "Connected to Archipelago" message will appear if you sucessfully connect. If you close the game during play, you can reconnect to the MultiWorld game by selecting the same save file slot.
 
diff --git a/worlds/sm/variaRandomizer/rando/RandoSettings.py b/worlds/sm/variaRandomizer/rando/RandoSettings.py
index 7699a5b67c6..a2ce5908ed9 100644
--- a/worlds/sm/variaRandomizer/rando/RandoSettings.py
+++ b/worlds/sm/variaRandomizer/rando/RandoSettings.py
@@ -10,7 +10,7 @@
 # Holds settings not related to graph layout.
 class RandoSettings(object):
     def __init__(self, maxDiff, progSpeed, progDiff, qty, restrictions,
-                 superFun, runtimeLimit_s, plandoSettings, minDiff):
+                 superFun, runtimeLimit_s, PlandoOptions, minDiff):
         self.progSpeed = progSpeed.lower()
         self.progDiff = progDiff.lower()
         self.maxDiff = maxDiff
@@ -20,7 +20,7 @@ def __init__(self, maxDiff, progSpeed, progDiff, qty, restrictions,
         self.runtimeLimit_s = runtimeLimit_s
         if self.runtimeLimit_s <= 0:
             self.runtimeLimit_s = sys.maxsize
-        self.plandoSettings = plandoSettings
+        self.PlandoOptions = PlandoOptions
         self.minDiff = minDiff
 
     def getSuperFun(self):
@@ -30,7 +30,7 @@ def updateSuperFun(self, superFun):
         self.superFun = superFun[:]
 
     def isPlandoRando(self):
-        return self.plandoSettings is not None
+        return self.PlandoOptions is not None
 
     def getItemManager(self, smbm, nLocs):
         if not self.isPlandoRando():
@@ -43,20 +43,20 @@ def getExcludeItems(self, locations):
             return None
         exclude = {'alreadyPlacedItems': defaultdict(int), 'forbiddenItems': []}
         # locsItems is a dict {'loc name': 'item type'}
-        for locName,itemType in self.plandoSettings["locsItems"].items():
+        for locName,itemType in self.PlandoOptions["locsItems"].items():
             if not any(loc.Name == locName for loc in locations):
                 continue
             exclude['alreadyPlacedItems'][itemType] += 1
             exclude['alreadyPlacedItems']['total'] += 1
 
-        exclude['forbiddenItems'] = self.plandoSettings['forbiddenItems']
+        exclude['forbiddenItems'] = self.PlandoOptions['forbiddenItems']
 
         return exclude
 
     def collectAlreadyPlacedItemLocations(self, container):
         if not self.isPlandoRando():
             return
-        for locName,itemType in self.plandoSettings["locsItems"].items():
+        for locName,itemType in self.PlandoOptions["locsItems"].items():
             if not any(loc.Name == locName for loc in container.unusedLocations):
                 continue
             item = container.getNextItemInPool(itemType)
diff --git a/worlds/sm/variaRandomizer/randomizer.py b/worlds/sm/variaRandomizer/randomizer.py
index 3f6a9cc5fa7..854e76b3dbb 100644
--- a/worlds/sm/variaRandomizer/randomizer.py
+++ b/worlds/sm/variaRandomizer/randomizer.py
@@ -621,7 +621,7 @@ def forceArg(arg, value, msg, altValue=None, webArg=None, webValue=None):
         self.ctrlDict = { getattr(ctrl, button) : button for button in ctrlButton }
         args.moonWalk = ctrl.Moonwalk
 
-        plandoSettings = None
+        PlandoOptions = None
         if args.plandoRando is not None:
             forceArg('progressionSpeed', 'speedrun', "'Progression Speed' forced to speedrun")
             progSpeed = 'speedrun'
@@ -632,10 +632,10 @@ def forceArg(arg, value, msg, altValue=None, webArg=None, webValue=None):
             args.plandoRando = json.loads(args.plandoRando)
             RomPatches.ActivePatches[self.player] = args.plandoRando["patches"]
             DoorsManager.unserialize(args.plandoRando["doors"])
-            plandoSettings = {"locsItems": args.plandoRando['locsItems'], "forbiddenItems": args.plandoRando['forbiddenItems']}
+            PlandoOptions = {"locsItems": args.plandoRando['locsItems'], "forbiddenItems": args.plandoRando['forbiddenItems']}
         randoSettings = RandoSettings(self.maxDifficulty, progSpeed, progDiff, qty,
                                     restrictions, args.superFun, args.runtimeLimit_s,
-                                    plandoSettings, minDifficulty)
+                                    PlandoOptions, minDifficulty)
 
         # print some parameters for jm's stats
         if args.jm == True:
diff --git a/worlds/spire/__init__.py b/worlds/spire/__init__.py
index d923ce75ffb..237e6775003 100644
--- a/worlds/spire/__init__.py
+++ b/worlds/spire/__init__.py
@@ -1,12 +1,12 @@
 import string
 
-from BaseClasses import Item, MultiWorld, Region, Location, Entrance, Tutorial, ItemClassification, RegionType
-from .Items import item_table, item_pool, event_item_pairs
+from BaseClasses import Entrance, Item, ItemClassification, Location, MultiWorld, Region, RegionType, Tutorial
+from .Items import event_item_pairs, item_pool, item_table
 from .Locations import location_table
+from .Options import spire_options
 from .Regions import create_regions
 from .Rules import set_rules
-from ..AutoWorld import World, WebWorld
-from .Options import spire_options
+from ..AutoWorld import WebWorld, World
 
 
 class SpireWeb(WebWorld):
@@ -36,8 +36,6 @@ class SpireWorld(World):
     item_name_to_id = {name: data.code for name, data in item_table.items()}
     location_name_to_id = location_table
 
-    forced_auto_forfeit = True
-
     def _get_slot_data(self):
         return {
             'seed': "".join(self.multiworld.slot_seeds[self.player].choice(string.ascii_letters) for i in range(16)),
diff --git a/worlds/subnautica/Options.py b/worlds/subnautica/Options.py
index deef33d625a..03834cdbbad 100644
--- a/worlds/subnautica/Options.py
+++ b/worlds/subnautica/Options.py
@@ -31,8 +31,8 @@ def consider_items(self) -> bool:
 
 
 class EarlySeaglide(DefaultOnToggle):
-    display_name = "Early Seaglide"
     """Make sure 2 of the Seaglide Fragments are available in or near the Safe Shallows (Sphere 1 Locations)."""
+    display_name = "Early Seaglide"
 
 
 class ItemPool(Choice):
diff --git a/worlds/subnautica/__init__.py b/worlds/subnautica/__init__.py
index 0f793af913e..116450a3aec 100644
--- a/worlds/subnautica/__init__.py
+++ b/worlds/subnautica/__init__.py
@@ -47,7 +47,7 @@ class SubnauticaWorld(World):
     creatures_to_scan: List[str]
 
     def generate_early(self) -> None:
-        if self.multiworld.early_seaglide:
+        if self.multiworld.early_seaglide[self.player]:
             self.multiworld.local_early_items[self.player]["Seaglide Fragment"] = 2
 
         scan_option: Options.AggressiveScanLogic = self.multiworld.creature_scan_logic[self.player]
diff --git a/worlds/subnautica/docs/setup_en.md b/worlds/subnautica/docs/setup_en.md
index f6ce09ebe8c..a9403cf11be 100644
--- a/worlds/subnautica/docs/setup_en.md
+++ b/worlds/subnautica/docs/setup_en.md
@@ -12,6 +12,8 @@
 
 2. Start Subnautica. You should see a connect form with three text boxes in the top left of your main menu.
 
+**If using Linux,** add ``WINEDLLOVERRIDES="winhttp=n,b" %command%`` to your Subnautica launch arguments on Steam. If you bought Subnautica elsewhere, you can either add it as a non-steam game and use those launch arguments or use winecfg to set the dll override.
+
 ## Connecting
 
 Use the connect form in Subnautica's main menu to enter your connection information to connect to an Archipelago multiworld.
@@ -33,18 +35,19 @@ Warning: Currently it is not checked whether a loaded savegame belongs to the mu
 ## Console Commands
 
 The mod adds the following console commands:
- - `say` sends the text following it to Archipelago as a chat message. ! is not an allowed character, use / instead.
- - `silent` toggles Archipelago chat messages appearing.
+ - `say` sends the text following it to Archipelago as a chat message.
+   - `!` is not an allowed character, use `/` in its place. For example, to use the [`!hint` command](/tutorial/Archipelago/commands/en#remote-commands), type `say /hint`.
+ - `silent` toggles Archipelago messages appearing.
+ - `tracker` rotates through the possible settings for the in-game tracker that displays the closest uncollected location.
  - `deathlink` toggles death link.
 
-To enable the console in Subnautica, press `F3` and `F8`, then uncheck "Disable Console" in the top left. Press `F3` and `F8` again to close the menus.
-To enter a console command, press `Enter`.
+To enable the console in Subnautica, press `Shift+Enter`.
 
 ## Known Issues
 
 - Do not attempt playing vanilla saves while the mod is installed, as the mod will override the scan information of the savegame.
 - When exiting to the main menu the mod's state is not properly reset. Loading a savegame from here will break various things.
-  If you want to reload a save it is recommended you restart the game entirely.
+  If you want to reload a save it is recommended you relaunch the game entirely.
 - Attempting to load a savegame containing no longer valid connection information without entering valid information on the main menu will hang on the loading screen.
 
 ## Troubleshooting
diff --git a/worlds/zillion/requirements.txt b/worlds/zillion/requirements.txt
index 501b3a7aef3..964016fd3fd 100644
--- a/worlds/zillion/requirements.txt
+++ b/worlds/zillion/requirements.txt
@@ -1 +1 @@
-git+https://github.com/beauxq/zilliandomizer@a0fd0a1199c0234756b8637420c1e46434c687f0#egg=zilliandomizer==0.5.0
+git+https://github.com/beauxq/zilliandomizer@23d938daa5aaeaa3ec2255c50f2729b33a9e7f87#egg=zilliandomizer==0.5.1