108 files changed, 6065 insertions, 390 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,29 @@
+# lingo2-archipelago Apworld Releases
+
+## 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,13 +62,29 @@ 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):
@@ -65,14 +92,23 @@ class Lingo2World(World):
 
     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,13 +1,57 @@
 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.
@@ -17,6 +61,27 @@ class KeyholderSanity(Toggle):
     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
@@ -28,7 +93,23 @@ class DaedalusRoofAccess(Toggle):
 
 
 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
@@ -45,9 +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,7 +1,10 @@
+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
+from .options import VictoryCondition, ShuffleLetters, CyanDoorBehavior
 
 if TYPE_CHECKING:
     from . import Lingo2World
@@ -14,10 +17,6 @@ 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
 
 
@@ -25,25 +24,38 @@ 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:
@@ -55,15 +67,78 @@ class AccessRequirements:
         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"):
+                sub_reqs.letters = {l: v for l, v in sub_reqs.letters.items() if self.letters.get(l, 0) < v}
+
+            self.or_logic = []
+            for disjunction in old_or_logic:
+                new_disjunction = []
+                for ssr in disjunction:
+                    remove_redundant(ssr)
+                    if not ssr.is_empty():
+                        new_disjunction.append(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 __repr__(self):
         parts = []
         if len(self.items) > 0:
@@ -72,13 +147,17 @@ class AccessRequirements:
             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):
@@ -86,6 +165,12 @@ class PlayerLocation(NamedTuple):
     reqs: AccessRequirements
 
 
+class LetterBehavior(IntEnum):
+    VANILLA = auto()
+    ITEM = auto()
+    UNLOCKED = auto()
+
+
 class Lingo2PlayerLogic:
     world: "Lingo2World"
 
@@ -100,6 +185,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 = {}
@@ -109,6 +196,7 @@ 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:
@@ -116,16 +204,60 @@ class Lingo2PlayerLogic:
                     self.item_by_door[progressive.doors[i]] = (progressive.name, i + 1)
                     self.real_items.append(progressive.name)
 
+        for door_group in world.static_logic.objects.door_groups:
+            if door_group.type == data_pb2.DoorGroupType.CONNECTOR:
+                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:
-                if door.id in self.item_by_door:
+            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
 
-                door_item_name = self.world.static_logic.get_door_item_name(door)
-                self.item_by_door[door.id] = (door_item_name, 1)
-                self.real_items.append(door_item_name)
+                for door in 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]:
@@ -135,14 +267,20 @@ 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,
@@ -170,11 +308,17 @@ class Lingo2PlayerLogic:
             for keyholder in world.static_logic.objects.keyholders:
                 if keyholder.HasField("key"):
                     reqs = AccessRequirements()
-                    reqs.letters[keyholder.key.upper()] = 1
+
+                    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:
@@ -194,28 +338,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)
@@ -238,31 +392,46 @@ class Lingo2PlayerLogic:
         door = self.world.static_logic.objects.doors[door_id]
         reqs = AccessRequirements()
 
-        # TODO: lavender_cubes, endings
         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:
-            # TODO: When letter shuffle is on, change this to require any double letter instead.
-            reqs.rooms.add("The Repetitive - Main Room")
+            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]
@@ -273,12 +442,18 @@ class Lingo2PlayerLogic:
 
         for ending_id in door.endings:
             ending = self.world.static_logic.objects.endings[ending_id]
-            reqs.items.add(f"{ending.name.capitalize()} Ending (Achieved)")
+
+            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
@@ -296,3 +471,40 @@ class Lingo2PlayerLogic:
             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,18 @@ 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()
+        if new_region.name in reqs.rooms:
+            reqs.rooms.remove(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,17 +31,23 @@ 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")
 
@@ -82,14 +94,18 @@ def create_regions(world: "Lingo2World"):
             else:
                 connection_name = f"{connection_name} (via panel {panel.name})"
 
+        reqs.simplify()
+
         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)
+            connection.access_rule = make_location_lambda(reqs, world, regions)
 
             regions[from_region].exits.append(connection)
             connection.connect(regions[to_region])
 
             for region in reqs.rooms:
+                if region == from_region:
+                    continue
                 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,14 +1,15 @@
 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
 
@@ -18,18 +19,45 @@ def lingo2_can_satisfy_requirements(state: CollectionState, reqs: AccessRequirem
     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()
@@ -29,31 +38,49 @@ class Lingo2StaticLogic:
             letter_name = f"{letter.key.upper()}{'2' if letter.level2 else '1'}"
             location_name = f"{self.get_room_object_map_name(letter)} - {letter_name}"
             self.location_id_to_name[letter.ap_id] = location_name
+            self.location_name_groups.setdefault("Letters", []).append(location_name)
 
             if not letter.level2:
-                self.item_id_to_name[letter.ap_id] = letter_name
+                self.item_id_to_name[letter.ap_id] = letter.key.upper()
+                self.item_name_groups.setdefault("Letters", []).append(letter.key.upper())
 
         for mastery in self.objects.masteries:
             location_name = f"{self.get_room_object_map_name(mastery)} - Mastery"
             self.location_id_to_name[mastery.ap_id] = location_name
+            self.location_name_groups.setdefault("Masteries", []).append(location_name)
 
         for ending in self.objects.endings:
             location_name = f"{self.get_room_object_map_name(ending)} - {ending.name.title()} Ending"
             self.location_id_to_name[ending.ap_id] = location_name
+            self.location_name_groups.setdefault("Endings", []).append(location_name)
 
         for progressive in self.objects.progressives:
             self.item_id_to_name[progressive.ap_id] = progressive.name
 
+        for door_group in self.objects.door_groups:
+            self.item_id_to_name[door_group.ap_id] = door_group.name
+
         for keyholder in self.objects.keyholders:
             if keyholder.HasField("key"):
                 location_name = f"{self.get_room_object_location_prefix(keyholder)} - {keyholder.key.upper()} Keyholder"
                 self.location_id_to_name[keyholder.ap_id] = location_name
+                self.location_name_groups.setdefault("Keyholders", []).append(location_name)
+
+        self.item_id_to_name[self.objects.special_ids["A Job Well Done"]] = "A Job Well Done"
 
-        self.item_id_to_name[self.objects.special_ids["Nothing"]] = "Nothing"
+        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()}
 
+        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}"
 
@@ -77,7 +104,7 @@ class Lingo2StaticLogic:
         if door.type != data_pb2.DoorType.STANDARD:
             return None
 
-        if len(door.keyholders) > 0 or len(door.endings) > 0:
+        if len(door.keyholders) > 0 or len(door.endings) > 0 or door.HasField("complete_at"):
             return None
 
         if len(door.panels) > 4:
@@ -113,7 +140,7 @@ class Lingo2StaticLogic:
                        for panel_id in door.panels]
         panel_names.sort()
 
-        return f"{map_part} - {", ".join(panel_names)}"
+        return map_part + " - " + ", ".join(panel_names)
 
     def get_door_location_name_by_id(self, door_id: int) -> str:
         door = self.objects.doors[door_id]
@@ -137,3 +164,6 @@ class Lingo2StaticLogic:
             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 = 4
@@ -41,9 +41,14 @@ signal connect_status
 signal client_connected(slot_data)
 signal item_received(item_id, index, player, flags, amount)
 signal message_received(message)
+signal location_scout_received(item_id, location_id, player, flags)
 
 
 func _init():
+        set_process_mode(Node.PROCESS_MODE_ALWAYS)
+
+        _ws.inbound_buffer_size = 8388608
+
         global._print("Instantiated APClient")
 
         # Read AP datapackages from file, if there are any
@@ -222,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")
@@ -255,6 +260,16 @@ func _process(_delta):
                                         elif cmd == "PrintJSON":
                                                 emit_signal("message_received", message)
 
+                                        elif cmd == "LocationInfo":
+                                                for loc in message["locations"]:
+                                                        emit_signal(
+                                                                "location_scout_received",
+                                                                int(loc["item"]),
+                                                                int(loc["location"]),
+                                                                int(loc["player"]),
+                                                                int(loc["flags"])
+                                                        )
+
                 elif state == WebSocketPeer.STATE_CLOSED:
                         if _has_connected:
                                 _closed()
@@ -296,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
 
@@ -390,6 +405,10 @@ func completedGoal():
         sendMessage([{"cmd": "StatusUpdate", "status": 30}])  # CLIENT_GOAL
 
 
+func scoutLocations(loc_ids):
+        sendMessage([{"cmd": "LocationScouts", "locations": loc_ids}])
+
+
 func hasItem(item_id):
         return _received_items.has(item_id)
 
@@ -0,0 +1,16 @@
+extends "res://scripts/nodes/collectable.gd"
+
+
+func pickedUp():
+        if unlock_type == "key":
+                var ap = global.get_node("Archipelago")
+                if ap.get_letter_behavior(unlock_key, level == 2) == ap.kLETTER_BEHAVIOR_VANILLA:
+                        ap.keyboard.collect_local_letter(unlock_key, level)
+                else:
+                        ap.keyboard.update_unlocks()
+
+        super.pickedUp()
+
+
+func setScoutedText(text):
+        get_node("MeshInstance3D").mesh.text = text.replace(" ", "\n")
@@ -5,14 +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()
@@ -54,6 +82,28 @@ func load(data_bytes):
         for progressive in objects.get_progressives():
                 progressive_id_by_ap_id[progressive.get_ap_id()] = progressive.get_id()
 
+        for letter in objects.get_letters():
+                letter_id_by_ap_id[letter.get_ap_id()] = letter.get_id()
+
+        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):
@@ -63,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,8 +1,9 @@
 extends Node
 
-const my_version = "0.1.0"
+const MOD_VERSION = 4
 
 var SCRIPT_client
+var SCRIPT_keyboard
 var SCRIPT_locationListener
 var SCRIPT_uuid
 var SCRIPT_victoryListener
@@ -13,15 +14,42 @@ var ap_pass = ""
 var connection_history = []
 
 var client
+var keyboard
 
 var _localdata_file = ""
 var _last_new_item = -1
 var _batch_locations = false
 var _held_locations = []
+var _held_location_scouts = []
+var _location_scouts = {}
 var _item_locks = {}
-
+var _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
@@ -59,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.
@@ -99,6 +131,12 @@ func saveLocaldata():
 
 func connectToServer():
         _last_new_item = -1
+        _batch_locations = false
+        _held_locations = []
+        _held_location_scouts = []
+        _location_scouts = {}
+        _letters_setup = false
+        _held_letters = {}
 
         client.connectToServer(ap_server, ap_user, ap_pass)
 
@@ -121,29 +159,37 @@ func _process_item(item, index, from, flags, amount):
                 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)
-        var prog_id = null
 
-        if door_id == null:
-                prog_id = gamedata.progressive_id_by_ap_id.get(item, null)
-                if prog_id != null:
-                        var progressive = gamedata.objects.get_progressives()[prog_id]
-                        if progressive.get_doors().size() >= amount:
-                                door_id = progressive.get_doors()[amount - 1]
-
-        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:
@@ -151,14 +197,14 @@ func _process_item(item, index, from, flags, amount):
                 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 and door_id != null:
-                        var door = gamedata.objects.get_doors()[door_id]
+                if prog_id != null:
+                        var door = gamedata.objects.get_doors()[prog_id]
                         full_item_name = "%s (%s)" % [item_name, door.get_name()]
 
                 var message
@@ -169,6 +215,9 @@ func _process_item(item, index, from, flags, amount):
                                 "Received [color=%s]%s[/color] from %s" % [item_color, full_item_name, player_name]
                         )
 
+                if gamedata.anti_trap_ids.has(item):
+                        keyboard.block_letter(gamedata.anti_trap_ids[item])
+
                 global._print(message)
 
                 global.get_node("Messages").showMessage(message)
@@ -186,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"]):
@@ -260,8 +309,35 @@ 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):
@@ -289,10 +365,19 @@ func _client_connected(slot_data):
                         _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 = {}
 
@@ -309,6 +394,47 @@ func _client_connected(slot_data):
                                 var door = gamedata.objects.get_doors()[progressive.get_doors()[i]]
                                 _item_locks[door.get_id()] = [progressive.get_ap_id(), i + 1]
 
+                for door_group in gamedata.objects.get_door_groups():
+                        if (
+                                door_group.get_type() == gamedata.SCRIPT_proto.DoorGroupType.CONNECTOR
+                                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")
 
 
@@ -323,10 +449,28 @@ func send_location(loc_id):
                 client.sendLocation(loc_id)
 
 
+func scout_location(loc_id):
+        if _location_scouts.has(loc_id):
+                return _location_scouts.get(loc_id)
+
+        if _batch_locations:
+                _held_location_scouts.append(loc_id)
+        else:
+                client.scoutLocation(loc_id)
+
+        return null
+
+
 func stop_batching_locations():
         _batch_locations = false
-        client.sendLocations(_held_locations)
-        _held_locations.clear()
+
+        if not _held_locations.is_empty():
+                client.sendLocations(_held_locations)
+                _held_locations.clear()
+
+        if not _held_location_scouts.is_empty():
+                client.scoutLocations(_held_location_scouts)
+                _held_location_scouts.clear()
 
 
 func colorForItemType(flags):
@@ -342,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()
@@ -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()
@@ -16,6 +16,8 @@ const kEndingNameByVictoryValue = {
         12: "WHITE",
 }
 
+signal evaluate_solvability
+
 
 func _ready():
         var khl_script = load("res://scripts/nodes/keyHolderListener.gd")
@@ -34,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()
@@ -66,6 +71,12 @@ func _ready():
 
                         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.
@@ -81,6 +92,26 @@ 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()]
@@ -139,7 +170,7 @@ func _ready():
                         get_parent().add_child.call_deferred(locationListener)
 
         # Block off roof access in Daedalus.
-        if global.map == "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)
@@ -171,6 +202,29 @@ func _ready():
                 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
@@ -2,4 +2,8 @@ extends "res://scripts/nodes/saver.gd"
 
 
 func levelLoaded():
-        reload.call_deferred()
+        if type == "keyholders":
+                var ap = global.get_node("Archipelago")
+                ap.keyboard.load_keyholders.call_deferred(global.map)
+        else:
+                reload.call_deferred()
@@ -22,14 +22,8 @@ func _ready():
                 var ap_instance = ap_script.new()
                 ap_instance.name = "Archipelago"
 
-                #apclient_instance.SCRIPT_doorControl = load("user://maps/Archipelago/doorControl.gd")
-                #apclient_instance.SCRIPT_effects = load("user://maps/Archipelago/effects.gd")
-                #apclient_instance.SCRIPT_location = load("user://maps/Archipelago/location.gd")
-                #apclient_instance.SCRIPT_mypainting = load("user://maps/Archipelago/mypainting.gd")
-                #apclient_instance.SCRIPT_panel = load("user://maps/Archipelago/panel.gd")
-                #apclient_instance.SCRIPT_textclient = load("user://maps/Archipelago/textclient.gd")
-
                 ap_instance.SCRIPT_client = load("user://maps/Archipelago/client.gd")
+                ap_instance.SCRIPT_keyboard = load("user://maps/Archipelago/keyboard.gd")
                 ap_instance.SCRIPT_locationListener = load("user://maps/Archipelago/locationListener.gd")
                 ap_instance.SCRIPT_uuid = load("user://maps/Archipelago/vendor/uuid.gd")
                 ap_instance.SCRIPT_victoryListener = load("user://maps/Archipelago/victoryListener.gd")
@@ -38,12 +32,22 @@ func _ready():
 
                 # Let's also inject any scripts we need to inject now.
                 installScriptExtension(ResourceLoader.load("user://maps/Archipelago/animationListener.gd"))
+                installScriptExtension(ResourceLoader.load("user://maps/Archipelago/collectable.gd"))
                 installScriptExtension(ResourceLoader.load("user://maps/Archipelago/door.gd"))
+                installScriptExtension(ResourceLoader.load("user://maps/Archipelago/keyHolder.gd"))
+                installScriptExtension(ResourceLoader.load("user://maps/Archipelago/keyHolderChecker.gd"))
+                installScriptExtension(
+                        ResourceLoader.load("user://maps/Archipelago/keyHolderResetterListener.gd")
+                )
                 installScriptExtension(ResourceLoader.load("user://maps/Archipelago/painting.gd"))
+                installScriptExtension(ResourceLoader.load("user://maps/Archipelago/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")
@@ -66,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)
@@ -89,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):
@@ -125,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]
@@ -141,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")
@@ -180,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")
@@ -191,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()
@@ -9,6 +9,17 @@ func _ready():
                 get_tree().get_root().get_node("scene").get_path_to(self).get_concatenated_names()
         )
 
+        if (
+                global.map == "daedalus"
+                and (
+                        node_path == "Components/Triggers/teleportListenerConnections"
+                        or node_path == "Components/Triggers/teleportListenerConnections2"
+                )
+        ):
+                # Effectively disable these.
+                teleport_point = target_path.position
+                return
+
         var gamedata = global.get_node("Gamedata")
         var door_id = gamedata.get_door_for_map_node_path(global.map, node_path)
         if door_id != null:
@@ -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
@@ -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 {
@@ -1435,7 +1473,6 @@ connections {
       name: "GREAT"
     }
   }
-  door { map: "the_great" name: "Daedalus Entrance" }
   oneway: true
 }
 connections {
@@ -1454,6 +1491,7 @@ connections {
     }
   }
   oneway: true
+  bypass_target_door: true
 }
 connections {
   from {
@@ -1749,12 +1787,13 @@ connections {
     }
   }
   oneway: true
+  bypass_target_door: true
 }
 connections {
   from {
     port {
       map: "the_bearer"
-      room: "Back Area"
+      room: "Tree Entrance"
       name: "TREE"
     }
   }
@@ -1831,7 +1870,6 @@ connections {
   }
 }
 connections {
-  # Two one-way connections because the door only blocks one direction.
   from {
     port {
       map: "the_great"
@@ -1848,6 +1886,7 @@ connections {
   }
 }
 connections {
+  # Two one-way connections because the door only blocks one direction.
   from {
     port {
       map: "the_unkempt"
@@ -1880,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"
+  }
+}
@@ -897,7 +897,6 @@ maps:
           REDACTED: 2274
           STRINGS: 2205
           WINDS: 2204
-          "[REDACTED]": 2207
       Yellow Color Door:
         panels:
           Paintings: 2210
@@ -1045,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
@@ -1125,6 +1125,7 @@ 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
@@ -1217,7 +1218,6 @@ maps:
         panels:
           THIS: 45
     doors:
-      End Door: 42
       Front Door: 41
       Lavender Cubes: 43
   the_bearer:
@@ -1298,7 +1298,6 @@ maps:
       Control Center Brown Door: 49
       Exit Door: 47
       Overlook Door: 46
-      Q2 Door: 48
   the_between:
     rooms:
       Control Center Side:
@@ -1487,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:
@@ -1518,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:
@@ -1720,8 +1716,6 @@ maps:
         panels:
           CORN: 393
           DICE: 392
-          HOLE: 390
-          RABBIT: 389
           WREATH: 391
     doors:
       Blue Alcove Entrance: 297
@@ -1733,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
@@ -1751,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
@@ -2092,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
@@ -2337,7 +2329,6 @@ maps:
     doors:
       Left Room Puzzles: 763
       Main Room Door: 2750
-      Main Room Puzzles: 765
       Right Room Puzzles: 764
   the_orb:
     rooms:
@@ -2398,11 +2389,6 @@ maps:
         panels:
           CRUSH: 845
           RAY: 846
-      R2C2.5 Bottom:
-        panels:
-          BLACK: 849
-          FIGMENT: 848
-          FIZZLE: 847
       R2C3 Bottom:
         panels:
           BLACK: 2747
@@ -2666,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
@@ -2773,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
@@ -2782,7 +2771,6 @@ maps:
       Lime Puzzles: 1031
       Magenta Door: 1029
       Magenta Puzzles: 1033
-      Plaza Entrance: 1024
       Yellow Door: 1030
       Yellow Puzzles: 1034
   the_revitalized:
@@ -3148,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:
@@ -3713,7 +3694,6 @@ maps:
           HEALTH: 1428
     doors:
       Bearer Entrance: 1259
-      Black Alcove: 2265
       Brown Alcove: 1255
       Digital Entrance: 1257
       East Room 1: 2740
@@ -3859,7 +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
-  Progressive Symbolic Entrance: 2752
+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
@@ -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
@@ -1857,3 +1862,9 @@ connections {
   oneway: true
   roof_access: true
 }
+connections {
+  from_room: "Roof"
+  to_room: "F Keyholder"
+  oneway: true
+  roof_access: true
+}
@@ -195,8 +195,8 @@ doors {
 }
 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"
 }
@@ -493,7 +493,6 @@ doors {
   panels { room: "Outside House" name: "WALLS" }
   panels { room: "Outside House" name: "LOCK" }
   location_room: "Outside House"
-  location_name: "North Purple Vestibules"
 }
 doors {
   name: "Purple NW Vestibule"
@@ -892,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"
@@ -1080,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"
@@ -1088,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"
@@ -1210,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"
@@ -1921,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"
@@ -2113,8 +2078,12 @@ doors {
 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"
@@ -2184,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"
@@ -2303,3 +2273,24 @@ doors {
   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,6 +1,5 @@
 name: "Wonderland"
 panel_display_name: "Northwest Area"
-# TODO: There's a warp from The Entry into here.
 panels {
   name: "APRIL"
   path: "Panels/Wonderland/wonderland_1"
@@ -38,7 +38,8 @@ doors {
 }
 doors {
   name: "Lavender Cubes"
-  type: STANDARD
+  type: LOCATION_ONLY
   panels { room: "Inside" name: "COLOR" }
   location_room: "Inside"
+  location_name: "COLOR"
 }
@@ -5,5 +5,4 @@ panels {
   clue: "color"
   answer: "lavender"
   symbols: EXAMPLE
-  # TODO: how does this connect to the "lavender_cubes" switch?
 }
@@ -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" }
+}
@@ -7,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"
@@ -0,0 +1,6 @@
+name: "Tree Entrance"
+ports {
+  name: "TREE"
+  path: "Components/Warps/worldport3"
+  orientation: "north"
+}
@@ -119,7 +119,11 @@ doors {
 }
 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"
+  }
 }
@@ -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" }
+}
@@ -2,8 +2,8 @@
 doors {
   name: "Double Letter Panel Blockers"
   type: EVENT
-  #receivers: "Panels/Room 1/panel_3/visibilityListener"
-  #receivers: "Panels/Room 2/panel_3/visibilityListener"
+  receivers: "Panels/Room 1/panel_3/visibilityListener"
+  receivers: "Panels/Room 2/panel_3/visibilityListener"
   double_letters: true
 }
 doors {
@@ -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"
+}
@@ -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" }
-}
@@ -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" }
-}
@@ -192,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" }
+}
@@ -137,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"
@@ -193,7 +195,7 @@ doors {
   location_room: "Starting Room"
 }
 doors {
-  name: "Repetitive Entrance"
+  name: "Starting Room West Wall North Door"
   type: ITEM_ONLY
   receivers: "Components/Doors/Entry/entry_proxied_9"
   double_letters: true
@@ -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
+}
@@ -0,0 +1,6 @@
+name: "Liberated Entrance"
+ports {
+  name: "BLUE"
+  path: "worldport8"
+  orientation: "west"
+}
@@ -26,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"
+}
@@ -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,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" }
@@ -19,5 +19,7 @@ doors {
 doors {
   name: "Double Letters"
   type: EVENT
+  receivers: "Panels/panel_3/teleportListener"
+  receivers: "Components/Paintings/omrt/teleportListener"
   double_letters: true
 }
@@ -49,6 +49,7 @@ doors {
   type: LOCATION_ONLY
   panels { room: "West Side" name: "ERASE" }
   location_room: "West Side"
+  location_name: "ERASE"
 }
 doors {
   name: "Control Center Purple Door"
@@ -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 {
@@ -470,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"
@@ -497,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" }
+}
@@ -111,6 +111,7 @@ panels {
   answer: "high"
   symbols: SUN
   symbols: ZERO
+  required_door { name: "Cyan Doors" }
 }
 panels {
   name: "CURT"
@@ -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" }
 }
@@ -10,4 +10,5 @@ doors {
   panels { room: "Room" name: "INTO" }
   panels { room: "Room" name: "NOR" }
   location_room: "Room"
+  location_name: "Gravestone"
 }
@@ -10,10 +10,20 @@ connections {
 }
 connections {
   from_room: "R2C2 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: "Connected Area"
+  door { name: "Sky Owl" }
+}
+connections {
   from_room: "R2C3 Bottom"
   to_room: "Connected Area"
   oneway: true
@@ -45,6 +55,11 @@ connections {
 }
 connections {
   from_room: "Connected Area"
+  to_room: "R2C3 Bottom"
+  door { name: "Sky Owl" }
+}
+connections {
+  from_room: "Connected Area"
   to_room: "Magenta Hallway"
   door { name: "Control Center Magenta Door" }
 }
@@ -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"
@@ -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,12 +1,24 @@
 doors {
   name: "Double Letters"
   type: EVENT
+  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"
@@ -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,5 +1,4 @@
 name: "Anti Room"
-# Ignore the collectible. The mod should remove it and the back wall too.
 panels {
   name: "HA (1)"
   path: "Panels/Entry/panel_7"
@@ -38,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,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)" }
@@ -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,6 +21,7 @@ doors {
 doors {
   name: "Cyan Doors"
   type: EVENT
+  receivers: "Components/Doors/entry_12"
   double_letters: true
 }
 doors {
@@ -67,6 +68,7 @@ doors {
   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
 }
@@ -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" }
 }
@@ -499,5 +499,8 @@ doors {
 doors {
   name: "Cyan Doors"
   type: EVENT
+  receivers: "Components/Doors/entry_4"
+  receivers: "Panels/Miscellaneous/entry_2/teleportListener"
+  receivers: "Panels/Miscellaneous/entry_3/teleportListener"
   double_letters: true
 }
@@ -0,0 +1,50 @@
+version: 4
+# 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"
@@ -1,15 +1,4 @@
 progressives {
-  name: "Progressive Symbolic Entrance"
-  doors { map: "the_symbolic" name: "White Door" }
-  doors { map: "the_symbolic" name: "Black Door" }
-  doors { map: "the_symbolic" name: "Red Door" }
-  doors { map: "the_symbolic" name: "Blue Door" }
-  doors { map: "the_symbolic" name: "Green Door" }
-  doors { map: "the_symbolic" name: "Yellow Door" }
-  doors { map: "the_symbolic" name: "Purple Door" }
-  doors { map: "the_symbolic" name: "Orange Door" }
-}
-progressives {
   name: "Progressive Gold Ending"
   doors { map: "daedalus" name: "Red Rainbow Room" }
   doors { map: "daedalus" name: "Orange 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 {
@@ -102,12 +125,12 @@ 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;
 
@@ -232,7 +255,17 @@ message Progressive {
   repeated uint64 doors = 4;
 }
 
+message DoorGroup {
+  optional uint64 id = 1;
+  optional string name = 2;
+  optional uint64 ap_id = 3;
+  optional DoorGroupType type = 4;
+  repeated uint64 doors = 5;
+}
+
 message AllObjects {
+  optional uint64 version = 15;
+
   repeated Map maps = 7;
   repeated Room rooms = 1;
   repeated Door doors = 2;
@@ -245,5 +278,6 @@ message AllObjects {
   repeated Ending endings = 12;
   repeated Connection connections = 6;
   repeated Progressive progressives = 13;
+  repeated DoorGroup door_groups = 14;
   map<string, uint64> special_ids = 8;
 }
@@ -66,6 +66,10 @@ message HumanConnection {
   // 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 {
@@ -86,13 +90,16 @@ 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;
@@ -203,6 +210,21 @@ 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;
@@ -220,4 +242,5 @@ message IdMappings {
   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,7 +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);
 
@@ -60,6 +64,7 @@ class AssignIds {
       for (const auto& [_, room] : map.rooms()) {
         UpdateNextId(room.panels());
         UpdateNextId(room.masteries());
+        UpdateNextId(room.keyholders());
       }
     }
 
@@ -67,12 +72,13 @@ class AssignIds {
     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) {
@@ -109,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());
     }
   }
 
@@ -131,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)
@@ -142,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)
@@ -170,17 +194,24 @@ 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());
       }
     }
 
@@ -189,6 +220,10 @@ class AssignIds {
         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)
@@ -200,25 +235,73 @@ class AssignIds {
                .at(h_room.name())
                .keyholders()
                .contains(h_keyholder.name())) {
-        auto& maps = *id_mappings_.mutable_maps();
-        auto& rooms = *maps[current_map_name].mutable_rooms();
-        auto& keyholders = *rooms[h_room.name()].mutable_keyholders();
         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 = *id_mappings_.mutable_progressives();
+    auto& progs = *output_.mutable_progressives();
 
     for (const HumanProgressive& h_prog : h_progs.progressives()) {
-      if (!progs.contains(h_prog.name())) {
+      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);
       }
     }
   }
@@ -237,6 +320,7 @@ class AssignIds {
   uint64_t next_id_ = 1;
 
   IdMappings id_mappings_;
+  IdMappings output_;
 };
 
 }  // namespace
@@ -348,6 +348,23 @@ uint64_t Container::FindOrAddProgressive(std::string prog_name) {
   }
 }
 
+uint64_t Container::FindOrAddDoorGroup(std::string group_name) {
+  auto it = door_group_id_by_name_.find(group_name);
+
+  if (it == door_group_id_by_name_.end()) {
+    uint64_t new_id = all_objects_.door_groups_size();
+    DoorGroup* door_group = all_objects_.add_door_groups();
+    door_group->set_id(new_id);
+    door_group->set_name(group_name);
+
+    door_group_id_by_name_[group_name] = new_id;
+
+    return new_id;
+  } else {
+    return it->second;
+  }
+}
+
 void Container::AddConnection(const Connection& connection) {
   *all_objects_.add_connections() = connection;
 }
@@ -62,6 +62,8 @@ class Container {
 
   uint64_t FindOrAddProgressive(std::string prog_name);
 
+  uint64_t FindOrAddDoorGroup(std::string group_name);
+
   AllObjects& all_objects() { return all_objects_; }
 
  private:
@@ -85,6 +87,7 @@ class Container {
       door_id_by_map_door_names_;
   std::map<std::string, uint64_t> ending_id_by_name_;
   std::map<std::string, uint64_t> progressive_id_by_name_;
+  std::map<std::string, uint64_t> door_group_id_by_name_;
 };
 
 }  // namespace com::fourisland::lingo2_archipelago
@@ -44,6 +44,8 @@ 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");
 
     {
@@ -344,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 =
@@ -577,6 +579,40 @@ class DataPacker {
     }
   }
 
+  void ProcessDoorGroupsFile(std::filesystem::path path) {
+    if (!std::filesystem::exists(path)) {
+      return;
+    }
+
+    auto h_groups = ReadMessageFromFile<HumanDoorGroups>(path.string());
+
+    for (const HumanDoorGroup& h_group : h_groups.door_groups()) {
+      ProcessDoorGroup(h_group);
+    }
+  }
+
+  void ProcessDoorGroup(const HumanDoorGroup& h_group) {
+    uint64_t group_id = container_.FindOrAddDoorGroup(h_group.name());
+    DoorGroup& group = *container_.all_objects().mutable_door_groups(group_id);
+
+    group.set_type(h_group.type());
+
+    for (const DoorIdentifier& di : h_group.doors()) {
+      uint64_t door_id =
+          container_.FindOrAddDoor(di.map(), di.name(), std::nullopt);
+      group.add_doors(door_id);
+    }
+  }
+
+  void 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());
 
@@ -631,6 +667,11 @@ class DataPacker {
       uint64_t prog_id = container_.FindOrAddProgressive(prog_name);
       container_.all_objects().mutable_progressives(prog_id)->set_ap_id(ap_id);
     }
+
+    for (const auto& [group_name, ap_id] : ids.door_groups()) {
+      uint64_t group_id = container_.FindOrAddDoorGroup(group_name);
+      container_.all_objects().mutable_door_groups(group_id)->set_ap_id(ap_id);
+    }
   }
 
   std::string mapdir_;
@@ -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;
 
@@ -104,6 +104,13 @@ IdMappings ReadIdsFromYaml(const std::string& filename) {
     }
   }
 
+  if (document["door_groups"]) {
+    for (const auto& group_it : document["door_groups"]) {
+      (*result.mutable_door_groups())[group_it.first.as<std::string>()] =
+          group_it.second.as<uint64_t>();
+    }
+  }
+
   return result;
 }
 
@@ -171,6 +178,11 @@ void WriteIdsAsYaml(const IdMappings& ids, const std::string& filename) {
                        result["progressives"][prog_name] = prog_id;
                      });
 
+  OperateOnSortedMap(ids.door_groups(), [&result](const std::string& group_name,
+                                                  uint64_t group_id) {
+    result["door_groups"][group_name] = group_id;
+  });
+
   std::ofstream output_stream(filename);
   output_stream << result << std::endl;
 }
@@ -13,6 +13,7 @@
 #include <string>
 
 #include "structs.h"
+#include "util/ids_yaml_format.h"
 
 namespace com::fourisland::lingo2_archipelago {
 namespace {
@@ -42,7 +43,8 @@ class HumanProcessor {
     ProcessConnectionsFile(datadir_path / "connections.txtpb", std::nullopt);
     ProcessMaps(datadir_path);
     ProcessProgressivesFile(datadir_path / "progressives.txtpb");
-    ProcessIdsFile(datadir_path / "ids.txtpb");
+    ProcessDoorGroupsFile(datadir_path / "door_groups.txtpb");
+    ProcessIdsFile(datadir_path / "ids.yaml");
   }
 
  private:
@@ -392,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()) {
@@ -408,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()) {
@@ -430,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);
@@ -449,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
@@ -461,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
@@ -478,6 +493,11 @@ 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);
+        }
       }
     }
   }
@@ -509,8 +529,101 @@ class HumanProcessor {
     }
   }
 
+  void ProcessDoorGroupsFile(std::filesystem::path path) {
+    if (!std::filesystem::exists(path)) {
+      return;
+    }
+
+    auto h_groups = ReadMessageFromFile<HumanDoorGroups>(path.string());
+
+    for (const HumanDoorGroup& h_group : h_groups.door_groups()) {
+      ProcessDoorGroup(h_group);
+    }
+  }
+
+  void ProcessDoorGroup(const HumanDoorGroup& h_group) {
+    DoorGroupInfo& group_info = info_.door_groups[h_group.name()];
+    group_info.definitions.push_back(h_group);
+
+    for (const DoorIdentifier& di : h_group.doors()) {
+      if (!di.has_map()) {
+        group_info.malformed_doors.push_back(di);
+        continue;
+      }
+
+      DoorInfo& door_info = info_.doors[di];
+      door_info.door_groups_referenced_by.push_back(h_group.name());
+    }
+  }
+
   void ProcessIdsFile(std::filesystem::path path) {
-    // 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,6 +39,7 @@ struct RoomInfo {
 
 struct DoorInfo {
   std::vector<HumanDoor> definitions;
+  bool has_id = false;
 
   std::vector<HumanConnection> connections_referenced_by;
   std::vector<DoorIdentifier> doors_referenced_by;
@@ -46,6 +47,7 @@ struct DoorInfo {
   std::vector<PaintingIdentifier> paintings_referenced_by;
   std::vector<PortIdentifier> ports_referenced_by;
   std::vector<std::string> progressives_referenced_by;
+  std::vector<std::string> door_groups_referenced_by;
 
   MalformedIdentifiers malformed_identifiers;
 };
@@ -54,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;
 };
 
@@ -72,10 +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;
@@ -83,6 +89,7 @@ struct PanelInfo {
 
 struct KeyholderInfo {
   std::vector<HumanKeyholder> definitions;
+  bool has_id = false;
 
   std::vector<DoorIdentifier> doors_referenced_by;
 };
@@ -91,10 +98,12 @@ 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;
 };
@@ -105,6 +114,14 @@ struct PanelNameInfo {
 
 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;
 };
@@ -122,6 +139,7 @@ struct CollectedInfo {
   std::map<std::string, EndingInfo> endings;
   std::map<std::string, PanelNameInfo> panel_names;
   std::map<std::string, ProgressiveInfo> progressives;
+  std::map<std::string, DoorGroupInfo> door_groups;
 };
 
 }  // namespace com::fourisland::lingo2_archipelago
@@ -48,6 +48,9 @@ class Validator {
     for (const auto& [prog_name, prog_info] : info_.progressives) {
       ValidateProgressive(prog_name, prog_info);
     }
+    for (const auto& [group_name, group_info] : info_.door_groups) {
+      ValidateDoorGroup(group_name, group_info);
+    }
   }
 
  private:
@@ -103,7 +106,8 @@ class Validator {
       return false;
     }
 
-    if (h_door.keyholders_size() > 0 || h_door.endings_size() > 0) {
+    if (h_door.keyholders_size() > 0 || h_door.endings_size() > 0 ||
+        h_door.complete_at() > 0) {
       return true;
     }
 
@@ -172,6 +176,15 @@ class Validator {
            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;
@@ -215,6 +228,17 @@ class Validator {
                   << " 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;
+        }
+      }
     }
   }
 
@@ -233,6 +257,22 @@ class Validator {
       std::cout << "Port " << port_identifier.ShortDebugString()
                 << " was defined multiple times." << 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;
+          }
+        }
+      }
+    }
   }
 
   void ValidatePainting(const PaintingIdentifier& painting_identifier,
@@ -256,6 +296,22 @@ class Validator {
       std::cout << "Painting " << painting_identifier.ShortDebugString()
                 << " was defined multiple times." << 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;
+          }
+        }
+      }
+    }
   }
 
   void ValidatePanel(const PanelIdentifier& panel_identifier,
@@ -280,6 +336,10 @@ class Validator {
         std::cout << "    CONNECTION " << connection.ShortDebugString()
                   << std::endl;
       }
+
+      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()
                 << " was defined multiple times." << std::endl;
@@ -308,6 +368,27 @@ class Validator {
                   << "\" 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,
@@ -321,10 +402,28 @@ class Validator {
         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 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,
@@ -332,7 +431,14 @@ class Validator {
     std::string letter_name = std::string(1, std::get<0>(letter_identifier)) +
                               (std::get<1>(letter_identifier) ? "2" : "1");
 
-    if (letter_info.defined_in.size() > 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;
 
@@ -340,6 +446,11 @@ class Validator {
         std::cout << "    " << room_identifier.ShortDebugString() << std::endl;
       }
     }
+
+    if (!letter_info.has_id) {
+      std::cout << "Letter " << letter_name << " is missing an AP ID."
+                << std::endl;
+    }
   }
 
   void ValidateEnding(const std::string& ending_name,
@@ -353,6 +464,10 @@ class Validator {
         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;
@@ -361,6 +476,11 @@ class Validator {
         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,
@@ -379,10 +499,42 @@ class Validator {
 
   void ValidateProgressive(const std::string& prog_name,
                            const ProgressiveInfo& prog_info) const {
-    if (prog_info.definitions.size() > 1) {
+    if (prog_info.definitions.empty()) {
+      std::cout << "Progressive \"" << prog_name
+                << "\" has no definition, but was referenced:" << std::endl;
+
+      if (prog_info.has_id) {
+        std::cout << "    An AP ID is present." << std::endl;
+      }
+    } else if (prog_info.definitions.size() > 1) {
       std::cout << "Progressive \"" << prog_name
                 << "\" has multiple definitions." << std::endl;
     }
+
+    if (!prog_info.has_id) {
+      std::cout << "Progressive \"" << prog_name << "\" is missing an AP ID."
+                << std::endl;
+    }
+  }
+
+  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_;
@@ -7,7 +7,7 @@
   "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"