676 files changed, 14820 insertions, 1277 deletions

@@ -5,3 +5,4 @@ apworld/generated/
 __pycache__
 .vs/
 ^out/
+client/Archipelago/generated/
@@ -0,0 +1,104 @@
+# 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.
+
+## How To Play
+
+Here are the components needed in order to play:
+
+- **Apworld**: This is used by Archipelago to generate randomized Lingo 2
+  worlds.
+    - [Installation & FAQ](https://code.fourisland.com/lingo2-archipelago/about/apworld/README.md)
+    - [Downloads](https://code.fourisland.com/lingo2-archipelago/about/apworld/CHANGELOG.md)
+- **Client**: This is how Lingo 2 connects to an Archipelago multiworld.
+    - [Installation & FAQ](https://code.fourisland.com/lingo2-archipelago/about/client/README.md)
+    - [Downloads](https://code.fourisland.com/lingo2-archipelago/about/client/CHANGELOG.md)
+
+## 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
+
+### 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.
+
+## Project Details
+
+There are multiple parts of this project:
+
+- [Client](https://code.fourisland.com/lingo2-archipelago/about/client/README.md)
+- [Apworld](https://code.fourisland.com/lingo2-archipelago/about/apworld/README.md)
+- [Data](https://code.fourisland.com/lingo2-archipelago/about/data/README.md)
@@ -0,0 +1,54 @@
+# lingo2-archipelago Apworld Releases
+
+## 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)
+
+## 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)
+
+## 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)
+
+## 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,48 @@
+# Lingo 2 Apworld
+
+The Lingo 2 Apworld allows you to generate Archipelago Multiworlds containing
+Lingo 2.
+
+## Installation
+
+1. Download the Lingo 2 Apworld from
+   [the releases page](https://code.fourisland.com/lingo2-archipelago/about/apworld/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.
+
+## Running from source
+
+The apworld is mostly written in Python, which does not need to be compiled.
+However, there are two 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.
+
+After generating those two 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,27 @@
 """
 Archipelago init file for Lingo 2
 """
-from BaseClasses import ItemClassification, Item
+from BaseClasses import ItemClassification, Item, Tutorial
 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 .static_logic import Lingo2StaticLogic
+from .version import APWORLD_VERSION
 
 
 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 Lingo2World(World):
@@ -24,12 +33,16 @@ class Lingo2World(World):
     game = "Lingo 2"
     web = Lingo2WebWorld()
 
+    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
 
     player_logic: Lingo2PlayerLogic
 
@@ -49,11 +62,55 @@ 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",
+            "strict_cyan_ending",
+            "strict_purple_ending",
+            "victory_condition",
+        ]
+
+        slot_data = {
+            **self.options.as_dict(*slot_options),
+            "version": [self.static_logic.get_data_version(), APWORLD_VERSION],
+        }
+
+        return slot_data
+
+    def get_filler_item_name(self) -> str:
+        return "A Job Well Done"
@@ -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"]
@@ -1,13 +1,166 @@
 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 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
+    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:
+                    continue
+            elif door_group.type == data_pb2.DoorGroupType.COLOR_CONNECTOR:
+                if not self.world.options.shuffle_control_center_colors:
+                    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,57 @@ 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:
+                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 ever create a location for White Ending. Don't even make an event for it if it's not the victory
+            # condition, since it is necessarily going to be in the postgame.
+            if ending.name == "WHITE":
+                if self.world.options.victory_condition != VictoryCondition.option_white_ending:
+                    continue
+            else:
+                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 +366,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 +420,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 +489,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,7 @@
 from typing import TYPE_CHECKING
 
-from BaseClasses import Region
+from BaseClasses import Region, ItemClassification, Entrance
+from .items import Lingo2Item
 from .locations import Lingo2Location
 from .player_logic import AccessRequirements
 from .rules import make_location_lambda
@@ -10,32 +11,56 @@ 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)
 
-    return new_region
-
+    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)
+        event_item = Lingo2Item(item_name, ItemClassification.progression, None, world.player)
+        new_location.place_locked_item(event_item)
+        new_region.locations.append(new_location)
 
 def create_regions(world: "Lingo2World"):
     regions = {
         "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
+
         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()
@@ -72,7 +97,22 @@ 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()
@@ -1 +1 @@
-protobuf>=5.29.3
\ No newline at end of file
+protobuf==3.20.3
@@ -1,27 +1,63 @@
 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]) -> Callable[[CollectionState], bool]:
+    # Replace required rooms with regions for the top level requirement, which saves looking up the regions during rule
+    # checking.
+    required_regions = [regions[room_name] 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,4 +1,5 @@
 from .generated import data_pb2 as data_pb2
+from .items import SYMBOL_ITEMS, ANTI_COLLECTABLE_TRAPS
 import pkgutil
 
 class Lingo2StaticLogic:
@@ -8,9 +9,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 +27,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
 
-        self.item_id_to_name[self.objects.special_ids["Nothing"]] = "Nothing"
+        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
+
+        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 +155,15 @@ 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) -> int:
+        return self.objects.version
@@ -0,0 +1 @@
+APWORLD_VERSION = 6
@@ -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,417 @@
+extends Node
+
+const ap_version = {"major": 0, "minor": 6, "build": 3, "class": "Version"}
+
+var SCRIPT_uuid
+
+var _ws = WebSocketPeer.new()
+var _should_process = false
+var _initiated_disconnect = false
+var _try_wss = false
+var _has_connected = false
+
+var _datapackages = {}
+var _pending_packages = []
+var _item_id_to_name = {}  # All games
+var _location_id_to_name = {}  # All games
+var _item_name_to_id = {}  # Lingo 2 only
+var _location_name_to_id = {}  # Lingo 2 only
+
+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 _authenticated = false
+var _seed = ""
+var _team = 0
+var _slot = 0
+var _players = []
+var _player_name_by_slot = {}
+var _game_by_player = {}
+var _checked_locations = []
+var _received_indexes = []
+var _received_items = {}
+var _slot_data = {}
+
+signal could_not_connect
+signal connect_status
+signal client_connected(slot_data)
+signal item_received(item_id, index, player, flags, amount)
+signal message_received(message)
+signal location_scout_received(item_id, location_id, player, flags)
+
+
+func _init():
+        set_process_mode(Node.PROCESS_MODE_ALWAYS)
+
+        _ws.inbound_buffer_size = 8388608
+
+        global._print("Instantiated APClient")
+
+        # Read AP datapackages from file, if there are any
+        if FileAccess.file_exists("user://ap_datapackages"):
+                var file = FileAccess.open("user://ap_datapackages", FileAccess.READ)
+                var data = file.get_var(true)
+                file.close()
+
+                if typeof(data) != TYPE_DICTIONARY:
+                        global._print("AP datapackages file is corrupted")
+                        data = {}
+
+                _datapackages = data
+
+                processDatapackages()
+
+
+func _ready():
+        pass
+        #_ws.connect("connection_closed", _closed)
+        #_ws.connect("connection_failed", _closed)
+        #_ws.connect("server_disconnected", _closed)
+        #_ws.connect("connection_error", _errored)
+        #_ws.connect("connection_established", _connected)
+
+
+func _reset_state():
+        _should_process = false
+        _authenticated = false
+        _try_wss = false
+        _has_connected = false
+        _received_items = {}
+        _received_indexes = []
+
+
+func _errored():
+        if _try_wss:
+                global._print("Could not connect to AP with ws://, now trying wss://")
+                connectToServer(ap_server, ap_user, ap_pass)
+        else:
+                global._print("AP connection failed")
+                _reset_state()
+
+                emit_signal(
+                        "could_not_connect",
+                        "Could not connect to Archipelago. Check that your server and port are correct. See the error log for more information."
+                )
+
+
+func _closed(_was_clean = true):
+        global._print("Connection closed")
+        _reset_state()
+
+        if not _initiated_disconnect:
+                emit_signal("could_not_connect", "Disconnected from Archipelago")
+
+        _initiated_disconnect = false
+
+
+func _connected(_proto = ""):
+        global._print("Connected!")
+        _try_wss = false
+
+
+func disconnect_from_ap():
+        _initiated_disconnect = true
+        _ws.close()
+
+
+func _process(_delta):
+        if _should_process:
+                _ws.poll()
+
+                var state = _ws.get_ready_state()
+                if state == WebSocketPeer.STATE_OPEN:
+                        if not _has_connected:
+                                _has_connected = true
+
+                                _connected()
+
+                        while _ws.get_available_packet_count():
+                                var packet = _ws.get_packet()
+                                global._print("Got data from server: " + packet.get_string_from_utf8())
+                                var json = JSON.new()
+                                var jserror = json.parse(packet.get_string_from_utf8())
+                                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 == "RoomInfo":
+                                                _seed = message["seed_name"]
+                                                _remote_version = message["version"]
+                                                _gen_version = message["generator_version"]
+
+                                                var needed_games = []
+                                                for game in message["datapackage_checksums"].keys():
+                                                        if (
+                                                                !_datapackages.has(game)
+                                                                or (
+                                                                        _datapackages[game]["checksum"]
+                                                                        != message["datapackage_checksums"][game]
+                                                                )
+                                                        ):
+                                                                needed_games.append(game)
+
+                                                if !needed_games.is_empty():
+                                                        _pending_packages = needed_games
+                                                        var cur_needed = _pending_packages.pop_front()
+                                                        requestDatapackages([cur_needed])
+                                                else:
+                                                        connectToRoom()
+
+                                        elif cmd == "DataPackage":
+                                                for game in message["data"]["games"].keys():
+                                                        _datapackages[game] = message["data"]["games"][game]
+                                                saveDatapackages()
+
+                                                if !_pending_packages.is_empty():
+                                                        var cur_needed = _pending_packages.pop_front()
+                                                        requestDatapackages([cur_needed])
+                                                else:
+                                                        processDatapackages()
+                                                        connectToRoom()
+
+                                        elif cmd == "Connected":
+                                                _authenticated = true
+                                                _team = message["team"]
+                                                _slot = message["slot"]
+                                                _players = message["players"]
+                                                _checked_locations = message["checked_locations"]
+                                                _slot_data = message["slot_data"]
+
+                                                for player in _players:
+                                                        _player_name_by_slot[player["slot"]] = player["alias"]
+                                                        _game_by_player[player["slot"]] = message["slot_info"][str(
+                                                                player["slot"]
+                                                        )]["game"]
+
+                                                emit_signal("client_connected", _slot_data)
+
+                                        elif cmd == "ConnectionRefused":
+                                                var error_message = ""
+                                                for error in message["errors"]:
+                                                        var submsg = ""
+                                                        if error == "InvalidSlot":
+                                                                submsg = "Invalid player name."
+                                                        elif error == "InvalidGame":
+                                                                submsg = "The specified player is not playing Lingo."
+                                                        elif error == "IncompatibleVersion":
+                                                                submsg = (
+                                                                        "The Archipelago server is not the correct version for this client. Expected v%d.%d.%d. Found v%d.%d.%d."
+                                                                        % [
+                                                                                ap_version["major"],
+                                                                                ap_version["minor"],
+                                                                                ap_version["build"],
+                                                                                _remote_version["major"],
+                                                                                _remote_version["minor"],
+                                                                                _remote_version["build"]
+                                                                        ]
+                                                                )
+                                                        elif error == "InvalidPassword":
+                                                                submsg = "Incorrect password."
+                                                        elif error == "InvalidItemsHandling":
+                                                                submsg = "Invalid item handling flag. This is a bug with the client."
+
+                                                        if submsg != "":
+                                                                if error_message != "":
+                                                                        error_message += " "
+                                                                error_message += submsg
+
+                                                if error_message == "":
+                                                        error_message = "Unknown error."
+
+                                                _initiated_disconnect = true
+                                                _ws.close()
+
+                                                emit_signal("could_not_connect", error_message)
+                                                global._print("Connection to AP refused")
+                                                global._print(message)
+
+                                        elif cmd == "ReceivedItems":
+                                                var i = 0
+                                                for item in message["items"]:
+                                                        var index = int(message["index"] + i)
+                                                        i += 1
+
+                                                        if _received_indexes.has(index):
+                                                                # Do not re-process items.
+                                                                continue
+
+                                                        _received_indexes.append(index)
+
+                                                        var item_id = int(item["item"])
+                                                        _received_items[item_id] = _received_items.get(item_id, 0) + 1
+
+                                                        emit_signal(
+                                                                "item_received",
+                                                                item_id,
+                                                                index,
+                                                                int(item["player"]),
+                                                                int(item["flags"]),
+                                                                _received_items[item_id]
+                                                        )
+
+                                        elif cmd == "PrintJSON":
+                                                emit_signal("message_received", message)
+
+                                        elif cmd == "LocationInfo":
+                                                for loc in message["locations"]:
+                                                        emit_signal(
+                                                                "location_scout_received",
+                                                                int(loc["item"]),
+                                                                int(loc["location"]),
+                                                                int(loc["player"]),
+                                                                int(loc["flags"])
+                                                        )
+
+                elif state == WebSocketPeer.STATE_CLOSED:
+                        if _has_connected:
+                                _closed()
+                        else:
+                                _errored()
+
+
+func saveDatapackages():
+        # Save the AP datapackages to disk.
+        var file = FileAccess.open("user://ap_datapackages", FileAccess.WRITE)
+        file.store_var(_datapackages, true)
+        file.close()
+
+
+func connectToServer(server, un, pw):
+        ap_server = server
+        ap_user = un
+        ap_pass = pw
+
+        _initiated_disconnect = false
+
+        var url = ""
+        if ap_server.begins_with("ws://") or ap_server.begins_with("wss://"):
+                url = ap_server
+                _try_wss = false
+        elif _try_wss:
+                url = "wss://" + ap_server
+                _try_wss = false
+        else:
+                url = "ws://" + ap_server
+                _try_wss = true
+
+        var err = _ws.connect_to_url(url)
+        if err != OK:
+                emit_signal(
+                        "could_not_connect",
+                        (
+                                "Could not connect to Archipelago. Check that your server and port are correct. See the error log for more information. Error code: %d."
+                                % err
+                        )
+                )
+                global._print("Could not connect to AP: %d" % err)
+                return
+        _should_process = true
+
+        emit_signal("connect_status", "Connecting...")
+
+
+func sendMessage(msg):
+        var payload = JSON.stringify(msg)
+        _ws.send_text(payload)
+
+
+func requestDatapackages(games):
+        emit_signal("connect_status", "Downloading %s data package..." % games[0])
+
+        sendMessage([{"cmd": "GetDataPackage", "games": games}])
+
+
+func processDatapackages():
+        _item_id_to_name = {}
+        _location_id_to_name = {}
+        for game in _datapackages.keys():
+                var package = _datapackages[game]
+
+                _item_id_to_name[game] = {}
+                for item_name in package["item_name_to_id"].keys():
+                        _item_id_to_name[game][int(package["item_name_to_id"][item_name])] = item_name
+
+                _location_id_to_name[game] = {}
+                for location_name in package["location_name_to_id"].keys():
+                        _location_id_to_name[game][int(package["location_name_to_id"][location_name])] = location_name
+
+        if _datapackages.has("Lingo 2"):
+                _item_name_to_id = _datapackages["Lingo 2"]["item_name_to_id"]
+                _location_name_to_id = _datapackages["Lingo 2"]["location_name_to_id"]
+
+
+func connectToRoom():
+        emit_signal("connect_status", "Authenticating...")
+
+        sendMessage(
+                [
+                        {
+                                "cmd": "Connect",
+                                "password": ap_pass,
+                                "game": "Lingo 2",
+                                "name": ap_user,
+                                "uuid": SCRIPT_uuid.v4(),
+                                "version": ap_version,
+                                "items_handling": 0b111,  # always receive our items
+                                "tags": [],
+                                "slot_data": true
+                        }
+                ]
+        )
+
+
+func sendConnectUpdate(tags):
+        sendMessage([{"cmd": "ConnectUpdate", "tags": tags}])
+
+
+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 setValue(key, value, operation = "replace"):
+        sendMessage(
+                [
+                        {
+                                "cmd": "Set",
+                                "key": "Lingo2_%d_%s" % [_slot, key],
+                                "want_reply": false,
+                                "operations": [{"operation": operation, "value": value}]
+                        }
+                ]
+        )
+
+
+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 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,140 @@
+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 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 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()
+
+        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 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()
+
+        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_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_receivers(door_id):
+        var door = objects.get_doors()[door_id]
+        return door.get_receivers()
+
+
+func get_door_map_name(door_id):
+        var door = objects.get_doors()[door_id]
+        var map = objects.get_maps()[door.get_map_id()]
+        return map.get_name()
@@ -0,0 +1,38 @@
+extends "res://scripts/nodes/keyHolder.gd"
+
+
+func setFromAp(key, level):
+        if level > 0:
+                has_key = true
+                is_complete = "%s%d" % [key, level]
+                held_key = key
+                held_level = level
+                get_node("Hinge/Letter").mesh.text = held_key
+                get_node("Hinge/Letter2").mesh.text = held_key
+                setMaterial()
+                emit_signal("trigger")
+        else:
+                has_key = false
+                held_key = ""
+                held_level = 0
+                setMaterial()
+                get_node("Hinge/Letter").mesh.text = "-"
+                get_node("Hinge/Letter2").mesh.text = "-"
+                is_complete = ""
+                emit_signal("untrigger")
+
+
+func addKey(key):
+        var node_path = String(
+                get_tree().get_root().get_node("scene").get_path_to(self).get_concatenated_names()
+        )
+        var ap = global.get_node("Archipelago")
+        ap.keyboard.put_in_keyholder(key, global.map, node_path)
+
+
+func removeKey():
+        var node_path = String(
+                get_tree().get_root().get_node("scene").get_path_to(self).get_concatenated_names()
+        )
+        var ap = global.get_node("Archipelago")
+        ap.keyboard.remove_from_keyholder(held_key, global.map, node_path)
@@ -0,0 +1,24 @@
+extends "res://scripts/nodes/listeners/keyHolderChecker.gd"
+
+
+func check():
+        var ap = global.get_node("Archipelago")
+        var matches = []
+        for map in ap.keyboard.keyholder_state.keys():
+                var nodes = ap.keyboard.keyholder_state[map]
+                for node in nodes.keys():
+                        matches.append([nodes[node], 1, map, "/root/scene/%s" % node])
+
+        var count = 0
+        for key_match in matches:
+                var active = (
+                        key_match[2] + String(key_match[3]).replace("/root/scene/Components/KeyHolders/", ".")
+                )
+                if map[active] == key_match[0]:
+                        emit_signal("trigger_letter", key_match[0], true)
+                        count += 1
+                else:
+                        emit_signal("trigger_letter", key_match[0], false)
+
+        if count > 25:
+                emit_signal("trigger")
@@ -0,0 +1,8 @@
+extends "res://scripts/nodes/listeners/keyHolderResetterListener.gd"
+
+
+func reset():
+        var ap = global.get_node("Archipelago")
+        var was_removed = ap.keyboard.reset_keyholders()
+        if was_removed:
+                sfxPlayer.sfx_play("pickup")
@@ -0,0 +1,199 @@
+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]
+
+        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):
+        if level < 0 or level > 2 or level < letters_saved.get(key, 0):
+                return
+
+        letters_saved[key] = 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
@@ -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,544 @@
+extends Node
+
+const MOD_VERSION = 7
+
+var SCRIPT_client
+var SCRIPT_keyboard
+var SCRIPT_locationListener
+var SCRIPT_uuid
+var SCRIPT_victoryListener
+
+var ap_server = ""
+var ap_user = ""
+var ap_pass = ""
+var connection_history = []
+var show_compass = 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
+
+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
+
+var apworld_version = [0, 0]
+var cyan_door_behavior = kCYAN_DOOR_BEHAVIOR_H2
+var daedalus_roof_access = false
+var keyholder_sanity = false
+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 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]
+
+
+func _ready():
+        client = SCRIPT_client.new()
+        client.SCRIPT_uuid = SCRIPT_uuid
+
+        client.connect("item_received", _process_item)
+        client.connect("message_received", _process_message)
+        client.connect("location_scout_received", _process_location_scout)
+        client.connect("could_not_connect", _client_could_not_connect)
+        client.connect("connect_status", _client_connect_status)
+        client.connect("client_connected", _client_connected)
+
+        add_child(client)
+
+        keyboard = SCRIPT_keyboard.new()
+        add_child(keyboard)
+
+
+func saveSettings():
+        # Save the AP settings to disk.
+        var path = "user://ap_settings"
+        var file = FileAccess.open(path, FileAccess.WRITE)
+
+        var data = [
+                ap_server,
+                ap_user,
+                ap_pass,
+                connection_history,
+                show_compass,
+        ]
+        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 = {}
+
+        client.connectToServer(ap_server, ap_user, ap_pass)
+
+
+func getSaveFileName():
+        return "zzAP_%s_%d" % [client._seed, client._slot]
+
+
+func disconnect_from_ap():
+        client.disconnect_from_ap()
+
+
+func get_item_id_for_door(door_id):
+        return _item_locks.get(door_id, null)
+
+
+func _process_item(item, index, from, flags, amount):
+        var item_name = "Unknown"
+        if client._item_id_to_name["Lingo 2"].has(item):
+                item_name = client._item_id_to_name["Lingo 2"][item]
+
+        var gamedata = global.get_node("Gamedata")
+
+        var prog_id = null
+        if _inverse_item_locks.has(item):
+                for lock in _inverse_item_locks.get(item):
+                        if lock[1] != amount:
+                                continue
+
+                        if gamedata.progressive_id_by_ap_id.has(item):
+                                prog_id = lock[0]
+
+                        if gamedata.get_door_map_name(lock[0]) != global.map:
+                                continue
+
+                        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, 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):
+                var player = get_tree().get_root().get_node_or_null("scene/player")
+                if player != null:
+                        player.emit_signal("evaluate_solvability")
+
+        # Show a message about the item if it's new.
+        if index != null and index > _last_new_item:
+                _last_new_item = index
+                saveLocaldata()
+
+                var player_name = "Unknown"
+                if client._player_name_by_slot.has(float(from)):
+                        player_name = client._player_name_by_slot[float(from)]
+
+                var item_color = colorForItemType(flags)
+
+                var full_item_name = item_name
+                if prog_id != null:
+                        var door = gamedata.objects.get_doors()[prog_id]
+                        full_item_name = "%s (%s)" % [item_name, door.get_name()]
+
+                var message
+                if from == client._slot:
+                        message = "Found [color=%s]%s[/color]" % [item_color, full_item_name]
+                else:
+                        message = (
+                                "Received [color=%s]%s[/color] from %s" % [item_color, full_item_name, player_name]
+                        )
+
+                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_message(message):
+        parse_printjson_for_textclient(message)
+
+        if (
+                !message.has("receiving")
+                or !message.has("item")
+                or message["item"]["player"] != client._slot
+        ):
+                return
+
+        var item_name = "Unknown"
+        var item_player_game = client._game_by_player[message["receiving"]]
+        if client._item_id_to_name[item_player_game].has(int(message["item"]["item"])):
+                item_name = client._item_id_to_name[item_player_game][int(message["item"]["item"])]
+
+        var location_name = "Unknown"
+        var location_player_game = client._game_by_player[message["item"]["player"]]
+        if client._location_id_to_name[location_player_game].has(int(message["item"]["location"])):
+                location_name = (client._location_id_to_name[location_player_game][int(
+                        message["item"]["location"]
+                )])
+
+        var player_name = "Unknown"
+        if client._player_name_by_slot.has(message["receiving"]):
+                player_name = client._player_name_by_slot[message["receiving"]]
+
+        var item_color = colorForItemType(message["item"]["flags"])
+
+        if message["type"] == "Hint":
+                var is_for = ""
+                if message["receiving"] != client._slot:
+                        is_for = " for %s" % player_name
+                if !message.has("found") || !message["found"]:
+                        global.get_node("Messages").showMessage(
+                                (
+                                        "Hint: [color=%s]%s[/color]%s is on %s"
+                                        % [item_color, item_name, is_for, location_name]
+                                )
+                        )
+        else:
+                if message["receiving"] != client._slot:
+                        var sentMsg = "Sent [color=%s]%s[/color] to %s" % [item_color, item_name, player_name]
+                        #if _hinted_locations.has(message["item"]["location"]):
+                        #       sentMsg += " ([color=#fafad2]Hinted![/color])"
+                        global.get_node("Messages").showMessage(sentMsg)
+
+
+func parse_printjson_for_textclient(message):
+        var parts = []
+        for message_part in message["data"]:
+                if !message_part.has("type") and message_part.has("text"):
+                        parts.append(message_part["text"])
+                elif message_part["type"] == "player_id":
+                        if int(message_part["text"]) == client._slot:
+                                parts.append(
+                                        "[color=#ee00ee]%s[/color]" % client._player_name_by_slot[client._slot]
+                                )
+                        else:
+                                var from = float(message_part["text"])
+                                parts.append("[color=#fafad2]%s[/color]" % client._player_name_by_slot[from])
+                elif message_part["type"] == "item_id":
+                        var item_name = "Unknown"
+                        var item_player_game = client._game_by_player[message_part["player"]]
+                        if client._item_id_to_name[item_player_game].has(int(message_part["text"])):
+                                item_name = client._item_id_to_name[item_player_game][int(message_part["text"])]
+
+                        parts.append(
+                                "[color=%s]%s[/color]" % [colorForItemType(message_part["flags"]), item_name]
+                        )
+                elif message_part["type"] == "location_id":
+                        var location_name = "Unknown"
+                        var location_player_game = client._game_by_player[message_part["player"]]
+                        if client._location_id_to_name[location_player_game].has(int(message_part["text"])):
+                                location_name = client._location_id_to_name[location_player_game][int(
+                                        message_part["text"]
+                                )]
+
+                        parts.append("[color=#00ff7f]%s[/color]" % location_name)
+                elif message_part.has("text"):
+                        parts.append(message_part["text"])
+
+        var textclient_node = global.get_node("Textclient")
+        if textclient_node != null:
+                textclient_node.parse_printjson("".join(parts))
+
+
+func _process_location_scout(item_id, location_id, player, flags):
+        _location_scouts[location_id] = {"item": item_id, "player": player, "flags": flags}
+
+        if player == client._slot 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 item_name = "Unknown"
+        var item_player_game = client._game_by_player[float(player)]
+        if client._item_id_to_name[item_player_game].has(item_id):
+                item_name = client._item_id_to_name[item_player_game][item_id]
+
+        var letter_id = gamedata.letter_id_by_ap_id.get(location_id, null)
+        if letter_id != null:
+                var letter = gamedata.objects.get_letters()[letter_id]
+                var room = gamedata.objects.get_rooms()[letter.get_room_id()]
+                if room.get_map_id() == map_id:
+                        var collectable = get_tree().get_root().get_node("scene").get_node_or_null(
+                                letter.get_path()
+                        )
+                        if collectable != null:
+                                collectable.setScoutedText(item_name)
+
+
+func _client_could_not_connect(message):
+        emit_signal("could_not_connect", message)
+
+
+func _client_connect_status(message):
+        emit_signal("connect_status", message)
+
+
+func _client_connected(slot_data):
+        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))
+        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"):
+                apworld_version = [int(slot_data["version"][0]), int(slot_data["version"][1])]
+
+        # 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
+                                or door_group.get_type() == gamedata.SCRIPT_proto.DoorGroupType.SHUFFLE_GROUP
+                        ):
+                                for door in door_group.get_doors():
+                                        _item_locks[door] = [door_group.get_ap_id(), 1]
+
+        if shuffle_control_center_colors:
+                for door in gamedata.objects.get_doors():
+                        if door.get_type() == gamedata.SCRIPT_proto.DoorType.CONTROL_CENTER_COLOR:
+                                _item_locks[door.get_id()] = [door.get_ap_id(), 1]
+
+                for door_group in gamedata.objects.get_door_groups():
+                        if door_group.get_type() == gamedata.SCRIPT_proto.DoorGroupType.COLOR_CONNECTOR:
+                                for door in door_group.get_doors():
+                                        _item_locks[door] = [door_group.get_ap_id(), 1]
+
+        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]])
+
+        emit_signal("ap_connected")
+
+
+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 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,71 @@
+extends CanvasLayer
+
+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.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,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").connect(
+                                "evaluate_solvability", 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,44 @@
+extends "res://scripts/ui/pauseMenu.gd"
+
+var compass_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)
+
+        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
+        super._main_menu()
+
+
+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
@@ -0,0 +1,362 @@
+extends "res://scripts/nodes/player.gd"
+
+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",
+}
+
+signal evaluate_solvability
+
+var compass
+
+
+func _ready():
+        var khl_script = load("res://scripts/nodes/keyHolderListener.gd")
+
+        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["player"] == ap.client._slot and scout["flags"] & 4 != 0)
+                        ):
+                                var item_name = "Unknown"
+                                var item_player_game = ap.client._game_by_player[float(scout["player"])]
+                                if ap.client._item_id_to_name[item_player_game].has(scout["item"]):
+                                        item_name = ap.client._item_id_to_name[item_player_game][scout["item"]]
+
+                                        var collectable = get_tree().get_root().get_node("scene").get_node_or_null(
+                                                letter.get_path()
+                                        )
+                                        if collectable != null:
+                                                collectable.setScoutedText.call_deferred(item_name)
+
+        # Set up mastery locations.
+        for mastery in gamedata.objects.get_masteries():
+                var room = gamedata.objects.get_rooms()[mastery.get_room_id()]
+                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 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" % kEndingNameByVictoryValue.get(ap.victory_condition, "?")
+
+                var sign2_color = 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()
+
+        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,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,24 @@
+extends Button
+
+
+func _ready():
+        pass
+
+
+func _connect_pressed():
+        self.disabled = true
+
+        var ap = global.get_node("Archipelago")
+        ap.ap_server = self.get_parent().get_node("server_box").text
+        ap.ap_user = self.get_parent().get_node("player_box").text
+        ap.ap_pass = self.get_parent().get_node("password_box").text
+        ap.saveSettings()
+
+        ap.connectToServer()
+
+
+func _back_pressed():
+        var ap = global.get_node("Archipelago")
+        ap.disconnect_from_ap()
+
+        get_tree().change_scene_to_file("res://objects/scenes/menus/main_menu.tscn")
@@ -0,0 +1,252 @@
+extends Node2D
+
+
+func _ready():
+        # 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)
+
+        # Create the global AP manager, if it doesn't already exist.
+        if not global.has_node("Archipelago"):
+                var ap_script = ResourceLoader.load("user://maps/Archipelago/manager.gd")
+                var ap_instance = ap_script.new()
+                ap_instance.name = "Archipelago"
+
+                ap_instance.SCRIPT_client = load("user://maps/Archipelago/client.gd")
+                ap_instance.SCRIPT_keyboard = load("user://maps/Archipelago/keyboard.gd")
+                ap_instance.SCRIPT_locationListener = load("user://maps/Archipelago/locationListener.gd")
+                ap_instance.SCRIPT_uuid = load("user://maps/Archipelago/vendor/uuid.gd")
+                ap_instance.SCRIPT_victoryListener = load("user://maps/Archipelago/victoryListener.gd")
+
+                global.add_child(ap_instance)
+
+                # Let's also inject any scripts we need to inject now.
+                installScriptExtension(ResourceLoader.load("user://maps/Archipelago/animationListener.gd"))
+                installScriptExtension(ResourceLoader.load("user://maps/Archipelago/collectable.gd"))
+                installScriptExtension(ResourceLoader.load("user://maps/Archipelago/door.gd"))
+                installScriptExtension(ResourceLoader.load("user://maps/Archipelago/keyHolder.gd"))
+                installScriptExtension(ResourceLoader.load("user://maps/Archipelago/keyHolderChecker.gd"))
+                installScriptExtension(
+                        ResourceLoader.load("user://maps/Archipelago/keyHolderResetterListener.gd")
+                )
+                installScriptExtension(ResourceLoader.load("user://maps/Archipelago/painting.gd"))
+                installScriptExtension(ResourceLoader.load("user://maps/Archipelago/panel.gd"))
+                installScriptExtension(ResourceLoader.load("user://maps/Archipelago/pauseMenu.gd"))
+                installScriptExtension(ResourceLoader.load("user://maps/Archipelago/player.gd"))
+                installScriptExtension(ResourceLoader.load("user://maps/Archipelago/saver.gd"))
+                installScriptExtension(ResourceLoader.load("user://maps/Archipelago/teleport.gd"))
+                installScriptExtension(ResourceLoader.load("user://maps/Archipelago/teleportListener.gd"))
+                installScriptExtension(ResourceLoader.load("user://maps/Archipelago/visibilityListener.gd"))
+                installScriptExtension(ResourceLoader.load("user://maps/Archipelago/worldport.gd"))
+                installScriptExtension(ResourceLoader.load("user://maps/Archipelago/worldportListener.gd"))
+
+                var proto_script = load("user://maps/Archipelago/generated/proto.gd")
+                var gamedata_script = load("user://maps/Archipelago/gamedata.gd")
+                var gamedata_instance = gamedata_script.new(proto_script)
+                gamedata_instance.load(
+                        FileAccess.get_file_as_bytes("user://maps/Archipelago/generated/data.binpb")
+                )
+                gamedata_instance.name = "Gamedata"
+                global.add_child(gamedata_instance)
+
+                var messages_script = load("user://maps/Archipelago/messages.gd")
+                var messages_instance = messages_script.new()
+                messages_instance.name = "Messages"
+                global.add_child(messages_instance)
+
+                var textclient_script = load("user://maps/Archipelago/textclient.gd")
+                var textclient_instance = textclient_script.new()
+                textclient_instance.name = "Textclient"
+                global.add_child(textclient_instance)
+
+                var compass_overlay_script = load("user://maps/Archipelago/compass_overlay.gd")
+                var compass_overlay_instance = compass_overlay_script.new()
+                compass_overlay_instance.name = "Compass"
+                compass_overlay_instance.SCRIPT_compass = load("user://maps/Archipelago/compass.gd")
+                global.add_child(compass_overlay_instance)
+
+        var ap = global.get_node("Archipelago")
+        var gamedata = global.get_node("Gamedata")
+        ap.connect("ap_connected", connectionSuccessful)
+        ap.connect("could_not_connect", connectionUnsuccessful)
+        ap.connect("connect_status", connectionStatus)
+
+        # Populate textboxes with AP settings.
+        $Panel/server_box.text = ap.ap_server
+        $Panel/player_box.text = ap.ap_user
+        $Panel/password_box.text = ap.ap_pass
+
+        var history_box = $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().connect("id_pressed", historySelected)
+
+        # Show client version.
+        $Panel/title.text = "ARCHIPELAGO (%d.%d)" % [gamedata.objects.get_version(), ap.MOD_VERSION]
+
+        # Increase font size in text boxes.
+        $Panel/server_box.add_theme_font_size_override("font_size", 36)
+        $Panel/player_box.add_theme_font_size_override("font_size", 36)
+        $Panel/password_box.add_theme_font_size_override("font_size", 36)
+
+        # Set up version mismatch dialog.
+        $Panel/VersionMismatch.connect("confirmed", startGame)
+        $Panel/VersionMismatch.get_cancel_button().pressed.connect(versionMismatchDeclined)
+
+
+# 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 = self.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():
+                $Panel/AcceptDialog.exclusive = false
+
+                var popup = self.get_node("Panel/VersionMismatch")
+                popup.title = "Version Mismatch!"
+                popup.dialog_text = (
+                        "This slot was generated using v%d.%d of the Lingo 2 apworld,\nwhich has a different major version than this client (v%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],
+                                gamedata.objects.get_version(),
+                                ap.MOD_VERSION
+                        ]
+                )
+                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)
+
+        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):
+        $Panel/connect_button.disabled = false
+
+        var popup = $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()
+
+        $Panel/connect_button.disabled = false
+
+
+func versionMismatchDeclined():
+        $Panel/AcceptDialog.hide()
+        $Panel/connect_button.disabled = false
+
+
+func historySelected(index):
+        var ap = global.get_node("Archipelago")
+        var details = ap.connection_history[index]
+
+        $Panel/server_box.text = details[0]
+        $Panel/player_box.text = details[1]
+        $Panel/password_box.text = details[2]
+
+
+func clearResourceCache(path):
+        ResourceLoader.load(path, "", ResourceLoader.CACHE_MODE_REPLACE)
@@ -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,86 @@
+extends CanvasLayer
+
+var panel
+var label
+var entry
+var is_open = false
+
+
+func _ready():
+        process_mode = ProcessMode.PROCESS_MODE_ALWAYS
+
+        panel = Panel.new()
+        panel.set_name("Panel")
+        panel.offset_left = 100
+        panel.offset_right = 1820
+        panel.offset_top = 100
+        panel.offset_bottom = 980
+        panel.visible = false
+        add_child(panel)
+
+        label = RichTextLabel.new()
+        label.set_name("Label")
+        label.offset_left = 80
+        label.offset_right = 1640
+        label.offset_top = 80
+        label.offset_bottom = 720
+        label.scroll_following = true
+        label.selection_enabled = true
+        panel.add_child(label)
+
+        label.push_font(load("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.offset_left = 80
+        entry.offset_right = 1640
+        entry.offset_top = 760
+        entry.offset_bottom = 840
+        entry.add_theme_font_override("font", load("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)
+        panel.add_child(entry)
+        entry.connect("text_submitted", text_entered)
+
+
+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)
+                                panel.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)
+                panel.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")
+        ap.client.say(cmd)
+        entry.text = ""
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Xavier Sellier
+
+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.
\ No newline at end of file
@@ -0,0 +1,195 @@
+# Note: The code might not be as pretty it could be, since it's written
+# in a way that maximizes performance. Methods are inlined and loops are avoided.
+extends Node
+
+const BYTE_MASK: int = 0b11111111
+
+
+static func uuidbin():
+        randomize()
+        # 16 random bytes with the bytes on index 6 and 8 modified
+        return [
+                randi() & BYTE_MASK,
+                randi() & BYTE_MASK,
+                randi() & BYTE_MASK,
+                randi() & BYTE_MASK,
+                randi() & BYTE_MASK,
+                randi() & BYTE_MASK,
+                ((randi() & BYTE_MASK) & 0x0f) | 0x40,
+                randi() & BYTE_MASK,
+                ((randi() & BYTE_MASK) & 0x3f) | 0x80,
+                randi() & BYTE_MASK,
+                randi() & BYTE_MASK,
+                randi() & BYTE_MASK,
+                randi() & BYTE_MASK,
+                randi() & BYTE_MASK,
+                randi() & BYTE_MASK,
+                randi() & BYTE_MASK,
+        ]
+
+
+static func uuidbinrng(rng: RandomNumberGenerator):
+        rng.randomize()
+        return [
+                rng.randi() & BYTE_MASK,
+                rng.randi() & BYTE_MASK,
+                rng.randi() & BYTE_MASK,
+                rng.randi() & BYTE_MASK,
+                rng.randi() & BYTE_MASK,
+                rng.randi() & BYTE_MASK,
+                ((rng.randi() & BYTE_MASK) & 0x0f) | 0x40,
+                rng.randi() & BYTE_MASK,
+                ((rng.randi() & BYTE_MASK) & 0x3f) | 0x80,
+                rng.randi() & BYTE_MASK,
+                rng.randi() & BYTE_MASK,
+                rng.randi() & BYTE_MASK,
+                rng.randi() & BYTE_MASK,
+                rng.randi() & BYTE_MASK,
+                rng.randi() & BYTE_MASK,
+                rng.randi() & BYTE_MASK,
+        ]
+
+
+static func v4():
+        # 16 random bytes with the bytes on index 6 and 8 modified
+        var b = uuidbin()
+
+        return (
+                "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x"
+                % [
+                        # low
+                        b[0],
+                        b[1],
+                        b[2],
+                        b[3],
+                        # mid
+                        b[4],
+                        b[5],
+                        # hi
+                        b[6],
+                        b[7],
+                        # clock
+                        b[8],
+                        b[9],
+                        # clock
+                        b[10],
+                        b[11],
+                        b[12],
+                        b[13],
+                        b[14],
+                        b[15]
+                ]
+        )
+
+
+static func v4_rng(rng: RandomNumberGenerator):
+        # 16 random bytes with the bytes on index 6 and 8 modified
+        var b = uuidbinrng(rng)
+
+        return (
+                "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x"
+                % [
+                        # low
+                        b[0],
+                        b[1],
+                        b[2],
+                        b[3],
+                        # mid
+                        b[4],
+                        b[5],
+                        # hi
+                        b[6],
+                        b[7],
+                        # clock
+                        b[8],
+                        b[9],
+                        # clock
+                        b[10],
+                        b[11],
+                        b[12],
+                        b[13],
+                        b[14],
+                        b[15]
+                ]
+        )
+
+
+var _uuid: Array
+
+
+func _init(rng := RandomNumberGenerator.new()) -> void:
+        _uuid = uuidbinrng(rng)
+
+
+func as_array() -> Array:
+        return _uuid.duplicate()
+
+
+func as_dict(big_endian := true) -> Dictionary:
+        if big_endian:
+                return {
+                        "low": (_uuid[0] << 24) + (_uuid[1] << 16) + (_uuid[2] << 8) + _uuid[3],
+                        "mid": (_uuid[4] << 8) + _uuid[5],
+                        "hi": (_uuid[6] << 8) + _uuid[7],
+                        "clock": (_uuid[8] << 8) + _uuid[9],
+                        "node":
+                        (
+                                (_uuid[10] << 40)
+                                + (_uuid[11] << 32)
+                                + (_uuid[12] << 24)
+                                + (_uuid[13] << 16)
+                                + (_uuid[14] << 8)
+                                + _uuid[15]
+                        )
+                }
+        else:
+                return {
+                        "low": _uuid[0] + (_uuid[1] << 8) + (_uuid[2] << 16) + (_uuid[3] << 24),
+                        "mid": _uuid[4] + (_uuid[5] << 8),
+                        "hi": _uuid[6] + (_uuid[7] << 8),
+                        "clock": _uuid[8] + (_uuid[9] << 8),
+                        "node":
+                        (
+                                _uuid[10]
+                                + (_uuid[11] << 8)
+                                + (_uuid[12] << 16)
+                                + (_uuid[13] << 24)
+                                + (_uuid[14] << 32)
+                                + (_uuid[15] << 40)
+                        )
+                }
+
+
+func as_string() -> String:
+        return (
+                "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x"
+                % [
+                        # low
+                        _uuid[0],
+                        _uuid[1],
+                        _uuid[2],
+                        _uuid[3],
+                        # mid
+                        _uuid[4],
+                        _uuid[5],
+                        # hi
+                        _uuid[6],
+                        _uuid[7],
+                        # clock
+                        _uuid[8],
+                        _uuid[9],
+                        # node
+                        _uuid[10],
+                        _uuid[11],
+                        _uuid[12],
+                        _uuid[13],
+                        _uuid[14],
+                        _uuid[15]
+                ]
+        )
+
+
+func is_equal(other) -> bool:
+        # Godot Engine compares Array recursively
+        # There's no need for custom comparison here.
+        return _uuid == other._uuid
@@ -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,10 @@
+extends "res://scripts/nodes/worldport.gd"
+
+
+func _ready():
+        if global.map == "icarus" and exit == "daedalus":
+                var ap = global.get_node("Archipelago")
+                if not ap.daedalus_roof_access:
+                        entry_point = Vector3(58, 10, 0)
+
+        super._ready()
@@ -0,0 +1,8 @@
+extends "res://scripts/nodes/listeners/worldportListener.gd"
+
+
+func handleTriggered():
+        if exit == "menus/credits":
+                return
+
+        super.handleTriggered()
@@ -0,0 +1,59 @@
+# lingo2-archipelago Client Releases
+
+## 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)
+
+## 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)
+
+## 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)
+
+## 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)
+
+## 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)
@@ -0,0 +1,90 @@
+# Lingo 2 Archipelago Client
+
+The Lingo 2 Archipelago Client is a mod for Lingo 2 that allows you to connect
+to an Archipelago Multiworld and randomize your game.
+
+## Installation
+
+1. Download the Lingo 2 Archipelago Randomizer from
+   [the releases page](https://code.fourisland.com/lingo2-archipelago/about/client/CHANGELOG.md).
+2. Open up Lingo 2, go to settings, and click View Game Data. This should open
+   up a folder in Windows Explorer.
+3. Unzip the randomizer into the "maps" folder. Ensure that archipelago.tscn and
+   the Archipelago folder are both within the maps folder.
+
+**NOTE**: It is important that the major version number of your client matches
+the major version number of the apworld you generated with.
+
+## Joining a Multiworld game
+
+1. Launch Lingo 2.
+2. Click on Level Selection, and choose Archipelago from the list.
+3. The selected player is generally ignored by the mod, and you don't even need
+   to ensure you use the same player between connections. However, if your
+   player name has a gift map associated with it, Lingo 2 will prioritize the
+   gift map over loading the mod, so in that case you should choose another
+   player.
+4. Press Play.
+5. Enter the Archipelago address, slot name, and password into the fields.
+6. Press Connect.
+7. Enjoy!
+
+To continue an earlier game, you can perform the exact same steps as above. You
+will probably have to re-select Archipelago from the Level Selection screen, as
+the game does not remember which level you were playing.
+
+**Note**: Running the randomizer modifies the game's memory. If you want to play
+the base game after playing the randomizer, you need to restart Lingo 2 first.
+
+## Running from source
+
+The mod is mostly written in GDScript, which is parsed and executed by Lingo 2
+itself, and thus does not need to be compiled. However, there are two files that
+need to be generated before the client can be run.
+
+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 `client` called `generated`.
+
+The second generated file is `proto.gd`. This file allows Lingo 2 to read the
+datafile. 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=..\..\client\Archipelago\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 two files, the contents of the `client` folder (minus
+this README) can be pasted into the Lingo 2 maps directory as described above.
+
+## Frequently Asked Questions
+
+### 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 file from the level1 save file directory.
+
+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.
@@ -0,0 +1,167 @@
+[gd_scene load_steps=11 format=2]
+
+[ext_resource path="user://maps/Archipelago/settings_buttons.gd" type="Script" id=4]
+[ext_resource path="user://maps/Archipelago/settings_screen.gd" type="Script" id=5]
+[ext_resource path="res://images/unchecked.png" type="Texture" id=7]
+[ext_resource path="res://images/checked.png" type="Texture" id=8]
+[ext_resource type="Theme" uid="uid://7w454egydi41" path="res://assets/themes/baseUI.tres" id="2_g4bvn"]
+
+[sub_resource type="StyleBoxFlat" id=1]
+bg_color = Color( 0, 0, 0, 0 )
+
+[sub_resource type="StyleBoxFlat" id=2]
+bg_color = Color( 1, 1, 1, 1 )
+border_width_left = 1
+border_width_top = 1
+border_width_right = 1
+border_width_bottom = 1
+border_color = Color( 1, 1, 0, 1 )
+border_blend = true
+corner_radius_top_left = 3
+corner_radius_top_right = 3
+corner_radius_bottom_right = 3
+corner_radius_bottom_left = 3
+expand_offset_left = 5.0
+expand_offset_right = 5.0
+expand_offset_top = 5.0
+expand_offset_bottom = 5.0
+
+[node name="settings_screen" type="Node2D"]
+script = ExtResource( 5 )
+
+[node name="Panel" type="Panel" parent="."]
+offset_right = 1920.0
+offset_bottom = 1080.0
+
+[node name="title" parent="Panel" type="Label"]
+offset_left = 0.0
+offset_top = 75.0
+offset_right = 1920.0
+offset_bottom = 225.0
+text = "ARCHIPELAGO"
+valign = 1
+horizontal_alignment = 1
+theme = ExtResource("2_g4bvn")
+
+[node name="credit" parent="Panel" type="Label"]
+visible = false
+offset_left = 1278.0
+offset_top = 974.0
+offset_right = 1868.0
+offset_bottom = 1034.0
+text = "Brenton Wildes"
+theme = ExtResource("2_g4bvn")
+
+[node name="connect_button" parent="Panel" type="Button"]
+offset_left = 255.0
+offset_top = 875.0
+offset_right = 891.0
+offset_bottom = 1025.0
+custom_colors/font_color_hover = Color( 1, 0.501961, 0, 1 )
+text = "CONNECT"
+theme = ExtResource("2_g4bvn")
+script = ExtResource( 4 )
+
+[node name="quit_button" parent="Panel" type="Button"]
+offset_left = 1102.0
+offset_top = 875.0
+offset_right = 1738.0
+offset_bottom = 1025.0
+custom_colors/font_color_hover = Color( 1, 0, 0, 1 )
+text = "BACK"
+theme = ExtResource("2_g4bvn")
+script = ExtResource( 4 )
+
+[node name="credit2" parent="Panel" type="Label"]
+offset_left = -105.0
+offset_top = 346.0
+offset_right = 485.0
+offset_bottom = 410.0
+custom_styles/normal = SubResource( 1 )
+text = "SERVER"
+align = 2
+theme = ExtResource("2_g4bvn")
+
+[node name="credit5" parent="Panel" type="Label"]
+offset_left = 1239.0
+offset_top = 422.0
+offset_right = 1829.0
+offset_bottom = 486.0
+custom_styles/normal = SubResource( 1 )
+text = "OPTIONS"
+theme = ExtResource("2_g4bvn")
+
+[node name="credit3" parent="Panel" type="Label"]
+offset_left = -105.0
+offset_top = 519.0
+offset_right = 485.0
+offset_bottom = 583.0
+custom_styles/normal = SubResource( 1 )
+text = "PLAYER"
+align = 2
+theme = ExtResource("2_g4bvn")
+
+[node name="credit4" parent="Panel" type="Label"]
+offset_left = -105.0
+offset_top = 704.0
+offset_right = 485.0
+offset_bottom = 768.0
+custom_styles/normal = SubResource( 1 )
+text = "PASSWORD"
+align = 2
+theme = ExtResource("2_g4bvn")
+
+[node name="server_box" type="LineEdit" parent="Panel"]
+offset_left = 502.0
+offset_top = 295.0
+offset_right = 1144.0
+offset_bottom = 445.0
+custom_colors/selection_color = Color( 0.482353, 0, 0, 1 )
+custom_colors/cursor_color = Color( 0, 0, 0, 1 )
+custom_colors/font_color = Color( 0, 0, 0, 1 )
+custom_styles/focus = SubResource( 2 )
+align = 1
+caret_blink = true
+
+[node name="player_box" type="LineEdit" parent="Panel"]
+offset_left = 502.0
+offset_top = 477.0
+offset_right = 1144.0
+offset_bottom = 627.0
+custom_colors/selection_color = Color( 0.482353, 0, 0, 1 )
+custom_colors/cursor_color = Color( 0, 0, 0, 1 )
+custom_colors/font_color = Color( 0, 0, 0, 1 )
+custom_styles/focus = SubResource( 2 )
+align = 1
+caret_blink = true
+
+[node name="password_box" type="LineEdit" parent="Panel"]
+offset_left = 502.0
+offset_top = 659.0
+offset_right = 1144.0
+offset_bottom = 809.0
+custom_colors/selection_color = Color( 0.482353, 0, 0, 1 )
+custom_colors/cursor_color = Color( 0, 0, 0, 1 )
+custom_colors/font_color = Color( 0, 0, 0, 1 )
+custom_styles/focus = SubResource( 2 )
+align = 1
+caret_blink = true
+
+[node name="AcceptDialog" type="AcceptDialog" parent="Panel"]
+offset_right = 83.0
+offset_bottom = 58.0
+
+[node name="VersionMismatch" type="ConfirmationDialog" parent="Panel"]
+offset_right = 83.0
+offset_bottom = 58.0
+
+[node name="connection_history" type="MenuButton" parent="Panel"]
+offset_left = 1239.0
+offset_top = 276.0
+offset_right = 1829.0
+offset_bottom = 372.0
+text = "connection history"
+flat = false
+
+[connection signal="pressed" from="Panel/connect_button" to="Panel/connect_button" method="_connect_pressed"]
+[connection signal="pressed" from="Panel/quit_button" to="Panel/quit_button" method="_back_pressed"]
@@ -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,39 +1,5 @@
 # TODO
-# the_entry/Starting Room/HI/thewords
-# the_entry/Link Area/PYRAMID
-# control center -> the_ancient
-# the_bearer/Back Area/TREE
-# the_between/Control Center Side/CC
-# the_digital/Tree Area/TREE
-# the_gallery/Main Area/WISE
-# the_gallery/Main Area/TREE
-# the_gallery/Main Area/CC
-# the_gallery/Main Area/TOWER
-# the_gallery/Main Area/WORDS
-# the_gallery/Main Area/WONDROUS
-# the_great/West Side/CC
-# the_great/Back Area/UNKEMPT
-# the_great/Back Area/THREEDOORS
-# the_great/Back Area/TOWER (keep in mind the door only blocks one direction of this)
-# the_great/Back Area/TREE
-# 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/Wisdom Panel/INTELLIGENCE (panel)
-# daedalus/South Castle Area/TRIANGLE
 # daedalus/roof -> icarus
-# daedalus/Hedges Tower/TENACIOUS
-# daedalus/Tree Entrance/TREE
-# daedalus/Unkempt Entrance/UNKEMPT
-# daedalus/Wonderland/WONDROUS
 connections {
   from {
     port {
@@ -54,7 +20,7 @@ connections {
   from {
     port {
       map: "the_entry"
-      room: "Flipped Second Room"
+      room: "Four Rooms Entrance"
       name: "FOUR"
     }
   }
@@ -175,7 +141,7 @@ connections {
   to {
     port {
       map: "the_darkroom"
-      room: "First Room"
+      room: "Cyan Hallway"
       name: "COLORFUL"
     }
   }
@@ -191,7 +157,7 @@ connections {
   to {
     port {
       map: "the_darkroom"
-      room: "Second Room"
+      room: "Congruent Entrance"
       name: "CONGRUENT"
     }
   }
@@ -267,7 +233,7 @@ connections {
   from {
     port {
       map: "the_darkroom"
-      room: "First Room"
+      room: "Double Sided Entrance"
       name: "DOUBLESIDED"
     }
   }
@@ -342,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 {
@@ -652,7 +635,7 @@ connections {
   from {
     port {
       map: "the_entry"
-      room: "Link Area"
+      room: "Liberated Entrance"
       name: "BLUE"
     }
   }
@@ -700,7 +683,7 @@ connections {
   from {
     port {
       map: "the_entry"
-      room: "Link Area"
+      room: "Literate Entrance"
       name: "BROWN"
     }
   }
@@ -875,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 {
@@ -890,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 {
@@ -1227,6 +1231,7 @@ connections {
     }
   }
   oneway: true
+  roof_access: true
 }
 connections {
   from {
@@ -1432,7 +1437,7 @@ connections {
   to {
     room {
       map: "daedalus"
-      name: "Roof"
+      name: "Castle"
     }
   }
   oneway: true
@@ -1468,7 +1473,6 @@ connections {
       name: "GREAT"
     }
   }
-  door { map: "the_great" name: "Daedalus Entrance" }
   oneway: true
 }
 connections {
@@ -1487,6 +1491,7 @@ connections {
     }
   }
   oneway: true
+  bypass_target_door: true
 }
 connections {
   from {
@@ -1668,3 +1673,791 @@ connections {
     }
   }
 }
+connections {
+  from {
+    panel {
+      map: "daedalus"
+      room: "Wisdom Panel"
+      name: "INTELLIGENCE"
+    }
+  }
+  to {
+    room {
+      map: "the_tenacious"
+      name: "Wisdom Room"
+    }
+  }
+  oneway: true
+}
+connections {
+  from {
+    painting {
+      map: "daedalus"
+      room: "South Castle Area"
+      name: "TRIANGLE"
+    }
+  }
+  to {
+    room {
+      map: "the_tenacious"
+      name: "Color Room"
+    }
+  }
+  oneway: true
+}
+connections {
+  from {
+    port {
+      map: "daedalus"
+      room: "Hedges Tower"
+      name: "TENACIOUS"
+    }
+  }
+  to {
+    room {
+      map: "the_tenacious"
+      name: "Tower Room"
+    }
+  }
+  oneway: true
+}
+connections {
+  from {
+    port {
+      map: "the_great"
+      room: "Back Area"
+      name: "THREEDOORS"
+    }
+  }
+  to {
+    port {
+      map: "the_three_doors"
+      room: "First Second Room"
+      name: "GREAT"
+    }
+  }
+}
+connections {
+  from {
+    painting {
+      map: "the_gallery"
+      room: "Main Area"
+      name: "TOWER"
+    }
+  }
+  to {
+    room {
+      map: "the_tower"
+      name: "First Floor"
+    }
+  }
+  oneway: true
+}
+connections {
+  # Two one-way connections because the door only blocks one direction.
+  from {
+    port {
+      map: "the_great"
+      room: "Back Area"
+      name: "TOWER"
+    }
+  }
+  to {
+    port {
+      map: "the_tower"
+      room: "First Floor"
+      name: "GREAT"
+    }
+  }
+  oneway: true
+}
+connections {
+  from {
+    port {
+      map: "the_tower"
+      room: "First Floor"
+      name: "GREAT"
+    }
+  }
+  to {
+    port {
+      map: "the_great"
+      room: "Back Area"
+      name: "TOWER"
+    }
+  }
+  oneway: true
+  bypass_target_door: true
+}
+connections {
+  from {
+    port {
+      map: "the_bearer"
+      room: "Tree Entrance"
+      name: "TREE"
+    }
+  }
+  to {
+    port {
+      map: "the_tree"
+      room: "Bearer Entrance"
+      name: "BEARER"
+    }
+  }
+}
+connections {
+  from {
+    port {
+      map: "the_digital"
+      room: "Tree Area"
+      name: "TREE"
+    }
+  }
+  to {
+    port {
+      map: "the_tree"
+      room: "Main Area"
+      name: "DIGITAL"
+    }
+  }
+}
+connections {
+  from {
+    painting {
+      map: "the_gallery"
+      room: "Main Area"
+      name: "TREE"
+    }
+  }
+  to {
+    room {
+      map: "the_tree"
+      name: "Main Area"
+    }
+  }
+  oneway: true
+}
+connections {
+  from {
+    port {
+      map: "the_great"
+      room: "Back Area"
+      name: "TREE"
+    }
+  }
+  to {
+    port {
+      map: "the_tree"
+      room: "Main Area"
+      name: "GREAT"
+    }
+  }
+}
+connections {
+  from {
+    port {
+      map: "daedalus"
+      room: "Tree Entrance"
+      name: "TREE"
+    }
+  }
+  to {
+    port {
+      map: "the_tree"
+      room: "Main Area"
+      name: "DAEDALUS"
+    }
+  }
+}
+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,160 @@
+door_groups {
+  name: "The Entry - Repetitive Entrance"
+  type: CONNECTOR
+  doors {
+    map: "the_entry"
+    name: "Starting Room West Wall North Door"
+  }
+  doors {
+    map: "the_repetitive"
+    name: "Entry Entrance"
+  }
+}
+door_groups {
+  name: "The Repetitive - Plaza Entrance"
+  type: CONNECTOR
+  doors {
+    map: "the_repetitive"
+    name: "Black Hallway"
+  }
+  doors {
+    map: "the_plaza"
+    name: "Repetitive Entrance"
+  }
+}
+door_groups {
+  name: "Control Center White Doors"
+  type: COLOR_CONNECTOR
+  doors {
+    map: "daedalus"
+    name: "White Hallway From Entry"
+  }
+  doors {
+    map: "the_entry"
+    name: "Control Center White Door"
+  }
+}
+door_groups {
+  name: "Control Center Purple Doors"
+  type: COLOR_CONNECTOR
+  doors {
+    map: "daedalus"
+    name: "Purple Hallway From Great"
+  }
+  doors {
+    map: "the_great"
+    name: "Control Center Purple Door"
+  }
+}
+door_groups {
+  name: "Control Center Orange Doors"
+  type: COLOR_CONNECTOR
+  doors {
+    map: "daedalus"
+    name: "Control Center Orange Door"
+  }
+  doors {
+    map: "the_unkempt"
+    name: "Control Center Orange Door"
+  }
+}
+door_groups {
+  name: "Control Center Brown Doors"
+  type: COLOR_CONNECTOR
+  doors {
+    map: "the_bearer"
+    name: "Control Center Brown Door"
+  }
+  doors {
+    map: "the_tree"
+    name: "Control Center Brown Door"
+  }
+}
+door_groups {
+  name: "Control Center Blue Doors"
+  type: COLOR_CONNECTOR
+  doors {
+    map: "the_digital"
+    name: "Control Center Blue Door"
+  }
+  doors {
+    map: "the_unyielding"
+    name: "Digital Entrance"
+  }
+}
+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,10 +3173,290 @@ maps:
           SWINE (Brown): 2446
           WIFE (Black): 2440
           WIFE (Brown): 2447
+        keyholders:
+          Y: 2764
     doors:
       Black Side Panels: 2427
       Brown Side Panels: 2428
       Main Room Door: 2429
+  the_tenacious:
+    rooms:
+      Color Room:
+        panels:
+          COLOR: 2454
+      Control Center Entrance:
+        panels:
+          ZERO: 2455
+      Main Area:
+        keyholders:
+          K: 2768
+      Mastery:
+        masteries:
+          MASTERY: 2456
+      Paintings Room:
+        panels:
+          PAINTINGS: 2457
+      Tower Room:
+        panels:
+          TOWER: 2458
+      Wisdom Room:
+        panels:
+          WISDOM: 2459
+    doors:
+      Paintings Door: 2453
+  the_three_doors:
+    rooms:
+      Dead End Room:
+        panels:
+          DEAD: 2463
+          DOOR: 2461
+          END: 2464
+          WAYS: 2462
+      First Second Room:
+        panels:
+          FIRS: 2465
+          INITIAL: 2466
+          MINUTE (1): 2467
+          MINUTE (2): 2468
+      Loose Strings Room:
+        panels:
+          LOOSE: 2469
+          STRINGS: 2470
+      One Luck Room:
+        panels:
+          CHANCE: 2472
+          LONE: 2471
+      Silver Portal Room:
+        panels:
+          GOLD: 2473
+          Left: 2475
+          PORT: 2474
+          Right: 2476
+    doors:
+      The Three Doors Gravestone: 2460
+  the_tower:
+    rooms:
+      First Floor:
+        panels:
+          ADULT: 2493
+          BUTTER: 2495
+          CALF: 2494
+          COLLEGE: 2487
+          CRAM: 2489
+          CUP: 2490
+          HER: 2488
+          IRE: 2492
+          IRONY: 2491
+          PROD: 2485
+          RIDE: 2484
+          WARM: 2486
+      Tower:
+        panels:
+          ANNOY (1): 2508
+          ANNOY (2): 2509
+          BARE: 2526
+          BETTER: 2545
+          CANON: 2527
+          CONTINENT: 2516
+          COPYRIGHT: 2515
+          COY: 2529
+          CRUST: 2543
+          Colors: 2546
+          Context: 2547
+          DOUGH: 2503
+          DUCTS: 2528
+          ENVELOPE: 2537
+          ENVELOPES: 2539
+          ERECTS: 2540
+          EYE: 2518
+          FISH: 2497
+          FLEECE: 2506
+          FLY: 2524
+          FOOT: 2517
+          FUEL: 2502
+          FUND: 2536
+          GIGGLING: 2510
+          GRUMPY: 2499
+          HEAL: 2522
+          HIDE (1): 2541
+          HIDE (2): 2544
+          HUE: 2542
+          ICE: 2505
+          LINEAGE: 2498
+          LIQUID: 2504
+          LYNX: 2530
+          MINUSCULE: 2511
+          MIX (1): 2521
+          MIX (2): 2525
+          NEED: 2507
+          NUCLEUS: 2520
+          READJUST: 2513
+          REINDICT: 2514
+          RHINO: 2496
+          RIVER: 2519
+          ROTE: 2538
+          SCENTS (1): 2531
+          SCENTS (2): 2532
+          SCREW: 2523
+          SEIZE (1): 2533
+          SEIZE (2): 2534
+          SLID: 2501
+          THROWN: 2535
+          TYPEWRITER: 2512
+          ZEBRA: 2500
+    doors:
+      Fifth Floor Puzzles: 2482
+      First Floor Door: 2478
+      First Floor Puzzles: 2477
+      Fourth Floor Puzzles: 2481
+      Second Floor Puzzles: 2479
+      Third Floor Puzzles: 2480
+  the_tree:
+    rooms:
+      Main Area:
+        panels:
+          COLOR: 2550
+          DAMAGE (1): 2551
+          DAMAGE (2): 2552
+          DRIZZLE: 2561
+          GOOD (1): 2566
+          GOOD (2): 2567
+          GOOD (3): 2568
+          GROW (1): 2563
+          GROW (2): 2564
+          GROW (3): 2565
+          HAPPY (1): 2570
+          HAPPY (2): 2571
+          HAPPY (3): 2572
+          HOVER: 2569
+          JUMP (1): 2559
+          JUMP (2): 2560
+          LIGHT (1): 2573
+          LIGHT (2): 2574
+          LIGHT (3): 2575
+          MEAL (1): 2553
+          MEAL (2): 2554
+          REST: 2557
+          SLEEP: 2558
+          SMALL (1): 2576
+          SMALL (2): 2577
+          SMALL (3): 2578
+          SPRINKLE: 2579
+          WADE: 2562
+          WALK (1): 2555
+          WALK (2): 2556
+    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:
@@ -3314,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
@@ -3327,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
@@ -3370,8 +3814,10 @@ letters:
   t2: 2452
   u1: 263
   u2: 2140
+  v1: 2664
   v2: 2246
   w1: 681
+  w2: 2665
   x1: 394
   x2: 1192
   y1: 621
@@ -3380,13 +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,5 @@
+name: "Ancient Entrance"
+ports {
+  name: "ANCIENT"
+  path: "Components/Warps/worldport8"
+}
@@ -0,0 +1,12 @@
+name: "Between Entrance"
+panels {
+  name: "RIGHT"
+  path: "Panels/Hallway Right/entry_4"
+  clue: "right"
+  answer: "left"
+  symbols: SUN
+}
+ports {
+  name: "BETWEEN"
+  path: "Components/Warps/worldport5"
+}
@@ -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,12 @@
+name: "Entry Entrance"
+panels {
+  name: "ENTRY"
+  path: "Panels/Hallway Right/entry_3"
+  clue: "entry"
+  answer: "exit"
+  symbols: SUN
+}
+ports {
+  name: "ENTRY"
+  path: "Components/Warps/worldport2"
+}
@@ -0,0 +1,12 @@
+name: "Entry"
+panels {
+  name: "HELLO"
+  path: "Panels/Doors/entry_1"
+  clue: "hello"
+  answer: "hi"
+  symbols: SUN
+}
+ports {
+  name: "GREAT"
+  path: "Components/Warps/worldport"
+}
@@ -0,0 +1,8 @@
+name: "Hide Room"
+panels {
+  name: "HIDE"
+  path: "Panels/Doors/entry_4"
+  clue: "hide"
+  answer: "unmask"
+  symbols: SUN
+}
@@ -0,0 +1,70 @@
+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"
+  path: "Components/Warps/worldport6"
+}
+ports {
+  name: "LEFT"
+  path: "Components/Warps/worldport7"
+  # Check that this is correct.
+}
+ports {
+  name: "RELENTLESS_LEFT"
+  path: "Components/Warps/worldport9"
+}
+ports {
+  name: "RELENTLESS_SHOP"
+  path: "Components/Warps/worldport11"
+}
+ports {
+  name: "RELENTLESS_TURN"
+  path: "Components/Warps/worldport10"
+}
@@ -0,0 +1,5 @@
+name: "Mint Ending"
+endings {
+  name: "MINT"
+  path: "Components/Endings/mint_ending"
+}
@@ -0,0 +1,12 @@
+name: "Partial Entrance"
+panels {
+  name: "PARTIAL"
+  path: "Panels/Hallway Left/entry_5"
+  clue: "partial"
+  answer: "part"
+  symbols: SPARKLES
+}
+ports {
+  name: "PARTIAL"
+  path: "Components/Warps/worldport4"
+}
@@ -0,0 +1,20 @@
+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"
+  path: "Components/Warps/worldport12"
+}
@@ -0,0 +1,5 @@
+name: "Repetitive Entrance"
+ports {
+  name: "REPETITIVE"
+  path: "Components/Warps/worldport14"
+}
@@ -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,12 @@
+name: "Tenacious Entrance"
+panels {
+  name: "HERO"
+  path: "Panels/Hallway Left/entry_7"
+  clue: "hero"
+  answer: "zero"
+  symbols: ZERO
+}
+ports {
+  name: "TENACIOUS"
+  path: "Components/Warps/worldport13"
+}
@@ -0,0 +1,12 @@
+name: "Unkempt Entrance"
+panels {
+  name: "RETURN"
+  path: "Panels/Hallway Left/entry_4"
+  clue: "return"
+  answer: "turn"
+  symbols: SPARKLES
+}
+ports {
+  name: "UNKEMPT"
+  path: "Components/Warps/worldport3"
+}
@@ -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"
@@ -1600,6 +1614,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 +1646,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 +1655,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 +1663,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 +1688,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 +1727,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 +1751,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 +1790,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 +1804,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 +1817,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 +1854,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 +1890,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 +1910,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 +1923,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 +1963,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 +2065,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 +2078,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 +2150,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 +2158,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 +2178,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 +2264,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"
@@ -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,11 +1,12 @@
 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"
@@ -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,5 +1,5 @@
 name: "Hedges Tower"
-display_name: "Hedges"
+panel_display_name: "Hedges"
 ports {
   name: "TENACIOUS"
   path: "Components/Warps/Worldports/worldport13"
@@ -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,5 +1,5 @@
 name: "Moat"
-display_name: "East Area"
+panel_display_name: "East Area"
 paintings {
   name: "CASTLE"
   path: "Components/Paintings/Group1/castle"
@@ -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"
@@ -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,5 +1,5 @@
 name: "Purple Hallway From Great"
-display_name: "South Area"
+panel_display_name: "South Area"
 ports {
   name: "GREAT"
   path: "Components/Warps/Worldports/worldport17"
@@ -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"
@@ -1,11 +1,12 @@
 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"
@@ -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"
@@ -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"
@@ -1,5 +1,5 @@
 name: "Tree Entrance"
-display_name: "Outside Pumpkin"
+panel_display_name: "Outside Pumpkin"
 panels {
   name: "RAT"
   path: "Panels/Hexes/lime_1"
@@ -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,5 +1,5 @@
 name: "Unkempt Entrance"
-display_name: "O2 Room"
+panel_display_name: "O2 Room"
 ports {
   name: "UNKEMPT"
   path: "Components/Warps/Worldports/worldport6"
@@ -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,5 +1,5 @@
 name: "White Hallway From Entry"
-display_name: "Southwest Area"
+panel_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
@@ -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"
@@ -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,7 +26,7 @@ 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"
@@ -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"
@@ -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"
@@ -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"
@@ -1,5 +1,4 @@
 name: "Time Room"
-display_name: "Time Room"
 panels {
   name: "BROODING"
   path: "Panels/Room 4 Time/entry_1"
@@ -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,12 +7,6 @@ panels {
   symbols: EXAMPLE
 }
 ports {
-  name: "TREE"
-  path: "Components/Warps/worldport3"
-  orientation: "north"
-  required_door { name: "Control Center Brown Door" }
-}
-ports {
   name: "DAEDALUS"
   path: "Components/Warps/worldport2"
   orientation: "north"
@@ -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"
@@ -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,6 @@
+name: "Tree Entrance"
+ports {
+  name: "TREE"
+  path: "Components/Warps/worldport3"
+  orientation: "north"
+}
@@ -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"
@@ -1,5 +1,4 @@
 name: "Main Area"
-display_name: "Main Area"
 panels {
   name: "NEW"
   path: "Panels/Room 1/panel_1"
@@ -1,5 +1,4 @@
 name: "Plaza Entrance"
-display_name: "Main Area"
 ports {
   name: "PLAZA"
   path: "Components/Warps/worldport4"
@@ -1,5 +1,4 @@
 name: "Main Area"
-display_name: "Main Area"
 panels {
   name: "SPECIES"
   path: "Panels/Room_1/panel_1"
@@ -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"
@@ -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"
@@ -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"
@@ -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"
 }
@@ -33,3 +33,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,7 @@
+name: "Congruent Entrance"
+panel_display_name: "Second Room"
+ports {
+  name: "CONGRUENT"
+  path: "Components/Warps/worldport7"
+  orientation: "east"
+}
@@ -0,0 +1,7 @@
+name: "Cyan Hallway"
+panel_display_name: "First Room"
+ports {
+  name: "COLORFUL"
+  path: "Components/Warps/worldport8"
+  orientation: "north"
+}
@@ -0,0 +1,7 @@
+name: "Double Sided Entrance"
+panel_display_name: "First Room"
+ports {
+  name: "DOUBLESIDED"
+  path: "Components/Warps/worldport6"
+  orientation: "east"
+}
@@ -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"
@@ -42,15 +42,3 @@ ports {
   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" }
-}
@@ -1,5 +1,4 @@
 name: "S Room"
-display_name: "Third Room"
 letters {
   key: "s"
   path: "Components/Collectables/collectable"
@@ -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"
@@ -47,9 +47,3 @@ ports {
   orientation: "north"
   required_door { name: "Third Room Entrance" }
 }
-ports {
-  name: "CONGRUENT"
-  path: "Components/Warps/worldport7"
-  orientation: "east"
-  required_door { name: "Congruent Entrance" }
-}
@@ -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"
@@ -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,5 +1,4 @@
 name: "Gallery Maze"
-display_name: "Main Area"
 ports {
   name: "GALLERY"
   path: "Components/Warps/worldport4"
@@ -1,5 +1,4 @@
 name: "Main Area"
-display_name: "Main Area"
 panels {
   name: "HIT"
   path: "Panels/open_c"
@@ -1,5 +1,4 @@
 name: "Tree Area"
-display_name: "Main Area"
 panels {
   name: "TREE"
   path: "Panels/open_tree"
@@ -1,5 +1,4 @@
 name: "U Room"
-display_name: "Chamber"
 letters {
   key: "u"
   path: "Components/Collectables/u"
@@ -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"
@@ -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"
@@ -182,10 +198,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,5 +1,5 @@
 name: "Composite Room Entrance"
-display_name: "Starting Room"
+panel_display_name: "Starting Room"
 ports {
   name: "COMPOSITE"
   path: "Components/Warps/worldport12"
@@ -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,5 +1,5 @@
 name: "Daedalus Entrance"
-display_name: "Starting Room"
+panel_display_name: "Starting Room"
 ports {
   name: "DAEDALUS"
   path: "Components/Warps/worldport6"
@@ -1,5 +1,5 @@
 name: "Digital Entrance"
-display_name: "Starting Room"
+panel_display_name: "Starting Room"
 ports {
   name: "DIGITAL"
   path: "Components/Warps/worldport"
@@ -1,5 +1,5 @@
 name: "Entry Exit"
-display_name: "Starting Room"
+panel_display_name: "Starting Room"
 ports {
   name: "GREAT"
   path: "Components/Warps/worldport2"
@@ -1,5 +1,5 @@
 name: "Eye Room"
-display_name: "Eye Room"
+panel_display_name: "Eye Room"
 panels {
   name: "I"
   path: "Panels/Entry/eyes_1"
@@ -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,7 @@
+name: "Four Rooms Entrance"
+ports {
+  name: "FOUR"
+  path: "Components/Warps/worldport9"
+  orientation: "south"
+  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"
@@ -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"
@@ -0,0 +1,6 @@
+name: "Liberated Entrance"
+ports {
+  name: "BLUE"
+  path: "worldport8"
+  orientation: "west"
+}
@@ -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"
@@ -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,6 @@
+name: "Literate Entrance"
+ports {
+  name: "BROWN"
+  path: "worldport9"
+  orientation: "east"
+}
@@ -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"
@@ -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"
@@ -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,5 +1,5 @@
 name: "Repetitive Entrance"
-display_name: "Starting Room"
+panel_display_name: "Starting Room"
 ports {
   name: "REPETITIVE"
   path: "Components/Warps/worldport7"
@@ -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"
@@ -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,5 +1,5 @@
 name: "White Hallway To Daedalus"
-display_name: "Colored Doors Area"
+panel_display_name: "Colored Doors Area"
 ports {
   name: "DAEDALUS"
   path: "Components/Warps/worldport11"
@@ -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,5 +1,5 @@
 name: "X Area"
-display_name: "Starting Room"
+panel_display_name: "Starting Room"
 letters {
   key: "x"
   path: "Components/Collectables/x"
@@ -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"
@@ -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,86 +70,161 @@ 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" }
-  # TODO: any panel in The 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)" }
+  panels { map: "the_tree" room: "Main Area" name: "MEAL (1)" }
+  panels { map: "the_tree" room: "Main Area" name: "MEAL (2)" }
+  panels { map: "the_tree" room: "Main Area" name: "WALK (1)" }
+  panels { map: "the_tree" room: "Main Area" name: "WALK (2)" }
+  panels { map: "the_tree" room: "Main Area" name: "REST" }
+  panels { map: "the_tree" room: "Main Area" name: "SLEEP" }
+  panels { map: "the_tree" room: "Main Area" name: "JUMP (1)" }
+  panels { map: "the_tree" room: "Main Area" name: "JUMP (2)" }
+  panels { map: "the_tree" room: "Main Area" name: "DRIZZLE" }
+  panels { map: "the_tree" room: "Main Area" name: "WADE" }
+  panels { map: "the_tree" room: "Main Area" name: "GROW (1)" }
+  panels { map: "the_tree" room: "Main Area" name: "GROW (2)" }
+  panels { map: "the_tree" room: "Main Area" name: "GROW (3)" }
+  panels { map: "the_tree" room: "Main Area" name: "GOOD (1)" }
+  panels { map: "the_tree" room: "Main Area" name: "GOOD (2)" }
+  panels { map: "the_tree" room: "Main Area" name: "GOOD (3)" }
+  panels { map: "the_tree" room: "Main Area" name: "HOVER" }
+  panels { map: "the_tree" room: "Main Area" name: "HAPPY (1)" }
+  panels { map: "the_tree" room: "Main Area" name: "HAPPY (2)" }
+  panels { map: "the_tree" room: "Main Area" name: "HAPPY (3)" }
+  panels { map: "the_tree" room: "Main Area" name: "LIGHT (1)" }
+  panels { map: "the_tree" room: "Main Area" name: "LIGHT (2)" }
+  panels { map: "the_tree" room: "Main Area" name: "LIGHT (3)" }
+  panels { map: "the_tree" room: "Main Area" name: "SMALL (1)" }
+  panels { map: "the_tree" room: "Main Area" name: "SMALL (2)" }
+  panels { map: "the_tree" room: "Main Area" name: "SMALL (3)" }
+  panels { map: "the_tree" room: "Main Area" name: "SPRINKLE" }
+  complete_at: 1
 }
 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" }
-  # TODO: Enter The 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"
@@ -1,5 +1,4 @@
 name: "The Whole Thing"
-display_name: "The Whole Thing"
 panels {
   name: "PANEL"
   path: "Panels/Room_1/panel_1"
@@ -7,9 +7,8 @@ doors {
   doors { map: "the_great" name: "The Maze Gravestone" }
   doors { map: "the_great" name: "Building Building Gravestone" }
   doors { map: "the_linear" name: "Behind The Keen Gravestone" }
-  # TODO: gravestones
-  # The Tree (the_tree)
-  # The Three Doors (the_three_doors)
+  doors { map: "the_three_doors" name: "The Three Doors Gravestone" }
+  doors { map: "the_tree" name: "The Tree Gravestone" }
 }
 doors {
   name: "Mausoleum Door"
@@ -20,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"
@@ -65,7 +66,7 @@ doors {
 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"
@@ -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,5 +1,5 @@
 name: "Colorful Entrance"
-display_name: "Pillar Room"
+panel_display_name: "Pillar Room"
 ports {
   name: "COLORFUL"
   path: "Meshes/Blocks/Warps/worldport13"
@@ -1,5 +1,5 @@
 name: "Daedalus Entrance"
-display_name: "Main Area"
+panel_display_name: "Main Area"
 panels {
   name: "MISSING"
   path: "Panels/General/entry_2"
@@ -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"
@@ -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,5 +1,5 @@
 name: "Jubilant Entrance"
-display_name: "West Side"
+panel_display_name: "West Side"
 ports {
   name: "JUBILANT"
   path: "Meshes/Blocks/Warps/worldport12"
@@ -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"
@@ -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,6 +52,7 @@ panels {
 keyholders {
   name: "X"
   path: "Components/KeyHolders/keyHolderX"
+  key: "x"
 }
 ports {
   name: "INVISIBLE"
@@ -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,5 +1,5 @@
 name: "Purple Room"
-display_name: "Main Area"
+panel_display_name: "Main Area"
 ports {
   name: "DAEDALUS"
   path: "Meshes/Blocks/Warps/worldport18"
@@ -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,5 +1,5 @@
 name: "Salmon Room"
-display_name: "Main Area"
+panel_display_name: "Main Area"
 ports {
   name: "BETWEEN"
   path: "Meshes/Blocks/Warps/worldport11"
@@ -1,5 +1,5 @@
 name: "Talented Entrance"
-display_name: "Question Room"
+panel_display_name: "Question Room"
 ports {
   name: "TALENTED"
   path: "Meshes/Blocks/Warps/worldport14"
@@ -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"
@@ -76,4 +76,5 @@ ports {
   path: "Meshes/Blocks/Warps/worldport7"
   orientation: "east"
   # 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,5 +1,4 @@
 name: "Main Area"
-display_name: "Main Area"
 # I'm probably not going to include any of the panels in here.
 ports {
   name: "RIGHT"
@@ -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,6 +268,7 @@ panels {
 keyholders {
   name: "B"
   path: "Components/KeyHolders/keyHolderB"
+  key: "b"
 }
 ports {
   name: "DAED1"
@@ -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"
@@ -1,5 +1,5 @@
 name: "Lobby"
-display_name: "Impressive"
+panel_display_name: "Outside"
 panels {
   name: "RIGHT"
   path: "Panels/entry_1"
@@ -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"
@@ -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"
@@ -1,5 +1,4 @@
 name: "Maze"
-display_name: "Invisible"
 masteries {
   name: "MASTERY"
   path: "Components/Collectables/smiley"
@@ -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"
@@ -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"
@@ -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"
@@ -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"
@@ -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"
@@ -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"
@@ -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"
@@ -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"
@@ -113,4 +112,5 @@ ports {
 keyholders {
   name: "S"
   path: "Components/KeyHolders/keyHolderS"
+  key: "s"
 }
@@ -1,5 +1,4 @@
 name: "N2 Room"
-display_name: "Nuanced"
 letters {
   key: "n"
   level2: true
@@ -1,5 +1,4 @@
 name: "B Room"
-display_name: "Orb"
 letters {
   key: "b"
   path: "Components/Collectables/b"
@@ -1,5 +1,4 @@
 name: "Main Area"
-display_name: "Orb"
 panels {
   name: "STRIKE"
   path: "Panels/O/entry_1"
@@ -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"
@@ -1,5 +1,4 @@
 name: "Magenta Hallway"
-display_name: "Owl"
 ports {
   name: "STURDY"
   path: "Components/Warps/worldport3"
@@ -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"
@@ -11,5 +10,6 @@ ports {
   name: "GALLERY"
   path: "Components/Warps/worldport"
   orientation: "south"
-  # Note that this port is accessible from the other side in the Z1 room. Hmm.
+  # 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,7 +50,7 @@ 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 {
@@ -1,6 +1,6 @@
 name: "U Keyholder"
-display_name: "Parthenon"
 keyholders {
   name: "U"
   path: "Components/KeyHolders/keyHolderU"
+  key: "u"
 }
@@ -17,13 +17,11 @@ connections {
   from_room: "Obverse Side"
   to_room: "Control Center Entrance"
   door { name: "L Entered" }
-  oneway: true
 }
 connections {
   from_room: "Control Center Entrance"
   to_room: "Obverse Side"
   door { name: "Control Center Entrance" }
-  oneway: true
 }
 connections {
   from_room: "Reverse Side"
@@ -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"
@@ -49,8 +50,8 @@ doors {
 }
 doors {
   name: "Control Center Entrance"
-  type: STANDARD
-  receivers: "Components/Doors/controlDoor"
+  type: LOCATION_ONLY
+  #receivers: "Components/Doors/controlDoor"
   panels { room: "Control Center Entrance" name: "RETURN" }
   location_room: "Control Center Entrance"
 }
@@ -1,5 +1,4 @@
 name: "Control Center Entrance"
-display_name: "Partial"
 panels {
   name: "RETURN"
   path: "Panels/Control/panel_10"
@@ -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"
@@ -107,6 +106,7 @@ 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,5 +1,4 @@
 name: "Main Area"
-display_name: "Perceptive"
 ports {
   name: "CC"
   path: "Components/Warps/worldport"
@@ -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"
@@ -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"
@@ -1,5 +1,4 @@
 name: "Sirenic Entrance"
-display_name: "Plaza"
 panels {
   name: "SIREN"
   path: "Panels/Entrances/panel_8"
@@ -1,5 +1,4 @@
 name: "Symbolic Entrance"
-display_name: "Plaza"
 panels {
   name: "FIGURATIVE"
   path: "Panels/Entrances/panel_5"
@@ -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"
@@ -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,7 +6,7 @@ connections {
 connections {
   from_room: "Main Room"
   to_room: "Plaza Connector"
-  door { name: "Plaza Entrance" }
+  door { name: "Black Hallway" }
   oneway: true
 }
 connections {
@@ -6,7 +6,7 @@ doors {
   location_room: "Main Room"
 }
 doors {
-  name: "Plaza Entrance"
+  name: "Black Hallway"
   type: STANDARD
   receivers: "Components/Doors/Door12"
   panels { room: "Main Room" name: "I" }
@@ -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,5 +1,4 @@
 name: "Entry Connector"
-display_name: "Repetitive"
 ports {
   name: "ENTRY"
   path: "Components/Warps/worldport2"
@@ -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"
@@ -1,5 +1,4 @@
 name: "Mastery Room"
-display_name: "Repetitive"
 masteries {
   name: "MASTERY"
   path: "Components/Collectables/smiley"
@@ -1,5 +1,4 @@
 name: "Plaza Connector"
-display_name: "Repetitive"
 ports {
   name: "PLAZA"
   path: "Components/Warps/worldport"
@@ -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"
@@ -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"
@@ -161,4 +160,5 @@ ports {
 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"
@@ -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,6 +27,7 @@ panels {
   clue: "wind"
   answer: "tornado"
   symbols: CROSS
+  display_name: "WIND (1)"
 }
 ports {
   name: "ENTRY"
@@ -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,7 +101,7 @@ 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"
@@ -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,11 +1,10 @@
 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 {
@@ -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"
@@ -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" }
 }
@@ -107,6 +107,7 @@ panels {
 keyholders {
   name: "Y"
   path: "Components/KeyHolders/keyHolderY"
+  key: "y"
 }
 ports {
   name: "GREAT"
@@ -0,0 +1,35 @@
+connections {
+  from_room: "Control Center Entrance"
+  to_room: "Main Area"
+  door { name: "Control Center Entrance" }
+}
+connections {
+  from_room: "Main Area"
+  to_room: "Control Center Entrance"
+  door { name: "K Entered" }
+}
+connections {
+  from_room: "Paintings Room"
+  to_room: "Main Area"
+  door { name: "Paintings Door" }
+}
+connections {
+  from_room: "Wisdom Room"
+  to_room: "Main Area"
+  door { name: "Wisdom Door" }
+}
+connections {
+  from_room: "Tower Room"
+  to_room: "Main Area"
+  door { name: "Tower Door" }
+}
+connections {
+  from_room: "Color Room"
+  to_room: "Main Area"
+  door { name: "Color Door" }
+}
+connections {
+  from_room: "Main Area"
+  to_room: "Mastery"
+  door { name: "Mastery" }
+}
@@ -0,0 +1,39 @@
+doors {
+  name: "Control Center Entrance"
+  type: EVENT
+  panels { room: "Control Center Entrance" name: "ZERO" }
+}
+doors {
+  name: "K Entered"
+  type: EVENT
+  keyholders { room: "Main Area" name: "K" key: "k" }
+}
+doors {
+  name: "Paintings Door"
+  type: ITEM_ONLY
+  receivers: "Components/Doors/entry_3"
+  rooms { name: "Main Area" }
+}
+doors {
+  name: "Wisdom Door"
+  type: EVENT
+  panels { room: "Wisdom Room" name: "WISDOM" }
+}
+doors {
+  name: "Color Door"
+  type: EVENT
+  panels { room: "Color Room" name: "COLOR" }
+}
+doors {
+  name: "Tower Door"
+  type: EVENT
+  panels { room: "Tower Room" name: "TOWER" }
+}
+doors {
+  name: "Mastery"
+  type: EVENT
+  panels { room: "Paintings Room" name: "PAINTINGS" }
+  panels { room: "Wisdom Room" name: "WISDOM" }
+  panels { room: "Color Room" name: "COLOR" }
+  panels { room: "Tower Room" name: "TOWER" }
+}
@@ -0,0 +1 @@
+display_name: "The Tenacious"
@@ -0,0 +1,7 @@
+name: "Color Room"
+panels {
+  name: "COLOR"
+  path: "Panels/Room_1/panel_1"
+  clue: "color"
+  answer: "color"
+}
@@ -0,0 +1,12 @@
+name: "Control Center Entrance"
+panels {
+  name: "ZERO"
+  path: "Panels/Room_1/panel_5"
+  clue: "zero"
+  answer: "hero"
+  symbols: ZERO
+}
+ports {
+  name: "CC"
+  path: "Components/Warps/worldport"
+}
@@ -0,0 +1,6 @@
+name: "Main Area"
+keyholders {
+  name: "K"
+  path: "Components/KeyHolders/keyHolderK"
+  key: "k"
+}
@@ -0,0 +1,5 @@
+name: "Mastery"
+masteries {
+  name: "MASTERY"
+  path: "Components/Collectables/smiley"
+}
@@ -0,0 +1,10 @@
+name: "Paintings Room"
+# NOTE: It will be non-trivial to implement the painting pilgrimage in Daedalus,
+# so until then, the door to this room will be an item in door shuffle, and will
+# automatically be open without door shuffle.
+panels {
+  name: "PAINTINGS"
+  path: "Panels/Room_1/panel_3"
+  clue: "paintings"
+  answer: "paintings"
+}
@@ -0,0 +1,7 @@
+name: "Tower Room"
+panels {
+  name: "TOWER"
+  path: "Panels/Room_1/panel_2"
+  clue: "tower"
+  answer: "tower"
+}
@@ -0,0 +1,7 @@
+name: "Wisdom Room"
+panels {
+  name: "WISDOM"
+  path: "Panels/Room_1/panel_4"
+  clue: "wisdom"
+  answer: "wisdom"
+}
@@ -0,0 +1,150 @@
+connections {
+  from_room: "First Second Room"
+  to_room: "Loose Strings Room"
+  door { name: "Firs Door" }
+}
+connections {
+  from_room: "First Second Room"
+  to_room: "Silver Portal Room"
+  door { name: "Initial Door" }
+}
+connections {
+  from {
+    port {
+      room: "First Second Room"
+      name: "TTD"
+    }
+  }
+  to {
+    port {
+      room: "First Second Room"
+      name: "GREAT"
+    }
+  }
+  oneway: true
+}
+connections {
+  from_room: "First Second Room"
+  to_room: "Silver Portal Room"
+  door { name: "Second Left Door" }
+}
+connections {
+  from_room: "First Second Room"
+  to_room: "One Luck Room"
+  door { name: "Second Right Door" }
+}
+connections {
+  from_room: "Silver Portal Room"
+  to_room: "First Second Room"
+  oneway: true
+}
+connections {
+  from {
+    port {
+      room: "Silver Portal Room"
+      name: "BEGIN"
+    }
+  }
+  to {
+    port {
+      room: "First Second Room"
+      name: "GREAT"
+    }
+  }
+  oneway: true
+}
+connections {
+  from {
+    port {
+      room: "Silver Portal Room"
+      name: "NEXT"
+    }
+  }
+  to {
+    port {
+      room: "One Luck Room"
+      name: "BEGIN"
+    }
+  }
+  oneway: true
+}
+connections {
+  from {
+    port {
+      room: "One Luck Room"
+      name: "BEGIN"
+    }
+  }
+  to {
+    port {
+      room: "First Second Room"
+      name: "GREAT"
+    }
+  }
+  oneway: true
+}
+connections {
+  from_room: "One Luck Room"
+  to_room: "Dead End Room"
+  oneway: true
+}
+connections {
+  from_room: "One Luck Room"
+  to_room: "First Second Room"
+  oneway: true
+}
+connections {
+  from_room: "Dead End Room"
+  to_room: "Silver Portal Room"
+  oneway: true
+}
+connections {
+  from {
+    port {
+      room: "Dead End Room"
+      name: "BEGIN"
+    }
+  }
+  to {
+    port {
+      room: "First Second Room"
+      name: "GREAT"
+    }
+  }
+  oneway: true
+}
+connections {
+  from {
+    port {
+      room: "Dead End Room"
+      name: "BEGIN2"
+    }
+  }
+  to {
+    port {
+      room: "First Second Room"
+      name: "GREAT"
+    }
+  }
+  oneway: true
+}
+connections {
+  from_room: "Loose Strings Room"
+  to_room: "First Second Room"
+  oneway: true
+}
+connections {
+  from {
+    port {
+      room: "Loose Strings Room"
+      name: "BEGIN"
+    }
+  }
+  to {
+    port {
+      room: "First Second Room"
+      name: "GREAT"
+    }
+  }
+  oneway: true
+}
@@ -0,0 +1,54 @@
+doors {
+  name: "Firs Door"
+  type: EVENT
+  panels { room: "Silver Portal Room" name: "GOLD" }
+  panels { room: "Silver Portal Room" name: "PORT" }
+  panels { room: "Silver Portal Room" name: "Left" }
+  panels { room: "Silver Portal Room" name: "Right" }
+}
+doors {
+  name: "Initial Door"
+  type: EVENT
+  panels { room: "Silver Portal Room" name: "GOLD" }
+  panels { room: "Silver Portal Room" name: "PORT" }
+  panels { room: "Silver Portal Room" name: "Left" }
+  panels { room: "Silver Portal Room" name: "Right" }
+}
+doors {
+  name: "Second Left Door"
+  type: EVENT
+  panels { room: "First Second Room" name: "FIRS" }
+  panels { room: "First Second Room" name: "INITIAL" }
+  panels { room: "First Second Room" name: "MINUTE (1)" }
+  panels { room: "First Second Room" name: "MINUTE (2)" }
+}
+doors {
+  name: "Second Right Door"
+  type: EVENT
+  panels { room: "Loose Strings Room" name: "LOOSE" }
+  panels { room: "Loose Strings Room" name: "STRINGS" }
+  panels { room: "One Luck Room" name: "LONE" }
+  panels { room: "One Luck Room" name: "CHANCE" }
+}
+doors {
+  name: "The Three Doors Gravestone"
+  type: GRAVESTONE
+  panels { room: "First Second Room" name: "FIRS" }
+  panels { room: "First Second Room" name: "INITIAL" }
+  panels { room: "First Second Room" name: "MINUTE (1)" }
+  panels { room: "First Second Room" name: "MINUTE (2)" }
+  panels { room: "Silver Portal Room" name: "GOLD" }
+  panels { room: "Silver Portal Room" name: "PORT" }
+  panels { room: "Silver Portal Room" name: "Left" }
+  panels { room: "Silver Portal Room" name: "Right" }
+  panels { room: "Loose Strings Room" name: "LOOSE" }
+  panels { room: "Loose Strings Room" name: "STRINGS" }
+  panels { room: "One Luck Room" name: "LONE" }
+  panels { room: "One Luck Room" name: "CHANCE" }
+  panels { room: "Dead End Room" name: "DOOR" }
+  panels { room: "Dead End Room" name: "WAYS" }
+  panels { room: "Dead End Room" name: "DEAD" }
+  panels { room: "Dead End Room" name: "END" }
+  location_room: "Loose Strings Room"
+  location_name: "Gravestone"
+}
@@ -0,0 +1 @@
+display_name: "The Three Doors"
@@ -0,0 +1,37 @@
+name: "Dead End Room"
+panels {
+  name: "DOOR"
+  path: "Panels/Dead End/panel3"
+  clue: "door"
+  answer: "knob"
+  symbols: BOXES
+}
+panels {
+  name: "WAYS"
+  path: "Panels/Dead End/panel4"
+  clue: "ways"
+  answer: "sway"
+  symbols: SPARKLES
+}
+panels {
+  name: "DEAD"
+  path: "Panels/Dead End/panel"
+  clue: "dead"
+  answer: "alive"
+  symbols: SUN
+}
+panels {
+  name: "END"
+  path: "Panels/Dead End/panel2"
+  clue: "end"
+  answer: "begin"
+  symbols: SUN
+}
+ports {
+  name: "BEGIN"
+  path: "Components/Warps/worldport6"
+}
+ports {
+  name: "BEGIN2"
+  path: "Components/Warps/worldport5"
+}
@@ -0,0 +1,37 @@
+name: "First Second Room"
+panels {
+  name: "FIRS"
+  path: "Panels/First Second/panel"
+  clue: "firs"
+  answer: "first"
+  symbols: SPARKLES
+}
+panels {
+  name: "INITIAL"
+  path: "Panels/First Second/panel2"
+  clue: "initial"
+  answer: "first"
+  symbols: SUN
+}
+panels {
+  name: "MINUTE (1)"
+  path: "Panels/First Second/panel3"
+  clue: "minute"
+  answer: "second"
+  symbols: EXAMPLE
+}
+panels {
+  name: "MINUTE (2)"
+  path: "Panels/First Second/panel4"
+  clue: "minute"
+  answer: "second"
+  symbols: BOXES
+}
+ports {
+  name: "GREAT"
+  path: "Components/Warps/worldport"
+}
+ports {
+  name: "TTD"
+  path: "Components/Warps/worldport2"
+}
@@ -0,0 +1,19 @@
+name: "Loose Strings Room"
+panels {
+  name: "LOOSE"
+  path: "Panels/Something/panel3"
+  clue: "loose"
+  answer: "lose"
+  symbols: SPARKLES
+}
+panels {
+  name: "STRINGS"
+  path: "Panels/Something/panel4"
+  clue: "strings"
+  answer: "threads"
+  symbols: SUN
+}
+ports {
+  name: "BEGIN"
+  path: "Components/Warps/worldport7"
+}
@@ -0,0 +1,19 @@
+name: "One Luck Room"
+panels {
+  name: "LONE"
+  path: "Panels/Something/panel"
+  clue: "lone"
+  answer: "one"
+  symbols: SPARKLES
+}
+panels {
+  name: "CHANCE"
+  path: "Panels/Something/panel2"
+  clue: "chance"
+  answer: "luck"
+  symbols: SUN
+}
+ports {
+  name: "BEGIN"
+  path: "Components/Warps/worldport8"
+}
@@ -0,0 +1,35 @@
+name: "Silver Portal Room"
+panels {
+  name: "GOLD"
+  path: "Panels/Silver Portal/panel"
+  clue: "gold"
+  answer: "silver"
+  symbols: EXAMPLE
+}
+panels {
+  name: "PORT"
+  path: "Panels/Silver Portal/panel2"
+  clue: "port"
+  answer: "portal"
+  symbols: SPARKLES
+}
+panels {
+  name: "Left"
+  path: "Panels/Silver Portal/panel3"
+  clue: ""
+  answer: "third"
+}
+panels {
+  name: "Right"
+  path: "Panels/Silver Portal/panel4"
+  clue: ""
+  answer: "fourth"
+}
+ports {
+  name: "BEGIN"
+  path: "Components/Warps/worldport3"
+}
+ports {
+  name: "NEXT"
+  path: "Components/Warps/worldport4"
+}
@@ -0,0 +1,10 @@
+connections {
+  from_room: "First Floor"
+  to_room: "Tower"
+  door { name: "First Floor Door" }
+}
+connections {
+  from_room: "Tower"
+  to_room: "Ending"
+  door { name: "Ending" }
+}
@@ -0,0 +1,181 @@
+doors {
+  name: "First Floor Puzzles"
+  type: LOCATION_ONLY
+  panels { room: "First Floor" name: "RIDE" }
+  panels { room: "First Floor" name: "PROD" }
+  panels { room: "First Floor" name: "WARM" }
+  panels { room: "First Floor" name: "COLLEGE" }
+  panels { room: "First Floor" name: "HER" }
+  panels { room: "First Floor" name: "CRAM" }
+  panels { room: "First Floor" name: "CUP" }
+  panels { room: "First Floor" name: "IRONY" }
+  panels { room: "First Floor" name: "IRE" }
+  panels { room: "First Floor" name: "ADULT" }
+  panels { room: "First Floor" name: "CALF" }
+  panels { room: "First Floor" name: "BUTTER" }
+  location_room: "First Floor"
+}
+doors {
+  name: "First Floor Door"
+  type: ITEM_ONLY
+  receivers: "Components/Doors/entry_1"
+  panels { room: "First Floor" name: "RIDE" }
+  panels { room: "First Floor" name: "PROD" }
+  panels { room: "First Floor" name: "WARM" }
+  panels { room: "First Floor" name: "COLLEGE" }
+  panels { room: "First Floor" name: "HER" }
+  panels { room: "First Floor" name: "CRAM" }
+  panels { room: "First Floor" name: "CUP" }
+  panels { room: "First Floor" name: "IRONY" }
+  panels { room: "First Floor" name: "IRE" }
+  panels { room: "First Floor" name: "ADULT" }
+  panels { room: "First Floor" name: "CALF" }
+  panels { room: "First Floor" name: "BUTTER" }
+  complete_at: 1
+}
+doors {
+  name: "Second Floor Puzzles"
+  type: LOCATION_ONLY
+  panels { room: "Tower" name: "RHINO" }
+  panels { room: "Tower" name: "FISH" }
+  panels { room: "Tower" name: "LINEAGE" }
+  panels { room: "Tower" name: "GRUMPY" }
+  panels { room: "Tower" name: "ZEBRA" }
+  panels { room: "Tower" name: "SLID" }
+  panels { room: "Tower" name: "FUEL" }
+  panels { room: "Tower" name: "DOUGH" }
+  panels { room: "Tower" name: "LIQUID" }
+  panels { room: "Tower" name: "ICE" }
+  panels { room: "Tower" name: "FLEECE" }
+  panels { room: "Tower" name: "NEED" }
+  panels { room: "Tower" name: "ANNOY (1)" }
+  panels { room: "Tower" name: "ANNOY (2)" }
+  panels { room: "Tower" name: "GIGGLING" }
+  location_room: "Tower"
+}
+doors {
+  name: "Third Floor Puzzles"
+  type: LOCATION_ONLY
+  panels { room: "Tower" name: "MINUSCULE" }
+  panels { room: "Tower" name: "TYPEWRITER" }
+  panels { room: "Tower" name: "READJUST" }
+  panels { room: "Tower" name: "REINDICT" }
+  panels { room: "Tower" name: "COPYRIGHT" }
+  panels { room: "Tower" name: "CONTINENT" }
+  panels { room: "Tower" name: "FOOT" }
+  panels { room: "Tower" name: "EYE" }
+  panels { room: "Tower" name: "RIVER" }
+  panels { room: "Tower" name: "NUCLEUS" }
+  panels { room: "Tower" name: "MIX (1)" }
+  panels { room: "Tower" name: "HEAL" }
+  panels { room: "Tower" name: "SCREW" }
+  panels { room: "Tower" name: "FLY" }
+  panels { room: "Tower" name: "MIX (2)" }
+  location_room: "Tower"
+}
+doors {
+  name: "Fourth Floor Puzzles"
+  type: LOCATION_ONLY
+  panels { room: "Tower" name: "BARE" }
+  panels { room: "Tower" name: "CANON" }
+  panels { room: "Tower" name: "DUCTS" }
+  panels { room: "Tower" name: "COY" }
+  panels { room: "Tower" name: "LYNX" }
+  panels { room: "Tower" name: "SCENTS (1)" }
+  panels { room: "Tower" name: "SCENTS (2)" }
+  panels { room: "Tower" name: "SEIZE (1)" }
+  panels { room: "Tower" name: "SEIZE (2)" }
+  panels { room: "Tower" name: "THROWN" }
+  location_room: "Tower"
+}
+doors {
+  name: "Fifth Floor Puzzles"
+  type: LOCATION_ONLY
+  panels { room: "Tower" name: "FUND" }
+  panels { room: "Tower" name: "ENVELOPE" }
+  panels { room: "Tower" name: "ROTE" }
+  panels { room: "Tower" name: "ENVELOPES" }
+  panels { room: "Tower" name: "ERECTS" }
+  panels { room: "Tower" name: "HIDE (1)" }
+  panels { room: "Tower" name: "HUE" }
+  panels { room: "Tower" name: "CRUST" }
+  panels { room: "Tower" name: "HIDE (2)" }
+  panels { room: "Tower" name: "BETTER" }
+  location_room: "Tower"
+}
+doors {
+  name: "Colors Panel"
+  type: EVENT
+  panels { room: "First Floor" name: "RIDE" }
+  panels { room: "First Floor" name: "PROD" }
+  panels { room: "First Floor" name: "WARM" }
+  panels { room: "First Floor" name: "COLLEGE" }
+  panels { room: "First Floor" name: "HER" }
+  panels { room: "First Floor" name: "CRAM" }
+  panels { room: "First Floor" name: "CUP" }
+  panels { room: "First Floor" name: "IRONY" }
+  panels { room: "First Floor" name: "IRE" }
+  panels { room: "First Floor" name: "ADULT" }
+  panels { room: "First Floor" name: "CALF" }
+  panels { room: "First Floor" name: "BUTTER" }
+  panels { room: "Tower" name: "RHINO" }
+  panels { room: "Tower" name: "FISH" }
+  panels { room: "Tower" name: "LINEAGE" }
+  panels { room: "Tower" name: "GRUMPY" }
+  panels { room: "Tower" name: "ZEBRA" }
+  panels { room: "Tower" name: "SLID" }
+  panels { room: "Tower" name: "FUEL" }
+  panels { room: "Tower" name: "DOUGH" }
+  panels { room: "Tower" name: "LIQUID" }
+  panels { room: "Tower" name: "ICE" }
+  panels { room: "Tower" name: "FLEECE" }
+  panels { room: "Tower" name: "NEED" }
+  panels { room: "Tower" name: "ANNOY (1)" }
+  panels { room: "Tower" name: "ANNOY (2)" }
+  panels { room: "Tower" name: "GIGGLING" }
+  panels { room: "Tower" name: "MINUSCULE" }
+  panels { room: "Tower" name: "TYPEWRITER" }
+  panels { room: "Tower" name: "READJUST" }
+  panels { room: "Tower" name: "REINDICT" }
+  panels { room: "Tower" name: "COPYRIGHT" }
+  panels { room: "Tower" name: "CONTINENT" }
+  panels { room: "Tower" name: "FOOT" }
+  panels { room: "Tower" name: "EYE" }
+  panels { room: "Tower" name: "RIVER" }
+  panels { room: "Tower" name: "NUCLEUS" }
+  panels { room: "Tower" name: "MIX (1)" }
+  panels { room: "Tower" name: "HEAL" }
+  panels { room: "Tower" name: "SCREW" }
+  panels { room: "Tower" name: "FLY" }
+  panels { room: "Tower" name: "MIX (2)" }
+  panels { room: "Tower" name: "BARE" }
+  panels { room: "Tower" name: "CANON" }
+  panels { room: "Tower" name: "DUCTS" }
+  panels { room: "Tower" name: "COY" }
+  panels { room: "Tower" name: "LYNX" }
+  panels { room: "Tower" name: "SCENTS (1)" }
+  panels { room: "Tower" name: "SCENTS (2)" }
+  panels { room: "Tower" name: "SEIZE (1)" }
+  panels { room: "Tower" name: "SEIZE (2)" }
+  panels { room: "Tower" name: "THROWN" }
+  panels { room: "Tower" name: "FUND" }
+  panels { room: "Tower" name: "ENVELOPE" }
+  panels { room: "Tower" name: "ROTE" }
+  panels { room: "Tower" name: "ENVELOPES" }
+  panels { room: "Tower" name: "ERECTS" }
+  panels { room: "Tower" name: "HIDE (1)" }
+  panels { room: "Tower" name: "HUE" }
+  panels { room: "Tower" name: "CRUST" }
+  panels { room: "Tower" name: "HIDE (2)" }
+  panels { room: "Tower" name: "BETTER" }
+}
+doors {
+  name: "Context Panel"
+  type: EVENT
+  panels { room: "Tower" name: "Colors" }
+}
+doors {
+  name: "Ending"
+  type: EVENT
+  panels { room: "Tower" name: "Context" }
+}
@@ -0,0 +1 @@
+display_name: "The Tower"
@@ -0,0 +1,5 @@
+name: "Ending"
+endings {
+  name: "RED"
+  path: "Components/end"
+}
@@ -0,0 +1,101 @@
+name: "First Floor"
+panels {
+  name: "RIDE"
+  path: "Panels/Floor 1/panel_1"
+  clue: "ride"
+  answer: "lion"
+  symbols: SPARKLES
+  symbols: PLANET
+}
+panels {
+  name: "PROD"
+  path: "Panels/Floor 1/panel_2"
+  clue: "prod"
+  answer: "dolphin"
+  symbols: SPARKLES
+  symbols: PLANET
+}
+panels {
+  name: "WARM"
+  path: "Panels/Floor 1/panel_3"
+  clue: "warm"
+  answer: "bee"
+  symbols: SPARKLES
+  symbols: PLANET
+}
+panels {
+  name: "COLLEGE"
+  path: "Panels/Floor 1/panel_4"
+  clue: "college"
+  answer: "fish"
+  symbols: EXAMPLE
+  symbols: PLANET
+}
+panels {
+  name: "HER"
+  path: "Panels/Floor 1/panel_5"
+  clue: "her"
+  answer: "cow"
+  symbols: SPARKLES
+  symbols: PLANET
+}
+panels {
+  name: "CRAM"
+  path: "Panels/Floor 1/panel_6"
+  clue: "cram"
+  answer: "wolf"
+  symbols: SUN
+  symbols: PLANET
+}
+panels {
+  name: "CUP"
+  path: "Panels/Floor 1/panel_7"
+  clue: "cup"
+  answer: "lion"
+  symbols: SPARKLES
+  symbols: AGE
+}
+panels {
+  name: "IRONY"
+  path: "Panels/Floor 1/panel_8"
+  clue: "irony"
+  answer: "rust"
+  symbols: SPARKLES
+  symbols: AGE
+}
+panels {
+  name: "IRE"
+  path: "Panels/Floor 1/panel_9"
+  clue: "ire"
+  answer: "ash"
+  symbols: SPARKLES
+  symbols: AGE
+}
+panels {
+  name: "ADULT"
+  path: "Panels/Floor 1/panel_10"
+  clue: "adult"
+  answer: "children"
+  symbols: PLANET
+  symbols: AGE
+}
+panels {
+  name: "CALF"
+  path: "Panels/Floor 1/panel_11"
+  clue: "calf"
+  answer: "bull"
+  symbols: GENDER
+  symbols: AGE
+}
+panels {
+  name: "BUTTER"
+  path: "Panels/Floor 1/panel_12"
+  clue: "butter"
+  answer: "cram"
+  symbols: SPARKLES
+  symbols: EXAMPLE
+}
+ports {
+  name: "GREAT"
+  path: "Components/Warps/worldport"
+}
@@ -0,0 +1,409 @@
+name: "Tower"
+panels {
+  name: "RHINO"
+  path: "Panels/Floor 2/panel_1"
+  clue: "rhino"
+  answer: "hornet"
+  symbols: SPARKLES
+  symbols: BOXES
+}
+panels {
+  name: "FISH"
+  path: "Panels/Floor 2/panel_2"
+  clue: "fish"
+  answer: "fishes"
+  symbols: PLANET
+}
+panels {
+  name: "LINEAGE"
+  path: "Panels/Floor 2/panel_3"
+  clue: "lineage"
+  answer: "eaglet"
+  symbols: AGE
+  symbols: EVAL
+}
+panels {
+  name: "GRUMPY"
+  path: "Panels/Floor 2/panel_4"
+  clue: "grumpy"
+  answer: "crab"
+  symbols: SUN
+  symbols: SPARKLES
+}
+panels {
+  name: "ZEBRA"
+  path: "Panels/Floor 2/panel_5"
+  clue: "zebra"
+  answer: "tiger"
+  symbols: BOXES
+}
+panels {
+  name: "SLID"
+  path: "Panels/Floor 2/panel_6"
+  clue: "slid"
+  answer: "liquid"
+  symbols: SPARKLES
+  symbols: CROSS
+}
+panels {
+  name: "FUEL"
+  path: "Panels/Floor 2/panel_7"
+  clue: "fuel"
+  answer: "fir"
+  symbols: SPARKLES
+  symbols: CROSS
+}
+panels {
+  name: "DOUGH"
+  path: "Panels/Floor 2/panel_8"
+  clue: "dough"
+  answer: "sandwich"
+  symbols: BOXES
+  symbols: CROSS
+}
+panels {
+  name: "LIQUID"
+  path: "Panels/Floor 2/panel_9"
+  clue: "liquid"
+  answer: "plasma"
+  symbols: CROSS
+}
+panels {
+  name: "ICE"
+  path: "Panels/Floor 2/panel_10"
+  clue: "ice"
+  answer: "sea"
+  symbols: BOXES
+  symbols: CROSS
+}
+panels {
+  name: "FLEECE"
+  path: "Panels/Floor 2/panel_11"
+  clue: "fleece"
+  answer: "nephew"
+  symbols: ZERO
+  symbols: GENDER
+}
+panels {
+  name: "NEED"
+  path: "Panels/Floor 2/panel_12"
+  clue: "need"
+  answer: "aunt"
+  symbols: ZERO
+  symbols: PYRAMID
+}
+panels {
+  name: "ANNOY (1)"
+  path: "Panels/Floor 2/panel_13"
+  clue: "annoy"
+  answer: "brother"
+  symbols: SPARKLES
+  symbols: PYRAMID
+}
+panels {
+  name: "ANNOY (2)"
+  path: "Panels/Floor 2/panel_14"
+  clue: "annoy"
+  answer: "father"
+  symbols: ZERO
+  symbols: PYRAMID
+}
+panels {
+  name: "GIGGLING"
+  path: "Panels/Floor 2/panel_15"
+  clue: "giggling"
+  answer: "daughter"
+  symbols: SPARKLES
+  symbols: PYRAMID
+}
+panels {
+  name: "MINUSCULE"
+  path: "Panels/Floor 3/panel_1"
+  clue: "minuscule"
+  answer: "tin"
+  symbols: SUN
+  symbols: SPARKLES
+}
+panels {
+  name: "TYPEWRITER"
+  path: "Panels/Floor 3/panel_2"
+  clue: "typewriter"
+  answer: "keyboards"
+  symbols: PLANET
+  symbols: AGE
+}
+panels {
+  name: "READJUST"
+  path: "Panels/Floor 3/panel_3"
+  clue: "readjust"
+  answer: "adjusted"
+  symbols: SPARKLES
+}
+panels {
+  name: "REINDICT"
+  path: "Panels/Floor 3/panel_4"
+  clue: "reindict"
+  answer: "credit"
+  symbols: ANAGRAM
+  symbols: EVAL
+}
+panels {
+  name: "COPYRIGHT"
+  path: "Panels/Floor 3/panel_5"
+  clue: "copyright"
+  answer: "trader"
+  symbols: SUN
+  symbols: SPARKLES
+}
+panels {
+  name: "CONTINENT"
+  path: "Panels/Floor 3/panel_6"
+  clue: "continent"
+  answer: "shop"
+  symbols: BOXES
+}
+panels {
+  name: "FOOT"
+  path: "Panels/Floor 3/panel_7"
+  clue: "foot"
+  answer: "house"
+  symbols: BOXES
+}
+panels {
+  name: "EYE"
+  path: "Panels/Floor 3/panel_8"
+  clue: "eye"
+  answer: "school"
+  symbols: BOXES
+  symbols: STARS
+}
+panels {
+  name: "RIVER"
+  path: "Panels/Floor 3/panel_9"
+  clue: "river"
+  answer: "hospital"
+  symbols: BOXES
+}
+panels {
+  name: "NUCLEUS"
+  path: "Panels/Floor 3/panel_10"
+  clue: "nucleus"
+  answer: "jail"
+  symbols: BOXES
+}
+panels {
+  name: "MIX (1)"
+  path: "Panels/Floor 3/panel_11"
+  clue: "mix"
+  answer: "bar"
+  symbols: JOB
+  symbols: STARS
+}
+panels {
+  name: "HEAL"
+  path: "Panels/Floor 3/panel_12"
+  clue: "heal"
+  answer: "hospital"
+  symbols: JOB
+  symbols: STARS
+}
+panels {
+  name: "SCREW"
+  path: "Panels/Floor 3/panel_13"
+  clue: "screw"
+  answer: "toolbox"
+  symbols: JOB
+  symbols: STARS
+}
+panels {
+  name: "FLY"
+  path: "Panels/Floor 3/panel_14"
+  clue: "fly"
+  answer: "airplane"
+  symbols: JOB
+  symbols: STARS
+}
+panels {
+  name: "MIX (2)"
+  path: "Panels/Floor 3/panel_15"
+  clue: "mix"
+  answer: "kitchen"
+  symbols: JOB
+  symbols: STARS
+}
+panels {
+  name: "BARE"
+  path: "Panels/Floor 4/panel_1"
+  clue: "bare"
+  answer: "cub"
+  symbols: ZERO
+  symbols: AGE
+}
+panels {
+  name: "CANON"
+  path: "Panels/Floor 4/panel_2"
+  clue: "canon"
+  answer: "boom"
+  symbols: ZERO
+  symbols: SOUND
+}
+panels {
+  name: "DUCTS"
+  path: "Panels/Floor 4/panel_3"
+  clue: "ducts"
+  answer: "quack"
+  symbols: ZERO
+  symbols: SOUND
+}
+panels {
+  name: "COY"
+  path: "Panels/Floor 4/panel_4"
+  clue: "coy"
+  answer: "fish"
+  symbols: ZERO
+  symbols: EXAMPLE
+}
+panels {
+  name: "LYNX"
+  path: "Panels/Floor 4/panel_5"
+  clue: "lynx"
+  answer: "slink"
+  symbols: ZERO
+  symbols: ANAGRAM
+}
+panels {
+  name: "SCENTS (1)"
+  path: "Panels/Floor 4/panel_6"
+  clue: "scents"
+  answer: "dollars"
+  symbols: ZERO
+  symbols: BOXES
+}
+panels {
+  name: "SCENTS (2)"
+  path: "Panels/Floor 4/panel_7"
+  clue: "scents"
+  answer: "sight"
+  symbols: ZERO
+  symbols: EXAMPLE
+}
+panels {
+  name: "SEIZE (1)"
+  path: "Panels/Floor 4/panel_8"
+  clue: "seize"
+  answer: "oceans"
+  symbols: ZERO
+  symbols: PYRAMID
+}
+panels {
+  name: "SEIZE (2)"
+  path: "Panels/Floor 4/panel_9"
+  clue: "seize"
+  answer: "eye"
+  symbols: ZERO
+  symbols: PLANET
+  symbols: JOB
+}
+panels {
+  name: "THROWN"
+  path: "Panels/Floor 4/panel_10"
+  clue: "thrown"
+  answer: "chair"
+  symbols: ZERO
+  symbols: EXAMPLE
+}
+panels {
+  name: "FUND"
+  path: "Panels/Floor 5/panel_1"
+  clue: "fund"
+  answer: "find"
+  symbols: SPARKLES
+  symbols: AGE
+}
+panels {
+  name: "ENVELOPE"
+  path: "Panels/Floor 5/panel_2"
+  clue: "envelope"
+  answer: "letters"
+  symbols: PLANET
+  symbols: STARS
+}
+panels {
+  name: "ROTE"
+  path: "Panels/Floor 5/panel_3"
+  clue: "rote"
+  answer: "write"
+  symbols: ZERO
+  symbols: AGE
+}
+panels {
+  name: "ENVELOPES"
+  path: "Panels/Floor 5/panel_4"
+  clue: "envelopes"
+  answer: "words"
+  symbols: BOXES
+  symbols: STARS
+}
+panels {
+  name: "ERECTS"
+  path: "Panels/Floor 5/panel_5"
+  clue: "erects"
+  answer: "hidden"
+  symbols: SUN
+  symbols: ANAGRAM
+}
+panels {
+  name: "HIDE (1)"
+  path: "Panels/Floor 5/panel_6"
+  clue: "hide"
+  answer: "see"
+  symbols: SUN
+  symbols: SPARKLES
+}
+panels {
+  name: "HUE"
+  path: "Panels/Floor 5/panel_7"
+  clue: "hue"
+  answer: "colors"
+  symbols: SUN
+  symbols: PLANET
+}
+panels {
+  name: "CRUST"
+  path: "Panels/Floor 5/panel_8"
+  clue: "crust"
+  answer: "read"
+  symbols: SPARKLES
+  symbols: BOXES
+}
+panels {
+  name: "HIDE (2)"
+  path: "Panels/Floor 5/panel_9"
+  clue: "hide"
+  answer: "secret"
+  symbols: SUN
+  symbols: SPARKLES
+}
+panels {
+  name: "BETTER"
+  path: "Panels/Floor 5/panel_10"
+  clue: "better"
+  answer: "letters"
+  symbols: ZERO
+  symbols: PLANET
+}
+panels {
+  name: "Colors"
+  path: "Panels/End/panel_1"
+  clue: ""
+  answer: "backdoor"
+  symbols: QUESTION
+  required_door { name: "Colors Panel" }
+}
+panels {
+  name: "Context"
+  path: "Panels/End/panel_2"
+  clue: ""
+  answer: "door"
+  required_door { name: "Context Panel" }
+}
@@ -0,0 +1,5 @@
+connections {
+  from_room: "Main Area"
+  to_room: "Bearer Entrance"
+  door { name: "Control Center Brown Door" }
+}
@@ -0,0 +1,42 @@
+doors {
+  name: "Control Center Brown Door"
+  type: CONTROL_CENTER_COLOR
+  receivers: "Components/Doors/entry_1"
+  control_center_color: "brown"
+}
+doors {
+  name: "The Tree Gravestone"
+  type: GRAVESTONE
+  panels { room: "Main Area" name: "COLOR" }
+  panels { room: "Main Area" name: "DAMAGE (1)" }
+  panels { room: "Main Area" name: "DAMAGE (2)" }
+  panels { room: "Main Area" name: "MEAL (1)" }
+  panels { room: "Main Area" name: "MEAL (2)" }
+  panels { room: "Main Area" name: "WALK (1)" }
+  panels { room: "Main Area" name: "WALK (2)" }
+  panels { room: "Main Area" name: "REST" }
+  panels { room: "Main Area" name: "SLEEP" }
+  panels { room: "Main Area" name: "JUMP (1)" }
+  panels { room: "Main Area" name: "JUMP (2)" }
+  panels { room: "Main Area" name: "DRIZZLE" }
+  panels { room: "Main Area" name: "WADE" }
+  panels { room: "Main Area" name: "GROW (1)" }
+  panels { room: "Main Area" name: "GROW (2)" }
+  panels { room: "Main Area" name: "GROW (3)" }
+  panels { room: "Main Area" name: "GOOD (1)" }
+  panels { room: "Main Area" name: "GOOD (2)" }
+  panels { room: "Main Area" name: "GOOD (3)" }
+  panels { room: "Main Area" name: "HOVER" }
+  panels { room: "Main Area" name: "HAPPY (1)" }
+  panels { room: "Main Area" name: "HAPPY (2)" }
+  panels { room: "Main Area" name: "HAPPY (3)" }
+  panels { room: "Main Area" name: "LIGHT (1)" }
+  panels { room: "Main Area" name: "LIGHT (2)" }
+  panels { room: "Main Area" name: "LIGHT (3)" }
+  panels { room: "Main Area" name: "SMALL (1)" }
+  panels { room: "Main Area" name: "SMALL (2)" }
+  panels { room: "Main Area" name: "SMALL (3)" }
+  panels { room: "Main Area" name: "SPRINKLE" }
+  location_room: "Main Area"
+  location_name: "Gravestone"
+}
@@ -0,0 +1 @@
+display_name: "The Tree"
@@ -0,0 +1,5 @@
+name: "Bearer Entrance"
+ports {
+  name: "BEARER"
+  path: "Components/Warps/worldport"
+}
@@ -0,0 +1,239 @@
+name: "Main Area"
+panels {
+  name: "COLOR"
+  path: "Panels/Room_1/panel_1"
+  clue: "color"
+  answer: "brown"
+  symbols: EXAMPLE
+}
+panels {
+  name: "DAMAGE (1)"
+  path: "Panels/Room_1/panel_2"
+  clue: "damage"
+  answer: "dent"
+  symbols: PYRAMID
+}
+panels {
+  name: "DAMAGE (2)"
+  path: "Panels/Room_1/panel_3"
+  clue: "damage"
+  answer: "ruin"
+  symbols: PYRAMID
+}
+panels {
+  name: "MEAL (1)"
+  path: "Panels/Room_1/panel_4"
+  clue: "meal"
+  answer: "snack"
+  symbols: PYRAMID
+}
+panels {
+  name: "MEAL (2)"
+  path: "Panels/Room_1/panel_5"
+  clue: "meal"
+  answer: "feast"
+  symbols: PYRAMID
+}
+panels {
+  name: "WALK (1)"
+  path: "Panels/Room_1/panel_6"
+  clue: "walk"
+  answer: "run"
+  symbols: PYRAMID
+}
+panels {
+  name: "WALK (2)"
+  path: "Panels/Room_1/panel_7"
+  clue: "walk"
+  answer: "sprint"
+  symbols: PYRAMID
+}
+panels {
+  name: "REST"
+  path: "Panels/Room_1/panel_8"
+  clue: "rest"
+  answer: "lounge"
+  symbols: PYRAMID
+}
+panels {
+  name: "SLEEP"
+  path: "Panels/Room_1/panel_9"
+  clue: "sleep"
+  answer: "rest"
+  symbols: PYRAMID
+}
+panels {
+  name: "JUMP (1)"
+  path: "Panels/Room_1/panel_10"
+  clue: "jump"
+  answer: "hop"
+  symbols: PYRAMID
+}
+panels {
+  name: "JUMP (2)"
+  path: "Panels/Room_1/panel_11"
+  clue: "jump"
+  answer: "leap"
+  symbols: PYRAMID
+}
+panels {
+  name: "DRIZZLE"
+  path: "Panels/Room_1/panel_12"
+  clue: "drizzle"
+  answer: "pour"
+  symbols: PYRAMID
+}
+panels {
+  name: "WADE"
+  path: "Panels/Room_1/panel_13"
+  clue: "wade"
+  answer: "dive"
+  symbols: PYRAMID
+}
+panels {
+  name: "GROW (1)"
+  path: "Panels/Room_1/panel_14"
+  clue: "grow"
+  answer: "sprout"
+  symbols: PYRAMID
+}
+panels {
+  name: "GROW (2)"
+  path: "Panels/Room_1/panel_15"
+  clue: "grow"
+  answer: "flourish"
+  symbols: PYRAMID
+}
+panels {
+  name: "GROW (3)"
+  path: "Panels/Room_1/panel_16"
+  clue: "grow"
+  answer: "die"
+  symbols: SUN
+}
+panels {
+  name: "GOOD (1)"
+  path: "Panels/Room_1/panel_17"
+  clue: "good"
+  answer: "bad"
+  symbols: SUN
+}
+panels {
+  name: "GOOD (2)"
+  path: "Panels/Room_1/panel_18"
+  clue: "good"
+  answer: "okay"
+  symbols: PYRAMID
+}
+panels {
+  name: "GOOD (3)"
+  path: "Panels/Room_1/panel_19"
+  clue: "good"
+  answer: "great"
+  symbols: PYRAMID
+}
+panels {
+  name: "HOVER"
+  path: "Panels/Room_1/panel_20"
+  clue: "hover"
+  answer: "fly"
+  symbols: PYRAMID
+}
+panels {
+  name: "HAPPY (1)"
+  path: "Panels/Room_1/panel_21"
+  clue: "happy"
+  answer: "glad"
+  symbols: PYRAMID
+}
+panels {
+  name: "HAPPY (2)"
+  path: "Panels/Room_1/panel_22"
+  clue: "happy"
+  answer: "joyful"
+  symbols: PYRAMID
+}
+panels {
+  name: "HAPPY (3)"
+  path: "Panels/Room_1/panel_23"
+  clue: "happy"
+  answer: "sad"
+  symbols: SUN
+}
+panels {
+  name: "LIGHT (1)"
+  path: "Panels/Room_1/panel_24"
+  clue: "light"
+  answer: "dim"
+  symbols: PYRAMID
+}
+panels {
+  name: "LIGHT (2)"
+  path: "Panels/Room_1/panel_25"
+  clue: "light"
+  answer: "bright"
+  symbols: PYRAMID
+}
+panels {
+  name: "LIGHT (3)"
+  path: "Panels/Room_1/panel_26"
+  clue: "light"
+  answer: "dark"
+  symbols: SUN
+}
+panels {
+  name: "SMALL (1)"
+  path: "Panels/Room_1/panel_27"
+  clue: "small"
+  answer: "big"
+  symbols: SUN
+}
+panels {
+  name: "SMALL (2)"
+  path: "Panels/Room_1/panel_28"
+  clue: "small"
+  answer: "modest"
+  symbols: PYRAMID
+}
+panels {
+  name: "SMALL (3)"
+  path: "Panels/Room_1/panel_29"
+  clue: "small"
+  answer: "tiny"
+  symbols: PYRAMID
+}
+panels {
+  name: "SPRINKLE"
+  path: "Panels/Room_1/panel_30"
+  clue: "sprinkle"
+  answer: "rain"
+  symbols: PYRAMID
+}
+ports {
+  name: "UNKEMPT"
+  path: "Components/Warps/worldport4"
+}
+ports {
+  name: "DIGITAL"
+  path: "Components/Warps/worldport5"
+}
+ports {
+  name: "GREAT"
+  path: "Components/Warps/worldport2"
+}
+ports {
+  name: "DAEDALUS"
+  path: "Components/Warps/worldport3"
+}
+paintings {
+  name: "SEA"
+  path: "Components/Paintings/sea"
+}
+paintings {
+  name: "EYERED"
+  path: "Components/Paintings/eyeRed"
+}
+paintings {
+  name: "WHY_LETTERS"
+  path: "Components/Paintings/why_letters"
+}
@@ -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,12 @@
+name: "Control Center Entrance"
+panels {
+  name: "RETURN"
+  path: "Panels/Entry/panel_1"
+  clue: "return"
+  answer: "turn"
+  symbols: SPARKLES
+}
+ports {
+  name: "CC"
+  path: "Components/Warps/worldport2"
+}
@@ -0,0 +1,5 @@
+name: "Daedalus Entrance"
+ports {
+  name: "DAEDALUS"
+  path: "Components/Warps/worldport4"
+}
@@ -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,229 @@
+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"
+  path: "Components/Warps/worldport"
+}
+ports {
+  name: "TREE"
+  path: "Components/Warps/worldport5"
+}
+ports {
+  name: "SUNTEMPLE"
+  path: "Components/Warps/worldport3"
+  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
 }
@@ -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,11 @@
+name: "Entry"
+panels {
+  name: "WONDER"
+  path: "Panels/panel_1"
+  clue: "wonder"
+  answer: "wonder"
+}
+ports {
+  name: "DAEDALUS"
+  path: "Components/Warps/worldport"
+}
@@ -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,61 @@
+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"
+  path: "Components/Warps/worldport"
+}
@@ -0,0 +1,50 @@
+version: 6
+# 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 {
@@ -84,6 +107,10 @@ message Connection {
     uint64 painting = 5;
     ProxyIdentifier panel = 6;
   }
+
+  optional bool roof_access = 7;
+  optional bool purple_ending = 8;
+  optional bool cyan_ending = 9;
 }
 
 message Door {
@@ -100,12 +127,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 +154,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;
@@ -154,12 +187,14 @@ message Port {
   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 +232,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 +250,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 uint64 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,22 @@ 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;
 }
 
 message HumanConnections {
@@ -82,13 +98,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 +129,8 @@ message HumanPanel {
 
   optional DoorIdentifier required_door = 7;
   optional RoomIdentifier required_room = 8;
+
+  optional string display_name = 9;
 }
 
 message HumanPainting {
@@ -137,6 +161,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 +191,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 +209,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 uint64 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 +249,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());
@@ -279,11 +290,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 +346,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 +396,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 +409,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 +468,21 @@ 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());
+    }
+
     container_.AddConnection(f_connection);
     if (!human_connection.oneway()) {
       container_.AddConnection(r_connection);
@@ -524,6 +566,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().set_version(h_metadata.version());
+  }
+
   void ProcessIdsFile(std::filesystem::path path) {
     auto ids = ReadIdsFromYaml(path.string());
 
@@ -548,6 +647,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 +672,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,542 @@
 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;
-  }
+  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;
 
-  if (panel_info.definitions.empty()) {
-    std::cout << "Panel " << panel_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 DoorIdentifier& door_identifier :
-         panel_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;
+
+      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 : ending_info.defined_in) {
-      std::cout << "    " << room_identifier.ShortDebugString() << 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,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"