36 files changed, 779 insertions, 33 deletions

@@ -68,6 +68,7 @@ class Lingo2World(World):
         slot_options = [
             "daedalus_roof_access",
             "keyholder_sanity",
+            "shuffle_control_center_colors",
             "shuffle_doors",
             "shuffle_letters",
             "victory_condition",
@@ -8,6 +8,14 @@ class ShuffleDoors(Toggle):
     display_name = "Shuffle Doors"
 
 
+class ShuffleControlCenterColors(Toggle):
+    """
+    Some doors open after solving the COLOR panel in the Control Center. If this option is enabled, these doors will
+    instead open upon receiving an item.
+    """
+    display_name = "Shuffle Control Center Colors"
+
+
 class ShuffleLetters(Choice):
     """
     Controls how letter unlocks are handled. Note that H1, I1, N1, and T1 will always be present at their vanilla
@@ -71,6 +79,7 @@ class VictoryCondition(Choice):
 @dataclass
 class Lingo2Options(PerGameCommonOptions):
     shuffle_doors: ShuffleDoors
+    shuffle_control_center_colors: ShuffleControlCenterColors
     shuffle_letters: ShuffleLetters
     keyholder_sanity: KeyholderSanity
     daedalus_roof_access: DaedalusRoofAccess
@@ -123,16 +123,39 @@ class Lingo2PlayerLogic:
                     self.item_by_door[progressive.doors[i]] = (progressive.name, i + 1)
                     self.real_items.append(progressive.name)
 
+        for door_group in world.static_logic.objects.door_groups:
+            if door_group.type == data_pb2.DoorGroupType.CONNECTOR and not self.world.options.shuffle_doors:
+                continue
+
+            if (door_group.type == data_pb2.DoorGroupType.COLOR_CONNECTOR and
+                    not self.world.options.shuffle_control_center_colors):
+                continue
+
+            for door in door_group.doors:
+                self.item_by_door[door] = (door_group.name, 1)
+
+            self.real_items.append(door_group.name)
+
         # We iterate through the doors in two parts because it is essential that we determine which doors are shuffled
         # before we calculate any access requirements.
         for door in world.static_logic.objects.doors:
-            if door.type in [data_pb2.DoorType.STANDARD, data_pb2.DoorType.ITEM_ONLY] and self.world.options.shuffle_doors:
-                if door.id in self.item_by_door:
-                    continue
+            if door.type in [data_pb2.DoorType.EVENT, data_pb2.DoorType.LOCATION_ONLY, data_pb2.DoorType.GRAVESTONE]:
+                continue
+
+            if door.id in self.item_by_door:
+                continue
+
+            if (door.type in [data_pb2.DoorType.STANDARD, data_pb2.DoorType.ITEM_ONLY] and
+                    not self.world.options.shuffle_doors):
+                continue
+
+            if (door.type == data_pb2.DoorType.CONTROL_CENTER_COLOR and
+                    not self.world.options.shuffle_control_center_colors):
+                continue
 
-                door_item_name = self.world.static_logic.get_door_item_name(door)
-                self.item_by_door[door.id] = (door_item_name, 1)
-                self.real_items.append(door_item_name)
+            door_item_name = self.world.static_logic.get_door_item_name(door)
+            self.item_by_door[door.id] = (door_item_name, 1)
+            self.real_items.append(door_item_name)
 
         for door in world.static_logic.objects.doors:
             if door.type in [data_pb2.DoorType.STANDARD, data_pb2.DoorType.LOCATION_ONLY, data_pb2.DoorType.GRAVESTONE]:
@@ -44,6 +44,9 @@ class Lingo2StaticLogic:
         for progressive in self.objects.progressives:
             self.item_id_to_name[progressive.ap_id] = progressive.name
 
+        for door_group in self.objects.door_groups:
+            self.item_id_to_name[door_group.ap_id] = door_group.name
+
         for keyholder in self.objects.keyholders:
             if keyholder.HasField("key"):
                 location_name = f"{self.get_room_object_location_prefix(keyholder)} - {keyholder.key.upper()} Keyholder"
@@ -41,6 +41,7 @@ signal connect_status
 signal client_connected(slot_data)
 signal item_received(item_id, index, player, flags, amount)
 signal message_received(message)
+signal location_scout_received(item_id, location_id, player, flags)
 
 
 func _init():
@@ -257,6 +258,16 @@ func _process(_delta):
                                         elif cmd == "PrintJSON":
                                                 emit_signal("message_received", message)
 
+                                        elif cmd == "LocationInfo":
+                                                for loc in message["locations"]:
+                                                        emit_signal(
+                                                                "location_scout_received",
+                                                                int(loc["item"]),
+                                                                int(loc["location"]),
+                                                                int(loc["player"]),
+                                                                int(loc["flags"])
+                                                        )
+
                 elif state == WebSocketPeer.STATE_CLOSED:
                         if _has_connected:
                                 _closed()
@@ -392,6 +403,10 @@ func completedGoal():
         sendMessage([{"cmd": "StatusUpdate", "status": 30}])  # CLIENT_GOAL
 
 
+func scoutLocations(loc_ids):
+        sendMessage([{"cmd": "LocationScouts", "locations": loc_ids}])
+
+
 func hasItem(item_id):
         return _received_items.has(item_id)
 
@@ -0,0 +1,16 @@
+extends "res://scripts/nodes/collectable.gd"
+
+
+func pickedUp():
+        if unlock_type == "key":
+                var ap = global.get_node("Archipelago")
+                if ap.get_letter_behavior(unlock_key, level == 2) == ap.kLETTER_BEHAVIOR_VANILLA:
+                        ap.keyboard.collect_local_letter(unlock_key, level)
+                else:
+                        ap.keyboard.update_unlocks()
+
+        super.pickedUp()
+
+
+func setScoutedText(text):
+        get_node("MeshInstance3D").mesh.text = text.replace(" ", "\n")
@@ -8,6 +8,7 @@ var painting_id_by_map_node_path = {}
 var door_id_by_ap_id = {}
 var map_id_by_name = {}
 var progressive_id_by_ap_id = {}
+var letter_id_by_ap_id = {}
 
 
 func _init(proto_script):
@@ -54,6 +55,9 @@ func load(data_bytes):
         for progressive in objects.get_progressives():
                 progressive_id_by_ap_id[progressive.get_ap_id()] = progressive.get_id()
 
+        for letter in objects.get_letters():
+                letter_id_by_ap_id[letter.get_ap_id()] = letter.get_id()
+
 
 func get_door_for_map_node_path(map_name, node_path):
         if not door_id_by_map_node_path.has(map_name):
@@ -0,0 +1,38 @@
+extends "res://scripts/nodes/keyHolder.gd"
+
+
+func setFromAp(key, level):
+        if level > 0:
+                has_key = true
+                is_complete = "%s%d" % [key, level]
+                held_key = key
+                held_level = level
+                get_node("Hinge/Letter").mesh.text = held_key
+                get_node("Hinge/Letter2").mesh.text = held_key
+                setMaterial()
+                emit_signal("trigger")
+        else:
+                has_key = false
+                held_key = ""
+                held_level = 0
+                setMaterial()
+                get_node("Hinge/Letter").mesh.text = "-"
+                get_node("Hinge/Letter2").mesh.text = "-"
+                is_complete = ""
+                emit_signal("untrigger")
+
+
+func addKey(key):
+        var node_path = String(
+                get_tree().get_root().get_node("scene").get_path_to(self).get_concatenated_names()
+        )
+        var ap = global.get_node("Archipelago")
+        ap.keyboard.put_in_keyholder(key, global.map, node_path)
+
+
+func removeKey():
+        var node_path = String(
+                get_tree().get_root().get_node("scene").get_path_to(self).get_concatenated_names()
+        )
+        var ap = global.get_node("Archipelago")
+        ap.keyboard.remove_from_keyholder(held_key, global.map, node_path)
@@ -0,0 +1,24 @@
+extends "res://scripts/nodes/listeners/keyHolderChecker.gd"
+
+
+func check():
+        var ap = global.get_node("Archipelago")
+        var matches = []
+        for map in ap.keyboard.keyholder_state.keys():
+                var nodes = ap.keyboard.keyholder_state[map]
+                for node in nodes.keys():
+                        matches.append([nodes[node], 1, map, "/root/scene/%s" % node])
+
+        var count = 0
+        for key_match in matches:
+                var active = (
+                        key_match[2] + String(key_match[3]).replace("/root/scene/Components/KeyHolders/", ".")
+                )
+                if map[active] == key_match[0]:
+                        emit_signal("trigger_letter", key_match[0], true)
+                        count += 1
+                else:
+                        emit_signal("trigger_letter", key_match[0], false)
+
+        if count > 25:
+                emit_signal("trigger")
@@ -0,0 +1,8 @@
+extends "res://scripts/nodes/listeners/keyHolderResetterListener.gd"
+
+
+func reset():
+        var ap = global.get_node("Archipelago")
+        var was_removed = ap.keyboard.reset_keyholders()
+        if was_removed:
+                sfxPlayer.sfx_play("pickup")
@@ -0,0 +1,170 @@
+extends Node
+
+const kALL_LETTERS = "abcdefghjiklmnopqrstuvwxyz"
+
+var letters_saved = {}
+var letters_in_keyholders = []
+var letters_dynamic = {}
+var keyholder_state = {}
+
+var filename = ""
+
+
+func _init():
+        reset()
+
+
+func reset():
+        letters_saved.clear()
+        letters_in_keyholders.clear()
+        letters_dynamic.clear()
+        keyholder_state.clear()
+
+
+func load_seed():
+        var ap = global.get_node("Archipelago")
+
+        reset()
+
+        filename = "user://archipelago_keys/%s_%d" % [ap.client._seed, ap.client._slot]
+
+        if FileAccess.file_exists(filename):
+                var ap_file = FileAccess.open(filename, FileAccess.READ)
+                var localdata = []
+                if ap_file != null:
+                        localdata = ap_file.get_var(true)
+                        ap_file.close()
+
+                if typeof(localdata) != TYPE_ARRAY:
+                        print("AP keyboard file is corrupted")
+                        localdata = []
+
+                if localdata.size() > 0:
+                        letters_saved = localdata[0]
+                if localdata.size() > 1:
+                        letters_in_keyholders = localdata[1]
+                if localdata.size() > 2:
+                        keyholder_state = localdata[2]
+
+        for k in kALL_LETTERS:
+                var level = 0
+
+                if ap.get_letter_behavior(k, false) == ap.kLETTER_BEHAVIOR_UNLOCKED:
+                        level += 1
+                if ap.get_letter_behavior(k, true) == ap.kLETTER_BEHAVIOR_UNLOCKED:
+                        level += 1
+
+                letters_dynamic[k] = level
+
+        update_unlocks()
+
+
+func save():
+        var dir = DirAccess.open("user://")
+        var folder = "archipelago_keys"
+        if not dir.dir_exists(folder):
+                dir.make_dir(folder)
+
+        var file = FileAccess.open(filename, FileAccess.WRITE)
+
+        var data = [
+                letters_saved,
+                letters_in_keyholders,
+                keyholder_state,
+        ]
+        file.store_var(data, true)
+        file.close()
+
+
+func update_unlocks():
+        unlocks.resetKeys()
+
+        for k in kALL_LETTERS:
+                var level = 0
+
+                if not letters_in_keyholders.has(k):
+                        level = letters_saved.get(k, 0) + letters_dynamic.get(k, 0)
+
+                if level > 2:
+                        level = 2
+
+                unlocks.unlockKey(k, level)
+
+
+func collect_local_letter(key, level):
+        if level < 0 or level > 2 or level < letters_saved.get(key, 0):
+                return
+
+        letters_saved[key] = level
+
+        update_unlocks()
+        save()
+
+
+func collect_remote_letter(key, level):
+        if level < 0 or level > 2 or level < letters_dynamic.get(key, 0):
+                return
+
+        letters_dynamic[key] = level
+
+        update_unlocks()
+        save()
+
+
+func put_in_keyholder(key, map, kh_path):
+        if not keyholder_state.has(map):
+                keyholder_state[map] = {}
+
+        keyholder_state[map][kh_path] = key
+        letters_in_keyholders.append(key)
+
+        get_tree().get_root().get_node("scene").get_node(kh_path).setFromAp(
+                key, min(letters_saved.get(key, 0) + letters_dynamic.get(key, 0), 2)
+        )
+
+        update_unlocks()
+        save()
+
+
+func remove_from_keyholder(key, map, kh_path):
+        if not keyholder_state.has(map):
+                # This... shouldn't happen.
+                keyholder_state[map] = {}
+
+        keyholder_state[map].erase(kh_path)
+        letters_in_keyholders.erase(key)
+
+        get_tree().get_root().get_node("scene").get_node(kh_path).setFromAp(key, 0)
+
+        update_unlocks()
+        save()
+
+
+func load_keyholders(map):
+        if keyholder_state.has(map):
+                var khs = keyholder_state[map]
+
+                for path in khs.keys():
+                        var key = khs[path]
+                        get_tree().get_root().get_node("scene").get_node(path).setFromAp(
+                                key, min(letters_saved.get(key, 0) + letters_dynamic.get(key, 0), 2)
+                        )
+
+
+func reset_keyholders():
+        if letters_in_keyholders.is_empty():
+                return false
+
+        if keyholder_state.has(global.map):
+                for path in keyholder_state[global.map]:
+                        get_tree().get_root().get_node("scene").get_node(path).setFromAp(
+                                keyholder_state[global.map][path], 0
+                        )
+
+        keyholder_state.clear()
+        letters_in_keyholders.clear()
+
+        update_unlocks()
+        save()
+
+        return true
@@ -3,6 +3,7 @@ extends Node
 const my_version = "0.1.0"
 
 var SCRIPT_client
+var SCRIPT_keyboard
 var SCRIPT_locationListener
 var SCRIPT_uuid
 var SCRIPT_victoryListener
@@ -13,16 +14,33 @@ var ap_pass = ""
 var connection_history = []
 
 var client
+var keyboard
 
 var _localdata_file = ""
 var _last_new_item = -1
 var _batch_locations = false
 var _held_locations = []
+var _held_location_scouts = []
+var _location_scouts = {}
 var _item_locks = {}
+var _held_letters = {}
+var _letters_setup = false
+
+const kSHUFFLE_LETTERS_VANILLA = 0
+const kSHUFFLE_LETTERS_UNLOCKED = 1
+const kSHUFFLE_LETTERS_PROGRESSIVE = 2
+const kSHUFFLE_LETTERS_VANILLA_CYAN = 3
+const kSHUFFLE_LETTERS_ITEM_CYAN = 4
+
+const kLETTER_BEHAVIOR_VANILLA = 0
+const kLETTER_BEHAVIOR_ITEM = 1
+const kLETTER_BEHAVIOR_UNLOCKED = 2
 
 var daedalus_roof_access = false
 var keyholder_sanity = false
+var shuffle_control_center_colors = false
 var shuffle_doors = false
+var shuffle_letters = kSHUFFLE_LETTERS_VANILLA
 var victory_condition = -1
 
 signal could_not_connect
@@ -60,12 +78,16 @@ func _ready():
 
         client.connect("item_received", _process_item)
         client.connect("message_received", _process_message)
+        client.connect("location_scout_received", _process_location_scout)
         client.connect("could_not_connect", _client_could_not_connect)
         client.connect("connect_status", _client_connect_status)
         client.connect("client_connected", _client_connected)
 
         add_child(client)
 
+        keyboard = SCRIPT_keyboard.new()
+        add_child(keyboard)
+
 
 func saveSettings():
         # Save the AP settings to disk.
@@ -100,6 +122,8 @@ func saveLocaldata():
 
 func connectToServer():
         _last_new_item = -1
+        _letters_setup = false
+        _held_letters = {}
 
         client.connectToServer(ap_server, ap_user, ap_pass)
 
@@ -140,11 +164,12 @@ func _process_item(item, index, from, flags, amount):
                                 var rnode = scene.get_node_or_null(receiver)
                                 if rnode != null:
                                         rnode.handleTriggered()
-                        #for painting_id in gamedata.objects.get_doors()[door_id].get_move_paintings():
-                        #       var painting = gamedata.objects.get_paintings()[painting_id]
-                        #       var pnode = scene.get_node_or_null(painting.get_path() + "/teleportListener")
-                        #       if pnode != null:
-                        #               pnode.handleTriggered()
+
+        var letter_id = gamedata.letter_id_by_ap_id.get(item, null)
+        if letter_id != null:
+                var letter = gamedata.objects.get_letters()[letter_id]
+                if not letter.has_level2() or not letter.get_level2():
+                        _process_key_item(letter.get_key(), amount)
 
         # Show a message about the item if it's new.
         if index != null and index > _last_new_item:
@@ -261,6 +286,29 @@ func parse_printjson_for_textclient(message):
                 textclient_node.parse_printjson("".join(parts))
 
 
+func _process_location_scout(item_id, location_id, player, flags):
+        _location_scouts[location_id] = {"item": item_id, "player": player, "flags": flags}
+
+        var gamedata = global.get_node("Gamedata")
+        var map_id = gamedata.map_id_by_name.get(global.map)
+
+        var item_name = "Unknown"
+        var item_player_game = client._game_by_player[float(player)]
+        if client._item_id_to_name[item_player_game].has(item_id):
+                item_name = client._item_id_to_name[item_player_game][item_id]
+
+        var letter_id = gamedata.letter_id_by_ap_id.get(location_id, null)
+        if letter_id != null:
+                var letter = gamedata.objects.get_letters()[letter_id]
+                var room = gamedata.objects.get_rooms()[letter.get_room_id()]
+                if room.get_map_id() == map_id:
+                        var collectable = get_tree().get_root().get_node("scene").get_node_or_null(
+                                letter.get_path()
+                        )
+                        if collectable != null:
+                                collectable.setScoutedText(item_name)
+
+
 func _client_could_not_connect():
         emit_signal("could_not_connect")
 
@@ -292,7 +340,9 @@ func _client_connected(slot_data):
         # Read slot data.
         daedalus_roof_access = bool(slot_data.get("daedalus_roof_access", false))
         keyholder_sanity = bool(slot_data.get("keyholder_sanity", false))
+        shuffle_control_center_colors = bool(slot_data.get("shuffle_control_center_colors", false))
         shuffle_doors = bool(slot_data.get("shuffle_doors", false))
+        shuffle_letters = int(slot_data.get("shuffle_letters", 0))
         victory_condition = int(slot_data.get("victory_condition", 0))
 
         # Set up item locks.
@@ -311,6 +361,21 @@ func _client_connected(slot_data):
                                 var door = gamedata.objects.get_doors()[progressive.get_doors()[i]]
                                 _item_locks[door.get_id()] = [progressive.get_ap_id(), i + 1]
 
+                for door_group in gamedata.objects.get_door_groups():
+                        if door_group.get_type() == gamedata.SCRIPT_proto.DoorGroupType.CONNECTOR:
+                                for door in door_group.get_doors():
+                                        _item_locks[door] = [door_group.get_ap_id(), 1]
+
+        if shuffle_control_center_colors:
+                for door in gamedata.objects.get_doors():
+                        if door.get_type() == gamedata.SCRIPT_proto.DoorType.CONTROL_CENTER_COLOR:
+                                _item_locks[door.get_id()] = [door.get_ap_id(), 1]
+
+                for door_group in gamedata.objects.get_door_groups():
+                        if door_group.get_type() == gamedata.SCRIPT_proto.DoorGroupType.COLOR_CONNECTOR:
+                                for door in door_group.get_doors():
+                                        _item_locks[door] = [door_group.get_ap_id(), 1]
+
         emit_signal("ap_connected")
 
 
@@ -325,10 +390,28 @@ func send_location(loc_id):
                 client.sendLocation(loc_id)
 
 
+func scout_location(loc_id):
+        if _location_scouts.has(loc_id):
+                return _location_scouts.get(loc_id)
+
+        if _batch_locations:
+                _held_location_scouts.append(loc_id)
+        else:
+                client.scoutLocation(loc_id)
+
+        return null
+
+
 func stop_batching_locations():
         _batch_locations = false
-        client.sendLocations(_held_locations)
-        _held_locations.clear()
+
+        if not _held_locations.is_empty():
+                client.sendLocations(_held_locations)
+                _held_locations.clear()
+
+        if not _held_location_scouts.is_empty():
+                client.scoutLocations(_held_location_scouts)
+                _held_location_scouts.clear()
 
 
 func colorForItemType(flags):
@@ -344,3 +427,47 @@ func colorForItemType(flags):
                 return "#d63a22"
         else:  # filler
                 return "#14de9e"
+
+
+func get_letter_behavior(key, level2):
+        if shuffle_letters == kSHUFFLE_LETTERS_UNLOCKED:
+                return kLETTER_BEHAVIOR_UNLOCKED
+
+        if [kSHUFFLE_LETTERS_VANILLA_CYAN, kSHUFFLE_LETTERS_ITEM_CYAN].has(shuffle_letters):
+                if level2:
+                        if shuffle_letters == kSHUFFLE_LETTERS_VANILLA_CYAN:
+                                return kLETTER_BEHAVIOR_VANILLA
+                        else:
+                                return kLETTER_BEHAVIOR_ITEM
+                else:
+                        return kLETTER_BEHAVIOR_UNLOCKED
+
+        if not level2 and ["h", "i", "n", "t"].has(key):
+                # This differs from the equivalent function in the apworld. Logically it is
+                # the same as UNLOCKED since they are in the starting room, but VANILLA
+                # means the player still has to actually pick up the letters.
+                return kLETTER_BEHAVIOR_VANILLA
+
+        if shuffle_letters == kSHUFFLE_LETTERS_PROGRESSIVE:
+                return kLETTER_BEHAVIOR_ITEM
+
+        return kLETTER_BEHAVIOR_VANILLA
+
+
+func setup_keys():
+        keyboard.load_seed()
+
+        _letters_setup = true
+
+        for k in _held_letters.keys():
+                _process_key_item(k, _held_letters[k])
+
+        _held_letters.clear()
+
+
+func _process_key_item(key, level):
+        if not _letters_setup:
+                _held_letters[key] = max(_held_letters.get(key, 0), level)
+                return
+
+        keyboard.collect_remote_letter(key, level)
@@ -81,6 +81,23 @@ func _ready():
 
                 get_parent().add_child.call_deferred(locationListener)
 
+                if (
+                        ap.get_letter_behavior(letter.get_key(), letter.has_level2() and letter.get_level2())
+                        != ap.kLETTER_BEHAVIOR_VANILLA
+                ):
+                        var scout = ap.scout_location(letter.get_ap_id())
+                        if scout != null:
+                                var item_name = "Unknown"
+                                var item_player_game = ap.client._game_by_player[float(scout["player"])]
+                                if ap.client._item_id_to_name[item_player_game].has(scout["item"]):
+                                        item_name = ap.client._item_id_to_name[item_player_game][scout["item"]]
+
+                                        var collectable = get_tree().get_root().get_node("scene").get_node_or_null(
+                                                letter.get_path()
+                                        )
+                                        if collectable != null:
+                                                collectable.setScoutedText.call_deferred(item_name)
+
         # Set up mastery locations.
         for mastery in gamedata.objects.get_masteries():
                 var room = gamedata.objects.get_rooms()[mastery.get_room_id()]
@@ -2,4 +2,8 @@ extends "res://scripts/nodes/saver.gd"
 
 
 func levelLoaded():
-        reload.call_deferred()
+        if type == "keyholders":
+                var ap = global.get_node("Archipelago")
+                ap.keyboard.load_keyholders.call_deferred(global.map)
+        else:
+                reload.call_deferred()
@@ -22,14 +22,8 @@ func _ready():
                 var ap_instance = ap_script.new()
                 ap_instance.name = "Archipelago"
 
-                #apclient_instance.SCRIPT_doorControl = load("user://maps/Archipelago/doorControl.gd")
-                #apclient_instance.SCRIPT_effects = load("user://maps/Archipelago/effects.gd")
-                #apclient_instance.SCRIPT_location = load("user://maps/Archipelago/location.gd")
-                #apclient_instance.SCRIPT_mypainting = load("user://maps/Archipelago/mypainting.gd")
-                #apclient_instance.SCRIPT_panel = load("user://maps/Archipelago/panel.gd")
-                #apclient_instance.SCRIPT_textclient = load("user://maps/Archipelago/textclient.gd")
-
                 ap_instance.SCRIPT_client = load("user://maps/Archipelago/client.gd")
+                ap_instance.SCRIPT_keyboard = load("user://maps/Archipelago/keyboard.gd")
                 ap_instance.SCRIPT_locationListener = load("user://maps/Archipelago/locationListener.gd")
                 ap_instance.SCRIPT_uuid = load("user://maps/Archipelago/vendor/uuid.gd")
                 ap_instance.SCRIPT_victoryListener = load("user://maps/Archipelago/victoryListener.gd")
@@ -38,7 +32,13 @@ func _ready():
 
                 # Let's also inject any scripts we need to inject now.
                 installScriptExtension(ResourceLoader.load("user://maps/Archipelago/animationListener.gd"))
+                installScriptExtension(ResourceLoader.load("user://maps/Archipelago/collectable.gd"))
                 installScriptExtension(ResourceLoader.load("user://maps/Archipelago/door.gd"))
+                installScriptExtension(ResourceLoader.load("user://maps/Archipelago/keyHolder.gd"))
+                installScriptExtension(ResourceLoader.load("user://maps/Archipelago/keyHolderChecker.gd"))
+                installScriptExtension(
+                        ResourceLoader.load("user://maps/Archipelago/keyHolderResetterListener.gd")
+                )
                 installScriptExtension(ResourceLoader.load("user://maps/Archipelago/painting.gd"))
                 installScriptExtension(ResourceLoader.load("user://maps/Archipelago/pauseMenu.gd"))
                 installScriptExtension(ResourceLoader.load("user://maps/Archipelago/player.gd"))
@@ -141,17 +141,22 @@ func connectionSuccessful():
         global.universe = "lingo"
         global.map = "the_entry"
 
-        unlocks.resetKeys()
         unlocks.resetCollectables()
         unlocks.resetData()
-        unlocks.loadKeys()
+
+        ap.setup_keys()
+
         unlocks.loadCollectables()
         unlocks.loadData()
         unlocks.unlockKey("capslock", 1)
 
         clearResourceCache("res://objects/meshes/gridDoor.tscn")
+        clearResourceCache("res://objects/nodes/collectable.tscn")
         clearResourceCache("res://objects/nodes/door.tscn")
+        clearResourceCache("res://objects/nodes/keyHolder.tscn")
         clearResourceCache("res://objects/nodes/listeners/animationListener.tscn")
+        clearResourceCache("res://objects/nodes/listeners/keyHolderChecker.tscn")
+        clearResourceCache("res://objects/nodes/listeners/keyHolderResetterListener.tscn")
         clearResourceCache("res://objects/nodes/listeners/teleportListener.tscn")
         clearResourceCache("res://objects/nodes/listeners/worldportListener.tscn")
         clearResourceCache("res://objects/nodes/player.tscn")
@@ -0,0 +1,84 @@
+door_groups {
+  name: "The Entry - Repetitive Entrance"
+  type: CONNECTOR
+  doors {
+    map: "the_entry"
+    name: "Starting Room West Wall North Door"
+  }
+  doors {
+    map: "the_repetitive"
+    name: "Entry Entrance"
+  }
+}
+door_groups {
+  name: "The Repetitive - Plaza Entrance"
+  type: CONNECTOR
+  doors {
+    map: "the_repetitive"
+    name: "Black Hallway"
+  }
+  doors {
+    map: "the_plaza"
+    name: "Repetitive Entrance"
+  }
+}
+door_groups {
+  name: "Control Center White Doors"
+  type: COLOR_CONNECTOR
+  doors {
+    map: "daedalus"
+    name: "White Hallway From Entry"
+  }
+  doors {
+    map: "the_entry"
+    name: "Control Center White Door"
+  }
+}
+door_groups {
+  name: "Control Center Purple Doors"
+  type: COLOR_CONNECTOR
+  doors {
+    map: "daedalus"
+    name: "Purple Hallway From Great"
+  }
+  doors {
+    map: "the_great"
+    name: "Control Center Purple Door"
+  }
+}
+door_groups {
+  name: "Control Center Orange Doors"
+  type: COLOR_CONNECTOR
+  doors {
+    map: "daedalus"
+    name: "Control Center Orange Door"
+  }
+  doors {
+    map: "the_unkempt"
+    name: "Control Center Orange Door"
+  }
+}
+door_groups {
+  name: "Control Center Brown Doors"
+  type: COLOR_CONNECTOR
+  doors {
+    map: "the_bearer"
+    name: "Control Center Brown Door"
+  }
+  doors {
+    map: "the_tree"
+    name: "Control Center Brown Door"
+  }
+}
+door_groups {
+  name: "Control Center Blue Doors"
+  type: COLOR_CONNECTOR
+  doors {
+    map: "the_digital"
+    name: "Control Center Blue Door"
+  }
+  doors {
+    map: "the_unyielding"
+    name: "Digital Entrance"
+  }
+}
@@ -1743,13 +1743,13 @@ maps:
       Red Blue Area Left Door: 302
       Red Blue Area Right Door: 303
       Red Room Painting: 323
-      Repetitive Entrance: 312
       Revitalized Entrance: 306
       Right Eye Entrance: 301
       Scarf Door: 296
       Second Room Left Door: 298
       Second Room Right Door: 290
       Shop Entrance: 313
+      Starting Room West Wall North Door: 2781
       Third Eye Painting: 324
       Trick Door: 287
       Trick To Shop Door: 289
@@ -2760,6 +2760,7 @@ maps:
           ZEROING: 1118
     doors:
       Anti-Collectable Room: 1025
+      Black Hallway: 2780
       Cyan Door: 1028
       Cyan Puzzles: 1032
       Dot Area Entrance: 1026
@@ -2768,7 +2769,6 @@ maps:
       Lime Puzzles: 1031
       Magenta Door: 1029
       Magenta Puzzles: 1033
-      Plaza Entrance: 1024
       Yellow Door: 1030
       Yellow Puzzles: 1034
   the_revitalized:
@@ -3840,3 +3840,11 @@ special:
   A Job Well Done: 1160
 progressives:
   Progressive Gold Ending: 2753
+door_groups:
+  Control Center Blue Doors: 2788
+  Control Center Brown Doors: 2787
+  Control Center Orange Doors: 2786
+  Control Center Purple Doors: 2785
+  Control Center White Doors: 2784
+  The Entry - Repetitive Entrance: 2782
+  The Repetitive - Plaza Entrance: 2783
@@ -892,16 +892,12 @@ doors {
 }
 doors {
   name: "White Hallway From Entry"
-  # TODO: This should be combined with the corresponding door in the_entry, at
-  # least when connections are not shuffled.
   type: CONTROL_CENTER_COLOR
   receivers: "Components/Doors/Halls/froom_6"
   control_center_color: "white"
 }
 doors {
   name: "Purple Hallway From Great"
-  # TODO: This should be combined with the corresponding door in the_great, at
-  # least when connections are not shuffled.
   type: CONTROL_CENTER_COLOR
   receivers: "Components/Doors/Halls/froom_7"
   control_center_color: "purple"
@@ -1080,6 +1076,7 @@ doors {
   panels { room: "Outside Snake Room" name: "SONG (South)" }
   panels { room: "West Castle Area" name: "SONG (2)" }
   location_room: "West Castle Area"
+  location_name: "South SONGs"
 }
 doors {
   name: "Amber North Door"
@@ -1088,6 +1085,7 @@ doors {
   panels { room: "Outside Snake Room" name: "SONG (North)" }
   panels { room: "Amber North 2" name: "SONG" }
   location_room: "Amber North 2"
+  location_name: "North SONGs"
 }
 doors {
   name: "Amber East Doors"
@@ -1921,6 +1919,7 @@ doors {
   type: LOCATION_ONLY
   panels { room: "Dark Light Exit" name: "GASKET" }
   location_room: "Dark Light Exit"
+  location_name: "GASKET"
 }
 doors {
   name: "Dark Light Room Divider"
@@ -192,7 +192,7 @@ connections {
 connections {
   from_room: "Starting Room"
   to_room: "Repetitive Entrance"
-  door { name: "Repetitive Entrance" }
+  door { name: "Starting Room West Wall North Door" }
 }
 connections {
   from_room: "Lime Room"
@@ -193,7 +193,7 @@ doors {
   location_room: "Starting Room"
 }
 doors {
-  name: "Repetitive Entrance"
+  name: "Starting Room West Wall North Door"
   type: ITEM_ONLY
   receivers: "Components/Doors/Entry/entry_proxied_9"
   double_letters: true
@@ -49,6 +49,7 @@ doors {
   type: LOCATION_ONLY
   panels { room: "West Side" name: "ERASE" }
   location_room: "West Side"
+  location_name: "ERASE"
 }
 doors {
   name: "Control Center Purple Door"
@@ -10,4 +10,5 @@ doors {
   panels { room: "Room" name: "INTO" }
   panels { room: "Room" name: "NOR" }
   location_room: "Room"
+  location_name: "Gravestone"
 }
@@ -6,7 +6,7 @@ connections {
 connections {
   from_room: "Main Room"
   to_room: "Plaza Connector"
-  door { name: "Plaza Entrance" }
+  door { name: "Black Hallway" }
   oneway: true
 }
 connections {
@@ -6,7 +6,7 @@ doors {
   location_room: "Main Room"
 }
 doors {
-  name: "Plaza Entrance"
+  name: "Black Hallway"
   type: STANDARD
   receivers: "Components/Doors/Door12"
   panels { room: "Main Room" name: "I" }
@@ -50,4 +50,5 @@ doors {
   panels { room: "Dead End Room" name: "DEAD" }
   panels { room: "Dead End Room" name: "END" }
   location_room: "Loose Strings Room"
+  location_name: "Gravestone"
 }
@@ -38,4 +38,5 @@ doors {
   panels { room: "Main Area" name: "SMALL (3)" }
   panels { room: "Main Area" name: "SPRINKLE" }
   location_room: "Main Area"
+  location_name: "Gravestone"
 }
@@ -29,6 +29,20 @@ enum DoorType {
   GRAVESTONE = 6;
 }
 
+enum DoorGroupType {
+  DOOR_GROUP_TYPE_UNKNOWN = 0;
+
+  // These doors border a worldport. They should be grouped when connections are
+  // not shuffled.
+  CONNECTOR = 1;
+
+  // Similar to CONNECTOR, but these doors are also ordinarily opened by solving
+  // the COLOR panel in the Control Center. These should be grouped when
+  // connections are not shuffled, but are not items at all when control center
+  // colors are not shuffled.
+  COLOR_CONNECTOR = 2;
+}
+
 enum AxisDirection {
   AXIS_DIRECTION_UNKNOWN = 0;
 
@@ -232,6 +246,14 @@ message Progressive {
   repeated uint64 doors = 4;
 }
 
+message DoorGroup {
+  optional uint64 id = 1;
+  optional string name = 2;
+  optional uint64 ap_id = 3;
+  optional DoorGroupType type = 4;
+  repeated uint64 doors = 5;
+}
+
 message AllObjects {
   repeated Map maps = 7;
   repeated Room rooms = 1;
@@ -245,5 +267,6 @@ message AllObjects {
   repeated Ending endings = 12;
   repeated Connection connections = 6;
   repeated Progressive progressives = 13;
+  repeated DoorGroup door_groups = 14;
   map<string, uint64> special_ids = 8;
 }
@@ -203,6 +203,16 @@ message HumanProgressives {
   repeated HumanProgressive progressives = 1;
 }
 
+message HumanDoorGroup {
+  optional string name = 1;
+  optional DoorGroupType type = 2;
+  repeated DoorIdentifier doors = 3;
+}
+
+message HumanDoorGroups {
+  repeated HumanDoorGroup door_groups = 1;
+}
+
 message IdMappings {
   message RoomIds {
     map<string, uint64> panels = 1;
@@ -220,4 +230,5 @@ message IdMappings {
   map<string, uint64> letters = 3;
   map<string, uint64> endings = 4;
   map<string, uint64> progressives = 5;
+  map<string, uint64> door_groups = 6;
 }
@@ -42,6 +42,7 @@ class AssignIds {
     ProcessMaps(datadir_path);
     ProcessSpecialIds();
     ProcessProgressivesFile(datadir_path / "progressives.txtpb");
+    ProcessDoorGroupsFile(datadir_path / "door_groups.txtpb");
 
     WriteIds(ids_path);
 
@@ -61,6 +62,7 @@ class AssignIds {
       for (const auto& [_, room] : map.rooms()) {
         UpdateNextId(room.panels());
         UpdateNextId(room.masteries());
+        UpdateNextId(room.keyholders());
       }
     }
 
@@ -68,6 +70,7 @@ class AssignIds {
     UpdateNextId(id_mappings_.letters());
     UpdateNextId(id_mappings_.endings());
     UpdateNextId(id_mappings_.progressives());
+    UpdateNextId(id_mappings_.door_groups());
 
     next_id_++;
   }
@@ -267,6 +270,23 @@ class AssignIds {
     }
   }
 
+  void ProcessDoorGroupsFile(std::filesystem::path path) {
+    if (!std::filesystem::exists(path)) {
+      return;
+    }
+
+    auto h_groups = ReadMessageFromFile<HumanDoorGroups>(path.string());
+    auto& groups = *output_.mutable_door_groups();
+
+    for (const HumanDoorGroup& h_group : h_groups.door_groups()) {
+      if (!id_mappings_.door_groups().contains(h_group.name())) {
+        groups[h_group.name()] = next_id_++;
+      } else {
+        groups[h_group.name()] = id_mappings_.door_groups().at(h_group.name());
+      }
+    }
+  }
+
  private:
   void UpdateNextId(const google::protobuf::Map<std::string, uint64_t>& ids) {
     for (const auto& [_, id] : ids) {
@@ -348,6 +348,23 @@ uint64_t Container::FindOrAddProgressive(std::string prog_name) {
   }
 }
 
+uint64_t Container::FindOrAddDoorGroup(std::string group_name) {
+  auto it = door_group_id_by_name_.find(group_name);
+
+  if (it == door_group_id_by_name_.end()) {
+    uint64_t new_id = all_objects_.door_groups_size();
+    DoorGroup* door_group = all_objects_.add_door_groups();
+    door_group->set_id(new_id);
+    door_group->set_name(group_name);
+
+    door_group_id_by_name_[group_name] = new_id;
+
+    return new_id;
+  } else {
+    return it->second;
+  }
+}
+
 void Container::AddConnection(const Connection& connection) {
   *all_objects_.add_connections() = connection;
 }
@@ -62,6 +62,8 @@ class Container {
 
   uint64_t FindOrAddProgressive(std::string prog_name);
 
+  uint64_t FindOrAddDoorGroup(std::string group_name);
+
   AllObjects& all_objects() { return all_objects_; }
 
  private:
@@ -85,6 +87,7 @@ class Container {
       door_id_by_map_door_names_;
   std::map<std::string, uint64_t> ending_id_by_name_;
   std::map<std::string, uint64_t> progressive_id_by_name_;
+  std::map<std::string, uint64_t> door_group_id_by_name_;
 };
 
 }  // namespace com::fourisland::lingo2_archipelago
@@ -44,6 +44,7 @@ class DataPacker {
     ProcessConnectionsFile(datadir_path / "connections.txtpb", std::nullopt);
     ProcessMaps(datadir_path);
     ProcessProgressivesFile(datadir_path / "progressives.txtpb");
+    ProcessDoorGroupsFile(datadir_path / "door_groups.txtpb");
     ProcessIdsFile(datadir_path / "ids.yaml");
 
     {
@@ -577,6 +578,31 @@ class DataPacker {
     }
   }
 
+  void ProcessDoorGroupsFile(std::filesystem::path path) {
+    if (!std::filesystem::exists(path)) {
+      return;
+    }
+
+    auto h_groups = ReadMessageFromFile<HumanDoorGroups>(path.string());
+
+    for (const HumanDoorGroup& h_group : h_groups.door_groups()) {
+      ProcessDoorGroup(h_group);
+    }
+  }
+
+  void ProcessDoorGroup(const HumanDoorGroup& h_group) {
+    uint64_t group_id = container_.FindOrAddDoorGroup(h_group.name());
+    DoorGroup& group = *container_.all_objects().mutable_door_groups(group_id);
+
+    group.set_type(h_group.type());
+
+    for (const DoorIdentifier& di : h_group.doors()) {
+      uint64_t door_id =
+          container_.FindOrAddDoor(di.map(), di.name(), std::nullopt);
+      group.add_doors(door_id);
+    }
+  }
+
   void ProcessIdsFile(std::filesystem::path path) {
     auto ids = ReadIdsFromYaml(path.string());
 
@@ -631,6 +657,11 @@ class DataPacker {
       uint64_t prog_id = container_.FindOrAddProgressive(prog_name);
       container_.all_objects().mutable_progressives(prog_id)->set_ap_id(ap_id);
     }
+
+    for (const auto& [group_name, ap_id] : ids.door_groups()) {
+      uint64_t group_id = container_.FindOrAddDoorGroup(group_name);
+      container_.all_objects().mutable_door_groups(group_id)->set_ap_id(ap_id);
+    }
   }
 
   std::string mapdir_;
@@ -104,6 +104,13 @@ IdMappings ReadIdsFromYaml(const std::string& filename) {
     }
   }
 
+  if (document["door_groups"]) {
+    for (const auto& group_it : document["door_groups"]) {
+      (*result.mutable_door_groups())[group_it.first.as<std::string>()] =
+          group_it.second.as<uint64_t>();
+    }
+  }
+
   return result;
 }
 
@@ -171,6 +178,11 @@ void WriteIdsAsYaml(const IdMappings& ids, const std::string& filename) {
                        result["progressives"][prog_name] = prog_id;
                      });
 
+  OperateOnSortedMap(ids.door_groups(), [&result](const std::string& group_name,
+                                                  uint64_t group_id) {
+    result["door_groups"][group_name] = group_id;
+  });
+
   std::ofstream output_stream(filename);
   output_stream << result << std::endl;
 }
@@ -43,6 +43,7 @@ class HumanProcessor {
     ProcessConnectionsFile(datadir_path / "connections.txtpb", std::nullopt);
     ProcessMaps(datadir_path);
     ProcessProgressivesFile(datadir_path / "progressives.txtpb");
+    ProcessDoorGroupsFile(datadir_path / "door_groups.txtpb");
     ProcessIdsFile(datadir_path / "ids.yaml");
   }
 
@@ -510,6 +511,33 @@ class HumanProcessor {
     }
   }
 
+  void ProcessDoorGroupsFile(std::filesystem::path path) {
+    if (!std::filesystem::exists(path)) {
+      return;
+    }
+
+    auto h_groups = ReadMessageFromFile<HumanDoorGroups>(path.string());
+
+    for (const HumanDoorGroup& h_group : h_groups.door_groups()) {
+      ProcessDoorGroup(h_group);
+    }
+  }
+
+  void ProcessDoorGroup(const HumanDoorGroup& h_group) {
+    DoorGroupInfo& group_info = info_.door_groups[h_group.name()];
+    group_info.definitions.push_back(h_group);
+
+    for (const DoorIdentifier& di : h_group.doors()) {
+      if (!di.has_map()) {
+        group_info.malformed_doors.push_back(di);
+        continue;
+      }
+
+      DoorInfo& door_info = info_.doors[di];
+      door_info.door_groups_referenced_by.push_back(h_group.name());
+    }
+  }
+
   void ProcessIdsFile(std::filesystem::path path) {
     auto ids = ReadIdsFromYaml(path.string());
 
@@ -573,6 +601,11 @@ class HumanProcessor {
       ProgressiveInfo& prog_info = info_.progressives[prog_name];
       prog_info.has_id = true;
     }
+
+    for (const auto& [group_name, ap_id] : ids.door_groups()) {
+      DoorGroupInfo& group_info = info_.door_groups[group_name];
+      group_info.has_id = true;
+    }
   }
 
   std::string mapdir_;
@@ -47,6 +47,7 @@ struct DoorInfo {
   std::vector<PaintingIdentifier> paintings_referenced_by;
   std::vector<PortIdentifier> ports_referenced_by;
   std::vector<std::string> progressives_referenced_by;
+  std::vector<std::string> door_groups_referenced_by;
 
   MalformedIdentifiers malformed_identifiers;
 };
@@ -115,6 +116,13 @@ struct ProgressiveInfo {
   std::vector<DoorIdentifier> malformed_doors;
 };
 
+struct DoorGroupInfo {
+  std::vector<HumanDoorGroup> definitions;
+  bool has_id = false;
+
+  std::vector<DoorIdentifier> malformed_doors;
+};
+
 struct CollectedInfo {
   std::map<std::string, MapInfo> maps;
   std::map<RoomIdentifier, RoomInfo, RoomIdentifierLess> rooms;
@@ -128,6 +136,7 @@ struct CollectedInfo {
   std::map<std::string, EndingInfo> endings;
   std::map<std::string, PanelNameInfo> panel_names;
   std::map<std::string, ProgressiveInfo> progressives;
+  std::map<std::string, DoorGroupInfo> door_groups;
 };
 
 }  // namespace com::fourisland::lingo2_archipelago
@@ -48,6 +48,9 @@ class Validator {
     for (const auto& [prog_name, prog_info] : info_.progressives) {
       ValidateProgressive(prog_name, prog_info);
     }
+    for (const auto& [group_name, group_info] : info_.door_groups) {
+      ValidateDoorGroup(group_name, group_info);
+    }
   }
 
  private:
@@ -173,6 +176,11 @@ class Validator {
         std::cout << "    PROGRESSIVE " << prog_name << std::endl;
       }
 
+      for (const std::string& group_name :
+           door_info.door_groups_referenced_by) {
+        std::cout << "    DOOR GROUP " << group_name << std::endl;
+      }
+
       if (door_info.has_id) {
         std::cout << "    An AP ID is present." << std::endl;
       }
@@ -460,6 +468,26 @@ class Validator {
     }
   }
 
+  void ValidateDoorGroup(const std::string& group_name,
+                         const DoorGroupInfo& group_info) const {
+    if (group_info.definitions.empty()) {
+      std::cout << "Door group \"" << group_name
+                << "\" has no definition, but was referenced:" << std::endl;
+
+      if (group_info.has_id) {
+        std::cout << "    An AP ID is present." << std::endl;
+      }
+    } else if (group_info.definitions.size() > 1) {
+      std::cout << "Door group \"" << group_name
+                << "\" has multiple definitions." << std::endl;
+    }
+
+    if (!group_info.has_id) {
+      std::cout << "Door group \"" << group_name << "\" is missing an AP ID."
+                << std::endl;
+    }
+  }
+
   const CollectedInfo& info_;
 };