590 files changed, 8043 insertions, 1228 deletions

@@ -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
+while standing in the same position, as the keyholder is still there, just
+invisible. If you have already left the room, though, there is an easier 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,40 @@
+# lingo2-archipelago Apworld Releases
+
+## 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):
@@ -32,6 +41,8 @@ class Lingo2World(World):
     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
 
@@ -51,14 +62,53 @@ 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",
+            "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,15 +1,115 @@
 from dataclasses import dataclass
 
-from Options import PerGameCommonOptions, Toggle, Choice
+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 VictoryCondition(Choice):
-    """Victory condition."""
+    """
+    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
@@ -26,7 +126,23 @@ class VictoryCondition(Choice):
     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
     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
 
@@ -12,64 +17,175 @@ def calculate_letter_histogram(solution: str) -> dict[str, int]:
             real_l = l.upper()
             histogram[real_l] = min(histogram.get(real_l, 0) + 1, 2)
 
-    for free_letter in "HINT":
-        if histogram.get(free_letter, 0) == 1:
-            del histogram[free_letter]
-
     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.symbols) > 0:
-            parts.append(f"symbols={self.symbols}")
         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}")
-        return f"AccessRequirements({", ".join(parts)})"
+        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):
@@ -77,13 +193,19 @@ class PlayerLocation(NamedTuple):
     reqs: AccessRequirements
 
 
+class LetterBehavior(IntEnum):
+    VANILLA = auto()
+    ITEM = auto()
+    UNLOCKED = auto()
+
+
 class Lingo2PlayerLogic:
     world: "Lingo2World"
 
     locations_by_room: dict[int, list[PlayerLocation]]
     event_loc_item_by_room: dict[int, dict[str, str]]
 
-    item_by_door: dict[int, str]
+    item_by_door: dict[int, tuple[str, int]]
 
     panel_reqs: dict[int, AccessRequirements]
     proxy_reqs: dict[int, dict[str, AccessRequirements]]
@@ -91,6 +213,8 @@ class Lingo2PlayerLogic:
 
     real_items: list[str]
 
+    double_letter_amount: dict[str, int]
+
     def __init__(self, world: "Lingo2World"):
         self.world = world
         self.locations_by_room = {}
@@ -100,14 +224,68 @@ class Lingo2PlayerLogic:
         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]:
@@ -117,22 +295,34 @@ 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()
 
-            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 letter.level2:
-                event_name = f"{letter_name} (Double Collected)"
-                self.event_loc_item_by_room.setdefault(letter.room_id, {})[event_name] = 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
@@ -142,6 +332,21 @@ class Lingo2PlayerLogic:
 
             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:
             if panel_id not in self.panel_reqs:
@@ -161,28 +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)
 
-                possibilities.append(proxy_reqs)
+                if not proxy_reqs.is_empty():
+                    possibilities.append(proxy_reqs)
+                else:
+                    already_filled = True
+                    break
 
-            if not any(proxy.answer == panel.answer for proxy in panel.proxies):
+            if not already_filled and not any(proxy.answer == panel.answer for proxy in panel.proxies):
                 proxy_reqs = AccessRequirements()
-                proxy_reqs.add_solution(panel.answer)
+                self.add_solution_reqs(proxy_reqs, panel.answer)
 
-                possibilities.append(proxy_reqs)
+                if not proxy_reqs.is_empty():
+                    possibilities.append(proxy_reqs)
+                else:
+                    already_filled = True
 
-            reqs.or_logic.append(possibilities)
+            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)
@@ -205,26 +420,46 @@ class Lingo2PlayerLogic:
         door = self.world.static_logic.objects.doors[door_id]
         reqs = AccessRequirements()
 
-        # TODO: control_center_color, switches
         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])
+            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: Handle complete_at > 1
-            pass
+            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")
-            reqs.add_solution(door.control_center_color)
+            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 keyholder_uses in door.keyholders:
             key_name = keyholder_uses.key.upper()
-            if key_name not in reqs.letters:
+            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]
@@ -233,10 +468,20 @@ class Lingo2PlayerLogic:
         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)
 
+        reqs.simplify()
+
         return reqs
 
     # This gets the requirements to open a door within the world. When a door is shuffled, this means having the item
@@ -244,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)
@@ -11,12 +11,17 @@ if TYPE_CHECKING:
 
 
 def create_region(room, world: "Lingo2World") -> Region:
-    new_region = Region(world.static_logic.get_room_region_name(room.id), world.player, world.multiworld)
+    return Region(world.static_logic.get_room_region_name(room.id), world.player, world.multiworld)
 
+
+def create_locations(room, new_region: Region, world: "Lingo2World", regions: dict[str, Region]):
     for location in world.player_logic.locations_by_room.get(room.id, {}):
+        reqs = location.reqs.copy()
+        reqs.remove_room(new_region.name)
+
         new_location = Lingo2Location(world.player, world.static_logic.location_id_to_name[location.code],
                                       location.code, new_region)
-        new_location.access_rule = make_location_lambda(location.reqs, world)
+        new_location.access_rule = make_location_lambda(reqs, world, regions)
         new_region.locations.append(new_location)
 
     for event_name, item_name in world.player_logic.event_loc_item_by_room.get(room.id, {}).items():
@@ -25,24 +30,37 @@ def create_region(room, world: "Lingo2World") -> Region:
         new_location.place_locked_item(event_item)
         new_region.locations.append(new_location)
 
-    return new_region
-
-
 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()
@@ -79,14 +97,16 @@ 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:
-            connection = Entrance(world.player, connection_name, regions[from_region])
-            connection.access_rule = make_location_lambda(reqs, world)
+        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])
+        regions[from_region].exits.append(connection)
+        connection.connect(regions[to_region])
 
-            for region in reqs.rooms:
-                world.multiworld.register_indirect_condition(regions[region], connection)
+        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,32 +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
+    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)
+        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
 
+    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 = 5
@@ -1,6 +1,7 @@
 extends "res://scripts/nodes/listeners/animationListener.gd"
 
 var item_id
+var item_amount
 
 
 func _ready():
@@ -8,17 +9,16 @@ func _ready():
                 get_tree().get_root().get_node("scene").get_path_to(self).get_concatenated_names()
         )
 
-        print("node: %s" % node_path)
-
         var gamedata = global.get_node("Gamedata")
         var door_id = gamedata.get_door_for_map_node_path(global.map, node_path)
         if door_id != null:
-                print("door_id: %d" % door_id)
-
                 var ap = global.get_node("Archipelago")
-                item_id = ap.get_item_id_for_door(door_id)
+                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]
 
-                if item_id != null:
                         self.senders = []
                         self.senderGroup = []
                         self.nested = false
@@ -34,5 +34,5 @@ func _ready():
 func _readier():
         var ap = global.get_node("Archipelago")
 
-        if ap.has_item(item_id):
+        if ap.client.getItemAmount(item_id) >= item_amount:
                 handleTriggered()
@@ -32,17 +32,23 @@ var _players = []
 var _player_name_by_slot = {}
 var _game_by_player = {}
 var _checked_locations = []
-var _received_items = []
+var _received_indexes = []
+var _received_items = {}
 var _slot_data = {}
 
 signal could_not_connect
 signal connect_status
-signal client_connected
-signal item_received(item_id, index, player, flags)
+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
@@ -74,6 +80,8 @@ func _reset_state():
         _authenticated = false
         _try_wss = false
         _has_connected = false
+        _received_items = {}
+        _received_indexes = []
 
 
 func _errored():
@@ -183,7 +191,7 @@ func _process(_delta):
                                                                 player["slot"]
                                                         )]["game"]
 
-                                                emit_signal("client_connected")
+                                                emit_signal("client_connected", _slot_data)
 
                                         elif cmd == "ConnectionRefused":
                                                 var error_message = ""
@@ -219,7 +227,7 @@ func _process(_delta):
                                                         error_message = "Unknown error."
 
                                                 _initiated_disconnect = true
-                                                _ws.disconnect_from_host()
+                                                _ws.close()
 
                                                 emit_signal("could_not_connect", error_message)
                                                 global._print("Connection to AP refused")
@@ -228,21 +236,40 @@ func _process(_delta):
                                         elif cmd == "ReceivedItems":
                                                 var i = 0
                                                 for item in message["items"]:
-                                                        if not _received_items.has(int(item["item"])):
-                                                                _received_items.append(int(item["item"]))
+                                                        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",
-                                                                int(item["item"]),
-                                                                int(message["index"]) + i,
+                                                                item_id,
+                                                                index,
                                                                 int(item["player"]),
-                                                                int(item["flags"])
+                                                                int(item["flags"]),
+                                                                _received_items[item_id]
                                                         )
-                                                        i += 1
 
                                         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()
@@ -284,7 +311,7 @@ func connectToServer(server, un, pw):
                                 % err
                         )
                 )
-                global._print("Could not connect to AP: " + err)
+                global._print("Could not connect to AP: %d" % err)
                 return
         _should_process = true
 
@@ -353,6 +380,10 @@ 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(
                 [
@@ -374,5 +405,13 @@ 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")
@@ -1,6 +1,7 @@
 extends "res://scripts/nodes/door.gd"
 
 var item_id
+var item_amount
 
 
 func _ready():
@@ -8,17 +9,16 @@ func _ready():
                 get_tree().get_root().get_node("scene").get_path_to(self).get_concatenated_names()
         )
 
-        print("node: %s" % node_path)
-
         var gamedata = global.get_node("Gamedata")
         var door_id = gamedata.get_door_for_map_node_path(global.map, node_path)
         if door_id != null:
-                print("door_id: %d" % door_id)
-
                 var ap = global.get_node("Archipelago")
-                item_id = ap.get_item_id_for_door(door_id)
+                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]
 
-                if item_id != null:
                         self.senders = []
                         self.senderGroup = []
                         self.nested = false
@@ -34,5 +34,5 @@ func _ready():
 func _readier():
         var ap = global.get_node("Archipelago")
 
-        if ap.has_item(item_id):
+        if ap.client.getItemAmount(item_id) >= item_amount:
                 handleTriggered()
@@ -5,13 +5,42 @@ 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()
@@ -50,6 +79,31 @@ func load(data_bytes):
 
                 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):
@@ -59,6 +113,14 @@ func get_door_for_map_node_path(map_name, node_path):
         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():
@@ -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
@@ -1,10 +1,12 @@
 extends Node
 
-const my_version = "0.1.0"
+const MOD_VERSION = 5
 
 var SCRIPT_client
+var SCRIPT_keyboard
 var SCRIPT_locationListener
 var SCRIPT_uuid
+var SCRIPT_victoryListener
 
 var ap_server = ""
 var ap_user = ""
@@ -12,10 +14,43 @@ var ap_pass = ""
 var connection_history = []
 
 var client
+var keyboard
 
 var _localdata_file = ""
-var _received_indexes = []
 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 victory_condition = -1
 
 signal could_not_connect
 signal connect_status
@@ -52,12 +87,16 @@ func _ready():
 
         client.connect("item_received", _process_item)
         client.connect("message_received", _process_message)
+        client.connect("location_scout_received", _process_location_scout)
         client.connect("could_not_connect", _client_could_not_connect)
         client.connect("connect_status", _client_connect_status)
         client.connect("client_connected", _client_connected)
 
         add_child(client)
 
+        keyboard = SCRIPT_keyboard.new()
+        add_child(keyboard)
+
 
 func saveSettings():
         # Save the AP settings to disk.
@@ -91,8 +130,13 @@ func saveLocaldata():
 
 
 func connectToServer():
-        _received_indexes = []
         _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)
 
@@ -106,48 +150,46 @@ func disconnect_from_ap():
 
 
 func get_item_id_for_door(door_id):
-        var gamedata = global.get_node("Gamedata")
-        var door = gamedata.objects.get_doors()[door_id]
-        if (
-                door.get_type() == gamedata.SCRIPT_proto.DoorType.EVENT
-                or door.get_type() == gamedata.SCRIPT_proto.DoorType.LOCATION_ONLY
-                or door.get_type() == gamedata.SCRIPT_proto.DoorType.CONTROL_CENTER_COLOR
-        ):
-                return null
-        return gamedata.get_door_ap_id(door_id)
-
-
-func has_item(item_id):
-        return client.hasItem(item_id)
-
+        return _item_locks.get(door_id, null)
 
-func _process_item(item, index, from, flags):
-        if index != null:
-                if _received_indexes.has(index):
-                        # Do not re-process items.
-                        return
-
-                _received_indexes.append(index)
 
+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 door_id = gamedata.door_id_by_ap_id.get(item, null)
-        if door_id != null and gamedata.get_door_map_name(door_id) == global.map:
-                var receivers = gamedata.get_door_receivers(door_id)
-                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()
-                        #for painting_id in gamedata.objects.get_doors()[door_id].get_move_paintings():
-                        #       var painting = gamedata.objects.get_paintings()[painting_id]
-                        #       var pnode = scene.get_node_or_null(painting.get_path() + "/teleportListener")
-                        #       if pnode != null:
-                        #               pnode.handleTriggered()
+
+        var 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:
@@ -155,16 +197,26 @@ func _process_item(item, index, from, flags):
                 saveLocaldata()
 
                 var player_name = "Unknown"
-                if client._player_name_by_slot.has(from):
-                        player_name = client._player_name_by_slot[from]
+                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, item_name]
+                        message = "Found [color=%s]%s[/color]" % [item_color, full_item_name]
                 else:
-                        message = "Received [color=%s]%s[/color] from %s" % [item_color, item_name, player_name]
+                        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)
 
@@ -183,15 +235,15 @@ func _process_message(message):
 
         var item_name = "Unknown"
         var item_player_game = client._game_by_player[message["receiving"]]
-        if client._item_id_to_name[item_player_game].has(message["item"]["item"]):
-                item_name = client._item_id_to_name[item_player_game][message["item"]["item"]]
+        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(message["item"]["location"]):
-                location_name = (
-                        client._location_id_to_name[location_player_game][message["item"]["location"]]
-                )
+        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"]):
@@ -257,22 +309,53 @@ func parse_printjson_for_textclient(message):
                 textclient_node.parse_printjson("".join(parts))
 
 
-func _client_could_not_connect():
-        emit_signal("could_not_connect")
+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():
+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 = ap_file.get_var(true)
-                ap_file.close()
+                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")
@@ -281,11 +364,113 @@ func _client_connected():
                 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))
+        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):
-        client.sendLocation(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):
@@ -301,3 +486,50 @@ func colorForItemType(flags):
                 return "#d63a22"
         else:  # filler
                 return "#14de9e"
+
+
+func get_letter_behavior(key, level2):
+        if shuffle_letters == kSHUFFLE_LETTERS_UNLOCKED:
+                return kLETTER_BEHAVIOR_UNLOCKED
+
+        if [kSHUFFLE_LETTERS_VANILLA_CYAN, kSHUFFLE_LETTERS_ITEM_CYAN].has(shuffle_letters):
+                if level2:
+                        if shuffle_letters == kSHUFFLE_LETTERS_VANILLA_CYAN:
+                                return kLETTER_BEHAVIOR_VANILLA
+                        else:
+                                return kLETTER_BEHAVIOR_ITEM
+                else:
+                        return kLETTER_BEHAVIOR_UNLOCKED
+
+        if not level2 and ["h", "i", "n", "t"].has(key):
+                # This differs from the equivalent function in the apworld. Logically it is
+                # the same as UNLOCKED since they are in the starting room, but VANILLA
+                # means the player still has to actually pick up the letters.
+                return kLETTER_BEHAVIOR_VANILLA
+
+        if shuffle_letters == kSHUFFLE_LETTERS_PROGRESSIVE:
+                return kLETTER_BEHAVIOR_ITEM
+
+        return kLETTER_BEHAVIOR_VANILLA
+
+
+func setup_keys():
+        keyboard.load_seed()
+
+        _letters_setup = true
+
+        for k in _held_letters.keys():
+                _process_key_item(k, _held_letters[k])
+
+        _held_letters.clear()
+
+
+func _process_key_item(key, level):
+        if not _letters_setup:
+                _held_letters[key] = max(_held_letters.get(key, 0), level)
+                return
+
+        if shuffle_letters == kSHUFFLE_LETTERS_ITEM_CYAN:
+                level += 1
+
+        keyboard.collect_remote_letter(key, level)
@@ -48,10 +48,11 @@ func showMessage(text):
         while !_ordered_labels.is_empty():
                 await get_tree().create_timer(timeout).timeout
 
-                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 !_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()
@@ -59,3 +60,12 @@ func showMessage(text):
 
                 if timeout > 4:
                         timeout -= 3
+
+
+func clear():
+        _message_queue.clear()
+
+        for message_label in _ordered_labels:
+                message_label.queue_free()
+
+        _ordered_labels.clear()
@@ -1,6 +1,7 @@
 extends "res://scripts/nodes/painting.gd"
 
 var item_id
+var item_amount
 
 
 func _ready():
@@ -8,17 +9,16 @@ func _ready():
                 get_tree().get_root().get_node("scene").get_path_to(self).get_concatenated_names()
         )
 
-        print("node: %s" % node_path)
-
         var gamedata = global.get_node("Gamedata")
         var door_id = gamedata.get_door_for_map_node_path(global.map, node_path)
         if door_id != null:
-                print("door_id: %d" % door_id)
-
                 var ap = global.get_node("Archipelago")
-                item_id = ap.get_item_id_for_door(door_id)
+                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]
 
-                if item_id != null:
                         self.senders = []
                         self.senderGroup = []
                         self.nested = false
@@ -34,5 +34,5 @@ func _ready():
 func _readier():
         var ap = global.get_node("Archipelago")
 
-        if ap.has_item(item_id):
+        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()
@@ -4,3 +4,10 @@ extends "res://scripts/ui/pauseMenu.gd"
 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()
+        super._main_menu()
@@ -1,10 +1,33 @@
 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
+
 
 func _ready():
+        var khl_script = load("res://scripts/nodes/keyHolderListener.gd")
+
         var ap = global.get_node("Archipelago")
         var gamedata = global.get_node("Gamedata")
 
+        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:
@@ -13,7 +36,10 @@ func _ready():
                 if not door.has_ap_id():
                         continue
 
-                if door.get_type() == gamedata.SCRIPT_proto.DoorType.ITEM_ONLY:
+                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()
@@ -21,12 +47,39 @@ func _ready():
                 locationListener.name = "locationListener_%d" % door.get_ap_id()
 
                 for panel_ref in door.get_panels():
-                        # TODO: specific answers
                         var panel_data = gamedata.objects.get_panels()[panel_ref.get_panel()]
-                        locationListener.senders.append(NodePath("/root/scene/" + panel_data.get_path()))
+                        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:
@@ -39,6 +92,27 @@ func _ready():
 
                 get_parent().add_child.call_deferred(locationListener)
 
+                if (
+                        ap.get_letter_behavior(letter.get_key(), letter.has_level2() and letter.get_level2())
+                        != ap.kLETTER_BEHAVIOR_VANILLA
+                ):
+                        var scout = ap.scout_location(letter.get_ap_id())
+                        if (
+                                scout != null
+                                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:
@@ -51,6 +125,7 @@ func _ready():
 
                 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:
@@ -63,4 +138,113 @@ func _ready():
 
                 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)
+
         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)
@@ -2,4 +2,8 @@ extends "res://scripts/nodes/saver.gd"
 
 
 func levelLoaded():
-        reload.call_deferred()
+        if type == "keyholders":
+                var ap = global.get_node("Archipelago")
+                ap.keyboard.load_keyholders.call_deferred(global.map)
+        else:
+                reload.call_deferred()
@@ -22,27 +22,32 @@ func _ready():
                 var ap_instance = ap_script.new()
                 ap_instance.name = "Archipelago"
 
-                #apclient_instance.SCRIPT_doorControl = load("user://maps/Archipelago/doorControl.gd")
-                #apclient_instance.SCRIPT_effects = load("user://maps/Archipelago/effects.gd")
-                #apclient_instance.SCRIPT_location = load("user://maps/Archipelago/location.gd")
-                #apclient_instance.SCRIPT_mypainting = load("user://maps/Archipelago/mypainting.gd")
-                #apclient_instance.SCRIPT_panel = load("user://maps/Archipelago/panel.gd")
-                #apclient_instance.SCRIPT_textclient = load("user://maps/Archipelago/textclient.gd")
-
                 ap_instance.SCRIPT_client = load("user://maps/Archipelago/client.gd")
+                ap_instance.SCRIPT_keyboard = load("user://maps/Archipelago/keyboard.gd")
                 ap_instance.SCRIPT_locationListener = load("user://maps/Archipelago/locationListener.gd")
                 ap_instance.SCRIPT_uuid = load("user://maps/Archipelago/vendor/uuid.gd")
+                ap_instance.SCRIPT_victoryListener = load("user://maps/Archipelago/victoryListener.gd")
 
                 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")
@@ -65,6 +70,7 @@ func _ready():
                 global.add_child(textclient_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)
@@ -88,13 +94,17 @@ func _ready():
         history_box.get_popup().connect("id_pressed", historySelected)
 
         # Show client version.
-        $Panel/title.text = "ARCHIPELAGO (%s)" % ap.my_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):
@@ -124,6 +134,33 @@ func connectionStatus(message):
 
 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]
@@ -140,21 +177,30 @@ func connectionSuccessful():
         global.universe = "lingo"
         global.map = "the_entry"
 
-        unlocks.resetKeys()
         unlocks.resetCollectables()
         unlocks.resetData()
-        unlocks.loadKeys()
+
+        ap.setup_keys()
+
         unlocks.loadCollectables()
         unlocks.loadData()
         unlocks.unlockKey("capslock", 1)
 
         clearResourceCache("res://objects/meshes/gridDoor.tscn")
+        clearResourceCache("res://objects/nodes/collectable.tscn")
         clearResourceCache("res://objects/nodes/door.tscn")
+        clearResourceCache("res://objects/nodes/keyHolder.tscn")
         clearResourceCache("res://objects/nodes/listeners/animationListener.tscn")
+        clearResourceCache("res://objects/nodes/listeners/keyHolderChecker.tscn")
+        clearResourceCache("res://objects/nodes/listeners/keyHolderResetterListener.tscn")
         clearResourceCache("res://objects/nodes/listeners/teleportListener.tscn")
+        clearResourceCache("res://objects/nodes/listeners/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")
@@ -166,7 +212,7 @@ func connectionSuccessful():
                                 clearResourceCache("res://objects/meshes/paintings/" + file_name)
                         file_name = paintings_dir.get_next()
 
-        switcher.switch_map("res://objects/scenes/the_entry.tscn")
+        switcher.switch_map.call_deferred("res://objects/scenes/the_entry.tscn")
 
 
 func connectionUnsuccessful(error_message):
@@ -179,6 +225,13 @@ func connectionUnsuccessful(error_message):
         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")
@@ -190,5 +243,4 @@ func historySelected(index):
 
 
 func clearResourceCache(path):
-        ResourceLoader.load_threaded_request(path, "", false, ResourceLoader.CACHE_MODE_REPLACE)
-        ResourceLoader.load_threaded_get(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()
@@ -1,6 +1,7 @@
 extends "res://scripts/nodes/listeners/teleportListener.gd"
 
 var item_id
+var item_amount
 
 
 func _ready():
@@ -8,17 +9,27 @@ func _ready():
                 get_tree().get_root().get_node("scene").get_path_to(self).get_concatenated_names()
         )
 
-        print("node: %s" % node_path)
+        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:
-                print("door_id: %d" % door_id)
-
                 var ap = global.get_node("Archipelago")
-                item_id = ap.get_item_id_for_door(door_id)
+                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]
 
-                if item_id != null:
                         self.senders = []
                         self.senderGroup = []
                         self.nested = false
@@ -34,5 +45,5 @@ func _ready():
 func _readier():
         var ap = global.get_node("Archipelago")
 
-        if ap.has_item(item_id):
+        if ap.client.getItemAmount(item_id) >= item_amount:
                 handleTriggered()
@@ -50,7 +50,7 @@ func _ready():
 
 
 func _input(event):
-        if event is InputEventKey and event.pressed:
+        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
@@ -76,10 +76,6 @@ func dismiss():
 
 
 func parse_printjson(text):
-        if !label.text.is_empty():
-                #label.newline()
-                pass
-
         label.append_text("[p]" + text + "[/p]")
 
 
@@ -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()
@@ -1,8 +1,8 @@
 extends "res://scripts/nodes/listeners/worldportListener.gd"
 
 
-func changeScene():
+func handleTriggered():
         if exit == "menus/credits":
                 return
 
-        super.changeScene()
+        super.handleTriggered()
@@ -0,0 +1,38 @@
+# lingo2-archipelago Client Releases
+
+## 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.
@@ -40,6 +40,7 @@ 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"]
@@ -150,6 +151,10 @@ caret_blink = true
 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
@@ -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.
@@ -20,7 +20,7 @@ connections {
   from {
     port {
       map: "the_entry"
-      room: "Flipped Second Room"
+      room: "Four Rooms Entrance"
       name: "FOUR"
     }
   }
@@ -141,7 +141,7 @@ connections {
   to {
     port {
       map: "the_darkroom"
-      room: "First Room"
+      room: "Cyan Hallway"
       name: "COLORFUL"
     }
   }
@@ -157,7 +157,7 @@ connections {
   to {
     port {
       map: "the_darkroom"
-      room: "Second Room"
+      room: "Congruent Entrance"
       name: "CONGRUENT"
     }
   }
@@ -233,7 +233,7 @@ connections {
   from {
     port {
       map: "the_darkroom"
-      room: "First Room"
+      room: "Double Sided Entrance"
       name: "DOUBLESIDED"
     }
   }
@@ -308,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 {
@@ -618,7 +635,7 @@ connections {
   from {
     port {
       map: "the_entry"
-      room: "Link Area"
+      room: "Liberated Entrance"
       name: "BLUE"
     }
   }
@@ -666,7 +683,7 @@ connections {
   from {
     port {
       map: "the_entry"
-      room: "Link Area"
+      room: "Literate Entrance"
       name: "BROWN"
     }
   }
@@ -841,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 {
@@ -856,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 {
@@ -1193,6 +1231,7 @@ connections {
     }
   }
   oneway: true
+  roof_access: true
 }
 connections {
   from {
@@ -1434,7 +1473,6 @@ connections {
       name: "GREAT"
     }
   }
-  door { map: "the_great" name: "Daedalus Entrance" }
   oneway: true
 }
 connections {
@@ -1453,6 +1491,7 @@ connections {
     }
   }
   oneway: true
+  bypass_target_door: true
 }
 connections {
   from {
@@ -1748,12 +1787,13 @@ connections {
     }
   }
   oneway: true
+  bypass_target_door: true
 }
 connections {
   from {
     port {
       map: "the_bearer"
-      room: "Back Area"
+      room: "Tree Entrance"
       name: "TREE"
     }
   }
@@ -1830,7 +1870,6 @@ connections {
   }
 }
 connections {
-  # Two one-way connections because the door only blocks one direction.
   from {
     port {
       map: "the_great"
@@ -1847,6 +1886,7 @@ connections {
   }
 }
 connections {
+  # Two one-way connections because the door only blocks one direction.
   from {
     port {
       map: "the_unkempt"
@@ -1879,6 +1919,7 @@ connections {
     }
   }
   oneway: true
+  bypass_target_door: true
 }
 connections {
   from {
@@ -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"
+  }
+}
@@ -20,6 +20,11 @@ maps:
         panels:
           COLOR: 2726
           Letters: 2727
+        keyholders:
+          1: 2760
+          2: 2761
+          3: 2762
+          4: 2763
       Partial Entrance:
         panels:
           PARTIAL: 2729
@@ -155,6 +160,9 @@ maps:
       Brown Smiley:
         panels:
           OTHERS: 1667
+      C Keyholder:
+        keyholders:
+          C: 2755
       Castle:
         panels:
           FIVE (Blue): 1673
@@ -265,6 +273,9 @@ maps:
           SUMMER: 1754
           WORD: 1753
           WORDWORD: 1761
+      D Keyholder:
+        keyholders:
+          D: 2759
       Dark Light Exit:
         panels:
           GASKET: 1763
@@ -287,6 +298,9 @@ maps:
       Eye Painting:
         panels:
           REVILED: 1777
+      F Keyholder:
+        keyholders:
+          F: 2756
       F2 Room:
         panels:
           CAST: 1782
@@ -480,6 +494,8 @@ maps:
         panels:
           GOING: 1934
           TURN: 1935
+        keyholders:
+          G: 2757
       Nursery:
         panels:
           "?": 1937
@@ -547,6 +563,8 @@ maps:
           WALLS: 1986
           WHISPER: 1978
           WING: 1979
+        keyholders:
+          H: 2758
       Outside Magic Room:
         panels:
           WIZARD: 1988
@@ -879,7 +897,6 @@ maps:
           REDACTED: 2274
           STRINGS: 2205
           WINDS: 2204
-          "[REDACTED]": 2207
       Yellow Color Door:
         panels:
           Paintings: 2210
@@ -998,6 +1015,7 @@ 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
@@ -1026,6 +1044,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
@@ -1037,6 +1056,7 @@ maps:
       Near Sweet Blue Door: 1573
       Near Sweet Brown Door: 1561
       Near Yellow Room Door: 1565
+      North Castle Panel: 2742
       O2 Room Back Door: 1485
       Orange Rainbow Panel: 2267
       Orange Rainbow Room: 1535
@@ -1064,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
@@ -1088,6 +1109,7 @@ 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
@@ -1103,12 +1125,14 @@ maps:
       Starting Room West Wall South Door: 1433
       Sticks And Stones Door: 1593
       Temple of the Eyes Entrance: 1444
+      Theo Panels: 2811
       U2 Room Back Door: 1497
       U2 Room Back Right Door: 1496
       U2 Room Entrance: 1498
       U2 Room Shortcut: 1493
       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
@@ -1155,6 +1179,9 @@ maps:
           SWAY: 24
           TERROR: 20
           TURN: 22
+      Keyholder Room:
+        keyholders:
+          A: 2773
       Synonyms Room:
         panels:
           ADORE: 26
@@ -1191,7 +1218,6 @@ maps:
         panels:
           THIS: 45
     doors:
-      End Door: 42
       Front Door: 41
       Lavender Cubes: 43
   the_bearer:
@@ -1272,7 +1298,6 @@ maps:
       Control Center Brown Door: 49
       Exit Door: 47
       Overlook Door: 46
-      Q2 Door: 48
   the_between:
     rooms:
       Control Center Side:
@@ -1447,6 +1472,9 @@ maps:
         panels:
           CIVIL: 216
           CRABS: 217
+      T Keyholder:
+        keyholders:
+          T: 2754
     doors:
       C Keyholder Blocker: 176
       C2 Door: 177
@@ -1458,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:
@@ -1489,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:
@@ -1651,6 +1676,10 @@ maps:
       Rabbit Hole:
         panels:
           PUZZLE: 364
+      Rabbit Hole Lock:
+        panels:
+          HOLE: 2749
+          RABBIT: 2748
       Red Alcove:
         panels:
           BROW: 365
@@ -1687,8 +1716,6 @@ maps:
         panels:
           CORN: 393
           DICE: 392
-          HOLE: 390
-          RABBIT: 389
           WREATH: 391
     doors:
       Blue Alcove Entrance: 297
@@ -1700,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
@@ -1718,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
@@ -1751,6 +1777,8 @@ maps:
       X Plus:
         panels:
           ROSE: 405
+        keyholders:
+          M: 2766
       X Plus Middle Leg:
         panels:
           COLONY: 403
@@ -1780,6 +1808,9 @@ maps:
       Daedalus Extension:
         panels:
           WHERE: 433
+      Main Area:
+        keyholders:
+          P: 2765
     doors:
       Ancient Painting: 428
       Between Painting: 414
@@ -1964,6 +1995,8 @@ maps:
           LAUGH FINISHED: 573
           PLANTS: 570
           WEATHER: 568
+        keyholders:
+          X: 2770
       Outside Jail:
         panels:
           GUT: 575
@@ -2052,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
@@ -2111,6 +2143,8 @@ maps:
           WAS: 631
           WINGS: 662
           YELL: 636
+        keyholders:
+          B: 2769
       Mastery Room:
         masteries:
           MASTERY: 666
@@ -2177,6 +2211,8 @@ maps:
           FLASHBACK: 705
           PUSH: 703
           PUSHBACK: 702
+        keyholders:
+          J: 2772
     doors:
       Side Door: 687
   the_keen:
@@ -2288,9 +2324,11 @@ maps:
           NAY: 774
           NIGH: 781
           TORE: 787
+        keyholders:
+          S: 2767
     doors:
       Left Room Puzzles: 763
-      Main Room Puzzles: 765
+      Main Room Door: 2750
       Right Room Puzzles: 764
   the_orb:
     rooms:
@@ -2318,6 +2356,7 @@ maps:
           COLOR: 823
           ETCH: 837
           FAINT: 821
+          FIZZLE: 2745
           HAD: 830
           HEAVY: 829
           LAY: 834
@@ -2350,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
@@ -2389,6 +2427,9 @@ maps:
           CLEOPATRA: 859
           NAPOLEON: 860
           XERXES: 857
+      U Keyholder:
+        keyholders:
+          U: 2777
     doors:
       K2 Door: 852
   the_partial:
@@ -2412,6 +2453,8 @@ maps:
           TON: 878
           TURN: 875
           UP: 870
+        keyholders:
+          L: 2771
       Reverse Side:
         panels:
           BRO: 884
@@ -2530,6 +2573,9 @@ maps:
       Turtle Entrance: 891
   the_quiet:
     rooms:
+      Keyholder Room:
+        keyholders:
+          Q: 2778
       Main Area:
         panels:
           BEE: 979
@@ -2606,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
@@ -2713,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
@@ -2722,7 +2771,6 @@ maps:
       Lime Puzzles: 1031
       Magenta Door: 1029
       Magenta Puzzles: 1033
-      Plaza Entrance: 1024
       Yellow Door: 1030
       Yellow Puzzles: 1034
   the_revitalized:
@@ -2776,6 +2824,8 @@ maps:
           STIM: 1148
           STONE: 1142
           TADPOLES: 1159
+        keyholders:
+          N: 2779
     doors:
       Books Puzzles: 1136
       Games Puzzles: 1137
@@ -3086,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:
@@ -3130,6 +3173,8 @@ maps:
           SWINE (Brown): 2446
           WIFE (Black): 2440
           WIFE (Brown): 2447
+        keyholders:
+          Y: 2764
     doors:
       Black Side Panels: 2427
       Brown Side Panels: 2428
@@ -3142,6 +3187,9 @@ maps:
       Control Center Entrance:
         panels:
           ZERO: 2455
+      Main Area:
+        keyholders:
+          K: 2768
       Mastery:
         masteries:
           MASTERY: 2456
@@ -3346,6 +3394,8 @@ maps:
           WAYS: 2621
           WHILE: 2613
           ZOO: 2615
+        keyholders:
+          I: 2775
       Middle Room:
         panels:
           FELLOW: 2624
@@ -3393,6 +3443,12 @@ maps:
           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
@@ -3638,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
@@ -3783,4 +3839,61 @@ endings:
   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
@@ -109,6 +109,7 @@ doors {
   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"
@@ -132,6 +133,7 @@ doors {
   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"
@@ -30,18 +30,22 @@ panels {
 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"
@@ -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
@@ -205,6 +210,11 @@ connections {
   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" }
@@ -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" }
 }
@@ -1540,3 +1555,316 @@ 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
+}
@@ -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,6 +295,7 @@ 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"
@@ -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"
@@ -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,6 +815,7 @@ 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"
@@ -829,6 +853,7 @@ 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"
@@ -866,16 +891,12 @@ doors {
 }
 doors {
   name: "White Hallway From Entry"
-  # TODO: This should be combined with the corresponding door in the_entry, at
-  # least when connections are not shuffled.
   type: CONTROL_CENTER_COLOR
   receivers: "Components/Doors/Halls/froom_6"
   control_center_color: "white"
 }
 doors {
   name: "Purple Hallway From Great"
-  # TODO: This should be combined with the corresponding door in the_great, at
-  # least when connections are not shuffled.
   type: CONTROL_CENTER_COLOR
   receivers: "Components/Doors/Halls/froom_7"
   control_center_color: "purple"
@@ -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"
@@ -1389,7 +1381,7 @@ 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"
@@ -1398,6 +1390,23 @@ doors {
   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 {
@@ -1414,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"
@@ -1456,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 {
@@ -1545,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"
@@ -1711,6 +1722,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"
@@ -1734,6 +1746,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"
@@ -1772,6 +1785,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"
@@ -1785,6 +1799,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"
@@ -1797,6 +1812,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"
@@ -1833,6 +1849,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"
@@ -1868,6 +1885,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"
@@ -1887,6 +1905,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"
@@ -1899,6 +1918,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"
@@ -1938,6 +1958,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"
@@ -2039,6 +2060,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"
@@ -2051,12 +2073,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"
@@ -2118,6 +2145,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"
@@ -2125,6 +2153,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"
@@ -2144,6 +2173,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"
@@ -2237,3 +2267,30 @@ doors {
   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,5 +1,5 @@
 name: "Red Color Door"
-display_name: "Southwest Area"
+panel_display_name: "Southwest Area"
 panels {
   name: "Left"
   path: "Panels/Halls/wb_1"
@@ -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"
@@ -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,6 +1,7 @@
 doors {
   name: "Front Door"
   type: STANDARD
+  receivers: "Components/Doors/Front N Tree"
   panels { room: "Outside" name: "THIS" }
   location_room: "Outside"
 }
@@ -37,7 +38,8 @@ doors {
 }
 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"
@@ -53,6 +53,7 @@ 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,5 +1,4 @@
 name: "Purple Room"
-display_name: "Purple Room"
 panels {
   name: "FISH"
   path: "Panels/Hallway/panel_7"
@@ -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"
@@ -44,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"
@@ -55,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"
@@ -105,6 +105,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" }
 }
@@ -121,7 +126,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"
@@ -187,10 +192,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"
@@ -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,5 +1,5 @@
 name: "Starting Room"
-display_name: "Starting Room"
+panel_display_name: "Starting Room"
 panels {
   name: "HI"
   path: "Panels/Entry/entry_proxying_1"
@@ -24,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,7 +1,7 @@
 # The Gallery is interesting because there's so many cross-map requirements.
 doors {
   name: "Darkroom Painting"
-  type: ITEM_ONLY
+  type: GALLERY_PAINTING
   #move_paintings { room: "Main Area" name: "DARKROOM" }
   receivers: "Components/Paintings/darkroom/teleportListener"
   panels { map: "the_darkroom" room: "First Room" name: "BISON" }
@@ -27,14 +27,14 @@ doors {
 }
 doors {
   name: "Butterfly Painting"
-  type: ITEM_ONLY
+  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
+  type: GALLERY_PAINTING
   #move_paintings { room: "Main Area" name: "BETWEEN" }
   receivers: "Components/Paintings/between/teleportListener"
   panels { map: "the_between" room: "Main Area" name: "SUN" }
@@ -70,14 +70,14 @@ doors {
 }
 doors {
   name: "Entry Painting"
-  type: ITEM_ONLY
+  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
+  type: GALLERY_PAINTING
   #move_paintings { room: "Main Area" name: "WISE" }
   receivers: "Components/Paintings/triangle/teleportListener"
   panels { map: "the_wise" room: "Entry" name: "INK" }
@@ -105,7 +105,7 @@ doors {
 }
 doors {
   name: "Tree Painting"
-  type: ITEM_ONLY
+  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" }
@@ -142,35 +142,35 @@ doors {
 }
 doors {
   name: "Unyielding Painting"
-  type: ITEM_ONLY
+  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
+  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
+  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
+  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
+  type: GALLERY_PAINTING
   #move_paintings { room: "Main Area" name: "WONDROUS" }
   receivers: "Components/Paintings/Endings/window/teleportListener"
   panels { map: "the_wondrous" room: "Entry" name: "WONDER" }
@@ -187,42 +187,42 @@ doors {
 }
 doors {
   name: "Rainbow Painting"
-  type: ITEM_ONLY
+  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
+  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
+  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
+  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
+  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
+  type: GALLERY_PAINTING
   #move_paintings { room: "Main Area" name: "ANCIENT" }
   receivers: "Components/Paintings/Endings/cubes/teleportListener"
   rooms { map: "the_ancient" name: "Outside" }
@@ -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"
@@ -19,6 +19,7 @@ doors {
 doors {
   name: "Double Letters"
   type: EVENT
-  switches: "double_letters"
-  # TODO: once again, not sure whether this is how it should work
+  receivers: "Panels/panel_3/teleportListener"
+  receivers: "Components/Paintings/omrt/teleportListener"
+  double_letters: true
 }
@@ -1,5 +1,4 @@
 name: "Inside"
-display_name: "Inside"
 panels {
   name: "REMEMBER"
   path: "Panels/panel_3"
@@ -1,5 +1,4 @@
 name: "Outside"
-display_name: "Outside"
 panels {
   name: "FOOT"
   path: "Panels/panel_1"
@@ -49,6 +49,7 @@ doors {
   type: LOCATION_ONLY
   panels { room: "West Side" name: "ERASE" }
   location_room: "West Side"
+  location_name: "ERASE"
 }
 doors {
   name: "Control Center Purple Door"
@@ -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 {
@@ -142,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"
@@ -225,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"
@@ -391,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"
@@ -418,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"
@@ -466,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"
@@ -493,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,5 +1,5 @@
 name: "Question Room How"
-display_name: "Question Room"
+panel_display_name: "Question Room"
 panels {
   name: "QUESTION"
   path: "Panels/Questions/question_3"
@@ -12,6 +12,7 @@ panels {
   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" }
-  proxies { answer: "what" path: "Panels/Question Proxies/question_4_proxied5" }
-  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"
@@ -12,6 +12,7 @@ panels {
   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"
@@ -12,4 +12,5 @@ panels {
   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,5 +1,5 @@
 name: "Under Question Room"
-display_name: "Question Room"
+panel_display_name: "Question Room"
 panels {
   name: "QUESTION"
   path: "Panels/General/question_1"
@@ -8,4 +8,5 @@ panels {
   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"
@@ -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"
@@ -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,20 +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" }
   #receivers: "Components/Paintings/owl/teleportListener"
-  doors { name: "Orange Owl" }
-  doors { name: "Black Owl" }
-  doors { name: "Blue Owl" }
-  doors { name: "White Owl" }
-  doors { name: "Sky Owl" }
+  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"
@@ -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,5 +1,4 @@
 name: "Main Area"
-display_name: "Parthenon"
 panels {
   name: "XERXES"
   path: "Panels/Main/panel_1"
@@ -1,6 +1,6 @@
 name: "U Keyholder"
-display_name: "Parthenon"
 keyholders {
   name: "U"
   path: "Components/KeyHolders/keyHolderU"
+  key: "u"
 }
@@ -22,6 +22,7 @@ doors {
   panels { room: "Obverse Side" name: "CUT" }
   panels { room: "Obverse Side" name: "FUN" }
   location_room: "Obverse Side"
+  location_name: "Obverse Side Room"
 }
 doors {
   name: "Giant P"
@@ -1,5 +1,4 @@
 name: "Control Center Entrance"
-display_name: "Partial"
 panels {
   name: "RETURN"
   path: "Panels/Control/panel_10"
@@ -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"
@@ -41,6 +41,7 @@ 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"
@@ -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"
@@ -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"
@@ -1,5 +1,4 @@
 name: "S2 Area"
-display_name: "Sturdy"
 panels {
   name: "COLORS"
   path: "Panels/Rainbow/panel_1"
@@ -1,5 +1,4 @@
 name: "Ending"
-display_name: "Sun Temple"
 endings {
   name: "PURPLE"
   path: "Components/purple_ending"
@@ -1,5 +1,4 @@
 name: "Entrance"
-display_name: "Sun Temple"
 panels {
   name: "SUN"
   path: "Panels/Main/panel_1"
@@ -1,5 +1,4 @@
 name: "Mastery"
-display_name: "Sun Temple"
 masteries {
   name: "MASTERY"
   path: "Components/Collectables/collectable"
@@ -1,5 +1,4 @@
 name: "Temple"
-display_name: "Sun Temple"
 panels {
   name: "DELAY"
   path: "Panels/Main/panel_2"
@@ -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)" }
@@ -107,6 +107,7 @@ panels {
 keyholders {
   name: "Y"
   path: "Components/KeyHolders/keyHolderY"
+  key: "y"
 }
 ports {
   name: "GREAT"
@@ -2,4 +2,5 @@ name: "Main Area"
 keyholders {
   name: "K"
   path: "Components/KeyHolders/keyHolderK"
+  key: "k"
 }
@@ -50,4 +50,5 @@ doors {
   panels { room: "Dead End Room" name: "DEAD" }
   panels { room: "Dead End Room" name: "END" }
   location_room: "Loose Strings Room"
+  location_name: "Gravestone"
 }
@@ -38,4 +38,5 @@ doors {
   panels { room: "Main Area" name: "SMALL (3)" }
   panels { room: "Main Area" name: "SPRINKLE" }
   location_room: "Main Area"
+  location_name: "Gravestone"
 }
@@ -21,7 +21,8 @@ doors {
 doors {
   name: "Cyan Doors"
   type: EVENT
-  switches: "double_letters"
+  receivers: "Components/Doors/entry_12"
+  double_letters: true
 }
 doors {
   name: "Sun Temple Entrance"
@@ -66,7 +67,10 @@ 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"
@@ -212,6 +212,7 @@ panels {
 keyholders {
   name: "I"
   path: "Components/KeyHolders/keyHolderL"
+  key: "i"
 }
 ports {
   name: "GREAT"
@@ -159,6 +159,5 @@ panels {
   clue: "color"
   answer: "orange"
   symbols: EXAMPLE
-  # TODO: This is hidden in-game until double letters are unlocked AND "orange"
-  # is entered in the control center.
+  required_door { name: "Control Center Orange Door" }
 }
@@ -2,4 +2,5 @@ name: "V Keyholder"
 keyholders {
   name: "V"
   path: "Components/KeyHolders/keyHolderV"
+  key: "v"
 }
@@ -2,4 +2,5 @@ name: "W Keyholder"
 keyholders {
   name: "W"
   path: "Components/KeyHolders/keyHolderW"
+  key: "w"
 }
@@ -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" }
 }
@@ -4,6 +4,7 @@ panels {
   path: "Panels/panel_3"
   clue: "shrink"
   answer: "shrink"
+  display_name: "SHRINK (2)"
 }
 panels {
   name: "IRE"
@@ -4,4 +4,5 @@ panels {
   path: "Panels/panel_2"
   clue: "shrink"
   answer: "shrink"
+  display_name: "SHRINK (1)"
 }
@@ -0,0 +1,50 @@
+version: 5
+# 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,8 @@ message Connection {
     uint64 painting = 5;
     ProxyIdentifier panel = 6;
   }
+
+  optional bool roof_access = 7;
 }
 
 message Door {
@@ -100,13 +125,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 {
@@ -124,6 +152,8 @@ message PanelData {
 
   optional uint64 required_door = 9;
   optional uint64 required_room = 11;
+
+  optional string display_name = 12;
 }
 
 message PaintingData {
@@ -157,10 +187,12 @@ message Port {
 
 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 {
@@ -198,6 +230,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;
@@ -215,7 +248,24 @@ 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;
@@ -227,5 +277,7 @@ message AllObjects {
   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,14 @@ 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;
 }
 
 message HumanConnections {
@@ -82,14 +90,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 {
@@ -108,6 +121,8 @@ message HumanPanel {
 
   optional DoorIdentifier required_door = 7;
   optional RoomIdentifier required_room = 8;
+
+  optional string display_name = 9;
 }
 
 message HumanPainting {
@@ -138,6 +153,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 {
@@ -161,6 +183,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;
@@ -175,10 +201,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 {
@@ -190,4 +241,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_ = 1;
 
   IdMappings id_mappings_;
+  IdMappings output_;
 };
 
 }  // namespace
@@ -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;
   }
 
@@ -284,6 +295,10 @@ class DataPacker {
 
     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 =
@@ -380,7 +395,7 @@ class DataPacker {
       door.add_doors(
           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));
     }
@@ -394,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,
@@ -445,6 +468,11 @@ 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());
+    }
+
     container_.AddConnection(f_connection);
     if (!human_connection.oneway()) {
       container_.AddConnection(r_connection);
@@ -528,6 +556,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());
 
@@ -552,6 +637,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);
+        }
       }
     }
 
@@ -569,6 +662,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,10 +127,10 @@ 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];
@@ -155,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,
@@ -372,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()) {
@@ -388,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()) {
@@ -410,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);
@@ -429,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
@@ -441,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
@@ -458,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,14 +98,34 @@ 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 {
   std::map<std::string, MapInfo> maps;
   std::map<RoomIdentifier, RoomInfo, RoomIdentifierLess> rooms;
@@ -107,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,291 +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;
+      }
+    }
+
+    if (!panel_info.has_id) {
+      std::cout << "Panel " << panel_identifier.ShortDebugString()
+                << " is missing an AP ID." << 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;
+          }
+        }
+      }
     }
   }
-}
 
-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;
+  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;
+
+      for (const DoorIdentifier& door_identifier :
+           keyholder_info.doors_referenced_by) {
+        std::cout << "    DOOR " << door_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 DoorIdentifier& door_identifier :
-         keyholder_info.doors_referenced_by) {
-      std::cout << "    DOOR " << door_identifier.ShortDebugString()
+    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 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 : 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;
     }
-  } 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 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;
+
+      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;
 
-  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 (!ending_info.has_id) {
+      std::cout << "Ending " << ending_name << " is missing an AP ID."
+                << std::endl;
+    }
+  }
+
+  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;
+      }
     }
   }
-}
 
-void ValidateEnding(const std::string& ending_name,
-                    const EndingInfo& ending_info) {
-  if (ending_info.defined_in.empty()) {
-    std::cout << "Ending " << ending_name
-              << " has no definition, but was referenced:" << std::endl;
+  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;
+    }
 
-    for (const DoorIdentifier& door_identifier :
-         ending_info.doors_referenced_by) {
-      std::cout << "    DOOR " << door_identifier.ShortDebugString()
+    if (!prog_info.has_id) {
+      std::cout << "Progressive \"" << prog_name << "\" is missing an AP ID."
                 << 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;
+  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) {
-  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);
-  }
+  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"