14 files changed, 661 insertions, 241 deletions

@@ -7,7 +7,7 @@ from BaseClasses import ItemClassification, Item, Tutorial
 from Options import OptionError
 from settings import Group, UserFilePath
 from worlds.AutoWorld import WebWorld, World
-from .items import Lingo2Item, ANTI_COLLECTABLE_TRAPS
+from .items import Lingo2Item, ANTI_COLLECTABLE_TRAPS, ALL_LETTERS_UPPER
 from .options import Lingo2Options
 from .player_logic import Lingo2PlayerLogic
 from .regions import create_regions, shuffle_entrances, connect_ports_from_ut
@@ -70,7 +70,14 @@ class Lingo2World(World):
         self.player_logic = Lingo2PlayerLogic(self)
         self.port_pairings = {}
 
+        if self.options.restrict_letter_placements:
+            self.options.local_items.value |= set(ALL_LETTERS_UPPER)
+
     def create_regions(self):
+        if hasattr(self.multiworld, "re_gen_passthrough") and "Lingo 2" in self.multiworld.re_gen_passthrough:
+            self.player_logic.rte_mapping = [self.world.static_logic.map_id_by_name[map_name]
+                                             for map_name in self.multiworld.re_gen_passthrough["Lingo 2"]["rte"]]
+
         create_regions(self)
 
     def connect_entrances(self):
@@ -124,11 +131,14 @@ class Lingo2World(World):
             self.push_precollected(self.create_item(name))
 
     def create_item(self, name: str) -> Item:
-        return Lingo2Item(name, ItemClassification.filler if name == self.get_filler_item_name() else
+        item = Lingo2Item(name, ItemClassification.filler if name == self.get_filler_item_name() else
                                 ItemClassification.trap if name in ANTI_COLLECTABLE_TRAPS else
                                 ItemClassification.progression,
                           self.item_name_to_id.get(name), self.player)
 
+        item.is_letter = (name in ALL_LETTERS_UPPER)
+        return item
+
     def set_rules(self):
         self.multiworld.completion_condition[self.player] = lambda state: state.has("Victory", self.player)
 
@@ -140,12 +150,14 @@ class Lingo2World(World):
             "enable_gift_maps",
             "enable_icarus",
             "endings_requirement",
+            "fast_travel_access",
             "keyholder_sanity",
             "masteries_requirement",
             "shuffle_control_center_colors",
             "shuffle_doors",
             "shuffle_gallery_paintings",
             "shuffle_letters",
+            "shuffle_music",
             "shuffle_symbols",
             "shuffle_worldports",
             "strict_cyan_ending",
@@ -155,6 +167,9 @@ class Lingo2World(World):
 
         slot_data: dict[str, object] = {
             **self.options.as_dict(*slot_options),
+            "custom_mint_ending": self.player_logic.custom_mint_ending or "",
+            "rte": [self.static_logic.objects.maps[map_id].name for map_id in self.player_logic.rte_mapping],
+            "seed": self.random.randint(0, 1000000),
             "version": self.static_logic.get_data_version(),
         }
 
@@ -16,6 +16,7 @@ var anti_trap_ids = {}
 var location_name_by_id = {}
 var ending_display_name_by_name = {}
 var port_id_by_ap_id = {}
+var map_id_by_rte_ap_id = {}
 
 var kSYMBOL_ITEMS
 
@@ -57,6 +58,9 @@ func load(data_bytes):
         for map in objects.get_maps():
                 map_id_by_name[map.get_name()] = map.get_id()
 
+                if map.has_rte_ap_id():
+                        map_id_by_rte_ap_id[map.get_rte_ap_id()] = map.get_id()
+
         for door in objects.get_doors():
                 var map = objects.get_maps()[door.get_map_id()]
 
@@ -300,3 +304,7 @@ func _get_keyholder_location_name(keyholder):
                 "%s - %s Keyholder"
                 % [_get_room_object_location_prefix(keyholder), keyholder.get_key().to_upper()]
         )
+
+
+func vec3d_to_vector3(input) -> Vector3:
+        return Vector3(input.get_x(), input.get_y(), input.get_z())
@@ -46,6 +46,10 @@ const kCYAN_DOOR_BEHAVIOR_H2 = 0
 const kCYAN_DOOR_BEHAVIOR_DOUBLE_LETTER = 1
 const kCYAN_DOOR_BEHAVIOR_ITEM = 2
 
+const kFAST_TRAVEL_ACCESS_VANILLA = 0
+const kFAST_TRAVEL_ACCESS_UNLOCKED = 1
+const kFAST_TRAVEL_ACCESS_ITEMS = 2
+
 const kEndingNameByVictoryValue = {
         0: "GRAY",
         1: "PURPLE",
@@ -63,21 +67,26 @@ const kEndingNameByVictoryValue = {
 }
 
 var apworld_version = [0, 0, 0]
+var custom_mint_ending = ""
 var cyan_door_behavior = kCYAN_DOOR_BEHAVIOR_H2
 var daedalus_only = false
 var daedalus_roof_access = false
 var enable_gift_maps = []
 var enable_icarus = false
 var endings_requirement = 0
+var fast_travel_access = 0
 var keyholder_sanity = false
 var masteries_requirement = 0
+var music_mapping = {}
 var port_pairings = {}
+var rte_mapping = []
 var shuffle_control_center_colors = false
 var shuffle_doors = false
 var shuffle_gallery_paintings = false
 var shuffle_letters = kSHUFFLE_LETTERS_VANILLA
 var shuffle_symbols = false
 var shuffle_worldports = false
+var slot_rng = null
 var strict_cyan_ending = false
 var strict_purple_ending = false
 var victory_condition = -1
@@ -269,6 +278,13 @@ func _process_item(item, amount):
         if item_id == gamedata.objects.get_special_ids()["Numbers"] and global.map == "the_fuzzy":
                 global.allow_numbers = true
 
+        if gamedata.map_id_by_rte_ap_id.has(item_id):
+                var rteInner = get_tree().get_root().get_node_or_null(
+                        "scene/player/pause_menu/menu/return/rteInner"
+                )
+                if rteInner != null:
+                        rteInner.refreshButtons()
+
         # Show a message about the item if it's new.
         if int(item["index"]) > _last_new_item:
                 _last_new_item = int(item["index"])
@@ -463,12 +479,14 @@ func _client_connected(slot_data):
                         _last_new_item = localdata[0]
 
         # Read slot data.
+        custom_mint_ending = slot_data.get("custom_mint_ending", "")
         cyan_door_behavior = int(slot_data.get("cyan_door_behavior", 0))
         daedalus_only = bool(slot_data.get("daedalus_only", false))
         daedalus_roof_access = bool(slot_data.get("daedalus_roof_access", false))
         enable_gift_maps = slot_data.get("enable_gift_maps", [])
         enable_icarus = bool(slot_data.get("enable_icarus", false))
         endings_requirement = int(slot_data.get("endings_requirement", 0))
+        fast_travel_access = int(slot_data.get("fast_travel_access", 0))
         keyholder_sanity = bool(slot_data.get("keyholder_sanity", false))
         masteries_requirement = int(slot_data.get("masteries_requirement", 0))
         shuffle_control_center_colors = bool(slot_data.get("shuffle_control_center_colors", false))
@@ -496,6 +514,19 @@ func _client_connected(slot_data):
                                 raw_pp[p1]
                         )]
 
+        rte_mapping.clear()
+        if slot_data.has("rte"):
+                rte_mapping = slot_data.get("rte")
+
+        slot_rng = RandomNumberGenerator.new()
+        slot_rng.seed = int(slot_data.get("seed", 0))
+
+        music_mapping.clear()
+        if bool(slot_data.get("shuffle_music", false)):
+                for map_name in global.reserved_scenes:
+                        var track_index = slot_rng.randi_range(0, musicPlayer.all_tracks.size() - 1)
+                        music_mapping[map_name] = musicPlayer.all_tracks.keys()[track_index]
+
         # Set up item locks.
         _item_locks = {}
 
@@ -74,6 +74,61 @@ func on_map_load(root):
                 old_door.queue_free()
                 root.get_node("/root/scene/Components/Doors").add_child.call_deferred(new_door)
 
+        # Display White Ending requirements.
+        var ending_count = 0
+        var mastery_count = 0
+        for key in unlocks.data:
+                if unlocks.data[key] == "unlocked":
+                        if key.ends_with("_ending") and key != "free_ending":
+                                ending_count += 1
+                        elif key.ends_with("_mastery"):
+                                mastery_count += 1
+
+        var sign_prefab = preload("res://objects/nodes/sign.tscn")
+        var sign1 = sign_prefab.instantiate()
+        sign1.position = Vector3(87.5, 5, -42.01)
+        sign1.text = "Endings: %d/%d" % [ending_count, ap.endings_requirement]
+        root.get_node("/root/scene").add_child.call_deferred(sign1)
+
+        var sign2 = sign_prefab.instantiate()
+        sign2.position = Vector3(87.5, 5, -15.99)
+        sign2.rotation_degrees.y = 180
+        sign2.text = "Masteries: %d/%d" % [mastery_count, ap.masteries_requirement]
+        root.get_node("/root/scene").add_child.call_deferred(sign2)
+
+        # Handle custom Mint Ending.
+        if ap.custom_mint_ending != "":
+                var panel_prefab = preload("res://objects/nodes/panel.tscn")
+                var tpl_prefab = preload("res://objects/nodes/listeners/teleportListener.tscn")
+
+                var mint_ending = root.get_node("/root/scene/Components/Endings/mint_ending")
+
+                var mint_panel = panel_prefab.instantiate()
+                mint_panel.name = "mint_panel"
+                mint_panel.clue = ap.custom_mint_ending
+                mint_panel.symbol = ""
+                mint_panel.answer = ap.custom_mint_ending
+                mint_panel.position = Vector3(-63, 3, -29)
+                mint_panel.rotation_degrees = Vector3(-45, 90, 0)
+                root.get_node("/root/scene").add_child.call_deferred(mint_panel)
+
+                var mint_tpl = tpl_prefab.instantiate()
+                mint_tpl.name = "mint_tpl"
+                mint_tpl.teleport_point = mint_ending.position
+                mint_tpl.teleport_rotate = mint_ending.rotation_degrees
+                mint_tpl.target_path = mint_ending
+                mint_tpl.senders.append(NodePath("/root/scene/mint_panel"))
+                root.get_node("/root/scene").add_child.call_deferred(mint_tpl)
+
+                var mint_tpl2 = tpl_prefab.instantiate()
+                mint_tpl2.name = "mint_tpl2"
+                mint_tpl2.teleport_point = Vector3(0, -1000, 0)
+                mint_tpl2.target_path = mint_panel
+                mint_tpl2.senders.append(NodePath("/root/scene/mint_panel"))
+                root.get_node("/root/scene").add_child.call_deferred(mint_tpl2)
+
+                mint_ending.position.y = -1000
+
 
 func _set_up_mastery_listener(root, name):
         var prefab = preload("res://objects/nodes/listeners/unlockReaderListener.tscn")
@@ -13,6 +13,8 @@ func _ready():
 
         var ap = global.get_node("Archipelago")
         var gamedata = global.get_node("Gamedata")
+        var map_id = gamedata.map_id_by_name.get(global.map)
+        var map_data = gamedata.objects.get_maps()[map_id]
 
         compass = global.get_node("Compass")
         compass.visible = ap.show_compass
@@ -26,8 +28,33 @@ func _ready():
 
         ap.update_job_well_done_sign()
 
+        # Set up the RTE trigger, if there is one.
+        if map_data.has_rte_trigger_pos():
+                var oneShotListener_prefab = preload("res://objects/nodes/listeners/oneShotListener.tscn")
+                var triggerArea_prefab = preload("res://objects/nodes/triggerArea.tscn")
+                var unlockSetterListener_prefab = preload(
+                        "res://objects/nodes/listeners/unlockSetterListener.tscn"
+                )
+
+                var triggerArea = triggerArea_prefab.instantiate()
+                triggerArea.name = "rte_triggerArea"
+                triggerArea.position = gamedata.vec3d_to_vector3(map_data.get_rte_trigger_pos())
+                triggerArea.scale = gamedata.vec3d_to_vector3(map_data.get_rte_trigger_scale())
+                get_parent().add_child.call_deferred(triggerArea)
+
+                var osl = oneShotListener_prefab.instantiate()
+                osl.name = "rte_osl"
+                osl.senders.append(NodePath("/root/scene/rte_triggerArea"))
+                get_parent().add_child.call_deferred(osl)
+
+                var usl = unlockSetterListener_prefab.instantiate()
+                usl.name = "rte_usl"
+                usl.key = "rte_%s" % global.map
+                usl.value = "unlocked"
+                usl.senders.append(NodePath("/root/scene/rte_osl"))
+                get_parent().add_child.call_deferred(usl)
+
         # Set up door locations.
-        var map_id = gamedata.map_id_by_name.get(global.map)
         for door in gamedata.objects.get_doors():
                 if door.get_map_id() != map_id:
                         continue
@@ -169,6 +196,17 @@ func _ready():
         minimap.visible = ap.show_minimap
         get_parent().add_child.call_deferred(minimap)
 
+        if ap.music_mapping.has(global.map):
+                var song_setter = get_node_or_null("/root/scene/songSetter")
+                if song_setter:
+                        song_setter.song_name = ap.music_mapping[global.map]
+                else:
+                        var song_setter_prefab = preload("res://objects/nodes/songSetter.tscn")
+                        song_setter = song_setter_prefab.instantiate()
+                        song_setter.name = "songSetter"
+                        song_setter.song_name = ap.music_mapping[global.map]
+                        get_parent().add_child.call_deferred(song_setter)
+
         super._ready()
 
         await get_tree().process_frame
@@ -1,5 +1,7 @@
 extends "res://scripts/ui/rteMenu.gd"
 
+var buttons = []
+
 
 func _readier():
         var ap = global.get_node("Archipelago")
@@ -8,5 +10,58 @@ func _readier():
                 get_node("rte_daedalus").show()
 
                 switcher.preload_map("res://objects/scenes/daedalus.tscn")
+        elif !ap.rte_mapping.is_empty():
+                buttons = [$rte_the_plaza, $rte_the_gallery, $rte_daedalus, $rte_control_center]
+                for i in range(4):
+                        buttons[i].name = "button_%d" % i
+                for i in range(4):
+                        _setupButton(buttons[i], ap.rte_mapping[i])
+
+                refreshButtons()
         else:
                 super()._readier()
+
+
+func _setupButton(button, map_name):
+        switcher.preload_map("res://objects/scenes/%s.tscn" % map_name)
+
+        button.hide()
+        button.text = map_name.replace("_", " ")
+        button.name = "rte_%s" % map_name
+        button.autowrap_mode = TextServer.AUTOWRAP_WORD
+
+        var ap = global.get_node("Archipelago")
+        if (
+                ap.fast_travel_access == ap.kFAST_TRAVEL_ACCESS_VANILLA
+                and !unlocks.data.has("rte_%s" % map_name)
+        ):
+                unlocks.data["rte_%s" % map_name] = ""
+
+
+func refreshButtons():
+        var ap = global.get_node("Archipelago")
+        if ap.rte_mapping.is_empty():
+                return
+
+        for i in range(4):
+                if _shouldShowButton(ap.rte_mapping[i]):
+                        buttons[i].show()
+                else:
+                        buttons[i].hide()
+
+
+func _shouldShowButton(map_name):
+        var ap = global.get_node("Archipelago")
+
+        if ap.fast_travel_access == ap.kFAST_TRAVEL_ACCESS_VANILLA:
+                return unlocks.data["rte_%s" % map_name] == "unlocked"
+        elif ap.fast_travel_access == ap.kFAST_TRAVEL_ACCESS_UNLOCKED:
+                return true
+        elif ap.fast_travel_access == ap.kFAST_TRAVEL_ACCESS_ITEMS:
+                var gamedata = global.get_node("Gamedata")
+                var map_id = gamedata.map_id_by_name[map_name]
+                var rte_ap_id = gamedata.objects.get_maps()[map_id].get_rte_ap_id()
+
+                return ap.client.hasItem(rte_ap_id)
+
+        return false
@@ -5,6 +5,8 @@ from BaseClasses import Item
 class Lingo2Item(Item):
     game: str = "Lingo 2"
 
+    is_letter: bool
+
 
 SYMBOL_ITEMS: dict[data_pb2.PuzzleSymbol, str] = {
     data_pb2.PuzzleSymbol.SUN: "Sun Symbol",
@@ -28,4 +30,5 @@ SYMBOL_ITEMS: dict[data_pb2.PuzzleSymbol, str] = {
     data_pb2.PuzzleSymbol.QUESTION: "Question Symbol",
 }
 
-ANTI_COLLECTABLE_TRAPS: list[str] = [f"Anti {letter}" for letter in "ABCDEFGHIJKLMNOPQRSTUVWXYZ"]
+ALL_LETTERS_UPPER = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+ANTI_COLLECTABLE_TRAPS: list[str] = [f"Anti {letter}" for letter in ALL_LETTERS_UPPER]
@@ -1,8 +1,112 @@
-from BaseClasses import Location
+from enum import Enum
+from typing import TYPE_CHECKING
+
+from BaseClasses import Location, Item, Region, CollectionState, Entrance
+from .items import Lingo2Item
+from .rules import AccessRequirements
+
+if TYPE_CHECKING:
+    from . import Lingo2World
+
+
+class LetterPlacementType(Enum):
+    ANY = 0
+    DISALLOW = 1
+    FORCE = 2
+
+
+def get_required_regions(reqs: AccessRequirements, world: "Lingo2World",
+                         regions: dict[str, Region] | None) -> list[Region]:
+    # Replace required rooms with regions for the top level requirement, which saves looking up the regions during rule
+    # checking.
+    if regions is not None:
+        return [regions[room_name] for room_name in reqs.rooms]
+    else:
+        return [world.multiworld.get_region(room_name, world.player) for room_name in reqs.rooms]
 
 
 class Lingo2Location(Location):
     game: str = "Lingo 2"
 
+    reqs: AccessRequirements | None
+    world: "Lingo2World"
+    required_regions: list[Region]
+
     port_id: int
     goal: bool
+    letter_placement_type: LetterPlacementType
+
+    @classmethod
+    def non_event_location(cls, world: "Lingo2World", code: int, region: Region):
+        result = cls(world.player, world.static_logic.location_id_to_name[code], code, region)
+        result.reqs = None
+        result.world = world
+        result.required_regions = []
+
+        return result
+
+    @classmethod
+    def event_location(cls, world: "Lingo2World", name: str, region: Region):
+        result = cls(world.player, name, None, region)
+        result.reqs = None
+        result.world = world
+        result.required_regions = []
+
+        return result
+
+    def set_access_rule(self, reqs: AccessRequirements, regions: dict[str, Region] | None):
+        self.reqs = reqs
+        self.required_regions = get_required_regions(reqs, self.world, regions)
+        self.access_rule = self._l2_access_rule
+
+    def _l2_access_rule(self, state: CollectionState) -> bool:
+        if self.reqs is not None and not self.reqs.check_access(state, self.world):
+            return False
+
+        if not all(state.can_reach(region) for region in self.required_regions):
+            return False
+
+        return True
+
+    def set_up_letter_rule(self, lpt: LetterPlacementType):
+        self.letter_placement_type = lpt
+        self.item_rule = self._l2_item_rule
+
+    def _l2_item_rule(self, item: Item) -> bool:
+        if not isinstance(item, Lingo2Item):
+            return True
+
+        if self.letter_placement_type == LetterPlacementType.FORCE:
+            return item.is_letter
+        elif self.letter_placement_type == LetterPlacementType.DISALLOW:
+            return not item.is_letter
+
+        return True
+
+
+class Lingo2Entrance(Entrance):
+    reqs: AccessRequirements | None
+    world: "Lingo2World"
+    required_regions: list[Region]
+
+    def __init__(self, world: "Lingo2World", description: str, region: Region):
+        super().__init__(world.player, description, region)
+
+        self.reqs = None
+        self.world = world
+        self.required_regions = []
+
+    def set_access_rule(self, reqs: AccessRequirements, regions: dict[str, Region] | None):
+        self.reqs = reqs
+        self.required_regions = get_required_regions(reqs, self.world, regions)
+        self.access_rule = self._l2_access_rule
+
+    def _l2_access_rule(self, state: CollectionState) -> bool:
+        if self.reqs is not None and not self.reqs.check_access(state, self.world):
+            return False
+
+        if not all(state.can_reach(region) for region in self.required_regions):
+            return False
+
+        return True
+
@@ -1,6 +1,6 @@
 from dataclasses import dataclass
 
-from Options import PerGameCommonOptions, Toggle, Choice, DefaultOnToggle, Range, OptionSet
+from Options import PerGameCommonOptions, Toggle, Choice, DefaultOnToggle, Range, OptionSet, FreeText
 
 
 class ShuffleDoors(DefaultOnToggle):
@@ -44,6 +44,17 @@ class ShuffleLetters(Choice):
     option_item_cyan = 4
 
 
+class RestrictLetterPlacements(Toggle):
+    """
+    If enabled, letter items will be shuffled among letter locations in your local world. Shuffle Letters must be set to
+    Progressive or Item Cyan for this to be useful.
+
+    WARNING: This option may slow down generation. Additionally, it is only reliable with Shuffle Letters set to Item
+    Cyan. When set to Progressive, Shuffle Doors and Shuffle Symbols must be turned off.
+    """
+    display_name = "Restrict Letter Placements"
+
+
 class ShuffleSymbols(Toggle):
     """
     If enabled, 19 items will be added to the pool, representing the different symbols that can appear on a panel.
@@ -91,6 +102,27 @@ class CyanDoorBehavior(Choice):
     option_item = 2
 
 
+class ShuffleFastTravel(Toggle):
+    """If enabled, the list of maps you can fast travel to is randomized, except for The Entry, which is always
+    accessible."""
+    display_name = "Shuffle Fast Travel"
+
+
+class FastTravelAccess(Choice):
+    """
+    Controls how the fast travel buttons on the pause menu work.
+
+    - **Vanilla**: You can only fast travel to maps once you have been to them and stepped foot in the general area that
+      the warp would place you. This option means that fast travel has no impact on logic.
+    - **Unlocked**: All five fast travel maps will be available from the start.
+    - **Items**: Only The Entry is available from the start. The other fast travel buttons are locked behind items.
+    """
+    display_name = "Fast Travel Access"
+    option_vanilla = 0
+    option_unlocked = 1
+    option_items = 2
+
+
 class EnableIcarus(Toggle):
     """
     Controls whether Icarus is randomized. If disabled, which is the default, no locations or items will be created for
@@ -146,6 +178,15 @@ class DaedalusRoofAccess(Toggle):
     display_name = "Allow Daedalus Roof Access"
 
 
+class CustomMintEnding(FreeText):
+    """
+    If not blank, this will add a new panel that must be solved before collecting Mint Ending (EXIT in the Control
+    Center). The panel will only require typing the text provided for this option, which means the choice of letters
+    here has an impact on logic.
+    """
+    display_name = "Custom Mint Ending"
+
+
 class StrictPurpleEnding(DefaultOnToggle):
     """
     If enabled, the player will be required to have all purple (level 1) letters in order to get Purple Ending.
@@ -224,23 +265,35 @@ class TrapPercentage(Range):
     default = 0
 
 
+class ShuffleMusic(Toggle):
+    """
+    If enabled, every map will be assigned a random music track.
+    """
+    display_name = "Shuffle Music"
+
+
 @dataclass
 class Lingo2Options(PerGameCommonOptions):
     shuffle_doors: ShuffleDoors
     shuffle_control_center_colors: ShuffleControlCenterColors
     shuffle_gallery_paintings: ShuffleGalleryPaintings
     shuffle_letters: ShuffleLetters
+    restrict_letter_placements: RestrictLetterPlacements
     shuffle_symbols: ShuffleSymbols
     shuffle_worldports: ShuffleWorldports
     keyholder_sanity: KeyholderSanity
     cyan_door_behavior: CyanDoorBehavior
+    shuffle_fast_travel: ShuffleFastTravel
+    fast_travel_access: FastTravelAccess
     enable_icarus: EnableIcarus
     enable_gift_maps: EnableGiftMaps
     daedalus_only: DaedalusOnly
     daedalus_roof_access: DaedalusRoofAccess
+    custom_mint_ending: CustomMintEnding
     strict_purple_ending: StrictPurpleEnding
     strict_cyan_ending: StrictCyanEnding
     victory_condition: VictoryCondition
     endings_requirement: EndingsRequirement
     masteries_requirement: MasteriesRequirement
     trap_percentage: TrapPercentage
+    shuffle_music: ShuffleMusic
@@ -5,7 +5,8 @@ from .generated import data_pb2 as data_pb2
 from .items import SYMBOL_ITEMS
 from typing import TYPE_CHECKING, NamedTuple
 
-from .options import ShuffleLetters, CyanDoorBehavior, VictoryCondition
+from .options import ShuffleLetters, CyanDoorBehavior, VictoryCondition, FastTravelAccess
+from .rules import AccessRequirements
 
 if TYPE_CHECKING:
     from . import Lingo2World
@@ -21,177 +22,10 @@ def calculate_letter_histogram(solution: str) -> dict[str, int]:
     return histogram
 
 
-class AccessRequirements:
-    items: set[str]
-    progressives: dict[str, int]
-    rooms: set[str]
-    letters: dict[str, int]
-    cyans: bool
-
-    # This is an AND of ORs.
-    or_logic: list[list["AccessRequirements"]]
-
-    # When complete_at is set, at least that many of the requirements in possibilities must be accessible. This should
-    # only be used for doors with complete_at > 1, as or_logic is more efficient for complete_at == 1.
-    complete_at: int | None
-    possibilities: list["AccessRequirements"]
-
-    def __init__(self):
-        self.items = set()
-        self.progressives = dict()
-        self.rooms = set()
-        self.letters = dict()
-        self.cyans = False
-        self.or_logic = list()
-        self.complete_at = None
-        self.possibilities = list()
-
-    def copy(self) -> "AccessRequirements":
-        reqs = AccessRequirements()
-        reqs.items = self.items.copy()
-        reqs.progressives = self.progressives.copy()
-        reqs.rooms = self.rooms.copy()
-        reqs.letters = self.letters.copy()
-        reqs.cyans = self.cyans
-        reqs.or_logic = [[other_req.copy() for other_req in disjunction] for disjunction in self.or_logic]
-        reqs.complete_at = self.complete_at
-        reqs.possibilities = self.possibilities.copy()
-        return reqs
-
-    def merge(self, other: "AccessRequirements"):
-        for item in other.items:
-            self.items.add(item)
-
-        for item, amount in other.progressives.items():
-            self.progressives[item] = max(amount, self.progressives.get(item, 0))
-
-        for room in other.rooms:
-            self.rooms.add(room)
-
-        for letter, level in other.letters.items():
-            self.letters[letter] = max(self.letters.get(letter, 0), level)
-
-        self.cyans = self.cyans or other.cyans
-
-        for disjunction in other.or_logic:
-            self.or_logic.append([sub_req.copy() for sub_req in disjunction])
-
-        if other.complete_at is not None:
-            # Merging multiple requirements that use complete_at sucks, and is part of why we want to minimize use of
-            # it. If both requirements use complete_at, we will cheat by using the or_logic field, which supports
-            # conjunctions of requirements.
-            if self.complete_at is not None:
-                print("Merging requirements with complete_at > 1. This is messy and should be avoided!")
-
-                left_req = AccessRequirements()
-                left_req.complete_at = self.complete_at
-                left_req.possibilities = [sub_req.copy() for sub_req in self.possibilities]
-                self.or_logic.append([left_req])
-
-                self.complete_at = None
-                self.possibilities = list()
-
-                right_req = AccessRequirements()
-                right_req.complete_at = other.complete_at
-                right_req.possibilities = [sub_req.copy() for sub_req in other.possibilities]
-                self.or_logic.append([right_req])
-            else:
-                self.complete_at = other.complete_at
-                self.possibilities = [sub_req.copy() for sub_req in other.possibilities]
-
-    def is_empty(self) -> bool:
-        return (len(self.items) == 0 and len(self.progressives) == 0 and len(self.rooms) == 0 and len(self.letters) == 0
-                and not self.cyans and len(self.or_logic) == 0 and self.complete_at is None)
-
-    def __eq__(self, other: "AccessRequirements"):
-        return (self.items == other.items and self.progressives == other.progressives and self.rooms == other.rooms and
-                self.letters == other.letters and self.cyans == other.cyans and self.or_logic == other.or_logic and
-                self.complete_at == other.complete_at and self.possibilities == other.possibilities)
-
-    def simplify(self):
-        resimplify = False
-
-        if len(self.or_logic) > 0:
-            old_or_logic = self.or_logic
-
-            def remove_redundant(sub_reqs: "AccessRequirements"):
-                new_reqs = sub_reqs.copy()
-                new_reqs.letters = {l: v for l, v in new_reqs.letters.items() if self.letters.get(l, 0) < v}
-                if new_reqs != sub_reqs:
-                    return new_reqs
-                else:
-                    return sub_reqs
-
-            self.or_logic = []
-            for disjunction in old_or_logic:
-                new_disjunction = []
-                for ssr in disjunction:
-                    new_ssr = remove_redundant(ssr)
-                    if not new_ssr.is_empty():
-                        new_disjunction.append(new_ssr)
-                    else:
-                        new_disjunction.clear()
-                        break
-                if len(new_disjunction) == 1:
-                    self.merge(new_disjunction[0])
-                    resimplify = True
-                elif len(new_disjunction) > 1:
-                    if all(cjr == new_disjunction[0] for cjr in new_disjunction):
-                        self.merge(new_disjunction[0])
-                        resimplify = True
-                    else:
-                        self.or_logic.append(new_disjunction)
-
-        if resimplify:
-            self.simplify()
-
-    def get_referenced_rooms(self):
-        result = set(self.rooms)
-
-        for disjunction in self.or_logic:
-            for sub_req in disjunction:
-                result = result.union(sub_req.get_referenced_rooms())
-
-        for sub_req in self.possibilities:
-            result = result.union(sub_req.get_referenced_rooms())
-
-        return result
-
-    def remove_room(self, room: str):
-        if room in self.rooms:
-            self.rooms.remove(room)
-
-        for disjunction in self.or_logic:
-            for sub_req in disjunction:
-                sub_req.remove_room(room)
-
-        for sub_req in self.possibilities:
-            sub_req.remove_room(room)
-
-    def __repr__(self):
-        parts = []
-        if len(self.items) > 0:
-            parts.append(f"items={self.items}")
-        if len(self.progressives) > 0:
-            parts.append(f"progressives={self.progressives}")
-        if len(self.rooms) > 0:
-            parts.append(f"rooms={self.rooms}")
-        if len(self.letters) > 0:
-            parts.append(f"letters={self.letters}")
-        if self.cyans:
-            parts.append(f"cyans=True")
-        if len(self.or_logic) > 0:
-            parts.append(f"or_logic={self.or_logic}")
-        if self.complete_at is not None:
-            parts.append(f"complete_at={self.complete_at}")
-        if len(self.possibilities) > 0:
-            parts.append(f"possibilities={self.possibilities}")
-        return "AccessRequirements(" + ", ".join(parts) + ")"
-
-
 class PlayerLocation(NamedTuple):
     code: int | None
     reqs: AccessRequirements
+    is_letter: bool = False
 
 
 class LetterBehavior(IntEnum):
@@ -221,6 +55,8 @@ class Lingo2PlayerLogic:
 
     double_letter_amount: dict[str, int]
     goal_room_id: int
+    rte_mapping: list[int]
+    custom_mint_ending: str | None
 
     def __init__(self, world: "Lingo2World"):
         self.world = world
@@ -235,6 +71,7 @@ class Lingo2PlayerLogic:
         self.real_items = list()
         self.starting_items = list()
         self.double_letter_amount = dict()
+        self.custom_mint_ending = None
 
         def should_shuffle_map(game_map) -> bool | set[int]:
             if world.options.daedalus_only:
@@ -294,6 +131,18 @@ class Lingo2PlayerLogic:
                     self.shuffled_doors.update(set(door.id for door in world.static_logic.objects.doors
                                                    if door.map_id == game_map.id and door.daedalus_only_allow))
 
+        if (world.options.restrict_letter_placements
+                and world.options.shuffle_letters == ShuffleLetters.option_progressive
+                and (world.options.shuffle_doors or world.options.shuffle_symbols)):
+            raise OptionError(f"When Restrict Letter Placements is enabled and Shuffle Letters is set to Progressive, "
+                              f"both Shuffle Doors and Shuffle Symbols must be disabled (Player {world.player}).")
+
+        if world.options.custom_mint_ending.value != "":
+            self.custom_mint_ending = ''.join(filter(str.isalpha, world.options.custom_mint_ending.value)).lower()
+
+            if len(self.custom_mint_ending) > 52:
+                raise OptionError(f"Custom Mint Ending should not be greater than 52 letters (Player {world.player}).")
+
         maximum_masteries = 13 + len(world.options.enable_gift_maps.value)
         if world.options.enable_icarus:
             maximum_masteries += 1
@@ -304,6 +153,19 @@ class Lingo2PlayerLogic:
         if "The Fuzzy" in world.options.enable_gift_maps.value:
             self.real_items.append("Numbers")
 
+        if world.options.shuffle_fast_travel:
+            travelable_maps = [map_id for map_id in self.shuffled_maps
+                               if world.static_logic.objects.maps[map_id].HasField("rte_room")]
+            self.rte_mapping = world.random.sample(travelable_maps, 4)
+        else:
+            canonical_rtes = ["the_plaza", "the_gallery", "daedalus", "control_center"]
+            self.rte_mapping = [world.static_logic.map_id_by_name[map_name] for map_name in canonical_rtes
+                                if world.static_logic.map_id_by_name[map_name] in self.shuffled_maps]
+
+        if world.options.fast_travel_access == FastTravelAccess.option_items:
+            for rte_map in self.rte_mapping:
+                self.real_items.append(world.static_logic.get_map_rte_item_name(rte_map))
+
         if self.world.options.shuffle_doors:
             for progressive in world.static_logic.objects.progressives:
                 for i in range(0, len(progressive.doors)):
@@ -392,9 +254,11 @@ class Lingo2PlayerLogic:
             if not self.should_shuffle_room(letter.room_id):
                 continue
 
-            self.locations_by_room.setdefault(letter.room_id, []).append(PlayerLocation(letter.ap_id,
-                                                                                        AccessRequirements()))
             behavior = self.get_letter_behavior(letter.key, letter.level2)
+
+            self.locations_by_room.setdefault(letter.room_id, []).append(
+                PlayerLocation(letter.ap_id, AccessRequirements(), behavior == LetterBehavior.ITEM))
+
             if behavior == LetterBehavior.VANILLA:
                 if not world.for_tracker:
                     letter_name = f"{letter.key.upper()}{'2' if letter.level2 else '1'}"
@@ -4,9 +4,9 @@ import BaseClasses
 from BaseClasses import Region, ItemClassification, Entrance
 from entrance_rando import randomize_entrances
 from .items import Lingo2Item
-from .locations import Lingo2Location
+from .locations import Lingo2Location, LetterPlacementType, Lingo2Entrance
+from .options import FastTravelAccess
 from .player_logic import AccessRequirements
-from .rules import make_location_lambda
 
 if TYPE_CHECKING:
     from . import Lingo2World
@@ -21,13 +21,17 @@ def create_locations(room, new_region: Region, world: "Lingo2World", regions: di
         reqs = location.reqs.copy()
         reqs.remove_room(new_region.name)
 
-        new_location = Lingo2Location(world.player, world.static_logic.location_id_to_name[location.code],
-                                      location.code, new_region)
-        new_location.access_rule = make_location_lambda(reqs, world, regions)
+        new_location = Lingo2Location.non_event_location(world, location.code, new_region)
+        new_location.set_access_rule(reqs, regions)
+        if world.options.restrict_letter_placements:
+            if location.is_letter:
+                new_location.set_up_letter_rule(LetterPlacementType.FORCE)
+            else:
+                new_location.set_up_letter_rule(LetterPlacementType.DISALLOW)
         new_region.locations.append(new_location)
 
     for event_name, item_name in world.player_logic.event_loc_item_by_room.get(room.id, {}).items():
-        new_location = Lingo2Location(world.player, event_name, None, new_region)
+        new_location = Lingo2Location.event_location(world, event_name, new_region)
         if world.for_tracker and item_name == "Victory":
             new_location.goal = True
 
@@ -41,12 +45,11 @@ def create_locations(room, new_region: Region, world: "Lingo2World", regions: di
             if port.no_shuffle:
                 continue
 
-            new_location = Lingo2Location(world.player, f"Worldport {port.id} Entered", None, new_region)
+            new_location = Lingo2Location.event_location(world, f"Worldport {port.id} Entered", new_region)
             new_location.port_id = port.id
 
             if port.HasField("required_door"):
-                new_location.access_rule = \
-                    make_location_lambda(world.player_logic.get_door_open_reqs(port.required_door), world, regions)
+                new_location.set_access_rule(world.player_logic.get_door_open_reqs(port.required_door), regions)
 
             new_region.locations.append(new_location)
 
@@ -135,6 +138,10 @@ def create_regions(world: "Lingo2World"):
         if connection.HasField("cyan_ending") and connection.cyan_ending and world.options.strict_cyan_ending:
             world.player_logic.add_solution_reqs(reqs, "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz")
 
+        if (connection.HasField("mint_ending") and connection.mint_ending
+                and world.player_logic.custom_mint_ending is not None):
+            world.player_logic.add_solution_reqs(reqs, world.player_logic.custom_mint_ending)
+
         reqs.simplify()
         reqs.remove_room(from_region)
 
@@ -144,8 +151,8 @@ def create_regions(world: "Lingo2World"):
             # what regions are dead ends.
             continue
 
-        connection = Entrance(world.player, connection_name, regions[from_region])
-        connection.access_rule = make_location_lambda(reqs, world, regions)
+        connection = Lingo2Entrance(world, connection_name, regions[from_region])
+        connection.set_access_rule(reqs, regions)
 
         regions[from_region].exits.append(connection)
         connection.connect(regions[to_region])
@@ -153,6 +160,25 @@ def create_regions(world: "Lingo2World"):
         for region in reqs.get_referenced_rooms():
             world.multiworld.register_indirect_condition(regions[region], connection)
 
+    if world.options.fast_travel_access != FastTravelAccess.option_vanilla:
+        for rte_map_id in world.player_logic.rte_mapping:
+            rte_map = world.static_logic.objects.maps[rte_map_id]
+            to_region = world.static_logic.get_room_region_name(rte_map.rte_room)
+
+            if to_region not in regions:
+                continue
+
+            connection_name = f"Return to {to_region}"
+            connection = Lingo2Entrance(world, connection_name, regions["Menu"])
+            regions["Menu"].exits.append(connection)
+            connection.connect(regions[to_region])
+
+            if world.options.fast_travel_access == FastTravelAccess.option_items:
+                reqs = AccessRequirements()
+                reqs.items.add(world.static_logic.get_map_rte_item_name(rte_map_id))
+
+                connection.set_access_rule(reqs, regions)
+
     world.multiworld.regions += regions.values()
 
 
@@ -184,13 +210,13 @@ def shuffle_entrances(world: "Lingo2World"):
         from_region = world.multiworld.get_region(from_region_name, world.player)
         to_region = world.multiworld.get_region(to_region_name, world.player)
 
-        connection = Entrance(world.player, f"{from_region_name} - {chosen_port.display_name}", from_region)
+        connection = Lingo2Entrance(world, f"{from_region_name} - {chosen_port.display_name}", from_region)
         from_region.exits.append(connection)
         connection.connect(to_region)
 
         if chosen_port.HasField("required_door"):
             door_reqs = world.player_logic.get_door_open_reqs(chosen_port.required_door)
-            connection.access_rule = make_location_lambda(door_reqs, world, None)
+            connection.set_access_rule(door_reqs, None)
 
             for region in door_reqs.get_referenced_rooms():
                 world.multiworld.register_indirect_condition(world.multiworld.get_region(region, world.player),
@@ -206,12 +232,13 @@ def shuffle_entrances(world: "Lingo2World"):
         entrance = port_region.create_er_target(connection_name)
         entrance.randomization_type = BaseClasses.EntranceType.TWO_WAY
 
-        er_exit = port_region.create_exit(connection_name)
+        er_exit = Lingo2Entrance(world, connection_name, port_region)
+        port_region.exits.append(er_exit)
         er_exit.randomization_type = BaseClasses.EntranceType.TWO_WAY
 
         if port.HasField("required_door"):
             door_reqs = world.player_logic.get_door_open_reqs(port.required_door)
-            er_exit.access_rule = make_location_lambda(door_reqs, world, None)
+            er_exit.set_access_rule(door_reqs, None)
 
             for region in door_reqs.get_referenced_rooms():
                 world.multiworld.register_indirect_condition(world.multiworld.get_region(region, world.player),
@@ -238,7 +265,7 @@ def connect_ports_from_ut(port_pairings: dict[int, int], world: "Lingo2World"):
         from_region = world.multiworld.get_region(from_region_name, world.player)
         to_region = world.multiworld.get_region(to_region_name, world.player)
 
-        connection = Entrance(world.player, f"{from_region_name} - {from_port.display_name}", from_region)
+        connection = Lingo2Entrance(world, f"{from_region_name} - {from_port.display_name}", from_region)
 
         reqs = AccessRequirements()
         if from_port.HasField("required_door"):
@@ -248,7 +275,7 @@ def connect_ports_from_ut(port_pairings: dict[int, int], world: "Lingo2World"):
             reqs.items.add(f"Worldport {fpid} Entered")
 
         if not reqs.is_empty():
-            connection.access_rule = make_location_lambda(reqs, world, None)
+            connection.set_access_rule(reqs, None)
 
             for region in reqs.get_referenced_rooms():
                 world.multiworld.register_indirect_condition(world.multiworld.get_region(region, world.player),
@@ -1,66 +1,215 @@
-from collections.abc import Callable
 from typing import TYPE_CHECKING
 
-from BaseClasses import CollectionState, Region
-from .player_logic import AccessRequirements
+from BaseClasses import CollectionState
 
 if TYPE_CHECKING:
     from . import Lingo2World
 
 
-def lingo2_can_satisfy_requirements(state: CollectionState, reqs: AccessRequirements, regions: list[Region],
-                                    world: "Lingo2World") -> bool:
-    if not all(state.has(item, world.player) for item in reqs.items):
-        return False
+class AccessRequirements:
+    items: set[str]
+    progressives: dict[str, int]
+    rooms: set[str]
+    letters: dict[str, int]
+    cyans: bool
 
-    if not all(state.has(item, world.player, amount) for item, amount in reqs.progressives.items()):
-        return False
+    # This is an AND of ORs.
+    or_logic: list[list["AccessRequirements"]]
 
-    if not all(state.can_reach_region(region_name, world.player) for region_name in reqs.rooms):
-        return False
+    # When complete_at is set, at least that many of the requirements in possibilities must be accessible. This should
+    # only be used for doors with complete_at > 1, as or_logic is more efficient for complete_at == 1.
+    complete_at: int | None
+    possibilities: list["AccessRequirements"]
 
-    if not all(state.can_reach(region) for region in regions):
-        return False
+    def __init__(self):
+        self.items = set()
+        self.progressives = dict()
+        self.rooms = set()
+        self.letters = dict()
+        self.cyans = False
+        self.or_logic = list()
+        self.complete_at = None
+        self.possibilities = list()
 
-    for letter_key, letter_level in reqs.letters.items():
-        if not state.has(letter_key, world.player, letter_level):
+    def copy(self) -> "AccessRequirements":
+        reqs = AccessRequirements()
+        reqs.items = self.items.copy()
+        reqs.progressives = self.progressives.copy()
+        reqs.rooms = self.rooms.copy()
+        reqs.letters = self.letters.copy()
+        reqs.cyans = self.cyans
+        reqs.or_logic = [[other_req.copy() for other_req in disjunction] for disjunction in self.or_logic]
+        reqs.complete_at = self.complete_at
+        reqs.possibilities = self.possibilities.copy()
+        return reqs
+
+    def merge(self, other: "AccessRequirements"):
+        for item in other.items:
+            self.items.add(item)
+
+        for item, amount in other.progressives.items():
+            self.progressives[item] = max(amount, self.progressives.get(item, 0))
+
+        for room in other.rooms:
+            self.rooms.add(room)
+
+        for letter, level in other.letters.items():
+            self.letters[letter] = max(self.letters.get(letter, 0), level)
+
+        self.cyans = self.cyans or other.cyans
+
+        for disjunction in other.or_logic:
+            self.or_logic.append([sub_req.copy() for sub_req in disjunction])
+
+        if other.complete_at is not None:
+            # Merging multiple requirements that use complete_at sucks, and is part of why we want to minimize use of
+            # it. If both requirements use complete_at, we will cheat by using the or_logic field, which supports
+            # conjunctions of requirements.
+            if self.complete_at is not None:
+                print("Merging requirements with complete_at > 1. This is messy and should be avoided!")
+
+                left_req = AccessRequirements()
+                left_req.complete_at = self.complete_at
+                left_req.possibilities = [sub_req.copy() for sub_req in self.possibilities]
+                self.or_logic.append([left_req])
+
+                self.complete_at = None
+                self.possibilities = list()
+
+                right_req = AccessRequirements()
+                right_req.complete_at = other.complete_at
+                right_req.possibilities = [sub_req.copy() for sub_req in other.possibilities]
+                self.or_logic.append([right_req])
+            else:
+                self.complete_at = other.complete_at
+                self.possibilities = [sub_req.copy() for sub_req in other.possibilities]
+
+    def is_empty(self) -> bool:
+        return (len(self.items) == 0 and len(self.progressives) == 0 and len(self.rooms) == 0 and len(self.letters) == 0
+                and not self.cyans and len(self.or_logic) == 0 and self.complete_at is None)
+
+    def __eq__(self, other: "AccessRequirements"):
+        return (self.items == other.items and self.progressives == other.progressives and self.rooms == other.rooms and
+                self.letters == other.letters and self.cyans == other.cyans and self.or_logic == other.or_logic and
+                self.complete_at == other.complete_at and self.possibilities == other.possibilities)
+
+    def simplify(self):
+        resimplify = False
+
+        if len(self.or_logic) > 0:
+            old_or_logic = self.or_logic
+
+            def remove_redundant(sub_reqs: "AccessRequirements"):
+                new_reqs = sub_reqs.copy()
+                new_reqs.letters = {l: v for l, v in new_reqs.letters.items() if self.letters.get(l, 0) < v}
+                if new_reqs != sub_reqs:
+                    return new_reqs
+                else:
+                    return sub_reqs
+
+            self.or_logic = []
+            for disjunction in old_or_logic:
+                new_disjunction = []
+                for ssr in disjunction:
+                    new_ssr = remove_redundant(ssr)
+                    if not new_ssr.is_empty():
+                        new_disjunction.append(new_ssr)
+                    else:
+                        new_disjunction.clear()
+                        break
+                if len(new_disjunction) == 1:
+                    self.merge(new_disjunction[0])
+                    resimplify = True
+                elif len(new_disjunction) > 1:
+                    if all(cjr == new_disjunction[0] for cjr in new_disjunction):
+                        self.merge(new_disjunction[0])
+                        resimplify = True
+                    else:
+                        self.or_logic.append(new_disjunction)
+
+        if resimplify:
+            self.simplify()
+
+    def get_referenced_rooms(self):
+        result = set(self.rooms)
+
+        for disjunction in self.or_logic:
+            for sub_req in disjunction:
+                result = result.union(sub_req.get_referenced_rooms())
+
+        for sub_req in self.possibilities:
+            result = result.union(sub_req.get_referenced_rooms())
+
+        return result
+
+    def remove_room(self, room: str):
+        if room in self.rooms:
+            self.rooms.remove(room)
+
+        for disjunction in self.or_logic:
+            for sub_req in disjunction:
+                sub_req.remove_room(room)
+
+        for sub_req in self.possibilities:
+            sub_req.remove_room(room)
+
+    def __repr__(self):
+        parts = []
+        if len(self.items) > 0:
+            parts.append(f"items={self.items}")
+        if len(self.progressives) > 0:
+            parts.append(f"progressives={self.progressives}")
+        if len(self.rooms) > 0:
+            parts.append(f"rooms={self.rooms}")
+        if len(self.letters) > 0:
+            parts.append(f"letters={self.letters}")
+        if self.cyans:
+            parts.append(f"cyans=True")
+        if len(self.or_logic) > 0:
+            parts.append(f"or_logic={self.or_logic}")
+        if self.complete_at is not None:
+            parts.append(f"complete_at={self.complete_at}")
+        if len(self.possibilities) > 0:
+            parts.append(f"possibilities={self.possibilities}")
+        return "AccessRequirements(" + ", ".join(parts) + ")"
+
+    def check_access(self, state: CollectionState, world: "Lingo2World") -> bool:
+        if not all(state.has(item, world.player) for item in self.items):
             return False
 
-    if reqs.cyans:
-        if not any(state.has(letter, world.player, amount)
-                   for letter, amount in world.player_logic.double_letter_amount.items()):
+        if not all(state.has(item, world.player, amount) for item, amount in self.progressives.items()):
             return False
 
-    if len(reqs.or_logic) > 0:
-        if not all(any(lingo2_can_satisfy_requirements(state, sub_reqs, [], world) for sub_reqs in subjunction)
-                   for subjunction in reqs.or_logic):
+        if not all(state.can_reach_region(region_name, world.player) for region_name in self.rooms):
             return False
 
-    if reqs.complete_at is not None:
-        completed = 0
-        checked = 0
-        for possibility in reqs.possibilities:
-            checked += 1
-            if lingo2_can_satisfy_requirements(state, possibility, [], world):
-                completed += 1
-                if completed >= reqs.complete_at:
-                    break
-            elif len(reqs.possibilities) - checked + completed < reqs.complete_at:
-                # There aren't enough remaining possibilities for the check to pass.
+        for letter_key, letter_level in self.letters.items():
+            if not state.has(letter_key, world.player, letter_level):
+                return False
+
+        if self.cyans:
+            if not any(state.has(letter, world.player, amount)
+                       for letter, amount in world.player_logic.double_letter_amount.items()):
+                return False
+
+        if len(self.or_logic) > 0:
+            if not all(any(sub_reqs.check_access(state, world) for sub_reqs in subjunction)
+                       for subjunction in self.or_logic):
+                return False
+
+        if self.complete_at is not None:
+            completed = 0
+            checked = 0
+            for possibility in self.possibilities:
+                checked += 1
+                if possibility.check_access(state, world):
+                    completed += 1
+                    if completed >= self.complete_at:
+                        break
+                elif len(self.possibilities) - checked + completed < self.complete_at:
+                    # There aren't enough remaining possibilities for the check to pass.
+                    return False
+            if completed < self.complete_at:
                 return False
-        if completed < reqs.complete_at:
-            return False
 
-    return True
-
-def make_location_lambda(reqs: AccessRequirements, world: "Lingo2World",
-                         regions: dict[str, Region] | None) -> Callable[[CollectionState], bool]:
-    # Replace required rooms with regions for the top level requirement, which saves looking up the regions during rule
-    # checking.
-    if regions is not None:
-        required_regions = [regions[room_name] for room_name in reqs.rooms]
-    else:
-        required_regions = [world.multiworld.get_region(room_name, world.player) for room_name in reqs.rooms]
-    new_reqs = reqs.copy()
-    new_reqs.rooms.clear()
-    return lambda state: lingo2_can_satisfy_requirements(state, new_reqs, required_regions, world)
+        return True
@@ -18,6 +18,8 @@ class Lingo2StaticLogic:
     door_id_by_ap_id: dict[int, int]
     port_id_by_ap_id: dict[int, int]
 
+    map_id_by_name: dict[str, int]
+
     def __init__(self):
         self.item_id_to_name = {}
         self.location_id_to_name = {}
@@ -73,12 +75,18 @@ class Lingo2StaticLogic:
         self.item_id_to_name[self.objects.special_ids["A Job Well Done"]] = "A Job Well Done"
         self.item_id_to_name[self.objects.special_ids["Numbers"]] = "Numbers"
 
+        self.item_name_groups["Symbols"] = []
         for symbol_name in SYMBOL_ITEMS.values():
             self.item_id_to_name[self.objects.special_ids[symbol_name]] = symbol_name
+            self.item_name_groups["Symbols"].append(symbol_name)
 
         for trap_name in ANTI_COLLECTABLE_TRAPS:
             self.item_id_to_name[self.objects.special_ids[trap_name]] = trap_name
 
+        for game_map in self.objects.maps:
+            if game_map.HasField("rte_room"):
+                self.item_id_to_name[game_map.rte_ap_id] = self.get_map_rte_item_name(game_map.id)
+
         self.item_name_to_id = {name: ap_id for ap_id, name in self.item_id_to_name.items()}
         self.location_name_to_id = {name: ap_id for ap_id, name in self.location_id_to_name.items()}
 
@@ -90,6 +98,8 @@ class Lingo2StaticLogic:
         self.door_id_by_ap_id = {door.ap_id: door.id for door in self.objects.doors if door.HasField("ap_id")}
         self.port_id_by_ap_id = {port.ap_id: port.id for port in self.objects.ports if port.HasField("ap_id")}
 
+        self.map_id_by_name = {game_map.name: game_map.id for game_map in self.objects.maps}
+
     def get_door_item_name(self, door: data_pb2.Door) -> str:
         return f"{self.get_map_object_map_name(door)} - {door.name}"
 
@@ -177,6 +187,10 @@ class Lingo2StaticLogic:
     def get_room_object_map_id(self, obj) -> int:
         return self.objects.rooms[obj.room_id].map_id
 
+    def get_map_rte_item_name(self, map_id: int) -> str:
+        game_map = self.objects.maps[map_id]
+        return f"Return to {game_map.display_name}"
+
     def get_data_version(self) -> list[int]:
         version = self.objects.version
         return [version.major, version.minor, version.patch]
@@ -44,6 +44,10 @@ class Tracker:
                                               for k, t in Lingo2Options.type_hints.items()})
 
         self.world.generate_early()
+
+        self.world.player_logic.rte_mapping = [self.world.static_logic.map_id_by_name[map_name]
+                                               for map_name in slot_data.get("rte", [])]
+
         self.world.create_regions()
 
         if self.world.options.shuffle_worldports: