680 files changed, 15272 insertions, 1419 deletions

@@ -5,3 +5,4 @@ apworld/generated/
 __pycache__
 .vs/
 ^out/
+client/Archipelago/generated/
@@ -0,0 +1,180 @@
+# lingo2-archipelago Releases
+
+## v7.0.0 - 2025-09-30
+
+- Major update! First and foremost: the client and apworld are no longer
+  separate! There is only an apworld now, which you install into your
+  Archipelago custom worlds folder as per normal. In order to play a randomized
+  world, you open the Archipelago Launcher and click Lingo 2 Client. The first
+  time you do this, it will ask you for the location of your Lingo2.exe, which
+  you can find by right clicking on the game in Steam and clicking Browse Local
+  Files.
+- **Built-in tracker**: The in-game text client has a new tab called "Locations"
+  which lists the currently accessible locations similar to how Universal
+  Tracker does it. There is also an optional overlay you can enable in the
+  settings, which shows you some of your accessible locations on screen while
+  you're playing. If you're playing with vanilla letters, the tracker won't show
+  you locations that are solvable with letters until you collect the actual
+  letters, in order to help direct you better. More features will be coming to
+  the tracker in the future!
+- **Worldport shuffle**: The first part of entrance randomization is here!
+  Enabling this shuffles the destinations of the worldports, which are the
+  loading zones you walk into in order to change maps. Some restrictions apply,
+  which are noted in the option description. The tracker will show a list of
+  worldports you haven't entered yet, and will also not show you what lies
+  beyond a worldport until you've entered it. There is also a tab in the
+  textclient showing you the mapping between worldports you've already entered.
+- **Minimap**: There is an option in the settings to show a minimap in the
+  corner of the screen. This shows an overhead view of the map you're on, and
+  where you are in it. More features will be coming to the minimap in the
+  future!
+- Fixed the gate outside the Daedalus entrance in The Great not opening when
+  control center colors are shuffled.
+
+Download:
+[lingo2.apworld](https://files.fourisland.com/releases/lingo2-archipelago/apworld/v7.0.0/lingo2.apworld)<br/>
+Template YAML:
+[Lingo 2.yaml](https://files.fourisland.com/releases/lingo2-archipelago/apworld/v7.0.0/Lingo%202.yaml)<br/>
+Source: [v7.0.0](https://code.fourisland.com/lingo2-archipelago/tag/?h=v7.0.0)
+
+## Legacy Client v6.7 - 2025-09-19
+
+- Added a compass overlay. This makes it clearer which direction corresponds to
+  which compass direction, which is useful since many location/item names
+  reference compass directions. It can be enabled in the settings screen on the
+  pause menu.
+- Compatability update for the changes in v6.6 of the apworld.
+
+Download:
+[lingo2-archipelago-client-v6.7.zip](https://files.fourisland.com/releases/lingo2-archipelago/client/lingo2-archipelago-client-v6.7.zip)<br/>
+Source:
+[v6.7](https://code.fourisland.com/lingo2-archipelago/tag/?h=client-v6.7)
+
+## Legacy Apworld v6.6 - 2025-09-19
+
+- Added options that make the requirements for Purple Ending and Cyan Ending
+  stricter. With the strict options on, players are required to have all purple
+  (level 1) letters in order to get Purple Ending, and all cyan (level 2)
+  letters to get Cyan Ending. These options are on by default.
+- Renamed several items and locations, mostly regarding changing relative
+  directions (left, right, etc) to compass directions. The colored SMILE panels
+  in Daedalus now have clearer names too.
+- Fixed some minor logic errors.
+
+Download:
+[lingo2.apworld](https://files.fourisland.com/releases/lingo2-archipelago/apworld/v6.6/lingo2.apworld)<br/>
+Template YAML:
+[Lingo 2.yaml](https://files.fourisland.com/releases/lingo2-archipelago/apworld/v6.6/Lingo%202.yaml)<br/>
+Source:
+[v6.6](https://code.fourisland.com/lingo2-archipelago/tag/?h=apworld-v6.6)
+
+## Legacy Client v5.6 - 2025-09-17
+
+- Letter locations will no longer reappear after being collected.
+- This also prevents a potential scenario in which it is impossible to access
+  the location "The Congruent - Obverse Yellow Puzzles" when door shuffle is
+  disabled.
+
+Download:
+[lingo2-archipelago-client-v5.6.zip](https://files.fourisland.com/releases/lingo2-archipelago/client/lingo2-archipelago-client-v5.6.zip)<br/>
+Source:
+[v5.6](https://code.fourisland.com/lingo2-archipelago/tag/?h=client-v5.6)
+
+## Legacy Client v5.5 - 2025-09-16
+
+- Compatability update for v5.5 of the apworld.
+
+Download:
+[lingo2-archipelago-client-v5.5.zip](https://files.fourisland.com/releases/lingo2-archipelago/client/lingo2-archipelago-client-v5.5.zip)<br/>
+Source:
+[v5.5](https://code.fourisland.com/lingo2-archipelago/tag/?h=client-v5.5)
+
+## Legacy Apworld v5.5 - 2025-09-16
+
+- Fixed a panel in The Ancient that was missing a symbol.
+- Fixed an issue where you could be expected to get S1 in The Darkroom without
+  having U.
+- Renamed a few locations.
+
+Download:
+[lingo2.apworld](https://files.fourisland.com/releases/lingo2-archipelago/apworld/v5.5/lingo2.apworld)<br/>
+Template YAML:
+[Lingo 2.yaml](https://files.fourisland.com/releases/lingo2-archipelago/apworld/v5.5/Lingo%202.yaml)<br/>
+Source:
+[v5.5](https://code.fourisland.com/lingo2-archipelago/tag/?h=apworld-v5.5)
+
+## Legacy Apworld v4.4 - 2025-09-14
+
+- Fixed panel set location names.
+
+Download:
+[lingo2.apworld](https://files.fourisland.com/releases/lingo2-archipelago/apworld/v4.4/lingo2.apworld)<br/>
+Template YAML:
+[Lingo 2.yaml](https://files.fourisland.com/releases/lingo2-archipelago/apworld/v4.4/Lingo%202.yaml)<br/>
+Source:
+[v4.4](https://code.fourisland.com/lingo2-archipelago/tag/?h=apworld-v4.4)
+
+## Legacy Client v4.4 - 2025-09-13
+
+- Added support for anti-collectable trap items.
+- Fixed entrance to The Jubilant not opening properly when using control center
+  color shuffle.
+- Fixed the location "The Entry (Colored Doors Area) - OPEN" not sending.
+- Fixed level 2 letters not activating properly when letter shuffle is set to
+  Item Cyan.
+- Messages are now cleared out when returning to the main menu.
+- The player is prevented from accidentally breaking roof access logic when
+  returning to Daedalus from Icarus.
+
+Download:
+[lingo2-archipelago-client-v4.4.zip](https://files.fourisland.com/releases/lingo2-archipelago/client/lingo2-archipelago-client-v4.4.zip)<br/>
+Source:
+[v4.4](https://code.fourisland.com/lingo2-archipelago/tag/?h=client-v4.4)
+
+## Legacy Apworld v4.3 - 2025-09-13
+
+- Added a location for the anti-collectable in The Repetitive.
+- Added trap items. These remove letters from your keyboard until you use the
+  Key Return in The Entry, similar to the anti-collectable in The Repetitive.
+  This can be controlled using the `trap_percentage` option, which defaults to
+  zero.
+- Fixed crash on load when using Python 3.11.
+
+Download:
+[lingo2.apworld](https://files.fourisland.com/releases/lingo2-archipelago/apworld/v4.3/lingo2.apworld)<br/>
+Template YAML:
+[Lingo 2.yaml](https://files.fourisland.com/releases/lingo2-archipelago/apworld/v4.3/Lingo%202.yaml)<br/>
+Source:
+[v4.3](https://code.fourisland.com/lingo2-archipelago/tag/?h=apworld-v4.3)
+
+## Legacy Client v3.3 - 2025-09-12
+
+- Fixed issue downloading large datapackages (such as TUNIC's).
+- Connection failures now show error messages.
+
+Download:
+[lingo2-archipelago-client-v3.3.zip](https://files.fourisland.com/releases/lingo2-archipelago/client/lingo2-archipelago-client-v3.3.zip)<br/>
+Source:
+[v3.3](https://code.fourisland.com/lingo2-archipelago/tag/?h=client-v3.3)
+
+## Legacy Client v3.2 - 2025-09-12
+
+- Initial release for testing. Features include door shuffle, letter shuffle,
+  and symbol shuffle.
+
+Download:
+[lingo2-archipelago-client-v3.2.zip](https://files.fourisland.com/releases/lingo2-archipelago/client/lingo2-archipelago-client-v3.2.zip)<br/>
+Source:
+[v3.2](https://code.fourisland.com/lingo2-archipelago/tag/?h=client-v3.2)
+
+## Legacy Apworld v3.2 - 2025-09-12
+
+- Initial release for testing. Features include door shuffle, letter shuffle,
+  and symbol shuffle.
+
+Download:
+[lingo2.apworld](https://files.fourisland.com/releases/lingo2-archipelago/apworld/v3.2/lingo2.apworld)<br/>
+Template YAML:
+[Lingo 2.yaml](https://files.fourisland.com/releases/lingo2-archipelago/apworld/v3.2/Lingo%202.yaml)<br/>
+Source:
+[v3.2](https://code.fourisland.com/lingo2-archipelago/tag/?h=apworld-v3.2)
@@ -0,0 +1,190 @@
+# lingo2-archipelago
+
+[Archipelago](https://archipelago.gg/) is an open-source project that supports
+randomizing a number of different games and combining them into one cooperative
+experience. Items from each game are hidden in other games. For more information
+about Archipelago, you can look at their website.
+
+This is a project that modifies the game
+[Lingo 2](https://www.lingothegame.com/lingo2.html) so that it can be played as
+part of an Archipelago multiworld game.
+
+## Installation
+
+1. Download the Lingo 2 Apworld from
+   [the releases page](https://code.fourisland.com/lingo2-archipelago/about/CHANGELOG.md).
+2. If you do not already have it, download and install the
+   [Archipelago software](https://github.com/ArchipelagoMW/Archipelago/releases/).
+3. Double click on `lingo2.apworld` to install it, or copy it manually to the
+   `custom_worlds` folder of your Archipelago installation.
+
+## Joining a Multiworld game
+
+1. Open the Archipelago Launcher.
+2. Select "Lingo 2 Client".
+3. The first time you do this, Archipelago will prompt you for the location of
+   the Lingo 2 executable file ("Lingo2.exe"). You can find this by
+   right-clicking on Lingo 2 in Steam, going to "Manage", and clicking "Browse
+   local files".
+4. Lingo 2 will open, and you will see a form asking for your connection
+   details. Enter the Archipelago address, slot name, and password into the
+   fields.
+5. Press Connect.
+6. Enjoy!
+
+To continue an earlier game, you can perform the exact same steps as above.
+
+## Frequently Asked Questions
+
+### Why aren't the starting room letters shuffled?
+
+The letter requirements for solving puzzles are very restrictive, especially in
+the early game. It is possible for the generator to find some subset of letters
+and doors to place in the starting room such that you are not trapped, but this
+places a lot of strain on generation and leads to significantly more generation
+failures.
+
+As a result, the starting room letters (H1, I1, N1, and T1) are always present
+in the starting room, even when remote letter shuffle is enabled. These letters
+will _also_ count as clearing a check, so you will send out another item at the
+same time as collecting the letter.
+
+### What areas are randomized?
+
+Almost all maps that you can access from the base game are randomized. The
+exceptions are:
+
+- Icarus (this will be randomized at some point, although it will be optional)
+- Demo
+- The Hinterlands (this will probably be repurposed)
+- The beta tester gift maps
+
+### Is my progress saved locally?
+
+Lingo 2 autosaves your progress every time you solve a puzzle, get a
+collectable, or interact with a keyholder. The randomizer generates a savefile
+name based on your Multiworld seed and slot number, so you should be able to
+seamlessly switch between multiworlds and even slots within a multiworld.
+
+The exception to this is different rooms created from the same multiworld seed.
+The client is unable to tell rooms in a seed apart (this is a limitation of the
+Archipelago API), so the client will use the same save file for the same slot in
+different rooms on the same seed. You can work around this by manually moving or
+removing the save folder from the users directory in Lingo 2's game files.
+
+If you play the base game again, you will see one or more save files with a long
+name that begins with "zzAP\_". These are the saves for your multiworlds. They
+can be safely deleted after you have completed the associated multiworld. It is
+not recommended to load these save files outside of the randomizer.
+
+A connection to Archipelago is required to resume playing a multiworld. This is
+because the set of items you have received is not stored locally.
+
+### What about wall snipes?
+
+"Wall sniping" refers to the fact that you are able to solve puzzles on the
+other side of opaque walls. The player is never expected to or required to do
+this in normal gameplay. This randomizer does not change how wall snipes work,
+but it will likewise never require the use of them.
+
+### How do cyan doors work?
+
+In the base game, there are a number of cyan-colored doors that ordinarily open
+once you collect H2 in The Repetitive. There are also a handful of panels that
+only appear upon getting H2 as well, which the apworld treats the same as the
+cyan doors.
+
+There is an option that lets you choose how these doors and panels behave. By
+default, they act the same as in the base game: they only open or appear after
+collecting H2. Note that this means the actual H2 collectable in The Repetitive.
+Receiving H2 via remote letter shuffle does not count for this requirement.
+However, you can also make cyan doors activate upon collecting or receiving your
+first double letter, regardless of what it is or if it's remote. Finally, you
+can lock cyan doors behind an item called "Cyan Doors".
+
+It is important to note, however, that the Cyan Door Behavior option only
+applies to cyan doors that are not already affected by another type of
+shuffling. When door shuffle is on, the following cyan doors are activated by
+individual items and are not impacted by your choice of Cyan Door Behavior:
+
+- The entrance to The Tower from The Great (The Great - Tower Entrance)
+- The entrance to The Butterfly from The Bearer (The Bearer - Butterfly
+  Entrance)
+- The entrance to The Repetitive from The Entry (The Entry - Repetitive
+  Entrance)
+- The eye painting near the yellow color hallway in Daedalus (Daedalus - Eye
+  Painting)
+- The Red I room in The Repetitive (The Repetitive - Anti Collectable Room)
+
+Additionally, when control center color shuffle is enabled, the orange door in
+The Unkempt (which ordinarily doubles as a cyan door) opens upon receiving the
+Control Center Orange Doors item, instead of following the Cyan Door Behavior
+option.
+
+### Help! I lost C/G in The Congruent!
+
+If you place C or G into the relevant keyholders in The Congruent, the keyholder
+disappears. You can retrieve your letter immediately by pressing C or G again
+before leaving solve mode, as the keyholder will still be considered to be
+"focused", even though it has moved. If you have already moved, though, there is
+another way to get your letters back: just use the Key Return in The Entry.
+
+### Why is the tracker telling me to solve a panel that's currently red?
+
+Red usually indicates that a panel cannot be solved because of missing letters.
+However, that only applies to the puzzle's main answer. If a puzzle has
+alternate answers, you may be expected to use one of those instead of the main
+one. As long as you have all of the necessary letters, an alternate answer can
+be typed into a red panel even though it does not show you typing. When you
+finish typing the answer, the panel will solve as normal.
+
+## Running from source
+
+The randomizer is mostly written in Python and GDScript, which do not need to be
+compiled. However, there are three files that need to be generated before the
+apworld can be used.
+
+The first file is `data.binpb`, the datafile containing the randomizer logic.
+You can read about how to generate it on
+[its own README page](https://code.fourisland.com/lingo2-archipelago/about/data/README.md).
+Once you have it, put it in a subfolder of `apworld` called `generated`.
+
+The second generated file is `data_pb2.py`. This file allows Archipelago to read
+the datafile. We use `protoc`, the Protocol Buffer compiler, to generate it. As
+of 0.6.3, Archipelago has protobuf 3.20.3 packaged with it, which means we need
+to compile our proto file with a similar version.
+
+If you followed the steps to generate `data.binpb` and compiled the `datapacker`
+tool yourself, you will already have protobuf version 3.21.12 installed through
+vcpkg. You can then run a command similar to this in order to generate the
+python file.
+
+```shell
+.\out\build\x64-Debug\vcpkg_installed\x64-windows\tools\protobuf\protoc.exe -Iproto\ ^
+  --python_out=apworld\generated\ .\proto\data.proto
+```
+
+The exact path to `protoc.exe` is going to depend on where vcpkg installed its
+packages. The above location is where Visual Studio will probably put it.
+
+The third generated file is `proto.gd`. This is the GDScript version of the
+previous file. We use a Godot script to generate it, which means
+[the Godot Editor](https://godotengine.org/download/) is required. From the root
+of the repository:
+
+```shell
+cd vendor\godobuf
+godot --headless -s addons\protobuf\protobuf_cmdln.gd --input=..\..\proto\data.proto ^
+  --output=..\..\apworld\generated\proto.gd
+```
+
+If you are not on Windows, replace the forward slashes with backslashes as
+appropriate (and the caret with a forward slash). You will also probably need to
+replace "godot" at the start of the second line with a path to a Godot Editor
+executable.
+
+After generating those three files, the apworld should be functional. You can
+copy it into an Archipelago source tree (rename the folder `apworld` to `lingo2`
+if you do so) if you want to edit/debug the code. Otherwise, you can zip up the
+folder and rename it to `lingo2.apworld` in order to package it for
+distribution.
@@ -1,18 +1,38 @@
 """
 Archipelago init file for Lingo 2
 """
-from BaseClasses import ItemClassification, Item
+from typing import ClassVar
+
+from BaseClasses import ItemClassification, Item, Tutorial
+from settings import Group, UserFilePath
 from worlds.AutoWorld import WebWorld, World
-from .items import Lingo2Item
+from .items import Lingo2Item, ANTI_COLLECTABLE_TRAPS
 from .options import Lingo2Options
 from .player_logic import Lingo2PlayerLogic
-from .regions import create_regions
+from .regions import create_regions, shuffle_entrances, connect_ports_from_ut
 from .static_logic import Lingo2StaticLogic
+from ..LauncherComponents import Component, Type, components, launch as launch_component, icon_paths
 
 
 class Lingo2WebWorld(WebWorld):
     rich_text_options_doc = True
     theme = "grass"
+    tutorials = [Tutorial(
+        "Multiworld Setup Guide",
+        "A guide to playing Lingo 2 with Archipelago.",
+        "English",
+        "en_Lingo_2.md",
+        "setup/en",
+        ["hatkirby"]
+    )]
+
+
+class Lingo2Settings(Group):
+    class ExecutableFile(UserFilePath):
+        """Path to the Lingo 2 executable"""
+        is_exe = True
+
+    exe_file: ExecutableFile = ExecutableFile()
 
 
 class Lingo2World(World):
@@ -24,21 +44,43 @@ class Lingo2World(World):
     game = "Lingo 2"
     web = Lingo2WebWorld()
 
+    settings: ClassVar[Lingo2Settings]
+    settings_key = "lingo2_options"
+
+    topology_present = True
+
     options_dataclass = Lingo2Options
     options: Lingo2Options
 
     static_logic = Lingo2StaticLogic()
     item_name_to_id = static_logic.item_name_to_id
     location_name_to_id = static_logic.location_name_to_id
+    item_name_groups = static_logic.item_name_groups
+    location_name_groups = static_logic.location_name_groups
+
+    for_tracker: ClassVar[bool] = False
 
     player_logic: Lingo2PlayerLogic
 
+    port_pairings: dict[int, int]
+
     def generate_early(self):
         self.player_logic = Lingo2PlayerLogic(self)
+        self.port_pairings = {}
 
     def create_regions(self):
         create_regions(self)
 
+    def connect_entrances(self):
+        if self.options.shuffle_worldports:
+            if hasattr(self.multiworld, "re_gen_passthrough") and "Lingo 2" in self.multiworld.re_gen_passthrough:
+                slot_value = self.multiworld.re_gen_passthrough["Lingo 2"]["port_pairings"]
+                self.port_pairings = {int(fp): int(tp) for fp, tp in slot_value.items()}
+
+                connect_ports_from_ut(self.port_pairings, self)
+            else:
+                shuffle_entrances(self)
+
         from Utils import visualize_regions
 
         visualize_regions(self.multiworld.get_region("Menu", self.player), "my_world.puml")
@@ -49,11 +91,78 @@ class Lingo2World(World):
         total_locations = sum(len(locs) for locs in self.player_logic.locations_by_room.values())
 
         item_difference = total_locations - len(pool)
+
+        if self.options.trap_percentage > 0:
+            num_traps = int(item_difference * self.options.trap_percentage / 100)
+            item_difference = item_difference - num_traps
+
+            trap_names = []
+            trap_weights = []
+            for letter_name, weight in self.static_logic.letter_weights.items():
+                trap_names.append(f"Anti {letter_name}")
+                trap_weights.append(weight)
+
+            bad_letters = self.random.choices(trap_names, weights=trap_weights, k=num_traps)
+            pool += [self.create_item(trap_name) for trap_name in bad_letters]
+
         for i in range(0, item_difference):
-            pool.append(self.create_item("Nothing"))
+            pool.append(self.create_item(self.get_filler_item_name()))
 
         self.multiworld.itempool += pool
 
     def create_item(self, name: str) -> Item:
-        return Lingo2Item(name, ItemClassification.filler if name == "Nothing" else ItemClassification.progression,
+        return 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)
+
+    def set_rules(self):
+        self.multiworld.completion_condition[self.player] = lambda state: state.has("Victory", self.player)
+
+    def fill_slot_data(self):
+        slot_options = [
+            "cyan_door_behavior",
+            "daedalus_roof_access",
+            "keyholder_sanity",
+            "shuffle_control_center_colors",
+            "shuffle_doors",
+            "shuffle_gallery_paintings",
+            "shuffle_letters",
+            "shuffle_symbols",
+            "shuffle_worldports",
+            "strict_cyan_ending",
+            "strict_purple_ending",
+            "victory_condition",
+        ]
+
+        slot_data: dict[str, object] = {
+            **self.options.as_dict(*slot_options),
+            "version": self.static_logic.get_data_version(),
+        }
+
+        if self.options.shuffle_worldports:
+            slot_data["port_pairings"] = self.port_pairings
+
+        return slot_data
+
+    def get_filler_item_name(self) -> str:
+        return "A Job Well Done"
+
+    # for the universal tracker, doesn't get called in standard gen
+    # docs: https://github.com/FarisTheAncient/Archipelago/blob/tracker/worlds/tracker/docs/re-gen-passthrough.md
+    @staticmethod
+    def interpret_slot_data(slot_data: dict[str, object]) -> dict[str, object]:
+        # returning slot_data so it regens, giving it back in multiworld.re_gen_passthrough
+        # we are using re_gen_passthrough over modifying the world here due to complexities with ER
+        return slot_data
+
+
+def launch_client(*args):
+    from .context import client_main
+    launch_component(client_main, name="Lingo2Client", args=args)
+
+
+icon_paths["lingo2_ico"] = f"ap:{__name__}/logo.png"
+component = Component("Lingo 2 Client", component_type=Type.CLIENT, func=launch_client,
+                      description="Open Lingo 2.", supports_uri=True, game_name="Lingo 2", icon="lingo2_ico")
+components.append(component)
@@ -0,0 +1,38 @@
+extends "res://scripts/nodes/listeners/animationListener.gd"
+
+var item_id
+var item_amount
+
+
+func _ready():
+        var node_path = String(
+                get_tree().get_root().get_node("scene").get_path_to(self).get_concatenated_names()
+        )
+
+        var gamedata = global.get_node("Gamedata")
+        var door_id = gamedata.get_door_for_map_node_path(global.map, node_path)
+        if door_id != null:
+                var ap = global.get_node("Archipelago")
+                var item_lock = ap.get_item_id_for_door(door_id)
+
+                if item_lock != null:
+                        item_id = item_lock[0]
+                        item_amount = item_lock[1]
+
+                        self.senders = []
+                        self.senderGroup = []
+                        self.nested = false
+                        self.complete_at = 0
+                        self.max_length = 0
+                        self.excludeSenders = []
+
+                        call_deferred("_readier")
+
+        super._ready()
+
+
+func _readier():
+        var ap = global.get_node("Archipelago")
+
+        if ap.client.getItemAmount(item_id) >= item_amount:
+                handleTriggered()
@@ -0,0 +1,44 @@
+extends Node
+
+var apworld_reader
+
+
+func _init(path):
+        apworld_reader = ZIPReader.new()
+        apworld_reader.open(path)
+
+
+func _get_true_path(path):
+        if path.begins_with("../"):
+                return "lingo2/%s" % path.substr(3)
+        else:
+                return "lingo2/client/%s" % path
+
+
+func load_script(path):
+        var true_path = _get_true_path(path)
+
+        var script = GDScript.new()
+        script.source_code = apworld_reader.read_file(true_path).get_string_from_utf8()
+        script.reload()
+
+        return script
+
+
+func read_path(path):
+        var true_path = _get_true_path(path)
+        return apworld_reader.read_file(true_path)
+
+
+func load_script_as_scene(path, scene_name):
+        var script = load_script(path)
+        var instance = script.new()
+        instance.name = scene_name
+
+        get_tree().unload_current_scene()
+        _load_scene.call_deferred(instance)
+
+
+func _load_scene(instance):
+        get_tree().get_root().add_child(instance)
+        get_tree().current_scene = instance
@@ -0,0 +1,265 @@
+extends Node
+
+const ap_version = {"major": 0, "minor": 6, "build": 3, "class": "Version"}
+
+var SCRIPT_websocketserver
+
+var _server
+var _should_process = false
+
+var _remote_version = {"major": 0, "minor": 0, "build": 0}
+var _gen_version = {"major": 0, "minor": 0, "build": 0}
+
+var ap_server = ""
+var ap_user = ""
+var ap_pass = ""
+
+var _seed = ""
+var _team = 0
+var _slot = 0
+var _checked_locations = []
+var _checked_worldports = []
+var _received_indexes = []
+var _received_items = {}
+var _slot_data = {}
+var _accessible_locations = []
+var _accessible_worldports = []
+var _goal_accessible = false
+
+signal could_not_connect
+signal connect_status
+signal client_connected(slot_data)
+signal item_received(item, amount)
+signal location_scout_received(location_id, item_name, player_name, flags, for_self)
+signal text_message_received(message)
+signal item_sent_notification(message)
+signal hint_received(message)
+signal accessible_locations_updated
+signal checked_locations_updated
+signal checked_worldports_updated
+signal keyboard_update_received
+
+
+func _init():
+        set_process_mode(Node.PROCESS_MODE_ALWAYS)
+
+        global._print("Instantiated APClient")
+
+
+func _ready():
+        _server = SCRIPT_websocketserver.new()
+        _server.client_connected.connect(_on_web_socket_server_client_connected)
+        _server.client_disconnected.connect(_on_web_socket_server_client_disconnected)
+        _server.message_received.connect(_on_web_socket_server_message_received)
+        add_child(_server)
+        _server.listen(43182)
+
+
+func _reset_state():
+        _should_process = false
+        _received_items = {}
+        _received_indexes = []
+        _checked_worldports = []
+        _accessible_locations = []
+        _accessible_worldports = []
+        _goal_accessible = false
+
+
+func disconnect_from_ap():
+        sendMessage([{"cmd": "Disconnect"}])
+
+
+func _on_web_socket_server_client_connected(peer_id: int) -> void:
+        var peer: WebSocketPeer = _server.peers[peer_id]
+        print("Remote client connected: %d. Protocol: %s" % [peer_id, peer.get_selected_protocol()])
+        _server.send(-peer_id, "[%d] connected" % peer_id)
+
+
+func _on_web_socket_server_client_disconnected(peer_id: int) -> void:
+        var peer: WebSocketPeer = _server.peers[peer_id]
+        print(
+                (
+                        "Remote client disconnected: %d. Code: %d, Reason: %s"
+                        % [peer_id, peer.get_close_code(), peer.get_close_reason()]
+                )
+        )
+        _server.send(-peer_id, "[%d] disconnected" % peer_id)
+
+
+func _on_web_socket_server_message_received(_peer_id: int, packet: String) -> void:
+        global._print("Got data from server: " + packet)
+        var json = JSON.new()
+        var jserror = json.parse(packet)
+        if jserror != OK:
+                global._print("Error parsing packet from AP: " + jserror.error_string)
+                return
+
+        for message in json.data:
+                var cmd = message["cmd"]
+                global._print("Received command: " + cmd)
+
+                if cmd == "Connected":
+                        _seed = message["seed_name"]
+                        _remote_version = message["version"]
+                        _gen_version = message["generator_version"]
+                        _team = message["team"]
+                        _slot = message["slot"]
+                        _slot_data = message["slot_data"]
+
+                        _checked_locations = []
+                        for location in message["checked_locations"]:
+                                _checked_locations.append(int(message["checked_locations"]))
+
+                        client_connected.emit(_slot_data)
+
+                elif cmd == "ConnectionRefused":
+                        could_not_connect.emit(message["text"])
+                        global._print("Connection to AP refused")
+
+                elif cmd == "UpdateLocations":
+                        for location in message["locations"]:
+                                var lint = int(location)
+                                if not _checked_locations.has(lint):
+                                        _checked_locations.append(lint)
+
+                        checked_locations_updated.emit()
+
+                elif cmd == "UpdateWorldports":
+                        for port_id in message["worldports"]:
+                                var lint = int(port_id)
+                                if not _checked_worldports.has(lint):
+                                        _checked_worldports.append(lint)
+
+                        checked_worldports_updated.emit()
+
+                elif cmd == "ItemReceived":
+                        for item in message["items"]:
+                                var index = int(item["index"])
+                                if _received_indexes.has(index):
+                                        # Do not re-process items.
+                                        continue
+
+                                _received_indexes.append(index)
+
+                                var item_id = int(item["id"])
+                                _received_items[item_id] = _received_items.get(item_id, 0) + 1
+
+                                item_received.emit(item, _received_items[item_id])
+
+                elif cmd == "TextMessage":
+                        text_message_received.emit(message["data"])
+
+                elif cmd == "ItemSentNotif":
+                        item_sent_notification.emit(message)
+
+                elif cmd == "HintReceived":
+                        hint_received.emit(message)
+
+                elif cmd == "LocationInfo":
+                        for loc in message["locations"]:
+                                location_scout_received.emit(
+                                        int(loc["id"]),
+                                        loc["item"],
+                                        loc["player"],
+                                        int(loc["flags"]),
+                                        int(loc["for_self"])
+                                )
+
+                elif cmd == "AccessibleLocations":
+                        _accessible_locations.clear()
+                        _accessible_worldports.clear()
+
+                        for loc in message["locations"]:
+                                _accessible_locations.append(int(loc))
+
+                        if "worldports" in message:
+                                for port_id in message["worldports"]:
+                                        _accessible_worldports.append(int(port_id))
+
+                        _goal_accessible = bool(message.get("goal", false))
+
+                        accessible_locations_updated.emit()
+
+                elif cmd == "UpdateKeyboard":
+                        var updates = {}
+                        for k in message["updates"]:
+                                updates[k] = int(message["updates"][k])
+
+                        keyboard_update_received.emit(updates)
+
+
+func connectToServer(server, un, pw):
+        sendMessage([{"cmd": "Connect", "server": server, "player": un, "password": pw}])
+
+        ap_server = server
+        ap_user = un
+        ap_pass = pw
+
+        _should_process = true
+
+        connect_status.emit("Connecting...")
+
+
+func sendMessage(msg):
+        var payload = JSON.stringify(msg)
+        _server.send(0, payload)
+
+
+func connectToRoom():
+        connect_status.emit("Authenticating...")
+
+        sendMessage(
+                [
+                        {
+                                "cmd": "Connect",
+                                "password": ap_pass,
+                                "game": "Lingo 2",
+                                "name": ap_user,
+                        }
+                ]
+        )
+
+
+func requestSync():
+        sendMessage([{"cmd": "Sync"}])
+
+
+func sendLocation(loc_id):
+        sendMessage([{"cmd": "LocationChecks", "locations": [loc_id]}])
+
+
+func sendLocations(loc_ids):
+        sendMessage([{"cmd": "LocationChecks", "locations": loc_ids}])
+
+
+func say(textdata):
+        sendMessage([{"cmd": "Say", "text": textdata}])
+
+
+func completedGoal():
+        sendMessage([{"cmd": "StatusUpdate", "status": 30}])  # CLIENT_GOAL
+
+
+func scoutLocations(loc_ids):
+        sendMessage([{"cmd": "LocationScouts", "locations": loc_ids}])
+
+
+func updateKeyboard(updates):
+        sendMessage([{"cmd": "UpdateKeyboard", "keyboard": updates}])
+
+
+func checkWorldport(port_id):
+        if not _checked_worldports.has(port_id):
+                sendMessage([{"cmd": "CheckWorldport", "port_id": port_id}])
+
+
+func sendQuit():
+        sendMessage([{"cmd": "Quit"}])
+
+
+func hasItem(item_id):
+        return _received_items.has(item_id)
+
+
+func getItemAmount(item_id):
+        return _received_items.get(item_id, 0)
@@ -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")
@@ -0,0 +1,66 @@
+extends Node2D
+
+const RADIUS = 48
+
+var _font
+
+
+func _ready():
+        _font = load("res://assets/fonts/Lingo2.ttf")
+
+
+func _draw():
+        draw_circle(Vector2.ZERO, RADIUS, Color(1.0, 1.0, 1.0, 0.8), true)
+        draw_circle(Vector2.ZERO, RADIUS, Color.BLACK, false)
+        draw_string(
+                _font,
+                Vector2(-4, -RADIUS * 3.0 / 4.0),
+                "N",
+                HorizontalAlignment.HORIZONTAL_ALIGNMENT_LEFT,
+                -1,
+                16,
+                Color.BLACK
+        )
+        draw_set_transform(Vector2.ZERO, PI / 2)
+        draw_string(
+                _font,
+                Vector2(-4, -RADIUS * 3.0 / 4.0),
+                "E",
+                HorizontalAlignment.HORIZONTAL_ALIGNMENT_LEFT,
+                -1,
+                16,
+                Color.BLACK
+        )
+        draw_set_transform(Vector2.ZERO, PI)
+        draw_string(
+                _font,
+                Vector2(-4, -RADIUS * 3.0 / 4.0),
+                "S",
+                HorizontalAlignment.HORIZONTAL_ALIGNMENT_LEFT,
+                -1,
+                16,
+                Color.BLACK
+        )
+        draw_set_transform(Vector2.ZERO, PI * 3.0 / 2.0)
+        draw_string(
+                _font,
+                Vector2(-4, -RADIUS * 3.0 / 4.0),
+                "W",
+                HorizontalAlignment.HORIZONTAL_ALIGNMENT_LEFT,
+                -1,
+                16,
+                Color.BLACK
+        )
+        draw_set_transform(Vector2.ZERO)
+        draw_colored_polygon(
+                PackedVector2Array(
+                        [Vector2(0, -RADIUS * 5.0 / 8.0), Vector2(-RADIUS / 6.0, 0), Vector2(RADIUS / 6.0, 0)]
+                ),
+                Color.RED
+        )
+        draw_colored_polygon(
+                PackedVector2Array(
+                        [Vector2(0, RADIUS * 5.0 / 8.0), Vector2(-RADIUS / 6.0, 0), Vector2(RADIUS / 6.0, 0)]
+                ),
+                Color.GRAY
+        )
@@ -0,0 +1,17 @@
+extends CanvasLayer
+
+var SCRIPT_compass
+
+var compass
+
+
+func _ready():
+        compass = SCRIPT_compass.new()
+        compass.position = Vector2(1840, 80)
+        add_child(compass)
+
+        visible = false
+
+
+func update_rotation(ry):
+        compass.rotation = ry
@@ -0,0 +1,46 @@
+extends "res://scripts/nodes/door.gd"
+
+var item_id
+var item_amount
+
+
+func _ready():
+        var node_path = String(
+                get_tree().get_root().get_node("scene").get_path_to(self).get_concatenated_names()
+        )
+
+        var gamedata = global.get_node("Gamedata")
+        var door_id = gamedata.get_door_for_map_node_path(global.map, node_path)
+        if door_id != null:
+                var ap = global.get_node("Archipelago")
+                var item_lock = ap.get_item_id_for_door(door_id)
+
+                if item_lock != null:
+                        item_id = item_lock[0]
+                        item_amount = item_lock[1]
+
+                        self.senders = []
+                        self.senderGroup = []
+                        self.nested = false
+                        self.complete_at = 0
+                        self.max_length = 0
+                        self.excludeSenders = []
+
+                        call_deferred("_readier")
+
+        if global.map == "the_sun_temple":
+                if name == "spe_EndPlatform" or name == "spe_entry_2":
+                        senders = [NodePath("/root/scene/Panels/EndCheck_dog")]
+
+        if global.map == "the_parthenon":
+                if name == "spe_entry_1":
+                        senders = [NodePath("/root/scene/Panels/EndCheck_dog")]
+
+        super._ready()
+
+
+func _readier():
+        var ap = global.get_node("Archipelago")
+
+        if ap.client.getItemAmount(item_id) >= item_amount:
+                handleTriggered()
@@ -0,0 +1,32 @@
+extends CanvasLayer
+
+var _label
+
+var _disconnected = false
+
+
+func _ready():
+        _label = Label.new()
+        _label.name = "Label"
+        _label.offset_left = 20
+        _label.offset_top = 20
+        _label.horizontal_alignment = HORIZONTAL_ALIGNMENT_LEFT
+        _label.vertical_alignment = VERTICAL_ALIGNMENT_TOP
+        _label.theme = preload("res://assets/themes/baseUI.tres")
+        _label.add_theme_font_size_override("font_size", 36)
+        add_child(_label)
+
+
+func set_connection_lost(arg):
+        _disconnected = arg
+
+        _update_label()
+
+
+func _update_label():
+        var text = []
+
+        if _disconnected:
+                text.append("Disconnected from multiworld.")
+
+        _label.text = "\n".join(text)
@@ -0,0 +1,286 @@
+extends Node
+
+var SCRIPT_proto
+
+var objects
+var door_id_by_map_node_path = {}
+var painting_id_by_map_node_path = {}
+var panel_id_by_map_node_path = {}
+var port_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 = {}
+var symbol_item_ids = []
+var anti_trap_ids = {}
+var location_name_by_id = {}
+var ending_display_name_by_name = {}
+
+var kSYMBOL_ITEMS
+
+
+func _init(proto_script):
+        SCRIPT_proto = proto_script
+
+        kSYMBOL_ITEMS = {
+                SCRIPT_proto.PuzzleSymbol.SUN: "Sun Symbol",
+                SCRIPT_proto.PuzzleSymbol.SPARKLES: "Sparkles Symbol",
+                SCRIPT_proto.PuzzleSymbol.ZERO: "Zero Symbol",
+                SCRIPT_proto.PuzzleSymbol.EXAMPLE: "Example Symbol",
+                SCRIPT_proto.PuzzleSymbol.BOXES: "Boxes Symbol",
+                SCRIPT_proto.PuzzleSymbol.PLANET: "Planet Symbol",
+                SCRIPT_proto.PuzzleSymbol.PYRAMID: "Pyramid Symbol",
+                SCRIPT_proto.PuzzleSymbol.CROSS: "Cross Symbol",
+                SCRIPT_proto.PuzzleSymbol.SWEET: "Sweet Symbol",
+                SCRIPT_proto.PuzzleSymbol.GENDER: "Gender Symbol",
+                SCRIPT_proto.PuzzleSymbol.AGE: "Age Symbol",
+                SCRIPT_proto.PuzzleSymbol.SOUND: "Sound Symbol",
+                SCRIPT_proto.PuzzleSymbol.ANAGRAM: "Anagram Symbol",
+                SCRIPT_proto.PuzzleSymbol.JOB: "Job Symbol",
+                SCRIPT_proto.PuzzleSymbol.STARS: "Stars Symbol",
+                SCRIPT_proto.PuzzleSymbol.NULL: "Null Symbol",
+                SCRIPT_proto.PuzzleSymbol.EVAL: "Eval Symbol",
+                SCRIPT_proto.PuzzleSymbol.LINGO: "Lingo Symbol",
+                SCRIPT_proto.PuzzleSymbol.QUESTION: "Question Symbol",
+        }
+
+
+func load(data_bytes):
+        objects = SCRIPT_proto.AllObjects.new()
+
+        var result_code = objects.from_bytes(data_bytes)
+        if result_code != SCRIPT_proto.PB_ERR.NO_ERRORS:
+                print("Could not load generated data: %d" % result_code)
+                return
+
+        for map in objects.get_maps():
+                map_id_by_name[map.get_name()] = map.get_id()
+
+        for door in objects.get_doors():
+                var map = objects.get_maps()[door.get_map_id()]
+
+                if not map.get_name() in door_id_by_map_node_path:
+                        door_id_by_map_node_path[map.get_name()] = {}
+
+                var map_data = door_id_by_map_node_path[map.get_name()]
+                for receiver in door.get_receivers():
+                        map_data[receiver] = door.get_id()
+
+                for painting_id in door.get_move_paintings():
+                        var painting = objects.get_paintings()[painting_id]
+                        map_data[painting.get_path()] = door.get_id()
+
+                if door.has_ap_id():
+                        door_id_by_ap_id[door.get_ap_id()] = door.get_id()
+                        location_name_by_id[door.get_ap_id()] = _get_door_location_name(door)
+
+        for painting in objects.get_paintings():
+                var room = objects.get_rooms()[painting.get_room_id()]
+                var map = objects.get_maps()[room.get_map_id()]
+
+                if not map.get_name() in painting_id_by_map_node_path:
+                        painting_id_by_map_node_path[map.get_name()] = {}
+
+                var _map_data = painting_id_by_map_node_path[map.get_name()]
+
+        for port in objects.get_ports():
+                var room = objects.get_rooms()[port.get_room_id()]
+                var map = objects.get_maps()[room.get_map_id()]
+
+                if not map.get_name() in port_id_by_map_node_path:
+                        port_id_by_map_node_path[map.get_name()] = {}
+
+                var map_data = port_id_by_map_node_path[map.get_name()]
+                map_data[port.get_path()] = port.get_id()
+
+        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()
+                location_name_by_id[letter.get_ap_id()] = _get_letter_location_name(letter)
+
+        for mastery in objects.get_masteries():
+                location_name_by_id[mastery.get_ap_id()] = _get_mastery_location_name(mastery)
+
+        for ending in objects.get_endings():
+                var location_name = _get_ending_location_name(ending)
+                location_name_by_id[ending.get_ap_id()] = location_name
+                ending_display_name_by_name[ending.get_name()] = location_name
+
+        for keyholder in objects.get_keyholders():
+                if keyholder.has_key():
+                        location_name_by_id[keyholder.get_ap_id()] = _get_keyholder_location_name(keyholder)
+
+        for panel in objects.get_panels():
+                var room = objects.get_rooms()[panel.get_room_id()]
+                var map = objects.get_maps()[room.get_map_id()]
+
+                if not map.get_name() in panel_id_by_map_node_path:
+                        panel_id_by_map_node_path[map.get_name()] = {}
+
+                var map_data = panel_id_by_map_node_path[map.get_name()]
+                map_data[panel.get_path()] = panel.get_id()
+
+        for symbol_name in kSYMBOL_ITEMS.values():
+                symbol_item_ids.append(objects.get_special_ids()[symbol_name])
+
+        for special_name in objects.get_special_ids().keys():
+                if special_name.begins_with("Anti "):
+                        anti_trap_ids[objects.get_special_ids()[special_name]] = (
+                                special_name.substr(5).to_lower()
+                        )
+
+
+func get_door_for_map_node_path(map_name, node_path):
+        if not door_id_by_map_node_path.has(map_name):
+                return null
+
+        var map_data = door_id_by_map_node_path[map_name]
+        return map_data.get(node_path, null)
+
+
+func get_panel_for_map_node_path(map_name, node_path):
+        if not panel_id_by_map_node_path.has(map_name):
+                return null
+
+        var map_data = panel_id_by_map_node_path[map_name]
+        return map_data.get(node_path, null)
+
+
+func get_port_for_map_node_path(map_name, node_path):
+        if not port_id_by_map_node_path.has(map_name):
+                return null
+
+        var map_data = port_id_by_map_node_path[map_name]
+        return map_data.get(node_path, null)
+
+
+func get_door_ap_id(door_id):
+        var door = objects.get_doors()[door_id]
+        if door.has_ap_id():
+                return door.get_ap_id()
+        else:
+                return null
+
+
+func get_door_map_name(door_id):
+        var door = objects.get_doors()[door_id]
+        var room = objects.get_rooms()[door.get_room_id()]
+        var map = objects.get_maps()[room.get_map_id()]
+        return map.get_name()
+
+
+func get_door_receivers(door_id):
+        var door = objects.get_doors()[door_id]
+        return door.get_receivers()
+
+
+func get_worldport_display_name(port_id):
+        var port = objects.get_ports()[port_id]
+        return "%s - %s" % [_get_room_object_map_name(port), port.get_display_name()]
+
+
+func _get_map_object_map_name(obj):
+        return objects.get_maps()[obj.get_map_id()].get_display_name()
+
+
+func _get_room_object_map_name(obj):
+        return _get_map_object_map_name(objects.get_rooms()[obj.get_room_id()])
+
+
+func _get_room_object_location_prefix(obj):
+        var room = objects.get_rooms()[obj.get_room_id()]
+        var game_map = objects.get_maps()[room.get_map_id()]
+
+        if room.has_panel_display_name():
+                return "%s (%s)" % [game_map.get_display_name(), room.get_panel_display_name()]
+        else:
+                return game_map.get_display_name()
+
+
+func _get_door_location_name(door):
+        var map_part = _get_room_object_location_prefix(door)
+
+        if door.has_location_name():
+                return "%s - %s" % [map_part, door.get_location_name()]
+
+        var generated_location_name = _get_generated_door_location_name(door)
+        if generated_location_name != null:
+                return generated_location_name
+
+        return "%s - %s" % [map_part, door.get_name()]
+
+
+func _get_generated_door_location_name(door):
+        if door.get_type() != SCRIPT_proto.DoorType.STANDARD:
+                return null
+
+        if door.get_keyholders().size() > 0 or door.get_endings().size() > 0 or door.has_complete_at():
+                return null
+
+        if door.get_panels().size() > 4:
+                return null
+
+        var map_areas = []
+        for panel_id in door.get_panels():
+                var panel = objects.get_panels()[panel_id.get_panel()]
+                var panel_room = objects.get_rooms()[panel.get_room_id()]
+                # It's okay if panel_display_name is not present because then it's coalesced with other unnamed areas.
+                if not map_areas.has(panel_room.get_panel_display_name()):
+                        map_areas.append(panel_room.get_panel_display_name())
+
+        if map_areas.size() > 1:
+                return null
+
+        var game_map = objects.get_maps()[door.get_map_id()]
+        var map_area = map_areas[0]
+        var map_part
+        if map_area == "":
+                map_part = game_map.get_display_name()
+        else:
+                map_part = "%s (%s)" % [game_map.get_display_name(), map_area]
+
+        var panel_names = []
+        for panel_id in door.get_panels():
+                var panel_data = objects.get_panels()[panel_id.get_panel()]
+                var panel_name
+                if panel_data.has_display_name():
+                        panel_name = panel_data.get_display_name()
+                else:
+                        panel_name = panel_data.get_name()
+
+                var location_part
+                if panel_id.has_answer():
+                        location_part = "%s/%s" % [panel_name, panel_id.get_answer().to_upper()]
+                else:
+                        location_part = panel_name
+
+                panel_names.append(location_part)
+
+        panel_names.sort()
+
+        return map_part + " - " + ", ".join(panel_names)
+
+
+func _get_letter_location_name(letter):
+        var letter_level = 2 if letter.get_level2() else 1
+        var letter_name = "%s%d" % [letter.get_key().to_upper(), letter_level]
+        return "%s - %s" % [_get_room_object_map_name(letter), letter_name]
+
+
+func _get_mastery_location_name(mastery):
+        return "%s - Mastery" % _get_room_object_map_name(mastery)
+
+
+func _get_ending_location_name(ending):
+        return (
+                "%s - %s Ending" % [_get_room_object_map_name(ending), ending.get_name().to_pascal_case()]
+        )
+
+
+func _get_keyholder_location_name(keyholder):
+        return (
+                "%s - %s Keyholder"
+                % [_get_room_object_location_prefix(keyholder), keyholder.get_key().to_upper()]
+        )
@@ -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,231 @@
+extends Node
+
+const kALL_LETTERS = "abcdefghjiklmnopqrstuvwxyz"
+
+var letters_saved = {}
+var letters_in_keyholders = []
+var letters_blocked = []
+var letters_dynamic = {}
+var keyholder_state = {}
+
+var filename = ""
+
+
+func _init():
+        reset()
+
+
+func reset():
+        letters_saved.clear()
+        letters_in_keyholders.clear()
+        letters_blocked.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]
+
+        if not letters_saved.is_empty():
+                ap.client.updateKeyboard(letters_saved)
+
+        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()
+
+        var has_doubles = false
+
+        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
+                        has_doubles = true
+
+                if letters_blocked.has(k):
+                        level = 0
+
+                unlocks.unlockKey(k, level)
+
+        if has_doubles and unlocks.data["double_letters"] != "unlocked":
+                var ap = global.get_node("Archipelago")
+                if ap.cyan_door_behavior == ap.kCYAN_DOOR_BEHAVIOR_DOUBLE_LETTER:
+                        unlocks.setData("double_letters", "unlocked")
+
+
+func collect_local_letter(key, level):
+        var ap = global.get_node("Archipelago")
+        var true_level = 0
+
+        if ap.get_letter_behavior(key, false) == ap.kLETTER_BEHAVIOR_VANILLA:
+                true_level += 1
+        if level == 2 and ap.get_letter_behavior(key, true) == ap.kLETTER_BEHAVIOR_VANILLA:
+                true_level += 1
+
+        if true_level < letters_saved.get(key, 0):
+                return
+
+        letters_saved[key] = true_level
+
+        ap.client.updateKeyboard({key: true_level})
+
+        if letters_blocked.has(key):
+                letters_blocked.erase(key)
+
+        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
+
+        if letters_blocked.has(key):
+                letters_blocked.erase(key)
+
+        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 block_letter(key):
+        if not letters_blocked.has(key):
+                letters_blocked.append(key)
+
+        update_unlocks()
+
+
+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() and letters_blocked.is_empty():
+                return false
+
+        var cleared_anything = not letters_in_keyholders.is_empty() or not letters_blocked.is_empty()
+
+        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()
+        letters_blocked.clear()
+
+        update_unlocks()
+        save()
+
+        return cleared_anything
+
+
+func remote_keyboard_updated(updates):
+        var reverse = {}
+        var should_update = false
+
+        for k in updates:
+                if not letters_saved.has(k) or updates[k] > letters_saved[k]:
+                        letters_saved[k] = updates[k]
+                        should_update = true
+                elif updates[k] < letters_saved[k]:
+                        reverse[k] = letters_saved[k]
+
+        if should_update:
+                update_unlocks()
+
+        if not reverse.is_empty():
+                var ap = global.get_node("Archipelago")
+                ap.client.updateKeyboard(reverse)
@@ -0,0 +1,20 @@
+extends Receiver
+
+var location_id
+
+
+func _ready():
+        super._ready()
+
+
+func handleTriggered():
+        triggered += 1
+        if triggered >= total:
+                var ap = global.get_node("Archipelago")
+                ap.send_location(location_id)
+
+
+func handleUntriggered():
+        triggered -= 1
+        if triggered < total:
+                pass
@@ -0,0 +1,296 @@
+extends Node
+
+
+func _ready():
+        var runtime = global.get_node("Runtime")
+
+        # Some helpful logging.
+        if Steam.isSubscribed():
+                global._print("Provisioning successful! Build ID: %d" % Steam.getAppBuildId())
+        else:
+                global._print("Provisioning failed.")
+
+        # Undo the load screen removing our cursor
+        get_tree().get_root().set_disable_input(false)
+        Input.set_mouse_mode(Input.MOUSE_MODE_VISIBLE)
+
+        # Increase the WebSocket input buffer size so that we can download large
+        # data packages.
+        ProjectSettings.set_setting("network/limits/websocket_client/max_in_buffer_kb", 8192)
+
+        switcher.layer = 4
+
+        # Create the global AP manager, if it doesn't already exist.
+        if not global.has_node("Archipelago"):
+                var ap_script = runtime.load_script("manager.gd")
+                var ap_instance = ap_script.new()
+                ap_instance.name = "Archipelago"
+
+                ap_instance.SCRIPT_client = runtime.load_script("client.gd")
+                ap_instance.SCRIPT_keyboard = runtime.load_script("keyboard.gd")
+                ap_instance.SCRIPT_locationListener = runtime.load_script("locationListener.gd")
+                ap_instance.SCRIPT_minimap = runtime.load_script("minimap.gd")
+                ap_instance.SCRIPT_victoryListener = runtime.load_script("victoryListener.gd")
+                ap_instance.SCRIPT_websocketserver = runtime.load_script("vendor/WebSocketServer.gd")
+
+                global.add_child(ap_instance)
+
+                # Let's also inject any scripts we need to inject now.
+                installScriptExtension(runtime.load_script("animationListener.gd"))
+                installScriptExtension(runtime.load_script("collectable.gd"))
+                installScriptExtension(runtime.load_script("door.gd"))
+                installScriptExtension(runtime.load_script("keyHolder.gd"))
+                installScriptExtension(runtime.load_script("keyHolderChecker.gd"))
+                installScriptExtension(runtime.load_script("keyHolderResetterListener.gd"))
+                installScriptExtension(runtime.load_script("painting.gd"))
+                installScriptExtension(runtime.load_script("panel.gd"))
+                installScriptExtension(runtime.load_script("pauseMenu.gd"))
+                installScriptExtension(runtime.load_script("player.gd"))
+                installScriptExtension(runtime.load_script("saver.gd"))
+                installScriptExtension(runtime.load_script("teleport.gd"))
+                installScriptExtension(runtime.load_script("teleportListener.gd"))
+                installScriptExtension(runtime.load_script("visibilityListener.gd"))
+                installScriptExtension(runtime.load_script("worldport.gd"))
+                installScriptExtension(runtime.load_script("worldportListener.gd"))
+
+                var proto_script = runtime.load_script("../generated/proto.gd")
+                var gamedata_script = runtime.load_script("gamedata.gd")
+                var gamedata_instance = gamedata_script.new(proto_script)
+                gamedata_instance.load(runtime.read_path("../generated/data.binpb"))
+                gamedata_instance.name = "Gamedata"
+                global.add_child(gamedata_instance)
+
+                var messages_script = runtime.load_script("messages.gd")
+                var messages_instance = messages_script.new()
+                messages_instance.name = "Messages"
+                messages_instance.SCRIPT_rainbowText = runtime.load_script("rainbowText.gd")
+                global.add_child(messages_instance)
+
+                var effects_script = runtime.load_script("effects.gd")
+                var effects_instance = effects_script.new()
+                effects_instance.name = "Effects"
+                global.add_child(effects_instance)
+
+                var textclient_script = runtime.load_script("textclient.gd")
+                var textclient_instance = textclient_script.new()
+                textclient_instance.name = "Textclient"
+                global.add_child(textclient_instance)
+
+                var compass_overlay_script = runtime.load_script("compass_overlay.gd")
+                var compass_overlay_instance = compass_overlay_script.new()
+                compass_overlay_instance.name = "Compass"
+                compass_overlay_instance.SCRIPT_compass = runtime.load_script("compass.gd")
+                global.add_child(compass_overlay_instance)
+
+        var ap = global.get_node("Archipelago")
+        var gamedata = global.get_node("Gamedata")
+        ap.ap_connected.connect(connectionSuccessful)
+        ap.could_not_connect.connect(connectionUnsuccessful)
+        ap.connect_status.connect(connectionStatus)
+
+        # Populate textboxes with AP settings.
+        get_node("../Panel/server_box").text = ap.ap_server
+        get_node("../Panel/player_box").text = ap.ap_user
+        get_node("../Panel/password_box").text = ap.ap_pass
+
+        var history_box = get_node("../Panel/connection_history")
+        if ap.connection_history.is_empty():
+                history_box.disabled = true
+        else:
+                history_box.disabled = false
+
+                var i = 0
+                for details in ap.connection_history:
+                        history_box.get_popup().add_item("%s (%s)" % [details[1], details[0]], i)
+                        i += 1
+
+        history_box.get_popup().id_pressed.connect(historySelected)
+
+        # Show client version.
+        var version = gamedata.objects.get_version()
+        get_node("../Panel/title").text = (
+                "ARCHIPELAGO (%d.%d.%d)" % [version.get_major(), version.get_minor(), version.get_patch()]
+        )
+
+        # Increase font size in text boxes.
+        get_node("../Panel/server_box").add_theme_font_size_override("font_size", 36)
+        get_node("../Panel/player_box").add_theme_font_size_override("font_size", 36)
+        get_node("../Panel/password_box").add_theme_font_size_override("font_size", 36)
+
+        # Set up version mismatch dialog.
+        get_node("../Panel/VersionMismatch").confirmed.connect(startGame)
+        get_node("../Panel/VersionMismatch").get_cancel_button().pressed.connect(
+                versionMismatchDeclined
+        )
+
+        # Set up buttons.
+        get_node("../Panel/connect_button").pressed.connect(_connect_pressed)
+        get_node("../Panel/quit_button").pressed.connect(_back_pressed)
+
+
+func _connect_pressed():
+        get_node("../Panel/connect_button").disabled = true
+
+        var ap = global.get_node("Archipelago")
+        ap.ap_server = get_node("../Panel/server_box").text
+        ap.ap_user = get_node("../Panel/player_box").text
+        ap.ap_pass = get_node("../Panel/password_box").text
+        ap.saveSettings()
+
+        ap.connectToServer()
+
+
+func _back_pressed():
+        var ap = global.get_node("Archipelago")
+        ap.disconnect_from_ap()
+        ap.client.sendQuit()
+
+        get_tree().quit()
+
+
+# Adapted from https://gitlab.com/Delta-V-Modding/Mods/-/blob/main/game/ModLoader.gd
+func installScriptExtension(childScript: Resource):
+        # Force Godot to compile the script now.
+        # We need to do this here to ensure that the inheritance chain is
+        # properly set up, and multiple mods can chain-extend the same
+        # class multiple times.
+        # This is also needed to make Godot instantiate the extended class
+        # when creating singletons.
+        # The actual instance is thrown away.
+        childScript.new()
+
+        var parentScript = childScript.get_base_script()
+        var parentScriptPath = parentScript.resource_path
+        global._print("ModLoader: Installing script extension over %s" % parentScriptPath)
+        childScript.take_over_path(parentScriptPath)
+
+
+func connectionStatus(message):
+        var popup = get_node("../Panel/AcceptDialog")
+        popup.title = "Connecting to Archipelago"
+        popup.dialog_text = message
+        popup.exclusive = true
+        popup.get_ok_button().visible = false
+        popup.popup_centered()
+
+
+func connectionSuccessful():
+        var ap = global.get_node("Archipelago")
+        var gamedata = global.get_node("Gamedata")
+
+        # Check for major version mismatch.
+        if ap.apworld_version[0] != gamedata.objects.get_version().get_major():
+                get_node("../Panel/AcceptDialog").exclusive = false
+
+                var popup = get_node("../Panel/VersionMismatch")
+                popup.title = "Version Mismatch!"
+                popup.dialog_text = (
+                        "This slot was generated using v%d.%d.%d of the Lingo 2 apworld,\nwhich has a different major version than this client (v%d.%d.%d).\nIt is highly recommended to play using the correct version of the client.\nYou may experience bugs or logic issues if you continue."
+                        % [
+                                ap.apworld_version[0],
+                                ap.apworld_version[1],
+                                ap.apworld_version[2],
+                                gamedata.objects.get_version().get_major(),
+                                gamedata.objects.get_version().get_minor(),
+                                gamedata.objects.get_version().get_patch()
+                        ]
+                )
+                popup.exclusive = true
+                popup.popup_centered()
+
+                return
+
+        startGame()
+
+
+func startGame():
+        var ap = global.get_node("Archipelago")
+
+        # Save connection details
+        var connection_details = [ap.ap_server, ap.ap_user, ap.ap_pass]
+        if ap.connection_history.has(connection_details):
+                ap.connection_history.erase(connection_details)
+        ap.connection_history.push_front(connection_details)
+        if ap.connection_history.size() > 10:
+                ap.connection_history.resize(10)
+        ap.saveSettings()
+
+        # Switch to the_entry
+        Input.set_mouse_mode(Input.MOUSE_MODE_CAPTURED)
+        global.user = ap.getSaveFileName()
+        global.universe = "lingo"
+        global.map = "the_entry"
+
+        unlocks.resetCollectables()
+        unlocks.resetData()
+
+        ap.setup_keys()
+
+        unlocks.loadCollectables()
+        unlocks.loadData()
+        unlocks.unlockKey("capslock", 1)
+
+        if ap.shuffle_worldports:
+                settings.worldport_fades = "default"
+        else:
+                settings.worldport_fades = "never"
+
+        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/visibilityListener.tscn")
+        clearResourceCache("res://objects/nodes/listeners/worldportListener.tscn")
+        clearResourceCache("res://objects/nodes/panel.tscn")
+        clearResourceCache("res://objects/nodes/player.tscn")
+        clearResourceCache("res://objects/nodes/saver.tscn")
+        clearResourceCache("res://objects/nodes/teleport.tscn")
+        clearResourceCache("res://objects/nodes/worldport.tscn")
+        clearResourceCache("res://objects/scenes/menus/pause_menu.tscn")
+
+        var paintings_dir = DirAccess.open("res://objects/meshes/paintings")
+        if paintings_dir:
+                paintings_dir.list_dir_begin()
+                var file_name = paintings_dir.get_next()
+                while file_name != "":
+                        if not paintings_dir.current_is_dir() and file_name.ends_with(".tscn"):
+                                clearResourceCache("res://objects/meshes/paintings/" + file_name)
+                        file_name = paintings_dir.get_next()
+
+        switcher.switch_map.call_deferred("res://objects/scenes/the_entry.tscn")
+
+
+func connectionUnsuccessful(error_message):
+        get_node("../Panel/connect_button").disabled = false
+
+        var popup = get_node("../Panel/AcceptDialog")
+        popup.title = "Could not connect to Archipelago"
+        popup.dialog_text = error_message
+        popup.exclusive = true
+        popup.get_ok_button().visible = true
+        popup.popup_centered()
+
+
+func versionMismatchDeclined():
+        get_node("../Panel/AcceptDialog").hide()
+        get_node("../Panel/connect_button").disabled = false
+
+        var ap = global.get_node("Archipelago")
+        ap.disconnect_from_ap()
+
+
+func historySelected(index):
+        var ap = global.get_node("Archipelago")
+        var details = ap.connection_history[index]
+
+        get_node("../Panel/server_box").text = details[0]
+        get_node("../Panel/player_box").text = details[1]
+        get_node("../Panel/password_box").text = details[2]
+
+
+func clearResourceCache(path):
+        ResourceLoader.load(path, "", ResourceLoader.CACHE_MODE_REPLACE)
@@ -0,0 +1,603 @@
+extends Node
+
+var SCRIPT_client
+var SCRIPT_keyboard
+var SCRIPT_locationListener
+var SCRIPT_minimap
+var SCRIPT_victoryListener
+var SCRIPT_websocketserver
+
+var ap_server = ""
+var ap_user = ""
+var ap_pass = ""
+var connection_history = []
+var show_compass = false
+var show_locations = false
+var show_minimap = false
+
+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 _inverse_item_locks = {}
+var _held_letters = {}
+var _letters_setup = false
+var _already_connected = 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
+
+const kCYAN_DOOR_BEHAVIOR_H2 = 0
+const kCYAN_DOOR_BEHAVIOR_DOUBLE_LETTER = 1
+const kCYAN_DOOR_BEHAVIOR_ITEM = 2
+
+const kEndingNameByVictoryValue = {
+        0: "GRAY",
+        1: "PURPLE",
+        2: "MINT",
+        3: "BLACK",
+        4: "BLUE",
+        5: "CYAN",
+        6: "RED",
+        7: "PLUM",
+        8: "ORANGE",
+        9: "GOLD",
+        10: "YELLOW",
+        11: "GREEN",
+        12: "WHITE",
+}
+
+var apworld_version = [0, 0, 0]
+var cyan_door_behavior = kCYAN_DOOR_BEHAVIOR_H2
+var daedalus_roof_access = false
+var keyholder_sanity = false
+var port_pairings = {}
+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 strict_cyan_ending = false
+var strict_purple_ending = false
+var victory_condition = -1
+
+signal could_not_connect
+signal connect_status
+signal ap_connected
+
+
+func _init():
+        # Read AP settings from file, if there are any
+        if FileAccess.file_exists("user://ap_settings"):
+                var file = FileAccess.open("user://ap_settings", FileAccess.READ)
+                var data = file.get_var(true)
+                file.close()
+
+                if typeof(data) != TYPE_ARRAY:
+                        global._print("AP settings file is corrupted")
+                        data = []
+
+                if data.size() > 0:
+                        ap_server = data[0]
+
+                if data.size() > 1:
+                        ap_user = data[1]
+
+                if data.size() > 2:
+                        ap_pass = data[2]
+
+                if data.size() > 3:
+                        connection_history = data[3]
+
+                if data.size() > 4:
+                        show_compass = data[4]
+
+                if data.size() > 5:
+                        show_locations = data[5]
+
+                if data.size() > 6:
+                        show_minimap = data[6]
+
+
+func _ready():
+        client = SCRIPT_client.new()
+        client.SCRIPT_websocketserver = SCRIPT_websocketserver
+
+        client.item_received.connect(_process_item)
+        client.location_scout_received.connect(_process_location_scout)
+        client.text_message_received.connect(_process_text_message)
+        client.item_sent_notification.connect(_process_item_sent_notification)
+        client.hint_received.connect(_process_hint_received)
+        client.accessible_locations_updated.connect(_on_accessible_locations_updated)
+        client.checked_locations_updated.connect(_on_checked_locations_updated)
+        client.checked_worldports_updated.connect(_on_checked_worldports_updated)
+
+        client.could_not_connect.connect(_client_could_not_connect)
+        client.connect_status.connect(_client_connect_status)
+        client.client_connected.connect(_client_connected)
+
+        add_child(client)
+
+        keyboard = SCRIPT_keyboard.new()
+        add_child(keyboard)
+        client.keyboard_update_received.connect(keyboard.remote_keyboard_updated)
+
+
+func saveSettings():
+        # Save the AP settings to disk.
+        var path = "user://ap_settings"
+        var file = FileAccess.open(path, FileAccess.WRITE)
+
+        var data = [
+                ap_server,
+                ap_user,
+                ap_pass,
+                connection_history,
+                show_compass,
+                show_locations,
+                show_minimap,
+        ]
+        file.store_var(data, true)
+        file.close()
+
+
+func saveLocaldata():
+        # Save the MW/slot specific settings to disk.
+        var dir = DirAccess.open("user://")
+        var folder = "archipelago_data"
+        if not dir.dir_exists(folder):
+                dir.make_dir(folder)
+
+        var file = FileAccess.open(_localdata_file, FileAccess.WRITE)
+
+        var data = [
+                _last_new_item,
+        ]
+        file.store_var(data, true)
+        file.close()
+
+
+func connectToServer():
+        _last_new_item = -1
+        _batch_locations = false
+        _held_locations = []
+        _held_location_scouts = []
+        _location_scouts = {}
+        _letters_setup = false
+        _held_letters = {}
+        _already_connected = false
+
+        client.connectToServer(ap_server, ap_user, ap_pass)
+
+
+func getSaveFileName():
+        return "zzAP_%s_%d" % [client._seed, client._slot]
+
+
+func disconnect_from_ap():
+        _already_connected = false
+
+        var effects = global.get_node("Effects")
+        effects.set_connection_lost(false)
+
+        client.disconnect_from_ap()
+
+
+func get_item_id_for_door(door_id):
+        return _item_locks.get(door_id, null)
+
+
+func _process_item(item, amount):
+        var gamedata = global.get_node("Gamedata")
+
+        var item_id = int(item["id"])
+        var prog_id = null
+        if _inverse_item_locks.has(item_id):
+                for lock in _inverse_item_locks.get(item_id):
+                        if lock[1] != amount:
+                                continue
+
+                        if gamedata.progressive_id_by_ap_id.has(item_id):
+                                prog_id = lock[0]
+
+                        if gamedata.get_door_map_name(lock[0]) != global.map:
+                                continue
+
+                        # TODO: fix doors opening from door groups
+                        var receivers = gamedata.get_door_receivers(lock[0])
+                        var scene = get_tree().get_root().get_node_or_null("scene")
+                        if scene != null:
+                                for receiver in receivers:
+                                        var rnode = scene.get_node_or_null(receiver)
+                                        if rnode != null:
+                                                rnode.handleTriggered()
+
+        var letter_id = gamedata.letter_id_by_ap_id.get(item_id, 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)
+
+        if gamedata.symbol_item_ids.has(item_id):
+                var player = get_tree().get_root().get_node_or_null("scene/player")
+                if player != null:
+                        player.evaluate_solvability.emit()
+
+        # Show a message about the item if it's new.
+        if int(item["index"]) > _last_new_item:
+                _last_new_item = int(item["index"])
+                saveLocaldata()
+
+                var full_item_name = item["text"]
+                if prog_id != null:
+                        var door = gamedata.objects.get_doors()[prog_id]
+                        full_item_name = "%s (%s)" % [full_item_name, door.get_name()]
+
+                var message
+                if "sender" in item:
+                        message = (
+                                "Received %s from %s"
+                                % [wrapInItemColorTags(full_item_name, item["flags"]), item["sender"]]
+                        )
+                else:
+                        message = "Found %s" % wrapInItemColorTags(full_item_name, item["flags"])
+
+                if gamedata.anti_trap_ids.has(item):
+                        keyboard.block_letter(gamedata.anti_trap_ids[item])
+
+                global._print(message)
+
+                global.get_node("Messages").showMessage(message)
+
+
+func _process_item_sent_notification(message):
+        var sentMsg = (
+                "Sent %s to %s"
+                % [
+                        wrapInItemColorTags(message["item_name"], message["item_flags"]),
+                        message["receiver_name"]
+                ]
+        )
+        #if _hinted_locations.has(message["item"]["location"]):
+        #       sentMsg += " ([color=#fafad2]Hinted![/color])"
+        global.get_node("Messages").showMessage(sentMsg)
+
+
+func _process_hint_received(message):
+        var is_for = ""
+        if message["self"] == 0:
+                is_for = " for %s" % message["receiver_name"]
+
+        global.get_node("Messages").showMessage(
+                (
+                        "Hint: %s%s is on %s"
+                        % [
+                                wrapInItemColorTags(message["item_name"], message["item_flags"]),
+                                is_for,
+                                message["location_name"]
+                        ]
+                )
+        )
+
+
+func _process_text_message(message):
+        var parts = []
+        for message_part in message:
+                if message_part["type"] == "text":
+                        parts.append(message_part["text"])
+                elif message_part["type"] == "player":
+                        if message_part["self"] == 1:
+                                parts.append("[color=#ee00ee]%s[/color]" % message_part["text"])
+                        else:
+                                parts.append("[color=#fafad2]%s[/color]" % message_part["text"])
+                elif message_part["type"] == "item":
+                        parts.append(wrapInItemColorTags(message_part["text"], int(message_part["flags"])))
+                elif message_part["type"] == "location":
+                        parts.append("[color=#00ff7f]%s[/color]" % message_part["text"])
+
+        var textclient_node = global.get_node("Textclient")
+        if textclient_node != null:
+                textclient_node.parse_printjson("".join(parts))
+
+
+func _process_location_scout(location_id, item_name, player_name, flags, for_self):
+        _location_scouts[location_id] = {
+                "item": item_name, "player": player_name, "flags": flags, "for_self": for_self
+        }
+
+        if for_self and flags & 4 != 0:
+                # This is a trap for us, so let's not display it.
+                return
+
+        var gamedata = global.get_node("Gamedata")
+        var map_id = gamedata.map_id_by_name.get(global.map)
+
+        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 _on_accessible_locations_updated():
+        var textclient_node = global.get_node("Textclient")
+        if textclient_node != null:
+                textclient_node.update_locations()
+
+
+func _on_checked_locations_updated():
+        var textclient_node = global.get_node("Textclient")
+        if textclient_node != null:
+                textclient_node.update_locations()
+
+
+func _on_checked_worldports_updated():
+        var textclient_node = global.get_node("Textclient")
+        if textclient_node != null:
+                textclient_node.update_locations()
+                textclient_node.update_worldports()
+
+
+func _client_could_not_connect(message):
+        could_not_connect.emit(message)
+
+        if global.loaded:
+                var effects = global.get_node("Effects")
+                effects.set_connection_lost(true)
+
+                var messages = global.get_node("Messages")
+                messages.showMessage("Connection to multiworld lost.")
+
+
+func _client_connect_status(message):
+        connect_status.emit(message)
+
+
+func _client_connected(slot_data):
+        var effects = global.get_node("Effects")
+        effects.set_connection_lost(false)
+
+        if _already_connected:
+                var messages = global.get_node("Messages")
+                messages.showMessage("Reconnected to multiworld!")
+                return
+
+        _already_connected = true
+
+        var gamedata = global.get_node("Gamedata")
+
+        _localdata_file = "user://archipelago_data/%s_%d" % [client._seed, client._slot]
+        _last_new_item = -1
+
+        if FileAccess.file_exists(_localdata_file):
+                var ap_file = FileAccess.open(_localdata_file, FileAccess.READ)
+                var localdata = []
+                if ap_file != null:
+                        localdata = ap_file.get_var(true)
+                        ap_file.close()
+
+                if typeof(localdata) != TYPE_ARRAY:
+                        print("AP localdata file is corrupted")
+                        localdata = []
+
+                if localdata.size() > 0:
+                        _last_new_item = localdata[0]
+
+        # Read slot data.
+        cyan_door_behavior = int(slot_data.get("cyan_door_behavior", 0))
+        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_gallery_paintings = bool(slot_data.get("shuffle_gallery_paintings", false))
+        shuffle_letters = int(slot_data.get("shuffle_letters", 0))
+        shuffle_symbols = bool(slot_data.get("shuffle_symbols", false))
+        shuffle_worldports = bool(slot_data.get("shuffle_worldports", false))
+        strict_cyan_ending = bool(slot_data.get("strict_cyan_ending", false))
+        strict_purple_ending = bool(slot_data.get("strict_purple_ending", false))
+        victory_condition = int(slot_data.get("victory_condition", 0))
+
+        if slot_data.has("version"):
+                var version_msg = slot_data["version"]
+                apworld_version = [int(version_msg[0]), int(version_msg[1]), 0]
+                if version_msg.size() > 2:
+                        apworld_version[2] = int(version_msg[2])
+
+        port_pairings.clear()
+        if slot_data.has("port_pairings"):
+                var raw_pp = slot_data.get("port_pairings")
+
+                for p1 in raw_pp.keys():
+                        port_pairings[int(p1)] = int(raw_pp[p1])
+
+        # Set up item locks.
+        _item_locks = {}
+
+        if shuffle_doors:
+                for door in gamedata.objects.get_doors():
+                        if (
+                                door.get_type() == gamedata.SCRIPT_proto.DoorType.STANDARD
+                                or door.get_type() == gamedata.SCRIPT_proto.DoorType.ITEM_ONLY
+                        ):
+                                _item_locks[door.get_id()] = [door.get_ap_id(), 1]
+
+                for progressive in gamedata.objects.get_progressives():
+                        for i in range(0, progressive.get_doors().size()):
+                                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:
+                                if shuffle_worldports:
+                                        continue
+                        elif door_group.get_type() != gamedata.SCRIPT_proto.DoorGroupType.SHUFFLE_GROUP:
+                                continue
+
+                        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
+                                and not shuffle_worldports
+                        ):
+                                for door in door_group.get_doors():
+                                        _item_locks[door] = [door_group.get_ap_id(), 1]
+
+        if shuffle_gallery_paintings:
+                for door in gamedata.objects.get_doors():
+                        if door.get_type() == gamedata.SCRIPT_proto.DoorType.GALLERY_PAINTING:
+                                _item_locks[door.get_id()] = [door.get_ap_id(), 1]
+
+        if cyan_door_behavior == kCYAN_DOOR_BEHAVIOR_ITEM:
+                for door_group in gamedata.objects.get_door_groups():
+                        if door_group.get_type() == gamedata.SCRIPT_proto.DoorGroupType.CYAN_DOORS:
+                                for door in door_group.get_doors():
+                                        if not _item_locks.has(door):
+                                                _item_locks[door] = [door_group.get_ap_id(), 1]
+
+        # Create a reverse item locks map for processing items.
+        _inverse_item_locks = {}
+
+        for door_id in _item_locks.keys():
+                var lock = _item_locks.get(door_id)
+
+                if not _inverse_item_locks.has(lock[0]):
+                        _inverse_item_locks[lock[0]] = []
+
+                _inverse_item_locks[lock[0]].append([door_id, lock[1]])
+
+        if shuffle_worldports:
+                var textclient = global.get_node("Textclient")
+                textclient.setup_worldports()
+
+        ap_connected.emit()
+
+
+func start_batching_locations():
+        _batch_locations = true
+
+
+func send_location(loc_id):
+        if _batch_locations:
+                _held_locations.append(loc_id)
+        else:
+                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
+
+        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):
+        var int_flags = int(flags)
+        if int_flags & 1:  # progression
+                if int_flags & 2:  # proguseful
+                        return "#f0d200"
+                else:
+                        return "#bc51e0"
+        elif int_flags & 2:  # useful
+                return "#2b67ff"
+        elif int_flags & 4:  # trap
+                return "#d63a22"
+        else:  # filler
+                return "#14de9e"
+
+
+func wrapInItemColorTags(text, flags):
+        var int_flags = int(flags)
+        if int_flags & 1 and int_flags & 2:  # proguseful
+                return "[rainbow]%s[/rainbow]" % text
+        else:
+                return "[color=%s]%s[/color]" % [colorForItemType(flags), text]
+
+
+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
+
+        if shuffle_letters == kSHUFFLE_LETTERS_ITEM_CYAN:
+                level += 1
+
+        keyboard.collect_remote_letter(key, level)
@@ -0,0 +1,74 @@
+extends CanvasLayer
+
+var SCRIPT_rainbowText
+
+var _message_queue = []
+var _font
+var _container
+var _ordered_labels = []
+
+
+func _ready():
+        _container = VBoxContainer.new()
+        _container.set_name("Container")
+        _container.anchor_bottom = 1
+        _container.offset_left = 20.0
+        _container.offset_right = 1920.0
+        _container.offset_top = 0.0
+        _container.offset_bottom = -20.0
+        _container.alignment = BoxContainer.ALIGNMENT_END
+        _container.mouse_filter = Control.MOUSE_FILTER_IGNORE
+        self.add_child(_container)
+
+        _font = load("res://assets/fonts/Lingo2.ttf")
+
+
+func _add_message(text):
+        var new_label = RichTextLabel.new()
+        new_label.install_effect(SCRIPT_rainbowText.new())
+        new_label.push_font(_font)
+        new_label.push_font_size(36)
+        new_label.push_outline_color(Color(0, 0, 0, 1))
+        new_label.push_outline_size(2)
+        new_label.append_text(text)
+        new_label.fit_content = true
+
+        _container.add_child(new_label)
+        _ordered_labels.push_back(new_label)
+
+
+func showMessage(text):
+        if _ordered_labels.size() >= 9:
+                _message_queue.append(text)
+                return
+
+        _add_message(text)
+
+        if _ordered_labels.size() > 1:
+                return
+
+        var timeout = 10.0
+        while !_ordered_labels.is_empty():
+                await get_tree().create_timer(timeout).timeout
+
+                if !_ordered_labels.is_empty():
+                        var to_remove = _ordered_labels.pop_front()
+                        var to_tween = get_tree().create_tween().bind_node(to_remove)
+                        to_tween.tween_property(to_remove, "modulate:a", 0.0, 0.5)
+                        to_tween.tween_callback(to_remove.queue_free)
+
+                if !_message_queue.is_empty():
+                        var next_msg = _message_queue.pop_front()
+                        _add_message(next_msg)
+
+                if timeout > 4:
+                        timeout -= 3
+
+
+func clear():
+        _message_queue.clear()
+
+        for message_label in _ordered_labels:
+                message_label.queue_free()
+
+        _ordered_labels.clear()
@@ -0,0 +1,175 @@
+extends CanvasLayer
+
+var player
+var drawer
+var sprite
+var label
+
+var cell_left
+var cell_top
+var cell_right
+var cell_bottom
+var cell_width
+var cell_height
+var center_x_min
+var center_x_max
+var center_y_min
+var center_y_max
+
+
+func _ready():
+        player = get_tree().get_root().get_node("scene/player")
+
+        var svc = PanelContainer.new()
+        svc.anchor_left = 1.0
+        svc.anchor_top = 1.0
+        svc.anchor_right = 1.0
+        svc.anchor_bottom = 1.0
+        svc.offset_left = -320.0
+        svc.offset_top = -320.0
+        svc.offset_right = -64.0
+        svc.offset_bottom = -64.0
+        svc.clip_contents = true
+        add_child(svc)
+
+        var background_color = Color.WHITE
+
+        var world_env = get_tree().get_root().get_node("scene/WorldEnvironment")
+        if world_env != null and world_env.environment != null:
+                if world_env.environment.background_mode == Environment.BG_COLOR:
+                        background_color = world_env.environment.background_color
+                elif (
+                        world_env.environment.background_mode == Environment.BG_SKY
+                        and world_env.environment.sky != null
+                        and world_env.environment.sky.sky_material != null
+                ):
+                        var sky = world_env.environment.sky.sky_material
+                        if sky is PhysicalSkyMaterial:
+                                background_color = sky.ground_color
+                        elif sky is ProceduralSkyMaterial:
+                                background_color = sky.sky_top_color
+
+        var stylebox = StyleBoxFlat.new()
+        stylebox.bg_color = Color(background_color, 0.6)
+        svc.add_theme_stylebox_override("panel", stylebox)
+
+        drawer = Node2D.new()
+        svc.add_child(drawer)
+
+        var gridmap = get_tree().get_root().get_node("scene/GridMap")
+        if gridmap == null:
+                visible = false
+                return
+
+        cell_left = 0
+        cell_top = 0
+        cell_right = 0
+        cell_bottom = 0
+
+        for pos in gridmap.get_used_cells():
+                if pos.x < cell_left:
+                        cell_left = pos.x
+                if pos.x > cell_right:
+                        cell_right = pos.x
+                if pos.z < cell_top:
+                        cell_top = pos.z
+                if pos.z > cell_bottom:
+                        cell_bottom = pos.z
+
+        cell_width = cell_right - cell_left + 1
+        cell_height = cell_bottom - cell_top + 1
+
+        var rendered = _renderMap(gridmap)
+
+        var image_texture = ImageTexture.create_from_image(rendered)
+        sprite = Sprite2D.new()
+        sprite.texture = image_texture
+        sprite.texture_filter = CanvasItem.TEXTURE_FILTER_NEAREST
+        sprite.scale = Vector2(2, 2)
+        sprite.centered = false
+        drawer.add_child(sprite)
+
+        label = Label.new()
+        label.theme = preload("res://assets/themes/baseUI.tres")
+        label.add_theme_font_size_override("font_size", 32)
+        label.text = "@"
+        drawer.add_child(label)
+
+        #var local_tl = gridmap.map_to_local(Vector3i(cell_left, 0, cell_top))
+        #var global_tl = gridmap.to_global(local_tl)
+        #var local_br = gridmap.map_to_local(Vector3i(cell_right, 0, cell_bottom))
+        #var global_br = gridmap.to_global(local_br)
+
+        center_x_min = 0
+        center_x_max = cell_width - 128
+        center_y_min = 0
+        center_y_max = cell_height - 128
+
+        if center_x_max < center_x_min:
+                center_x_min = (center_x_min + center_x_max) / 2
+                center_x_max = center_x_min
+
+        if center_y_max < center_y_min:
+                center_y_min = (center_y_min + center_y_max) / 2
+                center_y_max = center_y_min
+
+
+func _process(_delta):
+        if visible == false:
+                return
+
+        drawer.position.x = clamp(player.position.x - cell_left - 64, center_x_min, center_x_max) * -2
+        drawer.position.y = clamp(player.position.z - cell_top - 64, center_y_min, center_y_max) * -2
+
+        label.position.x = (player.position.x - cell_left) * 2 - 16
+        label.position.y = (player.position.z - cell_top) * 2 - 16
+
+
+func _renderMap(gridmap):
+        var heights = {}
+
+        var rendered = Image.create_empty(cell_width, cell_height, false, Image.FORMAT_RGBA8)
+        rendered.fill(Color.TRANSPARENT)
+
+        var meshes_node = get_tree().get_root().get_node("scene/Meshes")
+        if meshes_node != null:
+                _renderMeshNode(gridmap, meshes_node, rendered)
+
+        for pos in gridmap.get_used_cells():
+                var in_plane = Vector2i(pos.x, pos.z)
+
+                if in_plane in heights and heights[in_plane] > pos.y:
+                        continue
+
+                heights[in_plane] = pos.y
+
+                var cell_item = gridmap.get_cell_item(pos)
+                var mesh = gridmap.mesh_library.get_item_mesh(cell_item)
+                var material = mesh.surface_get_material(0)
+                var color = material.albedo_color
+
+                rendered.set_pixel(pos.x - cell_left, pos.z - cell_top, color)
+
+        return rendered
+
+
+func _renderMeshNode(gridmap, mesh, rendered):
+        if mesh is MeshInstance3D:
+                var local_tl = gridmap.map_to_local(Vector3i(cell_left, 0, cell_top))
+                var global_tl = gridmap.to_global(local_tl)
+                var mesh_material = mesh.get_surface_override_material(0)
+                if mesh_material != null:
+                        var mesh_color = mesh_material.albedo_color
+
+                        for y in range(
+                                max(mesh.position.z - mesh.scale.z / 2 - global_tl.z, 0),
+                                min(mesh.position.z + mesh.scale.z / 2 - global_tl.z, cell_height)
+                        ):
+                                for x in range(
+                                        max(mesh.position.x - mesh.scale.x / 2 - global_tl.x, 0),
+                                        min(mesh.position.x + mesh.scale.x / 2 - global_tl.x, cell_width)
+                                ):
+                                        rendered.set_pixel(x, y, mesh_color)
+
+        for child in mesh.get_children():
+                _renderMeshNode(gridmap, child, rendered)
@@ -0,0 +1,38 @@
+extends "res://scripts/nodes/painting.gd"
+
+var item_id
+var item_amount
+
+
+func _ready():
+        var node_path = String(
+                get_tree().get_root().get_node("scene").get_path_to(self).get_concatenated_names()
+        )
+
+        var gamedata = global.get_node("Gamedata")
+        var door_id = gamedata.get_door_for_map_node_path(global.map, node_path)
+        if door_id != null:
+                var ap = global.get_node("Archipelago")
+                var item_lock = ap.get_item_id_for_door(door_id)
+
+                if item_lock != null:
+                        item_id = item_lock[0]
+                        item_amount = item_lock[1]
+
+                        self.senders = []
+                        self.senderGroup = []
+                        self.nested = false
+                        self.complete_at = 0
+                        self.max_length = 0
+                        self.excludeSenders = []
+
+                        call_deferred("_readier")
+
+        super._ready()
+
+
+func _readier():
+        var ap = global.get_node("Archipelago")
+
+        if ap.client.getItemAmount(item_id) >= item_amount:
+                handleTriggered()
@@ -0,0 +1,101 @@
+extends "res://scripts/nodes/panel.gd"
+
+var panel_logic = null
+var symbol_solvable = true
+
+var black = load("res://assets/materials/black.material")
+
+
+func _ready():
+        super._ready()
+
+        var node_path = String(
+                get_tree().get_root().get_node("scene").get_path_to(self).get_concatenated_names()
+        )
+
+        var gamedata = global.get_node("Gamedata")
+        var panel_id = gamedata.get_panel_for_map_node_path(global.map, node_path)
+        if panel_id != null:
+                var ap = global.get_node("Archipelago")
+                if ap.shuffle_symbols:
+                        if global.map == "the_entry" and node_path == "Panels/Entry/front_1":
+                                clue = "i"
+                                symbol = ""
+
+                                setField("clue", clue)
+                                setField("symbol", symbol)
+
+                panel_logic = gamedata.objects.get_panels()[panel_id]
+                checkSymbolSolvable()
+
+                if not symbol_solvable:
+                        get_tree().get_root().get_node("scene/player").evaluate_solvability.connect(
+                                evaluateSolvability
+                        )
+
+
+func checkSymbolSolvable():
+        var old_solvable = symbol_solvable
+        symbol_solvable = true
+
+        if panel_logic == null:
+                # There's no logic for this panel.
+                return
+
+        var ap = global.get_node("Archipelago")
+        if not ap.shuffle_symbols:
+                # Symbols aren't item-locked.
+                return
+
+        var gamedata = global.get_node("Gamedata")
+        for symbol in panel_logic.get_symbols():
+                var item_name = gamedata.kSYMBOL_ITEMS.get(symbol)
+                var item_id = gamedata.objects.get_special_ids()[item_name]
+                if ap.client.getItemAmount(item_id) < 1:
+                        symbol_solvable = false
+                        break
+
+        if symbol_solvable != old_solvable:
+                if symbol_solvable:
+                        setField("clue", clue)
+                        setField("symbol", symbol)
+                        setField("answer", answer)
+                else:
+                        quad_mesh.surface_set_material(0, black)
+                        get_node("Hinge/clue").text = "missing"
+                        get_node("Hinge/answer").text = "symbols"
+
+
+func checkSolvable(key):
+        checkSymbolSolvable()
+        if not symbol_solvable:
+                return false
+
+        return super.checkSolvable(key)
+
+
+func evaluateSolvability():
+        checkSolvable("")
+
+
+func passedInput(key, skip_focus_check = false):
+        if not symbol_solvable:
+                return
+
+        super.passedInput(key, skip_focus_check)
+
+
+func focus():
+        if not symbol_solvable:
+                has_focus = false
+                return
+
+        super.focus()
+
+
+func unfocus():
+        if not symbol_solvable:
+                has_focus = false
+                return
+
+        super.unfocus()
@@ -0,0 +1,91 @@
+extends "res://scripts/ui/pauseMenu.gd"
+
+var compass_button
+var locations_button
+var minimap_button
+
+
+func _ready():
+        var ap_panel = Panel.new()
+        ap_panel.name = "Archipelago"
+        get_node("menu/settings/settingsInner/TabContainer").add_child(ap_panel)
+
+        var ap = global.get_node("Archipelago")
+
+        compass_button = CheckBox.new()
+        compass_button.text = "show compass"
+        compass_button.button_pressed = ap.show_compass
+        compass_button.position = Vector2(65, 100)
+        compass_button.theme = preload("res://assets/themes/baseUI.tres")
+        compass_button.add_theme_font_size_override("font_size", 60)
+        compass_button.pressed.connect(_toggle_compass)
+        ap_panel.add_child(compass_button)
+
+        locations_button = CheckBox.new()
+        locations_button.text = "show locations overlay"
+        locations_button.button_pressed = ap.show_locations
+        locations_button.position = Vector2(65, 200)
+        locations_button.theme = preload("res://assets/themes/baseUI.tres")
+        locations_button.add_theme_font_size_override("font_size", 60)
+        locations_button.pressed.connect(_toggle_locations)
+        ap_panel.add_child(locations_button)
+
+        minimap_button = CheckBox.new()
+        minimap_button.text = "show minimap"
+        minimap_button.button_pressed = ap.show_minimap
+        minimap_button.position = Vector2(65, 300)
+        minimap_button.theme = preload("res://assets/themes/baseUI.tres")
+        minimap_button.add_theme_font_size_override("font_size", 60)
+        minimap_button.pressed.connect(_toggle_minimap)
+        ap_panel.add_child(minimap_button)
+
+        super._ready()
+
+
+func _pause_game():
+        global.get_node("Textclient").dismiss()
+        super._pause_game()
+
+
+func _main_menu():
+        global.loaded = false
+        global.get_node("Archipelago").disconnect_from_ap()
+        global.get_node("Messages").clear()
+        global.get_node("Compass").visible = false
+        global.get_node("Textclient").reset()
+
+        autosplitter.reset()
+        _unpause_game()
+        Input.set_mouse_mode(Input.MOUSE_MODE_VISIBLE)
+        musicPlayer.stop()
+
+        var runtime = global.get_node("Runtime")
+        runtime.load_script_as_scene.call_deferred("settings_screen.gd", "settings_screen")
+
+
+func _toggle_compass():
+        var ap = global.get_node("Archipelago")
+        ap.show_compass = compass_button.button_pressed
+        ap.saveSettings()
+
+        var compass = global.get_node("Compass")
+        compass.visible = compass_button.button_pressed
+
+
+func _toggle_locations():
+        var ap = global.get_node("Archipelago")
+        ap.show_locations = locations_button.button_pressed
+        ap.saveSettings()
+
+        var textclient = global.get_node("Textclient")
+        textclient.update_locations_visibility()
+
+
+func _toggle_minimap():
+        var ap = global.get_node("Archipelago")
+        ap.show_minimap = minimap_button.button_pressed
+        ap.saveSettings()
+
+        var minimap = get_tree().get_root().get_node("scene/Minimap")
+        if minimap != null:
+                minimap.visible = ap.show_minimap
@@ -0,0 +1,346 @@
+extends "res://scripts/nodes/player.gd"
+
+signal evaluate_solvability
+
+var compass
+
+
+func _ready():
+        var khl_script = load("res://scripts/nodes/keyHolderListener.gd")
+
+        var pause_menu = get_node("pause_menu")
+        pause_menu.layer = 3
+
+        var ap = global.get_node("Archipelago")
+        var gamedata = global.get_node("Gamedata")
+
+        compass = global.get_node("Compass")
+        compass.visible = ap.show_compass
+
+        ap.start_batching_locations()
+
+        # 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
+
+                if not door.has_ap_id():
+                        continue
+
+                if (
+                        door.get_type() == gamedata.SCRIPT_proto.DoorType.ITEM_ONLY
+                        or door.get_type() == gamedata.SCRIPT_proto.DoorType.GALLERY_PAINTING
+                ):
+                        continue
+
+                var locationListener = ap.SCRIPT_locationListener.new()
+                locationListener.location_id = door.get_ap_id()
+                locationListener.name = "locationListener_%d" % door.get_ap_id()
+
+                for panel_ref in door.get_panels():
+                        var panel_data = gamedata.objects.get_panels()[panel_ref.get_panel()]
+                        var panel_path = panel_data.get_path()
+
+                        if panel_ref.has_answer():
+                                for proxy in panel_data.get_proxies():
+                                        if proxy.get_answer() == panel_ref.get_answer():
+                                                panel_path = proxy.get_path()
+                                                break
+
+                        locationListener.senders.append(NodePath("/root/scene/" + panel_path))
+
+                for keyholder_ref in door.get_keyholders():
+                        var keyholder_data = gamedata.objects.get_keyholders()[keyholder_ref.get_keyholder()]
+
+                        var khl = khl_script.new()
+                        khl.name = (
+                                "location_%d_keyholder_%d" % [door.get_ap_id(), keyholder_ref.get_keyholder()]
+                        )
+                        khl.answer = keyholder_ref.get_key()
+                        khl.senders.append(NodePath("/root/scene/" + keyholder_data.get_path()))
+                        get_parent().add_child.call_deferred(khl)
+
+                        locationListener.senders.append(NodePath("../" + khl.name))
+
+                for sender in door.get_senders():
+                        locationListener.senders.append(NodePath("/root/scene/" + sender))
+
+                if door.has_complete_at():
+                        locationListener.complete_at = door.get_complete_at()
+
+                get_parent().add_child.call_deferred(locationListener)
+
+        # Set up letter locations.
+        for letter in gamedata.objects.get_letters():
+                var room = gamedata.objects.get_rooms()[letter.get_room_id()]
+                if room.get_map_id() != map_id:
+                        continue
+
+                var locationListener = ap.SCRIPT_locationListener.new()
+                locationListener.location_id = letter.get_ap_id()
+                locationListener.name = "locationListener_%d" % letter.get_ap_id()
+                locationListener.senders.append(NodePath("/root/scene/" + letter.get_path()))
+
+                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 and not (scout["for_self"] and scout["flags"] & 4 != 0):
+                                var collectable = get_tree().get_root().get_node("scene").get_node_or_null(
+                                        letter.get_path()
+                                )
+                                if collectable != null:
+                                        collectable.setScoutedText.call_deferred(scout["item"])
+
+        # Set up mastery locations.
+        for mastery in gamedata.objects.get_masteries():
+                var room = gamedata.objects.get_rooms()[mastery.get_room_id()]
+                if room.get_map_id() != map_id:
+                        continue
+
+                var locationListener = ap.SCRIPT_locationListener.new()
+                locationListener.location_id = mastery.get_ap_id()
+                locationListener.name = "locationListener_%d" % mastery.get_ap_id()
+                locationListener.senders.append(NodePath("/root/scene/" + mastery.get_path()))
+
+                get_parent().add_child.call_deferred(locationListener)
+
+        # Set up ending locations.
+        for ending in gamedata.objects.get_endings():
+                var room = gamedata.objects.get_rooms()[ending.get_room_id()]
+                if room.get_map_id() != map_id:
+                        continue
+
+                var locationListener = ap.SCRIPT_locationListener.new()
+                locationListener.location_id = ending.get_ap_id()
+                locationListener.name = "locationListener_%d" % ending.get_ap_id()
+                locationListener.senders.append(NodePath("/root/scene/" + ending.get_path()))
+
+                get_parent().add_child.call_deferred(locationListener)
+
+                if ap.kEndingNameByVictoryValue.get(ap.victory_condition, null) == ending.get_name():
+                        var victoryListener = ap.SCRIPT_victoryListener.new()
+                        victoryListener.name = "victoryListener"
+                        victoryListener.senders.append(NodePath("/root/scene/" + ending.get_path()))
+
+                        get_parent().add_child.call_deferred(victoryListener)
+
+        # Set up keyholder locations, in keyholder sanity.
+        if ap.keyholder_sanity:
+                for keyholder in gamedata.objects.get_keyholders():
+                        if not keyholder.has_key():
+                                continue
+
+                        var room = gamedata.objects.get_rooms()[keyholder.get_room_id()]
+                        if room.get_map_id() != map_id:
+                                continue
+
+                        var locationListener = ap.SCRIPT_locationListener.new()
+                        locationListener.location_id = keyholder.get_ap_id()
+                        locationListener.name = "locationListener_%d" % keyholder.get_ap_id()
+
+                        var khl = khl_script.new()
+                        khl.name = "location_%d_keyholder" % keyholder.get_ap_id()
+                        khl.answer = keyholder.get_key()
+                        khl.senders.append(NodePath("/root/scene/" + keyholder.get_path()))
+                        get_parent().add_child.call_deferred(khl)
+
+                        locationListener.senders.append(NodePath("../" + khl.name))
+
+                        get_parent().add_child.call_deferred(locationListener)
+
+        # Block off roof access in Daedalus.
+        if global.map == "daedalus" and not ap.daedalus_roof_access:
+                _set_up_invis_wall(75.5, 11, -24.5, 1, 10, 49)
+                _set_up_invis_wall(51.5, 11, -17, 16, 10, 1)
+                _set_up_invis_wall(46, 10, -9.5, 1, 10, 10)
+                _set_up_invis_wall(67.5, 11, 17, 16, 10, 1)
+                _set_up_invis_wall(50.5, 11, 14, 10, 10, 1)
+                _set_up_invis_wall(39, 10, 18.5, 1, 10, 22)
+                _set_up_invis_wall(20, 15, 18.5, 1, 10, 16)
+                _set_up_invis_wall(11.5, 15, 3, 32, 10, 1)
+                _set_up_invis_wall(11.5, 16, -20, 14, 20, 1)
+                _set_up_invis_wall(14, 16, -26.5, 1, 20, 4)
+                _set_up_invis_wall(28.5, 20.5, -26.5, 1, 15, 25)
+                _set_up_invis_wall(40.5, 20.5, -11, 30, 15, 1)
+                _set_up_invis_wall(50.5, 15, 5.5, 7, 10, 1)
+                _set_up_invis_wall(83.5, 33.5, 5.5, 1, 7, 11)
+                _set_up_invis_wall(83.5, 33.5, -5.5, 1, 7, 11)
+
+                var warp_exit_prefab = preload("res://objects/nodes/exit.tscn")
+                var warp_exit = warp_exit_prefab.instantiate()
+                warp_exit.name = "roof_access_blocker_warp_exit"
+                warp_exit.position = Vector3(58, 10, 0)
+                warp_exit.rotation_degrees.y = 90
+                get_parent().add_child.call_deferred(warp_exit)
+
+                var warp_enter_prefab = preload("res://objects/nodes/teleportAuto.tscn")
+                var warp_enter = warp_enter_prefab.instantiate()
+                warp_enter.target = warp_exit
+                warp_enter.position = Vector3(76.5, 30, 1)
+                warp_enter.scale = Vector3(4, 1.5, 1)
+                warp_enter.rotation_degrees.y = 90
+                get_parent().add_child.call_deferred(warp_enter)
+
+        if global.map == "the_entry":
+                # Remove door behind X1.
+                var door_node = get_tree().get_root().get_node("/root/scene/Components/Doors/exit_1")
+                door_node.handleTriggered()
+
+                # Display win condition.
+                var sign_prefab = preload("res://objects/nodes/sign.tscn")
+                var sign1 = sign_prefab.instantiate()
+                sign1.position = Vector3(-7, 5, -15.01)
+                sign1.text = "victory"
+                get_parent().add_child.call_deferred(sign1)
+
+                var sign2 = sign_prefab.instantiate()
+                sign2.position = Vector3(-7, 4, -15.01)
+                sign2.text = "%s ending" % ap.kEndingNameByVictoryValue.get(ap.victory_condition, "?")
+
+                var sign2_color = ap.kEndingNameByVictoryValue.get(ap.victory_condition, "coral").to_lower()
+                if sign2_color == "white":
+                        sign2_color = "silver"
+
+                sign2.material = load("res://assets/materials/%s.material" % sign2_color)
+                get_parent().add_child.call_deferred(sign2)
+
+        # Add the strict purple ending validation.
+        if global.map == "the_sun_temple" and ap.strict_purple_ending:
+                var panel_prefab = preload("res://objects/nodes/panel.tscn")
+                var tpl_prefab = preload("res://objects/nodes/listeners/teleportListener.tscn")
+                var reverse_prefab = preload("res://objects/nodes/listeners/reversingListener.tscn")
+
+                var previous_panel = null
+                var next_y = -100
+                var words = ["quick", "brown", "fox", "jumps", "over", "the", "lazy", "dog"]
+                for word in words:
+                        var panel = panel_prefab.instantiate()
+                        panel.position = Vector3(0, next_y, 0)
+                        next_y -= 10
+                        panel.clue = word
+                        panel.symbol = ""
+                        panel.answer = word
+                        panel.name = "EndCheck_%s" % word
+
+                        var tpl = tpl_prefab.instantiate()
+                        tpl.teleport_point = Vector3(0, 1, 0)
+                        tpl.teleport_rotate = Vector3(-45, 180, 0)
+                        tpl.target_path = panel
+                        tpl.name = "Teleport"
+
+                        if previous_panel == null:
+                                tpl.senders.append(NodePath("/root/scene/Panels/End/panel_24"))
+                        else:
+                                tpl.senders.append(NodePath("../../%s" % previous_panel.name))
+
+                        var reversing = reverse_prefab.instantiate()
+                        reversing.senders.append(NodePath(".."))
+                        reversing.name = "Reversing"
+                        tpl.senders.append(NodePath("../Reversing"))
+
+                        panel.add_child.call_deferred(tpl)
+                        panel.add_child.call_deferred(reversing)
+                        get_parent().get_node("Panels").add_child.call_deferred(panel)
+
+                        previous_panel = panel
+
+                # Duplicate the doors that usually wait on EQUINOX. We can't set the senders
+                # here for some reason so we actually set them in the door ready function.
+                var endplat = get_node("/root/scene/Components/Doors/EndPlatform")
+                var endplat2 = endplat.duplicate()
+                endplat2.name = "spe_EndPlatform"
+                endplat.get_parent().add_child.call_deferred(endplat2)
+                endplat.queue_free()
+
+                var entry2 = get_node("/root/scene/Components/Doors/entry_2")
+                var entry22 = entry2.duplicate()
+                entry22.name = "spe_entry_2"
+                entry2.get_parent().add_child.call_deferred(entry22)
+                entry2.queue_free()
+
+        # Add the strict cyan ending validation.
+        if global.map == "the_parthenon" and ap.strict_cyan_ending:
+                var panel_prefab = preload("res://objects/nodes/panel.tscn")
+                var tpl_prefab = preload("res://objects/nodes/listeners/teleportListener.tscn")
+                var reverse_prefab = preload("res://objects/nodes/listeners/reversingListener.tscn")
+
+                var previous_panel = null
+                var next_y = -100
+                var words = ["quick", "brown", "fox", "jumps", "over", "the", "lazy", "dog"]
+                for word in words:
+                        var panel = panel_prefab.instantiate()
+                        panel.position = Vector3(0, next_y, 0)
+                        next_y -= 10
+                        panel.clue = word
+                        panel.symbol = "."
+                        panel.answer = "%s%s" % [word, word]
+                        panel.name = "EndCheck_%s" % word
+
+                        var tpl = tpl_prefab.instantiate()
+                        tpl.teleport_point = Vector3(0, 1, -11)
+                        tpl.teleport_rotate = Vector3(-45, 0, 0)
+                        tpl.target_path = panel
+                        tpl.name = "Teleport"
+
+                        if previous_panel == null:
+                                tpl.senderGroup.append(NodePath("/root/scene/Panels/Rulers"))
+                        else:
+                                tpl.senders.append(NodePath("../../%s" % previous_panel.name))
+
+                        var reversing = reverse_prefab.instantiate()
+                        reversing.senders.append(NodePath(".."))
+                        reversing.name = "Reversing"
+                        tpl.senders.append(NodePath("../Reversing"))
+
+                        panel.add_child.call_deferred(tpl)
+                        panel.add_child.call_deferred(reversing)
+                        get_parent().get_node("Panels").add_child.call_deferred(panel)
+
+                        previous_panel = panel
+
+                # Duplicate the door that usually waits on the rulers. We can't set the
+                # senders here for some reason so we actually set them in the door ready
+                # function.
+                var entry1 = get_node("/root/scene/Components/Doors/entry_1")
+                var entry12 = entry1.duplicate()
+                entry12.name = "spe_entry_1"
+                entry1.get_parent().add_child.call_deferred(entry12)
+                entry1.queue_free()
+
+        var minimap = ap.SCRIPT_minimap.new()
+        minimap.name = "Minimap"
+        minimap.visible = ap.show_minimap
+        get_parent().add_child.call_deferred(minimap)
+
+        super._ready()
+
+        await get_tree().process_frame
+        await get_tree().process_frame
+
+        ap.stop_batching_locations()
+
+
+func _set_up_invis_wall(x, y, z, sx, sy, sz):
+        var prefab = preload("res://objects/nodes/block.tscn")
+        var newwall = prefab.instantiate()
+        newwall.position.x = x
+        newwall.position.y = y
+        newwall.position.z = z
+        newwall.scale.x = sz
+        newwall.scale.y = sy
+        newwall.scale.z = sx
+        newwall.set_surface_override_material(0, preload("res://assets/materials/blackMatte.material"))
+        newwall.visibility_range_end = 3
+        newwall.visibility_range_end_margin = 1
+        newwall.visibility_range_fade_mode = RenderingServer.VISIBILITY_RANGE_FADE_SELF
+        newwall.skeleton = ".."
+        get_parent().add_child.call_deferred(newwall)
+
+
+func _process(_dt):
+        compass.update_rotation(global_rotation.y)
@@ -0,0 +1,10 @@
+extends RichTextEffect
+
+var bbcode = "rainbow"
+
+
+func _process_custom_fx(char_fx: CharFXTransform):
+        char_fx.color = Color.from_hsv(
+                char_fx.elapsed_time - floor(char_fx.elapsed_time), 1.0, 1.0, 1.0
+        )
+        return true
@@ -0,0 +1,30 @@
+[gd_scene load_steps=11 format=2]
+
+[sub_resource id=2 type="GDScript"]
+script/source = "extends Node2D
+
+
+func _ready():
+        var args = OS.get_cmdline_user_args()
+        var apworld_path = args[0]
+
+        var zip_reader = ZIPReader.new()
+        zip_reader.open(apworld_path)
+        
+        var runtime_script = GDScript.new()
+        runtime_script.source_code = zip_reader.read_file(\"lingo2/client/apworld_runtime.gd\").get_string_from_utf8()
+        runtime_script.reload()
+
+        zip_reader.close()
+
+        var runtime = runtime_script.new(apworld_path)
+        runtime.name = \"Runtime\"
+
+        global.add_child(runtime)
+
+        runtime.load_script_as_scene.call_deferred(\"settings_screen.gd\", \"settings_screen\")
+
+"
+
+[node name="loader" type="Node2D"]
+script = SubResource( 2 )
@@ -0,0 +1,22 @@
+[gd_scene load_steps=11 format=2]
+
+[sub_resource id=2 type="GDScript"]
+script/source = "extends Node2D
+
+
+func _ready():
+        var args = OS.get_cmdline_user_args()
+        var source_path = args[0]
+
+        var runtime_script = ResourceLoader.load(\"%s/source_runtime.gd\" % source_path)
+        var runtime = runtime_script.new(source_path)
+        runtime.name = \"Runtime\"
+
+        global.add_child(runtime)
+
+        runtime.load_script_as_scene.call_deferred(\"settings_screen.gd\", \"settings_screen\")
+
+"
+
+[node name="loader" type="Node2D"]
+script = SubResource( 2 )
@@ -0,0 +1,23 @@
+extends "res://scripts/nodes/saver.gd"
+
+
+func levelLoaded():
+        if type == "keyholders":
+                var ap = global.get_node("Archipelago")
+                ap.keyboard.load_keyholders.call_deferred(global.map)
+        else:
+                reload.call_deferred()
+
+
+func reload():
+        # Just rewriting this whole thing so I can remove Chris's safeguard.
+        var file = FileAccess.open(path + type + ".save", FileAccess.READ)
+        if file:
+                var data = file.get_var(true)
+                file.close()
+                for datum in data:
+                        var saveable = get_node_or_null(datum[0])
+                        if saveable != null:
+                                saveable.is_complete = datum[1]
+                                if saveable.is_complete:
+                                        saveable.loadData(saveable.is_complete)
@@ -0,0 +1,153 @@
+extends Node
+
+
+func _ready():
+        var theme = preload("res://assets/themes/baseUI.tres")
+
+        var simple_style_box = StyleBoxFlat.new()
+        simple_style_box.bg_color = Color(0, 0, 0, 0)
+
+        var panel = Panel.new()
+        panel.name = "Panel"
+        panel.offset_right = 1920.0
+        panel.offset_bottom = 1080.0
+        add_child(panel)
+
+        var title = Label.new()
+        title.name = "title"
+        title.offset_left = 0.0
+        title.offset_top = 75.0
+        title.offset_right = 1920.0
+        title.offset_bottom = 225.0
+        title.text = "ARCHIPELAGO"
+        title.vertical_alignment = VERTICAL_ALIGNMENT_CENTER
+        title.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
+        title.theme = theme
+        panel.add_child(title)
+
+        var connect_button = Button.new()
+        connect_button.name = "connect_button"
+        connect_button.offset_left = 255.0
+        connect_button.offset_top = 875.0
+        connect_button.offset_right = 891.0
+        connect_button.offset_bottom = 1025.0
+        connect_button.add_theme_color_override("font_color_hover", Color(1, 0.501961, 0, 1))
+        connect_button.text = "CONNECT"
+        connect_button.theme = theme
+        panel.add_child(connect_button)
+
+        var quit_button = Button.new()
+        quit_button.name = "quit_button"
+        quit_button.offset_left = 1102.0
+        quit_button.offset_top = 875.0
+        quit_button.offset_right = 1738.0
+        quit_button.offset_bottom = 1025.0
+        quit_button.add_theme_color_override("font_color_hover", Color(1, 0, 0, 1))
+        quit_button.text = "QUIT"
+        quit_button.theme = theme
+        panel.add_child(quit_button)
+
+        var credit2 = Label.new()
+        credit2.name = "credit2"
+        credit2.offset_left = -105.0
+        credit2.offset_top = 346.0
+        credit2.offset_right = 485.0
+        credit2.offset_bottom = 410.0
+        credit2.add_theme_stylebox_override("normal", simple_style_box)
+        credit2.text = "SERVER"
+        credit2.horizontal_alignment = HORIZONTAL_ALIGNMENT_RIGHT
+        credit2.theme = theme
+        panel.add_child(credit2)
+
+        var credit3 = Label.new()
+        credit3.name = "credit3"
+        credit3.offset_left = -105.0
+        credit3.offset_top = 519.0
+        credit3.offset_right = 485.0
+        credit3.offset_bottom = 583.0
+        credit3.add_theme_stylebox_override("normal", simple_style_box)
+        credit3.text = "PLAYER"
+        credit3.horizontal_alignment = HORIZONTAL_ALIGNMENT_RIGHT
+        credit3.theme = theme
+        panel.add_child(credit3)
+
+        var credit4 = Label.new()
+        credit4.name = "credit4"
+        credit4.offset_left = -105.0
+        credit4.offset_top = 704.0
+        credit4.offset_right = 485.0
+        credit4.offset_bottom = 768.0
+        credit4.add_theme_stylebox_override("normal", simple_style_box)
+        credit4.text = "PASSWORD"
+        credit4.horizontal_alignment = HORIZONTAL_ALIGNMENT_RIGHT
+        credit4.theme = theme
+        panel.add_child(credit4)
+
+        var credit5 = Label.new()
+        credit5.name = "credit5"
+        credit5.offset_left = 1239.0
+        credit5.offset_top = 422.0
+        credit5.offset_right = 1829.0
+        credit5.offset_bottom = 486.0
+        credit5.add_theme_stylebox_override("normal", simple_style_box)
+        credit5.text = "OPTIONS"
+        credit5.theme = theme
+        panel.add_child(credit5)
+
+        var server_box = LineEdit.new()
+        server_box.name = "server_box"
+        server_box.offset_left = 502.0
+        server_box.offset_top = 295.0
+        server_box.offset_right = 1144.0
+        server_box.offset_bottom = 445.0
+        server_box.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
+        server_box.caret_blink = true
+        panel.add_child(server_box)
+
+        var player_box = LineEdit.new()
+        player_box.name = "player_box"
+        player_box.offset_left = 502.0
+        player_box.offset_top = 477.0
+        player_box.offset_right = 1144.0
+        player_box.offset_bottom = 627.0
+        player_box.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
+        player_box.caret_blink = true
+        panel.add_child(player_box)
+
+        var password_box = LineEdit.new()
+        password_box.name = "password_box"
+        password_box.offset_left = 502.0
+        password_box.offset_top = 659.0
+        password_box.offset_right = 1144.0
+        password_box.offset_bottom = 809.0
+        password_box.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
+        password_box.caret_blink = true
+        panel.add_child(password_box)
+
+        var accept_dialog = AcceptDialog.new()
+        accept_dialog.name = "AcceptDialog"
+        accept_dialog.offset_right = 83.0
+        accept_dialog.offset_bottom = 58.0
+        panel.add_child(accept_dialog)
+
+        var version_mismatch = ConfirmationDialog.new()
+        version_mismatch.name = "VersionMismatch"
+        version_mismatch.offset_right = 83.0
+        version_mismatch.offset_bottom = 58.0
+        panel.add_child(version_mismatch)
+
+        var connection_history = MenuButton.new()
+        connection_history.name = "connection_history"
+        connection_history.offset_left = 1239.0
+        connection_history.offset_top = 276.0
+        connection_history.offset_right = 1829.0
+        connection_history.offset_bottom = 372.0
+        connection_history.text = "connection history"
+        connection_history.flat = false
+        panel.add_child(connection_history)
+
+        var runtime = global.get_node("Runtime")
+        var main_script = runtime.load_script("main.gd")
+        var main_node = main_script.new()
+        main_node.name = "Main"
+        add_child(main_node)
@@ -0,0 +1,29 @@
+extends Node
+
+var source_path
+
+
+func _init(path):
+        source_path = path
+
+
+func load_script(path):
+        return ResourceLoader.load("%s/%s" % [source_path, path])
+
+
+func read_path(path):
+        return FileAccess.get_file_as_bytes("%s/%s" % [source_path, path])
+
+
+func load_script_as_scene(path, scene_name):
+        var script = load_script(path)
+        var instance = script.new()
+        instance.name = scene_name
+
+        get_tree().unload_current_scene()
+        _load_scene.call_deferred(instance)
+
+
+func _load_scene(instance):
+        get_tree().get_root().add_child(instance)
+        get_tree().current_scene = instance
@@ -0,0 +1,38 @@
+extends "res://scripts/nodes/teleport.gd"
+
+var item_id
+var item_amount
+
+
+func _ready():
+        var node_path = String(
+                get_tree().get_root().get_node("scene").get_path_to(self).get_concatenated_names()
+        )
+
+        var gamedata = global.get_node("Gamedata")
+        var door_id = gamedata.get_door_for_map_node_path(global.map, node_path)
+        if door_id != null:
+                var ap = global.get_node("Archipelago")
+                var item_lock = ap.get_item_id_for_door(door_id)
+
+                if item_lock != null:
+                        item_id = item_lock[0]
+                        item_amount = item_lock[1]
+
+                        self.senders = []
+                        self.senderGroup = []
+                        self.nested = false
+                        self.complete_at = 0
+                        self.max_length = 0
+                        self.excludeSenders = []
+
+                        call_deferred("_readier")
+
+        super._ready()
+
+
+func _readier():
+        var ap = global.get_node("Archipelago")
+
+        if ap.client.getItemAmount(item_id) >= item_amount:
+                handleTriggered()
@@ -0,0 +1,49 @@
+extends "res://scripts/nodes/listeners/teleportListener.gd"
+
+var item_id
+var item_amount
+
+
+func _ready():
+        var node_path = String(
+                get_tree().get_root().get_node("scene").get_path_to(self).get_concatenated_names()
+        )
+
+        if (
+                global.map == "daedalus"
+                and (
+                        node_path == "Components/Triggers/teleportListenerConnections"
+                        or node_path == "Components/Triggers/teleportListenerConnections2"
+                )
+        ):
+                # Effectively disable these.
+                teleport_point = target_path.position
+                return
+
+        var gamedata = global.get_node("Gamedata")
+        var door_id = gamedata.get_door_for_map_node_path(global.map, node_path)
+        if door_id != null:
+                var ap = global.get_node("Archipelago")
+                var item_lock = ap.get_item_id_for_door(door_id)
+
+                if item_lock != null:
+                        item_id = item_lock[0]
+                        item_amount = item_lock[1]
+
+                        self.senders = []
+                        self.senderGroup = []
+                        self.nested = false
+                        self.complete_at = 0
+                        self.max_length = 0
+                        self.excludeSenders = []
+
+                        call_deferred("_readier")
+
+        super._ready()
+
+
+func _readier():
+        var ap = global.get_node("Archipelago")
+
+        if ap.client.getItemAmount(item_id) >= item_amount:
+                handleTriggered()
@@ -0,0 +1,310 @@
+extends CanvasLayer
+
+var tabs
+var panel
+var label
+var entry
+var tracker_label
+var is_open = false
+
+var locations_overlay
+var location_texture
+var worldport_texture
+var goal_texture
+
+var worldports_tab
+var worldports_tree
+var port_tree_item_by_map = {}
+var port_tree_item_by_map_port = {}
+
+
+func _ready():
+        process_mode = ProcessMode.PROCESS_MODE_ALWAYS
+        layer = 2
+
+        locations_overlay = RichTextLabel.new()
+        locations_overlay.name = "LocationsOverlay"
+        locations_overlay.offset_top = 220
+        locations_overlay.offset_bottom = 720
+        locations_overlay.offset_left = 20
+        locations_overlay.anchor_right = 1.0
+        locations_overlay.offset_right = -10
+        locations_overlay.scroll_active = false
+        locations_overlay.mouse_filter = Control.MOUSE_FILTER_IGNORE
+        locations_overlay.texture_filter = CanvasItem.TEXTURE_FILTER_NEAREST
+        add_child(locations_overlay)
+        update_locations_visibility()
+
+        tabs = TabContainer.new()
+        tabs.name = "Tabs"
+        tabs.offset_left = 100
+        tabs.offset_right = 1820
+        tabs.offset_top = 100
+        tabs.offset_bottom = 980
+        tabs.visible = false
+        tabs.theme = preload("res://assets/themes/baseUI.tres")
+        tabs.add_theme_font_size_override("font_size", 36)
+        add_child(tabs)
+
+        panel = MarginContainer.new()
+        panel.name = "Text Client"
+        panel.add_theme_constant_override("margin_top", 60)
+        panel.add_theme_constant_override("margin_left", 60)
+        panel.add_theme_constant_override("margin_right", 60)
+        panel.add_theme_constant_override("margin_bottom", 60)
+        tabs.add_child(panel)
+
+        label = RichTextLabel.new()
+        label.set_name("Label")
+        label.scroll_following = true
+        label.selection_enabled = true
+        label.size_flags_horizontal = Control.SIZE_EXPAND_FILL
+        label.size_flags_vertical = Control.SIZE_EXPAND_FILL
+        label.push_font(preload("res://assets/fonts/Lingo2.ttf"))
+        label.push_font_size(36)
+
+        var entry_style = StyleBoxFlat.new()
+        entry_style.bg_color = Color(0.9, 0.9, 0.9, 1)
+
+        entry = LineEdit.new()
+        entry.set_name("Entry")
+        entry.add_theme_font_override("font", preload("res://assets/fonts/Lingo2.ttf"))
+        entry.add_theme_font_size_override("font_size", 36)
+        entry.add_theme_color_override("font_color", Color(0, 0, 0, 1))
+        entry.add_theme_color_override("cursor_color", Color(0, 0, 0, 1))
+        entry.add_theme_stylebox_override("focus", entry_style)
+        entry.text_submitted.connect(text_entered)
+
+        var tc_arranger = VBoxContainer.new()
+        tc_arranger.add_child(label)
+        tc_arranger.add_child(entry)
+        tc_arranger.add_theme_constant_override("separation", 40)
+        panel.add_child(tc_arranger)
+
+        var tracker_margins = MarginContainer.new()
+        tracker_margins.name = "Locations"
+        tracker_margins.add_theme_constant_override("margin_top", 60)
+        tracker_margins.add_theme_constant_override("margin_left", 60)
+        tracker_margins.add_theme_constant_override("margin_right", 60)
+        tracker_margins.add_theme_constant_override("margin_bottom", 60)
+        tabs.add_child(tracker_margins)
+
+        tracker_label = RichTextLabel.new()
+        tracker_margins.add_child(tracker_label)
+
+        worldports_tab = MarginContainer.new()
+        worldports_tab.name = "Worldports"
+        worldports_tab.add_theme_constant_override("margin_top", 60)
+        worldports_tab.add_theme_constant_override("margin_left", 60)
+        worldports_tab.add_theme_constant_override("margin_right", 60)
+        worldports_tab.add_theme_constant_override("margin_bottom", 60)
+        tabs.add_child(worldports_tab)
+        tabs.set_tab_hidden(2, true)
+
+        worldports_tree = Tree.new()
+        worldports_tree.columns = 2
+        worldports_tree.hide_root = true
+        worldports_tree.theme = preload("res://assets/themes/baseUI.tres")
+        worldports_tree.add_theme_font_size_override("font_size", 24)
+        worldports_tab.add_child(worldports_tree)
+
+        var runtime = global.get_node("Runtime")
+        var location_image = Image.new()
+        location_image.load_png_from_buffer(runtime.read_path("assets/location.png"))
+        location_texture = ImageTexture.create_from_image(location_image)
+
+        var worldport_image = Image.new()
+        worldport_image.load_png_from_buffer(runtime.read_path("assets/worldport.png"))
+        worldport_texture = ImageTexture.create_from_image(worldport_image)
+
+        var goal_image = Image.new()
+        goal_image.load_png_from_buffer(runtime.read_path("assets/goal.png"))
+        goal_texture = ImageTexture.create_from_image(goal_image)
+
+
+func _input(event):
+        if global.loaded and event is InputEventKey and event.pressed:
+                if event.keycode == KEY_TAB and !Input.is_key_pressed(KEY_SHIFT):
+                        if !get_tree().paused:
+                                is_open = true
+                                get_tree().paused = true
+                                Input.set_mouse_mode(Input.MOUSE_MODE_VISIBLE)
+                                tabs.visible = true
+                                entry.grab_focus()
+                                get_viewport().set_input_as_handled()
+                        else:
+                                dismiss()
+                elif event.keycode == KEY_ESCAPE:
+                        if is_open:
+                                dismiss()
+                                get_viewport().set_input_as_handled()
+
+
+func dismiss():
+        if is_open:
+                get_tree().paused = false
+                Input.set_mouse_mode(Input.MOUSE_MODE_CAPTURED)
+                tabs.visible = false
+                is_open = false
+
+
+func parse_printjson(text):
+        label.append_text("[p]" + text + "[/p]")
+
+
+func text_entered(text):
+        var ap = global.get_node("Archipelago")
+        var cmd = text.trim_suffix("\n")
+        entry.text = ""
+        if OS.is_debug_build():
+                if cmd.begins_with("/tp_map "):
+                        var new_map = cmd.substr(8)
+                        global.map = new_map
+                        global.sets_entry_point = false
+                        switcher.switch_map("res://objects/scenes/%s.tscn" % new_map)
+                        return
+
+        ap.client.say(cmd)
+
+
+func update_locations():
+        var ap = global.get_node("Archipelago")
+        var gamedata = global.get_node("Gamedata")
+
+        tracker_label.clear()
+        tracker_label.push_font(preload("res://assets/fonts/Lingo2.ttf"))
+        tracker_label.push_font_size(24)
+
+        locations_overlay.clear()
+        locations_overlay.push_font(preload("res://assets/fonts/Lingo2.ttf"))
+        locations_overlay.push_font_size(24)
+        locations_overlay.push_color(Color(0.9, 0.9, 0.9, 1))
+        locations_overlay.push_outline_color(Color(0, 0, 0, 1))
+        locations_overlay.push_outline_size(2)
+
+        const kLocation = 0
+        const kWorldport = 1
+        const kGoal = 2
+
+        var location_names = []
+        var type_by_name = {}
+        for location_id in ap.client._accessible_locations:
+                if not ap.client._checked_locations.has(location_id):
+                        var location_name = gamedata.location_name_by_id.get(location_id, "(Unknown)")
+                        location_names.append(location_name)
+                        type_by_name[location_name] = kLocation
+
+        for port_id in ap.client._accessible_worldports:
+                if not ap.client._checked_worldports.has(port_id):
+                        var port_name = gamedata.get_worldport_display_name(port_id)
+                        location_names.append(port_name)
+                        type_by_name[port_name] = kWorldport
+
+        location_names.sort()
+
+        if ap.client._goal_accessible:
+                var location_name = gamedata.ending_display_name_by_name[ap.kEndingNameByVictoryValue[
+                        ap.victory_condition
+                ]]
+                location_names.push_front(location_name)
+                type_by_name[location_name] = kGoal
+
+        var count = 0
+        for location_name in location_names:
+                tracker_label.append_text("[p]%s[/p]" % location_name)
+                if count < 18:
+                        locations_overlay.push_paragraph(HORIZONTAL_ALIGNMENT_RIGHT)
+                        locations_overlay.append_text(location_name)
+                        locations_overlay.append_text(" ")
+                        if type_by_name[location_name] == kLocation:
+                                locations_overlay.add_image(location_texture)
+                        elif type_by_name[location_name] == kWorldport:
+                                locations_overlay.add_image(worldport_texture)
+                        elif type_by_name[location_name] == kGoal:
+                                locations_overlay.add_image(goal_texture)
+                        locations_overlay.pop()
+                count += 1
+
+        if count > 18:
+                locations_overlay.append_text("[p align=right][lb]...[rb][/p]")
+
+
+func update_locations_visibility():
+        var ap = global.get_node("Archipelago")
+        locations_overlay.visible = ap.show_locations
+
+
+func setup_worldports():
+        tabs.set_tab_hidden(2, false)
+
+        var root_ti = worldports_tree.create_item(null)
+
+        var ports_by_map_id = {}
+        var display_names_by_map_id = {}
+        var display_names_by_port_id = {}
+
+        var ap = global.get_node("Archipelago")
+        var gamedata = global.get_node("Gamedata")
+        for fpid in ap.port_pairings:
+                var port = gamedata.objects.get_ports()[fpid]
+                var room = gamedata.objects.get_rooms()[port.get_room_id()]
+
+                if not ports_by_map_id.has(room.get_map_id()):
+                        ports_by_map_id[room.get_map_id()] = []
+
+                        var map = gamedata.objects.get_maps()[room.get_map_id()]
+                        display_names_by_map_id[map.get_id()] = map.get_display_name()
+
+                ports_by_map_id[room.get_map_id()].append(fpid)
+                display_names_by_port_id[fpid] = port.get_display_name()
+
+        var sorted_map_ids = ports_by_map_id.keys().duplicate()
+        sorted_map_ids.sort_custom(
+                func(a, b): return display_names_by_map_id[a] < display_names_by_map_id[b]
+        )
+
+        for map_id in sorted_map_ids:
+                var map_ti = root_ti.create_child()
+                map_ti.set_text(0, display_names_by_map_id[map_id])
+                map_ti.visible = false
+                map_ti.collapsed = true
+                port_tree_item_by_map[map_id] = map_ti
+                port_tree_item_by_map_port[map_id] = {}
+
+                var port_ids = ports_by_map_id[map_id]
+                port_ids.sort_custom(
+                        func(a, b): return display_names_by_port_id[a] < display_names_by_port_id[b]
+                )
+
+                for port_id in port_ids:
+                        var port_ti = map_ti.create_child()
+                        port_ti.set_text(0, display_names_by_port_id[port_id])
+                        port_ti.set_text(1, gamedata.get_worldport_display_name(ap.port_pairings[port_id]))
+                        port_ti.visible = false
+                        port_tree_item_by_map_port[map_id][port_id] = port_ti
+
+        update_worldports()
+
+
+func update_worldports():
+        var ap = global.get_node("Archipelago")
+
+        for map_id in port_tree_item_by_map_port.keys():
+                var map_visible = false
+
+                for port_id in port_tree_item_by_map_port[map_id].keys():
+                        var ti = port_tree_item_by_map_port[map_id][port_id]
+                        ti.visible = ap.client._checked_worldports.has(port_id)
+
+                        if ti.visible:
+                                map_visible = true
+
+                port_tree_item_by_map[map_id].visible = map_visible
+
+
+func reset():
+        locations_overlay.clear()
+        tabs.set_tab_hidden(2, true)
+        port_tree_item_by_map.clear()
+        port_tree_item_by_map_port.clear()
+        worldports_tree.clear()
@@ -0,0 +1,21 @@
+WebSocketServer.gd:
+
+Copyright (c) 2014-present Godot Engine contributors. Copyright (c) 2007-2014
+Juan Linietsky, Ariel Manzur.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
@@ -0,0 +1,173 @@
+class_name WebSocketServer
+extends Node
+
+signal message_received(peer_id: int, message: String)
+signal client_connected(peer_id: int)
+signal client_disconnected(peer_id: int)
+
+@export var handshake_headers := PackedStringArray()
+@export var supported_protocols := PackedStringArray()
+@export var handshake_timout := 3000
+@export var use_tls := false
+@export var tls_cert: X509Certificate
+@export var tls_key: CryptoKey
+@export var refuse_new_connections := false:
+        set(refuse):
+                if refuse:
+                        pending_peers.clear()
+
+
+class PendingPeer:
+        var connect_time: int
+        var tcp: StreamPeerTCP
+        var connection: StreamPeer
+        var ws: WebSocketPeer
+
+        func _init(p_tcp: StreamPeerTCP) -> void:
+                tcp = p_tcp
+                connection = p_tcp
+                connect_time = Time.get_ticks_msec()
+
+
+var tcp_server := TCPServer.new()
+var pending_peers: Array[PendingPeer] = []
+var peers: Dictionary
+
+
+func listen(port: int) -> int:
+        assert(not tcp_server.is_listening())
+        return tcp_server.listen(port)
+
+
+func stop() -> void:
+        tcp_server.stop()
+        pending_peers.clear()
+        peers.clear()
+
+
+func send(peer_id: int, message: String) -> int:
+        var type := typeof(message)
+        if peer_id <= 0:
+                # Send to multiple peers, (zero = broadcast, negative = exclude one).
+                for id: int in peers:
+                        if id == -peer_id:
+                                continue
+                        if type == TYPE_STRING:
+                                peers[id].send_text(message)
+                        else:
+                                peers[id].put_packet(message)
+                return OK
+
+        assert(peers.has(peer_id))
+        var socket: WebSocketPeer = peers[peer_id]
+        if type == TYPE_STRING:
+                return socket.send_text(message)
+        return socket.send(var_to_bytes(message))
+
+
+func get_message(peer_id: int) -> Variant:
+        assert(peers.has(peer_id))
+        var socket: WebSocketPeer = peers[peer_id]
+        if socket.get_available_packet_count() < 1:
+                return null
+        var pkt: PackedByteArray = socket.get_packet()
+        if socket.was_string_packet():
+                return pkt.get_string_from_utf8()
+        return bytes_to_var(pkt)
+
+
+func has_message(peer_id: int) -> bool:
+        assert(peers.has(peer_id))
+        return peers[peer_id].get_available_packet_count() > 0
+
+
+func _create_peer() -> WebSocketPeer:
+        var ws := WebSocketPeer.new()
+        ws.supported_protocols = supported_protocols
+        ws.handshake_headers = handshake_headers
+        return ws
+
+
+func poll() -> void:
+        if not tcp_server.is_listening():
+                return
+
+        while not refuse_new_connections and tcp_server.is_connection_available():
+                var conn: StreamPeerTCP = tcp_server.take_connection()
+                assert(conn != null)
+                pending_peers.append(PendingPeer.new(conn))
+
+        var to_remove := []
+
+        for p in pending_peers:
+                if not _connect_pending(p):
+                        if p.connect_time + handshake_timout < Time.get_ticks_msec():
+                                # Timeout.
+                                to_remove.append(p)
+                        continue  # Still pending.
+
+                to_remove.append(p)
+
+        for r: RefCounted in to_remove:
+                pending_peers.erase(r)
+
+        to_remove.clear()
+
+        for id: int in peers:
+                var p: WebSocketPeer = peers[id]
+                p.poll()
+
+                if p.get_ready_state() != WebSocketPeer.STATE_OPEN:
+                        client_disconnected.emit(id)
+                        to_remove.append(id)
+                        continue
+
+                while p.get_available_packet_count():
+                        message_received.emit(id, get_message(id))
+
+        for r: int in to_remove:
+                peers.erase(r)
+        to_remove.clear()
+
+
+func _connect_pending(p: PendingPeer) -> bool:
+        if p.ws != null:
+                # Poll websocket client if doing handshake.
+                p.ws.poll()
+                var state := p.ws.get_ready_state()
+                if state == WebSocketPeer.STATE_OPEN:
+                        var id := randi_range(2, 1 << 30)
+                        peers[id] = p.ws
+                        client_connected.emit(id)
+                        return true  # Success.
+                elif state != WebSocketPeer.STATE_CONNECTING:
+                        return true  # Failure.
+                return false  # Still connecting.
+        elif p.tcp.get_status() != StreamPeerTCP.STATUS_CONNECTED:
+                return true  # TCP disconnected.
+        elif not use_tls:
+                # TCP is ready, create WS peer.
+                p.ws = _create_peer()
+                p.ws.accept_stream(p.tcp)
+                return false  # WebSocketPeer connection is pending.
+
+        else:
+                if p.connection == p.tcp:
+                        assert(tls_key != null and tls_cert != null)
+                        var tls := StreamPeerTLS.new()
+                        tls.accept_stream(p.tcp, TLSOptions.server(tls_key, tls_cert))
+                        p.connection = tls
+                p.connection.poll()
+                var status: StreamPeerTLS.Status = p.connection.get_status()
+                if status == StreamPeerTLS.STATUS_CONNECTED:
+                        p.ws = _create_peer()
+                        p.ws.accept_stream(p.connection)
+                        return false  # WebSocketPeer connection is pending.
+                if status != StreamPeerTLS.STATUS_HANDSHAKING:
+                        return true  # Failure.
+
+                return false
+
+
+func _process(_delta: float) -> void:
+        poll()
@@ -0,0 +1,20 @@
+extends Receiver
+
+
+func _ready():
+        super._ready()
+
+
+func handleTriggered():
+        triggered += 1
+        if triggered >= total:
+                var ap = global.get_node("Archipelago")
+                ap.client.completedGoal()
+
+                global.get_node("Messages").showMessage("You have completed your goal!")
+
+
+func handleUntriggered():
+        triggered -= 1
+        if triggered < total:
+                pass
@@ -0,0 +1,38 @@
+extends "res://scripts/nodes/listeners/visibilityListener.gd"
+
+var item_id
+var item_amount
+
+
+func _ready():
+        var node_path = String(
+                get_tree().get_root().get_node("scene").get_path_to(self).get_concatenated_names()
+        )
+
+        var gamedata = global.get_node("Gamedata")
+        var door_id = gamedata.get_door_for_map_node_path(global.map, node_path)
+        if door_id != null:
+                var ap = global.get_node("Archipelago")
+                var item_lock = ap.get_item_id_for_door(door_id)
+
+                if item_lock != null:
+                        item_id = item_lock[0]
+                        item_amount = item_lock[1]
+
+                        self.senders = []
+                        self.senderGroup = []
+                        self.nested = false
+                        self.complete_at = 0
+                        self.max_length = 0
+                        self.excludeSenders = []
+
+                        call_deferred("_readier")
+
+        super._ready()
+
+
+func _readier():
+        var ap = global.get_node("Archipelago")
+
+        if ap.client.getItemAmount(item_id) >= item_amount:
+                handleTriggered()
@@ -0,0 +1,61 @@
+extends "res://scripts/nodes/worldport.gd"
+
+var absolute_rotation = false
+var target_rotation = 0
+
+var port_id = null
+
+
+func _ready():
+        var node_path = String(
+                get_tree().get_root().get_node("scene").get_path_to(self).get_concatenated_names()
+        )
+
+        var ap = global.get_node("Archipelago")
+
+        if ap.shuffle_worldports:
+                var gamedata = global.get_node("Gamedata")
+                port_id = gamedata.get_port_for_map_node_path(global.map, node_path)
+                if port_id != null:
+                        if port_id in ap.port_pairings:
+                                var target_port = gamedata.objects.get_ports()[ap.port_pairings[port_id]]
+                                var target_room = gamedata.objects.get_rooms()[target_port.get_room_id()]
+                                var target_map = gamedata.objects.get_maps()[target_room.get_map_id()]
+
+                                exit = target_map.get_name()
+                                entry_point.x = target_port.get_destination().get_x()
+                                entry_point.y = target_port.get_destination().get_y()
+                                entry_point.z = target_port.get_destination().get_z()
+                                absolute_rotation = true
+                                target_rotation = target_port.get_rotation()
+                                sets_entry_point = true
+                                invisible = false
+                                fades = true
+                        else:
+                                port_id = null
+
+        if global.map == "icarus" and exit == "daedalus":
+                if not ap.daedalus_roof_access:
+                        entry_point = Vector3(58, 10, 0)
+
+        super._ready()
+
+
+func bodyEntered(body):
+        if body.is_in_group("player"):
+                if port_id != null:
+                        var ap = global.get_node("Archipelago")
+                        ap.client.checkWorldport(port_id)
+
+                if absolute_rotation:
+                        entry_rotate.y = target_rotation - body.rotation_degrees.y
+
+        super.bodyEntered(body)
+
+
+func changeScene():
+        var player = get_tree().get_root().get_node("scene/player")
+        if player != null:
+                player.playable = false
+
+        super.changeScene()
@@ -0,0 +1,8 @@
+extends "res://scripts/nodes/listeners/worldportListener.gd"
+
+
+func handleTriggered():
+        if exit == "menus/credits":
+                return
+
+        super.handleTriggered()
@@ -0,0 +1,630 @@
+import asyncio
+import os
+import pkgutil
+import subprocess
+import sys
+from typing import Any
+
+import websockets
+
+import Utils
+import settings
+from BaseClasses import ItemClassification
+from CommonClient import CommonContext, server_loop, gui_enabled, logger, get_base_parser, handle_url_arg
+from NetUtils import Endpoint, decode, encode, ClientStatus
+from Utils import async_start
+from . import Lingo2World
+from .tracker import Tracker
+
+ALL_LETTERS = "abcdefghijklmnopqrstuvwxyz"
+MESSAGE_MAX_SIZE = 16*1024*1024
+PORT = 43182
+
+KEY_STORAGE_MAPPING = {
+    "a": (1, 0), "b": (1, 1), "c": (1, 2), "d": (1, 3), "e": (1, 4), "f": (1, 5), "g": (1, 6), "h": (1, 7), "i": (1, 8),
+    "j": (1, 9), "k": (1, 10), "l": (1, 11), "m": (1, 12), "n": (2, 0), "o": (2, 1), "p": (2, 2), "q": (2, 3),
+    "r": (2, 4), "s": (2, 5), "t": (2, 6), "u": (2, 7), "v": (2, 8), "w": (2, 9), "x": (2, 10), "y": (2, 11),
+    "z": (2, 12),
+}
+
+REVERSE_KEY_STORAGE_MAPPING = {t: k for k, t in KEY_STORAGE_MAPPING.items()}
+
+
+class Lingo2Manager:
+    game_ctx: "Lingo2GameContext"
+    client_ctx: "Lingo2ClientContext"
+    tracker: Tracker
+
+    keyboard: dict[str, int]
+    worldports: set[int]
+    goaled: bool
+
+    def __init__(self, game_ctx: "Lingo2GameContext", client_ctx: "Lingo2ClientContext"):
+        self.game_ctx = game_ctx
+        self.game_ctx.manager = self
+        self.client_ctx = client_ctx
+        self.client_ctx.manager = self
+        self.tracker = Tracker(self)
+        self.keyboard = {}
+        self.worldports = set()
+
+        self.reset()
+
+    def reset(self):
+        for k in ALL_LETTERS:
+            self.keyboard[k] = 0
+
+        self.worldports = set()
+        self.goaled = False
+
+    def update_keyboard(self, new_keyboard: dict[str, int]) -> dict[str, int]:
+        ret: dict[str, int] = {}
+
+        for k, v in new_keyboard.items():
+            if v > self.keyboard.get(k, 0):
+                self.keyboard[k] = v
+                ret[k] = v
+
+        if len(ret) > 0:
+            self.tracker.refresh_state()
+            self.game_ctx.send_accessible_locations()
+
+        return ret
+
+    def update_worldports(self, new_worldports: set[int]) -> set[int]:
+        ret = new_worldports.difference(self.worldports)
+        self.worldports.update(new_worldports)
+
+        if len(ret) > 0:
+            self.tracker.refresh_state()
+            self.game_ctx.send_accessible_locations()
+
+        return ret
+
+
+class Lingo2GameContext:
+    server: Endpoint | None
+    manager: Lingo2Manager
+
+    def __init__(self):
+        self.server = None
+
+    def send_connected(self):
+        if self.server is None:
+            return
+
+        msg = {
+            "cmd": "Connected",
+            "user": self.manager.client_ctx.username,
+            "seed_name": self.manager.client_ctx.seed_name,
+            "version": self.manager.client_ctx.server_version,
+            "generator_version": self.manager.client_ctx.generator_version,
+            "team": self.manager.client_ctx.team,
+            "slot": self.manager.client_ctx.slot,
+            "checked_locations": self.manager.client_ctx.checked_locations,
+            "slot_data": self.manager.client_ctx.slot_data,
+        }
+
+        async_start(self.send_msgs([msg]), name="game Connected")
+
+    def send_connection_refused(self, text):
+        if self.server is None:
+            return
+
+        msg = {
+            "cmd": "ConnectionRefused",
+            "text": text,
+        }
+
+        async_start(self.send_msgs([msg]), name="game ConnectionRefused")
+
+    def send_item_sent_notification(self, item_name, receiver_name, item_flags):
+        if self.server is None:
+            return
+
+        msg = {
+            "cmd": "ItemSentNotif",
+            "item_name": item_name,
+            "receiver_name": receiver_name,
+            "item_flags": item_flags,
+        }
+
+        async_start(self.send_msgs([msg]), name="item sent notif")
+
+    def send_hint_received(self, item_name, location_name, receiver_name, item_flags, for_self):
+        if self.server is None:
+            return
+
+        msg = {
+            "cmd": "HintReceived",
+            "item_name": item_name,
+            "location_name": location_name,
+            "receiver_name": receiver_name,
+            "item_flags": item_flags,
+            "self": int(for_self),
+        }
+
+        async_start(self.send_msgs([msg]), name="hint received notif")
+
+    def send_item_received(self, items):
+        if self.server is None:
+            return
+
+        msg = {
+            "cmd": "ItemReceived",
+            "items": items,
+        }
+
+        async_start(self.send_msgs([msg]), name="item received")
+
+    def send_location_info(self, locations):
+        if self.server is None:
+            return
+
+        msg = {
+            "cmd": "LocationInfo",
+            "locations": locations,
+        }
+
+        async_start(self.send_msgs([msg]), name="location info")
+
+    def send_text_message(self, parts):
+        if self.server is None:
+            return
+
+        msg = {
+            "cmd": "TextMessage",
+            "data": parts,
+        }
+
+        async_start(self.send_msgs([msg]), name="notif")
+
+    def send_accessible_locations(self):
+        if self.server is None:
+            return
+
+        msg = {
+            "cmd": "AccessibleLocations",
+            "locations": list(self.manager.tracker.accessible_locations),
+        }
+
+        if len(self.manager.tracker.accessible_worldports) > 0:
+            msg["worldports"] = list(self.manager.tracker.accessible_worldports)
+
+        if self.manager.tracker.goal_accessible and not self.manager.goaled:
+            msg["goal"] = True
+
+        async_start(self.send_msgs([msg]), name="accessible locations")
+
+    def send_update_locations(self, locations):
+        if self.server is None:
+            return
+
+        msg = {
+            "cmd": "UpdateLocations",
+            "locations": locations,
+        }
+
+        async_start(self.send_msgs([msg]), name="update locations")
+
+    def send_update_keyboard(self, updates):
+        if self.server is None:
+            return
+
+        msg = {
+            "cmd": "UpdateKeyboard",
+            "updates": updates,
+        }
+
+        async_start(self.send_msgs([msg]), name="update keyboard")
+
+    def send_update_worldports(self, worldports):
+        if self.server is None:
+            return
+
+        msg = {
+            "cmd": "UpdateWorldports",
+            "worldports": worldports,
+        }
+
+        async_start(self.send_msgs([msg]), name="update worldports")
+
+    async def send_msgs(self, msgs: list[Any]) -> None:
+        """ `msgs` JSON serializable """
+        if not self.server or not self.server.socket.open or self.server.socket.closed:
+            return
+        await self.server.socket.send(encode(msgs))
+
+
+class Lingo2ClientContext(CommonContext):
+    manager: Lingo2Manager
+
+    game = "Lingo 2"
+    items_handling = 0b111
+
+    slot_data: dict[str, Any] | None
+    victory_data_storage_key: str
+
+    def __init__(self, server_address: str | None = None, password: str | None = None):
+        super().__init__(server_address, password)
+
+    def make_gui(self):
+        ui = super().make_gui()
+        ui.base_title = "Archipelago Lingo 2 Client"
+        return ui
+
+    async def server_auth(self, password_requested: bool = False):
+        if password_requested:
+            if self.password is None:
+                self.manager.game_ctx.send_connection_refused("Slot requires a password.")
+            else:
+                self.manager.game_ctx.send_connection_refused("Invalid password.")
+        else:
+            self.auth = self.username
+            await self.send_connect()
+
+    def handle_connection_loss(self, msg: str):
+        super().handle_connection_loss(msg)
+
+        exc_info = sys.exc_info()
+        self.manager.game_ctx.send_connection_refused(str(exc_info[1]))
+
+    def on_package(self, cmd: str, args: dict):
+        if cmd == "RoomInfo":
+            self.seed_name = args.get("seed_name", None)
+        elif cmd == "Connected":
+            self.slot_data = args.get("slot_data", None)
+
+            self.manager.reset()
+
+            self.manager.game_ctx.send_connected()
+
+            self.manager.tracker.setup_slot(self.slot_data)
+            self.manager.tracker.set_checked_locations(self.checked_locations)
+            self.manager.game_ctx.send_accessible_locations()
+
+            self.victory_data_storage_key = f"_read_client_status_{self.team}_{self.slot}"
+
+            self.set_notify(self.get_datastorage_key("keyboard1"), self.get_datastorage_key("keyboard2"),
+                            self.victory_data_storage_key)
+            msg_batch = [{
+                "cmd": "Set",
+                "key": self.get_datastorage_key("keyboard1"),
+                "default": 0,
+                "want_reply": True,
+                "operations": [{"operation": "default", "value": 0}]
+            }, {
+                "cmd": "Set",
+                "key": self.get_datastorage_key("keyboard2"),
+                "default": 0,
+                "want_reply": True,
+                "operations": [{"operation": "default", "value": 0}]
+            }]
+
+            if self.slot_data.get("shuffle_worldports", False):
+                self.set_notify(self.get_datastorage_key("worldports"))
+                msg_batch.append({
+                    "cmd": "Set",
+                    "key": self.get_datastorage_key("worldports"),
+                    "default": [],
+                    "want_reply": True,
+                    "operations": [{"operation": "default", "value": []}]
+                })
+
+            async_start(self.send_msgs(msg_batch), name="default keys")
+        elif cmd == "RoomUpdate":
+            if "checked_locations" in args:
+                self.manager.tracker.set_checked_locations(self.checked_locations)
+                self.manager.game_ctx.send_update_locations(args["checked_locations"])
+        elif cmd == "ReceivedItems":
+            self.manager.tracker.set_collected_items(self.items_received)
+
+            cur_index = 0
+            items = []
+
+            for item in args["items"]:
+                index = cur_index + args["index"]
+                cur_index += 1
+
+                item_msg = {
+                    "id": item.item,
+                    "index": index,
+                    "flags": item.flags,
+                    "text": self.item_names.lookup_in_slot(item.item, self.slot),
+                }
+
+                if item.player != self.slot:
+                    item_msg["sender"] = self.player_names.get(item.player)
+
+                items.append(item_msg)
+
+            self.manager.game_ctx.send_item_received(items)
+
+            if any(ItemClassification.progression in ItemClassification(item.flags) for item in args["items"]):
+                self.manager.game_ctx.send_accessible_locations()
+        elif cmd == "PrintJSON":
+            if "receiving" in args and "item" in args and args["item"].player == self.slot:
+                item_name = self.item_names.lookup_in_slot(args["item"].item, args["receiving"])
+                location_name = self.location_names.lookup_in_slot(args["item"].location, args["item"].player)
+                receiver_name = self.player_names.get(args["receiving"])
+
+                if args["type"] == "Hint" and not args.get("found", False):
+                    self.manager.game_ctx.send_hint_received(item_name, location_name, receiver_name, args["item"].flags,
+                                                             int(args["receiving"]) == self.slot)
+                elif args["receiving"] != self.slot:
+                    self.manager.game_ctx.send_item_sent_notification(item_name, receiver_name, args["item"].flags)
+
+            parts = []
+            for message_part in args["data"]:
+                if "type" not in message_part and "text" in message_part:
+                    parts.append({"type": "text", "text": message_part["text"]})
+                elif message_part["type"] == "player_id":
+                    parts.append({
+                        "type": "player",
+                        "text": self.player_names.get(int(message_part["text"])),
+                        "self": int(int(message_part["text"]) == self.slot),
+                    })
+                elif message_part["type"] == "item_id":
+                    parts.append({
+                        "type": "item",
+                        "text": self.item_names.lookup_in_slot(int(message_part["text"]), message_part["player"]),
+                        "flags": message_part["flags"],
+                    })
+                elif message_part["type"] == "location_id":
+                    parts.append({
+                        "type": "location",
+                        "text": self.location_names.lookup_in_slot(int(message_part["text"]),
+                                                                   message_part["player"])
+                    })
+                elif "text" in message_part:
+                    parts.append({"type": "text", "text": message_part["text"]})
+
+            self.manager.game_ctx.send_text_message(parts)
+        elif cmd == "LocationInfo":
+            locations = []
+
+            for location in args["locations"]:
+                locations.append({
+                    "id": location.location,
+                    "item": self.item_names.lookup_in_slot(location.item, location.player),
+                    "player": self.player_names.get(location.player),
+                    "flags": location.flags,
+                    "self": int(location.player) == self.slot,
+                })
+
+            self.manager.game_ctx.send_location_info(locations)
+        elif cmd == "Retrieved":
+            for k, v in args["keys"].items():
+                if k == self.victory_data_storage_key:
+                    self.handle_status_update(v)
+        elif cmd == "SetReply":
+            if args["key"] == self.get_datastorage_key("keyboard1"):
+                self.handle_keyboard_update(1, args)
+            elif args["key"] == self.get_datastorage_key("keyboard2"):
+                self.handle_keyboard_update(2, args)
+            elif args["key"] == self.get_datastorage_key("worldports"):
+                updates = self.manager.update_worldports(set(args["value"]))
+                if len(updates) > 0:
+                    self.manager.game_ctx.send_update_worldports(updates)
+            elif args["key"] == self.victory_data_storage_key:
+                self.handle_status_update(args["value"])
+
+    def get_datastorage_key(self, name: str):
+        return f"Lingo2_{self.slot}_{name}"
+
+    async def update_keyboard(self, updates: dict[str, int]):
+        kb1 = 0
+        kb2 = 0
+
+        for k, v in updates.items():
+            if v == 0:
+                continue
+
+            effect = 0
+            if v >= 1:
+                effect |= 1
+            if v == 2:
+                effect |= 2
+
+            pos = KEY_STORAGE_MAPPING[k]
+            if pos[0] == 1:
+                kb1 |= (effect << pos[1] * 2)
+            else:
+                kb2 |= (effect << pos[1] * 2)
+
+        msgs = []
+
+        if kb1 != 0:
+            msgs.append({
+                "cmd": "Set",
+                "key": self.get_datastorage_key("keyboard1"),
+                "want_reply": True,
+                "operations": [{
+                    "operation": "or",
+                    "value": kb1
+                }]
+            })
+
+        if kb2 != 0:
+            msgs.append({
+                "cmd": "Set",
+                "key": self.get_datastorage_key("keyboard2"),
+                "want_reply": True,
+                "operations": [{
+                    "operation": "or",
+                    "value": kb2
+                }]
+            })
+
+        if len(msgs) > 0:
+            await self.send_msgs(msgs)
+
+    def handle_keyboard_update(self, field: int, args: dict[str, Any]):
+        keys = {}
+        value = args["value"]
+
+        for i in range(0, 13):
+            if (value & (1 << (i * 2))) != 0:
+                keys[REVERSE_KEY_STORAGE_MAPPING[(field, i)]] = 1
+            if (value & (1 << (i * 2 + 1))) != 0:
+                keys[REVERSE_KEY_STORAGE_MAPPING[(field, i)]] = 2
+
+        updates = self.manager.update_keyboard(keys)
+        if len(updates) > 0:
+            self.manager.game_ctx.send_update_keyboard(updates)
+
+    async def update_worldports(self, updates: set[int]):
+        await self.send_msgs([{
+            "cmd": "Set",
+            "key": self.get_datastorage_key("worldports"),
+            "want_reply": True,
+            "operations": [{
+                "operation": "update",
+                "value": updates
+            }]
+        }])
+
+    def handle_status_update(self, value: int):
+        self.manager.goaled = (value == ClientStatus.CLIENT_GOAL)
+        self.manager.tracker.refresh_state()
+        self.manager.game_ctx.send_accessible_locations()
+
+
+async def pipe_loop(manager: Lingo2Manager):
+    while not manager.client_ctx.exit_event.is_set():
+        try:
+            socket = await websockets.connect("ws://localhost", port=PORT, ping_timeout=None, ping_interval=None,
+                                              max_size=MESSAGE_MAX_SIZE)
+            manager.game_ctx.server = Endpoint(socket)
+            logger.info("Connected to Lingo 2!")
+            if manager.client_ctx.auth is not None:
+                manager.game_ctx.send_connected()
+                manager.game_ctx.send_accessible_locations()
+            async for data in manager.game_ctx.server.socket:
+                for msg in decode(data):
+                    await process_game_cmd(manager, msg)
+        except ConnectionRefusedError:
+            logger.info("Could not connect to Lingo 2.")
+        finally:
+            manager.game_ctx.server = None
+
+
+async def process_game_cmd(manager: Lingo2Manager, args: dict):
+    cmd = args["cmd"]
+
+    if cmd == "Connect":
+        manager.client_ctx.seed_name = None
+
+        server = args.get("server")
+        player = args.get("player")
+        password = args.get("password")
+
+        if password != "":
+            server_address = f"{player}:{password}@{server}"
+        else:
+            server_address = f"{player}:None@{server}"
+
+        async_start(manager.client_ctx.connect(server_address), name="client connect")
+    elif cmd == "Disconnect":
+        manager.client_ctx.seed_name = None
+
+        async_start(manager.client_ctx.disconnect(), name="client disconnect")
+    elif cmd in ["Sync", "LocationChecks", "Say", "StatusUpdate", "LocationScouts"]:
+        async_start(manager.client_ctx.send_msgs([args]), name="client forward")
+    elif cmd == "UpdateKeyboard":
+        updates = manager.update_keyboard(args["keyboard"])
+        if len(updates) > 0:
+            async_start(manager.client_ctx.update_keyboard(updates), name="client update keyboard")
+    elif cmd == "CheckWorldport":
+        port_id = args["port_id"]
+        worldports = {port_id}
+        if str(port_id) in manager.client_ctx.slot_data["port_pairings"]:
+            worldports.add(manager.client_ctx.slot_data["port_pairings"][str(port_id)])
+
+        updates = manager.update_worldports(worldports)
+        if len(updates) > 0:
+            async_start(manager.client_ctx.update_worldports(updates), name="client update worldports")
+            manager.game_ctx.send_update_worldports(updates)
+    elif cmd == "Quit":
+        manager.client_ctx.exit_event.set()
+
+
+async def run_game():
+    exe_file = settings.get_settings().lingo2_options.exe_file
+
+    # This ensures we can use Steam features without having to open the game
+    # through steam.
+    steam_appid_path = os.path.join(os.path.dirname(exe_file), "steam_appid.txt")
+    with open(steam_appid_path, "w") as said_handle:
+        said_handle.write("2523310")
+
+    if Lingo2World.zip_path is not None:
+        # This is a packaged apworld.
+        init_scene = pkgutil.get_data(__name__, "client/run_from_apworld.tscn")
+        init_path = Utils.local_path("data", "lingo2_init.tscn")
+
+        with open(init_path, "wb") as file_handle:
+            file_handle.write(init_scene)
+
+        subprocess.Popen(
+            [
+                exe_file,
+                "--scene",
+                init_path,
+                "--",
+                str(Lingo2World.zip_path.absolute()),
+            ],
+            cwd=os.path.dirname(exe_file),
+        )
+    else:
+        # The world is unzipped and being run in source.
+        subprocess.Popen(
+            [
+                exe_file,
+                "--scene",
+                Utils.local_path("worlds", "lingo2", "client", "run_from_source.tscn"),
+                "--",
+                Utils.local_path("worlds", "lingo2", "client"),
+            ],
+            cwd=os.path.dirname(exe_file),
+        )
+
+
+def client_main(*launch_args: str) -> None:
+    async def main(args):
+        async_start(run_game())
+
+        client_ctx = Lingo2ClientContext(args.connect, args.password)
+        game_ctx = Lingo2GameContext()
+        manager = Lingo2Manager(game_ctx, client_ctx)
+
+        client_ctx.server_task = asyncio.create_task(server_loop(client_ctx), name="ServerLoop")
+
+        if gui_enabled:
+            client_ctx.run_gui()
+        client_ctx.run_cli()
+
+        pipe_task = asyncio.create_task(pipe_loop(manager), name="GameWatcher")
+
+        try:
+            await pipe_task
+        except Exception as e:
+            logger.exception(e)
+
+        await client_ctx.exit_event.wait()
+        client_ctx.ui.stop()
+        await client_ctx.shutdown()
+
+    Utils.init_logging("Lingo2Client", exception_logger="Client")
+    import colorama
+
+    parser = get_base_parser(description="Lingo 2 Archipelago Client")
+    parser.add_argument('--name', default=None, help="Slot Name to connect as.")
+    parser.add_argument("url", nargs="?", help="Archipelago connection url")
+    args = parser.parse_args(launch_args)
+
+    args = handle_url_arg(args, parser=parser)
+
+    colorama.just_fix_windows_console()
+    asyncio.run(main(args))
+    colorama.deinit()
@@ -0,0 +1,4 @@
+# Lingo 2
+
+See [the project README](https://code.fourisland.com/lingo2-archipelago/about/)
+for installation instructions and frequently asked questions. 
\ No newline at end of file
@@ -1,5 +1,31 @@
+from .generated import data_pb2 as data_pb2
 from BaseClasses import Item
 
 
 class Lingo2Item(Item):
     game: str = "Lingo 2"
+
+
+SYMBOL_ITEMS: dict[data_pb2.PuzzleSymbol, str] = {
+    data_pb2.PuzzleSymbol.SUN: "Sun Symbol",
+    data_pb2.PuzzleSymbol.SPARKLES: "Sparkles Symbol",
+    data_pb2.PuzzleSymbol.ZERO: "Zero Symbol",
+    data_pb2.PuzzleSymbol.EXAMPLE: "Example Symbol",
+    data_pb2.PuzzleSymbol.BOXES: "Boxes Symbol",
+    data_pb2.PuzzleSymbol.PLANET: "Planet Symbol",
+    data_pb2.PuzzleSymbol.PYRAMID: "Pyramid Symbol",
+    data_pb2.PuzzleSymbol.CROSS: "Cross Symbol",
+    data_pb2.PuzzleSymbol.SWEET: "Sweet Symbol",
+    data_pb2.PuzzleSymbol.GENDER: "Gender Symbol",
+    data_pb2.PuzzleSymbol.AGE: "Age Symbol",
+    data_pb2.PuzzleSymbol.SOUND: "Sound Symbol",
+    data_pb2.PuzzleSymbol.ANAGRAM: "Anagram Symbol",
+    data_pb2.PuzzleSymbol.JOB: "Job Symbol",
+    data_pb2.PuzzleSymbol.STARS: "Stars Symbol",
+    data_pb2.PuzzleSymbol.NULL: "Null Symbol",
+    data_pb2.PuzzleSymbol.EVAL: "Eval Symbol",
+    data_pb2.PuzzleSymbol.LINGO: "Lingo Symbol",
+    data_pb2.PuzzleSymbol.QUESTION: "Question Symbol",
+}
+
+ANTI_COLLECTABLE_TRAPS: list[str] = [f"Anti {letter}" for letter in "ABCDEFGHIJKLMNOPQRSTUVWXYZ"]
@@ -3,3 +3,6 @@ from BaseClasses import Location
 
 class Lingo2Location(Location):
     game: str = "Lingo 2"
+
+    port_id: int
+    goal: bool
@@ -1,13 +1,180 @@
 from dataclasses import dataclass
 
-from Options import PerGameCommonOptions, Toggle
+from Options import PerGameCommonOptions, Toggle, Choice, DefaultOnToggle, Range
 
 
-class ShuffleDoors(Toggle):
+class ShuffleDoors(DefaultOnToggle):
     """If enabled, most doors will open from receiving an item rather than fulfilling the in-game requirements."""
     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 ShuffleGalleryPaintings(Toggle):
+    """If enabled, gallery paintings will appear from receiving an item rather than by triggering them normally."""
+    display_name = "Shuffle Gallery Paintings"
+
+
+class ShuffleLetters(Choice):
+    """
+    Controls how letter unlocks are handled. Note that H1, I1, N1, and T1 will always be present at their vanilla
+    locations in the starting room, even if letters are shuffled remotely.
+
+    - **Vanilla**: All letters will be present at their vanilla locations.
+    - **Unlocked**: Players will start with their keyboards fully unlocked.
+    - **Progressive**: Two items will be added to the pool for every letter (one for H, I, N, and T). Receiving the
+      first item gives you the corresponding level 1 letter, and the second item gives you the corresponding level 2
+      letter.
+    - **Vanilla Cyan**: Players will start with all level 1 (purple) letters unlocked. Level 2 (cyan) letters will be
+      present at their vanilla locations.
+    - **Item Cyan**: Players will start with all level 1 (purple) letters unlocked. One item will be added to the pool
+      for every level 2 (cyan) letter.
+    """
+    display_name = "Shuffle Letters"
+    option_vanilla = 0
+    option_unlocked = 1
+    option_progressive = 2
+    option_vanilla_cyan = 3
+    option_item_cyan = 4
+
+
+class ShuffleSymbols(Toggle):
+    """
+    If enabled, 19 items will be added to the pool, representing the different symbols that can appear on a panel.
+    Players will be prevented from solving puzzles with symbols on them until all of the required symbols are unlocked.
+    """
+    display_name = "Shuffle Symbols"
+
+
+class ShuffleWorldports(Toggle):
+    """
+    Randomizes the connections between maps. This affects worldports only, which are the loading zones you walk into in
+    order to change maps. This does not affect paintings, panels that teleport you, or certain other special connections
+    like the one between The Shop and Control Center. Connections that depend on placing letters in keyholders are also
+    currently not shuffled.
+
+    NOTE: It is highly recommended that you turn on Shuffle Control Center Colors when using Shuffle Worldports. Not
+    doing so runs the risk of creating an unfinishable seed.
+    """
+    display_name = "Shuffle Worldports"
+
+
+class KeyholderSanity(Toggle):
+    """
+    If enabled, 26 locations will be created for placing each key into its respective Green Ending keyholder.
+
+    NOTE: This does not apply to the two disappearing keyholders in The Congruent, as they are not part of Green Ending.
+    """
+    display_name = "Keyholder Sanity"
+
+
+class CyanDoorBehavior(Choice):
+    """
+    Cyan-colored doors usually only open upon unlocking double letters. Some panels also only appear upon unlocking
+    double letters. This option determines how these unlocks should behave.
+
+    - **Collect H2**: In the base game, H2 is the first double letter you are intended to collect, so cyan doors only
+      open when you collect the H2 pickup in The Repetitive. Collecting the actual pickup is still required even with
+      remote letter shuffle enabled.
+    - **Any Double Letter**: Cyan doors will open when you have unlocked any cyan letter on your keyboard. In letter
+      shuffle, this means receiving a cyan letter, not picking up a cyan letter collectable.
+    - **Item**: Cyan doors will be grouped together in a single item.
+
+    Note that some cyan doors are impacted by door shuffle (e.g. the entrance to The Tower). When door shuffle is
+    enabled, these doors won't be affected by the value of this option.
+    """
+    display_name = "Cyan Door Behavior"
+    option_collect_h2 = 0
+    option_any_double_letter = 1
+    option_item = 2
+
+
+class DaedalusRoofAccess(Toggle):
+    """
+    If enabled, the player will be logically expected to be able to go from the castle entrance to any part of Daedalus
+    that is open to the air. If disabled, the player will only be expected to be able to enter the castle, the moat,
+    Icarus, and the area at the bottom of the stairs. Invisible walls that become opaque as you approach them are added
+    to the level to prevent the player from accidentally breaking logic.
+    """
+    display_name = "Allow Daedalus Roof Access"
+
+
+class StrictPurpleEnding(DefaultOnToggle):
+    """
+    If enabled, the player will be required to have all purple (level 1) letters in order to get Purple Ending.
+    Otherwise, some of the letters may be skippable depending on the other options.
+    """
+    display_name = "Strict Purple Ending"
+
+
+class StrictCyanEnding(DefaultOnToggle):
+    """
+    If enabled, the player will be required to have all cyan (level 2) letters in order to get Cyan Ending. Otherwise,
+    at least J2, Q2, and V2 are skippable. Others may also be skippable depending on the options chosen.
+    """
+    display_name = "Strict Cyan Ending"
+
+
+class VictoryCondition(Choice):
+    """
+    This option determines what your goal is.
+    
+    - **Gray Ending** (The Colorful)
+    - **Purple Ending** (The Sun Temple). This ordinarily requires all level 1 (purple) letters.
+    - **Mint Ending** (typing EXIT into the keyholders in Control Center)
+    - **Black Ending** (The Graveyard)
+    - **Blue Ending** (The Words)
+    - **Cyan Ending** (The Parthenon). This ordinarily requires almost all level 2 (cyan) letters.
+    - **Red Ending** (The Tower)
+    - **Plum Ending** (The Wondrous / The Door)
+    - **Orange Ending** (the castle in Daedalus)
+    - **Gold Ending** (The Gold). This involves going through the color rooms in Daedalus.
+    - **Yellow Ending** (The Gallery). This requires unlocking all gallery paintings.
+    - **Green Ending** (The Ancient). This requires filling all keyholders with specific letters.
+    - **White Ending** (Control Center). This combines every other ending.
+    """
+    display_name = "Victory Condition"
+    option_gray_ending = 0
+    option_purple_ending = 1
+    option_mint_ending = 2
+    option_black_ending = 3
+    option_blue_ending = 4
+    option_cyan_ending = 5
+    option_red_ending = 6
+    option_plum_ending = 7
+    option_orange_ending = 8
+    option_gold_ending = 9
+    option_yellow_ending = 10
+    option_green_ending = 11
+    option_white_ending = 12
+
+
+class TrapPercentage(Range):
+    """Replaces junk items with traps, at the specified rate."""
+    display_name = "Trap Percentage"
+    range_start = 0
+    range_end = 100
+    default = 0
+
+
 @dataclass
 class Lingo2Options(PerGameCommonOptions):
     shuffle_doors: ShuffleDoors
+    shuffle_control_center_colors: ShuffleControlCenterColors
+    shuffle_gallery_paintings: ShuffleGalleryPaintings
+    shuffle_letters: ShuffleLetters
+    shuffle_symbols: ShuffleSymbols
+    shuffle_worldports: ShuffleWorldports
+    keyholder_sanity: KeyholderSanity
+    cyan_door_behavior: CyanDoorBehavior
+    daedalus_roof_access: DaedalusRoofAccess
+    strict_purple_ending: StrictPurpleEnding
+    strict_cyan_ending: StrictCyanEnding
+    victory_condition: VictoryCondition
+    trap_percentage: TrapPercentage
@@ -1,6 +1,11 @@
+from enum import IntEnum, auto
+
 from .generated import data_pb2 as data_pb2
+from .items import SYMBOL_ITEMS
 from typing import TYPE_CHECKING, NamedTuple
 
+from .options import VictoryCondition, ShuffleLetters, CyanDoorBehavior
+
 if TYPE_CHECKING:
     from . import Lingo2World
 
@@ -10,60 +15,197 @@ def calculate_letter_histogram(solution: str) -> dict[str, int]:
     for l in solution:
         if l.isalpha():
             real_l = l.upper()
-            histogram[real_l] = min(histogram.get(l, 0) + 1, 2)
+            histogram[real_l] = min(histogram.get(real_l, 0) + 1, 2)
 
     return histogram
 
 
 class AccessRequirements:
     items: set[str]
+    progressives: dict[str, int]
     rooms: set[str]
-    symbols: 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.symbols = set()
         self.letters = dict()
+        self.cyans = False
         self.or_logic = list()
+        self.complete_at = None
+        self.possibilities = list()
 
-    def add_solution(self, solution: str):
-        histogram = calculate_letter_histogram(solution)
-
-        for l, a in histogram.items():
-            self.letters[l] = max(self.letters.get(l, 0), histogram.get(l))
+    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 symbol in other.symbols:
-            self.symbols.add(symbol)
-
         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(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 = 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 = other.possibilities
+                self.or_logic.append([right_req])
+            else:
+                self.complete_at = other.complete_at
+                self.possibilities = 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
 
 
+class LetterBehavior(IntEnum):
+    VANILLA = auto()
+    ITEM = auto()
+    UNLOCKED = auto()
+
+
 class Lingo2PlayerLogic:
     world: "Lingo2World"
 
     locations_by_room: dict[int, list[PlayerLocation]]
-    item_by_door: dict[int, str]
+    event_loc_item_by_room: dict[int, dict[str, str]]
+
+    item_by_door: dict[int, tuple[str, int]]
 
     panel_reqs: dict[int, AccessRequirements]
     proxy_reqs: dict[int, dict[str, AccessRequirements]]
@@ -71,22 +213,79 @@ class Lingo2PlayerLogic:
 
     real_items: list[str]
 
+    double_letter_amount: dict[str, int]
+
     def __init__(self, world: "Lingo2World"):
         self.world = world
         self.locations_by_room = {}
+        self.event_loc_item_by_room = {}
         self.item_by_door = {}
         self.panel_reqs = dict()
         self.proxy_reqs = dict()
         self.door_reqs = dict()
         self.real_items = list()
+        self.double_letter_amount = dict()
+
+        if self.world.options.shuffle_doors:
+            for progressive in world.static_logic.objects.progressives:
+                for i in range(0, len(progressive.doors)):
+                    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:
+                if not self.world.options.shuffle_doors or self.world.options.shuffle_worldports:
+                    continue
+            elif door_group.type == data_pb2.DoorGroupType.COLOR_CONNECTOR:
+                if not self.world.options.shuffle_control_center_colors or self.world.options.shuffle_worldports:
+                    continue
+            elif door_group.type == data_pb2.DoorGroupType.SHUFFLE_GROUP:
+                if not self.world.options.shuffle_doors:
+                    continue
+            else:
+                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:
-                door_item_name = self.world.static_logic.get_door_item_name(door.id)
-                self.item_by_door[door.id] = door_item_name
-                self.real_items.append(door_item_name)
+            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
+
+            if door.type == data_pb2.DoorType.GALLERY_PAINTING and not self.world.options.shuffle_gallery_paintings:
+                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)
+
+        # We handle cyan_door_behavior = Item after door shuffle, because cyan doors that are impacted by door shuffle
+        # should be exempt from cyan_door_behavior.
+        if world.options.cyan_door_behavior == CyanDoorBehavior.option_item:
+            for door_group in world.static_logic.objects.door_groups:
+                if door_group.type != data_pb2.DoorGroupType.CYAN_DOORS:
+                    continue
+
+                for door in door_group.doors:
+                    if not door in self.item_by_door:
+                        self.item_by_door[door] = (door_group.name, 1)
+
+                self.real_items.append(door_group.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]:
@@ -96,14 +295,55 @@ class Lingo2PlayerLogic:
         for letter in world.static_logic.objects.letters:
             self.locations_by_room.setdefault(letter.room_id, []).append(PlayerLocation(letter.ap_id,
                                                                                         AccessRequirements()))
+            behavior = self.get_letter_behavior(letter.key, letter.level2)
+            if behavior == LetterBehavior.VANILLA:
+                if not world.for_tracker:
+                    letter_name = f"{letter.key.upper()}{'2' if letter.level2 else '1'}"
+                    event_name = f"{letter_name} (Collected)"
+                    self.event_loc_item_by_room.setdefault(letter.room_id, {})[event_name] = letter.key.upper()
+
+                    if letter.level2:
+                        event_name = f"{letter_name} (Double Collected)"
+                        self.event_loc_item_by_room.setdefault(letter.room_id, {})[event_name] = letter.key.upper()
+            elif behavior == LetterBehavior.ITEM:
+                self.real_items.append(letter.key.upper())
+
+            if behavior != LetterBehavior.UNLOCKED:
+                self.double_letter_amount[letter.key.upper()] = self.double_letter_amount.get(letter.key.upper(), 0) + 1
 
         for mastery in world.static_logic.objects.masteries:
             self.locations_by_room.setdefault(mastery.room_id, []).append(PlayerLocation(mastery.ap_id,
                                                                                          AccessRequirements()))
 
         for ending in world.static_logic.objects.endings:
-            self.locations_by_room.setdefault(ending.room_id, []).append(PlayerLocation(ending.ap_id,
-                                                                                        AccessRequirements()))
+            # Don't create a location for your selected ending, and never create a location for White Ending.
+            if world.options.victory_condition.current_key.removesuffix("_ending").upper() != ending.name\
+                    and ending.name != "WHITE":
+                self.locations_by_room.setdefault(ending.room_id, []).append(PlayerLocation(ending.ap_id,
+                                                                                            AccessRequirements()))
+
+            event_name = f"{ending.name.capitalize()} Ending (Achieved)"
+            item_name = event_name
+
+            if world.options.victory_condition.current_key.removesuffix("_ending").upper() == ending.name:
+                item_name = "Victory"
+
+            self.event_loc_item_by_room.setdefault(ending.room_id, {})[event_name] = item_name
+
+        if self.world.options.keyholder_sanity:
+            for keyholder in world.static_logic.objects.keyholders:
+                if keyholder.HasField("key"):
+                    reqs = AccessRequirements()
+
+                    if self.get_letter_behavior(keyholder.key, False) != LetterBehavior.UNLOCKED:
+                        reqs.letters[keyholder.key.upper()] = 1
+
+                    self.locations_by_room.setdefault(keyholder.room_id, []).append(PlayerLocation(keyholder.ap_id,
+                                                                                                   reqs))
+
+        if self.world.options.shuffle_symbols:
+            for symbol_name in SYMBOL_ITEMS.values():
+                self.real_items.append(symbol_name)
 
     def get_panel_reqs(self, panel_id: int, answer: str | None) -> AccessRequirements:
         if answer is None:
@@ -124,18 +364,38 @@ class Lingo2PlayerLogic:
         reqs.rooms.add(self.world.static_logic.get_room_region_name(panel.room_id))
 
         if answer is not None:
-            reqs.add_solution(answer)
+            self.add_solution_reqs(reqs, answer)
         elif len(panel.proxies) > 0:
+            possibilities = []
+            already_filled = False
+
             for proxy in panel.proxies:
                 proxy_reqs = AccessRequirements()
-                proxy_reqs.add_solution(proxy.answer)
+                self.add_solution_reqs(proxy_reqs, proxy.answer)
+
+                if not proxy_reqs.is_empty():
+                    possibilities.append(proxy_reqs)
+                else:
+                    already_filled = True
+                    break
+
+            if not already_filled and not any(proxy.answer == panel.answer for proxy in panel.proxies):
+                proxy_reqs = AccessRequirements()
+                self.add_solution_reqs(proxy_reqs, panel.answer)
 
-                reqs.or_logic.append([proxy_reqs])
+                if not proxy_reqs.is_empty():
+                    possibilities.append(proxy_reqs)
+                else:
+                    already_filled = True
+
+            if not already_filled:
+                reqs.or_logic.append(possibilities)
         else:
-            reqs.add_solution(panel.answer)
+            self.add_solution_reqs(reqs, panel.answer)
 
-        for symbol in panel.symbols:
-            reqs.symbols.add(symbol)
+        if self.world.options.shuffle_symbols:
+            for symbol in panel.symbols:
+                reqs.items.add(SYMBOL_ITEMS.get(symbol))
 
         if panel.HasField("required_door"):
             door_reqs = self.get_door_open_reqs(panel.required_door)
@@ -158,32 +418,67 @@ class Lingo2PlayerLogic:
         door = self.world.static_logic.objects.doors[door_id]
         reqs = AccessRequirements()
 
-        use_item = False
-        if door.type in [data_pb2.DoorType.STANDARD, data_pb2.DoorType.ITEM_ONLY] and self.world.options.shuffle_doors:
-            use_item = True
-
-        if use_item:
-            reqs.items.add(self.world.static_logic.get_door_item_name(door.id))
+        if not door.HasField("complete_at") or door.complete_at == 0:
+            for proxy in door.panels:
+                panel_reqs = self.get_panel_reqs(proxy.panel, proxy.answer if proxy.HasField("answer") else None)
+                reqs.merge(panel_reqs)
+        elif door.complete_at == 1:
+            disjunction = []
+            for proxy in door.panels:
+                proxy_reqs = self.get_panel_reqs(proxy.panel, proxy.answer if proxy.HasField("answer") else None)
+                if proxy_reqs.is_empty():
+                    disjunction.clear()
+                    break
+                else:
+                    disjunction.append(proxy_reqs)
+            if len(disjunction) > 0:
+                reqs.or_logic.append(disjunction)
         else:
-            # TODO: complete_at, control_center_color, switches, keyholders
-            if not door.HasField("complete_at") or door.complete_at == 0:
-                for proxy in door.panels:
-                    panel_reqs = self.get_panel_reqs(proxy.panel, proxy.answer if proxy.HasField("answer") else None)
-                    reqs.merge(panel_reqs)
-            elif door.complete_at == 1:
-                reqs.or_logic.append([self.get_panel_reqs(proxy.panel,
-                                                          proxy.answer if proxy.HasField("answer") else None)
-                                      for proxy in door.panels])
-            else:
-                # TODO: Handle complete_at > 1
+            reqs.complete_at = door.complete_at
+            for proxy in door.panels:
+                panel_reqs = self.get_panel_reqs(proxy.panel, proxy.answer if proxy.HasField("answer") else None)
+                reqs.possibilities.append(panel_reqs)
+
+        if door.HasField("control_center_color"):
+            # TODO: Logic for ensuring two CC states aren't needed at once.
+            reqs.rooms.add("Control Center - Main Area")
+            self.add_solution_reqs(reqs, door.control_center_color)
+
+        if door.double_letters:
+            if self.world.options.cyan_door_behavior == CyanDoorBehavior.option_collect_h2:
+                reqs.rooms.add("The Repetitive - Main Room")
+            elif self.world.options.cyan_door_behavior == CyanDoorBehavior.option_any_double_letter:
+                if self.world.options.shuffle_letters != ShuffleLetters.option_unlocked:
+                    reqs.cyans = True
+            elif self.world.options.cyan_door_behavior == CyanDoorBehavior.option_item:
+                # There shouldn't be any locations that are cyan doors.
                 pass
 
-            for room in door.rooms:
-                reqs.rooms.add(self.world.static_logic.get_room_region_name(room))
+        for keyholder_uses in door.keyholders:
+            key_name = keyholder_uses.key.upper()
+            if (self.get_letter_behavior(keyholder_uses.key, False) != LetterBehavior.UNLOCKED
+                    and key_name not in reqs.letters):
+                reqs.letters[key_name] = 1
+
+            keyholder = self.world.static_logic.objects.keyholders[keyholder_uses.keyholder]
+            reqs.rooms.add(self.world.static_logic.get_room_region_name(keyholder.room_id))
+
+        for room in door.rooms:
+            reqs.rooms.add(self.world.static_logic.get_room_region_name(room))
+
+        for ending_id in door.endings:
+            ending = self.world.static_logic.objects.endings[ending_id]
+
+            if self.world.options.victory_condition.current_key.removesuffix("_ending").upper() == ending.name:
+                reqs.items.add("Victory")
+            else:
+                reqs.items.add(f"{ending.name.capitalize()} Ending (Achieved)")
+
+        for sub_door_id in door.doors:
+            sub_reqs = self.get_door_open_reqs(sub_door_id)
+            reqs.merge(sub_reqs)
 
-            for sub_door_id in door.doors:
-                sub_reqs = self.get_door_open_reqs(sub_door_id)
-                reqs.merge(sub_reqs)
+        reqs.simplify()
 
         return reqs
 
@@ -192,8 +487,50 @@ class Lingo2PlayerLogic:
     def get_door_open_reqs(self, door_id: int) -> AccessRequirements:
         if door_id in self.item_by_door:
             reqs = AccessRequirements()
-            reqs.items.add(self.item_by_door.get(door_id))
+
+            item_name, amount = self.item_by_door.get(door_id)
+            if amount == 1:
+                reqs.items.add(item_name)
+            else:
+                reqs.progressives[item_name] = amount
 
             return reqs
         else:
             return self.get_door_reqs(door_id)
+
+    def get_letter_behavior(self, letter: str, level2: bool) -> LetterBehavior:
+        if self.world.options.shuffle_letters == ShuffleLetters.option_unlocked:
+            return LetterBehavior.UNLOCKED
+
+        if self.world.options.shuffle_letters in [ShuffleLetters.option_vanilla_cyan, ShuffleLetters.option_item_cyan]:
+            if level2:
+                if self.world.options.shuffle_letters == ShuffleLetters.option_vanilla_cyan:
+                    return LetterBehavior.VANILLA
+                else:
+                    return LetterBehavior.ITEM
+            else:
+                return LetterBehavior.UNLOCKED
+
+        if not level2 and letter in ["h", "i", "n", "t"]:
+            return LetterBehavior.UNLOCKED
+
+        if self.world.options.shuffle_letters == ShuffleLetters.option_progressive:
+            return LetterBehavior.ITEM
+
+        return LetterBehavior.VANILLA
+
+    def add_solution_reqs(self, reqs: AccessRequirements, solution: str):
+        histogram = calculate_letter_histogram(solution)
+
+        for l, a in histogram.items():
+            needed = min(a, 2)
+            level2 = (needed == 2)
+
+            if level2 and self.get_letter_behavior(l.lower(), True) == LetterBehavior.UNLOCKED:
+                needed = 1
+
+            if self.get_letter_behavior(l.lower(), False) == LetterBehavior.UNLOCKED:
+                needed = needed - 1
+
+            if needed > 0:
+                reqs.letters[l] = max(reqs.letters.get(l, 0), needed)
@@ -1,6 +1,9 @@
 from typing import TYPE_CHECKING
 
-from BaseClasses import Region
+import BaseClasses
+from BaseClasses import Region, ItemClassification, Entrance
+from entrance_rando import randomize_entrances
+from .items import Lingo2Item
 from .locations import Lingo2Location
 from .player_logic import AccessRequirements
 from .rules import make_location_lambda
@@ -10,15 +13,42 @@ if TYPE_CHECKING:
 
 
 def create_region(room, world: "Lingo2World") -> Region:
-    new_region = Region(world.static_logic.get_room_region_name(room.id), world.player, world.multiworld)
+    return Region(world.static_logic.get_room_region_name(room.id), world.player, world.multiworld)
 
+
+def create_locations(room, new_region: Region, world: "Lingo2World", regions: dict[str, Region]):
     for location in world.player_logic.locations_by_room.get(room.id, {}):
+        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(location.reqs, world)
+        new_location.access_rule = make_location_lambda(reqs, world, regions)
+        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)
+        if world.for_tracker and item_name == "Victory":
+            new_location.goal = True
+
+        event_item = Lingo2Item(item_name, ItemClassification.progression, None, world.player)
+        new_location.place_locked_item(event_item)
         new_region.locations.append(new_location)
 
-    return new_region
+    if world.for_tracker and world.options.shuffle_worldports:
+        for port_id in room.ports:
+            port = world.static_logic.objects.ports[port_id]
+            if port.no_shuffle:
+                continue
+
+            new_location = Lingo2Location(world.player, f"Worldport {port.id} Entered", None, 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_region.locations.append(new_location)
 
 
 def create_regions(world: "Lingo2World"):
@@ -26,16 +56,34 @@ def create_regions(world: "Lingo2World"):
         "Menu": Region("Menu", world.player, world.multiworld)
     }
 
+    region_and_room = []
+
+    # Create the regions in two stages. First, make the actual region objects and memoize them. Then, add all of the
+    # locations. This allows us to reference the actual region objects in the access rules for the locations, which is
+    # faster than having to look them up during access checking.
     for room in world.static_logic.objects.rooms:
         region = create_region(room, world)
         regions[region.name] = region
+        region_and_room.append((region, room))
+
+    for (region, room) in region_and_room:
+        create_locations(room, region, world, regions)
 
     regions["Menu"].connect(regions["The Entry - Starting Room"], "Start Game")
 
-    # TODO: The requirements of the opposite trigger also matter.
     for connection in world.static_logic.objects.connections:
+        if connection.roof_access and not world.options.daedalus_roof_access:
+            continue
+
+        if connection.vanilla_only and world.options.shuffle_doors:
+            continue
+
         from_region = world.static_logic.get_room_region_name(connection.from_room)
         to_region = world.static_logic.get_room_region_name(connection.to_room)
+
+        if from_region not in regions or to_region not in regions:
+            continue
+
         connection_name = f"{from_region} -> {to_region}"
 
         reqs = AccessRequirements()
@@ -51,6 +99,9 @@ def create_regions(world: "Lingo2World"):
             port = world.static_logic.objects.ports[connection.port]
             connection_name = f"{connection_name} (via port {port.name})"
 
+            if world.options.shuffle_worldports and not port.no_shuffle:
+                continue
+
             if port.HasField("required_door"):
                 reqs.merge(world.player_logic.get_door_open_reqs(port.required_door))
 
@@ -72,7 +123,93 @@ def create_regions(world: "Lingo2World"):
             else:
                 connection_name = f"{connection_name} (via panel {panel.name})"
 
-        if from_region in regions and to_region in regions:
-            regions[from_region].connect(regions[to_region], connection_name, make_location_lambda(reqs, world))
+        if connection.HasField("purple_ending") and connection.purple_ending and world.options.strict_purple_ending:
+            world.player_logic.add_solution_reqs(reqs, "abcdefghijklmnopqrstuvwxyz")
+
+        if connection.HasField("cyan_ending") and connection.cyan_ending and world.options.strict_cyan_ending:
+            world.player_logic.add_solution_reqs(reqs, "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz")
+
+        reqs.simplify()
+        reqs.remove_room(from_region)
+
+        connection = Entrance(world.player, connection_name, regions[from_region])
+        connection.access_rule = make_location_lambda(reqs, world, regions)
+
+        regions[from_region].exits.append(connection)
+        connection.connect(regions[to_region])
+
+        for region in reqs.get_referenced_rooms():
+            world.multiworld.register_indirect_condition(regions[region], connection)
 
     world.multiworld.regions += regions.values()
+
+
+def shuffle_entrances(world: "Lingo2World"):
+    er_entrances: list[Entrance] = []
+    er_exits: list[Entrance] = []
+
+    port_id_by_name: dict[str, int] = {}
+
+    for port in world.static_logic.objects.ports:
+        if port.no_shuffle:
+            continue
+
+        port_region_name = world.static_logic.get_room_region_name(port.room_id)
+        port_region = world.multiworld.get_region(port_region_name, world.player)
+
+        connection_name = f"{port_region_name} - {port.name}"
+        port_id_by_name[connection_name] = port.id
+
+        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.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)
+
+            for region in door_reqs.get_referenced_rooms():
+                world.multiworld.register_indirect_condition(world.multiworld.get_region(region, world.player),
+                                                             er_exit)
+
+        er_entrances.append(entrance)
+        er_exits.append(er_exit)
+
+    result = randomize_entrances(world, True, {0:[0]}, False, er_entrances,
+                                 er_exits)
+
+    for (f, to) in result.pairings:
+        world.port_pairings[port_id_by_name[f]] = port_id_by_name[to]
+
+
+def connect_ports_from_ut(port_pairings: dict[int, int], world: "Lingo2World"):
+    for fpid, tpid in port_pairings.items():
+        from_port = world.static_logic.objects.ports[fpid]
+        to_port = world.static_logic.objects.ports[tpid]
+
+        from_region_name = world.static_logic.get_room_region_name(from_port.room_id)
+        to_region_name = world.static_logic.get_room_region_name(to_port.room_id)
+
+        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.name}", from_region)
+
+        reqs = AccessRequirements()
+        if from_port.HasField("required_door"):
+            reqs = world.player_logic.get_door_open_reqs(from_port.required_door).copy()
+
+        if world.for_tracker:
+            reqs.items.add(f"Worldport {fpid} Entered")
+
+        if not reqs.is_empty():
+            connection.access_rule = make_location_lambda(reqs, world, None)
+
+            for region in reqs.get_referenced_rooms():
+                world.multiworld.register_indirect_condition(world.multiworld.get_region(region, world.player),
+                                                             connection)
+
+        from_region.exits.append(connection)
+        connection.connect(to_region)
@@ -1 +1 @@
-protobuf>=5.29.3
\ No newline at end of file
+protobuf==3.20.3
@@ -1,27 +1,66 @@
 from collections.abc import Callable
 from typing import TYPE_CHECKING
 
-from BaseClasses import CollectionState
+from BaseClasses import CollectionState, Region
 from .player_logic import AccessRequirements
 
 if TYPE_CHECKING:
     from . import Lingo2World
 
 
-def lingo2_can_satisfy_requirements(state: CollectionState, reqs: AccessRequirements, world: "Lingo2World") -> bool:
+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
 
+    if not all(state.has(item, world.player, amount) for item, amount in reqs.progressives.items()):
+        return False
+
     if not all(state.can_reach_region(region_name, world.player) for region_name in reqs.rooms):
         return False
 
-    # TODO: symbols, letters
+    if not all(state.can_reach(region) for region in regions):
+        return False
+
+    for letter_key, letter_level in reqs.letters.items():
+        if not state.has(letter_key, world.player, letter_level):
+            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()):
+            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):
+            return False
 
-    for disjunction in reqs.or_logic:
-        if not any(lingo2_can_satisfy_requirements(state, sub_reqs, world) for sub_reqs in disjunction):
+    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.
+                return False
+        if completed < reqs.complete_at:
             return False
 
     return True
 
-def make_location_lambda(reqs: AccessRequirements, world: "Lingo2World") -> Callable[[CollectionState], bool]:
-    return lambda state: lingo2_can_satisfy_requirements(state, reqs, world)
+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)
@@ -1,6 +1,8 @@
 from .generated import data_pb2 as data_pb2
+from .items import SYMBOL_ITEMS, ANTI_COLLECTABLE_TRAPS
 import pkgutil
 
+
 class Lingo2StaticLogic:
     item_id_to_name: dict[int, str]
     location_id_to_name: dict[int, str]
@@ -8,9 +10,17 @@ class Lingo2StaticLogic:
     item_name_to_id: dict[str, int]
     location_name_to_id: dict[str, int]
 
+    item_name_groups: dict[str, list[str]]
+    location_name_groups: dict[str, list[str]]
+
+    letter_weights: dict[str, int]
+
     def __init__(self):
         self.item_id_to_name = {}
         self.location_id_to_name = {}
+        self.item_name_groups = {}
+        self.location_name_groups = {}
+        self.letter_weights = {}
 
         file = pkgutil.get_data(__name__, "generated/data.binpb")
         self.objects = data_pb2.AllObjects()
@@ -18,38 +28,125 @@ class Lingo2StaticLogic:
 
         for door in self.objects.doors:
             if door.type in [data_pb2.DoorType.STANDARD, data_pb2.DoorType.LOCATION_ONLY, data_pb2.DoorType.GRAVESTONE]:
-                location_name = f"{self.get_map_object_map_name(door)} - {door.name}"
+                location_name = self.get_door_location_name(door)
                 self.location_id_to_name[door.ap_id] = location_name
 
             if door.type not in [data_pb2.DoorType.EVENT, data_pb2.DoorType.LOCATION_ONLY, data_pb2.DoorType.GRAVESTONE]:
-                item_name = self.get_door_item_name(door.id)
+                item_name = self.get_door_item_name(door)
                 self.item_id_to_name[door.ap_id] = item_name
 
         for letter in self.objects.letters:
             letter_name = f"{letter.key.upper()}{'2' if letter.level2 else '1'}"
             location_name = f"{self.get_room_object_map_name(letter)} - {letter_name}"
             self.location_id_to_name[letter.ap_id] = location_name
+            self.location_name_groups.setdefault("Letters", []).append(location_name)
 
             if not letter.level2:
-                self.item_id_to_name[letter.ap_id] = letter_name
+                self.item_id_to_name[letter.ap_id] = letter.key.upper()
+                self.item_name_groups.setdefault("Letters", []).append(letter.key.upper())
 
         for mastery in self.objects.masteries:
             location_name = f"{self.get_room_object_map_name(mastery)} - Mastery"
             self.location_id_to_name[mastery.ap_id] = location_name
+            self.location_name_groups.setdefault("Masteries", []).append(location_name)
 
         for ending in self.objects.endings:
             location_name = f"{self.get_room_object_map_name(ending)} - {ending.name.title()} Ending"
             self.location_id_to_name[ending.ap_id] = location_name
+            self.location_name_groups.setdefault("Endings", []).append(location_name)
+
+        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"
+                self.location_id_to_name[keyholder.ap_id] = location_name
+                self.location_name_groups.setdefault("Keyholders", []).append(location_name)
+
+        self.item_id_to_name[self.objects.special_ids["A Job Well Done"]] = "A Job Well Done"
+
+        for symbol_name in SYMBOL_ITEMS.values():
+            self.item_id_to_name[self.objects.special_ids[symbol_name]] = symbol_name
 
-        self.item_id_to_name[self.objects.special_ids["Nothing"]] = "Nothing"
+        for trap_name in ANTI_COLLECTABLE_TRAPS:
+            self.item_id_to_name[self.objects.special_ids[trap_name]] = trap_name
 
         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()}
 
-    def get_door_item_name(self, door_id: int) -> str:
-        door = self.objects.doors[door_id]
+        for panel in self.objects.panels:
+            for letter in panel.answer.upper():
+                self.letter_weights[letter] = self.letter_weights.get(letter, 0) + 1
+
+    def get_door_item_name(self, door: data_pb2.Door) -> str:
         return f"{self.get_map_object_map_name(door)} - {door.name}"
 
+    def get_door_item_name_by_id(self, door_id: int) -> str:
+        door = self.objects.doors[door_id]
+        return self.get_door_item_name(door_id)
+
+    def get_door_location_name(self, door: data_pb2.Door) -> str:
+        map_part = self.get_room_object_location_prefix(door)
+
+        if door.HasField("location_name"):
+            return f"{map_part} - {door.location_name}"
+
+        generated_location_name = self.get_generated_door_location_name(door)
+        if generated_location_name is not None:
+            return generated_location_name
+
+        return f"{map_part} - {door.name}"
+
+    def get_generated_door_location_name(self, door: data_pb2.Door) -> str | None:
+        if door.type != data_pb2.DoorType.STANDARD:
+            return None
+
+        if len(door.keyholders) > 0 or len(door.endings) > 0 or door.HasField("complete_at"):
+            return None
+
+        if len(door.panels) > 4:
+            return None
+
+        map_areas = set()
+        for panel_id in door.panels:
+            panel = self.objects.panels[panel_id.panel]
+            panel_room = self.objects.rooms[panel.room_id]
+            # It's okay if panel_display_name is not present because then it's coalesced with other unnamed areas.
+            map_areas.add(panel_room.panel_display_name)
+
+        if len(map_areas) > 1:
+            return None
+
+        game_map = self.objects.maps[door.map_id]
+        map_area = map_areas.pop()
+        if map_area == "":
+            map_part = game_map.display_name
+        else:
+            map_part = f"{game_map.display_name} ({map_area})"
+
+        def get_panel_display_name(panel: data_pb2.ProxyIdentifier) -> str:
+            panel_data = self.objects.panels[panel.panel]
+            panel_name = panel_data.display_name if panel_data.HasField("display_name") else panel_data.name
+
+            if panel.HasField("answer"):
+                return f"{panel_name}/{panel.answer.upper()}"
+            else:
+                return panel_name
+
+        panel_names = [get_panel_display_name(panel_id)
+                       for panel_id in door.panels]
+        panel_names.sort()
+
+        return map_part + " - " + ", ".join(panel_names)
+
+    def get_door_location_name_by_id(self, door_id: int) -> str:
+        door = self.objects.doors[door_id]
+        return self.get_door_location_name(door)
+
     def get_room_region_name(self, room_id: int) -> str:
         room = self.objects.rooms[room_id]
         return f"{self.get_map_object_map_name(room)} - {room.name}"
@@ -59,3 +156,16 @@ class Lingo2StaticLogic:
 
     def get_room_object_map_name(self, obj) -> str:
         return self.get_map_object_map_name(self.objects.rooms[obj.room_id])
+
+    def get_room_object_location_prefix(self, obj) -> str:
+        room = self.objects.rooms[obj.room_id]
+        game_map = self.objects.maps[room.map_id]
+
+        if room.HasField("panel_display_name"):
+            return f"{game_map.display_name} ({room.panel_display_name})"
+        else:
+            return game_map.display_name
+
+    def get_data_version(self) -> list[int]:
+        version = self.objects.version
+        return [version.major, version.minor, version.patch]
@@ -0,0 +1,112 @@
+from typing import TYPE_CHECKING
+
+from BaseClasses import MultiWorld, CollectionState, ItemClassification
+from NetUtils import NetworkItem
+from . import Lingo2World, Lingo2Item
+from .regions import connect_ports_from_ut
+from .options import Lingo2Options, ShuffleLetters
+
+if TYPE_CHECKING:
+    from .context import Lingo2Manager
+
+PLAYER_NUM = 1
+
+
+class Tracker:
+    manager: "Lingo2Manager"
+
+    multiworld: MultiWorld
+    world: Lingo2World
+
+    collected_items: dict[int, int]
+    checked_locations: set[int]
+    accessible_locations: set[int]
+    accessible_worldports: set[int]
+    goal_accessible: bool
+
+    state: CollectionState
+
+    def __init__(self, manager: "Lingo2Manager"):
+        self.manager = manager
+        self.collected_items = {}
+        self.checked_locations = set()
+        self.accessible_locations = set()
+        self.accessible_worldports = set()
+        self.goal_accessible = False
+
+    def setup_slot(self, slot_data):
+        Lingo2World.for_tracker = True
+
+        self.multiworld = MultiWorld(players=PLAYER_NUM)
+        self.world = Lingo2World(self.multiworld, PLAYER_NUM)
+        self.multiworld.worlds[1] = self.world
+        self.world.options = Lingo2Options(**{k: t(slot_data.get(k, t.default))
+                                              for k, t in Lingo2Options.type_hints.items()})
+
+        self.world.generate_early()
+        self.world.create_regions()
+
+        if self.world.options.shuffle_worldports:
+            port_pairings = {int(fp): int(tp) for fp, tp in slot_data["port_pairings"].items()}
+            connect_ports_from_ut(port_pairings, self.world)
+
+        self.refresh_state()
+
+    def set_checked_locations(self, checked_locations: set[int]):
+        self.checked_locations = checked_locations.copy()
+
+    def set_collected_items(self, network_items: list[NetworkItem]):
+        self.collected_items = {}
+
+        for item in network_items:
+            self.collected_items[item.item] = self.collected_items.get(item.item, 0) + 1
+
+        self.refresh_state()
+
+    def refresh_state(self):
+        self.state = CollectionState(self.multiworld)
+
+        for item_id, item_amount in self.collected_items.items():
+            for i in range(item_amount):
+                self.state.collect(Lingo2Item(Lingo2World.static_logic.item_id_to_name.get(item_id),
+                                              ItemClassification.progression, item_id, PLAYER_NUM), prevent_sweep=True)
+
+        for k, v in self.manager.keyboard.items():
+            # Unless all level 1 letters are pre-unlocked, H1 I1 N1 and T1 act differently between the generator and
+            # game. The generator considers them to be unlocked, which means they are not included in logic
+            # requirements, and only one item/event is needed to unlock their level 2 forms. The game considers them to
+            # be vanilla, which means you still have to pick them up in the Starting Room in order for them to appear on
+            # your keyboard. This also means that whether or not you have the level 1 forms should be synced to the
+            # multiworld. The tracker specifically should collect one fewer item for these letters in this scenario.
+            tv = v
+            if k in "hint" and self.world.options.shuffle_letters in [ShuffleLetters.option_vanilla,
+                                                                      ShuffleLetters.option_progressive]:
+                tv = max(0, v - 1)
+
+            if tv > 0:
+                for i in range(tv):
+                    self.state.collect(Lingo2Item(k.upper(), ItemClassification.progression, None, PLAYER_NUM),
+                                       prevent_sweep=True)
+
+        for port_id in self.manager.worldports:
+            self.state.collect(Lingo2Item(f"Worldport {port_id} Entered", ItemClassification.progression, None,
+                                          PLAYER_NUM), prevent_sweep=True)
+
+        self.state.sweep_for_advancements()
+
+        self.accessible_locations = set()
+        self.accessible_worldports = set()
+        self.goal_accessible = False
+
+        for region in self.state.reachable_regions[PLAYER_NUM]:
+            for location in region.locations:
+                if location.access_rule(self.state):
+                    if location.address is not None:
+                        if location.address not in self.checked_locations:
+                            self.accessible_locations.add(location.address)
+                    elif hasattr(location, "port_id"):
+                        if location.port_id not in self.manager.worldports:
+                            self.accessible_worldports.add(location.port_id)
+                    elif hasattr(location, "goal") and location.goal:
+                        if not self.manager.goaled:
+                            self.goal_accessible = True
@@ -0,0 +1,13 @@
+# Lingo 2 Randomizer Data
+
+This folder contains the logic for the Lingo 2 randomizer in a human-readable
+format. This data is compiled into a single file and used in the various parts
+of the randomizer project (client, apworld, etc).
+
+The data is structured using [Protocol Buffers](https://protobuf.dev/). The
+schema for the human-readable format is
+[located in the repository](https://code.fourisland.com/lingo2-archipelago/tree/proto/human.proto).
+
+## Compiling
+
+Hi.
@@ -1,30 +1,5 @@
 # TODO
-# the_entry/Starting Room/HI/thewords
-# the_entry/Link Area/PYRAMID
-# control center -> the_ancient
-# the_between/Control Center Side/CC
-# the_gallery/Main Area/WISE
-# the_gallery/Main Area/CC
-# the_gallery/Main Area/WORDS
-# the_gallery/Main Area/WONDROUS
-# the_great/West Side/CC
-# the_great/Back Area/UNKEMPT
-# the_hinterlands/Main Area/LEFT
-# the_hinterlands/Main Area/RIGHT
-# the_liberated/Painting Room/PYRAMID
-# the_literate/Painting Room/PYRAMID
-# the_partial/Control Center Entrance/CC
-# the_perceptive/Main Area/CC
-# cc -> relentless (don't use port objects)
-# the_repetitive/Main Room/CC
-# cc <-> the shop (keyholder door only needed one way)
-# the_sun_temple/Entrance/UNKEMPT
-# the_unyielding/Central Connected Area/BACK (panel)
 # daedalus/roof -> icarus
-# daedalus/Unkempt Entrance/UNKEMPT
-# daedalus/Wonderland/WONDROUS
-# the_tenacious/Control Center Entrance/CC
-# the_tree/Main Area/UNKEMPT
 connections {
   from {
     port {
@@ -45,7 +20,7 @@ connections {
   from {
     port {
       map: "the_entry"
-      room: "Flipped Second Room"
+      room: "Four Rooms Entrance"
       name: "FOUR"
     }
   }
@@ -166,7 +141,7 @@ connections {
   to {
     port {
       map: "the_darkroom"
-      room: "First Room"
+      room: "Cyan Hallway"
       name: "COLORFUL"
     }
   }
@@ -182,7 +157,7 @@ connections {
   to {
     port {
       map: "the_darkroom"
-      room: "Second Room"
+      room: "Congruent Entrance"
       name: "CONGRUENT"
     }
   }
@@ -258,7 +233,7 @@ connections {
   from {
     port {
       map: "the_darkroom"
-      room: "First Room"
+      room: "Double Sided Entrance"
       name: "DOUBLESIDED"
     }
   }
@@ -333,6 +308,23 @@ connections {
       name: "GALLERY"
     }
   }
+  oneway: true
+}
+connections {
+  from {
+    port {
+      map: "the_butterfly"
+      room: "Main Area"
+      name: "GALLERY"
+    }
+  }
+  to {
+    room {
+      map: "the_gallery"
+      name: "Main Area"
+    }
+  }
+  oneway: true
 }
 connections {
   from {
@@ -643,7 +635,7 @@ connections {
   from {
     port {
       map: "the_entry"
-      room: "Link Area"
+      room: "Liberated Entrance"
       name: "BLUE"
     }
   }
@@ -691,7 +683,7 @@ connections {
   from {
     port {
       map: "the_entry"
-      room: "Link Area"
+      room: "Literate Entrance"
       name: "BROWN"
     }
   }
@@ -739,7 +731,7 @@ connections {
   from {
     port {
       map: "the_orb"
-      room: "B Room"
+      room: "Middle Room"
       name: "MID"
     }
   }
@@ -866,6 +858,8 @@ connections {
   }
   oneway: true
 }
+# Two one-way connections because the CLUE panel only needs to be solved to
+# go from The Great to The Partial.
 connections {
   from {
     port {
@@ -881,6 +875,25 @@ connections {
       name: "GREAT"
     }
   }
+  oneway: true
+}
+connections {
+  from {
+    port {
+      map: "the_partial"
+      room: "Obverse Side"
+      name: "GREAT"
+    }
+  }
+  to {
+    port {
+      map: "the_great"
+      room: "West Side"
+      name: "PARTIAL"
+    }
+  }
+  oneway: true
+  bypass_target_door: true
 }
 connections {
   from {
@@ -950,7 +963,7 @@ connections {
   from {
     port {
       map: "the_entry"
-      room: "Lime Room"
+      room: "Revitalized Entrance"
       name: "REVITALIZED"
     }
   }
@@ -1218,6 +1231,7 @@ connections {
     }
   }
   oneway: true
+  roof_access: true
 }
 connections {
   from {
@@ -1423,7 +1437,7 @@ connections {
   to {
     room {
       map: "daedalus"
-      name: "Roof"
+      name: "Castle"
     }
   }
   oneway: true
@@ -1459,7 +1473,6 @@ connections {
       name: "GREAT"
     }
   }
-  door { map: "the_great" name: "Daedalus Entrance" }
   oneway: true
 }
 connections {
@@ -1478,6 +1491,7 @@ connections {
     }
   }
   oneway: true
+  bypass_target_door: true
 }
 connections {
   from {
@@ -1773,12 +1787,13 @@ connections {
     }
   }
   oneway: true
+  bypass_target_door: true
 }
 connections {
   from {
     port {
       map: "the_bearer"
-      room: "Back Area"
+      room: "Tree Entrance"
       name: "TREE"
     }
   }
@@ -1854,3 +1869,595 @@ connections {
     }
   }
 }
+connections {
+  from {
+    port {
+      map: "the_great"
+      room: "Back Area"
+      name: "UNKEMPT"
+    }
+  }
+  to {
+    port {
+      map: "the_unkempt"
+      room: "Main Area"
+      name: "GREAT"
+    }
+  }
+}
+connections {
+  # Two one-way connections because the door only blocks one direction.
+  from {
+    port {
+      map: "the_unkempt"
+      room: "Main Area"
+      name: "SUNTEMPLE"
+    }
+  }
+  to {
+    port {
+      map: "the_sun_temple"
+      room: "Entrance"
+      name: "UNKEMPT"
+    }
+  }
+  oneway: true
+}
+connections {
+  from {
+    port {
+      map: "the_sun_temple"
+      room: "Entrance"
+      name: "UNKEMPT"
+    }
+  }
+  to {
+    port {
+      map: "the_unkempt"
+      room: "Main Area"
+      name: "SUNTEMPLE"
+    }
+  }
+  oneway: true
+  bypass_target_door: true
+}
+connections {
+  from {
+    port {
+      map: "the_unkempt"
+      room: "Daedalus Entrance"
+      name: "DAEDALUS"
+    }
+  }
+  to {
+    port {
+      map: "daedalus"
+      room: "Unkempt Entrance"
+      name: "UNKEMPT"
+    }
+  }
+}
+connections {
+  from {
+    port {
+      map: "the_unkempt"
+      room: "Main Area"
+      name: "TREE"
+    }
+  }
+  to {
+    port {
+      map: "the_tree"
+      room: "Main Area"
+      name: "UNKEMPT"
+    }
+  }
+}
+connections {
+  from {
+    painting {
+      map: "the_entry"
+      room: "Link Area"
+      name: "PYRAMID"
+    }
+  }
+  to {
+    room {
+      map: "the_wise"
+      name: "Entry"
+    }
+  }
+  oneway: true
+}
+connections {
+  from {
+    painting {
+      map: "the_gallery"
+      room: "Main Area"
+      name: "WISE"
+    }
+  }
+  to {
+    room {
+      map: "the_wise"
+      name: "Entry"
+    }
+  }
+  oneway: true
+}
+connections {
+  from {
+    painting {
+      map: "the_liberated"
+      room: "Painting Room"
+      name: "PYRAMID"
+    }
+  }
+  to {
+    room {
+      map: "the_wise"
+      name: "Entry"
+    }
+  }
+  oneway: true
+}
+connections {
+  from {
+    painting {
+      map: "the_literate"
+      room: "Painting Room"
+      name: "PYRAMID"
+    }
+  }
+  to {
+    room {
+      map: "the_wise"
+      name: "Entry"
+    }
+  }
+  oneway: true
+}
+connections {
+  from {
+    painting {
+      map: "the_wise"
+      room: "Entry"
+      name: "TRIANGLE"
+    }
+  }
+  to {
+    room {
+      map: "the_gallery"
+      name: "Main Area"
+    }
+  }
+  oneway: true
+}
+connections {
+  from {
+    room {
+      map: "the_wondrous"
+      name: "Huge"
+    }
+  }
+  to {
+    room {
+      map: "the_door"
+      name: "Main Area"
+    }
+  }
+  door {
+    map: "the_wondrous"
+    name: "Big Door"
+  }
+  oneway: true
+}
+connections {
+  from {
+    painting {
+      map: "the_gallery"
+      room: "Main Area"
+      name: "WONDROUS"
+    }
+  }
+  to {
+    room {
+      map: "the_wondrous"
+      name: "Huge"
+    }
+  }
+  oneway: true
+}
+connections {
+  from {
+    port {
+      map: "daedalus"
+      room: "Wonderland"
+      name: "WONDROUS"
+    }
+  }
+  to {
+    port {
+      map: "the_wondrous"
+      room: "Entry"
+      name: "DAEDALUS"
+    }
+  }
+}
+connections {
+  from {
+    panel {
+      map: "the_entry"
+      room: "Starting Room"
+      name: "HI"
+      answer: "thewords"
+    }
+  }
+  to {
+    room {
+      map: "the_words"
+      name: "Main Area"
+    }
+  }
+  oneway: true
+}
+connections {
+  from {
+    port {
+      map: "the_words"
+      room: "Main Area"
+      name: "ENTRY"
+    }
+  }
+  to {
+    room {
+      map: "the_entry"
+      name: "Starting Room"
+    }
+  }
+  oneway: true
+}
+connections {
+  from {
+    painting {
+      map: "the_gallery"
+      room: "Main Area"
+      name: "WORDS"
+    }
+  }
+  to {
+    room {
+      map: "the_words"
+      name: "Main Area"
+    }
+  }
+  oneway: true
+}
+connections {
+  from {
+    room {
+      map: "control_center"
+      name: "Main Area"
+    }
+  }
+  to {
+    room {
+      map: "the_relentless"
+      name: "Turn Room"
+    }
+  }
+  door {
+    map: "control_center"
+    name: "Relentless Turn Door"
+  }
+}
+connections {
+  from {
+    room {
+      map: "control_center"
+      name: "Main Area"
+    }
+  }
+  to {
+    room {
+      map: "the_relentless"
+      name: "Shop Room"
+    }
+  }
+  door {
+    map: "control_center"
+    name: "Relentless Shop Door"
+  }
+}
+connections {
+  from {
+    room {
+      map: "control_center"
+      name: "Main Area"
+    }
+  }
+  to {
+    room {
+      map: "the_relentless"
+      name: "Left Room"
+    }
+  }
+  door {
+    map: "control_center"
+    name: "Relentless Left Door"
+  }
+}
+connections {
+  from {
+    port {
+      map: "control_center"
+      room: "Ancient Entrance"
+      name: "ANCIENT"
+    }
+  }
+  to {
+    room {
+      map: "the_ancient"
+      name: "Outside"
+    }
+  }
+  oneway: true
+}
+connections {
+  from {
+    port {
+      map: "the_between"
+      room: "Control Center Side"
+      name: "CC"
+    }
+  }
+  to {
+    port {
+      map: "control_center"
+      room: "Between Entrance"
+      name: "BETWEEN"
+    }
+  }
+}
+connections {
+  from {
+    painting {
+      map: "the_gallery"
+      room: "Main Area"
+      name: "CC"
+    }
+  }
+  to {
+    room {
+      map: "control_center"
+      name: "Desert Room"
+    }
+  }
+  oneway: true
+}
+connections {
+  from {
+    port {
+      map: "the_great"
+      room: "West Side"
+      name: "CC"
+    }
+  }
+  to {
+    port {
+      map: "control_center"
+      room: "Entry"
+      name: "GREAT"
+    }
+  }
+}
+connections {
+  from {
+    port {
+      map: "the_hinterlands"
+      room: "Main Area"
+      name: "LEFT"
+    }
+  }
+  to {
+    port {
+      map: "control_center"
+      room: "Main Area"
+      name: "LEFT"
+    }
+  }
+}
+connections {
+  from {
+    port {
+      map: "the_hinterlands"
+      room: "Main Area"
+      name: "RIGHT"
+    }
+  }
+  to {
+    port {
+      map: "control_center"
+      room: "Main Area"
+      name: "RIGHT"
+    }
+  }
+}
+connections {
+  from {
+    port {
+      map: "the_partial"
+      room: "Control Center Entrance"
+      name: "CC"
+    }
+  }
+  to {
+    port {
+      map: "control_center"
+      room: "Partial Entrance"
+      name: "PARTIAL"
+    }
+  }
+}
+connections {
+  from {
+    port {
+      map: "the_perceptive"
+      room: "Main Area"
+      name: "CC"
+    }
+  }
+  to {
+    port {
+      map: "control_center"
+      room: "Perceptive Entrance"
+      name: "PERCEPTIVE"
+    }
+  }
+}
+connections {
+  from {
+    port {
+      map: "the_repetitive"
+      room: "Main Room"
+      name: "CC"
+    }
+  }
+  to {
+    port {
+      map: "control_center"
+      room: "Repetitive Entrance"
+      name: "REPETITIVE"
+    }
+  }
+}
+connections {
+  from {
+    room {
+      map: "the_shop"
+      name: "Main Area"
+    }
+  }
+  to {
+    room {
+      map: "control_center"
+      name: "Shop Entrance"
+    }
+  }
+  door {
+    map: "the_shop"
+    name: "N Entered"
+  }
+  oneway: true
+}
+connections {
+  from {
+    room {
+      map: "control_center"
+      name: "Shop Entrance"
+    }
+  }
+  to {
+    room {
+      map: "the_shop"
+      name: "Main Area"
+    }
+  }
+  oneway: true
+}
+connections {
+  from {
+    panel {
+      map: "the_unyielding"
+      room: "Central Connected Area"
+      name: "BACK"
+    }
+  }
+  to {
+    panel {
+      map: "control_center"
+      room: "Unyielding Entrance"
+      name: "FORTH"
+    }
+  }
+}
+connections {
+  from {
+    port {
+      map: "the_tenacious"
+      room: "Control Center Entrance"
+      name: "CC"
+    }
+  }
+  to {
+    port {
+      map: "control_center"
+      room: "Tenacious Entrance"
+      name: "TENACIOUS"
+    }
+  }
+}
+connections {
+  from {
+    port {
+      map: "the_unkempt"
+      room: "Control Center Entrance"
+      name: "CC"
+    }
+  }
+  to {
+    port {
+      map: "control_center"
+      room: "Unkempt Entrance"
+      name: "UNKEMPT"
+    }
+  }
+}
+connections {
+  from {
+    panel {
+      map: "control_center"
+      room: "Stormy Entrance"
+      name: "TURN"
+    }
+  }
+  to {
+    room {
+      map: "the_stormy"
+      name: "Center"
+    }
+  }
+  oneway: true
+}
+connections {
+  from {
+    port {
+      map: "the_entry"
+      room: "X Area"
+      name: "CC"
+    }
+  }
+  to {
+    port {
+      map: "control_center"
+      room: "Entry Entrance"
+      name: "ENTRY"
+    }
+  }
+}
+connections {
+  from {
+    painting {
+      map: "the_entry"
+      room: "Eye Room"
+      name: "GALLERY"
+    }
+  }
+  to {
+    room {
+      map: "the_gallery"
+      name: "Main Area"
+    }
+  }
+  oneway: true
+}
@@ -0,0 +1,163 @@
+door_groups {
+  name: "The Entry - Repetitive Entrance"
+  # This *should* be a CONNECTOR, but currently we're not shuffling these
+  # entrances because we want to guarantee that there's a way to The Repetitive
+  # without missing keys in vanilla doors. Hopefully can be changed eventually.
+  type: SHUFFLE_GROUP
+  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"
+  }
+}
+door_groups {
+  name: "Cyan Doors"
+  type: CYAN_DOORS
+  doors {
+    map: "daedalus"
+    name: "Eye Painting"
+  }
+  doors {
+    map: "the_bearer"
+    name: "Butterfly Entrance"
+  }
+  doors {
+    map: "the_darkroom"
+    name: "Double Letter Panel Blockers"
+  }
+  doors {
+    map: "the_entry"
+    name: "Starting Room West Wall North Door"
+  }
+  doors {
+    map: "the_entry"
+    name: "Flipped Pyramid Area Entrance"
+  }
+  doors {
+    map: "the_entry"
+    name: "Near D Room Painting"
+  }
+  doors {
+    map: "the_graveyard"
+    name: "Double Letters"
+  }
+  doors {
+    map: "the_great"
+    name: "Tower Entrance"
+  }
+  doors {
+    map: "the_great"
+    name: "Cyan Doors"
+  }
+  doors {
+    map: "the_parthenon"
+    name: "Double Letters"
+  }
+  doors {
+    map: "the_unkempt"
+    name: "Cyan Doors"
+  }
+  doors {
+    map: "the_unkempt"
+    name: "Control Center Orange Door"
+  }
+  doors {
+    map: "the_unyielding"
+    name: "Cyan Doors"
+  }
+}
+door_groups {
+  name: "Lavender Cubes"
+  type: SHUFFLE_GROUP
+  doors {
+    map: "daedalus"
+    name: "C Keyholder Blocker"
+  }
+  doors {
+    map: "the_congruent"
+    name: "T Keyholder Blocker"
+  }
+  doors {
+    map: "the_great"
+    name: "Lavender Cube"
+  }
+  doors {
+    map: "the_parthenon"
+    name: "Lavender Cubes"
+  }
+}
@@ -1,4 +1,66 @@
 maps:
+  control_center:
+    rooms:
+      Between Entrance:
+        panels:
+          RIGHT: 2721
+      Desert Room:
+        panels:
+          LESS: 2722
+      Entry:
+        panels:
+          HELLO: 2724
+      Entry Entrance:
+        panels:
+          ENTRY: 2723
+      Hide Room:
+        panels:
+          HIDE: 2725
+      Main Area:
+        panels:
+          COLOR: 2726
+          Letters: 2727
+        keyholders:
+          1: 2760
+          2: 2761
+          3: 2762
+          4: 2763
+      Partial Entrance:
+        panels:
+          PARTIAL: 2729
+      Perceptive Entrance:
+        panels:
+          COLORS: 2731
+          PART: 2730
+      Shop Entrance:
+        panels:
+          HOPS: 2732
+      Stormy Entrance:
+        panels:
+          TURN: 2733
+      Tenacious Entrance:
+        panels:
+          HERO: 2734
+      Unkempt Entrance:
+        panels:
+          RETURN: 2735
+      Unyielding Entrance:
+        panels:
+          FORTH: 2736
+          SEEK: 2737
+    doors:
+      Ancient Entrance: 2715
+      Between Door: 2716
+      Desert Door: 2717
+      Front Door: 2709
+      Partial Door: 2713
+      Repetitive Entrance: 2714
+      Shop Door: 2718
+      Stormy Entrance: 2710
+      Tenacious Door: 2719
+      Unkempt Door: 2712
+      Unyielding Door: 2720
+      X1 Door: 2711
   daedalus:
     rooms:
       After Bee Room:
@@ -98,6 +160,9 @@ maps:
       Brown Smiley:
         panels:
           OTHERS: 1667
+      C Keyholder:
+        keyholders:
+          C: 2755
       Castle:
         panels:
           FIVE (Blue): 1673
@@ -208,6 +273,9 @@ maps:
           SUMMER: 1754
           WORD: 1753
           WORDWORD: 1761
+      D Keyholder:
+        keyholders:
+          D: 2759
       Dark Light Exit:
         panels:
           GASKET: 1763
@@ -230,6 +298,9 @@ maps:
       Eye Painting:
         panels:
           REVILED: 1777
+      F Keyholder:
+        keyholders:
+          F: 2756
       F2 Room:
         panels:
           CAST: 1782
@@ -423,6 +494,8 @@ maps:
         panels:
           GOING: 1934
           TURN: 1935
+        keyholders:
+          G: 2757
       Nursery:
         panels:
           "?": 1937
@@ -490,6 +563,8 @@ maps:
           WALLS: 1986
           WHISPER: 1978
           WING: 1979
+        keyholders:
+          H: 2758
       Outside Magic Room:
         panels:
           WIZARD: 1988
@@ -673,7 +748,7 @@ maps:
           Back (2): 2090
           Colors: 2097
           FIR: 2095
-          Left: 2088
+          Near Obscured Puzzles: 2088
           OAK: 2093
           PINE: 2094
           WALK BACK: 2091
@@ -822,7 +897,6 @@ maps:
           REDACTED: 2274
           STRINGS: 2205
           WINDS: 2204
-          "[REDACTED]": 2207
       Yellow Color Door:
         panels:
           Paintings: 2210
@@ -913,7 +987,6 @@ maps:
       Blue Rainbow Room: 1538
       Blue Room: 1477
       Blue Room Entrance: 1476
-      Blue Smiley Entrance: 1478
       Blue Smiley Exit To Red: 1547
       Book Room Entrance: 1588
       Book Room Exit: 1592
@@ -941,12 +1014,13 @@ maps:
       Dark Light Room Exit: 1570
       Dark Light Room Exit Panel: 1571
       Entry Shortcut Secret Exit: 1437
+      Eye Painting: 2751
       Eye Painting Exit: 1446
       F Keyholder Door: 1551
-      F2 Room Back Left Door: 1491
-      F2 Room Back Middle Door: 1492
-      F2 Room Back Right Door: 1490
-      F2 Room Entrance: 1487
+      F2 Room Northwest Door: 1491
+      F2 Room Southeast Door: 1487
+      F2 Room Southwest Door: 1490
+      F2 Room West Door: 1492
       Flip Painting Blocker: 1552
       Globe Room East Door: 1589
       Globe Room South Door: 1591
@@ -969,6 +1043,7 @@ maps:
       House Entrance: 1495
       House Side Door: 1566
       Intense Room Entrance: 1522
+      Lime Hexes: 2810
       Magenta Hexes: 2272
       Magic Room Entrance: 1500
       Magic Room Panels: 1499
@@ -980,7 +1055,9 @@ maps:
       Near Sweet Blue Door: 1573
       Near Sweet Brown Door: 1561
       Near Yellow Room Door: 1565
-      O2 Room Back Door: 1485
+      North Castle Panel: 2742
+      O2 Room Northeast Door: 1485
+      O2 Room Southeast Door: 1478
       Orange Rainbow Panel: 2267
       Orange Rainbow Room: 1535
       Orange Room: 1507
@@ -1007,6 +1084,7 @@ maps:
       Purple NW Vestibule: 1459
       Purple Rainbow Panel: 2271
       Purple Rainbow Room: 1539
+      Purple Room: 2741
       Purple Room East Entrance: 1472
       Purple Room North Entrance: 1469
       Purple Room South Entrance: 1470
@@ -1031,9 +1109,10 @@ maps:
       Snake Room Entrance: 1514
       South Castle Area Back Door: 1574
       South Castle Area Entrance: 1575
+      South Castle Panel: 2744
       Southwest Area Intersection: 1475
-      Splintering Exit Left Door: 1449
-      Splintering Exit Right Door: 1450
+      Splintering Exit North Door: 1449
+      Splintering Exit South Door: 1450
       Starting Room East Wall Center Door: 1439
       Starting Room East Wall North Door: 1440
       Starting Room North Wall Center Door: 1432
@@ -1046,15 +1125,17 @@ maps:
       Starting Room West Wall South Door: 1433
       Sticks And Stones Door: 1593
       Temple of the Eyes Entrance: 1444
-      U2 Room Back Door: 1497
-      U2 Room Back Right Door: 1496
-      U2 Room Entrance: 1498
-      U2 Room Shortcut: 1493
+      Theo Panels: 2811
+      U2 Room East Door: 1498
+      U2 Room Southeast Door: 1493
+      U2 Room Southwest Door: 1496
+      U2 Room West Door: 1497
       Welcome Back Door: 1435
       Welcome Back Secret Door: 1434
+      West Castle Panel: 2743
       White Hallway From Entry: 1488
-      Wonderland Left Door: 1520
-      Wonderland Right Door: 1504
+      Wonderland North Door: 1520
+      Wonderland South Door: 1504
       Yellow Rainbow Panel: 2268
       Yellow Rainbow Room: 1536
       Yellow Room: 1568
@@ -1098,6 +1179,9 @@ maps:
           SWAY: 24
           TERROR: 20
           TURN: 22
+      Keyholder Room:
+        keyholders:
+          A: 2773
       Synonyms Room:
         panels:
           ADORE: 26
@@ -1121,7 +1205,7 @@ maps:
     doors:
       A2 Door: 4
       Examples Door: 1
-      Intensify Door: 0
+      Intensify Door: 2739
       Keyholder Door: 5
       Synonyms Door: 2
       Time Door: 3
@@ -1134,7 +1218,6 @@ maps:
         panels:
           THIS: 45
     doors:
-      End Door: 42
       Front Door: 41
       Lavender Cubes: 43
   the_bearer:
@@ -1215,7 +1298,6 @@ maps:
       Control Center Brown Door: 49
       Exit Door: 47
       Overlook Door: 46
-      Q2 Door: 48
   the_between:
     rooms:
       Control Center Side:
@@ -1390,6 +1472,9 @@ maps:
         panels:
           CIVIL: 216
           CRABS: 217
+      T Keyholder:
+        keyholders:
+          T: 2754
     doors:
       C Keyholder Blocker: 176
       C2 Door: 177
@@ -1401,7 +1486,6 @@ maps:
       Obverse Magenta Door: 173
       Obverse Yellow Door: 178
       Obverse Yellow Puzzles: 179
-      T Keyholder Blocker: 183
   the_darkroom:
     rooms:
       First Room:
@@ -1432,9 +1516,7 @@ maps:
     doors:
       Colorful Entrance: 222
       Congruent Entrance: 223
-      Double Letter Panel Blockers: 218
       Double Sided Entrance: 224
-      S1 Door: 221
       Second Room Entrance: 219
       Third Room Entrance: 220
   the_digital:
@@ -1594,6 +1676,10 @@ maps:
       Rabbit Hole:
         panels:
           PUZZLE: 364
+      Rabbit Hole Lock:
+        panels:
+          HOLE: 2749
+          RABBIT: 2748
       Red Alcove:
         panels:
           BROW: 365
@@ -1630,8 +1716,6 @@ maps:
         panels:
           CORN: 393
           DICE: 392
-          HOLE: 390
-          RABBIT: 389
           WREATH: 391
     doors:
       Blue Alcove Entrance: 297
@@ -1643,7 +1727,6 @@ maps:
       D Room Entrance: 319
       Daedalus Entrance: 311
       Flip Area Entrance: 310
-      Flipped Pyramid Area Entrance: 315
       Flipped Second Room Left Door: 300
       Flipped Second Room Right Door: 299
       Gallery Entrance: 321
@@ -1661,13 +1744,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
@@ -1694,6 +1777,8 @@ maps:
       X Plus:
         panels:
           ROSE: 405
+        keyholders:
+          M: 2766
       X Plus Middle Leg:
         panels:
           COLONY: 403
@@ -1723,6 +1808,9 @@ maps:
       Daedalus Extension:
         panels:
           WHERE: 433
+      Main Area:
+        keyholders:
+          P: 2765
     doors:
       Ancient Painting: 428
       Between Painting: 414
@@ -1907,6 +1995,8 @@ maps:
           LAUGH FINISHED: 573
           PLANTS: 570
           WEATHER: 568
+        keyholders:
+          X: 2770
       Outside Jail:
         panels:
           GUT: 575
@@ -1995,7 +2085,6 @@ maps:
       Into The Mouth Gravestone: 457
       Invisible Entrance: 465
       Jail Entrance: 451
-      Lavender Cube: 469
       Magnet Room Entrance: 449
       Nature Room Door: 466
       Nature Room Panels: 467
@@ -2054,6 +2143,8 @@ maps:
           WAS: 631
           WINGS: 662
           YELL: 636
+        keyholders:
+          B: 2769
       Mastery Room:
         masteries:
           MASTERY: 666
@@ -2120,6 +2211,8 @@ maps:
           FLASHBACK: 705
           PUSH: 703
           PUSHBACK: 702
+        keyholders:
+          J: 2772
     doors:
       Side Door: 687
   the_keen:
@@ -2231,10 +2324,12 @@ maps:
           NAY: 774
           NIGH: 781
           TORE: 787
+        keyholders:
+          S: 2767
     doors:
-      Left Room Puzzles: 763
-      Main Room Puzzles: 765
-      Right Room Puzzles: 764
+      Blue Side Puzzles: 763
+      Green Side Puzzles: 764
+      Main Room Door: 2750
   the_orb:
     rooms:
       Main Area:
@@ -2261,6 +2356,7 @@ maps:
           COLOR: 823
           ETCH: 837
           FAINT: 821
+          FIZZLE: 2745
           HAD: 830
           HEAVY: 829
           LAY: 834
@@ -2293,11 +2389,10 @@ maps:
         panels:
           CRUSH: 845
           RAY: 846
-      R2C2.5 Bottom:
+      R2C3 Bottom:
         panels:
-          BLACK: 849
-          FIGMENT: 848
-          FIZZLE: 847
+          BLACK: 2747
+          FIGMENT: 2746
       Z Room:
         panels:
           MAZE: 850
@@ -2332,6 +2427,9 @@ maps:
           CLEOPATRA: 859
           NAPOLEON: 860
           XERXES: 857
+      U Keyholder:
+        keyholders:
+          U: 2777
     doors:
       K2 Door: 852
   the_partial:
@@ -2355,6 +2453,8 @@ maps:
           TON: 878
           TURN: 875
           UP: 870
+        keyholders:
+          L: 2771
       Reverse Side:
         panels:
           BRO: 884
@@ -2459,20 +2559,23 @@ maps:
           TYPIST BEAR RIGHT WING: 968
           WING: 950
     doors:
-      Bottom Left Door: 894
-      Bottom Left Puzzles: 898
-      Bottom Right Door: 895
-      Bottom Right Puzzles: 899
+      Northeast Door: 893
+      Northeast Puzzles: 897
+      Northwest Door: 892
+      Northwest Puzzles: 896
       Repetitive Entrance: 888
       Sirenic Entrance: 890
+      Southeast Door: 895
+      Southeast Puzzles: 899
+      Southwest Door: 894
+      Southwest Puzzles: 898
       Symbolic Entrance: 889
-      Top Left Door: 892
-      Top Left Puzzles: 896
-      Top Right Door: 893
-      Top Right Puzzles: 897
       Turtle Entrance: 891
   the_quiet:
     rooms:
+      Keyholder Room:
+        keyholders:
+          Q: 2778
       Main Area:
         panels:
           BEE: 979
@@ -2549,7 +2652,8 @@ maps:
     rooms:
       Anti Room:
         panels:
-          EYE: 1041
+          EYE (1): 1041
+          EYE (2): 2813
           HA (1): 1035
           HA (2): 1036
           HA (3): 1037
@@ -2656,7 +2760,9 @@ maps:
           W: 1117
           ZEROING: 1118
     doors:
+      Anti-Collectable: 2812
       Anti-Collectable Room: 1025
+      Black Hallway: 2780
       Cyan Door: 1028
       Cyan Puzzles: 1032
       Dot Area Entrance: 1026
@@ -2665,7 +2771,6 @@ maps:
       Lime Puzzles: 1031
       Magenta Door: 1029
       Magenta Puzzles: 1033
-      Plaza Entrance: 1024
       Yellow Door: 1030
       Yellow Puzzles: 1034
   the_revitalized:
@@ -2719,6 +2824,8 @@ maps:
           STIM: 1148
           STONE: 1142
           TADPOLES: 1159
+        keyholders:
+          N: 2779
     doors:
       Books Puzzles: 1136
       Games Puzzles: 1137
@@ -3029,22 +3136,15 @@ maps:
         panels:
           WHOLE: 2426
     doors:
-      Black Door: 2276
-      Blue Door: 2278
-      Green Door: 2279
       Main Area Fifth Row: 2290
       Main Area First Row: 2286
       Main Area Fourth Row: 2289
       Main Area Second Row: 2287
       Main Area Third Row: 2288
-      Orange Door: 2282
       Poetry Room Panels: 2285
-      Purple Door: 2281
-      Red Door: 2277
+      Tutorial Door: 2754
       Tutorial Panels: 2283
       Whirred Room Panels: 2284
-      White Door: 2275
-      Yellow Door: 2280
   the_talented:
     rooms:
       Back Room:
@@ -3073,6 +3173,8 @@ maps:
           SWINE (Brown): 2446
           WIFE (Black): 2440
           WIFE (Brown): 2447
+        keyholders:
+          Y: 2764
     doors:
       Black Side Panels: 2427
       Brown Side Panels: 2428
@@ -3085,6 +3187,9 @@ maps:
       Control Center Entrance:
         panels:
           ZERO: 2455
+      Main Area:
+        keyholders:
+          K: 2768
       Mastery:
         masteries:
           MASTERY: 2456
@@ -3243,6 +3348,115 @@ maps:
     doors:
       Control Center Brown Door: 2548
       The Tree Gravestone: 2549
+  the_unkempt:
+    rooms:
+      Control Center Entrance:
+        panels:
+          RETURN: 2587
+      Exit Room 2:
+        panels:
+          DOOR: 2590
+          FOUR: 2588
+          MINE: 2589
+          WINE: 2591
+      Exit Room 3:
+        panels:
+          ENTER: 2592
+      Main Area:
+        panels:
+          AISLE: 2614
+          CONTRITE: 2604
+          COUP: 2610
+          CRUTCH: 2603
+          DOUBTER: 2608
+          EYE: 2597
+          FLEW: 2611
+          GUILE: 2612
+          HEFT: 2596
+          I: 2593
+          MOON: 2618
+          MOONLIGHT: 2602
+          MUCH: 2609
+          NOON: 2617
+          PHASE: 2619
+          QUITE: 2600
+          ROUTER: 2605
+          SCALE: 2620
+          SHY: 2599
+          SIGHT: 2598
+          SOON: 2616
+          SPY: 2594
+          STOUTER: 2607
+          SUCH: 2601
+          THEFT: 2595
+          TONIGHT: 2606
+          TRAIL: 2622
+          WAYS: 2621
+          WHILE: 2613
+          ZOO: 2615
+        keyholders:
+          I: 2775
+      Middle Room:
+        panels:
+          FELLOW: 2624
+          FIDDLE: 2626
+          RIDDLE: 2623
+          YELLOW: 2625
+      Right Area:
+        panels:
+          BEEN: 2642
+          BLUFF: 2638
+          COLOR: 2649
+          CORN: 2635
+          DIET: 2647
+          FLOWER: 2633
+          FORTH: 2645
+          FOURTH: 2648
+          INN: 2639
+          MOURN: 2634
+          OFF: 2640
+          OUTDO: 2629
+          QUIET: 2646
+          SCOFF: 2643
+          SCUFF: 2636
+          SOUR: 2631
+          TATTOO: 2630
+          TOUGH: 2644
+          TOWER: 2627
+          TROUGH: 2641
+          UNTRUE: 2632
+          WARN: 2628
+          WIN: 2637
+      Unsymmetry Room:
+        panels:
+          ACCEPT: 2660
+          ACCIDENTAL: 2657
+          COMPLETE: 2658
+          CONFUSE: 2653
+          DISPROVE: 2661
+          ENROLL: 2659
+          ENTERTAIN: 2652
+          IMPARTIAL: 2651
+          SCRUTINIZE (Cyan): 2663
+          SCRUTINIZE (Purple): 2662
+          UNEXPECTED: 2655
+          UNINTERESTED: 2650
+          UNIRONIC: 2656
+          UNLUCKY: 2654
+      V Keyholder:
+        keyholders:
+          V: 2776
+      W Keyholder:
+        keyholders:
+          W: 2774
+    doors:
+      Cog Rhino Hug Rug: 2586
+      Control Center Orange Door: 2582
+      East Door: 2580
+      Honor Our Hint: 2585
+      Let Untrue Tie: 2583
+      Routine Out Chute: 2584
+      W2 Room Door: 2581
   the_unyielding:
     rooms:
       Behind Northeast:
@@ -3480,9 +3694,9 @@ maps:
           HEALTH: 1428
     doors:
       Bearer Entrance: 1259
-      Black Alcove: 2265
       Brown Alcove: 1255
       Digital Entrance: 1257
+      East Room 1: 2740
       East Room 1 Entrance: 1251
       Hero Room Entrance: 1252
       Jay Painting: 1253
@@ -3493,6 +3707,70 @@ maps:
       Southwest Corner Behind: 1254
       Southwest Room: 1431
       Yellow Room Puzzles: 1250
+  the_wise:
+    rooms:
+      Entry:
+        panels:
+          INK: 2667
+      Mastery:
+        masteries:
+          MASTERY: 2668
+      Puzzles:
+        panels:
+          BATH: 2679
+          BOTTLE: 2687
+          CHAOTIC: 2680
+          DARKNESS: 2677
+          EARTHWAR: 2685
+          ERAS: 2676
+          EYES: 2681
+          INTELLIGENCE: 2684
+          OBSCURE: 2674
+          PASSED: 2671
+          PRINCE: 2678
+          PROPHET: 2675
+          QUEENDOOM: 2682
+          RHYME: 2673
+          SHOUTS: 2683
+          SLEEPER: 2686
+          SLUMBERING: 2672
+          STORY: 2669
+          VENTURE: 2670
+          WORDS: 2688
+    doors:
+      Front Door: 2666
+  the_wondrous:
+    rooms:
+      Entry:
+        panels:
+          WONDER: 2690
+      Huge:
+        panels:
+          BARK: 2695
+          BRIE: 2693
+          CHIME: 2697
+          HARE: 2696
+          IRE: 2692
+          LIBRARY: 2698
+          SHRINK: 2691
+          WICK: 2694
+      Regular:
+        panels:
+          SHRINK: 2699
+    doors:
+      Shrink Door: 2689
+  the_words:
+    rooms:
+      Main Area:
+        panels:
+          CLOTHES: 2707
+          DAIRY: 2704
+          FLOWER: 2702
+          FRUIT: 2701
+          GEM: 2703
+          METAL: 2706
+          SPICE: 2708
+          TREE: 2705
 letters:
   a1: 596
   a2: 6
@@ -3536,8 +3814,10 @@ letters:
   t2: 2452
   u1: 263
   u2: 2140
+  v1: 2664
   v2: 2246
   w1: 681
+  w2: 2665
   x1: 394
   x2: 1192
   y1: 621
@@ -3546,14 +3826,74 @@ letters:
   z2: 2224
 endings:
   BLACK: 1208
+  BLUE: 2700
   CYAN: 1209
   GOLD: 1207
   GRAY: 1204
   GREEN: 1203
+  MINT: 2728
   ORANGE: 1775
   PLUM: 1205
   PURPLE: 1211
   RED: 2483
+  WHITE: 2738
   YELLOW: 1206
 special:
-  Nothing: 1160
+  A Job Well Done: 1160
+  Age Symbol: 2791
+  Anagram Symbol: 2792
+  Anti A: 2814
+  Anti B: 2815
+  Anti C: 2816
+  Anti D: 2817
+  Anti E: 2818
+  Anti F: 2819
+  Anti G: 2820
+  Anti H: 2821
+  Anti I: 2822
+  Anti J: 2823
+  Anti K: 2824
+  Anti L: 2825
+  Anti M: 2826
+  Anti N: 2827
+  Anti O: 2828
+  Anti P: 2829
+  Anti Q: 2830
+  Anti R: 2831
+  Anti S: 2832
+  Anti T: 2833
+  Anti U: 2834
+  Anti V: 2835
+  Anti W: 2836
+  Anti X: 2837
+  Anti Y: 2838
+  Anti Z: 2839
+  Boxes Symbol: 2793
+  Cross Symbol: 2794
+  Eval Symbol: 2795
+  Example Symbol: 2796
+  Gender Symbol: 2797
+  Job Symbol: 2798
+  Lingo Symbol: 2799
+  Null Symbol: 2800
+  Planet Symbol: 2801
+  Pyramid Symbol: 2802
+  Question Symbol: 2803
+  Sound Symbol: 2804
+  Sparkles Symbol: 2805
+  Stars Symbol: 2806
+  Sun Symbol: 2807
+  Sweet Symbol: 2808
+  Zero Symbol: 2809
+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
+  Cyan Doors: 2789
+  Lavender Cubes: 2790
+  The Entry - Repetitive Entrance: 2782
+  The Repetitive - Plaza Entrance: 2783
@@ -0,0 +1,85 @@
+connections {
+  from_room: "Entry"
+  to_room: "Main Area"
+  door { name: "Front Door" }
+}
+connections {
+  from_room: "Main Area"
+  to_room: "Stormy Entrance"
+  door { name: "Stormy Entrance" }
+}
+connections {
+  from_room: "Entry"
+  to_room: "Hide Room"
+  door { name: "Hidden Door" }
+}
+connections {
+  from_room: "Main Area"
+  to_room: "Mint Ending"
+  door { name: "Mint Ending Door" }
+}
+connections {
+  from_room: "Main Area"
+  to_room: "Entry Entrance"
+  door { name: "X1 Door" }
+}
+connections {
+  from_room: "Main Area"
+  to_room: "Unkempt Entrance"
+  door { name: "Unkempt Door" }
+}
+connections {
+  from_room: "Main Area"
+  to_room: "Partial Entrance"
+  door { name: "Partial Door" }
+}
+connections {
+  from_room: "Main Area"
+  to_room: "White Ending"
+  door { name: "White Ending Door" }
+}
+connections {
+  from_room: "Main Area"
+  to_room: "Repetitive Entrance"
+  door { name: "Repetitive Entrance" }
+}
+connections {
+  from_room: "Main Area"
+  to_room: "Perceptive Entrance"
+  door { name: "Perceptive From Outside" }
+}
+connections {
+  from_room: "Main Area"
+  to_room: "Perceptive Entrance"
+  door { name: "Perceptive From Inside" }
+}
+connections {
+  from_room: "Main Area"
+  to_room: "Ancient Entrance"
+  door { name: "Ancient Entrance" }
+}
+connections {
+  from_room: "Main Area"
+  to_room: "Between Entrance"
+  door { name: "Between Door" }
+}
+connections {
+  from_room: "Main Area"
+  to_room: "Desert Room"
+  door { name: "Desert Door" }
+}
+connections {
+  from_room: "Main Area"
+  to_room: "Shop Entrance"
+  door { name: "Shop Door" }
+}
+connections {
+  from_room: "Main Area"
+  to_room: "Tenacious Entrance"
+  door { name: "Tenacious Door" }
+}
+connections {
+  from_room: "Main Area"
+  to_room: "Unyielding Entrance"
+  door { name: "Unyielding Door" }
+}
@@ -0,0 +1,172 @@
+doors {
+  name: "Front Door"
+  type: STANDARD
+  receivers: "Components/Doors/entry_1"
+  panels { room: "Entry" name: "HELLO" }
+  location_room: "Entry"
+}
+doors {
+  name: "Stormy Entrance"
+  type: STANDARD
+  receivers: "Components/Doors/entry_13"
+  panels { room: "Hide Room" name: "HIDE" }
+  location_room: "Hide Room"
+}
+doors {
+  name: "Hidden Door"
+  type: EVENT
+  keyholders { room: "Main Area" name: "1" key: "h" }
+  keyholders { room: "Main Area" name: "2" key: "i" }
+  keyholders { room: "Main Area" name: "3" key: "d" }
+  keyholders { room: "Main Area" name: "4" key: "e" }
+}
+doors {
+  name: "Mint Ending Door"
+  type: EVENT
+  keyholders { room: "Main Area" name: "1" key: "e" }
+  keyholders { room: "Main Area" name: "2" key: "x" }
+  keyholders { room: "Main Area" name: "3" key: "i" }
+  keyholders { room: "Main Area" name: "4" key: "t" }
+}
+doors {
+  name: "Relentless Left Door"
+  type: EVENT
+  keyholders { room: "Main Area" name: "1" key: "l" }
+  keyholders { room: "Main Area" name: "2" key: "e" }
+  keyholders { room: "Main Area" name: "3" key: "f" }
+  keyholders { room: "Main Area" name: "4" key: "t" }
+}
+doors {
+  name: "Relentless Shop Door"
+  type: EVENT
+  keyholders { room: "Main Area" name: "1" key: "s" }
+  keyholders { room: "Main Area" name: "2" key: "h" }
+  keyholders { room: "Main Area" name: "3" key: "o" }
+  keyholders { room: "Main Area" name: "4" key: "p" }
+}
+doors {
+  name: "Relentless Turn Door"
+  type: EVENT
+  keyholders { room: "Main Area" name: "1" key: "t" }
+  keyholders { room: "Main Area" name: "2" key: "u" }
+  keyholders { room: "Main Area" name: "3" key: "r" }
+  keyholders { room: "Main Area" name: "4" key: "n" }
+}
+doors {
+  name: "X1 Door"
+  type: STANDARD
+  receivers: "Components/Doors/entry_3"
+  panels { room: "Entry Entrance" name: "ENTRY" }
+  location_room: "Entry Entrance"
+}
+doors {
+  name: "Unkempt Door"
+  type: STANDARD
+  receivers: "Components/Doors/entry_4"
+  panels { room: "Unkempt Entrance" name: "RETURN" }
+  location_room: "Unkempt Entrance"
+}
+doors {
+  name: "Partial Door"
+  type: STANDARD
+  receivers: "Components/Doors/entry_5"
+  panels { room: "Partial Entrance" name: "PARTIAL" }
+  location_room: "Partial Entrance"
+}
+doors {
+  name: "Link Blocker"
+  type: EVENT
+  panels { room: "Unkempt Entrance" name: "RETURN" }
+  panels { room: "Partial Entrance" name: "PARTIAL" }
+  panels { room: "Shop Entrance" name: "HOPS" }
+  panels { room: "Tenacious Entrance" name: "HERO" }
+}
+doors {
+  name: "White Ending Door"
+  type: EVENT
+  # This is the only time a door depends on endings. However, it's nice to do it
+  # this way instead of just checking for ending room access because this lets
+  # us use events, which makes the playthrough more readable.
+  endings: "MINT"
+  endings: "ORANGE"
+  endings: "GREEN"
+  endings: "GRAY"
+  endings: "PLUM"
+  endings: "YELLOW"
+  endings: "GOLD"
+  endings: "BLACK"
+  endings: "CYAN"
+  endings: "PURPLE"
+  endings: "RED"
+  endings: "BLUE"
+}
+doors {
+  name: "Repetitive Entrance"
+  type: STANDARD
+  receivers: "Components/Doors/entry_7"
+  keyholders { room: "Main Area" name: "1" key: "m" }
+  keyholders { room: "Main Area" name: "2" key: "o" }
+  keyholders { room: "Main Area" name: "3" key: "r" }
+  keyholders { room: "Main Area" name: "4" key: "e" }
+  location_room: "Main Area"
+  location_name: "Keyword MORE"
+}
+doors {
+  name: "Perceptive From Outside"
+  type: EVENT
+  keyholders { room: "Main Area" name: "1" key: "p" }
+  keyholders { room: "Main Area" name: "2" key: "a" }
+  keyholders { room: "Main Area" name: "3" key: "r" }
+  keyholders { room: "Main Area" name: "4" key: "t" }
+}
+doors {
+  name: "Perceptive From Inside"
+  type: EVENT
+  panels { room: "Perceptive Entrance" name: "PART" }
+}
+doors {
+  name: "Ancient Entrance"
+  type: STANDARD
+  receivers: "Components/Doors/entry_20"
+  keyholders { room: "Main Area" name: "1" key: "z" }
+  keyholders { room: "Main Area" name: "2" key: "e" }
+  keyholders { room: "Main Area" name: "3" key: "r" }
+  keyholders { room: "Main Area" name: "4" key: "o" }
+  location_room: "Main Area"
+  location_name: "Keyword ZERO"
+}
+doors {
+  name: "Between Door"
+  type: STANDARD
+  receivers: "Components/Doors/entry_8"
+  panels { room: "Between Entrance" name: "RIGHT" }
+  location_room: "Between Entrance"
+}
+doors {
+  name: "Desert Door"
+  type: STANDARD
+  receivers: "Components/Doors/entry_9"
+  panels { room: "Desert Room" name: "LESS" }
+  location_room: "Desert Room"
+}
+doors {
+  name: "Shop Door"
+  type: STANDARD
+  receivers: "Components/Doors/entry_23"
+  panels { room: "Shop Entrance" name: "HOPS" }
+  location_room: "Shop Entrance"
+}
+doors {
+  name: "Tenacious Door"
+  type: STANDARD
+  receivers: "Components/Doors/entry_24"
+  panels { room: "Tenacious Entrance" name: "HERO" }
+  location_room: "Tenacious Entrance"
+}
+doors {
+  name: "Unyielding Door"
+  type: STANDARD
+  receivers: "Components/Doors/entry_11"
+  panels { room: "Unyielding Entrance" name: "SEEK" }
+  location_room: "Unyielding Entrance"
+}
@@ -0,0 +1 @@
+display_name: "Control Center"
@@ -0,0 +1,10 @@
+name: "Ancient Entrance"
+ports {
+  name: "ANCIENT"
+  display_name: "Ancient Entrance"
+  path: "Components/Warps/worldport8"
+  destination { x: -27 y: 0 z: -34 }
+  rotation: 90
+  # TODO: shuffle entrances with dependent keyholders
+  no_shuffle: true
+}
@@ -0,0 +1,15 @@
+name: "Between Entrance"
+panels {
+  name: "RIGHT"
+  path: "Panels/Hallway Right/entry_4"
+  clue: "right"
+  answer: "left"
+  symbols: SUN
+}
+ports {
+  name: "BETWEEN"
+  display_name: "Between Connector"
+  path: "Components/Warps/worldport5"
+  destination { x: 39 y: 0 z: -17 }
+  rotation: 270
+}
@@ -0,0 +1,8 @@
+name: "Desert Room"
+panels {
+  name: "LESS"
+  path: "Panels/Hallway Right/entry_5"
+  clue: "less"
+  answer: "more"
+  symbols: SUN
+}
@@ -0,0 +1,15 @@
+name: "Entry Entrance"
+panels {
+  name: "ENTRY"
+  path: "Panels/Hallway Right/entry_3"
+  clue: "entry"
+  answer: "exit"
+  symbols: SUN
+}
+ports {
+  name: "ENTRY"
+  display_name: "Entry Connector"
+  path: "Components/Warps/worldport2"
+  destination { x: 26 y: 0 z: -16.5 }
+  rotation: 0
+}
@@ -0,0 +1,15 @@
+name: "Entry"
+panels {
+  name: "HELLO"
+  path: "Panels/Doors/entry_1"
+  clue: "hello"
+  answer: "hi"
+  symbols: SUN
+}
+ports {
+  name: "GREAT"
+  display_name: "Main Entrance"
+  path: "Components/Warps/worldport"
+  destination { x: 0 y: 0 z: -1.5 }
+  rotation: 0
+}
@@ -0,0 +1,8 @@
+name: "Hide Room"
+panels {
+  name: "HIDE"
+  path: "Panels/Doors/entry_4"
+  clue: "hide"
+  answer: "unmask"
+  symbols: SUN
+}
@@ -0,0 +1,81 @@
+name: "Main Area"
+panels {
+  name: "COLOR"
+  path: "Panels/Doors/entry_2"
+  clue: "color"
+  answer: "red"
+  proxies { answer: "red" path: "Panels/Colors/color_1" }
+  proxies { answer: "blue" path: "Panels/Colors/color_2" }
+  proxies { answer: "green" path: "Panels/Colors/color_3" }
+  proxies { answer: "yellow" path: "Panels/Colors/color_4" }
+  proxies { answer: "white" path: "Panels/Colors/color_5" }
+  proxies { answer: "black" path: "Panels/Colors/color_6" }
+  proxies { answer: "orange" path: "Panels/Colors/color_7" }
+  proxies { answer: "purple" path: "Panels/Colors/color_8" }
+  proxies { answer: "brown" path: "Panels/Colors/color_9" }
+  proxies { answer: "silver" path: "Panels/Colors/color_10" }
+  proxies { answer: "gold" path: "Panels/Colors/color_11" }
+  proxies { answer: "brass" path: "Panels/Colors/color_12" }
+  proxies { answer: "gray" path: "Panels/Colors/color_13" }
+  proxies { answer: "magenta" path: "Panels/Colors/color_14" }
+}
+panels {
+  name: "Letters"
+  path: "Panels/Doors/entry_6"
+  clue: ""
+  answer: "link"
+  symbols: LINGO
+  required_door { name: "Link Blocker" }
+}
+keyholders {
+  name: "1"
+  path: "Components/KeyHolders/keyHolder"
+  key: "z"
+}
+keyholders {
+  name: "2"
+  path: "Components/KeyHolders/keyHolder2"
+  key: "e"
+}
+keyholders {
+  name: "3"
+  path: "Components/KeyHolders/keyHolder3"
+  key: "r"
+}
+keyholders {
+  name: "4"
+  path: "Components/KeyHolders/keyHolder4"
+  key: "o"
+}
+ports {
+  name: "RIGHT"
+  display_name: "Hinterlands South Entrance"
+  path: "Components/Warps/worldport6"
+  destination { x: 82 y: 0 z: -10 }
+  rotation: 90
+}
+ports {
+  name: "LEFT"
+  display_name: "Hinterlands North Entrance"
+  path: "Components/Warps/worldport7"
+  destination { x: 82 y: 0 z: -48 }
+  rotation: 90
+}
+ports {
+  name: "RELENTLESS_LEFT"
+  display_name: "Relentless LEFT Entrance"
+  path: "Components/Warps/worldport9"
+  no_shuffle: true
+}
+ports {
+  name: "RELENTLESS_SHOP"
+  display_name: "Relentless SHOP Entrance"
+  path: "Components/Warps/worldport11"
+  no_shuffle: true
+}
+ports {
+  name: "RELENTLESS_TURN"
+  display_name: "Relentless TURN Entrance"
+  path: "Components/Warps/worldport10"
+  no_shuffle: true
+}
@@ -0,0 +1,5 @@
+name: "Mint Ending"
+endings {
+  name: "MINT"
+  path: "Components/Endings/mint_ending"
+}
@@ -0,0 +1,17 @@
+name: "Partial Entrance"
+panels {
+  name: "PARTIAL"
+  path: "Panels/Hallway Left/entry_5"
+  clue: "partial"
+  answer: "part"
+  symbols: SPARKLES
+}
+ports {
+  name: "PARTIAL"
+  display_name: "Partial Connector"
+  path: "Components/Warps/worldport4"
+  destination { x: 21 y: 0 z: -41 }
+  rotation: 270
+  # TODO: shuffle entrances with dependent keyholders
+  no_shuffle: true
+}
@@ -0,0 +1,25 @@
+name: "Perceptive Entrance"
+panels {
+  name: "PART"
+  path: "Panels/Doors/stormyPanel2"
+  clue: "part"
+  answer: "hole"
+  symbols: SUN
+  symbols: ZERO
+}
+panels {
+  name: "COLORS"
+  path: "Panels/Doors/stormyPanel3"
+  clue: "colors"
+  answer: "hues"
+  symbols: SUN
+}
+ports {
+  name: "PERCEPTIVE"
+  display_name: "Perceptive Entrance"
+  path: "Components/Warps/worldport12"
+  destination { x: -23 y: 0 z: -11 }
+  rotation: 0
+  # TODO: shuffle entrances with dependent keyholders
+  no_shuffle: true
+}
@@ -0,0 +1,10 @@
+name: "Repetitive Entrance"
+ports {
+  name: "REPETITIVE"
+  display_name: "Repetitive Entrance"
+  path: "Components/Warps/worldport14"
+  destination { x: -16 y: 0 z: -17.5 }
+  rotation: 0
+  # TODO: shuffle entrances with dependent keyholders
+  no_shuffle: true
+}
@@ -0,0 +1,9 @@
+name: "Shop Entrance"
+# The connection to The Shop isn't a worldport.
+panels {
+  name: "HOPS"
+  path: "Panels/Hallway Left/entry_6"
+  clue: "hops"
+  answer: "shop"
+  symbols: ANAGRAM
+}
@@ -0,0 +1,8 @@
+name: "Stormy Entrance"
+panels {
+  name: "TURN"
+  path: "Components/Warps/stormyPanel"
+  clue: "turn"
+  answer: "spin"
+  symbols: SUN
+}
@@ -0,0 +1,17 @@
+name: "Tenacious Entrance"
+panels {
+  name: "HERO"
+  path: "Panels/Hallway Left/entry_7"
+  clue: "hero"
+  answer: "zero"
+  symbols: ZERO
+}
+ports {
+  name: "TENACIOUS"
+  display_name: "Tenacious Connector"
+  path: "Components/Warps/worldport13"
+  destination { x: 56 y: 0 z: -38 }
+  rotation: 180
+  # TODO: shuffle entrances with dependent keyholders
+  no_shuffle: true
+}
@@ -0,0 +1,17 @@
+name: "Unkempt Entrance"
+panels {
+  name: "RETURN"
+  path: "Panels/Hallway Left/entry_4"
+  clue: "return"
+  answer: "turn"
+  symbols: SPARKLES
+}
+ports {
+  name: "UNKEMPT"
+  display_name: "Unkempt Connector"
+  path: "Components/Warps/worldport3"
+  destination { x: 34 y: 0 z: -38.5 }
+  rotation: 90
+  # TODO: shuffle entrances with dependent keyholders
+  no_shuffle: true
+}
@@ -0,0 +1,15 @@
+name: "Unyielding Entrance"
+panels {
+  name: "FORTH"
+  path: "Components/UnlockListeners/panelPorter"
+  clue: "forth"
+  answer: "back"
+  symbols: SUN
+}
+panels {
+  name: "SEEK"
+  path: "Panels/Hallway Right/entry_6"
+  clue: "seek"
+  answer: "hide"
+  symbols: SUN
+}
@@ -0,0 +1,5 @@
+name: "White Ending"
+endings {
+  name: "WHITE"
+  path: "Components/Endings/white_ending"
+}
@@ -100,6 +100,11 @@ connections {
   oneway: true
 }
 connections {
+  from_room: "Outside House"
+  to_room: "Blue Hallway Tall Side"
+  door { name: "House Side Door" }
+}
+connections {
   from_room: "Purple SE Vestibule"
   to_room: "Welcome Back Area"
   oneway: true
@@ -200,11 +205,16 @@ connections {
   door { name: "Temple of the Eyes Entrance" }
 }
 connections {
-  from_room: "Outside Eye Temple"
+  from_room: "Eye Painting"
   to_room: "Starting Room"
   door { name: "Starting Room South Wall West Door" }
 }
 connections {
+  from_room: "Eye Painting"
+  to_room: "Outside Eye Temple"
+  door { name: "Eye Painting Exit" }
+}
+connections {
   from_room: "Outside Pyramid"
   to_room: "Number Paintings Area"
   door { name: "Near Pyramid Gate" }
@@ -217,12 +227,12 @@ connections {
 connections {
   from_room: "West Castle Area"
   to_room: "Post Orange Smiley Three Way"
-  door { name: "Splintering Exit Left Door" }
+  door { name: "Splintering Exit North Door" }
 }
 connections {
   from_room: "West Castle Area"
   to_room: "Amber North 2"
-  door { name: "Splintering Exit Right Door" }
+  door { name: "Splintering Exit South Door" }
 }
 connections {
   from_room: "Z2 Room"
@@ -373,7 +383,7 @@ connections {
 connections {
   from_room: "O2 Room"
   to_room: "Blue Smiley"
-  door { name: "Blue Smiley Entrance" }
+  door { name: "O2 Room Southeast Door" }
 }
 connections {
   from_room: "O2 Room"
@@ -403,7 +413,7 @@ connections {
 connections {
   from_room: "O2 Room"
   to_room: "Blue Hallway"
-  door { name: "O2 Room Back Door" }
+  door { name: "O2 Room Northeast Door" }
 }
 connections {
   from_room: "O2 Room"
@@ -418,7 +428,7 @@ connections {
 connections {
   from_room: "Sweet Foyer"
   to_room: "F2 Room"
-  door { name: "F2 Room Entrance" }
+  door { name: "F2 Room Southeast Door" }
 }
 connections {
   from_room: "Globe Room"
@@ -433,17 +443,17 @@ connections {
 connections {
   from_room: "F2 Room"
   to_room: "Blue Hallway"
-  door { name: "F2 Room Back Right Door" }
+  door { name: "F2 Room Southwest Door" }
 }
 connections {
   from_room: "F2 Room"
   to_room: "Outside Salt Room"
-  door { name: "F2 Room Back Left Door" }
+  door { name: "F2 Room Northwest Door" }
 }
 connections {
   from_room: "F2 Room"
   to_room: "Red Color Door"
-  door { name: "F2 Room Back Middle Door" }
+  door { name: "F2 Room West Door" }
   oneway: true
   # This is the red backside, which has nothing in it. Maybe could be its own
   # region at some point.
@@ -456,7 +466,7 @@ connections {
 connections {
   from_room: "U2 Room"
   to_room: "Maze Paintings Area"
-  door { name: "U2 Room Shortcut" }
+  door { name: "U2 Room Southeast Door" }
 }
 connections {
   from_room: "Maze Paintings Area"
@@ -471,17 +481,17 @@ connections {
 connections {
   from_room: "U2 Room"
   to_room: "Purple SE Vestibule"
-  door { name: "U2 Room Back Right Door" }
+  door { name: "U2 Room Southwest Door" }
 }
 connections {
   from_room: "U2 Room"
   to_room: "Purple Room East"
-  door { name: "U2 Room Back Door" }
+  door { name: "U2 Room West Door" }
 }
 connections {
   from_room: "Maze"
   to_room: "U2 Room"
-  door { name: "U2 Room Entrance" }
+  door { name: "U2 Room East Door" }
 }
 connections {
   from_room: "Outside Magic Room"
@@ -506,7 +516,7 @@ connections {
 connections {
   from_room: "Wonderland"
   to_room: "Black Hex"
-  door { name: "Wonderland Right Door" }
+  door { name: "Wonderland South Door" }
 }
 connections {
   from_room: "Outside Pyramid"
@@ -530,6 +540,11 @@ connections {
 }
 connections {
   from_room: "Z2 Room"
+  to_room: "Orange Room Hallway"
+  door { name: "Z2 Room Southeast Door" }
+}
+connections {
+  from_room: "Orange Room Hallway"
   to_room: "Orange Room"
   door { name: "Z2 Room Southeast Door" }
 }
@@ -591,7 +606,7 @@ connections {
 connections {
   from_room: "Wonderland"
   to_room: "Number Paintings Area"
-  door { name: "Wonderland Left Door" }
+  door { name: "Wonderland North Door" }
 }
 connections {
   from_room: "Outside House"
@@ -1540,3 +1555,322 @@ connections {
   to_room: "Pyramid Top"
   door { name: "Pyramid Third Floor Door" }
 }
+connections {
+  from_room: "Roof"
+  to_room: "After Bee Room"
+  oneway: true
+  roof_access: true
+}
+connections {
+  from_room: "Roof"
+  to_room: "Amber North 2"
+  oneway: true
+  roof_access: true
+}
+connections {
+  from_room: "Roof"
+  to_room: "Black Hex"
+  oneway: true
+  roof_access: true
+}
+connections {
+  from_room: "Roof"
+  to_room: "Blue Hallway Tall Side"
+  oneway: true
+  roof_access: true
+}
+connections {
+  from_room: "Roof"
+  to_room: "Blue Hallway"
+  oneway: true
+  roof_access: true
+}
+# Blue Hallway Cut Side is inside.
+connections {
+  from_room: "Roof"
+  to_room: "Eye Painting"
+  oneway: true
+  roof_access: true
+}
+connections {
+  from_room: "Roof"
+  to_room: "Globe Room"
+  oneway: true
+  roof_access: true
+}
+connections {
+  from_room: "Roof"
+  to_room: "Gray Color Door"
+  oneway: true
+  roof_access: true
+}
+connections {
+  from_room: "Roof"
+  to_room: "Green Color Door"
+  oneway: true
+  roof_access: true
+}
+connections {
+  from_room: "Roof"
+  to_room: "Green Smiley"
+  oneway: true
+  roof_access: true
+}
+connections {
+  from_room: "Roof"
+  to_room: "Hedges"
+  oneway: true
+  roof_access: true
+}
+connections {
+  from_room: "Roof"
+  to_room: "Maze Paintings Area"
+  oneway: true
+  roof_access: true
+}
+connections {
+  from_room: "Roof"
+  to_room: "Maze"
+  oneway: true
+  roof_access: true
+}
+connections {
+  from_room: "Roof"
+  to_room: "North Castle Area"
+  oneway: true
+  roof_access: true
+}
+connections {
+  from_room: "Roof"
+  to_room: "Number Paintings Area"
+  oneway: true
+  roof_access: true
+}
+connections {
+  from_room: "Roof"
+  to_room: "Orange Room Hallway"
+  oneway: true
+  roof_access: true
+}
+connections {
+  from_room: "Roof"
+  to_room: "Outside Book Room"
+  oneway: true
+  roof_access: true
+}
+connections {
+  from_room: "Roof"
+  to_room: "Outside Eye Temple"
+  oneway: true
+  roof_access: true
+}
+connections {
+  from_room: "Roof"
+  to_room: "Outside Hedges"
+  oneway: true
+  roof_access: true
+}
+connections {
+  from_room: "Roof"
+  to_room: "Outside Hotel"
+  oneway: true
+  roof_access: true
+}
+connections {
+  from_room: "Roof"
+  to_room: "Outside House"
+  oneway: true
+  roof_access: true
+}
+connections {
+  from_room: "Roof"
+  to_room: "Outside Magic Room"
+  oneway: true
+  roof_access: true
+}
+connections {
+  from_room: "Roof"
+  to_room: "Outside Orange Room"
+  oneway: true
+  roof_access: true
+}
+connections {
+  from_room: "Roof"
+  to_room: "Outside Pyramid"
+  oneway: true
+  roof_access: true
+}
+connections {
+  from_room: "Roof"
+  to_room: "Outside Red Room"
+  oneway: true
+  roof_access: true
+}
+connections {
+  from_room: "Roof"
+  to_room: "Outside Salt Room"
+  oneway: true
+  roof_access: true
+}
+connections {
+  from_room: "Roof"
+  to_room: "Outside Snake Room"
+  oneway: true
+  roof_access: true
+}
+connections {
+  from_room: "Roof"
+  to_room: "Post Orange Smiley Three Way"
+  oneway: true
+  roof_access: true
+}
+connections {
+  from_room: "Roof"
+  to_room: "Purple NW Vestibule"
+  oneway: true
+  roof_access: true
+}
+connections {
+  from_room: "Roof"
+  to_room: "Purple Room East"
+  oneway: true
+  roof_access: true
+}
+connections {
+  from_room: "Roof"
+  to_room: "Purple Room South"
+  oneway: true
+  roof_access: true
+}
+connections {
+  from_room: "Roof"
+  to_room: "Purple Room West"
+  oneway: true
+  roof_access: true
+}
+connections {
+  from_room: "Roof"
+  to_room: "Purple SE Vestibule"
+  oneway: true
+  roof_access: true
+}
+connections {
+  from_room: "Roof"
+  to_room: "Pyramid Second Floor"
+  oneway: true
+  roof_access: true
+}
+connections {
+  from_room: "Roof"
+  to_room: "Pyramid Top"
+  oneway: true
+  roof_access: true
+}
+connections {
+  from_room: "Roof"
+  to_room: "Quiet Entrance"
+  oneway: true
+  roof_access: true
+}
+connections {
+  from_room: "Roof"
+  to_room: "Red Color Door"
+  oneway: true
+  roof_access: true
+}
+connections {
+  from_room: "Roof"
+  to_room: "South Castle Area"
+  oneway: true
+  roof_access: true
+}
+connections {
+  from_room: "Roof"
+  to_room: "Starting Room"
+  oneway: true
+  roof_access: true
+}
+connections {
+  from_room: "Roof"
+  to_room: "Sweet Foyer"
+  oneway: true
+  roof_access: true
+}
+connections {
+  from_room: "Roof"
+  to_room: "Tree Entrance"
+  oneway: true
+  roof_access: true
+}
+connections {
+  from_room: "Roof"
+  to_room: "West Castle Area"
+  oneway: true
+  roof_access: true
+}
+connections {
+  from_room: "Roof"
+  to_room: "West Spire"
+  oneway: true
+  roof_access: true
+}
+connections {
+  from_room: "Roof"
+  to_room: "Yellow Color Door"
+  oneway: true
+  roof_access: true
+}
+connections {
+  from_room: "Roof"
+  to_room: "Z2 Room"
+  oneway: true
+  roof_access: true
+}
+connections {
+  from_room: "Roof"
+  to_room: "Zoo Center"
+  oneway: true
+  roof_access: true
+}
+connections {
+  from_room: "Roof"
+  to_room: "Zoo E"
+  oneway: true
+  roof_access: true
+}
+connections {
+  from_room: "Roof"
+  to_room: "Zoo N"
+  oneway: true
+  roof_access: true
+}
+connections {
+  from_room: "Roof"
+  to_room: "Zoo NE"
+  oneway: true
+  roof_access: true
+}
+connections {
+  from_room: "Roof"
+  to_room: "Zoo S"
+  oneway: true
+  roof_access: true
+}
+connections {
+  from_room: "Roof"
+  to_room: "Zoo SE"
+  oneway: true
+  roof_access: true
+}
+connections {
+  from_room: "Roof"
+  to_room: "F Keyholder"
+  oneway: true
+  roof_access: true
+}
+connections {
+  from_room: "Roof"
+  to_room: "Yellow Color Backside"
+  oneway: true
+  roof_access: true
+}
@@ -188,16 +188,15 @@ doors {
 }
 doors {
   name: "Welcome Back Secret Door"
-  type: STANDARD
+  type: ITEM_ONLY
   receivers: "Components/Doors/Entry/entry_13"
   panels { room: "Welcome Back Area" name: "FAREWELL LITTLE LAMB" }
   panels { room: "West Spire" name: "BYE" }
-  location_room: "West Spire"
 }
 doors {
   name: "Welcome Back Door"
-  type: STANDARD
-  receivers: "Components/Doors/Entry/entry_14"
+  type: LOCATION_ONLY
+  #receivers: "Components/Doors/Entry/entry_14"
   panels { room: "Welcome Back Area" name: "GREETINGS OLD FRIEND" }
   location_room: "Welcome Back Area"
 }
@@ -296,9 +295,10 @@ doors {
   panels { room: "Black Hex" name: "CLUES" }
   panels { room: "Black Hex" name: "SECRET" }
   location_room: "Black Hex"
+  location_name: "Black Hex"
 }
 doors {
-  name: "Splintering Exit Left Door"
+  name: "Splintering Exit North Door"
   type: STANDARD
   receivers: "Components/Doors/Entry/gate_4"
   panels { room: "West Castle Area" name: "EVER" }
@@ -308,7 +308,7 @@ doors {
   location_room: "West Castle Area"
 }
 doors {
-  name: "Splintering Exit Right Door"
+  name: "Splintering Exit South Door"
   type: ITEM_ONLY
   receivers: "Components/Doors/Entry/gate_5"
   panels { room: "West Castle Area" name: "EVER" }
@@ -382,6 +382,7 @@ doors {
   panels { room: "Z2 Room" name: "CAPE" }
   panels { room: "Z2 Room" name: "GLANCE" }
   location_room: "Z2 Room"
+  location_name: "West Puzzles"
 }
 doors {
   name: "Z2 Room Northwest Door"
@@ -413,6 +414,7 @@ doors {
   panels { room: "Z2 Room" name: "DISCORD" }
   panels { room: "Z2 Room" name: "CAT" }
   location_room: "Z2 Room"
+  location_name: "East Puzzles"
 }
 doors {
   name: "Z2 Room Southeast Door"
@@ -517,6 +519,7 @@ doors {
   panels { room: "Outside House" name: "BLITHELY" }
   panels { room: "Purple Room South" name: "THESE" }
   location_room: "Outside House"
+  location_name: "West Purple Vestibules"
 }
 doors {
   name: "Purple West Area South Door"
@@ -545,6 +548,7 @@ doors {
   panels { room: "Godot Room" name: "TRAIN" }
   panels { room: "Godot Room" name: "RECORDING" }
   location_room: "Godot Room"
+  location_name: "Godot Room"
 }
 doors {
   name: "Beehalls Intersection"
@@ -576,6 +580,7 @@ doors {
   panels { room: "Purple Room South" name: "ANY" }
   panels { room: "Outside House" name: "A" }
   location_room: "Outside House"
+  location_name: "East Purple Vestibules"
 }
 doors {
   name: "Purple East Area North Door"
@@ -593,6 +598,7 @@ doors {
   panels { room: "Outside House" name: "BLITHELY" }
   panels { room: "Purple Room South" name: "THESE" }
   location_room: "Outside House"
+  location_name: "Purple Vestibules"
 }
 doors {
   name: "Purple Room South Entrance"
@@ -622,6 +628,20 @@ doors {
   panels { room: "Purple Room South" name: "THESE" }
 }
 doors {
+  name: "Purple Room"
+  type: LOCATION_ONLY
+  panels { room: "Purple Room" name: "HOIST" }
+  panels { room: "Purple Room" name: "CORE" }
+  panels { room: "Purple Room" name: "FISH" }
+  panels { room: "Purple Room" name: "ALLOW" }
+  panels { room: "Purple Room" name: "BIRD" }
+  panels { room: "Purple Room" name: "HONK" }
+  panels { room: "Purple Room" name: "APE" }
+  panels { room: "Purple Room" name: "APATHY" }
+  location_room: "Purple Room"
+  location_name: "Puzzles"
+}
+doors {
   name: "Hedges Tower"
   type: LOCATION_ONLY
   # TODO: Not making this an item right now in order to force the player to
@@ -676,6 +696,7 @@ doors {
   panels { room: "Blue Room" name: "CELEBRATORY" }
   panels { room: "Blue Room" name: "DETECTIVE" }
   location_room: "Blue Room"
+  location_name: "Puzzles"
 }
 doors {
   name: "O2 Prize"
@@ -694,7 +715,7 @@ doors {
   panels { room: "O2 Room" name: "UNBLOCKED" }
 }
 doors {
-  name: "Blue Smiley Entrance"
+  name: "O2 Room Southeast Door"
   type: STANDARD
   receivers: "Components/Doors/Halls/oroom_2"
   panels { room: "O2 Room" name: "HONEST" }
@@ -734,6 +755,7 @@ doors {
   panels { room: "Composite Room S" name: "BLEAKCARD" }
   panels { room: "Composite Room S" name: "MISSIONMISSION" }
   location_room: "Composite Room S"
+  location_name: "East Rooms"
 }
 doors {
   name: "Composite Room North Door"
@@ -762,6 +784,7 @@ doors {
   panels { room: "Composite Room NW" name: "OUTGARDEN" }
   panels { room: "Composite Room NW" name: "HELLOTALE" }
   location_room: "Composite Room NE"
+  location_name: "North Rooms"
 }
 doors {
   name: "Composite Room West Door"
@@ -792,12 +815,13 @@ doors {
   panels { room: "Composite Room S" name: "OUTEAT" }
   panels { room: "Composite Room S" name: "SUMMERIN" }
   location_room: "Composite Room NW"
+  location_name: "West Rooms"
 }
 doors {
   name: "Composite Room NW Entrance"
   type: STANDARD
   receivers: "Components/Doors/Halls/oroom_10"
-  panels { room: "Red Color Door" name: "Left" }
+  panels { room: "Red Color Door" name: "Near Obscured Puzzles" }
   location_room: "Red Color Door"
 }
 doors {
@@ -829,9 +853,10 @@ doors {
   panels { room: "Composite Room S" name: "OUTEAT" }
   panels { room: "Composite Room S" name: "SUMMERIN" }
   location_room: "Composite Room S"
+  location_name: "South Rooms"
 }
 doors {
-  name: "O2 Room Back Door"
+  name: "O2 Room Northeast Door"
   type: STANDARD
   receivers: "Components/Doors/Halls/oroom_4"
   panels { room: "O2 Room" name: "UNBLOCKED" }
@@ -858,7 +883,7 @@ doors {
   panels { room: "F2 Room" name: "SHAPE" }
 }
 doors {
-  name: "F2 Room Entrance"
+  name: "F2 Room Southeast Door"
   type: STANDARD
   receivers: "Components/Doors/Halls/froom_2"
   panels { room: "Sweet Foyer" name: "RENT (1)" }
@@ -866,36 +891,32 @@ 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"
 }
 doors {
-  name: "F2 Room Back Right Door"
+  name: "F2 Room Southwest Door"
   type: STANDARD
   receivers: "Components/Doors/Halls/froom_3"
   panels { room: "F2 Room" name: "RISKY" }
   location_room: "F2 Room"
 }
 doors {
-  name: "F2 Room Back Left Door"
+  name: "F2 Room Northwest Door"
   type: STANDARD
   receivers: "Components/Doors/Halls/froom_4"
   panels { room: "F2 Room" name: "SHAPE" }
   location_room: "F2 Room"
 }
 doors {
-  name: "F2 Room Back Middle Door"
+  name: "F2 Room West Door"
   type: STANDARD
   receivers: "Components/Doors/Halls/froom_5"
   panels { room: "F2 Room" name: "DIRT" }
@@ -916,7 +937,7 @@ doors {
   panels { room: "U2 Room" name: "HEAVEN" }
 }
 doors {
-  name: "U2 Room Shortcut"
+  name: "U2 Room Southeast Door"
   type: STANDARD
   receivers: "Components/Doors/Halls/uroom_2"
   panels { room: "U2 Room" name: "WICKED" }
@@ -937,21 +958,21 @@ doors {
   location_room: "House Entrance"
 }
 doors {
-  name: "U2 Room Back Right Door"
+  name: "U2 Room Southwest Door"
   type: STANDARD
   receivers: "Components/Doors/Halls/uroom_3"
   panels { room: "U2 Room" name: "HEAVEN" }
   location_room: "U2 Room"
 }
 doors {
-  name: "U2 Room Back Door"
+  name: "U2 Room West Door"
   type: ITEM_ONLY
   receivers: "Components/Doors/Halls/uroom_5"
   panels { room: "Purple Room South" name: "ANY" }
   panels { room: "Outside House" name: "A" }
 }
 doors {
-  name: "U2 Room Entrance"
+  name: "U2 Room East Door"
   type: ITEM_ONLY
   receivers: "Components/Doors/Halls/uroom_4"
   panels { room: "Outside Magic Room" name: "WIZARD" }
@@ -995,7 +1016,7 @@ doors {
   panels { room: "Outside Magic Room" name: "WIZARD" }
 }
 doors {
-  name: "Wonderland Right Door"
+  name: "Wonderland South Door"
   type: STANDARD
   receivers: "Components/Doors/Halls/wonderland_1"
   panels { room: "Wonderland" name: "APRIL" }
@@ -1004,6 +1025,7 @@ doors {
   panels { room: "Wonderland" name: "ARTS" }
   panels { room: "Wonderland" name: "SONG" }
   location_room: "Wonderland"
+  location_name: "Wonderland"
 }
 doors {
   name: "Pyramid Entrance"
@@ -1034,6 +1056,7 @@ doors {
   panels { room: "Orange Room" name: "COAL" }
   panels { room: "Orange Room" name: "OWED" }
   location_room: "Orange Room"
+  location_name: "Puzzles"
 }
 doors {
   name: "Hedges Entrance"
@@ -1052,6 +1075,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"
@@ -1060,6 +1084,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"
@@ -1182,70 +1207,37 @@ doors {
   type: ITEM_ONLY
   receivers: "Components/Doors/Halls/connections_1"
   receivers: "Components/Doors/Halls/connections_3"
+  # These have the same effect as the above, but including them here prevents
+  # them from opening in door shuffle when the J2 door opens.
+  receivers: "Components/Triggers/teleportListenerConnections3"
+  receivers: "Components/Triggers/teleportListenerConnections4"
+  # This door can open from either solving all panels, or just the smiley ones,
+  # and the latter is obviously a subset of the former so let's just check for
+  # that.
   panels { room: "Hotel" name: "PARKA" }
-  panels { room: "Hotel" name: "MARLIN" }
-  panels { room: "Hotel" name: "WHO" }
   panels { room: "Hotel" name: "CLOAK" }
-  panels { room: "Hotel" name: "MANE" }
-  panels { room: "Hotel" name: "WHAT" }
-  panels { room: "Hotel" name: "BLAZER" }
-  panels { room: "Hotel" name: "WHERE" }
   panels { room: "Hotel" name: "DOROTHY" }
-  panels { room: "Hotel" name: "JACKET" }
-  panels { room: "Hotel" name: "TAIL" }
   panels { room: "Hotel" name: "JAWS" }
-  panels { room: "Hotel" name: "FLOUNDER" }
   panels { room: "Hotel" name: "WHEN" }
   panels { room: "Hotel" name: "CLAWS" }
-  panels { room: "Hotel" name: "BRUCE" }
   panels { room: "Hotel" name: "POTATO" }
-  panels { room: "Hotel" name: "SALAD" }
-  panels { room: "Hotel" name: "BATHING" }
   panels { room: "Hotel" name: "MICRO" }
-  panels { room: "Hotel" name: "BUSINESS" }
-  panels { room: "Hotel" name: "WEDDING" }
-  panels { room: "Hotel" name: "TREE" }
-  panels { room: "Hotel" name: "RIVER" }
   panels { room: "Hotel" name: "TUNING" }
-  panels { room: "Hotel" name: "BOXING" }
-  panels { room: "Hotel" name: "TELEPHONE" }
   panels { room: "Hotel" name: "LAW" }
-  panels { room: "Hotel" name: "POKER" }
   panels { room: "Hotel" name: "CARD" }
   panels { room: "Hotel" name: "ROAD" }
-  panels { room: "Hotel" name: "CHOCOLATE" }
   panels { room: "Hotel" name: "DEPART" }
-  panels { room: "Hotel" name: "WITHDRAW" }
-  panels { room: "Hotel" name: "QUIT" }
   panels { room: "Hotel" name: "LEAVE" }
-  panels { room: "Hotel" name: "PALE" }
-  panels { room: "Hotel" name: "JUST" }
-  panels { room: "Hotel" name: "NEW" }
-  panels { room: "Hotel" name: "UNTALENTED" }
   panels { room: "Hotel" name: "SERVICE" }
-  panels { room: "Hotel" name: "FULL" }
-  panels { room: "Hotel" name: "EVIL" }
   panels { room: "Hotel" name: "HONEY" }
-  panels { room: "Hotel" name: "CRESCENT" }
   panels { room: "Hotel" name: "INVALID" }
   panels { room: "Hotel" name: "FESTIVAL" }
-  panels { room: "Hotel" name: "BEAUTIFUL" }
   panels { room: "Hotel" name: "WILTED" }
-  panels { room: "Hotel" name: "DROOPED" }
-  panels { room: "Hotel" name: "FADED" }
   panels { room: "Hotel" name: "WANED" }
-  panels { room: "Hotel" name: "TALL" }
-  panels { room: "Hotel" name: "CANVAS" }
-  panels { room: "Hotel" name: "LEVER" }
-  panels { room: "Hotel" name: "SCULPTURE" }
   panels { room: "Hotel" name: "RAGE" }
-  panels { room: "Hotel" name: "BALL" }
-  panels { room: "Hotel" name: "FOOL" }
   panels { room: "Hotel" name: "VERGE" }
-  panels { room: "Hotel" name: "ART" }
   panels { room: "Hotel" name: "EVER" }
   panels { room: "Hotel" name: "PAIN" }
-  panels { room: "Hotel" name: "FOOT" }
 }
 doors {
   name: "J2 Door 1"
@@ -1281,7 +1273,7 @@ doors {
   panels { room: "J2 Vestibule" name: "COLORFUL" }
 }
 doors {
-  name: "Wonderland Left Door"
+  name: "Wonderland North Door"
   type: ITEM_ONLY
   receivers: "Components/Doors/Halls/wonderland_2"
   panels { room: "Wonderland" name: "APRIL" }
@@ -1389,12 +1381,32 @@ doors {
 }
 doors {
   name: "Roof Access"
-  type: STANDARD
+  type: ITEM_ONLY
   receivers: "Components/Doors/Castle/entry_stairs_big"
   receivers: "Components/Doors/Castle/entry_stairs_big2"
+  receivers: "Meshes/Stairs/staircase31/teleportListener"
+  receivers: "Meshes/Stairs/staircase32/teleportListener2"
+  receivers: "Meshes/Stairs/staircase33/teleportListener3"
   panels { room: "North Castle Area" name: "A SUMMER PLACE" }
   panels { room: "West Castle Area" name: "SONG FACE" }
   panels { room: "South Castle Area" name: "AN OFFER VILLAGE BEFORE LAIR" }
+}
+doors {
+  name: "North Castle Panel"
+  type: LOCATION_ONLY
+  panels { room: "North Castle Area" name: "A SUMMER PLACE" }
+  location_room: "North Castle Area"
+}
+doors {
+  name: "West Castle Panel"
+  type: LOCATION_ONLY
+  panels { room: "West Castle Area" name: "SONG FACE" }
+  location_room: "West Castle Area"
+}
+doors {
+  name: "South Castle Panel"
+  type: LOCATION_ONLY
+  panels { room: "South Castle Area" name: "AN OFFER VILLAGE BEFORE LAIR" }
   location_room: "South Castle Area"
 }
 doors {
@@ -1411,6 +1423,7 @@ doors {
   panels { room: "West Spire" name: "CUT" }
   panels { room: "West Spire" name: "STONES" }
   location_room: "West Spire"
+  location_name: "Pairs Room Puzzles"
 }
 doors {
   name: "Pairs Room West Door"
@@ -1453,87 +1466,87 @@ doors {
 }
 doors {
   name: "Red Rainbow Room"
-  type: ITEM_ONLY
+  type: STANDARD
   receivers: "Components/Doors/Color Reading/door_3"
   panels { room: "Rainbow Start" name: "PAINTING" }
-  panels { room: "Red Smiley" name: "SMILE" }
+  location_room: "Rainbow Start"
 }
 doors {
   name: "Orange Rainbow Room"
   type: ITEM_ONLY
   receivers: "Components/Doors/Color Reading/door_4"
   panels { room: "Rainbow Red" name: "THEME" }
-  panels { room: "Outside Orange Room" name: "SMILE" }
+  panels { room: "Red Smiley" name: "SMILE" }
 }
 doors {
   name: "Yellow Rainbow Room"
   type: ITEM_ONLY
   receivers: "Components/Doors/Color Reading/door_17"
   panels { room: "Rainbow Orange" name: "THEME" }
-  panels { room: "Hedges" name: "SMILE" }
+  panels { room: "Outside Orange Room" name: "SMILE" }
 }
 doors {
   name: "Green Rainbow Room"
   type: ITEM_ONLY
   receivers: "Components/Doors/Color Reading/door_5"
   panels { room: "Rainbow Yellow" name: "THEME" }
-  panels { room: "Green Smiley" name: "SMILE" }
+  panels { room: "Hedges" name: "SMILE" }
 }
 doors {
   name: "Blue Rainbow Room"
   type: ITEM_ONLY
   receivers: "Components/Doors/Color Reading/door_6"
   panels { room: "Rainbow Green" name: "THEME" }
-  panels { room: "Blue Smiley" name: "SMILE" }
+  panels { room: "Green Smiley" name: "SMILE" }
 }
 doors {
   name: "Purple Rainbow Room"
   type: ITEM_ONLY
   receivers: "Components/Doors/Color Reading/door_7"
   panels { room: "Rainbow Blue" name: "THEME" }
-  panels { room: "Purple Smiley" name: "SMILE" }
+  panels { room: "Blue Smiley" name: "SMILE" }
 }
 doors {
   name: "Red Rainbow Panel"
   type: LOCATION_ONLY
-  panels { room: "Rainbow Start" name: "PAINTING" }
-  location_room: "Rainbow Start"
-}
-doors {
-  name: "Orange Rainbow Panel"
-  type: LOCATION_ONLY
   panels { room: "Rainbow Red" name: "THEME" }
   location_room: "Rainbow Red"
 }
 doors {
-  name: "Yellow Rainbow Panel"
+  name: "Orange Rainbow Panel"
   type: LOCATION_ONLY
   panels { room: "Rainbow Orange" name: "THEME" }
   location_room: "Rainbow Orange"
 }
 doors {
-  name: "Green Rainbow Panel"
+  name: "Yellow Rainbow Panel"
   type: LOCATION_ONLY
   panels { room: "Rainbow Yellow" name: "THEME" }
   location_room: "Rainbow Yellow"
 }
 doors {
-  name: "Blue Rainbow Panel"
+  name: "Green Rainbow Panel"
   type: LOCATION_ONLY
   panels { room: "Rainbow Green" name: "THEME" }
   location_room: "Rainbow Green"
 }
 doors {
-  name: "Purple Rainbow Panel"
+  name: "Blue Rainbow Panel"
   type: LOCATION_ONLY
   panels { room: "Rainbow Blue" name: "THEME" }
   location_room: "Rainbow Blue"
 }
 doors {
   name: "Cyan Rainbow Room"
-  type: STANDARD
+  type: ITEM_ONLY
   receivers: "Components/Doors/Color Reading/door_18"
   panels { room: "Rainbow Purple" name: "THEME" }
+  panels { room: "Purple Smiley" name: "SMILE" }
+}
+doors {
+  name: "Purple Rainbow Panel"
+  type: LOCATION_ONLY
+  panels { room: "Rainbow Purple" name: "THEME" }
   location_room: "Rainbow Purple"
 }
 doors {
@@ -1542,6 +1555,7 @@ doors {
   receivers: "Components/Doors/Color Reading/door_8"
   panels { room: "Rainbow Cyan" name: "THEME" }
   location_room: "Rainbow Cyan"
+  location_name: "Cyan Rainbow Panel"
 }
 doors {
   name: "Pepper Room Entrance"
@@ -1565,6 +1579,7 @@ doors {
   panels { room: "Salt Room" name: "SEASONING" }
   panels { room: "Pepper Room" name: "SEASONING" }
   location_room: "Pepper Room"
+  location_name: "Seasonings"
 }
 doors {
   name: "Bow Side"
@@ -1600,6 +1615,7 @@ doors {
   # Components/Doors/Smileys/blue_1
   panels { room: "Blue Smiley" name: "SMILE" }
   location_room: "Blue Smiley"
+  location_name: "Blue SMILE"
 }
 doors {
   name: "Blue Smiley Annex"
@@ -1631,6 +1647,7 @@ doors {
   receivers: "Components/Doors/Smileys/yellow_2"
   panels { room: "Hedges" name: "SMILE" }
   location_room: "Hedges"
+  location_name: "Yellow SMILE"
 }
 doors {
   name: "Green Smiley"
@@ -1639,6 +1656,7 @@ doors {
   receivers: "Components/Doors/Smileys/green_2"
   panels { room: "Green Smiley" name: "SMILE" }
   location_room: "Green Smiley"
+  location_name: "Green SMILE"
 }
 doors {
   name: "Orange Smiley Exit"
@@ -1646,6 +1664,7 @@ doors {
   receivers: "Components/Doors/Smileys/orange_1"
   panels { room: "Outside Orange Room" name: "SMILE" }
   location_room: "Outside Orange Room"
+  location_name: "Orange SMILE"
 }
 doors {
   name: "F Keyholder Door"
@@ -1670,6 +1689,7 @@ doors {
   type: LOCATION_ONLY
   panels { room: "Red Smiley" name: "SMILE" }
   location_room: "Red Smiley"
+  location_name: "Red SMILE"
 }
 doors {
   name: "Pink Hallway"
@@ -1708,6 +1728,7 @@ doors {
   panels { room: "Cyan Room" name: "COLD" }
   panels { room: "Cyan Room" name: "WORDWORD" }
   location_room: "Cyan Room"
+  location_name: "Puzzles"
 }
 doors {
   name: "Green Room Entrance"
@@ -1731,6 +1752,7 @@ doors {
   panels { room: "Green Room" name: "DOUBLE" }
   panels { room: "Green Room" name: "BADMINTON" }
   location_room: "Green Room"
+  location_name: "Puzzles"
 }
 doors {
   name: "Blue Hallway South Divider"
@@ -1769,6 +1791,7 @@ doors {
   panels { room: "Red Room" name: "TESTAMENT" }
   panels { room: "Red Room" name: "TAKEOUT" }
   location_room: "Red Room"
+  location_name: "Puzzles"
 }
 doors {
   name: "Blue Hallway To Red Room"
@@ -1782,6 +1805,7 @@ doors {
   panels { room: "Blue Hallway" name: "CHOP" }
   panels { room: "Blue Hallway Tall Side" name: "TALL" }
   location_room: "Blue Hallway Tall Side"
+  location_name: "CHOP, TALL"
 }
 doors {
   name: "Near Yellow Room Door"
@@ -1794,6 +1818,7 @@ doors {
   panels { room: "Blue Hallway Tall Side" name: "CHILD" }
   panels { room: "Blue Hallway Tall Side" name: "NEW" }
   location_room: "Blue Hallway Tall Side"
+  location_name: "Pink Hex"
 }
 doors {
   name: "House Side Door"
@@ -1830,6 +1855,7 @@ doors {
   panels { room: "Yellow Room" name: "PROTON" }
   panels { room: "Yellow Room" name: "SPIRIT" }
   location_room: "Yellow Room"
+  location_name: "Puzzles"
 }
 doors {
   name: "Dark Light Room Entrance"
@@ -1865,6 +1891,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"
@@ -1884,6 +1911,7 @@ doors {
   # Not technically true; it's complete_at=11 with both rooms, but you couldn't
   # get to the other side in vanilla doors anyway.
   location_room: "Dark Light Room"
+  location_name: "Main Puzzles"
 }
 doors {
   name: "Near Sweet Blue Door"
@@ -1896,6 +1924,7 @@ doors {
   panels { room: "Gray Color Backside" name: "LAST" }
   panels { room: "Gray Color Backside" name: "RISE" }
   location_room: "Gray Color Backside"
+  location_name: "Light Green Hex"
 }
 doors {
   name: "South Castle Area Back Door"
@@ -1935,6 +1964,7 @@ doors {
   panels { room: "Plum Room" name: "SNAKE" }
   panels { room: "Plum Room" name: "CENTER" }
   location_room: "Plum Room"
+  location_name: "Plum Room"
 }
 doors {
   name: "D Keyholder Blocker"
@@ -2036,6 +2066,7 @@ doors {
   panels { room: "Computer Room" name: "MOUSE (2)" }
   panels { room: "Computer Room" name: "KEYBOARD (2)" }
   location_room: "Computer Room"
+  location_name: "Main Puzzles"
 }
 doors {
   name: "Computer Room Entrance"
@@ -2048,12 +2079,17 @@ doors {
   panels { room: "Rainbow Color Doors" name: "MISCHIEF" }
   panels { room: "Rainbow Color Doors" name: "CASUAL" }
   location_room: "Rainbow Color Doors"
+  location_name: "Red Tower"
 }
 doors {
   name: "C Keyholder Blocker"
   type: EVENT
-  # Components/Doors/Unincorporated/temple_foyer_7
-  switches: "lavender_cubes"
+  receivers: "Components/Doors/Unincorporated/temple_foyer_7"
+  panels {
+    map: "the_ancient"
+    room: "Inside"
+    name: "COLOR"
+  }
 }
 doors {
   name: "Computer Room Back Door"
@@ -2115,6 +2151,7 @@ doors {
   panels { room: "Book Room" name: "BOOK (11)" }
   panels { room: "Book Room" name: "BOOK (12)" }
   location_room: "Book Room"
+  location_name: "Book Room"
 }
 doors {
   name: "Sticks And Stones Door"
@@ -2122,6 +2159,7 @@ doors {
   receivers: "Components/Doors/Unincorporated/temple_foyer_6"
   panels { room: "Globe Room" name: "WORD" }
   location_room: "Globe Room"
+  location_name: "Sticks and Stones"
 }
 doors {
   name: "Castle Numbers Puzzle"
@@ -2141,6 +2179,7 @@ doors {
   panels { room: "Black Hex" name: "BARK" }
   panels { room: "Zoo N" name: "LEAF" }
   location_room: "Zoo N"
+  location_name: "BARK, LEAF"
 }
 doors {
   name: "Zoo East Entrance"
@@ -2226,3 +2265,38 @@ doors {
   panels { room: "Yellow Color Backside" name: "REDACTED" }
   location_room: "Yellow Color Backside"
 }
+doors {
+  name: "Tenacious Color Painting"
+  type: EVENT
+  panels { room: "South Castle Area" name: "COLOR (1)" answer: "red" }
+  panels { room: "South Castle Area" name: "COLOR (2)" answer: "yellow" }
+  panels { room: "South Castle Area" name: "COLOR (3)" answer: "purple" }
+  panels { room: "South Castle Area" name: "COLOR (4)" answer: "green" }
+}
+doors {
+  name: "Eye Painting"
+  type: ITEM_ONLY
+  receivers: "Components/Paintings/Temple of the Eyes/eyeRedStart/teleportListener"
+  double_letters: true
+}
+doors {
+  name: "Lime Hexes"
+  type: LOCATION_ONLY
+  panels { room: "Tree Entrance" name: "RAT" }
+  panels { room: "Tree Entrance" name: "DIFFERENCE" }
+  panels { room: "Tree Entrance" name: "LEANS" }
+  panels { room: "Tree Entrance" name: "QUESTION" }
+  panels { room: "Tree Entrance" name: "WHERE" }
+  panels { room: "Tree Entrance" name: "SUNDER" }
+  location_room: "Tree Entrance"
+}
+doors {
+  name: "Theo Panels"
+  type: LOCATION_ONLY
+  panels { room: "House" name: "GOAT" }
+  panels { room: "House" name: "AMAZE" }
+  panels { room: "House" name: "SKINNYHIM" }
+  panels { room: "House" name: "THEO" }
+  location_room: "House"
+  location_name: "All Puzzles"
+}
@@ -1,5 +1,5 @@
 name: "After Bee Room"
-display_name: "North Area"
+panel_display_name: "North Area"
 panels {
   name: "GAS"
   path: "Panels/Beehalls/beehalls_2"
@@ -1,5 +1,5 @@
 name: "Amber North 2"
-display_name: "West Area"
+panel_display_name: "West Area"
 panels {
   name: "SONG"
   path: "Panels/Amber/amber_north_2"
@@ -1,5 +1,5 @@
 name: "Bee Room Obverse"
-display_name: "Bee Room"
+panel_display_name: "Bee Room"
 panels {
   name: "SINGLE"
   path: "Panels/Bee Room/bee_1"
@@ -1,5 +1,5 @@
 name: "Bee Room Reverse"
-display_name: "Bee Room"
+panel_display_name: "Bee Room"
 panels {
   name: "POCKET"
   path: "Panels/Bee Room/bee_9"
@@ -1,5 +1,5 @@
 name: "Beehalls Intersection"
-display_name: "North Area"
+panel_display_name: "North Area"
 panels {
   name: "CLOUDS"
   path: "Panels/Halls/beehalls_4"
@@ -1,5 +1,5 @@
 name: "Black Hex"
-display_name: "Northwest Area"
+panel_display_name: "Northwest Area"
 panels {
   name: "HIDE"
   path: "Panels/Hexes/black_1"
@@ -1,5 +1,5 @@
 name: "Blue Hallway Cut Side"
-display_name: "South Area"
+panel_display_name: "South Area"
 panels {
   name: "CUT"
   path: "Panels/Halls/halls_6"
@@ -1,5 +1,5 @@
 name: "Blue Hallway Tall Side"
-display_name: "Northeast Area"
+panel_display_name: "Northeast Area"
 panels {
   name: "TALL"
   path: "Panels/Halls/halls_9"
@@ -1,5 +1,5 @@
 name: "Blue Hallway"
-display_name: "South Area"
+panel_display_name: "South Area"
 panels {
   name: "CHOP"
   path: "Panels/Halls/halls_10"
@@ -1,5 +1,5 @@
 name: "Blue Room"
-display_name: "East Area"
+panel_display_name: "Blue Room"
 panels {
   name: "RED"
   path: "Panels/Blue Room/panel_1"
@@ -1,5 +1,5 @@
 name: "Blue Smiley Annex"
-display_name: "South Area"
+panel_display_name: "South Area"
 panels {
   name: "ORANGE (1)"
   path: "Panels/Miscellaneous/yellow"
@@ -1,5 +1,5 @@
 name: "Blue Smiley"
-display_name: "South Area"
+panel_display_name: "South Area"
 panels {
   name: "SMILE"
   path: "Panels/Smiley Rooms/blue"
@@ -1,5 +1,5 @@
 name: "Book Room"
-display_name: "Southwest Area"
+panel_display_name: "Southwest Area"
 panels {
   name: "BOOK (1)"
   path: "Panels/Book Room/book_1"
@@ -1,9 +1,10 @@
 name: "Bow Side"
-display_name: "Rainbow"
+panel_display_name: "Rainbow"
 panels {
   name: "?"
   path: "Panels/Smiley Rooms/bow"
   clue: ""
   answer: "bow"
   symbols: QUESTION
+  display_name: "? (2)"
 }
@@ -1,5 +1,5 @@
 name: "Brown Smiley"
-display_name: "Rainbow"
+panel_display_name: "Rainbow"
 panels {
   name: "OTHERS"
   path: "Panels/Smiley Rooms/rainbow2"
@@ -1,6 +1,7 @@
 name: "C Keyholder"
-display_name: "North Area"
+panel_display_name: "East Area"
 keyholders {
   name: "C"
   path: "Components/KeyHolders/keyHolderC"
+  key: "c"
 }
@@ -1,5 +1,5 @@
 name: "Castle"
-display_name: "Castle"
+panel_display_name: "Castle"
 panels {
   name: "REVERSE"
   path: "Panels/Castle Interior/panel_flip"
@@ -1,5 +1,5 @@
 name: "Coin Tower"
-display_name: "Northeast Area"
+panel_display_name: "Northeast Area"
 panels {
   name: "RAIN"
   path: "Panels/Entry/db_2"
@@ -1,5 +1,5 @@
 name: "Composite Room NE"
-display_name: "Composite Room"
+panel_display_name: "Composite Room"
 panels {
   name: "<-"
   path: "Panels/Combo Room NE/panel_1"
@@ -1,5 +1,5 @@
 name: "Composite Room NW"
-display_name: "Composite Room"
+panel_display_name: "Composite Room"
 panels {
   name: "BEHOUSE"
   path: "Panels/Combo Room NW/panel_1"
@@ -1,5 +1,5 @@
 name: "Composite Room S"
-display_name: "Composite Room"
+panel_display_name: "Composite Room"
 panels {
   name: "CONCAVE"
   path: "Panels/Combo Room SW/panel_1"
@@ -194,5 +194,8 @@ panels {
 }
 ports {
   name: "ENTRY"
+  display_name: "Composite Room Worldport"
   path: "Components/Warps/Worldports/worldport16"
+  destination { x: -84 y: 0 z: 81 }
+  rotation: 270
 }
@@ -1,5 +1,5 @@
 name: "Computer Room Seal"
-display_name: "Computer Room"
+panel_display_name: "Computer Room"
 panels {
   name: "SCROLL"
   path: "Panels/Computer/computer_11"
@@ -1,5 +1,5 @@
 name: "Computer Room"
-display_name: "Computer Room"
+panel_display_name: "Computer Room"
 panels {
   name: "MONITOR (1)"
   path: "Panels/Computer/computer_1"
@@ -1,5 +1,5 @@
 name: "Cyan Room"
-display_name: "West Area"
+panel_display_name: "Cyan Room"
 panels {
   name: "LIFE"
   path: "Panels/Brown Room/panel_1"
@@ -1,6 +1,7 @@
 name: "D Keyholder"
-display_name: "Plum Room"
+panel_display_name: "Plum Room"
 keyholders {
   name: "D"
   path: "Components/KeyHolders/keyHolderD"
+  key: "d"
 }
@@ -1,5 +1,5 @@
 name: "D2 Room"
-display_name: "Intense Room"
+panel_display_name: "Intense Room"
 letters {
   key: "d"
   level2: true
@@ -1,5 +1,5 @@
 name: "Dark Light Exit"
-display_name: "Outside Pumpkin"
+panel_display_name: "Dark Light Room"
 panels {
   name: "GASKET"
   path: "Panels/Dark Light Room/dark_7"
@@ -1,5 +1,5 @@
 name: "Dark Light Room"
-display_name: "Outside Pumpkin"
+panel_display_name: "Dark Light Room"
 panels {
   name: "COIN (1)"
   path: "Panels/Dark Light Room/dark_1"
@@ -1,5 +1,5 @@
 name: "Ending"
-display_name: "Castle"
+panel_display_name: "Castle"
 endings {
   name: "ORANGE"
   path: "Components/Triggers/orange_ending"
@@ -1,13 +1,17 @@
 name: "Entry Shortcut"
-display_name: "Central"
+panel_display_name: "Central"
 panels {
   name: "WELCOME"
   path: "Panels/Entry/entry_3"
   clue: "welcome"
   answer: "back"
   symbols: QUESTION
+  display_name: "WELCOME (Red/Blue)"
 }
 ports {
   name: "ENTRY"
+  display_name: "Starting Room West Wall Middle Worldport"
   path: "Components/Warps/Worldports/worldport4"
+  destination { x: -21 y: 0 z: -4 }
+  rotation: 90
 }
@@ -1,5 +1,5 @@
 name: "Eye Painting"
-display_name: "Temple of the Eyes"
+panel_display_name: "Temple of the Eyes"
 panels {
   name: "REVILED"
   path: "Panels/Entry/entry_5"
@@ -1,5 +1,5 @@
 name: "Eye Temple 1F Side"
-display_name: "Temple of the Eyes"
+panel_display_name: "Temple of the Eyes"
 paintings {
   name: "EYEREDSIDE1"
   path: "Components/Paintings/Temple of the Eyes/eyeRedSide1"
@@ -1,5 +1,5 @@
 name: "Eye Temple 1F"
-display_name: "Temple of the Eyes"
+panel_display_name: "Temple of the Eyes"
 paintings {
   name: "EYEREDTOEXITMAIN2"
   path: "Components/Paintings/Temple of the Eyes/eyeRedToExitMain2"
@@ -1,5 +1,5 @@
 name: "Eye Temple 2F Side"
-display_name: "Temple of the Eyes"
+panel_display_name: "Temple of the Eyes"
 paintings {
   name: "EYEREDTOEXITMAIN4"
   path: "Components/Paintings/Temple of the Eyes/eyeRedToExitMain4"
@@ -1,5 +1,5 @@
 name: "Eye Temple 2F"
-display_name: "Temple of the Eyes"
+panel_display_name: "Temple of the Eyes"
 paintings {
   name: "EYEREDEXITTOP1"
   path: "Components/Paintings/Temple of the Eyes/eyeRedExitTop1"
@@ -1,5 +1,5 @@
 name: "Eye Temple Pillar 1"
-display_name: "Temple of the Eyes"
+panel_display_name: "Temple of the Eyes"
 paintings {
   name: "EYEREDEXITPILLAR1"
   path: "Components/Paintings/Temple of the Eyes/eyeRedExitPillar1"
@@ -1,5 +1,5 @@
 name: "Eye Temple Pillar 2"
-display_name: "Temple of the Eyes"
+panel_display_name: "Temple of the Eyes"
 paintings {
   name: "EYEREDEXITPILLAR2"
   path: "Components/Paintings/Temple of the Eyes/eyeRedExitPillar2"
@@ -1,6 +1,7 @@
 name: "F Keyholder"
-display_name: "West Area"
+panel_display_name: "West Area"
 keyholders {
   name: "F"
   path: "Components/KeyHolders/keyHolderF"
+  key: "f"
 }
@@ -1,5 +1,5 @@
 name: "F2 Prize"
-display_name: "F2 Room"
+panel_display_name: "F2 Room"
 letters {
   key: "f"
   level2: true
@@ -1,5 +1,5 @@
 name: "F2 Room"
-display_name: "F2 Room"
+panel_display_name: "F2 Room"
 panels {
   name: "DULLS"
   path: "Panels/The Big F/o_1"
@@ -1,5 +1,5 @@
 name: "Flip Painting Destination"
-display_name: "Central"
+panel_display_name: "Central"
 paintings {
   name: "FLIP"
   path: "Components/Paintings/Group2/flip"
@@ -1,5 +1,5 @@
 name: "Flip Painting Hidden Panel"
-display_name: "Central"
+panel_display_name: "Central"
 panels {
   name: "HIDDEN"
   path: "Panels/Halls/halls_2"
@@ -8,4 +8,5 @@ panels {
   symbols: SUN
   proxies { answer: "covert" path: "Panels/Halls/secret_proxy_1" }
   proxies { answer: "secret" path: "Panels/Halls/secret_proxy_2" }
+  display_name: "HIDDEN (East)"
 }
@@ -1,5 +1,5 @@
 name: "Flip Painting"
-display_name: "West Area"
+panel_display_name: "West Area"
 paintings {
   name: "FLIP2"
   path: "Components/Paintings/Group2/flip2"
@@ -1,5 +1,5 @@
 name: "Gallery Entrance"
-display_name: "Central"
+panel_display_name: "Central"
 paintings {
   name: "GALLERY"
   path: "Components/Warps/eyeWorldport"
@@ -1,5 +1,5 @@
 name: "Globe Room"
-display_name: "Southwest Area"
+panel_display_name: "Southwest Area"
 panels {
   name: "NORTH"
   path: "Panels/Halls/directions_1"
@@ -1,5 +1,5 @@
 name: "Godot Room"
-display_name: "Central"
+panel_display_name: "Central"
 panels {
   name: "MOTORCYCLE"
   path: "Panels/Southwest Room/sw_1"
@@ -1,5 +1,5 @@
 name: "Gray Color Backside"
-display_name: "Outside Pumpkin"
+panel_display_name: "Outside Pumpkin"
 panels {
   name: "ORANGE"
   path: "Panels/Hexes/lightgreen_1"
@@ -1,5 +1,5 @@
 name: "Gray Color Door"
-display_name: "Outside Pumpkin"
+panel_display_name: "Outside Pumpkin"
 panels {
   name: "PATCH"
   path: "Panels/Halls/halls_3"
@@ -1,5 +1,5 @@
 name: "Green Color Door"
-display_name: "Outside Pumpkin"
+panel_display_name: "Outside Pumpkin"
 panels {
   name: "OLD (1)"
   path: "Panels/Halls/halls_20"
@@ -1,5 +1,5 @@
 name: "Green Room"
-display_name: "Green Room"
+panel_display_name: "Green Room"
 panels {
   name: "TIMESCALE"
   path: "Panels/Green Room/panel_1"
@@ -1,5 +1,5 @@
 name: "Green Smiley"
-display_name: "Southwest Area"
+panel_display_name: "Southwest Area"
 panels {
   name: "SMILE"
   path: "Panels/Smiley Rooms/green"
@@ -1,6 +1,8 @@
 name: "Hedges Tower"
-display_name: "Hedges"
+panel_display_name: "Hedges"
 ports {
   name: "TENACIOUS"
+  display_name: "Hedge Maze Tower"
   path: "Components/Warps/Worldports/worldport13"
+  no_shuffle: true
 }
@@ -1,5 +1,5 @@
 name: "Hedges"
-display_name: "Hedges"
+panel_display_name: "Hedges"
 panels {
   name: "SOLVE"
   path: "Panels/Tower Maze/maze_1"
@@ -1,5 +1,5 @@
 name: "Hotel"
-display_name: "Southwest Area"
+panel_display_name: "Southwest Area"
 # TODO: Something has to be changed in-game so that the puzzles don't disappear
 # and thus cause them to become unsolvable.
 panels {
@@ -1,5 +1,5 @@
 name: "House Entrance"
-display_name: "Maze"
+panel_display_name: "Maze"
 panels {
   name: "ADULT"
   path: "Panels/Entry/entry_6"
@@ -1,5 +1,5 @@
 name: "House"
-display_name: "House"
+panel_display_name: "House"
 panels {
   name: "GOAT"
   path: "Panels/Theos House/panel_1"
@@ -1,5 +1,5 @@
 name: "I2 Room"
-display_name: "Temple of the Eyes"
+panel_display_name: "Temple of the Eyes"
 letters {
   key: "i"
   level2: true
@@ -1,5 +1,5 @@
 name: "Intense Room"
-display_name: "Intense Room"
+panel_display_name: "Intense Room"
 panels {
   name: "BRILLIANT"
   path: "Panels/Intense Room/intense_1"
@@ -1,5 +1,5 @@
 name: "J2 Room"
-display_name: "Southwest Area"
+panel_display_name: "Southwest Area"
 letters {
   key: "j"
   level2: true
@@ -1,9 +1,10 @@
 name: "J2 Vestibule"
-display_name: "Southwest Area"
+panel_display_name: "Southwest Area"
 panels {
   name: "COLORFUL"
   path: "Panels/Entry/hotel_entry2"
   clue: "colorful"
   answer: "vivid"
   symbols: SUN
+  display_name: "COLORFUL (2)"
 }
@@ -1,5 +1,5 @@
 name: "Magic Room"
-display_name: "Maze"
+panel_display_name: "Maze"
 panels {
   name: "1"
   path: "Panels/Magic Maze/maze_1"
@@ -1,5 +1,5 @@
 name: "Maze Paintings Area"
-display_name: "Maze"
+panel_display_name: "Maze"
 panels {
   name: "Paintings"
   path: "Panels/Halls/halls_28"
@@ -1,2 +1,2 @@
 name: "Maze"
-display_name: "Maze"
+panel_display_name: "Maze"
@@ -1,10 +1,13 @@
 name: "Moat"
-display_name: "East Area"
+panel_display_name: "East Area"
 paintings {
   name: "CASTLE"
   path: "Components/Paintings/Group1/castle"
 }
 ports {
   name: "HIVE"
+  display_name: "Moat Worldport"
   path: "Components/Warps/Worldports/worldport9"
+  destination { x: 64 y: 1 z: 24.5 }
+  rotation: 0
 }
@@ -1,5 +1,5 @@
 name: "North Castle Area"
-display_name: "North Area"
+panel_display_name: "North Area"
 panels {
   name: "A"
   path: "Panels/Castle Entrance/castle_north_helper"
@@ -1,5 +1,5 @@
 name: "Number Paintings Area"
-display_name: "Northwest Area"
+panel_display_name: "Northwest Area"
 panels {
   name: "GOING"
   path: "Panels/Entry/g_hedge_1"
@@ -17,6 +17,7 @@ panels {
 keyholders {
   name: "G"
   path: "Components/KeyHolders/keyHolderG"
+  key: "g"
 }
 paintings {
   name: "WON"
@@ -1,5 +1,5 @@
 name: "Nursery"
-display_name: "Central"
+panel_display_name: "Central"
 panels {
   name: "Paintings"
   path: "Panels/Entry/entry_2"
@@ -12,6 +12,7 @@ panels {
   path: "Panels/Halls/halls_17"
   clue: ""
   answer: "welcome"
+  display_name: "Nursery Behind"
 }
 paintings {
   name: "ARE"
@@ -1,5 +1,5 @@
 name: "O2 Prize"
-display_name: "O2 Room"
+panel_display_name: "O2 Room"
 letters {
   key: "o"
   level2: true
@@ -1,5 +1,5 @@
 name: "O2 Room"
-display_name: "O2 Room"
+panel_display_name: "O2 Room"
 panels {
   name: "LISTEN"
   path: "Panels/The Big O/o_1"
@@ -0,0 +1,4 @@
+name: "Orange Room Hallway"
+panel_display_name: "Orange Room"
+# This has the same door at both sides, and mainly just connects Z2 Room and
+# Orange Room. It's separate because you can also get here from the Roof.
@@ -1,5 +1,5 @@
 name: "Orange Room"
-display_name: "East Area"
+panel_display_name: "Orange Room"
 panels {
   name: "FRANCE"
   path: "Panels/Orange Room/panel_1"
@@ -1,5 +1,5 @@
 name: "Outside Book Room"
-display_name: "Southwest Area"
+panel_display_name: "Southwest Area"
 # This is behind a teal wall.
 panels {
   name: "TEAL"
@@ -1,5 +1,5 @@
 name: "Outside Eye Temple"
-display_name: "Temple of the Eyes"
+panel_display_name: "Temple of the Eyes"
 panels {
   name: "Entrance"
   path: "Panels/Halls/eye_temple_entry_1"
@@ -1,5 +1,5 @@
 name: "Outside Hedges"
-display_name: "Hedges"
+panel_display_name: "Hedges"
 panels {
   name: "GOURD (1)"
   path: "Panels/Halls/halls_11"
@@ -76,5 +76,8 @@ paintings {
 }
 ports {
   name: "REVITALIZED"
+  display_name: "Near Hedges Plum Hallway"
   path: "Components/Warps/Worldports/worldport7"
+  destination { x: 45 y: 0 z: 94 }
+  rotation: 270
 }
@@ -1,9 +1,10 @@
 name: "Outside Hotel"
-display_name: "Southwest Area"
+panel_display_name: "Southwest Area"
 panels {
   name: "COLORFUL"
   path: "Panels/Entry/hotel_entry"
   clue: "colorful"
   answer: "bright"
   symbols: SUN
+  display_name: "COLORFUL (1)"
 }
@@ -1,5 +1,5 @@
 name: "Outside House"
-display_name: "Maze"
+panel_display_name: "Maze"
 panels {
   name: "WHISPER"
   path: "Panels/Beehalls/beehalls_1"
@@ -75,6 +75,7 @@ panels {
 keyholders {
   name: "H"
   path: "Components/KeyHolders/keyHolderH"
+  key: "h"
 }
 paintings {
   name: "CASTLE2"
@@ -1,5 +1,5 @@
 name: "Outside Magic Room"
-display_name: "Maze"
+panel_display_name: "Maze"
 panels {
   name: "WIZARD"
   path: "Panels/Magic Maze/maze_entry_1"
@@ -1,5 +1,5 @@
 name: "Outside Orange Room"
-display_name: "East Area"
+panel_display_name: "East Area"
 panels {
   name: "SMILE"
   path: "Panels/Smiley Rooms/orange"
@@ -1,5 +1,5 @@
 name: "Outside Pyramid"
-display_name: "Pyramid"
+panel_display_name: "Pyramid"
 panels {
   name: "PEER"
   path: "Panels/Pyramid/pyramid_entry"
@@ -1,5 +1,5 @@
 name: "Outside Red Room"
-display_name: "Red Room"
+panel_display_name: "Red Room"
 panels {
   name: "ROCK"
   path: "Panels/Red Room/red_entry"
@@ -1,9 +1,10 @@
 name: "Outside Salt Room"
-display_name: "Southwest Area"
+panel_display_name: "Southwest Area"
 panels {
   name: "Colors"
   path: "Panels/Color Reading/cr_1"
   clue: ""
   answer: "rob"
   symbols: LINGO
+  display_name: "Colors (White)"
 }
@@ -1,5 +1,5 @@
 name: "Outside Snake Room"
-display_name: "West Area"
+panel_display_name: "West Area"
 panels {
   name: "TONGUE"
   path: "Panels/Pairs Room/pairs_7"
@@ -1,5 +1,5 @@
 name: "Pains Room"
-display_name: "Central"
+panel_display_name: "Central"
 panels {
   name: "MOO"
   path: "Panels/Gold/gold_1"
@@ -1,2 +1,2 @@
 name: "Pairs Room"
-display_name: "West Area"
+panel_display_name: "West Area"
@@ -1,9 +1,10 @@
 name: "Pepper Room"
-display_name: "Southwest Area"
+panel_display_name: "Southwest Area"
 panels {
   name: "SEASONING"
   path: "Panels/Color Reading/cr_4"
   clue: "seasoning"
   answer: "pepper"
   symbols: EXAMPLE
+  display_name: "SEASONING (Black)"
 }
@@ -1,5 +1,5 @@
 name: "Plum Room"
-display_name: "Plum Room"
+panel_display_name: "Plum Room"
 panels {
   name: "GOD"
   path: "Panels/Plum Room/plum_1"
@@ -1,2 +1,2 @@
 name: "Post Orange Smiley Three Way"
-display_name: "West Area"
+panel_display_name: "West Area"
@@ -1,5 +1,5 @@
 name: "Pumpkin Entrance"
-display_name: "East Area"
+panel_display_name: "East Area"
 panels {
   name: "JACK"
   path: "Panels/Pumpkin Room/pumpkin_2"
@@ -1,5 +1,5 @@
 name: "Pumpkin Room"
-display_name: "East Area"
+panel_display_name: "East Area"
 panels {
   name: "BONE"
   path: "Panels/Pumpkin Room/pumpkin_3"
@@ -1,6 +1,9 @@
 name: "Purple Hallway From Great"
-display_name: "South Area"
+panel_display_name: "South Area"
 ports {
   name: "GREAT"
+  display_name: "Near Sweet Purple Hallway"
   path: "Components/Warps/Worldports/worldport17"
+  destination { x: -24 y: 0 z: 61 }
+  rotation: 270
 }
@@ -1,5 +1,5 @@
 name: "Purple NW Vestibule"
-display_name: "Central"
+panel_display_name: "Central"
 panels {
   name: "MESSAGES"
   path: "Panels/Purple Exterior/purple_8"
@@ -1,2 +1,2 @@
 name: "Purple Room East"
-display_name: "Central"
+panel_display_name: "Central"
@@ -1,5 +1,5 @@
 name: "Purple Room South"
-display_name: "Central"
+panel_display_name: "Central"
 panels {
   name: "LITTLE"
   path: "Panels/Halls/hof_1"
@@ -1,2 +1,2 @@
 name: "Purple Room West"
-display_name: "Central"
+panel_display_name: "Central"
@@ -1,5 +1,5 @@
 name: "Purple Room"
-display_name: "Central"
+panel_display_name: "Purple Room"
 panels {
   name: "HOIST"
   path: "Panels/Purple Room/purple_1"
@@ -1,5 +1,5 @@
 name: "Purple SE Vestibule"
-display_name: "Central"
+panel_display_name: "Central"
 panels {
   name: "RUN"
   path: "Panels/Purple Exterior/purple_1"
@@ -1,5 +1,5 @@
 name: "Purple SW Vestibule"
-display_name: "Central"
+panel_display_name: "Central"
 panels {
   name: "LETTERS"
   path: "Panels/Purple Exterior/purple_11"
@@ -1,5 +1,5 @@
 name: "Purple Smiley"
-display_name: "Northeast Area"
+panel_display_name: "Northeast Area"
 panels {
   name: "SMILE"
   path: "Panels/Smiley Rooms/purple"
@@ -1,5 +1,5 @@
 name: "Pyramid 3"
-display_name: "Pyramid"
+panel_display_name: "Pyramid"
 panels {
   name: "VEHICLE"
   path: "Panels/Pyramid/pyramid_3"
@@ -1,5 +1,5 @@
 name: "Pyramid 4"
-display_name: "Pyramid"
+panel_display_name: "Pyramid"
 panels {
   name: "CAT"
   path: "Panels/Pyramid/pyramid_4"
@@ -1,5 +1,5 @@
 name: "Pyramid 5"
-display_name: "Pyramid"
+panel_display_name: "Pyramid"
 panels {
   name: "ROYAL"
   path: "Panels/Pyramid/pyramid_5"
@@ -1,5 +1,5 @@
 name: "Pyramid 6"
-display_name: "Pyramid"
+panel_display_name: "Pyramid"
 panels {
   name: "TEA"
   path: "Panels/Pyramid/pyramid_6"
@@ -1,5 +1,5 @@
 name: "Pyramid 7"
-display_name: "Pyramid"
+panel_display_name: "Pyramid"
 panels {
   name: "ARTIST"
   path: "Panels/Pyramid/pyramid_7"
@@ -1,9 +1,10 @@
 name: "Pyramid 8"
-display_name: "Pyramid"
+panel_display_name: "Pyramid"
 panels {
   name: "INSTRUMENT"
   path: "Panels/Pyramid/pyramid_8"
   clue: "instrument"
   answer: "drum"
   symbols: EXAMPLE
+  display_name: "INSTRUMENT (1F)"
 }
@@ -1,5 +1,5 @@
 name: "Pyramid Entry"
-display_name: "Pyramid"
+panel_display_name: "Pyramid"
 panels {
   name: "TREE"
   path: "Panels/Pyramid/pyramid_1"
@@ -1,5 +1,5 @@
 name: "Pyramid Second Floor"
-display_name: "Pyramid"
+panel_display_name: "Pyramid"
 panels {
   name: "TOOL"
   path: "Panels/Pyramid/pyramid_10"
@@ -36,6 +36,7 @@ panels {
   answer: "organ"
   symbols: EXAMPLE
   required_door { name: "Pyramid 13 Blocker" }
+  display_name: "INSTRUMENT (2F)"
 }
 panels {
   name: "BEVERAGE"
@@ -1,5 +1,5 @@
 name: "Pyramid Top"
-display_name: "Pyramid"
+panel_display_name: "Pyramid"
 letters {
   key: "r"
   level2: true
@@ -1,5 +1,5 @@
 name: "Quiet Entrance"
-display_name: "Central"
+panel_display_name: "Central"
 panels {
   name: "HIDDEN"
   path: "Panels/Halls/halls_7"
@@ -8,6 +8,7 @@ panels {
   symbols: SUN
   proxies { answer: "covert" path: "Panels/Halls/secret_proxy_3" }
   proxies { answer: "secret" path: "Panels/Halls/secret_proxy_4" }
+  display_name: "HIDDEN (West)"
 }
 paintings {
   name: "PLANET2"
@@ -15,5 +16,8 @@ paintings {
 }
 ports {
   name: "QUIET"
+  display_name: "Near Planet Painting Worldport"
   path: "Components/Warps/Worldports/worldport5"
+  destination { x: -32 y: 0 z: -40 }
+  rotation: 90
 }
@@ -1,13 +1,17 @@
 name: "Rain Side"
-display_name: "Rainbow"
+panel_display_name: "Rainbow"
 panels {
   name: "?"
   path: "Panels/Smiley Rooms/rain"
   clue: ""
   answer: "rain"
   symbols: QUESTION
+  display_name: "? (1)"
 }
 ports {
   name: "BEARER"
+  display_name: "Rain Panel Worldport"
   path: "Components/Warps/Worldports/worldport11"
+  destination { x: 93.5 y: 0 z: 27 }
+  rotation: 90
 }
@@ -1,9 +1,10 @@
 name: "Rainbow Blue"
-display_name: "Rainbow"
+panel_display_name: "Rainbow"
 panels {
   name: "THEME"
   path: "Panels/Smiley Rooms/blue2"
   clue: "theme"
   answer: "seasonings"
   symbols: QUESTION
+  display_name: "THEME (Blue)"
 }
@@ -1,5 +1,5 @@
 name: "Rainbow Color Backside"
-display_name: "Central"
+panel_display_name: "Central"
 panels {
   name: "BACKSIDE"
   path: "Panels/Halls/halls_1"
@@ -11,4 +11,5 @@ panels {
   path: "Panels/Halls/halls_4"
   clue: ""
   answer: "side"
+  display_name: "Backside Behind"
 }
@@ -1,5 +1,5 @@
 name: "Rainbow Color Doors"
-display_name: "East Area"
+panel_display_name: "East Area"
 panels {
   name: "CROW"
   path: "Panels/Blue Room/panel_entry"
@@ -1,9 +1,10 @@
 name: "Rainbow Cyan"
-display_name: "Rainbow"
+panel_display_name: "Rainbow"
 panels {
   name: "THEME"
   path: "Panels/Smiley Rooms/cyan"
   clue: "theme"
   answer: "apocalypse"
   symbols: QUESTION
+  display_name: "THEME (Cyan)"
 }
@@ -1,5 +1,5 @@
 name: "Rainbow End"
-display_name: "Rainbow"
+panel_display_name: "Rainbow"
 panels {
   name: "POT"
   path: "Components/Warps/gold"
@@ -1,9 +1,10 @@
 name: "Rainbow Green"
-display_name: "Rainbow"
+panel_display_name: "Rainbow"
 panels {
   name: "THEME"
   path: "Panels/Smiley Rooms/green2"
   clue: "theme"
   answer: "tea"
   symbols: QUESTION
+  display_name: "THEME (Green)"
 }
@@ -1,9 +1,10 @@
 name: "Rainbow Orange"
-display_name: "Rainbow"
+panel_display_name: "Rainbow"
 panels {
   name: "THEME"
   path: "Panels/Smiley Rooms/orange2"
   clue: "theme"
   answer: "fish"
   symbols: QUESTION
+  display_name: "THEME (Orange)"
 }
@@ -1,9 +1,10 @@
 name: "Rainbow Purple"
-display_name: "Rainbow"
+panel_display_name: "Rainbow"
 panels {
   name: "THEME"
   path: "Panels/Smiley Rooms/purple2"
   clue: "theme"
   answer: "fruit"
   symbols: QUESTION
+  display_name: "THEME (Purple)"
 }
@@ -1,9 +1,10 @@
 name: "Rainbow Red"
-display_name: "Rainbow"
+panel_display_name: "Rainbow"
 panels {
   name: "THEME"
   path: "Panels/Smiley Rooms/red2"
   clue: "theme"
   answer: "names"
   symbols: QUESTION
+  display_name: "THEME (Red)"
 }
@@ -1,5 +1,5 @@
 name: "Rainbow Start"
-display_name: "Rainbow"
+panel_display_name: "Rainbow"
 panels {
   name: "PAINTING"
   path: "Panels/Smiley Rooms/rainbow"
@@ -1,9 +1,10 @@
 name: "Rainbow Yellow"
-display_name: "Rainbow"
+panel_display_name: "Rainbow"
 panels {
   name: "THEME"
   path: "Panels/Smiley Rooms/yellow2"
   clue: "theme"
   answer: "music"
   symbols: QUESTION
+  display_name: "THEME (Yellow)"
 }
@@ -1,7 +1,7 @@
 name: "Red Color Door"
-display_name: "Southwest Area"
+panel_display_name: "Southwest Area"
 panels {
-  name: "Left"
+  name: "Near Obscured Puzzles"
   path: "Panels/Halls/wb_1"
   clue: ""
   answer: "sidewalk"
@@ -67,4 +67,5 @@ panels {
   clue: ""
   answer: "bank"
   symbols: LINGO
+  display_name: "Colors (Black)"
 }
@@ -1,5 +1,5 @@
 name: "Red Room"
-display_name: "Red Room"
+panel_display_name: "Red Room"
 panels {
   name: "BLINDING"
   path: "Panels/Red Room/red_1"
@@ -1,5 +1,5 @@
 name: "Red Smiley"
-display_name: "Northwest Area"
+panel_display_name: "Northwest Area"
 panels {
   name: "SMILE"
   path: "Panels/Smiley Rooms/red"
@@ -1,4 +1,5 @@
 name: "Roof"
+panel_display_name: "Roof"
 panels {
   name: "?"
   path: "Panels/Castle Entrance/moat"
@@ -1,9 +1,10 @@
 name: "Salt Room"
-display_name: "Southwest Area"
+panel_display_name: "Southwest Area"
 panels {
   name: "SEASONING"
   path: "Panels/Color Reading/cr_3"
   clue: "seasoning"
   answer: "salt"
   symbols: EXAMPLE
+  display_name: "SEASONING (White)"
 }
@@ -1,5 +1,5 @@
 name: "Seasoning Room"
-display_name: "Southwest Area"
+panel_display_name: "Southwest Area"
 panels {
   name: "PARITY"
   path: "Panels/Color Reading/cr_5"
@@ -1,5 +1,5 @@
 name: "Snake Room"
-display_name: "West Area"
+panel_display_name: "West Area"
 panels {
   name: "HISS"
   path: "Panels/Snake Room/snake_1"
@@ -1,5 +1,5 @@
 name: "South Castle Area"
-display_name: "Outside Pumpkin"
+panel_display_name: "Outside Pumpkin"
 # There is a teal wall in the middle of this room.
 panels {
   name: "AN"
@@ -107,5 +107,5 @@ paintings {
   path: "Components/Paintings/Group2/triangle"
   move: true
   enter_only: true
-  # TODO: required_door
+  required_door { name: "Tenacious Color Painting" }
 }
@@ -1,5 +1,5 @@
 name: "Starting Room"
-display_name: "Central"
+panel_display_name: "Central"
 panels {
   name: "ENTRANCE"
   path: "Panels/Entry/entry_1"
@@ -9,5 +9,8 @@ panels {
 }
 ports {
   name: "GREAT"
+  display_name: "Starting Room South Wall Middle Worldport"
   path: "Components/Warps/Worldports/worldport"
+  destination { x: 0 y: 0 z: 11 }
+  rotation: 0
 }
@@ -1,5 +1,5 @@
 name: "Sweet Foyer"
-display_name: "South Area"
+panel_display_name: "South Area"
 panels {
   name: "QUALITY"
   path: "Panels/Sweet Foyer/panel_1"
@@ -51,9 +51,15 @@ paintings {
 }
 ports {
   name: "SWEET1"
+  display_name: "Sweet East Entrance"
   path: "Components/Warps/Worldports/worldport14"
+  destination { x: -27 y: 0 z: 76.5 }
+  rotation: 270
 }
 ports {
   name: "SWEET2"
+  display_name: "Sweet West Entrance"
   path: "Components/Warps/Worldports/worldport15"
+  destination { x: -36 y: 0 z: 76.5 }
+  rotation: 90
 }
@@ -1,5 +1,5 @@
 name: "Tree Entrance"
-display_name: "Outside Pumpkin"
+panel_display_name: "Outside Pumpkin"
 panels {
   name: "RAT"
   path: "Panels/Hexes/lime_1"
@@ -48,5 +48,8 @@ panels {
 }
 ports {
   name: "TREE"
+  display_name: "Near Pumpkin Brown Hallway"
   path: "Components/Warps/Worldports/worldport12"
+  destination { x: 41 y: 0 z: 50.5 }
+  rotation: 0
 }
@@ -1,5 +1,5 @@
 name: "U2 Prize"
-display_name: "U2 Room"
+panel_display_name: "U2 Room"
 letters {
   key: "u"
   level2: true
@@ -1,5 +1,5 @@
 name: "U2 Room"
-display_name: "U2 Room"
+panel_display_name: "U2 Room"
 panels {
   name: "DREAMSCAPE"
   path: "Panels/The Big U/o_1"
@@ -1,6 +1,9 @@
 name: "Unkempt Entrance"
-display_name: "O2 Room"
+panel_display_name: "O2 Room"
 ports {
   name: "UNKEMPT"
+  display_name: "O2 Room Worldport"
   path: "Components/Warps/Worldports/worldport6"
+  destination { x: -61 y: 0 z: 95 }
+  rotation: 270
 }
@@ -1,5 +1,5 @@
 name: "Welcome Back Area"
-display_name: "Central"
+panel_display_name: "Central"
 panels {
   name: "FAREWELL LITTLE LAMB"
   path: "Panels/Entry/wb_2"
@@ -1,5 +1,5 @@
 name: "Welcome Back Exit"
-display_name: "Central"
+panel_display_name: "Central"
 panels {
   name: "WELCOME"
   path: "Panels/Entry/wb_1"
@@ -7,4 +7,5 @@ panels {
   answer: "welcome"
   symbols: QUESTION
   proxies { answer: "back" path: "Panels/Entry/wb_proxy" }
+  display_name: "WELCOME (White)"
 }
@@ -1,5 +1,5 @@
 name: "West Castle Area"
-display_name: "West Area"
+panel_display_name: "West Area"
 panels {
   name: "SONG (1)"
   path: "Panels/Castle Entrance/castle_west_helper"
@@ -1,5 +1,5 @@
 name: "West Spire"
-display_name: "West Area"
+panel_display_name: "West Area"
 panels {
   name: "MISSING"
   path: "Panels/Entry/wb_5"
@@ -1,12 +1,9 @@
 name: "White Hallway From Entry"
-display_name: "Southwest Area"
-# Not exactly sure what to do with this yet. In unshuffled connections, the door
-# here should be paired with the door on the other end (which is vanilla) even
-# if control center color doors are shuffled. But when connections are shuffled
-# maybe this should be shuffled separately? I might also want to find a way to
-# register when there's a door immediately outside of a connection so that when
-# two connections behind doors are shuffled together, their doors can be paired.
+panel_display_name: "Southwest Area"
 ports {
   name: "ENTRY"
+  display_name: "Near Globe White Hallway"
   path: "Components/Warps/Worldports/worldport10"
+  destination { x: -46 y: 0 z: 23 }
+  rotation: 90
 }
@@ -1,5 +1,5 @@
 name: "Wisdom Panel"
-display_name: "Castle"
+panel_display_name: "Castle"
 panels {
   name: "INTELLIGENCE"
   path: "Components/Warps/numbers"
@@ -1,6 +1,5 @@
 name: "Wonderland"
-display_name: "Northwest Area"
-# TODO: There's a warp from The Entry into here.
+panel_display_name: "Northwest Area"
 panels {
   name: "APRIL"
   path: "Panels/Wonderland/wonderland_1"
@@ -38,5 +37,8 @@ panels {
 }
 ports {
   name: "WONDROUS"
+  display_name: "Wonderland Worldport"
   path: "Components/Warps/Worldports/worldport3"
+  destination { x: -104 y: 0 z: -69 }
+  rotation: 180
 }
@@ -1,5 +1,5 @@
 name: "Yellow Color Backside"
-display_name: "Northeast Area"
+panel_display_name: "Northeast Area"
 panels {
   name: "WINDS"
   path: "Panels/Halls/halls_24"
@@ -1,5 +1,5 @@
 name: "Yellow Color Door"
-display_name: "Northeast Area"
+panel_display_name: "Northeast Area"
 panels {
   name: "SUN"
   path: "Panels/Yellow Room/panel_entry"
@@ -26,9 +26,12 @@ paintings {
   path: "Components/Paintings/Temple of the Eyes/eyeRedStart"
   move: true
   enter_only: true
-  # TODO: requires double letters
+  required_door { name: "Eye Painting" }
 }
 ports {
   name: "FOURROOMS"
+  display_name: "Near Yellow Worldport"
   path: "Components/Warps/Worldports/worldport8"
+  destination { x: 92.5 y: 0 z: -62 }
+  rotation: 90
 }
@@ -1,5 +1,5 @@
 name: "Yellow Room"
-display_name: "Northeast Area"
+panel_display_name: "Yellow Room"
 panels {
   name: "FREE"
   path: "Panels/Yellow Room/panel_1"
@@ -1,5 +1,5 @@
 name: "Yellow Smiley Annex"
-display_name: "Hedges"
+panel_display_name: "Hedges"
 panels {
   name: "COW"
   path: "Panels/Miscellaneous/plum1"
@@ -1,5 +1,5 @@
 name: "Z2 Prize"
-display_name: "Northwest Area"
+panel_display_name: "Z2 Room"
 letters {
   key: "z"
   level2: true
@@ -1,5 +1,5 @@
 name: "Z2 Room"
-display_name: "Northwest Area"
+panel_display_name: "Z2 Room"
 panels {
   name: "EXHIBIT"
   path: "Panels/V Maze/entry"
@@ -1,5 +1,5 @@
 name: "Zoo Center"
-display_name: "Zoo"
+panel_display_name: "Zoo"
 letters {
   key: "v"
   level2: true
@@ -1,5 +1,5 @@
 name: "Zoo E"
-display_name: "Zoo"
+panel_display_name: "Zoo"
 panels {
   name: "WING"
   path: "Panels/V Maze/four_1"
@@ -1,5 +1,5 @@
 name: "Zoo N"
-display_name: "Zoo"
+panel_display_name: "Zoo"
 panels {
   name: "BILL"
   path: "Panels/V Maze/four_13"
@@ -13,6 +13,7 @@ panels {
   clue: "fin"
   answer: "whale"
   symbols: BOXES
+  display_name: "FIN (N)"
 }
 panels {
   name: "BLOWHOLE"
@@ -1,5 +1,5 @@
 name: "Zoo NE"
-display_name: "Zoo"
+panel_display_name: "Zoo"
 panels {
   name: "FANG"
   path: "Panels/V Maze/four_5"
@@ -1,5 +1,5 @@
 name: "Zoo S"
-display_name: "Zoo"
+panel_display_name: "Zoo"
 panels {
   name: "SHELL"
   path: "Panels/V Maze/four_9"
@@ -13,6 +13,7 @@ panels {
   clue: "fin"
   answer: "fish"
   symbols: BOXES
+  display_name: "FIN (S)"
 }
 panels {
   name: "PINCER"
@@ -1,2 +1,2 @@
 name: "Zoo SE"
-display_name: "Zoo"
+panel_display_name: "Zoo"
@@ -11,6 +11,7 @@ doors {
   panels { room: "Intensify Room" name: "INJURY" }
   panels { room: "Intensify Room" name: "SWAY" }
   location_room: "Intensify Room"
+  location_name: "Intensify Room"
 }
 doors {
   name: "Examples Door"
@@ -25,6 +26,7 @@ doors {
   panels { room: "Examples Room" name: "URN" }
   panels { room: "Examples Room" name: "ART" }
   location_room: "Examples Room"
+  location_name: "Examples Room"
 }
 doors {
   name: "Synonyms Door"
@@ -39,6 +41,7 @@ doors {
   panels { room: "Synonyms Room" name: "SERIOUS" }
   panels { room: "Synonyms Room" name: "FURY" }
   location_room: "Synonyms Room"
+  location_name: "Synonyms Room"
 }
 doors {
   name: "Time Door"
@@ -53,6 +56,7 @@ doors {
   panels { room: "Time Room" name: "HOLE" }
   panels { room: "Time Room" name: "RHYTHM" }
   location_room: "Time Room"
+  location_name: "Time Room"
 }
 doors {
   name: "A2 Door"
@@ -1,5 +1,4 @@
 name: "A2 Room"
-display_name: "Hallway"
 letters {
   key: "a"
   level2: true
@@ -1,5 +1,4 @@
 name: "Examples Room"
-display_name: "Examples Room"
 panels {
   name: "SIZE (1)"
   path: "Panels/Room 2 Examples/entry_1"
@@ -58,6 +57,8 @@ panels {
 }
 ports {
   name: "DAEDALUS"
+  display_name: "Examples Room Worldport"
   path: "Components/Warps/worldport2"
-  orientation: "north"
+  destination { x: 0 y: 0 z: -40.5 }
+  rotation: 180
 }
@@ -1,5 +1,4 @@
 name: "Hallway"
-display_name: "Hallway"
 panels {
   name: "SUSPICION"
   path: "Panels/Reward Room/reward_1"
@@ -1,5 +1,4 @@
 name: "Intensify Room"
-display_name: "Intensify Room"
 panels {
   name: "SMALL"
   path: "Panels/Room 1 Intensify/entry_1"
@@ -58,6 +57,8 @@ panels {
 }
 ports {
   name: "IMPRESSIVE"
+  display_name: "Intensify Room Worldport"
   path: "Components/Warps/worldport"
-  orientation: "south"
+  destination { x: 0 y: 0 z: 6.5 }
+  rotation: 0
 }
@@ -1,6 +1,6 @@
 name: "Keyholder Room"
-display_name: "Hallway"
 keyholders {
   name: "A"
   path: "Components/KeyHolders/keyHolderA"
+  key: "a"
 }
@@ -1,5 +1,4 @@
 name: "Synonyms Room"
-display_name: "Synonyms Room"
 panels {
   name: "MINUTE"
   path: "Panels/Room 3 Synonyms/entry_1"
@@ -58,6 +57,8 @@ panels {
 }
 ports {
   name: "ENTRY"
+  display_name: "Synonyms Room Worldport"
   path: "Components/Warps/worldport3"
-  orientation: "south"
+  destination { x: 20 y: 0 z: 6.5 }
+  rotation: 0
 }
@@ -1,5 +1,4 @@
 name: "Time Room"
-display_name: "Time Room"
 panels {
   name: "BROODING"
   path: "Panels/Room 4 Time/entry_1"
@@ -58,6 +57,8 @@ panels {
 }
 ports {
   name: "OWL"
+  display_name: "Time Room Worldport"
   path: "Components/Warps/worldport4"
-  orientation: "north"
+  destination { x: 20 y: 0 z: -40.5 }
+  rotation: 180
 }
@@ -1,18 +1,45 @@
 doors {
   name: "Front Door"
   type: STANDARD
+  receivers: "Components/Doors/Front N Tree"
   panels { room: "Outside" name: "THIS" }
   location_room: "Outside"
 }
 doors {
   name: "End Door"
-  type: STANDARD
-  # TODO: all the keyholders!
+  type: EVENT
+  keyholders { map: "four_rooms" room: "Keyholder Room" name: "A" key: "a" }
+  keyholders { map: "the_hive" room: "Main Area" name: "B" key: "b" }
+  keyholders { map: "daedalus" room: "C Keyholder" name: "C" key: "c" }
+  keyholders { map: "daedalus" room: "D Keyholder" name: "D" key: "d" }
+  keyholders { map: "control_center" room: "Main Area" name: "2" key: "e" }
+  keyholders { map: "daedalus" room: "F Keyholder" name: "F" key: "f" }
+  keyholders { map: "daedalus" room: "Number Paintings Area" name: "G" key: "g" }
+  keyholders { map: "daedalus" room: "Outside House" name: "H" key: "h" }
+  keyholders { map: "the_unkempt" room: "Main Area" name: "I" key: "i" }
+  keyholders { map: "the_jubilant" room: "Side Area" name: "J" key: "j" }
+  keyholders { map: "the_tenacious" room: "Main Area" name: "K" key: "k" }
+  keyholders { map: "the_partial" room: "Obverse Side" name: "L" key: "l" }
+  keyholders { map: "the_extravagant" room: "X Plus" name: "M" key: "m" }
+  keyholders { map: "the_shop" room: "Main Area" name: "N" key: "n" }
+  keyholders { map: "control_center" room: "Main Area" name: "4" key: "o" }
+  keyholders { map: "the_gallery" room: "Main Area" name: "P" key: "p" }
+  keyholders { map: "the_quiet" room: "Keyholder Room" name: "Q" key: "q" }
+  keyholders { map: "control_center" room: "Main Area" name: "3" key: "r" }
+  keyholders { map: "the_nuanced" room: "Main Room" name: "S" key: "s" }
+  keyholders { map: "the_congruent" room: "T Keyholder" name: "T" key: "t" }
+  keyholders { map: "the_parthenon" room: "U Keyholder" name: "U" key: "u" }
+  keyholders { map: "the_unkempt" room: "V Keyholder" name: "V" key: "v" }
+  keyholders { map: "the_unkempt" room: "W Keyholder" name: "W" key: "w" }
+  keyholders { map: "the_great" room: "North Landscape" name: "X" key: "x" }
+  keyholders { map: "the_talented" room: "Main Area" name: "Y" key: "y" }
+  keyholders { map: "control_center" room: "Main Area" name: "1" key: "z" }
   location_room: "Inside"
 }
 doors {
   name: "Lavender Cubes"
-  type: STANDARD
+  type: LOCATION_ONLY
   panels { room: "Inside" name: "COLOR" }
   location_room: "Inside"
+  location_name: "COLOR"
 }
@@ -1,5 +1,4 @@
 name: "Ending"
-display_name: "Ending"
 endings {
   name: "GREEN"
   path: "Components/Ending/green_ending"
@@ -1,10 +1,8 @@
 name: "Inside"
-display_name: "Inside"
 panels {
   name: "COLOR"
   path: "Panels/panel_2"
   clue: "color"
   answer: "lavender"
   symbols: EXAMPLE
-  # TODO: how does this connect to the "lavender_cubes" switch?
 }
@@ -1,8 +1,8 @@
 name: "Outside"
-display_name: "Outside"
 panels {
   name: "THIS"
   path: "Panels/panel_1"
   clue: "this"
   answer: "sphinx"
+  symbols: QUESTION
 }
@@ -263,3 +263,8 @@ connections {
   to_room: "Butterfly Room"
   door { name: "Butterfly Entrance" }
 }
+connections {
+  from_room: "Back Area"
+  to_room: "Tree Entrance"
+  door { name: "Control Center Brown Door" }
+}
@@ -211,7 +211,7 @@ doors {
 }
 doors {
   name: "Q2 Door"
-  type: STANDARD
+  type: EVENT
   receivers: "Components/Doors/entry_3"
   panels { room: "Entry" name: "SQUISH" }
   panels { room: "Entry" name: "MANE" }
@@ -237,7 +237,6 @@ doors {
   panels { room: "Red Vegetable" name: "CARD" }
   panels { room: "Yellow Planet" name: "ZEUS" }
   panels { room: "Yellow Vegetable" name: "CAKE" }
-  location_room: "Entry"
 }
 doors {
   name: "Control Center Brown Door"
@@ -249,5 +248,5 @@ doors {
   name: "Butterfly Entrance"
   type: ITEM_ONLY
   receivers: "Components/Doors/brown_2"
-  switches: "double_letters"
+  double_letters: true
 }
@@ -1,5 +1,4 @@
 name: "Back Area"
-display_name: "Back Area"
 panels {
   name: "COLOR"
   path: "Panels/Entry/panel_3"
@@ -8,13 +7,9 @@ panels {
   symbols: EXAMPLE
 }
 ports {
-  name: "TREE"
-  path: "Components/Warps/worldport3"
-  orientation: "north"
-  required_door { name: "Control Center Brown Door" }
-}
-ports {
   name: "DAEDALUS"
+  display_name: "Dark Hallway"
   path: "Components/Warps/worldport2"
-  orientation: "north"
+  destination { x: 10 y: 0 z: -84.5 }
+  rotation: 180
 }
@@ -1,5 +1,4 @@
 name: "Blue Animal (View)"
-display_name: "Main Area"
 panels {
   name: "HALF"
   path: "Panels/Blue/panel_2"
@@ -1,2 +1 @@
 name: "Blue Animal"
-display_name: "Main Area"
@@ -1,5 +1,4 @@
 name: "Blue Planet (View)"
-display_name: "Main Area"
 panels {
   name: "TUNE"
   path: "Panels/Blue/panel_4"
@@ -1,2 +1 @@
 name: "Blue Planet"
-display_name: "Main Area"
@@ -1,5 +1,4 @@
 name: "Blue Town (View)"
-display_name: "Main Area"
 panels {
   name: "LICE"
   path: "Panels/Blue/panel_3"
@@ -1,2 +1 @@
 name: "Blue Town"
-display_name: "Main Area"
@@ -1,5 +1,4 @@
 name: "Blue Vegetable (View)"
-display_name: "Main Area"
 panels {
   name: "THORN"
   path: "Panels/Blue/panel_1"
@@ -1,2 +1 @@
 name: "Blue Vegetable"
-display_name: "Main Area"
@@ -1,5 +1,4 @@
 name: "Butterfly Room"
-display_name: "Back Area"
 panels {
   name: "VIBRANT"
   path: "Panels/Entry/panel_4"
@@ -1,5 +1,4 @@
 name: "Entry"
-display_name: "Main Area"
 panels {
   name: "VIEW"
   path: "Panels/Entry/panel_1"
@@ -58,6 +57,8 @@ panels {
 }
 ports {
   name: "UNYIELDING"
+  display_name: "Main Entrance"
   path: "Components/Warps/worldport"
-  orientation: "east"
+  destination { x: 3 y: 4 z: 15 }
+  rotation: 90
 }
@@ -1,2 +1 @@
 name: "Green Animal"
-display_name: "Main Area"
@@ -1,5 +1,4 @@
 name: "Green Planet (View)"
-display_name: "Main Area"
 panels {
   name: "SOIL"
   path: "Panels/Green/panel_4"
@@ -1,2 +1 @@
 name: "Green Planet"
-display_name: "Main Area"
@@ -1,2 +1 @@
 name: "Green Town"
-display_name: "Main Area"
@@ -1,5 +1,4 @@
 name: "Green Vegetable (View)"
-display_name: "Main Area"
 panels {
   name: "SPIN"
   path: "Panels/Green/panel_1"
@@ -1,2 +1 @@
 name: "Green Vegetable"
-display_name: "Main Area"
@@ -1,5 +1,4 @@
 name: "Orange Planet"
-display_name: "Main Area"
 panels {
   name: "MAR"
   path: "Panels/Red/panel_4"
@@ -1,5 +1,4 @@
 name: "Orange Vegetable"
-display_name: "Main Area"
 panels {
   name: "POTATO"
   path: "Panels/Red/panel_1"
@@ -1,2 +1 @@
 name: "Overlook"
-display_name: "Main Area"
@@ -1,5 +1,4 @@
 name: "Purple Animal (View)"
-display_name: "Main Area"
 panels {
   name: "SUNBASS"
   path: "Panels/Purple/panel_2"
@@ -1,2 +1 @@
 name: "Purple Animal"
-display_name: "Main Area"
@@ -1,5 +1,4 @@
 name: "Purple Planet (View)"
-display_name: "Main Area"
 panels {
   name: "DOG"
   path: "Panels/Purple/panel_4"
@@ -1,2 +1 @@
 name: "Purple Planet"
-display_name: "Main Area"
@@ -1,5 +1,4 @@
 name: "Purple Town (View)"
-display_name: "Main Area"
 panels {
   name: "GRACEFUL"
   path: "Panels/Purple/panel_3"
@@ -1,2 +1 @@
 name: "Purple Town"
-display_name: "Main Area"
@@ -1,5 +1,4 @@
 name: "Purple Vegetable (View)"
-display_name: "Main Area"
 panels {
   name: "AUBERGINE"
   path: "Panels/Purple/panel_1"
@@ -1,2 +1 @@
 name: "Purple Vegetable"
-display_name: "Main Area"
@@ -1,5 +1,4 @@
 name: "Q2 Room"
-display_name: "Back Area"
 letters {
   key: "q"
   level2: true
@@ -1,5 +1,4 @@
 name: "Red Animal"
-display_name: "Main Area"
 panels {
   name: "FOOLSHARK"
   path: "Panels/Orange/panel_2"
@@ -1,5 +1,4 @@
 name: "Red Planet"
-display_name: "Main Area"
 panels {
   name: "FUEL"
   path: "Panels/Red/panel_3"
@@ -1,5 +1,4 @@
 name: "Red Town"
-display_name: "Main Area"
 panels {
   name: "DESTRUCTION"
   path: "Panels/Orange/panel_3"
@@ -1,5 +1,4 @@
 name: "Red Vegetable"
-display_name: "Main Area"
 panels {
   name: "CARD"
   path: "Panels/Red/panel_2"
@@ -0,0 +1,8 @@
+name: "Tree Entrance"
+ports {
+  name: "TREE"
+  display_name: "Brown Hallway"
+  path: "Components/Warps/worldport3"
+  destination { x: -19 y: 0 z: -83.5 }
+  rotation: 180
+}
@@ -1,5 +1,4 @@
 name: "Yellow Planet"
-display_name: "Main Area"
 panels {
   name: "ZEUS"
   path: "Panels/Orange/panel_4"
@@ -1,5 +1,4 @@
 name: "Yellow Vegetable"
-display_name: "Main Area"
 panels {
   name: "CAKE"
   path: "Panels/Orange/panel_1"
@@ -1,5 +1,4 @@
 name: "B2 Back Room"
-display_name: "B2 Room"
 letters {
   key: "b"
   level2: true
@@ -1,5 +1,4 @@
 name: "B2 Front Room"
-display_name: "B2 Room"
 paintings {
   name: "EYES"
   path: "Components/Paintings/eyes"
@@ -1,5 +1,4 @@
 name: "Control Center Side"
-display_name: "Control Center Side"
 panels {
   name: "RIGHT"
   path: "Panels/Helpers/panel_1"
@@ -14,11 +13,15 @@ paintings {
 }
 ports {
   name: "CC"
+  display_name: "Lavender Structure"
   path: "Components/Warps/worldport3"
-  orientation: "north"
+  destination { x: 36 y: 0 z: 1 }
+  rotation: 180
 }
 ports {
   name: "LIVELY"
+  display_name: "Near Painting Worldport"
   path: "Components/Warps/worldport2"
-  orientation: "south"
+  destination { x: 24 y: 0 z: 6.5 }
+  rotation: 0
 }
@@ -1,5 +1,4 @@
 name: "Main Area"
-display_name: "Main Area"
 panels {
   name: "NEW"
   path: "Panels/Room 1/panel_1"
@@ -198,6 +197,8 @@ panels {
 }
 ports {
   name: "GREAT"
+  display_name: "Salmon Hallway"
   path: "Components/Warps/worldport"
-  orientation: "east"
+  destination { x: -1 y: 0 z: 20 }
+  rotation: 90
 }
@@ -1,7 +1,8 @@
 name: "Plaza Entrance"
-display_name: "Main Area"
 ports {
   name: "PLAZA"
+  display_name: "Trick or Treat Worldport"
   path: "Components/Warps/worldport4"
-  orientation: "north"
+  destination { x: -38 y: 0 z: 1 }
+  rotation: 180
 }
@@ -1,5 +1,4 @@
 name: "Main Area"
-display_name: "Main Area"
 panels {
   name: "SPECIES"
   path: "Panels/Room_1/panel_1"
@@ -128,6 +127,8 @@ panels {
 }
 ports {
   name: "GALLERY"
+  display_name: "Worldport"
   path: "Components/Warps/worldport"
-  orientation: "southwest" # uhhhh this is new
+  destination { x: -19 y: 0 z: 19 }
+  rotation: 315
 }
@@ -1,5 +1,4 @@
 name: "Mastery"
-display_name: "Main Area"
 masteries {
   name: "MASTERY"
   path: "Components/Collectables/collectable"
@@ -46,13 +46,14 @@ doors {
   type: STANDARD
   receivers: "Components/Doors/entry_7"
   panels { room: "Yellow Room" name: "CIRCLE" }
-  panels { room: "Purple Room" name: "FISH" }
+  panels { room: "Purple Room" name: "FISH" answer: "fish" }
   location_room: "Purple Room"
 }
 doors {
   name: "Purple Side Entrance"
   type: STANDARD
   receivers: "Components/Doors/entry_7b3"
+  receivers: "Components/Doors/entry_7b4"
   panels { room: "Cyan Hallway" name: "KOI" }
   panels { room: "Cyan Hallway" name: "WISH" }
   location_room: "Cyan Hallway"
@@ -1,5 +1,4 @@
 name: "Black Room"
-display_name: "Black Room"
 panels {
   name: "STARK"
   path: "Panels/Hallway/panel_2"
@@ -1,5 +1,4 @@
 name: "Blue Room"
-display_name: "Blue Room"
 panels {
   name: "VINE"
   path: "Panels/Hallway/panel_4"
@@ -1,5 +1,4 @@
 name: "Brown Room"
-display_name: "Brown Room"
 panels {
   name: "FIRE"
   path: "Panels/Hallway/panel_9"
@@ -1,5 +1,4 @@
 name: "Cyan Hallway"
-display_name: "Cyan Hallway"
 panels {
   name: "KOI"
   path: "Panels/Extra/panel_12"
@@ -24,11 +23,15 @@ panels {
 }
 ports {
   name: "STURDY"
+  display_name: "North Cyan Worldport"
   path: "Components/Warps/worldport3"
-  orientation: "west"
+  destination { x: -17 y: 0 z: -75 }
+  rotation: 270
 }
 ports {
   name: "DARKROOM"
+  display_name: "South Cyan Worldport"
   path: "Components/Warps/worldport2"
-  orientation: "west"
+  destination { x: -17 y: 0 z: -51 }
+  rotation: 270
 }
@@ -1,5 +1,4 @@
 name: "Cyan Room"
-display_name: "Cyan Room"
 panels {
   name: "BROTHER"
   path: "Panels/Cyan/panel_cyan_1"
@@ -1,5 +1,4 @@
 name: "Ending"
-display_name: "Ending"
 endings {
   name: "GRAY"
   path: "Components/Endings/gray_ending"
@@ -1,5 +1,4 @@
 name: "Gray Room"
-display_name: "Gray Room"
 panels {
   name: "MEND"
   path: "Panels/Hallway/panel_11"
@@ -1,5 +1,4 @@
 name: "Green Room"
-display_name: "Green Room"
 panels {
   name: "MOTHER"
   path: "Panels/Hallway/panel_5"
@@ -1,5 +1,4 @@
 name: "Orange Room"
-display_name: "Orange Room"
 panels {
   name: "CLOUD"
   path: "Panels/Hallway/panel_8"
@@ -1,5 +1,4 @@
 name: "P2 Room"
-display_name: "Cyan Room"
 letters {
   key: "p"
   level2: true
@@ -1,10 +1,10 @@
 name: "Purple Room"
-display_name: "Purple Room"
 panels {
   name: "FISH"
   path: "Panels/Hallway/panel_7"
   clue: "fish"
   answer: "fish"
   symbols: PLANET
+  proxies { answer: "fish" path: "Panels/Hallway/panel_7a" }
   proxies { answer: "fishes" path: "Panels/Hallway/panel_7b" }
 }
@@ -1,5 +1,4 @@
 name: "Red Room"
-display_name: "Red Room"
 panels {
   name: "SANDWICH"
   path: "Panels/Hallway/panel_3"
@@ -1,5 +1,4 @@
 name: "White Room"
-display_name: "White Room"
 panels {
   name: "BRIGHT"
   path: "Panels/Hallway/panel_1"
@@ -9,6 +8,8 @@ panels {
 }
 ports {
   name: "GREAT"
+  display_name: "Main Entrance"
   path: "Components/Warps/worldport"
-  orientation: "west"
+  destination { x: -3.5 y: 0 z: 19 }
+  rotation: 270
 }
@@ -1,5 +1,4 @@
 name: "Window Room"
-display_name: "Window Room"
 panels {
   name: "FADING"
   path: "Panels/Hallway/panel_10"
@@ -1,5 +1,4 @@
 name: "Yellow Room"
-display_name: "Yellow Room"
 panels {
   name: "CIRCLE"
   path: "Panels/Hallway/panel_6"
@@ -17,6 +17,7 @@ doors {
   panels { room: "Main Area" name: "LABS (1)" }
   panels { room: "Main Area" name: "LABS (2)" }
   location_room: "Main Area"
+  location_name: "Obverse Cyan Large Room"
 }
 doors {
   name: "Flipped Yellow Door"
@@ -33,6 +34,7 @@ doors {
   panels { room: "Flipped Magenta Room" name: "LUST" }
   panels { room: "Flipped Magenta Room" name: "LAND" }
   location_room: "Flipped Magenta Room"
+  location_name: "Flipped Magenta Room"
 }
 doors {
   name: "C Keyholder Blocker"
@@ -47,6 +49,7 @@ doors {
   panels { room: "Flipped Yellow Room" name: "CAVE (1)" }
   panels { room: "Flipped Yellow Room" name: "CAVE (2)" }
   location_room: "Flipped Yellow Room"
+  location_name: "Flipped Yellow Room"
 }
 doors {
   name: "C2 Door"
@@ -59,6 +62,7 @@ doors {
     key: "c"
   }
   location_room: "C Keyholder"
+  location_name: "C Keyholder"
 }
 doors {
   name: "Obverse Yellow Door"
@@ -111,10 +115,15 @@ doors {
     key: "g"
   }
   location_room: "G Keyholder"
+  location_name: "G Keyholder"
 }
 doors {
   name: "T Keyholder Blocker"
-  type: ITEM_ONLY
+  type: EVENT
   receivers: "Components/Doors/magenta_enterer3"
-  switches: "lavender_cubes"
+  panels {
+    map: "the_ancient"
+    room: "Inside"
+    name: "COLOR"
+  }
 }
@@ -1,5 +1,4 @@
 name: "C Keyholder"
-display_name: "Main Area"
 keyholders {
   name: "C"
   path: "Components/KeyHolders/keyHolder"
@@ -1,5 +1,4 @@
 name: "C2 Room"
-display_name: "Main Area"
 letters {
   key: "c"
   level2: true
@@ -1,5 +1,4 @@
 name: "Flipped Magenta Room"
-display_name: "Flipped Magenta Room"
 panels {
   name: "LOOK"
   path: "Panels/Side Up 1/panel_1"
@@ -1,5 +1,4 @@
 name: "Flipped Yellow Room"
-display_name: "Flipped Yellow Room"
 panels {
   name: "DANCER"
   path: "Panels/Back 1/panel_1"
@@ -1,5 +1,4 @@
 name: "G Keyholder"
-display_name: "Obverse Yellow Room"
 keyholders {
   name: "G"
   path: "Components/KeyHolders/keyHolder2"
@@ -1,5 +1,4 @@
 name: "G2 Room"
-display_name: "Main Area"
 letters {
   key: "g"
   level2: true
@@ -1,5 +1,4 @@
 name: "Main Area"
-display_name: "Main Area"
 panels {
   name: "LANE (1)"
   path: "Panels/Main/panel_1"
@@ -86,8 +85,10 @@ panels {
 }
 ports {
   name: "DARKROOM"
+  display_name: "Entrance"
   path: "Components/Warps/worldport2"
-  orientation: "north"
+  destination { x: -19 y: 0 z: 7.5 }
+  rotation: 180
 }
 paintings {
   name: "P"
@@ -1,5 +1,4 @@
 name: "Obverse Magenta Room"
-display_name: "Obverse Magenta Room"
 # TODO: Should these two maybe not be randomizable because they hint the keyholder?
 paintings {
   name: "TEA"
@@ -1,5 +1,4 @@
 name: "Obverse Yellow Room"
-display_name: "Obverse Yellow Room"
 panels {
   name: "CIVIL"
   path: "Panels/Main/panel_6"
@@ -1,6 +1,6 @@
 name: "T Keyholder"
-display_name: "Obverse Magenta Room"
 keyholders {
   name: "T"
   path: "Components/KeyHolders/keyHolderT"
+  key: "t"
 }
@@ -1,7 +1,12 @@
 connections {
+  from_room: "First Room"
+  to_room: "First Room Exit"
+  door { name: "Second Room Entrance" }
+}
+connections {
   from {
     port {
-      room: "First Room"
+      room: "First Room Exit"
       name: "NEXT"
     }
   }
@@ -14,9 +19,14 @@ connections {
   oneway: true
 }
 connections {
+  from_room: "Second Room"
+  to_room: "Second Room Exit"
+  door { name: "Third Room Entrance" }
+}
+connections {
   from {
     port {
-      room: "Second Room"
+      room: "Second Room Exit"
       name: "NEXT"
     }
   }
@@ -33,3 +43,18 @@ connections {
   to_room: "S Room"
   door { name: "S1 Door" }
 }
+connections {
+  from_room: "First Room"
+  to_room: "Cyan Hallway"
+  door { name: "Colorful Entrance" }
+}
+connections {
+  from_room: "Second Room"
+  to_room: "Congruent Entrance"
+  door { name: "Congruent Entrance" }
+}
+connections {
+  from_room: "First Room"
+  to_room: "Double Sided Entrance"
+  door { name: "Double Sided Entrance" }
+}
@@ -1,11 +1,10 @@
 # TODO: gallery painting
 doors {
   name: "Double Letter Panel Blockers"
-  type: ITEM_ONLY
+  type: EVENT
   receivers: "Panels/Room 1/panel_3/visibilityListener"
   receivers: "Panels/Room 2/panel_3/visibilityListener"
-  # TODO: honestly idk if this should even exist
-  switches: "double_letters"
+  double_letters: true
 }
 doors {
   name: "Second Room Entrance"
@@ -23,8 +22,7 @@ doors {
 }
 doors {
   name: "S1 Door"
-  type: LOCATION_ONLY
-  receivers: "Components/Doors/entry_3"
+  type: EVENT
   panels { room: "Third Room" name: "CULTS" }
   panels { room: "Third Room" name: "TURNS" }
   panels { room: "Third Room" name: "COINS" }
@@ -34,7 +32,6 @@ doors {
   panels { room: "Third Room" name: "LOCKS" }
   panels { room: "Third Room" name: "TOUCHES" }
   panels { room: "Third Room" name: "KOI" }
-  location_room: "Third Room"
 }
 doors {
   name: "Colorful Entrance"
@@ -46,6 +43,7 @@ doors {
   panels { room: "First Room" name: "KOI" }
   panels { room: "First Room" name: "TUNA" }
   location_room: "First Room"
+  location_name: "All Puzzles"
 }
 doors {
   name: "Congruent Entrance"
@@ -57,6 +55,7 @@ doors {
   panels { room: "Second Room" name: "KOI" }
   panels { room: "Second Room" name: "TUNA" }
   location_room: "Second Room"
+  location_name: "All Puzzles"
 }
 doors {
   name: "Double Sided Entrance"
@@ -0,0 +1,9 @@
+name: "Congruent Entrance"
+panel_display_name: "Second Room"
+ports {
+  name: "CONGRUENT"
+  display_name: "Second Room Gray Hallway"
+  path: "Components/Warps/worldport7"
+  destination { x: 51.5 y: 0 z: 29 }
+  rotation: 90
+}
@@ -0,0 +1,9 @@
+name: "Cyan Hallway"
+panel_display_name: "First Room"
+ports {
+  name: "COLORFUL"
+  display_name: "First Room Cyan Hallway"
+  path: "Components/Warps/worldport8"
+  destination { x: 20 y: 0 z: -12 }
+  rotation: 180
+}
@@ -0,0 +1,9 @@
+name: "Double Sided Entrance"
+panel_display_name: "First Room"
+ports {
+  name: "DOUBLESIDED"
+  display_name: "First Room White Hallway"
+  path: "Components/Warps/worldport6"
+  destination { x: 15 y: 0 z: 23 }
+  rotation: 90
+}
@@ -0,0 +1,9 @@
+name: "First Room Exit"
+panel_display_name: "First Room"
+ports {
+  name: "NEXT"
+  display_name: "First Room Exit"
+  path: "Components/Warps/worldport2"
+  destination { x: 0 y: 0 z: -15 }
+  rotation: 180
+}
@@ -1,5 +1,5 @@
 name: "First Room"
-display_name: "First Room"
+panel_display_name: "First Room"
 panels {
   name: "BISON"
   path: "Panels/Room 1/panel_1"
@@ -33,24 +33,8 @@ panels {
 }
 ports {
   name: "ENTRY"
+  display_name: "First Room Entrance"
   path: "Components/Warps/worldport"
-  orientation: "south"
-}
-ports {
-  name: "NEXT"
-  path: "Components/Warps/worldport2"
-  orientation: "north"
-  required_door { name: "Second Room Entrance" }
-}
-ports {
-  name: "COLORFUL"
-  path: "Components/Warps/worldport8"
-  orientation: "north"
-  required_door { name: "Colorful Entrance" }
-}
-ports {
-  name: "DOUBLESIDED"
-  path: "Components/Warps/worldport6"
-  orientation: "east"
-  required_door { name: "Double Sided Entrance" }
+  destination { x: -10 y: 0 z: 10 }
+  rotation: 0
 }
@@ -1,5 +1,4 @@
 name: "S Room"
-display_name: "Third Room"
 letters {
   key: "s"
   path: "Components/Collectables/collectable"
@@ -0,0 +1,9 @@
+name: "Second Room Exit"
+panel_display_name: "Second Room"
+ports {
+  name: "NEXT"
+  display_name: "Second Room Exit"
+  path: "Components/Warps/worldport4"
+  destination { x: 48 y: 0 z: -15 }
+  rotation: 180
+}
@@ -1,5 +1,5 @@
 name: "Second Room"
-display_name: "Second Room"
+panel_display_name: "Second Room"
 panels {
   name: "BISON"
   path: "Panels/Room 2/panel_1"
@@ -38,18 +38,8 @@ panels {
 }
 ports {
   name: "ENTRY"
+  display_name: "Second Room Entrance"
   path: "Components/Warps/worldport3"
-  orientation: "south"
-}
-ports {
-  name: "NEXT"
-  path: "Components/Warps/worldport4"
-  orientation: "north"
-  required_door { name: "Third Room Entrance" }
-}
-ports {
-  name: "CONGRUENT"
-  path: "Components/Warps/worldport7"
-  orientation: "east"
-  required_door { name: "Congruent Entrance" }
+  destination { x: 38 y: 0 z: 10 }
+  rotation: 0
 }
@@ -1,5 +1,5 @@
 name: "Third Room"
-display_name: "Third Room"
+panel_display_name: "Third Room"
 panels {
   name: "CULTS"
   path: "Panels/Room 3/panel_1"
@@ -65,6 +65,8 @@ panels {
 }
 ports {
   name: "ENTRY"
+  display_name: "Third Room Entrance"
   path: "Components/Warps/worldport5"
-  orientation: "south"
+  destination { x: 97 y: 0 z: 10 }
+  rotation: 0
 }
@@ -24,11 +24,6 @@ connections {
   door { name: "Gallery Entrance" }
 }
 connections {
-  from_room: "Gallery Maze"
-  to_room: "Main Area"
-  oneway: true
-}
-connections {
   from_room: "Tree Area"
   to_room: "Main Area"
   door { name: "Tree Entrance" }
@@ -1,5 +1,4 @@
 name: "C Room"
-display_name: "Chamber"
 letters {
   key: "c"
   path: "Components/Collectables/c"
@@ -1,5 +1,4 @@
 name: "Chamber"
-display_name: "Chamber"
 panels {
   name: "I"
   path: "Panels/c1"
@@ -1,7 +1,8 @@
 name: "Gallery Maze"
-display_name: "Main Area"
 ports {
   name: "GALLERY"
+  display_name: "Gallery Maze Worldport"
   path: "Components/Warps/worldport4"
-  orientation: "east"
+  destination { x: -58 y: 0 z: -76 }
+  rotation: 90
 }
@@ -1,5 +1,4 @@
 name: "Main Area"
-display_name: "Main Area"
 panels {
   name: "HIT"
   path: "Panels/open_c"
@@ -28,16 +27,22 @@ panels {
 }
 ports {
   name: "ENTRY1"
+  display_name: "Maze NW Worldport"
   path: "Components/Worldports/worldport3"
-  orientation: "west"
+  destination { x: -33 y: 0 z: 28 }
+  rotation: 270
 }
 ports {
   name: "ENTRY2"
+  display_name: "Maze SW Worldport"
   path: "Components/Worldports/worldport"
-  orientation: "south"
+  destination { x: -30 y: 0 z: 51 }
+  rotation: 0
 }
 ports {
   name: "ENTRY3"
+  display_name: "Maze SE Worldport"
   path: "Components/Worldports/worldport2"
-  orientation: "south"
+  destination { x: 0 y: 0 z: 51 }
+  rotation: 0
 }
@@ -1,5 +1,4 @@
 name: "Tree Area"
-display_name: "Main Area"
 panels {
   name: "TREE"
   path: "Panels/open_tree"
@@ -9,7 +8,8 @@ panels {
 }
 ports {
   name: "TREE"
+  display_name: "Brown Hallway"
   path: "Components/Worldports/worldport4"
-  orientation: "east"
-  # This is double sided.
+  destination { x: -16 y: 0 z: -31 }
+  rotation: 270
 }
@@ -1,5 +1,4 @@
 name: "U Room"
-display_name: "Chamber"
 letters {
   key: "u"
   path: "Components/Collectables/u"
@@ -1,6 +1,8 @@
 name: "Unyielding Entrance"
 ports {
   name: "UNYIELDING"
+  display_name: "Blue Door Worldport"
   path: "Components/Warps/worldport5"
-  orientation: "east"
+  destination { x: 14 y: 0 z: 5 }
+  rotation: 90
 }
@@ -1,5 +1,4 @@
 name: "Ending"
-display_name: "Main Area"
 endings {
   name: "PLUM"
   path: "Components/plum_ending"
@@ -1,5 +1,4 @@
 name: "Main Area"
-display_name: "Main Area"
 panels {
   name: "HAIR"
   path: "Panels/Room_1/panel"
@@ -1,5 +1,4 @@
 name: "Brown Area"
-display_name: "Maze"
 masteries {
   name: "MASTERY"
   path: "Components/Collectables/smiley"
@@ -1,5 +1,4 @@
 name: "Flipped Black Area"
-display_name: "Maze"
 panels {
   name: "SEAPLANE"
   path: "Panels/Maze/panel_15"
@@ -1,5 +1,4 @@
 name: "Flipped Blue Area"
-display_name: "Maze"
 panels {
   name: "SKY"
   path: "Panels/Maze/panel_5"
@@ -1,5 +1,4 @@
 name: "Flipped Green Area"
-display_name: "Maze"
 panels {
   name: "HIGH"
   path: "Panels/Maze/panel_3"
@@ -1,5 +1,4 @@
 name: "Flipped Orange Area"
-display_name: "Maze"
 panels {
   name: "HEAVEN"
   path: "Panels/Maze/panel_6"
@@ -1,2 +1 @@
 name: "Flipped Pink Area"
-display_name: "Maze"
@@ -1,5 +1,4 @@
 name: "Flipped Purple Area"
-display_name: "Maze"
 panels {
   name: "CEILING"
   path: "Panels/Maze/panel_8"
@@ -1,5 +1,4 @@
 name: "Flipped Red Area"
-display_name: "Maze"
 panels {
   name: "RAISED"
   path: "Panels/Maze/panel_12"
@@ -1,5 +1,4 @@
 name: "Flipped Yellow Back Area"
-display_name: "Maze"
 panels {
   name: "ANGELS"
   path: "Panels/Maze/panel_13"
@@ -1,2 +1 @@
 name: "Flipped Yellow Front Area"
-display_name: "Maze"
@@ -1,5 +1,4 @@
 name: "Obverse Black Area"
-display_name: "Maze"
 panels {
   name: "MOUNTAIN"
   path: "Panels/Maze/panel_16"
@@ -1,2 +1 @@
 name: "Obverse Blue Area"
-display_name: "Maze"
@@ -1,5 +1,4 @@
 name: "Obverse Green Area"
-display_name: "Maze"
 panels {
   name: "UPSIDE"
   path: "Panels/Maze/panel_7"
@@ -1,5 +1,4 @@
 name: "Obverse Orange Back Area"
-display_name: "Maze"
 panels {
   name: "OVER"
   path: "Panels/Maze/panel_2b"
@@ -1,5 +1,4 @@
 name: "Obverse Orange Front Area"
-display_name: "Maze"
 panels {
   name: "UP"
   path: "Panels/Maze/panel_2"
@@ -1,5 +1,4 @@
 name: "Obverse Orange Isolated Section"
-display_name: "Maze"
 panels {
   name: "TOP"
   path: "Panels/Maze/panel_4"
@@ -1,5 +1,4 @@
 name: "Obverse Pink Area"
-display_name: "Maze"
 panels {
   name: "CLOUD"
   path: "Panels/Maze/panel_14"
@@ -1,5 +1,4 @@
 name: "Obverse Purple Area"
-display_name: "Maze"
 panels {
   name: "DRAGON"
   path: "Panels/Maze/panel_18"
@@ -1,2 +1 @@
 name: "Obverse Red Area"
-display_name: "Maze"
@@ -1,2 +1 @@
 name: "Obverse Yellow Area"
-display_name: "Maze"
@@ -1,5 +1,4 @@
 name: "Start"
-display_name: "Maze"
 panels {
   name: "ATTIC"
   path: "Panels/Maze/panel_11"
@@ -16,6 +15,8 @@ panels {
 }
 ports {
   name: "DARKROOM"
+  display_name: "Entrance"
   path: "Components/Warps/worldport"
-  orientation: "west"
+  destination { x: -3 y: 0 z: 8 }
+  rotation: 270
 }
@@ -90,8 +90,19 @@ connections {
 }
 connections {
   from_room: "Red Blue Halls"
+  to_room: "Least Blue Last"
+  oneway: true
+}
+connections {
+  from_room: "Red Blue Halls"
   to_room: "Wrath Room"
   door { name: "Noon Door" }
+  oneway: true
+}
+connections {
+  from_room: "Wrath Room"
+  to_room: "Least Blue Last"
+  oneway: true
 }
 connections {
   from_room: "Red Blue Halls"
@@ -100,6 +111,11 @@ connections {
 }
 connections {
   from_room: "Wrath Room"
+  to_room: "Rabbit Hole Lock"
+  door { name: "Noon Door" }
+}
+connections {
+  from_room: "Wrath Room"
   to_room: "Rabbit Hole"
   door { name: "Rabbithole Door" }
 }
@@ -116,7 +132,7 @@ connections {
 connections {
   from_room: "Blue Alcove"
   to_room: "Least Blue Last"
-  door { name: "Red Alcove Exit" }
+  door { name: "Blue Alcove Exit" }
 }
 connections {
   from_room: "Parthenon Return"
@@ -144,6 +160,11 @@ connections {
   door { name: "Lime Room Entrance" }
 }
 connections {
+  from_room: "Lime Room"
+  to_room: "Revitalized Entrance"
+  door { name: "Revitalized Entrance" }
+}
+connections {
   from { painting { room: "Link Area" name: "NEAR" } }
   to { painting { room: "Flipped Link Area" name: "NEAR" } }
   oneway: true
@@ -162,12 +183,12 @@ connections {
   from_room: "Starting Room"
   to_room: "Digital Entrance"
   door { name: "Second Room Left Door" }
-  oneway: true
 }
 connections {
   from_room: "Digital Entrance"
   to_room: "Starting Room"
   oneway: true
+  vanilla_only: true
 }
 connections {
   from_room: "Starting Room"
@@ -182,10 +203,25 @@ 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"
   to_room: "White Hallway To Daedalus"
   door { name: "Control Center White Door" }
 }
+connections {
+  from_room: "Flipped Second Room"
+  to_room: "Four Rooms Entrance"
+  door { name: "Flipped Second Room Right Door" }
+}
+connections {
+  from_room: "Link Area"
+  to_room: "Liberated Entrance"
+  door { name: "Liberated Entrance" }
+}
+connections {
+  from_room: "Link Area"
+  to_room: "Literate Entrance"
+  door { name: "Literate Entrance" }
+}
@@ -62,9 +62,9 @@ doors {
   name: "Rabbithole Door"
   type: STANDARD
   receivers: "Components/Doors/second_right8"
-  panels { room: "Wrath Room" name: "RABBIT" }
-  panels { room: "Wrath Room" name: "HOLE" }
-  location_room: "Wrath Room"
+  panels { room: "Rabbit Hole Lock" name: "RABBIT" }
+  panels { room: "Rabbit Hole Lock" name: "HOLE" }
+  location_room: "Rabbit Hole Lock"
 }
 # second_right is vanilla because it's like LOST door.
 doors {
@@ -113,10 +113,9 @@ doors {
 }
 doors {
   name: "Right Eye Entrance"
-  type: STANDARD
+  type: ITEM_ONLY
   receivers: "Components/Doors/third_right"
   panels { room: "Trick Room" name: "INK" }
-  location_room: "Trick Room"
 }
 doors {
   name: "Red Blue Area Left Door"
@@ -138,8 +137,10 @@ doors {
   type: STANDARD
   receivers: "Components/Doors/back_left_2"
   panels { room: "Colored Doors Area" name: "OPEN" answer: "orange" }
-  # "wall" is supposed to also work. idk man
+  panels { room: "Colored Doors Area" name: "OPEN" answer: "wall" }
+  complete_at: 1
   location_room: "Colored Doors Area"
+  location_name: "OPEN"
 }
 doors {
   name: "Lime Room Entrance"
@@ -194,10 +195,10 @@ 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"
-  switches: "double_letters"
+  double_letters: true
 }
 doors {
   name: "Shop Entrance"
@@ -215,9 +216,9 @@ doors {
 }
 doors {
   name: "Flipped Pyramid Area Entrance"
-  type: ITEM_ONLY
+  type: EVENT
   receivers: "Components/Doors/Entry/entry_proxied_12"
-  switches: "double_letters"
+  double_letters: true
 }
 doors {
   name: "Literate Entrance"
@@ -252,7 +253,7 @@ doors {
   type: ITEM_ONLY
   receivers: "Components/Doors/Entry/d_3"
   receivers: "Components/Doors/Entry/d_4"
-  switches: "double_letters"
+  double_letters: true
 }
 doors {
   name: "D Room Panels"
@@ -287,7 +288,8 @@ doors {
 doors {
   name: "Least Blue Last Panels"
   type: EVENT
-  move_paintings { room: "Starting Room" name: "OWL" }
+  #move_paintings { room: "Starting Room" name: "OWL" }
+  #receivers: "Components/Paintings/owl/visibilityListener"
   panels { room: "Least Blue Last" name: "CAPABLE (1)" }
   panels { room: "Least Blue Last" name: "CAPABLE (2)" }
   panels { room: "Least Blue Last" name: "LUSTRE" }
@@ -301,7 +303,8 @@ doors {
 doors {
   name: "Red Room Painting"
   type: STANDARD
-  move_paintings { room: "Right Eye" name: "PSYCHIC" }
+  #move_paintings { room: "Right Eye" name: "PSYCHIC" }
+  receivers: "Components/Paintings/psychic/teleportListener"
   panels { room: "Right Eye" name: "FAINT" }
   location_room: "Right Eye"
 }
@@ -9,3 +9,5 @@ excluded_nodes: "Panels/Back Left/backleft_3_proxied_1"
 excluded_nodes: "Panels/Back Left/backleft_3_proxied_2"
 excluded_nodes: "Panels/Back Left/backleft_4_proxied_1"
 excluded_nodes: "Panels/Back Left/backleft_4_proxied_2"
+# This is a proxy related to the first panel and it doesn't seem useful.
+excluded_nodes: "Panels/Entry/entry_proxied_fake"
@@ -1,5 +1,5 @@
 name: "Blue Alcove"
-display_name: "Red Blue Area"
+panel_display_name: "Red Blue Area"
 panels {
   name: "BLUE"
   path: "Panels/Back Right/br_11"
@@ -1,5 +1,5 @@
 name: "Colored Doors Area"
-display_name: "Colored Doors Area"
+panel_display_name: "Colored Doors Area"
 panels {
   name: "OPEN"
   path: "Panels/Back Left/backleft_proxying_1"
@@ -1,7 +1,9 @@
 name: "Composite Room Entrance"
-display_name: "Starting Room"
+panel_display_name: "Starting Room"
 ports {
   name: "COMPOSITE"
+  display_name: "Starting Room NE Worldport"
   path: "Components/Warps/worldport12"
-  orientation: "east"
+  destination { x: 16 y: 0 z: -20 }
+  rotation: 90
 }
@@ -1,5 +1,5 @@
 name: "Ctrl Tutorial"
-display_name: "Colored Doors Area"
+panel_display_name: "Colored Doors Area"
 panels {
   name: "RIGHT"
   path: "Panels/Back Left/backleft_proxying_2"
@@ -1,5 +1,5 @@
 name: "D Room Final"
-display_name: "D Room"
+panel_display_name: "D Room"
 letters {
   key: "d"
   path: "Components/Collectables/d"
@@ -1,5 +1,5 @@
 name: "D Room"
-display_name: "D Room"
+panel_display_name: "D Room"
 panels {
   name: "BASEBALL"
   path: "Panels/D/d_2"
@@ -1,7 +1,9 @@
 name: "Daedalus Entrance"
-display_name: "Starting Room"
+panel_display_name: "Starting Room"
 ports {
   name: "DAEDALUS"
+  display_name: "Starting Room North Wall West Worldport"
   path: "Components/Warps/worldport6"
-  orientation: "west"
+  destination { x: -16 y: 0 z: -20 }
+  rotation: 270
 }
@@ -1,7 +1,9 @@
 name: "Digital Entrance"
-display_name: "Starting Room"
+panel_display_name: "Starting Room"
 ports {
   name: "DIGITAL"
+  display_name: "Second Room Left Worldport"
   path: "Components/Warps/worldport"
-  orientation: "west"
+  destination { x: -78 y: 0 z: -24 }
+  rotation: 270
 }
@@ -1,7 +1,9 @@
 name: "Entry Exit"
-display_name: "Starting Room"
+panel_display_name: "Starting Room"
 ports {
   name: "GREAT"
+  display_name: "Second Room Right Worldport"
   path: "Components/Warps/worldport2"
-  orientation: "north"
+  destination { x: 18 y: 0 z: -36 }
+  rotation: 180
 }
@@ -1,5 +1,5 @@
 name: "Eye Room"
-display_name: "Eye Room"
+panel_display_name: "Eye Room"
 panels {
   name: "I"
   path: "Panels/Entry/eyes_1"
@@ -31,6 +31,8 @@ paintings {
 }
 ports {
   name: "LIONIZED"
+  display_name: "Eye Room Worldport"
   path: "Components/Warps/worldport10"
-  orientation: "north"
+  destination { x: 18 y: 0 z: -88.5 }
+  rotation: 180
 }
@@ -1,18 +1,19 @@
 name: "Flipped Link Area"
-display_name: "Pyramid Area"
+panel_display_name: "Pyramid Area"
 panels {
   name: "WANDER"
   path: "Panels/Pilgrimage/cream_4"
   clue: "wander"
   answer: "roam"
   symbols: SUN
+  display_name: "WANDER (Flipped)"
 }
 paintings {
   name: "NEAR"
   path: "Components/Paintings/aches2"
   orientation: "north"
   gravity: Y_PLUS
-  display_name: "Flipper Near Painting"
+  display_name: "Flipped Near Painting"
 }
 paintings {
   name: "FAR"
@@ -1,5 +1,5 @@
 name: "Flipped Pyramid Area"
-display_name: "Pyramid Area"
+panel_display_name: "Pyramid Area"
 panels {
   name: "TURN (1)"
   path: "Panels/Entry/l_opener_3"
@@ -1,5 +1,5 @@
 name: "Flipped Right Eye"
-display_name: "Flip Area"
+panel_display_name: "Flip Area"
 panels {
   name: "WHERE"
   path: "Panels/Pilgrimage/cream_5"
@@ -1,5 +1,5 @@
 name: "Flipped Second Room"
-display_name: "Flip Area"
+panel_display_name: "Flip Area"
 panels {
   name: "CLUE"
   path: "Panels/Entry/second_right_top"
@@ -21,10 +21,3 @@ paintings {
   gravity: Y_PLUS
   display_name: "Eye Painting"
 }
-ports {
-  name: "FOUR"
-  path: "Components/Warps/worldport9"
-  orientation: "south"
-  gravity: Y_PLUS
-  required_door { name: "Flipped Second Room Right Door" }
-}
\ No newline at end of file
@@ -0,0 +1,9 @@
+name: "Four Rooms Entrance"
+ports {
+  name: "FOUR"
+  display_name: "Flipped Second Room Right Worldport"
+  path: "Components/Warps/worldport9"
+  destination { x: -41 y: 6 z: -17.5 }
+  rotation: 0
+  gravity: Y_PLUS
+}
@@ -1,5 +1,5 @@
 name: "Gallery Return"
-display_name: "Starting Room"
+panel_display_name: "Gallery Return"
 panels {
   name: "RETURN"
   path: "Panels/Entry/gallery_return"
@@ -9,6 +9,8 @@ panels {
 }
 ports {
   name: "GALLERY"
+  display_name: "Gallery Return"
   path: "Components/Warps/worldport4"
-  orientation: "north"
+  destination { x: -38 y: 0 z: 8.5 }
+  rotation: 180
 }
\ No newline at end of file
@@ -1,5 +1,5 @@
 name: "Least Blue Last"
-display_name: "Red Blue Area"
+panel_display_name: "Red Blue Area"
 panels {
   name: "CAPABLE (1)"
   path: "Panels/LBL/lbl_1"
@@ -72,8 +72,10 @@ panels {
 }
 ports {
   name: "DARKROOM"
+  display_name: "Near L1 Worldport"
   path: "Components/Warps/worldport5"
-  orientation: "south"
+  destination { x: 43 y: 0 z: -10 }
+  rotation: 0
 }
 paintings {
   name: "PAINS"
@@ -0,0 +1,8 @@
+name: "Liberated Entrance"
+ports {
+  name: "BLUE"
+  display_name: "Pyramid Area Blue Worldport"
+  path: "worldport8"
+  destination { x: 18 y: 0 z: 55 }
+  rotation: 270
+}
@@ -1,5 +1,5 @@
 name: "Lime Room"
-display_name: "Colored Doors Area"
+panel_display_name: "Colored Doors Area"
 panels {
   name: "HIDE"
   path: "Panels/Back Left/backleft_proxying_3"
@@ -19,9 +19,3 @@ panels {
   answer: "white"
   symbols: EXAMPLE
 }
-ports {
-  name: "REVITALIZED"
-  path: "worldport7"
-  orientation: "north"
-  required_door { name: "Revitalized Entrance" }
-}
\ No newline at end of file
@@ -1,11 +1,12 @@
 name: "Link Area"
-display_name: "Pyramid Area"
+panel_display_name: "Pyramid Area"
 panels {
   name: "WANDER"
   path: "Panels/Pilgrimage/cream_3"
   clue: "wander"
   answer: "amble"
   symbols: SUN
+  display_name: "WANDER (Obverse)"
 }
 paintings {
   name: "NEAR"
@@ -25,15 +26,3 @@ paintings {
   orientation: "south"
   display_name: "Center Painting"
 }
-ports {
-  name: "BLUE"
-  path: "worldport8"
-  orientation: "west"
-  required_door { name: "Liberated Entrance" }
-}
-ports {
-  name: "BROWN"
-  path: "worldport9"
-  orientation: "east"
-  required_door { name: "Literate Entrance" }
-}
\ No newline at end of file
@@ -0,0 +1,8 @@
+name: "Literate Entrance"
+ports {
+  name: "BROWN"
+  display_name: "Pyramid Area Brown Worldport"
+  path: "worldport9"
+  destination { x: 39 y: 0 z: 55 }
+  rotation: 90
+}
@@ -1,5 +1,5 @@
 name: "Parthenon Return"
-display_name: "Starting Room"
+panel_display_name: "Parthenon Return"
 panels {
   name: "RETURN"
   path: "Panels/Back Left/backleft_return"
@@ -9,6 +9,8 @@ panels {
 }
 ports {
   name: "PARTHENON"
+  display_name: "Parthenon Return"
   path: "Components/Warps/worldport8"
-  orientation: "north"
-}
\ No newline at end of file
+  destination { x: -5.5 y: 0 z: 18 }
+  rotation: 180
+}
@@ -0,0 +1,18 @@
+name: "Rabbit Hole Lock"
+panel_display_name: "Red Blue Area"
+panels {
+  name: "RABBIT"
+  path: "Panels/Back Right/br_4"
+  clue: "rabbit"
+  answer: "hair"
+  symbols: SUN
+  symbols: ZERO
+}
+panels {
+  name: "HOLE"
+  path: "Panels/Back Right/br_5"
+  clue: "hole"
+  answer: "part"
+  symbols: ZERO
+  symbols: BOXES
+}
@@ -1,5 +1,5 @@
 name: "Rabbit Hole"
-display_name: "Red Blue Area"
+panel_display_name: "Red Blue Area"
 panels {
   name: "PUZZLE"
   path: "Panels/Back Right/br_6"
@@ -8,6 +8,8 @@ panels {
 }
 ports {
   name: "HOLE"
+  display_name: "Rabbit Hole"
   path: "worldport4"
-  orientation: "down"
-}
\ No newline at end of file
+  destination { x: 74 y: 0 z: -43 }
+  rotation: 0
+}
@@ -1,5 +1,5 @@
 name: "Red Alcove"
-display_name: "Red Blue Area"
+panel_display_name: "Red Blue Area"
 panels {
   name: "BROW"
   path: "Panels/Back Right/br_10"
@@ -1,5 +1,5 @@
 name: "Red Blue Halls"
-display_name: "Red Blue Area"
+panel_display_name: "Red Blue Area"
 panels {
   name: "CENTER"
   path: "Panels/Back Right/br_1"
@@ -1,7 +1,12 @@
 name: "Repetitive Entrance"
-display_name: "Starting Room"
+panel_display_name: "Starting Room"
 ports {
   name: "REPETITIVE"
+  display_name: "Starting Room West Wall North Worldport"
   path: "Components/Warps/worldport7"
-  orientation: "north"
+  destination { x: -20 y: 0 z: -16 }
+  rotation: 180
+  # TODO: this is part of what makes the keyholder dependent connection from CC
+  # safe in vanilla doors
+  no_shuffle: true
 }
@@ -0,0 +1,9 @@
+name: "Revitalized Entrance"
+panel_display_name: "Colored Doors Area"
+ports {
+  name: "REVITALIZED"
+  display_name: "Plum Hallway"
+  path: "worldport7"
+  destination { x: -58 y: 0 z: 31.5 }
+  rotation: 180
+}
@@ -1,5 +1,5 @@
 name: "Right Eye"
-display_name: "Right Eye Area"
+panel_display_name: "Right Eye Area"
 panels {
   name: "EYE"
   path: "Panels/Entry/front_2"
@@ -1,5 +1,5 @@
 name: "Shop Entrance"
-display_name: "Starting Room"
+panel_display_name: "Shop Entrance"
 panels {
   name: "TURN"
   path: "Panels/Entry/l_opener_2"
@@ -9,6 +9,8 @@ panels {
 }
 ports {
   name: "SHOP"
+  display_name: "Shop Entrance"
   path: "Components/Warps/worldport13"
-  orientation: "east"
+  destination { x: 18 y: 0 z: 49 }
+  rotation: 90
 }
\ No newline at end of file
@@ -1,10 +1,11 @@
 name: "Starting Room"
-display_name: "Starting Room"
+panel_display_name: "Starting Room"
 panels {
   name: "HI"
   path: "Panels/Entry/entry_proxying_1"
   clue: "hi"
   answer: "hi"
+  proxies { answer: "hi" path: "Panels/Entry/entry_proxied_1" }
   proxies { answer: "bye" path: "Panels/Entry/entry_proxied_2" }
   proxies { answer: "hidden" path: "Panels/Entry/entry_proxied_5" }
   proxies { answer: "high" path: "Panels/Entry/entry_proxied_3" }
@@ -23,7 +24,9 @@ panels {
   path: "Panels/Entry/front_1"
   clue: "eye"
   answer: "i"
-  symbols: ZERO
+  #symbols: ZERO
+  # This panel blocks getting N1 and T1. We will mod it to be I/I with no symbol
+  # when symbol shuffle is on.
 }
 panels {
   name: "HINT"
@@ -1,5 +1,5 @@
 name: "Trick Room"
-display_name: "Starting Room"
+panel_display_name: "Starting Room"
 panels {
   name: "INK"
   path: "Panels/Entry/l_opener_1"
@@ -1,7 +1,9 @@
 name: "White Hallway To Daedalus"
-display_name: "Colored Doors Area"
+panel_display_name: "Colored Doors Area"
 ports {
   name: "DAEDALUS"
+  display_name: "White Control Center Hallway"
   path: "Components/Warps/worldport11"
-  orientation: "west"
+  destination { x: -45 y: 0 z: 24 }
+  rotation: 270
 }
@@ -1,21 +1,5 @@
 name: "Wrath Room"
-display_name: "Red Blue Area"
-panels {
-  name: "RABBIT"
-  path: "Panels/Back Right/br_4"
-  clue: "rabbit"
-  answer: "hair"
-  symbols: SUN
-  symbols: ZERO
-}
-panels {
-  name: "HOLE"
-  path: "Panels/Back Right/br_5"
-  clue: "hole"
-  answer: "part"
-  symbols: ZERO
-  symbols: BOXES
-}
+panel_display_name: "Red Blue Area"
 panels {
   name: "WREATH"
   path: "Panels/Back Right/br_17"
@@ -1,11 +1,13 @@
 name: "X Area"
-display_name: "Starting Room"
+panel_display_name: "Starting Room"
 letters {
   key: "x"
   path: "Components/Collectables/x"
 }
 ports {
   name: "CC"
+  display_name: "Near X1 Worldport"
   path: "Components/Warps/worldport3"
-  orientation: "west"
+  destination { x: -12.5 y: 0 z: 60 }
+  rotation: 270
 }
@@ -1,5 +1,4 @@
 name: "E Room"
-display_name: "3"
 letters {
   key: "e"
   path: "Components/Collectables/e"
@@ -1,5 +1,4 @@
 name: "Engine Room"
-display_name: "Engine Room"
 panels {
   name: "ENGINE"
   path: "Panels/panel_8"
@@ -23,7 +22,9 @@ paintings {
 }
 ports {
   name: "GALLERY"
+  display_name: "Engine Room Worldport"
   path: "Components/Warps/worldport2"
   gravity: Z_PLUS
-  # TODO: orientation is not well defined with Z-axis gravity
+  # TODO: entrance shuffling for non Y axis gravity
+  no_shuffle: true
 }
@@ -1,5 +1,4 @@
 name: "Hat Chamber"
-display_name: "3"
 panels {
   name: "BRIM"
   path: "Panels/panel_14"
@@ -1,5 +1,4 @@
 name: "X Minus Middle Leg"
-display_name: "W"
 panels {
   name: "ANTENNA"
   path: "Panels/panel_7"
@@ -1,5 +1,4 @@
 name: "X Minus Right Leg"
-display_name: "W"
 panels {
   name: "ROWBOAT"
   path: "Panels/panel_13"
@@ -1,5 +1,4 @@
 name: "X Minus"
-display_name: "W"
 panels {
   name: "DUO"
   path: "Panels/panel_1"
@@ -1,5 +1,4 @@
 name: "X Plus Middle Leg"
-display_name: "M"
 panels {
   name: "COLONY"
   path: "Panels/panel_10"
@@ -1,5 +1,4 @@
 name: "X Plus Right Leg"
-display_name: "M"
 panels {
   name: "HEAD"
   path: "Panels/panel_4"
@@ -1,5 +1,4 @@
 name: "X Plus"
-display_name: "M"
 panels {
   name: "ROSE"
   path: "Panels/panel_16"
@@ -24,4 +23,5 @@ paintings {
 keyholders {
   name: "M"
   path: "Components/KeyHolders/keyHolderM"
+  key: "m"
 }
@@ -1,5 +1,4 @@
 name: "Y Minus First Floor"
-display_name: "3"
 panels {
   name: "RHINO"
   path: "Panels/panel_2"
@@ -1,5 +1,4 @@
 name: "Y Minus Second Floor"
-display_name: "3"
 panels {
   name: "COMPASS"
   path: "Panels/panel_5"
@@ -1,5 +1,4 @@
 name: "Y Minus Third Floor"
-display_name: "3"
 panels {
   name: "WHISKERS"
   path: "Panels/panel_11"
@@ -1,5 +1,4 @@
 name: "Y Plus First Floor"
-display_name: "E"
 paintings {
   name: "UNDUE"
   path: "Components/Paintings/undue4"
@@ -1,6 +1,5 @@
 name: "Y Plus Third Floor"
 # It's the second floor too...
-display_name: "E"
 panels {
   name: "CACTUS"
   path: "Panels/panel_6"
@@ -1,8 +1,9 @@
 # The Gallery is interesting because there's so many cross-map requirements.
 doors {
   name: "Darkroom Painting"
-  type: ITEM_ONLY
-  move_paintings { room: "Main Area" name: "DARKROOM" }
+  type: GALLERY_PAINTING
+  #move_paintings { room: "Main Area" name: "DARKROOM" }
+  receivers: "Components/Paintings/darkroom/teleportListener"
   panels { map: "the_darkroom" room: "First Room" name: "BISON" }
   panels { map: "the_darkroom" room: "First Room" name: "FISH" }
   panels { map: "the_darkroom" room: "First Room" name: "SHEEP" }
@@ -26,14 +27,16 @@ doors {
 }
 doors {
   name: "Butterfly Painting"
-  type: ITEM_ONLY
-  move_paintings { room: "Main Area" name: "BUTTERFLY" }
+  type: GALLERY_PAINTING
+  #move_paintings { room: "Main Area" name: "BUTTERFLY" }
+  receivers: "Components/Paintings/butterfly/teleportListener"
   rooms { map: "the_butterfly" name: "Main Area" }
 }
 doors {
   name: "Between Painting"
-  type: ITEM_ONLY
-  move_paintings { room: "Main Area" name: "BETWEEN" }
+  type: GALLERY_PAINTING
+  #move_paintings { room: "Main Area" name: "BETWEEN" }
+  receivers: "Components/Paintings/between/teleportListener"
   panels { map: "the_between" room: "Main Area" name: "SUN" }
   panels { map: "the_between" room: "Main Area" name: "KOI" }
   panels { map: "the_between" room: "Main Area" name: "SUN KOI" }
@@ -67,20 +70,44 @@ doors {
 }
 doors {
   name: "Entry Painting"
-  type: ITEM_ONLY
-  move_paintings { room: "Main Area" name: "ENTRY" }
+  type: GALLERY_PAINTING
+  #move_paintings { room: "Main Area" name: "ENTRY" }
+  receivers: "Components/Paintings/eyes/teleportListener"
   panels { map: "the_entry" room: "Eye Room" name: "I" }
 }
 doors {
   name: "Wise Painting"
-  type: ITEM_ONLY
-  move_paintings { room: "Main Area" name: "WISE" }
-  # TODO: any panel in The Wise
+  type: GALLERY_PAINTING
+  #move_paintings { room: "Main Area" name: "WISE" }
+  receivers: "Components/Paintings/triangle/teleportListener"
+  panels { map: "the_wise" room: "Entry" name: "INK" }
+  panels { map: "the_wise" room: "Puzzles" name: "STORY" }
+  panels { map: "the_wise" room: "Puzzles" name: "VENTURE" }
+  panels { map: "the_wise" room: "Puzzles" name: "PASSED" }
+  panels { map: "the_wise" room: "Puzzles" name: "SLUMBERING" }
+  panels { map: "the_wise" room: "Puzzles" name: "RHYME" }
+  panels { map: "the_wise" room: "Puzzles" name: "OBSCURE" }
+  panels { map: "the_wise" room: "Puzzles" name: "PROPHET" }
+  panels { map: "the_wise" room: "Puzzles" name: "ERAS" }
+  panels { map: "the_wise" room: "Puzzles" name: "DARKNESS" }
+  panels { map: "the_wise" room: "Puzzles" name: "PRINCE" }
+  panels { map: "the_wise" room: "Puzzles" name: "BATH" }
+  panels { map: "the_wise" room: "Puzzles" name: "CHAOTIC" }
+  panels { map: "the_wise" room: "Puzzles" name: "EYES" }
+  panels { map: "the_wise" room: "Puzzles" name: "QUEENDOOM" }
+  panels { map: "the_wise" room: "Puzzles" name: "SHOUTS" }
+  panels { map: "the_wise" room: "Puzzles" name: "INTELLIGENCE" }
+  panels { map: "the_wise" room: "Puzzles" name: "EARTHWAR" }
+  panels { map: "the_wise" room: "Puzzles" name: "SLEEPER" }
+  panels { map: "the_wise" room: "Puzzles" name: "BOTTLE" }
+  panels { map: "the_wise" room: "Puzzles" name: "WORDS" }
+  complete_at: 1
 }
 doors {
   name: "Tree Painting"
-  type: ITEM_ONLY
-  move_paintings { room: "Main Area" name: "TREE" }
+  type: GALLERY_PAINTING
+  #move_paintings { room: "Main Area" name: "TREE" }
+  receivers: "Components/Paintings/Clue Maps/tree/teleportListener"
   panels { map: "the_tree" room: "Main Area" name: "COLOR" }
   panels { map: "the_tree" room: "Main Area" name: "DAMAGE (1)" }
   panels { map: "the_tree" room: "Main Area" name: "DAMAGE (2)" }
@@ -115,68 +142,89 @@ doors {
 }
 doors {
   name: "Unyielding Painting"
-  type: ITEM_ONLY
-  move_paintings { room: "Main Area" name: "UNYIELDING" }
+  type: GALLERY_PAINTING
+  #move_paintings { room: "Main Area" name: "UNYIELDING" }
+  receivers: "Components/Paintings/Clue Maps/unyielding/teleportListener"
   rooms { map: "the_unyielding" name: "Digital Entrance" }
 }
 doors {
   name: "Graveyard Painting"
-  type: ITEM_ONLY
-  move_paintings { room: "Main Area" name: "GRAVEYARD" }
+  type: GALLERY_PAINTING
+  #move_paintings { room: "Main Area" name: "GRAVEYARD" }
+  receivers: "Components/Paintings/Endings/grave/teleportListener"
   rooms { map: "the_graveyard" name: "Outside" }
 }
 doors {
   name: "Control Center Painting"
-  type: ITEM_ONLY
-  move_paintings { room: "Main Area" name: "CC" }
+  type: GALLERY_PAINTING
+  #move_paintings { room: "Main Area" name: "CC" }
+  receivers: "Components/Paintings/Endings/desert/teleportListener"
   rooms { map: "the_impressive" name: "M2 Room" }
 }
 doors {
   name: "Tower Painting"
-  type: ITEM_ONLY
-  move_paintings { room: "Main Area" name: "TOWER" }
+  type: GALLERY_PAINTING
+  #move_paintings { room: "Main Area" name: "TOWER" }
+  receivers: "Components/Paintings/Endings/red/teleportListener"
   rooms { map: "the_tower" name: "First Floor" }
 }
 doors {
   name: "Wondrous Painting"
-  type: ITEM_ONLY
-  move_paintings { room: "Main Area" name: "WONDROUS" }
-  # TODO: any panel in The Wondrous
+  type: GALLERY_PAINTING
+  #move_paintings { room: "Main Area" name: "WONDROUS" }
+  receivers: "Components/Paintings/Endings/window/teleportListener"
+  panels { map: "the_wondrous" room: "Entry" name: "WONDER" }
+  panels { map: "the_wondrous" room: "Regular" name: "SHRINK" }
+  panels { map: "the_wondrous" room: "Huge" name: "SHRINK" }
+  panels { map: "the_wondrous" room: "Huge" name: "IRE" }
+  panels { map: "the_wondrous" room: "Huge" name: "BRIE" }
+  panels { map: "the_wondrous" room: "Huge" name: "WICK" }
+  panels { map: "the_wondrous" room: "Huge" name: "BARK" }
+  panels { map: "the_wondrous" room: "Huge" name: "HARE" }
+  panels { map: "the_wondrous" room: "Huge" name: "CHIME" }
+  panels { map: "the_wondrous" room: "Huge" name: "LIBRARY" }
+  complete_at: 1
 }
 doors {
   name: "Rainbow Painting"
-  type: ITEM_ONLY
-  move_paintings { room: "Main Area" name: "RAINBOW" }
+  type: GALLERY_PAINTING
+  #move_paintings { room: "Main Area" name: "RAINBOW" }
+  receivers: "Components/Paintings/Endings/rainbow/teleportListener"
   rooms { map: "daedalus" name: "Rainbow Start" }
 }
 doors {
   name: "Words Painting"
-  type: ITEM_ONLY
-  move_paintings { room: "Main Area" name: "WORDS" }
-  # TODO: Enter The Words
+  type: GALLERY_PAINTING
+  #move_paintings { room: "Main Area" name: "WORDS" }
+  receivers: "Components/Paintings/Endings/words/teleportListener"
+  rooms { map: "the_words" name: "Main Area" }
 }
 doors {
   name: "Colorful Painting"
-  type: ITEM_ONLY
-  move_paintings { room: "Main Area" name: "COLORFUL" }
+  type: GALLERY_PAINTING
+  #move_paintings { room: "Main Area" name: "COLORFUL" }
+  receivers: "Components/Paintings/Endings/colorful/teleportListener"
   rooms { map: "the_colorful" name: "White Room" }
 }
 doors {
   name: "Castle Painting"
-  type: ITEM_ONLY
-  move_paintings { room: "Main Area" name: "CASTLE" }
+  type: GALLERY_PAINTING
+  #move_paintings { room: "Main Area" name: "CASTLE" }
+  receivers: "Components/Paintings/Endings/castle/teleportListener"
   rooms { map: "daedalus" name: "Castle" }
 }
 doors {
   name: "Sun Temple Painting"
-  type: ITEM_ONLY
-  move_paintings { room: "Main Area" name: "SUNTEMPLE" }
+  type: GALLERY_PAINTING
+  #move_paintings { room: "Main Area" name: "SUNTEMPLE" }
+  receivers: "Components/Paintings/Endings/temple/teleportListener"
   rooms { map: "the_sun_temple" name: "Entrance" }
 }
 doors {
   name: "Ancient Painting"
-  type: ITEM_ONLY
-  move_paintings { room: "Main Area" name: "ANCIENT" }
+  type: GALLERY_PAINTING
+  #move_paintings { room: "Main Area" name: "ANCIENT" }
+  receivers: "Components/Paintings/Endings/cubes/teleportListener"
   rooms { map: "the_ancient" name: "Outside" }
 }
 doors {
@@ -1,5 +1,4 @@
 name: "Back Room"
-display_name: "Back Room"
 panels {
   name: "UNYIELDING"
   path: "Panels/entry_2"
@@ -1,5 +1,4 @@
 name: "Daedalus Extension"
-display_name: "Daedalus Extension"
 panels {
   name: "WHERE"
   path: "Panels/entry_1"
@@ -1,5 +1,4 @@
 name: "Ending"
-display_name: "Back Room"
 endings {
   name: "YELLOW"
   path: "Components/Endings/yellow_ending"
@@ -1,8 +1,8 @@
 name: "Main Area"
-display_name: "Main Area"
 keyholders {
   name: "P"
   path: "Components/KeyHolders/keyHolderP"
+  key: "p"
 }
 paintings {
   name: "OWL"
@@ -162,6 +162,8 @@ paintings {
 }
 ports {
   name: "ENTRY"
+  display_name: "Entrance"
   path: "Components/Warps/worldport"
-  orientation: "west"
+  destination { x: -3.5 y: 0 z: 16 }
+  rotation: 270
 }
@@ -1,5 +1,4 @@
 name: "The Whole Thing"
-display_name: "The Whole Thing"
 panels {
   name: "PANEL"
   path: "Panels/Room_1/panel_1"
@@ -19,6 +19,7 @@ doors {
 doors {
   name: "Double Letters"
   type: EVENT
-  switches: "double_letters"
-  # TODO: once again, not sure whether this is how it should work
+  receivers: "Panels/panel_3/teleportListener"
+  receivers: "Components/Paintings/omrt/teleportListener"
+  double_letters: true
 }
@@ -1,5 +1,4 @@
 name: "Inside"
-display_name: "Inside"
 panels {
   name: "REMEMBER"
   path: "Panels/panel_3"
@@ -1,5 +1,4 @@
 name: "Outside"
-display_name: "Outside"
 panels {
   name: "FOOT"
   path: "Panels/panel_1"
@@ -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"
@@ -59,13 +60,13 @@ doors {
 doors {
   name: "Control Center Gray Door"
   type: CONTROL_CENTER_COLOR
-  receivers: "Components/Doors/Gates/Gate"
+  receivers: "Components/Doors/Gates/Gate/animationListener"
   control_center_color: "gray"
 }
 doors {
   name: "Control Center Red Door"
   type: CONTROL_CENTER_COLOR
-  receivers: "Components/Doors/Gates/Gate"
+  receivers: "Components/Doors/entry_18"
   control_center_color: "red"
 }
 doors {
@@ -98,7 +99,8 @@ doors {
 doors {
   name: "Savory Painting"
   type: STANDARD
-  move_paintings { room: "West Side" name: "EXTRAVAGANT" }
+  #move_paintings { room: "West Side" name: "EXTRAVAGANT" }
+  receivers: "Components/Paintings/unless/teleportListener"
   panels { room: "West Side" name: "SAVORY" }
   panels { room: "West Side" name: "FLAVORS" }
   location_room: "West Side"
@@ -141,6 +143,7 @@ doors {
   panels { room: "Pillar Room" name: "CAUGHT" }
   panels { room: "Pillar Room" name: "TEN" }
   location_room: "Pillar Room"
+  location_name: "Puzzles"
 }
 doors {
   name: "North Landscape Entrance"
@@ -224,7 +227,7 @@ doors {
   name: "Tower Entrance"
   type: ITEM_ONLY
   receivers: "Components/Doors/entry_25"
-  switches: "double_letters"
+  double_letters: true
 }
 doors {
   name: "Maze Out/South Door"
@@ -390,11 +393,13 @@ doors {
   name: "Big Y"
   type: STANDARD
   receivers: "Components/Doors/question_3"
+  receivers: "Components/Doors/question_12"
   panels { room: "Question Room What" name: "QUESTION" answer: "why" }
   panels { room: "Question Room How" name: "QUESTION" answer: "why" }
   panels { room: "Question Room When" name: "QUESTION" answer: "why" }
   panels { room: "Question Room Who" name: "QUESTION" answer: "why" }
   location_room: "Question Room Who"
+  location_name: "Whys"
 }
 doors {
   name: "Talented Entrance"
@@ -417,6 +422,7 @@ doors {
   panels { room: "Back Area" name: "Right Landscape Top" answer: "tell" }
   panels { room: "Back Area" name: "Right Landscape Left" answer: "eyes" }
   location_room: "Back Area"
+  location_name: "Landscapes Room Alternate Answers"
 }
 doors {
   name: "Nature Room Door"
@@ -465,9 +471,13 @@ doors {
 }
 doors {
   name: "Lavender Cube"
-  type: ITEM_ONLY
+  type: EVENT
   receivers: "Components/Doors/entry_28"
-  switches: "lavender_cubes"
+  panels {
+    map: "the_ancient"
+    room: "Inside"
+    name: "COLOR"
+  }
 }
 doors {
   name: "Zero Entrance"
@@ -492,3 +502,14 @@ doors {
   panels { room: "Back Area" name: "PAINTING" }
   location_room: "Back Area"
 }
+doors {
+  name: "Cyan Doors"
+  type: EVENT
+  receivers: "Panels/General/entry_7/teleportListener"
+  double_letters: true
+}
+doors {
+  name: "Partial Entrance"
+  type: EVENT
+  panels { room: "West Side" name: "CLUE" }
+}
@@ -1,5 +1,5 @@
 name: "Back Area"
-display_name: "Back Area"
+panel_display_name: "Back Area"
 panels {
   name: "PLANT"
   path: "Panels/General/entry_14"
@@ -124,23 +124,31 @@ paintings {
 }
 ports {
   name: "UNKEMPT"
+  display_name: "Unkempt Entrance"
   path: "Meshes/Blocks/Warps/worldport5"
-  orientation: "north"
+  destination { x: 72 y: 0 z: 10.5 }
+  rotation: 180
 }
 ports {
   name: "THREEDOORS"
+  display_name: "Three Doors Entrance"
   path: "Meshes/Blocks/Warps/worldport16"
-  orientation: "south"
+  destination { x: 77 y: 0 z: 33.5 }
+  rotation: 0
 }
 ports {
   name: "TOWER"
+  display_name: "Tower Entrance"
   path: "Meshes/Blocks/Warps/worldport10"
-  orientation: "south"
+  destination { x: 0 y: 0 z: 52 }
+  rotation: 0
   required_door { name: "Tower Entrance" }
   # The reverse warp bypasses the door, so there needs to be two oneway connections.
 }
 ports {
   name: "TREE"
+  display_name: "Tree Entrance"
   path: "Meshes/Blocks/Warps/worldport17"
-  orientation: "north"
+  destination { x: 26 y: 0 z: 58 }
+  rotation: 180
 }
@@ -1,5 +1,5 @@
 name: "Behind Question Area"
-display_name: "Main Area"
+panel_display_name: "Question Room"
 panels {
   name: "DEW"
   path: "Panels/General/uc_4"
@@ -1,7 +1,9 @@
 name: "Colorful Entrance"
-display_name: "Pillar Room"
+panel_display_name: "Pillar Room"
 ports {
   name: "COLORFUL"
+  display_name: "Pillar Room Worldport"
   path: "Meshes/Blocks/Warps/worldport13"
-  orientation: "west"
+  destination { x: -37.5 y: 0 z: 74 }
+  rotation: 270
 }
@@ -1,5 +1,5 @@
 name: "Daedalus Entrance"
-display_name: "Main Area"
+panel_display_name: "Main Area"
 panels {
   name: "MISSING"
   path: "Panels/General/entry_2"
@@ -9,8 +9,10 @@ panels {
 }
 ports {
   name: "DAEDALUS"
+  display_name: "Daedalus Entrance"
   path: "Meshes/Blocks/Warps/worldport8"
-  orientation: "south"
+  destination { x: 98 y: 2 z: 27.5 }
+  rotation: 0
   required_door { name: "Daedalus Entrance" }
   # The reverse warp bypasses the door, so there needs to be two oneway connections.
 }
@@ -1,5 +1,5 @@
 name: "East Landscape"
-display_name: "East Landscape"
+panel_display_name: "East Landscape"
 panels {
   name: "COLOR"
   path: "Panels/General/entry_10"
@@ -1,5 +1,5 @@
 name: "G Room"
-display_name: "Courtyard"
+panel_display_name: "Courtyard"
 letters {
   key: "g"
   path: "Components/Collectables/g"
@@ -1,5 +1,5 @@
 name: "Hive Entrance"
-display_name: "West Side"
+panel_display_name: "West Side"
 panels {
   name: "LOST"
   path: "Panels/Hive Room/hive_1"
@@ -9,6 +9,8 @@ panels {
 }
 ports {
   name: "HIVE"
+  display_name: "Hive Entrance"
   path: "Meshes/Blocks/Warps/worldport19"
-  orientation: "east"
+  destination { x: -91.5 y: 0 z: 37 }
+  rotation: 90
 }
@@ -1,5 +1,5 @@
 name: "Jail Part 1"
-display_name: "Jail"
+panel_display_name: "Jail"
 panels {
   name: "FLAP"
   path: "Panels/Throat/throat_1"
@@ -1,5 +1,5 @@
 name: "Jail Part 2"
-display_name: "Jail"
+panel_display_name: "Jail"
 panels {
   name: "DIGEST"
   path: "Panels/Bowels3/bowels_1"
@@ -1,7 +1,9 @@
 name: "Jubilant Entrance"
-display_name: "West Side"
+panel_display_name: "West Side"
 ports {
   name: "JUBILANT"
+  display_name: "Jubilant Entrance"
   path: "Meshes/Blocks/Warps/worldport12"
-  orientation: "east"
+  destination { x: -62 y: 0 z: -19 }
+  rotation: 90
 }
@@ -1,5 +1,5 @@
 name: "Magnet Room"
-display_name: "Magnet Room"
+panel_display_name: "Magnet Room"
 panels {
   name: "AIRPLANE"
   path: "Panels/Magnet Room/magnet_2"
@@ -1,5 +1,5 @@
 name: "Main Area"
-display_name: "Main Area"
+panel_display_name: "Main Area"
 panels {
   name: "INTRO"
   path: "Panels/General/entry_8"
@@ -111,6 +111,7 @@ panels {
   answer: "high"
   symbols: SUN
   symbols: ZERO
+  required_door { name: "Cyan Doors" }
 }
 panels {
   name: "CURT"
@@ -121,27 +122,37 @@ panels {
 }
 ports {
   name: "ENTRY"
+  display_name: "Entry Building"
   path: "Meshes/Blocks/Warps/worldport"
-  orientation: "south"
+  destination { x: 33 y: 0 z: 15 }
+  rotation: 0
 }
 ports {
   name: "KEEN"
+  display_name: "Keen Building Front"
   path: "Meshes/Blocks/Warps/worldport6"
-  orientation: "north"
+  destination { x: 33 y: 0 z: -21 }
+  rotation: 180
 }
 ports {
   name: "ORB"
+  display_name: "Orb Building"
   path: "Meshes/Blocks/Warps/worldport3"
-  orientation: "north"
+  destination { x: 62 y: 0 z: -13 }
+  rotation: 180
 }
 ports {
   name: "LINEAR"
+  display_name: "Keen Building Back"
   path: "Meshes/Blocks/Warps/worldport15"
-  orientation: "south"
+  destination { x: 33 y: 0 z: -42.5 }
+  rotation: 0
 }
 ports {
   name: "DIGITAL"
+  display_name: "Digital Hole"
   path: "Meshes/Blocks/Warps/worldport4"
-  orientation: "down"
+  destination { x: -6.5 y: 0 z: 7.5 }
+  rotation: 0
   required_door { name: "Digital Entrance" }
 }
@@ -1,5 +1,5 @@
 name: "Maze Center"
-display_name: "Courtyard"
+panel_display_name: "Courtyard"
 panels {
   name: "POOR"
   path: "Panels/Maze/maze_7"
@@ -1,5 +1,5 @@
 name: "Maze Cold Area"
-display_name: "Courtyard"
+panel_display_name: "Courtyard"
 panels {
   name: "COLD"
   path: "Panels/Maze/maze_11"
@@ -1,2 +1,2 @@
 name: "Maze Empty Vestibule"
-display_name: "Courtyard"
+panel_display_name: "Courtyard"
@@ -1,5 +1,5 @@
 name: "Maze In Area"
-display_name: "Courtyard"
+panel_display_name: "Courtyard"
 panels {
   name: "IN"
   path: "Panels/Maze/maze_3"
@@ -1,5 +1,5 @@
 name: "Maze Moon Area"
-display_name: "Courtyard"
+panel_display_name: "Courtyard"
 panels {
   name: "MOON"
   path: "Panels/Maze/maze_9"
@@ -1,5 +1,5 @@
 name: "Maze Off Area"
-display_name: "Courtyard"
+panel_display_name: "Courtyard"
 panels {
   name: "OFF"
   path: "Panels/Maze/maze_14"
@@ -1,5 +1,5 @@
 name: "Maze Slice Area"
-display_name: "Courtyard"
+panel_display_name: "Courtyard"
 panels {
   name: "SLICE"
   path: "Panels/Maze/maze_4"
@@ -1,5 +1,5 @@
 name: "Maze Smooth Area"
-display_name: "Courtyard"
+panel_display_name: "Courtyard"
 panels {
   name: "SMOOTH"
   path: "Panels/Maze/maze_5"
@@ -1,5 +1,5 @@
 name: "Maze South Area"
-display_name: "Courtyard"
+panel_display_name: "Courtyard"
 panels {
   name: "SOUTH"
   path: "Panels/Maze/maze_2"
@@ -1,5 +1,5 @@
 name: "Maze Start"
-display_name: "Courtyard"
+panel_display_name: "Courtyard"
 panels {
   name: "OUT"
   path: "Panels/Maze/maze_1"
@@ -1,5 +1,5 @@
 name: "Maze Tower"
-display_name: "Courtyard"
+panel_display_name: "Courtyard"
 panels {
   name: "FEEL"
   path: "Panels/Maze/maze_12"
@@ -1,5 +1,5 @@
 name: "Maze Up Area"
-display_name: "Courtyard"
+panel_display_name: "Courtyard"
 panels {
   name: "UP"
   path: "Panels/Maze/maze_15"
@@ -1,5 +1,5 @@
 name: "Maze Wreck Area"
-display_name: "Courtyard"
+panel_display_name: "Courtyard"
 panels {
   name: "WRECK"
   path: "Panels/Maze/maze_8"
@@ -1,5 +1,5 @@
 name: "Nature Room"
-display_name: "North Landscape"
+panel_display_name: "North Landscape"
 panels {
   name: "SEVERE"
   path: "Panels/General/nature_2"
@@ -1,5 +1,5 @@
 name: "North Landscape"
-display_name: "North Landscape"
+panel_display_name: "North Landscape"
 panels {
   name: "WEATHER"
   path: "Panels/General/platforms_1"
@@ -52,11 +52,13 @@ panels {
 keyholders {
   name: "X"
   path: "Components/KeyHolders/keyHolderX"
+  key: "x"
 }
 ports {
   name: "INVISIBLE"
+  display_name: "Eye Worldport"
   path: "Meshes/Blocks/Warps/worldport20"
-  orientation: "north"
-  # Note that this can be easily entered from the other side.
+  destination { x: 33 y: 0 z: -66.5 }
+  rotation: 0
   required_door { name: "Invisible Entrance" }
 }
@@ -1,5 +1,5 @@
 name: "Outside Jail"
-display_name: "Jail"
+panel_display_name: "Jail"
 panels {
   name: "GUT"
   path: "Panels/Head/head_1"
@@ -1,5 +1,5 @@
 name: "Pillar Room"
-display_name: "Pillar Room"
+panel_display_name: "Pillar Room"
 panels {
   name: "EYE"
   path: "Panels/Impressive/entry_2"
@@ -1,7 +1,9 @@
 name: "Purple Room"
-display_name: "Main Area"
+panel_display_name: "Main Area"
 ports {
   name: "DAEDALUS"
+  display_name: "Purple Hallway"
   path: "Meshes/Blocks/Warps/worldport18"
-  orientation: "north"
+  destination { x: 158 y: 0 z: 14 }
+  rotation: 180
 }
@@ -1,17 +1,18 @@
 name: "Question Room How"
-display_name: "Question Room"
+panel_display_name: "Question Room"
 panels {
   name: "QUESTION"
   path: "Panels/Questions/question_3"
   clue: "question"
   answer: "how"
   symbols: EXAMPLE
-  # "Panels/Question Proxies/question_3_proxied" <- this is just how again
+  proxies { answer: "how" path: "Panels/Question Proxies/question_3_proxied" }
   proxies { answer: "who" path: "Panels/Question Proxies/question_3_proxied2" }
   proxies { answer: "why" path: "Panels/Question Proxies/question_3_proxied3" }
   proxies { answer: "what" path: "Panels/Question Proxies/question_3_proxied4" }
   proxies { answer: "when" path: "Panels/Question Proxies/question_3_proxied5" }
   proxies { answer: "where" path: "Panels/Question Proxies/question_3_proxied6" }
+  display_name: "QUESTION (How)"
 }
 paintings {
   name: "WHY"
@@ -1,15 +1,16 @@
 name: "Question Room What"
-display_name: "Question Room"
+panel_display_name: "Question Room"
 panels {
   name: "QUESTION"
   path: "Panels/Questions/question_4"
   clue: "question"
   answer: "what"
   symbols: EXAMPLE
-  proxies { answer: "why" path: "Panels/Question Proxies/question_4_proxied" }
-  proxies { answer: "who" path: "Panels/Question Proxies/question_4_proxied2" }
-  proxies { answer: "where" path: "Panels/Question Proxies/question_4_proxied3" }
+  proxies { answer: "what" path: "Panels/Question Proxies/question_4_proxied" }
+  proxies { answer: "why" path: "Panels/Question Proxies/question_4_proxied2" }
+  proxies { answer: "when" path: "Panels/Question Proxies/question_4_proxied3" }
   proxies { answer: "how" path: "Panels/Question Proxies/question_4_proxied4" }
-  # "Panels/Question Proxies/question_4_proxied5" <- this is just what again
-  proxies { answer: "when" path: "Panels/Question Proxies/question_4_proxied6" }
+  proxies { answer: "who" path: "Panels/Question Proxies/question_4_proxied5" }
+  proxies { answer: "where" path: "Panels/Question Proxies/question_4_proxied6" }
+  display_name: "QUESTION (What)"
 }
@@ -1,5 +1,5 @@
 name: "Question Room When"
-display_name: "Question Room"
+panel_display_name: "Question Room"
 panels {
   name: "QUESTION"
   path: "Panels/Questions/question_1"
@@ -8,10 +8,11 @@ panels {
   symbols: EXAMPLE
   proxies { answer: "when" path: "Panels/Question Proxies/question_1_proxied" }
   proxies { answer: "why" path: "Panels/Question Proxies/question_1_proxied2" }
-  # "Panels/Question Proxies/question_1_proxied3" <- this is just what again
+  proxies { answer: "what" path: "Panels/Question Proxies/question_1_proxied3" }
   proxies { answer: "who" path: "Panels/Question Proxies/question_1_proxied4" }
   proxies { answer: "how" path: "Panels/Question Proxies/question_1_proxied5" }
   proxies { answer: "where" path: "Panels/Question Proxies/question_1_proxied6" }
+  display_name: "QUESTION (When)"
 }
 paintings {
   name: "WHY"
@@ -1,5 +1,5 @@
 name: "Question Room Who"
-display_name: "Question Room"
+panel_display_name: "Question Room"
 panels {
   name: "QUESTION"
   path: "Panels/Questions/question_2"
@@ -7,9 +7,10 @@ panels {
   answer: "who"
   symbols: EXAMPLE
   proxies { answer: "why" path: "Panels/Question Proxies/question_2_proxied" }
-  # "Panels/Question Proxies/question_2_proxied2" <- this is just who again
+  proxies { answer: "who" path: "Panels/Question Proxies/question_2_proxied2" }
   proxies { answer: "where" path: "Panels/Question Proxies/question_2_proxied3" }
   proxies { answer: "how" path: "Panels/Question Proxies/question_2_proxied4" }
   proxies { answer: "what" path: "Panels/Question Proxies/question_2_proxied5" }
   proxies { answer: "when" path: "Panels/Question Proxies/question_2_proxied6" }
+  display_name: "QUESTION (Who)"
 }
@@ -1,7 +1,9 @@
 name: "Salmon Room"
-display_name: "Main Area"
+panel_display_name: "Main Area"
 ports {
   name: "BETWEEN"
+  display_name: "Salmon Hallway"
   path: "Meshes/Blocks/Warps/worldport11"
-  orientation: "east"
+  destination { x: 83 y: 0 z: -21 }
+  rotation: 90
 }
@@ -1,7 +1,9 @@
 name: "Talented Entrance"
-display_name: "Question Room"
+panel_display_name: "Question Room"
 ports {
   name: "TALENTED"
+  display_name: "Under Question Room Worldport"
   path: "Meshes/Blocks/Warps/worldport14"
-  orientation: "south"
+  destination { x: 109 y: -6 z: -26.5 }
+  rotation: 0
 }
@@ -1,10 +1,12 @@
 name: "Under Question Room"
-display_name: "Question Room"
+panel_display_name: "Question Room"
 panels {
   name: "QUESTION"
   path: "Panels/General/question_1"
   clue: "question"
   answer: "which"
   symbols: EXAMPLE
+  proxies { answer: "which" path: "Panels/General/question_1_proxy_1" }
   proxies { answer: "where" path: "Panels/General/question_1_proxy_2" }
+  display_name: "QUESTION (Where)"
 }
@@ -1,5 +1,5 @@
 name: "West Side"
-display_name: "West Side"
+panel_display_name: "West Side"
 panels {
   name: "ERASE"
   path: "Panels/General/entry_9"
@@ -63,17 +63,24 @@ paintings {
 }
 ports {
   name: "IMPRESSIVE"
+  display_name: "Impressive Entrance"
   path: "Meshes/Blocks/Warps/worldport2"
-  orientation: "south"
+  destination { x: -34 y: 0 z: 22.5 }
+  rotation: 0
 }
 ports {
   name: "CC"
+  display_name: "Control Center"
   path: "Meshes/Blocks/Warps/worldport9"
-  orientation: "north"
+  destination { x: -59 y: 0 z: -50.5 }
+  rotation: 180
 }
 ports {
   name: "PARTIAL"
+  display_name: "Red Hallway"
   path: "Meshes/Blocks/Warps/worldport7"
-  orientation: "east"
+  destination { x: -62 y: 0 z: 11 }
+  rotation: 90
   # ER with this is weird; make sure to place on the surface
+  required_door { name: "Partial Entrance" }
 }
@@ -1,5 +1,5 @@
 name: "Whole Room"
-display_name: "North Landscape"
+panel_display_name: "North Landscape"
 panels {
   name: "VAULT"
   path: "Panels/Whole Room/whole_1"
@@ -1,5 +1,5 @@
 name: "Y Room"
-display_name: "Question Room"
+panel_display_name: "Question Room"
 letters {
   key: "y"
   path: "Components/Collectables/y"
@@ -1,5 +1,5 @@
 name: "Zero Room"
-display_name: "Zero Room"
+panel_display_name: "Zero Room"
 panels {
   name: "HERO"
   path: "Panels/General/zero_1"
@@ -1,13 +1,16 @@
 name: "Main Area"
-display_name: "Main Area"
 # I'm probably not going to include any of the panels in here.
 ports {
   name: "RIGHT"
+  display_name: "South Worldport"
   path: "Components/Warps/worldport"
-  orientation: "east"
+  destination { x: 30 y: 0 z: 19 }
+  rotation: 270
 }
 ports {
   name: "LEFT"
+  display_name: "North Worldport"
   path: "Components/Warps/worldport2"
-  orientation: "east"
+  destination { x: 30 y: 0 z: -76 }
+  rotation: 270
 }
@@ -1,6 +1,7 @@
 doors {
   name: "Room 8 Door"
-  type: LOCATION_ONLY
+  type: STANDARD
+  receivers: "Components/Doors/entry_10"
   panels { room: "Main Area" name: "STEM" }
   panels { room: "Main Area" name: "PETAL" }
   panels { room: "Main Area" name: "SOIL" }
@@ -1,5 +1,4 @@
 name: "Main Area"
-display_name: "Hive"
 panels {
   name: "ASP"
   path: "Panels/Room 1/panel_1"
@@ -269,24 +268,33 @@ panels {
 keyholders {
   name: "B"
   path: "Components/KeyHolders/keyHolderB"
+  key: "b"
 }
 ports {
   name: "DAED1"
+  display_name: "Blue Area Worldport"
   path: "Components/Warps/worldport"
-  orientation: "west"
+  destination { x: -1.5 y: 0 z: 24 }
+  rotation: 270
 }
 ports {
   name: "DAED2"
+  display_name: "Pink Area South Worldport"
   path: "Components/Warps/worldport2"
-  orientation: "west"
+  destination { x: -26.5 y: 0 z: -22 }
+  rotation: 270
 }
 ports {
   name: "DAED3"
+  display_name: "Lime Area Worldport"
   path: "Components/Warps/worldport3"
-  orientation: "east"
+  destination { x: -44.5 y: 0 z: -13 }
+  rotation: 90
 }
 ports {
   name: "GREAT"
+  display_name: "Pink Area North Worldport"
   path: "Components/Warps/worldport4"
-  orientation: "west"
+  destination { x: -29.5 y: 0 z: -62 }
+  rotation: 270
 }
@@ -1,5 +1,4 @@
 name: "Mastery Room"
-display_name: "Hive"
 masteries {
   name: "MASTERY"
   path: "Components/Collectables/smiley"
@@ -1,5 +1,4 @@
 name: "Room 8"
-display_name: "Hive"
 panels {
   name: "BUMBLE"
   path: "Panels/Room 8/panel_1"
@@ -1,5 +1,5 @@
 name: "Green Eye"
-display_name: "Impressive"
+panel_display_name: "Outside"
 panels {
   name: "RETURN"
   path: "Panels/entry_5"
@@ -22,6 +22,8 @@ panels {
 }
 ports {
   name: "PLAZA"
+  display_name: "Green Hallway"
   path: "Components/Warps/worldport3"
-  orientation: "east"
+  destination { x: -33 y: 0 z: 1 }
+  rotation: 90
 }
@@ -1,5 +1,5 @@
 name: "Lobby"
-display_name: "Impressive"
+panel_display_name: "Outside"
 panels {
   name: "RIGHT"
   path: "Panels/entry_1"
@@ -9,6 +9,8 @@ panels {
 }
 ports {
   name: "GREAT"
+  display_name: "Main Entrance"
   path: "Components/Warps/worldport"
-  orientation: "south"
+  destination { x: 0 y: 0 z: 11.5 }
+  rotation: 0
 }
@@ -1,5 +1,5 @@
 name: "M Room"
-display_name: "Impressive"
+panel_display_name: "Inside"
 letters {
   key: "m"
   path: "Components/Collectables/collectable"
@@ -1,5 +1,5 @@
 name: "M2 Room"
-display_name: "Impressive"
+panel_display_name: "Inside"
 letters {
   key: "m"
   level2: true
@@ -1,5 +1,5 @@
 name: "Side Area"
-display_name: "Impressive"
+panel_display_name: "Outside"
 panels {
   name: "COLOR"
   path: "Panels/entry_4"
@@ -9,6 +9,8 @@ panels {
 }
 ports {
   name: "FOURROOMS"
+  display_name: "Four Rooms Entrance"
   path: "Components/Warps/worldport2"
-  orientation: "south"
+  destination { x: -27 y: 0 z: 25.5 }
+  rotation: 0
 }
@@ -1,5 +1,5 @@
 name: "W Room"
-display_name: "Impressive"
+panel_display_name: "Inside"
 letters {
   key: "w"
   path: "Components/Collectables/collectable2"
@@ -1,5 +1,5 @@
 name: "WM Room"
-display_name: "Impressive"
+panel_display_name: "Inside"
 panels {
   name: "LEFT"
   path: "Panels/entry_2"
@@ -13,4 +13,5 @@ panels {
   clue: "right"
   answer: "right"
   proxies { answer: "left" path: "Panels/proxied_1" }
+  proxies { answer: "right" path: "Panels/proxied_2" }
 }
@@ -1,5 +1,4 @@
 name: "Entrance"
-display_name: "Invisible"
 panels {
   name: "VISIBLE"
   path: "Panels/Room_1/panel_1"
@@ -9,6 +8,8 @@ panels {
 }
 ports {
   name: "ENTRY"
+  display_name: "Entrance"
   path: "Components/Warps/worldport2"
-  orientation: "north"
+  destination { x: 0 y: 0 z: -57 }
+  rotation: 180
 }
@@ -1,11 +1,13 @@
 name: "Maze"
-display_name: "Invisible"
 masteries {
   name: "MASTERY"
   path: "Components/Collectables/smiley"
 }
 ports {
   name: "ENTRY"
+  display_name: "Exit"
   path: "Components/Warps/worldport"
-  orientation: "south"
+  # Should this be shuffleable? It skips the maze lol.
+  destination { x: 0 y: 0 z: 9.5 }
+  rotation: 0
 }
@@ -1,5 +1,4 @@
 name: "J Room"
-display_name: "Jubilant"
 letters {
   key: "j"
   path: "Components/Collectables/q" # yeah lol
@@ -1,5 +1,4 @@
 name: "Main Area"
-display_name: "Jubilant"
 panels {
   name: "GEMSTONE"
   path: "Panels/Main/panel_1"
@@ -98,6 +97,8 @@ panels {
 }
 ports {
   name: "GREAT"
+  display_name: "Entrance"
   path: "Components/Warps/worldport"
-  orientation: "west"
+  destination { x: -3 y: 0 z: 9 }
+  rotation: 270
 }
@@ -1,5 +1,4 @@
 name: "Side Area"
-display_name: "Jubilant"
 panels {
   name: "CALLBACK"
   path: "Panels/Back Helpers/back_1"
@@ -39,4 +38,5 @@ panels {
 keyholders {
   name: "J"
   path: "Components/KeyHolders/keyHolderJ"
+  key: "j"
 }
@@ -1,5 +1,4 @@
 name: "K Room"
-display_name: "Keen"
 letters {
   key: "k"
   path: "Components/Collectables/collectable"
@@ -1,5 +1,4 @@
 name: "Main Area"
-display_name: "Keen"
 panels {
   name: "TIN (1)"
   path: "Panels/entry_3"
@@ -70,6 +69,8 @@ panels {
 }
 ports {
   name: "GREAT"
+  display_name: "Entrance"
   path: "Components/Warps/worldport"
-  orientation: "south"
+  destination { x: 0 y: 0 z: 7.5 }
+  rotation: 0
 }
@@ -11,4 +11,5 @@ doors {
   panels { room: "Puzzle Room" name: "WOLF" }
   panels { room: "Puzzle Room" name: "FOOT" }
   location_room: "Puzzle Room"
+  location_name: "Puzzles"
 }
@@ -1,5 +1,4 @@
 name: "Painting Room"
-display_name: "Liberated"
 paintings {
   name: "PYRAMID"
   path: "Components/triangle"
@@ -1,5 +1,4 @@
 name: "Puzzle Room"
-display_name: "Liberated"
 panels {
   name: "CORPSE"
   path: "Panels/entry_1"
@@ -58,6 +57,8 @@ panels {
 }
 ports {
   name: "ENTRY"
+  display_name: "Entrance"
   path: "Components/Warps/worldport"
-  orientation: "south"
+  destination { x: 0 y: 0 z: 7.5 }
+  rotation: 0
 }
@@ -10,4 +10,5 @@ doors {
   panels { room: "Room" name: "INTO" }
   panels { room: "Room" name: "NOR" }
   location_room: "Room"
+  location_name: "Gravestone"
 }
@@ -1,5 +1,4 @@
 name: "Room"
-display_name: "Room"
 panels {
   name: "HORN"
   path: "Panels/entry_1"
@@ -58,6 +57,8 @@ panels {
 }
 ports {
   name: "GREAT"
+  display_name: "Entrance"
   path: "Components/Warps/worldport"
-  orientation: "south"
+  destination { x: 0 y: 0 z: 7.5 }
+  rotation: 0
 }
@@ -1,5 +1,4 @@
 name: "E2 Room"
-display_name: "Lionized"
 letters {
   key: "e"
   level2: true
@@ -1,5 +1,4 @@
 name: "Puzzle Room"
-display_name: "Lionized"
 panels {
   name: "CHILD"
   path: "Panels/entry_1"
@@ -58,6 +57,8 @@ panels {
 }
 ports {
   name: "ENTRY"
+  display_name: "Entrance"
   path: "Components/Warps/worldport"
-  orientation: "south"
+  destination { x: 0 y: 0 z: 6.5 }
+  rotation: 0
 }
@@ -11,4 +11,5 @@ doors {
   panels { room: "Puzzle Room" name: "STICK" }
   panels { room: "Puzzle Room" name: "BREAD" }
   location_room: "Puzzle Room"
+  location_name: "Puzzles"
 }
@@ -1,5 +1,4 @@
 name: "Painting Room"
-display_name: "Literate"
 paintings {
   name: "PYRAMID"
   path: "Components/triangle"
@@ -1,5 +1,4 @@
 name: "Puzzle Room"
-display_name: "Literate"
 panels {
   name: "WATER"
   path: "Panels/entry_1"
@@ -58,6 +57,8 @@ panels {
 }
 ports {
   name: "ENTRY"
+  display_name: "Entrance"
   path: "Components/Warps/worldport"
-  orientation: "south"
+  destination { x: 0 y: 0 z: 7.5 }
+  rotation: 0
 }
@@ -1,5 +1,4 @@
 name: "L2 Room"
-display_name: "Lively"
 letters {
   key: "l"
   level2: true
@@ -1,5 +1,4 @@
 name: "Puzzle Room"
-display_name: "Lively"
 panels {
   name: "LIONESS"
   path: "Panels/entry_1"
@@ -58,5 +57,8 @@ panels {
 }
 ports {
   name: "BETWEEN"
+  display_name: "Entrance"
   path: "Components/Warps/worldport"
+  destination { x: 0 y: 0 z: 6.5 }
+  rotation: 0
 }
@@ -1,7 +1,7 @@
 connections {
   from_room: "Main Room"
   to_room: "Back Room"
-  door { name: "Main Room Puzzles" }
+  door { name: "Main Room Door" }
 }
 connections {
   from_room: "Back Room"
@@ -1,5 +1,5 @@
 doors {
-  name: "Left Room Puzzles"
+  name: "Blue Side Puzzles"
   type: LOCATION_ONLY
   panels { room: "Main Room" name: "HOARSE" }
   panels { room: "Main Room" name: "NAY" }
@@ -11,7 +11,7 @@ doors {
   location_room: "Main Room"
 }
 doors {
-  name: "Right Room Puzzles"
+  name: "Green Side Puzzles"
   type: LOCATION_ONLY
   panels { room: "Main Room" name: "HOSE" }
   panels { room: "Main Room" name: "NIGH" }
@@ -23,7 +23,7 @@ doors {
   location_room: "Main Room"
 }
 doors {
-  name: "Main Room Puzzles"
+  name: "Main Room Door"
   type: ITEM_ONLY
   receivers: "Components/Doors/entry_1"
   panels { room: "Main Room" name: "HOARSE" }
@@ -1,5 +1,4 @@
 name: "Back Room"
-display_name: "Nuanced"
 panels {
   name: "COURSE"
   path: "Panels/Rhymes/panel_1"
@@ -1,5 +1,4 @@
 name: "Main Room"
-display_name: "Nuanced"
 panels {
   name: "HOARSE"
   path: "Panels/Eyes/panel_1"
@@ -107,10 +106,13 @@ panels {
 }
 ports {
   name: "UNYIELDING"
+  display_name: "Entrance"
   path: "Components/Warps/worldport"
-  orientation: "west"
+  destination { x: -3.5 y: 0 z: 21 }
+  rotation: 270
 }
 keyholders {
   name: "S"
   path: "Components/KeyHolders/keyHolderS"
+  key: "s"
 }
@@ -1,5 +1,4 @@
 name: "N2 Room"
-display_name: "Nuanced"
 letters {
   key: "n"
   level2: true
@@ -10,10 +10,20 @@ connections {
 }
 connections {
   from_room: "Main Area"
-  to_room: "B Room"
+  to_room: "Middle Room"
   door { name: "B Puzzles" }
 }
 connections {
+  from_room: "Middle Room"
+  to_room: "B Room"
+  oneway: true
+}
+connections {
+  from_room: "Middle Room"
+  to_room: "Main Area"
+  oneway: true
+}
+connections {
   from_room: "B Room"
   to_room: "Main Area"
   oneway: true
@@ -1,5 +1,4 @@
 name: "B Room"
-display_name: "Orb"
 letters {
   key: "b"
   path: "Components/Collectables/b"
@@ -10,19 +9,10 @@ paintings {
   # TODO: This is too high up to enter. It's also a hint painting.
   exit_only: true
 }
-# TODO: Should these two be independent for shuffling purposes, or always tied
-# to the Main Area's port?
-ports {
-  name: "MID"
-  path: "Components/Warps/worldport4"
-  orientation: "south"
-  # This port is in the room immediately after solving the B puzzles, which
-  # means it seems like it would be inaccessible if you enter the map from the
-  # painting or from the final port, but entering the O or R areas brings you
-  # back to the beginning.
-}
 ports {
   name: "FINAL"
+  display_name: "Final Worldport"
   path: "Components/Warps/worldport5"
-  orientation: "south"
+  destination { x: -69 y: 0 z: 87 }
+  rotation: 90
 }
@@ -1,5 +1,4 @@
 name: "Main Area"
-display_name: "Orb"
 panels {
   name: "STRIKE"
   path: "Panels/O/entry_1"
@@ -86,6 +85,8 @@ panels {
 }
 ports {
   name: "GREAT"
+  display_name: "Main Entrance"
   path: "Components/Warps/worldport"
-  orientation: "south"
+  destination { x: 38 y: 0 z: 39 }
+  rotation: 90
 }
@@ -0,0 +1,12 @@
+name: "Middle Room"
+# This is the room after solving the B puzzles but before getting to B1 itself.
+# It has to be a separate region because if you are shuffling worldports and you
+# warp to the B1 room port, you can't access this port if you're not able to
+# solve the B puzzles.
+ports {
+  name: "MID"
+  display_name: "Middle Worldport"
+  path: "Components/Warps/worldport4"
+  destination { x: -69 y: 0 z: 43 }
+  rotation: 90
+}
@@ -1,5 +1,4 @@
 name: "O Room"
-display_name: "Orb"
 letters {
   key: "o"
   path: "Components/Collectables/o"
@@ -1,5 +1,4 @@
 name: "R Room"
-display_name: "Orb"
 letters {
   key: "r"
   path: "Components/Collectables/r"
@@ -10,12 +10,27 @@ connections {
 }
 connections {
   from_room: "R2C2 Bottom"
-  to_room: "R2C2.5 Bottom"
+  to_room: "R2C2 Top"
+  door { name: "Sky Owl" }
+}
+connections {
+  from_room: "R2C2 Bottom"
+  to_room: "Connected Area"
   door { name: "Gray Owl" }
 }
 connections {
   from_room: "R2C2 Bottom"
-  to_room: "R2C2.5 Bottom"
+  to_room: "Connected Area"
+  door { name: "Sky Owl" }
+}
+connections {
+  from_room: "R2C3 Bottom"
+  to_room: "Connected Area"
+  oneway: true
+}
+connections {
+  from_room: "R2C2 Bottom"
+  to_room: "Connected Area"
   door { name: "First Room Shortcut" }
 }
 connections {
@@ -30,18 +45,18 @@ connections {
 }
 connections {
   from_room: "R2C2 Top"
-  to_room: "R2C2.5 Bottom"
+  to_room: "R2C3 Bottom"
   door { name: "Gray Bottom Door" }
 }
 connections {
-  from_room: "R2C2 Top"
-  to_room: "R2C2.5 Bottom"
+  from_room: "Connected Area"
+  to_room: "R2C3 Bottom"
   door { name: "Gray Owl" }
 }
 connections {
   from_room: "Connected Area"
-  to_room: "R2C2.5 Bottom"
-  door { name: "Gray Owl" }
+  to_room: "R2C3 Bottom"
+  door { name: "Sky Owl" }
 }
 connections {
   from_room: "Connected Area"
@@ -70,6 +85,11 @@ connections {
 }
 connections {
   from_room: "Connected Area"
+  to_room: "R1C4 Left"
+  door { name: "Sky Owl" }
+}
+connections {
+  from_room: "Connected Area"
   to_room: "R2C1 Left"
   door { name: "Sky Top Doors" }
 }
@@ -84,6 +104,11 @@ connections {
   door { name: "Gray Owl" }
 }
 connections {
+  from_room: "Connected Area"
+  to_room: "R2C1 Left"
+  door { name: "Sky Owl" }
+}
+connections {
   from {
     painting {
       room: "Connected Area"
@@ -25,8 +25,8 @@ doors {
   name: "First Room Shortcut"
   type: STANDARD
   receivers: "Components/Doors/entry_6"
-  panels { room: "R2C2.5 Bottom" name: "FIZZLE" }
-  location_room: "R2C2.5 Bottom"
+  panels { room: "Connected Area" name: "FIZZLE" }
+  location_room: "Connected Area"
 }
 doors {
   name: "First Door"
@@ -171,8 +171,8 @@ doors {
   receivers: "Components/Owl/Room 10/WG"
   receivers: "Components/Owl/Room 11/W"
   receivers: "Components/Owl/Room 11/WG"
-  panels { room: "R2C2.5 Bottom" name: "BLACK" }
-  location_room: "R2C2.5 Bottom"
+  panels { room: "R2C3 Bottom" name: "BLACK" }
+  location_room: "R2C3 Bottom"
 }
 doors {
   name: "Black Owl"
@@ -233,19 +233,20 @@ doors {
 doors {
   name: "Gray Panel"
   type: EVENT
-  # TODO: Is it okay to have an event with an in-game effect?
-  receivers: "Panels/Colors/owl_2/animationListener2"
-  doors { name: "Orange Owl" }
-  doors { name: "Black Owl" }
-  doors { name: "Blue Owl" }
+  #receivers: "Panels/Colors/owl_2/animationListener2"
+  panels { room: "Connected Area" name: "RANGE" }
+  panels { room: "Connected Area" name: "WHITE" }
+  panels { room: "Blue Room" name: "SKY" }
 }
 doors {
   name: "Owl Painting"
   type: EVENT
-  move_paintings { room: "Connected Area" name: "OWL" }
-  doors { name: "Orange Owl" }
-  doors { name: "Black Owl" }
-  doors { name: "Blue Owl" }
-  doors { name: "White Owl" }
-  doors { name: "Sky Owl" }
+  #move_paintings { room: "Connected Area" name: "OWL" }
+  #receivers: "Components/Paintings/owl/teleportListener"
+  panels { room: "R2C1 Left" name: "DUSKY" }
+  panels { room: "R2C2 Top" name: "RAY" }
+  panels { room: "Connected Area" name: "RANGE" }
+  panels { room: "R2C3 Bottom" name: "BLACK" }
+  panels { room: "Connected Area" name: "WHITE" }
+  panels { room: "Blue Room" name: "SKY" }
 }
@@ -1,5 +1,4 @@
 name: "Blue Room"
-display_name: "Owl"
 panels {
   name: "SKY"
   path: "Panels/Colors/owl_7"
@@ -1,5 +1,4 @@
 name: "Connected Area"
-display_name: "Owl"
 panels {
   name: "MODE"
   path: "Panels/Noncritical/owl_12"
@@ -133,6 +132,13 @@ panels {
   answer: "orange"
   symbols: SPARKLES
 }
+panels {
+  name: "FIZZLE"
+  path: "Panels/Bottom Mid/owl_10"
+  clue: "fizzle"
+  answer: "chisel"
+  symbols: ZERO
+}
 paintings {
   name: "OWL"
   path: "Components/Paintings/owl"
@@ -143,7 +149,9 @@ paintings {
 }
 ports {
   name: "FOURROOMS"
+  display_name: "Four Rooms Entrance"
   path: "Components/Warps/worldport2"
-  orientation: "east"
+  destination { x: 71.5 y: 0 z: -9 }
+  rotation: 90
   # Note that this is behind teal walls.
 }
@@ -1,7 +1,8 @@
 name: "Magenta Hallway"
-display_name: "Owl"
 ports {
   name: "STURDY"
+  display_name: "Magenta Hallway"
   path: "Components/Warps/worldport3"
-  orientation: "west"
+  destination { x: 17 y: 0 z: -46 }
+  rotation: 270
 }
@@ -1,5 +1,4 @@
 name: "R1C4 Left"
-display_name: "Owl"
 panels {
   name: "WALK"
   path: "Panels/Noncritical/owl_5"
@@ -1,5 +1,4 @@
 name: "R2C1 Left"
-display_name: "Owl"
 panels {
   name: "VERB"
   path: "Panels/Bottom Left/owl_8"
@@ -1,5 +1,4 @@
 name: "R2C2 Bottom"
-display_name: "Owl"
 panels {
   name: "FOUL"
   path: "Panels/Bottom Mid/owl_11"
@@ -9,7 +8,10 @@ panels {
 }
 ports {
   name: "GALLERY"
+  display_name: "Gallery Worldport"
   path: "Components/Warps/worldport"
-  orientation: "south"
-  # Note that this port is accessible from the other side in the Z1 room. Hmm.
+  destination { x: 0 y: 0 z: 9 }
+  rotation: 0
+  # TODO: Note that this port is accessible from the other side in the Z1
+  # room. Hmm.
 }
@@ -1,5 +1,4 @@
 name: "R2C2 Top"
-display_name: "Owl"
 panels {
   name: "CRUSH"
   path: "Panels/Bottom Mid/owl_1"
@@ -1,12 +1,4 @@
-name: "R2C2.5 Bottom"
-display_name: "Owl"
-panels {
-  name: "FIZZLE"
-  path: "Panels/Bottom Mid/owl_10"
-  clue: "fizzle"
-  answer: "chisel"
-  symbols: ZERO
-}
+name: "R2C3 Bottom"
 panels {
   name: "FIGMENT"
   path: "Panels/Noncritical/owl_14"
@@ -1,5 +1,4 @@
 name: "Z Room"
-display_name: "Owl"
 panels {
   name: "MAZE"
   path: "Panels/Noncritical/owl_10"
@@ -7,6 +7,7 @@ connections {
   from_room: "Main Area"
   to_room: "Ending"
   door { name: "Ending Door" }
+  cyan_ending: true
 }
 connections {
   from_room: "Main Area"
@@ -1,12 +1,24 @@
 doors {
   name: "Double Letters"
   type: EVENT
-  switches: "double_letters"
+  receivers: "Components/Doors/entry_11"
+  receivers: "Components/Doors/entry_5"
+  receivers: "Components/Doors/entry_6"
+  receivers: "Components/Doors/entry_7"
+  receivers: "Components/Doors/entry_8"
+  receivers: "Components/Doors/entry_9"
+  receivers: "Components/Doors/entry_10"
+  double_letters: true
 }
 doors {
   name: "Lavender Cubes"
   type: EVENT
-  switches: "lavender_cubes"
+  receivers: "Components/Doors/entry_3"
+  panels {
+    map: "the_ancient"
+    room: "Inside"
+    name: "COLOR"
+  }
 }
 doors {
   name: "K2 Door"
@@ -19,6 +31,7 @@ doors {
   panels { room: "Main Area" name: "ALEXANDER" answer: "greece" }
   panels { room: "Main Area" name: "CAESAR" answer: "rome" }
   location_room: "Main Area"
+  location_name: "Empires"
 }
 doors {
   name: "Ending Door"
@@ -1,5 +1,4 @@
 name: "Ending"
-display_name: "Parthenon"
 endings {
   name: "CYAN"
   path: "Components/cyan_end"
@@ -1,5 +1,4 @@
 name: "K2 Room"
-display_name: "Parthenon"
 letters {
   key: "k"
   level2: true
@@ -1,5 +1,4 @@
 name: "Lavender Area"
-display_name: "Parthenon"
 panels {
   name: "ME"
   path: "Panels/Lavender/panel_7"
@@ -1,12 +1,11 @@
 name: "Main Area"
-display_name: "Parthenon"
 panels {
   name: "XERXES"
   path: "Panels/Main/panel_1"
   clue: "xerxes"
   answer: "xerxes"
   proxies { answer: "persia" path: "Panels/Empires/panel_7" }
-  #proxies { answer: "xerxes" path: "Panels/Rulers/panel_13" }
+  proxies { answer: "xerxes" path: "Panels/Rulers/panel_13" }
   required_door { name: "Double Letters" }
 }
 panels {
@@ -15,7 +14,7 @@ panels {
   clue: "arthur"
   answer: "arthur"
   proxies { answer: "england" path: "Panels/Empires/panel_8" }
-  #proxies { answer: "arthur" path: "Panels/Rulers/panel_14" }
+  proxies { answer: "arthur" path: "Panels/Rulers/panel_14" }
   required_door { name: "Double Letters" }
 }
 panels {
@@ -24,7 +23,7 @@ panels {
   clue: "cleopatra"
   answer: "cleopatra"
   proxies { answer: "egypt" path: "Panels/Empires/panel_9" }
-  #proxies { answer: "cleopatra" path: "Panels/Rulers/panel_15" }
+  proxies { answer: "cleopatra" path: "Panels/Rulers/panel_15" }
   required_door { name: "Double Letters" }
 }
 panels {
@@ -33,7 +32,7 @@ panels {
   clue: "napoleon"
   answer: "napoleon"
   proxies { answer: "france" path: "Panels/Empires/panel_10" }
-  #proxies { answer: "napoleon" path: "Panels/Rulers/panel_16" }
+  proxies { answer: "napoleon" path: "Panels/Rulers/panel_16" }
   required_door { name: "Double Letters" }
 }
 panels {
@@ -42,7 +41,7 @@ panels {
   clue: "alexander"
   answer: "alexander"
   proxies { answer: "greece" path: "Panels/Empires/panel_11" }
-  #proxies { answer: "alexander" path: "Panels/Rulers/panel_17" }
+  proxies { answer: "alexander" path: "Panels/Rulers/panel_17" }
   required_door { name: "Double Letters" }
 }
 panels {
@@ -51,21 +50,27 @@ panels {
   clue: "caesar"
   answer: "caesar"
   proxies { answer: "rome" path: "Panels/Empires/panel_12" }
-  #proxies { answer: "caesar" path: "Panels/Rulers/panel_18" }
+  proxies { answer: "caesar" path: "Panels/Rulers/panel_18" }
   required_door { name: "Double Letters" }
 }
 ports {
   name: "GALLERY"
+  display_name: "Columns Worldport"
   path: "Components/Warps/worldport"
-  orientation: "south"
+  destination { x: 0 y: 0 z: 0 }
+  rotation: 0
 }
 ports {
   name: "ENTRY"
+  display_name: "Building Worldport"
   path: "Components/Warps/worldport2"
-  orientation: "south"
+  destination { x: 0 y: 0 z: -21 }
+  rotation: 0
 }
 ports {
   name: "REVITALIZED"
+  display_name: "Plum Hallway"
   path: "Components/Warps/worldport3"
-  orientation: "north"
+  destination { x: -24 y: 0 z: -39 }
+  rotation: 180
 }
@@ -1,6 +1,6 @@
 name: "U Keyholder"
-display_name: "Parthenon"
 keyholders {
   name: "U"
   path: "Components/KeyHolders/keyHolderU"
+  key: "u"
 }
@@ -22,6 +22,7 @@ doors {
   panels { room: "Obverse Side" name: "CUT" }
   panels { room: "Obverse Side" name: "FUN" }
   location_room: "Obverse Side"
+  location_name: "Obverse Side Room"
 }
 doors {
   name: "Giant P"
@@ -1,5 +1,4 @@
 name: "Control Center Entrance"
-display_name: "Partial"
 panels {
   name: "RETURN"
   path: "Panels/Control/panel_10"
@@ -9,6 +8,10 @@ panels {
 }
 ports {
   name: "CC"
+  display_name: "Control Center Connector"
   path: "Components/Warps/worldport2"
-  orientation: "north"
+  destination { x: -19 y: 0 z: 8 }
+  rotation: 180
+  # TODO: shuffle entrances with dependent keyholders
+  no_shuffle: true
 }
@@ -1,5 +1,4 @@
 name: "F Room"
-display_name: "Partial"
 letters {
   key: "f"
   path: "Components/Collectables/collectable2"
@@ -1,5 +1,4 @@
 name: "Obverse Side"
-display_name: "Partial"
 panels {
   name: "PUN"
   path: "Panels/Main/panel_1"
@@ -100,13 +99,16 @@ panels {
 }
 ports {
   name: "GREAT"
+  display_name: "Main Entrance"
   path: "Components/Warps/worldport"
-  orientation: "west"
+  destination { x: -3 y: 0 z: 20 }
+  rotation: 270
 }
 keyholders {
   # This is one of the ones that's misnamed within the game.
   name: "L"
   path: "Components/KeyHolders/keyHolderI"
+  key: "l"
 }
 paintings {
   name: "F"
@@ -1,5 +1,4 @@
 name: "P Room"
-display_name: "Partial"
 letters {
   key: "p"
   path: "Components/Collectables/collectable"
@@ -1,5 +1,4 @@
 name: "Reverse Side"
-display_name: "Partial"
 panels {
   name: "BRO"
   path: "Panels/Side 2/panel_2"
@@ -1,7 +1,10 @@
 name: "Main Area"
-display_name: "Perceptive"
 ports {
   name: "CC"
+  display_name: "Entrance"
   path: "Components/Warps/worldport"
-  orientation: "east"
+  destination { x: 3 y: 0 z: 13 }
+  rotation: 90
+  # TODO: shuffle entrances with dependent keyholders
+  no_shuffle: true
 }
@@ -21,22 +21,22 @@ connections {
 connections {
   from_room: "Center Room"
   to_room: "Top Left Room"
-  door { name: "Top Left Door" }
+  door { name: "Northwest Door" }
 }
 connections {
   from_room: "Center Room"
   to_room: "Top Right Room"
-  door { name: "Top Right Door" }
+  door { name: "Northeast Door" }
 }
 connections {
   from_room: "Center Room"
   to_room: "Bottom Left Room"
-  door { name: "Bottom Left Door" }
+  door { name: "Southwest Door" }
 }
 connections {
   from_room: "Center Room"
   to_room: "Bottom Right Room"
-  door { name: "Bottom Right Door" }
+  door { name: "Southeast Door" }
 }
 connections {
   from_room: "Center Room"
@@ -31,7 +31,7 @@ doors {
   location_room: "Main Area"
 }
 doors {
-  name: "Top Left Door"
+  name: "Northwest Door"
   type: STANDARD
   receivers: "Components/Doors/entry_6"
   panels { room: "Center Room" name: "REPORTER" }
@@ -41,9 +41,10 @@ doors {
   panels { room: "Center Room" name: "DENTIST" }
   panels { room: "Center Room" name: "SQUIRREL" }
   location_room: "Center Room"
+  location_name: "First Room"
 }
 doors {
-  name: "Top Right Door"
+  name: "Northeast Door"
   type: ITEM_ONLY
   receivers: "Components/Doors/entry_7"
   panels { room: "Center Room" name: "REPORTER" }
@@ -54,7 +55,7 @@ doors {
   panels { room: "Center Room" name: "SQUIRREL" }
 }
 doors {
-  name: "Bottom Left Door"
+  name: "Southwest Door"
   type: ITEM_ONLY
   receivers: "Components/Doors/entry_5"
   panels { room: "Center Room" name: "REPORTER" }
@@ -65,7 +66,7 @@ doors {
   panels { room: "Center Room" name: "SQUIRREL" }
 }
 doors {
-  name: "Bottom Right Door"
+  name: "Southeast Door"
   type: ITEM_ONLY
   receivers: "Components/Doors/entry_4"
   panels { room: "Center Room" name: "REPORTER" }
@@ -76,7 +77,7 @@ doors {
   panels { room: "Center Room" name: "SQUIRREL" }
 }
 doors {
-  name: "Top Left Puzzles"
+  name: "Northwest Puzzles"
   type: LOCATION_ONLY
   panels { room: "Top Left Room" name: "BARE SOD" }
   panels { room: "Top Left Room" name: "SOD" }
@@ -103,7 +104,7 @@ doors {
   location_room: "Top Left Room"
 }
 doors {
-  name: "Top Right Puzzles"
+  name: "Northeast Puzzles"
   type: LOCATION_ONLY
   panels { room: "Top Right Room" name: "RIGHT WING" }
   panels { room: "Top Right Room" name: "WING" }
@@ -129,7 +130,7 @@ doors {
   location_room: "Top Right Room"
 }
 doors {
-  name: "Bottom Left Puzzles"
+  name: "Southwest Puzzles"
   type: LOCATION_ONLY
   panels { room: "Bottom Left Room" name: "SHELL (1)" }
   panels { room: "Bottom Left Room" name: "SHELL (2)" }
@@ -140,7 +141,7 @@ doors {
   location_room: "Bottom Left Room"
 }
 doors {
-  name: "Bottom Right Puzzles"
+  name: "Southeast Puzzles"
   type: LOCATION_ONLY
   panels { room: "Bottom Right Room" name: "FLY" }
   panels { room: "Bottom Right Room" name: "DECLOG" }
@@ -1,5 +1,4 @@
 name: "Bottom Left Room"
-display_name: "Plaza"
 panels {
   name: "SHELL (1)"
   path: "Panels/Room 4/panel_1"
@@ -1,5 +1,4 @@
 name: "Bottom Right Room"
-display_name: "Plaza"
 panels {
   name: "FLY"
   path: "Panels/Room 3/panel_1"
@@ -1,5 +1,4 @@
 name: "Center Room"
-display_name: "Plaza"
 panels {
   name: "REPORTER"
   path: "Panels/Room 2/panel_1"
@@ -1,5 +1,4 @@
 name: "Main Area"
-display_name: "Plaza"
 panels {
   name: "COURTYARD"
   path: "Panels/Entrances/panel_1"
@@ -37,16 +36,22 @@ panels {
 }
 ports {
   name: "UNYIELDING"
+  display_name: "Unyielding Hallway"
   path: "Components/Warps/worldport"
-  orientation: "west"
+  destination { x: 1 y: 0 z: 10 }
+  rotation: 270
 }
 ports {
   name: "IMPRESSIVE"
+  display_name: "Impressive Hallway"
   path: "Components/Warps/worldport2"
-  orientation: "west"
+  destination { x: 11 y: 0 z: 10 }
+  rotation: 270
 }
 ports {
   name: "BETWEEN"
+  display_name: "Between Hallway"
   path: "Components/Warps/worldport3"
-  orientation: "west"
+  destination { x: -9 y: 0 z: 10 }
+  rotation: 270
 }
@@ -1,5 +1,4 @@
 name: "Mastery"
-display_name: "Plaza"
 masteries {
   name: "MASTERY"
   path: "Components/Collectables/smiley"
@@ -1,5 +1,4 @@
 name: "Repetitive Entrance"
-display_name: "Plaza"
 panels {
   name: "TEDIOUS"
   path: "Panels/Entrances/panel_6"
@@ -9,6 +8,8 @@ panels {
 }
 ports {
   name: "REPETITIVE"
+  display_name: "Repetitive Entrance"
   path: "Components/Warps/worldport5"
-  orientation: "north"
+  destination { x: -19 y: 0 z: 16 }
+  rotation: 180
 }
@@ -1,5 +1,4 @@
 name: "Sirenic Entrance"
-display_name: "Plaza"
 panels {
   name: "SIREN"
   path: "Panels/Entrances/panel_8"
@@ -9,6 +8,8 @@ panels {
 }
 ports {
   name: "SIRENIC"
+  display_name: "Sirenic Entrance"
   path: "Components/Warps/worldport6"
-  orientation: "west"
+  destination { x: -51 y: 0 z: -43 }
+  rotation: 270
 }
@@ -1,5 +1,4 @@
 name: "Symbolic Entrance"
-display_name: "Plaza"
 panels {
   name: "FIGURATIVE"
   path: "Panels/Entrances/panel_5"
@@ -9,6 +8,8 @@ panels {
 }
 ports {
   name: "SYMBOLIC"
+  display_name: "Symbolic Entrance"
   path: "Components/Warps/worldport4"
-  orientation: "south"
+  destination { x: 28 y: 0 z: 4 }
+  rotation: 0
 }
@@ -1,5 +1,4 @@
 name: "Top Left Room"
-display_name: "Plaza"
 panels {
   name: "BARE SOD"
   path: "Panels/Room 6/panel_1"
@@ -42,6 +41,7 @@ panels {
   clue: "knot"
   answer: "not"
   symbols: ZERO
+  display_name: "KNOT (TL)"
 }
 panels {
   name: "SURE TEMPER"
@@ -129,6 +129,7 @@ panels {
   clue: "bear"
   answer: "bearer"
   symbols: SPARKLES
+  display_name: "BEAR (TL)"
 }
 panels {
   name: "CHILL"
@@ -1,5 +1,4 @@
 name: "Top Right Room"
-display_name: "Plaza"
 panels {
   name: "RIGHT WING"
   path: "Panels/Room 5/panel_1"
@@ -34,6 +33,7 @@ panels {
   clue: "bear"
   answer: "cave"
   symbols: STARS
+  display_name: "BEAR (TR)"
 }
 panels {
   name: "TYPIST"
@@ -125,6 +125,7 @@ panels {
   clue: "knot"
   answer: "not"
   symbols: ZERO
+  display_name: "KNOT (TR)"
 }
 panels {
   name: "HALVES ANNOYED SOUR GOOD"
@@ -1,6 +1,6 @@
 name: "Keyholder Room"
-display_name: "Quiet"
 keyholders {
   name: "Q"
   path: "Components/KeyHolders/keyHolderQ"
+  key: "q"
 }
@@ -1,5 +1,4 @@
 name: "Main Area"
-display_name: "Quiet"
 panels {
   name: "SOLID"
   path: "Panels/Main/panel_1"
@@ -98,6 +97,8 @@ panels {
 }
 ports {
   name: "DAEDALUS"
+  display_name: "Entrance"
   path: "Components/Warps/worldport"
-  orientation: "east"
+  destination { x: 3 y: 0 z: 8 }
+  rotation: 90
 }
@@ -1,5 +1,4 @@
 name: "Q Room"
-display_name: "Quiet"
 letters {
   key: "q"
   path: "Components/Collectables/q"
@@ -1,5 +1,4 @@
 name: "All"
-display_name: "Relentless"
 panels {
   name: "LEFT (1)"
   path: "Panels/Room_1/panel_6"
@@ -1,5 +1,4 @@
 name: "Left And Turn"
-display_name: "Relentless"
 panels {
   name: "HIDE (1)"
   path: "Panels/Room_1/panel_2"
@@ -1,5 +1,4 @@
 name: "Left Room"
-display_name: "Relentless"
 panels {
   name: "HIDE"
   path: "Panels/Room_1/panel_1"
@@ -1,5 +1,4 @@
 name: "Mastery"
-display_name: "Relentless"
 masteries {
   name: "MASTERY"
   path: "Components/Collectables/smiley"
@@ -1,5 +1,4 @@
 name: "Shop Room"
-display_name: "Relentless"
 panels {
   name: "LEFT (1)"
   path: "Panels/Room_3/panel_5"
@@ -1,5 +1,4 @@
 name: "Turn And Shop"
-display_name: "Relentless"
 panels {
   name: "LEFT (1)"
   path: "Panels/Room_2/panel_5"
@@ -1,5 +1,4 @@
 name: "Turn Room"
-display_name: "Relentless"
 panels {
   name: "HIDE (1)"
   path: "Panels/Room_2/panel_2"
@@ -6,13 +6,13 @@ connections {
 connections {
   from_room: "Main Room"
   to_room: "Plaza Connector"
-  door { name: "Plaza Entrance" }
-  oneway: true
+  door { name: "Black Hallway" }
 }
 connections {
   from_room: "Plaza Connector"
   to_room: "Main Room"
   oneway: true
+  vanilla_only: true
 }
 connections {
   from_room: "Main Room"
@@ -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" }
@@ -194,3 +194,9 @@ doors {
   panels { room: "Yellow Room" name: "ASSESSES" }
   panels { room: "Yellow Room" name: "TINTING" }
 }
+doors {
+  name: "Anti-Collectable"
+  type: LOCATION_ONLY
+  senders: "Components/Collectables/anticollectable"
+  location_room: "Anti Room"
+}
@@ -1,10 +1,6 @@
 display_name: "The Repetitive"
-# The anti-collectable doesn't fit into our system right now so let's ignore it.
-excluded_nodes: "Components/Collectables/anticollectable"
 # These paintings are directly above/behind panels and thus can't be entered.
 excluded_nodes: "Meshes/eyeRed3"
 excluded_nodes: "Meshes/eyeRed4"
-# I do not know what this is.
-excluded_nodes: "Components/Doors/Door3/Hinge/panel_i"
 # This has something to do with the magenta room entrance proxy panel.
 excluded_nodes: "Panels/Eval/panel_26_proxyied_fake"
@@ -1,6 +1,4 @@
 name: "Anti Room"
-display_name: "Repetitive"
-# Ignore the collectible. The mod should remove it and the back wall too.
 panels {
   name: "HA (1)"
   path: "Panels/Entry/panel_7"
@@ -39,9 +37,17 @@ panels {
   symbols: EXAMPLE
 }
 panels {
-  name: "EYE"
+  name: "EYE (1)"
   path: "Panels/Entry/panel4"
   clue: "eye"
   answer: "iris"
   symbols: BOXES
 }
+panels {
+  # This appears after grabbing the anti-collectable.
+  name: "EYE (2)"
+  path: "Components/Doors/Door3/Hinge/panel_i"
+  clue: "eye"
+  answer: "i"
+  symbols: ZERO
+}
@@ -1,5 +1,4 @@
 name: "Cyan Room"
-display_name: "Repetitive"
 panels {
   name: "ALFA"
   path: "Panels/Lingo2/panel_3"
@@ -1,5 +1,4 @@
 name: "Dot Area"
-display_name: "Repetitive"
 panels {
   name: "TUTU (1)"
   path: "Panels/Lingo2/panel"
@@ -96,7 +95,7 @@ panels {
   clue: "door"
   answer: "door"
   symbols: EVAL
-  #proxies { answer: "door" path: "Panels/Eval/panel_26_proxyied_1" }
+  proxies { answer: "door" path: "Panels/Eval/panel_26_proxyied_1" }
   proxies { answer: "do" path: "Panels/Eval/panel_26_proxyied_2" }
 }
 panels {
@@ -1,7 +1,11 @@
 name: "Entry Connector"
-display_name: "Repetitive"
 ports {
   name: "ENTRY"
+  display_name: "Northwest Worldport"
   path: "Components/Warps/worldport2"
-  orientation: "south"
+  destination { x: -11 y: 0 z: 13 }
+  rotation: 0
+  # TODO: this is part of what makes the keyholder dependent connection form CC
+  # safe in vanilla doors
+  no_shuffle: true
 }
@@ -1,5 +1,4 @@
 name: "Lime Room"
-display_name: "Repetitive"
 panels {
   name: "RAT"
   path: "Panels/Lingo2/panel_1"
@@ -1,5 +1,4 @@
 name: "Magenta Room"
-display_name: "Repetitive"
 panels {
   name: "WRITE"
   path: "Panels/Eval/panel_9"
@@ -1,5 +1,4 @@
 name: "Main Room"
-display_name: "Repetitive"
 panels {
   name: "HOTS (2)"
   path: "Panels/Entry/panel_3"
@@ -139,6 +138,10 @@ paintings {
 }
 ports {
   name: "CC"
+  display_name: "Southwest Worldport"
   path: "Components/Warps/worldport3"
-  orientation: "east"
+  destination { x: -5.5 y: 0 z: 56 }
+  rotation: 90
+  # TODO: shuffle entrances with dependent keyholders
+  no_shuffle: true
 }
@@ -1,5 +1,4 @@
 name: "Mastery Room"
-display_name: "Repetitive"
 masteries {
   name: "MASTERY"
   path: "Components/Collectables/smiley"
@@ -1,7 +1,8 @@
 name: "Plaza Connector"
-display_name: "Repetitive"
 ports {
   name: "PLAZA"
+  display_name: "Northeast Worldport"
   path: "Components/Warps/worldport"
-  orientation: "north"
+  destination { x: 15 y: 0 z: 13 }
+  rotation: 0
 }
@@ -1,5 +1,4 @@
 name: "Yellow Room"
-display_name: "Repetitive"
 panels {
   name: "W"
   path: "Panels/Eval/panel_1"
@@ -1,5 +1,4 @@
 name: "Bye Room"
-display_name: "Revitalized"
 panels {
   name: "BYE"
   path: "Panels/panel_1"
@@ -9,6 +8,8 @@ panels {
 }
 ports {
   name: "PARTHENON"
+  display_name: "Entrance"
   path: "Components/Warps/worldport"
-  orientation: "south"
+  destination { x: 30 y: 0 z: 16 }
+  rotation: 0
 }
@@ -1,5 +1,4 @@
 name: "Hidden Room"
-display_name: "Revitalized"
 panels {
   name: "HIDDEN"
   path: "Panels/panel_3"
@@ -1,5 +1,4 @@
 name: "Hide Room"
-display_name: "Revitalized"
 panels {
   name: "HIDE"
   path: "Panels/panel_2"
@@ -1,5 +1,4 @@
 name: "High Room"
-display_name: "Revitalized"
 panels {
   name: "HIGH"
   path: "Panels/panel_4"
@@ -1,5 +1,4 @@
 name: "Return Room"
-display_name: "Revitalized"
 panels {
   name: "RETURN"
   path: "Components/panel_7"
@@ -1,5 +1,4 @@
 name: "Too Room"
-display_name: "Revitalized"
 panels {
   name: "TOO"
   path: "Panels/panel_6"
@@ -1,5 +1,4 @@
 name: "Won Room"
-display_name: "Revitalized"
 panels {
   name: "WON"
   path: "Panels/panel_5"
@@ -1,5 +1,4 @@
 name: "Main Area"
-display_name: "Shop"
 panels {
   name: "DUCKS"
   path: "Panels/Books/panel_1"
@@ -156,9 +155,13 @@ panels {
 }
 ports {
   name: "ENTRY"
+  display_name: "Entrance"
   path: "Components/Warps/worldport"
+  destination { x: 4 y: 0 z: 12 }
+  rotation: 90
 }
 keyholders {
   name: "N"
   path: "Components/KeyHolders/keyHolderN"
+  key: "n"
 }
@@ -1,5 +1,4 @@
 name: "Mastery"
-display_name: "Sirenic"
 masteries {
   name: "MASTERY"
   path: "Components/Collectables/smiley"
@@ -1,5 +1,4 @@
 name: "Puzzles"
-display_name: "Sirenic"
 panels {
   name: "Left Top 1"
   path: "Panels/Room_1/pip_1"
@@ -1,5 +1,4 @@
 name: "Start"
-display_name: "Sirenic"
 panels {
   name: "Flipped"
   path: "Panels/Entry/entry_2"
@@ -16,6 +15,8 @@ panels {
 }
 ports {
   name: "PLAZA"
+  display_name: "Entrance"
   path: "Components/Warps/worldport"
-  orientation: "south"
+  destination { x: 0 y: 0 z: 26 }
+  rotation: 0
 }
@@ -1,5 +1,4 @@
 name: "Center"
-display_name: "Stormy"
 panels {
   name: "REACTOR"
   path: "Panels/Room_1/panel_7"
@@ -20,6 +19,7 @@ panels {
   clue: "cloud"
   answer: "rain"
   symbols: AGE
+  display_name: "CLOUD (1)"
 }
 panels {
   name: "WIND"
@@ -27,9 +27,12 @@ panels {
   clue: "wind"
   answer: "tornado"
   symbols: CROSS
+  display_name: "WIND (1)"
 }
 ports {
   name: "ENTRY"
+  display_name: "Worldport"
   path: "Components/Warps/worldport"
-  orientation: "west"
+  destination { x: -8.5 y: 0 z: 6 }
+  rotation: 270
 }
@@ -1,5 +1,4 @@
 name: "Nuclear Side"
-display_name: "Stormy"
 panels {
   name: "GERM"
   path: "Panels/Room_1/panel_2"
@@ -1,5 +1,4 @@
 name: "Nuclear Vestibule"
-display_name: "Stormy"
 panels {
   name: "STORM"
   path: "Panels/Room 2/panel_11"
@@ -1,11 +1,11 @@
 name: "Rain Side"
-display_name: "Stormy"
 panels {
   name: "CLOUD"
   path: "Panels/Room_1/panel_4"
   clue: "cloud"
   answer: "lightning"
   symbols: CROSS
+  display_name: "CLOUD (2)"
 }
 panels {
   name: "WIND"
@@ -13,4 +13,5 @@ panels {
   clue: "wind"
   answer: "whirlwind"
   symbols: PYRAMID
+  display_name: "WIND (2)"
 }
@@ -1,5 +1,4 @@
 name: "Tornado Side"
-display_name: "Stormy"
 panels {
   name: "PUDDLE"
   path: "Panels/Room_1/panel_6"
@@ -1,5 +1,4 @@
 name: "Tornado Vestibule"
-display_name: "Stormy"
 panels {
   name: "SHIP"
   path: "Panels/Room 2/panel_12"
@@ -1,5 +1,4 @@
 name: "Volcano Side"
-display_name: "Stormy"
 panels {
   name: "SNOW"
   path: "Panels/Room_1/panel_1"
@@ -1,5 +1,4 @@
 name: "X2 Room"
-display_name: "Stormy"
 letters {
   key: "x"
   level2: true
@@ -1,5 +1,4 @@
 name: "Main Area"
-display_name: "Sturdy"
 panels {
   name: "MOVE (1)"
   path: "Panels/Main/panel_1"
@@ -11,7 +10,7 @@ panels {
   proxies { answer: "down" path: "Panels/Down/down_1" }
   proxies { answer: "left" path: "Panels/Left/left_1" }
   proxies { answer: "right" path: "Panels/Right/right_1" }
-  #proxies { answer: "move" path: "Panels/Secret/secret_1" }
+  proxies { answer: "move" path: "Panels/Secret/secret_1" }
 }
 panels {
   name: "MOVE (2)"
@@ -24,7 +23,7 @@ panels {
   proxies { answer: "down" path: "Panels/Down/down_2" }
   proxies { answer: "left" path: "Panels/Left/left_2" }
   proxies { answer: "right" path: "Panels/Right/right_2" }
-  #proxies { answer: "move" path: "Panels/Secret/secret_2" }
+  proxies { answer: "move" path: "Panels/Secret/secret_2" }
 }
 panels {
   name: "MOVE (3)"
@@ -37,7 +36,7 @@ panels {
   proxies { answer: "down" path: "Panels/Down/down_3" }
   proxies { answer: "left" path: "Panels/Left/left_3" }
   proxies { answer: "right" path: "Panels/Right/right_3" }
-  #proxies { answer: "move" path: "Panels/Secret/secret_3" }
+  proxies { answer: "move" path: "Panels/Secret/secret_3" }
 }
 panels {
   name: "MOVE (4)"
@@ -50,7 +49,7 @@ panels {
   proxies { answer: "down" path: "Panels/Down/down_4" }
   proxies { answer: "left" path: "Panels/Left/left_4" }
   proxies { answer: "right" path: "Panels/Right/right_4" }
-  #proxies { answer: "move" path: "Panels/Secret/secret_4" }
+  proxies { answer: "move" path: "Panels/Secret/secret_4" }
 }
 panels {
   name: "MOVE (5)"
@@ -63,7 +62,7 @@ panels {
   proxies { answer: "down" path: "Panels/Down/down_5" }
   proxies { answer: "left" path: "Panels/Left/left_5" }
   proxies { answer: "right" path: "Panels/Right/right_5" }
-  #proxies { answer: "move" path: "Panels/Secret/secret_5" }
+  proxies { answer: "move" path: "Panels/Secret/secret_5" }
 }
 panels {
   name: "MOVE (6)"
@@ -76,7 +75,7 @@ panels {
   proxies { answer: "down" path: "Panels/Down/down_6" }
   proxies { answer: "left" path: "Panels/Left/left_6" }
   proxies { answer: "right" path: "Panels/Right/right_6" }
-  #proxies { answer: "move" path: "Panels/Secret/secret_6" }
+  proxies { answer: "move" path: "Panels/Secret/secret_6" }
 }
 panels {
   name: "MOVE (7)"
@@ -89,7 +88,7 @@ panels {
   proxies { answer: "down" path: "Panels/Down/down_7" }
   proxies { answer: "left" path: "Panels/Left/left_7" }
   proxies { answer: "right" path: "Panels/Right/right_7" }
-  #proxies { answer: "move" path: "Panels/Secret/secret_7" }
+  proxies { answer: "move" path: "Panels/Secret/secret_7" }
 }
 panels {
   name: "MOVE (8)"
@@ -102,13 +101,19 @@ panels {
   proxies { answer: "down" path: "Panels/Down/down_8" }
   proxies { answer: "left" path: "Panels/Left/left_8" }
   proxies { answer: "right" path: "Panels/Right/right_8" }
-  #proxies { answer: "move" path: "Panels/Secret/secret_8" }
+  proxies { answer: "move" path: "Panels/Secret/secret_8" }
 }
 ports {
   name: "OWL"
+  display_name: "Magenta Hallway"
   path: "Components/Warps/worldport"
+  destination { x: 17 y: 0 z: 41 }
+  rotation: 90
 }
 ports {
   name: "COLORFUL"
+  display_name: "Cyan Hallway"
   path: "Components/Warps/worldport2"
+  destination { x: 17 y: 0 z: -33 }
+  rotation: 90
 }
@@ -1,5 +1,4 @@
 name: "S2 Area"
-display_name: "Sturdy"
 panels {
   name: "COLORS"
   path: "Panels/Rainbow/panel_1"
@@ -7,6 +7,7 @@ connections {
   from_room: "Temple"
   to_room: "Ending"
   door { name: "Ending" }
+  purple_ending: true
 }
 connections {
   from_room: "Temple"
@@ -1,5 +1,4 @@
 name: "Ending"
-display_name: "Sun Temple"
 endings {
   name: "PURPLE"
   path: "Components/purple_ending"
@@ -1,14 +1,16 @@
 name: "Entrance"
-display_name: "Sun Temple"
 panels {
   name: "SUN"
   path: "Panels/Main/panel_1"
   clue: "sun"
   answer: "sun"
-  #proxies { answer: "sun" path: "Panels/Sun/panel_8" }
+  proxies { answer: "sun" path: "Panels/Sun/panel_8" }
   proxies { answer: "moon" path: "Panels/Moon/panel_15" }
 }
 ports {
   name: "UNKEMPT"
+  display_name: "Entrance"
   path: "Components/Warps/worldport"
+  destination { x: 0 y: 0 z: 13 }
+  rotation: 0
 }
@@ -1,5 +1,4 @@
 name: "Mastery"
-display_name: "Sun Temple"
 masteries {
   name: "MASTERY"
   path: "Components/Collectables/collectable"
@@ -1,12 +1,11 @@
 name: "Temple"
-display_name: "Sun Temple"
 panels {
   name: "DELAY"
   path: "Panels/Main/panel_2"
   clue: "delay"
   answer: "day"
   symbols: SPARKLES
-  #proxies { answer: "day" path: "Panels/Sun/panel_9" }
+  proxies { answer: "day" path: "Panels/Sun/panel_9" }
   proxies { answer: "night" path: "Panels/Moon/panel_16" }
 }
 panels {
@@ -15,7 +14,7 @@ panels {
   clue: "lawn"
   answer: "dawn"
   symbols: SPARKLES
-  #proxies { answer: "dawn" path: "Panels/Sun/panel_10" }
+  proxies { answer: "dawn" path: "Panels/Sun/panel_10" }
   proxies { answer: "dusk" path: "Panels/Moon/panel_17" }
 }
 panels {
@@ -24,7 +23,7 @@ panels {
   clue: "jump"
   answer: "spring"
   symbols: SUN
-  #proxies { answer: "spring" path: "Panels/Sun/panel_11" }
+  proxies { answer: "spring" path: "Panels/Sun/panel_11" }
   proxies { answer: "autumn" path: "Panels/Moon/panel_18" }
 }
 panels {
@@ -33,7 +32,7 @@ panels {
   clue: "heavy"
   answer: "light"
   symbols: SUN
-  #proxies { answer: "light" path: "Panels/Sun/panel_12" }
+  proxies { answer: "light" path: "Panels/Sun/panel_12" }
   proxies { answer: "dark" path: "Panels/Moon/panel_19" }
 }
 panels {
@@ -42,7 +41,7 @@ panels {
   clue: "knife"
   answer: "life"
   symbols: ZERO
-  #proxies { answer: "life" path: "Panels/Sun/panel_13" }
+  proxies { answer: "life" path: "Panels/Sun/panel_13" }
   proxies { answer: "death" path: "Panels/Moon/panel_20" }
 }
 panels {
@@ -51,7 +50,7 @@ panels {
   clue: "arm"
   answer: "warmth"
   symbols: SPARKLES
-  #proxies { answer: "warmth" path: "Panels/Sun/panel_14" }
+  proxies { answer: "warmth" path: "Panels/Sun/panel_14" }
   proxies { answer: "chill" path: "Panels/Moon/panel_21" }
 }
 panels {
@@ -60,5 +59,5 @@ panels {
   clue: "equinox"
   answer: "equinox"
   proxies { answer: "solstice" path: "Panels/End/panel_23" }
-  #proxies { answer: "equinox" path: "Panels/End/panel_24" }
+  proxies { answer: "equinox" path: "Panels/End/panel_24" }
 }
@@ -1,5 +1,4 @@
 name: "Main Area"
-display_name: "Sweet"
 panels {
   name: "POTATO"
   path: "Panels/Sweetening Room/panel_1"
@@ -201,9 +200,15 @@ panels {
 }
 ports {
   name: "EXIT1"
+  display_name: "South Worldport"
   path: "Components/Warps/worldport"
+  destination { x: 0 y: 0 z: -11.5 }
+  rotation: 180
 }
 ports {
   name: "EXIT2"
+  display_name: "North Worldport"
   path: "Components/Warps/worldport2"
+  destination { x: 0 y: 0 z: -17.5 }
+  rotation: 0
 }
@@ -1,5 +1,4 @@
 name: "Y2 Room"
-display_name: "Sweet"
 letters {
   key: "y"
   level2: true
@@ -1,62 +1,55 @@
 doors {
   name: "White Door"
-  type: STANDARD
-  receivers: "Components/Doors/Door18"
+  type: EVENT
+  #receivers: "Components/Doors/Door18"
   panels { room: "White Room" name: "WRITE" }
-  location_room: "White Room"
 }
 doors {
   name: "Black Door"
-  type: STANDARD
-  receivers: "Components/Doors/Door19"
+  type: EVENT
+  #receivers: "Components/Doors/Door19"
   panels { room: "Black Room" name: "HERE" }
-  location_room: "Black Room"
 }
 doors {
   name: "Red Door"
-  type: STANDARD
-  receivers: "Components/Doors/Door20"
+  type: EVENT
+  #receivers: "Components/Doors/Door20"
   panels { room: "Red Room" name: "SYNONYM" }
-  location_room: "Red Room"
 }
 doors {
   name: "Blue Door"
-  type: STANDARD
-  receivers: "Components/Doors/Door21"
+  type: EVENT
+  #receivers: "Components/Doors/Door21"
   panels { room: "Blue Room" name: "DEPLETE" }
-  location_room: "Blue Room"
 }
 doors {
   name: "Green Door"
-  type: STANDARD
-  receivers: "Components/Doors/Door22"
+  type: EVENT
+  #receivers: "Components/Doors/Door22"
   panels { room: "Green Room" name: "INERT" }
-  location_room: "Green Room"
 }
 doors {
   name: "Yellow Door"
-  type: STANDARD
-  receivers: "Components/Doors/Door23"
+  type: EVENT
+  #receivers: "Components/Doors/Door23"
   panels { room: "Yellow Room" name: "WHOLE" }
-  location_room: "Yellow Room"
 }
 doors {
   name: "Purple Door"
-  type: STANDARD
-  receivers: "Components/Doors/Door24"
+  type: EVENT
+  #receivers: "Components/Doors/Door24"
   panels { room: "Purple Room" name: "TIME" }
-  location_room: "Purple Room"
 }
 doors {
   name: "Orange Door"
-  type: STANDARD
-  receivers: "Components/Doors/Door25"
+  type: EVENT
+  #receivers: "Components/Doors/Door25"
   panels { room: "Orange Room" name: "YOUNG" }
-  location_room: "Orange Room"
 }
 doors {
   name: "Tutorial Door"
-  type: EVENT
+  type: ITEM_ONLY
+  receivers: "Components/Doors/Door"
   panels { room: "Tutorial" name: "<- (1)" }
   panels { room: "Tutorial" name: "<- (2)" }
   panels { room: "Tutorial" name: "<- (3)" }
@@ -5,7 +5,7 @@ panels {
   clue: "absorbed"
   answer: "abs"
   symbols: EVAL
-  #proxies { answer: "abs" path: "Panels/Proxy/absorbed_proxied_1" }
+  proxies { answer: "abs" path: "Panels/Proxy/absorbed_proxied_1" }
   proxies { answer: "bed" path: "Panels/Proxy/absorbed_proxied_2" }
 }
 panels {
@@ -14,6 +14,6 @@ panels {
   clue: "primordial"
   answer: "prim"
   symbols: EVAL
-  #proxies { answer: "prim" path: "Panels/Proxy/primordial_proxied_1" }
+  proxies { answer: "prim" path: "Panels/Proxy/primordial_proxied_1" }
   proxies { answer: "dial" path: "Panels/Proxy/primordial_proxied_2" }
 }
@@ -18,6 +18,6 @@ panels {
   answer: "ugly"
   symbols: EVAL
   symbols: LINGO
-  #proxies { answer: "ugly" path: "Panels/NotNoT/not_pretty_proxied_1" }
+  proxies { answer: "ugly" path: "Panels/NotNoT/not_pretty_proxied_1" }
   proxies { answer: "prey" path: "Panels/NotNoT/not_pretty_proxied_2" }
 }
@@ -18,6 +18,6 @@ panels {
   answer: "false"
   symbols: EVAL
   symbols: LINGO
-  #proxies { answer: "false" path: "Panels/NotNoT/not_true_proxied_1" }
+  proxies { answer: "false" path: "Panels/NotNoT/not_true_proxied_1" }
   proxies { answer: "rue" path: "Panels/NotNoT/not_true_proxied_2" }
 }
@@ -18,6 +18,6 @@ panels {
   answer: "worse"
   symbols: EVAL
   symbols: LINGO
-  #proxies { answer: "worse" path: "Panels/NotNoT/not_better_proxied_1" }
+  proxies { answer: "worse" path: "Panels/NotNoT/not_better_proxied_1" }
   proxies { answer: "beer" path: "Panels/NotNoT/not_better_proxied_2" }
 }
@@ -6,7 +6,7 @@ panels {
   answer: "word"
   symbols: ZERO
   symbols: EVAL
-  #proxies { answer: "word" path: "Panels/Entry/rightward_proxyied_1" }
+  proxies { answer: "word" path: "Panels/Entry/rightward_proxyied_1" }
   proxies { answer: "whirred" path: "Panels/Entry/rightward_proxyied_2" }
 }
 panels {
@@ -15,6 +15,6 @@ panels {
   clue: "typewriting"
   answer: "writing"
   symbols: EVAL
-  #proxies { answer: "writing" path: "Panels/Entry/typewriter_proxied_1" }
+  proxies { answer: "writing" path: "Panels/Entry/typewriter_proxied_1" }
   proxies { answer: "poetry" path: "Panels/Entry/typewriter_proxied_2" }
 }
@@ -7,5 +7,8 @@ panels {
 }
 ports {
   name: "PLAZA"
+  display_name: "Entrance"
   path: "Components/Warps/worldport"
+  destination { x: 0 y: 0 z: 2.5 }
+  rotation: 0
 }
@@ -107,8 +107,12 @@ panels {
 keyholders {
   name: "Y"
   path: "Components/KeyHolders/keyHolderY"
+  key: "y"
 }
 ports {
   name: "GREAT"
+  display_name: "Entrance"
   path: "Components/Warps/worldport"
+  destination { x: -3.5 y: 0 z: 21 }
+  rotation: 270
 }
@@ -8,5 +8,10 @@ panels {
 }
 ports {
   name: "CC"
+  display_name: "Control Center Connector"
   path: "Components/Warps/worldport"
+  destination { x: 0 y: 0 z: 10 }
+  rotation: 0
+  # TODO: shuffle entrances with dependent keyholders
+  no_shuffle: true
 }
@@ -2,4 +2,5 @@ name: "Main Area"
 keyholders {
   name: "K"
   path: "Components/KeyHolders/keyHolderK"
+  key: "k"
 }
@@ -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"
 }
@@ -29,9 +29,15 @@ panels {
 }
 ports {
   name: "BEGIN"
+  display_name: "Door Ways Worldport"
   path: "Components/Warps/worldport6"
+  destination { x: -38 y: 0 z: 41.5 }
+  rotation: 0
 }
 ports {
   name: "BEGIN2"
+  display_name: "Dead End Worldport"
   path: "Components/Warps/worldport5"
+  destination { x: -38 y: 0 z: 27.5 }
+  rotation: 180
 }
@@ -29,9 +29,15 @@ panels {
 }
 ports {
   name: "GREAT"
+  display_name: "First Worldport"
   path: "Components/Warps/worldport"
+  destination { x: -16 y: 0 z: 0.5 }
+  rotation: 180
 }
 ports {
   name: "TTD"
+  display_name: "Second Worldport"
   path: "Components/Warps/worldport2"
+  destination { x: -16 y: 0 z: 14.5 }
+  rotation: 0
 }
@@ -15,5 +15,8 @@ panels {
 }
 ports {
   name: "BEGIN"
+  display_name: "Loose Strings Worldport"
   path: "Components/Warps/worldport7"
+  destination { x: -16 y: 0 z: 41.5 }
+  rotation: 0
 }
@@ -15,5 +15,8 @@ panels {
 }
 ports {
   name: "BEGIN"
+  display_name: "Lone Chance Worldport"
   path: "Components/Warps/worldport8"
+  destination { x: -16 y: 0 z: 27.5 }
+  rotation: 180
 }
@@ -27,9 +27,15 @@ panels {
 }
 ports {
   name: "BEGIN"
+  display_name: "Third Fourth Worldport"
   path: "Components/Warps/worldport3"
+  destination { x: -38 y: 0 z: 14.5 }
+  rotation: 0
 }
 ports {
   name: "NEXT"
+  display_name: "Silver Portal Worldport"
   path: "Components/Warps/worldport4"
+  destination { x: -38 y: 0 z: 0.5 }
+  rotation: 180
 }
@@ -97,5 +97,8 @@ panels {
 }
 ports {
   name: "GREAT"
+  display_name: "Entrance"
   path: "Components/Warps/worldport"
+  destination { x: -0 y: 0 z: 13 }
+  rotation: 0
 }
@@ -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"
 }
@@ -1,5 +1,8 @@
 name: "Bearer Entrance"
 ports {
   name: "BEARER"
+  display_name: "Brown Control Center Hallway"
   path: "Components/Warps/worldport"
+  destination { x: -15.5 y: 0 z: 20 }
+  rotation: 270
 }
@@ -211,19 +211,33 @@ panels {
 }
 ports {
   name: "UNKEMPT"
+  display_name: "SW Worldport"
   path: "Components/Warps/worldport4"
+  destination { x: -21 y: 0 z: 7 }
+  rotation: 0
+  # enterable from either side
 }
 ports {
   name: "DIGITAL"
+  display_name: "NW Worldport"
   path: "Components/Warps/worldport5"
+  destination { x: -21 y: 0 z: -7 }
+  rotation: 180
+  # enterable from either side
 }
 ports {
   name: "GREAT"
+  display_name: "E Worldport"
   path: "Components/Warps/worldport2"
+  destination { x: 21 y: 0 z: -4 }
+  rotation: 180
 }
 ports {
   name: "DAEDALUS"
+  display_name: "NE Worldport"
   path: "Components/Warps/worldport3"
+  destination { x: 15.5 y: 0 z: -19 }
+  rotation: 90
 }
 paintings {
   name: "SEA"
@@ -0,0 +1,60 @@
+connections {
+  from_room: "Main Area"
+  to_room: "Right Area"
+  door { name: "East Door" }
+}
+connections {
+  from_room: "Middle Room"
+  to_room: "Unsymmetry Room"
+  door { name: "W2 Room Door" }
+}
+connections {
+  from_room: "Main Area"
+  to_room: "Middle Room"
+  door { name: "Cyan Doors" }
+}
+connections {
+  from_room: "Main Area"
+  to_room: "Exit Room 2"
+  door { name: "Exit Door 1" }
+}
+connections {
+  from_room: "Exit Room 2"
+  to_room: "Exit Room 3"
+  door { name: "Exit Door 2" }
+}
+connections {
+  from_room: "Main Area"
+  to_room: "Control Center Entrance"
+  door { name: "I Entered" }
+}
+connections {
+  from_room: "Main Area"
+  to_room: "Control Center Entrance"
+  door { name: "Control Center Entrance" }
+}
+connections {
+  from_room: "Right Area"
+  to_room: "V1 Room"
+  door { name: "V1 Door" }
+}
+connections {
+  from_room: "Right Area"
+  to_room: "Daedalus Entrance"
+  door { name: "Control Center Orange Door" }
+}
+connections {
+  from_room: "Unsymmetry Room"
+  to_room: "W2 Room"
+  door { name: "W2 Door" }
+}
+connections {
+  from_room: "Unsymmetry Room"
+  to_room: "V Keyholder"
+  door { name: "V Keyholder" }
+}
+connections {
+  from_room: "Unsymmetry Room"
+  to_room: "W Keyholder"
+  door { name: "W Keyholder" }
+}
@@ -0,0 +1,184 @@
+doors {
+  name: "East Door"
+  type: STANDARD
+  receivers: "Components/Doors/entry_2"
+  panels { room: "Main Area" name: "EYE" }
+  panels { room: "Main Area" name: "SIGHT" }
+  panels { room: "Main Area" name: "SHY" }
+  panels { room: "Main Area" name: "QUITE" }
+  location_room: "Main Area"
+}
+doors {
+  name: "W2 Room Door"
+  type: STANDARD
+  receivers: "Components/Doors/entry_1"
+  panels { room: "Middle Room" name: "RIDDLE" }
+  panels { room: "Middle Room" name: "FELLOW" }
+  panels { room: "Middle Room" name: "YELLOW" }
+  panels { room: "Middle Room" name: "FIDDLE" }
+  location_room: "Middle Room"
+}
+doors {
+  name: "Cyan Doors"
+  type: EVENT
+  receivers: "Components/Doors/entry_12"
+  double_letters: true
+}
+doors {
+  name: "Sun Temple Entrance"
+  type: EVENT
+  panels { room: "Exit Room 3" name: "ENTER" }
+}
+doors {
+  name: "Exit Door 1"
+  type: EVENT
+  panels { room: "Main Area" name: "PHASE" }
+  panels { room: "Main Area" name: "SCALE" }
+  panels { room: "Main Area" name: "WAYS" }
+  panels { room: "Main Area" name: "TRAIL" }
+}
+doors {
+  name: "Exit Door 2"
+  type: EVENT
+  panels { room: "Exit Room 2" name: "FOUR" }
+  panels { room: "Exit Room 2" name: "MINE" }
+  panels { room: "Exit Room 2" name: "DOOR" }
+  panels { room: "Exit Room 2" name: "WINE" }
+}
+doors {
+  name: "I Entered"
+  type: EVENT
+  keyholders { room: "Main Area" name: "I" key: "i" }
+}
+doors {
+  name: "Control Center Entrance"
+  type: EVENT
+  panels { room: "Control Center Entrance" name: "RETURN" }
+}
+doors {
+  name: "V1 Door"
+  type: EVENT
+  panels { room: "Right Area" name: "QUIET" }
+  panels { room: "Right Area" name: "DIET" }
+  panels { room: "Right Area" name: "FOURTH" }
+  panels { room: "Right Area" name: "FORTH" }
+}
+doors {
+  name: "Control Center Orange Door"
+  type: CONTROL_CENTER_COLOR
+  receivers: "Components/Doors/entry_6"
+  receivers: "Components/Doors/entry_13"
+  receivers: "Panels/Assorted/panel_1/teleportListener"
+  control_center_color: "orange"
+  double_letters: true
+}
+doors {
+  name: "W2 Door"
+  type: EVENT
+  panels { room: "Unsymmetry Room" name: "UNINTERESTED" }
+  panels { room: "Unsymmetry Room" name: "IMPARTIAL" }
+  panels { room: "Unsymmetry Room" name: "ENTERTAIN" }
+  panels { room: "Unsymmetry Room" name: "CONFUSE" }
+  panels { room: "Unsymmetry Room" name: "UNLUCKY" }
+  panels { room: "Unsymmetry Room" name: "UNEXPECTED" }
+  panels { room: "Unsymmetry Room" name: "UNIRONIC" }
+  panels { room: "Unsymmetry Room" name: "ACCIDENTAL" }
+  panels { room: "Unsymmetry Room" name: "COMPLETE" }
+  panels { room: "Unsymmetry Room" name: "ENROLL" }
+  panels { room: "Unsymmetry Room" name: "ACCEPT" }
+  panels { room: "Unsymmetry Room" name: "DISPROVE" }
+  panels { room: "Unsymmetry Room" name: "SCRUTINIZE (Purple)" }
+  panels { room: "Unsymmetry Room" name: "SCRUTINIZE (Cyan)" }
+}
+doors {
+  name: "V Keyholder"
+  type: EVENT
+  panels { room: "Unsymmetry Room" name: "UNINTERESTED" }
+  panels { room: "Unsymmetry Room" name: "IMPARTIAL" }
+  panels { room: "Unsymmetry Room" name: "ENTERTAIN" }
+  panels { room: "Unsymmetry Room" name: "CONFUSE" }
+  panels { room: "Unsymmetry Room" name: "UNLUCKY" }
+  panels { room: "Unsymmetry Room" name: "UNEXPECTED" }
+  panels { room: "Unsymmetry Room" name: "UNIRONIC" }
+  panels { room: "Unsymmetry Room" name: "ACCIDENTAL" }
+  panels { room: "Unsymmetry Room" name: "COMPLETE" }
+  panels { room: "Unsymmetry Room" name: "ENROLL" }
+  panels { room: "Unsymmetry Room" name: "ACCEPT" }
+  panels { room: "Unsymmetry Room" name: "DISPROVE" }
+  panels { room: "Unsymmetry Room" name: "SCRUTINIZE (Purple)" }
+  panels { room: "Unsymmetry Room" name: "SCRUTINIZE (Cyan)" }
+}
+doors {
+  name: "W Keyholder"
+  type: EVENT
+  panels { room: "Unsymmetry Room" name: "UNINTERESTED" }
+  panels { room: "Unsymmetry Room" name: "IMPARTIAL" }
+  panels { room: "Unsymmetry Room" name: "ENTERTAIN" }
+  panels { room: "Unsymmetry Room" name: "CONFUSE" }
+  panels { room: "Unsymmetry Room" name: "UNLUCKY" }
+  panels { room: "Unsymmetry Room" name: "UNEXPECTED" }
+  panels { room: "Unsymmetry Room" name: "UNIRONIC" }
+  panels { room: "Unsymmetry Room" name: "ACCIDENTAL" }
+  panels { room: "Unsymmetry Room" name: "COMPLETE" }
+  panels { room: "Unsymmetry Room" name: "ENROLL" }
+  panels { room: "Unsymmetry Room" name: "ACCEPT" }
+  panels { room: "Unsymmetry Room" name: "DISPROVE" }
+  panels { room: "Unsymmetry Room" name: "SCRUTINIZE (Purple)" }
+  panels { room: "Unsymmetry Room" name: "SCRUTINIZE (Cyan)" }
+}
+doors {
+  name: "Let Untrue Tie"
+  type: LOCATION_ONLY
+  panels { room: "Main Area" name: "COUP" }
+  panels { room: "Main Area" name: "FLEW" }
+  panels { room: "Main Area" name: "GUILE" }
+  panels { room: "Main Area" name: "WHILE" }
+  panels { room: "Main Area" name: "AISLE" }
+  panels { room: "Main Area" name: "ZOO" }
+  panels { room: "Main Area" name: "SOON" }
+  panels { room: "Main Area" name: "NOON" }
+  panels { room: "Main Area" name: "MOON" }
+  location_room: "Main Area"
+}
+doors {
+  name: "Routine Out Chute"
+  type: LOCATION_ONLY
+  panels { room: "Main Area" name: "SUCH" }
+  panels { room: "Main Area" name: "MOONLIGHT" }
+  panels { room: "Main Area" name: "CRUTCH" }
+  panels { room: "Main Area" name: "CONTRITE" }
+  panels { room: "Main Area" name: "ROUTER" }
+  panels { room: "Main Area" name: "TONIGHT" }
+  panels { room: "Main Area" name: "STOUTER" }
+  panels { room: "Main Area" name: "DOUBTER" }
+  panels { room: "Main Area" name: "MUCH" }
+  location_room: "Main Area"
+}
+doors {
+  name: "Honor Our Hint"
+  type: LOCATION_ONLY
+  panels { room: "Right Area" name: "TOWER" }
+  panels { room: "Right Area" name: "WARN" }
+  panels { room: "Right Area" name: "OUTDO" }
+  panels { room: "Right Area" name: "TATTOO" }
+  panels { room: "Right Area" name: "SOUR" }
+  panels { room: "Right Area" name: "UNTRUE" }
+  panels { room: "Right Area" name: "FLOWER" }
+  panels { room: "Right Area" name: "MOURN" }
+  panels { room: "Right Area" name: "CORN" }
+  location_room: "Right Area"
+}
+doors {
+  name: "Cog Rhino Hug Rug"
+  type: LOCATION_ONLY
+  panels { room: "Right Area" name: "SCUFF" }
+  panels { room: "Right Area" name: "WIN" }
+  panels { room: "Right Area" name: "BLUFF" }
+  panels { room: "Right Area" name: "INN" }
+  panels { room: "Right Area" name: "OFF" }
+  panels { room: "Right Area" name: "TROUGH" }
+  panels { room: "Right Area" name: "BEEN" }
+  panels { room: "Right Area" name: "SCOFF" }
+  panels { room: "Right Area" name: "TOUGH" }
+  location_room: "Right Area"
+}
@@ -0,0 +1 @@
+display_name: "The Unkempt"
@@ -0,0 +1,17 @@
+name: "Control Center Entrance"
+panels {
+  name: "RETURN"
+  path: "Panels/Entry/panel_1"
+  clue: "return"
+  answer: "turn"
+  symbols: SPARKLES
+}
+ports {
+  name: "CC"
+  display_name: "Control Center Connector"
+  path: "Components/Warps/worldport2"
+  destination { x: -4.5 y: 0 z: 7 }
+  rotation: 0
+  # TODO: shuffle entrances with dependent keyholders
+  no_shuffle: true
+}
@@ -0,0 +1,8 @@
+name: "Daedalus Entrance"
+ports {
+  name: "DAEDALUS"
+  display_name: "Orange Hallway"
+  path: "Components/Warps/worldport4"
+  destination { x: 33 y: 0 z: -10 }
+  rotation: 90
+}
@@ -0,0 +1,29 @@
+name: "Exit Room 2"
+panels {
+  name: "FOUR"
+  path: "Panels/Room 9/panel_5"
+  clue: "four"
+  answer: "more"
+  symbols: ZERO
+}
+panels {
+  name: "MINE"
+  path: "Panels/Room 9/panel_6"
+  clue: "mine"
+  answer: "vine"
+  symbols: ZERO
+}
+panels {
+  name: "DOOR"
+  path: "Panels/Room 9/panel_7"
+  clue: "door"
+  answer: "more"
+  symbols: ZERO
+}
+panels {
+  name: "WINE"
+  path: "Panels/Room 9/panel_8"
+  clue: "wine"
+  answer: "vine"
+  symbols: ZERO
+}
@@ -0,0 +1,8 @@
+name: "Exit Room 3"
+panels {
+  name: "ENTER"
+  path: "Panels/Room 9/panel_9"
+  clue: "enter"
+  answer: "exit"
+  symbols: SUN
+}
@@ -0,0 +1,238 @@
+name: "Main Area"
+panels {
+  name: "I"
+  path: "Panels/Room 1/panel_1"
+  clue: "i"
+  answer: "hi"
+  symbols: ZERO
+}
+panels {
+  name: "SPY"
+  path: "Panels/Room 1/panel_2"
+  clue: "spy"
+  answer: "hi"
+  symbols: ZERO
+}
+panels {
+  name: "THEFT"
+  path: "Panels/Room 1/panel_3"
+  clue: "theft"
+  answer: "left"
+  symbols: ZERO
+}
+panels {
+  name: "HEFT"
+  path: "Panels/Room 1/panel_4"
+  clue: "heft"
+  answer: "left"
+  symbols: ZERO
+}
+panels {
+  name: "EYE"
+  path: "Panels/Room 2/panel_1"
+  clue: "eye"
+  answer: "hi"
+  symbols: ZERO
+}
+panels {
+  name: "SIGHT"
+  path: "Panels/Room 2/panel_2"
+  clue: "sight"
+  answer: "right"
+  symbols: ZERO
+}
+panels {
+  name: "SHY"
+  path: "Panels/Room 2/panel_3"
+  clue: "shy"
+  answer: "hi"
+  symbols: ZERO
+}
+panels {
+  name: "QUITE"
+  path: "Panels/Room 2/panel_4"
+  clue: "quite"
+  answer: "right"
+  symbols: ZERO
+}
+panels {
+  name: "SUCH"
+  path: "Panels/Room 6/panel_1"
+  clue: "such"
+  answer: "touch"
+  symbols: ZERO
+}
+panels {
+  name: "MOONLIGHT"
+  path: "Panels/Room 6/panel_2"
+  clue: "moonlight"
+  answer: "unite"
+  symbols: ZERO
+}
+panels {
+  name: "CRUTCH"
+  path: "Panels/Room 6/panel_3"
+  clue: "crutch"
+  answer: "touch"
+  symbols: ZERO
+}
+panels {
+  name: "CONTRITE"
+  path: "Panels/Room 6/panel_4"
+  clue: "contrite"
+  answer: "unite"
+  symbols: ZERO
+}
+panels {
+  name: "ROUTER"
+  path: "Panels/Room 6/panel_5"
+  clue: "router"
+  answer: "outer"
+  symbols: ZERO
+}
+panels {
+  name: "TONIGHT"
+  path: "Panels/Room 6/panel_6"
+  clue: "tonight"
+  answer: "unite"
+  symbols: ZERO
+}
+panels {
+  name: "STOUTER"
+  path: "Panels/Room 6/panel_7"
+  clue: "stouter"
+  answer: "outer"
+  symbols: ZERO
+}
+panels {
+  name: "DOUBTER"
+  path: "Panels/Room 6/panel_8"
+  clue: "doubter"
+  answer: "outer"
+  symbols: ZERO
+}
+panels {
+  name: "MUCH"
+  path: "Panels/Room 6/panel_9"
+  clue: "much"
+  answer: "touch"
+  symbols: ZERO
+}
+panels {
+  name: "COUP"
+  path: "Panels/Room 7/panel_1"
+  clue: "coup"
+  answer: "true"
+  symbols: ZERO
+}
+panels {
+  name: "FLEW"
+  path: "Panels/Room 7/panel_2"
+  clue: "flew"
+  answer: "true"
+  symbols: ZERO
+}
+panels {
+  name: "GUILE"
+  path: "Panels/Room 7/panel_3"
+  clue: "guile"
+  answer: "tile"
+  symbols: ZERO
+}
+panels {
+  name: "WHILE"
+  path: "Panels/Room 7/panel_4"
+  clue: "while"
+  answer: "tile"
+  symbols: ZERO
+}
+panels {
+  name: "AISLE"
+  path: "Panels/Room 7/panel_5"
+  clue: "aisle"
+  answer: "tile"
+  symbols: ZERO
+}
+panels {
+  name: "ZOO"
+  path: "Panels/Room 7/panel_6"
+  clue: "zoo"
+  answer: "true"
+  symbols: ZERO
+}
+panels {
+  name: "SOON"
+  path: "Panels/Room 7/panel_7"
+  clue: "soon"
+  answer: "tune"
+  symbols: ZERO
+}
+panels {
+  name: "NOON"
+  path: "Panels/Room 7/panel_8"
+  clue: "noon"
+  answer: "tune"
+  symbols: ZERO
+}
+panels {
+  name: "MOON"
+  path: "Panels/Room 7/panel_9"
+  clue: "moon"
+  answer: "tune"
+  symbols: ZERO
+}
+panels {
+  name: "PHASE"
+  path: "Panels/Room 9/panel_1"
+  clue: "phase"
+  answer: "maze"
+  symbols: ZERO
+}
+panels {
+  name: "SCALE"
+  path: "Panels/Room 9/panel_2"
+  clue: "scale"
+  answer: "jail"
+  symbols: ZERO
+}
+panels {
+  name: "WAYS"
+  path: "Panels/Room 9/panel_3"
+  clue: "ways"
+  answer: "maze"
+  symbols: ZERO
+}
+panels {
+  name: "TRAIL"
+  path: "Panels/Room 9/panel_4"
+  clue: "trail"
+  answer: "jail"
+  symbols: ZERO
+}
+keyholders {
+  name: "I"
+  path: "Components/KeyHolders/keyHolderL"
+  key: "i"
+}
+ports {
+  name: "GREAT"
+  display_name: "Main Entrance"
+  path: "Components/Warps/worldport"
+  destination { x: -3 y: 0 z: 11 }
+  rotation: 270
+}
+ports {
+  name: "TREE"
+  display_name: "Brown Hallway"
+  path: "Components/Warps/worldport5"
+  destination { x: -34 y: 0 z: 7 }
+  rotation: 270
+}
+ports {
+  name: "SUNTEMPLE"
+  display_name: "Sun Temple Entrance"
+  path: "Components/Warps/worldport3"
+  destination { x: -42 y: 0 z: -2 }
+  rotation: 270
+  required_door { name: "Sun Temple Entrance" }
+}
@@ -0,0 +1,29 @@
+name: "Middle Room"
+panels {
+  name: "RIDDLE"
+  path: "Panels/Room 5/panel_1"
+  clue: "riddle"
+  answer: "middle"
+  symbols: ZERO
+}
+panels {
+  name: "FELLOW"
+  path: "Panels/Room 5/panel_2"
+  clue: "fellow"
+  answer: "hello"
+  symbols: ZERO
+}
+panels {
+  name: "YELLOW"
+  path: "Panels/Room 5/panel_3"
+  clue: "yellow"
+  answer: "hello"
+  symbols: ZERO
+}
+panels {
+  name: "FIDDLE"
+  path: "Panels/Room 5/panel_4"
+  clue: "fiddle"
+  answer: "middle"
+  symbols: ZERO
+}
@@ -0,0 +1,163 @@
+name: "Right Area"
+panels {
+  name: "TOWER"
+  path: "Panels/Room 3/panel_1"
+  clue: "tower"
+  answer: "hour"
+  symbols: ZERO
+}
+panels {
+  name: "WARN"
+  path: "Panels/Room 3/panel_2"
+  clue: "warn"
+  answer: "horn"
+  symbols: ZERO
+}
+panels {
+  name: "OUTDO"
+  path: "Panels/Room 3/panel_3"
+  clue: "outdo"
+  answer: "into"
+  symbols: ZERO
+}
+panels {
+  name: "TATTOO"
+  path: "Panels/Room 3/panel_4"
+  clue: "tattoo"
+  answer: "into"
+  symbols: ZERO
+}
+panels {
+  name: "SOUR"
+  path: "Panels/Room 3/panel_5"
+  clue: "sour"
+  answer: "hour"
+  symbols: ZERO
+}
+panels {
+  name: "UNTRUE"
+  path: "Panels/Room 3/panel_6"
+  clue: "untrue"
+  answer: "into"
+  symbols: ZERO
+}
+panels {
+  name: "FLOWER"
+  path: "Panels/Room 3/panel_7"
+  clue: "flower"
+  answer: "hour"
+  symbols: ZERO
+}
+panels {
+  name: "MOURN"
+  path: "Panels/Room 3/panel_8"
+  clue: "mourn"
+  answer: "horn"
+  symbols: ZERO
+}
+panels {
+  name: "CORN"
+  path: "Panels/Room 3/panel_9"
+  clue: "corn"
+  answer: "horn"
+  symbols: ZERO
+}
+panels {
+  name: "SCUFF"
+  path: "Panels/Room 4/panel_1"
+  clue: "scuff"
+  answer: "rough"
+  symbols: ZERO
+}
+panels {
+  name: "WIN"
+  path: "Panels/Room 4/panel_2"
+  clue: "win"
+  answer: "grin"
+  symbols: ZERO
+}
+panels {
+  name: "BLUFF"
+  path: "Panels/Room 4/panel_3"
+  clue: "bluff"
+  answer: "rough"
+  symbols: ZERO
+}
+panels {
+  name: "INN"
+  path: "Panels/Room 4/panel_4"
+  clue: "inn"
+  answer: "grin"
+  symbols: ZERO
+}
+panels {
+  name: "OFF"
+  path: "Panels/Room 4/panel_5"
+  clue: "off"
+  answer: "cough"
+  symbols: ZERO
+}
+panels {
+  name: "TROUGH"
+  path: "Panels/Room 4/panel_6"
+  clue: "trough"
+  answer: "cough"
+  symbols: ZERO
+}
+panels {
+  name: "BEEN"
+  path: "Panels/Room 4/panel_7"
+  clue: "been"
+  answer: "grin"
+  symbols: ZERO
+}
+panels {
+  name: "SCOFF"
+  path: "Panels/Room 4/panel_8"
+  clue: "scoff"
+  answer: "cough"
+  symbols: ZERO
+}
+panels {
+  name: "TOUGH"
+  path: "Panels/Room 4/panel_9"
+  clue: "tough"
+  answer: "rough"
+  symbols: ZERO
+}
+panels {
+  name: "FORTH"
+  path: "Panels/Room 8/panel_1"
+  clue: "forth"
+  answer: "north"
+  symbols: ZERO
+}
+panels {
+  name: "QUIET"
+  path: "Panels/Room 8/panel_2"
+  clue: "quiet"
+  answer: "riot"
+  symbols: ZERO
+}
+panels {
+  name: "DIET"
+  path: "Panels/Room 8/panel_3"
+  clue: "diet"
+  answer: "riot"
+  symbols: ZERO
+}
+panels {
+  name: "FOURTH"
+  path: "Panels/Room 8/panel_4"
+  clue: "fourth"
+  answer: "north"
+  symbols: ZERO
+}
+panels {
+  name: "COLOR"
+  path: "Panels/Assorted/panel_1"
+  clue: "color"
+  answer: "orange"
+  symbols: EXAMPLE
+  required_door { name: "Control Center Orange Door" }
+}
@@ -0,0 +1,99 @@
+name: "Unsymmetry Room"
+panels {
+  name: "UNINTERESTED"
+  path: "Panels/Unsymmetry Room/panel_a_1"
+  clue: "uninterested"
+  answer: "interested"
+  symbols: SUN
+}
+panels {
+  name: "IMPARTIAL"
+  path: "Panels/Unsymmetry Room/panel_b_1"
+  clue: "impartial"
+  answer: "disinterested"
+  symbols: SUN
+}
+panels {
+  name: "ENTERTAIN"
+  path: "Panels/Unsymmetry Room/panel_a_2"
+  clue: "entertain"
+  answer: "amuse"
+  symbols: SUN
+}
+panels {
+  name: "CONFUSE"
+  path: "Panels/Unsymmetry Room/panel_b_2"
+  clue: "confuse"
+  answer: "bemuse"
+  symbols: SUN
+}
+panels {
+  name: "UNLUCKY"
+  path: "Panels/Unsymmetry Room/panel_a_3"
+  clue: "unlucky"
+  answer: "lucky"
+  symbols: SUN
+}
+panels {
+  name: "UNEXPECTED"
+  path: "Panels/Unsymmetry Room/panel_b_3"
+  clue: "unexpected"
+  answer: "fortuitous"
+  symbols: SUN
+}
+panels {
+  name: "UNIRONIC"
+  path: "Panels/Unsymmetry Room/panel_a_4"
+  clue: "unironic"
+  answer: "ironic"
+  symbols: SUN
+}
+panels {
+  name: "ACCIDENTAL"
+  path: "Panels/Unsymmetry Room/panel_b_4"
+  clue: "accidental"
+  answer: "coincidental"
+  symbols: SUN
+}
+panels {
+  name: "COMPLETE"
+  path: "Panels/Unsymmetry Room/panel_a_5"
+  clue: "complete"
+  answer: "graduate"
+  symbols: SUN
+}
+panels {
+  name: "ENROLL"
+  path: "Panels/Unsymmetry Room/panel_b_5"
+  clue: "enroll"
+  answer: "matriculate"
+  symbols: SUN
+}
+panels {
+  name: "ACCEPT"
+  path: "Panels/Unsymmetry Room/panel_a_6"
+  clue: "accept"
+  answer: "deny"
+  symbols: SUN
+}
+panels {
+  name: "DISPROVE"
+  path: "Panels/Unsymmetry Room/panel_b_6"
+  clue: "disprove"
+  answer: "refute"
+  symbols: SUN
+}
+panels {
+  name: "SCRUTINIZE (Purple)"
+  path: "Panels/Unsymmetry Room/panel_a_7"
+  clue: "scrutinize"
+  answer: "skim"
+  symbols: SUN
+}
+panels {
+  name: "SCRUTINIZE (Cyan)"
+  path: "Panels/Unsymmetry Room/panel_b_7"
+  clue: "scrutinize"
+  answer: "peruse"
+  symbols: SUN
+}
@@ -0,0 +1,6 @@
+name: "V Keyholder"
+keyholders {
+  name: "V"
+  path: "Components/KeyHolders/keyHolderV"
+  key: "v"
+}
@@ -0,0 +1,5 @@
+name: "V1 Room"
+letters {
+  key: "v"
+  path: "Components/Collectables/v"
+}
@@ -0,0 +1,6 @@
+name: "W Keyholder"
+keyholders {
+  name: "W"
+  path: "Components/KeyHolders/keyHolderW"
+  key: "w"
+}
@@ -0,0 +1,6 @@
+name: "W2 Room"
+letters {
+  key: "w"
+  level2: true
+  path: "Components/Collectables/w2"
+}
@@ -183,6 +183,21 @@ doors {
   panels { room: "Central Connected Area" name: "CHIN" }
   panels { room: "Central Connected Area" name: "DING" }
   location_room: "Central Connected Area"
+  location_name: "East Room 2"
+}
+doors {
+  name: "East Room 1"
+  type: LOCATION_ONLY
+  panels { room: "East Room 1" name: "CHIN" }
+  panels { room: "East Room 1" name: "HEAT" }
+  panels { room: "East Room 1" name: "END" }
+  panels { room: "East Room 1" name: "FLY" }
+  panels { room: "East Room 1" name: "OUCH" }
+  panels { room: "East Room 1" name: "HAG" }
+  panels { room: "East Room 1" name: "TIN" }
+  panels { room: "East Room 1" name: "RID" }
+  panels { room: "East Room 1" name: "TUG" }
+  location_room: "East Room 1"
 }
 doors {
   name: "Orange Alcove"
@@ -199,6 +214,7 @@ doors {
 }
 doors {
   name: "Black Alcove"
+  type: EVENT
   panels { room: "Star Rooms" name: "TURN" }
   panels { room: "Central Connected Area" name: "HAD" }
   panels { room: "Central Connected Area" name: "SOW" }
@@ -218,6 +234,7 @@ doors {
   panels { room: "Northeast Room 1" name: "CAR" }
   panels { room: "Northeast Room 1" name: "SIR" }
   location_room: "Northeast Room 1"
+  location_name: "Northeast Room 1"
 }
 doors {
   name: "Northeast Corner Behind"
@@ -245,6 +262,7 @@ doors {
   panels { room: "Northwest Room" name: "HER" }
   panels { room: "Northwest Room" name: "DAM" }
   location_room: "Northwest Room"
+  location_name: "Northwest Room"
 }
 doors {
   name: "Cyan Alcove"
@@ -274,6 +292,7 @@ doors {
   panels { room: "Southwest Room 3" name: "HOST" }
   panels { room: "Southwest Room 3" name: "MUG" }
   location_room: "Southwest Room 3"
+  location_name: "Southwest Room 3"
 }
 doors {
   name: "Southwest Room 2 Entrance"
@@ -293,6 +312,7 @@ doors {
   panels { room: "Southwest Room 2" name: "ION" }
   panels { room: "Southwest Room 2" name: "INN" }
   location_room: "Southwest Room 2"
+  location_name: "Southwest Room 2"
 }
 doors {
   name: "Southwest 4"
@@ -411,6 +431,7 @@ doors {
   panels { room: "Central Connected Area" name: "SON (1)" }
   panels { room: "Central Connected Area" name: "URGE" }
   location_room: "Central Connected Area"
+  location_name: "Northeast Room 2"
 }
 doors {
   name: "South Right Painting"
@@ -478,5 +499,8 @@ doors {
 doors {
   name: "Cyan Doors"
   type: EVENT
-  switches: "double_letters"
+  receivers: "Components/Doors/entry_4"
+  receivers: "Panels/Miscellaneous/entry_2/teleportListener"
+  receivers: "Panels/Miscellaneous/entry_3/teleportListener"
+  double_letters: true
 }
@@ -1,5 +1,8 @@
 name: "Bearer Entrance"
 ports {
   name: "BEARER"
+  display_name: "East of Yellow Worldport"
   path: "Components/Warps/worldport4"
+  destination { x: 23 y: 0 z: -29 }
+  rotation: 90
 }
@@ -8,5 +8,8 @@ panels {
 }
 ports {
   name: "DIGITAL"
+  display_name: "South of Yellow Worldport"
   path: "Components/Warps/worldport"
+  destination { x: 0 y: 0 z: 0 }
+  rotation: 0
 }
@@ -1,5 +1,8 @@
 name: "Nuanced Entrance"
 ports {
   name: "NUANCED"
+  display_name: "West of Yellow Worldport"
   path: "Components/Warps/worldport3"
+  destination { x: -23 y: 0 z: -29 }
+  rotation: 270
 }
@@ -15,5 +15,8 @@ panels {
 }
 ports {
   name: "PLAZA"
+  display_name: "Dark Hallway"
   path: "Components/Warps/worldport5"
+  destination { x: 35 y: 0 z: 44 }
+  rotation: 270
 }
@@ -5,4 +5,5 @@ panels {
   clue: "sickness"
   answer: "health"
   symbols: SUN
+  required_door { name: "Cyan Doors" }
 }
@@ -5,4 +5,5 @@ panels {
   clue: "health"
   answer: "sickness"
   symbols: SUN
+  required_door { name: "Cyan Doors" }
 }
@@ -0,0 +1,10 @@
+connections {
+  from_room: "Entry"
+  to_room: "Puzzles"
+  door { name: "Front Door" }
+}
+connections {
+  from_room: "Puzzles"
+  to_room: "Mastery"
+  door { name: "Mastery" }
+}
@@ -0,0 +1,36 @@
+doors {
+  name: "Front Door"
+  type: STANDARD
+  receivers: "Components/Doors/entry_2"
+  panels { room: "Entry" name: "INK" }
+  location_room: "Entry"
+}
+doors {
+  name: "Seasons"
+  type: EVENT
+  panels { room: "Puzzles" name: "ERAS" answer: "seasons" }
+}
+doors {
+  name: "Mastery"
+  type: EVENT
+  panels { room: "Puzzles" name: "STORY" }
+  panels { room: "Puzzles" name: "VENTURE" }
+  panels { room: "Puzzles" name: "PASSED" }
+  panels { room: "Puzzles" name: "SLUMBERING" }
+  panels { room: "Puzzles" name: "RHYME" }
+  panels { room: "Puzzles" name: "OBSCURE" }
+  panels { room: "Puzzles" name: "PROPHET" }
+  panels { room: "Puzzles" name: "ERAS" }
+  panels { room: "Puzzles" name: "DARKNESS" }
+  panels { room: "Puzzles" name: "PRINCE" }
+  panels { room: "Puzzles" name: "BATH" }
+  panels { room: "Puzzles" name: "CHAOTIC" }
+  panels { room: "Puzzles" name: "EYES" }
+  panels { room: "Puzzles" name: "QUEENDOOM" }
+  panels { room: "Puzzles" name: "SHOUTS" }
+  panels { room: "Puzzles" name: "INTELLIGENCE" }
+  panels { room: "Puzzles" name: "EARTHWAR" }
+  panels { room: "Puzzles" name: "SLEEPER" }
+  panels { room: "Puzzles" name: "BOTTLE" }
+  panels { room: "Puzzles" name: "WORDS" }
+}
@@ -0,0 +1,3 @@
+display_name: "The Wise"
+# This port is out of bounds.
+excluded_nodes: "Components/Warps/worldport"
@@ -0,0 +1,12 @@
+name: "Entry"
+panels {
+  name: "INK"
+  path: "Panels/Entry/entry_1"
+  clue: "ink"
+  answer: "link"
+  symbols: SPARKLES
+}
+paintings {
+  name: "TRIANGLE"
+  path: "Components/Paintings/triangle"
+}
@@ -0,0 +1,5 @@
+name: "Mastery"
+masteries {
+  name: "MASTERY"
+  path: "Components/Collectables/smiley"
+}
@@ -0,0 +1,151 @@
+name: "Puzzles"
+panels {
+  name: "STORY"
+  path: "Panels/Room_1/panel_1"
+  clue: "story"
+  answer: "legend"
+  symbols: SUN
+  required_door { name: "Seasons" }
+}
+panels {
+  name: "VENTURE"
+  path: "Panels/Room_1/panel_2"
+  clue: "venture"
+  answer: "adventure"
+  symbols: SPARKLES
+  required_door { name: "Seasons" }
+}
+panels {
+  name: "PASSED"
+  path: "Panels/Room_1/panel_3"
+  clue: "passed"
+  answer: "past"
+  symbols: ZERO
+}
+panels {
+  name: "SLUMBERING"
+  path: "Panels/Room_1/panel_4"
+  clue: "slumbering"
+  answer: "awakening"
+  symbols: SUN
+  required_door { name: "Seasons" }
+}
+panels {
+  name: "RHYME"
+  path: "Panels/Room_1/panel_5"
+  clue: "rhyme"
+  answer: "time"
+  symbols: ZERO
+}
+panels {
+  name: "OBSCURE"
+  path: "Panels/Room_1/panel_6"
+  clue: "obscure"
+  answer: "mask"
+  symbols: PYRAMID
+}
+panels {
+  name: "PROPHET"
+  path: "Panels/Room_1/panel_7"
+  clue: "prophet"
+  answer: "oracle"
+  symbols: SUN
+}
+panels {
+  name: "ERAS"
+  path: "Panels/Room_1/panel_8"
+  clue: "eras"
+  answer: "gsae"
+  symbols: SUN
+  proxies { answer: "ages" path: "Panels/Proxies/panel_8_proxy_1" }
+  proxies { answer: "seasons" path: "Panels/Proxies/panel_8_proxy_2" }
+}
+panels {
+  name: "DARKNESS"
+  path: "Panels/Room_1/panel_9"
+  clue: "darkness"
+  answer: "twilight"
+  symbols: PYRAMID
+  required_door { name: "Seasons" }
+}
+panels {
+  name: "PRINCE"
+  path: "Panels/Room_1/panel_10"
+  clue: "prince"
+  answer: "princess"
+  symbols: GENDER
+  required_door { name: "Seasons" }
+}
+panels {
+  name: "BATH"
+  path: "Panels/Room_1/panel_11"
+  clue: "bath"
+  answer: "breath"
+  symbols: SPARKLES
+}
+panels {
+  name: "CHAOTIC"
+  path: "Panels/Room_1/panel_12"
+  clue: "chaotic"
+  answer: "wild"
+  symbols: SUN
+}
+panels {
+  name: "EYES"
+  path: "Panels/Room_1/panel_13"
+  clue: "eyes"
+  answer: "tears"
+  symbols: STARS
+}
+panels {
+  name: "QUEENDOOM"
+  path: "Panels/Room_1/panel_14"
+  clue: "queendoom"
+  answer: "kingdom"
+  symbols: SUN
+  symbols: SPARKLES
+}
+panels {
+  name: "SHOUTS"
+  path: "Panels/Room_1/panel_15"
+  clue: "shouts"
+  answer: "echoes"
+  symbols: AGE
+  required_door { name: "Seasons" }
+}
+panels {
+  name: "INTELLIGENCE"
+  path: "Panels/Room_1/panel_16"
+  clue: "intelligence"
+  answer: "wisdom"
+  symbols: AGE
+}
+panels {
+  name: "EARTHWAR"
+  path: "Panels/Room_1/panel_17"
+  clue: "earthwar"
+  answer: "skyward"
+  symbols: SUN
+  symbols: SPARKLES
+}
+panels {
+  name: "SLEEPER"
+  path: "Panels/Room_1/panel_19"
+  clue: "sleeper"
+  answer: "waker"
+  symbols: SUN
+}
+panels {
+  name: "BOTTLE"
+  path: "Panels/Room_1/panel_20"
+  clue: "bottle"
+  answer: "cap"
+  symbols: BOXES
+}
+panels {
+  name: "WORDS"
+  path: "Panels/Room_1/panel_18"
+  clue: "words"
+  answer: "sword"
+  symbols: ANAGRAM
+}
@@ -0,0 +1,10 @@
+connections {
+  from_room: "Entry"
+  to_room: "Regular"
+  door { name: "Front Door" }
+}
+connections {
+  from_room: "Regular"
+  to_room: "Huge"
+  door { name: "Shrink Door" }
+}
@@ -0,0 +1,24 @@
+doors {
+  name: "Front Door"
+  type: EVENT
+  panels { room: "Entry" name: "WONDER" }
+}
+doors {
+  name: "Shrink Door"
+  type: STANDARD
+  receivers: "Components/Doors/wonderlandDoor2/animationListener2"
+  panels { room: "Regular" name: "SHRINK" }
+  location_room: "Regular"
+}
+doors {
+  name: "Big Door"
+  type: EVENT
+  panels { room: "Huge" name: "SHRINK" }
+  panels { room: "Huge" name: "IRE" }
+  panels { room: "Huge" name: "BRIE" }
+  panels { room: "Huge" name: "WICK" }
+  panels { room: "Huge" name: "BARK" }
+  panels { room: "Huge" name: "HARE" }
+  panels { room: "Huge" name: "CHIME" }
+  panels { room: "Huge" name: "LIBRARY" }
+}
@@ -0,0 +1 @@
+display_name: "The Wondrous"
@@ -0,0 +1,14 @@
+name: "Entry"
+panels {
+  name: "WONDER"
+  path: "Panels/panel_1"
+  clue: "wonder"
+  answer: "wonder"
+}
+ports {
+  name: "DAEDALUS"
+  display_name: "Entrance"
+  path: "Components/Warps/worldport"
+  destination { x: 18 y: 0 z: 41 }
+  rotation: 180
+}
@@ -0,0 +1,57 @@
+name: "Huge"
+panels {
+  name: "SHRINK"
+  path: "Panels/panel_3"
+  clue: "shrink"
+  answer: "shrink"
+  display_name: "SHRINK (2)"
+}
+panels {
+  name: "IRE"
+  path: "Panels/panel_4"
+  clue: "ire"
+  answer: "fire"
+  symbols: SPARKLES
+}
+panels {
+  name: "BRIE"
+  path: "Panels/panel_5"
+  clue: "brie"
+  answer: "three"
+  symbols: ZERO
+}
+panels {
+  name: "WICK"
+  path: "Panels/panel_6"
+  clue: "wick"
+  answer: "candle"
+  symbols: BOXES
+}
+panels {
+  name: "BARK"
+  path: "Panels/panel_7"
+  clue: "bark"
+  answer: "tree"
+  symbols: BOXES
+}
+panels {
+  name: "HARE"
+  path: "Panels/panel_8"
+  clue: "hare"
+  answer: "chair"
+  symbols: ZERO
+}
+panels {
+  name: "CHIME"
+  path: "Panels/panel_9"
+  clue: "chime"
+  answer: "chimney"
+  symbols: SPARKLES
+}
+panels {
+  name: "LIBRARY"
+  path: "Panels/panel_10"
+  clue: "library"
+  answer: "book"
+  symbols: BOXES
+}
@@ -0,0 +1,8 @@
+name: "Regular"
+panels {
+  name: "SHRINK"
+  path: "Panels/panel_2"
+  clue: "shrink"
+  answer: "shrink"
+  display_name: "SHRINK (1)"
+}
@@ -0,0 +1,5 @@
+connections {
+  from_room: "Main Area"
+  to_room: "Ending"
+  door { name: "Ending" }
+}
@@ -0,0 +1,12 @@
+doors {
+  name: "Ending"
+  type: EVENT
+  panels { room: "Main Area" name: "FRUIT" }
+  panels { room: "Main Area" name: "FLOWER" }
+  panels { room: "Main Area" name: "GEM" }
+  panels { room: "Main Area" name: "DAIRY" }
+  panels { room: "Main Area" name: "TREE" }
+  panels { room: "Main Area" name: "METAL" }
+  panels { room: "Main Area" name: "CLOTHES" }
+  panels { room: "Main Area" name: "SPICE" }
+}
@@ -0,0 +1,11 @@
+display_name: "The Words"
+# These are old proxies of the main room's panels that are not linked up
+# anymore.
+excluded_nodes: "Panels/Proxies/panel_3"
+excluded_nodes: "Panels/Proxies/panel_4"
+excluded_nodes: "Panels/Proxies/panel_6"
+excluded_nodes: "Panels/Proxies/panel_9"
+# These are all tantalyzingly hidden out of bounds. What's up with that?
+excluded_nodes: "Panels/Proxies/panel_backside_1"
+excluded_nodes: "Panels/Proxies/panel_backside_2"
+excluded_nodes: "Panels/Proxies/panel_backside_3"
@@ -0,0 +1,5 @@
+name: "Ending"
+endings {
+  name: "BLUE"
+  path: "Components/Endings/blue_ending"
+}
@@ -0,0 +1,64 @@
+name: "Main Area"
+panels {
+  name: "FRUIT"
+  path: "Panels/Room_1/panel_2"
+  clue: "fruit"
+  answer: "peach"
+  symbols: EXAMPLE
+}
+panels {
+  name: "FLOWER"
+  path: "Panels/Room_1/panel_3"
+  clue: "flower"
+  answer: "rose"
+  symbols: EXAMPLE
+}
+panels {
+  name: "GEM"
+  path: "Panels/Room_1/panel_4"
+  clue: "gem"
+  answer: "jade"
+  symbols: EXAMPLE
+}
+panels {
+  name: "DAIRY"
+  path: "Panels/Room_1/panel_5"
+  clue: "dairy"
+  answer: "cream"
+  symbols: EXAMPLE
+}
+panels {
+  name: "TREE"
+  path: "Panels/Room_1/panel_6"
+  clue: "tree"
+  answer: "walnut"
+  symbols: EXAMPLE
+}
+panels {
+  name: "METAL"
+  path: "Panels/Room_1/panel_7"
+  clue: "metal"
+  answer: "silver"
+  symbols: EXAMPLE
+}
+panels {
+  name: "CLOTHES"
+  path: "Panels/Room_1/panel_8"
+  clue: "clothes"
+  answer: "denim"
+  symbols: EXAMPLE
+}
+panels {
+  name: "SPICE"
+  path: "Panels/Room_1/panel_9"
+  clue: "spice"
+  answer: "sage"
+  symbols: EXAMPLE
+}
+ports {
+  name: "ENTRY"
+  display_name: "Worldport"
+  path: "Components/Warps/worldport"
+  destination { x: 0 y: 0 z: 9.5 }
+  rotation: 0
+}
@@ -0,0 +1,54 @@
+version {
+  major: 7
+  minor: 0
+  patch: 1
+}
+# Filler item.
+special_names: "A Job Well Done"
+# Symbol items.
+special_names: "Age Symbol"
+special_names: "Anagram Symbol"
+special_names: "Boxes Symbol"
+special_names: "Cross Symbol"
+special_names: "Eval Symbol"
+special_names: "Example Symbol"
+special_names: "Gender Symbol"
+special_names: "Job Symbol"
+special_names: "Lingo Symbol"
+special_names: "Null Symbol"
+special_names: "Planet Symbol"
+special_names: "Pyramid Symbol"
+special_names: "Question Symbol"
+special_names: "Sound Symbol"
+special_names: "Sparkles Symbol"
+special_names: "Stars Symbol"
+special_names: "Sun Symbol"
+special_names: "Sweet Symbol"
+special_names: "Zero Symbol"
+# Anti collectable traps
+special_names: "Anti A"
+special_names: "Anti B"
+special_names: "Anti C"
+special_names: "Anti D"
+special_names: "Anti E"
+special_names: "Anti F"
+special_names: "Anti G"
+special_names: "Anti H"
+special_names: "Anti I"
+special_names: "Anti J"
+special_names: "Anti K"
+special_names: "Anti L"
+special_names: "Anti M"
+special_names: "Anti N"
+special_names: "Anti O"
+special_names: "Anti P"
+special_names: "Anti Q"
+special_names: "Anti R"
+special_names: "Anti S"
+special_names: "Anti T"
+special_names: "Anti U"
+special_names: "Anti V"
+special_names: "Anti W"
+special_names: "Anti X"
+special_names: "Anti Y"
+special_names: "Anti Z"
@@ -0,0 +1,11 @@
+progressives {
+  name: "Progressive Gold Ending"
+  doors { map: "daedalus" name: "Red Rainbow Room" }
+  doors { map: "daedalus" name: "Orange Rainbow Room" }
+  doors { map: "daedalus" name: "Yellow Rainbow Room" }
+  doors { map: "daedalus" name: "Green Rainbow Room" }
+  doors { map: "daedalus" name: "Blue Rainbow Room" }
+  doors { map: "daedalus" name: "Purple Rainbow Room" }
+  doors { map: "daedalus" name: "Cyan Rainbow Room" }
+  doors { map: "daedalus" name: "Brown Rainbow Room" }
+}
@@ -27,6 +27,29 @@ enum DoorType {
 
   // This door is an item if gravestone shuffle is enabled, and is a location as long as panelsanity is not on.
   GRAVESTONE = 6;
+
+  // This door is never a location, and is an item as long as gallery painting shuffle is on.
+  GALLERY_PAINTING = 7;
+}
+
+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;
+
+  // Groups with this type become an item if cyan door behavior is set to item.
+  CYAN_DOORS = 3;
+
+  // Groups with this type always become an item if door shuffle is on.
+  SHUFFLE_GROUP = 4;
 }
 
 enum AxisDirection {
@@ -64,6 +87,18 @@ enum PuzzleSymbol {
   QUESTION = 19;
 }
 
+message Vec3d {
+  optional double x = 1;
+  optional double y = 2;
+  optional double z = 3;
+}
+
+message VersionNumber {
+  optional uint64 major = 1;
+  optional uint64 minor = 2;
+  optional uint64 patch = 3;
+}
+
 message ProxyIdentifier {
   optional uint64 panel = 1;
   optional string answer = 2;
@@ -84,6 +119,11 @@ message Connection {
     uint64 painting = 5;
     ProxyIdentifier panel = 6;
   }
+
+  optional bool roof_access = 7;
+  optional bool purple_ending = 8;
+  optional bool cyan_ending = 9;
+  optional bool vanilla_only = 10;
 }
 
 message Door {
@@ -100,12 +140,16 @@ message Door {
   optional uint64 complete_at = 12;
 
   optional string control_center_color = 6;
-  repeated string switches = 7;
   repeated KeyholderAnswer keyholders = 13;
   repeated uint64 rooms = 14;
   repeated uint64 doors = 15;
+  repeated uint64 endings = 16;
+  optional bool double_letters = 18;
+  repeated string senders = 19;
 
   optional DoorType type = 8;
+
+  optional string location_name = 17;
 }
 
 message PanelData {
@@ -123,9 +167,11 @@ message PanelData {
 
   optional uint64 required_door = 9;
   optional uint64 required_room = 11;
+
+  optional string display_name = 12;
 }
 
-message Painting {
+message PaintingData {
   optional uint64 id = 1;
   optional uint64 room_id = 2;
   optional string name = 9;
@@ -147,19 +193,24 @@ message Port {
   optional uint64 room_id = 2;
   optional string name = 3;
 
+  optional string display_name = 10;
   optional string path = 4;
-  optional string orientation = 5;
+  optional Vec3d destination = 5;
+  optional double rotation = 8;
   optional AxisDirection gravity = 7;
+  optional bool no_shuffle = 9;
 
   optional uint64 required_door = 6;
 }
 
-message Keyholder {
+message KeyholderData {
   optional uint64 id = 1;
+  optional uint64 ap_id = 6;
   optional uint64 room_id = 2;
 
   optional string name = 3;
   optional string path = 4;
+  optional string key = 5;
 }
 
 message Letter {
@@ -197,6 +248,7 @@ message Room {
   optional uint64 map_id = 8;
   optional string name = 2;
   optional string display_name = 3;
+  optional string panel_display_name = 13;
 
   repeated uint64 panels = 4;
   repeated uint64 paintings = 5;
@@ -214,17 +266,36 @@ message Map {
   optional string display_name = 3;
 }
 
+message Progressive {
+  optional uint64 id = 1;
+  optional string name = 2;
+  optional uint64 ap_id = 3;
+  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 {
+  optional VersionNumber version = 15;
+
   repeated Map maps = 7;
   repeated Room rooms = 1;
   repeated Door doors = 2;
   repeated PanelData panels = 3;
-  repeated Painting paintings = 4;
+  repeated PaintingData paintings = 4;
   repeated Port ports = 5;
-  repeated Keyholder keyholders = 11;
+  repeated KeyholderData keyholders = 11;
   repeated Letter letters = 9;
   repeated Mastery masteries = 10;
   repeated Ending endings = 12;
   repeated Connection connections = 6;
+  repeated Progressive progressives = 13;
+  repeated DoorGroup door_groups = 14;
   map<string, uint64> special_ids = 8;
 }
@@ -62,6 +62,25 @@ message HumanConnection {
 
   optional bool oneway = 3;
   optional DoorIdentifier door = 4;
+
+  // If true, this connection will only be logically allowed if the Daedalus
+  // Roof Access option is enabled.
+  optional bool roof_access = 7;
+
+  // This means that the connection intentionally skips the target object's
+  // required door.
+  optional bool bypass_target_door = 8;
+
+  // This means that the connection should additionally require all purple
+  // letters when the Strict Purple Ending option is on.
+  optional bool purple_ending = 9;
+
+  // This means that the connection should additionally require all cyan letters
+  // when the Strict Cyan Ending option is on.
+  optional bool cyan_ending = 10;
+
+  // This means that the connection only exists when doors are not shuffled.
+  optional bool vanilla_only = 11;
 }
 
 message HumanConnections {
@@ -82,13 +101,19 @@ message HumanDoor {
   optional uint64 complete_at = 9;
 
   optional string control_center_color = 6;
-  repeated string switches = 7;
   repeated KeyholderIdentifier keyholders = 10;
   repeated RoomIdentifier rooms = 11;
   repeated DoorIdentifier doors = 12;
+  repeated string endings = 13;
+  optional bool double_letters = 15;
+
+  // Sender nodes to be added to the list of requirements for triggering the
+  // location. Only for senders that have no logic requirements.
+  repeated string senders = 16;
 
   optional DoorType type = 4;
   optional string location_room = 5;
+  optional string location_name = 14;
 }
 
 message HumanDoors {
@@ -107,6 +132,8 @@ message HumanPanel {
 
   optional DoorIdentifier required_door = 7;
   optional RoomIdentifier required_room = 8;
+
+  optional string display_name = 9;
 }
 
 message HumanPainting {
@@ -126,9 +153,16 @@ message HumanPainting {
 
 message HumanPort {
   optional string name = 1;
+  optional string display_name = 8;
   optional string path = 2;
 
-  optional string orientation = 3;
+  optional bool no_shuffle = 7;
+
+  // These specify how the player should be placed when a randomized entrance
+  // sends them to this port. "rotation" is in degrees and is counter-clockwise 
+  // from the positive X axis.
+  optional Vec3d destination = 3;
+  optional double rotation = 6;
   optional AxisDirection gravity = 5 [default = Y_MINUS];
 
   optional DoorIdentifier required_door = 4;
@@ -137,6 +171,13 @@ message HumanPort {
 message HumanKeyholder {
   optional string name = 1;
   optional string path = 2;
+
+  // If this is set, the keyholder will become a location when keyholder shuffle
+  // is enabled. This value specifies the key that is required to clear the
+  // location. It should be the same as the key needed for Green Ending. The
+  // only cases when this shouldn't be set is the two disappearing keyholders in
+  // The Congruent.
+  optional string key = 3;
 }
 
 message HumanLetter {
@@ -160,6 +201,10 @@ message HumanRoom {
   optional string name = 1;
   optional string display_name = 2;
 
+  // This is used in panelsanity location names and location names for STANDARD
+  // doors generated from panels in the same area.
+  optional string panel_display_name = 10;
+
   repeated HumanPanel panels = 3;
   repeated HumanPainting paintings = 4;
   repeated HumanLetter letters = 5;
@@ -174,10 +219,35 @@ message HumanMap {
   repeated string excluded_nodes = 2;
 }
 
+message HumanProgressive {
+  optional string name = 1;
+  repeated DoorIdentifier doors = 2;
+}
+
+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 HumanGlobalMetadata {
+  repeated string special_names = 1;
+  optional VersionNumber version = 2;
+}
+
 message IdMappings {
   message RoomIds {
     map<string, uint64> panels = 1;
     map<string, uint64> masteries = 2;
+    map<string, uint64> keyholders = 3;
   }
 
   message MapIds {
@@ -189,4 +259,6 @@ message IdMappings {
   map<string, uint64> special = 2;
   map<string, uint64> letters = 3;
   map<string, uint64> endings = 4;
+  map<string, uint64> progressives = 5;
+  map<string, uint64> door_groups = 6;
 }
@@ -2,6 +2,7 @@
 #include <google/protobuf/text_format.h>
 
 #include <cstdint>
+#include <filesystem>
 #include <fstream>
 #include <iostream>
 #include <map>
@@ -40,6 +41,10 @@ class AssignIds {
     ReadIds(ids_path);
 
     ProcessMaps(datadir_path);
+    ProcessSpecialIds();
+    ProcessProgressivesFile(datadir_path / "progressives.txtpb");
+    ProcessDoorGroupsFile(datadir_path / "door_groups.txtpb");
+    ProcessGlobalMetadataFile(datadir_path / "metadata.txtpb");
 
     WriteIds(ids_path);
 
@@ -54,50 +59,26 @@ class AssignIds {
     id_mappings_ = ReadIdsFromYaml(path.string());
 
     for (const auto& [_, map] : id_mappings_.maps()) {
-      for (const auto& [_, id] : map.doors()) {
-        if (id > next_id_) {
-          next_id_ = id;
-        }
-      }
+      UpdateNextId(map.doors());
 
       for (const auto& [_, room] : map.rooms()) {
-        for (const auto& [_, id] : room.panels()) {
-          if (id > next_id_) {
-            next_id_ = id;
-          }
-        }
-
-        for (const auto& [_, id] : room.masteries()) {
-          if (id > next_id_) {
-            next_id_ = id;
-          }
-        }
-      }
-    }
-
-    for (const auto& [_, id] : id_mappings_.special()) {
-      if (id > next_id_) {
-        next_id_ = id;
-      }
-    }
-
-    for (const auto& [_, id] : id_mappings_.letters()) {
-      if (id > next_id_) {
-        next_id_ = id;
+        UpdateNextId(room.panels());
+        UpdateNextId(room.masteries());
+        UpdateNextId(room.keyholders());
       }
     }
 
-    for (const auto& [_, id] : id_mappings_.endings()) {
-      if (id > next_id_) {
-        next_id_ = id;
-      }
-    }
+    UpdateNextId(id_mappings_.special());
+    UpdateNextId(id_mappings_.letters());
+    UpdateNextId(id_mappings_.endings());
+    UpdateNextId(id_mappings_.progressives());
+    UpdateNextId(id_mappings_.door_groups());
 
     next_id_++;
   }
 
   void WriteIds(std::filesystem::path path) {
-    WriteIdsAsYaml(id_mappings_, path.string());
+    WriteIdsAsYaml(output_, path.string());
   }
 
   void ProcessMaps(std::filesystem::path path) {
@@ -134,14 +115,18 @@ class AssignIds {
       return;
     }
 
+    auto& maps = *output_.mutable_maps();
+    auto& doors = *maps[current_map_name].mutable_doors();
+
     if (!id_mappings_.maps().contains(current_map_name) ||
         !id_mappings_.maps()
              .at(current_map_name)
              .doors()
              .contains(h_door.name())) {
-      auto& maps = *id_mappings_.mutable_maps();
-      auto& doors = *maps[current_map_name].mutable_doors();
       doors[h_door.name()] = next_id_++;
+    } else {
+      doors[h_door.name()] =
+          id_mappings_.maps().at(current_map_name).doors().at(h_door.name());
     }
   }
 
@@ -156,6 +141,10 @@ class AssignIds {
   void ProcessRoom(const HumanRoom& h_room,
                    const std::string& current_map_name) {
     for (const HumanPanel& h_panel : h_room.panels()) {
+      auto& maps = *output_.mutable_maps();
+      auto& rooms = *maps[current_map_name].mutable_rooms();
+      auto& panels = *rooms[h_room.name()].mutable_panels();
+
       if (!id_mappings_.maps().contains(current_map_name) ||
           !id_mappings_.maps()
                .at(current_map_name)
@@ -167,23 +156,33 @@ class AssignIds {
                .at(h_room.name())
                .panels()
                .contains(h_panel.name())) {
-        auto& maps = *id_mappings_.mutable_maps();
-        auto& rooms = *maps[current_map_name].mutable_rooms();
-        auto& panels = *rooms[h_room.name()].mutable_panels();
         panels[h_panel.name()] = next_id_++;
+      } else {
+        panels[h_panel.name()] = id_mappings_.maps()
+                                     .at(current_map_name)
+                                     .rooms()
+                                     .at(h_room.name())
+                                     .panels()
+                                     .at(h_panel.name());
       }
     }
 
     for (const HumanLetter& h_letter : h_room.letters()) {
       std::string lettername = GetLetterName(h_letter.key(), h_letter.level2());
 
+      auto& letters = *output_.mutable_letters();
       if (!id_mappings_.letters().contains(lettername)) {
-        auto& letters = *id_mappings_.mutable_letters();
         letters[lettername] = next_id_++;
+      } else {
+        letters[lettername] = id_mappings_.letters().at(lettername);
       }
     }
 
     for (const HumanMastery& h_mastery : h_room.masteries()) {
+      auto& maps = *output_.mutable_maps();
+      auto& rooms = *maps[current_map_name].mutable_rooms();
+      auto& masteries = *rooms[h_room.name()].mutable_masteries();
+
       if (!id_mappings_.maps().contains(current_map_name) ||
           !id_mappings_.maps()
                .at(current_map_name)
@@ -195,27 +194,133 @@ class AssignIds {
                .at(h_room.name())
                .masteries()
                .contains(h_mastery.name())) {
-        auto& maps = *id_mappings_.mutable_maps();
-        auto& rooms = *maps[current_map_name].mutable_rooms();
-        auto& masteries = *rooms[h_room.name()].mutable_masteries();
         masteries[h_mastery.name()] = next_id_++;
+      } else {
+        masteries[h_mastery.name()] = id_mappings_.maps()
+                                          .at(current_map_name)
+                                          .rooms()
+                                          .at(h_room.name())
+                                          .masteries()
+                                          .at(h_mastery.name());
       }
     }
 
     for (const HumanEnding& h_ending : h_room.endings()) {
+      auto& endings = *output_.mutable_endings();
+
       if (!id_mappings_.endings().contains(h_ending.name())) {
-        auto& endings = *id_mappings_.mutable_endings();
         endings[h_ending.name()] = next_id_++;
+      } else {
+        endings[h_ending.name()] = id_mappings_.endings().at(h_ending.name());
+      }
+    }
+
+    for (const HumanKeyholder& h_keyholder : h_room.keyholders()) {
+      if (!h_keyholder.has_key()) {
+        continue;
+      }
+
+      auto& maps = *output_.mutable_maps();
+      auto& rooms = *maps[current_map_name].mutable_rooms();
+      auto& keyholders = *rooms[h_room.name()].mutable_keyholders();
+
+      if (!id_mappings_.maps().contains(current_map_name) ||
+          !id_mappings_.maps()
+               .at(current_map_name)
+               .rooms()
+               .contains(h_room.name()) ||
+          !id_mappings_.maps()
+               .at(current_map_name)
+               .rooms()
+               .at(h_room.name())
+               .keyholders()
+               .contains(h_keyholder.name())) {
+        keyholders[h_keyholder.name()] = next_id_++;
+      } else {
+        keyholders[h_keyholder.name()] = id_mappings_.maps()
+                                             .at(current_map_name)
+                                             .rooms()
+                                             .at(h_room.name())
+                                             .keyholders()
+                                             .at(h_keyholder.name());
+      }
+    }
+  }
+
+  void ProcessSpecialIds() {
+    auto& specials = *output_.mutable_special();
+
+    for (const auto& [special_name, ap_id] : id_mappings_.special()) {
+      specials[special_name] = ap_id;
+    }
+  }
+
+  void ProcessProgressivesFile(std::filesystem::path path) {
+    if (!std::filesystem::exists(path)) {
+      return;
+    }
+
+    auto h_progs = ReadMessageFromFile<HumanProgressives>(path.string());
+    auto& progs = *output_.mutable_progressives();
+
+    for (const HumanProgressive& h_prog : h_progs.progressives()) {
+      if (!id_mappings_.progressives().contains(h_prog.name())) {
+        progs[h_prog.name()] = next_id_++;
+      } else {
+        progs[h_prog.name()] = id_mappings_.progressives().at(h_prog.name());
+      }
+    }
+  }
+
+  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());
+      }
+    }
+  }
+
+  void ProcessGlobalMetadataFile(std::filesystem::path path) {
+    if (!std::filesystem::exists(path)) {
+      return;
+    }
+
+    auto h_metadata = ReadMessageFromFile<HumanGlobalMetadata>(path.string());
+    auto& specials = *output_.mutable_special();
+
+    for (const std::string& h_special : h_metadata.special_names()) {
+      if (!id_mappings_.special().contains(h_special)) {
+        specials[h_special] = next_id_++;
+      } else {
+        specials[h_special] = id_mappings_.special().at(h_special);
       }
     }
   }
 
  private:
+  void UpdateNextId(const google::protobuf::Map<std::string, uint64_t>& ids) {
+    for (const auto& [_, id] : ids) {
+      if (id > next_id_) {
+        next_id_ = id;
+      }
+    }
+  }
+
   std::string mapdir_;
 
-  uint64_t next_id_ = 0;
+  uint64_t next_id_ = 1;
 
   IdMappings id_mappings_;
+  IdMappings output_;
 };
 
 }  // namespace
@@ -79,7 +79,7 @@ uint64_t Container::FindOrAddPainting(
   auto it = room_container.find(painting_name);
   if (it == room_container.end()) {
     uint64_t new_id = all_objects_.paintings_size();
-    Painting* painting = all_objects_.add_paintings();
+    PaintingData* painting = all_objects_.add_paintings();
     painting->set_id(new_id);
     painting->set_room_id(FindOrAddRoom(map_name, *room_name, std::nullopt));
     painting->set_name(painting_name);
@@ -289,7 +289,7 @@ uint64_t Container::FindOrAddKeyholder(
   auto it = room_container.find(keyholder_name);
   if (it == room_container.end()) {
     uint64_t new_id = all_objects_.keyholders_size();
-    Keyholder* keyholder = all_objects_.add_keyholders();
+    KeyholderData* keyholder = all_objects_.add_keyholders();
     keyholder->set_id(new_id);
     keyholder->set_room_id(FindOrAddRoom(map_name, *room_name, std::nullopt));
     keyholder->set_name(keyholder_name);
@@ -331,6 +331,40 @@ uint64_t Container::FindOrAddDoor(std::optional<std::string> map_name,
   }
 }
 
+uint64_t Container::FindOrAddProgressive(std::string prog_name) {
+  auto it = progressive_id_by_name_.find(prog_name);
+
+  if (it == progressive_id_by_name_.end()) {
+    uint64_t new_id = all_objects_.progressives_size();
+    Progressive* progressive = all_objects_.add_progressives();
+    progressive->set_id(new_id);
+    progressive->set_name(prog_name);
+
+    progressive_id_by_name_[prog_name] = new_id;
+
+    return new_id;
+  } else {
+    return it->second;
+  }
+}
+
+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;
 }
@@ -60,6 +60,10 @@ class Container {
 
   void AddConnection(const Connection& connection);
 
+  uint64_t FindOrAddProgressive(std::string prog_name);
+
+  uint64_t FindOrAddDoorGroup(std::string group_name);
+
   AllObjects& all_objects() { return all_objects_; }
 
  private:
@@ -82,6 +86,8 @@ class Container {
   std::map<std::string, std::map<std::string, uint64_t>>
       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
@@ -43,6 +43,9 @@ class DataPacker {
 
     ProcessConnectionsFile(datadir_path / "connections.txtpb", std::nullopt);
     ProcessMaps(datadir_path);
+    ProcessProgressivesFile(datadir_path / "progressives.txtpb");
+    ProcessDoorGroupsFile(datadir_path / "door_groups.txtpb");
+    ProcessGlobalMetadataFile(datadir_path / "metadata.txtpb");
     ProcessIdsFile(datadir_path / "ids.yaml");
 
     {
@@ -104,7 +107,11 @@ class DataPacker {
         container_.FindOrAddRoom(current_map_name, h_room.name(), std::nullopt);
     Room& room = *container_.all_objects().mutable_rooms(room_id);
 
-    room.set_display_name(h_room.display_name());
+    // room.set_display_name(h_room.display_name());
+
+    if (h_room.has_panel_display_name()) {
+      room.set_panel_display_name(h_room.panel_display_name());
+    }
 
     for (const HumanPanel& h_panel : h_room.panels()) {
       room.add_panels(ProcessPanel(h_panel, current_map_name, room.name()));
@@ -175,6 +182,10 @@ class DataPacker {
           map_name, h_panel.required_room().name(), current_map_name));
     }
 
+    if (h_panel.has_display_name()) {
+      panel.set_display_name(h_panel.display_name());
+    }
+
     return panel_id;
   }
 
@@ -184,7 +195,7 @@ class DataPacker {
     uint64_t painting_id = container_.FindOrAddPainting(
         current_map_name, current_room_name, h_painting.name(), std::nullopt,
         std::nullopt);
-    Painting& painting =
+    PaintingData& painting =
         *container_.all_objects().mutable_paintings(painting_id);
 
     painting.set_path(h_painting.path());
@@ -228,7 +239,14 @@ class DataPacker {
     Port& port = *container_.all_objects().mutable_ports(port_id);
 
     port.set_path(h_port.path());
-    port.set_orientation(h_port.orientation());
+    port.set_display_name(h_port.display_name());
+
+    if (h_port.no_shuffle()) {
+      port.set_no_shuffle(h_port.no_shuffle());
+    } else {
+      *port.mutable_destination() = h_port.destination();
+      port.set_rotation(h_port.rotation());
+    }
 
     // Setting this explicitly because the Godot protobuf doesn't support
     // custom defaults.
@@ -279,11 +297,15 @@ class DataPacker {
     uint64_t keyholder_id = container_.FindOrAddKeyholder(
         current_map_name, current_room_name, h_keyholder.name(), std::nullopt,
         std::nullopt);
-    Keyholder& keyholder =
+    KeyholderData& keyholder =
         *container_.all_objects().mutable_keyholders(keyholder_id);
 
     keyholder.set_path(h_keyholder.path());
 
+    if (h_keyholder.has_key()) {
+      keyholder.set_key(h_keyholder.key());
+    }
+
     return keyholder_id;
   }
 
@@ -331,8 +353,8 @@ class DataPacker {
         h_door.receivers().begin(), h_door.receivers().end(),
         google::protobuf::RepeatedFieldBackInserter(door.mutable_receivers()));
     std::copy(
-        h_door.switches().begin(), h_door.switches().end(),
-        google::protobuf::RepeatedFieldBackInserter(door.mutable_switches()));
+        h_door.senders().begin(), h_door.senders().end(),
+        google::protobuf::RepeatedFieldBackInserter(door.mutable_senders()));
 
     for (const PaintingIdentifier& pi : h_door.move_paintings()) {
       std::optional<std::string> map_name =
@@ -381,6 +403,10 @@ class DataPacker {
           container_.FindOrAddDoor(map_name, di.name(), current_map_name));
     }
 
+    for (const std::string& ending_name : h_door.endings()) {
+      door.add_endings(container_.FindOrAddEnding(ending_name));
+    }
+
     if (h_door.has_control_center_color()) {
       door.set_control_center_color(h_door.control_center_color());
     }
@@ -390,6 +416,14 @@ class DataPacker {
     }
 
     door.set_type(h_door.type());
+
+    if (h_door.has_location_name()) {
+      door.set_location_name(h_door.location_name());
+    }
+
+    if (h_door.has_double_letters()) {
+      door.set_double_letters(h_door.double_letters());
+    }
   }
 
   void ProcessConnectionsFile(std::filesystem::path path,
@@ -441,6 +475,26 @@ class DataPacker {
       r_connection.set_required_door(door_id);
     }
 
+    if (human_connection.has_roof_access()) {
+      f_connection.set_roof_access(human_connection.roof_access());
+      r_connection.set_roof_access(human_connection.roof_access());
+    }
+
+    if (human_connection.has_purple_ending()) {
+      f_connection.set_purple_ending(human_connection.purple_ending());
+      r_connection.set_purple_ending(human_connection.purple_ending());
+    }
+
+    if (human_connection.has_cyan_ending()) {
+      f_connection.set_cyan_ending(human_connection.cyan_ending());
+      r_connection.set_cyan_ending(human_connection.cyan_ending());
+    }
+
+    if (human_connection.has_vanilla_only()) {
+      f_connection.set_vanilla_only(human_connection.vanilla_only());
+      r_connection.set_vanilla_only(human_connection.vanilla_only());
+    }
+
     container_.AddConnection(f_connection);
     if (!human_connection.oneway()) {
       container_.AddConnection(r_connection);
@@ -524,6 +578,63 @@ class DataPacker {
     }
   }
 
+  void ProcessProgressivesFile(std::filesystem::path path) {
+    if (!std::filesystem::exists(path)) {
+      return;
+    }
+
+    auto h_progs = ReadMessageFromFile<HumanProgressives>(path.string());
+
+    for (const HumanProgressive& h_prog : h_progs.progressives()) {
+      ProcessProgressive(h_prog);
+    }
+  }
+
+  void ProcessProgressive(const HumanProgressive& h_prog) {
+    uint64_t prog_id = container_.FindOrAddProgressive(h_prog.name());
+    Progressive& prog = *container_.all_objects().mutable_progressives(prog_id);
+
+    for (const DoorIdentifier& di : h_prog.doors()) {
+      uint64_t door_id =
+          container_.FindOrAddDoor(di.map(), di.name(), std::nullopt);
+      prog.add_doors(door_id);
+    }
+  }
+
+  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 ProcessGlobalMetadataFile(std::filesystem::path path) {
+    if (!std::filesystem::exists(path)) {
+      return;
+    }
+
+    auto h_metadata = ReadMessageFromFile<HumanGlobalMetadata>(path.string());
+    *container_.all_objects().mutable_version() = h_metadata.version();
+  }
+
   void ProcessIdsFile(std::filesystem::path path) {
     auto ids = ReadIdsFromYaml(path.string());
 
@@ -548,6 +659,14 @@ class DataPacker {
               .mutable_masteries(mastery_id)
               ->set_ap_id(ap_id);
         }
+
+        for (const auto& [keyholder_name, ap_id] : room.keyholders()) {
+          uint64_t keyholder_id = container_.FindOrAddKeyholder(
+              map_name, room_name, keyholder_name, std::nullopt, std::nullopt);
+          container_.all_objects()
+              .mutable_keyholders(keyholder_id)
+              ->set_ap_id(ap_id);
+        }
       }
     }
 
@@ -565,6 +684,16 @@ class DataPacker {
       uint64_t ending_id = container_.FindOrAddEnding(ending_name);
       container_.all_objects().mutable_endings(ending_id)->set_ap_id(ap_id);
     }
+
+    for (const auto& [prog_name, ap_id] : ids.progressives()) {
+      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_;
@@ -1,10 +1,8 @@
 #include "godot_scene.h"
 
-#include <absl/strings/str_split.h>
-#include <absl/strings/string_view.h>
-
 #include <fstream>
 #include <sstream>
+#include <string_view>
 #include <variant>
 
 namespace com::fourisland::lingo2_archipelago {
@@ -23,7 +21,7 @@ struct Heading {
   GodotInstanceType instance_type;
 };
 
-Heading ParseTscnHeading(absl::string_view line) {
+Heading ParseTscnHeading(std::string_view line) {
   std::string original_line(line);
   Heading heading;
 
@@ -56,6 +56,14 @@ IdMappings ReadIdsFromYaml(const std::string& filename) {
                   mastery_it.second.as<uint64_t>();
             }
           }
+
+          if (room_it.second["keyholders"]) {
+            for (const auto& keyholder_it : room_it.second["keyholders"]) {
+              (*room_ids.mutable_keyholders())[keyholder_it.first
+                                                   .as<std::string>()] =
+                  keyholder_it.second.as<uint64_t>();
+            }
+          }
         }
       }
 
@@ -89,6 +97,20 @@ IdMappings ReadIdsFromYaml(const std::string& filename) {
     }
   }
 
+  if (document["progressives"]) {
+    for (const auto& prog_it : document["progressives"]) {
+      (*result.mutable_progressives())[prog_it.first.as<std::string>()] =
+          prog_it.second.as<uint64_t>();
+    }
+  }
+
+  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;
 }
 
@@ -117,6 +139,13 @@ void WriteIdsAsYaml(const IdMappings& ids, const std::string& filename) {
                                    mastery_id;
                              });
 
+          OperateOnSortedMap(room_ids.keyholders(),
+                             [&room_node](const std::string& keyholder_name,
+                                          uint64_t keyholder_id) {
+                               room_node["keyholders"][keyholder_name] =
+                                   keyholder_id;
+                             });
+
           map_node["rooms"][room_name] = std::move(room_node);
         });
 
@@ -144,6 +173,16 @@ void WriteIdsAsYaml(const IdMappings& ids, const std::string& filename) {
     result["special"][special_name] = special_id;
   });
 
+  OperateOnSortedMap(ids.progressives(),
+                     [&result](const std::string& prog_name, uint64_t prog_id) {
+                       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;
 }
@@ -1,3 +1,4 @@
+find_package(fmt REQUIRED)
 find_package(Protobuf REQUIRED)
 
 add_executable(validator
@@ -9,4 +10,4 @@ add_executable(validator
 set_property(TARGET validator PROPERTY CXX_STANDARD 20)
 set_property(TARGET validator PROPERTY CXX_STANDARD_REQUIRED ON)
 target_include_directories(validator PUBLIC ${CMAKE_BINARY_DIR} ${CMAKE_SOURCE_DIR}/tools)
-target_link_libraries(validator PUBLIC protos util protobuf::libprotobuf)
+target_link_libraries(validator PUBLIC protos util fmt::fmt protobuf::libprotobuf)
@@ -1,5 +1,6 @@
 #include "human_processor.h"
 
+#include <fmt/core.h>
 #include <google/protobuf/message.h>
 #include <google/protobuf/text_format.h>
 
@@ -12,6 +13,7 @@
 #include <string>
 
 #include "structs.h"
+#include "util/ids_yaml_format.h"
 
 namespace com::fourisland::lingo2_archipelago {
 namespace {
@@ -40,7 +42,9 @@ class HumanProcessor {
 
     ProcessConnectionsFile(datadir_path / "connections.txtpb", std::nullopt);
     ProcessMaps(datadir_path);
-    ProcessIdsFile(datadir_path / "ids.txtpb");
+    ProcessProgressivesFile(datadir_path / "progressives.txtpb");
+    ProcessDoorGroupsFile(datadir_path / "door_groups.txtpb");
+    ProcessIdsFile(datadir_path / "ids.yaml");
   }
 
  private:
@@ -93,7 +97,7 @@ class HumanProcessor {
     room_info.definitions.push_back(h_room);
 
     for (const HumanPanel& h_panel : h_room.panels()) {
-      ProcessPanel(h_panel, current_map_name, h_room.name());
+      ProcessPanel(h_panel, current_map_name, h_room);
     }
 
     for (const HumanPainting& h_painting : h_room.paintings()) {
@@ -123,15 +127,14 @@ class HumanProcessor {
 
   void ProcessPanel(const HumanPanel& h_panel,
                     const std::string& current_map_name,
-                    const std::string& current_room_name) {
+                    const HumanRoom& h_room) {
     PanelIdentifier panel_identifier;
     panel_identifier.set_map(current_map_name);
-    panel_identifier.set_room(current_room_name);
+    panel_identifier.set_room(h_room.name());
     panel_identifier.set_name(h_panel.name());
 
     PanelInfo& panel_info = info_.panels[panel_identifier];
     panel_info.definitions.push_back(h_panel);
-    panel_info.proxies[h_panel.answer()].definitions.push_back(Proxy());
 
     MapInfo& map_info = info_.maps[current_map_name];
     map_info.game_nodes[h_panel.path()].uses++;
@@ -156,6 +159,24 @@ class HumanProcessor {
       RoomInfo& required_room_info = info_.rooms[required_room_identifier];
       required_room_info.panels_referenced_by.push_back(panel_identifier);
     }
+
+    std::string map_area_name = current_map_name;
+    if (h_room.has_panel_display_name()) {
+      map_area_name =
+          fmt::format("{} ({})", current_map_name, h_room.panel_display_name());
+    }
+
+    panel_info.map_area_name = map_area_name;
+
+    std::string panelsanity_name;
+    if (h_panel.has_display_name()) {
+      panelsanity_name =
+          fmt::format("{} - {}", map_area_name, h_panel.display_name());
+    } else {
+      panelsanity_name = fmt::format("{} - {}", map_area_name, h_panel.name());
+    }
+    info_.panel_names[panelsanity_name].panels_used_by.push_back(
+        panel_identifier);
   }
 
   void ProcessPainting(const HumanPainting& h_painting,
@@ -337,6 +358,11 @@ class HumanProcessor {
       DoorInfo& other_door_info = info_.doors[complete_door_identifier];
       other_door_info.doors_referenced_by.push_back(door_identifier);
     }
+
+    for (const std::string& ei : h_door.endings()) {
+      EndingInfo& ending_info = info_.endings[ei];
+      ending_info.doors_referenced_by.push_back(door_identifier);
+    }
   }
 
   void ProcessConnectionsFile(std::filesystem::path path,
@@ -368,7 +394,9 @@ class HumanProcessor {
       }
     } else if (human_connection.has_from()) {
       ProcessSingleConnection(human_connection, human_connection.from(),
-                              current_map_name);
+                              current_map_name,
+                              /*is_target=*/!human_connection.oneway() &&
+                                  !human_connection.bypass_target_door());
     }
 
     if (human_connection.has_to_room()) {
@@ -384,8 +412,9 @@ class HumanProcessor {
         std::cout << "A global connection used to_room." << std::endl;
       }
     } else if (human_connection.has_to()) {
-      ProcessSingleConnection(human_connection, human_connection.to(),
-                              current_map_name);
+      ProcessSingleConnection(
+          human_connection, human_connection.to(), current_map_name,
+          /*is_target=*/!human_connection.bypass_target_door());
     }
 
     if (human_connection.has_door()) {
@@ -406,7 +435,7 @@ class HumanProcessor {
   void ProcessSingleConnection(
       const HumanConnection& human_connection,
       const HumanConnection::Endpoint& endpoint,
-      const std::optional<std::string>& current_map_name) {
+      const std::optional<std::string>& current_map_name, bool is_target) {
     if (endpoint.has_room()) {
       auto room_identifier =
           GetCompleteRoomIdentifier(endpoint.room(), current_map_name);
@@ -425,6 +454,11 @@ class HumanProcessor {
       if (painting_identifier) {
         PaintingInfo& painting_info = info_.paintings[*painting_identifier];
         painting_info.connections_referenced_by.push_back(human_connection);
+
+        if (is_target) {
+          painting_info.target_connections_referenced_by.push_back(
+              human_connection);
+        }
       } else {
         // Not sure where else to store this right now.
         std::cout
@@ -437,6 +471,11 @@ class HumanProcessor {
       if (port_identifier) {
         PortInfo& port_info = info_.ports[*port_identifier];
         port_info.connections_referenced_by.push_back(human_connection);
+
+        if (is_target) {
+          port_info.target_connections_referenced_by.push_back(
+              human_connection);
+        }
       } else {
         // Not sure where else to store this right now.
         std::cout
@@ -454,12 +493,137 @@ class HumanProcessor {
           panel_info.proxies[endpoint.panel().answer()]
               .connections_referenced_by.push_back(human_connection);
         }
+
+        if (is_target) {
+          panel_info.target_connections_referenced_by.push_back(
+              human_connection);
+        }
+      }
+    }
+  }
+
+  void ProcessProgressivesFile(std::filesystem::path path) {
+    if (!std::filesystem::exists(path)) {
+      return;
+    }
+
+    auto h_progs = ReadMessageFromFile<HumanProgressives>(path.string());
+
+    for (const HumanProgressive& h_prog : h_progs.progressives()) {
+      ProcessProgressive(h_prog);
+    }
+  }
+
+  void ProcessProgressive(const HumanProgressive& h_prog) {
+    ProgressiveInfo& prog_info = info_.progressives[h_prog.name()];
+    prog_info.definitions.push_back(h_prog);
+
+    for (const DoorIdentifier& di : h_prog.doors()) {
+      if (!di.has_map()) {
+        prog_info.malformed_doors.push_back(di);
+        continue;
       }
+
+      DoorInfo& door_info = info_.doors[di];
+      door_info.progressives_referenced_by.push_back(h_prog.name());
+    }
+  }
+
+  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) {
-    // Ignore this for now.
+    auto ids = ReadIdsFromYaml(path.string());
+
+    DoorIdentifier di;
+    PanelIdentifier pi;
+    KeyholderIdentifier ki;
+
+    for (const auto& [map_name, map] : ids.maps()) {
+      di.set_map(map_name);
+      pi.set_map(map_name);
+      ki.set_map(map_name);
+
+      for (const auto& [door_name, ap_id] : map.doors()) {
+        di.set_name(door_name);
+
+        DoorInfo& door_info = info_.doors[di];
+        door_info.has_id = true;
+      }
+
+      for (const auto& [room_name, room] : map.rooms()) {
+        pi.set_room(room_name);
+        ki.set_room(room_name);
+
+        for (const auto& [panel_name, ap_id] : room.panels()) {
+          pi.set_name(panel_name);
+
+          PanelInfo& panel_info = info_.panels[pi];
+          panel_info.has_id = true;
+        }
+
+        for (const auto& [mastery_name, ap_id] : room.masteries()) {
+          // TODO: Mastery
+        }
+
+        for (const auto& [keyholder_name, ap_id] : room.keyholders()) {
+          ki.set_name(keyholder_name);
+
+          KeyholderInfo& keyholder_info = info_.keyholders[ki];
+          keyholder_info.has_id = true;
+        }
+      }
+    }
+
+    for (const auto& [tag, id] : ids.special()) {
+      // TODO: Specials
+    }
+
+    for (const auto& [letter_name, ap_id] : ids.letters()) {
+      LetterIdentifier li =
+          std::make_tuple(letter_name[0], letter_name[1] == '2');
+      LetterInfo& letter_info = info_.letters[li];
+      letter_info.has_id = true;
+    }
+
+    for (const auto& [ending_name, ap_id] : ids.endings()) {
+      EndingInfo& ending_info = info_.endings[ending_name];
+      ending_info.has_id = true;
+    }
+
+    for (const auto& [prog_name, ap_id] : ids.progressives()) {
+      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_;
@@ -39,12 +39,15 @@ struct RoomInfo {
 
 struct DoorInfo {
   std::vector<HumanDoor> definitions;
+  bool has_id = false;
 
   std::vector<HumanConnection> connections_referenced_by;
   std::vector<DoorIdentifier> doors_referenced_by;
   std::vector<PanelIdentifier> panels_referenced_by;
   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;
 };
@@ -53,12 +56,14 @@ struct PortInfo {
   std::vector<HumanPort> definitions;
 
   std::vector<HumanConnection> connections_referenced_by;
+  std::vector<HumanConnection> target_connections_referenced_by;
 };
 
 struct PaintingInfo {
   std::vector<HumanPainting> definitions;
 
   std::vector<HumanConnection> connections_referenced_by;
+  std::vector<HumanConnection> target_connections_referenced_by;
   std::vector<DoorIdentifier> doors_referenced_by;
 };
 
@@ -71,8 +76,12 @@ struct ProxyInfo {
 
 struct PanelInfo {
   std::vector<HumanPanel> definitions;
+  bool has_id = false;
+
+  std::string map_area_name;
 
   std::vector<HumanConnection> connections_referenced_by;
+  std::vector<HumanConnection> target_connections_referenced_by;
   std::vector<DoorIdentifier> doors_referenced_by;
 
   std::map<std::string, ProxyInfo> proxies;
@@ -80,6 +89,7 @@ struct PanelInfo {
 
 struct KeyholderInfo {
   std::vector<HumanKeyholder> definitions;
+  bool has_id = false;
 
   std::vector<DoorIdentifier> doors_referenced_by;
 };
@@ -88,10 +98,32 @@ using LetterIdentifier = std::tuple<char, bool>;
 
 struct LetterInfo {
   std::vector<RoomIdentifier> defined_in;
+  bool has_id = false;
 };
 
 struct EndingInfo {
   std::vector<RoomIdentifier> defined_in;
+  bool has_id = false;
+
+  std::vector<DoorIdentifier> doors_referenced_by;
+};
+
+struct PanelNameInfo {
+  std::vector<PanelIdentifier> panels_used_by;
+};
+
+struct ProgressiveInfo {
+  std::vector<HumanProgressive> definitions;
+  bool has_id = false;
+
+  std::vector<DoorIdentifier> malformed_doors;
+};
+
+struct DoorGroupInfo {
+  std::vector<HumanDoorGroup> definitions;
+  bool has_id = false;
+
+  std::vector<DoorIdentifier> malformed_doors;
 };
 
 struct CollectedInfo {
@@ -105,6 +137,9 @@ struct CollectedInfo {
       keyholders;
   std::map<LetterIdentifier, LetterInfo> letters;
   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
@@ -9,282 +9,557 @@
 namespace com::fourisland::lingo2_archipelago {
 namespace {
 
-void ValidateMap(const std::string& map_name, const MapInfo& map_info) {
-  for (const auto& [node_path, node_info] : map_info.game_nodes) {
-    if (node_info.uses > 1) {
-      std::cout << "Map " << map_name << " node " << node_path
-                << " is used in multiple places." << std::endl;
-    } else if (node_info.uses == 0) {
-      std::cout << "Map " << map_name << " node " << node_path
-                << " is not used." << std::endl;
-    }
+class Validator {
+ public:
+  explicit Validator(const CollectedInfo& info) : info_(info) {}
 
-    if (!node_info.defined) {
-      std::cout << "Map " << map_name << " node " << node_path
-                << " is not defined in the game file." << std::endl;
+  void Validate() const {
+    for (const auto& [map_name, map_info] : info_.maps) {
+      ValidateMap(map_name, map_info);
+    }
+    for (const auto& [room_identifier, room_info] : info_.rooms) {
+      ValidateRoom(room_identifier, room_info);
+    }
+    for (const auto& [door_identifier, door_info] : info_.doors) {
+      ValidateDoor(door_identifier, door_info);
+    }
+    for (const auto& [port_identifier, port_info] : info_.ports) {
+      ValidatePort(port_identifier, port_info);
+    }
+    for (const auto& [painting_identifier, painting_info] : info_.paintings) {
+      ValidatePainting(painting_identifier, painting_info);
+    }
+    for (const auto& [panel_identifier, panel_info] : info_.panels) {
+      ValidatePanel(panel_identifier, panel_info);
+    }
+    for (const auto& [keyholder_identifier, keyholder_info] :
+         info_.keyholders) {
+      ValidateKeyholder(keyholder_identifier, keyholder_info);
+    }
+    for (const auto& [letter_identifier, letter_info] : info_.letters) {
+      ValidateLetter(letter_identifier, letter_info);
+    }
+    for (const auto& [ending_name, ending_info] : info_.endings) {
+      ValidateEnding(ending_name, ending_info);
+    }
+    for (const auto& [panel_name, panel_info] : info_.panel_names) {
+      ValidatePanelName(panel_name, panel_info);
+    }
+    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);
     }
   }
-}
 
-void ValidateRoom(const RoomIdentifier& room_identifier,
-                  const RoomInfo& room_info) {
-  if (room_info.definitions.empty()) {
-    std::cout << "Room " << room_identifier.ShortDebugString()
-              << " has no definition, but was referenced:" << std::endl;
+ private:
+  void ValidateMap(const std::string& map_name, const MapInfo& map_info) const {
+    for (const auto& [node_path, node_info] : map_info.game_nodes) {
+      if (node_info.uses > 1) {
+        std::cout << "Map " << map_name << " node " << node_path
+                  << " is used in multiple places." << std::endl;
+      } else if (node_info.uses == 0) {
+        std::cout << "Map " << map_name << " node " << node_path
+                  << " is not used." << std::endl;
+      }
 
-    for (const DoorIdentifier& door_identifier :
-         room_info.doors_referenced_by) {
-      std::cout << "    DOOR " << door_identifier.ShortDebugString()
-                << std::endl;
+      if (!node_info.defined) {
+        std::cout << "Map " << map_name << " node " << node_path
+                  << " is not defined in the game file." << std::endl;
+      }
     }
+  }
 
-    for (const PanelIdentifier& panel_identifier :
-         room_info.panels_referenced_by) {
-      std::cout << "    PANEL " << panel_identifier.ShortDebugString()
-                << std::endl;
-    }
+  void ValidateRoom(const RoomIdentifier& room_identifier,
+                    const RoomInfo& room_info) const {
+    if (room_info.definitions.empty()) {
+      std::cout << "Room " << room_identifier.ShortDebugString()
+                << " has no definition, but was referenced:" << std::endl;
 
-    for (const HumanConnection& connection :
-         room_info.connections_referenced_by) {
-      std::cout << "    CONNECTION " << connection.ShortDebugString()
-                << std::endl;
+      for (const DoorIdentifier& door_identifier :
+           room_info.doors_referenced_by) {
+        std::cout << "    DOOR " << door_identifier.ShortDebugString()
+                  << std::endl;
+      }
+
+      for (const PanelIdentifier& panel_identifier :
+           room_info.panels_referenced_by) {
+        std::cout << "    PANEL " << panel_identifier.ShortDebugString()
+                  << std::endl;
+      }
+
+      for (const HumanConnection& connection :
+           room_info.connections_referenced_by) {
+        std::cout << "    CONNECTION " << connection.ShortDebugString()
+                  << std::endl;
+      }
+    } else if (room_info.definitions.size() > 1) {
+      std::cout << "Room " << room_identifier.ShortDebugString()
+                << " was defined multiple times." << std::endl;
     }
-  } else if (room_info.definitions.size() > 1) {
-    std::cout << "Room " << room_identifier.ShortDebugString()
-              << " was defined multiple times." << std::endl;
   }
-}
 
-void ValidateDoor(const DoorIdentifier& door_identifier,
-                  const DoorInfo& door_info) {
-  if (door_info.definitions.empty()) {
-    std::cout << "Door " << door_identifier.ShortDebugString()
-              << " has no definition, but was referenced:" << std::endl;
-
-    for (const DoorIdentifier& other_door_identifier :
-         door_info.doors_referenced_by) {
-      std::cout << "    DOOR " << other_door_identifier.ShortDebugString()
-                << std::endl;
+  bool DoesDoorNeedLocationName(const HumanDoor& h_door,
+                                const std::string& map_name) const {
+    if (h_door.type() != DoorType::STANDARD) {
+      return false;
     }
 
-    for (const PanelIdentifier& panel_identifier :
-         door_info.panels_referenced_by) {
-      std::cout << "    PANEL " << panel_identifier.ShortDebugString()
-                << std::endl;
+    if (h_door.keyholders_size() > 0 || h_door.endings_size() > 0 ||
+        h_door.complete_at() > 0) {
+      return true;
     }
 
-    for (const PaintingIdentifier& painting_identifier :
-         door_info.paintings_referenced_by) {
-      std::cout << "    PAINTING " << painting_identifier.ShortDebugString()
-                << std::endl;
+    if (h_door.panels_size() > 4) {
+      return true;
     }
 
-    for (const PortIdentifier& port_identifier :
-         door_info.ports_referenced_by) {
-      std::cout << "    PORT " << port_identifier.ShortDebugString()
-                << std::endl;
+    std::set<std::string> map_areas;
+    for (const PanelIdentifier& pi : h_door.panels()) {
+      auto full_pi =
+          GetCompletePanelIdentifierWithoutAnswer(pi, map_name, std::nullopt);
+      if (full_pi) {
+        auto panel_info_it = info_.panels.find(*full_pi);
+        if (panel_info_it != info_.panels.end()) {
+          const PanelInfo& panel_info = panel_info_it->second;
+
+          map_areas.insert(panel_info.map_area_name);
+        }
+      }
     }
 
-    for (const HumanConnection& connection :
-         door_info.connections_referenced_by) {
-      std::cout << "    CONNECTION " << connection.ShortDebugString()
-                << std::endl;
+    if (map_areas.size() > 1) {
+      return true;
     }
-  } else if (door_info.definitions.size() > 1) {
-    std::cout << "Door " << door_identifier.ShortDebugString()
-              << " was defined multiple times." << std::endl;
+
+    return false;
   }
 
-  if (door_info.malformed_identifiers.HasAny()) {
-    std::cout << "Door " << door_identifier.ShortDebugString()
-              << " has malformed identifiers:" << std::endl;
+  void ValidateDoor(const DoorIdentifier& door_identifier,
+                    const DoorInfo& door_info) const {
+    if (door_info.definitions.empty()) {
+      std::cout << "Door " << door_identifier.ShortDebugString()
+                << " has no definition, but was referenced:" << std::endl;
 
-    for (const PaintingIdentifier& painting_identifier :
-         door_info.malformed_identifiers.paintings) {
-      std::cout << "    PAINTING " << painting_identifier.ShortDebugString()
-                << std::endl;
-    }
+      for (const DoorIdentifier& other_door_identifier :
+           door_info.doors_referenced_by) {
+        std::cout << "    DOOR " << other_door_identifier.ShortDebugString()
+                  << std::endl;
+      }
 
-    for (const PanelIdentifier& panel_identifier :
-         door_info.malformed_identifiers.panels) {
-      std::cout << "    PANEL " << panel_identifier.ShortDebugString()
-                << std::endl;
+      for (const PanelIdentifier& panel_identifier :
+           door_info.panels_referenced_by) {
+        std::cout << "    PANEL " << panel_identifier.ShortDebugString()
+                  << std::endl;
+      }
+
+      for (const PaintingIdentifier& painting_identifier :
+           door_info.paintings_referenced_by) {
+        std::cout << "    PAINTING " << painting_identifier.ShortDebugString()
+                  << std::endl;
+      }
+
+      for (const PortIdentifier& port_identifier :
+           door_info.ports_referenced_by) {
+        std::cout << "    PORT " << port_identifier.ShortDebugString()
+                  << std::endl;
+      }
+
+      for (const HumanConnection& connection :
+           door_info.connections_referenced_by) {
+        std::cout << "    CONNECTION " << connection.ShortDebugString()
+                  << std::endl;
+      }
+
+      for (const std::string& prog_name :
+           door_info.progressives_referenced_by) {
+        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;
+      }
+    } else if (door_info.definitions.size() > 1) {
+      std::cout << "Door " << door_identifier.ShortDebugString()
+                << " was defined multiple times." << std::endl;
     }
 
-    for (const KeyholderIdentifier& keyholder_identifier :
-         door_info.malformed_identifiers.keyholders) {
-      std::cout << "    KEYHOLDER " << keyholder_identifier.ShortDebugString()
-                << std::endl;
+    if (door_info.malformed_identifiers.HasAny()) {
+      std::cout << "Door " << door_identifier.ShortDebugString()
+                << " has malformed identifiers:" << std::endl;
+
+      for (const PaintingIdentifier& painting_identifier :
+           door_info.malformed_identifiers.paintings) {
+        std::cout << "    PAINTING " << painting_identifier.ShortDebugString()
+                  << std::endl;
+      }
+
+      for (const PanelIdentifier& panel_identifier :
+           door_info.malformed_identifiers.panels) {
+        std::cout << "    PANEL " << panel_identifier.ShortDebugString()
+                  << std::endl;
+      }
+
+      for (const KeyholderIdentifier& keyholder_identifier :
+           door_info.malformed_identifiers.keyholders) {
+        std::cout << "    KEYHOLDER " << keyholder_identifier.ShortDebugString()
+                  << std::endl;
+      }
     }
-  }
-}
 
-void ValidatePort(const PortIdentifier& port_identifier,
-                  const PortInfo& port_info) {
-  if (port_info.definitions.empty()) {
-    std::cout << "Port " << port_identifier.ShortDebugString()
-              << " has no definition, but was referenced:" << std::endl;
+    for (const HumanDoor& h_door : door_info.definitions) {
+      if (DoesDoorNeedLocationName(h_door, door_identifier.map()) &&
+          !h_door.has_location_name()) {
+        std::cout << "Door " << door_identifier.ShortDebugString()
+                  << " needs an explicit location name." << std::endl;
+      }
 
-    for (const HumanConnection& connection :
-         port_info.connections_referenced_by) {
-      std::cout << "    CONNECTION " << connection.ShortDebugString()
-                << std::endl;
+      if (h_door.double_letters() &&
+          (h_door.type() == DoorType::STANDARD ||
+           h_door.type() == DoorType::LOCATION_ONLY ||
+           h_door.type() == DoorType::GRAVESTONE)) {
+        std::cout << "Door " << door_identifier.ShortDebugString()
+                  << " is a location that depends on double_letters."
+                  << std::endl;
+      }
+
+      bool needs_id = (h_door.type() != DoorType::EVENT);
+      if (door_info.has_id != needs_id) {
+        if (needs_id) {
+          std::cout << "Door " << door_identifier.ShortDebugString()
+                    << " is missing an AP ID." << std::endl;
+        } else {
+          std::cout << "Door " << door_identifier.ShortDebugString()
+                    << " should not have an AP ID." << std::endl;
+        }
+      }
     }
-  } else if (port_info.definitions.size() > 1) {
-    std::cout << "Port " << port_identifier.ShortDebugString()
-              << " was defined multiple times." << std::endl;
   }
-}
 
-void ValidatePainting(const PaintingIdentifier& painting_identifier,
-                      const PaintingInfo& painting_info) {
-  if (painting_info.definitions.empty()) {
-    std::cout << "Painting " << painting_identifier.ShortDebugString()
-              << " has no definition, but was referenced:" << std::endl;
+  void ValidatePort(const PortIdentifier& port_identifier,
+                    const PortInfo& port_info) const {
+    if (port_info.definitions.empty()) {
+      std::cout << "Port " << port_identifier.ShortDebugString()
+                << " has no definition, but was referenced:" << std::endl;
 
-    for (const DoorIdentifier& door_identifier :
-         painting_info.doors_referenced_by) {
-      std::cout << "    DOOR " << door_identifier.ShortDebugString()
-                << std::endl;
+      for (const HumanConnection& connection :
+           port_info.connections_referenced_by) {
+        std::cout << "    CONNECTION " << connection.ShortDebugString()
+                  << std::endl;
+      }
+    } else if (port_info.definitions.size() > 1) {
+      std::cout << "Port " << port_identifier.ShortDebugString()
+                << " was defined multiple times." << std::endl;
     }
 
-    for (const HumanConnection& connection :
-         painting_info.connections_referenced_by) {
-      std::cout << "    CONNECTION " << connection.ShortDebugString()
-                << std::endl;
+    if (!port_info.target_connections_referenced_by.empty()) {
+      for (const HumanPort& port : port_info.definitions) {
+        if (port.has_required_door()) {
+          std::cout << "Port " << port_identifier.ShortDebugString()
+                    << " has a required door but is the target of a connection:"
+                    << std::endl;
+
+          for (const HumanConnection& connection :
+               port_info.target_connections_referenced_by) {
+            std::cout << "    CONNECTION " << connection.ShortDebugString()
+                      << std::endl;
+          }
+        }
+      }
     }
-  } else if (painting_info.definitions.size() > 1) {
-    std::cout << "Painting " << painting_identifier.ShortDebugString()
-              << " was defined multiple times." << std::endl;
-  }
-}
 
-void ValidatePanel(const PanelIdentifier& panel_identifier,
-                   const PanelInfo& panel_info) {
-  if (panel_identifier.name().empty()) {
-    std::cout << "Panel " << panel_identifier.ShortDebugString()
-              << " has no name." << std::endl;
+    for (const HumanPort& port : port_info.definitions) {
+      if (!port.no_shuffle()) {
+        if (!port.has_destination()) {
+          std::cout << "Port " << port_identifier.ShortDebugString()
+                    << " is shuffleable and missing a destination."
+                    << std::endl;
+        }
+        if (!port.has_rotation()) {
+          std::cout << "Port " << port_identifier.ShortDebugString()
+                    << " is shuffleable and missing a rotation."
+                    << std::endl;
+        }
+      }
+    }
   }
 
-  if (panel_info.definitions.empty()) {
-    std::cout << "Panel " << panel_identifier.ShortDebugString()
-              << " has no definition, but was referenced:" << std::endl;
+  void ValidatePainting(const PaintingIdentifier& painting_identifier,
+                        const PaintingInfo& painting_info) const {
+    if (painting_info.definitions.empty()) {
+      std::cout << "Painting " << painting_identifier.ShortDebugString()
+                << " has no definition, but was referenced:" << std::endl;
 
-    for (const DoorIdentifier& door_identifier :
-         panel_info.doors_referenced_by) {
-      std::cout << "    DOOR " << door_identifier.ShortDebugString()
-                << std::endl;
+      for (const DoorIdentifier& door_identifier :
+           painting_info.doors_referenced_by) {
+        std::cout << "    DOOR " << door_identifier.ShortDebugString()
+                  << std::endl;
+      }
+
+      for (const HumanConnection& connection :
+           painting_info.connections_referenced_by) {
+        std::cout << "    CONNECTION " << connection.ShortDebugString()
+                  << std::endl;
+      }
+    } else if (painting_info.definitions.size() > 1) {
+      std::cout << "Painting " << painting_identifier.ShortDebugString()
+                << " was defined multiple times." << std::endl;
     }
 
-    for (const HumanConnection& connection :
-         panel_info.connections_referenced_by) {
-      std::cout << "    CONNECTION " << connection.ShortDebugString()
-                << std::endl;
+    if (!painting_info.target_connections_referenced_by.empty()) {
+      for (const HumanPainting& painting : painting_info.definitions) {
+        if (painting.has_required_door()) {
+          std::cout << "Painting " << painting_identifier.ShortDebugString()
+                    << " has a required door but is the target of a connection:"
+                    << std::endl;
+
+          for (const HumanConnection& connection :
+               painting_info.target_connections_referenced_by) {
+            std::cout << "    CONNECTION " << connection.ShortDebugString()
+                      << std::endl;
+          }
+        }
+      }
     }
-  } else if (panel_info.definitions.size() > 1) {
-    std::cout << "Panel " << panel_identifier.ShortDebugString()
-              << " was defined multiple times." << std::endl;
   }
 
-  for (const auto& [answer, proxy_info] : panel_info.proxies) {
-    if (proxy_info.definitions.empty()) {
+  void ValidatePanel(const PanelIdentifier& panel_identifier,
+                     const PanelInfo& panel_info) const {
+    if (panel_identifier.name().empty()) {
       std::cout << "Panel " << panel_identifier.ShortDebugString()
-                << " with answer \"" << answer
-                << "\" has no definition, but was referenced:" << std::endl;
+                << " has no name." << std::endl;
+    }
+
+    if (panel_info.definitions.empty()) {
+      std::cout << "Panel " << panel_identifier.ShortDebugString()
+                << " has no definition, but was referenced:" << std::endl;
 
       for (const DoorIdentifier& door_identifier :
-           proxy_info.doors_referenced_by) {
+           panel_info.doors_referenced_by) {
         std::cout << "    DOOR " << door_identifier.ShortDebugString()
                   << std::endl;
       }
 
       for (const HumanConnection& connection :
-           proxy_info.connections_referenced_by) {
+           panel_info.connections_referenced_by) {
         std::cout << "    CONNECTION " << connection.ShortDebugString()
                   << std::endl;
       }
-    } else if (proxy_info.definitions.size() > 1) {
+
+      if (panel_info.has_id) {
+        std::cout << "    An AP ID is present." << std::endl;
+      }
+    } else if (panel_info.definitions.size() > 1) {
       std::cout << "Panel " << panel_identifier.ShortDebugString()
-                << " with answer \"" << answer
-                << "\" was defined multiple times." << std::endl;
+                << " was defined multiple times." << std::endl;
+    }
+
+    for (const auto& [answer, proxy_info] : panel_info.proxies) {
+      if (proxy_info.definitions.empty()) {
+        std::cout << "Panel " << panel_identifier.ShortDebugString()
+                  << " with answer \"" << answer
+                  << "\" has no definition, but was referenced:" << std::endl;
+
+        for (const DoorIdentifier& door_identifier :
+             proxy_info.doors_referenced_by) {
+          std::cout << "    DOOR " << door_identifier.ShortDebugString()
+                    << std::endl;
+        }
+
+        for (const HumanConnection& connection :
+             proxy_info.connections_referenced_by) {
+          std::cout << "    CONNECTION " << connection.ShortDebugString()
+                    << std::endl;
+        }
+      } else if (proxy_info.definitions.size() > 1) {
+        std::cout << "Panel " << panel_identifier.ShortDebugString()
+                  << " with answer \"" << answer
+                  << "\" was defined multiple times." << std::endl;
+      }
     }
-  }
-}
 
-void ValidateKeyholder(const KeyholderIdentifier& keyholder_identifier,
-                       const KeyholderInfo& keyholder_info) {
-  if (keyholder_info.definitions.empty()) {
-    std::cout << "Keyholder " << keyholder_identifier.ShortDebugString()
-              << " has no definition, but was referenced:" << std::endl;
+    if (!panel_info.has_id) {
+      std::cout << "Panel " << panel_identifier.ShortDebugString()
+                << " is missing an AP ID." << std::endl;
+    }
 
-    for (const DoorIdentifier& door_identifier :
-         keyholder_info.doors_referenced_by) {
-      std::cout << "    DOOR " << door_identifier.ShortDebugString()
-                << std::endl;
+    if (!panel_info.target_connections_referenced_by.empty()) {
+      for (const HumanPanel& panel : panel_info.definitions) {
+        if (panel.has_required_door()) {
+          std::cout << "Panel " << panel_identifier.ShortDebugString()
+                    << " has a required door but is the target of a connection:"
+                    << std::endl;
+
+          for (const HumanConnection& connection :
+               panel_info.target_connections_referenced_by) {
+            std::cout << "    CONNECTION " << connection.ShortDebugString()
+                      << std::endl;
+          }
+        }
+      }
     }
-  } else if (keyholder_info.definitions.size() > 1) {
-    std::cout << "Keyholder " << keyholder_identifier.ShortDebugString()
-              << " was defined multiple times." << std::endl;
   }
-}
 
-void ValidateLetter(const LetterIdentifier& letter_identifier,
-                    const LetterInfo& letter_info) {
-  std::string letter_name = std::string(1, std::get<0>(letter_identifier)) +
-                            (std::get<1>(letter_identifier) ? "2" : "1");
+  void ValidateKeyholder(const KeyholderIdentifier& keyholder_identifier,
+                         const KeyholderInfo& keyholder_info) const {
+    if (keyholder_info.definitions.empty()) {
+      std::cout << "Keyholder " << keyholder_identifier.ShortDebugString()
+                << " has no definition, but was referenced:" << std::endl;
 
-  if (letter_info.defined_in.size() > 1) {
-    std::cout << "Letter " << letter_name
-              << " was defined in multiple places:" << std::endl;
+      for (const DoorIdentifier& door_identifier :
+           keyholder_info.doors_referenced_by) {
+        std::cout << "    DOOR " << door_identifier.ShortDebugString()
+                  << std::endl;
+      }
 
-    for (const RoomIdentifier& room_identifier : letter_info.defined_in) {
-      std::cout << "    " << room_identifier.ShortDebugString() << std::endl;
+      if (keyholder_info.has_id) {
+        std::cout << "    An AP ID is present." << std::endl;
+      }
+    } else if (keyholder_info.definitions.size() > 1) {
+      std::cout << "Keyholder " << keyholder_identifier.ShortDebugString()
+                << " was defined multiple times." << std::endl;
+    }
+
+    for (const HumanKeyholder& h_keyholder : keyholder_info.definitions) {
+      bool needs_id = (h_keyholder.has_key());
+
+      if (needs_id != keyholder_info.has_id) {
+        if (needs_id) {
+          std::cout << "Keyholder " << keyholder_identifier.ShortDebugString()
+                    << " is missing an AP ID." << std::endl;
+        } else {
+          std::cout << "Keyholder " << keyholder_identifier.ShortDebugString()
+                    << " should not have an AP ID." << std::endl;
+        }
+      }
     }
   }
-}
 
-void ValidateEnding(const std::string& ending_name,
-                    const EndingInfo& ending_info) {
-  if (ending_info.defined_in.size() > 1) {
-    std::cout << "Ending " << ending_name
-              << " was defined in multiple places:" << std::endl;
+  void ValidateLetter(const LetterIdentifier& letter_identifier,
+                      const LetterInfo& letter_info) const {
+    std::string letter_name = std::string(1, std::get<0>(letter_identifier)) +
+                              (std::get<1>(letter_identifier) ? "2" : "1");
+
+    if (letter_info.defined_in.empty()) {
+      std::cout << "Letter " << letter_name
+                << " has no definition, but was referenced:" << std::endl;
 
-    for (const RoomIdentifier& room_identifier : ending_info.defined_in) {
-      std::cout << "    " << room_identifier.ShortDebugString() << std::endl;
+      if (letter_info.has_id) {
+        std::cout << "    An AP ID is present." << std::endl;
+      }
+    } else if (letter_info.defined_in.size() > 1) {
+      std::cout << "Letter " << letter_name
+                << " was defined in multiple places:" << std::endl;
+
+      for (const RoomIdentifier& room_identifier : letter_info.defined_in) {
+        std::cout << "    " << room_identifier.ShortDebugString() << std::endl;
+      }
+    }
+
+    if (!letter_info.has_id) {
+      std::cout << "Letter " << letter_name << " is missing an AP ID."
+                << std::endl;
     }
   }
-}
 
-}  // namespace
+  void ValidateEnding(const std::string& ending_name,
+                      const EndingInfo& ending_info) const {
+    if (ending_info.defined_in.empty()) {
+      std::cout << "Ending " << ending_name
+                << " has no definition, but was referenced:" << std::endl;
 
-void ValidateCollectedInfo(const CollectedInfo& info) {
-  for (const auto& [map_name, map_info] : info.maps) {
-    ValidateMap(map_name, map_info);
-  }
-  for (const auto& [room_identifier, room_info] : info.rooms) {
-    ValidateRoom(room_identifier, room_info);
-  }
-  for (const auto& [door_identifier, door_info] : info.doors) {
-    ValidateDoor(door_identifier, door_info);
-  }
-  for (const auto& [port_identifier, port_info] : info.ports) {
-    ValidatePort(port_identifier, port_info);
-  }
-  for (const auto& [painting_identifier, painting_info] : info.paintings) {
-    ValidatePainting(painting_identifier, painting_info);
-  }
-  for (const auto& [panel_identifier, panel_info] : info.panels) {
-    ValidatePanel(panel_identifier, panel_info);
+      for (const DoorIdentifier& door_identifier :
+           ending_info.doors_referenced_by) {
+        std::cout << "    DOOR " << door_identifier.ShortDebugString()
+                  << std::endl;
+      }
+
+      if (ending_info.has_id) {
+        std::cout << "    An AP ID is present." << std::endl;
+      }
+    } else if (ending_info.defined_in.size() > 1) {
+      std::cout << "Ending " << ending_name
+                << " was defined in multiple places:" << std::endl;
+
+      for (const RoomIdentifier& room_identifier : ending_info.defined_in) {
+        std::cout << "    " << room_identifier.ShortDebugString() << std::endl;
+      }
+    }
+
+    if (!ending_info.has_id) {
+      std::cout << "Ending " << ending_name << " is missing an AP ID."
+                << std::endl;
+    }
   }
-  for (const auto& [keyholder_identifier, keyholder_info] : info.keyholders) {
-    ValidateKeyholder(keyholder_identifier, keyholder_info);
+
+  void ValidatePanelName(const std::string& panel_name,
+                         const PanelNameInfo& panel_info) const {
+    if (panel_info.panels_used_by.size() > 1) {
+      std::cout << "The location name \"" << panel_name
+                << "\" is used by multiple panels:" << std::endl;
+
+      for (const PanelIdentifier& panel_identifier :
+           panel_info.panels_used_by) {
+        std::cout << "    PANEL " << panel_identifier.ShortDebugString()
+                  << std::endl;
+      }
+    }
   }
-  for (const auto& [letter_identifier, letter_info] : info.letters) {
-    ValidateLetter(letter_identifier, letter_info);
+
+  void ValidateProgressive(const std::string& prog_name,
+                           const ProgressiveInfo& prog_info) const {
+    if (prog_info.definitions.empty()) {
+      std::cout << "Progressive \"" << prog_name
+                << "\" has no definition, but was referenced:" << std::endl;
+
+      if (prog_info.has_id) {
+        std::cout << "    An AP ID is present." << std::endl;
+      }
+    } else if (prog_info.definitions.size() > 1) {
+      std::cout << "Progressive \"" << prog_name
+                << "\" has multiple definitions." << std::endl;
+    }
+
+    if (!prog_info.has_id) {
+      std::cout << "Progressive \"" << prog_name << "\" is missing an AP ID."
+                << std::endl;
+    }
   }
-  for (const auto& [ending_name, ending_info] : info.endings) {
-    ValidateEnding(ending_name, ending_info);
+
+  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_;
+};
+
+}  // namespace
+
+void ValidateCollectedInfo(const CollectedInfo& info) {
+  Validator validator(info);
+  validator.Validate();
 }
 
 }  // namespace com::fourisland::lingo2_archipelago
@@ -1,4 +1,4 @@
-#ifndef TOOLS_VALIDATOR_VALIDATOR_H_
+#ifndef TOOLS_VALIDATOR_VALIDATOR_H
 #define TOOLS_VALIDATOR_VALIDATOR_H
 
 namespace com::fourisland::lingo2_archipelago {
@@ -1,12 +1,13 @@
 {
   "dependencies": [
+    "fmt",
     "protobuf",
     "yaml-cpp"
   ],
   "overrides": [
     {
       "name": "protobuf",
-      "version": "5.29.3"
+      "version": "3.21.12"
     }
   ]
 }
\ No newline at end of file
@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2018, oniksan
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the copyright holder nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
@@ -0,0 +1,4 @@
+This is a fork of https://github.com/oniksan/godobuf with some minor changes so
+that it is able to compile the Lingo 2 randomizer proto files. The plugin parts
+of the project have also been removed since we only need the command line
+script.
@@ -0,0 +1,2254 @@
+#
+# BSD 3-Clause License
+#
+# Copyright (c) 2018 - 2023, Oleg Malyavkin
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# * Redistributions of source code must retain the above copyright notice, this
+#   list of conditions and the following disclaimer.
+#
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+#
+# * Neither the name of the copyright holder nor the names of its
+#   contributors may be used to endorse or promote products derived from
+#   this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+extends Node
+
+const PROTO_VERSION_CONST : String = "const PROTO_VERSION = "
+const PROTO_VERSION_DEFAULT : String = PROTO_VERSION_CONST + "0"
+
+class Document:
+        
+        func _init(doc_name : String, doc_text : String):
+                name = doc_name
+                text = doc_text
+        
+        var name : String
+        var text : String
+
+class TokenPosition:
+        func _init(b : int, e : int):
+                begin = b
+                end = e
+        var begin : int = 0
+        var end : int = 0
+
+class Helper:
+
+        class StringPosition:
+                func _init(s : int, c : int, l : int):
+                        str_num = s
+                        column = c
+                        length = l
+                var str_num : int
+                var column : int
+                var length : int
+        
+        static func str_pos(text : String, position : TokenPosition) -> StringPosition:
+                var cur_str : int = 1
+                var cur_col : int = 1
+                var res_str : int = 0
+                var res_col : int = 0
+                var res_length : int = 0
+                for i in range(text.length()):
+                        if text[i] == "\n":
+                                cur_str += 1
+                                cur_col = 0
+                        if position.begin == i:
+                                res_str = cur_str
+                                res_col = cur_col
+                                res_length = position.end - position.begin + 1
+                                break
+                        cur_col += 1
+                return StringPosition.new(res_str, res_col, res_length)
+        
+        static func text_pos(tokens : Array, index : int) -> TokenPosition:
+                var res_begin : int = 0
+                var res_end : int = 0
+                if index < tokens.size() && index >= 0:
+                        res_begin = tokens[index].position.begin
+                        res_end = tokens[index].position.end
+                return TokenPosition.new(res_begin, res_end)
+        
+        static func error_string(file_name, col, row, error_text):
+                return file_name + ":" + str(col) + ":" + str(row) + ": error: " + error_text
+
+class AnalyzeResult:
+        var classes : Array = []
+        var fields : Array = []
+        var groups : Array = []
+        var version : int = 0
+        var state : bool = false
+        var tokens : Array = []
+        var syntax : Analysis.TranslationResult
+        var imports : Array = []
+        var doc : Document
+        
+        func soft_copy() -> AnalyzeResult:
+                var res : AnalyzeResult = AnalyzeResult.new()
+                res.classes = classes
+                res.fields = fields
+                res.groups = groups
+                res.version = version
+                res.state = state
+                res.tokens = tokens
+                res.syntax = syntax
+                res.imports = imports
+                res.doc = doc
+                return res
+
+class Analysis:
+        
+        func _init(path : String, doc : Document):
+                path_dir = path
+                document = doc
+        
+        var document : Document
+        var path_dir : String
+        
+        const LEX = {
+                LETTER = "[A-Za-z]",
+                DIGIT_DEC = "[0-9]",
+                DIGIT_OCT = "[0-7]",
+                DIGIT_HEX = "[0-9]|[A-F]|[a-f]",
+                BRACKET_ROUND_LEFT = "\\(",
+                BRACKET_ROUND_RIGHT = "\\)",
+                BRACKET_CURLY_LEFT = "\\{",
+                BRACKET_CURLY_RIGHT = "\\}",
+                BRACKET_SQUARE_LEFT = "\\[",
+                BRACKET_SQUARE_RIGHT = "\\]",
+                BRACKET_ANGLE_LEFT = "\\<",
+                BRACKET_ANGLE_RIGHT = "\\>",
+                SEMICOLON = ";",
+                COMMA = ",",
+                EQUAL = "=",
+                SIGN = "\\+|\\-",
+                SPACE = "\\s",
+                QUOTE_SINGLE = "'",
+                QUOTE_DOUBLE = "\"",
+        }
+        
+        const TOKEN_IDENT : String = "(" + LEX.LETTER + "+" + "(" + LEX.LETTER + "|" + LEX.DIGIT_DEC + "|" + "_)*)"
+        const TOKEN_FULL_IDENT : String = TOKEN_IDENT + "{0,1}(\\." + TOKEN_IDENT + ")+"
+        const TOKEN_BRACKET_ROUND_LEFT : String = "(" + LEX.BRACKET_ROUND_LEFT + ")"
+        const TOKEN_BRACKET_ROUND_RIGHT : String = "(" + LEX.BRACKET_ROUND_RIGHT + ")"
+        const TOKEN_BRACKET_CURLY_LEFT : String = "(" + LEX.BRACKET_CURLY_LEFT + ")"
+        const TOKEN_BRACKET_CURLY_RIGHT : String = "(" + LEX.BRACKET_CURLY_RIGHT + ")"
+        const TOKEN_BRACKET_SQUARE_LEFT : String = "(" + LEX.BRACKET_SQUARE_LEFT + ")"
+        const TOKEN_BRACKET_SQUARE_RIGHT : String = "(" + LEX.BRACKET_SQUARE_RIGHT + ")"
+        const TOKEN_BRACKET_ANGLE_LEFT : String = "(" + LEX.BRACKET_ANGLE_LEFT + ")"
+        const TOKEN_BRACKET_ANGLE_RIGHT : String = "(" + LEX.BRACKET_ANGLE_RIGHT + ")"
+        const TOKEN_SEMICOLON : String = "(" + LEX.SEMICOLON + ")"
+        const TOKEN_EUQAL : String = "(" + LEX.EQUAL + ")"
+        const TOKEN_SIGN : String = "(" + LEX.SIGN + ")"
+        const TOKEN_LITERAL_DEC : String = "(([1-9])" + LEX.DIGIT_DEC +"*)"
+        const TOKEN_LITERAL_OCT : String = "(0" + LEX.DIGIT_OCT +"*)"
+        const TOKEN_LITERAL_HEX : String = "(0(x|X)(" + LEX.DIGIT_HEX +")+)"
+        const TOKEN_LITERAL_INT : String = "((\\+|\\-){0,1}" + TOKEN_LITERAL_DEC + "|" + TOKEN_LITERAL_OCT + "|" + TOKEN_LITERAL_HEX + ")"
+        const TOKEN_LITERAL_FLOAT_DEC : String = "(" + LEX.DIGIT_DEC + "+)"
+        const TOKEN_LITERAL_FLOAT_EXP : String = "((e|E)(\\+|\\-)?" + TOKEN_LITERAL_FLOAT_DEC + "+)"
+        const TOKEN_LITERAL_FLOAT : String = "((\\+|\\-){0,1}(" + TOKEN_LITERAL_FLOAT_DEC + "\\." + TOKEN_LITERAL_FLOAT_DEC + "?" + TOKEN_LITERAL_FLOAT_EXP + "?)|(" + TOKEN_LITERAL_FLOAT_DEC + TOKEN_LITERAL_FLOAT_EXP + ")|(\\." + TOKEN_LITERAL_FLOAT_DEC + TOKEN_LITERAL_FLOAT_EXP + "?))"
+        const TOKEN_SPACE : String = "(" + LEX.SPACE + ")+"
+        const TOKEN_COMMA : String = "(" + LEX.COMMA + ")"
+        const TOKEN_CHAR_ESC : String = "[\\\\(a|b|f|n|r|t|v|\\\\|'|\")]"
+        const TOKEN_OCT_ESC : String = "[\\\\" + LEX.DIGIT_OCT + "{3}]"
+        const TOKEN_HEX_ESC : String = "[\\\\(x|X)" + LEX.DIGIT_HEX + "{2}]"
+        const TOKEN_CHAR_EXCLUDE : String = "[^\\0\\n\\\\]"
+        const TOKEN_CHAR_VALUE : String = "(" + TOKEN_HEX_ESC + "|" + TOKEN_OCT_ESC + "|" + TOKEN_CHAR_ESC + "|" + TOKEN_CHAR_EXCLUDE + ")"
+        const TOKEN_STRING_SINGLE : String = "('" + TOKEN_CHAR_VALUE + "*?')"
+        const TOKEN_STRING_DOUBLE : String = "(\"" + TOKEN_CHAR_VALUE + "*?\")"
+        const TOKEN_COMMENT_SINGLE : String = "((//[^\\n\\r]*[^\\s])|//)"
+        const TOKEN_COMMENT_MULTI : String = "/\\*(.|[\\n\\r])*?\\*/"
+        
+        const TOKEN_SECOND_MESSAGE : String = "^message$"
+        const TOKEN_SECOND_SIMPLE_DATA_TYPE : String = "^(double|float|int32|int64|uint32|uint64|sint32|sint64|fixed32|fixed64|sfixed32|sfixed64|bool|string|bytes)$"
+        const TOKEN_SECOND_ENUM : String = "^enum$"
+        const TOKEN_SECOND_MAP : String = "^map$"
+        const TOKEN_SECOND_ONEOF : String = "^oneof$"
+        const TOKEN_SECOND_LITERAL_BOOL : String = "^(true|false)$"
+        const TOKEN_SECOND_SYNTAX : String = "^syntax$"
+        const TOKEN_SECOND_IMPORT : String = "^import$"
+        const TOKEN_SECOND_PACKAGE : String = "^package$"
+        const TOKEN_SECOND_OPTION : String = "^option$"
+        const TOKEN_SECOND_SERVICE : String = "^service$"
+        const TOKEN_SECOND_RESERVED : String = "^reserved$"
+        const TOKEN_SECOND_IMPORT_QUALIFICATION : String = "^(weak|public)$"
+        const TOKEN_SECOND_FIELD_QUALIFICATION : String = "^(repeated|required|optional)$"
+        const TOKEN_SECOND_ENUM_OPTION : String = "^allow_alias$"
+        const TOKEN_SECOND_QUALIFICATION : String = "^(custom_option|extensions)$"
+        const TOKEN_SECOND_FIELD_OPTION : String = "^packed$"
+        
+        class TokenEntrance:
+                func _init(i : int, b : int, e : int, t : String):
+                        position = TokenPosition.new(b, e)
+                        text = t
+                        id = i
+                var position : TokenPosition
+                var text : String
+                var id : int
+        
+        enum RANGE_STATE {
+                INCLUDE = 0,
+                EXCLUDE_LEFT = 1,
+                EXCLUDE_RIGHT = 2,
+                OVERLAY = 3,
+                EQUAL = 4,
+                ENTERS = 5
+        }
+        
+        class TokenRange:
+                func _init(b : int, e : int, s):
+                        position = TokenPosition.new(b, e)
+                        state = s
+                var position : TokenPosition
+                var state
+        
+        class Token:
+                var _regex : RegEx
+                var _entrance : TokenEntrance = null
+                var _entrances : Array = []
+                var _entrance_index : int = 0
+                var _id : int
+                var _ignore : bool
+                var _clarification : String
+                
+                func _init(id : int, clarification : String, regex_str : String, ignore = false):
+                        _id = id
+                        _regex = RegEx.new()
+                        _regex.compile(regex_str)
+                        _clarification = clarification
+                        _ignore = ignore
+                        
+                func find(text : String, start : int) -> TokenEntrance:
+                        _entrance = null
+                        if !_regex.is_valid():
+                                return null
+                        var match_result : RegExMatch = _regex.search(text, start)
+                        if match_result != null:
+                                var capture
+                                capture = match_result.get_string(0)
+                                if capture.is_empty():
+                                        return null
+                                _entrance = TokenEntrance.new(_id, match_result.get_start(0), capture.length() - 1 + match_result.get_start(0), capture)
+                        return _entrance
+                        
+                func find_all(text : String) -> Array:
+                        var pos : int = 0
+                        clear()
+                        while find(text, pos) != null:
+                                _entrances.append(_entrance)
+                                pos = _entrance.position.end + 1
+                        return _entrances
+                
+                func add_entrance(entrance) -> void:
+                        _entrances.append(entrance)
+                
+                func clear() -> void:
+                        _entrance = null
+                        _entrances = []
+                        _entrance_index = 0
+                        
+                func get_entrances() -> Array:
+                        return _entrances
+                
+                func remove_entrance(index) -> void:
+                        if index < _entrances.size():
+                                _entrances.remove_at(index)
+                
+                func get_index() -> int:
+                        return _entrance_index
+                        
+                func set_index(index : int) -> void:
+                        if index < _entrances.size():
+                                _entrance_index = index
+                        else:
+                                _entrance_index = 0
+                
+                func is_ignore() -> bool:
+                        return _ignore
+                        
+                func get_clarification() -> String:
+                        return _clarification
+        
+        class TokenResult:
+                var tokens : Array = []
+                var errors : Array = []
+        
+        enum TOKEN_ID {
+                UNDEFINED = -1,
+                IDENT = 0,
+                FULL_IDENT = 1,
+                BRACKET_ROUND_LEFT = 2,
+                BRACKET_ROUND_RIGHT = 3,
+                BRACKET_CURLY_LEFT = 4,
+                BRACKET_CURLY_RIGHT = 5,
+                BRACKET_SQUARE_LEFT = 6,
+                BRACKET_SQUARE_RIGHT = 7,
+                BRACKET_ANGLE_LEFT = 8,
+                BRACKET_ANGLE_RIGHT = 9,
+                SEMICOLON = 10,
+                EUQAL = 11,
+                SIGN = 12,
+                INT = 13,
+                FLOAT = 14,
+                SPACE = 15,
+                COMMA = 16,
+                STRING_SINGLE = 17,
+                STRING_DOUBLE = 18,
+                COMMENT_SINGLE = 19,
+                COMMENT_MULTI = 20,
+                
+                MESSAGE = 21,
+                SIMPLE_DATA_TYPE = 22,
+                ENUM = 23,
+                MAP = 24,
+                ONEOF = 25,
+                LITERAL_BOOL = 26,
+                SYNTAX = 27,
+                IMPORT = 28,
+                PACKAGE = 29,
+                OPTION = 30,
+                SERVICE = 31,
+                RESERVED = 32,
+                IMPORT_QUALIFICATION = 33,
+                FIELD_QUALIFICATION = 34,
+                ENUM_OPTION = 35,
+                QUALIFICATION = 36,
+                FIELD_OPTION = 37,
+                
+                STRING = 38
+        }
+        
+        var TOKEN = {
+                TOKEN_ID.IDENT: Token.new(TOKEN_ID.IDENT, "Identifier", TOKEN_IDENT),
+                TOKEN_ID.FULL_IDENT: Token.new(TOKEN_ID.FULL_IDENT, "Full identifier", TOKEN_FULL_IDENT),
+                TOKEN_ID.BRACKET_ROUND_LEFT: Token.new(TOKEN_ID.BRACKET_ROUND_LEFT, "(", TOKEN_BRACKET_ROUND_LEFT),
+                TOKEN_ID.BRACKET_ROUND_RIGHT: Token.new(TOKEN_ID.BRACKET_ROUND_RIGHT, ")", TOKEN_BRACKET_ROUND_RIGHT),
+                TOKEN_ID.BRACKET_CURLY_LEFT: Token.new(TOKEN_ID.BRACKET_CURLY_LEFT, "{", TOKEN_BRACKET_CURLY_LEFT),
+                TOKEN_ID.BRACKET_CURLY_RIGHT: Token.new(TOKEN_ID.BRACKET_CURLY_RIGHT, "}", TOKEN_BRACKET_CURLY_RIGHT),
+                TOKEN_ID.BRACKET_SQUARE_LEFT: Token.new(TOKEN_ID.BRACKET_SQUARE_LEFT, "[", TOKEN_BRACKET_SQUARE_LEFT),
+                TOKEN_ID.BRACKET_SQUARE_RIGHT: Token.new(TOKEN_ID.BRACKET_SQUARE_RIGHT, "]", TOKEN_BRACKET_SQUARE_RIGHT),
+                TOKEN_ID.BRACKET_ANGLE_LEFT: Token.new(TOKEN_ID.BRACKET_ANGLE_LEFT, "<", TOKEN_BRACKET_ANGLE_LEFT),
+                TOKEN_ID.BRACKET_ANGLE_RIGHT: Token.new(TOKEN_ID.BRACKET_ANGLE_RIGHT, ">", TOKEN_BRACKET_ANGLE_RIGHT),
+                TOKEN_ID.SEMICOLON: Token.new(TOKEN_ID.SEMICOLON, ";", TOKEN_SEMICOLON),
+                TOKEN_ID.EUQAL: Token.new(TOKEN_ID.EUQAL, "=", TOKEN_EUQAL),
+                TOKEN_ID.INT: Token.new(TOKEN_ID.INT, "Integer", TOKEN_LITERAL_INT),
+                TOKEN_ID.FLOAT: Token.new(TOKEN_ID.FLOAT, "Float", TOKEN_LITERAL_FLOAT),
+                TOKEN_ID.SPACE: Token.new(TOKEN_ID.SPACE, "Space", TOKEN_SPACE),
+                TOKEN_ID.COMMA: Token.new(TOKEN_ID.COMMA, ",", TOKEN_COMMA),
+                TOKEN_ID.STRING_SINGLE: Token.new(TOKEN_ID.STRING_SINGLE, "'String'", TOKEN_STRING_SINGLE),
+                TOKEN_ID.STRING_DOUBLE: Token.new(TOKEN_ID.STRING_DOUBLE, "\"String\"", TOKEN_STRING_DOUBLE),
+                TOKEN_ID.COMMENT_SINGLE: Token.new(TOKEN_ID.COMMENT_SINGLE, "//Comment", TOKEN_COMMENT_SINGLE),
+                TOKEN_ID.COMMENT_MULTI: Token.new(TOKEN_ID.COMMENT_MULTI, "/*Comment*/", TOKEN_COMMENT_MULTI),
+                
+                TOKEN_ID.MESSAGE: Token.new(TOKEN_ID.MESSAGE, "Message", TOKEN_SECOND_MESSAGE, true),
+                TOKEN_ID.SIMPLE_DATA_TYPE: Token.new(TOKEN_ID.SIMPLE_DATA_TYPE, "Data type", TOKEN_SECOND_SIMPLE_DATA_TYPE, true),
+                TOKEN_ID.ENUM: Token.new(TOKEN_ID.ENUM, "Enum", TOKEN_SECOND_ENUM, true),
+                TOKEN_ID.MAP: Token.new(TOKEN_ID.MAP, "Map", TOKEN_SECOND_MAP, true),
+                TOKEN_ID.ONEOF: Token.new(TOKEN_ID.ONEOF, "OneOf", TOKEN_SECOND_ONEOF, true),
+                TOKEN_ID.LITERAL_BOOL: Token.new(TOKEN_ID.LITERAL_BOOL, "Bool literal", TOKEN_SECOND_LITERAL_BOOL, true),
+                TOKEN_ID.SYNTAX: Token.new(TOKEN_ID.SYNTAX, "Syntax", TOKEN_SECOND_SYNTAX, true),
+                TOKEN_ID.IMPORT: Token.new(TOKEN_ID.IMPORT, "Import", TOKEN_SECOND_IMPORT, true),
+                TOKEN_ID.PACKAGE: Token.new(TOKEN_ID.PACKAGE, "Package", TOKEN_SECOND_PACKAGE, true),
+                TOKEN_ID.OPTION: Token.new(TOKEN_ID.OPTION, "Option", TOKEN_SECOND_OPTION, true),
+                TOKEN_ID.SERVICE: Token.new(TOKEN_ID.SERVICE, "Service", TOKEN_SECOND_SERVICE, true),
+                TOKEN_ID.RESERVED: Token.new(TOKEN_ID.RESERVED, "Reserved", TOKEN_SECOND_RESERVED, true),
+                TOKEN_ID.IMPORT_QUALIFICATION: Token.new(TOKEN_ID.IMPORT_QUALIFICATION, "Import qualification", TOKEN_SECOND_IMPORT_QUALIFICATION, true),
+                TOKEN_ID.FIELD_QUALIFICATION: Token.new(TOKEN_ID.FIELD_QUALIFICATION, "Field qualification", TOKEN_SECOND_FIELD_QUALIFICATION, true),
+                TOKEN_ID.ENUM_OPTION: Token.new(TOKEN_ID.ENUM_OPTION, "Enum option", TOKEN_SECOND_ENUM_OPTION, true),
+                TOKEN_ID.QUALIFICATION: Token.new(TOKEN_ID.QUALIFICATION, "Qualification", TOKEN_SECOND_QUALIFICATION, true),
+                TOKEN_ID.FIELD_OPTION: Token.new(TOKEN_ID.FIELD_OPTION, "Field option", TOKEN_SECOND_FIELD_OPTION, true),
+                
+                TOKEN_ID.STRING: Token.new(TOKEN_ID.STRING, "String", "", true)
+        }
+        
+        static func check_range(main : TokenEntrance, current : TokenEntrance) -> TokenRange:
+                if main.position.begin > current.position.begin:
+                        if main.position.end > current.position.end:
+                                if main.position.begin >= current.position.end:
+                                        return TokenRange.new(current.position.begin, current.position.end, RANGE_STATE.EXCLUDE_LEFT)
+                                else:
+                                        return TokenRange.new(main.position.begin, current.position.end, RANGE_STATE.OVERLAY)
+                        else:
+                                return TokenRange.new(current.position.begin, current.position.end, RANGE_STATE.ENTERS)
+                elif main.position.begin < current.position.begin:
+                        if main.position.end >= current.position.end:
+                                return TokenRange.new(main.position.begin, main.position.end, RANGE_STATE.INCLUDE)
+                        else:
+                                if main.position.end < current.position.begin:
+                                        return TokenRange.new(main.position.begin, main.position.end, RANGE_STATE.EXCLUDE_RIGHT)
+                                else:
+                                        return TokenRange.new(main.position.begin, current.position.end, RANGE_STATE.OVERLAY)
+                else:
+                        if main.position.end == current.position.end:
+                                return TokenRange.new(main.position.begin, main.position.end, RANGE_STATE.EQUAL)
+                        elif main.position.end > current.position.end:
+                                return TokenRange.new(main.position.begin, main.position.end, RANGE_STATE.INCLUDE)
+                        else:
+                                return TokenRange.new(current.position.begin, current.position.end, RANGE_STATE.ENTERS)
+
+        func tokenizer() -> TokenResult:
+                for k in TOKEN:
+                        if !TOKEN[k].is_ignore():
+                                TOKEN[k].find_all(document.text)
+                var second_tokens : Array = []
+                second_tokens.append(TOKEN[TOKEN_ID.MESSAGE])
+                second_tokens.append(TOKEN[TOKEN_ID.SIMPLE_DATA_TYPE])
+                second_tokens.append(TOKEN[TOKEN_ID.ENUM])
+                second_tokens.append(TOKEN[TOKEN_ID.MAP])
+                second_tokens.append(TOKEN[TOKEN_ID.ONEOF])
+                second_tokens.append(TOKEN[TOKEN_ID.LITERAL_BOOL])
+                second_tokens.append(TOKEN[TOKEN_ID.SYNTAX])
+                second_tokens.append(TOKEN[TOKEN_ID.IMPORT])
+                second_tokens.append(TOKEN[TOKEN_ID.PACKAGE])
+                second_tokens.append(TOKEN[TOKEN_ID.OPTION])
+                second_tokens.append(TOKEN[TOKEN_ID.SERVICE])
+                second_tokens.append(TOKEN[TOKEN_ID.RESERVED])
+                second_tokens.append(TOKEN[TOKEN_ID.IMPORT_QUALIFICATION])
+                second_tokens.append(TOKEN[TOKEN_ID.FIELD_QUALIFICATION])
+                second_tokens.append(TOKEN[TOKEN_ID.ENUM_OPTION])
+                second_tokens.append(TOKEN[TOKEN_ID.QUALIFICATION])
+                second_tokens.append(TOKEN[TOKEN_ID.FIELD_OPTION])
+                
+                var ident_token : Token = TOKEN[TOKEN_ID.IDENT]
+                for sec_token in second_tokens:
+                        var remove_indexes : Array = []
+                        for i in range(ident_token.get_entrances().size()):
+                                var entrance : TokenEntrance = sec_token.find(ident_token.get_entrances()[i].text, 0)
+                                if entrance != null:
+                                        entrance.position.begin = ident_token.get_entrances()[i].position.begin
+                                        entrance.position.end = ident_token.get_entrances()[i].position.end
+                                        sec_token.add_entrance(entrance)
+                                        remove_indexes.append(i)
+                        for i in range(remove_indexes.size()):
+                                ident_token.remove_entrance(remove_indexes[i] - i)
+                for v in TOKEN[TOKEN_ID.STRING_DOUBLE].get_entrances():
+                        v.id = TOKEN_ID.STRING
+                        TOKEN[TOKEN_ID.STRING].add_entrance(v)
+                TOKEN[TOKEN_ID.STRING_DOUBLE].clear()
+                for v in TOKEN[TOKEN_ID.STRING_SINGLE].get_entrances():
+                        v.id = TOKEN_ID.STRING
+                        TOKEN[TOKEN_ID.STRING].add_entrance(v)
+                TOKEN[TOKEN_ID.STRING_SINGLE].clear()
+                var main_token : TokenEntrance
+                var cur_token : TokenEntrance
+                var main_index : int = -1
+                var token_index_flag : bool = false
+                var result : TokenResult = TokenResult.new()
+                var check : TokenRange
+                var end : bool = false
+                var all : bool = false
+                var repeat : bool = false
+                while true:
+                        all = true
+                        for k in TOKEN:
+                                if main_index == k:
+                                        continue
+                                repeat = false
+                                while TOKEN[k].get_entrances().size() > 0:
+                                        all = false
+                                        if !token_index_flag:
+                                                main_index = k
+                                                main_token = TOKEN[main_index].get_entrances()[0]
+                                                token_index_flag = true
+                                                break
+                                        else:
+                                                cur_token = TOKEN[k].get_entrances()[0]
+                                                check = check_range(main_token, cur_token)
+                                                if check.state == RANGE_STATE.INCLUDE:
+                                                        TOKEN[k].remove_entrance(0)
+                                                        end = true
+                                                elif check.state == RANGE_STATE.EXCLUDE_LEFT:
+                                                        main_token = cur_token
+                                                        main_index = k
+                                                        end = false
+                                                        repeat = true
+                                                        break
+                                                elif check.state == RANGE_STATE.EXCLUDE_RIGHT:
+                                                        end = true
+                                                        break
+                                                elif check.state == RANGE_STATE.OVERLAY || check.state == RANGE_STATE.EQUAL:
+                                                        result.errors.append(check)
+                                                        TOKEN[main_index].remove_entrance(0)
+                                                        TOKEN[k].remove_entrance(0)
+                                                        token_index_flag = false
+                                                        end = false
+                                                        repeat = true
+                                                        break
+                                                elif check.state == RANGE_STATE.ENTERS:
+                                                        TOKEN[main_index].remove_entrance(0)
+                                                        main_token = cur_token
+                                                        main_index = k
+                                                        end = false
+                                                        repeat = true
+                                                        break
+                                if repeat:
+                                        break
+                        if end:
+                                if TOKEN[main_index].get_entrances().size() > 0:
+                                        result.tokens.append(main_token)
+                                        TOKEN[main_index].remove_entrance(0)
+                                token_index_flag = false
+                        if all:
+                                break
+                return result
+
+        static func check_tokens_integrity(tokens : Array, end : int) -> Array:
+                var cur_index : int = 0
+                var result : Array = []
+                for v in tokens:
+                        if v.position.begin > cur_index:
+                                result.append(TokenPosition.new(cur_index, v.position.begin))
+                        cur_index = v.position.end + 1
+                if cur_index < end:
+                        result.append(TokenPosition.new(cur_index, end))
+                return result
+
+        static func comment_space_processing(tokens : Array) -> void:
+                var remove_indexes : Array = []
+                for i in range(tokens.size()):
+                        if tokens[i].id == TOKEN_ID.COMMENT_SINGLE || tokens[i].id == TOKEN_ID.COMMENT_MULTI:
+                                tokens[i].id = TOKEN_ID.SPACE
+                var space_index : int = -1
+                for i in range(tokens.size()):
+                        if tokens[i].id == TOKEN_ID.SPACE:
+                                if space_index >= 0:
+                                        tokens[space_index].position.end = tokens[i].position.end
+                                        tokens[space_index].text = tokens[space_index].text + tokens[i].text
+                                        remove_indexes.append(i)
+                                else:
+                                        space_index = i
+                        else:
+                                space_index = -1
+                for i in range(remove_indexes.size()):
+                        tokens.remove_at(remove_indexes[i] - i)
+        
+        #Analysis rule
+        enum AR {
+                MAYBE = 1,
+                MUST_ONE = 2,
+                ANY = 3,
+                OR = 4,
+                MAYBE_BEGIN = 5,
+                MAYBE_END = 6,
+                ANY_BEGIN = 7,
+                ANY_END = 8
+        }
+
+        #Space rule (space after token)
+        enum SP {
+                MAYBE = 1,
+                MUST = 2,
+                NO = 3
+        }
+
+        #Analysis Syntax Description
+        class ASD:
+                func _init(t, s : int = SP.MAYBE, r : int = AR.MUST_ONE, i : bool = false):
+                        token = t
+                        space = s
+                        rule = r
+                        importance = i
+                var token
+                var space : int
+                var rule : int
+                var importance : bool
+        
+        var TEMPLATE_SYNTAX : Array = [
+                Callable(self, "desc_syntax"),
+                ASD.new(TOKEN_ID.SYNTAX),
+                ASD.new(TOKEN_ID.EUQAL),
+                ASD.new(TOKEN_ID.STRING, SP.MAYBE, AR.MUST_ONE, true),
+                ASD.new(TOKEN_ID.SEMICOLON)
+        ]
+        
+        var TEMPLATE_IMPORT : Array = [
+                Callable(self, "desc_import"),
+                ASD.new(TOKEN_ID.IMPORT, SP.MUST),
+                ASD.new(TOKEN_ID.IMPORT_QUALIFICATION, SP.MUST, AR.MAYBE, true),
+                ASD.new(TOKEN_ID.STRING, SP.MAYBE, AR.MUST_ONE, true),
+                ASD.new(TOKEN_ID.SEMICOLON)
+        ]
+        
+        var TEMPLATE_PACKAGE : Array = [
+                Callable(self, "desc_package"),
+                ASD.new(TOKEN_ID.PACKAGE, SP.MUST),
+                ASD.new([TOKEN_ID.IDENT, TOKEN_ID.FULL_IDENT], SP.MAYBE, AR.OR, true),
+                ASD.new(TOKEN_ID.SEMICOLON)
+        ]
+        
+        var TEMPLATE_OPTION : Array = [
+                Callable(self, "desc_option"),
+                ASD.new(TOKEN_ID.OPTION, SP.MUST),
+                ASD.new([TOKEN_ID.IDENT, TOKEN_ID.FULL_IDENT], SP.MAYBE, AR.OR, true),
+                ASD.new(TOKEN_ID.EUQAL),
+                ASD.new([TOKEN_ID.STRING, TOKEN_ID.INT, TOKEN_ID.FLOAT, TOKEN_ID.LITERAL_BOOL], SP.MAYBE, AR.OR, true),
+                ASD.new(TOKEN_ID.SEMICOLON)
+        ]
+        
+        var TEMPLATE_FIELD : Array = [
+                Callable(self, "desc_field"),
+                ASD.new(TOKEN_ID.FIELD_QUALIFICATION, SP.MUST, AR.MAYBE, true),
+                ASD.new([TOKEN_ID.SIMPLE_DATA_TYPE, TOKEN_ID.IDENT, TOKEN_ID.FULL_IDENT], SP.MAYBE, AR.OR, true),
+                ASD.new(TOKEN_ID.IDENT, SP.MAYBE, AR.MUST_ONE, true),
+                ASD.new(TOKEN_ID.EUQAL),
+                ASD.new(TOKEN_ID.INT, SP.MAYBE, AR.MUST_ONE, true),
+                ASD.new(TOKEN_ID.BRACKET_SQUARE_LEFT, SP.MAYBE, AR.MAYBE_BEGIN),
+                ASD.new(TOKEN_ID.FIELD_OPTION, SP.MAYBE, AR.MUST_ONE, true),
+                ASD.new(TOKEN_ID.EUQAL),
+                ASD.new(TOKEN_ID.LITERAL_BOOL, SP.MAYBE, AR.MUST_ONE, true),
+                ASD.new(TOKEN_ID.BRACKET_SQUARE_RIGHT, SP.MAYBE, AR.MAYBE_END),
+                ASD.new(TOKEN_ID.SEMICOLON)
+        ]
+        
+        var TEMPLATE_FIELD_ONEOF : Array = TEMPLATE_FIELD
+        
+        var TEMPLATE_MAP_FIELD : Array = [
+                Callable(self, "desc_map_field"),
+                ASD.new(TOKEN_ID.MAP),
+                ASD.new(TOKEN_ID.BRACKET_ANGLE_LEFT),
+                ASD.new(TOKEN_ID.SIMPLE_DATA_TYPE, SP.MAYBE, AR.MUST_ONE, true),
+                ASD.new(TOKEN_ID.COMMA),
+                ASD.new([TOKEN_ID.SIMPLE_DATA_TYPE, TOKEN_ID.IDENT, TOKEN_ID.FULL_IDENT], SP.MAYBE, AR.OR, true),
+                ASD.new(TOKEN_ID.BRACKET_ANGLE_RIGHT, SP.MUST),
+                ASD.new(TOKEN_ID.IDENT, SP.MAYBE, AR.MUST_ONE, true),
+                ASD.new(TOKEN_ID.EUQAL),
+                ASD.new(TOKEN_ID.INT, SP.MAYBE, AR.MUST_ONE, true),
+                ASD.new(TOKEN_ID.BRACKET_SQUARE_LEFT, SP.MAYBE, AR.MAYBE_BEGIN),
+                ASD.new(TOKEN_ID.FIELD_OPTION, SP.MAYBE, AR.MUST_ONE, true),
+                ASD.new(TOKEN_ID.EUQAL),
+                ASD.new(TOKEN_ID.LITERAL_BOOL, SP.MAYBE, AR.MUST_ONE, true),
+                ASD.new(TOKEN_ID.BRACKET_SQUARE_RIGHT, SP.MAYBE, AR.MAYBE_END),
+                ASD.new(TOKEN_ID.SEMICOLON)
+        ]
+        
+        var TEMPLATE_MAP_FIELD_ONEOF : Array = TEMPLATE_MAP_FIELD
+        
+        var TEMPLATE_ENUM : Array = [
+                Callable(self, "desc_enum"),
+                ASD.new(TOKEN_ID.ENUM, SP.MUST),
+                ASD.new(TOKEN_ID.IDENT, SP.MAYBE, AR.MUST_ONE, true),
+                ASD.new(TOKEN_ID.BRACKET_CURLY_LEFT),
+                ASD.new(TOKEN_ID.OPTION, SP.MUST, AR.MAYBE_BEGIN),
+                ASD.new(TOKEN_ID.ENUM_OPTION, SP.MAYBE, AR.MUST_ONE, true),
+                ASD.new(TOKEN_ID.EUQAL),
+                ASD.new(TOKEN_ID.LITERAL_BOOL, SP.MAYBE, AR.MUST_ONE, true),
+                ASD.new(TOKEN_ID.SEMICOLON, SP.MAYBE, AR.MAYBE_END),
+                ASD.new(TOKEN_ID.IDENT, SP.MAYBE, AR.ANY_BEGIN, true),
+                ASD.new(TOKEN_ID.EUQAL),
+                ASD.new(TOKEN_ID.INT, SP.MAYBE, AR.MUST_ONE, true),
+                ASD.new(TOKEN_ID.SEMICOLON, SP.MAYBE, AR.ANY_END),
+                ASD.new(TOKEN_ID.BRACKET_CURLY_RIGHT)
+        ]
+        
+        var TEMPLATE_MESSAGE_HEAD : Array = [
+                Callable(self, "desc_message_head"),
+                ASD.new(TOKEN_ID.MESSAGE, SP.MUST),
+                ASD.new(TOKEN_ID.IDENT, SP.MAYBE, AR.MUST_ONE, true),
+                ASD.new(TOKEN_ID.BRACKET_CURLY_LEFT)
+        ]
+        
+        var TEMPLATE_MESSAGE_TAIL : Array = [
+                Callable(self, "desc_message_tail"),
+                ASD.new(TOKEN_ID.BRACKET_CURLY_RIGHT)
+        ]
+        
+        var TEMPLATE_ONEOF_HEAD : Array = [
+                Callable(self, "desc_oneof_head"),
+                ASD.new(TOKEN_ID.ONEOF, SP.MUST),
+                ASD.new(TOKEN_ID.IDENT, SP.MAYBE, AR.MUST_ONE, true),
+                ASD.new(TOKEN_ID.BRACKET_CURLY_LEFT),
+        ]
+        
+        var TEMPLATE_ONEOF_TAIL : Array = [
+                Callable(self, "desc_oneof_tail"),
+                ASD.new(TOKEN_ID.BRACKET_CURLY_RIGHT)
+        ]
+        
+        var TEMPLATE_BEGIN : Array = [
+                null,
+                ASD.new(TOKEN_ID.SPACE, SP.NO, AR.MAYBE)
+        ]
+        
+        var TEMPLATE_END : Array = [
+                null
+        ]
+        
+        func get_token_id(tokens : Array, index : int) -> int:
+                if index < tokens.size():
+                        return tokens[index].id
+                return TOKEN_ID.UNDEFINED
+        
+        enum COMPARE_STATE {
+                DONE = 0,
+                MISMATCH = 1,
+                INCOMPLETE = 2,
+                ERROR_VALUE = 3
+        }
+
+        class TokenCompare:
+                func _init(s : int, i : int, d : String = ""):
+                        state = s
+                        index = i
+                        description = d
+                var state : int
+                var index : int
+                var description : String
+        
+        func check_space(tokens : Array, index : int, space) -> int:
+                if get_token_id(tokens, index) == TOKEN_ID.SPACE:
+                        if space == SP.MAYBE:
+                                return 1
+                        elif space == SP.MUST:
+                                return 1
+                        elif space == SP.NO:
+                                return -1
+                else:
+                        if space == SP.MUST:
+                                return -2
+                return 0
+        
+        class IndexedToken:
+                func _init(t : TokenEntrance, i : int):
+                        token = t
+                        index = i
+                var token : TokenEntrance
+                var index : int
+        
+        func token_importance_checkadd(template : ASD, token : TokenEntrance, index : int, importance : Array) -> void:
+                if template.importance:
+                        importance.append(IndexedToken.new(token, index))
+        
+        class CompareSettings:
+                func _init(ci : int, n : int, pi : int, pn : String = ""):
+                        construction_index = ci
+                        nesting = n
+                        parent_index = pi
+                        parent_name = pn
+                        
+                var construction_index : int
+                var nesting : int
+                var parent_index : int
+                var parent_name : String
+        
+        func description_compare(template : Array, tokens : Array, index : int, settings : CompareSettings) -> TokenCompare:
+                var j : int = index
+                var space : int
+                var rule : int
+                var rule_flag : bool
+                var cont : bool
+                var check : int
+                var maybe_group_skip : bool = false
+                var any_group_index : int = -1
+                var any_end_group_index : int = -1
+                var i : int = 0
+                var importance : Array = []
+                while true:
+                        i += 1
+                        if i >= template.size():
+                                break
+                        rule_flag = false
+                        cont = false
+                        rule = template[i].rule
+                        space = template[i].space
+                        if rule == AR.MAYBE_END && maybe_group_skip:
+                                maybe_group_skip = false
+                                continue
+                        if maybe_group_skip:
+                                continue
+                        if rule == AR.MAYBE:
+                                if template[i].token == get_token_id(tokens, j):
+                                        token_importance_checkadd(template[i], tokens[j], j, importance)
+                                        rule_flag = true
+                                else:
+                                        continue
+                        elif rule == AR.MUST_ONE || rule == AR.MAYBE_END || rule == AR.ANY_END:
+                                if template[i].token == get_token_id(tokens, j):
+                                        token_importance_checkadd(template[i], tokens[j], j, importance)
+                                        rule_flag = true
+                        elif rule == AR.ANY:
+                                var find_any : bool = false
+                                while true:
+                                        if template[i].token == get_token_id(tokens, j):
+                                                token_importance_checkadd(template[i], tokens[j], j, importance)
+                                                find_any = true
+                                                j += 1
+                                                check = check_space(tokens, j, space)
+                                                if check < 0:
+                                                        return TokenCompare.new(COMPARE_STATE.INCOMPLETE, j)
+                                                else:
+                                                        j += check
+                                        else:
+                                                if find_any:
+                                                        cont = true
+                                                break
+                        elif rule == AR.OR:
+                                var or_tokens = template[i].token
+                                for v in or_tokens:
+                                        if v == get_token_id(tokens, j):
+                                                token_importance_checkadd(template[i], tokens[j], j, importance)
+                                                j += 1
+                                                check = check_space(tokens, j, space)
+                                                if check < 0:
+                                                        return TokenCompare.new(COMPARE_STATE.INCOMPLETE, j)
+                                                else:
+                                                        j += check
+                                                        cont = true
+                                                        break
+                        elif rule == AR.MAYBE_BEGIN:
+                                if template[i].token == get_token_id(tokens, j):
+                                        token_importance_checkadd(template[i], tokens[j], j, importance)
+                                        rule_flag = true
+                                else:
+                                        maybe_group_skip = true
+                                        continue
+                        elif rule == AR.ANY_BEGIN:
+                                if template[i].token == get_token_id(tokens, j):
+                                        token_importance_checkadd(template[i], tokens[j], j, importance)
+                                        rule_flag = true
+                                        any_group_index = i
+                                else:
+                                        if any_end_group_index > 0:
+                                                any_group_index = -1
+                                                i = any_end_group_index
+                                                any_end_group_index = -1
+                                                continue
+                        if cont:
+                                continue
+                        if rule_flag:
+                                j += 1
+                                check = check_space(tokens, j, space)
+                                if check < 0:
+                                        return TokenCompare.new(COMPARE_STATE.INCOMPLETE, j)
+                                else:
+                                        j += check
+                        else:
+                                if j > index:
+                                        return TokenCompare.new(COMPARE_STATE.INCOMPLETE, j)
+                                else:
+                                        return TokenCompare.new(COMPARE_STATE.MISMATCH, j)
+                        if any_group_index >= 0 && rule == AR.ANY_END:
+                                any_end_group_index = i
+                                i = any_group_index - 1
+                if template[0] != null:
+                        var result : DescriptionResult = template[0].call(importance, settings)
+                        if !result.success:
+                                return TokenCompare.new(COMPARE_STATE.ERROR_VALUE, result.error, result.description)
+                return TokenCompare.new(COMPARE_STATE.DONE, j)
+        
+        var DESCRIPTION : Array = [
+                TEMPLATE_BEGIN,                         #0
+                TEMPLATE_SYNTAX,                        #1
+                TEMPLATE_IMPORT,                        #2
+                TEMPLATE_PACKAGE,                       #3
+                TEMPLATE_OPTION,                        #4
+                TEMPLATE_FIELD,                         #5
+                TEMPLATE_FIELD_ONEOF,           #6
+                TEMPLATE_MAP_FIELD,                     #7
+                TEMPLATE_MAP_FIELD_ONEOF,       #8
+                TEMPLATE_ENUM,                          #9
+                TEMPLATE_MESSAGE_HEAD,          #10
+                TEMPLATE_MESSAGE_TAIL,          #11
+                TEMPLATE_ONEOF_HEAD,            #12
+                TEMPLATE_ONEOF_TAIL,            #13
+                TEMPLATE_END                            #14
+        ]
+        
+        enum JUMP {
+                NOTHING = 0,                            #nothing
+                SIMPLE = 1,                                     #simple jump
+                NESTED_INCREMENT = 2,           #nested increment
+                NESTED_DECREMENT = 3,           #nested decrement
+                MUST_NESTED_SIMPLE = 4,         #check: must be nested > 0
+                MUST_NESTED_INCREMENT = 5,      #check: must be nested > 0, then nested increment
+                MUST_NESTED_DECREMENT = 6,      #nested decrement, then check: must be nested > 0
+        }
+        
+        var TRANSLATION_TABLE : Array = [
+        #   BEGIN       SYNTAX  IMPORT  PACKAGE OPTION  FIELD   FIELD_O MAP_F   MAP_F_O ENUM    MES_H   MES_T   ONEOF_H ONEOF_T END
+        [       0,              1,              0,              0,              0,              0,              0,              0,              0,              0,              0,              0,              0,              0,              0], #BEGIN
+        [       0,              0,              1,              1,              1,              0,              0,              0,              0,              1,              2,              0,              0,              0,              1], #SYNTAX
+        [       0,              0,              1,              1,              1,              0,              0,              0,              0,              1,              2,              0,              0,              0,              1], #IMPORT
+        [       0,              0,              1,              1,              1,              0,              0,              0,              0,              1,              2,              0,              0,              0,              1], #PACKAGE
+        [       0,              0,              1,              1,              1,              0,              0,              0,              0,              1,              2,              0,              0,              0,              1], #OPTION
+        [       0,              0,              0,              0,              0,              4,              0,              4,              0,              1,              2,              3,              5,              0,              0], #FIELD
+        [       0,              0,              0,              0,              0,              0,              4,              0,              4,              0,              0,              0,              0,              6,              0], #FIELD_ONEOF
+        [       0,              0,              0,              0,              0,              4,              0,              4,              0,              1,              2,              3,              5,              0,              0], #MAP_F
+        [       0,              0,              0,              0,              0,              0,              4,              0,              4,              0,              0,              0,              0,              6,              0], #MAP_F_ONEOF
+        [       0,              0,              0,              0,              0,              4,              0,              4,              0,              1,              2,              3,              5,              0,              1], #ENUM
+        [       0,              0,              0,              0,              0,              4,              0,              4,              0,              1,              2,              3,              5,              0,              0], #MES_H
+        [       0,              0,              0,              0,              0,              4,              0,              4,              0,              1,              2,              3,              5,              0,              1], #MES_T
+        [       0,              0,              0,              0,              0,              0,              4,              0,              4,              0,              0,              0,              0,              0,              0], #ONEOF_H
+        [       0,              0,              0,              0,              0,              4,              0,              4,              0,              1,              2,              3,              5,              0,              1], #ONEOF_T
+        [       0,              0,              0,              0,              0,              0,              0,              0,              0,              0,              0,              0,              0,              0,              0]  #END
+        ]
+        
+        class Construction:
+                func _init(b : int, e : int, d : int):
+                        begin_token_index = b
+                        end_token_index = e
+                        description = d
+                var begin_token_index : int
+                var end_token_index : int
+                var description : int
+        
+        class TranslationResult:
+                var constructions : Array = []
+                var done : bool = false
+                var error_description_id : int = -1
+                var error_description_text : String = ""
+                var parse_token_index : int = 0
+                var error_token_index : int = 0
+        
+        func analyze_tokens(tokens : Array) -> TranslationResult:
+                var i : int = 0
+                var result : TranslationResult = TranslationResult.new()
+                var comp : TokenCompare
+                var cur_template_id : int = 0
+                var error : bool = false
+                var template_index : int
+                var comp_set : CompareSettings = CompareSettings.new(result.constructions.size(), 0, -1)
+                comp = description_compare(DESCRIPTION[cur_template_id], tokens, i, comp_set)
+                if comp.state == COMPARE_STATE.DONE:
+                        i = comp.index
+                        while true:
+                                var end : bool = true
+                                var find : bool = false
+                                for j in range(TRANSLATION_TABLE[cur_template_id].size()):
+                                        template_index = j
+                                        if j == DESCRIPTION.size() - 1 && i < tokens.size():
+                                                end = false
+                                                if result.error_description_id < 0:
+                                                        error = true
+                                                break
+                                        if TRANSLATION_TABLE[cur_template_id][j] > 0:
+                                                end = false
+                                                comp_set.construction_index = result.constructions.size()
+                                                comp = description_compare(DESCRIPTION[j], tokens, i, comp_set)
+                                                if comp.state == COMPARE_STATE.DONE:
+                                                        if TRANSLATION_TABLE[cur_template_id][j] == JUMP.NESTED_INCREMENT:
+                                                                comp_set.nesting += 1
+                                                        elif TRANSLATION_TABLE[cur_template_id][j] == JUMP.NESTED_DECREMENT:
+                                                                comp_set.nesting -= 1
+                                                                if comp_set.nesting < 0:
+                                                                        error = true
+                                                                        break
+                                                        elif TRANSLATION_TABLE[cur_template_id][j] == JUMP.MUST_NESTED_SIMPLE:
+                                                                if comp_set.nesting <= 0:
+                                                                        error = true
+                                                                        break
+                                                        elif TRANSLATION_TABLE[cur_template_id][j] == JUMP.MUST_NESTED_INCREMENT:
+                                                                if comp_set.nesting <= 0:
+                                                                        error = true
+                                                                        break
+                                                                comp_set.nesting += 1
+                                                        elif TRANSLATION_TABLE[cur_template_id][j] == JUMP.MUST_NESTED_DECREMENT:
+                                                                comp_set.nesting -= 1
+                                                                if comp_set.nesting <= 0:
+                                                                        error = true
+                                                                        break
+                                                        result.constructions.append(Construction.new(i, comp.index, j))
+                                                        find = true
+                                                        i = comp.index
+                                                        cur_template_id = j
+                                                        if i == tokens.size():
+                                                                if TRANSLATION_TABLE[cur_template_id][DESCRIPTION.size() - 1] == JUMP.SIMPLE:
+                                                                        if comp_set.nesting == 0:
+                                                                                end = true
+                                                                        else:
+                                                                                error = true
+                                                                else:
+                                                                        error = true
+                                                        elif i > tokens.size():
+                                                                error = true
+                                                        break
+                                                elif comp.state == COMPARE_STATE.INCOMPLETE:
+                                                        error = true
+                                                        break
+                                                elif comp.state == COMPARE_STATE.ERROR_VALUE:
+                                                        error = true
+                                                        break
+                                if error:
+                                        result.error_description_text = comp.description
+                                        result.error_description_id = template_index
+                                        result.parse_token_index = i
+                                        if comp.index >= tokens.size():
+                                                result.error_token_index = tokens.size() - 1
+                                        else:
+                                                result.error_token_index = comp.index
+                                if end:
+                                        result.done = true
+                                        result.error_description_id = -1
+                                        break
+                                if !find:
+                                        break
+                return result
+        
+        enum CLASS_TYPE {
+                ENUM = 0,
+                MESSAGE = 1,
+                MAP = 2
+        }
+        
+        enum FIELD_TYPE {
+                UNDEFINED = -1,
+                INT32 = 0,
+                SINT32 = 1,
+                UINT32 = 2,
+                INT64 = 3,
+                SINT64 = 4,
+                UINT64 = 5,
+                BOOL = 6,
+                ENUM = 7,
+                FIXED32 = 8,
+                SFIXED32 = 9,
+                FLOAT = 10,
+                FIXED64 = 11,
+                SFIXED64 = 12,
+                DOUBLE = 13,
+                STRING = 14,
+                BYTES = 15,
+                MESSAGE = 16,
+                MAP = 17
+        }
+        
+        enum FIELD_QUALIFICATOR {
+                OPTIONAL = 0,
+                REQUIRED = 1,
+                REPEATED = 2,
+                RESERVED = 3
+        }
+        
+        enum FIELD_OPTION {
+                PACKED = 0,
+                NOT_PACKED = 1
+        }
+        
+        class ASTClass:
+                func _init(n : String, t : int, p : int, pn : String, o : String, ci : int):
+                        name = n
+                        type = t
+                        parent_index = p
+                        parent_name = pn
+                        option = o
+                        construction_index = ci
+                        values = []
+                
+                var name : String
+                var type : int
+                var parent_index : int
+                var parent_name : String
+                var option : String
+                var construction_index
+                var values : Array
+                
+                func copy() -> ASTClass:
+                        var res : ASTClass = ASTClass.new(name, type, parent_index, parent_name, option, construction_index)
+                        for v in values:
+                                res.values.append(v.copy())
+                        return res
+        
+        class ASTEnumValue:
+                func _init(n : String, v : String):
+                        name = n
+                        value = v
+                
+                var name : String
+                var value : String
+                
+                func copy() -> ASTEnumValue:
+                        return ASTEnumValue.new(name, value)
+        
+        class ASTField:
+                func _init(t, n : String, tn : String, p : int, q : int, o : int, ci : int, mf : bool):
+                        tag = t
+                        name = n
+                        type_name = tn
+                        parent_class_id = p
+                        qualificator = q
+                        option = o
+                        construction_index = ci
+                        is_map_field = mf
+                
+                var tag
+                var name : String
+                var type_name : String
+                var parent_class_id : int
+                var qualificator : int
+                var option : int
+                var construction_index : int
+                var is_map_field : bool
+                var field_type : int = FIELD_TYPE.UNDEFINED
+                var type_class_id : int = -1
+                
+                func copy() -> ASTField:
+                        var res : ASTField = ASTField.new(tag, name, type_name, parent_class_id, qualificator, option, construction_index, is_map_field)
+                        res.field_type = field_type
+                        res.type_class_id = type_class_id
+                        return res
+        
+        enum AST_GROUP_RULE {
+                ONEOF = 0,
+                ALL = 1
+        }
+        
+        class ASTFieldGroup:
+                func _init(n : String, pi : int, r : int):
+                        name = n
+                        parent_class_id = pi
+                        rule = r
+                        opened = true
+                        
+                var name : String
+                var parent_class_id : int
+                var rule : int
+                var field_indexes : Array = []
+                var opened : bool
+                
+                func copy() -> ASTFieldGroup:
+                        var res : ASTFieldGroup = ASTFieldGroup.new(name, parent_class_id, rule)
+                        res.opened = opened
+                        for fi in field_indexes:
+                                res.field_indexes.append(fi)
+                        return res
+        
+        class ASTImport:
+                func _init(a_path : String, a_public : bool, sha : String):
+                        path = a_path
+                        public = a_public
+                        sha256 = sha
+                        
+                var path : String
+                var public : bool
+                var sha256 : String
+        
+        var class_table : Array = []
+        var field_table : Array = []
+        var group_table : Array = []
+        var import_table : Array = []
+        var proto_version : int = 0
+        
+        class DescriptionResult:
+                func _init(s : bool = true, e = null, d : String = ""):
+                        success = s
+                        error = e
+                        description = d
+                var success : bool
+                var error
+                var description : String
+        
+        static func get_text_from_token(string_token : TokenEntrance) -> String:
+                return string_token.text.substr(1, string_token.text.length() - 2)
+        
+        func desc_syntax(indexed_tokens : Array, settings : CompareSettings) -> DescriptionResult:
+                var result : DescriptionResult = DescriptionResult.new()
+                var s : String = get_text_from_token(indexed_tokens[0].token)
+                if s == "proto2":
+                        proto_version = 2
+                elif s == "proto3":
+                        proto_version = 3
+                else:
+                        result.success = false
+                        result.error = indexed_tokens[0].index
+                        result.description = "Unspecified version of the protocol. Use \"proto2\" or \"proto3\" syntax string."
+                return result
+                
+        func desc_import(indexed_tokens : Array, settings : CompareSettings) -> DescriptionResult:
+                var result : DescriptionResult = DescriptionResult.new()
+                var offset : int = 0
+                var public : bool = false
+                if indexed_tokens[offset].token.id == TOKEN_ID.IMPORT_QUALIFICATION:
+                        if indexed_tokens[offset].token.text == "public":
+                                public = true
+                        offset += 1
+                var f_name : String = path_dir + get_text_from_token(indexed_tokens[offset].token)
+                var sha : String = FileAccess.get_sha256(f_name)
+                if FileAccess.file_exists(f_name):
+                        for i in import_table:
+                                if i.path == f_name:
+                                        result.success = false
+                                        result.error = indexed_tokens[offset].index
+                                        result.description = "File '" + f_name + "' already imported."
+                                        return result
+                                if i.sha256 == sha:
+                                        result.success = false
+                                        result.error = indexed_tokens[offset].index
+                                        result.description = "File '" + f_name + "' with matching SHA256 already imported."
+                                        return result
+                        import_table.append(ASTImport.new(f_name, public, sha))
+                else:
+                        result.success = false
+                        result.error = indexed_tokens[offset].index
+                        result.description = "Import file '" + f_name + "' not found."
+                return result
+                
+        func desc_package(indexed_tokens : Array, settings : CompareSettings) -> DescriptionResult:
+                printerr("UNRELEASED desc_package: ", indexed_tokens.size(), ", nesting: ", settings.nesting)
+                var result : DescriptionResult = DescriptionResult.new()
+                return result
+                
+        func desc_option(indexed_tokens : Array, settings : CompareSettings) -> DescriptionResult:
+                printerr("UNRELEASED desc_option: ", indexed_tokens.size(), ", nesting: ", settings.nesting)
+                var result : DescriptionResult = DescriptionResult.new()
+                return result
+        
+        func desc_field(indexed_tokens : Array, settings : CompareSettings) -> DescriptionResult:
+                var result : DescriptionResult = DescriptionResult.new()
+                var qualifcator : int = FIELD_QUALIFICATOR.OPTIONAL
+                var option : int
+                var offset : int = 0
+                
+                if proto_version == 3:
+                        option = FIELD_OPTION.PACKED
+                        if indexed_tokens[offset].token.id == TOKEN_ID.FIELD_QUALIFICATION:
+                                if indexed_tokens[offset].token.text == "repeated":
+                                        qualifcator = FIELD_QUALIFICATOR.REPEATED
+                                elif indexed_tokens[offset].token.text == "required" || indexed_tokens[offset].token.text == "optional":
+                                        result.success = false
+                                        result.error = indexed_tokens[offset].index
+                                        result.description = "Using the 'required' or 'optional' qualificator is unacceptable in Protobuf v3."
+                                        return result
+                                offset += 1
+                if proto_version == 2:
+                        option = FIELD_OPTION.NOT_PACKED
+                        if !(group_table.size() > 0 && group_table[group_table.size() - 1].opened):
+                                if indexed_tokens[offset].token.id == TOKEN_ID.FIELD_QUALIFICATION:
+                                        if indexed_tokens[offset].token.text == "repeated":
+                                                qualifcator = FIELD_QUALIFICATOR.REPEATED
+                                        elif indexed_tokens[offset].token.text == "required":
+                                                qualifcator = FIELD_QUALIFICATOR.REQUIRED
+                                        elif indexed_tokens[offset].token.text == "optional":
+                                                qualifcator = FIELD_QUALIFICATOR.OPTIONAL
+                                        offset += 1
+                                else:
+                                        if class_table[settings.parent_index].type == CLASS_TYPE.MESSAGE:
+                                                result.success = false
+                                                result.error = indexed_tokens[offset].index
+                                                result.description = "Using the 'required', 'optional' or 'repeated' qualificator necessarily in Protobuf v2."
+                                                return result
+                var type_name : String = indexed_tokens[offset].token.text; offset += 1
+                var field_name : String = indexed_tokens[offset].token.text; offset += 1
+                var tag : String = indexed_tokens[offset].token.text; offset += 1
+                
+                if indexed_tokens.size() == offset + 2:
+                        if indexed_tokens[offset].token.text == "packed":
+                                offset += 1
+                                if indexed_tokens[offset].token.text == "true":
+                                        option = FIELD_OPTION.PACKED
+                                else:
+                                        option = FIELD_OPTION.NOT_PACKED
+                        else:
+                                result.success = false
+                                result.error = indexed_tokens[offset].index
+                                result.description = "Undefined field option."
+                                return result
+                                
+                if group_table.size() > 0:
+                        if group_table[group_table.size() - 1].opened:
+                                if indexed_tokens[0].token.id == TOKEN_ID.FIELD_QUALIFICATION:
+                                        result.success = false
+                                        result.error = indexed_tokens[0].index
+                                        result.description = "Using the 'required', 'optional' or 'repeated' qualificator is unacceptable in 'OneOf' field."
+                                        return result
+                                group_table[group_table.size() - 1].field_indexes.append(field_table.size())
+                field_table.append(ASTField.new(tag, field_name, type_name, settings.parent_index, qualifcator, option, settings.construction_index, false))
+                return result
+        
+        func desc_map_field(indexed_tokens : Array, settings : CompareSettings) -> DescriptionResult:
+                var result : DescriptionResult = DescriptionResult.new()
+                var qualifcator : int = FIELD_QUALIFICATOR.REPEATED
+                var option : int
+                var offset : int = 0
+                
+                if proto_version == 3:
+                        option = FIELD_OPTION.PACKED
+                if proto_version == 2:
+                        option = FIELD_OPTION.NOT_PACKED
+                        
+                var key_type_name : String = indexed_tokens[offset].token.text; offset += 1
+                if key_type_name == "float" || key_type_name == "double" || key_type_name == "bytes":
+                        result.success = false
+                        result.error = indexed_tokens[offset - 1].index
+                        result.description = "Map 'key_type' can't be floating point types and bytes."
+                var type_name : String  = indexed_tokens[offset].token.text; offset += 1
+                var field_name : String  = indexed_tokens[offset].token.text; offset += 1
+                var tag : String = indexed_tokens[offset].token.text; offset += 1
+                
+                if indexed_tokens.size() == offset + 2:
+                        if indexed_tokens[offset].token.text == "packed":
+                                offset += 1
+                                if indexed_tokens[offset] == "true":
+                                        option = FIELD_OPTION.PACKED
+                                else:
+                                        option = FIELD_OPTION.NOT_PACKED
+                        else:
+                                result.success = false
+                                result.error = indexed_tokens[offset].index
+                                result.description = "Undefined field option."
+                
+                if group_table.size() > 0:
+                        if group_table[group_table.size() - 1].opened:
+                                group_table[group_table.size() - 1].field_indexes.append(field_table.size())
+                                
+                class_table.append(ASTClass.new("map_type_" + field_name, CLASS_TYPE.MAP, settings.parent_index, settings.parent_name, "", settings.construction_index))
+                field_table.append(ASTField.new(tag, field_name, "map_type_" + field_name, settings.parent_index, qualifcator, option, settings.construction_index, false))
+                
+                field_table.append(ASTField.new(1, "key", key_type_name, class_table.size() - 1, FIELD_QUALIFICATOR.OPTIONAL, option, settings.construction_index, true))
+                field_table.append(ASTField.new(2, "value", type_name, class_table.size() - 1, FIELD_QUALIFICATOR.OPTIONAL, option, settings.construction_index, true))
+                
+                return result
+        
+        func desc_enum(indexed_tokens : Array, settings : CompareSettings) -> DescriptionResult:
+                var result : DescriptionResult = DescriptionResult.new()
+                var option : String = ""
+                var offset : int = 0
+                var type_name : String = indexed_tokens[offset].token.text; offset += 1
+                if indexed_tokens[offset].token.id == TOKEN_ID.ENUM_OPTION:
+                        if indexed_tokens[offset].token.text == "allow_alias" && indexed_tokens[offset + 1].token.text == "true":
+                                option = "allow_alias"
+                        offset += 2
+                var value : ASTEnumValue
+                var enum_class : ASTClass = ASTClass.new(type_name, CLASS_TYPE.ENUM, settings.parent_index, settings.parent_name, option, settings.construction_index)
+                var first_value : bool = true
+                while offset < indexed_tokens.size():
+                        if first_value:
+                                if indexed_tokens[offset + 1].token.text != "0":
+                                        result.success = false
+                                        result.error = indexed_tokens[offset + 1].index
+                                        result.description = "For Enums, the default value is the first defined enum value, which must be 0."
+                                        break
+                                first_value = false
+                        #if indexed_tokens[offset + 1].token.text[0] == "+" || indexed_tokens[offset + 1].token.text[0] == "-":
+                        #       result.success = false
+                        #       result.error = indexed_tokens[offset + 1].index
+                        #       result.description = "For Enums, signed values are not allowed."
+                        #       break
+                        value = ASTEnumValue.new(indexed_tokens[offset].token.text, indexed_tokens[offset + 1].token.text)
+                        enum_class.values.append(value)
+                        offset += 2
+                
+                class_table.append(enum_class)
+                return result
+                
+        func desc_message_head(indexed_tokens : Array, settings : CompareSettings) -> DescriptionResult:
+                var result : DescriptionResult = DescriptionResult.new()
+                class_table.append(ASTClass.new(indexed_tokens[0].token.text, CLASS_TYPE.MESSAGE, settings.parent_index, settings.parent_name, "", settings.construction_index))
+                settings.parent_index = class_table.size() - 1
+                settings.parent_name = settings.parent_name + "." + indexed_tokens[0].token.text
+                return result
+                
+        func desc_message_tail(indexed_tokens : Array, settings : CompareSettings) -> DescriptionResult:
+                settings.parent_index = class_table[settings.parent_index].parent_index
+                settings.parent_name = class_table[settings.parent_index + 1].parent_name
+                var result : DescriptionResult = DescriptionResult.new()
+                return result
+        
+        func desc_oneof_head(indexed_tokens : Array, settings : CompareSettings) -> DescriptionResult:
+                var result : DescriptionResult = DescriptionResult.new()
+                for g in group_table:
+                        if g.parent_class_id == settings.parent_index && g.name == indexed_tokens[0].token.text:
+                                result.success = false
+                                result.error = indexed_tokens[0].index
+                                result.description = "OneOf name must be unique."
+                                return result
+                group_table.append(ASTFieldGroup.new(indexed_tokens[0].token.text, settings.parent_index, AST_GROUP_RULE.ONEOF))
+                return result
+                
+        func desc_oneof_tail(indexed_tokens : Array, settings : CompareSettings) -> DescriptionResult:
+                group_table[group_table.size() - 1].opened = false
+                var result : DescriptionResult = DescriptionResult.new()
+                return result
+                
+        func analyze() -> AnalyzeResult:
+                var analyze_result : AnalyzeResult = AnalyzeResult.new()
+                analyze_result.doc = document
+                analyze_result.classes = class_table
+                analyze_result.fields = field_table
+                analyze_result.groups = group_table
+                analyze_result.state = false
+                var result : TokenResult = tokenizer()
+                if result.errors.size() > 0:
+                        for v in result.errors:
+                                var spos : Helper.StringPosition = Helper.str_pos(document.text, v.position)
+                                var err_text : String = "Unexpected token intersection " + "'" + document.text.substr(v.position.begin, spos.length) + "'"
+                                printerr(Helper.error_string(document.name, spos.str_num, spos.column, err_text))
+                else:
+                        var integrity = check_tokens_integrity(result.tokens, document.text.length() - 1)
+                        if integrity.size() > 0:
+                                for v in integrity:
+                                        var spos: Helper.StringPosition = Helper.str_pos(document.text, TokenPosition.new(v.begin, v.end))
+                                        var err_text : String = "Unexpected token " + "'" + document.text.substr(v.begin, spos.length) + "'"
+                                        printerr(Helper.error_string(document.name, spos.str_num, spos.column, err_text))
+                        else:
+                                analyze_result.tokens = result.tokens
+                                comment_space_processing(result.tokens)
+                                var syntax : TranslationResult = analyze_tokens(result.tokens)
+                                if !syntax.done:
+                                        var pos_main : TokenPosition = Helper.text_pos(result.tokens, syntax.parse_token_index)
+                                        var pos_inner : TokenPosition = Helper.text_pos(result.tokens, syntax.error_token_index)
+                                        var spos_main : Helper.StringPosition = Helper.str_pos(document.text, pos_main)
+                                        var spos_inner : Helper.StringPosition = Helper.str_pos(document.text, pos_inner)
+                                        var err_text : String = "Syntax error in construction '" + result.tokens[syntax.parse_token_index].text + "'. "
+                                        err_text += "Unacceptable use '" + result.tokens[syntax.error_token_index].text + "' at:" + str(spos_inner.str_num) + ":" + str(spos_inner.column)
+                                        err_text += "\n" + syntax.error_description_text
+                                        printerr(Helper.error_string(document.name, spos_main.str_num, spos_main.column, err_text))
+                                else:
+                                        analyze_result.version = proto_version
+                                        analyze_result.imports = import_table
+                                        analyze_result.syntax = syntax
+                                        analyze_result.state = true
+                return analyze_result
+
+class Semantic:
+        
+        var class_table : Array
+        var field_table : Array
+        var group_table : Array
+        var syntax : Analysis.TranslationResult
+        var tokens : Array
+        var document : Document
+        
+        func _init(analyze_result : AnalyzeResult):
+                class_table = analyze_result.classes
+                field_table = analyze_result.fields
+                group_table = analyze_result.groups
+                syntax = analyze_result.syntax
+                tokens = analyze_result.tokens
+                document = analyze_result.doc
+                
+        
+        enum CHECK_SUBJECT {
+                CLASS_NAME = 0,
+                FIELD_NAME = 1,
+                FIELD_TAG_NUMBER = 2,
+                FIELD_TYPE = 3
+        }
+        
+        var STRING_FIELD_TYPE = {
+                "int32": Analysis.FIELD_TYPE.INT32,
+                "sint32": Analysis.FIELD_TYPE.SINT32,
+                "uint32": Analysis.FIELD_TYPE.UINT32,
+                "int64": Analysis.FIELD_TYPE.INT64,
+                "sint64": Analysis.FIELD_TYPE.SINT64,
+                "uint64": Analysis.FIELD_TYPE.UINT64,
+                "bool": Analysis.FIELD_TYPE.BOOL,
+                "fixed32": Analysis.FIELD_TYPE.FIXED32,
+                "sfixed32": Analysis.FIELD_TYPE.SFIXED32,
+                "float": Analysis.FIELD_TYPE.FLOAT,
+                "fixed64": Analysis.FIELD_TYPE.FIXED64,
+                "sfixed64": Analysis.FIELD_TYPE.SFIXED64,
+                "double": Analysis.FIELD_TYPE.DOUBLE,
+                "string": Analysis.FIELD_TYPE.STRING,
+                "bytes": Analysis.FIELD_TYPE.BYTES,
+                "map": Analysis.FIELD_TYPE.MAP
+        }
+        
+        class CheckResult:
+                func _init(mci : int, aci : int, ti : int, s : int):
+                        main_construction_index = mci
+                        associated_construction_index = aci
+                        table_index = ti
+                        subject = s
+                        
+                var main_construction_index: int = -1
+                var associated_construction_index: int = -1
+                var table_index: int = -1
+                var subject : int
+        
+        func check_class_names() -> Array:
+                var result : Array = []
+                for i in range(class_table.size()):
+                        var the_class_name : String = class_table[i].parent_name + "." + class_table[i].name
+                        for j in range(i + 1, class_table.size(), 1):
+                                var inner_name : String = class_table[j].parent_name + "." + class_table[j].name
+                                if inner_name == the_class_name:
+                                        var check : CheckResult = CheckResult.new(class_table[j].construction_index, class_table[i].construction_index, j, CHECK_SUBJECT.CLASS_NAME)
+                                        result.append(check)
+                                        break
+                return result
+        
+        func check_field_names() -> Array:
+                var result : Array = []
+                for i in range(field_table.size()):
+                        var the_class_name : String = class_table[field_table[i].parent_class_id].parent_name + "." + class_table[field_table[i].parent_class_id].name
+                        for j in range(i + 1, field_table.size(), 1):
+                                var inner_name : String = class_table[field_table[j].parent_class_id].parent_name + "." + class_table[field_table[j].parent_class_id].name
+                                if inner_name == the_class_name:
+                                        if field_table[i].name == field_table[j].name:
+                                                var check : CheckResult = CheckResult.new(field_table[j].construction_index, field_table[i].construction_index, j, CHECK_SUBJECT.FIELD_NAME)
+                                                result.append(check)
+                                                break
+                                        if field_table[i].tag == field_table[j].tag:
+                                                var check : CheckResult = CheckResult.new(field_table[j].construction_index, field_table[i].construction_index, j, CHECK_SUBJECT.FIELD_TAG_NUMBER)
+                                                result.append(check)
+                                                break
+                return result
+        
+        func find_full_class_name(the_class_name : String) -> int:
+                for i in range(class_table.size()):
+                        if the_class_name == class_table[i].parent_name + "." + class_table[i].name:
+                                return i
+                return -1
+        
+        func find_class_name(the_class_name : String) -> int:
+                for i in range(class_table.size()):
+                        if the_class_name == class_table[i].name:
+                                return i
+                return -1
+        
+        func get_class_childs(class_index : int) -> Array:
+                var result : Array = []
+                for i in range(class_table.size()):
+                        if class_table[i].parent_index == class_index:
+                                result.append(i)
+                return result
+        
+        func find_in_childs(the_class_name : String, child_indexes : Array) -> int:
+                for c in child_indexes:
+                        if the_class_name == class_table[c].name:
+                                return c
+                return -1
+        
+        func determine_field_types() -> Array:
+                var result : Array = []
+                for f in field_table:
+                        if STRING_FIELD_TYPE.has(f.type_name):
+                                f.field_type = STRING_FIELD_TYPE[f.type_name]
+                        else:
+                                if f.type_name[0] == ".":
+                                        f.type_class_id = find_full_class_name(f.type_name)
+                                else:
+                                        # Reset result from previous assignment, that can be incorrect because of merging of imports
+                                        f.type_class_id = -1
+                                        var splited_name : Array = f.type_name.split(".", false)
+                                        var cur_class_index : int = f.parent_class_id
+                                        var exit : bool = false
+                                        while(true):
+                                                var find : bool = false
+                                                if cur_class_index == -1:
+                                                        break
+                                                for n in splited_name:
+                                                        var childs_and_parent : Array = get_class_childs(cur_class_index)
+                                                        var res_index : int = find_in_childs(n, childs_and_parent)
+                                                        if res_index >= 0:
+                                                                find = true
+                                                                cur_class_index = res_index
+                                                        else:
+                                                                if find:
+                                                                        exit = true
+                                                                else:
+                                                                        cur_class_index = class_table[cur_class_index].parent_index
+                                                                break
+                                                if exit:
+                                                        break
+                                                if find:
+                                                        f.type_class_id = cur_class_index
+                                                        break
+                                if f.type_class_id == -1:
+                                        f.type_class_id = find_full_class_name("." + f.type_name)
+                for i in range(field_table.size()):
+                        if field_table[i].field_type == Analysis.FIELD_TYPE.UNDEFINED:
+                                if field_table[i].type_class_id == -1:
+                                        result.append(CheckResult.new(field_table[i].construction_index, field_table[i].construction_index, i, CHECK_SUBJECT.FIELD_TYPE))
+                                else:
+                                        if class_table[field_table[i].type_class_id].type == Analysis.CLASS_TYPE.ENUM:
+                                                field_table[i].field_type = Analysis.FIELD_TYPE.ENUM
+                                        elif class_table[field_table[i].type_class_id].type == Analysis.CLASS_TYPE.MESSAGE:
+                                                field_table[i].field_type = Analysis.FIELD_TYPE.MESSAGE
+                                        elif class_table[field_table[i].type_class_id].type == Analysis.CLASS_TYPE.MAP:
+                                                field_table[i].field_type = Analysis.FIELD_TYPE.MAP
+                                        else:
+                                                result.append(CheckResult.new(field_table[i].construction_index, field_table[i].construction_index, i, CHECK_SUBJECT.FIELD_TYPE))
+                return result
+        
+        func check_constructions() -> Array:
+                var cl : Array = check_class_names()
+                var fl : Array = check_field_names()
+                var ft : Array = determine_field_types()
+                return cl + fl + ft
+                
+        func check() -> bool:
+                var check_result : Array = check_constructions()
+                if check_result.size() == 0:
+                        return true
+                else:
+                        for v in check_result:
+                                var main_tok : int = syntax.constructions[v.main_construction_index].begin_token_index
+                                var assoc_tok : int = syntax.constructions[v.associated_construction_index].begin_token_index
+                                var main_err_pos : Helper.StringPosition = Helper.str_pos(document.text, Helper.text_pos(tokens, main_tok))
+                                var assoc_err_pos : Helper.StringPosition = Helper.str_pos(document.text, Helper.text_pos(tokens, assoc_tok))
+                                var err_text : String
+                                if v.subject == CHECK_SUBJECT.CLASS_NAME:
+                                        var class_type = "Undefined"
+                                        if class_table[v.table_index].type == Analysis.CLASS_TYPE.ENUM:
+                                                class_type = "Enum"
+                                        elif class_table[v.table_index].type == Analysis.CLASS_TYPE.MESSAGE:
+                                                class_type = "Message"
+                                        elif class_table[v.table_index].type == Analysis.CLASS_TYPE.MAP:
+                                                class_type = "Map"
+                                        err_text = class_type + " name '" + class_table[v.table_index].name + "' is already defined at:" + str(assoc_err_pos.str_num) + ":" + str(assoc_err_pos.column)
+                                elif v.subject == CHECK_SUBJECT.FIELD_NAME:
+                                        err_text = "Field name '" + field_table[v.table_index].name + "' is already defined at:" + str(assoc_err_pos.str_num) + ":" + str(assoc_err_pos.column)
+                                elif v.subject == CHECK_SUBJECT.FIELD_TAG_NUMBER:
+                                        err_text = "Tag number '" + field_table[v.table_index].tag + "' is already defined at:" + str(assoc_err_pos.str_num) + ":" + str(assoc_err_pos.column)
+                                elif v.subject == CHECK_SUBJECT.FIELD_TYPE:
+                                        err_text = "Type '" + field_table[v.table_index].type_name + "' of the '" + field_table[v.table_index].name + "' field undefined"
+                                else:
+                                        err_text = "Undefined error"
+                                printerr(Helper.error_string(document.name, main_err_pos.str_num, main_err_pos.column, err_text))
+                return false
+
+class Translator:
+        
+        var class_table : Array
+        var field_table : Array
+        var group_table : Array
+        var proto_version : int
+        
+        func _init(analyzer_result : AnalyzeResult):
+                class_table = analyzer_result.classes
+                field_table = analyzer_result.fields
+                group_table = analyzer_result.groups
+                proto_version = analyzer_result.version
+        
+        func tabulate(text : String, nesting : int) -> String:
+                var tab : String = ""
+                for i in range(nesting):
+                        tab += "\t"
+                return tab + text
+        
+        func default_dict_text() -> String:
+                if proto_version == 2:
+                        return "DEFAULT_VALUES_2"
+                elif proto_version == 3:
+                        return "DEFAULT_VALUES_3"
+                return "TRANSLATION_ERROR"
+        
+        func generate_field_type(field : Analysis.ASTField) -> String:
+                var text : String = "PB_DATA_TYPE."
+                if field.field_type == Analysis.FIELD_TYPE.INT32:
+                        return text + "INT32"
+                elif field.field_type == Analysis.FIELD_TYPE.SINT32:
+                        return text + "SINT32"
+                elif field.field_type == Analysis.FIELD_TYPE.UINT32:
+                        return text + "UINT32"
+                elif field.field_type == Analysis.FIELD_TYPE.INT64:
+                        return text + "INT64"
+                elif field.field_type == Analysis.FIELD_TYPE.SINT64:
+                        return text + "SINT64"
+                elif field.field_type == Analysis.FIELD_TYPE.UINT64:
+                        return text + "UINT64"
+                elif field.field_type == Analysis.FIELD_TYPE.BOOL:
+                        return text + "BOOL"
+                elif field.field_type == Analysis.FIELD_TYPE.ENUM:
+                        return text + "ENUM"
+                elif field.field_type == Analysis.FIELD_TYPE.FIXED32:
+                        return text + "FIXED32"
+                elif field.field_type == Analysis.FIELD_TYPE.SFIXED32:
+                        return text + "SFIXED32"
+                elif field.field_type == Analysis.FIELD_TYPE.FLOAT:
+                        return text + "FLOAT"
+                elif field.field_type == Analysis.FIELD_TYPE.FIXED64:
+                        return text + "FIXED64"
+                elif field.field_type == Analysis.FIELD_TYPE.SFIXED64:
+                        return text + "SFIXED64"
+                elif field.field_type == Analysis.FIELD_TYPE.DOUBLE:
+                        return text + "DOUBLE"
+                elif field.field_type == Analysis.FIELD_TYPE.STRING:
+                        return text + "STRING"
+                elif field.field_type == Analysis.FIELD_TYPE.BYTES:
+                        return text + "BYTES"
+                elif field.field_type == Analysis.FIELD_TYPE.MESSAGE:
+                        return text + "MESSAGE"
+                elif field.field_type == Analysis.FIELD_TYPE.MAP:
+                        return text + "MAP"
+                return text
+        
+        func generate_field_rule(field : Analysis.ASTField) -> String:
+                var text : String = "PB_RULE."
+                if field.qualificator == Analysis.FIELD_QUALIFICATOR.OPTIONAL:
+                        return text + "OPTIONAL"
+                elif field.qualificator == Analysis.FIELD_QUALIFICATOR.REQUIRED:
+                        return text + "REQUIRED"
+                elif field.qualificator == Analysis.FIELD_QUALIFICATOR.REPEATED:
+                        return text + "REPEATED"
+                elif field.qualificator == Analysis.FIELD_QUALIFICATOR.RESERVED:
+                        return text + "RESERVED"
+                return text
+        
+        func generate_gdscript_type(field : Analysis.ASTField) -> String:
+                if field.field_type == Analysis.FIELD_TYPE.MESSAGE:
+                        var type_name : String = class_table[field.type_class_id].parent_name + "." + class_table[field.type_class_id].name
+                        return type_name.substr(1, type_name.length() - 1)
+                return generate_gdscript_simple_type(field)
+
+        func generate_gdscript_simple_type(field : Analysis.ASTField) -> String:
+                if field.field_type == Analysis.FIELD_TYPE.INT32:
+                        return "int"
+                elif field.field_type == Analysis.FIELD_TYPE.SINT32:
+                        return "int"
+                elif field.field_type == Analysis.FIELD_TYPE.UINT32:
+                        return "int"
+                elif field.field_type == Analysis.FIELD_TYPE.INT64:
+                        return "int"
+                elif field.field_type == Analysis.FIELD_TYPE.SINT64:
+                        return "int"
+                elif field.field_type == Analysis.FIELD_TYPE.UINT64:
+                        return "int"
+                elif field.field_type == Analysis.FIELD_TYPE.BOOL:
+                        return "bool"
+                elif field.field_type == Analysis.FIELD_TYPE.ENUM:
+                        return ""
+                elif field.field_type == Analysis.FIELD_TYPE.FIXED32:
+                        return "int"
+                elif field.field_type == Analysis.FIELD_TYPE.SFIXED32:
+                        return "int"
+                elif field.field_type == Analysis.FIELD_TYPE.FLOAT:
+                        return "float"
+                elif field.field_type == Analysis.FIELD_TYPE.FIXED64:
+                        return "int"
+                elif field.field_type == Analysis.FIELD_TYPE.SFIXED64:
+                        return "int"
+                elif field.field_type == Analysis.FIELD_TYPE.DOUBLE:
+                        return "float"
+                elif field.field_type == Analysis.FIELD_TYPE.STRING:
+                        return "String"
+                elif field.field_type == Analysis.FIELD_TYPE.BYTES:
+                        return "PackedByteArray"
+                return ""
+
+        func generate_field_constructor(field_index : int, nesting : int) -> String:
+                var text : String = ""
+                var f : Analysis.ASTField = field_table[field_index]
+                var field_name : String = "__" + f.name
+                var pbfield_text : String
+                var default_var_name := field_name + "_default"
+                if f.qualificator == Analysis.FIELD_QUALIFICATOR.REPEATED:
+                        var type_name := generate_gdscript_type(f)
+                        if type_name:
+                                text = tabulate("var %s: Array[%s] = []\n" % [default_var_name, type_name], nesting)
+                        else:
+                                text = tabulate("var %s: Array = []\n" % [default_var_name], nesting)
+                pbfield_text += field_name + " = PBField.new("
+                pbfield_text += "\"" + f.name + "\", "
+                pbfield_text += generate_field_type(f) + ", "
+                pbfield_text += generate_field_rule(f) + ", "
+                pbfield_text += str(f.tag) + ", "
+                if f.option == Analysis.FIELD_OPTION.PACKED:
+                        pbfield_text += "true"
+                elif f.option == Analysis.FIELD_OPTION.NOT_PACKED:
+                        pbfield_text += "false"
+                if f.qualificator == Analysis.FIELD_QUALIFICATOR.REPEATED:
+                        pbfield_text += ", " + default_var_name
+                else:
+                        pbfield_text += ", " + default_dict_text() + "[" + generate_field_type(f) + "]"
+                pbfield_text += ")\n"
+                text += tabulate(pbfield_text, nesting)
+                if f.is_map_field:
+                        text += tabulate(field_name + ".is_map_field = true\n", nesting)
+                text += tabulate("service = PBServiceField.new()\n", nesting)
+                text += tabulate("service.field = " + field_name + "\n", nesting)
+                if f.field_type == Analysis.FIELD_TYPE.MESSAGE:
+                        if f.qualificator == Analysis.FIELD_QUALIFICATOR.REPEATED:
+                                text += tabulate("service.func_ref = Callable(self, \"add_" + f.name + "\")\n", nesting)
+                        else:
+                                text += tabulate("service.func_ref = Callable(self, \"new_" + f.name + "\")\n", nesting)
+                elif f.field_type == Analysis.FIELD_TYPE.MAP:
+                        text += tabulate("service.func_ref = Callable(self, \"add_empty_" + f.name + "\")\n", nesting)
+                text += tabulate("data[" + field_name + ".tag] = service\n", nesting)
+                
+                return text
+        
+        func generate_group_clear(field_index : int, nesting : int) -> String:
+                for g in group_table:
+                        var text : String = ""
+                        var find : bool = false
+                        if g.parent_class_id == field_table[field_index].parent_class_id:
+                                for i in g.field_indexes:
+                                        if field_index == i:
+                                                find = true
+                                                text += tabulate("data[" + field_table[i].tag + "].state = PB_SERVICE_STATE.FILLED\n", nesting)
+                                        else:
+                                                text += tabulate("__" + field_table[i].name + ".value = " + default_dict_text() + "[" + generate_field_type(field_table[i]) + "]\n", nesting)
+                                                text += tabulate("data[" + field_table[i].tag + "].state = PB_SERVICE_STATE.UNFILLED\n", nesting)
+                        if find:
+                                return text
+                return ""
+        
+        func generate_has_oneof(field_index : int, nesting : int) -> String:
+                for g in group_table:
+                        var text : String = ""
+                        if g.parent_class_id == field_table[field_index].parent_class_id:
+                                for i in g.field_indexes:
+                                        if field_index == i:
+                                                text += tabulate("func has_" + field_table[i].name + "() -> bool:\n", nesting)
+                                                nesting += 1
+                                                text += tabulate("return data[" + field_table[i].tag + "].state == PB_SERVICE_STATE.FILLED\n", nesting)
+                                                return text
+                return ""
+        
+        func generate_field(field_index : int, nesting : int) -> String:
+                var text : String = ""
+                var f : Analysis.ASTField = field_table[field_index]
+                var varname : String = "__" + f.name
+                text += tabulate("var " + varname + ": PBField\n", nesting)
+                if f.field_type == Analysis.FIELD_TYPE.MESSAGE:
+                        var the_class_name : String = class_table[f.type_class_id].parent_name + "." + class_table[f.type_class_id].name
+                        the_class_name = the_class_name.substr(1, the_class_name.length() - 1)
+                        if f.qualificator != Analysis.FIELD_QUALIFICATOR.OPTIONAL:
+                                text += generate_has_oneof(field_index, nesting)
+                        if f.qualificator == Analysis.FIELD_QUALIFICATOR.REPEATED:
+                                text += tabulate("func get_" + f.name + "() -> Array[" + the_class_name + "]:\n", nesting)
+                        else:
+                                if f.qualificator == Analysis.FIELD_QUALIFICATOR.OPTIONAL:
+                                        text += tabulate("func has_" + f.name + "() -> bool:\n", nesting)
+                                        nesting += 1
+                                        text += tabulate("if " + varname + ".value != null:\n", nesting)
+                                        nesting += 1
+                                        text += tabulate("return true\n", nesting)
+                                        nesting -= 1
+                                        text += tabulate("return false\n", nesting)
+                                        nesting -= 1
+                                text += tabulate("func get_" + f.name + "() -> " + the_class_name + ":\n", nesting)
+                        nesting += 1
+                        text += tabulate("return " + varname + ".value\n", nesting)
+                        nesting -= 1
+                        text += tabulate("func clear_" + f.name + "() -> void:\n", nesting)
+                        nesting += 1
+                        text += tabulate("data[" + str(f.tag) + "].state = PB_SERVICE_STATE.UNFILLED\n", nesting)
+                        if f.qualificator == Analysis.FIELD_QUALIFICATOR.REPEATED:
+                                text += tabulate(varname + ".value.clear()\n", nesting)
+                                nesting -= 1
+                                text += tabulate("func add_" + f.name + "() -> " + the_class_name + ":\n", nesting)
+                                nesting += 1
+                                text += tabulate("var element = " + the_class_name + ".new()\n", nesting)
+                                text += tabulate(varname + ".value.append(element)\n", nesting)
+                                text += tabulate("return element\n", nesting)
+                        else:
+                                text += tabulate(varname + ".value = " + default_dict_text() + "[" + generate_field_type(f) + "]\n", nesting)
+                                nesting -= 1
+                                text += tabulate("func new_" + f.name + "() -> " + the_class_name + ":\n", nesting)
+                                nesting += 1
+                                text += generate_group_clear(field_index, nesting)
+                                text += tabulate(varname + ".value = " + the_class_name + ".new()\n", nesting)
+                                text += tabulate("return " + varname + ".value\n", nesting)
+                elif f.field_type == Analysis.FIELD_TYPE.MAP:
+                        var the_parent_class_name : String = class_table[f.type_class_id].parent_name
+                        the_parent_class_name = the_parent_class_name.substr(1, the_parent_class_name.length() - 1)
+                        var the_class_name : String = the_parent_class_name + "." + class_table[f.type_class_id].name
+
+                        text += generate_has_oneof(field_index, nesting)
+                        text += tabulate("func get_raw_" + f.name + "():\n", nesting)
+                        nesting += 1
+                        text += tabulate("return " + varname + ".value\n", nesting)
+                        nesting -= 1
+                        text += tabulate("func get_" + f.name + "():\n", nesting)
+                        nesting += 1
+                        text += tabulate("return PBPacker.construct_map(" + varname + ".value)\n", nesting)
+                        nesting -= 1
+                        text += tabulate("func clear_" + f.name + "():\n", nesting)
+                        nesting += 1
+                        text += tabulate("data[" + str(f.tag) + "].state = PB_SERVICE_STATE.UNFILLED\n", nesting)
+                        text += tabulate(varname + ".value = " + default_dict_text() + "[" + generate_field_type(f) + "]\n", nesting)
+                        nesting -= 1
+                        for i in range(field_table.size()):
+                                if field_table[i].parent_class_id == f.type_class_id && field_table[i].name == "value":
+                                        var gd_type : String = generate_gdscript_simple_type(field_table[i])
+                                        var return_type : String = " -> " + the_class_name
+                                        var value_return_type : String = ""
+                                        if gd_type != "":
+                                                value_return_type = return_type
+                                        elif field_table[i].field_type == Analysis.FIELD_TYPE.MESSAGE:
+                                                value_return_type = " -> " + the_parent_class_name + "." + field_table[i].type_name
+                                        text += tabulate("func add_empty_" + f.name + "()" + return_type + ":\n", nesting)
+                                        nesting += 1
+                                        text += generate_group_clear(field_index, nesting)
+                                        text += tabulate("var element = " + the_class_name + ".new()\n", nesting)
+                                        text += tabulate(varname + ".value.append(element)\n", nesting)
+                                        text += tabulate("return element\n", nesting)
+                                        nesting -= 1
+                                        if field_table[i].field_type == Analysis.FIELD_TYPE.MESSAGE:
+                                                text += tabulate("func add_" + f.name + "(a_key)" + value_return_type + ":\n", nesting)
+                                                nesting += 1
+                                                text += generate_group_clear(field_index, nesting)
+                                                text += tabulate("var idx = -1\n", nesting)
+                                                text += tabulate("for i in range(" + varname + ".value.size()):\n", nesting)
+                                                nesting += 1
+                                                text += tabulate("if " + varname + ".value[i].get_key() == a_key:\n", nesting)
+                                                nesting += 1
+                                                text += tabulate("idx = i\n", nesting)
+                                                text += tabulate("break\n", nesting)
+                                                nesting -= 2
+                                                text += tabulate("var element = " + the_class_name + ".new()\n", nesting)
+                                                text += tabulate("element.set_key(a_key)\n", nesting)
+                                                text += tabulate("if idx != -1:\n", nesting)
+                                                nesting += 1
+                                                text += tabulate(varname + ".value[idx] = element\n", nesting)
+                                                nesting -= 1
+                                                text += tabulate("else:\n", nesting)
+                                                nesting += 1
+                                                text += tabulate(varname + ".value.append(element)\n", nesting)
+                                                nesting -= 1
+                                                text += tabulate("return element.new_value()\n", nesting)
+                                        else:
+                                                text += tabulate("func add_" + f.name + "(a_key, a_value) -> void:\n", nesting)
+                                                nesting += 1
+                                                text += generate_group_clear(field_index, nesting)
+                                                text += tabulate("var idx = -1\n", nesting)
+                                                text += tabulate("for i in range(" + varname + ".value.size()):\n", nesting)
+                                                nesting += 1
+                                                text += tabulate("if " + varname + ".value[i].get_key() == a_key:\n", nesting)
+                                                nesting += 1
+                                                text += tabulate("idx = i\n", nesting)
+                                                text += tabulate("break\n", nesting)
+                                                nesting -= 2
+                                                text += tabulate("var element = " + the_class_name + ".new()\n", nesting)
+                                                text += tabulate("element.set_key(a_key)\n", nesting)
+                                                text += tabulate("element.set_value(a_value)\n", nesting)
+                                                text += tabulate("if idx != -1:\n", nesting)
+                                                nesting += 1
+                                                text += tabulate(varname + ".value[idx] = element\n", nesting)
+                                                nesting -= 1
+                                                text += tabulate("else:\n", nesting)
+                                                nesting += 1
+                                                text += tabulate(varname + ".value.append(element)\n", nesting)
+                                                nesting -= 1
+                                        break
+                else:
+                        var gd_type : String = generate_gdscript_simple_type(f)
+                        var return_type : String = ""
+                        var argument_type : String = ""
+                        if gd_type != "":
+                                return_type = " -> " + gd_type
+                                argument_type = " : " + gd_type
+                        if f.qualificator != Analysis.FIELD_QUALIFICATOR.OPTIONAL:
+                                text += generate_has_oneof(field_index, nesting)
+                        if f.qualificator == Analysis.FIELD_QUALIFICATOR.REPEATED:
+                                var array_type := "[" + gd_type + "]" if gd_type else ""
+                                text += tabulate("func get_" + f.name + "() -> Array" + array_type + ":\n", nesting)
+                        else:
+                                if f.qualificator == Analysis.FIELD_QUALIFICATOR.OPTIONAL:
+                                        text += tabulate("func has_" + f.name + "() -> bool:\n", nesting)
+                                        nesting += 1
+                                        text += tabulate("if " + varname + ".value != null:\n", nesting)
+                                        nesting += 1
+                                        text += tabulate("return true\n", nesting)
+                                        nesting -= 1
+                                        text += tabulate("return false\n", nesting)
+                                        nesting -= 1
+                                text += tabulate("func get_" + f.name + "()" + return_type + ":\n", nesting)
+                        nesting += 1
+                        text += tabulate("return " + varname + ".value\n", nesting)
+                        nesting -= 1
+                        text += tabulate("func clear_" + f.name + "() -> void:\n", nesting)
+                        nesting += 1
+                        text += tabulate("data[" + str(f.tag) + "].state = PB_SERVICE_STATE.UNFILLED\n", nesting)
+                        if f.qualificator == Analysis.FIELD_QUALIFICATOR.REPEATED:
+                                text += tabulate(varname + ".value.clear()\n", nesting)
+                                nesting -= 1
+                                text += tabulate("func add_" + f.name + "(value" + argument_type + ") -> void:\n", nesting)
+                                nesting += 1
+                                text += tabulate(varname + ".value.append(value)\n", nesting)
+                        else:
+                                text += tabulate(varname + ".value = " + default_dict_text() + "[" + generate_field_type(f) + "]\n", nesting)
+                                nesting -= 1
+                                text += tabulate("func set_" + f.name + "(value" + argument_type + ") -> void:\n", nesting)
+                                nesting += 1
+                                text += generate_group_clear(field_index, nesting)
+                                text += tabulate(varname + ".value = value\n", nesting)
+                return text
+
+        func generate_class(class_index : int, nesting : int) -> String:
+                var text : String = ""
+                if class_table[class_index].type == Analysis.CLASS_TYPE.MESSAGE || class_table[class_index].type == Analysis.CLASS_TYPE.MAP:
+                        var cls_pref : String = ""
+                        cls_pref += tabulate("class " + class_table[class_index].name + ":\n", nesting)
+                        nesting += 1
+                        cls_pref += tabulate("func _init():\n", nesting)
+                        text += cls_pref
+                        nesting += 1
+                        text += tabulate("var service\n", nesting)
+                        text += tabulate("\n", nesting)
+                        var field_text : String = ""
+                        for i in range(field_table.size()):
+                                if field_table[i].parent_class_id == class_index:
+                                        text += generate_field_constructor(i, nesting)
+                                        text += tabulate("\n", nesting)
+                                        field_text += generate_field(i, nesting - 1)
+                                        field_text += tabulate("\n", nesting - 1)
+                        nesting -= 1
+                        text += tabulate("var data = {}\n", nesting)
+                        text += tabulate("\n", nesting)
+                        text += field_text
+                        for j in range(class_table.size()):
+                                if class_table[j].parent_index == class_index:
+                                        var cl_text = generate_class(j, nesting)
+                                        text += cl_text
+                                        if class_table[j].type == Analysis.CLASS_TYPE.MESSAGE || class_table[j].type == Analysis.CLASS_TYPE.MAP:
+                                                text += generate_class_services(nesting + 1)
+                                                text += tabulate("\n", nesting + 1)
+                elif class_table[class_index].type == Analysis.CLASS_TYPE.ENUM:
+                        text += tabulate("enum " + class_table[class_index].name + " {\n", nesting)
+                        nesting += 1
+
+                        var expected_prefix = class_table[class_index].name.to_snake_case().to_upper() + "_"
+                        var all_have_prefix = true
+                        for en in range(class_table[class_index].values.size()):
+                                var value_name = class_table[class_index].values[en].name
+                                all_have_prefix = all_have_prefix and value_name.begins_with(expected_prefix) and value_name != expected_prefix
+
+                        for en in range(class_table[class_index].values.size()):
+                                var value_name = class_table[class_index].values[en].name
+                                if all_have_prefix:
+                                        value_name = value_name.substr(expected_prefix.length())
+                                var enum_val = value_name + " = " + class_table[class_index].values[en].value
+                                if en == class_table[class_index].values.size() - 1:
+                                        text += tabulate(enum_val + "\n", nesting)
+                                else:
+                                        text += tabulate(enum_val + ",\n", nesting)
+                        nesting -= 1
+                        text += tabulate("}\n", nesting)
+                        text += tabulate("\n", nesting)
+                        
+                return text
+        
+        func generate_class_services(nesting : int) -> String:
+                var text : String = ""
+                text += tabulate("func _to_string() -> String:\n", nesting)
+                nesting += 1
+                text += tabulate("return PBPacker.message_to_string(data)\n", nesting)
+                text += tabulate("\n", nesting)
+                nesting -= 1
+                text += tabulate("func to_bytes() -> PackedByteArray:\n", nesting)
+                nesting += 1
+                text += tabulate("return PBPacker.pack_message(data)\n", nesting)
+                text += tabulate("\n", nesting)
+                nesting -= 1
+                text += tabulate("func from_bytes(bytes : PackedByteArray, offset : int = 0, limit : int = -1) -> int:\n", nesting)
+                nesting += 1
+                text += tabulate("var cur_limit = bytes.size()\n", nesting)
+                text += tabulate("if limit != -1:\n", nesting)
+                nesting += 1
+                text += tabulate("cur_limit = limit\n", nesting)
+                nesting -= 1
+                text += tabulate("var result = PBPacker.unpack_message(data, bytes, offset, cur_limit)\n", nesting)
+                text += tabulate("if result == cur_limit:\n", nesting)
+                nesting += 1
+                text += tabulate("if PBPacker.check_required(data):\n", nesting)
+                nesting += 1
+                text += tabulate("if limit == -1:\n", nesting)
+                nesting += 1
+                text += tabulate("return PB_ERR.NO_ERRORS\n", nesting)
+                nesting -= 2
+                text += tabulate("else:\n", nesting)
+                nesting += 1
+                text += tabulate("return PB_ERR.REQUIRED_FIELDS\n", nesting)
+                nesting -= 2
+                text += tabulate("elif limit == -1 && result > 0:\n", nesting)
+                nesting += 1
+                text += tabulate("return PB_ERR.PARSE_INCOMPLETE\n", nesting)
+                nesting -= 1
+                text += tabulate("return result\n", nesting)
+                return text
+        
+        func translate(file_name : String, core_file_name : String) -> bool:
+
+                var file : FileAccess = FileAccess.open(file_name, FileAccess.WRITE)
+                if file == null:
+                        printerr("File: '", file_name, "' save error.")
+                        return false
+                
+                if !FileAccess.file_exists(core_file_name):
+                        printerr("File: '", core_file_name, "' not found.")
+                        return false
+                        
+                var core_file : FileAccess = FileAccess.open(core_file_name, FileAccess.READ)
+                if core_file == null:
+                        printerr("File: '", core_file_name, "' read error.")
+                        return false
+                var core_text : String = core_file.get_as_text()
+                core_file.close()
+                
+                var text : String = ""
+                var nesting : int = 0
+                core_text = core_text.replace(PROTO_VERSION_DEFAULT, PROTO_VERSION_CONST + str(proto_version))
+                text += core_text + "\n\n\n"
+                text += "############### USER DATA BEGIN ################\n"
+                var cls_user : String = ""
+                for i in range(class_table.size()):
+                        if class_table[i].parent_index == -1:
+                                var cls_text = generate_class(i, nesting)
+                                cls_user += cls_text
+                                if class_table[i].type == Analysis.CLASS_TYPE.MESSAGE:
+                                        nesting += 1
+                                        cls_user += generate_class_services(nesting)
+                                        cls_user += tabulate("\n", nesting)
+                                        nesting -= 1
+                text += "\n\n"
+                text += cls_user
+                text += "################ USER DATA END #################\n"
+                file.store_string(text)
+                file.close()
+                if !FileAccess.file_exists(file_name):
+                        printerr("File: '", file_name, "' save error.")
+                        return false
+                return true
+        
+
+class ImportFile:
+        func _init(sha : String, a_path : String, a_parent : int):
+                sha256 = sha
+                path = a_path
+                parent_index = a_parent
+                
+        var sha256 : String
+        var path : String
+        var parent_index : int
+
+func parse_all(analyzes : Dictionary, imports : Array, path : String, full_name : String, parent_index : int) -> bool:
+        
+        if !FileAccess.file_exists(full_name):
+                printerr(full_name, ": not found.")
+                return false
+                
+        var file : FileAccess = FileAccess.open(full_name, FileAccess.READ)
+        if file == null:
+                printerr(full_name, ": read error.")
+                return false
+        var doc : Document = Document.new(full_name, file.get_as_text())
+        var sha : String = file.get_sha256(full_name)
+        file.close()
+        
+        if !analyzes.has(sha):
+                print(full_name, ": parsing.")
+                var analysis : Analysis = Analysis.new(path, doc)
+                var an_result : AnalyzeResult = analysis.analyze()
+                if an_result.state:
+                        analyzes[sha] = an_result
+                        var parent : int = imports.size()
+                        imports.append(ImportFile.new(sha, doc.name, parent_index))
+                        for im in an_result.imports:
+                                if !parse_all(analyzes, imports, path, im.path, parent):
+                                        return false
+                else:
+                        printerr(doc.name + ": parsing error.")
+                        return false
+        else:
+                print(full_name, ": retrieving data from cache.")
+                imports.append(ImportFile.new(sha, doc.name, parent_index))
+        return true
+
+func union_analyses(a1 : AnalyzeResult, a2 : AnalyzeResult, only_classes : bool = true) -> void:
+        var class_offset : int = a1.classes.size()
+        var field_offset = a1.fields.size()
+        for cl in a2.classes:
+                var cur_class : Analysis.ASTClass = cl.copy()
+                if cur_class.parent_index != -1:
+                        cur_class.parent_index += class_offset
+                a1.classes.append(cur_class)
+        if only_classes:
+                return
+        for fl in a2.fields:
+                var cur_field : Analysis.ASTField = fl.copy()
+                cur_field.parent_class_id += class_offset
+                cur_field.type_class_id = -1
+                a1.fields.append(cur_field)
+        for gr in a2.groups:
+                var cur_group : Analysis.ASTFieldGroup = gr.copy()
+                cur_group.parent_class_id += class_offset
+                var indexes : Array = []
+                for i in cur_group.field_indexes:
+                        indexes.append(i + field_offset)
+                cur_group.field_indexes = indexes
+                a1.groups.append(cur_group)
+
+func union_imports(analyzes : Dictionary, key : String, result : AnalyzeResult, keys : Array, nesting : int, use_public : bool = true, only_classes : bool = true) -> void:
+        nesting += 1
+        for im in analyzes[key].imports:
+                var find : bool = false
+                for k in keys:
+                        if im.sha256 == k:
+                                find = true
+                                break
+                if find:
+                        continue
+                if (!use_public) || (use_public && ((im.public && nesting > 1) || nesting < 2)):
+                        keys.append(im.sha256)
+                        union_analyses(result, analyzes[im.sha256], only_classes)
+                        union_imports(analyzes, im.sha256, result, keys, nesting, use_public, only_classes)
+
+func semantic_all(analyzes : Dictionary, imports : Array)-> bool:
+        for k in analyzes.keys():
+                print(analyzes[k].doc.name, ": analysis.")
+                var keys : Array = []
+                var analyze : AnalyzeResult = analyzes[k].soft_copy()
+                keys.append(k)
+                analyze.classes = []
+                for cl in analyzes[k].classes:
+                        analyze.classes.append(cl.copy())
+                union_imports(analyzes, k, analyze, keys, 0)
+                var semantic : Semantic = Semantic.new(analyze)
+                if !semantic.check():
+                        printerr(analyzes[k].doc.name, ": analysis error.")
+                        return false
+        return true
+        
+func translate_all(analyzes : Dictionary, file_name : String, core_file_name : String) -> bool:
+        var first_key : String = analyzes.keys()[0]
+        var analyze : AnalyzeResult = analyzes[first_key]
+        var keys : Array = []
+        keys.append(first_key)
+        union_imports(analyzes, first_key, analyze, keys, 0, false, false)
+        print("Performing full semantic analysis.")
+        var semantic : Semantic = Semantic.new(analyze)
+        if !semantic.check():
+                return false
+        print("Performing translation.")
+        var translator : Translator = Translator.new(analyze)
+        if !translator.translate(file_name, core_file_name):
+                return false
+        var first : bool = true
+        return true
+
+func work(path : String, in_file : String, out_file : String, core_file : String) -> bool:
+        var in_full_name : String = path + in_file
+        var imports : Array = []
+        var analyzes : Dictionary = {}
+        
+        print("Compiling source: '", in_full_name, "', output: '", out_file, "'.")
+        print("\n1. Parsing:")
+        if parse_all(analyzes, imports, path, in_full_name, -1):
+                print("* Parsing completed successfully. *")
+        else:
+                return false
+        print("\n2. Perfoming semantic analysis:")
+        if semantic_all(analyzes, imports):
+                print("* Semantic analysis completed successfully. *")
+        else:
+                return false
+        print("\n3. Output file creating:")
+        if translate_all(analyzes, out_file, core_file):
+                print("* Output file was created successfully. *")
+        else:
+                return false
+        return true
+
+func _ready():
+        pass
@@ -0,0 +1,7 @@
+[plugin]
+
+name="Godobuf"
+description="Google Protobuf implementation for Godot/GDScript"
+author="oniksan"
+version="0.6.1 for Godot 4.x.y"
+script="protobuf_ui.gd"
@@ -0,0 +1,66 @@
+#
+# BSD 3-Clause License
+#
+# Copyright (c) 2018, Oleg Malyavkin
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# * Redistributions of source code must retain the above copyright notice, this
+#   list of conditions and the following disclaimer.
+#
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+#
+# * Neither the name of the copyright holder nor the names of its
+#   contributors may be used to endorse or promote products derived from
+#   this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+extends SceneTree
+
+var Parser = preload("res://addons/protobuf/parser.gd")
+var Util = preload("res://addons/protobuf/protobuf_util.gd")
+
+func error(msg : String):
+        push_error(msg)
+        quit()
+
+func _init():
+        var arguments = {}
+        for argument in OS.get_cmdline_args():
+                if argument.find("=") > -1:
+                        var key_value = argument.split("=")
+                        arguments[key_value[0].lstrip("--")] = key_value[1]
+
+        if !arguments.has("input") || !arguments.has("output"):
+                error("Expected 2 Parameters: input and output")
+
+        var input_file_name = arguments["input"]
+        var output_file_name = arguments["output"]
+
+        var file = FileAccess.open(input_file_name, FileAccess.READ)
+        if file == null:
+                error("File: '" + input_file_name + "' not found.")
+
+        var parser = Parser.new()
+
+        if parser.work(Util.extract_dir(input_file_name), Util.extract_filename(input_file_name), \
+                output_file_name, "res://addons/protobuf/protobuf_core.gd"):
+                print("Compiled '", input_file_name, "' to '", output_file_name, "'.")
+        else:
+                error("Compilation failed.")
+
+        quit()
@@ -0,0 +1,668 @@
+#
+# BSD 3-Clause License
+#
+# Copyright (c) 2018 - 2023, Oleg Malyavkin
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# * Redistributions of source code must retain the above copyright notice, this
+#   list of conditions and the following disclaimer.
+#
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+#
+# * Neither the name of the copyright holder nor the names of its
+#   contributors may be used to endorse or promote products derived from
+#   this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+# DEBUG_TAB redefine this "  " if you need, example: const DEBUG_TAB = "\t"
+
+const PROTO_VERSION = 0
+
+const DEBUG_TAB : String = "  "
+
+enum PB_ERR {
+        NO_ERRORS = 0,
+        VARINT_NOT_FOUND = -1,
+        REPEATED_COUNT_NOT_FOUND = -2,
+        REPEATED_COUNT_MISMATCH = -3,
+        LENGTHDEL_SIZE_NOT_FOUND = -4,
+        LENGTHDEL_SIZE_MISMATCH = -5,
+        PACKAGE_SIZE_MISMATCH = -6,
+        UNDEFINED_STATE = -7,
+        PARSE_INCOMPLETE = -8,
+        REQUIRED_FIELDS = -9
+}
+
+enum PB_DATA_TYPE {
+        INT32 = 0,
+        SINT32 = 1,
+        UINT32 = 2,
+        INT64 = 3,
+        SINT64 = 4,
+        UINT64 = 5,
+        BOOL = 6,
+        ENUM = 7,
+        FIXED32 = 8,
+        SFIXED32 = 9,
+        FLOAT = 10,
+        FIXED64 = 11,
+        SFIXED64 = 12,
+        DOUBLE = 13,
+        STRING = 14,
+        BYTES = 15,
+        MESSAGE = 16,
+        MAP = 17
+}
+
+const DEFAULT_VALUES_2 = {
+        PB_DATA_TYPE.INT32: null,
+        PB_DATA_TYPE.SINT32: null,
+        PB_DATA_TYPE.UINT32: null,
+        PB_DATA_TYPE.INT64: null,
+        PB_DATA_TYPE.SINT64: null,
+        PB_DATA_TYPE.UINT64: null,
+        PB_DATA_TYPE.BOOL: null,
+        PB_DATA_TYPE.ENUM: null,
+        PB_DATA_TYPE.FIXED32: null,
+        PB_DATA_TYPE.SFIXED32: null,
+        PB_DATA_TYPE.FLOAT: null,
+        PB_DATA_TYPE.FIXED64: null,
+        PB_DATA_TYPE.SFIXED64: null,
+        PB_DATA_TYPE.DOUBLE: null,
+        PB_DATA_TYPE.STRING: null,
+        PB_DATA_TYPE.BYTES: null,
+        PB_DATA_TYPE.MESSAGE: null,
+        PB_DATA_TYPE.MAP: null
+}
+
+const DEFAULT_VALUES_3 = {
+        PB_DATA_TYPE.INT32: 0,
+        PB_DATA_TYPE.SINT32: 0,
+        PB_DATA_TYPE.UINT32: 0,
+        PB_DATA_TYPE.INT64: 0,
+        PB_DATA_TYPE.SINT64: 0,
+        PB_DATA_TYPE.UINT64: 0,
+        PB_DATA_TYPE.BOOL: false,
+        PB_DATA_TYPE.ENUM: 0,
+        PB_DATA_TYPE.FIXED32: 0,
+        PB_DATA_TYPE.SFIXED32: 0,
+        PB_DATA_TYPE.FLOAT: 0.0,
+        PB_DATA_TYPE.FIXED64: 0,
+        PB_DATA_TYPE.SFIXED64: 0,
+        PB_DATA_TYPE.DOUBLE: 0.0,
+        PB_DATA_TYPE.STRING: "",
+        PB_DATA_TYPE.BYTES: [],
+        PB_DATA_TYPE.MESSAGE: null,
+        PB_DATA_TYPE.MAP: []
+}
+
+enum PB_TYPE {
+        VARINT = 0,
+        FIX64 = 1,
+        LENGTHDEL = 2,
+        STARTGROUP = 3,
+        ENDGROUP = 4,
+        FIX32 = 5,
+        UNDEFINED = 8
+}
+
+enum PB_RULE {
+        OPTIONAL = 0,
+        REQUIRED = 1,
+        REPEATED = 2,
+        RESERVED = 3
+}
+
+enum PB_SERVICE_STATE {
+        FILLED = 0,
+        UNFILLED = 1
+}
+
+class PBField:
+        func _init(a_name : String, a_type : int, a_rule : int, a_tag : int, packed : bool, a_value = null):
+                name = a_name
+                type = a_type
+                rule = a_rule
+                tag = a_tag
+                option_packed = packed
+                value = a_value
+                
+        var name : String
+        var type : int
+        var rule : int
+        var tag : int
+        var option_packed : bool
+        var value
+        var is_map_field : bool = false
+        var option_default : bool = false
+
+class PBTypeTag:
+        var ok : bool = false
+        var type : int
+        var tag : int
+        var offset : int
+
+class PBServiceField:
+        var field : PBField
+        var func_ref = null
+        var state : int = PB_SERVICE_STATE.UNFILLED
+
+class PBPacker:
+        static func convert_signed(n : int) -> int:
+                if n < -2147483648:
+                        return (n << 1) ^ (n >> 63)
+                else:
+                        return (n << 1) ^ (n >> 31)
+
+        static func deconvert_signed(n : int) -> int:
+                if n & 0x01:
+                        return ~(n >> 1)
+                else:
+                        return (n >> 1)
+
+        static func pack_varint(value) -> PackedByteArray:
+                var varint : PackedByteArray = PackedByteArray()
+                if typeof(value) == TYPE_BOOL:
+                        if value:
+                                value = 1
+                        else:
+                                value = 0
+                for _i in range(9):
+                        var b = value & 0x7F
+                        value >>= 7
+                        if value:
+                                varint.append(b | 0x80)
+                        else:
+                                varint.append(b)
+                                break
+                if varint.size() == 9 && (varint[8] & 0x80 != 0):
+                        varint.append(0x01)
+                return varint
+
+        static func pack_bytes(value, count : int, data_type : int) -> PackedByteArray:
+                var bytes : PackedByteArray = PackedByteArray()
+                if data_type == PB_DATA_TYPE.FLOAT:
+                        var spb : StreamPeerBuffer = StreamPeerBuffer.new()
+                        spb.put_float(value)
+                        bytes = spb.get_data_array()
+                elif data_type == PB_DATA_TYPE.DOUBLE:
+                        var spb : StreamPeerBuffer = StreamPeerBuffer.new()
+                        spb.put_double(value)
+                        bytes = spb.get_data_array()
+                else:
+                        for _i in range(count):
+                                bytes.append(value & 0xFF)
+                                value >>= 8
+                return bytes
+
+        static func unpack_bytes(bytes : PackedByteArray, index : int, count : int, data_type : int):
+                if data_type == PB_DATA_TYPE.FLOAT:
+                        return bytes.decode_float(index)
+                elif data_type == PB_DATA_TYPE.DOUBLE:
+                        return bytes.decode_double(index)
+                else:
+                        # Convert to big endian
+                        var slice: PackedByteArray = bytes.slice(index, index + count)
+                        slice.reverse()
+                        return slice
+
+        static func unpack_varint(varint_bytes) -> int:
+                var value : int = 0
+                var i: int = varint_bytes.size() - 1
+                while i > -1:
+                        value = (value << 7) | (varint_bytes[i] & 0x7F)
+                        i -= 1
+                return value
+
+        static func pack_type_tag(type : int, tag : int) -> PackedByteArray:
+                return pack_varint((tag << 3) | type)
+
+        static func isolate_varint(bytes : PackedByteArray, index : int) -> PackedByteArray:
+                var i: int = index
+                while i <= index + 10: # Protobuf varint max size is 10 bytes
+                        if !(bytes[i] & 0x80):
+                                return bytes.slice(index, i + 1)
+                        i += 1
+                return [] # Unreachable
+
+        static func unpack_type_tag(bytes : PackedByteArray, index : int) -> PBTypeTag:
+                var varint_bytes : PackedByteArray = isolate_varint(bytes, index)
+                var result : PBTypeTag = PBTypeTag.new()
+                if varint_bytes.size() != 0:
+                        result.ok = true
+                        result.offset = varint_bytes.size()
+                        var unpacked : int = unpack_varint(varint_bytes)
+                        result.type = unpacked & 0x07
+                        result.tag = unpacked >> 3
+                return result
+
+        static func pack_length_delimeted(type : int, tag : int, bytes : PackedByteArray) -> PackedByteArray:
+                var result : PackedByteArray = pack_type_tag(type, tag)
+                result.append_array(pack_varint(bytes.size()))
+                result.append_array(bytes)
+                return result
+
+        static func pb_type_from_data_type(data_type : int) -> int:
+                if data_type == PB_DATA_TYPE.INT32 || data_type == PB_DATA_TYPE.SINT32 || data_type == PB_DATA_TYPE.UINT32 || data_type == PB_DATA_TYPE.INT64 || data_type == PB_DATA_TYPE.SINT64 || data_type == PB_DATA_TYPE.UINT64 || data_type == PB_DATA_TYPE.BOOL || data_type == PB_DATA_TYPE.ENUM:
+                        return PB_TYPE.VARINT
+                elif data_type == PB_DATA_TYPE.FIXED32 || data_type == PB_DATA_TYPE.SFIXED32 || data_type == PB_DATA_TYPE.FLOAT:
+                        return PB_TYPE.FIX32
+                elif data_type == PB_DATA_TYPE.FIXED64 || data_type == PB_DATA_TYPE.SFIXED64 || data_type == PB_DATA_TYPE.DOUBLE:
+                        return PB_TYPE.FIX64
+                elif data_type == PB_DATA_TYPE.STRING || data_type == PB_DATA_TYPE.BYTES || data_type == PB_DATA_TYPE.MESSAGE || data_type == PB_DATA_TYPE.MAP:
+                        return PB_TYPE.LENGTHDEL
+                else:
+                        return PB_TYPE.UNDEFINED
+
+        static func pack_field(field : PBField) -> PackedByteArray:
+                var type : int = pb_type_from_data_type(field.type)
+                var type_copy : int = type
+                if field.rule == PB_RULE.REPEATED && field.option_packed:
+                        type = PB_TYPE.LENGTHDEL
+                var head : PackedByteArray = pack_type_tag(type, field.tag)
+                var data : PackedByteArray = PackedByteArray()
+                if type == PB_TYPE.VARINT:
+                        var value
+                        if field.rule == PB_RULE.REPEATED:
+                                for v in field.value:
+                                        data.append_array(head)
+                                        if field.type == PB_DATA_TYPE.SINT32 || field.type == PB_DATA_TYPE.SINT64:
+                                                value = convert_signed(v)
+                                        else:
+                                                value = v
+                                        data.append_array(pack_varint(value))
+                                return data
+                        else:
+                                if field.type == PB_DATA_TYPE.SINT32 || field.type == PB_DATA_TYPE.SINT64:
+                                        value = convert_signed(field.value)
+                                else:
+                                        value = field.value
+                                data = pack_varint(value)
+                elif type == PB_TYPE.FIX32:
+                        if field.rule == PB_RULE.REPEATED:
+                                for v in field.value:
+                                        data.append_array(head)
+                                        data.append_array(pack_bytes(v, 4, field.type))
+                                return data
+                        else:
+                                data.append_array(pack_bytes(field.value, 4, field.type))
+                elif type == PB_TYPE.FIX64:
+                        if field.rule == PB_RULE.REPEATED:
+                                for v in field.value:
+                                        data.append_array(head)
+                                        data.append_array(pack_bytes(v, 8, field.type))
+                                return data
+                        else:
+                                data.append_array(pack_bytes(field.value, 8, field.type))
+                elif type == PB_TYPE.LENGTHDEL:
+                        if field.rule == PB_RULE.REPEATED:
+                                if type_copy == PB_TYPE.VARINT:
+                                        if field.type == PB_DATA_TYPE.SINT32 || field.type == PB_DATA_TYPE.SINT64:
+                                                var signed_value : int
+                                                for v in field.value:
+                                                        signed_value = convert_signed(v)
+                                                        data.append_array(pack_varint(signed_value))
+                                        else:
+                                                for v in field.value:
+                                                        data.append_array(pack_varint(v))
+                                        return pack_length_delimeted(type, field.tag, data)
+                                elif type_copy == PB_TYPE.FIX32:
+                                        for v in field.value:
+                                                data.append_array(pack_bytes(v, 4, field.type))
+                                        return pack_length_delimeted(type, field.tag, data)
+                                elif type_copy == PB_TYPE.FIX64:
+                                        for v in field.value:
+                                                data.append_array(pack_bytes(v, 8, field.type))
+                                        return pack_length_delimeted(type, field.tag, data)
+                                elif field.type == PB_DATA_TYPE.STRING:
+                                        for v in field.value:
+                                                var obj = v.to_utf8_buffer()
+                                                data.append_array(pack_length_delimeted(type, field.tag, obj))
+                                        return data
+                                elif field.type == PB_DATA_TYPE.BYTES:
+                                        for v in field.value:
+                                                data.append_array(pack_length_delimeted(type, field.tag, v))
+                                        return data
+                                elif typeof(field.value[0]) == TYPE_OBJECT:
+                                        for v in field.value:
+                                                var obj : PackedByteArray = v.to_bytes()
+                                                data.append_array(pack_length_delimeted(type, field.tag, obj))
+                                        return data
+                        else:
+                                if field.type == PB_DATA_TYPE.STRING:
+                                        var str_bytes : PackedByteArray = field.value.to_utf8_buffer()
+                                        if PROTO_VERSION == 2 || (PROTO_VERSION == 3 && str_bytes.size() > 0):
+                                                data.append_array(str_bytes)
+                                                return pack_length_delimeted(type, field.tag, data)
+                                if field.type == PB_DATA_TYPE.BYTES:
+                                        if PROTO_VERSION == 2 || (PROTO_VERSION == 3 && field.value.size() > 0):
+                                                data.append_array(field.value)
+                                                return pack_length_delimeted(type, field.tag, data)
+                                elif typeof(field.value) == TYPE_OBJECT:
+                                        var obj : PackedByteArray = field.value.to_bytes()
+                                        if obj.size() > 0:
+                                                data.append_array(obj)
+                                        return pack_length_delimeted(type, field.tag, data)
+                                else:
+                                        pass
+                if data.size() > 0:
+                        head.append_array(data)
+                        return head
+                else:
+                        return data
+
+        static func skip_unknown_field(bytes : PackedByteArray, offset : int, type : int) -> int:
+                if type == PB_TYPE.VARINT:
+                        return offset + isolate_varint(bytes, offset).size()
+                if type == PB_TYPE.FIX64:
+                        return offset + 8
+                if type == PB_TYPE.LENGTHDEL:
+                        var length_bytes : PackedByteArray = isolate_varint(bytes, offset)
+                        var length : int = unpack_varint(length_bytes)
+                        return offset + length_bytes.size() + length
+                if type == PB_TYPE.FIX32:
+                        return offset + 4
+                return PB_ERR.UNDEFINED_STATE
+
+        static func unpack_field(bytes : PackedByteArray, offset : int, field : PBField, type : int, message_func_ref) -> int:
+                if field.rule == PB_RULE.REPEATED && type != PB_TYPE.LENGTHDEL && field.option_packed:
+                        var count = isolate_varint(bytes, offset)
+                        if count.size() > 0:
+                                offset += count.size()
+                                count = unpack_varint(count)
+                                if type == PB_TYPE.VARINT:
+                                        var val
+                                        var counter = offset + count
+                                        while offset < counter:
+                                                val = isolate_varint(bytes, offset)
+                                                if val.size() > 0:
+                                                        offset += val.size()
+                                                        val = unpack_varint(val)
+                                                        if field.type == PB_DATA_TYPE.SINT32 || field.type == PB_DATA_TYPE.SINT64:
+                                                                val = deconvert_signed(val)
+                                                        elif field.type == PB_DATA_TYPE.BOOL:
+                                                                if val:
+                                                                        val = true
+                                                                else:
+                                                                        val = false
+                                                        field.value.append(val)
+                                                else:
+                                                        return PB_ERR.REPEATED_COUNT_MISMATCH
+                                        return offset
+                                elif type == PB_TYPE.FIX32 || type == PB_TYPE.FIX64:
+                                        var type_size
+                                        if type == PB_TYPE.FIX32:
+                                                type_size = 4
+                                        else:
+                                                type_size = 8
+                                        var val
+                                        var counter = offset + count
+                                        while offset < counter:
+                                                if (offset + type_size) > bytes.size():
+                                                        return PB_ERR.REPEATED_COUNT_MISMATCH
+                                                val = unpack_bytes(bytes, offset, type_size, field.type)
+                                                offset += type_size
+                                                field.value.append(val)
+                                        return offset
+                        else:
+                                return PB_ERR.REPEATED_COUNT_NOT_FOUND
+                else:
+                        if type == PB_TYPE.VARINT:
+                                var val = isolate_varint(bytes, offset)
+                                if val.size() > 0:
+                                        offset += val.size()
+                                        val = unpack_varint(val)
+                                        if field.type == PB_DATA_TYPE.SINT32 || field.type == PB_DATA_TYPE.SINT64:
+                                                val = deconvert_signed(val)
+                                        elif field.type == PB_DATA_TYPE.BOOL:
+                                                if val:
+                                                        val = true
+                                                else:
+                                                        val = false
+                                        if field.rule == PB_RULE.REPEATED:
+                                                field.value.append(val)
+                                        else:
+                                                field.value = val
+                                else:
+                                        return PB_ERR.VARINT_NOT_FOUND
+                                return offset
+                        elif type == PB_TYPE.FIX32 || type == PB_TYPE.FIX64:
+                                var type_size
+                                if type == PB_TYPE.FIX32:
+                                        type_size = 4
+                                else:
+                                        type_size = 8
+                                var val
+                                if (offset + type_size) > bytes.size():
+                                        return PB_ERR.REPEATED_COUNT_MISMATCH
+                                val = unpack_bytes(bytes, offset, type_size, field.type)
+                                offset += type_size
+                                if field.rule == PB_RULE.REPEATED:
+                                        field.value.append(val)
+                                else:
+                                        field.value = val
+                                return offset
+                        elif type == PB_TYPE.LENGTHDEL:
+                                var inner_size = isolate_varint(bytes, offset)
+                                if inner_size.size() > 0:
+                                        offset += inner_size.size()
+                                        inner_size = unpack_varint(inner_size)
+                                        if inner_size >= 0:
+                                                if inner_size + offset > bytes.size():
+                                                        return PB_ERR.LENGTHDEL_SIZE_MISMATCH
+                                                if message_func_ref != null:
+                                                        var message = message_func_ref.call()
+                                                        if inner_size > 0:
+                                                                var sub_offset = message.from_bytes(bytes, offset, inner_size + offset)
+                                                                if sub_offset > 0:
+                                                                        if sub_offset - offset >= inner_size:
+                                                                                offset = sub_offset
+                                                                                return offset
+                                                                        else:
+                                                                                return PB_ERR.LENGTHDEL_SIZE_MISMATCH
+                                                                return sub_offset
+                                                        else:
+                                                                return offset
+                                                elif field.type == PB_DATA_TYPE.STRING:
+                                                        var str_bytes : PackedByteArray = bytes.slice(offset, inner_size + offset)
+                                                        if field.rule == PB_RULE.REPEATED:
+                                                                field.value.append(str_bytes.get_string_from_utf8())
+                                                        else:
+                                                                field.value = str_bytes.get_string_from_utf8()
+                                                        return offset + inner_size
+                                                elif field.type == PB_DATA_TYPE.BYTES:
+                                                        var val_bytes : PackedByteArray = bytes.slice(offset, inner_size + offset)
+                                                        if field.rule == PB_RULE.REPEATED:
+                                                                field.value.append(val_bytes)
+                                                        else:
+                                                                field.value = val_bytes
+                                                        return offset + inner_size
+                                        else:
+                                                return PB_ERR.LENGTHDEL_SIZE_NOT_FOUND
+                                else:
+                                        return PB_ERR.LENGTHDEL_SIZE_NOT_FOUND
+                return PB_ERR.UNDEFINED_STATE
+
+        static func unpack_message(data, bytes : PackedByteArray, offset : int, limit : int) -> int:
+                while true:
+                        var tt : PBTypeTag = unpack_type_tag(bytes, offset)
+                        if tt.ok:
+                                offset += tt.offset
+                                if data.has(tt.tag):
+                                        var service : PBServiceField = data[tt.tag]
+                                        var type : int = pb_type_from_data_type(service.field.type)
+                                        if type == tt.type || (tt.type == PB_TYPE.LENGTHDEL && service.field.rule == PB_RULE.REPEATED && service.field.option_packed):
+                                                var res : int = unpack_field(bytes, offset, service.field, type, service.func_ref)
+                                                if res > 0:
+                                                        service.state = PB_SERVICE_STATE.FILLED
+                                                        offset = res
+                                                        if offset == limit:
+                                                                return offset
+                                                        elif offset > limit:
+                                                                return PB_ERR.PACKAGE_SIZE_MISMATCH
+                                                elif res < 0:
+                                                        return res
+                                                else:
+                                                        break
+                                else:
+                                        var res : int = skip_unknown_field(bytes, offset, tt.type)
+                                        if res > 0:
+                                                offset = res
+                                                if offset == limit:
+                                                        return offset
+                                                elif offset > limit:
+                                                        return PB_ERR.PACKAGE_SIZE_MISMATCH
+                                        elif res < 0:
+                                                return res
+                                        else:
+                                                break                                                   
+                        else:
+                                return offset
+                return PB_ERR.UNDEFINED_STATE
+
+        static func pack_message(data) -> PackedByteArray:
+                var DEFAULT_VALUES
+                if PROTO_VERSION == 2:
+                        DEFAULT_VALUES = DEFAULT_VALUES_2
+                elif PROTO_VERSION == 3:
+                        DEFAULT_VALUES = DEFAULT_VALUES_3
+                var result : PackedByteArray = PackedByteArray()
+                var keys : Array = data.keys()
+                keys.sort()
+                for i in keys:
+                        if data[i].field.value != null:
+                                if data[i].state == PB_SERVICE_STATE.UNFILLED \
+                                && !data[i].field.is_map_field \
+                                && typeof(data[i].field.value) == typeof(DEFAULT_VALUES[data[i].field.type]) \
+                                && data[i].field.value == DEFAULT_VALUES[data[i].field.type]:
+                                        continue
+                                elif data[i].field.rule == PB_RULE.REPEATED && data[i].field.value.size() == 0:
+                                        continue
+                                result.append_array(pack_field(data[i].field))
+                        elif data[i].field.rule == PB_RULE.REQUIRED:
+                                print("Error: required field is not filled: Tag:", data[i].field.tag)
+                                return PackedByteArray()
+                return result
+
+        static func check_required(data) -> bool:
+                var keys : Array = data.keys()
+                for i in keys:
+                        if data[i].field.rule == PB_RULE.REQUIRED && data[i].state == PB_SERVICE_STATE.UNFILLED:
+                                return false
+                return true
+
+        static func construct_map(key_values):
+                var result = {}
+                for kv in key_values:
+                        result[kv.get_key()] = kv.get_value()
+                return result
+        
+        static func tabulate(text : String, nesting : int) -> String:
+                var tab : String = ""
+                for _i in range(nesting):
+                        tab += DEBUG_TAB
+                return tab + text
+        
+        static func value_to_string(value, field : PBField, nesting : int) -> String:
+                var result : String = ""
+                var text : String
+                if field.type == PB_DATA_TYPE.MESSAGE:
+                        result += "{"
+                        nesting += 1
+                        text = message_to_string(value.data, nesting)
+                        if text != "":
+                                result += "\n" + text
+                                nesting -= 1
+                                result += tabulate("}", nesting)
+                        else:
+                                nesting -= 1
+                                result += "}"
+                elif field.type == PB_DATA_TYPE.BYTES:
+                        result += "<"
+                        for i in range(value.size()):
+                                result += str(value[i])
+                                if i != (value.size() - 1):
+                                        result += ", "
+                        result += ">"
+                elif field.type == PB_DATA_TYPE.STRING:
+                        result += "\"" + value + "\""
+                elif field.type == PB_DATA_TYPE.ENUM:
+                        result += "ENUM::" + str(value)
+                else:
+                        result += str(value)
+                return result
+        
+        static func field_to_string(field : PBField, nesting : int) -> String:
+                var result : String = tabulate(field.name + ": ", nesting)
+                if field.type == PB_DATA_TYPE.MAP:
+                        if field.value.size() > 0:
+                                result += "(\n"
+                                nesting += 1
+                                for i in range(field.value.size()):
+                                        var local_key_value = field.value[i].data[1].field
+                                        result += tabulate(value_to_string(local_key_value.value, local_key_value, nesting), nesting) + ": "
+                                        local_key_value = field.value[i].data[2].field
+                                        result += value_to_string(local_key_value.value, local_key_value, nesting)
+                                        if i != (field.value.size() - 1):
+                                                result += ","
+                                        result += "\n"
+                                nesting -= 1
+                                result += tabulate(")", nesting)
+                        else:
+                                result += "()"
+                elif field.rule == PB_RULE.REPEATED:
+                        if field.value.size() > 0:
+                                result += "[\n"
+                                nesting += 1
+                                for i in range(field.value.size()):
+                                        result += tabulate(str(i) + ": ", nesting)
+                                        result += value_to_string(field.value[i], field, nesting)
+                                        if i != (field.value.size() - 1):
+                                                result += ","
+                                        result += "\n"
+                                nesting -= 1
+                                result += tabulate("]", nesting)
+                        else:
+                                result += "[]"
+                else:
+                        result += value_to_string(field.value, field, nesting)
+                result += ";\n"
+                return result
+                
+        static func message_to_string(data, nesting : int = 0) -> String:
+                var DEFAULT_VALUES
+                if PROTO_VERSION == 2:
+                        DEFAULT_VALUES = DEFAULT_VALUES_2
+                elif PROTO_VERSION == 3:
+                        DEFAULT_VALUES = DEFAULT_VALUES_3
+                var result : String = ""
+                var keys : Array = data.keys()
+                keys.sort()
+                for i in keys:
+                        if data[i].field.value != null:
+                                if data[i].state == PB_SERVICE_STATE.UNFILLED \
+                                && !data[i].field.is_map_field \
+                                && typeof(data[i].field.value) == typeof(DEFAULT_VALUES[data[i].field.type]) \
+                                && data[i].field.value == DEFAULT_VALUES[data[i].field.type]:
+                                        continue
+                                elif data[i].field.rule == PB_RULE.REPEATED && data[i].field.value.size() == 0:
+                                        continue
+                                result += field_to_string(data[i].field, nesting)
+                        elif data[i].field.rule == PB_RULE.REQUIRED:
+                                result += data[i].field.name + ": " + "error"
+                return result
@@ -0,0 +1,46 @@
+#
+# BSD 3-Clause License
+#
+# Copyright (c) 2018, Oleg Malyavkin
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# * Redistributions of source code must retain the above copyright notice, this
+#   list of conditions and the following disclaimer.
+#
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+#
+# * Neither the name of the copyright holder nor the names of its
+#   contributors may be used to endorse or promote products derived from
+#   this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+static func extract_dir(file_path):
+        var parts = file_path.split("/", false)
+        parts.remove_at(parts.size() - 1)
+        var path
+        if file_path.begins_with("/"):
+                path = "/"
+        else:
+                path = ""
+        for part in parts:
+                path += part + "/"
+        return path
+
+static func extract_filename(file_path):
+        var parts = file_path.split("/", false)
+        return parts[parts.size() - 1]
@@ -0,0 +1,7 @@
+[gd_resource type="Environment" load_steps=2 format=2]
+
+[sub_resource type="ProceduralSky" id=1]
+
+[resource]
+background_mode = 2
+background_sky = SubResource( 1 )
@@ -0,0 +1,35 @@
+[remap]
+
+importer="texture"
+type="StreamTexture"
+path="res://.import/logo.png-cca8726399059c8d4f806e28e356b14d.stex"
+metadata={
+"vram_texture": false
+}
+
+[deps]
+
+source_file="res://logo.png"
+dest_files=[ "res://.import/logo.png-cca8726399059c8d4f806e28e356b14d.stex" ]
+
+[params]
+
+compress/mode=0
+compress/lossy_quality=0.7
+compress/hdr_mode=0
+compress/bptc_ldr=0
+compress/normal_map=0
+flags/repeat=0
+flags/filter=true
+flags/mipmaps=false
+flags/anisotropic=false
+flags/srgb=2
+process/fix_alpha_border=true
+process/premult_alpha=false
+process/HDR_as_SRGB=false
+process/invert_color=false
+process/normal_map_invert_y=false
+stream=false
+size_limit=0
+detect_3d=true
+svg/scale=1.0
@@ -0,0 +1,26 @@
+; Engine configuration file.
+; It's best edited using the editor UI and not directly,
+; since the parameters that go here are not all obvious.
+;
+; Format:
+;   [section] ; section goes between []
+;   param=value ; assign values to parameters
+
+config_version=4
+
+_global_script_classes=[  ]
+_global_script_class_icons={
+}
+
+[application]
+
+config/name="Protobuf Plugin"
+config/icon="res://logo.png"
+
+[editor_plugins]
+
+enabled=PoolStringArray( "res://addons/protobuf/plugin.cfg" )
+
+[rendering]
+
+environment/default_environment="res://default_env.tres"