431 files changed, 17050 insertions, 2481 deletions

@@ -0,0 +1,307 @@
+# lingo2-archipelago Releases
+
+## v8.0.1 - 2025-11-05
+
+- Fixed issue where The Unkempt - COLOR would disappear when it became logical
+  to solve it. It is now always present, and does not logically require cyan
+  doors or the orange control center door.
+- Fixed issue where you would be expected to solve The Owl - COLOR while it is
+  invisible. It is now considered a cyan door.
+
+Compatability notes:
+
+- This client should overall be compatible with worlds generated on v8.0.0. The
+  tracker will show the new logic for The Unkempt - COLOR, which reflects when
+  it is solvable in game, but may place it in an earlier sphere than it was in
+  the original generation. Conversely, The Owl - COLOR is now more restricted in
+  the new logic, so you may end up in a situation where you are required to
+  solve it but the tracker does not realize it is in logic. However, the panel
+  is simply invisible when you don't have cyan doors, meaning it is easy to
+  solve it early if necessary.
+
+Download:
+[lingo2.apworld](https://files.fourisland.com/releases/lingo2-archipelago/apworld/v8.0.1/lingo2.apworld)<br/>
+Template YAML:
+[Lingo 2.yaml](https://files.fourisland.com/releases/lingo2-archipelago/apworld/v8.0.1/Lingo%202.yaml)<br/>
+Source: [v8.0.1](https://code.fourisland.com/lingo2-archipelago/tag/?h=v8.0.1)
+
+## v8.0.0 - 2025-11-02
+
+- ~50 new locations were added, such that almost every panel in the game is now
+  part of either a location or a connection. Some existing locations were also
+  modified or removed to make this cleaner. The only panels that are not part of
+  any location or connection are the ones in rooms that you are explicitly not
+  supposed to solve (e.g. the letter rooms in Daedalus where you are only
+  supposed to solve the panels indicated by the ceiling).
+- Multiworld state is now saved in a way that should increase compatibility when
+  playing on a client that is a different version than the apworld that
+  generated the world, going forward. Complete compatibility is not guaranteed,
+  but this fixes some of the glaring issues. Also note that this client is _not_
+  compatible with worlds generated on v7.x.x.
+- Hinted locations are now prioritized in the tracker, and are displayed in a
+  different color.
+- Locations can now be ignored in the tracker, which removes them from the
+  overlay and puts them at the bottom of the tab in the text client.
+- Fixed the Yellow Ending door not opening properly when gallery paintings are
+  shuffled.
+- The trigger for the gallery painting in The Unyielding is now smaller, so that
+  it matches the logical requirement.
+- The DIRECTION panels near the Castle in Daedalus are now moved when the roof
+  access stairs are present, so that you don't lose access to them.
+
+Download:
+[lingo2.apworld](https://files.fourisland.com/releases/lingo2-archipelago/apworld/v8.0.0/lingo2.apworld)<br/>
+Template YAML:
+[Lingo 2.yaml](https://files.fourisland.com/releases/lingo2-archipelago/apworld/v8.0.0/Lingo%202.yaml)<br/>
+Source: [v8.0.0](https://code.fourisland.com/lingo2-archipelago/tag/?h=v8.0.0)
+
+## v7.2.0 - 2025-10-25
+
+- Doors that rely on keyholders or the control center color panel are now
+  "latched". This means they will not close once they've been opened. Because of
+  this, the worldports near these doors are now eligible for randomization in
+  worldport shuffle.
+- Icarus is now optionally randomizable.
+- The requirements for accessing White Ending are now customizable. You can
+  choose to require a number of endings as well as a number of masteries.
+- The "Return To" trigger in The Plaza is now outside of the turtle.
+- Fixed a logic error regarding a couple of specific doors in vanilla doors
+  mode.
+- Fixed a bug where unlocks would not persist if you were playing with all
+  letters pre-unlocked and cyan doors on "any double letter".
+- Fixed a bug where the client would fail to connect properly when launched from
+  a URL if the player name had spaces in it.
+
+Download:
+[lingo2.apworld](https://files.fourisland.com/releases/lingo2-archipelago/apworld/v7.2.0/lingo2.apworld)<br/>
+Template YAML:
+[Lingo 2.yaml](https://files.fourisland.com/releases/lingo2-archipelago/apworld/v7.2.0/Lingo%202.yaml)<br/>
+Source: [v7.2.0](https://code.fourisland.com/lingo2-archipelago/tag/?h=v7.2.0)
+
+## v7.1.0 - 2025-10-07
+
+- Added a "Get Path" button to the locations tracker. This shows you the path
+  you're currently expected to be able to take in order to reach that
+  location/worldport/goal.
+- Worldport names in the spoiler log have been changed to be more descriptive.
+- Jumping into The Graveyard from The Sun Temple is now in logic.
+- Solving the FLIP panels above the Liberated and Literate entrances by looking
+  up is now in logic.
+- Renamed some locations so that they're shorter.
+- Fixed bug where White Ending would kick the player out of Archipelago.
+- Fixed bug where the minimap would be completely white when a texture pack is
+  enabled.
+- Generation failures while shuffling worldports should be significantly less
+  common.
+
+Download:
+[lingo2.apworld](https://files.fourisland.com/releases/lingo2-archipelago/apworld/v7.1.0/lingo2.apworld)<br/>
+Template YAML:
+[Lingo 2.yaml](https://files.fourisland.com/releases/lingo2-archipelago/apworld/v7.1.0/Lingo%202.yaml)<br/>
+Source: [v7.1.0](https://code.fourisland.com/lingo2-archipelago/tag/?h=v7.1.0)
+
+## v7.0.2 - 2025-10-03
+
+- Fixed issue connecting to password-protected slots.
+- Added instructions for using the client on Linux.
+
+Download:
+[lingo2.apworld](https://files.fourisland.com/releases/lingo2-archipelago/apworld/v7.0.2/lingo2.apworld)<br/>
+Template YAML:
+[Lingo 2.yaml](https://files.fourisland.com/releases/lingo2-archipelago/apworld/v7.0.2/Lingo%202.yaml)<br/>
+Source: [v7.0.2](https://code.fourisland.com/lingo2-archipelago/tag/?h=v7.0.2)
+
+## v7.0.1 - 2025-10-01
+
+- Fixed logic error regarding the Plaza Entrance in The Repetitive. Going from
+  The Plaza to The Repetitive does not require the door to be open in vanilla
+  doors, but both directions require the door item when doors are shuffled.
+- Fixed Worldports tracker tab getting messed up after disconnecting and
+  reconnecting to multiworld.
+- Improved error messages when failing to connect. The game now also shows you
+  when your connection has dropped.
+
+Download:
+[lingo2.apworld](https://files.fourisland.com/releases/lingo2-archipelago/apworld/v7.0.1/lingo2.apworld)<br/>
+Template YAML:
+[Lingo 2.yaml](https://files.fourisland.com/releases/lingo2-archipelago/apworld/v7.0.1/Lingo%202.yaml)<br/>
+Source: [v7.0.1](https://code.fourisland.com/lingo2-archipelago/tag/?h=v7.0.1)
+
+## v7.0.0 - 2025-09-30
+
+- Major update! First and foremost: the client and apworld are no longer
+  separate! There is only an apworld now, which you install into your
+  Archipelago custom worlds folder as per normal. In order to play a randomized
+  world, you open the Archipelago Launcher and click Lingo 2 Client. The first
+  time you do this, it will ask you for the location of your Lingo2.exe, which
+  you can find by right clicking on the game in Steam and clicking Browse Local
+  Files.
+- **Built-in tracker**: The in-game text client has a new tab called "Locations"
+  which lists the currently accessible locations similar to how Universal
+  Tracker does it. There is also an optional overlay you can enable in the
+  settings, which shows you some of your accessible locations on screen while
+  you're playing. If you're playing with vanilla letters, the tracker won't show
+  you locations that are solvable with letters until you collect the actual
+  letters, in order to help direct you better. More features will be coming to
+  the tracker in the future!
+- **Worldport shuffle**: The first part of entrance randomization is here!
+  Enabling this shuffles the destinations of the worldports, which are the
+  loading zones you walk into in order to change maps. Some restrictions apply,
+  which are noted in the option description. The tracker will show a list of
+  worldports you haven't entered yet, and will also not show you what lies
+  beyond a worldport until you've entered it. There is also a tab in the
+  textclient showing you the mapping between worldports you've already entered.
+- **Minimap**: There is an option in the settings to show a minimap in the
+  corner of the screen. This shows an overhead view of the map you're on, and
+  where you are in it. More features will be coming to the minimap in the
+  future!
+- Fixed the gate outside the Daedalus entrance in The Great not opening when
+  control center colors are shuffled.
+
+Download:
+[lingo2.apworld](https://files.fourisland.com/releases/lingo2-archipelago/apworld/v7.0.0/lingo2.apworld)<br/>
+Template YAML:
+[Lingo 2.yaml](https://files.fourisland.com/releases/lingo2-archipelago/apworld/v7.0.0/Lingo%202.yaml)<br/>
+Source: [v7.0.0](https://code.fourisland.com/lingo2-archipelago/tag/?h=v7.0.0)
+
+## Legacy Client v6.7 - 2025-09-19
+
+- Added a compass overlay. This makes it clearer which direction corresponds to
+  which compass direction, which is useful since many location/item names
+  reference compass directions. It can be enabled in the settings screen on the
+  pause menu.
+- Compatability update for the changes in v6.6 of the apworld.
+
+Download:
+[lingo2-archipelago-client-v6.7.zip](https://files.fourisland.com/releases/lingo2-archipelago/client/lingo2-archipelago-client-v6.7.zip)<br/>
+Source:
+[v6.7](https://code.fourisland.com/lingo2-archipelago/tag/?h=client-v6.7)
+
+## Legacy Apworld v6.6 - 2025-09-19
+
+- Added options that make the requirements for Purple Ending and Cyan Ending
+  stricter. With the strict options on, players are required to have all purple
+  (level 1) letters in order to get Purple Ending, and all cyan (level 2)
+  letters to get Cyan Ending. These options are on by default.
+- Renamed several items and locations, mostly regarding changing relative
+  directions (left, right, etc) to compass directions. The colored SMILE panels
+  in Daedalus now have clearer names too.
+- Fixed some minor logic errors.
+
+Download:
+[lingo2.apworld](https://files.fourisland.com/releases/lingo2-archipelago/apworld/v6.6/lingo2.apworld)<br/>
+Template YAML:
+[Lingo 2.yaml](https://files.fourisland.com/releases/lingo2-archipelago/apworld/v6.6/Lingo%202.yaml)<br/>
+Source:
+[v6.6](https://code.fourisland.com/lingo2-archipelago/tag/?h=apworld-v6.6)
+
+## Legacy Client v5.6 - 2025-09-17
+
+- Letter locations will no longer reappear after being collected.
+- This also prevents a potential scenario in which it is impossible to access
+  the location "The Congruent - Obverse Yellow Puzzles" when door shuffle is
+  disabled.
+
+Download:
+[lingo2-archipelago-client-v5.6.zip](https://files.fourisland.com/releases/lingo2-archipelago/client/lingo2-archipelago-client-v5.6.zip)<br/>
+Source:
+[v5.6](https://code.fourisland.com/lingo2-archipelago/tag/?h=client-v5.6)
+
+## Legacy Client v5.5 - 2025-09-16
+
+- Compatability update for v5.5 of the apworld.
+
+Download:
+[lingo2-archipelago-client-v5.5.zip](https://files.fourisland.com/releases/lingo2-archipelago/client/lingo2-archipelago-client-v5.5.zip)<br/>
+Source:
+[v5.5](https://code.fourisland.com/lingo2-archipelago/tag/?h=client-v5.5)
+
+## Legacy Apworld v5.5 - 2025-09-16
+
+- Fixed a panel in The Ancient that was missing a symbol.
+- Fixed an issue where you could be expected to get S1 in The Darkroom without
+  having U.
+- Renamed a few locations.
+
+Download:
+[lingo2.apworld](https://files.fourisland.com/releases/lingo2-archipelago/apworld/v5.5/lingo2.apworld)<br/>
+Template YAML:
+[Lingo 2.yaml](https://files.fourisland.com/releases/lingo2-archipelago/apworld/v5.5/Lingo%202.yaml)<br/>
+Source:
+[v5.5](https://code.fourisland.com/lingo2-archipelago/tag/?h=apworld-v5.5)
+
+## Legacy Apworld v4.4 - 2025-09-14
+
+- Fixed panel set location names.
+
+Download:
+[lingo2.apworld](https://files.fourisland.com/releases/lingo2-archipelago/apworld/v4.4/lingo2.apworld)<br/>
+Template YAML:
+[Lingo 2.yaml](https://files.fourisland.com/releases/lingo2-archipelago/apworld/v4.4/Lingo%202.yaml)<br/>
+Source:
+[v4.4](https://code.fourisland.com/lingo2-archipelago/tag/?h=apworld-v4.4)
+
+## Legacy Client v4.4 - 2025-09-13
+
+- Added support for anti-collectable trap items.
+- Fixed entrance to The Jubilant not opening properly when using control center
+  color shuffle.
+- Fixed the location "The Entry (Colored Doors Area) - OPEN" not sending.
+- Fixed level 2 letters not activating properly when letter shuffle is set to
+  Item Cyan.
+- Messages are now cleared out when returning to the main menu.
+- The player is prevented from accidentally breaking roof access logic when
+  returning to Daedalus from Icarus.
+
+Download:
+[lingo2-archipelago-client-v4.4.zip](https://files.fourisland.com/releases/lingo2-archipelago/client/lingo2-archipelago-client-v4.4.zip)<br/>
+Source:
+[v4.4](https://code.fourisland.com/lingo2-archipelago/tag/?h=client-v4.4)
+
+## Legacy Apworld v4.3 - 2025-09-13
+
+- Added a location for the anti-collectable in The Repetitive.
+- Added trap items. These remove letters from your keyboard until you use the
+  Key Return in The Entry, similar to the anti-collectable in The Repetitive.
+  This can be controlled using the `trap_percentage` option, which defaults to
+  zero.
+- Fixed crash on load when using Python 3.11.
+
+Download:
+[lingo2.apworld](https://files.fourisland.com/releases/lingo2-archipelago/apworld/v4.3/lingo2.apworld)<br/>
+Template YAML:
+[Lingo 2.yaml](https://files.fourisland.com/releases/lingo2-archipelago/apworld/v4.3/Lingo%202.yaml)<br/>
+Source:
+[v4.3](https://code.fourisland.com/lingo2-archipelago/tag/?h=apworld-v4.3)
+
+## Legacy Client v3.3 - 2025-09-12
+
+- Fixed issue downloading large datapackages (such as TUNIC's).
+- Connection failures now show error messages.
+
+Download:
+[lingo2-archipelago-client-v3.3.zip](https://files.fourisland.com/releases/lingo2-archipelago/client/lingo2-archipelago-client-v3.3.zip)<br/>
+Source:
+[v3.3](https://code.fourisland.com/lingo2-archipelago/tag/?h=client-v3.3)
+
+## Legacy Client v3.2 - 2025-09-12
+
+- Initial release for testing. Features include door shuffle, letter shuffle,
+  and symbol shuffle.
+
+Download:
+[lingo2-archipelago-client-v3.2.zip](https://files.fourisland.com/releases/lingo2-archipelago/client/lingo2-archipelago-client-v3.2.zip)<br/>
+Source:
+[v3.2](https://code.fourisland.com/lingo2-archipelago/tag/?h=client-v3.2)
+
+## Legacy Apworld v3.2 - 2025-09-12
+
+- Initial release for testing. Features include door shuffle, letter shuffle,
+  and symbol shuffle.
+
+Download:
+[lingo2.apworld](https://files.fourisland.com/releases/lingo2-archipelago/apworld/v3.2/lingo2.apworld)<br/>
+Template YAML:
+[Lingo 2.yaml](https://files.fourisland.com/releases/lingo2-archipelago/apworld/v3.2/Lingo%202.yaml)<br/>
+Source:
+[v3.2](https://code.fourisland.com/lingo2-archipelago/tag/?h=apworld-v3.2)
@@ -0,0 +1,284 @@
+# lingo2-archipelago
+
+[Archipelago](https://archipelago.gg/) is an open-source project that supports
+randomizing a number of different games and combining them into one cooperative
+experience. Items from each game are hidden in other games. For more information
+about Archipelago, you can look at their website.
+
+This is a project that modifies the game
+[Lingo 2](https://www.lingothegame.com/lingo2.html) so that it can be played as
+part of an Archipelago multiworld game.
+
+## Installation
+
+1. Download the Lingo 2 Apworld from
+   [the releases page](https://code.fourisland.com/lingo2-archipelago/about/CHANGELOG.md).
+2. If you do not already have it, download and install the
+   [Archipelago software](https://github.com/ArchipelagoMW/Archipelago/releases/).
+3. Double click on `lingo2.apworld` to install it, or copy it manually to the
+   `custom_worlds` folder of your Archipelago installation.
+
+## Joining a Multiworld game (Windows)
+
+1. Open the Archipelago Launcher.
+2. Select "Lingo 2 Client".
+3. The first time you do this, Archipelago will prompt you for the location of
+   the Lingo 2 executable file ("Lingo2.exe"). You can find this by
+   right-clicking on Lingo 2 in Steam, going to "Manage", and clicking "Browse
+   local files".
+4. Lingo 2 will open, and you will see a form asking for your connection
+   details. Enter the Archipelago address, slot name, and password into the
+   fields.
+5. Press Connect.
+6. Enjoy!
+
+To continue an earlier game, you can perform the exact same steps as above.
+
+## Joining a Multiworld game (Non-Windows)
+
+Lingo 2 only officially supports Windows, but has been known to work on Linux
+using Proton. Archipelago can be played on a non-Windows system, but the process
+is a little more complex.
+
+1. Download
+   [archipelago.tscn](https://code.fourisland.com/lingo2-archipelago/plain/client/archipelago.tscn)
+   and put it in your custom maps folder. You only have to do this once.
+2. Open Lingo 2, and select Archipelago from the level selection list.
+3. Put the path to your `lingo2.apworld` into the field provided. You only have
+   to do this once, as the game will remember what you put in.
+4. Click Start and wait for the connection settings screen to load.
+5. Open the Archipelago Launcher.
+6. Select "Lingo 2 Client".
+7. You should see "Connected to Lingo 2!" You can then return to Lingo 2 and
+   fill out your connection details.
+8. Press Connect.
+9. Enjoy!
+
+## 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 only
+exception is The Hinterlands, which will probably be repurposed into a hint
+area. Some advanced/hidden maps are also disabled by default (as discussed
+below).
+
+### Is my progress saved locally?
+
+Lingo 2 autosaves your progress every time you solve a puzzle, get a
+collectable, or interact with a keyholder. The randomizer generates a savefile
+name based on your Multiworld seed and slot number, so you should be able to
+seamlessly switch between multiworlds and even slots within a multiworld.
+
+The exception to this is different rooms created from the same multiworld seed.
+The client is unable to tell rooms in a seed apart (this is a limitation of the
+Archipelago API), so the client will use the same save file for the same slot in
+different rooms on the same seed. You can work around this by manually moving or
+removing the save folder from the users directory in Lingo 2's game files.
+
+If you play the base game again, you will see one or more save files with a long
+name that begins with "zzAP\_". These are the saves for your multiworlds. They
+can be safely deleted after you have completed the associated multiworld. It is
+not recommended to load these save files outside of the randomizer.
+
+A connection to Archipelago is required to resume playing a multiworld. This is
+because the set of items you have received is not stored locally.
+
+### What about wall snipes?
+
+"Wall sniping" refers to the fact that you are able to solve puzzles on the
+other side of opaque walls. The player is never expected to or required to do
+this in normal gameplay. This randomizer does not change how wall snipes work,
+but it will likewise never require the use of them.
+
+### How do cyan doors work?
+
+In the base game, there are a number of cyan-colored doors that ordinarily open
+once you collect H2 in The Repetitive. There are also a handful of panels that
+only appear upon getting H2 as well, which the apworld treats the same as the
+cyan doors.
+
+There is an option that lets you choose how these doors and panels behave. By
+default, they act the same as in the base game: they only open or appear after
+collecting H2. Note that this means the actual H2 collectable in The Repetitive.
+Receiving H2 via remote letter shuffle does not count for this requirement.
+However, you can also make cyan doors activate upon collecting or receiving your
+first double letter, regardless of what it is or if it's remote. Finally, you
+can lock cyan doors behind an item called "Cyan Doors".
+
+It is important to note, however, that the Cyan Door Behavior option only
+applies to cyan doors that are not already affected by another type of
+shuffling. When door shuffle is on, the following cyan doors are activated by
+individual items and are not impacted by your choice of Cyan Door Behavior:
+
+- The entrance to The Tower from The Great (The Great - Tower Entrance)
+- The entrance to The Butterfly from The Bearer (The Bearer - Butterfly
+  Entrance)
+- The entrance to The Repetitive from The Entry (The Entry - Repetitive
+  Entrance)
+- The eye painting near the yellow color hallway in Daedalus (Daedalus - Eye
+  Painting)
+- The Red I room in The Repetitive (The Repetitive - Anti Collectable Room)
+
+Additionally, when control center color shuffle is enabled, the orange door in
+The Unkempt (which ordinarily doubles as a cyan door) opens upon receiving the
+Control Center Orange Doors item, instead of following the Cyan Door Behavior
+option.
+
+### Help! I lost C/G in The Congruent!
+
+If you place C or G into the relevant keyholders in The Congruent, the keyholder
+disappears. You can retrieve your letter immediately by pressing C or G again
+before leaving solve mode, as the keyholder will still be considered to be
+"focused", even though it has moved. If you have already moved, though, there is
+another way to get your letters back: just use the Key Return in The Entry.
+
+### Why is the tracker telling me to solve a panel that's currently red?
+
+Red usually indicates that a panel cannot be solved because of missing letters.
+However, that only applies to the puzzle's main answer. If a puzzle has
+alternate answers, you may be expected to use one of those instead of the main
+one. As long as you have all of the necessary letters, an alternate answer can
+be typed into a red panel even though it does not show you typing. When you
+finish typing the answer, the panel will solve as normal.
+
+### Why does the tracker say "The Entry (Colored Doors Area) - OPEN" is in logic?
+
+This is an infamous panel, both in the base game and in the randomizer. There
+are _two_ valid answers that open the door / clear the location. These are
+"ORANGE" and "WALL".
+
+### I can't solve the COLORS panel in The Sturdy!
+
+The Sturdy contains a rainbow painting that leads to the Gold Ending area in
+Daedalus. There are three ways to spawn this painting, which have different
+logical requirements:
+
+- Solve the COLORS panel that appears after collecting S2. This is the most
+  well-known way, and causes the most confusion because you may be expected to
+  enter the painting even if you are unable to solve the panel (e.g. if you are
+  missing letters or missing Boxes Symbol).
+- Solve the panels in the order that you walk across the colors on the way
+  toward S2: Magenta, Red, Orange, Yellow, Green, Blue, Purple, Cyan. This has
+  the same logic as accessing S2.
+- Type "MOVE" into the Green and Yellow panels, and none of the other ones. This
+  is a subset of the logic for accessing S2, so you may actually be expected to
+  use the rainbow painting before you can even collect S2.
+
+### How does Icarus work?
+
+While Icarus is easily accessible during normal play, it is not randomized by
+default. The main reason for this is that Icarus employs significantly more use
+of gravity changing mechanics than the rest of the game and as a result tends to
+cause motion sickness in a lot of players. It is also an infamously confusing
+area to navigate.
+
+Because of this, the player may enter and exit Icarus from the usual place in
+Daedalus, but it will not contain any locations, and no items will be added to
+the pool for it. The worldport will not be included in the randomization if
+worldport shuffle is on. Icarus can also still be entered from The Crystalline,
+but doing so (in order to then access Daedalus) will not be logically required.
+
+However, Icarus can be randomized via the "Enable Icarus" option. Doing so
+creates locations and items for the map, and includes the worldport in worldport
+shuffle. The aforementioned connection from The Crystalline also becomes
+logical, if The Crystalline is enabled.
+
+It is not trivial to telegraph exactly what is logical within Icarus. It is very
+easy to break logic because the gravity changers allow you to fall in almost any
+direction you want to. In general, falling is only in logic if it is "guided",
+i.e. falling through a hole or an open door to another platform, or using a
+gravity inverter. You may also sometimes be required to solve panels that are
+physically near you and easily visible, but not on your plane of gravity. The
+tracker can help you determine what is considered logical, if you want to stay
+within the randomizer's logic.
+
+### How do the gift maps work?
+
+The beta tester gift maps are hidden levels intended for specific people. By
+default, these are not accessible at all from within the randomizer. The "Enable
+Gift Maps" option allows you to enter the maps, and creates items and locations
+for them. If worldport shuffle is on, their worldports will be included in the
+randomization.
+
+The gift maps are accessed via a panel in The Entry's Starting Room, which only
+appears if at least one gift map is enabled. It is also treated like a cyan
+door, and will not appear until the condition specified in the Cyan Door
+Behavior option is satisfied. Solving this panel with the name of one of the
+beta testers will teleport you to their corresponding gift map. This README
+purposefully does not list the names you need to enter the maps via the panel.
+
+In the base game, nothing happens once you complete a gift map. Masteries have
+been added to the gift maps in the randomizer so that the player can be rewarded
+for completing them.
+
+Note that the gift maps were originally only intended to be played by specific
+people, and as a result may be frustrating or require knowledge of inside jokes.
+The Crystalline is particularly difficult as it requires completing a parkour
+course. It is highly recommended that you complete these maps vanilla or solo
+before bringing them to a multiworld. It is also perfectly acceptable to never
+enable them.
+
+## Running from source
+
+The randomizer is mostly written in Python and GDScript, which do not need to be
+compiled. However, there are three files that need to be generated before the
+apworld can be used.
+
+The first file is `data.binpb`, the datafile containing the randomizer logic.
+You can read about how to generate it on
+[its own README page](https://code.fourisland.com/lingo2-archipelago/about/data/README.md).
+Once you have it, put it in a subfolder of `apworld` called `generated`.
+
+The second generated file is `data_pb2.py`. This file allows Archipelago to read
+the datafile. We use `protoc`, the Protocol Buffer compiler, to generate it. As
+of 0.6.3, Archipelago has protobuf 3.20.3 packaged with it, which means we need
+to compile our proto file with a similar version.
+
+If you followed the steps to generate `data.binpb` and compiled the `datapacker`
+tool yourself, you will already have protobuf version 3.21.12 installed through
+vcpkg. You can then run a command similar to this in order to generate the
+python file.
+
+```shell
+.\out\build\x64-Debug\vcpkg_installed\x64-windows\tools\protobuf\protoc.exe -Iproto\ ^
+  --python_out=apworld\generated\ .\proto\data.proto
+```
+
+The exact path to `protoc.exe` is going to depend on where vcpkg installed its
+packages. The above location is where Visual Studio will probably put it.
+
+The third generated file is `proto.gd`. This is the GDScript version of the
+previous file. We use a Godot script to generate it, which means
+[the Godot Editor](https://godotengine.org/download/) is required. From the root
+of the repository:
+
+```shell
+cd vendor\godobuf
+godot --headless -s addons\protobuf\protobuf_cmdln.gd --input=..\..\proto\data.proto ^
+  --output=..\..\apworld\generated\proto.gd
+```
+
+If you are not on Windows, replace the forward slashes with backslashes as
+appropriate (and the caret with a forward slash). You will also probably need to
+replace "godot" at the start of the second line with a path to a Godot Editor
+executable.
+
+After generating those three files, the apworld should be functional. You can
+copy it into an Archipelago source tree (rename the folder `apworld` to `lingo2`
+if you do so) if you want to edit/debug the code. Otherwise, you can zip up the
+folder and rename it to `lingo2.apworld` in order to package it for
+distribution.
@@ -1,18 +1,40 @@
 """
 Archipelago init file for Lingo 2
 """
-from BaseClasses import ItemClassification, Item
+from typing import ClassVar
+
+from BaseClasses import ItemClassification, Item, Tutorial
+from Options import OptionError
+from settings import Group, UserFilePath
 from worlds.AutoWorld import WebWorld, World
-from .items import Lingo2Item
+from .items import Lingo2Item, ANTI_COLLECTABLE_TRAPS
 from .options import Lingo2Options
 from .player_logic import Lingo2PlayerLogic
-from .regions import create_regions
+from .regions import create_regions, shuffle_entrances, connect_ports_from_ut
 from .static_logic import Lingo2StaticLogic
+from worlds.LauncherComponents import Component, Type, components, launch as launch_component, icon_paths
 
 
 class Lingo2WebWorld(WebWorld):
     rich_text_options_doc = True
     theme = "grass"
+    tutorials = [Tutorial(
+        "Multiworld Setup Guide",
+        "A guide to playing Lingo 2 with Archipelago.",
+        "English",
+        "en_Lingo_2.md",
+        "setup/en",
+        ["hatkirby"]
+    )]
+
+
+class Lingo2Settings(Group):
+    class ExecutableFile(UserFilePath):
+        """Path to the Lingo 2 executable"""
+        is_exe = True
+
+    exe_file: ExecutableFile = ExecutableFile()
+    start_game: bool = True
 
 
 class Lingo2World(World):
@@ -24,6 +46,9 @@ class Lingo2World(World):
     game = "Lingo 2"
     web = Lingo2WebWorld()
 
+    settings: ClassVar[Lingo2Settings]
+    settings_key = "lingo2_options"
+
     topology_present = True
 
     options_dataclass = Lingo2Options
@@ -32,18 +57,38 @@ 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
+
+    for_tracker: ClassVar[bool] = False
 
     player_logic: Lingo2PlayerLogic
 
+    port_pairings: dict[int, int]
+
     def generate_early(self):
         self.player_logic = Lingo2PlayerLogic(self)
+        self.port_pairings = {}
 
     def create_regions(self):
         create_regions(self)
 
-        from Utils import visualize_regions
+    def connect_entrances(self):
+        if self.options.shuffle_worldports:
+            if hasattr(self.multiworld, "re_gen_passthrough") and "Lingo 2" in self.multiworld.re_gen_passthrough:
+                slot_value = self.multiworld.re_gen_passthrough["Lingo 2"]["port_pairings"]
+                self.port_pairings = {
+                    self.static_logic.port_id_by_ap_id[int(fp)]: self.static_logic.port_id_by_ap_id[int(tp)]
+                    for fp, tp in slot_value.items()
+                }
+
+                connect_ports_from_ut(self.port_pairings, self)
+            else:
+                shuffle_entrances(self)
+
+        #from Utils import visualize_regions
 
-        visualize_regions(self.multiworld.get_region("Menu", self.player), "my_world.puml")
+        #visualize_regions(self.multiworld.get_region("Menu", self.player), "my_world.puml")
 
     def create_items(self):
         pool = [self.create_item(name) for name in self.player_logic.real_items]
@@ -51,13 +96,33 @@ 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(self.get_filler_item_name()))
 
+        if not any(ItemClassification.progression in item.classification for item in pool):
+            raise OptionError(f"Lingo 2 player {self.player} has no progression items. Please enable at least one "
+                              f"option that would add progression gating to your world, such as Shuffle Doors or "
+                              f"Shuffle Letters.")
+
         self.multiworld.itempool += pool
 
     def create_item(self, name: str) -> Item:
         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)
 
@@ -68,18 +133,54 @@ class Lingo2World(World):
         slot_options = [
             "cyan_door_behavior",
             "daedalus_roof_access",
+            "enable_gift_maps",
+            "enable_icarus",
+            "endings_requirement",
             "keyholder_sanity",
+            "masteries_requirement",
             "shuffle_control_center_colors",
             "shuffle_doors",
+            "shuffle_gallery_paintings",
             "shuffle_letters",
+            "shuffle_symbols",
+            "shuffle_worldports",
+            "strict_cyan_ending",
+            "strict_purple_ending",
             "victory_condition",
         ]
 
-        slot_data = {
+        slot_data: dict[str, object] = {
             **self.options.as_dict(*slot_options),
+            "version": self.static_logic.get_data_version(),
         }
 
+        if self.options.shuffle_worldports:
+            def get_port_ap_id(port_id):
+                return self.static_logic.objects.ports[port_id].ap_id
+
+            slot_data["port_pairings"] = {get_port_ap_id(from_id): get_port_ap_id(to_id)
+                                          for from_id, to_id in self.port_pairings.items()}
+
         return slot_data
 
     def get_filler_item_name(self) -> str:
         return "A Job Well Done"
+
+    # for the universal tracker, doesn't get called in standard gen
+    # docs: https://github.com/FarisTheAncient/Archipelago/blob/tracker/worlds/tracker/docs/re-gen-passthrough.md
+    @staticmethod
+    def interpret_slot_data(slot_data: dict[str, object]) -> dict[str, object]:
+        # returning slot_data so it regens, giving it back in multiworld.re_gen_passthrough
+        # we are using re_gen_passthrough over modifying the world here due to complexities with ER
+        return slot_data
+
+
+def launch_client(*args):
+    from .context import client_main
+    launch_component(client_main, name="Lingo2Client", args=args)
+
+
+icon_paths["lingo2_ico"] = f"ap:{__name__}/logo.png"
+component = Component("Lingo 2 Client", component_type=Type.CLIENT, func=launch_client,
+                      description="Open Lingo 2.", supports_uri=True, game_name="Lingo 2", icon="lingo2_ico")
+components.append(component)
@@ -0,0 +1,10 @@
+extends "res://scripts/nodes/allowNumbers.gd"
+
+
+func _readier():
+        var ap = global.get_node("Archipelago")
+        var gamedata = global.get_node("Gamedata")
+
+        var item_id = gamedata.objects.get_special_ids()["Numbers"]
+        if ap.client.getItemAmount(item_id) >= 1:
+                global.allow_numbers = true
@@ -0,0 +1,49 @@
+extends Node
+
+var apworld_reader
+
+
+func _init(path):
+        apworld_reader = ZIPReader.new()
+        apworld_reader.open(path)
+
+
+func _get_true_path(path):
+        if path.begins_with("../"):
+                return "lingo2/%s" % path.substr(3)
+        else:
+                return "lingo2/client/%s" % path
+
+
+func path_exists(path):
+        var true_path = _get_true_path(path)
+        return apworld_reader.file_exists(true_path)
+
+
+func load_script(path):
+        var true_path = _get_true_path(path)
+
+        var script = GDScript.new()
+        script.source_code = apworld_reader.read_file(true_path).get_string_from_utf8()
+        script.reload()
+
+        return script
+
+
+func read_path(path):
+        var true_path = _get_true_path(path)
+        return apworld_reader.read_file(true_path)
+
+
+func load_script_as_scene(path, scene_name):
+        var script = load_script(path)
+        var instance = script.new()
+        instance.name = scene_name
+
+        get_tree().unload_current_scene()
+        _load_scene.call_deferred(instance)
+
+
+func _load_scene(instance):
+        get_tree().get_root().add_child(instance)
+        get_tree().current_scene = instance
@@ -0,0 +1,318 @@
+extends Node
+
+const ap_version = {"major": 0, "minor": 6, "build": 3, "class": "Version"}
+
+var SCRIPT_websocketserver
+
+var _server
+var _should_process = false
+
+var _remote_version = {"major": 0, "minor": 0, "build": 0}
+var _gen_version = {"major": 0, "minor": 0, "build": 0}
+
+var ap_server = ""
+var ap_user = ""
+var ap_pass = ""
+
+var _seed = ""
+var _team = 0
+var _slot = 0
+var _checked_locations = []
+var _checked_worldports = []
+var _received_indexes = []
+var _received_items = {}
+var _slot_data = {}
+var _accessible_locations = []
+var _accessible_worldports = []
+var _goal_accessible = false
+var _latched_doors = []
+var _hinted_locations = []
+
+signal could_not_connect
+signal connect_status
+signal client_connected(slot_data)
+signal item_received(item, amount)
+signal location_scout_received(location_id, item_name, player_name, flags, for_self)
+signal text_message_received(message)
+signal item_sent_notification(message)
+signal hint_received(message)
+signal door_latched(id)
+signal accessible_locations_updated
+signal checked_locations_updated
+signal ignored_locations_updated(locations)
+signal checked_worldports_updated
+signal keyboard_update_received
+signal hinted_locations_updated
+
+
+func _init():
+        set_process_mode(Node.PROCESS_MODE_ALWAYS)
+
+        global._print("Instantiated APClient")
+
+
+func _ready():
+        _server = SCRIPT_websocketserver.new()
+        _server.client_connected.connect(_on_web_socket_server_client_connected)
+        _server.client_disconnected.connect(_on_web_socket_server_client_disconnected)
+        _server.message_received.connect(_on_web_socket_server_message_received)
+        add_child(_server)
+        _server.listen(43182)
+
+
+func _reset_state():
+        _should_process = false
+        _received_items = {}
+        _received_indexes = []
+        _checked_worldports = []
+        _accessible_locations = []
+        _accessible_worldports = []
+        _goal_accessible = false
+
+
+func disconnect_from_ap():
+        sendMessage([{"cmd": "Disconnect"}])
+
+
+func _on_web_socket_server_client_connected(peer_id: int) -> void:
+        var peer: WebSocketPeer = _server.peers[peer_id]
+        print("Remote client connected: %d. Protocol: %s" % [peer_id, peer.get_selected_protocol()])
+        _server.send(-peer_id, "[%d] connected" % peer_id)
+
+
+func _on_web_socket_server_client_disconnected(peer_id: int) -> void:
+        var peer: WebSocketPeer = _server.peers[peer_id]
+        print(
+                (
+                        "Remote client disconnected: %d. Code: %d, Reason: %s"
+                        % [peer_id, peer.get_close_code(), peer.get_close_reason()]
+                )
+        )
+        _server.send(-peer_id, "[%d] disconnected" % peer_id)
+
+
+func _on_web_socket_server_message_received(_peer_id: int, packet: String) -> void:
+        global._print("Got data from server: " + packet)
+        var json = JSON.new()
+        var jserror = json.parse(packet)
+        if jserror != OK:
+                global._print("Error parsing packet from AP: " + jserror.error_string)
+                return
+
+        for message in json.data:
+                var cmd = message["cmd"]
+                global._print("Received command: " + cmd)
+
+                if cmd == "Connected":
+                        _seed = message["seed_name"]
+                        _remote_version = message["version"]
+                        _gen_version = message["generator_version"]
+                        _team = message["team"]
+                        _slot = message["slot"]
+                        _slot_data = message["slot_data"]
+
+                        _checked_locations = []
+                        for location in message["checked_locations"]:
+                                _checked_locations.append(int(location))
+
+                        client_connected.emit(_slot_data)
+
+                elif cmd == "ConnectionRefused":
+                        could_not_connect.emit(message["text"])
+                        global._print("Connection to AP refused")
+
+                elif cmd == "UpdateLocations":
+                        for location in message["locations"]:
+                                var lint = int(location)
+                                if not _checked_locations.has(lint):
+                                        _checked_locations.append(lint)
+
+                        checked_locations_updated.emit()
+
+                elif cmd == "UpdateWorldports":
+                        for port_id in message["worldports"]:
+                                var lint = int(port_id)
+                                if not _checked_worldports.has(lint):
+                                        _checked_worldports.append(lint)
+
+                        checked_worldports_updated.emit()
+
+                elif cmd == "ItemReceived":
+                        for item in message["items"]:
+                                var index = int(item["index"])
+                                if _received_indexes.has(index):
+                                        # Do not re-process items.
+                                        continue
+
+                                _received_indexes.append(index)
+
+                                var item_id = int(item["id"])
+                                _received_items[item_id] = _received_items.get(item_id, 0) + 1
+
+                                item_received.emit(item, _received_items[item_id])
+
+                elif cmd == "TextMessage":
+                        text_message_received.emit(message["data"])
+
+                elif cmd == "ItemSentNotif":
+                        item_sent_notification.emit(message)
+
+                elif cmd == "HintReceived":
+                        hint_received.emit(message)
+
+                elif cmd == "LocationInfo":
+                        for loc in message["locations"]:
+                                location_scout_received.emit(
+                                        int(loc["id"]), loc["item"], loc["player"], int(loc["flags"]), int(loc["self"])
+                                )
+
+                elif cmd == "AccessibleLocations":
+                        _accessible_locations.clear()
+                        _accessible_worldports.clear()
+
+                        for loc in message["locations"]:
+                                _accessible_locations.append(int(loc))
+
+                        if "worldports" in message:
+                                for port_id in message["worldports"]:
+                                        _accessible_worldports.append(int(port_id))
+
+                        _goal_accessible = bool(message.get("goal", false))
+
+                        accessible_locations_updated.emit()
+
+                elif cmd == "UpdateKeyboard":
+                        var updates = {}
+                        for k in message["updates"]:
+                                updates[k] = int(message["updates"][k])
+
+                        keyboard_update_received.emit(updates)
+
+                elif cmd == "PathReply":
+                        var textclient = global.get_node("Textclient")
+                        textclient.display_logical_path(
+                                message["type"], int(message.get("id", null)), message["path"]
+                        )
+
+                elif cmd == "UpdateLatches":
+                        for id in message["latches"]:
+                                var iid = int(id)
+                                if not _latched_doors.has(iid):
+                                        _latched_doors.append(iid)
+
+                                door_latched.emit(iid)
+
+                elif cmd == "SetIgnoredLocations":
+                        var locs = []
+                        for id in message["locations"]:
+                                locs.append(int(id))
+
+                        ignored_locations_updated.emit(locs)
+
+                elif cmd == "UpdateHintedLocations":
+                        for id in message["locations"]:
+                                var iid = int(id)
+                                if !_hinted_locations.has(iid):
+                                        _hinted_locations.append(iid)
+
+                        hinted_locations_updated.emit()
+
+
+func connectToServer(server, un, pw):
+        sendMessage([{"cmd": "Connect", "server": server, "player": un, "password": pw}])
+
+        ap_server = server
+        ap_user = un
+        ap_pass = pw
+
+        _should_process = true
+
+        connect_status.emit("Connecting...")
+
+
+func sendMessage(msg):
+        var payload = JSON.stringify(msg)
+        _server.send(0, payload)
+
+
+func connectToRoom():
+        connect_status.emit("Authenticating...")
+
+        sendMessage(
+                [
+                        {
+                                "cmd": "Connect",
+                                "password": ap_pass,
+                                "game": "Lingo 2",
+                                "name": ap_user,
+                        }
+                ]
+        )
+
+
+func requestSync():
+        sendMessage([{"cmd": "Sync"}])
+
+
+func sendLocation(loc_id):
+        sendMessage([{"cmd": "LocationChecks", "locations": [loc_id]}])
+
+
+func sendLocations(loc_ids):
+        sendMessage([{"cmd": "LocationChecks", "locations": loc_ids}])
+
+
+func say(textdata):
+        sendMessage([{"cmd": "Say", "text": textdata}])
+
+
+func completedGoal():
+        sendMessage([{"cmd": "StatusUpdate", "status": 30}])  # CLIENT_GOAL
+
+
+func scoutLocations(loc_ids):
+        sendMessage([{"cmd": "LocationScouts", "locations": loc_ids}])
+
+
+func updateKeyboard(updates):
+        sendMessage([{"cmd": "UpdateKeyboard", "keyboard": updates}])
+
+
+func checkWorldport(port_id):
+        if not _checked_worldports.has(port_id):
+                sendMessage([{"cmd": "CheckWorldport", "port_id": port_id}])
+
+
+func latchDoor(id):
+        if not _latched_doors.has(id):
+                _latched_doors.append(id)
+
+                sendMessage([{"cmd": "LatchDoor", "door": id}])
+
+
+func getLogicalPath(object_type, object_id):
+        var msg = {"cmd": "GetPath", "type": object_type}
+        if object_id != null:
+                msg["id"] = object_id
+
+        sendMessage([msg])
+
+
+func addIgnoredLocation(loc_id):
+        sendMessage([{"cmd": "IgnoreLocation", "id": loc_id}])
+
+
+func removeIgnoredLocation(loc_id):
+        sendMessage([{"cmd": "UnignoreLocation", "id": loc_id}])
+
+
+func sendQuit():
+        sendMessage([{"cmd": "Quit"}])
+
+
+func hasItem(item_id):
+        return _received_items.has(item_id)
+
+
+func getItemAmount(item_id):
+        return _received_items.get(item_id, 0)
@@ -0,0 +1,66 @@
+extends Node2D
+
+const RADIUS = 48
+
+var _font
+
+
+func _ready():
+        _font = load("res://assets/fonts/Lingo2.ttf")
+
+
+func _draw():
+        draw_circle(Vector2.ZERO, RADIUS, Color(1.0, 1.0, 1.0, 0.8), true)
+        draw_circle(Vector2.ZERO, RADIUS, Color.BLACK, false)
+        draw_string(
+                _font,
+                Vector2(-4, -RADIUS * 3.0 / 4.0),
+                "N",
+                HorizontalAlignment.HORIZONTAL_ALIGNMENT_LEFT,
+                -1,
+                16,
+                Color.BLACK
+        )
+        draw_set_transform(Vector2.ZERO, PI / 2)
+        draw_string(
+                _font,
+                Vector2(-4, -RADIUS * 3.0 / 4.0),
+                "E",
+                HorizontalAlignment.HORIZONTAL_ALIGNMENT_LEFT,
+                -1,
+                16,
+                Color.BLACK
+        )
+        draw_set_transform(Vector2.ZERO, PI)
+        draw_string(
+                _font,
+                Vector2(-4, -RADIUS * 3.0 / 4.0),
+                "S",
+                HorizontalAlignment.HORIZONTAL_ALIGNMENT_LEFT,
+                -1,
+                16,
+                Color.BLACK
+        )
+        draw_set_transform(Vector2.ZERO, PI * 3.0 / 2.0)
+        draw_string(
+                _font,
+                Vector2(-4, -RADIUS * 3.0 / 4.0),
+                "W",
+                HorizontalAlignment.HORIZONTAL_ALIGNMENT_LEFT,
+                -1,
+                16,
+                Color.BLACK
+        )
+        draw_set_transform(Vector2.ZERO)
+        draw_colored_polygon(
+                PackedVector2Array(
+                        [Vector2(0, -RADIUS * 5.0 / 8.0), Vector2(-RADIUS / 6.0, 0), Vector2(RADIUS / 6.0, 0)]
+                ),
+                Color.RED
+        )
+        draw_colored_polygon(
+                PackedVector2Array(
+                        [Vector2(0, RADIUS * 5.0 / 8.0), Vector2(-RADIUS / 6.0, 0), Vector2(RADIUS / 6.0, 0)]
+                ),
+                Color.GRAY
+        )
@@ -0,0 +1,17 @@
+extends CanvasLayer
+
+var SCRIPT_compass
+
+var compass
+
+
+func _ready():
+        compass = SCRIPT_compass.new()
+        compass.position = Vector2(1840, 80)
+        add_child(compass)
+
+        visible = false
+
+
+func update_rotation(ry):
+        compass.rotation = ry
@@ -0,0 +1,75 @@
+extends "res://scripts/nodes/door.gd"
+
+var door_id
+var item_id
+var item_amount
+var latched = false
+
+
+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")
+        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")
+                else:
+                        var door_data = gamedata.objects.get_doors()[door_id]
+                        if door_data.has_latch() and door_data.get_latch():
+                                _check_latched.call_deferred(door_id)
+
+                                latched = true
+
+        if global.map == "the_sun_temple":
+                if name == "spe_EndPlatform" or name == "spe_entry_2":
+                        senders = [NodePath("/root/scene/Panels/EndCheck_dog")]
+
+        if global.map == "the_parthenon":
+                if name == "spe_entry_1":
+                        senders = [NodePath("/root/scene/Panels/EndCheck_dog")]
+
+        super._ready()
+
+
+func _readier():
+        var ap = global.get_node("Archipelago")
+
+        if ap.client.getItemAmount(item_id) >= item_amount:
+                handleTriggered()
+
+
+func _check_latched(door_id):
+        var ap = global.get_node("Archipelago")
+
+        if ap.client._latched_doors.has(door_id):
+                triggered = total
+                handleTriggered()
+
+
+func handleTriggered():
+        super.handleTriggered()
+
+        if latched and ran:
+                var ap = global.get_node("Archipelago")
+                ap.client.latchDoor(door_id)
+
+
+func handleUntriggered():
+        if not latched or not ran:
+                super.handleUntriggered()
@@ -0,0 +1,32 @@
+extends CanvasLayer
+
+var _label
+
+var _disconnected = false
+
+
+func _ready():
+        _label = Label.new()
+        _label.name = "Label"
+        _label.offset_left = 20
+        _label.offset_top = 20
+        _label.horizontal_alignment = HORIZONTAL_ALIGNMENT_LEFT
+        _label.vertical_alignment = VERTICAL_ALIGNMENT_TOP
+        _label.theme = preload("res://assets/themes/baseUI.tres")
+        _label.add_theme_font_size_override("font_size", 36)
+        add_child(_label)
+
+
+func set_connection_lost(arg):
+        _disconnected = arg
+
+        _update_label()
+
+
+func _update_label():
+        var text = []
+
+        if _disconnected:
+                text.append("Disconnected from multiworld.")
+
+        _label.text = "\n".join(text)
@@ -0,0 +1,302 @@
+extends Node
+
+var SCRIPT_proto
+
+var objects
+var door_id_by_map_node_path = {}
+var painting_id_by_map_node_path = {}
+var panel_id_by_map_node_path = {}
+var port_id_by_map_node_path = {}
+var door_id_by_ap_id = {}
+var map_id_by_name = {}
+var progressive_id_by_ap_id = {}
+var letter_id_by_ap_id = {}
+var symbol_item_ids = []
+var anti_trap_ids = {}
+var location_name_by_id = {}
+var ending_display_name_by_name = {}
+var port_id_by_ap_id = {}
+
+var kSYMBOL_ITEMS
+
+
+func _init(proto_script):
+        SCRIPT_proto = proto_script
+
+        kSYMBOL_ITEMS = {
+                SCRIPT_proto.PuzzleSymbol.SUN: "Sun Symbol",
+                SCRIPT_proto.PuzzleSymbol.SPARKLES: "Sparkles Symbol",
+                SCRIPT_proto.PuzzleSymbol.ZERO: "Zero Symbol",
+                SCRIPT_proto.PuzzleSymbol.EXAMPLE: "Example Symbol",
+                SCRIPT_proto.PuzzleSymbol.BOXES: "Boxes Symbol",
+                SCRIPT_proto.PuzzleSymbol.PLANET: "Planet Symbol",
+                SCRIPT_proto.PuzzleSymbol.PYRAMID: "Pyramid Symbol",
+                SCRIPT_proto.PuzzleSymbol.CROSS: "Cross Symbol",
+                SCRIPT_proto.PuzzleSymbol.SWEET: "Sweet Symbol",
+                SCRIPT_proto.PuzzleSymbol.GENDER: "Gender Symbol",
+                SCRIPT_proto.PuzzleSymbol.AGE: "Age Symbol",
+                SCRIPT_proto.PuzzleSymbol.SOUND: "Sound Symbol",
+                SCRIPT_proto.PuzzleSymbol.ANAGRAM: "Anagram Symbol",
+                SCRIPT_proto.PuzzleSymbol.JOB: "Job Symbol",
+                SCRIPT_proto.PuzzleSymbol.STARS: "Stars Symbol",
+                SCRIPT_proto.PuzzleSymbol.NULL: "Null Symbol",
+                SCRIPT_proto.PuzzleSymbol.EVAL: "Eval Symbol",
+                SCRIPT_proto.PuzzleSymbol.LINGO: "Lingo Symbol",
+                SCRIPT_proto.PuzzleSymbol.QUESTION: "Question Symbol",
+        }
+
+
+func load(data_bytes):
+        objects = SCRIPT_proto.AllObjects.new()
+
+        var result_code = objects.from_bytes(data_bytes)
+        if result_code != SCRIPT_proto.PB_ERR.NO_ERRORS:
+                print("Could not load generated data: %d" % result_code)
+                return
+
+        for map in objects.get_maps():
+                map_id_by_name[map.get_name()] = map.get_id()
+
+        for door in objects.get_doors():
+                var map = objects.get_maps()[door.get_map_id()]
+
+                if not map.get_name() in door_id_by_map_node_path:
+                        door_id_by_map_node_path[map.get_name()] = {}
+
+                var map_data = door_id_by_map_node_path[map.get_name()]
+                for receiver in door.get_receivers():
+                        map_data[receiver] = door.get_id()
+
+                for painting_id in door.get_move_paintings():
+                        var painting = objects.get_paintings()[painting_id]
+                        map_data[painting.get_path()] = door.get_id()
+
+                if door.has_ap_id():
+                        door_id_by_ap_id[door.get_ap_id()] = door.get_id()
+
+                        if (
+                                door.get_type() == SCRIPT_proto.DoorType.STANDARD
+                                or door.get_type() == SCRIPT_proto.DoorType.LOCATION_ONLY
+                                or door.get_type() == SCRIPT_proto.DoorType.GRAVESTONE
+                        ):
+                                location_name_by_id[door.get_ap_id()] = _get_door_location_name(door)
+
+        for painting in objects.get_paintings():
+                var room = objects.get_rooms()[painting.get_room_id()]
+                var map = objects.get_maps()[room.get_map_id()]
+
+                if not map.get_name() in painting_id_by_map_node_path:
+                        painting_id_by_map_node_path[map.get_name()] = {}
+
+                var _map_data = painting_id_by_map_node_path[map.get_name()]
+
+        for port in objects.get_ports():
+                var room = objects.get_rooms()[port.get_room_id()]
+                var map = objects.get_maps()[room.get_map_id()]
+
+                if not map.get_name() in port_id_by_map_node_path:
+                        port_id_by_map_node_path[map.get_name()] = {}
+
+                var map_data = port_id_by_map_node_path[map.get_name()]
+                map_data[port.get_path()] = port.get_id()
+
+                if port.has_ap_id():
+                        port_id_by_ap_id[port.get_ap_id()] = port.get_id()
+
+        for progressive in objects.get_progressives():
+                progressive_id_by_ap_id[progressive.get_ap_id()] = progressive.get_id()
+
+        for letter in objects.get_letters():
+                letter_id_by_ap_id[letter.get_ap_id()] = letter.get_id()
+                location_name_by_id[letter.get_ap_id()] = _get_letter_location_name(letter)
+
+        for mastery in objects.get_masteries():
+                location_name_by_id[mastery.get_ap_id()] = _get_mastery_location_name(mastery)
+
+        for ending in objects.get_endings():
+                var location_name = _get_ending_location_name(ending)
+                location_name_by_id[ending.get_ap_id()] = location_name
+                ending_display_name_by_name[ending.get_name()] = location_name
+
+        for keyholder in objects.get_keyholders():
+                if keyholder.has_key():
+                        location_name_by_id[keyholder.get_ap_id()] = _get_keyholder_location_name(keyholder)
+
+        for panel in objects.get_panels():
+                var room = objects.get_rooms()[panel.get_room_id()]
+                var map = objects.get_maps()[room.get_map_id()]
+
+                if not map.get_name() in panel_id_by_map_node_path:
+                        panel_id_by_map_node_path[map.get_name()] = {}
+
+                var map_data = panel_id_by_map_node_path[map.get_name()]
+                map_data[panel.get_path()] = panel.get_id()
+
+        for symbol_name in kSYMBOL_ITEMS.values():
+                symbol_item_ids.append(objects.get_special_ids()[symbol_name])
+
+        for special_name in objects.get_special_ids().keys():
+                if special_name.begins_with("Anti "):
+                        anti_trap_ids[objects.get_special_ids()[special_name]] = (
+                                special_name.substr(5).to_lower()
+                        )
+
+
+func get_door_for_map_node_path(map_name, node_path):
+        if not door_id_by_map_node_path.has(map_name):
+                return null
+
+        var map_data = door_id_by_map_node_path[map_name]
+        return map_data.get(node_path, null)
+
+
+func get_panel_for_map_node_path(map_name, node_path):
+        if not panel_id_by_map_node_path.has(map_name):
+                return null
+
+        var map_data = panel_id_by_map_node_path[map_name]
+        return map_data.get(node_path, null)
+
+
+func get_port_for_map_node_path(map_name, node_path):
+        if not port_id_by_map_node_path.has(map_name):
+                return null
+
+        var map_data = port_id_by_map_node_path[map_name]
+        return map_data.get(node_path, null)
+
+
+func get_door_ap_id(door_id):
+        var door = objects.get_doors()[door_id]
+        if door.has_ap_id():
+                return door.get_ap_id()
+        else:
+                return null
+
+
+func get_door_map_name(door_id):
+        var door = objects.get_doors()[door_id]
+        var map = objects.get_maps()[door.get_map_id()]
+        return map.get_name()
+
+
+func get_door_receivers(door_id):
+        var door = objects.get_doors()[door_id]
+        return door.get_receivers()
+
+
+func get_worldport_display_name(port_id):
+        var port = objects.get_ports()[port_id]
+        return "%s - %s" % [_get_room_object_map_name(port), port.get_display_name()]
+
+
+func _get_map_object_map_name(obj):
+        return objects.get_maps()[obj.get_map_id()].get_display_name()
+
+
+func _get_room_object_map_name(obj):
+        return _get_map_object_map_name(objects.get_rooms()[obj.get_room_id()])
+
+
+func _get_room_object_location_prefix(obj):
+        var room = objects.get_rooms()[obj.get_room_id()]
+        var game_map = objects.get_maps()[room.get_map_id()]
+
+        if room.has_panel_display_name():
+                return "%s (%s)" % [game_map.get_display_name(), room.get_panel_display_name()]
+        else:
+                return game_map.get_display_name()
+
+
+func _get_door_location_name(door):
+        var map_part = _get_room_object_location_prefix(door)
+
+        if door.has_location_name():
+                return "%s - %s" % [map_part, door.get_location_name()]
+
+        var generated_location_name = _get_generated_door_location_name(door)
+        if generated_location_name != null:
+                return generated_location_name
+
+        return "%s - %s" % [map_part, door.get_name()]
+
+
+func _get_generated_door_location_name(door):
+        if door.get_type() != SCRIPT_proto.DoorType.STANDARD:
+                return null
+
+        if (
+                door.get_keyholders().size() > 0
+                or (door.has_white_ending() and door.get_white_ending())
+                or door.has_complete_at()
+        ):
+                return null
+
+        if door.get_panels().size() > 4:
+                return null
+
+        var map_areas = []
+        for panel_id in door.get_panels():
+                var panel = objects.get_panels()[panel_id.get_panel()]
+                var panel_room = objects.get_rooms()[panel.get_room_id()]
+                # It's okay if panel_display_name is not present because then it's coalesced with other unnamed areas.
+                var panel_display_name = ""
+                if panel_room.has_panel_display_name():
+                        panel_display_name = panel_room.get_panel_display_name()
+                if not map_areas.has(panel_display_name):
+                        map_areas.append(panel_display_name)
+
+        if map_areas.size() > 1:
+                return null
+
+        var game_map = objects.get_maps()[door.get_map_id()]
+        var map_area = map_areas[0]
+        var map_part
+        if map_area == "":
+                map_part = game_map.get_display_name()
+        else:
+                map_part = "%s (%s)" % [game_map.get_display_name(), map_area]
+
+        var panel_names = []
+        for panel_id in door.get_panels():
+                var panel_data = objects.get_panels()[panel_id.get_panel()]
+                var panel_name
+                if panel_data.has_display_name():
+                        panel_name = panel_data.get_display_name()
+                else:
+                        panel_name = panel_data.get_name()
+
+                var location_part
+                if panel_id.has_answer():
+                        location_part = "%s/%s" % [panel_name, panel_id.get_answer().to_upper()]
+                else:
+                        location_part = panel_name
+
+                panel_names.append(location_part)
+
+        panel_names.sort()
+
+        return map_part + " - " + ", ".join(panel_names)
+
+
+func _get_letter_location_name(letter):
+        var letter_level = 2 if (letter.has_level2() and letter.get_level2()) else 1
+        var letter_name = "%s%d" % [letter.get_key().to_upper(), letter_level]
+        return "%s - %s" % [_get_room_object_map_name(letter), letter_name]
+
+
+func _get_mastery_location_name(mastery):
+        return "%s - Mastery" % _get_room_object_map_name(mastery)
+
+
+func _get_ending_location_name(ending):
+        return (
+                "%s - %s Ending" % [_get_room_object_map_name(ending), ending.get_name().to_pascal_case()]
+        )
+
+
+func _get_keyholder_location_name(keyholder):
+        return (
+                "%s - %s Keyholder"
+                % [_get_room_object_location_prefix(keyholder), keyholder.get_key().to_upper()]
+        )
@@ -4,6 +4,7 @@ const kALL_LETTERS = "abcdefghjiklmnopqrstuvwxyz"
 
 var letters_saved = {}
 var letters_in_keyholders = []
+var letters_blocked = []
 var letters_dynamic = {}
 var keyholder_state = {}
 
@@ -17,6 +18,7 @@ func _init():
 func reset():
         letters_saved.clear()
         letters_in_keyholders.clear()
+        letters_blocked.clear()
         letters_dynamic.clear()
         keyholder_state.clear()
 
@@ -46,6 +48,9 @@ func load_seed():
                 if localdata.size() > 2:
                         keyholder_state = localdata[2]
 
+        if not letters_saved.is_empty():
+                ap.client.updateKeyboard(letters_saved)
+
         for k in kALL_LETTERS:
                 var level = 0
 
@@ -79,23 +84,47 @@ func save():
 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:
+                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):
+        var ap = global.get_node("Archipelago")
+        var true_level = 0
+
+        if ap.get_letter_behavior(key, false) == ap.kLETTER_BEHAVIOR_VANILLA:
+                true_level += 1
+        if level == 2 and ap.get_letter_behavior(key, true) == ap.kLETTER_BEHAVIOR_VANILLA:
+                true_level += 1
+
+        if true_level < letters_saved.get(key, 0):
                 return
 
-        letters_saved[key] = level
+        letters_saved[key] = true_level
+
+        ap.client.updateKeyboard({key: true_level})
+
+        if letters_blocked.has(key):
+                letters_blocked.erase(key)
 
         update_unlocks()
         save()
@@ -107,6 +136,9 @@ func collect_remote_letter(key, level):
 
         letters_dynamic[key] = level
 
+        if letters_blocked.has(key):
+                letters_blocked.erase(key)
+
         update_unlocks()
         save()
 
@@ -140,6 +172,13 @@ func remove_from_keyholder(key, map, kh_path):
         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]
@@ -152,9 +191,11 @@ func load_keyholders(map):
 
 
 func reset_keyholders():
-        if letters_in_keyholders.is_empty():
+        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(
@@ -163,8 +204,28 @@ func reset_keyholders():
 
         keyholder_state.clear()
         letters_in_keyholders.clear()
+        letters_blocked.clear()
 
         update_unlocks()
         save()
 
-        return true
+        return cleared_anything
+
+
+func remote_keyboard_updated(updates):
+        var reverse = {}
+        var should_update = false
+
+        for k in updates:
+                if not letters_saved.has(k) or updates[k] > letters_saved[k]:
+                        letters_saved[k] = updates[k]
+                        should_update = true
+                elif updates[k] < letters_saved[k]:
+                        reverse[k] = letters_saved[k]
+
+        if should_update:
+                update_unlocks()
+
+        if not reverse.is_empty():
+                var ap = global.get_node("Archipelago")
+                ap.client.updateKeyboard(reverse)
@@ -0,0 +1,308 @@
+extends Node
+
+
+func _ready():
+        var runtime = global.get_node("Runtime")
+
+        # Some helpful logging.
+        if Steam.isSubscribed():
+                global._print("Provisioning successful! Build ID: %d" % Steam.getAppBuildId())
+        else:
+                global._print("Provisioning failed.")
+
+        # Undo the load screen removing our cursor
+        get_tree().get_root().set_disable_input(false)
+        Input.set_mouse_mode(Input.MOUSE_MODE_VISIBLE)
+
+        # Increase the WebSocket input buffer size so that we can download large
+        # data packages.
+        ProjectSettings.set_setting("network/limits/websocket_client/max_in_buffer_kb", 8192)
+
+        switcher.layer = 4
+
+        # Create the global AP manager, if it doesn't already exist.
+        if not global.has_node("Archipelago"):
+                var ap_script = runtime.load_script("manager.gd")
+                var ap_instance = ap_script.new()
+                ap_instance.name = "Archipelago"
+
+                ap_instance.SCRIPT_client = runtime.load_script("client.gd")
+                ap_instance.SCRIPT_keyboard = runtime.load_script("keyboard.gd")
+                ap_instance.SCRIPT_locationListener = runtime.load_script("locationListener.gd")
+                ap_instance.SCRIPT_minimap = runtime.load_script("minimap.gd")
+                ap_instance.SCRIPT_victoryListener = runtime.load_script("victoryListener.gd")
+                ap_instance.SCRIPT_websocketserver = runtime.load_script("vendor/WebSocketServer.gd")
+
+                global.add_child(ap_instance)
+
+                # Let's also inject any scripts we need to inject now.
+                installScriptExtension(runtime.load_script("allowNumbers.gd"))
+                installScriptExtension(runtime.load_script("animationListener.gd"))
+                installScriptExtension(runtime.load_script("collectable.gd"))
+                installScriptExtension(runtime.load_script("door.gd"))
+                installScriptExtension(runtime.load_script("keyHolder.gd"))
+                installScriptExtension(runtime.load_script("keyHolderChecker.gd"))
+                installScriptExtension(runtime.load_script("keyHolderResetterListener.gd"))
+                installScriptExtension(runtime.load_script("painting.gd"))
+                installScriptExtension(runtime.load_script("paintingAuto.gd"))
+                installScriptExtension(runtime.load_script("panel.gd"))
+                installScriptExtension(runtime.load_script("pauseMenu.gd"))
+                installScriptExtension(runtime.load_script("player.gd"))
+                installScriptExtension(runtime.load_script("saver.gd"))
+                installScriptExtension(runtime.load_script("teleport.gd"))
+                installScriptExtension(runtime.load_script("teleportListener.gd"))
+                installScriptExtension(runtime.load_script("unlockReaderListener.gd"))
+                installScriptExtension(runtime.load_script("visibilityListener.gd"))
+                installScriptExtension(runtime.load_script("worldport.gd"))
+                installScriptExtension(runtime.load_script("worldportListener.gd"))
+
+                var proto_script = runtime.load_script("../generated/proto.gd")
+                var gamedata_script = runtime.load_script("gamedata.gd")
+                var gamedata_instance = gamedata_script.new(proto_script)
+                gamedata_instance.load(runtime.read_path("../generated/data.binpb"))
+                gamedata_instance.name = "Gamedata"
+                global.add_child(gamedata_instance)
+
+                var messages_script = runtime.load_script("messages.gd")
+                var messages_instance = messages_script.new()
+                messages_instance.name = "Messages"
+                messages_instance.SCRIPT_rainbowText = runtime.load_script("rainbowText.gd")
+                global.add_child(messages_instance)
+
+                var effects_script = runtime.load_script("effects.gd")
+                var effects_instance = effects_script.new()
+                effects_instance.name = "Effects"
+                global.add_child(effects_instance)
+
+                var textclient_script = runtime.load_script("textclient.gd")
+                var textclient_instance = textclient_script.new()
+                textclient_instance.name = "Textclient"
+                global.add_child(textclient_instance)
+
+                var compass_overlay_script = runtime.load_script("compass_overlay.gd")
+                var compass_overlay_instance = compass_overlay_script.new()
+                compass_overlay_instance.name = "Compass"
+                compass_overlay_instance.SCRIPT_compass = runtime.load_script("compass.gd")
+                global.add_child(compass_overlay_instance)
+
+                unlocks.data["advanced_mastery"] = ""
+                unlocks.data["charismatic_mastery"] = ""
+                unlocks.data["crystalline_mastery"] = ""
+                unlocks.data["fuzzy_mastery"] = ""
+                unlocks.data["icarus_mastery"] = ""
+                unlocks.data["stellar_mastery"] = ""
+
+        var ap = global.get_node("Archipelago")
+        var gamedata = global.get_node("Gamedata")
+        ap.ap_connected.connect(connectionSuccessful)
+        ap.could_not_connect.connect(connectionUnsuccessful)
+        ap.connect_status.connect(connectionStatus)
+
+        # Populate textboxes with AP settings.
+        get_node("../Panel/server_box").text = ap.ap_server
+        get_node("../Panel/player_box").text = ap.ap_user
+        get_node("../Panel/password_box").text = ap.ap_pass
+
+        var history_box = get_node("../Panel/connection_history")
+        if ap.connection_history.is_empty():
+                history_box.disabled = true
+        else:
+                history_box.disabled = false
+
+                var i = 0
+                for details in ap.connection_history:
+                        history_box.get_popup().add_item("%s (%s)" % [details[1], details[0]], i)
+                        i += 1
+
+        history_box.get_popup().id_pressed.connect(historySelected)
+
+        # Show client version.
+        var version = gamedata.objects.get_version()
+        get_node("../Panel/title").text = (
+                "ARCHIPELAGO (%d.%d.%d)" % [version.get_major(), version.get_minor(), version.get_patch()]
+        )
+
+        # Increase font size in text boxes.
+        get_node("../Panel/server_box").add_theme_font_size_override("font_size", 36)
+        get_node("../Panel/player_box").add_theme_font_size_override("font_size", 36)
+        get_node("../Panel/password_box").add_theme_font_size_override("font_size", 36)
+
+        # Set up version mismatch dialog.
+        get_node("../Panel/VersionMismatch").confirmed.connect(startGame)
+        get_node("../Panel/VersionMismatch").get_cancel_button().pressed.connect(
+                versionMismatchDeclined
+        )
+
+        # Set up buttons.
+        get_node("../Panel/connect_button").pressed.connect(_connect_pressed)
+        get_node("../Panel/quit_button").pressed.connect(_back_pressed)
+
+
+func _connect_pressed():
+        get_node("../Panel/connect_button").disabled = true
+
+        var ap = global.get_node("Archipelago")
+        ap.ap_server = get_node("../Panel/server_box").text
+        ap.ap_user = get_node("../Panel/player_box").text
+        ap.ap_pass = get_node("../Panel/password_box").text
+        ap.saveSettings()
+
+        ap.connectToServer()
+
+
+func _back_pressed():
+        var ap = global.get_node("Archipelago")
+        ap.disconnect_from_ap()
+        ap.client.sendQuit()
+
+        get_tree().quit()
+
+
+# Adapted from https://gitlab.com/Delta-V-Modding/Mods/-/blob/main/game/ModLoader.gd
+func installScriptExtension(childScript: Resource):
+        # Force Godot to compile the script now.
+        # We need to do this here to ensure that the inheritance chain is
+        # properly set up, and multiple mods can chain-extend the same
+        # class multiple times.
+        # This is also needed to make Godot instantiate the extended class
+        # when creating singletons.
+        # The actual instance is thrown away.
+        childScript.new()
+
+        var parentScript = childScript.get_base_script()
+        var parentScriptPath = parentScript.resource_path
+        global._print("ModLoader: Installing script extension over %s" % parentScriptPath)
+        childScript.take_over_path(parentScriptPath)
+
+
+func connectionStatus(message):
+        var popup = get_node("../Panel/AcceptDialog")
+        popup.title = "Connecting to Archipelago"
+        popup.dialog_text = message
+        popup.exclusive = true
+        popup.get_ok_button().visible = false
+        popup.popup_centered()
+
+
+func connectionSuccessful():
+        var ap = global.get_node("Archipelago")
+        var gamedata = global.get_node("Gamedata")
+
+        # Check for major version mismatch.
+        if ap.apworld_version[0] != gamedata.objects.get_version().get_major():
+                get_node("../Panel/AcceptDialog").exclusive = false
+
+                var popup = get_node("../Panel/VersionMismatch")
+                popup.title = "Version Mismatch!"
+                popup.dialog_text = (
+                        "This slot was generated using v%d.%d.%d of the Lingo 2 apworld,\nwhich has a different major version than this client (v%d.%d.%d).\nIt is highly recommended to play using the correct version of the client.\nYou may experience bugs or logic issues if you continue."
+                        % [
+                                ap.apworld_version[0],
+                                ap.apworld_version[1],
+                                ap.apworld_version[2],
+                                gamedata.objects.get_version().get_major(),
+                                gamedata.objects.get_version().get_minor(),
+                                gamedata.objects.get_version().get_patch()
+                        ]
+                )
+                popup.exclusive = true
+                popup.popup_centered()
+
+                return
+
+        startGame()
+
+
+func startGame():
+        var ap = global.get_node("Archipelago")
+
+        # Save connection details
+        var connection_details = [ap.ap_server, ap.ap_user, ap.ap_pass]
+        if ap.connection_history.has(connection_details):
+                ap.connection_history.erase(connection_details)
+        ap.connection_history.push_front(connection_details)
+        if ap.connection_history.size() > 10:
+                ap.connection_history.resize(10)
+        ap.saveSettings()
+
+        # Switch to the_entry
+        Input.set_mouse_mode(Input.MOUSE_MODE_CAPTURED)
+        global.user = ap.getSaveFileName()
+        global.universe = "lingo"
+        global.map = "the_entry"
+
+        unlocks.resetCollectables()
+        unlocks.resetData()
+        unlocks.loadCollectables()
+        unlocks.loadData()
+
+        ap.setup_keys()
+
+        unlocks.unlockKey("capslock", 1)
+
+        if ap.shuffle_worldports:
+                settings.worldport_fades = "default"
+        else:
+                settings.worldport_fades = "never"
+
+        clearResourceCache("res://objects/meshes/gridDoor.tscn")
+        clearResourceCache("res://objects/nodes/allowNumbers.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/unlockReaderListener.tscn")
+        clearResourceCache("res://objects/nodes/listeners/visibilityListener.tscn")
+        clearResourceCache("res://objects/nodes/listeners/worldportListener.tscn")
+        clearResourceCache("res://objects/nodes/panel.tscn")
+        clearResourceCache("res://objects/nodes/player.tscn")
+        clearResourceCache("res://objects/nodes/saver.tscn")
+        clearResourceCache("res://objects/nodes/teleport.tscn")
+        clearResourceCache("res://objects/nodes/worldport.tscn")
+        clearResourceCache("res://objects/scenes/menus/pause_menu.tscn")
+
+        var paintings_dir = DirAccess.open("res://objects/meshes/paintings")
+        if paintings_dir:
+                paintings_dir.list_dir_begin()
+                var file_name = paintings_dir.get_next()
+                while file_name != "":
+                        if not paintings_dir.current_is_dir() and file_name.ends_with(".tscn"):
+                                clearResourceCache("res://objects/meshes/paintings/" + file_name)
+                        file_name = paintings_dir.get_next()
+
+        switcher.switch_map.call_deferred("res://objects/scenes/the_entry.tscn")
+
+
+func connectionUnsuccessful(error_message):
+        get_node("../Panel/connect_button").disabled = false
+
+        var popup = get_node("../Panel/AcceptDialog")
+        popup.title = "Could not connect to Archipelago"
+        popup.dialog_text = error_message
+        popup.exclusive = true
+        popup.get_ok_button().visible = true
+        popup.popup_centered()
+
+
+func versionMismatchDeclined():
+        get_node("../Panel/AcceptDialog").hide()
+        get_node("../Panel/connect_button").disabled = false
+
+        var ap = global.get_node("Archipelago")
+        ap.disconnect_from_ap()
+
+
+func historySelected(index):
+        var ap = global.get_node("Archipelago")
+        var details = ap.connection_history[index]
+
+        get_node("../Panel/server_box").text = details[0]
+        get_node("../Panel/player_box").text = details[1]
+        get_node("../Panel/password_box").text = details[2]
+
+
+func clearResourceCache(path):
+        ResourceLoader.load(path, "", ResourceLoader.CACHE_MODE_REPLACE)
@@ -0,0 +1,717 @@
+extends Node
+
+var SCRIPT_client
+var SCRIPT_keyboard
+var SCRIPT_locationListener
+var SCRIPT_minimap
+var SCRIPT_victoryListener
+var SCRIPT_websocketserver
+
+var ap_server = ""
+var ap_user = ""
+var ap_pass = ""
+var connection_history = []
+var show_compass = false
+var show_locations = false
+var show_minimap = false
+
+var client
+var keyboard
+
+var _localdata_file = ""
+var _last_new_item = -1
+var _batch_locations = false
+var _held_locations = []
+var _held_location_scouts = []
+var _location_scouts = {}
+var _item_locks = {}
+var _inverse_item_locks = {}
+var _held_letters = {}
+var _letters_setup = false
+var _already_connected = false
+var _ignored_locations = []
+var _map_scripts = {}
+
+const kSHUFFLE_LETTERS_VANILLA = 0
+const kSHUFFLE_LETTERS_UNLOCKED = 1
+const kSHUFFLE_LETTERS_PROGRESSIVE = 2
+const kSHUFFLE_LETTERS_VANILLA_CYAN = 3
+const kSHUFFLE_LETTERS_ITEM_CYAN = 4
+
+const kLETTER_BEHAVIOR_VANILLA = 0
+const kLETTER_BEHAVIOR_ITEM = 1
+const kLETTER_BEHAVIOR_UNLOCKED = 2
+
+const kCYAN_DOOR_BEHAVIOR_H2 = 0
+const kCYAN_DOOR_BEHAVIOR_DOUBLE_LETTER = 1
+const kCYAN_DOOR_BEHAVIOR_ITEM = 2
+
+const kEndingNameByVictoryValue = {
+        0: "GRAY",
+        1: "PURPLE",
+        2: "MINT",
+        3: "BLACK",
+        4: "BLUE",
+        5: "CYAN",
+        6: "RED",
+        7: "PLUM",
+        8: "ORANGE",
+        9: "GOLD",
+        10: "YELLOW",
+        11: "GREEN",
+        12: "WHITE",
+}
+
+var apworld_version = [0, 0, 0]
+var cyan_door_behavior = kCYAN_DOOR_BEHAVIOR_H2
+var daedalus_roof_access = false
+var enable_gift_maps = []
+var enable_icarus = false
+var endings_requirement = 0
+var keyholder_sanity = false
+var masteries_requirement = 0
+var port_pairings = {}
+var shuffle_control_center_colors = false
+var shuffle_doors = false
+var shuffle_gallery_paintings = false
+var shuffle_letters = kSHUFFLE_LETTERS_VANILLA
+var shuffle_symbols = false
+var shuffle_worldports = false
+var strict_cyan_ending = false
+var strict_purple_ending = false
+var victory_condition = -1
+
+var color_by_material_path = {}
+
+signal could_not_connect
+signal connect_status
+signal ap_connected
+
+
+func _init():
+        # Read AP settings from file, if there are any
+        if FileAccess.file_exists("user://ap_settings"):
+                var file = FileAccess.open("user://ap_settings", FileAccess.READ)
+                var data = file.get_var(true)
+                file.close()
+
+                if typeof(data) != TYPE_ARRAY:
+                        global._print("AP settings file is corrupted")
+                        data = []
+
+                if data.size() > 0:
+                        ap_server = data[0]
+
+                if data.size() > 1:
+                        ap_user = data[1]
+
+                if data.size() > 2:
+                        ap_pass = data[2]
+
+                if data.size() > 3:
+                        connection_history = data[3]
+
+                if data.size() > 4:
+                        show_compass = data[4]
+
+                if data.size() > 5:
+                        show_locations = data[5]
+
+                if data.size() > 6:
+                        show_minimap = data[6]
+
+        # We need to create a mapping from material paths to the original colors of
+        # those materials. We force reload the materials, overwriting any custom
+        # textures, and create the mapping. We then reload the textures in case the
+        # player had a custom one enabled.
+        var directory = DirAccess.open("res://assets/materials")
+        for material_name in directory.get_files():
+                var material = ResourceLoader.load(
+                        "res://assets/materials/" + material_name, "", ResourceLoader.CACHE_MODE_REPLACE
+                )
+
+                color_by_material_path[material.resource_path] = Color(material.albedo_color)
+
+        settings.load_user_textures()
+
+
+func _ready():
+        client = SCRIPT_client.new()
+        client.SCRIPT_websocketserver = SCRIPT_websocketserver
+
+        client.item_received.connect(_process_item)
+        client.location_scout_received.connect(_process_location_scout)
+        client.text_message_received.connect(_process_text_message)
+        client.item_sent_notification.connect(_process_item_sent_notification)
+        client.hint_received.connect(_process_hint_received)
+        client.accessible_locations_updated.connect(_on_accessible_locations_updated)
+        client.checked_locations_updated.connect(_on_checked_locations_updated)
+        client.ignored_locations_updated.connect(_on_ignored_locations_updated)
+        client.hinted_locations_updated.connect(_on_hinted_locations_updated)
+        client.checked_worldports_updated.connect(_on_checked_worldports_updated)
+        client.door_latched.connect(_on_door_latched)
+
+        client.could_not_connect.connect(_client_could_not_connect)
+        client.connect_status.connect(_client_connect_status)
+        client.client_connected.connect(_client_connected)
+
+        add_child(client)
+
+        keyboard = SCRIPT_keyboard.new()
+        add_child(keyboard)
+        client.keyboard_update_received.connect(keyboard.remote_keyboard_updated)
+
+
+func saveSettings():
+        # Save the AP settings to disk.
+        var path = "user://ap_settings"
+        var file = FileAccess.open(path, FileAccess.WRITE)
+
+        var data = [
+                ap_server,
+                ap_user,
+                ap_pass,
+                connection_history,
+                show_compass,
+                show_locations,
+                show_minimap,
+        ]
+        file.store_var(data, true)
+        file.close()
+
+
+func saveLocaldata():
+        # Save the MW/slot specific settings to disk.
+        var dir = DirAccess.open("user://")
+        var folder = "archipelago_data"
+        if not dir.dir_exists(folder):
+                dir.make_dir(folder)
+
+        var file = FileAccess.open(_localdata_file, FileAccess.WRITE)
+
+        var data = [
+                _last_new_item,
+        ]
+        file.store_var(data, true)
+        file.close()
+
+
+func connectToServer():
+        _last_new_item = -1
+        _batch_locations = false
+        _held_locations = []
+        _held_location_scouts = []
+        _location_scouts = {}
+        _letters_setup = false
+        _held_letters = {}
+        _already_connected = false
+
+        client.connectToServer(ap_server, ap_user, ap_pass)
+
+
+func getSaveFileName():
+        return "zzAP_%s_%d" % [client._seed, client._slot]
+
+
+func disconnect_from_ap():
+        _already_connected = false
+
+        var effects = global.get_node("Effects")
+        effects.set_connection_lost(false)
+
+        client.disconnect_from_ap()
+
+
+func get_item_id_for_door(door_id):
+        return _item_locks.get(door_id, null)
+
+
+func _process_item(item, amount):
+        var gamedata = global.get_node("Gamedata")
+
+        var item_id = int(item["id"])
+        var prog_id = null
+        if _inverse_item_locks.has(item_id):
+                for lock in _inverse_item_locks.get(item_id):
+                        if lock[1] != amount:
+                                continue
+
+                        if gamedata.progressive_id_by_ap_id.has(item_id):
+                                prog_id = lock[0]
+
+                        if gamedata.get_door_map_name(lock[0]) != global.map:
+                                continue
+
+                        # TODO: fix doors opening from door groups
+                        var receivers = gamedata.get_door_receivers(lock[0])
+                        var scene = get_tree().get_root().get_node_or_null("scene")
+                        if scene != null:
+                                for receiver in receivers:
+                                        var rnode = scene.get_node_or_null(receiver)
+                                        if rnode != null:
+                                                rnode.handleTriggered()
+
+        var letter_id = gamedata.letter_id_by_ap_id.get(item_id, null)
+        if letter_id != null:
+                var letter = gamedata.objects.get_letters()[letter_id]
+                if not letter.has_level2() or not letter.get_level2():
+                        _process_key_item(letter.get_key(), amount)
+
+        if gamedata.symbol_item_ids.has(item_id):
+                var player = get_tree().get_root().get_node_or_null("scene/player")
+                if player != null:
+                        player.evaluate_solvability.emit()
+
+        if item_id == gamedata.objects.get_special_ids()["A Job Well Done"]:
+                update_job_well_done_sign()
+
+        if item_id == gamedata.objects.get_special_ids()["Numbers"] and global.map == "the_fuzzy":
+                global.allow_numbers = true
+
+        # Show a message about the item if it's new.
+        if int(item["index"]) > _last_new_item:
+                _last_new_item = int(item["index"])
+                saveLocaldata()
+
+                var full_item_name = item["text"]
+                if prog_id != null:
+                        var door = gamedata.objects.get_doors()[prog_id]
+                        full_item_name = "%s (%s)" % [full_item_name, door.get_name()]
+
+                var message
+                if "sender" in item:
+                        message = (
+                                "Received %s from %s"
+                                % [wrapInItemColorTags(full_item_name, item["flags"]), item["sender"]]
+                        )
+                else:
+                        message = "Found %s" % wrapInItemColorTags(full_item_name, item["flags"])
+
+                if gamedata.anti_trap_ids.has(item):
+                        keyboard.block_letter(gamedata.anti_trap_ids[item])
+
+                global._print(message)
+
+                global.get_node("Messages").showMessage(message)
+
+
+func _process_item_sent_notification(message):
+        var sentMsg = (
+                "Sent %s to %s"
+                % [
+                        wrapInItemColorTags(message["item_name"], message["item_flags"]),
+                        message["receiver_name"]
+                ]
+        )
+        #if _hinted_locations.has(message["item"]["location"]):
+        #       sentMsg += " ([color=#fafad2]Hinted![/color])"
+        global.get_node("Messages").showMessage(sentMsg)
+
+
+func _process_hint_received(message):
+        var is_for = ""
+        if message["self"] == 0:
+                is_for = " for %s" % message["receiver_name"]
+
+        global.get_node("Messages").showMessage(
+                (
+                        "Hint: %s%s is on %s"
+                        % [
+                                wrapInItemColorTags(message["item_name"], message["item_flags"]),
+                                is_for,
+                                message["location_name"]
+                        ]
+                )
+        )
+
+
+func _process_text_message(message):
+        var parts = []
+        for message_part in message:
+                if message_part["type"] == "text":
+                        parts.append(message_part["text"])
+                elif message_part["type"] == "player":
+                        if message_part["self"] == 1:
+                                parts.append("[color=#ee00ee]%s[/color]" % message_part["text"])
+                        else:
+                                parts.append("[color=#fafad2]%s[/color]" % message_part["text"])
+                elif message_part["type"] == "item":
+                        parts.append(wrapInItemColorTags(message_part["text"], int(message_part["flags"])))
+                elif message_part["type"] == "location":
+                        parts.append("[color=#00ff7f]%s[/color]" % message_part["text"])
+
+        var textclient_node = global.get_node("Textclient")
+        if textclient_node != null:
+                textclient_node.parse_printjson("".join(parts))
+
+
+func _process_location_scout(location_id, item_name, player_name, flags, for_self):
+        _location_scouts[location_id] = {
+                "item": item_name, "player": player_name, "flags": flags, "for_self": for_self
+        }
+
+        if for_self and flags & 4 != 0:
+                # This is a trap for us, so let's not display it.
+                return
+
+        var gamedata = global.get_node("Gamedata")
+        var map_id = gamedata.map_id_by_name.get(global.map)
+
+        var letter_id = gamedata.letter_id_by_ap_id.get(location_id, null)
+        if letter_id != null:
+                var letter = gamedata.objects.get_letters()[letter_id]
+                var room = gamedata.objects.get_rooms()[letter.get_room_id()]
+                if room.get_map_id() == map_id:
+                        var collectable = get_tree().get_root().get_node("scene").get_node_or_null(
+                                letter.get_path()
+                        )
+                        if collectable != null:
+                                collectable.setScoutedText(item_name)
+
+
+func _on_accessible_locations_updated():
+        var textclient_node = global.get_node("Textclient")
+        if textclient_node != null:
+                textclient_node.update_locations()
+
+
+func _on_checked_locations_updated():
+        var textclient_node = global.get_node("Textclient")
+        if textclient_node != null:
+                textclient_node.update_locations(false)
+
+
+func _on_checked_worldports_updated():
+        var textclient_node = global.get_node("Textclient")
+        if textclient_node != null:
+                textclient_node.update_locations()
+                textclient_node.update_worldports()
+
+
+func _on_ignored_locations_updated(locations):
+        _ignored_locations = locations
+
+        var textclient_node = global.get_node("Textclient")
+        if textclient_node != null:
+                textclient_node.update_locations()
+
+
+func _on_hinted_locations_updated():
+        var textclient_node = global.get_node("Textclient")
+        if textclient_node != null:
+                textclient_node.update_locations()
+
+
+func _on_door_latched(door_id):
+        var gamedata = global.get_node("Gamedata")
+        if gamedata.get_door_map_name(door_id) != global.map:
+                return
+
+        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()
+
+
+func _client_could_not_connect(message):
+        could_not_connect.emit(message)
+
+        if global.loaded:
+                var effects = global.get_node("Effects")
+                effects.set_connection_lost(true)
+
+                var messages = global.get_node("Messages")
+                messages.showMessage("Connection to multiworld lost.")
+
+
+func _client_connect_status(message):
+        connect_status.emit(message)
+
+
+func _client_connected(slot_data):
+        var effects = global.get_node("Effects")
+        effects.set_connection_lost(false)
+
+        if _already_connected:
+                var messages = global.get_node("Messages")
+                messages.showMessage("Reconnected to multiworld!")
+                return
+
+        _already_connected = true
+
+        var gamedata = global.get_node("Gamedata")
+
+        _localdata_file = "user://archipelago_data/%s_%d" % [client._seed, client._slot]
+        _last_new_item = -1
+
+        if FileAccess.file_exists(_localdata_file):
+                var ap_file = FileAccess.open(_localdata_file, FileAccess.READ)
+                var localdata = []
+                if ap_file != null:
+                        localdata = ap_file.get_var(true)
+                        ap_file.close()
+
+                if typeof(localdata) != TYPE_ARRAY:
+                        print("AP localdata file is corrupted")
+                        localdata = []
+
+                if localdata.size() > 0:
+                        _last_new_item = localdata[0]
+
+        # Read slot data.
+        cyan_door_behavior = int(slot_data.get("cyan_door_behavior", 0))
+        daedalus_roof_access = bool(slot_data.get("daedalus_roof_access", false))
+        enable_gift_maps = slot_data.get("enable_gift_maps", [])
+        enable_icarus = bool(slot_data.get("enable_icarus", false))
+        endings_requirement = int(slot_data.get("endings_requirement", 0))
+        keyholder_sanity = bool(slot_data.get("keyholder_sanity", false))
+        masteries_requirement = int(slot_data.get("masteries_requirement", 0))
+        shuffle_control_center_colors = bool(slot_data.get("shuffle_control_center_colors", false))
+        shuffle_doors = bool(slot_data.get("shuffle_doors", false))
+        shuffle_gallery_paintings = bool(slot_data.get("shuffle_gallery_paintings", false))
+        shuffle_letters = int(slot_data.get("shuffle_letters", 0))
+        shuffle_symbols = bool(slot_data.get("shuffle_symbols", false))
+        shuffle_worldports = bool(slot_data.get("shuffle_worldports", false))
+        strict_cyan_ending = bool(slot_data.get("strict_cyan_ending", false))
+        strict_purple_ending = bool(slot_data.get("strict_purple_ending", false))
+        victory_condition = int(slot_data.get("victory_condition", 0))
+
+        if slot_data.has("version"):
+                var version_msg = slot_data["version"]
+                apworld_version = [int(version_msg[0]), int(version_msg[1]), 0]
+                if version_msg.size() > 2:
+                        apworld_version[2] = int(version_msg[2])
+
+        port_pairings.clear()
+        if slot_data.has("port_pairings"):
+                var raw_pp = slot_data.get("port_pairings")
+
+                for p1 in raw_pp.keys():
+                        port_pairings[gamedata.port_id_by_ap_id[int(p1)]] = gamedata.port_id_by_ap_id[int(
+                                raw_pp[p1]
+                        )]
+
+        # Set up item locks.
+        _item_locks = {}
+
+        if shuffle_doors:
+                for door in gamedata.objects.get_doors():
+                        if (
+                                door.get_type() == gamedata.SCRIPT_proto.DoorType.STANDARD
+                                or door.get_type() == gamedata.SCRIPT_proto.DoorType.ITEM_ONLY
+                        ):
+                                _item_locks[door.get_id()] = [door.get_ap_id(), 1]
+
+                for progressive in gamedata.objects.get_progressives():
+                        for i in range(0, progressive.get_doors().size()):
+                                var door = gamedata.objects.get_doors()[progressive.get_doors()[i]]
+                                _item_locks[door.get_id()] = [progressive.get_ap_id(), i + 1]
+
+                for door_group in gamedata.objects.get_door_groups():
+                        if door_group.get_type() == gamedata.SCRIPT_proto.DoorGroupType.CONNECTOR:
+                                if shuffle_worldports:
+                                        continue
+                        elif door_group.get_type() != gamedata.SCRIPT_proto.DoorGroupType.SHUFFLE_GROUP:
+                                continue
+
+                        for door in door_group.get_doors():
+                                _item_locks[door] = [door_group.get_ap_id(), 1]
+
+        if shuffle_control_center_colors:
+                for door in gamedata.objects.get_doors():
+                        if door.get_type() == gamedata.SCRIPT_proto.DoorType.CONTROL_CENTER_COLOR:
+                                _item_locks[door.get_id()] = [door.get_ap_id(), 1]
+
+                for door_group in gamedata.objects.get_door_groups():
+                        if (
+                                door_group.get_type() == gamedata.SCRIPT_proto.DoorGroupType.COLOR_CONNECTOR
+                                and not shuffle_worldports
+                        ):
+                                for door in door_group.get_doors():
+                                        _item_locks[door] = [door_group.get_ap_id(), 1]
+
+        if shuffle_gallery_paintings:
+                for door in gamedata.objects.get_doors():
+                        if door.get_type() == gamedata.SCRIPT_proto.DoorType.GALLERY_PAINTING:
+                                _item_locks[door.get_id()] = [door.get_ap_id(), 1]
+
+        if cyan_door_behavior == kCYAN_DOOR_BEHAVIOR_ITEM:
+                for door_group in gamedata.objects.get_door_groups():
+                        if door_group.get_type() == gamedata.SCRIPT_proto.DoorGroupType.CYAN_DOORS:
+                                for door in door_group.get_doors():
+                                        if not _item_locks.has(door):
+                                                _item_locks[door] = [door_group.get_ap_id(), 1]
+
+        # Create a reverse item locks map for processing items.
+        _inverse_item_locks = {}
+
+        for door_id in _item_locks.keys():
+                var lock = _item_locks.get(door_id)
+
+                if not _inverse_item_locks.has(lock[0]):
+                        _inverse_item_locks[lock[0]] = []
+
+                _inverse_item_locks[lock[0]].append([door_id, lock[1]])
+
+        if shuffle_worldports:
+                var textclient = global.get_node("Textclient")
+                textclient.setup_worldports()
+
+        ap_connected.emit()
+
+
+func start_batching_locations():
+        _batch_locations = true
+
+
+func send_location(loc_id):
+        if client._checked_locations.has(loc_id):
+                return
+
+        if _batch_locations:
+                _held_locations.append(loc_id)
+        else:
+                client.sendLocation(loc_id)
+
+
+func scout_location(loc_id):
+        if _location_scouts.has(loc_id):
+                return _location_scouts.get(loc_id)
+
+        if _batch_locations:
+                _held_location_scouts.append(loc_id)
+        else:
+                client.scoutLocation(loc_id)
+
+        return null
+
+
+func stop_batching_locations():
+        _batch_locations = false
+
+        if not _held_locations.is_empty():
+                client.sendLocations(_held_locations)
+                _held_locations.clear()
+
+        if not _held_location_scouts.is_empty():
+                client.scoutLocations(_held_location_scouts)
+                _held_location_scouts.clear()
+
+
+func colorForItemType(flags):
+        var int_flags = int(flags)
+        if int_flags & 1:  # progression
+                if int_flags & 2:  # proguseful
+                        return "#f0d200"
+                else:
+                        return "#bc51e0"
+        elif int_flags & 2:  # useful
+                return "#2b67ff"
+        elif int_flags & 4:  # trap
+                return "#d63a22"
+        else:  # filler
+                return "#14de9e"
+
+
+func wrapInItemColorTags(text, flags):
+        var int_flags = int(flags)
+        if int_flags & 1 and int_flags & 2:  # proguseful
+                return "[rainbow]%s[/rainbow]" % text
+        else:
+                return "[color=%s]%s[/color]" % [colorForItemType(flags), text]
+
+
+func get_letter_behavior(key, level2):
+        if shuffle_letters == kSHUFFLE_LETTERS_UNLOCKED:
+                return kLETTER_BEHAVIOR_UNLOCKED
+
+        if [kSHUFFLE_LETTERS_VANILLA_CYAN, kSHUFFLE_LETTERS_ITEM_CYAN].has(shuffle_letters):
+                if level2:
+                        if shuffle_letters == kSHUFFLE_LETTERS_VANILLA_CYAN:
+                                return kLETTER_BEHAVIOR_VANILLA
+                        else:
+                                return kLETTER_BEHAVIOR_ITEM
+                else:
+                        return kLETTER_BEHAVIOR_UNLOCKED
+
+        if not level2 and ["h", "i", "n", "t"].has(key):
+                # This differs from the equivalent function in the apworld. Logically it is
+                # the same as UNLOCKED since they are in the starting room, but VANILLA
+                # means the player still has to actually pick up the letters.
+                return kLETTER_BEHAVIOR_VANILLA
+
+        if shuffle_letters == kSHUFFLE_LETTERS_PROGRESSIVE:
+                return kLETTER_BEHAVIOR_ITEM
+
+        return kLETTER_BEHAVIOR_VANILLA
+
+
+func setup_keys():
+        keyboard.load_seed()
+
+        _letters_setup = true
+
+        for k in _held_letters.keys():
+                _process_key_item(k, _held_letters[k])
+
+        _held_letters.clear()
+
+
+func _process_key_item(key, level):
+        if not _letters_setup:
+                _held_letters[key] = max(_held_letters.get(key, 0), level)
+                return
+
+        if shuffle_letters == kSHUFFLE_LETTERS_ITEM_CYAN:
+                level += 1
+
+        keyboard.collect_remote_letter(key, level)
+
+
+func update_job_well_done_sign():
+        if global.map != "daedalus":
+                return
+
+        var gamedata = global.get_node("Gamedata")
+        var job_item = gamedata.objects.get_special_ids()["A Job Well Done"]
+        var jobs_done = client.getItemAmount(job_item)
+
+        var sign2 = get_tree().get_root().get_node_or_null("scene/Meshes/Miscellaneous/sign2")
+        var sign3 = get_tree().get_root().get_node_or_null("scene/Meshes/Miscellaneous/sign3")
+
+        if sign2 != null and sign3 != null:
+                if jobs_done == 0:
+                        sign2.text = "what are you doing"
+                        sign3.text = "?"
+                elif jobs_done == 1:
+                        sign2.text = "a job well done"
+                        sign3.text = "is its own reward"
+                else:
+                        sign2.text = "%d jobs well done" % jobs_done
+                        sign3.text = "are their own reward"
+
+                sign2.get_node("MeshInstance3D").mesh.text = sign2.text
+                sign3.get_node("MeshInstance3D").mesh.text = sign3.text
+
+
+func toggle_ignored_location(loc_id):
+        if loc_id in _ignored_locations:
+                client.removeIgnoredLocation(loc_id)
+        else:
+                client.addIgnoredLocation(loc_id)
+
+
+func get_map_script(map_name):
+        if !_map_scripts.has(map_name):
+                var runtime = global.get_node("Runtime")
+                var script_path = "maps/%s.gd" % map_name
+                if runtime.path_exists(script_path):
+                        var script = runtime.load_script(script_path)
+                        _map_scripts[map_name] = script.new()
+                else:
+                        _map_scripts[map_name] = null
+
+        return _map_scripts[map_name]
@@ -0,0 +1,85 @@
+func on_map_load(root):
+        var ap = global.get_node("Archipelago")
+
+        # Remove the door blocking the trophy case.
+        root.get_node("/root/scene/Components/Doors/entry_18").queue_free()
+
+        # Set up mastery listeners for extra maps.
+        _set_up_mastery_listener(root, "advanced")
+        _set_up_mastery_listener(root, "charismatic")
+        _set_up_mastery_listener(root, "crystalline")
+        _set_up_mastery_listener(root, "fuzzy")
+        _set_up_mastery_listener(root, "icarus")
+        _set_up_mastery_listener(root, "stellar")
+
+        if ap.endings_requirement != 12 or ap.masteries_requirement != 0:
+                # Set up listeners for the potential White Ending requirements.
+                var merging_prefab = preload("res://objects/nodes/listeners/mergingListener.tscn")
+
+                var old_door = root.get_node("/root/scene/Components/Doors/entry_19")
+                var new_door = old_door.duplicate()
+                new_door.name = "entry_19_new"
+                new_door.senders.clear()
+                new_door.senderGroup.clear()
+                new_door.excludeSenders.clear()
+
+                if ap.endings_requirement == 12:
+                        new_door.senderGroup.append(NodePath("/root/scene/Meshes/Trophies/Listeners"))
+                elif ap.endings_requirement > 0:
+                        if ap.masteries_requirement == 0:
+                                new_door.senderGroup.append(NodePath("/root/scene/Meshes/Trophies/Listeners"))
+                                new_door.complete_at = ap.endings_requirement
+                        else:
+                                var endings_merge = merging_prefab.instantiate()
+                                endings_merge.name = "EndingsMerge"
+                                endings_merge.senderGroup.append(NodePath("/root/scene/Meshes/Trophies/Listeners"))
+                                endings_merge.complete_at = ap.endings_requirement
+                                root.get_node("/root/scene/Components").add_child.call_deferred(endings_merge)
+                                new_door.senders.append(NodePath("/root/scene/Components/EndingsMerge"))
+
+                var max_masteries = 13 + ap.enable_gift_maps.size()
+                if ap.enable_icarus:
+                        max_masteries += 1
+
+                if ap.masteries_requirement == max_masteries:
+                        new_door.senderGroup.append(NodePath("/root/scene/Meshes/Trophies/MasteryListeners"))
+                        new_door.excludeSenders.append(
+                                NodePath("/root/scene/Meshes/Trophies/MasteryListeners/unlockReaderListenerWhite")
+                        )
+                elif ap.masteries_requirement > 0:
+                        if ap.endings_requirement == 0:
+                                new_door.senderGroup.append(
+                                        NodePath("/root/scene/Meshes/Trophies/MasteryListeners")
+                                )
+                                new_door.excludeSenders.append(
+                                        NodePath(
+                                                "/root/scene/Meshes/Trophies/MasteryListeners/unlockReaderListenerWhite"
+                                        )
+                                )
+                                new_door.complete_at = ap.masteries_requirement
+                        else:
+                                var masteries_merge = merging_prefab.instantiate()
+                                masteries_merge.name = "MasteriesMerge"
+                                masteries_merge.senderGroup.append(
+                                        NodePath("/root/scene/Meshes/Trophies/MasteryListeners")
+                                )
+                                masteries_merge.excludeSenders.append(
+                                        NodePath(
+                                                "/root/scene/Meshes/Trophies/MasteryListeners/unlockReaderListenerWhite"
+                                        )
+                                )
+                                masteries_merge.complete_at = ap.masteries_requirement
+                                root.get_node("/root/scene/Components").add_child.call_deferred(masteries_merge)
+                                new_door.senders.append(NodePath("/root/scene/Components/MasteriesMerge"))
+
+                old_door.queue_free()
+                root.get_node("/root/scene/Components/Doors").add_child.call_deferred(new_door)
+
+
+func _set_up_mastery_listener(root, name):
+        var prefab = preload("res://objects/nodes/listeners/unlockReaderListener.tscn")
+        var url = prefab.instantiate()
+        url.name = "unlockReaderListenerMastery_%s" % name
+        url.key = "%s_mastery" % name
+        url.value = "unlocked"
+        root.get_node("/root/scene/Meshes/Trophies/MasteryListeners").add_child.call_deferred(url)
@@ -0,0 +1,85 @@
+func on_map_load(root):
+        var ap = global.get_node("Archipelago")
+
+        # Teleport the direction panels when the stairs are there.
+        var tpl_prefab = preload("res://objects/nodes/listeners/teleportListener.tscn")
+
+        var dir1 = root.get_node("/root/scene/Panels/Castle Entrance/castle_direction_1")
+        var dir1_tpl = tpl_prefab.instantiate()
+        dir1_tpl.target_path = dir1
+        dir1_tpl.teleport_point = Vector3(59.5, 8, -6.5)
+        dir1_tpl.teleport_rotate = Vector3(-45, 0, 0)
+        dir1_tpl.senders.append(NodePath("/root/scene/Panels/Castle Entrance/castle_south"))
+        dir1_tpl.senders.append(NodePath("/root/scene/Panels/Castle Entrance/castle_north"))
+        dir1_tpl.senders.append(NodePath("/root/scene/Panels/Castle Entrance/castle_west"))
+        dir1.add_child.call_deferred(dir1_tpl)
+
+        var dir2 = root.get_node("/root/scene/Panels/Castle Entrance/castle_direction_2")
+        var dir2_tpl = tpl_prefab.instantiate()
+        dir2_tpl.target_path = dir2
+        dir2_tpl.teleport_point = Vector3(59.5, 8, 6.5)
+        dir2_tpl.teleport_rotate = Vector3(-45, -180, 0)
+        dir2_tpl.senders.append(NodePath("/root/scene/Panels/Castle Entrance/castle_south"))
+        dir2_tpl.senders.append(NodePath("/root/scene/Panels/Castle Entrance/castle_north"))
+        dir2_tpl.senders.append(NodePath("/root/scene/Panels/Castle Entrance/castle_west"))
+        dir2.add_child.call_deferred(dir2_tpl)
+
+        var dir3 = root.get_node("/root/scene/Panels/Castle Entrance/castle_direction_3")
+        var dir3_tpl = tpl_prefab.instantiate()
+        dir3_tpl.target_path = dir3
+        dir3_tpl.teleport_point = Vector3(54, 8, 0)
+        dir3_tpl.teleport_rotate = Vector3(-45, 90, 0)
+        dir3_tpl.senders.append(NodePath("/root/scene/Panels/Castle Entrance/castle_south"))
+        dir3_tpl.senders.append(NodePath("/root/scene/Panels/Castle Entrance/castle_north"))
+        dir3_tpl.senders.append(NodePath("/root/scene/Panels/Castle Entrance/castle_west"))
+        dir3.add_child.call_deferred(dir3_tpl)
+
+        # Block off roof access in Daedalus.
+        if not ap.daedalus_roof_access:
+                _set_up_invis_wall(root, 75.5, 11, -24.5, 1, 10, 49)
+                _set_up_invis_wall(root, 51.5, 11, -17, 16, 10, 1)
+                _set_up_invis_wall(root, 46, 10, -9.5, 1, 10, 10)
+                _set_up_invis_wall(root, 67.5, 11, 17, 16, 10, 1)
+                _set_up_invis_wall(root, 50.5, 11, 14, 10, 10, 1)
+                _set_up_invis_wall(root, 39, 10, 18.5, 1, 10, 22)
+                _set_up_invis_wall(root, 20, 15, 18.5, 1, 10, 16)
+                _set_up_invis_wall(root, 11.5, 15, 3, 32, 10, 1)
+                _set_up_invis_wall(root, 11.5, 16, -20, 14, 20, 1)
+                _set_up_invis_wall(root, 14, 16, -26.5, 1, 20, 4)
+                _set_up_invis_wall(root, 28.5, 20.5, -26.5, 1, 15, 25)
+                _set_up_invis_wall(root, 40.5, 20.5, -11, 30, 15, 1)
+                _set_up_invis_wall(root, 50.5, 15, 5.5, 7, 10, 1)
+                _set_up_invis_wall(root, 83.5, 33.5, 5.5, 1, 7, 11)
+                _set_up_invis_wall(root, 83.5, 33.5, -5.5, 1, 7, 11)
+
+                var warp_exit_prefab = preload("res://objects/nodes/exit.tscn")
+                var warp_exit = warp_exit_prefab.instantiate()
+                warp_exit.name = "roof_access_blocker_warp_exit"
+                warp_exit.position = Vector3(58, 10, 0)
+                warp_exit.rotation_degrees.y = 90
+                root.get_node("/root/scene").add_child.call_deferred(warp_exit)
+
+                var warp_enter_prefab = preload("res://objects/nodes/teleportAuto.tscn")
+                var warp_enter = warp_enter_prefab.instantiate()
+                warp_enter.target = warp_exit
+                warp_enter.position = Vector3(76.5, 30, 1)
+                warp_enter.scale = Vector3(4, 1.5, 1)
+                warp_enter.rotation_degrees.y = 90
+                root.get_node("/root/scene").add_child.call_deferred(warp_enter)
+
+
+func _set_up_invis_wall(root, x, y, z, sx, sy, sz):
+        var prefab = preload("res://objects/nodes/block.tscn")
+        var newwall = prefab.instantiate()
+        newwall.position.x = x
+        newwall.position.y = y
+        newwall.position.z = z
+        newwall.scale.x = sz
+        newwall.scale.y = sy
+        newwall.scale.z = sx
+        newwall.set_surface_override_material(0, preload("res://assets/materials/blackMatte.material"))
+        newwall.visibility_range_end = 3
+        newwall.visibility_range_end_margin = 1
+        newwall.visibility_range_fade_mode = RenderingServer.VISIBILITY_RANGE_FADE_SELF
+        newwall.skeleton = ".."
+        root.get_node("/root/scene").add_child.call_deferred(newwall)
@@ -0,0 +1,38 @@
+func on_map_load(root):
+        var ap = global.get_node("Archipelago")
+
+        # Add the mastery to Icarus.
+        if ap.enable_icarus:
+                var collectable_prefab = preload("res://objects/nodes/collectable.tscn")
+                var saver_prefab = preload("res://objects/nodes/saver.tscn")
+                var tpl_prefab = preload("res://objects/nodes/listeners/teleportListener.tscn")
+                var usl_prefab = preload("res://objects/nodes/listeners/unlockSetterListener.tscn")
+
+                var mastery = collectable_prefab.instantiate()
+                mastery.name = "collectable"
+                mastery.position = Vector3(0, -2000, 0)
+                mastery.unlock_type = "smiley"
+                mastery.material_override = load("res://assets/materials/gold.material")
+                root.get_node("/root/scene/Components/Collectables").add_child.call_deferred(mastery)
+
+                var tpl = tpl_prefab.instantiate()
+                tpl.teleport_point = Vector3(56.25, 0, -5.5)
+                tpl.teleport_rotate = Vector3(0, 0, 0)
+                tpl.target_path = mastery
+                tpl.name = "Teleport"
+                tpl.senderGroup.append(NodePath("/root/scene/Panels"))
+                tpl.nested = true
+                mastery.add_child.call_deferred(tpl)
+
+                var usl = usl_prefab.instantiate()
+                usl.name = "unlockSetterListenerMastery"
+                usl.key = "icarus_mastery"
+                usl.value = "unlocked"
+                usl.senders.append(NodePath("/root/scene/Components/Collectables/collectable"))
+                root.get_node("/root/scene/Components").add_child.call_deferred(usl)
+
+                var saver = saver_prefab.instantiate()
+                saver.name = "saver_collectables"
+                saver.type = "collectables"
+                saver.senderGroup.append(NodePath("/root/scene/Components/Collectables"))
+                root.get_node("/root/scene").add_child.call_deferred(saver)
@@ -0,0 +1,36 @@
+func on_map_load(root):
+        # Add the mastery to The Advanced.
+        var collectable_prefab = preload("res://objects/nodes/collectable.tscn")
+        var saver_prefab = preload("res://objects/nodes/saver.tscn")
+        var tpl_prefab = preload("res://objects/nodes/listeners/teleportListener.tscn")
+        var usl_prefab = preload("res://objects/nodes/listeners/unlockSetterListener.tscn")
+
+        var mastery = collectable_prefab.instantiate()
+        mastery.name = "collectable"
+        mastery.position = Vector3(0, -200, -5)
+        mastery.unlock_type = "smiley"
+        mastery.material_override = load("res://assets/materials/gold.material")
+        root.get_node("/root/scene/Components/Collectables").add_child.call_deferred(mastery)
+
+        var tpl = tpl_prefab.instantiate()
+        tpl.teleport_point = Vector3(0, 2, -5)
+        tpl.teleport_rotate = Vector3(0, 0, 0)
+        tpl.target_path = mastery
+        tpl.name = "Teleport"
+        tpl.senders.append(NodePath("/root/scene/Panels/Room_1/panel_29"))
+        tpl.senders.append(NodePath("/root/scene/Panels/Room_1/panel_30"))
+        tpl.senders.append(NodePath("/root/scene/Panels/Room_1/panel_31"))
+        mastery.add_child.call_deferred(tpl)
+
+        var usl = usl_prefab.instantiate()
+        usl.name = "unlockSetterListenerMastery"
+        usl.key = "advanced_mastery"
+        usl.value = "unlocked"
+        usl.senders.append(NodePath("/root/scene/Components/Collectables/collectable"))
+        root.get_node("/root/scene/Components").add_child.call_deferred(usl)
+
+        var saver = saver_prefab.instantiate()
+        saver.name = "saver_collectables"
+        saver.type = "collectables"
+        saver.senderGroup.append(NodePath("/root/scene/Components/Collectables"))
+        root.get_node("/root/scene").add_child.call_deferred(saver)
@@ -0,0 +1,26 @@
+func on_map_load(root):
+        # Add the mastery to The Charismatic.
+        var collectable_prefab = preload("res://objects/nodes/collectable.tscn")
+        var saver_prefab = preload("res://objects/nodes/saver.tscn")
+        var usl_prefab = preload("res://objects/nodes/listeners/unlockSetterListener.tscn")
+
+        var mastery = collectable_prefab.instantiate()
+        mastery.name = "collectable"
+        mastery.position = Vector3(-17, 2, -29)
+        mastery.rotation_degrees = Vector3(0, 45, 0)
+        mastery.unlock_type = "smiley"
+        mastery.material_override = load("res://assets/materials/gold.material")
+        root.get_node("/root/scene/Components/Collectables").add_child.call_deferred(mastery)
+
+        var usl = usl_prefab.instantiate()
+        usl.name = "unlockSetterListenerMastery"
+        usl.key = "charismatic_mastery"
+        usl.value = "unlocked"
+        usl.senders.append(NodePath("/root/scene/Components/Collectables/collectable"))
+        root.get_node("/root/scene/Components").add_child.call_deferred(usl)
+
+        var saver = saver_prefab.instantiate()
+        saver.name = "saver_collectables"
+        saver.type = "collectables"
+        saver.senderGroup.append(NodePath("/root/scene/Components/Collectables"))
+        root.get_node("/root/scene").add_child.call_deferred(saver)
@@ -0,0 +1,34 @@
+func on_map_load(root):
+        # Add the mastery to The Crystalline.
+        var collectable_prefab = preload("res://objects/nodes/collectable.tscn")
+        var saver_prefab = preload("res://objects/nodes/saver.tscn")
+        var tpl_prefab = preload("res://objects/nodes/listeners/teleportListener.tscn")
+        var usl_prefab = preload("res://objects/nodes/listeners/unlockSetterListener.tscn")
+
+        var mastery = collectable_prefab.instantiate()
+        mastery.name = "collectable"
+        mastery.position = Vector3(0, 13, 37)
+        mastery.unlock_type = "smiley"
+        mastery.material_override = load("res://assets/materials/gold.material")
+        root.get_node("/root/scene/Components/Collectables").add_child.call_deferred(mastery)
+
+        var tpl = tpl_prefab.instantiate()
+        tpl.teleport_point = Vector3(0, 11.5, -20)
+        tpl.teleport_rotate = Vector3(0, 0, 180)
+        tpl.target_path = mastery
+        tpl.name = "Teleport"
+        tpl.senders.append(NodePath("/root/scene/Panels/Room_1/panel_3"))
+        mastery.add_child.call_deferred(tpl)
+
+        var usl = usl_prefab.instantiate()
+        usl.name = "unlockSetterListenerMastery"
+        usl.key = "crystalline_mastery"
+        usl.value = "unlocked"
+        usl.senders.append(NodePath("/root/scene/Components/Collectables/collectable"))
+        root.get_node("/root/scene/Components").add_child.call_deferred(usl)
+
+        var saver = saver_prefab.instantiate()
+        saver.name = "saver_collectables"
+        saver.type = "collectables"
+        saver.senderGroup.append(NodePath("/root/scene/Components/Collectables"))
+        root.get_node("/root/scene").add_child.call_deferred(saver)
@@ -0,0 +1,156 @@
+func on_map_load(root):
+        var ap = global.get_node("Archipelago")
+
+        # Remove door behind X1.
+        var door_node = 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"
+        root.get_node("/root/scene").add_child.call_deferred(sign1)
+
+        var sign2 = sign_prefab.instantiate()
+        sign2.position = Vector3(-7, 4, -15.01)
+        sign2.text = "%s ending" % ap.kEndingNameByVictoryValue.get(ap.victory_condition, "?")
+
+        var sign2_color = ap.kEndingNameByVictoryValue.get(ap.victory_condition, "coral").to_lower()
+        if sign2_color == "white":
+                sign2_color = "silver"
+
+        sign2.material = load("res://assets/materials/%s.material" % sign2_color)
+        root.get_node("/root/scene").add_child.call_deferred(sign2)
+
+        # Add the gift map entry panel if needed.
+        if not ap.enable_gift_maps.is_empty():
+                var panel_prefab = preload("res://objects/nodes/panel.tscn")
+                var tpl_prefab = preload("res://objects/nodes/listeners/teleportListener.tscn")
+                var wpl_prefab = preload("res://objects/nodes/listeners/worldportListener.tscn")
+
+                var giftmap_parent = Node.new()
+                giftmap_parent.name = "GiftMapEntrance"
+                root.get_node("/root/scene/Components").add_child.call_deferred(giftmap_parent)
+
+                var symbolless_player = ""
+                for i in range(ap.client.ap_user.length()):
+                        if "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ".contains(
+                                ap.client.ap_user[i]
+                        ):
+                                symbolless_player = symbolless_player + ap.client.ap_user[i].to_lower()
+
+                var giftmap_panel = panel_prefab.instantiate()
+                giftmap_panel.name = "Panel"
+                giftmap_panel.position = Vector3(33.5, -190, 5.5)
+                giftmap_panel.rotation_degrees = Vector3(-45, 0, 0)
+                giftmap_panel.clue = "player"
+                giftmap_panel.answer = symbolless_player
+
+                if ap.enable_gift_maps.has("The Advanced"):
+                        var icely_panel = panel_prefab.instantiate()
+                        icely_panel.name = "IcelyPanel"
+                        icely_panel.answer = "icely"
+                        icely_panel.position = Vector3(33.5, -200, 5.5)
+                        giftmap_panel.proxies.append(NodePath("../IcelyPanel"))
+                        giftmap_parent.add_child.call_deferred(icely_panel)
+
+                        var icely_wpl = wpl_prefab.instantiate()
+                        icely_wpl.name = "IcelyWpl"
+                        icely_wpl.exit = "the_advanced"
+                        icely_wpl.senders.append(NodePath("../IcelyPanel"))
+                        giftmap_parent.add_child.call_deferred(icely_wpl)
+
+                if ap.enable_gift_maps.has("The Charismatic"):
+                        var souvey_panel = panel_prefab.instantiate()
+                        souvey_panel.name = "SouveyPanel"
+                        souvey_panel.answer = "souvey"
+                        souvey_panel.position = Vector3(33.5, -210, 5.5)
+                        giftmap_panel.proxies.append(NodePath("../SouveyPanel"))
+                        giftmap_parent.add_child.call_deferred(souvey_panel)
+
+                        var souvey_wpl = wpl_prefab.instantiate()
+                        souvey_wpl.name = "SouveyWpl"
+                        souvey_wpl.exit = "the_charismatic"
+                        souvey_wpl.senders.append(NodePath("../SouveyPanel"))
+                        giftmap_parent.add_child.call_deferred(souvey_wpl)
+
+                if ap.enable_gift_maps.has("The Crystalline"):
+                        var q_panel = panel_prefab.instantiate()
+                        q_panel.name = "QPanel"
+                        q_panel.answer = "q"
+                        q_panel.position = Vector3(33.5, -220, 5.5)
+                        giftmap_panel.proxies.append(NodePath("../QPanel"))
+                        giftmap_parent.add_child.call_deferred(q_panel)
+
+                        var q_wpl = wpl_prefab.instantiate()
+                        q_wpl.name = "QWpl"
+                        q_wpl.exit = "the_crystalline"
+                        q_wpl.senders.append(NodePath("../QPanel"))
+                        giftmap_parent.add_child.call_deferred(q_wpl)
+
+                if ap.enable_gift_maps.has("The Fuzzy"):
+                        var gongus_panel = panel_prefab.instantiate()
+                        gongus_panel.name = "GongusPanel"
+                        gongus_panel.answer = "gongus"
+                        gongus_panel.position = Vector3(33.5, -260, 5.5)
+                        giftmap_panel.proxies.append(NodePath("../GongusPanel"))
+                        giftmap_parent.add_child.call_deferred(gongus_panel)
+
+                        var kiwi_panel = panel_prefab.instantiate()
+                        kiwi_panel.name = "KiwiPanel"
+                        kiwi_panel.answer = "kiwi"
+                        kiwi_panel.position = Vector3(33.5, -270, 5.5)
+                        giftmap_panel.proxies.append(NodePath("../KiwiPanel"))
+                        giftmap_parent.add_child.call_deferred(kiwi_panel)
+
+                        var fuzzy_wpl = wpl_prefab.instantiate()
+                        fuzzy_wpl.name = "FuzzyWpl"
+                        fuzzy_wpl.exit = "the_fuzzy"
+                        fuzzy_wpl.senders.append(NodePath("../GongusPanel"))
+                        fuzzy_wpl.senders.append(NodePath("../KiwiPanel"))
+                        fuzzy_wpl.complete_at = 1
+                        giftmap_parent.add_child.call_deferred(fuzzy_wpl)
+
+                if ap.enable_gift_maps.has("The Stellar"):
+                        var hatkirby_panel = panel_prefab.instantiate()
+                        hatkirby_panel.name = "HatkirbyPanel"
+                        hatkirby_panel.answer = "hatkirby"
+                        hatkirby_panel.position = Vector3(33.5, -230, 5.5)
+                        giftmap_panel.proxies.append(NodePath("../HatkirbyPanel"))
+                        giftmap_parent.add_child.call_deferred(hatkirby_panel)
+
+                        var kirby_panel = panel_prefab.instantiate()
+                        kirby_panel.name = "KirbyPanel"
+                        kirby_panel.answer = "kirby"
+                        kirby_panel.position = Vector3(33.5, -240, 5.5)
+                        giftmap_panel.proxies.append(NodePath("../KirbyPanel"))
+                        giftmap_parent.add_child.call_deferred(kirby_panel)
+
+                        var star_panel = panel_prefab.instantiate()
+                        star_panel.name = "StarPanel"
+                        star_panel.answer = "star"
+                        star_panel.position = Vector3(33.5, -250, 5.5)
+                        giftmap_panel.proxies.append(NodePath("../StarPanel"))
+                        giftmap_parent.add_child.call_deferred(star_panel)
+
+                        var stellar_wpl = wpl_prefab.instantiate()
+                        stellar_wpl.name = "StellarWpl"
+                        stellar_wpl.exit = "the_stellar"
+                        stellar_wpl.senders.append(NodePath("../HatkirbyPanel"))
+                        stellar_wpl.senders.append(NodePath("../KirbyPanel"))
+                        stellar_wpl.senders.append(NodePath("../StarPanel"))
+                        stellar_wpl.complete_at = 1
+                        giftmap_parent.add_child.call_deferred(stellar_wpl)
+
+                giftmap_parent.add_child.call_deferred(giftmap_panel)
+
+                var giftmap_tpl = tpl_prefab.instantiate()
+                giftmap_tpl.name = "PanelTeleporter"
+                giftmap_tpl.teleport_point = Vector3(33.5, 1, 5.5)
+                giftmap_tpl.teleport_rotate = Vector3(-45, 0, 0)
+                giftmap_tpl.target_path = giftmap_panel
+                giftmap_tpl.senders.append(
+                        NodePath("/root/scene/Components/Listeners/unlockReaderListenerDoubles")
+                )
+                giftmap_parent.add_child.call_deferred(giftmap_tpl)
@@ -0,0 +1,25 @@
+func on_map_load(root):
+        # Add the mastery to The Fuzzy.
+        var collectable_prefab = preload("res://objects/nodes/collectable.tscn")
+        var saver_prefab = preload("res://objects/nodes/saver.tscn")
+        var usl_prefab = preload("res://objects/nodes/listeners/unlockSetterListener.tscn")
+
+        var mastery = collectable_prefab.instantiate()
+        mastery.name = "collectable"
+        mastery.position = Vector3(0, 2, -20)
+        mastery.unlock_type = "smiley"
+        mastery.material_override = load("res://assets/materials/gold.material")
+        root.get_node("/root/scene/Components/Collectables").add_child.call_deferred(mastery)
+
+        var usl = usl_prefab.instantiate()
+        usl.name = "unlockSetterListenerMastery"
+        usl.key = "fuzzy_mastery"
+        usl.value = "unlocked"
+        usl.senders.append(NodePath("/root/scene/Components/Collectables/collectable"))
+        root.get_node("/root/scene/Components").add_child.call_deferred(usl)
+
+        var saver = saver_prefab.instantiate()
+        saver.name = "saver_collectables"
+        saver.type = "collectables"
+        saver.senderGroup.append(NodePath("/root/scene/Components/Collectables"))
+        root.get_node("/root/scene").add_child.call_deferred(saver)
@@ -0,0 +1,51 @@
+func on_map_load(root):
+        var ap = global.get_node("Archipelago")
+
+        # Add the strict cyan ending validation.
+        if ap.strict_cyan_ending:
+                var panel_prefab = preload("res://objects/nodes/panel.tscn")
+                var tpl_prefab = preload("res://objects/nodes/listeners/teleportListener.tscn")
+                var reverse_prefab = preload("res://objects/nodes/listeners/reversingListener.tscn")
+
+                var previous_panel = null
+                var next_y = -100
+                var words = ["quick", "brown", "fox", "jumps", "over", "the", "lazy", "dog"]
+                for word in words:
+                        var panel = panel_prefab.instantiate()
+                        panel.position = Vector3(0, next_y, 0)
+                        next_y -= 10
+                        panel.clue = word
+                        panel.symbol = "."
+                        panel.answer = "%s%s" % [word, word]
+                        panel.name = "EndCheck_%s" % word
+
+                        var tpl = tpl_prefab.instantiate()
+                        tpl.teleport_point = Vector3(0, 1, -11)
+                        tpl.teleport_rotate = Vector3(-45, 0, 0)
+                        tpl.target_path = panel
+                        tpl.name = "Teleport"
+
+                        if previous_panel == null:
+                                tpl.senderGroup.append(NodePath("/root/scene/Panels/Rulers"))
+                        else:
+                                tpl.senders.append(NodePath("../../%s" % previous_panel.name))
+
+                        var reversing = reverse_prefab.instantiate()
+                        reversing.senders.append(NodePath(".."))
+                        reversing.name = "Reversing"
+                        tpl.senders.append(NodePath("../Reversing"))
+
+                        panel.add_child.call_deferred(tpl)
+                        panel.add_child.call_deferred(reversing)
+                        root.get_node("/root/scene/Panels").add_child.call_deferred(panel)
+
+                        previous_panel = panel
+
+                # Duplicate the door that usually waits on the rulers. We can't set the
+                # senders here for some reason so we actually set them in the door ready
+                # function.
+                var entry1 = root.get_node("/root/scene/Components/Doors/entry_1")
+                var entry12 = entry1.duplicate()
+                entry12.name = "spe_entry_1"
+                entry1.get_parent().add_child.call_deferred(entry12)
+                entry1.queue_free()
@@ -0,0 +1,4 @@
+func on_map_load(root):
+        # Move the Plaza RTE trigger outside of the turtle.
+        var rte_trigger = root.get_node("/root/scene/Components/Warps/triggerArea")
+        rte_trigger.position.z = 0
@@ -0,0 +1,30 @@
+func on_map_load(root):
+        # Add the mastery to The Stellar.
+        var collectable_prefab = preload("res://objects/nodes/collectable.tscn")
+        var saver_prefab = preload("res://objects/nodes/saver.tscn")
+        var usl_prefab = preload("res://objects/nodes/listeners/unlockSetterListener.tscn")
+
+        var collectables = Node.new()
+        collectables.name = "Collectables"
+
+        var mastery = collectable_prefab.instantiate()
+        mastery.name = "collectable"
+        mastery.position = Vector3(2, 2, -31)
+        mastery.rotation_degrees = Vector3(0, 90, 0)
+        mastery.unlock_type = "smiley"
+        mastery.material_override = load("res://assets/materials/gold.material")
+        collectables.add_child.call_deferred(mastery)
+        root.get_node("/root/scene/Components").add_child.call_deferred(collectables)
+
+        var usl = usl_prefab.instantiate()
+        usl.name = "unlockSetterListenerMastery"
+        usl.key = "stellar_mastery"
+        usl.value = "unlocked"
+        usl.senders.append(NodePath("/root/scene/Components/Collectables/collectable"))
+        root.get_node("/root/scene/Components").add_child.call_deferred(usl)
+
+        var saver = saver_prefab.instantiate()
+        saver.name = "saver_collectables"
+        saver.type = "collectables"
+        saver.senderGroup.append(NodePath("/root/scene/Components/Collectables"))
+        root.get_node("/root/scene").add_child.call_deferred(saver)
@@ -0,0 +1,56 @@
+func on_map_load(root):
+        var ap = global.get_node("Archipelago")
+
+        # Add the strict purple ending validation.
+        if ap.strict_purple_ending:
+                var panel_prefab = preload("res://objects/nodes/panel.tscn")
+                var tpl_prefab = preload("res://objects/nodes/listeners/teleportListener.tscn")
+                var reverse_prefab = preload("res://objects/nodes/listeners/reversingListener.tscn")
+
+                var previous_panel = null
+                var next_y = -100
+                var words = ["quick", "brown", "fox", "jumps", "over", "the", "lazy", "dog"]
+                for word in words:
+                        var panel = panel_prefab.instantiate()
+                        panel.position = Vector3(0, next_y, 0)
+                        next_y -= 10
+                        panel.clue = word
+                        panel.symbol = ""
+                        panel.answer = word
+                        panel.name = "EndCheck_%s" % word
+
+                        var tpl = tpl_prefab.instantiate()
+                        tpl.teleport_point = Vector3(0, 1, 0)
+                        tpl.teleport_rotate = Vector3(-45, 180, 0)
+                        tpl.target_path = panel
+                        tpl.name = "Teleport"
+
+                        if previous_panel == null:
+                                tpl.senders.append(NodePath("/root/scene/Panels/End/panel_24"))
+                        else:
+                                tpl.senders.append(NodePath("../../%s" % previous_panel.name))
+
+                        var reversing = reverse_prefab.instantiate()
+                        reversing.senders.append(NodePath(".."))
+                        reversing.name = "Reversing"
+                        tpl.senders.append(NodePath("../Reversing"))
+
+                        panel.add_child.call_deferred(tpl)
+                        panel.add_child.call_deferred(reversing)
+                        root.get_node("/root/scene/Panels").add_child.call_deferred(panel)
+
+                        previous_panel = panel
+
+                # Duplicate the doors that usually wait on EQUINOX. We can't set the senders
+                # here for some reason so we actually set them in the door ready function.
+                var endplat = root.get_node("/root/scene/Components/Doors/EndPlatform")
+                var endplat2 = endplat.duplicate()
+                endplat2.name = "spe_EndPlatform"
+                endplat.get_parent().add_child.call_deferred(endplat2)
+                endplat.queue_free()
+
+                var entry2 = root.get_node("/root/scene/Components/Doors/entry_2")
+                var entry22 = entry2.duplicate()
+                entry22.name = "spe_entry_2"
+                entry2.get_parent().add_child.call_deferred(entry22)
+                entry2.queue_free()
@@ -0,0 +1,4 @@
+func on_map_load(root):
+        # Prevent the COLOR panel from disappearing.
+        var color_tpl = root.get_node("/root/scene/Panels/Assorted/panel_1/teleportListener")
+        color_tpl.target_path = color_tpl
@@ -0,0 +1,5 @@
+func on_map_load(root):
+        # Shrink the painting trigger in The Unyielding.
+        var trigger_area = root.get_node("/root/scene/Components/PaintingUnlocker/triggerArea")
+        trigger_area.position = Vector3(0, 0, -6)
+        trigger_area.scale = Vector3(6, 1, 6)
@@ -1,5 +1,7 @@
 extends CanvasLayer
 
+var SCRIPT_rainbowText
+
 var _message_queue = []
 var _font
 var _container
@@ -23,6 +25,7 @@ func _ready():
 
 func _add_message(text):
         var new_label = RichTextLabel.new()
+        new_label.install_effect(SCRIPT_rainbowText.new())
         new_label.push_font(_font)
         new_label.push_font_size(36)
         new_label.push_outline_color(Color(0, 0, 0, 1))
@@ -48,10 +51,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 +63,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,178 @@
+extends CanvasLayer
+
+var player
+var drawer
+var sprite
+var label
+
+var cell_left
+var cell_top
+var cell_right
+var cell_bottom
+var cell_width
+var cell_height
+var center_x_min
+var center_x_max
+var center_y_min
+var center_y_max
+
+
+func _ready():
+        player = get_tree().get_root().get_node("scene/player")
+
+        var svc = PanelContainer.new()
+        svc.anchor_left = 1.0
+        svc.anchor_top = 1.0
+        svc.anchor_right = 1.0
+        svc.anchor_bottom = 1.0
+        svc.offset_left = -320.0
+        svc.offset_top = -320.0
+        svc.offset_right = -64.0
+        svc.offset_bottom = -64.0
+        svc.clip_contents = true
+        add_child(svc)
+
+        var background_color = Color.WHITE
+
+        var world_env = get_tree().get_root().get_node("scene/WorldEnvironment")
+        if world_env != null and world_env.environment != null:
+                if world_env.environment.background_mode == Environment.BG_COLOR:
+                        background_color = world_env.environment.background_color
+                elif (
+                        world_env.environment.background_mode == Environment.BG_SKY
+                        and world_env.environment.sky != null
+                        and world_env.environment.sky.sky_material != null
+                ):
+                        var sky = world_env.environment.sky.sky_material
+                        if sky is PhysicalSkyMaterial:
+                                background_color = sky.ground_color
+                        elif sky is ProceduralSkyMaterial:
+                                background_color = sky.sky_top_color
+
+        var stylebox = StyleBoxFlat.new()
+        stylebox.bg_color = Color(background_color, 0.6)
+        svc.add_theme_stylebox_override("panel", stylebox)
+
+        drawer = Node2D.new()
+        svc.add_child(drawer)
+
+        var gridmap = get_tree().get_root().get_node("scene/GridMap")
+        if gridmap == null:
+                visible = false
+                return
+
+        cell_left = 0
+        cell_top = 0
+        cell_right = 0
+        cell_bottom = 0
+
+        for pos in gridmap.get_used_cells():
+                if pos.x < cell_left:
+                        cell_left = pos.x
+                if pos.x > cell_right:
+                        cell_right = pos.x
+                if pos.z < cell_top:
+                        cell_top = pos.z
+                if pos.z > cell_bottom:
+                        cell_bottom = pos.z
+
+        cell_width = cell_right - cell_left + 1
+        cell_height = cell_bottom - cell_top + 1
+
+        var rendered = _renderMap(gridmap)
+
+        var image_texture = ImageTexture.create_from_image(rendered)
+        sprite = Sprite2D.new()
+        sprite.texture = image_texture
+        sprite.texture_filter = CanvasItem.TEXTURE_FILTER_NEAREST
+        sprite.scale = Vector2(2, 2)
+        sprite.centered = false
+        drawer.add_child(sprite)
+
+        label = Label.new()
+        label.theme = preload("res://assets/themes/baseUI.tres")
+        label.add_theme_font_size_override("font_size", 32)
+        label.text = "@"
+        drawer.add_child(label)
+
+        #var local_tl = gridmap.map_to_local(Vector3i(cell_left, 0, cell_top))
+        #var global_tl = gridmap.to_global(local_tl)
+        #var local_br = gridmap.map_to_local(Vector3i(cell_right, 0, cell_bottom))
+        #var global_br = gridmap.to_global(local_br)
+
+        center_x_min = 0
+        center_x_max = cell_width - 128
+        center_y_min = 0
+        center_y_max = cell_height - 128
+
+        if center_x_max < center_x_min:
+                center_x_min = (center_x_min + center_x_max) / 2
+                center_x_max = center_x_min
+
+        if center_y_max < center_y_min:
+                center_y_min = (center_y_min + center_y_max) / 2
+                center_y_max = center_y_min
+
+
+func _process(_delta):
+        if visible == false:
+                return
+
+        drawer.position.x = clamp(player.position.x - cell_left - 64, center_x_min, center_x_max) * -2
+        drawer.position.y = clamp(player.position.z - cell_top - 64, center_y_min, center_y_max) * -2
+
+        label.position.x = (player.position.x - cell_left) * 2 - 16
+        label.position.y = (player.position.z - cell_top) * 2 - 16
+
+
+func _renderMap(gridmap):
+        var ap = global.get_node("Archipelago")
+        var heights = {}
+
+        var rendered = Image.create_empty(cell_width, cell_height, false, Image.FORMAT_RGBA8)
+        rendered.fill(Color.TRANSPARENT)
+
+        var meshes_node = get_tree().get_root().get_node("scene/Meshes")
+        if meshes_node != null:
+                _renderMeshNode(ap, gridmap, meshes_node, rendered)
+
+        for pos in gridmap.get_used_cells():
+                var in_plane = Vector2i(pos.x, pos.z)
+
+                if in_plane in heights and heights[in_plane] > pos.y:
+                        continue
+
+                heights[in_plane] = pos.y
+
+                var cell_item = gridmap.get_cell_item(pos)
+                var mesh = gridmap.mesh_library.get_item_mesh(cell_item)
+                var material = mesh.surface_get_material(0)
+                var color = ap.color_by_material_path.get(material.resource_path, Color.TRANSPARENT)
+
+                rendered.set_pixel(pos.x - cell_left, pos.z - cell_top, color)
+
+        return rendered
+
+
+func _renderMeshNode(ap, gridmap, mesh, rendered):
+        if mesh is MeshInstance3D:
+                var local_tl = gridmap.map_to_local(Vector3i(cell_left, 0, cell_top))
+                var global_tl = gridmap.to_global(local_tl)
+                var mesh_material = mesh.get_surface_override_material(0)
+                if mesh_material != null:
+                        var mesh_color = ap.color_by_material_path.get(
+                                mesh_material.resource_path, Color.TRANSPARENT
+                        )
+
+                        for y in range(
+                                max(mesh.position.z - mesh.scale.z / 2 - global_tl.z, 0),
+                                min(mesh.position.z + mesh.scale.z / 2 - global_tl.z, cell_height)
+                        ):
+                                for x in range(
+                                        max(mesh.position.x - mesh.scale.x / 2 - global_tl.x, 0),
+                                        min(mesh.position.x + mesh.scale.x / 2 - global_tl.x, cell_width)
+                                ):
+                                        rendered.set_pixel(x, y, mesh_color)
+
+        for child in mesh.get_children():
+                _renderMeshNode(ap, gridmap, child, rendered)
@@ -0,0 +1,43 @@
+extends "res://scripts/nodes/paintingAuto.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()
+
+        if item_id != null and activate_on_sender_complete:
+                enabled = false
+                if not hide_particles:
+                        get_node("Hinge/paintingColliders/TeleportParticles").emitting = false
+
+
+func _readier():
+        var ap = global.get_node("Archipelago")
+
+        if ap.client.getItemAmount(item_id) >= item_amount:
+                handleTriggered()
@@ -0,0 +1,101 @@
+extends "res://scripts/nodes/panel.gd"
+
+var panel_logic = null
+var symbol_solvable = true
+
+var black = load("res://assets/materials/black.material")
+
+
+func _ready():
+        super._ready()
+
+        var node_path = String(
+                get_tree().get_root().get_node("scene").get_path_to(self).get_concatenated_names()
+        )
+
+        var gamedata = global.get_node("Gamedata")
+        var panel_id = gamedata.get_panel_for_map_node_path(global.map, node_path)
+        if panel_id != null:
+                var ap = global.get_node("Archipelago")
+                if ap.shuffle_symbols:
+                        if global.map == "the_entry" and node_path == "Panels/Entry/front_1":
+                                clue = "i"
+                                symbol = ""
+
+                                setField("clue", clue)
+                                setField("symbol", symbol)
+
+                panel_logic = gamedata.objects.get_panels()[panel_id]
+                checkSymbolSolvable()
+
+                if not symbol_solvable:
+                        get_tree().get_root().get_node("scene/player").evaluate_solvability.connect(
+                                evaluateSolvability
+                        )
+
+
+func checkSymbolSolvable():
+        var old_solvable = symbol_solvable
+        symbol_solvable = true
+
+        if panel_logic == null:
+                # There's no logic for this panel.
+                return
+
+        var ap = global.get_node("Archipelago")
+        if not ap.shuffle_symbols:
+                # Symbols aren't item-locked.
+                return
+
+        var gamedata = global.get_node("Gamedata")
+        for symbol in panel_logic.get_symbols():
+                var item_name = gamedata.kSYMBOL_ITEMS.get(symbol)
+                var item_id = gamedata.objects.get_special_ids()[item_name]
+                if ap.client.getItemAmount(item_id) < 1:
+                        symbol_solvable = false
+                        break
+
+        if symbol_solvable != old_solvable:
+                if symbol_solvable:
+                        setField("clue", clue)
+                        setField("symbol", symbol)
+                        setField("answer", answer)
+                else:
+                        quad_mesh.surface_set_material(0, black)
+                        get_node("Hinge/clue").text = "missing"
+                        get_node("Hinge/answer").text = "symbols"
+
+
+func checkSolvable(key):
+        checkSymbolSolvable()
+        if not symbol_solvable:
+                return false
+
+        return super.checkSolvable(key)
+
+
+func evaluateSolvability():
+        checkSolvable("")
+
+
+func passedInput(key, skip_focus_check = false):
+        if not symbol_solvable:
+                return
+
+        super.passedInput(key, skip_focus_check)
+
+
+func focus():
+        if not symbol_solvable:
+                has_focus = false
+                return
+
+        super.focus()
+
+
+func unfocus():
+        if not symbol_solvable:
+                has_focus = false
+                return
+
+        super.unfocus()
@@ -0,0 +1,91 @@
+extends "res://scripts/ui/pauseMenu.gd"
+
+var compass_button
+var locations_button
+var minimap_button
+
+
+func _ready():
+        var ap_panel = Panel.new()
+        ap_panel.name = "Archipelago"
+        get_node("menu/settings/settingsInner/TabContainer").add_child(ap_panel)
+
+        var ap = global.get_node("Archipelago")
+
+        compass_button = CheckBox.new()
+        compass_button.text = "show compass"
+        compass_button.button_pressed = ap.show_compass
+        compass_button.position = Vector2(65, 100)
+        compass_button.theme = preload("res://assets/themes/baseUI.tres")
+        compass_button.add_theme_font_size_override("font_size", 60)
+        compass_button.pressed.connect(_toggle_compass)
+        ap_panel.add_child(compass_button)
+
+        locations_button = CheckBox.new()
+        locations_button.text = "show locations overlay"
+        locations_button.button_pressed = ap.show_locations
+        locations_button.position = Vector2(65, 200)
+        locations_button.theme = preload("res://assets/themes/baseUI.tres")
+        locations_button.add_theme_font_size_override("font_size", 60)
+        locations_button.pressed.connect(_toggle_locations)
+        ap_panel.add_child(locations_button)
+
+        minimap_button = CheckBox.new()
+        minimap_button.text = "show minimap"
+        minimap_button.button_pressed = ap.show_minimap
+        minimap_button.position = Vector2(65, 300)
+        minimap_button.theme = preload("res://assets/themes/baseUI.tres")
+        minimap_button.add_theme_font_size_override("font_size", 60)
+        minimap_button.pressed.connect(_toggle_minimap)
+        ap_panel.add_child(minimap_button)
+
+        super._ready()
+
+
+func _pause_game():
+        global.get_node("Textclient").dismiss()
+        super._pause_game()
+
+
+func _main_menu():
+        global.loaded = false
+        global.get_node("Archipelago").disconnect_from_ap()
+        global.get_node("Messages").clear()
+        global.get_node("Compass").visible = false
+        global.get_node("Textclient").reset()
+
+        autosplitter.reset()
+        _unpause_game()
+        Input.set_mouse_mode(Input.MOUSE_MODE_VISIBLE)
+        musicPlayer.stop()
+
+        var runtime = global.get_node("Runtime")
+        runtime.load_script_as_scene.call_deferred("settings_screen.gd", "settings_screen")
+
+
+func _toggle_compass():
+        var ap = global.get_node("Archipelago")
+        ap.show_compass = compass_button.button_pressed
+        ap.saveSettings()
+
+        var compass = global.get_node("Compass")
+        compass.visible = compass_button.button_pressed
+
+
+func _toggle_locations():
+        var ap = global.get_node("Archipelago")
+        ap.show_locations = locations_button.button_pressed
+        ap.saveSettings()
+
+        var textclient = global.get_node("Textclient")
+        textclient.update_locations_visibility()
+
+
+func _toggle_minimap():
+        var ap = global.get_node("Archipelago")
+        ap.show_minimap = minimap_button.button_pressed
+        ap.saveSettings()
+
+        var minimap = get_tree().get_root().get_node("scene/Minimap")
+        if minimap != null:
+                minimap.visible = ap.show_minimap
@@ -1,30 +1,31 @@
 extends "res://scripts/nodes/player.gd"
 
-const kEndingNameByVictoryValue = {
-        0: "GRAY",
-        1: "PURPLE",
-        2: "MINT",
-        3: "BLACK",
-        4: "BLUE",
-        5: "CYAN",
-        6: "RED",
-        7: "PLUM",
-        8: "ORANGE",
-        9: "GOLD",
-        10: "YELLOW",
-        11: "GREEN",
-        12: "WHITE",
-}
+signal evaluate_solvability
+
+var compass
 
 
 func _ready():
         var khl_script = load("res://scripts/nodes/keyHolderListener.gd")
 
+        var pause_menu = get_node("pause_menu")
+        pause_menu.layer = 3
+
         var ap = global.get_node("Archipelago")
         var gamedata = global.get_node("Gamedata")
 
+        compass = global.get_node("Compass")
+        compass.visible = ap.show_compass
+
         ap.start_batching_locations()
 
+        # Run map-specific initialization.
+        var map_script = ap.get_map_script(global.map)
+        if map_script != null:
+                map_script.on_map_load(get_tree().get_root())
+
+        ap.update_job_well_done_sign()
+
         # Set up door locations.
         var map_id = gamedata.map_id_by_name.get(global.map)
         for door in gamedata.objects.get_doors():
@@ -34,7 +35,14 @@ func _ready():
                 if not door.has_ap_id():
                         continue
 
-                if door.get_type() == gamedata.SCRIPT_proto.DoorType.ITEM_ONLY:
+                if (
+                        not (door.has_legacy_location() and door.get_legacy_location())
+                        and (
+                                door.get_type() == gamedata.SCRIPT_proto.DoorType.ITEM_ONLY
+                                or door.get_type() == gamedata.SCRIPT_proto.DoorType.GALLERY_PAINTING
+                                or door.get_type() == gamedata.SCRIPT_proto.DoorType.CONTROL_CENTER_COLOR
+                        )
+                ):
                         continue
 
                 var locationListener = ap.SCRIPT_locationListener.new()
@@ -66,6 +74,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.
@@ -86,17 +100,12 @@ func _ready():
                         != ap.kLETTER_BEHAVIOR_VANILLA
                 ):
                         var scout = ap.scout_location(letter.get_ap_id())
-                        if scout != null:
-                                var item_name = "Unknown"
-                                var item_player_game = ap.client._game_by_player[float(scout["player"])]
-                                if ap.client._item_id_to_name[item_player_game].has(scout["item"]):
-                                        item_name = ap.client._item_id_to_name[item_player_game][scout["item"]]
-
-                                        var collectable = get_tree().get_root().get_node("scene").get_node_or_null(
-                                                letter.get_path()
-                                        )
-                                        if collectable != null:
-                                                collectable.setScoutedText.call_deferred(item_name)
+                        if scout != null and not (scout["for_self"] and scout["flags"] & 4 != 0):
+                                var collectable = get_tree().get_root().get_node("scene").get_node_or_null(
+                                        letter.get_path()
+                                )
+                                if collectable != null:
+                                        collectable.setScoutedText.call_deferred(scout["item"])
 
         # Set up mastery locations.
         for mastery in gamedata.objects.get_masteries():
@@ -124,7 +133,7 @@ func _ready():
 
                 get_parent().add_child.call_deferred(locationListener)
 
-                if kEndingNameByVictoryValue.get(ap.victory_condition, null) == ending.get_name():
+                if ap.kEndingNameByVictoryValue.get(ap.victory_condition, null) == ending.get_name():
                         var victoryListener = ap.SCRIPT_victoryListener.new()
                         victoryListener.name = "victoryListener"
                         victoryListener.senders.append(NodePath("/root/scene/" + ending.get_path()))
@@ -155,38 +164,10 @@ func _ready():
 
                         get_parent().add_child.call_deferred(locationListener)
 
-        # Block off roof access in Daedalus.
-        if global.map == "daedalus" and not ap.daedalus_roof_access:
-                _set_up_invis_wall(75.5, 11, -24.5, 1, 10, 49)
-                _set_up_invis_wall(51.5, 11, -17, 16, 10, 1)
-                _set_up_invis_wall(46, 10, -9.5, 1, 10, 10)
-                _set_up_invis_wall(67.5, 11, 17, 16, 10, 1)
-                _set_up_invis_wall(50.5, 11, 14, 10, 10, 1)
-                _set_up_invis_wall(39, 10, 18.5, 1, 10, 22)
-                _set_up_invis_wall(20, 15, 18.5, 1, 10, 16)
-                _set_up_invis_wall(11.5, 15, 3, 32, 10, 1)
-                _set_up_invis_wall(11.5, 16, -20, 14, 20, 1)
-                _set_up_invis_wall(14, 16, -26.5, 1, 20, 4)
-                _set_up_invis_wall(28.5, 20.5, -26.5, 1, 15, 25)
-                _set_up_invis_wall(40.5, 20.5, -11, 30, 15, 1)
-                _set_up_invis_wall(50.5, 15, 5.5, 7, 10, 1)
-                _set_up_invis_wall(83.5, 33.5, 5.5, 1, 7, 11)
-                _set_up_invis_wall(83.5, 33.5, -5.5, 1, 7, 11)
-
-                var warp_exit_prefab = preload("res://objects/nodes/exit.tscn")
-                var warp_exit = warp_exit_prefab.instantiate()
-                warp_exit.name = "roof_access_blocker_warp_exit"
-                warp_exit.position = Vector3(58, 10, 0)
-                warp_exit.rotation_degrees.y = 90
-                get_parent().add_child.call_deferred(warp_exit)
-
-                var warp_enter_prefab = preload("res://objects/nodes/teleportAuto.tscn")
-                var warp_enter = warp_enter_prefab.instantiate()
-                warp_enter.target = warp_exit
-                warp_enter.position = Vector3(76.5, 30, 1)
-                warp_enter.scale = Vector3(4, 1.5, 1)
-                warp_enter.rotation_degrees.y = 90
-                get_parent().add_child.call_deferred(warp_enter)
+        var minimap = ap.SCRIPT_minimap.new()
+        minimap.name = "Minimap"
+        minimap.visible = ap.show_minimap
+        get_parent().add_child.call_deferred(minimap)
 
         super._ready()
 
@@ -196,18 +177,5 @@ func _ready():
         ap.stop_batching_locations()
 
 
-func _set_up_invis_wall(x, y, z, sx, sy, sz):
-        var prefab = preload("res://objects/nodes/block.tscn")
-        var newwall = prefab.instantiate()
-        newwall.position.x = x
-        newwall.position.y = y
-        newwall.position.z = z
-        newwall.scale.x = sz
-        newwall.scale.y = sy
-        newwall.scale.z = sx
-        newwall.set_surface_override_material(0, preload("res://assets/materials/blackMatte.material"))
-        newwall.visibility_range_end = 3
-        newwall.visibility_range_end_margin = 1
-        newwall.visibility_range_fade_mode = RenderingServer.VISIBILITY_RANGE_FADE_SELF
-        newwall.skeleton = ".."
-        get_parent().add_child.call_deferred(newwall)
+func _process(_dt):
+        compass.update_rotation(global_rotation.y)
@@ -0,0 +1,10 @@
+extends RichTextEffect
+
+var bbcode = "rainbow"
+
+
+func _process_custom_fx(char_fx: CharFXTransform):
+        char_fx.color = Color.from_hsv(
+                char_fx.elapsed_time - floor(char_fx.elapsed_time), 1.0, 1.0, 1.0
+        )
+        return true
@@ -0,0 +1,30 @@
+[gd_scene load_steps=11 format=2]
+
+[sub_resource id=2 type="GDScript"]
+script/source = "extends Node2D
+
+
+func _ready():
+        var args = OS.get_cmdline_user_args()
+        var apworld_path = args[0]
+
+        var zip_reader = ZIPReader.new()
+        zip_reader.open(apworld_path)
+        
+        var runtime_script = GDScript.new()
+        runtime_script.source_code = zip_reader.read_file(\"lingo2/client/apworld_runtime.gd\").get_string_from_utf8()
+        runtime_script.reload()
+
+        zip_reader.close()
+
+        var runtime = runtime_script.new(apworld_path)
+        runtime.name = \"Runtime\"
+
+        global.add_child(runtime)
+
+        runtime.load_script_as_scene.call_deferred(\"settings_screen.gd\", \"settings_screen\")
+
+"
+
+[node name="loader" type="Node2D"]
+script = SubResource( 2 )
@@ -0,0 +1,22 @@
+[gd_scene load_steps=11 format=2]
+
+[sub_resource id=2 type="GDScript"]
+script/source = "extends Node2D
+
+
+func _ready():
+        var args = OS.get_cmdline_user_args()
+        var source_path = args[0]
+
+        var runtime_script = ResourceLoader.load(\"%s/source_runtime.gd\" % source_path)
+        var runtime = runtime_script.new(source_path)
+        runtime.name = \"Runtime\"
+
+        global.add_child(runtime)
+
+        runtime.load_script_as_scene.call_deferred(\"settings_screen.gd\", \"settings_screen\")
+
+"
+
+[node name="loader" type="Node2D"]
+script = SubResource( 2 )
@@ -0,0 +1,23 @@
+extends "res://scripts/nodes/saver.gd"
+
+
+func levelLoaded():
+        if type == "keyholders":
+                var ap = global.get_node("Archipelago")
+                ap.keyboard.load_keyholders.call_deferred(global.map)
+        else:
+                reload.call_deferred()
+
+
+func reload():
+        # Just rewriting this whole thing so I can remove Chris's safeguard.
+        var file = FileAccess.open(path + type + ".save", FileAccess.READ)
+        if file:
+                var data = file.get_var(true)
+                file.close()
+                for datum in data:
+                        var saveable = get_node_or_null(datum[0])
+                        if saveable != null:
+                                saveable.is_complete = datum[1]
+                                if saveable.is_complete:
+                                        saveable.loadData(saveable.is_complete)
@@ -0,0 +1,149 @@
+extends Node
+
+
+func _ready():
+        var theme = preload("res://assets/themes/baseUI.tres")
+
+        var simple_style_box = StyleBoxFlat.new()
+        simple_style_box.bg_color = Color(0, 0, 0, 0)
+
+        var panel = Panel.new()
+        panel.name = "Panel"
+        panel.offset_right = 1920.0
+        panel.offset_bottom = 1080.0
+        add_child(panel)
+
+        var title = Label.new()
+        title.name = "title"
+        title.offset_left = 0.0
+        title.offset_top = 75.0
+        title.offset_right = 1920.0
+        title.offset_bottom = 225.0
+        title.text = "ARCHIPELAGO"
+        title.vertical_alignment = VERTICAL_ALIGNMENT_CENTER
+        title.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
+        title.theme = theme
+        panel.add_child(title)
+
+        var connect_button = Button.new()
+        connect_button.name = "connect_button"
+        connect_button.offset_left = 255.0
+        connect_button.offset_top = 875.0
+        connect_button.offset_right = 891.0
+        connect_button.offset_bottom = 1025.0
+        connect_button.add_theme_color_override("font_color_hover", Color(1, 0.501961, 0, 1))
+        connect_button.text = "CONNECT"
+        connect_button.theme = theme
+        panel.add_child(connect_button)
+
+        var quit_button = Button.new()
+        quit_button.name = "quit_button"
+        quit_button.offset_left = 1102.0
+        quit_button.offset_top = 875.0
+        quit_button.offset_right = 1738.0
+        quit_button.offset_bottom = 1025.0
+        quit_button.add_theme_color_override("font_color_hover", Color(1, 0, 0, 1))
+        quit_button.text = "QUIT"
+        quit_button.theme = theme
+        panel.add_child(quit_button)
+
+        var credit2 = Label.new()
+        credit2.name = "credit2"
+        credit2.offset_left = -105.0
+        credit2.offset_top = 346.0
+        credit2.offset_right = 485.0
+        credit2.offset_bottom = 410.0
+        credit2.add_theme_stylebox_override("normal", simple_style_box)
+        credit2.text = "SERVER"
+        credit2.horizontal_alignment = HORIZONTAL_ALIGNMENT_RIGHT
+        credit2.theme = theme
+        panel.add_child(credit2)
+
+        var credit3 = Label.new()
+        credit3.name = "credit3"
+        credit3.offset_left = -105.0
+        credit3.offset_top = 519.0
+        credit3.offset_right = 485.0
+        credit3.offset_bottom = 583.0
+        credit3.add_theme_stylebox_override("normal", simple_style_box)
+        credit3.text = "PLAYER"
+        credit3.horizontal_alignment = HORIZONTAL_ALIGNMENT_RIGHT
+        credit3.theme = theme
+        panel.add_child(credit3)
+
+        var credit4 = Label.new()
+        credit4.name = "credit4"
+        credit4.offset_left = -105.0
+        credit4.offset_top = 704.0
+        credit4.offset_right = 485.0
+        credit4.offset_bottom = 768.0
+        credit4.add_theme_stylebox_override("normal", simple_style_box)
+        credit4.text = "PASSWORD"
+        credit4.horizontal_alignment = HORIZONTAL_ALIGNMENT_RIGHT
+        credit4.theme = theme
+        panel.add_child(credit4)
+
+        var credit5 = Label.new()
+        credit5.name = "credit5"
+        credit5.offset_left = 1239.0
+        credit5.offset_top = 422.0
+        credit5.offset_right = 1829.0
+        credit5.offset_bottom = 486.0
+        credit5.add_theme_stylebox_override("normal", simple_style_box)
+        credit5.text = "OPTIONS"
+        credit5.theme = theme
+        panel.add_child(credit5)
+
+        var server_box = LineEdit.new()
+        server_box.name = "server_box"
+        server_box.offset_left = 502.0
+        server_box.offset_top = 295.0
+        server_box.offset_right = 1144.0
+        server_box.offset_bottom = 445.0
+        server_box.alignment = HORIZONTAL_ALIGNMENT_CENTER
+        server_box.caret_blink = true
+        panel.add_child(server_box)
+
+        var player_box = LineEdit.new()
+        player_box.name = "player_box"
+        player_box.offset_left = 502.0
+        player_box.offset_top = 477.0
+        player_box.offset_right = 1144.0
+        player_box.offset_bottom = 627.0
+        player_box.alignment = HORIZONTAL_ALIGNMENT_CENTER
+        player_box.caret_blink = true
+        panel.add_child(player_box)
+
+        var password_box = LineEdit.new()
+        password_box.name = "password_box"
+        password_box.offset_left = 502.0
+        password_box.offset_top = 659.0
+        password_box.offset_right = 1144.0
+        password_box.offset_bottom = 809.0
+        password_box.alignment = HORIZONTAL_ALIGNMENT_CENTER
+        password_box.caret_blink = true
+        panel.add_child(password_box)
+
+        var accept_dialog = AcceptDialog.new()
+        accept_dialog.name = "AcceptDialog"
+        panel.add_child(accept_dialog)
+
+        var version_mismatch = ConfirmationDialog.new()
+        version_mismatch.name = "VersionMismatch"
+        panel.add_child(version_mismatch)
+
+        var connection_history = MenuButton.new()
+        connection_history.name = "connection_history"
+        connection_history.offset_left = 1239.0
+        connection_history.offset_top = 276.0
+        connection_history.offset_right = 1829.0
+        connection_history.offset_bottom = 372.0
+        connection_history.text = "connection history"
+        connection_history.flat = false
+        panel.add_child(connection_history)
+
+        var runtime = global.get_node("Runtime")
+        var main_script = runtime.load_script("main.gd")
+        var main_node = main_script.new()
+        main_node.name = "Main"
+        add_child(main_node)
@@ -0,0 +1,33 @@
+extends Node
+
+var source_path
+
+
+func _init(path):
+        source_path = path
+
+
+func path_exists(path):
+        return FileAccess.file_exists("%s/%s" % [source_path, path])
+
+
+func load_script(path):
+        return ResourceLoader.load("%s/%s" % [source_path, path])
+
+
+func read_path(path):
+        return FileAccess.get_file_as_bytes("%s/%s" % [source_path, path])
+
+
+func load_script_as_scene(path, scene_name):
+        var script = load_script(path)
+        var instance = script.new()
+        instance.name = scene_name
+
+        get_tree().unload_current_scene()
+        _load_scene.call_deferred(instance)
+
+
+func _load_scene(instance):
+        get_tree().get_root().add_child(instance)
+        get_tree().current_scene = instance
@@ -1,4 +1,4 @@
-extends "res://scripts/nodes/door.gd"
+extends "res://scripts/nodes/teleport.gd"
 
 var item_id
 var item_amount
@@ -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:
@@ -0,0 +1,508 @@
+extends CanvasLayer
+
+var tabs
+var panel
+var label
+var entry
+var is_open = false
+
+var locations_overlay
+var location_texture
+var worldport_texture
+var goal_texture
+
+var tracker_tree
+var tracker_loc_tree_item_by_id = {}
+var tracker_port_tree_item_by_id = {}
+var tracker_goal_tree_item = null
+var tracker_object_by_index = {}
+var tracker_object_by_ignored_index = {}
+var tracker_ignored_group = null
+
+var worldports_tab
+var worldports_tree
+var port_tree_item_by_map = {}
+var port_tree_item_by_map_port = {}
+
+const kLocation = 0
+const kWorldport = 1
+const kGoal = 2
+
+
+func _ready():
+        process_mode = ProcessMode.PROCESS_MODE_ALWAYS
+        layer = 2
+
+        locations_overlay = RichTextLabel.new()
+        locations_overlay.name = "LocationsOverlay"
+        locations_overlay.offset_top = 220
+        locations_overlay.offset_bottom = 720
+        locations_overlay.offset_left = 20
+        locations_overlay.anchor_right = 1.0
+        locations_overlay.offset_right = -10
+        locations_overlay.scroll_active = false
+        locations_overlay.mouse_filter = Control.MOUSE_FILTER_IGNORE
+        locations_overlay.texture_filter = CanvasItem.TEXTURE_FILTER_NEAREST
+        add_child(locations_overlay)
+        update_locations_visibility()
+
+        tabs = TabContainer.new()
+        tabs.name = "Tabs"
+        tabs.offset_left = 100
+        tabs.offset_right = 1820
+        tabs.offset_top = 100
+        tabs.offset_bottom = 980
+        tabs.visible = false
+        tabs.theme = preload("res://assets/themes/baseUI.tres")
+        tabs.add_theme_font_size_override("font_size", 36)
+        add_child(tabs)
+
+        panel = MarginContainer.new()
+        panel.name = "Text Client"
+        panel.add_theme_constant_override("margin_top", 60)
+        panel.add_theme_constant_override("margin_left", 60)
+        panel.add_theme_constant_override("margin_right", 60)
+        panel.add_theme_constant_override("margin_bottom", 60)
+        tabs.add_child(panel)
+
+        label = RichTextLabel.new()
+        label.set_name("Label")
+        label.scroll_following = true
+        label.selection_enabled = true
+        label.size_flags_horizontal = Control.SIZE_EXPAND_FILL
+        label.size_flags_vertical = Control.SIZE_EXPAND_FILL
+        label.push_font(preload("res://assets/fonts/Lingo2.ttf"))
+        label.push_font_size(30)
+
+        var entry_style = StyleBoxFlat.new()
+        entry_style.bg_color = Color(0.9, 0.9, 0.9, 1)
+
+        entry = LineEdit.new()
+        entry.set_name("Entry")
+        entry.add_theme_font_override("font", preload("res://assets/fonts/Lingo2.ttf"))
+        entry.add_theme_font_size_override("font_size", 36)
+        entry.add_theme_color_override("font_color", Color(0, 0, 0, 1))
+        entry.add_theme_color_override("cursor_color", Color(0, 0, 0, 1))
+        entry.add_theme_stylebox_override("focus", entry_style)
+        entry.text_submitted.connect(text_entered)
+
+        var tc_arranger = VBoxContainer.new()
+        tc_arranger.add_child(label)
+        tc_arranger.add_child(entry)
+        tc_arranger.add_theme_constant_override("separation", 40)
+        panel.add_child(tc_arranger)
+
+        var tracker_margins = MarginContainer.new()
+        tracker_margins.name = "Locations"
+        tracker_margins.add_theme_constant_override("margin_top", 60)
+        tracker_margins.add_theme_constant_override("margin_left", 60)
+        tracker_margins.add_theme_constant_override("margin_right", 60)
+        tracker_margins.add_theme_constant_override("margin_bottom", 60)
+        tabs.add_child(tracker_margins)
+
+        tracker_tree = Tree.new()
+        tracker_tree.columns = 4
+        tracker_tree.hide_root = true
+        tracker_tree.add_theme_font_size_override("font_size", 24)
+        tracker_tree.add_theme_color_override("font_color", Color(0.8, 0.8, 0.8, 1))
+        tracker_tree.add_theme_constant_override("v_separation", 1)
+        tracker_tree.item_edited.connect(_on_tracker_button_clicked)
+        tracker_tree.set_column_expand(0, false)
+        tracker_tree.set_column_expand(1, true)
+        tracker_tree.set_column_expand(2, false)
+        tracker_tree.set_column_expand(3, false)
+        tracker_tree.set_column_custom_minimum_width(2, 200)
+        tracker_tree.set_column_custom_minimum_width(3, 200)
+        tracker_margins.add_child(tracker_tree)
+
+        worldports_tab = MarginContainer.new()
+        worldports_tab.name = "Worldports"
+        worldports_tab.add_theme_constant_override("margin_top", 60)
+        worldports_tab.add_theme_constant_override("margin_left", 60)
+        worldports_tab.add_theme_constant_override("margin_right", 60)
+        worldports_tab.add_theme_constant_override("margin_bottom", 60)
+        tabs.add_child(worldports_tab)
+        tabs.set_tab_hidden(2, true)
+
+        worldports_tree = Tree.new()
+        worldports_tree.columns = 2
+        worldports_tree.hide_root = true
+        worldports_tree.theme = preload("res://assets/themes/baseUI.tres")
+        worldports_tree.add_theme_font_size_override("font_size", 24)
+        worldports_tab.add_child(worldports_tree)
+
+        var runtime = global.get_node("Runtime")
+        var location_image = Image.new()
+        location_image.load_png_from_buffer(runtime.read_path("assets/location.png"))
+        location_texture = ImageTexture.create_from_image(location_image)
+
+        var worldport_image = Image.new()
+        worldport_image.load_png_from_buffer(runtime.read_path("assets/worldport.png"))
+        worldport_texture = ImageTexture.create_from_image(worldport_image)
+
+        var goal_image = Image.new()
+        goal_image.load_png_from_buffer(runtime.read_path("assets/goal.png"))
+        goal_texture = ImageTexture.create_from_image(goal_image)
+
+
+func _input(event):
+        if global.loaded and event is InputEventKey and event.pressed:
+                if event.keycode == KEY_TAB and !Input.is_key_pressed(KEY_SHIFT):
+                        if !get_tree().paused:
+                                is_open = true
+                                get_tree().paused = true
+                                Input.set_mouse_mode(Input.MOUSE_MODE_VISIBLE)
+                                tabs.visible = true
+                                entry.grab_focus()
+                                get_viewport().set_input_as_handled()
+                        else:
+                                dismiss()
+                elif event.keycode == KEY_ESCAPE:
+                        if is_open:
+                                dismiss()
+                                get_viewport().set_input_as_handled()
+
+
+func dismiss():
+        if is_open:
+                get_tree().paused = false
+                Input.set_mouse_mode(Input.MOUSE_MODE_CAPTURED)
+                tabs.visible = false
+                is_open = false
+
+
+func parse_printjson(text):
+        label.append_text("[p]" + text + "[/p]")
+
+
+func text_entered(text):
+        var ap = global.get_node("Archipelago")
+        var cmd = text.trim_suffix("\n")
+        entry.text = ""
+        if OS.is_debug_build():
+                if cmd.begins_with("/tp_map "):
+                        var new_map = cmd.substr(8)
+                        global.map = new_map
+                        global.sets_entry_point = false
+                        switcher.switch_map("res://objects/scenes/%s.tscn" % new_map)
+                        return
+
+        ap.client.say(cmd)
+
+
+func update_locations(reset_locations = true):
+        var ap = global.get_node("Archipelago")
+        var gamedata = global.get_node("Gamedata")
+
+        locations_overlay.clear()
+        locations_overlay.push_font(preload("res://assets/fonts/Lingo2.ttf"))
+        locations_overlay.push_font_size(24)
+        locations_overlay.push_color(Color(0.9, 0.9, 0.9, 1))
+        locations_overlay.push_outline_color(Color(0, 0, 0, 1))
+        locations_overlay.push_outline_size(2)
+
+        var locations = []
+        for location_id in ap.client._accessible_locations:
+                if not ap.client._checked_locations.has(location_id):
+                        var location_name = gamedata.location_name_by_id.get(location_id, "(Unknown)")
+                        (
+                                locations
+                                . append(
+                                        {
+                                                "name": location_name,
+                                                "type": kLocation,
+                                                "id": location_id,
+                                                "ignored": ap._ignored_locations.has(location_id),
+                                                "hint": ap.client._hinted_locations.has(location_id),
+                                        }
+                                )
+                        )
+
+        for port_id in ap.client._accessible_worldports:
+                if not ap.client._checked_worldports.has(port_id):
+                        var port_name = gamedata.get_worldport_display_name(port_id)
+                        (
+                                locations
+                                . append(
+                                        {
+                                                "name": port_name,
+                                                "type": kWorldport,
+                                                "id": port_id,
+                                                "ignored": false,
+                                                "hint": false,
+                                        }
+                                )
+                        )
+
+        locations.sort_custom(_cmp_tracker_objects)
+
+        if ap.client._goal_accessible:
+                var location_name = gamedata.ending_display_name_by_name[ap.kEndingNameByVictoryValue[
+                        ap.victory_condition
+                ]]
+                (
+                        locations
+                        . push_front(
+                                {
+                                        "name": location_name,
+                                        "type": kGoal,
+                                        "ignored": false,
+                                        "hint": false,
+                                }
+                        )
+                )
+
+        var count = 0
+        for location in locations:
+                if count < 18 and not location["ignored"]:
+                        locations_overlay.push_paragraph(HORIZONTAL_ALIGNMENT_RIGHT)
+                        if location["hint"]:
+                                locations_overlay.push_color(Color("#fafad2"))
+                        locations_overlay.append_text(location["name"])
+                        locations_overlay.append_text(" ")
+                        if location["type"] == kLocation:
+                                locations_overlay.add_image(location_texture)
+                        elif location["type"] == kWorldport:
+                                locations_overlay.add_image(worldport_texture)
+                        elif location["type"] == kGoal:
+                                locations_overlay.add_image(goal_texture)
+                        if location["hint"]:
+                                locations_overlay.pop()
+                        locations_overlay.pop()
+                count += 1
+
+        if count > 18:
+                locations_overlay.append_text("[p align=right][lb]...[rb][/p]")
+
+        if reset_locations:
+                reset_tracker_tab()
+
+                var root_ti = tracker_tree.create_item(null)
+
+                for location in locations:
+                        var loc_row
+
+                        if location["ignored"]:
+                                if tracker_ignored_group == null:
+                                        tracker_ignored_group = root_ti.create_child()
+                                        tracker_ignored_group.set_text(1, "Ignored Locations")
+                                        tracker_ignored_group.set_selectable(0, false)
+                                        tracker_ignored_group.set_selectable(1, false)
+                                        tracker_ignored_group.set_selectable(2, false)
+                                        tracker_ignored_group.set_selectable(3, false)
+
+                                loc_row = tracker_ignored_group.create_child()
+                        else:
+                                loc_row = root_ti.create_child()
+
+                        loc_row.set_cell_mode(0, TreeItem.CELL_MODE_ICON)
+                        loc_row.set_selectable(0, false)
+                        loc_row.set_text(1, location["name"])
+                        loc_row.set_selectable(1, false)
+                        if location["hint"]:
+                                loc_row.set_custom_color(1, Color("#fafad2"))
+                        loc_row.set_cell_mode(2, TreeItem.CELL_MODE_CUSTOM)
+                        loc_row.set_text(2, "Show Path")
+                        loc_row.set_custom_as_button(2, true)
+                        loc_row.set_editable(2, true)
+                        loc_row.set_selectable(2, false)
+                        loc_row.set_text_alignment(2, HORIZONTAL_ALIGNMENT_CENTER)
+                        loc_row.set_selectable(3, false)
+                        if location["type"] == kLocation:
+                                loc_row.set_cell_mode(3, TreeItem.CELL_MODE_CUSTOM)
+                                if location["ignored"]:
+                                        loc_row.set_text(3, "Unignore")
+                                else:
+                                        loc_row.set_text(3, "Ignore")
+                                loc_row.set_custom_as_button(3, true)
+                                loc_row.set_editable(3, true)
+                                loc_row.set_text_alignment(3, HORIZONTAL_ALIGNMENT_CENTER)
+
+                        if location["type"] == kLocation:
+                                loc_row.set_icon(0, location_texture)
+                                tracker_loc_tree_item_by_id[location["id"]] = loc_row
+                        elif location["type"] == kWorldport:
+                                loc_row.set_icon(0, worldport_texture)
+                                tracker_port_tree_item_by_id[location["id"]] = loc_row
+                        elif location["type"] == kGoal:
+                                loc_row.set_icon(0, goal_texture)
+                                tracker_goal_tree_item = loc_row
+
+                        if location["ignored"]:
+                                tracker_object_by_ignored_index[loc_row.get_index()] = location
+                        else:
+                                tracker_object_by_index[loc_row.get_index()] = location
+        else:
+                for loc_row in tracker_tree.get_root().get_children():
+                        loc_row.visible = false
+
+                for location_id in tracker_loc_tree_item_by_id.keys():
+                        if (
+                                ap.client._accessible_locations.has(location_id)
+                                and not ap.client._checked_locations.has(location_id)
+                        ):
+                                tracker_loc_tree_item_by_id[location_id].visible = true
+
+                for port_id in tracker_port_tree_item_by_id.keys():
+                        if (
+                                ap.client._accessible_worldports.has(port_id)
+                                and not ap.client._checked_worldports.has(port_id)
+                        ):
+                                tracker_port_tree_item_by_id[port_id].visible = true
+
+                if tracker_goal_tree_item != null and ap.client._goal_accessible:
+                        tracker_goal_tree_item.visible = true
+
+                if tracker_ignored_group != null:
+                        tracker_ignored_group.visible = true
+
+
+func _cmp_tracker_objects(a, b) -> bool:
+        if a["ignored"] != b["ignored"]:
+                return !a["ignored"]
+        elif a["hint"] != b["hint"]:
+                return a["hint"]
+        else:
+                return a["name"] < b["name"]
+
+
+func update_locations_visibility():
+        var ap = global.get_node("Archipelago")
+        locations_overlay.visible = ap.show_locations
+
+
+func _on_tracker_button_clicked():
+        var ap = global.get_node("Archipelago")
+
+        var edited_item = tracker_tree.get_edited()
+        var edited_index = edited_item.get_index()
+
+        if edited_item.get_parent() == tracker_tree.get_root():
+                if tracker_object_by_index.has(edited_index):
+                        var tracker_object = tracker_object_by_index[edited_index]
+                        if tracker_tree.get_edited_column() == 2:
+                                var type_str = ""
+                                if tracker_object["type"] == kLocation:
+                                        type_str = "location"
+                                elif tracker_object["type"] == kWorldport:
+                                        type_str = "worldport"
+                                elif tracker_object["type"] == kGoal:
+                                        type_str = "goal"
+                                ap.client.getLogicalPath(type_str, tracker_object.get("id", null))
+                        elif tracker_tree.get_edited_column() == 3:
+                                ap.toggle_ignored_location(tracker_object["id"])
+        elif edited_item.get_parent() == tracker_ignored_group:
+                # This is the ignored locations group.
+                if (
+                        tracker_object_by_ignored_index.has(edited_index)
+                        and tracker_tree.get_edited_column() == 3
+                ):
+                        var tracker_object = tracker_object_by_ignored_index[edited_index]
+                        ap.toggle_ignored_location(tracker_object["id"])
+
+
+func display_logical_path(object_type, object_id, paths):
+        var ap = global.get_node("Archipelago")
+        var gamedata = global.get_node("Gamedata")
+
+        var location_name = "(Unknown)"
+        if object_type == "location" and object_id != null:
+                location_name = gamedata.location_name_by_id.get(object_id, "(Unknown)")
+        elif object_type == "worldport" and object_id != null:
+                location_name = gamedata.get_worldport_display_name(object_id)
+        elif object_type == "goal":
+                location_name = gamedata.ending_display_name_by_name[ap.kEndingNameByVictoryValue[
+                        ap.victory_condition
+                ]]
+
+        label.append_text("[p]Path to %s:[/p]" % location_name)
+        label.append_text("[ol]" + "\n".join(paths) + "[/ol]")
+
+        panel.visible = true
+
+
+func setup_worldports():
+        tabs.set_tab_hidden(2, false)
+
+        var root_ti = worldports_tree.create_item(null)
+
+        var ports_by_map_id = {}
+        var display_names_by_map_id = {}
+        var display_names_by_port_id = {}
+
+        var ap = global.get_node("Archipelago")
+        var gamedata = global.get_node("Gamedata")
+        for fpid in ap.port_pairings:
+                var port = gamedata.objects.get_ports()[fpid]
+                var room = gamedata.objects.get_rooms()[port.get_room_id()]
+
+                if not ports_by_map_id.has(room.get_map_id()):
+                        ports_by_map_id[room.get_map_id()] = []
+
+                        var map = gamedata.objects.get_maps()[room.get_map_id()]
+                        display_names_by_map_id[map.get_id()] = map.get_display_name()
+
+                ports_by_map_id[room.get_map_id()].append(fpid)
+                display_names_by_port_id[fpid] = port.get_display_name()
+
+        var sorted_map_ids = ports_by_map_id.keys().duplicate()
+        sorted_map_ids.sort_custom(
+                func(a, b): return display_names_by_map_id[a] < display_names_by_map_id[b]
+        )
+
+        for map_id in sorted_map_ids:
+                var map_ti = root_ti.create_child()
+                map_ti.set_text(0, display_names_by_map_id[map_id])
+                map_ti.visible = false
+                map_ti.collapsed = true
+                port_tree_item_by_map[map_id] = map_ti
+                port_tree_item_by_map_port[map_id] = {}
+
+                var port_ids = ports_by_map_id[map_id]
+                port_ids.sort_custom(
+                        func(a, b): return display_names_by_port_id[a] < display_names_by_port_id[b]
+                )
+
+                for port_id in port_ids:
+                        var port_ti = map_ti.create_child()
+                        port_ti.set_text(0, display_names_by_port_id[port_id])
+                        port_ti.set_text(1, gamedata.get_worldport_display_name(ap.port_pairings[port_id]))
+                        port_ti.visible = false
+                        port_tree_item_by_map_port[map_id][port_id] = port_ti
+
+        update_worldports()
+
+
+func update_worldports():
+        var ap = global.get_node("Archipelago")
+
+        for map_id in port_tree_item_by_map_port.keys():
+                var map_visible = false
+
+                for port_id in port_tree_item_by_map_port[map_id].keys():
+                        var ti = port_tree_item_by_map_port[map_id][port_id]
+                        ti.visible = ap.client._checked_worldports.has(port_id)
+
+                        if ti.visible:
+                                map_visible = true
+
+                port_tree_item_by_map[map_id].visible = map_visible
+
+
+func reset():
+        locations_overlay.clear()
+        tabs.set_tab_hidden(2, true)
+        port_tree_item_by_map.clear()
+        port_tree_item_by_map_port.clear()
+        worldports_tree.clear()
+        reset_tracker_tab()
+
+
+func reset_tracker_tab():
+        tracker_loc_tree_item_by_id.clear()
+        tracker_port_tree_item_by_id.clear()
+        tracker_goal_tree_item = null
+        tracker_object_by_index.clear()
+        tracker_object_by_ignored_index.clear()
+        tracker_ignored_group = null
+        tracker_tree.clear()
@@ -0,0 +1,46 @@
+extends "res://scripts/nodes/listeners/unlockReaderListener.gd"
+
+var item_id = null
+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 = []
+
+        super._ready()
+
+
+func _readier():
+        if item_id != null:
+                var ap = global.get_node("Archipelago")
+
+                if ap.client.getItemAmount(item_id) >= item_amount:
+                        handleTriggered()
+        else:
+                super._readier()
+
+
+func handleTriggered():
+        if item_id != null:
+                emit_signal("trigger")
+        else:
+                super.handleTriggered()
@@ -0,0 +1,21 @@
+WebSocketServer.gd:
+
+Copyright (c) 2014-present Godot Engine contributors. Copyright (c) 2007-2014
+Juan Linietsky, Ariel Manzur.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
@@ -0,0 +1,173 @@
+class_name WebSocketServer
+extends Node
+
+signal message_received(peer_id: int, message: String)
+signal client_connected(peer_id: int)
+signal client_disconnected(peer_id: int)
+
+@export var handshake_headers := PackedStringArray()
+@export var supported_protocols := PackedStringArray()
+@export var handshake_timout := 3000
+@export var use_tls := false
+@export var tls_cert: X509Certificate
+@export var tls_key: CryptoKey
+@export var refuse_new_connections := false:
+        set(refuse):
+                if refuse:
+                        pending_peers.clear()
+
+
+class PendingPeer:
+        var connect_time: int
+        var tcp: StreamPeerTCP
+        var connection: StreamPeer
+        var ws: WebSocketPeer
+
+        func _init(p_tcp: StreamPeerTCP) -> void:
+                tcp = p_tcp
+                connection = p_tcp
+                connect_time = Time.get_ticks_msec()
+
+
+var tcp_server := TCPServer.new()
+var pending_peers: Array[PendingPeer] = []
+var peers: Dictionary
+
+
+func listen(port: int) -> int:
+        assert(not tcp_server.is_listening())
+        return tcp_server.listen(port)
+
+
+func stop() -> void:
+        tcp_server.stop()
+        pending_peers.clear()
+        peers.clear()
+
+
+func send(peer_id: int, message: String) -> int:
+        var type := typeof(message)
+        if peer_id <= 0:
+                # Send to multiple peers, (zero = broadcast, negative = exclude one).
+                for id: int in peers:
+                        if id == -peer_id:
+                                continue
+                        if type == TYPE_STRING:
+                                peers[id].send_text(message)
+                        else:
+                                peers[id].put_packet(message)
+                return OK
+
+        assert(peers.has(peer_id))
+        var socket: WebSocketPeer = peers[peer_id]
+        if type == TYPE_STRING:
+                return socket.send_text(message)
+        return socket.send(var_to_bytes(message))
+
+
+func get_message(peer_id: int) -> Variant:
+        assert(peers.has(peer_id))
+        var socket: WebSocketPeer = peers[peer_id]
+        if socket.get_available_packet_count() < 1:
+                return null
+        var pkt: PackedByteArray = socket.get_packet()
+        if socket.was_string_packet():
+                return pkt.get_string_from_utf8()
+        return bytes_to_var(pkt)
+
+
+func has_message(peer_id: int) -> bool:
+        assert(peers.has(peer_id))
+        return peers[peer_id].get_available_packet_count() > 0
+
+
+func _create_peer() -> WebSocketPeer:
+        var ws := WebSocketPeer.new()
+        ws.supported_protocols = supported_protocols
+        ws.handshake_headers = handshake_headers
+        return ws
+
+
+func poll() -> void:
+        if not tcp_server.is_listening():
+                return
+
+        while not refuse_new_connections and tcp_server.is_connection_available():
+                var conn: StreamPeerTCP = tcp_server.take_connection()
+                assert(conn != null)
+                pending_peers.append(PendingPeer.new(conn))
+
+        var to_remove := []
+
+        for p in pending_peers:
+                if not _connect_pending(p):
+                        if p.connect_time + handshake_timout < Time.get_ticks_msec():
+                                # Timeout.
+                                to_remove.append(p)
+                        continue  # Still pending.
+
+                to_remove.append(p)
+
+        for r: RefCounted in to_remove:
+                pending_peers.erase(r)
+
+        to_remove.clear()
+
+        for id: int in peers:
+                var p: WebSocketPeer = peers[id]
+                p.poll()
+
+                if p.get_ready_state() != WebSocketPeer.STATE_OPEN:
+                        client_disconnected.emit(id)
+                        to_remove.append(id)
+                        continue
+
+                while p.get_available_packet_count():
+                        message_received.emit(id, get_message(id))
+
+        for r: int in to_remove:
+                peers.erase(r)
+        to_remove.clear()
+
+
+func _connect_pending(p: PendingPeer) -> bool:
+        if p.ws != null:
+                # Poll websocket client if doing handshake.
+                p.ws.poll()
+                var state := p.ws.get_ready_state()
+                if state == WebSocketPeer.STATE_OPEN:
+                        var id := randi_range(2, 1 << 30)
+                        peers[id] = p.ws
+                        client_connected.emit(id)
+                        return true  # Success.
+                elif state != WebSocketPeer.STATE_CONNECTING:
+                        return true  # Failure.
+                return false  # Still connecting.
+        elif p.tcp.get_status() != StreamPeerTCP.STATUS_CONNECTED:
+                return true  # TCP disconnected.
+        elif not use_tls:
+                # TCP is ready, create WS peer.
+                p.ws = _create_peer()
+                p.ws.accept_stream(p.tcp)
+                return false  # WebSocketPeer connection is pending.
+
+        else:
+                if p.connection == p.tcp:
+                        assert(tls_key != null and tls_cert != null)
+                        var tls := StreamPeerTLS.new()
+                        tls.accept_stream(p.tcp, TLSOptions.server(tls_key, tls_cert))
+                        p.connection = tls
+                p.connection.poll()
+                var status: StreamPeerTLS.Status = p.connection.get_status()
+                if status == StreamPeerTLS.STATUS_CONNECTED:
+                        p.ws = _create_peer()
+                        p.ws.accept_stream(p.connection)
+                        return false  # WebSocketPeer connection is pending.
+                if status != StreamPeerTLS.STATUS_HANDSHAKING:
+                        return true  # Failure.
+
+                return false
+
+
+func _process(_delta: float) -> void:
+        poll()
@@ -0,0 +1,38 @@
+extends "res://scripts/nodes/listeners/visibilityListener.gd"
+
+var item_id
+var item_amount
+
+
+func _ready():
+        var node_path = String(
+                get_tree().get_root().get_node("scene").get_path_to(self).get_concatenated_names()
+        )
+
+        var gamedata = global.get_node("Gamedata")
+        var door_id = gamedata.get_door_for_map_node_path(global.map, node_path)
+        if door_id != null:
+                var ap = global.get_node("Archipelago")
+                var item_lock = ap.get_item_id_for_door(door_id)
+
+                if item_lock != null:
+                        item_id = item_lock[0]
+                        item_amount = item_lock[1]
+
+                        self.senders = []
+                        self.senderGroup = []
+                        self.nested = false
+                        self.complete_at = 0
+                        self.max_length = 0
+                        self.excludeSenders = []
+
+                        call_deferred("_readier")
+
+        super._ready()
+
+
+func _readier():
+        var ap = global.get_node("Archipelago")
+
+        if ap.client.getItemAmount(item_id) >= item_amount:
+                handleTriggered()
@@ -0,0 +1,61 @@
+extends "res://scripts/nodes/worldport.gd"
+
+var absolute_rotation = false
+var target_rotation = 0
+
+var port_id = null
+
+
+func _ready():
+        var node_path = String(
+                get_tree().get_root().get_node("scene").get_path_to(self).get_concatenated_names()
+        )
+
+        var ap = global.get_node("Archipelago")
+
+        if ap.shuffle_worldports:
+                var gamedata = global.get_node("Gamedata")
+                port_id = gamedata.get_port_for_map_node_path(global.map, node_path)
+                if port_id != null:
+                        if port_id in ap.port_pairings:
+                                var target_port = gamedata.objects.get_ports()[ap.port_pairings[port_id]]
+                                var target_room = gamedata.objects.get_rooms()[target_port.get_room_id()]
+                                var target_map = gamedata.objects.get_maps()[target_room.get_map_id()]
+
+                                exit = target_map.get_name()
+                                entry_point.x = target_port.get_destination().get_x()
+                                entry_point.y = target_port.get_destination().get_y()
+                                entry_point.z = target_port.get_destination().get_z()
+                                absolute_rotation = true
+                                target_rotation = target_port.get_rotation()
+                                sets_entry_point = true
+                                invisible = false
+                                fades = true
+                        else:
+                                port_id = null
+
+        if global.map == "icarus" and exit == "daedalus":
+                if not ap.daedalus_roof_access:
+                        entry_point = Vector3(58, 10, 0)
+
+        super._ready()
+
+
+func bodyEntered(body):
+        if body.is_in_group("player"):
+                if port_id != null:
+                        var ap = global.get_node("Archipelago")
+                        ap.client.checkWorldport(port_id)
+
+                if absolute_rotation:
+                        entry_rotate.y = target_rotation - body.rotation_degrees.y
+
+        super.bodyEntered(body)
+
+
+func changeScene():
+        var player = get_tree().get_root().get_node("scene/player")
+        if player != null:
+                player.playable = false
+
+        super.changeScene()
@@ -0,0 +1,8 @@
+extends "res://scripts/nodes/listeners/worldportListener.gd"
+
+
+func handleTriggered():
+        if exit.begins_with("menus/credits"):
+                return
+
+        super.handleTriggered()
@@ -0,0 +1,800 @@
+import asyncio
+import os
+import pkgutil
+import subprocess
+import sys
+from typing import Any
+
+import websockets
+
+import Utils
+import settings
+from BaseClasses import ItemClassification
+from CommonClient import CommonContext, server_loop, gui_enabled, logger, get_base_parser, handle_url_arg
+from NetUtils import Endpoint, decode, encode, ClientStatus
+from Utils import async_start
+from . import Lingo2World
+from .tracker import Tracker
+
+ALL_LETTERS = "abcdefghijklmnopqrstuvwxyz"
+MESSAGE_MAX_SIZE = 16*1024*1024
+PORT = 43182
+
+KEY_STORAGE_MAPPING = {
+    "a": (1, 0), "b": (1, 1), "c": (1, 2), "d": (1, 3), "e": (1, 4), "f": (1, 5), "g": (1, 6), "h": (1, 7), "i": (1, 8),
+    "j": (1, 9), "k": (1, 10), "l": (1, 11), "m": (1, 12), "n": (2, 0), "o": (2, 1), "p": (2, 2), "q": (2, 3),
+    "r": (2, 4), "s": (2, 5), "t": (2, 6), "u": (2, 7), "v": (2, 8), "w": (2, 9), "x": (2, 10), "y": (2, 11),
+    "z": (2, 12),
+}
+
+REVERSE_KEY_STORAGE_MAPPING = {t: k for k, t in KEY_STORAGE_MAPPING.items()}
+
+
+# There is a distinction between an object's ID and its AP ID. The latter is stable between releases, whereas the former
+# can change and is also namespaced based on the object type. We should only store AP IDs in multiworld state (such as
+# slot data and data storage) to increase compatability between releases. The data we currently store is:
+# - Port pairings for worldport shuffle (slot data)
+# - Checked worldports for worldport shuffle (data storage)
+# - Latched doors (data storage)
+# The client generally deals in the actual object IDs rather than the stable IDs, although it does have to convert the
+# port pairing IDs when reading them from slot data. The context (this file here) does the work of converting back and
+# forth between the values. AP IDs are converted to IDs after reading them from data storage, and IDs are converted to
+# AP IDs before sending them to data storage.
+class Lingo2Manager:
+    game_ctx: "Lingo2GameContext"
+    client_ctx: "Lingo2ClientContext"
+    tracker: Tracker
+
+    keyboard: dict[str, int]
+    worldports: set[int]
+    goaled: bool
+    latches: set[int]
+    hinted_locations: set[int]
+
+    def __init__(self, game_ctx: "Lingo2GameContext", client_ctx: "Lingo2ClientContext"):
+        self.game_ctx = game_ctx
+        self.game_ctx.manager = self
+        self.client_ctx = client_ctx
+        self.client_ctx.manager = self
+        self.tracker = Tracker(self)
+        self.keyboard = {}
+
+        self.reset()
+
+    def reset(self):
+        for k in ALL_LETTERS:
+            self.keyboard[k] = 0
+
+        self.worldports = set()
+        self.goaled = False
+        self.latches = set()
+        self.hinted_locations = set()
+
+    def update_keyboard(self, new_keyboard: dict[str, int]) -> dict[str, int]:
+        ret: dict[str, int] = {}
+
+        for k, v in new_keyboard.items():
+            if v > self.keyboard.get(k, 0):
+                self.keyboard[k] = v
+                ret[k] = v
+
+        if len(ret) > 0:
+            self.tracker.refresh_state()
+            self.game_ctx.send_accessible_locations()
+
+        return ret
+
+    # Input should be real IDs, not AP IDs
+    def update_worldports(self, new_worldports: set[int]) -> set[int]:
+        ret = new_worldports.difference(self.worldports)
+        self.worldports.update(new_worldports)
+
+        if len(ret) > 0:
+            self.tracker.refresh_state()
+            self.game_ctx.send_accessible_locations()
+
+        return ret
+
+    def update_latches(self, new_latches: set[int]) -> set[int]:
+        ret = new_latches.difference(self.latches)
+        self.latches.update(new_latches)
+
+        return ret
+
+    def update_hinted_locations(self, new_locs: set[int]) -> set[int]:
+        ret = new_locs.difference(self.hinted_locations)
+        self.hinted_locations.update(new_locs)
+
+        return ret
+
+
+class Lingo2GameContext:
+    server: Endpoint | None
+    manager: Lingo2Manager
+
+    def __init__(self):
+        self.server = None
+
+    def send_connected(self):
+        if self.server is None:
+            return
+
+        msg = {
+            "cmd": "Connected",
+            "user": self.manager.client_ctx.username,
+            "seed_name": self.manager.client_ctx.seed_name,
+            "version": self.manager.client_ctx.server_version,
+            "generator_version": self.manager.client_ctx.generator_version,
+            "team": self.manager.client_ctx.team,
+            "slot": self.manager.client_ctx.slot,
+            "checked_locations": self.manager.client_ctx.checked_locations,
+            "slot_data": self.manager.client_ctx.slot_data,
+        }
+
+        async_start(self.send_msgs([msg]), name="game Connected")
+
+    def send_connection_refused(self, text):
+        if self.server is None:
+            return
+
+        msg = {
+            "cmd": "ConnectionRefused",
+            "text": text,
+        }
+
+        async_start(self.send_msgs([msg]), name="game ConnectionRefused")
+
+    def send_item_sent_notification(self, item_name, receiver_name, item_flags):
+        if self.server is None:
+            return
+
+        msg = {
+            "cmd": "ItemSentNotif",
+            "item_name": item_name,
+            "receiver_name": receiver_name,
+            "item_flags": item_flags,
+        }
+
+        async_start(self.send_msgs([msg]), name="item sent notif")
+
+    def send_hint_received(self, item_name, location_name, receiver_name, item_flags, for_self):
+        if self.server is None:
+            return
+
+        msg = {
+            "cmd": "HintReceived",
+            "item_name": item_name,
+            "location_name": location_name,
+            "receiver_name": receiver_name,
+            "item_flags": item_flags,
+            "self": int(for_self),
+        }
+
+        async_start(self.send_msgs([msg]), name="hint received notif")
+
+    def send_item_received(self, items):
+        if self.server is None:
+            return
+
+        msg = {
+            "cmd": "ItemReceived",
+            "items": items,
+        }
+
+        async_start(self.send_msgs([msg]), name="item received")
+
+    def send_location_info(self, locations):
+        if self.server is None:
+            return
+
+        msg = {
+            "cmd": "LocationInfo",
+            "locations": locations,
+        }
+
+        async_start(self.send_msgs([msg]), name="location info")
+
+    def send_text_message(self, parts):
+        if self.server is None:
+            return
+
+        msg = {
+            "cmd": "TextMessage",
+            "data": parts,
+        }
+
+        async_start(self.send_msgs([msg]), name="notif")
+
+    def send_accessible_locations(self):
+        if self.server is None:
+            return
+
+        msg = {
+            "cmd": "AccessibleLocations",
+            "locations": list(self.manager.tracker.accessible_locations),
+        }
+
+        if len(self.manager.tracker.accessible_worldports) > 0:
+            msg["worldports"] = list(self.manager.tracker.accessible_worldports)
+
+        if self.manager.tracker.goal_accessible and not self.manager.goaled:
+            msg["goal"] = True
+
+        async_start(self.send_msgs([msg]), name="accessible locations")
+
+    def send_update_locations(self, locations):
+        if self.server is None:
+            return
+
+        msg = {
+            "cmd": "UpdateLocations",
+            "locations": locations,
+        }
+
+        async_start(self.send_msgs([msg]), name="update locations")
+
+    def send_update_keyboard(self, updates):
+        if self.server is None:
+            return
+
+        msg = {
+            "cmd": "UpdateKeyboard",
+            "updates": updates,
+        }
+
+        async_start(self.send_msgs([msg]), name="update keyboard")
+
+    # Input should be real IDs, not AP IDs
+    def send_update_worldports(self, worldports):
+        if self.server is None:
+            return
+
+        msg = {
+            "cmd": "UpdateWorldports",
+            "worldports": worldports,
+        }
+
+        async_start(self.send_msgs([msg]), name="update worldports")
+
+    def send_path_reply(self, object_type: str, object_id: int | None, path: list[str]):
+        if self.server is None:
+            return
+
+        msg = {
+            "cmd": "PathReply",
+            "type": object_type,
+            "path": path,
+        }
+
+        if object_id is not None:
+            msg["id"] = object_id
+
+        async_start(self.send_msgs([msg]), name="path reply")
+
+    def send_update_latches(self, latches):
+        if self.server is None:
+            return
+
+        msg = {
+            "cmd": "UpdateLatches",
+            "latches": latches,
+        }
+
+        async_start(self.send_msgs([msg]), name="update latches")
+
+    def send_ignored_locations(self, ignored_locations):
+        if self.server is None:
+            return
+
+        msg = {
+            "cmd": "SetIgnoredLocations",
+            "locations": ignored_locations,
+        }
+
+        async_start(self.send_msgs([msg]), name="set ignored locations")
+
+    def send_update_hinted_locations(self, hinted_locations):
+        if self.server is None:
+            return
+
+        msg = {
+            "cmd": "UpdateHintedLocations",
+            "locations": hinted_locations,
+        }
+
+        async_start(self.send_msgs([msg]), name="update hinted locations")
+
+    async def send_msgs(self, msgs: list[Any]) -> None:
+        """ `msgs` JSON serializable """
+        if not self.server or not self.server.socket.open or self.server.socket.closed:
+            return
+        await self.server.socket.send(encode(msgs))
+
+
+class Lingo2ClientContext(CommonContext):
+    manager: Lingo2Manager
+
+    game = "Lingo 2"
+    items_handling = 0b111
+
+    slot_data: dict[str, Any] | None
+    hints_data_storage_key: str
+    victory_data_storage_key: str
+
+    def __init__(self, server_address: str | None = None, password: str | None = None):
+        super().__init__(server_address, password)
+
+    def make_gui(self):
+        ui = super().make_gui()
+        ui.base_title = "Archipelago Lingo 2 Client"
+        return ui
+
+    async def server_auth(self, password_requested: bool = False):
+        if password_requested and not self.password:
+            self.manager.game_ctx.send_connection_refused("Invalid password.")
+        else:
+            self.auth = self.username
+            await self.send_connect()
+
+    def handle_connection_loss(self, msg: str):
+        super().handle_connection_loss(msg)
+
+        exc_info = sys.exc_info()
+        self.manager.game_ctx.send_connection_refused(str(exc_info[1]))
+
+    def on_package(self, cmd: str, args: dict):
+        if cmd == "RoomInfo":
+            self.seed_name = args.get("seed_name", None)
+        elif cmd == "Connected":
+            self.slot_data = args.get("slot_data", None)
+
+            self.manager.reset()
+
+            self.manager.game_ctx.send_connected()
+
+            self.manager.tracker.setup_slot(self.slot_data)
+            self.manager.tracker.set_checked_locations(self.checked_locations)
+            self.manager.game_ctx.send_accessible_locations()
+
+            self.hints_data_storage_key = f"_read_hints_{self.team}_{self.slot}"
+            self.victory_data_storage_key = f"_read_client_status_{self.team}_{self.slot}"
+
+            self.set_notify(self.get_datastorage_key("keyboard1"), self.get_datastorage_key("keyboard2"),
+                            self.victory_data_storage_key, self.get_datastorage_key("latches"),
+                            self.get_datastorage_key("ignored_locations"))
+            msg_batch = [{
+                "cmd": "Set",
+                "key": self.get_datastorage_key("keyboard1"),
+                "default": 0,
+                "want_reply": True,
+                "operations": [{"operation": "default", "value": 0}]
+            }, {
+                "cmd": "Set",
+                "key": self.get_datastorage_key("keyboard2"),
+                "default": 0,
+                "want_reply": True,
+                "operations": [{"operation": "default", "value": 0}]
+            }, {
+                "cmd": "Set",
+                "key": self.get_datastorage_key("latches"),
+                "default": [],
+                "want_reply": True,
+                "operations": [{"operation": "default", "value": []}]
+            }, {
+                "cmd": "Set",
+                "key": self.get_datastorage_key("ignored_locations"),
+                "default": [],
+                "want_reply": True,
+                "operations": [{"operation": "default", "value": []}]
+            }]
+
+            if self.slot_data.get("shuffle_worldports", False):
+                self.set_notify(self.get_datastorage_key("worldports"))
+                msg_batch.append({
+                    "cmd": "Set",
+                    "key": self.get_datastorage_key("worldports"),
+                    "default": [],
+                    "want_reply": True,
+                    "operations": [{"operation": "default", "value": []}]
+                })
+
+            async_start(self.send_msgs(msg_batch), name="default keys")
+        elif cmd == "RoomUpdate":
+            if "checked_locations" in args:
+                self.manager.tracker.set_checked_locations(self.checked_locations)
+                self.manager.game_ctx.send_update_locations(args["checked_locations"])
+        elif cmd == "ReceivedItems":
+            self.manager.tracker.set_collected_items(self.items_received)
+
+            cur_index = 0
+            items = []
+
+            for item in args["items"]:
+                index = cur_index + args["index"]
+                cur_index += 1
+
+                item_msg = {
+                    "id": item.item,
+                    "index": index,
+                    "flags": item.flags,
+                    "text": self.item_names.lookup_in_slot(item.item, self.slot),
+                }
+
+                if item.player != self.slot:
+                    item_msg["sender"] = self.player_names.get(item.player)
+
+                items.append(item_msg)
+
+            self.manager.game_ctx.send_item_received(items)
+
+            if any(ItemClassification.progression in ItemClassification(item.flags) for item in args["items"]):
+                self.manager.game_ctx.send_accessible_locations()
+        elif cmd == "PrintJSON":
+            if "receiving" in args and "item" in args and args["item"].player == self.slot:
+                item_name = self.item_names.lookup_in_slot(args["item"].item, args["receiving"])
+                location_name = self.location_names.lookup_in_slot(args["item"].location, args["item"].player)
+                receiver_name = self.player_names.get(args["receiving"])
+
+                if args["type"] == "Hint" and not args.get("found", False):
+                    self.manager.game_ctx.send_hint_received(item_name, location_name, receiver_name, args["item"].flags,
+                                                             int(args["receiving"]) == self.slot)
+                elif args["receiving"] != self.slot:
+                    self.manager.game_ctx.send_item_sent_notification(item_name, receiver_name, args["item"].flags)
+
+            parts = []
+            for message_part in args["data"]:
+                if "type" not in message_part and "text" in message_part:
+                    parts.append({"type": "text", "text": message_part["text"]})
+                elif message_part["type"] == "player_id":
+                    parts.append({
+                        "type": "player",
+                        "text": self.player_names.get(int(message_part["text"])),
+                        "self": int(int(message_part["text"]) == self.slot),
+                    })
+                elif message_part["type"] == "item_id":
+                    parts.append({
+                        "type": "item",
+                        "text": self.item_names.lookup_in_slot(int(message_part["text"]), message_part["player"]),
+                        "flags": message_part["flags"],
+                    })
+                elif message_part["type"] == "location_id":
+                    parts.append({
+                        "type": "location",
+                        "text": self.location_names.lookup_in_slot(int(message_part["text"]),
+                                                                   message_part["player"])
+                    })
+                elif "text" in message_part:
+                    parts.append({"type": "text", "text": message_part["text"]})
+
+            self.manager.game_ctx.send_text_message(parts)
+        elif cmd == "LocationInfo":
+            locations = []
+
+            for location in args["locations"]:
+                locations.append({
+                    "id": location.location,
+                    "item": self.item_names.lookup_in_slot(location.item, location.player),
+                    "player": self.player_names.get(location.player),
+                    "flags": location.flags,
+                    "self": int(location.player) == self.slot,
+                })
+
+            self.manager.game_ctx.send_location_info(locations)
+        elif cmd == "Retrieved":
+            for k, v in args["keys"].items():
+                if k == self.victory_data_storage_key:
+                    self.handle_status_update(v)
+                elif k == self.hints_data_storage_key:
+                    self.update_hints()
+        elif cmd == "SetReply":
+            if args["key"] == self.get_datastorage_key("keyboard1"):
+                self.handle_keyboard_update(1, args)
+            elif args["key"] == self.get_datastorage_key("keyboard2"):
+                self.handle_keyboard_update(2, args)
+            elif args["key"] == self.get_datastorage_key("worldports"):
+                port_ids = set(Lingo2World.static_logic.port_id_by_ap_id[ap_id] for ap_id in args["value"])
+                updates = self.manager.update_worldports(port_ids)
+                if len(updates) > 0:
+                    self.manager.game_ctx.send_update_worldports(updates)
+            elif args["key"] == self.victory_data_storage_key:
+                self.handle_status_update(args["value"])
+            elif args["key"] == self.get_datastorage_key("latches"):
+                door_ids = set(Lingo2World.static_logic.door_id_by_ap_id[ap_id] for ap_id in args["value"])
+                updates = self.manager.update_latches(door_ids)
+                if len(updates) > 0:
+                    self.manager.game_ctx.send_update_latches(updates)
+            elif args["key"] == self.get_datastorage_key("ignored_locations"):
+                self.manager.game_ctx.send_ignored_locations(args["value"])
+            elif args["key"] == self.hints_data_storage_key:
+                self.update_hints()
+
+    def get_datastorage_key(self, name: str):
+        return f"Lingo2_{self.slot}_{name}"
+
+    async def update_keyboard(self, updates: dict[str, int]):
+        kb1 = 0
+        kb2 = 0
+
+        for k, v in updates.items():
+            if v == 0:
+                continue
+
+            effect = 0
+            if v >= 1:
+                effect |= 1
+            if v == 2:
+                effect |= 2
+
+            pos = KEY_STORAGE_MAPPING[k]
+            if pos[0] == 1:
+                kb1 |= (effect << pos[1] * 2)
+            else:
+                kb2 |= (effect << pos[1] * 2)
+
+        msgs = []
+
+        if kb1 != 0:
+            msgs.append({
+                "cmd": "Set",
+                "key": self.get_datastorage_key("keyboard1"),
+                "want_reply": True,
+                "operations": [{
+                    "operation": "or",
+                    "value": kb1
+                }]
+            })
+
+        if kb2 != 0:
+            msgs.append({
+                "cmd": "Set",
+                "key": self.get_datastorage_key("keyboard2"),
+                "want_reply": True,
+                "operations": [{
+                    "operation": "or",
+                    "value": kb2
+                }]
+            })
+
+        if len(msgs) > 0:
+            await self.send_msgs(msgs)
+
+    def handle_keyboard_update(self, field: int, args: dict[str, Any]):
+        keys = {}
+        value = args["value"]
+
+        for i in range(0, 13):
+            if (value & (1 << (i * 2))) != 0:
+                keys[REVERSE_KEY_STORAGE_MAPPING[(field, i)]] = 1
+            if (value & (1 << (i * 2 + 1))) != 0:
+                keys[REVERSE_KEY_STORAGE_MAPPING[(field, i)]] = 2
+
+        updates = self.manager.update_keyboard(keys)
+        if len(updates) > 0:
+            self.manager.game_ctx.send_update_keyboard(updates)
+
+    # Input should be real IDs, not AP IDs
+    async def update_worldports(self, updates: set[int]):
+        port_ap_ids = [Lingo2World.static_logic.objects.ports[port_id].ap_id for port_id in updates]
+        await self.send_msgs([{
+            "cmd": "Set",
+            "key": self.get_datastorage_key("worldports"),
+            "want_reply": True,
+            "operations": [{
+                "operation": "update",
+                "value": port_ap_ids
+            }]
+        }])
+
+    def handle_status_update(self, value: int):
+        self.manager.goaled = (value == ClientStatus.CLIENT_GOAL)
+        self.manager.tracker.refresh_state()
+        self.manager.game_ctx.send_accessible_locations()
+
+    async def update_latches(self, updates: set[int]):
+        door_ap_ids = [Lingo2World.static_logic.objects.doors[door_id].ap_id for door_id in updates]
+        await self.send_msgs([{
+            "cmd": "Set",
+            "key": self.get_datastorage_key("latches"),
+            "want_reply": True,
+            "operations": [{
+                "operation": "update",
+                "value": door_ap_ids
+            }]
+        }])
+
+    async def add_ignored_location(self, loc_id: int):
+        await self.send_msgs([{
+            "cmd": "Set",
+            "key": self.get_datastorage_key("ignored_locations"),
+            "want_reply": True,
+            "operations": [{
+                "operation": "update",
+                "value": [loc_id]
+            }]
+        }])
+
+    async def remove_ignored_location(self, loc_id: int):
+        await self.send_msgs([{
+            "cmd": "Set",
+            "key": self.get_datastorage_key("ignored_locations"),
+            "want_reply": True,
+            "operations": [{
+                "operation": "remove",
+                "value": loc_id
+            }]
+        }])
+
+    def update_hints(self):
+        hints = self.stored_data.get(self.hints_data_storage_key, [])
+
+        hinted_locations = set(hint["location"] for hint in hints if hint["finding_player"] == self.slot)
+        updates = self.manager.update_hinted_locations(hinted_locations)
+        if len(updates) > 0:
+            self.manager.game_ctx.send_update_hinted_locations(updates)
+
+
+async def pipe_loop(manager: Lingo2Manager):
+    while not manager.client_ctx.exit_event.is_set():
+        try:
+            socket = await websockets.connect("ws://localhost", port=PORT, ping_timeout=None, ping_interval=None,
+                                              max_size=MESSAGE_MAX_SIZE)
+            manager.game_ctx.server = Endpoint(socket)
+            logger.info("Connected to Lingo 2!")
+            if manager.client_ctx.auth is not None:
+                manager.game_ctx.send_connected()
+                manager.game_ctx.send_accessible_locations()
+            async for data in manager.game_ctx.server.socket:
+                for msg in decode(data):
+                    await process_game_cmd(manager, msg)
+        except ConnectionRefusedError:
+            logger.info("Could not connect to Lingo 2.")
+        finally:
+            manager.game_ctx.server = None
+
+
+async def process_game_cmd(manager: Lingo2Manager, args: dict):
+    cmd = args["cmd"]
+
+    if cmd == "Connect":
+        manager.client_ctx.seed_name = None
+
+        server = args.get("server")
+        player = args.get("player")
+        password = args.get("password")
+
+        if password != "":
+            server_address = f"{player}:{password}@{server}"
+        else:
+            server_address = f"{player}:None@{server}"
+
+        async_start(manager.client_ctx.connect(server_address), name="client connect")
+    elif cmd == "Disconnect":
+        manager.client_ctx.seed_name = None
+
+        async_start(manager.client_ctx.disconnect(), name="client disconnect")
+    elif cmd in ["Sync", "LocationChecks", "Say", "StatusUpdate", "LocationScouts"]:
+        async_start(manager.client_ctx.send_msgs([args]), name="client forward")
+    elif cmd == "UpdateKeyboard":
+        updates = manager.update_keyboard(args["keyboard"])
+        if len(updates) > 0:
+            async_start(manager.client_ctx.update_keyboard(updates), name="client update keyboard")
+    elif cmd == "CheckWorldport":
+        port_id = args["port_id"]
+        port_ap_id = Lingo2World.static_logic.objects.ports[port_id].ap_id
+        worldports = {port_id}
+
+        # Also check the reverse port if it's a two-way connection.
+        port_pairings = manager.client_ctx.slot_data["port_pairings"]
+        if str(port_ap_id) in port_pairings and\
+                port_pairings.get(str(port_pairings[str(port_ap_id)]), None) == port_ap_id:
+            worldports.add(Lingo2World.static_logic.port_id_by_ap_id[port_pairings[str(port_ap_id)]])
+
+        updates = manager.update_worldports(worldports)
+        if len(updates) > 0:
+            async_start(manager.client_ctx.update_worldports(updates), name="client update worldports")
+            manager.game_ctx.send_update_worldports(updates)
+    elif cmd == "GetPath":
+        path = None
+
+        if args["type"] == "location":
+            path = manager.tracker.get_path_to_location(args["id"])
+        elif args["type"] == "worldport":
+            path = manager.tracker.get_path_to_port(args["id"])
+        elif args["type"] == "goal":
+            path = manager.tracker.get_path_to_goal()
+
+        manager.game_ctx.send_path_reply(args["type"], args.get("id", None), path)
+    elif cmd == "LatchDoor":
+        updates = manager.update_latches({args["door"]})
+        if len(updates) > 0:
+            async_start(manager.client_ctx.update_latches(updates), name="client update latches")
+    elif cmd == "IgnoreLocation":
+        async_start(manager.client_ctx.add_ignored_location(args["id"]), name="client ignore loc")
+    elif cmd == "UnignoreLocation":
+        async_start(manager.client_ctx.remove_ignored_location(args["id"]), name="client unignore loc")
+    elif cmd == "Quit":
+        manager.client_ctx.exit_event.set()
+
+
+async def run_game():
+    exe_file = settings.get_settings().lingo2_options.exe_file
+
+    # This ensures we can use Steam features without having to open the game
+    # through steam.
+    steam_appid_path = os.path.join(os.path.dirname(exe_file), "steam_appid.txt")
+    with open(steam_appid_path, "w") as said_handle:
+        said_handle.write("2523310")
+
+    if Lingo2World.zip_path is not None:
+        # This is a packaged apworld.
+        init_scene = pkgutil.get_data(__name__, "client/run_from_apworld.tscn")
+        init_path = Utils.local_path("data", "lingo2_init.tscn")
+
+        with open(init_path, "wb") as file_handle:
+            file_handle.write(init_scene)
+
+        subprocess.Popen(
+            [
+                exe_file,
+                "--scene",
+                init_path,
+                "--",
+                str(Lingo2World.zip_path.absolute()),
+            ],
+            cwd=os.path.dirname(exe_file),
+        )
+    else:
+        # The world is unzipped and being run in source.
+        subprocess.Popen(
+            [
+                exe_file,
+                "--scene",
+                Utils.local_path("worlds", "lingo2", "client", "run_from_source.tscn"),
+                "--",
+                Utils.local_path("worlds", "lingo2", "client"),
+            ],
+            cwd=os.path.dirname(exe_file),
+        )
+
+
+def client_main(*launch_args: str) -> None:
+    async def main(args):
+        if settings.get_settings().lingo2_options.start_game:
+            async_start(run_game())
+
+        client_ctx = Lingo2ClientContext(args.connect, args.password)
+        client_ctx.auth = args.name
+
+        game_ctx = Lingo2GameContext()
+        manager = Lingo2Manager(game_ctx, client_ctx)
+
+        client_ctx.server_task = asyncio.create_task(server_loop(client_ctx), name="ServerLoop")
+
+        if gui_enabled:
+            client_ctx.run_gui()
+        client_ctx.run_cli()
+
+        pipe_task = asyncio.create_task(pipe_loop(manager), name="GameWatcher")
+
+        try:
+            await pipe_task
+        except Exception as e:
+            logger.exception(e)
+
+        await client_ctx.exit_event.wait()
+        client_ctx.ui.stop()
+        await client_ctx.shutdown()
+
+    Utils.init_logging("Lingo2Client", exception_logger="Client")
+    import colorama
+
+    parser = get_base_parser(description="Lingo 2 Archipelago Client")
+    parser.add_argument('--name', default=None, help="Slot Name to connect as.")
+    parser.add_argument("url", nargs="?", help="Archipelago connection url")
+    args = parser.parse_args(launch_args)
+
+    args = handle_url_arg(args, parser=parser)
+
+    colorama.just_fix_windows_console()
+    asyncio.run(main(args))
+    colorama.deinit()
@@ -0,0 +1,4 @@
+# Lingo 2
+
+See [the project README](https://code.fourisland.com/lingo2-archipelago/about/)
+for installation instructions and frequently asked questions. 
\ No newline at end of file
@@ -1,5 +1,31 @@
+from .generated import data_pb2 as data_pb2
 from BaseClasses import Item
 
 
 class Lingo2Item(Item):
     game: str = "Lingo 2"
+
+
+SYMBOL_ITEMS: dict[data_pb2.PuzzleSymbol, str] = {
+    data_pb2.PuzzleSymbol.SUN: "Sun Symbol",
+    data_pb2.PuzzleSymbol.SPARKLES: "Sparkles Symbol",
+    data_pb2.PuzzleSymbol.ZERO: "Zero Symbol",
+    data_pb2.PuzzleSymbol.EXAMPLE: "Example Symbol",
+    data_pb2.PuzzleSymbol.BOXES: "Boxes Symbol",
+    data_pb2.PuzzleSymbol.PLANET: "Planet Symbol",
+    data_pb2.PuzzleSymbol.PYRAMID: "Pyramid Symbol",
+    data_pb2.PuzzleSymbol.CROSS: "Cross Symbol",
+    data_pb2.PuzzleSymbol.SWEET: "Sweet Symbol",
+    data_pb2.PuzzleSymbol.GENDER: "Gender Symbol",
+    data_pb2.PuzzleSymbol.AGE: "Age Symbol",
+    data_pb2.PuzzleSymbol.SOUND: "Sound Symbol",
+    data_pb2.PuzzleSymbol.ANAGRAM: "Anagram Symbol",
+    data_pb2.PuzzleSymbol.JOB: "Job Symbol",
+    data_pb2.PuzzleSymbol.STARS: "Stars Symbol",
+    data_pb2.PuzzleSymbol.NULL: "Null Symbol",
+    data_pb2.PuzzleSymbol.EVAL: "Eval Symbol",
+    data_pb2.PuzzleSymbol.LINGO: "Lingo Symbol",
+    data_pb2.PuzzleSymbol.QUESTION: "Question Symbol",
+}
+
+ANTI_COLLECTABLE_TRAPS: list[str] = [f"Anti {letter}" for letter in "ABCDEFGHIJKLMNOPQRSTUVWXYZ"]
@@ -3,3 +3,6 @@ from BaseClasses import Location
 
 class Lingo2Location(Location):
     game: str = "Lingo 2"
+
+    port_id: int
+    goal: bool
@@ -1,9 +1,9 @@
 from dataclasses import dataclass
 
-from Options import PerGameCommonOptions, Toggle, Choice
+from Options import PerGameCommonOptions, Toggle, Choice, DefaultOnToggle, Range, OptionSet
 
 
-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"
 
@@ -16,6 +16,11 @@ class ShuffleControlCenterColors(Toggle):
     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
@@ -39,6 +44,23 @@ class ShuffleLetters(Choice):
     option_item_cyan = 4
 
 
+class ShuffleSymbols(Toggle):
+    """
+    If enabled, 19 items will be added to the pool, representing the different symbols that can appear on a panel.
+    Players will be prevented from solving puzzles with symbols on them until all of the required symbols are unlocked.
+    """
+    display_name = "Shuffle Symbols"
+
+
+class ShuffleWorldports(Toggle):
+    """
+    Randomizes the connections between maps. This affects worldports only, which are the loading zones you walk into in
+    order to change maps. This does not affect paintings, panels that teleport you, or certain other special connections
+    like the one between The Shop and Control Center.
+    """
+    display_name = "Shuffle Worldports"
+
+
 class KeyholderSanity(Toggle):
     """
     If enabled, 26 locations will be created for placing each key into its respective Green Ending keyholder.
@@ -69,6 +91,36 @@ class CyanDoorBehavior(Choice):
     option_item = 2
 
 
+class EnableIcarus(Toggle):
+    """
+    Controls whether Icarus is randomized. If disabled, which is the default, no locations or items will be created for
+    it, and its worldport will not be shuffled when worldport shuffle is on.
+    """
+    display_name = "Enable Icarus"
+
+
+class EnableGiftMaps(OptionSet):
+    """
+    Controls whether the beta tester gift maps are randomized. By default, these are not accessible at all from within
+    the randomizer. This option allows you to enter the maps, and creates items and locations for them. If worldport
+    shuffle is on, their worldports will be included in the randomization.
+
+    The gift maps are accessed via a panel in The Entry's Starting Room, which only appears if at least one gift map is
+    enabled. It is also treated like a cyan door, and will not appear until the condition specified in the Cyan Door
+    Behavior option is satisfied. Solving this panel with the name of one of the beta testers will teleport you to their
+    corresponding gift map.
+
+    In the base game, nothing happens once you complete a gift map. Masteries have been added to the gift maps in the
+    randomizer so that the player can be rewarded for completing them.
+
+    Note that the gift maps were originally only intended to be played by specific people, and as a result may be
+    frustrating or require knowledge of inside jokes. The Crystalline is particularly difficult as it requires
+    completing a parkour course.
+    """
+    display_name = "Enable Gift Maps"
+    valid_keys = ["The Advanced", "The Charismatic", "The Crystalline", "The Fuzzy", "The Stellar"]
+
+
 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
@@ -79,8 +131,40 @@ class DaedalusRoofAccess(Toggle):
     display_name = "Allow Daedalus Roof Access"
 
 
+class StrictPurpleEnding(DefaultOnToggle):
+    """
+    If enabled, the player will be required to have all purple (level 1) letters in order to get Purple Ending.
+    Otherwise, some of the letters may be skippable depending on the other options.
+    """
+    display_name = "Strict Purple Ending"
+
+
+class StrictCyanEnding(DefaultOnToggle):
+    """
+    If enabled, the player will be required to have all cyan (level 2) letters in order to get Cyan Ending. Otherwise,
+    at least J2, Q2, and V2 are skippable. Others may also be skippable depending on the options chosen.
+    """
+    display_name = "Strict Cyan Ending"
+
+
 class VictoryCondition(Choice):
-    """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
@@ -97,12 +181,50 @@ class VictoryCondition(Choice):
     option_white_ending = 12
 
 
+class EndingsRequirement(Range):
+    """The number of endings required to unlock White Ending."""
+    display_name = "Endings Requirement"
+    range_start = 0
+    range_end = 12
+    default = 12
+
+
+class MasteriesRequirement(Range):
+    """The number of masteries required to unlock White Ending.
+
+    There are only 13 masteries in the base game, but some of the other slot options may add more masteries to the
+    world. If the chosen number of masteries is higher than the total in your world, it will be automatically lowered to
+    the maximum."""
+    display_name = "Masteries Requirement"
+    range_start = 0
+    range_end = 19
+    default = 0
+
+
+class TrapPercentage(Range):
+    """Replaces junk items with traps, at the specified rate."""
+    display_name = "Trap Percentage"
+    range_start = 0
+    range_end = 100
+    default = 0
+
+
 @dataclass
 class Lingo2Options(PerGameCommonOptions):
     shuffle_doors: ShuffleDoors
     shuffle_control_center_colors: ShuffleControlCenterColors
+    shuffle_gallery_paintings: ShuffleGalleryPaintings
     shuffle_letters: ShuffleLetters
+    shuffle_symbols: ShuffleSymbols
+    shuffle_worldports: ShuffleWorldports
     keyholder_sanity: KeyholderSanity
     cyan_door_behavior: CyanDoorBehavior
+    enable_icarus: EnableIcarus
+    enable_gift_maps: EnableGiftMaps
     daedalus_roof_access: DaedalusRoofAccess
+    strict_purple_ending: StrictPurpleEnding
+    strict_cyan_ending: StrictCyanEnding
     victory_condition: VictoryCondition
+    endings_requirement: EndingsRequirement
+    masteries_requirement: MasteriesRequirement
+    trap_percentage: TrapPercentage
@@ -1,9 +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, ShuffleLetters, CyanDoorBehavior
+from .options import ShuffleLetters, CyanDoorBehavior
 
 if TYPE_CHECKING:
     from . import Lingo2World
@@ -23,21 +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 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:
@@ -49,16 +67,105 @@ 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)
+            self.or_logic.append([sub_req.copy() for sub_req in 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 = [sub_req.copy() for sub_req in 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 = [sub_req.copy() for sub_req in other.possibilities]
+                self.or_logic.append([right_req])
+            else:
+                self.complete_at = other.complete_at
+                self.possibilities = [sub_req.copy() for sub_req in other.possibilities]
+
+    def is_empty(self) -> bool:
+        return (len(self.items) == 0 and len(self.progressives) == 0 and len(self.rooms) == 0 and len(self.letters) == 0
+                and not self.cyans and len(self.or_logic) == 0 and self.complete_at is None)
+
+    def __eq__(self, other: "AccessRequirements"):
+        return (self.items == other.items and self.progressives == other.progressives and self.rooms == other.rooms and
+                self.letters == other.letters and self.cyans == other.cyans and self.or_logic == other.or_logic and
+                self.complete_at == other.complete_at and self.possibilities == other.possibilities)
+
+    def simplify(self):
+        resimplify = False
+
+        if len(self.or_logic) > 0:
+            old_or_logic = self.or_logic
+
+            def remove_redundant(sub_reqs: "AccessRequirements"):
+                new_reqs = sub_reqs.copy()
+                new_reqs.letters = {l: v for l, v in new_reqs.letters.items() if self.letters.get(l, 0) < v}
+                if new_reqs != sub_reqs:
+                    return new_reqs
+                else:
+                    return sub_reqs
+
+            self.or_logic = []
+            for disjunction in old_or_logic:
+                new_disjunction = []
+                for ssr in disjunction:
+                    new_ssr = remove_redundant(ssr)
+                    if not new_ssr.is_empty():
+                        new_disjunction.append(new_ssr)
+                    else:
+                        new_disjunction.clear()
+                        break
+                if len(new_disjunction) == 1:
+                    self.merge(new_disjunction[0])
+                    resimplify = True
+                elif len(new_disjunction) > 1:
+                    if all(cjr == new_disjunction[0] for cjr in new_disjunction):
+                        self.merge(new_disjunction[0])
+                        resimplify = True
+                    else:
+                        self.or_logic.append(new_disjunction)
+
+        if resimplify:
+            self.simplify()
+
+    def get_referenced_rooms(self):
+        result = set(self.rooms)
+
+        for disjunction in self.or_logic:
+            for sub_req in disjunction:
+                result = result.union(sub_req.get_referenced_rooms())
+
+        for sub_req in self.possibilities:
+            result = result.union(sub_req.get_referenced_rooms())
+
+        return result
+
+    def remove_room(self, room: str):
+        if room in self.rooms:
+            self.rooms.remove(room)
+
+        for disjunction in self.or_logic:
+            for sub_req in disjunction:
+                sub_req.remove_room(room)
+
+        for sub_req in self.possibilities:
+            sub_req.remove_room(room)
 
     def __repr__(self):
         parts = []
@@ -68,15 +175,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):
@@ -93,6 +202,8 @@ class LetterBehavior(IntEnum):
 class Lingo2PlayerLogic:
     world: "Lingo2World"
 
+    shuffled_maps: set[int]
+
     locations_by_room: dict[int, list[PlayerLocation]]
     event_loc_item_by_room: dict[int, dict[str, str]]
 
@@ -105,6 +216,7 @@ class Lingo2PlayerLogic:
     real_items: list[str]
 
     double_letter_amount: dict[str, int]
+    goal_room_id: int
 
     def __init__(self, world: "Lingo2World"):
         self.world = world
@@ -117,30 +229,76 @@ class Lingo2PlayerLogic:
         self.real_items = list()
         self.double_letter_amount = dict()
 
+        def should_shuffle_map(game_map) -> bool:
+            if game_map.type == data_pb2.MapType.NORMAL_MAP:
+                return True
+            elif game_map.type == data_pb2.MapType.ICARUS:
+                return bool(world.options.enable_icarus)
+            elif game_map.type == data_pb2.MapType.GIFT_MAP:
+                if game_map.name == "the_advanced":
+                    return "The Advanced" in world.options.enable_gift_maps.value
+                elif game_map.name == "the_charismatic":
+                    return "The Charismatic" in world.options.enable_gift_maps.value
+                elif game_map.name == "the_crystalline":
+                    return "The Crystalline" in world.options.enable_gift_maps.value
+                elif game_map.name == "the_fuzzy":
+                    return "The Fuzzy" in world.options.enable_gift_maps.value
+                elif game_map.name == "the_stellar":
+                    return "The Stellar" in world.options.enable_gift_maps.value
+
+            return False
+
+        self.shuffled_maps = set(game_map.id for game_map in world.static_logic.objects.maps
+                                 if should_shuffle_map(game_map))
+
+        maximum_masteries = 13 + len(world.options.enable_gift_maps.value)
+        if world.options.enable_icarus:
+            maximum_masteries += 1
+
+        if world.options.masteries_requirement > maximum_masteries:
+            world.options.masteries_requirement.value = maximum_masteries
+
+        if "The Fuzzy" in world.options.enable_gift_maps.value:
+            self.real_items.append("Numbers")
+
         if self.world.options.shuffle_doors:
             for progressive in world.static_logic.objects.progressives:
                 for i in range(0, len(progressive.doors)):
+                    door = world.static_logic.objects.doors[progressive.doors[i]]
+                    if door.map_id not in self.shuffled_maps:
+                        continue
+
                     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:
+                if not self.world.options.shuffle_doors or self.world.options.shuffle_worldports:
                     continue
             elif door_group.type == data_pb2.DoorGroupType.COLOR_CONNECTOR:
-                if not self.world.options.shuffle_control_center_colors:
+                if not self.world.options.shuffle_control_center_colors or self.world.options.shuffle_worldports:
+                    continue
+            elif door_group.type == data_pb2.DoorGroupType.SHUFFLE_GROUP:
+                if not self.world.options.shuffle_doors:
                     continue
             else:
                 continue
 
-            for door in door_group.doors:
-                self.item_by_door[door] = (door_group.name, 1)
+            shuffleable_doors = [door_id for door_id in door_group.doors
+                                 if world.static_logic.objects.doors[door_id].map_id in self.shuffled_maps]
 
-            self.real_items.append(door_group.name)
+            if len(shuffleable_doors) > 0:
+                for door in shuffleable_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.map_id not in self.shuffled_maps:
+                continue
+
             if door.type in [data_pb2.DoorType.EVENT, data_pb2.DoorType.LOCATION_ONLY, data_pb2.DoorType.GRAVESTONE]:
                 continue
 
@@ -155,6 +313,9 @@ class Lingo2PlayerLogic:
                     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)
@@ -166,29 +327,40 @@ class Lingo2PlayerLogic:
                 if door_group.type != data_pb2.DoorGroupType.CYAN_DOORS:
                     continue
 
-                for door in door_group.doors:
-                    if not door in self.item_by_door:
+                shuffleable_doors = [door_id for door_id in door_group.doors
+                                     if world.static_logic.objects.doors[door_id].map_id in self.shuffled_maps
+                                     and door_id not in self.item_by_door]
+
+                if len(shuffleable_doors) > 0:
+                    for door in shuffleable_doors:
                         self.item_by_door[door] = (door_group.name, 1)
 
-                self.real_items.append(door_group.name)
+                    self.real_items.append(door_group.name)
 
         for door in world.static_logic.objects.doors:
+            if door.map_id not in self.shuffled_maps:
+                continue
+
             if door.type in [data_pb2.DoorType.STANDARD, data_pb2.DoorType.LOCATION_ONLY, data_pb2.DoorType.GRAVESTONE]:
                 self.locations_by_room.setdefault(door.room_id, []).append(PlayerLocation(door.ap_id,
                                                                                           self.get_door_reqs(door.id)))
 
         for letter in world.static_logic.objects.letters:
+            if world.static_logic.get_room_object_map_id(letter) not in self.shuffled_maps:
+                continue
+
             self.locations_by_room.setdefault(letter.room_id, []).append(PlayerLocation(letter.ap_id,
                                                                                         AccessRequirements()))
             behavior = self.get_letter_behavior(letter.key, letter.level2)
             if behavior == LetterBehavior.VANILLA:
-                letter_name = f"{letter.key.upper()}{'2' if letter.level2 else '1'}"
-                event_name = f"{letter_name} (Collected)"
-                self.event_loc_item_by_room.setdefault(letter.room_id, {})[event_name] = letter.key.upper()
-
-                if letter.level2:
-                    event_name = f"{letter_name} (Double Collected)"
+                if not world.for_tracker:
+                    letter_name = f"{letter.key.upper()}{'2' if letter.level2 else '1'}"
+                    event_name = f"{letter_name} (Collected)"
                     self.event_loc_item_by_room.setdefault(letter.room_id, {})[event_name] = letter.key.upper()
+
+                    if letter.level2:
+                        event_name = f"{letter_name} (Double Collected)"
+                        self.event_loc_item_by_room.setdefault(letter.room_id, {})[event_name] = letter.key.upper()
             elif behavior == LetterBehavior.ITEM:
                 self.real_items.append(letter.key.upper())
 
@@ -196,30 +368,42 @@ class Lingo2PlayerLogic:
                 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:
+            if world.static_logic.get_room_object_map_id(mastery) not in self.shuffled_maps:
+                continue
+
             self.locations_by_room.setdefault(mastery.room_id, []).append(PlayerLocation(mastery.ap_id,
                                                                                          AccessRequirements()))
 
+            if world.options.masteries_requirement > 0:
+                event_name = f"{world.static_logic.get_room_object_map_name(mastery)} - Mastery (Collected)"
+                self.event_loc_item_by_room.setdefault(mastery.room_id, {})[event_name] = "Mastery"
+
         for ending in world.static_logic.objects.endings:
-            # Don't ever create a location for White Ending. Don't even make an event for it if it's not the victory
-            # condition, since it is necessarily going to be in the postgame.
-            if ending.name == "WHITE":
-                if self.world.options.victory_condition != VictoryCondition.option_white_ending:
-                    continue
-            else:
+            if world.static_logic.get_room_object_map_id(ending) not in self.shuffled_maps:
+                continue
+
+            # Don't create a location for your selected ending. Also don't create a location for White Ending if it's
+            # necessarily in the postgame, i.e. it requires all 12 other endings.
+            if world.options.victory_condition.current_key.removesuffix("_ending").upper() != ending.name\
+                    and (ending.name != "WHITE" or world.options.endings_requirement < 12):
                 self.locations_by_room.setdefault(ending.room_id, []).append(PlayerLocation(ending.ap_id,
                                                                                             AccessRequirements()))
 
-            event_name = f"{ending.name.capitalize()} Ending (Achieved)"
-            item_name = event_name
-
             if world.options.victory_condition.current_key.removesuffix("_ending").upper() == ending.name:
-                item_name = "Victory"
+                event_name = f"{ending.name.capitalize()} Ending (Goal)"
+                self.event_loc_item_by_room.setdefault(ending.room_id, {})[event_name] = "Victory"
+                self.goal_room_id = ending.room_id
 
-            self.event_loc_item_by_room.setdefault(ending.room_id, {})[event_name] = item_name
+            if ending.name != "WHITE":
+                event_name = f"{ending.name.capitalize()} Ending (Achieved)"
+                self.event_loc_item_by_room.setdefault(ending.room_id, {})[event_name] = "Ending"
 
         if self.world.options.keyholder_sanity:
             for keyholder in world.static_logic.objects.keyholders:
                 if keyholder.HasField("key"):
+                    if world.static_logic.get_room_object_map_id(keyholder) not in self.shuffled_maps:
+                        continue
+
                     reqs = AccessRequirements()
 
                     if self.get_letter_behavior(keyholder.key, False) != LetterBehavior.UNLOCKED:
@@ -228,6 +412,10 @@ class Lingo2PlayerLogic:
                     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:
@@ -250,25 +438,35 @@ class Lingo2PlayerLogic:
             self.add_solution_reqs(reqs, answer)
         elif len(panel.proxies) > 0:
             possibilities = []
+            already_filled = False
 
             for proxy in panel.proxies:
                 proxy_reqs = AccessRequirements()
                 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()
                 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:
             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)
@@ -291,21 +489,28 @@ 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")
             self.add_solution_reqs(reqs, door.control_center_color)
 
@@ -313,7 +518,8 @@ class Lingo2PlayerLogic:
             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:
-                reqs.cyans = True
+                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
@@ -330,14 +536,19 @@ class Lingo2PlayerLogic:
         for room in door.rooms:
             reqs.rooms.add(self.world.static_logic.get_room_region_name(room))
 
-        for ending_id in door.endings:
-            ending = self.world.static_logic.objects.endings[ending_id]
-            reqs.items.add(f"{ending.name.capitalize()} Ending (Achieved)")
+        if door.white_ending:
+            if self.world.options.endings_requirement > 0:
+                reqs.progressives["Ending"] = self.world.options.endings_requirement.value
+
+            if self.world.options.masteries_requirement > 0:
+                reqs.progressives["Mastery"] = self.world.options.masteries_requirement.value
 
         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
@@ -392,3 +603,6 @@ class Lingo2PlayerLogic:
 
             if needed > 0:
                 reqs.letters[l] = max(reqs.letters.get(l, 0), needed)
+
+        if any(l.isnumeric() for l in solution):
+            reqs.items.add("Numbers")
@@ -1,6 +1,8 @@
 from typing import TYPE_CHECKING
 
+import BaseClasses
 from BaseClasses import Region, ItemClassification, Entrance
+from entrance_rando import randomize_entrances
 from .items import Lingo2Item
 from .locations import Lingo2Location
 from .player_logic import AccessRequirements
@@ -11,21 +13,42 @@ if TYPE_CHECKING:
 
 
 def create_region(room, world: "Lingo2World") -> Region:
-    new_region = Region(world.static_logic.get_room_region_name(room.id), world.player, world.multiworld)
+    return Region(world.static_logic.get_room_region_name(room.id), world.player, world.multiworld)
 
+
+def create_locations(room, new_region: Region, world: "Lingo2World", regions: dict[str, Region]):
     for location in world.player_logic.locations_by_room.get(room.id, {}):
+        reqs = location.reqs.copy()
+        reqs.remove_room(new_region.name)
+
         new_location = Lingo2Location(world.player, world.static_logic.location_id_to_name[location.code],
                                       location.code, new_region)
-        new_location.access_rule = make_location_lambda(location.reqs, world)
+        new_location.access_rule = make_location_lambda(reqs, world, regions)
         new_region.locations.append(new_location)
 
     for event_name, item_name in world.player_logic.event_loc_item_by_room.get(room.id, {}).items():
         new_location = Lingo2Location(world.player, event_name, None, new_region)
+        if world.for_tracker and item_name == "Victory":
+            new_location.goal = True
+
         event_item = Lingo2Item(item_name, ItemClassification.progression, None, world.player)
         new_location.place_locked_item(event_item)
         new_region.locations.append(new_location)
 
-    return new_region
+    if world.for_tracker and world.options.shuffle_worldports:
+        for port_id in room.ports:
+            port = world.static_logic.objects.ports[port_id]
+            if port.no_shuffle:
+                continue
+
+            new_location = Lingo2Location(world.player, f"Worldport {port.id} Entered", None, new_region)
+            new_location.port_id = port.id
+
+            if port.HasField("required_door"):
+                new_location.access_rule = \
+                    make_location_lambda(world.player_logic.get_door_open_reqs(port.required_door), world, regions)
+
+            new_region.locations.append(new_location)
 
 
 def create_regions(world: "Lingo2World"):
@@ -33,19 +56,37 @@ def create_regions(world: "Lingo2World"):
         "Menu": Region("Menu", world.player, world.multiworld)
     }
 
+    region_and_room = []
+
+    # Create the regions in two stages. First, make the actual region objects and memoize them. Then, add all of the
+    # locations. This allows us to reference the actual region objects in the access rules for the locations, which is
+    # faster than having to look them up during access checking.
     for room in world.static_logic.objects.rooms:
+        if room.map_id not in world.player_logic.shuffled_maps:
+            continue
+
         region = create_region(room, world)
         regions[region.name] = region
+        region_and_room.append((region, room))
+
+    for (region, room) in region_and_room:
+        create_locations(room, region, world, regions)
 
     regions["Menu"].connect(regions["The Entry - Starting Room"], "Start Game")
 
-    # TODO: The requirements of the opposite trigger also matter.
     for connection in world.static_logic.objects.connections:
         if connection.roof_access and not world.options.daedalus_roof_access:
             continue
 
+        if connection.vanilla_only and world.options.shuffle_doors:
+            continue
+
         from_region = world.static_logic.get_room_region_name(connection.from_room)
         to_region = world.static_logic.get_room_region_name(connection.to_room)
+
+        if from_region not in regions or to_region not in regions:
+            continue
+
         connection_name = f"{from_region} -> {to_region}"
 
         reqs = AccessRequirements()
@@ -59,7 +100,10 @@ def create_regions(world: "Lingo2World"):
 
         if connection.HasField("port"):
             port = world.static_logic.objects.ports[connection.port]
-            connection_name = f"{connection_name} (via port {port.name})"
+            connection_name = f"{connection_name} (via {port.display_name})"
+
+            if world.options.shuffle_worldports and not port.no_shuffle:
+                continue
 
             if port.HasField("required_door"):
                 reqs.merge(world.player_logic.get_door_open_reqs(port.required_door))
@@ -82,14 +126,131 @@ def create_regions(world: "Lingo2World"):
             else:
                 connection_name = f"{connection_name} (via panel {panel.name})"
 
-        if from_region in regions and to_region in regions:
-            connection = Entrance(world.player, connection_name, regions[from_region])
-            connection.access_rule = make_location_lambda(reqs, world)
+        if connection.HasField("purple_ending") and connection.purple_ending and world.options.strict_purple_ending:
+            world.player_logic.add_solution_reqs(reqs, "abcdefghijklmnopqrstuvwxyz")
+
+        if connection.HasField("cyan_ending") and connection.cyan_ending and world.options.strict_cyan_ending:
+            world.player_logic.add_solution_reqs(reqs, "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz")
+
+        reqs.simplify()
+        reqs.remove_room(from_region)
+
+        if to_region in reqs.rooms:
+            # This connection can't ever increase access because you're required to have access to the other side in
+            # order for it to be usable. We will just not create the connection at all, in order to help GER figure out
+            # what regions are dead ends.
+            continue
+
+        connection = Entrance(world.player, connection_name, regions[from_region])
+        connection.access_rule = make_location_lambda(reqs, world, regions)
 
-            regions[from_region].exits.append(connection)
-            connection.connect(regions[to_region])
+        regions[from_region].exits.append(connection)
+        connection.connect(regions[to_region])
 
-            for region in reqs.rooms:
-                world.multiworld.register_indirect_condition(regions[region], connection)
+        for region in reqs.get_referenced_rooms():
+            world.multiworld.register_indirect_condition(regions[region], connection)
 
     world.multiworld.regions += regions.values()
+
+
+def shuffle_entrances(world: "Lingo2World"):
+    er_entrances: list[Entrance] = []
+    er_exits: list[Entrance] = []
+
+    port_id_by_name: dict[str, int] = {}
+
+    shuffleable_ports = [port for port in world.static_logic.objects.ports
+                         if not port.no_shuffle
+                         and world.static_logic.get_room_object_map_id(port) in world.player_logic.shuffled_maps]
+
+    if len(shuffleable_ports) % 2 == 1:
+        # We have an odd number of shuffleable ports! Pick a port from a room that has more than one, and make it a
+        # redundant warp to another port.
+        redundant_rooms = set(room.id for room in world.static_logic.objects.rooms if len(room.ports) > 1)
+        redundant_ports = [port for port in shuffleable_ports if port.room_id in redundant_rooms]
+        chosen_port = world.random.choice(redundant_ports)
+
+        shuffleable_ports.remove(chosen_port)
+
+        chosen_destination = world.random.choice(shuffleable_ports)
+
+        world.port_pairings[chosen_port.id] = chosen_destination.id
+
+        from_region_name = world.static_logic.get_room_region_name(chosen_port.room_id)
+        to_region_name = world.static_logic.get_room_region_name(chosen_destination.room_id)
+
+        from_region = world.multiworld.get_region(from_region_name, world.player)
+        to_region = world.multiworld.get_region(to_region_name, world.player)
+
+        connection = Entrance(world.player, f"{from_region_name} - {chosen_port.display_name}", from_region)
+        from_region.exits.append(connection)
+        connection.connect(to_region)
+
+        if chosen_port.HasField("required_door"):
+            door_reqs = world.player_logic.get_door_open_reqs(chosen_port.required_door)
+            connection.access_rule = make_location_lambda(door_reqs, world, None)
+
+            for region in door_reqs.get_referenced_rooms():
+                world.multiworld.register_indirect_condition(world.multiworld.get_region(region, world.player),
+                                                             connection)
+
+    for port in shuffleable_ports:
+        port_region_name = world.static_logic.get_room_region_name(port.room_id)
+        port_region = world.multiworld.get_region(port_region_name, world.player)
+
+        connection_name = f"{port_region_name} - {port.display_name}"
+        port_id_by_name[connection_name] = port.id
+
+        entrance = port_region.create_er_target(connection_name)
+        entrance.randomization_type = BaseClasses.EntranceType.TWO_WAY
+
+        er_exit = port_region.create_exit(connection_name)
+        er_exit.randomization_type = BaseClasses.EntranceType.TWO_WAY
+
+        if port.HasField("required_door"):
+            door_reqs = world.player_logic.get_door_open_reqs(port.required_door)
+            er_exit.access_rule = make_location_lambda(door_reqs, world, None)
+
+            for region in door_reqs.get_referenced_rooms():
+                world.multiworld.register_indirect_condition(world.multiworld.get_region(region, world.player),
+                                                             er_exit)
+
+        er_entrances.append(entrance)
+        er_exits.append(er_exit)
+
+    result = randomize_entrances(world, True, {0:[0]}, False, er_entrances,
+                                 er_exits)
+
+    for (f, to) in result.pairings:
+        world.port_pairings[port_id_by_name[f]] = port_id_by_name[to]
+
+
+def connect_ports_from_ut(port_pairings: dict[int, int], world: "Lingo2World"):
+    for fpid, tpid in port_pairings.items():
+        from_port = world.static_logic.objects.ports[fpid]
+        to_port = world.static_logic.objects.ports[tpid]
+
+        from_region_name = world.static_logic.get_room_region_name(from_port.room_id)
+        to_region_name = world.static_logic.get_room_region_name(to_port.room_id)
+
+        from_region = world.multiworld.get_region(from_region_name, world.player)
+        to_region = world.multiworld.get_region(to_region_name, world.player)
+
+        connection = Entrance(world.player, f"{from_region_name} - {from_port.display_name}", from_region)
+
+        reqs = AccessRequirements()
+        if from_port.HasField("required_door"):
+            reqs = world.player_logic.get_door_open_reqs(from_port.required_door).copy()
+
+        if world.for_tracker:
+            reqs.items.add(f"Worldport {fpid} Entered")
+
+        if not reqs.is_empty():
+            connection.access_rule = make_location_lambda(reqs, world, None)
+
+            for region in reqs.get_referenced_rooms():
+                world.multiworld.register_indirect_condition(world.multiworld.get_region(region, world.player),
+                                                             connection)
+
+        from_region.exits.append(connection)
+        connection.connect(to_region)
@@ -1 +1 @@
-protobuf>=5.29.3
\ No newline at end of file
+protobuf==3.20.3
@@ -1,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,7 +19,8 @@ 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):
@@ -30,11 +32,35 @@ def lingo2_can_satisfy_requirements(state: CollectionState, reqs: AccessRequirem
             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] | None) -> Callable[[CollectionState], bool]:
+    # Replace required rooms with regions for the top level requirement, which saves looking up the regions during rule
+    # checking.
+    if regions is not None:
+        required_regions = [regions[room_name] for room_name in reqs.rooms]
+    else:
+        required_regions = [world.multiworld.get_region(room_name, world.player) for room_name in reqs.rooms]
+    new_reqs = reqs.copy()
+    new_reqs.rooms.clear()
+    return lambda state: lingo2_can_satisfy_requirements(state, new_reqs, required_regions, world)
@@ -1,6 +1,8 @@
 from .generated import data_pb2 as data_pb2
+from .items import SYMBOL_ITEMS, ANTI_COLLECTABLE_TRAPS
 import pkgutil
 
+
 class Lingo2StaticLogic:
     item_id_to_name: dict[int, str]
     location_id_to_name: dict[int, str]
@@ -8,9 +10,20 @@ 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]
+
+    door_id_by_ap_id: dict[int, int]
+    port_id_by_ap_id: dict[int, 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,17 +42,21 @@ 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.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
@@ -51,12 +68,27 @@ class Lingo2StaticLogic:
             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["Numbers"]] = "Numbers"
+
+        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
+
+        self.door_id_by_ap_id = {door.ap_id: door.id for door in self.objects.doors if door.HasField("ap_id")}
+        self.port_id_by_ap_id = {port.ap_id: port.id for port in self.objects.ports if port.HasField("ap_id")}
+
     def get_door_item_name(self, door: data_pb2.Door) -> str:
         return f"{self.get_map_object_map_name(door)} - {door.name}"
 
@@ -80,7 +112,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 door.white_ending or door.HasField("complete_at"):
             return None
 
         if len(door.panels) > 4:
@@ -116,7 +148,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]
@@ -140,3 +172,10 @@ class Lingo2StaticLogic:
             return f"{game_map.display_name} ({room.panel_display_name})"
         else:
             return game_map.display_name
+
+    def get_room_object_map_id(self, obj) -> int:
+        return self.objects.rooms[obj.room_id].map_id
+
+    def get_data_version(self) -> list[int]:
+        version = self.objects.version
+        return [version.major, version.minor, version.patch]
@@ -0,0 +1,146 @@
+from typing import TYPE_CHECKING, Iterator
+
+from BaseClasses import MultiWorld, CollectionState, ItemClassification, Region, Entrance
+from NetUtils import NetworkItem
+from . import Lingo2World, Lingo2Item
+from .regions import connect_ports_from_ut
+from .options import Lingo2Options, ShuffleLetters
+
+if TYPE_CHECKING:
+    from .context import Lingo2Manager
+
+PLAYER_NUM = 1
+
+
+class Tracker:
+    manager: "Lingo2Manager"
+
+    multiworld: MultiWorld
+    world: Lingo2World
+
+    collected_items: dict[int, int]
+    checked_locations: set[int]
+    accessible_locations: set[int]
+    accessible_worldports: set[int]
+    goal_accessible: bool
+
+    state: CollectionState
+
+    def __init__(self, manager: "Lingo2Manager"):
+        self.manager = manager
+        self.collected_items = {}
+        self.checked_locations = set()
+        self.accessible_locations = set()
+        self.accessible_worldports = set()
+        self.goal_accessible = False
+
+    def setup_slot(self, slot_data):
+        Lingo2World.for_tracker = True
+
+        self.multiworld = MultiWorld(players=PLAYER_NUM)
+        self.world = Lingo2World(self.multiworld, PLAYER_NUM)
+        self.multiworld.worlds[1] = self.world
+        self.world.options = Lingo2Options(**{k: t(slot_data.get(k, t.default))
+                                              for k, t in Lingo2Options.type_hints.items()})
+
+        self.world.generate_early()
+        self.world.create_regions()
+
+        if self.world.options.shuffle_worldports:
+            port_pairings = {
+                self.world.static_logic.port_id_by_ap_id[int(fp)]: self.world.static_logic.port_id_by_ap_id[int(tp)]
+                for fp, tp in slot_data["port_pairings"].items()
+            }
+            connect_ports_from_ut(port_pairings, self.world)
+
+        self.refresh_state()
+
+    def set_checked_locations(self, checked_locations: set[int]):
+        self.checked_locations = checked_locations.copy()
+
+    def set_collected_items(self, network_items: list[NetworkItem]):
+        self.collected_items = {}
+
+        for item in network_items:
+            self.collected_items[item.item] = self.collected_items.get(item.item, 0) + 1
+
+        self.refresh_state()
+
+    def refresh_state(self):
+        self.state = CollectionState(self.multiworld)
+
+        for item_id, item_amount in self.collected_items.items():
+            for i in range(item_amount):
+                self.state.collect(Lingo2Item(Lingo2World.static_logic.item_id_to_name.get(item_id),
+                                              ItemClassification.progression, item_id, PLAYER_NUM), prevent_sweep=True)
+
+        for k, v in self.manager.keyboard.items():
+            # Unless all level 1 letters are pre-unlocked, H1 I1 N1 and T1 act differently between the generator and
+            # game. The generator considers them to be unlocked, which means they are not included in logic
+            # requirements, and only one item/event is needed to unlock their level 2 forms. The game considers them to
+            # be vanilla, which means you still have to pick them up in the Starting Room in order for them to appear on
+            # your keyboard. This also means that whether or not you have the level 1 forms should be synced to the
+            # multiworld. The tracker specifically should collect one fewer item for these letters in this scenario.
+            tv = v
+            if k in "hint" and self.world.options.shuffle_letters in [ShuffleLetters.option_vanilla,
+                                                                      ShuffleLetters.option_progressive]:
+                tv = max(0, v - 1)
+
+            if tv > 0:
+                for i in range(tv):
+                    self.state.collect(Lingo2Item(k.upper(), ItemClassification.progression, None, PLAYER_NUM),
+                                       prevent_sweep=True)
+
+        for port_id in self.manager.worldports:
+            self.state.collect(Lingo2Item(f"Worldport {port_id} Entered", ItemClassification.progression, None,
+                                          PLAYER_NUM), prevent_sweep=True)
+
+        self.state.sweep_for_advancements()
+
+        self.accessible_locations = set()
+        self.accessible_worldports = set()
+        self.goal_accessible = False
+
+        for region in self.state.reachable_regions[PLAYER_NUM]:
+            for location in region.locations:
+                if location.access_rule(self.state):
+                    if location.address is not None:
+                        if location.address not in self.checked_locations:
+                            self.accessible_locations.add(location.address)
+                    elif hasattr(location, "port_id"):
+                        if location.port_id not in self.manager.worldports:
+                            self.accessible_worldports.add(location.port_id)
+                    elif hasattr(location, "goal") and location.goal:
+                        if not self.manager.goaled:
+                            self.goal_accessible = True
+
+    def get_path_to_location(self, location_id: int) -> list[str] | None:
+        location_name = self.world.location_id_to_name.get(location_id)
+        location = self.multiworld.get_location(location_name, PLAYER_NUM)
+        return self.get_logical_path(location.parent_region)
+
+    def get_path_to_port(self, port_id: int) -> list[str] | None:
+        port = self.world.static_logic.objects.ports[port_id]
+        region_name = self.world.static_logic.get_room_region_name(port.room_id)
+        region = self.multiworld.get_region(region_name, PLAYER_NUM)
+        return self.get_logical_path(region)
+
+    def get_path_to_goal(self):
+        room_id = self.world.player_logic.goal_room_id
+        region_name = self.world.static_logic.get_room_region_name(room_id)
+        region = self.multiworld.get_region(region_name, PLAYER_NUM)
+        return self.get_logical_path(region)
+
+    def get_logical_path(self, region: Region) -> list[str] | None:
+        if region not in self.state.path:
+            return None
+
+        def flist_to_iter(path_value) -> Iterator[str]:
+            while path_value:
+                region_or_entrance, path_value = path_value
+                yield region_or_entrance
+
+        reversed_path = self.state.path.get(region)
+        flat_path = reversed(list(map(str, flist_to_iter(reversed_path))))
+
+        return list(flat_path)[1::2]
@@ -1,415 +0,0 @@
-extends Node
-
-const ap_version = {"major": 0, "minor": 6, "build": 3, "class": "Version"}
-
-var SCRIPT_uuid
-
-var _ws = WebSocketPeer.new()
-var _should_process = false
-var _initiated_disconnect = false
-var _try_wss = false
-var _has_connected = false
-
-var _datapackages = {}
-var _pending_packages = []
-var _item_id_to_name = {}  # All games
-var _location_id_to_name = {}  # All games
-var _item_name_to_id = {}  # Lingo 2 only
-var _location_name_to_id = {}  # Lingo 2 only
-
-var _remote_version = {"major": 0, "minor": 0, "build": 0}
-var _gen_version = {"major": 0, "minor": 0, "build": 0}
-
-var ap_server = ""
-var ap_user = ""
-var ap_pass = ""
-
-var _authenticated = false
-var _seed = ""
-var _team = 0
-var _slot = 0
-var _players = []
-var _player_name_by_slot = {}
-var _game_by_player = {}
-var _checked_locations = []
-var _received_indexes = []
-var _received_items = {}
-var _slot_data = {}
-
-signal could_not_connect
-signal connect_status
-signal client_connected(slot_data)
-signal item_received(item_id, index, player, flags, amount)
-signal message_received(message)
-signal location_scout_received(item_id, location_id, player, flags)
-
-
-func _init():
-        set_process_mode(Node.PROCESS_MODE_ALWAYS)
-
-        global._print("Instantiated APClient")
-
-        # Read AP datapackages from file, if there are any
-        if FileAccess.file_exists("user://ap_datapackages"):
-                var file = FileAccess.open("user://ap_datapackages", FileAccess.READ)
-                var data = file.get_var(true)
-                file.close()
-
-                if typeof(data) != TYPE_DICTIONARY:
-                        global._print("AP datapackages file is corrupted")
-                        data = {}
-
-                _datapackages = data
-
-                processDatapackages()
-
-
-func _ready():
-        pass
-        #_ws.connect("connection_closed", _closed)
-        #_ws.connect("connection_failed", _closed)
-        #_ws.connect("server_disconnected", _closed)
-        #_ws.connect("connection_error", _errored)
-        #_ws.connect("connection_established", _connected)
-
-
-func _reset_state():
-        _should_process = false
-        _authenticated = false
-        _try_wss = false
-        _has_connected = false
-        _received_items = {}
-        _received_indexes = []
-
-
-func _errored():
-        if _try_wss:
-                global._print("Could not connect to AP with ws://, now trying wss://")
-                connectToServer(ap_server, ap_user, ap_pass)
-        else:
-                global._print("AP connection failed")
-                _reset_state()
-
-                emit_signal(
-                        "could_not_connect",
-                        "Could not connect to Archipelago. Check that your server and port are correct. See the error log for more information."
-                )
-
-
-func _closed(_was_clean = true):
-        global._print("Connection closed")
-        _reset_state()
-
-        if not _initiated_disconnect:
-                emit_signal("could_not_connect", "Disconnected from Archipelago")
-
-        _initiated_disconnect = false
-
-
-func _connected(_proto = ""):
-        global._print("Connected!")
-        _try_wss = false
-
-
-func disconnect_from_ap():
-        _initiated_disconnect = true
-        _ws.close()
-
-
-func _process(_delta):
-        if _should_process:
-                _ws.poll()
-
-                var state = _ws.get_ready_state()
-                if state == WebSocketPeer.STATE_OPEN:
-                        if not _has_connected:
-                                _has_connected = true
-
-                                _connected()
-
-                        while _ws.get_available_packet_count():
-                                var packet = _ws.get_packet()
-                                global._print("Got data from server: " + packet.get_string_from_utf8())
-                                var json = JSON.new()
-                                var jserror = json.parse(packet.get_string_from_utf8())
-                                if jserror != OK:
-                                        global._print("Error parsing packet from AP: " + jserror.error_string)
-                                        return
-
-                                for message in json.data:
-                                        var cmd = message["cmd"]
-                                        global._print("Received command: " + cmd)
-
-                                        if cmd == "RoomInfo":
-                                                _seed = message["seed_name"]
-                                                _remote_version = message["version"]
-                                                _gen_version = message["generator_version"]
-
-                                                var needed_games = []
-                                                for game in message["datapackage_checksums"].keys():
-                                                        if (
-                                                                !_datapackages.has(game)
-                                                                or (
-                                                                        _datapackages[game]["checksum"]
-                                                                        != message["datapackage_checksums"][game]
-                                                                )
-                                                        ):
-                                                                needed_games.append(game)
-
-                                                if !needed_games.is_empty():
-                                                        _pending_packages = needed_games
-                                                        var cur_needed = _pending_packages.pop_front()
-                                                        requestDatapackages([cur_needed])
-                                                else:
-                                                        connectToRoom()
-
-                                        elif cmd == "DataPackage":
-                                                for game in message["data"]["games"].keys():
-                                                        _datapackages[game] = message["data"]["games"][game]
-                                                saveDatapackages()
-
-                                                if !_pending_packages.is_empty():
-                                                        var cur_needed = _pending_packages.pop_front()
-                                                        requestDatapackages([cur_needed])
-                                                else:
-                                                        processDatapackages()
-                                                        connectToRoom()
-
-                                        elif cmd == "Connected":
-                                                _authenticated = true
-                                                _team = message["team"]
-                                                _slot = message["slot"]
-                                                _players = message["players"]
-                                                _checked_locations = message["checked_locations"]
-                                                _slot_data = message["slot_data"]
-
-                                                for player in _players:
-                                                        _player_name_by_slot[player["slot"]] = player["alias"]
-                                                        _game_by_player[player["slot"]] = message["slot_info"][str(
-                                                                player["slot"]
-                                                        )]["game"]
-
-                                                emit_signal("client_connected", _slot_data)
-
-                                        elif cmd == "ConnectionRefused":
-                                                var error_message = ""
-                                                for error in message["errors"]:
-                                                        var submsg = ""
-                                                        if error == "InvalidSlot":
-                                                                submsg = "Invalid player name."
-                                                        elif error == "InvalidGame":
-                                                                submsg = "The specified player is not playing Lingo."
-                                                        elif error == "IncompatibleVersion":
-                                                                submsg = (
-                                                                        "The Archipelago server is not the correct version for this client. Expected v%d.%d.%d. Found v%d.%d.%d."
-                                                                        % [
-                                                                                ap_version["major"],
-                                                                                ap_version["minor"],
-                                                                                ap_version["build"],
-                                                                                _remote_version["major"],
-                                                                                _remote_version["minor"],
-                                                                                _remote_version["build"]
-                                                                        ]
-                                                                )
-                                                        elif error == "InvalidPassword":
-                                                                submsg = "Incorrect password."
-                                                        elif error == "InvalidItemsHandling":
-                                                                submsg = "Invalid item handling flag. This is a bug with the client."
-
-                                                        if submsg != "":
-                                                                if error_message != "":
-                                                                        error_message += " "
-                                                                error_message += submsg
-
-                                                if error_message == "":
-                                                        error_message = "Unknown error."
-
-                                                _initiated_disconnect = true
-                                                _ws.disconnect_from_host()
-
-                                                emit_signal("could_not_connect", error_message)
-                                                global._print("Connection to AP refused")
-                                                global._print(message)
-
-                                        elif cmd == "ReceivedItems":
-                                                var i = 0
-                                                for item in message["items"]:
-                                                        var index = int(message["index"] + i)
-                                                        i += 1
-
-                                                        if _received_indexes.has(index):
-                                                                # Do not re-process items.
-                                                                continue
-
-                                                        _received_indexes.append(index)
-
-                                                        var item_id = int(item["item"])
-                                                        _received_items[item_id] = _received_items.get(item_id, 0) + 1
-
-                                                        emit_signal(
-                                                                "item_received",
-                                                                item_id,
-                                                                index,
-                                                                int(item["player"]),
-                                                                int(item["flags"]),
-                                                                _received_items[item_id]
-                                                        )
-
-                                        elif cmd == "PrintJSON":
-                                                emit_signal("message_received", message)
-
-                                        elif cmd == "LocationInfo":
-                                                for loc in message["locations"]:
-                                                        emit_signal(
-                                                                "location_scout_received",
-                                                                int(loc["item"]),
-                                                                int(loc["location"]),
-                                                                int(loc["player"]),
-                                                                int(loc["flags"])
-                                                        )
-
-                elif state == WebSocketPeer.STATE_CLOSED:
-                        if _has_connected:
-                                _closed()
-                        else:
-                                _errored()
-
-
-func saveDatapackages():
-        # Save the AP datapackages to disk.
-        var file = FileAccess.open("user://ap_datapackages", FileAccess.WRITE)
-        file.store_var(_datapackages, true)
-        file.close()
-
-
-func connectToServer(server, un, pw):
-        ap_server = server
-        ap_user = un
-        ap_pass = pw
-
-        _initiated_disconnect = false
-
-        var url = ""
-        if ap_server.begins_with("ws://") or ap_server.begins_with("wss://"):
-                url = ap_server
-                _try_wss = false
-        elif _try_wss:
-                url = "wss://" + ap_server
-                _try_wss = false
-        else:
-                url = "ws://" + ap_server
-                _try_wss = true
-
-        var err = _ws.connect_to_url(url)
-        if err != OK:
-                emit_signal(
-                        "could_not_connect",
-                        (
-                                "Could not connect to Archipelago. Check that your server and port are correct. See the error log for more information. Error code: %d."
-                                % err
-                        )
-                )
-                global._print("Could not connect to AP: " + err)
-                return
-        _should_process = true
-
-        emit_signal("connect_status", "Connecting...")
-
-
-func sendMessage(msg):
-        var payload = JSON.stringify(msg)
-        _ws.send_text(payload)
-
-
-func requestDatapackages(games):
-        emit_signal("connect_status", "Downloading %s data package..." % games[0])
-
-        sendMessage([{"cmd": "GetDataPackage", "games": games}])
-
-
-func processDatapackages():
-        _item_id_to_name = {}
-        _location_id_to_name = {}
-        for game in _datapackages.keys():
-                var package = _datapackages[game]
-
-                _item_id_to_name[game] = {}
-                for item_name in package["item_name_to_id"].keys():
-                        _item_id_to_name[game][int(package["item_name_to_id"][item_name])] = item_name
-
-                _location_id_to_name[game] = {}
-                for location_name in package["location_name_to_id"].keys():
-                        _location_id_to_name[game][int(package["location_name_to_id"][location_name])] = location_name
-
-        if _datapackages.has("Lingo 2"):
-                _item_name_to_id = _datapackages["Lingo 2"]["item_name_to_id"]
-                _location_name_to_id = _datapackages["Lingo 2"]["location_name_to_id"]
-
-
-func connectToRoom():
-        emit_signal("connect_status", "Authenticating...")
-
-        sendMessage(
-                [
-                        {
-                                "cmd": "Connect",
-                                "password": ap_pass,
-                                "game": "Lingo 2",
-                                "name": ap_user,
-                                "uuid": SCRIPT_uuid.v4(),
-                                "version": ap_version,
-                                "items_handling": 0b111,  # always receive our items
-                                "tags": [],
-                                "slot_data": true
-                        }
-                ]
-        )
-
-
-func sendConnectUpdate(tags):
-        sendMessage([{"cmd": "ConnectUpdate", "tags": tags}])
-
-
-func requestSync():
-        sendMessage([{"cmd": "Sync"}])
-
-
-func sendLocation(loc_id):
-        sendMessage([{"cmd": "LocationChecks", "locations": [loc_id]}])
-
-
-func sendLocations(loc_ids):
-        sendMessage([{"cmd": "LocationChecks", "locations": loc_ids}])
-
-
-func setValue(key, value, operation = "replace"):
-        sendMessage(
-                [
-                        {
-                                "cmd": "Set",
-                                "key": "Lingo2_%d_%s" % [_slot, key],
-                                "want_reply": false,
-                                "operations": [{"operation": operation, "value": value}]
-                        }
-                ]
-        )
-
-
-func say(textdata):
-        sendMessage([{"cmd": "Say", "text": textdata}])
-
-
-func completedGoal():
-        sendMessage([{"cmd": "StatusUpdate", "status": 30}])  # CLIENT_GOAL
-
-
-func scoutLocations(loc_ids):
-        sendMessage([{"cmd": "LocationScouts", "locations": loc_ids}])
-
-
-func hasItem(item_id):
-        return _received_items.has(item_id)
-
-
-func getItemAmount(item_id):
-        return _received_items.get(item_id, 0)
@@ -1,86 +0,0 @@
-extends Node
-
-var SCRIPT_proto
-
-var objects
-var door_id_by_map_node_path = {}
-var painting_id_by_map_node_path = {}
-var door_id_by_ap_id = {}
-var map_id_by_name = {}
-var progressive_id_by_ap_id = {}
-var letter_id_by_ap_id = {}
-
-
-func _init(proto_script):
-        SCRIPT_proto = proto_script
-
-
-func load(data_bytes):
-        objects = SCRIPT_proto.AllObjects.new()
-
-        var result_code = objects.from_bytes(data_bytes)
-        if result_code != SCRIPT_proto.PB_ERR.NO_ERRORS:
-                print("Could not load generated data: %d" % result_code)
-                return
-
-        for map in objects.get_maps():
-                map_id_by_name[map.get_name()] = map.get_id()
-
-        for door in objects.get_doors():
-                var map = objects.get_maps()[door.get_map_id()]
-
-                if not map.get_name() in door_id_by_map_node_path:
-                        door_id_by_map_node_path[map.get_name()] = {}
-
-                var map_data = door_id_by_map_node_path[map.get_name()]
-                for receiver in door.get_receivers():
-                        map_data[receiver] = door.get_id()
-
-                for painting_id in door.get_move_paintings():
-                        var painting = objects.get_paintings()[painting_id]
-                        map_data[painting.get_path()] = door.get_id()
-
-                if door.has_ap_id():
-                        door_id_by_ap_id[door.get_ap_id()] = door.get_id()
-
-        for painting in objects.get_paintings():
-                var room = objects.get_rooms()[painting.get_room_id()]
-                var map = objects.get_maps()[room.get_map_id()]
-
-                if not map.get_name() in painting_id_by_map_node_path:
-                        painting_id_by_map_node_path[map.get_name()] = {}
-
-                var _map_data = painting_id_by_map_node_path[map.get_name()]
-
-        for progressive in objects.get_progressives():
-                progressive_id_by_ap_id[progressive.get_ap_id()] = progressive.get_id()
-
-        for letter in objects.get_letters():
-                letter_id_by_ap_id[letter.get_ap_id()] = letter.get_id()
-
-
-func get_door_for_map_node_path(map_name, node_path):
-        if not door_id_by_map_node_path.has(map_name):
-                return null
-
-        var map_data = door_id_by_map_node_path[map_name]
-        return map_data.get(node_path, null)
-
-
-func get_door_ap_id(door_id):
-        var door = objects.get_doors()[door_id]
-        if door.has_ap_id():
-                return door.get_ap_id()
-        else:
-                return null
-
-
-func get_door_receivers(door_id):
-        var door = objects.get_doors()[door_id]
-        return door.get_receivers()
-
-
-func get_door_map_name(door_id):
-        var door = objects.get_doors()[door_id]
-        var map = objects.get_maps()[door.get_map_id()]
-        return map.get_name()
@@ -1,473 +0,0 @@
-extends Node
-
-const my_version = "0.1.0"
-
-var SCRIPT_client
-var SCRIPT_keyboard
-var SCRIPT_locationListener
-var SCRIPT_uuid
-var SCRIPT_victoryListener
-
-var ap_server = ""
-var ap_user = ""
-var ap_pass = ""
-var connection_history = []
-
-var client
-var keyboard
-
-var _localdata_file = ""
-var _last_new_item = -1
-var _batch_locations = false
-var _held_locations = []
-var _held_location_scouts = []
-var _location_scouts = {}
-var _item_locks = {}
-var _held_letters = {}
-var _letters_setup = false
-
-const kSHUFFLE_LETTERS_VANILLA = 0
-const kSHUFFLE_LETTERS_UNLOCKED = 1
-const kSHUFFLE_LETTERS_PROGRESSIVE = 2
-const kSHUFFLE_LETTERS_VANILLA_CYAN = 3
-const kSHUFFLE_LETTERS_ITEM_CYAN = 4
-
-const kLETTER_BEHAVIOR_VANILLA = 0
-const kLETTER_BEHAVIOR_ITEM = 1
-const kLETTER_BEHAVIOR_UNLOCKED = 2
-
-var daedalus_roof_access = false
-var keyholder_sanity = false
-var shuffle_control_center_colors = false
-var shuffle_doors = false
-var shuffle_letters = kSHUFFLE_LETTERS_VANILLA
-var victory_condition = -1
-
-signal could_not_connect
-signal connect_status
-signal ap_connected
-
-
-func _init():
-        # Read AP settings from file, if there are any
-        if FileAccess.file_exists("user://ap_settings"):
-                var file = FileAccess.open("user://ap_settings", FileAccess.READ)
-                var data = file.get_var(true)
-                file.close()
-
-                if typeof(data) != TYPE_ARRAY:
-                        global._print("AP settings file is corrupted")
-                        data = []
-
-                if data.size() > 0:
-                        ap_server = data[0]
-
-                if data.size() > 1:
-                        ap_user = data[1]
-
-                if data.size() > 2:
-                        ap_pass = data[2]
-
-                if data.size() > 3:
-                        connection_history = data[3]
-
-
-func _ready():
-        client = SCRIPT_client.new()
-        client.SCRIPT_uuid = SCRIPT_uuid
-
-        client.connect("item_received", _process_item)
-        client.connect("message_received", _process_message)
-        client.connect("location_scout_received", _process_location_scout)
-        client.connect("could_not_connect", _client_could_not_connect)
-        client.connect("connect_status", _client_connect_status)
-        client.connect("client_connected", _client_connected)
-
-        add_child(client)
-
-        keyboard = SCRIPT_keyboard.new()
-        add_child(keyboard)
-
-
-func saveSettings():
-        # Save the AP settings to disk.
-        var path = "user://ap_settings"
-        var file = FileAccess.open(path, FileAccess.WRITE)
-
-        var data = [
-                ap_server,
-                ap_user,
-                ap_pass,
-                connection_history,
-        ]
-        file.store_var(data, true)
-        file.close()
-
-
-func saveLocaldata():
-        # Save the MW/slot specific settings to disk.
-        var dir = DirAccess.open("user://")
-        var folder = "archipelago_data"
-        if not dir.dir_exists(folder):
-                dir.make_dir(folder)
-
-        var file = FileAccess.open(_localdata_file, FileAccess.WRITE)
-
-        var data = [
-                _last_new_item,
-        ]
-        file.store_var(data, true)
-        file.close()
-
-
-func connectToServer():
-        _last_new_item = -1
-        _letters_setup = false
-        _held_letters = {}
-
-        client.connectToServer(ap_server, ap_user, ap_pass)
-
-
-func getSaveFileName():
-        return "zzAP_%s_%d" % [client._seed, client._slot]
-
-
-func disconnect_from_ap():
-        client.disconnect_from_ap()
-
-
-func get_item_id_for_door(door_id):
-        return _item_locks.get(door_id, null)
-
-
-func _process_item(item, index, from, flags, amount):
-        var item_name = "Unknown"
-        if client._item_id_to_name["Lingo 2"].has(item):
-                item_name = client._item_id_to_name["Lingo 2"][item]
-
-        var gamedata = global.get_node("Gamedata")
-        var 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()
-
-        var letter_id = gamedata.letter_id_by_ap_id.get(item, null)
-        if letter_id != null:
-                var letter = gamedata.objects.get_letters()[letter_id]
-                if not letter.has_level2() or not letter.get_level2():
-                        _process_key_item(letter.get_key(), amount)
-
-        # Show a message about the item if it's new.
-        if index != null and index > _last_new_item:
-                _last_new_item = index
-                saveLocaldata()
-
-                var player_name = "Unknown"
-                if client._player_name_by_slot.has(float(from)):
-                        player_name = client._player_name_by_slot[float(from)]
-
-                var item_color = colorForItemType(flags)
-
-                var full_item_name = item_name
-                if prog_id != null and door_id != null:
-                        var door = gamedata.objects.get_doors()[door_id]
-                        full_item_name = "%s (%s)" % [item_name, door.get_name()]
-
-                var message
-                if from == client._slot:
-                        message = "Found [color=%s]%s[/color]" % [item_color, full_item_name]
-                else:
-                        message = (
-                                "Received [color=%s]%s[/color] from %s" % [item_color, full_item_name, player_name]
-                        )
-
-                global._print(message)
-
-                global.get_node("Messages").showMessage(message)
-
-
-func _process_message(message):
-        parse_printjson_for_textclient(message)
-
-        if (
-                !message.has("receiving")
-                or !message.has("item")
-                or message["item"]["player"] != client._slot
-        ):
-                return
-
-        var item_name = "Unknown"
-        var item_player_game = client._game_by_player[message["receiving"]]
-        if client._item_id_to_name[item_player_game].has(int(message["item"]["item"])):
-                item_name = client._item_id_to_name[item_player_game][int(message["item"]["item"])]
-
-        var location_name = "Unknown"
-        var location_player_game = client._game_by_player[message["item"]["player"]]
-        if client._location_id_to_name[location_player_game].has(int(message["item"]["location"])):
-                location_name = (client._location_id_to_name[location_player_game][int(
-                        message["item"]["location"]
-                )])
-
-        var player_name = "Unknown"
-        if client._player_name_by_slot.has(message["receiving"]):
-                player_name = client._player_name_by_slot[message["receiving"]]
-
-        var item_color = colorForItemType(message["item"]["flags"])
-
-        if message["type"] == "Hint":
-                var is_for = ""
-                if message["receiving"] != client._slot:
-                        is_for = " for %s" % player_name
-                if !message.has("found") || !message["found"]:
-                        global.get_node("Messages").showMessage(
-                                (
-                                        "Hint: [color=%s]%s[/color]%s is on %s"
-                                        % [item_color, item_name, is_for, location_name]
-                                )
-                        )
-        else:
-                if message["receiving"] != client._slot:
-                        var sentMsg = "Sent [color=%s]%s[/color] to %s" % [item_color, item_name, player_name]
-                        #if _hinted_locations.has(message["item"]["location"]):
-                        #       sentMsg += " ([color=#fafad2]Hinted![/color])"
-                        global.get_node("Messages").showMessage(sentMsg)
-
-
-func parse_printjson_for_textclient(message):
-        var parts = []
-        for message_part in message["data"]:
-                if !message_part.has("type") and message_part.has("text"):
-                        parts.append(message_part["text"])
-                elif message_part["type"] == "player_id":
-                        if int(message_part["text"]) == client._slot:
-                                parts.append(
-                                        "[color=#ee00ee]%s[/color]" % client._player_name_by_slot[client._slot]
-                                )
-                        else:
-                                var from = float(message_part["text"])
-                                parts.append("[color=#fafad2]%s[/color]" % client._player_name_by_slot[from])
-                elif message_part["type"] == "item_id":
-                        var item_name = "Unknown"
-                        var item_player_game = client._game_by_player[message_part["player"]]
-                        if client._item_id_to_name[item_player_game].has(int(message_part["text"])):
-                                item_name = client._item_id_to_name[item_player_game][int(message_part["text"])]
-
-                        parts.append(
-                                "[color=%s]%s[/color]" % [colorForItemType(message_part["flags"]), item_name]
-                        )
-                elif message_part["type"] == "location_id":
-                        var location_name = "Unknown"
-                        var location_player_game = client._game_by_player[message_part["player"]]
-                        if client._location_id_to_name[location_player_game].has(int(message_part["text"])):
-                                location_name = client._location_id_to_name[location_player_game][int(
-                                        message_part["text"]
-                                )]
-
-                        parts.append("[color=#00ff7f]%s[/color]" % location_name)
-                elif message_part.has("text"):
-                        parts.append(message_part["text"])
-
-        var textclient_node = global.get_node("Textclient")
-        if textclient_node != null:
-                textclient_node.parse_printjson("".join(parts))
-
-
-func _process_location_scout(item_id, location_id, player, flags):
-        _location_scouts[location_id] = {"item": item_id, "player": player, "flags": flags}
-
-        var gamedata = global.get_node("Gamedata")
-        var map_id = gamedata.map_id_by_name.get(global.map)
-
-        var item_name = "Unknown"
-        var item_player_game = client._game_by_player[float(player)]
-        if client._item_id_to_name[item_player_game].has(item_id):
-                item_name = client._item_id_to_name[item_player_game][item_id]
-
-        var letter_id = gamedata.letter_id_by_ap_id.get(location_id, null)
-        if letter_id != null:
-                var letter = gamedata.objects.get_letters()[letter_id]
-                var room = gamedata.objects.get_rooms()[letter.get_room_id()]
-                if room.get_map_id() == map_id:
-                        var collectable = get_tree().get_root().get_node("scene").get_node_or_null(
-                                letter.get_path()
-                        )
-                        if collectable != null:
-                                collectable.setScoutedText(item_name)
-
-
-func _client_could_not_connect():
-        emit_signal("could_not_connect")
-
-
-func _client_connect_status(message):
-        emit_signal("connect_status", message)
-
-
-func _client_connected(slot_data):
-        var gamedata = global.get_node("Gamedata")
-
-        _localdata_file = "user://archipelago_data/%s_%d" % [client._seed, client._slot]
-        _last_new_item = -1
-
-        if FileAccess.file_exists(_localdata_file):
-                var ap_file = FileAccess.open(_localdata_file, FileAccess.READ)
-                var localdata = []
-                if ap_file != null:
-                        localdata = ap_file.get_var(true)
-                        ap_file.close()
-
-                if typeof(localdata) != TYPE_ARRAY:
-                        print("AP localdata file is corrupted")
-                        localdata = []
-
-                if localdata.size() > 0:
-                        _last_new_item = localdata[0]
-
-        # Read slot data.
-        daedalus_roof_access = bool(slot_data.get("daedalus_roof_access", false))
-        keyholder_sanity = bool(slot_data.get("keyholder_sanity", false))
-        shuffle_control_center_colors = bool(slot_data.get("shuffle_control_center_colors", false))
-        shuffle_doors = bool(slot_data.get("shuffle_doors", false))
-        shuffle_letters = int(slot_data.get("shuffle_letters", 0))
-        victory_condition = int(slot_data.get("victory_condition", 0))
-
-        # Set up item locks.
-        _item_locks = {}
-
-        if shuffle_doors:
-                for door in gamedata.objects.get_doors():
-                        if (
-                                door.get_type() == gamedata.SCRIPT_proto.DoorType.STANDARD
-                                or door.get_type() == gamedata.SCRIPT_proto.DoorType.ITEM_ONLY
-                        ):
-                                _item_locks[door.get_id()] = [door.get_ap_id(), 1]
-
-                for progressive in gamedata.objects.get_progressives():
-                        for i in range(0, progressive.get_doors().size()):
-                                var door = gamedata.objects.get_doors()[progressive.get_doors()[i]]
-                                _item_locks[door.get_id()] = [progressive.get_ap_id(), i + 1]
-
-                for door_group in gamedata.objects.get_door_groups():
-                        if door_group.get_type() == gamedata.SCRIPT_proto.DoorGroupType.CONNECTOR:
-                                for door in door_group.get_doors():
-                                        _item_locks[door] = [door_group.get_ap_id(), 1]
-
-        if shuffle_control_center_colors:
-                for door in gamedata.objects.get_doors():
-                        if door.get_type() == gamedata.SCRIPT_proto.DoorType.CONTROL_CENTER_COLOR:
-                                _item_locks[door.get_id()] = [door.get_ap_id(), 1]
-
-                for door_group in gamedata.objects.get_door_groups():
-                        if door_group.get_type() == gamedata.SCRIPT_proto.DoorGroupType.COLOR_CONNECTOR:
-                                for door in door_group.get_doors():
-                                        _item_locks[door] = [door_group.get_ap_id(), 1]
-
-        emit_signal("ap_connected")
-
-
-func start_batching_locations():
-        _batch_locations = true
-
-
-func send_location(loc_id):
-        if _batch_locations:
-                _held_locations.append(loc_id)
-        else:
-                client.sendLocation(loc_id)
-
-
-func scout_location(loc_id):
-        if _location_scouts.has(loc_id):
-                return _location_scouts.get(loc_id)
-
-        if _batch_locations:
-                _held_location_scouts.append(loc_id)
-        else:
-                client.scoutLocation(loc_id)
-
-        return null
-
-
-func stop_batching_locations():
-        _batch_locations = false
-
-        if not _held_locations.is_empty():
-                client.sendLocations(_held_locations)
-                _held_locations.clear()
-
-        if not _held_location_scouts.is_empty():
-                client.scoutLocations(_held_location_scouts)
-                _held_location_scouts.clear()
-
-
-func colorForItemType(flags):
-        var int_flags = int(flags)
-        if int_flags & 1:  # progression
-                if int_flags & 2:  # proguseful
-                        return "#f0d200"
-                else:
-                        return "#bc51e0"
-        elif int_flags & 2:  # useful
-                return "#2b67ff"
-        elif int_flags & 4:  # trap
-                return "#d63a22"
-        else:  # filler
-                return "#14de9e"
-
-
-func get_letter_behavior(key, level2):
-        if shuffle_letters == kSHUFFLE_LETTERS_UNLOCKED:
-                return kLETTER_BEHAVIOR_UNLOCKED
-
-        if [kSHUFFLE_LETTERS_VANILLA_CYAN, kSHUFFLE_LETTERS_ITEM_CYAN].has(shuffle_letters):
-                if level2:
-                        if shuffle_letters == kSHUFFLE_LETTERS_VANILLA_CYAN:
-                                return kLETTER_BEHAVIOR_VANILLA
-                        else:
-                                return kLETTER_BEHAVIOR_ITEM
-                else:
-                        return kLETTER_BEHAVIOR_UNLOCKED
-
-        if not level2 and ["h", "i", "n", "t"].has(key):
-                # This differs from the equivalent function in the apworld. Logically it is
-                # the same as UNLOCKED since they are in the starting room, but VANILLA
-                # means the player still has to actually pick up the letters.
-                return kLETTER_BEHAVIOR_VANILLA
-
-        if shuffle_letters == kSHUFFLE_LETTERS_PROGRESSIVE:
-                return kLETTER_BEHAVIOR_ITEM
-
-        return kLETTER_BEHAVIOR_VANILLA
-
-
-func setup_keys():
-        keyboard.load_seed()
-
-        _letters_setup = true
-
-        for k in _held_letters.keys():
-                _process_key_item(k, _held_letters[k])
-
-        _held_letters.clear()
-
-
-func _process_key_item(key, level):
-        if not _letters_setup:
-                _held_letters[key] = max(_held_letters.get(key, 0), level)
-                return
-
-        keyboard.collect_remote_letter(key, level)
@@ -1,6 +0,0 @@
-extends "res://scripts/ui/pauseMenu.gd"
-
-
-func _pause_game():
-        global.get_node("Textclient").dismiss()
-        super._pause_game()
@@ -1,9 +0,0 @@
-extends "res://scripts/nodes/saver.gd"
-
-
-func levelLoaded():
-        if type == "keyholders":
-                var ap = global.get_node("Archipelago")
-                ap.keyboard.load_keyholders.call_deferred(global.map)
-        else:
-                reload.call_deferred()
@@ -1,24 +0,0 @@
-extends Button
-
-
-func _ready():
-        pass
-
-
-func _connect_pressed():
-        self.disabled = true
-
-        var ap = global.get_node("Archipelago")
-        ap.ap_server = self.get_parent().get_node("server_box").text
-        ap.ap_user = self.get_parent().get_node("player_box").text
-        ap.ap_pass = self.get_parent().get_node("password_box").text
-        ap.saveSettings()
-
-        ap.connectToServer()
-
-
-func _back_pressed():
-        var ap = global.get_node("Archipelago")
-        ap.disconnect_from_ap()
-
-        get_tree().change_scene_to_file("res://objects/scenes/menus/main_menu.tscn")
@@ -1,199 +0,0 @@
-extends Node2D
-
-
-func _ready():
-        # Some helpful logging.
-        if Steam.isSubscribed():
-                global._print("Provisioning successful! Build ID: %d" % Steam.getAppBuildId())
-        else:
-                global._print("Provisioning failed.")
-
-        # Undo the load screen removing our cursor
-        get_tree().get_root().set_disable_input(false)
-        Input.set_mouse_mode(Input.MOUSE_MODE_VISIBLE)
-
-        # Increase the WebSocket input buffer size so that we can download large
-        # data packages.
-        ProjectSettings.set_setting("network/limits/websocket_client/max_in_buffer_kb", 8192)
-
-        # Create the global AP manager, if it doesn't already exist.
-        if not global.has_node("Archipelago"):
-                var ap_script = ResourceLoader.load("user://maps/Archipelago/manager.gd")
-                var ap_instance = ap_script.new()
-                ap_instance.name = "Archipelago"
-
-                ap_instance.SCRIPT_client = load("user://maps/Archipelago/client.gd")
-                ap_instance.SCRIPT_keyboard = load("user://maps/Archipelago/keyboard.gd")
-                ap_instance.SCRIPT_locationListener = load("user://maps/Archipelago/locationListener.gd")
-                ap_instance.SCRIPT_uuid = load("user://maps/Archipelago/vendor/uuid.gd")
-                ap_instance.SCRIPT_victoryListener = load("user://maps/Archipelago/victoryListener.gd")
-
-                global.add_child(ap_instance)
-
-                # Let's also inject any scripts we need to inject now.
-                installScriptExtension(ResourceLoader.load("user://maps/Archipelago/animationListener.gd"))
-                installScriptExtension(ResourceLoader.load("user://maps/Archipelago/collectable.gd"))
-                installScriptExtension(ResourceLoader.load("user://maps/Archipelago/door.gd"))
-                installScriptExtension(ResourceLoader.load("user://maps/Archipelago/keyHolder.gd"))
-                installScriptExtension(ResourceLoader.load("user://maps/Archipelago/keyHolderChecker.gd"))
-                installScriptExtension(
-                        ResourceLoader.load("user://maps/Archipelago/keyHolderResetterListener.gd")
-                )
-                installScriptExtension(ResourceLoader.load("user://maps/Archipelago/painting.gd"))
-                installScriptExtension(ResourceLoader.load("user://maps/Archipelago/pauseMenu.gd"))
-                installScriptExtension(ResourceLoader.load("user://maps/Archipelago/player.gd"))
-                installScriptExtension(ResourceLoader.load("user://maps/Archipelago/saver.gd"))
-                installScriptExtension(ResourceLoader.load("user://maps/Archipelago/teleportListener.gd"))
-                installScriptExtension(ResourceLoader.load("user://maps/Archipelago/worldportListener.gd"))
-
-                var proto_script = load("user://maps/Archipelago/generated/proto.gd")
-                var gamedata_script = load("user://maps/Archipelago/gamedata.gd")
-                var gamedata_instance = gamedata_script.new(proto_script)
-                gamedata_instance.load(
-                        FileAccess.get_file_as_bytes("user://maps/Archipelago/generated/data.binpb")
-                )
-                gamedata_instance.name = "Gamedata"
-                global.add_child(gamedata_instance)
-
-                var messages_script = load("user://maps/Archipelago/messages.gd")
-                var messages_instance = messages_script.new()
-                messages_instance.name = "Messages"
-                global.add_child(messages_instance)
-
-                var textclient_script = load("user://maps/Archipelago/textclient.gd")
-                var textclient_instance = textclient_script.new()
-                textclient_instance.name = "Textclient"
-                global.add_child(textclient_instance)
-
-        var ap = global.get_node("Archipelago")
-        ap.connect("ap_connected", connectionSuccessful)
-        ap.connect("could_not_connect", connectionUnsuccessful)
-        ap.connect("connect_status", connectionStatus)
-
-        # Populate textboxes with AP settings.
-        $Panel/server_box.text = ap.ap_server
-        $Panel/player_box.text = ap.ap_user
-        $Panel/password_box.text = ap.ap_pass
-
-        var history_box = $Panel/connection_history
-        if ap.connection_history.is_empty():
-                history_box.disabled = true
-        else:
-                history_box.disabled = false
-
-                var i = 0
-                for details in ap.connection_history:
-                        history_box.get_popup().add_item("%s (%s)" % [details[1], details[0]], i)
-                        i += 1
-
-        history_box.get_popup().connect("id_pressed", historySelected)
-
-        # Show client version.
-        $Panel/title.text = "ARCHIPELAGO (%s)" % ap.my_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)
-
-
-# Adapted from https://gitlab.com/Delta-V-Modding/Mods/-/blob/main/game/ModLoader.gd
-func installScriptExtension(childScript: Resource):
-        # Force Godot to compile the script now.
-        # We need to do this here to ensure that the inheritance chain is
-        # properly set up, and multiple mods can chain-extend the same
-        # class multiple times.
-        # This is also needed to make Godot instantiate the extended class
-        # when creating singletons.
-        # The actual instance is thrown away.
-        childScript.new()
-
-        var parentScript = childScript.get_base_script()
-        var parentScriptPath = parentScript.resource_path
-        global._print("ModLoader: Installing script extension over %s" % parentScriptPath)
-        childScript.take_over_path(parentScriptPath)
-
-
-func connectionStatus(message):
-        var popup = self.get_node("Panel/AcceptDialog")
-        popup.title = "Connecting to Archipelago"
-        popup.dialog_text = message
-        popup.exclusive = true
-        popup.get_ok_button().visible = false
-        popup.popup_centered()
-
-
-func connectionSuccessful():
-        var ap = global.get_node("Archipelago")
-
-        # Save connection details
-        var connection_details = [ap.ap_server, ap.ap_user, ap.ap_pass]
-        if ap.connection_history.has(connection_details):
-                ap.connection_history.erase(connection_details)
-        ap.connection_history.push_front(connection_details)
-        if ap.connection_history.size() > 10:
-                ap.connection_history.resize(10)
-        ap.saveSettings()
-
-        # Switch to the_entry
-        Input.set_mouse_mode(Input.MOUSE_MODE_CAPTURED)
-        global.user = ap.getSaveFileName()
-        global.universe = "lingo"
-        global.map = "the_entry"
-
-        unlocks.resetCollectables()
-        unlocks.resetData()
-
-        ap.setup_keys()
-
-        unlocks.loadCollectables()
-        unlocks.loadData()
-        unlocks.unlockKey("capslock", 1)
-
-        clearResourceCache("res://objects/meshes/gridDoor.tscn")
-        clearResourceCache("res://objects/nodes/collectable.tscn")
-        clearResourceCache("res://objects/nodes/door.tscn")
-        clearResourceCache("res://objects/nodes/keyHolder.tscn")
-        clearResourceCache("res://objects/nodes/listeners/animationListener.tscn")
-        clearResourceCache("res://objects/nodes/listeners/keyHolderChecker.tscn")
-        clearResourceCache("res://objects/nodes/listeners/keyHolderResetterListener.tscn")
-        clearResourceCache("res://objects/nodes/listeners/teleportListener.tscn")
-        clearResourceCache("res://objects/nodes/listeners/worldportListener.tscn")
-        clearResourceCache("res://objects/nodes/player.tscn")
-        clearResourceCache("res://objects/nodes/saver.tscn")
-        clearResourceCache("res://objects/scenes/menus/pause_menu.tscn")
-
-        var paintings_dir = DirAccess.open("res://objects/meshes/paintings")
-        if paintings_dir:
-                paintings_dir.list_dir_begin()
-                var file_name = paintings_dir.get_next()
-                while file_name != "":
-                        if not paintings_dir.current_is_dir() and file_name.ends_with(".tscn"):
-                                clearResourceCache("res://objects/meshes/paintings/" + file_name)
-                        file_name = paintings_dir.get_next()
-
-        switcher.switch_map.call_deferred("res://objects/scenes/the_entry.tscn")
-
-
-func connectionUnsuccessful(error_message):
-        $Panel/connect_button.disabled = false
-
-        var popup = $Panel/AcceptDialog
-        popup.title = "Could not connect to Archipelago"
-        popup.dialog_text = error_message
-        popup.exclusive = true
-        popup.get_ok_button().visible = true
-        popup.popup_centered()
-
-
-func historySelected(index):
-        var ap = global.get_node("Archipelago")
-        var details = ap.connection_history[index]
-
-        $Panel/server_box.text = details[0]
-        $Panel/player_box.text = details[1]
-        $Panel/password_box.text = details[2]
-
-
-func clearResourceCache(path):
-        ResourceLoader.load(path, "", ResourceLoader.CACHE_MODE_REPLACE)
@@ -1,86 +0,0 @@
-extends CanvasLayer
-
-var panel
-var label
-var entry
-var is_open = false
-
-
-func _ready():
-        process_mode = ProcessMode.PROCESS_MODE_ALWAYS
-
-        panel = Panel.new()
-        panel.set_name("Panel")
-        panel.offset_left = 100
-        panel.offset_right = 1820
-        panel.offset_top = 100
-        panel.offset_bottom = 980
-        panel.visible = false
-        add_child(panel)
-
-        label = RichTextLabel.new()
-        label.set_name("Label")
-        label.offset_left = 80
-        label.offset_right = 1640
-        label.offset_top = 80
-        label.offset_bottom = 720
-        label.scroll_following = true
-        label.selection_enabled = true
-        panel.add_child(label)
-
-        label.push_font(load("res://assets/fonts/Lingo2.ttf"))
-        label.push_font_size(36)
-
-        var entry_style = StyleBoxFlat.new()
-        entry_style.bg_color = Color(0.9, 0.9, 0.9, 1)
-
-        entry = LineEdit.new()
-        entry.set_name("Entry")
-        entry.offset_left = 80
-        entry.offset_right = 1640
-        entry.offset_top = 760
-        entry.offset_bottom = 840
-        entry.add_theme_font_override("font", load("res://assets/fonts/Lingo2.ttf"))
-        entry.add_theme_font_size_override("font_size", 36)
-        entry.add_theme_color_override("font_color", Color(0, 0, 0, 1))
-        entry.add_theme_color_override("cursor_color", Color(0, 0, 0, 1))
-        entry.add_theme_stylebox_override("focus", entry_style)
-        panel.add_child(entry)
-        entry.connect("text_submitted", text_entered)
-
-
-func _input(event):
-        if event is InputEventKey and event.pressed:
-                if event.keycode == KEY_TAB and !Input.is_key_pressed(KEY_SHIFT):
-                        if !get_tree().paused:
-                                is_open = true
-                                get_tree().paused = true
-                                Input.set_mouse_mode(Input.MOUSE_MODE_VISIBLE)
-                                panel.visible = true
-                                entry.grab_focus()
-                                get_viewport().set_input_as_handled()
-                        else:
-                                dismiss()
-                elif event.keycode == KEY_ESCAPE:
-                        if is_open:
-                                dismiss()
-                                get_viewport().set_input_as_handled()
-
-
-func dismiss():
-        if is_open:
-                get_tree().paused = false
-                Input.set_mouse_mode(Input.MOUSE_MODE_CAPTURED)
-                panel.visible = false
-                is_open = false
-
-
-func parse_printjson(text):
-        label.append_text("[p]" + text + "[/p]")
-
-
-func text_entered(text):
-        var ap = global.get_node("Archipelago")
-        var cmd = text.trim_suffix("\n")
-        ap.client.say(cmd)
-        entry.text = ""
@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2023 Xavier Sellier
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
\ No newline at end of file
@@ -1,195 +0,0 @@
-# Note: The code might not be as pretty it could be, since it's written
-# in a way that maximizes performance. Methods are inlined and loops are avoided.
-extends Node
-
-const BYTE_MASK: int = 0b11111111
-
-
-static func uuidbin():
-        randomize()
-        # 16 random bytes with the bytes on index 6 and 8 modified
-        return [
-                randi() & BYTE_MASK,
-                randi() & BYTE_MASK,
-                randi() & BYTE_MASK,
-                randi() & BYTE_MASK,
-                randi() & BYTE_MASK,
-                randi() & BYTE_MASK,
-                ((randi() & BYTE_MASK) & 0x0f) | 0x40,
-                randi() & BYTE_MASK,
-                ((randi() & BYTE_MASK) & 0x3f) | 0x80,
-                randi() & BYTE_MASK,
-                randi() & BYTE_MASK,
-                randi() & BYTE_MASK,
-                randi() & BYTE_MASK,
-                randi() & BYTE_MASK,
-                randi() & BYTE_MASK,
-                randi() & BYTE_MASK,
-        ]
-
-
-static func uuidbinrng(rng: RandomNumberGenerator):
-        rng.randomize()
-        return [
-                rng.randi() & BYTE_MASK,
-                rng.randi() & BYTE_MASK,
-                rng.randi() & BYTE_MASK,
-                rng.randi() & BYTE_MASK,
-                rng.randi() & BYTE_MASK,
-                rng.randi() & BYTE_MASK,
-                ((rng.randi() & BYTE_MASK) & 0x0f) | 0x40,
-                rng.randi() & BYTE_MASK,
-                ((rng.randi() & BYTE_MASK) & 0x3f) | 0x80,
-                rng.randi() & BYTE_MASK,
-                rng.randi() & BYTE_MASK,
-                rng.randi() & BYTE_MASK,
-                rng.randi() & BYTE_MASK,
-                rng.randi() & BYTE_MASK,
-                rng.randi() & BYTE_MASK,
-                rng.randi() & BYTE_MASK,
-        ]
-
-
-static func v4():
-        # 16 random bytes with the bytes on index 6 and 8 modified
-        var b = uuidbin()
-
-        return (
-                "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x"
-                % [
-                        # low
-                        b[0],
-                        b[1],
-                        b[2],
-                        b[3],
-                        # mid
-                        b[4],
-                        b[5],
-                        # hi
-                        b[6],
-                        b[7],
-                        # clock
-                        b[8],
-                        b[9],
-                        # clock
-                        b[10],
-                        b[11],
-                        b[12],
-                        b[13],
-                        b[14],
-                        b[15]
-                ]
-        )
-
-
-static func v4_rng(rng: RandomNumberGenerator):
-        # 16 random bytes with the bytes on index 6 and 8 modified
-        var b = uuidbinrng(rng)
-
-        return (
-                "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x"
-                % [
-                        # low
-                        b[0],
-                        b[1],
-                        b[2],
-                        b[3],
-                        # mid
-                        b[4],
-                        b[5],
-                        # hi
-                        b[6],
-                        b[7],
-                        # clock
-                        b[8],
-                        b[9],
-                        # clock
-                        b[10],
-                        b[11],
-                        b[12],
-                        b[13],
-                        b[14],
-                        b[15]
-                ]
-        )
-
-
-var _uuid: Array
-
-
-func _init(rng := RandomNumberGenerator.new()) -> void:
-        _uuid = uuidbinrng(rng)
-
-
-func as_array() -> Array:
-        return _uuid.duplicate()
-
-
-func as_dict(big_endian := true) -> Dictionary:
-        if big_endian:
-                return {
-                        "low": (_uuid[0] << 24) + (_uuid[1] << 16) + (_uuid[2] << 8) + _uuid[3],
-                        "mid": (_uuid[4] << 8) + _uuid[5],
-                        "hi": (_uuid[6] << 8) + _uuid[7],
-                        "clock": (_uuid[8] << 8) + _uuid[9],
-                        "node":
-                        (
-                                (_uuid[10] << 40)
-                                + (_uuid[11] << 32)
-                                + (_uuid[12] << 24)
-                                + (_uuid[13] << 16)
-                                + (_uuid[14] << 8)
-                                + _uuid[15]
-                        )
-                }
-        else:
-                return {
-                        "low": _uuid[0] + (_uuid[1] << 8) + (_uuid[2] << 16) + (_uuid[3] << 24),
-                        "mid": _uuid[4] + (_uuid[5] << 8),
-                        "hi": _uuid[6] + (_uuid[7] << 8),
-                        "clock": _uuid[8] + (_uuid[9] << 8),
-                        "node":
-                        (
-                                _uuid[10]
-                                + (_uuid[11] << 8)
-                                + (_uuid[12] << 16)
-                                + (_uuid[13] << 24)
-                                + (_uuid[14] << 32)
-                                + (_uuid[15] << 40)
-                        )
-                }
-
-
-func as_string() -> String:
-        return (
-                "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x"
-                % [
-                        # low
-                        _uuid[0],
-                        _uuid[1],
-                        _uuid[2],
-                        _uuid[3],
-                        # mid
-                        _uuid[4],
-                        _uuid[5],
-                        # hi
-                        _uuid[6],
-                        _uuid[7],
-                        # clock
-                        _uuid[8],
-                        _uuid[9],
-                        # node
-                        _uuid[10],
-                        _uuid[11],
-                        _uuid[12],
-                        _uuid[13],
-                        _uuid[14],
-                        _uuid[15]
-                ]
-        )
-
-
-func is_equal(other) -> bool:
-        # Godot Engine compares Array recursively
-        # There's no need for custom comparison here.
-        return _uuid == other._uuid
@@ -1,8 +0,0 @@
-extends "res://scripts/nodes/listeners/worldportListener.gd"
-
-
-func changeScene():
-        if exit == "menus/credits":
-                return
-
-        super.changeScene()
@@ -1,162 +1,153 @@
-[gd_scene load_steps=11 format=2]
-
-[ext_resource path="user://maps/Archipelago/settings_buttons.gd" type="Script" id=4]
-[ext_resource path="user://maps/Archipelago/settings_screen.gd" type="Script" id=5]
-[ext_resource path="res://images/unchecked.png" type="Texture" id=7]
-[ext_resource path="res://images/checked.png" type="Texture" id=8]
-[ext_resource type="Theme" uid="uid://7w454egydi41" path="res://assets/themes/baseUI.tres" id="2_g4bvn"]
-
-[sub_resource type="StyleBoxFlat" id=1]
-bg_color = Color( 0, 0, 0, 0 )
-
-[sub_resource type="StyleBoxFlat" id=2]
-bg_color = Color( 1, 1, 1, 1 )
-border_width_left = 1
-border_width_top = 1
-border_width_right = 1
-border_width_bottom = 1
-border_color = Color( 1, 1, 0, 1 )
-border_blend = true
-corner_radius_top_left = 3
-corner_radius_top_right = 3
-corner_radius_bottom_right = 3
-corner_radius_bottom_left = 3
-expand_offset_left = 5.0
-expand_offset_right = 5.0
-expand_offset_top = 5.0
-expand_offset_bottom = 5.0
-
-[node name="settings_screen" type="Node2D"]
-script = ExtResource( 5 )
+[gd_scene load_steps=3 format=3 uid="uid://b5mj3cq2bcesd"]
+
+[ext_resource type="Theme" uid="uid://7w454egydi41" path="res://assets/themes/baseUI.tres" id="1_mw3f1"]
+
+[sub_resource id=2 type="GDScript"]
+script/source = "extends Node2D
+
+const CACHE_PATH = \"user://apworld_path.txt\"
+
+
+func _ready():
+        if FileAccess.file_exists(CACHE_PATH):
+                var file = FileAccess.open(CACHE_PATH, FileAccess.READ)
+                $Panel/HBoxContainer/LineEdit.text = file.get_as_text()
+                file.close()
+
+
+func _browse_pressed():
+        $FileDialog.popup_centered()
+
+
+func _file_selected(path):
+        $Panel/HBoxContainer/LineEdit.text = path
+
+
+func _start_pressed():
+        var apworld_path = $Panel/HBoxContainer/LineEdit.text
+
+        if not FileAccess.file_exists(apworld_path):
+                $AcceptDialog.popup_centered()
+                return
+
+        var zip_reader = ZIPReader.new()
+        zip_reader.open(apworld_path)
+
+        var inner_path = \"lingo2/client/apworld_runtime.gd\"
+        if not zip_reader.file_exists(inner_path):
+                zip_reader.close()
+                $AcceptDialog.popup_centered()
+                return
+        
+        var cache_file = FileAccess.open(CACHE_PATH, FileAccess.WRITE)
+        cache_file.store_string(apworld_path)
+        cache_file.close()
+        
+        var runtime_script = GDScript.new()
+        runtime_script.source_code = zip_reader.read_file(inner_path).get_string_from_utf8()
+        runtime_script.reload()
+
+        zip_reader.close()
+
+        var runtime = runtime_script.new(apworld_path)
+        runtime.name = \"Runtime\"
+
+        global.add_child(runtime)
+
+        runtime.load_script_as_scene.call_deferred(\"settings_screen.gd\", \"settings_screen\")
+
+
+func _quit_pressed():
+        get_tree().change_scene_to_file(\"res://objects/scenes/menus/main_menu.tscn\")
+
+"
+
+[node name="Node2D" type="Node2D"]
+script = SubResource( 2 )
 
 [node name="Panel" type="Panel" parent="."]
+anchors_preset = -1
 offset_right = 1920.0
 offset_bottom = 1080.0
 
-[node name="title" parent="Panel" type="Label"]
-offset_left = 0.0
+[node name="Label" type="Label" parent="Panel"]
+layout_mode = 1
+anchors_preset = -1
 offset_top = 75.0
 offset_right = 1920.0
 offset_bottom = 225.0
-text = "ARCHIPELAGO"
-valign = 1
-theme = ExtResource("2_g4bvn")
-
-[node name="credit" parent="Panel" type="Label"]
-visible = false
-offset_left = 1278.0
-offset_top = 974.0
-offset_right = 1868.0
-offset_bottom = 1034.0
-text = "Brenton Wildes"
-theme = ExtResource("2_g4bvn")
-
-[node name="connect_button" parent="Panel" type="Button"]
+theme = ExtResource("1_mw3f1")
+text = "archipelago"
+horizontal_alignment = 1
+vertical_alignment = 1
+
+[node name="Label2" type="Label" parent="Panel"]
+layout_mode = 1
+anchors_preset = -1
+anchor_right = 1.0
+offset_left = 80.0
+offset_top = 300.0
+offset_right = -80.0
+offset_bottom = 388.0
+theme = ExtResource("1_mw3f1")
+theme_override_font_sizes/font_size = 56
+text = "Put the path to your lingo2.apworld in the below field and click start. Then, open the archipelago launcher and click \"Lingo 2 Client\"."
+horizontal_alignment = 1
+autowrap_mode = 3
+
+[node name="HBoxContainer" type="HBoxContainer" parent="Panel"]
+layout_mode = 1
+anchors_preset = -1
+anchor_right = 1.0
+offset_left = 80.0
+offset_top = 595.0
+offset_right = -80.0
+offset_bottom = 755.0
+theme_override_constants/separation = 32
+
+[node name="LineEdit" type="LineEdit" parent="Panel/HBoxContainer"]
+layout_mode = 2
+size_flags_horizontal = 3
+
+[node name="Button" type="Button" parent="Panel/HBoxContainer"]
+layout_mode = 2
+theme = ExtResource("1_mw3f1")
+text = "browse"
+
+[node name="StartButton" type="Button" parent="Panel"]
+layout_mode = 1
+anchors_preset = -1
 offset_left = 255.0
 offset_top = 875.0
 offset_right = 891.0
 offset_bottom = 1025.0
-custom_colors/font_color_hover = Color( 1, 0.501961, 0, 1 )
-text = "CONNECT"
-theme = ExtResource("2_g4bvn")
-script = ExtResource( 4 )
+theme = ExtResource("1_mw3f1")
+text = "start"
 
-[node name="quit_button" parent="Panel" type="Button"]
+[node name="QuitButton" type="Button" parent="Panel"]
+layout_mode = 1
+anchors_preset = -1
 offset_left = 1102.0
 offset_top = 875.0
 offset_right = 1738.0
 offset_bottom = 1025.0
-custom_colors/font_color_hover = Color( 1, 0, 0, 1 )
-text = "BACK"
-theme = ExtResource("2_g4bvn")
-script = ExtResource( 4 )
-
-[node name="credit2" parent="Panel" type="Label"]
-offset_left = -105.0
-offset_top = 346.0
-offset_right = 485.0
-offset_bottom = 410.0
-custom_styles/normal = SubResource( 1 )
-text = "SERVER"
-align = 2
-theme = ExtResource("2_g4bvn")
-
-[node name="credit5" parent="Panel" type="Label"]
-offset_left = 1239.0
-offset_top = 422.0
-offset_right = 1829.0
-offset_bottom = 486.0
-custom_styles/normal = SubResource( 1 )
-text = "OPTIONS"
-theme = ExtResource("2_g4bvn")
-
-[node name="credit3" parent="Panel" type="Label"]
-offset_left = -105.0
-offset_top = 519.0
-offset_right = 485.0
-offset_bottom = 583.0
-custom_styles/normal = SubResource( 1 )
-text = "PLAYER"
-align = 2
-theme = ExtResource("2_g4bvn")
-
-[node name="credit4" parent="Panel" type="Label"]
-offset_left = -105.0
-offset_top = 704.0
-offset_right = 485.0
-offset_bottom = 768.0
-custom_styles/normal = SubResource( 1 )
-text = "PASSWORD"
-align = 2
-theme = ExtResource("2_g4bvn")
-
-[node name="server_box" type="LineEdit" parent="Panel"]
-offset_left = 502.0
-offset_top = 295.0
-offset_right = 1144.0
-offset_bottom = 445.0
-custom_colors/selection_color = Color( 0.482353, 0, 0, 1 )
-custom_colors/cursor_color = Color( 0, 0, 0, 1 )
-custom_colors/font_color = Color( 0, 0, 0, 1 )
-custom_styles/focus = SubResource( 2 )
-align = 1
-caret_blink = true
-
-[node name="player_box" type="LineEdit" parent="Panel"]
-offset_left = 502.0
-offset_top = 477.0
-offset_right = 1144.0
-offset_bottom = 627.0
-custom_colors/selection_color = Color( 0.482353, 0, 0, 1 )
-custom_colors/cursor_color = Color( 0, 0, 0, 1 )
-custom_colors/font_color = Color( 0, 0, 0, 1 )
-custom_styles/focus = SubResource( 2 )
-align = 1
-caret_blink = true
-
-[node name="password_box" type="LineEdit" parent="Panel"]
-offset_left = 502.0
-offset_top = 659.0
-offset_right = 1144.0
-offset_bottom = 809.0
-custom_colors/selection_color = Color( 0.482353, 0, 0, 1 )
-custom_colors/cursor_color = Color( 0, 0, 0, 1 )
-custom_colors/font_color = Color( 0, 0, 0, 1 )
-custom_styles/focus = SubResource( 2 )
-align = 1
-caret_blink = true
-
-[node name="AcceptDialog" type="AcceptDialog" parent="Panel"]
-offset_right = 83.0
-offset_bottom = 58.0
-
-[node name="connection_history" type="MenuButton" parent="Panel"]
-offset_left = 1239.0
-offset_top = 276.0
-offset_right = 1829.0
-offset_bottom = 372.0
-text = "connection history"
-flat = false
-
-[connection signal="pressed" from="Panel/connect_button" to="Panel/connect_button" method="_connect_pressed"]
-[connection signal="pressed" from="Panel/quit_button" to="Panel/quit_button" method="_back_pressed"]
+theme = ExtResource("1_mw3f1")
+text = "back"
+
+[node name="FileDialog" type="FileDialog" parent="."]
+title = "Open a File"
+size = Vector2i(512, 512)
+ok_button_text = "Open"
+file_mode = 0
+access = 2
+filters = PackedStringArray("*.apworld;Archipelago Worlds")
+show_hidden_files = true
+use_native_dialog = true
+
+[node name="AcceptDialog" type="AcceptDialog" parent="."]
+dialog_text = "Could not open Lingo 2 apworld. Please check that the path is correct."
+
+[connection signal="pressed" from="Panel/HBoxContainer/Button" to="." method="_browse_pressed"]
+[connection signal="pressed" from="Panel/StartButton" to="." method="_start_pressed"]
+[connection signal="pressed" from="Panel/QuitButton" to="." method="_quit_pressed"]
+[connection signal="file_selected" from="FileDialog" to="." method="_file_selected"]
@@ -0,0 +1,32 @@
+Used in vanilla doors:
+
+The Between - RIGHT
+
+
+
+
+Used in a pseudo-connection:
+
+The Sturdy - COLORS
+
+
+
+
+Unsolved panels in letter rooms:
+
+Daedalus (F2 Room) - DEADLY
+Daedalus (F2 Room) - DIMS
+Daedalus (F2 Room) - GRAVE
+Daedalus (F2 Room) - LETHAL
+Daedalus (O2 Room) - ACCEPT
+Daedalus (O2 Room) - FOLLOW
+Daedalus (O2 Room) - PLEDGE
+Daedalus (O2 Room) - WARNING
+Daedalus (U2 Room) - EFFECTIVE
+Daedalus (U2 Room) - HELPFUL
+Daedalus (U2 Room) - INFERNAL
+Daedalus (U2 Room) - PRACTICAL
+Daedalus (U2 Room) - PRODUCTIVE
+Daedalus (U2 Room) - WONDERLAND
+The Digital - EYE
+The Digital - HIGH
@@ -0,0 +1,13 @@
+# Lingo 2 Randomizer Data
+
+This folder contains the logic for the Lingo 2 randomizer in a human-readable
+format. This data is compiled into a single file and used in the various parts
+of the randomizer project (client, apworld, etc).
+
+The data is structured using [Protocol Buffers](https://protobuf.dev/). The
+schema for the human-readable format is
+[located in the repository](https://code.fourisland.com/lingo2-archipelago/tree/proto/human.proto).
+
+## Compiling
+
+Hi.
@@ -1,5 +1,3 @@
-# TODO
-# daedalus/roof -> icarus
 connections {
   from {
     port {
@@ -20,7 +18,7 @@ connections {
   from {
     port {
       map: "the_entry"
-      room: "Flipped Second Room"
+      room: "Four Rooms Entrance"
       name: "FOUR"
     }
   }
@@ -141,7 +139,7 @@ connections {
   to {
     port {
       map: "the_darkroom"
-      room: "First Room"
+      room: "Cyan Hallway"
       name: "COLORFUL"
     }
   }
@@ -157,7 +155,7 @@ connections {
   to {
     port {
       map: "the_darkroom"
-      room: "Second Room"
+      room: "Congruent Entrance"
       name: "CONGRUENT"
     }
   }
@@ -233,7 +231,7 @@ connections {
   from {
     port {
       map: "the_darkroom"
-      room: "First Room"
+      room: "Double Sided Entrance"
       name: "DOUBLESIDED"
     }
   }
@@ -308,6 +306,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 +633,7 @@ connections {
   from {
     port {
       map: "the_entry"
-      room: "Link Area"
+      room: "Liberated Entrance"
       name: "BLUE"
     }
   }
@@ -666,7 +681,7 @@ connections {
   from {
     port {
       map: "the_entry"
-      room: "Link Area"
+      room: "Literate Entrance"
       name: "BROWN"
     }
   }
@@ -714,7 +729,7 @@ connections {
   from {
     port {
       map: "the_orb"
-      room: "B Room"
+      room: "Middle Room"
       name: "MID"
     }
   }
@@ -841,6 +856,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 +873,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 {
@@ -925,7 +961,7 @@ connections {
   from {
     port {
       map: "the_entry"
-      room: "Lime Room"
+      room: "Revitalized Entrance"
       name: "REVITALIZED"
     }
   }
@@ -1435,7 +1471,6 @@ connections {
       name: "GREAT"
     }
   }
-  door { map: "the_great" name: "Daedalus Entrance" }
   oneway: true
 }
 connections {
@@ -1454,6 +1489,7 @@ connections {
     }
   }
   oneway: true
+  bypass_target_door: true
 }
 connections {
   from {
@@ -1526,6 +1562,23 @@ connections {
     painting {
       map: "the_sturdy"
       room: "S2 Area"
+      name: "RAINBOW2"
+    }
+  }
+  to {
+    painting {
+      map: "daedalus"
+      room: "Rainbow Start"
+      name: "RAINBOW"
+    }
+  }
+  oneway: true
+}
+connections {
+  from {
+    painting {
+      map: "the_sturdy"
+      room: "Hidden Rainbow"
       name: "RAINBOW"
     }
   }
@@ -1749,12 +1802,13 @@ connections {
     }
   }
   oneway: true
+  bypass_target_door: true
 }
 connections {
   from {
     port {
       map: "the_bearer"
-      room: "Back Area"
+      room: "Tree Entrance"
       name: "TREE"
     }
   }
@@ -1831,7 +1885,6 @@ connections {
   }
 }
 connections {
-  # Two one-way connections because the door only blocks one direction.
   from {
     port {
       map: "the_great"
@@ -1848,6 +1901,7 @@ connections {
   }
 }
 connections {
+  # Two one-way connections because the door only blocks one direction.
   from {
     port {
       map: "the_unkempt"
@@ -1880,6 +1934,7 @@ connections {
     }
   }
   oneway: true
+  bypass_target_door: true
 }
 connections {
   from {
@@ -2405,3 +2460,281 @@ connections {
     }
   }
 }
+connections {
+  from {
+    painting {
+      map: "the_entry"
+      room: "Eye Room"
+      name: "GALLERY"
+    }
+  }
+  to {
+    room {
+      map: "the_gallery"
+      name: "Main Area"
+    }
+  }
+  oneway: true
+}
+connections {
+  from {
+    room {
+      map: "the_sun_temple"
+      name: "Temple"
+    }
+  }
+  to {
+    room {
+      map: "the_graveyard"
+      name: "Outside"
+    }
+  }
+  oneway: true
+}
+connections {
+  from {
+    room {
+      map: "daedalus"
+      name: "Roof"
+    }
+  }
+  to {
+    port {
+      map: "icarus"
+      room: "Welcome Spine (Obverse)"
+      name: "WORLDPORT"
+    }
+  }
+}
+connections {
+  from {
+    panel {
+      map: "the_entry"
+      room: "Starting Room"
+      name: "Gift Maps"
+      answer: "icely"
+    }
+  }
+  to {
+    room {
+      map: "the_advanced"
+      name: "Main Area"
+    }
+  }
+  oneway: true
+}
+connections {
+  from {
+    port {
+      map: "the_advanced"
+      room: "Main Area"
+      name: "WORLDPORT"
+    }
+  }
+  to {
+    room {
+      map: "the_entry"
+      name: "Starting Room"
+    }
+  }
+  oneway: true
+}
+connections {
+  from {
+    panel {
+      map: "the_entry"
+      room: "Starting Room"
+      name: "Gift Maps"
+      answer: "souvey"
+    }
+  }
+  to {
+    room {
+      map: "the_charismatic"
+      name: "Main Area"
+    }
+  }
+  oneway: true
+}
+connections {
+  from {
+    port {
+      map: "the_charismatic"
+      room: "Main Area"
+      name: "WORLDPORT"
+    }
+  }
+  to {
+    room {
+      map: "the_entry"
+      name: "Starting Room"
+    }
+  }
+  oneway: true
+}
+connections {
+  from {
+    panel {
+      map: "the_entry"
+      room: "Starting Room"
+      name: "Gift Maps"
+      answer: "q"
+    }
+  }
+  to {
+    room {
+      map: "the_crystalline"
+      name: "Main Area"
+    }
+  }
+  oneway: true
+}
+connections {
+  from {
+    port {
+      map: "the_crystalline"
+      room: "Main Area"
+      name: "WORLDPORT"
+    }
+  }
+  to {
+    room {
+      map: "the_entry"
+      name: "Starting Room"
+    }
+  }
+  oneway: true
+}
+connections {
+  # Possibly the most cursed connection in the entire game.
+  from {
+    room {
+      map: "the_crystalline"
+      name: "Flip Area"
+    }
+  }
+  to {
+    room {
+      map: "icarus"
+      name: "Welcome Spine (Obverse)"
+    }
+  }
+  oneway: true
+}
+connections {
+  from {
+    panel {
+      map: "the_entry"
+      room: "Starting Room"
+      name: "Gift Maps"
+      answer: "hatkirby"
+    }
+  }
+  to {
+    room {
+      map: "the_stellar"
+      name: "Starting Room"
+    }
+  }
+  oneway: true
+}
+connections {
+  from {
+    panel {
+      map: "the_entry"
+      room: "Starting Room"
+      name: "Gift Maps"
+      answer: "kirby"
+    }
+  }
+  to {
+    room {
+      map: "the_stellar"
+      name: "Starting Room"
+    }
+  }
+  oneway: true
+}
+connections {
+  from {
+    panel {
+      map: "the_entry"
+      room: "Starting Room"
+      name: "Gift Maps"
+      answer: "star"
+    }
+  }
+  to {
+    room {
+      map: "the_stellar"
+      name: "Starting Room"
+    }
+  }
+  oneway: true
+}
+connections {
+  from {
+    port {
+      map: "the_stellar"
+      room: "Starting Room"
+      name: "WORLDPORT"
+    }
+  }
+  to {
+    room {
+      map: "the_entry"
+      name: "Starting Room"
+    }
+  }
+  oneway: true
+}
+connections {
+  from {
+    panel {
+      map: "the_entry"
+      room: "Starting Room"
+      name: "Gift Maps"
+      answer: "gongus"
+    }
+  }
+  to {
+    room {
+      map: "the_fuzzy"
+      name: "Main Area"
+    }
+  }
+  oneway: true
+}
+connections {
+  from {
+    panel {
+      map: "the_entry"
+      room: "Starting Room"
+      name: "Gift Maps"
+      answer: "kiwi"
+    }
+  }
+  to {
+    room {
+      map: "the_fuzzy"
+      name: "Main Area"
+    }
+  }
+  oneway: true
+}
+connections {
+  from {
+    port {
+      map: "the_fuzzy"
+      room: "Main Area"
+      name: "WORLDPORT"
+    }
+  }
+  to {
+    room {
+      map: "the_entry"
+      name: "Starting Room"
+    }
+  }
+  oneway: true
+}
@@ -1,6 +1,9 @@
 door_groups {
   name: "The Entry - Repetitive Entrance"
-  type: CONNECTOR
+  # This *should* be a CONNECTOR, but currently we're not shuffling these
+  # entrances because we want to guarantee that there's a way to The Repetitive
+  # without missing keys in vanilla doors. Hopefully can be changed eventually.
+  type: SHUFFLE_GROUP
   doors {
     map: "the_entry"
     name: "Starting Room West Wall North Door"
@@ -107,6 +110,10 @@ door_groups {
   }
   doors {
     map: "the_entry"
+    name: "Gift Maps Entrance"
+  }
+  doors {
+    map: "the_entry"
     name: "Near D Room Painting"
   }
   doors {
@@ -118,6 +125,14 @@ door_groups {
     name: "Tower Entrance"
   }
   doors {
+    map: "the_great"
+    name: "Cyan Doors"
+  }
+  doors {
+    map: "the_owl"
+    name: "Double Letters"
+  }
+  doors {
     map: "the_parthenon"
     name: "Double Letters"
   }
@@ -134,3 +149,23 @@ door_groups {
     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"
+  }
+}
@@ -4,15 +4,21 @@ maps:
       Between Entrance:
         panels:
           RIGHT: 2721
+        ports:
+          BETWEEN: 3106
       Desert Room:
         panels:
           LESS: 2722
       Entry:
         panels:
           HELLO: 2724
+        ports:
+          GREAT: 3108
       Entry Entrance:
         panels:
           ENTRY: 2723
+        ports:
+          ENTRY: 3107
       Hide Room:
         panels:
           HIDE: 2725
@@ -25,13 +31,23 @@ maps:
           2: 2761
           3: 2762
           4: 2763
+        ports:
+          LEFT: 3110
+          RIGHT: 3109
       Partial Entrance:
         panels:
           PARTIAL: 2729
+        ports:
+          PARTIAL: 3111
       Perceptive Entrance:
         panels:
           COLORS: 2731
           PART: 2730
+        ports:
+          PERCEPTIVE: 3112
+      Repetitive Entrance:
+        ports:
+          REPETITIVE: 3113
       Shop Entrance:
         panels:
           HOPS: 2732
@@ -41,9 +57,13 @@ maps:
       Tenacious Entrance:
         panels:
           HERO: 2734
+        ports:
+          TENACIOUS: 3114
       Unkempt Entrance:
         panels:
           RETURN: 2735
+        ports:
+          UNKEMPT: 3115
       Unyielding Entrance:
         panels:
           FORTH: 2736
@@ -53,7 +73,12 @@ maps:
       Between Door: 2716
       Desert Door: 2717
       Front Door: 2709
+      Hidden Door: 2840
+      Letters Panel: 3285
+      Near Perceptive Panel: 3284
       Partial Door: 2713
+      Perceptive From Inside: 2842
+      Perceptive From Outside: 2841
       Repetitive Entrance: 2714
       Shop Door: 2718
       Stormy Entrance: 2710
@@ -245,6 +270,8 @@ maps:
           TICKETBORNE: 1737
           TWOGOTHIM: 1735
           UNDERPANTS: 1732
+        ports:
+          ENTRY: 3116
       Computer Room:
         panels:
           KEYBOARD (1): 1746
@@ -295,6 +322,8 @@ maps:
       Entry Shortcut:
         panels:
           WELCOME: 1776
+        ports:
+          ENTRY: 3117
       Eye Painting:
         panels:
           REVILED: 1777
@@ -484,6 +513,9 @@ maps:
       Maze Paintings Area:
         panels:
           Paintings: 1929
+      Moat:
+        ports:
+          HIVE: 3118
       North Castle Area:
         panels:
           A: 1930
@@ -548,6 +580,8 @@ maps:
           PETAL: 1976
           PLUM (1): 1971
           PLUM (2): 1972
+        ports:
+          REVITALIZED: 3119
       Outside Hotel:
         panels:
           COLORFUL: 1977
@@ -627,6 +661,9 @@ maps:
           PHARAOH: 2021
           SHEET: 2020
           STRAW: 2024
+      Purple Hallway From Great:
+        ports:
+          GREAT: 3120
       Purple NW Vestibule:
         panels:
           LOSE: 2029
@@ -693,9 +730,13 @@ maps:
       Quiet Entrance:
         panels:
           HIDDEN: 2064
+        ports:
+          QUIET: 3121
       Rain Side:
         panels:
           "?": 2065
+        ports:
+          BEARER: 3122
       Rainbow Blue:
         panels:
           THEME: 2066
@@ -748,7 +789,7 @@ maps:
           Back (2): 2090
           Colors: 2097
           FIR: 2095
-          Left: 2088
+          Near Obscured Puzzles: 2088
           OAK: 2093
           PINE: 2094
           WALK BACK: 2091
@@ -798,6 +839,8 @@ maps:
       Starting Room:
         panels:
           ENTRANCE: 2127
+        ports:
+          GREAT: 3123
       Sweet Foyer:
         panels:
           EQUAL: 2129
@@ -806,6 +849,9 @@ maps:
           RENT (2): 2132
           RENT (3): 2133
           RENT (4): 2131
+        ports:
+          SWEET1: 3124
+          SWEET2: 3125
       Tree Entrance:
         panels:
           DIFFERENCE: 2135
@@ -814,6 +860,8 @@ maps:
           RAT: 2134
           SUNDER: 2139
           WHERE: 2138
+        ports:
+          TREE: 3126
       U2 Room:
         panels:
           CHAOS: 2147
@@ -832,6 +880,9 @@ maps:
           TROUBLE: 2148
           WICKED: 2142
           WONDERLAND: 2156
+      Unkempt Entrance:
+        ports:
+          UNKEMPT: 3127
       Welcome Back Area:
         panels:
           FAREWELL LITTLE LAMB: 2157
@@ -881,6 +932,9 @@ maps:
           CUT: 2194
           MISSING: 2192
           STONES: 2195
+      White Hallway From Entry:
+        ports:
+          ENTRY: 3128
       Wisdom Panel:
         panels:
           INTELLIGENCE: 2198
@@ -891,6 +945,8 @@ maps:
           ARTS: 2202
           SONG: 2203
           UNDER: 2200
+        ports:
+          WONDROUS: 3129
       Yellow Color Backside:
         panels:
           BRASS: 2206
@@ -902,6 +958,8 @@ maps:
           Paintings: 2210
           SPIN: 2209
           SUN: 2208
+        ports:
+          FOURROOMS: 3130
       Yellow Room:
         panels:
           COLOR: 2217
@@ -971,6 +1029,7 @@ maps:
     doors:
       Amber East Doors: 1511
       Amber North Door: 1510
+      Amber Room Panels: 3289
       Amber South Door: 1509
       Bee Room Back Door: 1523
       Bee Room Entrance: 1521
@@ -987,7 +1046,6 @@ maps:
       Blue Rainbow Room: 1538
       Blue Room: 1477
       Blue Room Entrance: 1476
-      Blue Smiley Entrance: 1478
       Blue Smiley Exit To Red: 1547
       Book Room Entrance: 1588
       Book Room Exit: 1592
@@ -1014,14 +1072,17 @@ maps:
       Dark Light Room Entrance: 1569
       Dark Light Room Exit: 1570
       Dark Light Room Exit Panel: 1571
+      Direction Panels: 3297
       Entry Shortcut Secret Exit: 1437
+      Equality Panels: 3292
       Eye Painting: 2751
       Eye Painting Exit: 1446
       F Keyholder Door: 1551
-      F2 Room Back Left Door: 1491
-      F2 Room Back Middle Door: 1492
-      F2 Room Back Right Door: 1490
-      F2 Room Entrance: 1487
+      F2 Room Northwest Door: 1491
+      F2 Room Southeast Door: 1487
+      F2 Room Southwest Door: 1490
+      F2 Room West Door: 1492
+      Farewell Little Lamb Panels: 3302
       Flip Painting Blocker: 1552
       Globe Room East Door: 1589
       Globe Room South Door: 1591
@@ -1044,6 +1105,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
@@ -1051,12 +1113,16 @@ maps:
       Maze North Door: 1502
       Maze South Door: 1503
       Near Flip Painting Door: 1474
+      Near H Keyholder Panel: 3299
       Near Pyramid Gate: 1447
       Near Sweet Blue Door: 1573
       Near Sweet Brown Door: 1561
       Near Yellow Room Door: 1565
       North Castle Panel: 2742
-      O2 Room Back Door: 1485
+      Nursery Panels: 3298
+      O2 Room Northeast Door: 1485
+      O2 Room Southeast Door: 1478
+      Orange Panels: 3293
       Orange Rainbow Panel: 2267
       Orange Rainbow Room: 1535
       Orange Room: 1507
@@ -1071,6 +1137,7 @@ maps:
       Pink Hallway: 1555
       Planet Room Divider: 1513
       Planet Room Secret Door: 1578
+      Plum Panels: 3300
       Plum Room Entrance: 1576
       Plum Room Exit: 1577
       Pumpkin Door: 1583
@@ -1095,6 +1162,7 @@ maps:
       Purple West Area West Door: 1466
       Pyramid Entrance: 1505
       Rain Side Panel: 1546
+      Rainbow Color Backside Panels: 3286
       Rainbow Rooms Entrance: 1533
       Red Rainbow Panel: 2266
       Red Rainbow Room: 1534
@@ -1102,6 +1170,7 @@ maps:
       Red Room Entrance: 1562
       Red Smiley: 1554
       Red Smiley Entrance: 1553
+      Rent Panels: 3291
       Roof Access: 1528
       Salt Room Entrance: 1532
       Seasoning Doors: 1544
@@ -1110,8 +1179,9 @@ maps:
       South Castle Area Entrance: 1575
       South Castle Panel: 2744
       Southwest Area Intersection: 1475
-      Splintering Exit Left Door: 1449
-      Splintering Exit Right Door: 1450
+      Splintering Area Panels: 3287
+      Splintering Exit North Door: 1449
+      Splintering Exit South Door: 1450
       Starting Room East Wall Center Door: 1439
       Starting Room East Wall North Door: 1440
       Starting Room North Wall Center Door: 1432
@@ -1123,21 +1193,28 @@ maps:
       Starting Room West Wall North Door: 1438
       Starting Room West Wall South Door: 1433
       Sticks And Stones Door: 1593
+      Teal Panel: 3296
       Temple of the Eyes Entrance: 1444
-      U2 Room Back Door: 1497
-      U2 Room Back Right Door: 1496
-      U2 Room Entrance: 1498
-      U2 Room Shortcut: 1493
+      Theo Panels: 2811
+      Tree Panels: 3295
+      U2 Room East Door: 1498
+      U2 Room Southeast Door: 1493
+      U2 Room Southwest Door: 1496
+      U2 Room West Door: 1497
       Welcome Back Door: 1435
       Welcome Back Secret Door: 1434
       West Castle Panel: 2743
+      West Spire Panel: 3294
+      West Sticks And Stones Panel: 3288
       White Hallway From Entry: 1488
-      Wonderland Left Door: 1520
-      Wonderland Right Door: 1504
+      Wonderland North Door: 1520
+      Wonderland South Door: 1504
       Yellow Rainbow Panel: 2268
       Yellow Rainbow Room: 1536
+      Yellow Roof Puzzles: 3290
       Yellow Room: 1568
       Yellow Room Entrance: 1567
+      Yellow Smiley Annex Panels: 3301
       Yellow Smiley Door: 1548
       Z2 Room Back Exit: 1451
       Z2 Room Northeast Door: 1454
@@ -1151,6 +1228,84 @@ maps:
       Zoo Prize Door: 1599
       Zoo South Entrance: 1596
       Zoo West Entrance: 1594
+  demo:
+    rooms:
+      Backside Area:
+        panels:
+          BACKSIDE: 3049
+          DOORWAYS: 3050
+          ENDS (2): 3052
+          SEE: 3051
+      Castle:
+        panels:
+          G: 3054
+          SERIES: 3053
+      Center Building:
+        panels:
+          FUZZIES: 3056
+          WORLD: 3055
+      Flower Hallway:
+        panels:
+          LACES: 3057
+      Main Area:
+        panels:
+          A: 3089
+          AGES: 3063
+          ANY: 3071
+          ART: 3059
+          Blank: 3095
+          C: 3088
+          CASTS: 3086
+          CLOCKWISE: 3067
+          COLORFUL: 3061
+          COUNTER: 3070
+          DAZES: 3084
+          DEN: 3064
+          DISCOVER: 3096
+          E (1): 3091
+          E (2): 3093
+          END: 3079
+          FAMILY: 3097
+          GAZES: 3085
+          HAZES: 3083
+          HI: 3058
+          HID: 3065
+          MESS: 3066
+          MIND: 3078
+          N: 3092
+          PACES: 3069
+          POSSIBLE: 3068
+          R: 3094
+          RAD: 3080
+          RODS: 3072
+          S: 3087
+          SECRETIVE: 3075
+          STALK: 3082
+          TALK: 3074
+          TEES: 3060
+          TOADS: 3076
+          TON: 3077
+          TOO: 3081
+          TWO: 3073
+          V: 3090
+          WORD: 3062
+      Mastery:
+        masteries:
+          MASTERY: 3098
+      Tower:
+        panels:
+          ENDS (1): 3099
+    doors:
+      Castle: 3046
+      Center Building: 3039
+      Center Building Panels: 3041
+      Flower Hallway: 3040
+      Gold Door: 3048
+      Orange Door: 3042
+      Purple Door: 3043
+      Red Door: 3045
+      Scavenger Hunt: 3047
+      Yellow Door: 3044
   four_rooms:
     rooms:
       Examples Room:
@@ -1163,6 +1318,8 @@ maps:
           SONNET: 12
           SUPERLATIVE: 11
           URN: 13
+        ports:
+          DAEDALUS: 3131
       Hallway:
         panels:
           HUNCHBACK: 16
@@ -1177,6 +1334,8 @@ maps:
           SWAY: 24
           TERROR: 20
           TURN: 22
+        ports:
+          IMPRESSIVE: 3132
       Keyholder Room:
         keyholders:
           A: 2773
@@ -1190,6 +1349,8 @@ maps:
           SERIOUS: 31
           SURPASS: 29
           VERSE: 30
+        ports:
+          ENTRY: 3133
       Time Room:
         panels:
           BROODING: 33
@@ -1200,6 +1361,8 @@ maps:
           RHYTHM: 40
           SUSPENSE: 36
           WRITING: 38
+        ports:
+          OWL: 3134
     doors:
       A2 Door: 4
       Examples Door: 1
@@ -1207,6 +1370,179 @@ maps:
       Keyholder Door: 5
       Synonyms Door: 2
       Time Door: 3
+  icarus:
+    rooms:
+      Above Trans Rights:
+        panels:
+          ANT: 2877
+      Big U:
+        panels:
+          COLONY: 2879
+          DECK: 2878
+          MANOR: 2880
+      Fatherland:
+        panels:
+          FATHERLAND: 2881
+      Highest Point:
+        panels:
+          DIAGNOSIS: 2882
+          QUEEN: 2883
+      Mastery:
+        masteries:
+          MASTERY: 2994
+      Maze:
+        panels:
+          ANALYSIS: 2887
+          BOOKS: 2890
+          KING (1): 2886
+          MANSLAUGHTER: 2888
+          MEDIUMS: 2889
+      Maze Back:
+        panels:
+          THESE: 2884
+      Maze King Panel:
+        panels:
+          KING (2): 2885
+      Mini Icarus 2:
+        panels:
+          ANIMALS: 2893
+          ARROWS: 2894
+          BATTERY: 2891
+          SQUAD: 2895
+          TROUPE: 2892
+      Pillar Ramp:
+        panels:
+          ASTEROID: 2896
+          BUNCH: 2897
+          DRONE: 2900
+          PATRICIDE: 2899
+          PEA (1): 2901
+          PRINCES: 2898
+      Spiral Ramp:
+        panels:
+          FIREMAN: 2902
+      The Orb:
+        panels:
+          ADDERS: 2903
+          AXIS: 2913
+          BASIS (2): 2912
+          CLUTCH (1): 2911
+          CLUTCH (2): 2918
+          DEADLINE: 2908
+          DISCUS: 2916
+          FISH: 2907
+          HISS: 2915
+          NEEDLE: 2905
+          PEA (2): 2909
+          PUPPY: 2904
+          SON: 2917
+          STRAIGHT: 2914
+          THESIS: 2910
+          US: 2906
+      Through Woman (Obverse):
+        panels:
+          COW: 2920
+          HUMAN (2): 2919
+      Through Woman (Reverse):
+        panels:
+          BASIS (1): 2922
+          PRINCE: 2921
+      Trans Rights:
+        panels:
+          SERVANT (1): 2926
+          SERVANT (2): 2927
+      Trans Rights Panels:
+        panels:
+          AGENDER: 2923
+          HUMAN (3): 2924
+          HUMAN (4): 2925
+      Welcome Spine (Obverse):
+        panels:
+          FISHWIFE: 2928
+          HUMAN (1): 2929
+        ports:
+          WORLDPORT: 3135
+      Welcome Spine (Reverse):
+        panels:
+          FATHER: 2930
+          SISTER: 2932
+          TERMITE: 2931
+    doors:
+      Agender Door: 2846
+      Animals Door: 2866
+      Ant Door: 2855
+      Arrows Door: 2865
+      Asteroid Bunch Door: 2852
+      Battery Door: 2863
+      Cow Door: 2853
+      Fatherland Door: 2860
+      Man Door: 2856
+      Mediums Door: 2850
+      Murder Panels: 2871
+      Near Fireman Wings Painting: 2876
+      Orb Panels: 2875
+      Patricide Door: 2873
+      Pea Door: 2848
+      Quick Travel 1: 2851
+      Quick Travel 10: 2862
+      Quick Travel 2: 2857
+      Quick Travel 3: 2847
+      Quick Travel 4: 2858
+      Quick Travel 5: 2854
+      Quick Travel 6: 2870
+      Quick Travel 7: 2849
+      Quick Travel 8: 2861
+      Quick Travel 9: 2864
+      Reversed Arrows Door: 2868
+      Sun Painting To Drone: 2872
+      Termite Door: 2869
+      These Door: 2874
+      Troupe Door: 2867
+      Woman Door: 2859
+  the_advanced:
+    rooms:
+      CBA:
+        panels:
+          CBA (1): 2938
+          CBA (2): 2939
+          CBA (3): 2940
+      Main Area:
+        panels:
+          BIRD: 2955
+          Blank (1): 2964
+          Blank (2): 2965
+          Blank (3): 2966
+          Blank (4): 2967
+          Blank (5): 2968
+          DAIRY (1): 2946
+          DAIRY (2): 2947
+          DAIRY SAUCE: 2948
+          DECK (1): 2961
+          DECK (2): 2962
+          DECK (3): 2963
+          FRUIT (1): 2952
+          FRUIT (2): 2953
+          FRUIT FRUIT: 2954
+          GULLIBLE (1): 2949
+          GULLIBLE (2): 2950
+          GULLIBLE (3): 2951
+          I: 2942
+          LIVES: 2945
+          OBSERVE: 2941
+          ORDER (1): 2958
+          ORDER (2): 2959
+          ORDER (3): 2960
+          ORGANIZATION: 2957
+          REST: 2943
+          THE: 2944
+          UNBOTTLING: 2956
+        ports:
+          WORLDPORT: 3136
+      Mastery:
+        masteries:
+          MASTERY: 2969
+    doors:
+      Side Room Puzzles: 2934
   the_ancient:
     rooms:
       Inside:
@@ -1223,6 +1559,8 @@ maps:
       Back Area:
         panels:
           COLOR: 51
+        ports:
+          DAEDALUS: 3137
       Blue Animal (View):
         panels:
           HALF: 52
@@ -1249,6 +1587,8 @@ maps:
           SQUISH: 60
           TOAD: 64
           VIEW: 58
+        ports:
+          UNYIELDING: 3138
       Green Planet (View):
         panels:
           SOIL: 66
@@ -1285,6 +1625,9 @@ maps:
       Red Vegetable:
         panels:
           CARD: 78
+      Tree Entrance:
+        ports:
+          TREE: 3139
       Yellow Planet:
         panels:
           ZEUS: 79
@@ -1293,7 +1636,9 @@ maps:
           CAKE: 80
     doors:
       Butterfly Entrance: 50
+      Butterfly Room Panels: 3304
       Control Center Brown Door: 49
+      Control Center Color Panel: 3303
       Exit Door: 47
       Overlook Door: 46
   the_between:
@@ -1301,6 +1646,9 @@ maps:
       Control Center Side:
         panels:
           RIGHT: 93
+        ports:
+          CC: 3140
+          LIVELY: 3141
       Main Area:
         panels:
           CAUGHT: 107
@@ -1331,6 +1679,11 @@ maps:
           SUN KOI: 102
           THINK: 119
           YOU: 115
+        ports:
+          GREAT: 3142
+      Plaza Entrance:
+        ports:
+          PLAZA: 3143
     doors:
       B2 Door: 91
       Blue Puzzles: 88
@@ -1365,9 +1718,48 @@ maps:
           SPECIES: 122
           STRUCTURE: 129
           TEXT: 136
+        ports:
+          GALLERY: 3144
       Mastery:
         masteries:
           MASTERY: 140
+  the_charismatic:
+    rooms:
+      Latitude Middle:
+        panels:
+          FUNNY: 2972
+      Latitude North:
+        panels:
+          DEPENDABLE: 2973
+      Latitude South:
+        panels:
+          CHARISMA: 2974
+      Longitude East:
+        panels:
+          FUN: 2975
+      Longitude Middle:
+        panels:
+          INTELLIGENT: 2976
+      Longitude West:
+        panels:
+          CREATIVE: 2977
+      Main Area:
+        panels:
+          AQUA: 2981
+          ARC: 2978
+          Blank: 2987
+          HERE: 2984
+          IT: 2985
+          KING: 2979
+          NAIL: 2983
+          PINS: 2986
+          TILE: 2982
+          TIP: 2980
+        ports:
+          WORLDPORT: 3145
+      Mastery:
+        masteries:
+          MASTERY: 2988
   the_colorful:
     rooms:
       Black Room:
@@ -1384,6 +1776,9 @@ maps:
           CHAOS: 159
           KOI: 157
           WISH: 158
+        ports:
+          DARKROOM: 3147
+          STURDY: 3146
       Cyan Room:
         panels:
           BROTHER: 160
@@ -1408,6 +1803,8 @@ maps:
       White Room:
         panels:
           BRIGHT: 170
+        ports:
+          GREAT: 3148
       Window Room:
         panels:
           FADING: 171
@@ -1418,6 +1815,7 @@ maps:
       Black Door: 142
       Blue Door: 144
       Brown Door: 151
+      Chaos Panel: 3305
       Cyan Door: 149
       Gray Door: 153
       Green Door: 145
@@ -1466,6 +1864,8 @@ maps:
           LIGHT: 209
           LOVES: 210
           RANGER: 211
+        ports:
+          DARKROOM: 3149
       Obverse Yellow Room:
         panels:
           CIVIL: 216
@@ -1480,13 +1880,39 @@ maps:
       Flipped Yellow Door: 175
       G Keyholder Blocker: 181
       G2 Door: 182
+      Main Area Puzzles: 3306
       Near C Keyholder Puzzles: 180
       Obverse Magenta Door: 173
       Obverse Yellow Door: 178
       Obverse Yellow Puzzles: 179
-      T Keyholder Blocker: 183
+  the_crystalline:
+    rooms:
+      Flip Area:
+        panels:
+          SUCCEED: 2989
+      Main Area:
+        panels:
+          DROP: 2991
+          LEAP: 2990
+          SPIN: 2992
+        ports:
+          WORLDPORT: 3150
+      Mastery:
+        masteries:
+          MASTERY: 2993
+    doors:
+      Checkpoint Panels: 3307
   the_darkroom:
     rooms:
+      Congruent Entrance:
+        ports:
+          CONGRUENT: 3151
+      Cyan Hallway:
+        ports:
+          COLORFUL: 3152
+      Double Sided Entrance:
+        ports:
+          DOUBLESIDED: 3153
       First Room:
         panels:
           BISON: 225
@@ -1494,6 +1920,11 @@ maps:
           KOI: 228
           SHEEP: 227
           TUNA: 229
+        ports:
+          ENTRY: 3155
+      First Room Exit:
+        ports:
+          NEXT: 3154
       Second Room:
         panels:
           BISON: 231
@@ -1501,6 +1932,11 @@ maps:
           KOI: 234
           SHEEP: 233
           TUNA: 235
+        ports:
+          ENTRY: 3157
+      Second Room Exit:
+        ports:
+          NEXT: 3156
       Third Room:
         panels:
           COINS: 238
@@ -1512,6 +1948,8 @@ maps:
           LOCKS: 242
           TOUCHES: 243
           TURNS: 237
+        ports:
+          ENTRY: 3158
     doors:
       Colorful Entrance: 222
       Congruent Entrance: 223
@@ -1531,17 +1969,30 @@ maps:
           INN: 254
           OUT: 257
           YOU: 255
+      Gallery Maze:
+        ports:
+          GALLERY: 3159
       Main Area:
         panels:
           COLOR: 261
           HIT: 258
           PAINTING: 260
           TIN: 259
+        ports:
+          ENTRY1: 3160
+          ENTRY2: 3161
+          ENTRY3: 3162
       Tree Area:
         panels:
           TREE: 262
+        ports:
+          TREE: 3163
+      Unyielding Entrance:
+        ports:
+          UNYIELDING: 3164
     doors:
       Control Center Blue Door: 246
+      Control Center Blue Panel: 3308
       Gallery Entrance: 245
       Tree Entrance: 247
   the_door:
@@ -1605,6 +2056,12 @@ maps:
         panels:
           ATTIC: 285
           FULL: 286
+        ports:
+          DARKROOM: 3165
+    doors:
+      10 Panels: 3310
+      15 Panels: 3311
+      5 Panels: 3309
   the_entry:
     rooms:
       Blue Alcove:
@@ -1614,6 +2071,9 @@ maps:
       Colored Doors Area:
         panels:
           OPEN: 327
+      Composite Room Entrance:
+        ports:
+          COMPOSITE: 3166
       Ctrl Tutorial:
         panels:
           RIGHT: 328
@@ -1628,16 +2088,23 @@ maps:
           RED: 332
           SPRAY: 336
           SUN: 333
+      Daedalus Entrance:
+        ports:
+          DAEDALUS: 3167
+      Digital Entrance:
+        ports:
+          DIGITAL: 3168
+      Entry Exit:
+        ports:
+          GREAT: 3169
       Eye Room:
         panels:
           I: 339
+        ports:
+          LIONIZED: 3170
       Flipped Link Area:
         panels:
           WANDER: 340
-      Flipped Pyramid Area:
-        panels:
-          TURN (1): 341
-          TURN (2): 342
       Flipped Right Eye:
         panels:
           HERE: 344
@@ -1646,9 +2113,14 @@ maps:
         panels:
           CLUE: 345
           SLENDER: 346
+      Four Rooms Entrance:
+        ports:
+          FOUR: 3171
       Gallery Return:
         panels:
           RETURN: 347
+        ports:
+          GALLERY: 3172
       Least Blue Last:
         panels:
           AIL: 356
@@ -1661,6 +2133,14 @@ maps:
           STEALER: 352
           TRUST: 354
           WANT: 351
+        ports:
+          DARKROOM: 3173
+      Liberated Entrance:
+        ports:
+          BLUE: 3174
+      Liberated Entrance Panel:
+        panels:
+          TURN (1): 341
       Lime Room:
         panels:
           COLOR: 361
@@ -1669,12 +2149,22 @@ maps:
       Link Area:
         panels:
           WANDER: 362
+      Literate Entrance:
+        ports:
+          BROWN: 3175
+      Literate Entrance Panel:
+        panels:
+          TURN (2): 342
       Parthenon Return:
         panels:
           RETURN: 363
+        ports:
+          PARTHENON: 3176
       Rabbit Hole:
         panels:
-          PUZZLE: 364
+          Blank: 364
+        ports:
+          HOLE: 3177
       Rabbit Hole Lock:
         panels:
           HOLE: 2749
@@ -1692,6 +2182,12 @@ maps:
           RAIN WOMAN: 373
           WANDER: 370
           WOMAN: 372
+      Repetitive Entrance:
+        ports:
+          REPETITIVE: 3178
+      Revitalized Entrance:
+        ports:
+          REVITALIZED: 3179
       Right Eye:
         panels:
           EYE: 374
@@ -1700,9 +2196,12 @@ maps:
       Shop Entrance:
         panels:
           TURN: 377
+        ports:
+          SHOP: 3180
       Starting Room:
         panels:
           EYE: 380
+          Gift Maps: 2970
           HI: 378
           HINT: 381
           THAN: 383
@@ -1711,33 +2210,45 @@ maps:
       Trick Room:
         panels:
           INK: 388
+      White Hallway To Daedalus:
+        ports:
+          DAEDALUS: 3181
       Wrath Room:
         panels:
           CORN: 393
           DICE: 392
           WREATH: 391
+      X Area:
+        ports:
+          CC: 3182
     doors:
+      Big Eyes: 3316
       Blue Alcove Entrance: 297
       Blue Alcove Exit: 293
       Colored Doors Area Entrance: 318
       Composite Room Entrance: 309
       Control Center White Door: 307
+      Control Center White Panel: 3318
       Corners Painting: 292
       D Room Entrance: 319
       Daedalus Entrance: 311
       Flip Area Entrance: 310
+      Flipped Right Eye Panels: 3315
       Flipped Second Room Left Door: 300
       Flipped Second Room Right Door: 299
       Gallery Entrance: 321
       L Room Entrance: 322
+      Least Blue Last: 3317
       Liberated Entrance: 314
       Lime Room Entrance: 305
       Link Area Entrance: 288
       Literate Entrance: 316
       Near D Room Painting: 320
       Noon Door: 295
+      Noon Door Panels: 3312
       Orange Door Hider: 304
       Parthenon Entrance: 317
+      Rabbit Hole Blank Puzzle: 3319
       Rabbithole Door: 294
       Red Alcove Exit: 291
       Red Blue Area Left Door: 302
@@ -1746,6 +2257,7 @@ maps:
       Revitalized Entrance: 306
       Right Eye Entrance: 301
       Scarf Door: 296
+      Scarf Door Panels: 3313
       Second Room Left Door: 298
       Second Room Right Door: 290
       Shop Entrance: 313
@@ -1753,6 +2265,8 @@ maps:
       Third Eye Painting: 324
       Trick Door: 287
       Trick To Shop Door: 289
+      Wander Panels: 3314
+      Wrath Room Puzzles: 3320
       X Area Entrance: 308
   the_extravagant:
     rooms:
@@ -1798,6 +2312,33 @@ maps:
         panels:
           CACTUS: 410
           TAIL: 411
+  the_fuzzy:
+    rooms:
+      Main Area:
+        panels:
+          ACHIEVES: 3033
+          BEFORE: 3028
+          BOTH: 3036
+          Blank: 3022
+          CAGED: 3027
+          COMBINED: 3032
+          DICE: 3026
+          FIRST: 3035
+          FORGED: 3030
+          LOTTO: 3024
+          OTHERS: 3031
+          TOED: 3029
+          TUTU: 3023
+          UNVEILED: 3034
+          WHERETO: 3025
+        ports:
+          WORLDPORT: 3183
+      Mastery:
+        masteries:
+          MASTERY: 3037
+    doors:
+      Black Panels: 3021
+      Green Panels: 3321
   the_gallery:
     rooms:
       Back Room:
@@ -1810,6 +2351,8 @@ maps:
       Main Area:
         keyholders:
           P: 2765
+        ports:
+          ENTRY: 3184
     doors:
       Ancient Painting: 428
       Between Painting: 414
@@ -1835,6 +2378,8 @@ maps:
       The Whole Thing:
         panels:
           PANEL: 434
+    doors:
+      The Panel: 3322
   the_graveyard:
     rooms:
       Inside:
@@ -1844,34 +2389,34 @@ maps:
         panels:
           FOOT: 436
           SEVERE: 437
+    doors:
+      Remember Panel: 3323
   the_great:
     rooms:
       Back Area:
         panels:
-          Left Landscape Bottom: 482
-          Left Landscape Left: 483
-          Left Landscape Right: 481
-          Left Landscape Top: 480
           PAINTING: 474
           PLANT: 472
-          Right Landscape Bottom: 486
-          Right Landscape Left: 487
-          Right Landscape Right: 485
-          Right Landscape Top: 484
           TOWEL: 475
           TREE: 473
-          Top Landscape Bottom: 478
-          Top Landscape Left: 479
-          Top Landscape Right: 477
-          Top Landscape Top: 476
+        ports:
+          THREEDOORS: 3186
+          TOWER: 3187
+          TREE: 3188
+          UNKEMPT: 3185
       Behind Question Area:
         panels:
           DEW: 488
           NO: 490
           YEW: 489
+      Colorful Entrance:
+        ports:
+          COLORFUL: 3189
       Daedalus Entrance:
         panels:
           MISSING: 491
+        ports:
+          DAEDALUS: 3190
       East Landscape:
         panels:
           COLOR: 492
@@ -1879,6 +2424,8 @@ maps:
       Hive Entrance:
         panels:
           LOST: 495
+        ports:
+          HIVE: 3191
       Jail Part 1:
         panels:
           DECATHLON: 506
@@ -1903,6 +2450,9 @@ maps:
           NECROTIZE (2): 511
           PILGRIM: 513
           TORMENTS: 512
+      Jubilant Entrance:
+        ports:
+          JUBILANT: 3192
       Magnet Room:
         panels:
           AIRPLANE: 516
@@ -1939,6 +2489,12 @@ maps:
           SMILE: 539
           WHY: 540
           YOU: 537
+        ports:
+          DIGITAL: 3197
+          ENTRY: 3193
+          KEEN: 3194
+          LINEAR: 3196
+          ORB: 3195
       Maze Center:
         panels:
           CHASE: 549
@@ -1996,6 +2552,8 @@ maps:
           WEATHER: 568
         keyholders:
           X: 2770
+        ports:
+          INVISIBLE: 3198
       Outside Jail:
         panels:
           GUT: 575
@@ -2009,6 +2567,9 @@ maps:
           FOUR: 581
           HAVE: 580
           TEN: 583
+      Purple Room:
+        ports:
+          DAEDALUS: 3199
       Question Room How:
         panels:
           QUESTION: 584
@@ -2021,6 +2582,26 @@ maps:
       Question Room Who:
         panels:
           QUESTION: 587
+      Salmon Room:
+        ports:
+          BETWEEN: 3200
+      Talented Entrance:
+        ports:
+          TALENTED: 3201
+      The Landscapes:
+        panels:
+          Left Landscape Bottom: 482
+          Left Landscape Left: 483
+          Left Landscape Right: 481
+          Left Landscape Top: 480
+          Right Landscape Bottom: 486
+          Right Landscape Left: 487
+          Right Landscape Right: 485
+          Right Landscape Top: 484
+          Top Landscape Bottom: 478
+          Top Landscape Left: 479
+          Top Landscape Right: 477
+          Top Landscape Top: 476
       Under Question Room:
         panels:
           QUESTION: 588
@@ -2033,6 +2614,10 @@ maps:
           RIGHT: 591
           SAVORY: 592
           TEACH: 590
+        ports:
+          CC: 3203
+          IMPRESSIVE: 3202
+          PARTIAL: 3204
       Whole Room:
         panels:
           BATHROOM: 604
@@ -2068,13 +2653,19 @@ maps:
           SHIFT: 624
     doors:
       Back Area Entrance: 439
+      Behind Orb Panel: 3336
+      Behind Question Room Panels: 3332
       Between Entrance: 440
       Big Y: 462
+      Broken Shed Panels: 3333
       Building Building Gravestone: 468
       Colorful Entrance: 455
       Control Center Gray Door: 446
+      Control Center Gray Panel: 3326
       Control Center Purple Door: 445
+      Control Center Purple Panel: 3327
       Control Center Red Door: 447
+      Control Center Red Panel: 3328
       Courtyard Entrance: 442
       Courtyard Side Door: 461
       Daedalus Entrance: 448
@@ -2084,10 +2675,12 @@ maps:
       Into The Mouth Gravestone: 457
       Invisible Entrance: 465
       Jail Entrance: 451
-      Lavender Cube: 469
       Magnet Room Entrance: 449
+      Mistreat Panel: 3329
+      Nature Panels: 3334
       Nature Room Door: 466
       Nature Room Panels: 467
+      Near Linear Panels: 3324
       Near UC Painting Door: 441
       North Landscape Entrance: 456
       Pillar Room Entrance: 450
@@ -2096,11 +2689,21 @@ maps:
       Savory Painting: 452
       Spiral Painting: 471
       Talented Entrance: 463
+      Teal Panel: 3335
       The Landscapes Gravestone: 458
       The Maze Gravestone: 460
       Tower Entrance: 459
+      Tower Panels: 3330
+      Tree Panels: 3331
       West/East Divider: 443
+      Why Is It Not Red: 3325
       Zero Room Panels: 470
+  the_hinterlands:
+    rooms:
+      Main Area:
+        ports:
+          LEFT: 3206
+          RIGHT: 3205
   the_hive:
     rooms:
       Main Area:
@@ -2145,6 +2748,11 @@ maps:
           YELL: 636
         keyholders:
           B: 2769
+        ports:
+          DAED1: 3207
+          DAED2: 3208
+          DAED3: 3209
+          GREAT: 3210
       Mastery Room:
         masteries:
           MASTERY: 666
@@ -2163,28 +2771,40 @@ maps:
           LEFT: 676
           RETURN: 674
           TO: 675
+        ports:
+          PLAZA: 3211
       Lobby:
         panels:
           RIGHT: 677
+        ports:
+          GREAT: 3212
       Side Area:
         panels:
           COLOR: 680
+        ports:
+          FOURROOMS: 3213
       WM Room:
         panels:
           LEFT: 682
           RIGHT: 683
     doors:
       Control Center Green Door: 673
+      Control Center Green Panel: 3338
       Front Door: 671
+      Green Eye Panels: 3337
       Side Door: 672
   the_invisible:
     rooms:
       Entrance:
         panels:
           VISIBLE: 685
+        ports:
+          ENTRY: 3214
       Maze:
         masteries:
           MASTERY: 686
+        ports:
+          ENTRY: 3215
     doors:
       Maze Entrance: 684
   the_jubilant:
@@ -2203,6 +2823,8 @@ maps:
           SPRINT: 695
           TREE: 698
           UNFAIR: 694
+        ports:
+          GREAT: 3216
       Side Area:
         panels:
           CALL: 704
@@ -2215,6 +2837,7 @@ maps:
           J: 2772
     doors:
       Side Door: 687
+      Side Room Puzzles: 3339
   the_keen:
     rooms:
       Main Area:
@@ -2228,6 +2851,8 @@ maps:
           TIN (3): 711
           TIN (4): 712
           TIN (5): 713
+        ports:
+          GREAT: 3217
     doors:
       All Panels: 707
   the_liberated:
@@ -2242,6 +2867,8 @@ maps:
           PERSON: 720
           SAND: 723
           WOLF: 725
+        ports:
+          ENTRY: 3218
     doors:
       Door: 718
   the_linear:
@@ -2256,6 +2883,8 @@ maps:
           NOR: 735
           ROT: 731
           TON: 730
+        ports:
+          GREAT: 3219
     doors:
       Behind The Keen Gravestone: 727
   the_lionized:
@@ -2270,6 +2899,8 @@ maps:
           LION: 741
           PIG: 743
           ROCK: 740
+        ports:
+          ENTRY: 3220
   the_literate:
     rooms:
       Puzzle Room:
@@ -2282,6 +2913,8 @@ maps:
           SAND: 750
           STICK: 752
           WATER: 746
+        ports:
+          ENTRY: 3221
     doors:
       Door: 745
   the_lively:
@@ -2296,6 +2929,8 @@ maps:
           ROOSTER: 762
           SON: 759
           SOPRANO: 757
+        ports:
+          BETWEEN: 3222
   the_nuanced:
     rooms:
       Back Room:
@@ -2326,12 +2961,18 @@ maps:
           TORE: 787
         keyholders:
           S: 2767
+        ports:
+          UNYIELDING: 3223
     doors:
-      Left Room Puzzles: 763
+      Blue Side Puzzles: 763
+      Green Side Puzzles: 764
       Main Room Door: 2750
-      Right Room Puzzles: 764
+      Stores Panel: 3340
   the_orb:
     rooms:
+      B Room:
+        ports:
+          FINAL: 3224
       Main Area:
         panels:
           ACT: 799
@@ -2346,6 +2987,11 @@ maps:
           STRIKE: 790
           THICK: 797
           THIN: 793
+        ports:
+          GREAT: 3225
+      Middle Room:
+        ports:
+          MID: 3226
   the_owl:
     rooms:
       Blue Room:
@@ -2373,6 +3019,11 @@ maps:
           SKETCH: 832
           WHITE: 824
           WING: 826
+        ports:
+          FOURROOMS: 3227
+      Magenta Hallway:
+        ports:
+          STURDY: 3228
       R1C4 Left:
         panels:
           STENCIL: 840
@@ -2385,6 +3036,8 @@ maps:
       R2C2 Bottom:
         panels:
           FOUL: 844
+        ports:
+          GALLERY: 3229
       R2C2 Top:
         panels:
           CRUSH: 845
@@ -2402,12 +3055,22 @@ maps:
       Blue Owl: 818
       Brush Door: 804
       Control Center Magenta Door: 812
+      Control Center Magenta Panel: 3343
       First Door: 808
       First Room Shortcut: 807
       Gray Bottom Door: 811
       Gray Owl: 814
       Gray Top Door: 810
+      Near Z1 Panel: 3350
       Orange Owl: 815
+      R1C1 Panels: 3341
+      R1C2 Panels: 3342
+      R1C3 Panels: 3344
+      R1C4 Panels: 3345
+      R2C1 Panels: 3346
+      R2C2 Panels: 3347
+      R2C3 Panels: 3348
+      R2C4 Panels: 3349
       Sky Bottom Doors: 806
       Sky Owl: 813
       Sky Top Doors: 805
@@ -2427,16 +3090,23 @@ maps:
           CLEOPATRA: 859
           NAPOLEON: 860
           XERXES: 857
+        ports:
+          ENTRY: 3231
+          GALLERY: 3230
+          REVITALIZED: 3232
       U Keyholder:
         keyholders:
           U: 2777
     doors:
       K2 Door: 852
+      Lavender Area Puzzles: 3351
   the_partial:
     rooms:
       Control Center Entrance:
         panels:
           RETURN: 867
+        ports:
+          CC: 3233
       Obverse Side:
         panels:
           CUT: 881
@@ -2455,6 +3125,8 @@ maps:
           UP: 870
         keyholders:
           L: 2771
+        ports:
+          GREAT: 3234
       Reverse Side:
         panels:
           BRO: 884
@@ -2464,8 +3136,14 @@ maps:
     doors:
       Control Center Entrance: 865
       F Door: 866
+      L Entered: 2843
       Main Room Puzzles: 863
       P Door: 864
+  the_perceptive:
+    rooms:
+      Main Area:
+        ports:
+          CC: 3235
   the_plaza:
     rooms:
       Bottom Left Room:
@@ -2499,18 +3177,28 @@ maps:
           ASTOUNDING: 919
           COURTYARD: 918
           INFLEXIBLE: 920
+        ports:
+          BETWEEN: 3238
+          IMPRESSIVE: 3237
+          UNYIELDING: 3236
       Mastery:
         masteries:
           MASTERY: 923
       Repetitive Entrance:
         panels:
           TEDIOUS: 924
+        ports:
+          REPETITIVE: 3239
       Sirenic Entrance:
         panels:
           SIREN: 925
+        ports:
+          SIRENIC: 3240
       Symbolic Entrance:
         panels:
           FIGURATIVE: 926
+        ports:
+          SYMBOLIC: 3241
       Top Left Room:
         panels:
           BACKPACK: 939
@@ -2559,17 +3247,21 @@ maps:
           TYPIST BEAR RIGHT WING: 968
           WING: 950
     doors:
-      Bottom Left Door: 894
-      Bottom Left Puzzles: 898
-      Bottom Right Door: 895
-      Bottom Right Puzzles: 899
+      Near Broken Portal Panel: 3355
+      Near Repetitive Panel: 3354
+      Near Sirenic Panel: 3352
+      Near Symbolic Panel: 3353
+      Northeast Door: 893
+      Northeast Puzzles: 897
+      Northwest Door: 892
+      Northwest Puzzles: 896
       Repetitive Entrance: 888
       Sirenic Entrance: 890
+      Southeast Door: 895
+      Southeast Puzzles: 899
+      Southwest Door: 894
+      Southwest Puzzles: 898
       Symbolic Entrance: 889
-      Top Left Door: 892
-      Top Left Puzzles: 896
-      Top Right Door: 893
-      Top Right Puzzles: 897
       Turtle Entrance: 891
   the_quiet:
     rooms:
@@ -2590,6 +3282,8 @@ maps:
           RODENT: 972
           RULE: 974
           SOLID: 971
+        ports:
+          DAEDALUS: 3242
     doors:
       Side Door: 970
   the_relentless:
@@ -2646,13 +3340,17 @@ maps:
           HIDE (2): 1021
           MORE: 1022
     doors:
+      Left Only Puzzles: 3020
       Left/Turn Door: 984
+      Shop Only Puzzles: 3019
+      Turn Only Puzzles: 3018
       Turn/Shop Door: 985
   the_repetitive:
     rooms:
       Anti Room:
         panels:
-          EYE: 1041
+          EYE (1): 1041
+          EYE (2): 2813
           HA (1): 1035
           HA (2): 1036
           HA (3): 1037
@@ -2690,6 +3388,9 @@ maps:
           TO (2): 1056
           TUTU (1): 1054
           TUTU (2): 1068
+      Entry Connector:
+        ports:
+          ENTRY: 3243
       Lime Room:
         panels:
           BIRD: 1074
@@ -2742,9 +3443,14 @@ maps:
           MISHMASH: 1114
           QUESTION: 1105
           RICHES: 1112
+        ports:
+          CC: 3244
       Mastery Room:
         masteries:
           MASTERY: 1116
+      Plaza Connector:
+        ports:
+          PLAZA: 3245
       Yellow Room:
         panels:
           3D: 1123
@@ -2759,12 +3465,16 @@ maps:
           W: 1117
           ZEROING: 1118
     doors:
+      Anti-Collectable: 2812
       Anti-Collectable Room: 1025
+      Anti-Collectable Room Panels: 3358
       Black Hallway: 2780
       Cyan Door: 1028
       Cyan Puzzles: 1032
       Dot Area Entrance: 1026
       Entry Entrance: 1023
+      H2 Room Puzzles: 3357
+      Hots Panels: 3356
       Lime Door: 1027
       Lime Puzzles: 1031
       Magenta Door: 1029
@@ -2776,6 +3486,8 @@ maps:
       Bye Room:
         panels:
           BYE: 1129
+        ports:
+          PARTHENON: 3246
       Hidden Room:
         panels:
           HIDDEN: 1130
@@ -2824,9 +3536,12 @@ maps:
           TADPOLES: 1159
         keyholders:
           N: 2779
+        ports:
+          ENTRY: 3247
     doors:
       Books Puzzles: 1136
       Games Puzzles: 1137
+      N Entered: 2971
   the_sirenic:
     rooms:
       Mastery:
@@ -2853,8 +3568,62 @@ maps:
         panels:
           Flipped: 1178
           Obverse: 1179
+        ports:
+          PLAZA: 3248
     doors:
       Entrance: 1161
+  the_stellar:
+    rooms:
+      Blue Panel:
+        panels:
+          BLUE: 2996
+      Connected Area:
+        panels:
+          BEHIND: 3003
+          Blank: 3004
+          GREETINGS: 3002
+          HERE: 2997
+          HI: 3000
+          QUESTION (1): 2999
+          QUESTION (2): 3016
+          START: 3005
+          WHERE: 3001
+      Green Area:
+        panels:
+          STRAYS: 3006
+      Green Panel:
+        panels:
+          GREEN: 3007
+      Hi Room:
+        panels:
+          HI: 3008
+      Mastery:
+        masteries:
+          MASTERY: 3009
+      Old Crossroads:
+        panels:
+          DOORWAY: 3010
+      Orange Panel:
+        panels:
+          ORANGE: 3011
+      Purple Panel:
+        panels:
+          PURPLE: 3012
+      Red Panel:
+        panels:
+          RED: 3013
+      Starting Room:
+        panels:
+          STARLIKE: 3014
+        ports:
+          WORLDPORT: 3249
+      Yellow Panel:
+        panels:
+          YELLOW: 3015
+    doors:
+      Entrance: 2995
+      Question Panels: 3017
+      Welcome Back Panels: 3359
   the_stormy:
     rooms:
       Center:
@@ -2863,6 +3632,8 @@ maps:
           REACTOR: 1180
           VOLCANO: 1181
           WIND: 1183
+        ports:
+          ENTRY: 3250
       Nuclear Side:
         panels:
           GERM: 1184
@@ -2895,6 +3666,9 @@ maps:
           MOVE (6): 1198
           MOVE (7): 1199
           MOVE (8): 1200
+        ports:
+          COLORFUL: 3252
+          OWL: 3251
       S2 Area:
         panels:
           COLORS: 1201
@@ -2903,6 +3677,8 @@ maps:
       Entrance:
         panels:
           SUN: 1212
+        ports:
+          UNKEMPT: 3253
       Mastery:
         masteries:
           MASTERY: 1213
@@ -2949,6 +3725,9 @@ maps:
           SQUISH: 1241
           VEGETABLE: 1232
           WATER: 1226
+        ports:
+          EXIT1: 3254
+          EXIT2: 3255
   the_symbolic:
     rooms:
       Black Room:
@@ -3130,6 +3909,8 @@ maps:
       White Room:
         panels:
           WRITE: 2425
+        ports:
+          PLAZA: 3256
       Yellow Room:
         panels:
           WHOLE: 2426
@@ -3173,9 +3954,12 @@ maps:
           WIFE (Brown): 2447
         keyholders:
           Y: 2764
+        ports:
+          GREAT: 3257
     doors:
       Black Side Panels: 2427
       Brown Side Panels: 2428
+      Keyholder Hint Panel: 3360
       Main Room Door: 2429
   the_tenacious:
     rooms:
@@ -3185,6 +3969,8 @@ maps:
       Control Center Entrance:
         panels:
           ZERO: 2455
+        ports:
+          CC: 3258
       Main Area:
         keyholders:
           K: 2768
@@ -3201,6 +3987,7 @@ maps:
         panels:
           WISDOM: 2459
     doors:
+      K Entered: 2844
       Paintings Door: 2453
   the_three_doors:
     rooms:
@@ -3210,26 +3997,39 @@ maps:
           DOOR: 2461
           END: 2464
           WAYS: 2462
+        ports:
+          BEGIN: 3259
+          BEGIN2: 3260
       First Second Room:
         panels:
           FIRS: 2465
           INITIAL: 2466
           MINUTE (1): 2467
           MINUTE (2): 2468
+        ports:
+          GREAT: 3261
+          TTD: 3262
       Loose Strings Room:
         panels:
           LOOSE: 2469
           STRINGS: 2470
+        ports:
+          BEGIN: 3263
       One Luck Room:
         panels:
           CHANCE: 2472
           LONE: 2471
+        ports:
+          BEGIN: 3264
       Silver Portal Room:
         panels:
           GOLD: 2473
           Left: 2475
           PORT: 2474
           Right: 2476
+        ports:
+          BEGIN: 3265
+          NEXT: 3266
     doors:
       The Three Doors Gravestone: 2460
   the_tower:
@@ -3248,6 +4048,8 @@ maps:
           PROD: 2485
           RIDE: 2484
           WARM: 2486
+        ports:
+          GREAT: 3267
       Tower:
         panels:
           ANNOY (1): 2508
@@ -3311,6 +4113,9 @@ maps:
       Third Floor Puzzles: 2480
   the_tree:
     rooms:
+      Bearer Entrance:
+        ports:
+          BEARER: 3268
       Main Area:
         panels:
           COLOR: 2550
@@ -3343,6 +4148,11 @@ maps:
           WADE: 2562
           WALK (1): 2555
           WALK (2): 2556
+        ports:
+          DAEDALUS: 3272
+          DIGITAL: 3270
+          GREAT: 3271
+          UNKEMPT: 3269
     doors:
       Control Center Brown Door: 2548
       The Tree Gravestone: 2549
@@ -3351,6 +4161,11 @@ maps:
       Control Center Entrance:
         panels:
           RETURN: 2587
+        ports:
+          CC: 3273
+      Daedalus Entrance:
+        ports:
+          DAEDALUS: 3274
       Exit Room 2:
         panels:
           DOOR: 2590
@@ -3394,6 +4209,10 @@ maps:
           ZOO: 2615
         keyholders:
           I: 2775
+        ports:
+          GREAT: 3275
+          SUNTEMPLE: 3277
+          TREE: 3276
       Middle Room:
         panels:
           FELLOW: 2624
@@ -3450,13 +4269,19 @@ maps:
     doors:
       Cog Rhino Hug Rug: 2586
       Control Center Orange Door: 2582
+      Control Center Orange Panel: 3362
+      East Door: 2580
       Honor Our Hint: 2585
+      I Entered: 2845
       Let Untrue Tie: 2583
-      Right Door: 2580
+      Near Teal Door Panels: 3361
       Routine Out Chute: 2584
       W2 Room Door: 2581
   the_unyielding:
     rooms:
+      Bearer Entrance:
+        ports:
+          BEARER: 3278
       Behind Northeast:
         panels:
           FIND: 1260
@@ -3544,6 +4369,8 @@ maps:
       Digital Entrance:
         panels:
           ORANGE: 1326
+        ports:
+          DIGITAL: 3279
       Directions Room:
         panels:
           ABS: 1327
@@ -3625,6 +4452,9 @@ maps:
           RAT: 1380
           SEE: 1377
           TIC: 1379
+      Nuanced Entrance:
+        ports:
+          NUANCED: 3280
       Orange Alcove:
         panels:
           ON: 1386
@@ -3632,6 +4462,8 @@ maps:
         panels:
           GEE: 1387
           SEA: 1388
+        ports:
+          PLAZA: 3281
       Red Eyes:
         panels:
           RED EYES: 1389
@@ -3692,7 +4524,9 @@ maps:
           HEALTH: 1428
     doors:
       Bearer Entrance: 1259
+      Blue D Room Puzzles: 3363
       Brown Alcove: 1255
+      Color Hallway Panels: 3364
       Digital Entrance: 1257
       East Room 1: 2740
       East Room 1 Entrance: 1251
@@ -3742,6 +4576,8 @@ maps:
       Entry:
         panels:
           WONDER: 2690
+        ports:
+          DAEDALUS: 3282
       Huge:
         panels:
           BARK: 2695
@@ -3769,6 +4605,8 @@ maps:
           METAL: 2706
           SPICE: 2708
           TREE: 2705
+        ports:
+          ENTRY: 3283
 letters:
   a1: 596
   a2: 6
@@ -3838,7 +4676,54 @@ endings:
   YELLOW: 1206
 special:
   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
+  Numbers: 3038
+  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:
+  Icarus Quick Travel: 2933
   Progressive Gold Ending: 2753
 door_groups:
   Control Center Blue Doors: 2788
@@ -3847,5 +4732,6 @@ door_groups:
   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
@@ -15,6 +15,8 @@ doors {
 doors {
   name: "Hidden Door"
   type: EVENT
+  latch: true
+  receivers: "Components/Doors/entry_12"
   keyholders { room: "Main Area" name: "1" key: "h" }
   keyholders { room: "Main Area" name: "2" key: "i" }
   keyholders { room: "Main Area" name: "3" key: "d" }
@@ -84,25 +86,12 @@ doors {
 doors {
   name: "White Ending Door"
   type: EVENT
-  # This is the only time a door depends on endings. However, it's nice to do it
-  # this way instead of just checking for ending room access because this lets
-  # us use events, which makes the playthrough more readable.
-  endings: "MINT"
-  endings: "ORANGE"
-  endings: "GREEN"
-  endings: "GRAY"
-  endings: "PLUM"
-  endings: "YELLOW"
-  endings: "GOLD"
-  endings: "BLACK"
-  endings: "CYAN"
-  endings: "PURPLE"
-  endings: "RED"
-  endings: "BLUE"
+  white_ending: true
 }
 doors {
   name: "Repetitive Entrance"
   type: STANDARD
+  latch: true
   receivers: "Components/Doors/entry_7"
   keyholders { room: "Main Area" name: "1" key: "m" }
   keyholders { room: "Main Area" name: "2" key: "o" }
@@ -113,20 +102,26 @@ doors {
 }
 doors {
   name: "Perceptive From Outside"
-  type: EVENT
+  type: STANDARD
+  latch: true
+  receivers: "Components/Doors/entry_26"
   keyholders { room: "Main Area" name: "1" key: "p" }
   keyholders { room: "Main Area" name: "2" key: "a" }
   keyholders { room: "Main Area" name: "3" key: "r" }
   keyholders { room: "Main Area" name: "4" key: "t" }
+  location_room: "Main Area"
+  location_name: "Keyword PART"
 }
 doors {
   name: "Perceptive From Inside"
-  type: EVENT
+  type: LOCATION_ONLY
   panels { room: "Perceptive Entrance" name: "PART" }
+  location_room: "Perceptive Entrance"
 }
 doors {
   name: "Ancient Entrance"
   type: STANDARD
+  latch: true
   receivers: "Components/Doors/entry_20"
   keyholders { room: "Main Area" name: "1" key: "z" }
   keyholders { room: "Main Area" name: "2" key: "e" }
@@ -170,3 +165,16 @@ doors {
   panels { room: "Unyielding Entrance" name: "SEEK" }
   location_room: "Unyielding Entrance"
 }
+doors {
+  name: "Near Perceptive Panel"
+  type: LOCATION_ONLY
+  panels { room: "Perceptive Entrance" name: "COLORS" }
+  location_room: "Perceptive Entrance"
+  location_name: "COLORS"
+}
+doors {
+  name: "Letters Panel"
+  type: LOCATION_ONLY
+  panels { room: "Main Area" name: "Letters" }
+  location_room: "Main Area"
+}
@@ -1,5 +1,12 @@
 name: "Ancient Entrance"
 ports {
   name: "ANCIENT"
+  display_name: "Ancient Entrance"
   path: "Components/Warps/worldport8"
+  destination { x: -27 y: 0 z: -34 }
+  rotation: 90
+  # This is because there's no port on the other side of the connection, so if
+  # this connection was removed and gallery paintings aren't shuffled then
+  # there'd be no way into The Ancient.
+  no_shuffle: true
 }
@@ -8,5 +8,8 @@ panels {
 }
 ports {
   name: "BETWEEN"
+  display_name: "Between Connector"
   path: "Components/Warps/worldport5"
+  destination { x: 39 y: 0 z: -17 }
+  rotation: 270
 }
@@ -8,5 +8,8 @@ panels {
 }
 ports {
   name: "ENTRY"
+  display_name: "Entry Connector"
   path: "Components/Warps/worldport2"
+  destination { x: 26 y: 0 z: -16.5 }
+  rotation: 0
 }
@@ -8,5 +8,8 @@ panels {
 }
 ports {
   name: "GREAT"
+  display_name: "Main Entrance"
   path: "Components/Warps/worldport"
+  destination { x: 0 y: 0 z: -1.5 }
+  rotation: 0
 }
@@ -49,22 +49,33 @@ keyholders {
 }
 ports {
   name: "RIGHT"
+  display_name: "Hinterlands South Entrance"
   path: "Components/Warps/worldport6"
+  destination { x: 82 y: 0 z: -10 }
+  rotation: 90
 }
 ports {
   name: "LEFT"
+  display_name: "Hinterlands North Entrance"
   path: "Components/Warps/worldport7"
-  # Check that this is correct.
+  destination { x: 82 y: 0 z: -48 }
+  rotation: 90
 }
 ports {
   name: "RELENTLESS_LEFT"
+  display_name: "Relentless LEFT Entrance"
   path: "Components/Warps/worldport9"
+  no_shuffle: true
 }
 ports {
   name: "RELENTLESS_SHOP"
+  display_name: "Relentless SHOP Entrance"
   path: "Components/Warps/worldport11"
+  no_shuffle: true
 }
 ports {
   name: "RELENTLESS_TURN"
+  display_name: "Relentless TURN Entrance"
   path: "Components/Warps/worldport10"
+  no_shuffle: true
 }
@@ -8,5 +8,8 @@ panels {
 }
 ports {
   name: "PARTIAL"
+  display_name: "Partial Connector"
   path: "Components/Warps/worldport4"
+  destination { x: 21 y: 0 z: -41 }
+  rotation: 270
 }
@@ -16,5 +16,8 @@ panels {
 }
 ports {
   name: "PERCEPTIVE"
+  display_name: "Perceptive Entrance"
   path: "Components/Warps/worldport12"
+  destination { x: -23 y: 0 z: -11 }
+  rotation: 0
 }
@@ -1,5 +1,8 @@
 name: "Repetitive Entrance"
 ports {
   name: "REPETITIVE"
+  display_name: "Repetitive Entrance"
   path: "Components/Warps/worldport14"
+  destination { x: -16 y: 0 z: -17.5 }
+  rotation: 0
 }
@@ -8,5 +8,8 @@ panels {
 }
 ports {
   name: "TENACIOUS"
+  display_name: "Tenacious Connector"
   path: "Components/Warps/worldport13"
+  destination { x: 56 y: 0 z: -38 }
+  rotation: 180
 }
@@ -8,5 +8,8 @@ panels {
 }
 ports {
   name: "UNKEMPT"
+  display_name: "Unkempt Connector"
   path: "Components/Warps/worldport3"
+  destination { x: 34 y: 0 z: -38.5 }
+  rotation: 90
 }
@@ -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
@@ -222,12 +227,12 @@ connections {
 connections {
   from_room: "West Castle Area"
   to_room: "Post Orange Smiley Three Way"
-  door { name: "Splintering Exit Left Door" }
+  door { name: "Splintering Exit North Door" }
 }
 connections {
   from_room: "West Castle Area"
   to_room: "Amber North 2"
-  door { name: "Splintering Exit Right Door" }
+  door { name: "Splintering Exit South Door" }
 }
 connections {
   from_room: "Z2 Room"
@@ -378,7 +383,7 @@ connections {
 connections {
   from_room: "O2 Room"
   to_room: "Blue Smiley"
-  door { name: "Blue Smiley Entrance" }
+  door { name: "O2 Room Southeast Door" }
 }
 connections {
   from_room: "O2 Room"
@@ -408,7 +413,7 @@ connections {
 connections {
   from_room: "O2 Room"
   to_room: "Blue Hallway"
-  door { name: "O2 Room Back Door" }
+  door { name: "O2 Room Northeast Door" }
 }
 connections {
   from_room: "O2 Room"
@@ -423,7 +428,7 @@ connections {
 connections {
   from_room: "Sweet Foyer"
   to_room: "F2 Room"
-  door { name: "F2 Room Entrance" }
+  door { name: "F2 Room Southeast Door" }
 }
 connections {
   from_room: "Globe Room"
@@ -438,17 +443,17 @@ connections {
 connections {
   from_room: "F2 Room"
   to_room: "Blue Hallway"
-  door { name: "F2 Room Back Right Door" }
+  door { name: "F2 Room Southwest Door" }
 }
 connections {
   from_room: "F2 Room"
   to_room: "Outside Salt Room"
-  door { name: "F2 Room Back Left Door" }
+  door { name: "F2 Room Northwest Door" }
 }
 connections {
   from_room: "F2 Room"
   to_room: "Red Color Door"
-  door { name: "F2 Room Back Middle Door" }
+  door { name: "F2 Room West Door" }
   oneway: true
   # This is the red backside, which has nothing in it. Maybe could be its own
   # region at some point.
@@ -461,7 +466,7 @@ connections {
 connections {
   from_room: "U2 Room"
   to_room: "Maze Paintings Area"
-  door { name: "U2 Room Shortcut" }
+  door { name: "U2 Room Southeast Door" }
 }
 connections {
   from_room: "Maze Paintings Area"
@@ -476,17 +481,17 @@ connections {
 connections {
   from_room: "U2 Room"
   to_room: "Purple SE Vestibule"
-  door { name: "U2 Room Back Right Door" }
+  door { name: "U2 Room Southwest Door" }
 }
 connections {
   from_room: "U2 Room"
   to_room: "Purple Room East"
-  door { name: "U2 Room Back Door" }
+  door { name: "U2 Room West Door" }
 }
 connections {
   from_room: "Maze"
   to_room: "U2 Room"
-  door { name: "U2 Room Entrance" }
+  door { name: "U2 Room East Door" }
 }
 connections {
   from_room: "Outside Magic Room"
@@ -511,7 +516,7 @@ connections {
 connections {
   from_room: "Wonderland"
   to_room: "Black Hex"
-  door { name: "Wonderland Right Door" }
+  door { name: "Wonderland South Door" }
 }
 connections {
   from_room: "Outside Pyramid"
@@ -601,7 +606,7 @@ connections {
 connections {
   from_room: "Wonderland"
   to_room: "Number Paintings Area"
-  door { name: "Wonderland Left Door" }
+  door { name: "Wonderland North Door" }
 }
 connections {
   from_room: "Outside House"
@@ -1857,3 +1862,15 @@ connections {
   oneway: true
   roof_access: true
 }
+connections {
+  from_room: "Roof"
+  to_room: "F Keyholder"
+  oneway: true
+  roof_access: true
+}
+connections {
+  from_room: "Roof"
+  to_room: "Yellow Color Backside"
+  oneway: true
+  roof_access: true
+}
@@ -188,17 +188,20 @@ doors {
 }
 doors {
   name: "Welcome Back Secret Door"
-  type: ITEM_ONLY
+  type: STANDARD
   receivers: "Components/Doors/Entry/entry_13"
   panels { room: "Welcome Back Area" name: "FAREWELL LITTLE LAMB" }
   panels { room: "West Spire" name: "BYE" }
+  location_room: "West Spire"
+  location_name: "BYE, FAREWELL LITTLE LAMB"
 }
 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"
+  location_name: "GREETINGS OLD FRIEND"
 }
 # entry_3 is the door to SEAL, which we will ignore.
 doors {
@@ -224,12 +227,21 @@ doors {
 }
 doors {
   name: "Starting Room East Wall Center Door"
-  type: STANDARD
+  type: ITEM_ONLY
+  legacy_location: true
   receivers: "Components/Doors/Entry/entry_6"
   panels { room: "Rainbow Color Backside" name: "?" }
   location_room: "Rainbow Color Backside"
 }
 doors {
+  name: "Rainbow Color Backside Panels"
+  type: LOCATION_ONLY
+  panels { room: "Rainbow Color Backside" name: "?" }
+  panels { room: "Rainbow Color Backside" name: "BACKSIDE" }
+  location_room: "Rainbow Color Backside"
+  location_name: "BACKSIDE, ?"
+}
+doors {
   name: "Starting Room East Wall North Door"
   type: ITEM_ONLY
   receivers: "Components/Doors/Entry/entry_7"
@@ -298,8 +310,9 @@ doors {
   location_name: "Black Hex"
 }
 doors {
-  name: "Splintering Exit Left Door"
-  type: STANDARD
+  name: "Splintering Exit North Door"
+  type: ITEM_ONLY
+  legacy_location: true
   receivers: "Components/Doors/Entry/gate_4"
   panels { room: "West Castle Area" name: "EVER" }
   panels { room: "West Castle Area" name: "AXES" }
@@ -308,7 +321,7 @@ doors {
   location_room: "West Castle Area"
 }
 doors {
-  name: "Splintering Exit Right Door"
+  name: "Splintering Exit South Door"
   type: ITEM_ONLY
   receivers: "Components/Doors/Entry/gate_5"
   panels { room: "West Castle Area" name: "EVER" }
@@ -317,6 +330,48 @@ doors {
   panels { room: "West Castle Area" name: "SLOT" }
 }
 doors {
+  name: "Splintering Area Panels"
+  type: LOCATION_ONLY
+  panels { room: "West Castle Area" name: "EVER" }
+  panels { room: "West Castle Area" name: "AXES" }
+  panels { room: "West Castle Area" name: "FLIP (1)" }
+  panels { room: "West Castle Area" name: "SLOT" }
+  panels { room: "West Castle Area" name: "WICKEDLY" }
+  panels { room: "West Castle Area" name: "CATHOLIC" }
+  panels { room: "West Castle Area" name: "SISTERLY" }
+  panels { room: "West Castle Area" name: "SQUEALED" }
+  panels { room: "West Castle Area" name: "READ" }
+  panels { room: "West Castle Area" name: "WORD" }
+  panels { room: "West Castle Area" name: "EACH" }
+  panels { room: "West Castle Area" name: "RANK" }
+  panels { room: "West Castle Area" name: "TEAR" }
+  panels { room: "West Castle Area" name: "SHUT" }
+  panels { room: "West Castle Area" name: "FLIP (2)" }
+  panels { room: "West Castle Area" name: "STUN" }
+  panels { room: "West Castle Area" name: "CHAT" }
+  panels { room: "West Castle Area" name: "LOST" }
+  panels { room: "West Castle Area" name: "PODS" }
+  panels { room: "West Castle Area" name: "FAME" }
+  location_room: "West Castle Area"
+}
+doors {
+  name: "West Sticks And Stones Panel"
+  type: LOCATION_ONLY
+  panels { room: "West Castle Area" name: "LETTERS" }
+  location_room: "West Castle Area"
+  location_name: "LETTERS"
+}
+doors {
+  name: "Amber Room Panels"
+  type: LOCATION_ONLY
+  panels { room: "West Castle Area" name: "HARMONY" }
+  panels { room: "West Castle Area" name: "MELODY" }
+  panels { room: "West Castle Area" name: "RHYTHM" }
+  panels { room: "West Castle Area" name: "TEXTURE" }
+  location_room: "West Castle Area"
+  location_name: "HARMONY, MELODY, RHYTHM, TEXTURE"
+}
+doors {
   name: "Z2 Room Back Exit"
   type: ITEM_ONLY
   receivers: "Components/Doors/Entry/gate_2"
@@ -493,7 +548,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"
@@ -716,7 +770,7 @@ doors {
   panels { room: "O2 Room" name: "UNBLOCKED" }
 }
 doors {
-  name: "Blue Smiley Entrance"
+  name: "O2 Room Southeast Door"
   type: STANDARD
   receivers: "Components/Doors/Halls/oroom_2"
   panels { room: "O2 Room" name: "HONEST" }
@@ -820,9 +874,20 @@ doors {
 }
 doors {
   name: "Composite Room NW Entrance"
-  type: STANDARD
+  type: ITEM_ONLY
+  legacy_location: true
   receivers: "Components/Doors/Halls/oroom_10"
-  panels { room: "Red Color Door" name: "Left" }
+  panels { room: "Red Color Door" name: "Near Obscured Puzzles" }
+  location_room: "Red Color Door"
+}
+doors {
+  name: "Yellow Roof Puzzles"
+  type: LOCATION_ONLY
+  panels { room: "Red Color Door" name: "BACKSIDE" }
+  panels { room: "Red Color Door" name: "WALK BACK" }
+  panels { room: "Red Color Door" name: "Back (1)" }
+  panels { room: "Red Color Door" name: "Back (2)" }
+  panels { room: "Red Color Door" name: "Near Obscured Puzzles" }
   location_room: "Red Color Door"
 }
 doors {
@@ -857,7 +922,7 @@ doors {
   location_name: "South Rooms"
 }
 doors {
-  name: "O2 Room Back Door"
+  name: "O2 Room Northeast Door"
   type: STANDARD
   receivers: "Components/Doors/Halls/oroom_4"
   panels { room: "O2 Room" name: "UNBLOCKED" }
@@ -866,6 +931,7 @@ doors {
 doors {
   name: "Control Center Orange Door"
   type: CONTROL_CENTER_COLOR
+  latch: true
   receivers: "Components/Doors/Halls/oroom_6"
   control_center_color: "orange"
 }
@@ -884,8 +950,9 @@ doors {
   panels { room: "F2 Room" name: "SHAPE" }
 }
 doors {
-  name: "F2 Room Entrance"
-  type: STANDARD
+  name: "F2 Room Southeast Door"
+  type: ITEM_ONLY
+  legacy_location: true
   receivers: "Components/Doors/Halls/froom_2"
   panels { room: "Sweet Foyer" name: "RENT (1)" }
   location_room: "Sweet Foyer"
@@ -893,31 +960,33 @@ doors {
 doors {
   name: "White Hallway From Entry"
   type: CONTROL_CENTER_COLOR
+  latch: true
   receivers: "Components/Doors/Halls/froom_6"
   control_center_color: "white"
 }
 doors {
   name: "Purple Hallway From Great"
   type: CONTROL_CENTER_COLOR
+  latch: true
   receivers: "Components/Doors/Halls/froom_7"
   control_center_color: "purple"
 }
 doors {
-  name: "F2 Room Back Right Door"
+  name: "F2 Room Southwest Door"
   type: STANDARD
   receivers: "Components/Doors/Halls/froom_3"
   panels { room: "F2 Room" name: "RISKY" }
   location_room: "F2 Room"
 }
 doors {
-  name: "F2 Room Back Left Door"
+  name: "F2 Room Northwest Door"
   type: STANDARD
   receivers: "Components/Doors/Halls/froom_4"
   panels { room: "F2 Room" name: "SHAPE" }
   location_room: "F2 Room"
 }
 doors {
-  name: "F2 Room Back Middle Door"
+  name: "F2 Room West Door"
   type: STANDARD
   receivers: "Components/Doors/Halls/froom_5"
   panels { room: "F2 Room" name: "DIRT" }
@@ -938,7 +1007,7 @@ doors {
   panels { room: "U2 Room" name: "HEAVEN" }
 }
 doors {
-  name: "U2 Room Shortcut"
+  name: "U2 Room Southeast Door"
   type: STANDARD
   receivers: "Components/Doors/Halls/uroom_2"
   panels { room: "U2 Room" name: "WICKED" }
@@ -959,21 +1028,21 @@ doors {
   location_room: "House Entrance"
 }
 doors {
-  name: "U2 Room Back Right Door"
+  name: "U2 Room Southwest Door"
   type: STANDARD
   receivers: "Components/Doors/Halls/uroom_3"
   panels { room: "U2 Room" name: "HEAVEN" }
   location_room: "U2 Room"
 }
 doors {
-  name: "U2 Room Back Door"
+  name: "U2 Room West Door"
   type: ITEM_ONLY
   receivers: "Components/Doors/Halls/uroom_5"
   panels { room: "Purple Room South" name: "ANY" }
   panels { room: "Outside House" name: "A" }
 }
 doors {
-  name: "U2 Room Entrance"
+  name: "U2 Room East Door"
   type: ITEM_ONLY
   receivers: "Components/Doors/Halls/uroom_4"
   panels { room: "Outside Magic Room" name: "WIZARD" }
@@ -1017,7 +1086,7 @@ doors {
   panels { room: "Outside Magic Room" name: "WIZARD" }
 }
 doors {
-  name: "Wonderland Right Door"
+  name: "Wonderland South Door"
   type: STANDARD
   receivers: "Components/Doors/Halls/wonderland_1"
   panels { room: "Wonderland" name: "APRIL" }
@@ -1208,70 +1277,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"
@@ -1307,7 +1343,7 @@ doors {
   panels { room: "J2 Vestibule" name: "COLORFUL" }
 }
 doors {
-  name: "Wonderland Left Door"
+  name: "Wonderland North Door"
   type: ITEM_ONLY
   receivers: "Components/Doors/Halls/wonderland_2"
   panels { room: "Wonderland" name: "APRIL" }
@@ -1421,6 +1457,9 @@ doors {
   receivers: "Meshes/Stairs/staircase31/teleportListener"
   receivers: "Meshes/Stairs/staircase32/teleportListener2"
   receivers: "Meshes/Stairs/staircase33/teleportListener3"
+  receivers: "Panels/Castle Entrance/castle_direction_1/teleportListener"
+  receivers: "Panels/Castle Entrance/castle_direction_2/teleportListener"
+  receivers: "Panels/Castle Entrance/castle_direction_3/teleportListener"
   panels { room: "North Castle Area" name: "A SUMMER PLACE" }
   panels { room: "West Castle Area" name: "SONG FACE" }
   panels { room: "South Castle Area" name: "AN OFFER VILLAGE BEFORE LAIR" }
@@ -1613,6 +1652,7 @@ doors {
   panels { room: "Salt Room" name: "SEASONING" }
   panels { room: "Pepper Room" name: "SEASONING" }
   location_room: "Pepper Room"
+  location_name: "Seasonings"
 }
 doors {
   name: "Bow Side"
@@ -1648,6 +1688,7 @@ doors {
   # Components/Doors/Smileys/blue_1
   panels { room: "Blue Smiley" name: "SMILE" }
   location_room: "Blue Smiley"
+  location_name: "Blue SMILE"
 }
 doors {
   name: "Blue Smiley Annex"
@@ -1679,6 +1720,7 @@ doors {
   receivers: "Components/Doors/Smileys/yellow_2"
   panels { room: "Hedges" name: "SMILE" }
   location_room: "Hedges"
+  location_name: "Yellow SMILE"
 }
 doors {
   name: "Green Smiley"
@@ -1687,6 +1729,7 @@ doors {
   receivers: "Components/Doors/Smileys/green_2"
   panels { room: "Green Smiley" name: "SMILE" }
   location_room: "Green Smiley"
+  location_name: "Green SMILE"
 }
 doors {
   name: "Orange Smiley Exit"
@@ -1694,6 +1737,7 @@ doors {
   receivers: "Components/Doors/Smileys/orange_1"
   panels { room: "Outside Orange Room" name: "SMILE" }
   location_room: "Outside Orange Room"
+  location_name: "Orange SMILE"
 }
 doors {
   name: "F Keyholder Door"
@@ -1718,6 +1762,7 @@ doors {
   type: LOCATION_ONLY
   panels { room: "Red Smiley" name: "SMILE" }
   location_room: "Red Smiley"
+  location_name: "Red SMILE"
 }
 doors {
   name: "Pink Hallway"
@@ -1792,12 +1837,37 @@ doors {
 }
 doors {
   name: "Near Sweet Brown Door"
-  type: STANDARD
+  type: ITEM_ONLY
+  legacy_location: true
   receivers: "Components/Doors/Halls 2/halls_2"
   panels { room: "Sweet Foyer" name: "RENT (4)" }
   location_room: "Sweet Foyer"
 }
 doors {
+  name: "Rent Panels"
+  type: LOCATION_ONLY
+  panels { room: "Sweet Foyer" name: "RENT (1)" }
+  panels { room: "Sweet Foyer" name: "RENT (2)" }
+  panels { room: "Sweet Foyer" name: "RENT (3)" }
+  panels { room: "Sweet Foyer" name: "RENT (4)" }
+  location_room: "Sweet Foyer"
+}
+doors {
+  name: "Equality Panels"
+  type: LOCATION_ONLY
+  panels { room: "Sweet Foyer" name: "EQUAL" }
+  panels { room: "Sweet Foyer" name: "QUALITY" }
+  location_room: "Sweet Foyer"
+  location_name: "EQUAL, QUALITY"
+}
+doors {
+  name: "Orange Panels"
+  type: LOCATION_ONLY
+  panels { room: "Blue Smiley Annex" name: "ORANGE (1)" }
+  panels { room: "Blue Smiley Annex" name: "ORANGE (2)" }
+  location_room: "Blue Smiley Annex"
+}
+doors {
   name: "Red Room Entrance"
   type: STANDARD
   receivers: "Components/Doors/Halls 2/halls_3"
@@ -1952,7 +2022,7 @@ doors {
   panels { room: "Gray Color Backside" name: "LAST" }
   panels { room: "Gray Color Backside" name: "RISE" }
   location_room: "Gray Color Backside"
-  location_name: "Light Green Hex"
+  location_name: "Pale Green Hex"
 }
 doors {
   name: "South Castle Area Back Door"
@@ -2112,8 +2182,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"
@@ -2183,6 +2257,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"
@@ -2302,3 +2377,95 @@ 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"
+}
+doors {
+  name: "West Spire Panel"
+  type: LOCATION_ONLY
+  panels { room: "West Spire" name: "MISSING" }
+  location_room: "West Spire"
+  location_name: "MISSING"
+}
+doors {
+  name: "Tree Panels"
+  type: LOCATION_ONLY
+  panels { room: "Red Color Door" name: "FIR" }
+  panels { room: "Red Color Door" name: "OAK" }
+  panels { room: "Red Color Door" name: "PINE" }
+  panels { room: "Red Color Door" name: "ASH" }
+  location_room: "Red Color Door"
+  location_name: "ASH, FIR, OAK, PINE"
+}
+doors {
+  name: "Teal Panel"
+  type: LOCATION_ONLY
+  panels { room: "Outside Book Room" name: "TEAL" }
+  location_room: "Outside Book Room"
+  location_name: "TEAL"
+}
+doors {
+  name: "Direction Panels"
+  type: LOCATION_ONLY
+  panels { room: "Rainbow Color Doors" name: "DIRECTION (1)" }
+  panels { room: "Rainbow Color Doors" name: "DIRECTION (2)" }
+  panels { room: "Rainbow Color Doors" name: "DIRECTION (3)" }
+  location_room: "Rainbow Color Doors"
+}
+doors {
+  name: "Nursery Panels"
+  type: LOCATION_ONLY
+  panels { room: "Nursery" name: "Paintings" }
+  panels { room: "Nursery" name: "?" }
+  location_room: "Nursery"
+  location_name: "Paintings, ?"
+}
+doors {
+  name: "Near H Keyholder Panel"
+  type: LOCATION_ONLY
+  panels { room: "Outside House" name: "SILENCE" }
+  location_room: "Outside House"
+  location_name: "SILENCE"
+}
+doors {
+  name: "Plum Panels"
+  type: LOCATION_ONLY
+  panels { room: "Outside Hedges" name: "PLUM (1)" }
+  panels { room: "Outside Hedges" name: "PLUM (2)" }
+  location_room: "Outside Hedges"
+}
+doors {
+  name: "Yellow Smiley Annex Panels"
+  type: LOCATION_ONLY
+  panels { room: "Yellow Smiley Annex" name: "BELL" }
+  panels { room: "Yellow Smiley Annex" name: "COW" }
+  location_room: "Yellow Smiley Annex"
+  location_name: "BELL, COW"
+}
+doors {
+  name: "Farewell Little Lamb Panels"
+  type: LOCATION_ONLY
+  panels { room: "Purple Room South" name: "FAREWELL" }
+  panels { room: "Purple Room South" name: "LITTLE" }
+  panels { room: "Purple Room South" name: "LAMB" }
+  location_room: "Purple Room South"
+  location_name: "FAREWELL, LITTLE, LAMB"
+}
@@ -1,5 +1,5 @@
 name: "C Keyholder"
-panel_display_name: "North Area"
+panel_display_name: "East Area"
 keyholders {
   name: "C"
   path: "Components/KeyHolders/keyHolderC"
@@ -194,5 +194,8 @@ panels {
 }
 ports {
   name: "ENTRY"
+  display_name: "Composite Room Worldport"
   path: "Components/Warps/Worldports/worldport16"
+  destination { x: -84 y: 0 z: 81 }
+  rotation: 270
 }
@@ -10,5 +10,8 @@ panels {
 }
 ports {
   name: "ENTRY"
+  display_name: "Starting Room West Wall Middle Worldport"
   path: "Components/Warps/Worldports/worldport4"
+  destination { x: -21 y: 0 z: -4 }
+  rotation: 90
 }
@@ -2,5 +2,7 @@ name: "Hedges Tower"
 panel_display_name: "Hedges"
 ports {
   name: "TENACIOUS"
+  display_name: "Hedge Maze Tower"
   path: "Components/Warps/Worldports/worldport13"
+  no_shuffle: true
 }
@@ -1,7 +1,5 @@
 name: "Hotel"
 panel_display_name: "Southwest Area"
-# TODO: Something has to be changed in-game so that the puzzles don't disappear
-# and thus cause them to become unsolvable.
 panels {
   name: "MARLIN"
   path: "Panels/Connections/connections_2"
@@ -6,5 +6,8 @@ paintings {
 }
 ports {
   name: "HIVE"
+  display_name: "Moat Worldport"
   path: "Components/Warps/Worldports/worldport9"
+  destination { x: 64 y: 1 z: 24.5 }
+  rotation: 0
 }
@@ -76,5 +76,8 @@ paintings {
 }
 ports {
   name: "REVITALIZED"
+  display_name: "Near Hedges Plum Hallway"
   path: "Components/Warps/Worldports/worldport7"
+  destination { x: 45 y: 0 z: 94 }
+  rotation: 270
 }
@@ -2,5 +2,8 @@ name: "Purple Hallway From Great"
 panel_display_name: "South Area"
 ports {
   name: "GREAT"
+  display_name: "Near Sweet Purple Hallway"
   path: "Components/Warps/Worldports/worldport17"
+  destination { x: -24 y: 0 z: 61 }
+  rotation: 270
 }
@@ -16,5 +16,8 @@ paintings {
 }
 ports {
   name: "QUIET"
+  display_name: "Near Planet Painting Worldport"
   path: "Components/Warps/Worldports/worldport5"
+  destination { x: -32 y: 0 z: -40 }
+  rotation: 90
 }
@@ -10,5 +10,8 @@ panels {
 }
 ports {
   name: "BEARER"
+  display_name: "Rain Panel Worldport"
   path: "Components/Warps/Worldports/worldport11"
+  destination { x: 93.5 y: 0 z: 27 }
+  rotation: 90
 }
@@ -1,7 +1,7 @@
 name: "Red Color Door"
 panel_display_name: "Southwest Area"
 panels {
-  name: "Left"
+  name: "Near Obscured Puzzles"
   path: "Panels/Halls/wb_1"
   clue: ""
   answer: "sidewalk"
@@ -9,5 +9,8 @@ panels {
 }
 ports {
   name: "GREAT"
+  display_name: "Starting Room South Wall Middle Worldport"
   path: "Components/Warps/Worldports/worldport"
+  destination { x: 0 y: 0 z: 11 }
+  rotation: 0
 }
@@ -51,9 +51,15 @@ paintings {
 }
 ports {
   name: "SWEET1"
+  display_name: "Sweet East Entrance"
   path: "Components/Warps/Worldports/worldport14"
+  destination { x: -27 y: 0 z: 76.5 }
+  rotation: 270
 }
 ports {
   name: "SWEET2"
+  display_name: "Sweet West Entrance"
   path: "Components/Warps/Worldports/worldport15"
+  destination { x: -36 y: 0 z: 76.5 }
+  rotation: 90
 }
@@ -48,5 +48,8 @@ panels {
 }
 ports {
   name: "TREE"
+  display_name: "Near Pumpkin Brown Hallway"
   path: "Components/Warps/Worldports/worldport12"
+  destination { x: 41 y: 0 z: 50.5 }
+  rotation: 0
 }
@@ -2,5 +2,8 @@ name: "Unkempt Entrance"
 panel_display_name: "O2 Room"
 ports {
   name: "UNKEMPT"
+  display_name: "O2 Room Worldport"
   path: "Components/Warps/Worldports/worldport6"
+  destination { x: -61 y: 0 z: 95 }
+  rotation: 270
 }
@@ -1,12 +1,9 @@
 name: "White Hallway From Entry"
 panel_display_name: "Southwest Area"
-# Not exactly sure what to do with this yet. In unshuffled connections, the door
-# here should be paired with the door on the other end (which is vanilla) even
-# if control center color doors are shuffled. But when connections are shuffled
-# maybe this should be shuffled separately? I might also want to find a way to
-# register when there's a door immediately outside of a connection so that when
-# two connections behind doors are shuffled together, their doors can be paired.
 ports {
   name: "ENTRY"
+  display_name: "Near Globe White Hallway"
   path: "Components/Warps/Worldports/worldport10"
+  destination { x: -46 y: 0 z: 23 }
+  rotation: 90
 }
@@ -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,5 +37,8 @@ panels {
 }
 ports {
   name: "WONDROUS"
+  display_name: "Wonderland Worldport"
   path: "Components/Warps/Worldports/worldport3"
+  destination { x: -104 y: 0 z: -69 }
+  rotation: 180
 }
@@ -30,5 +30,8 @@ paintings {
 }
 ports {
   name: "FOURROOMS"
+  display_name: "Near Yellow Worldport"
   path: "Components/Warps/Worldports/worldport8"
+  destination { x: 92.5 y: 0 z: -62 }
+  rotation: 90
 }
@@ -0,0 +1,30 @@
+connections {
+  from_room: "Main Area"
+  to_room: "Center Building"
+  door { name: "Center Building" }
+}
+connections {
+  from_room: "Main Area"
+  to_room: "Flower Hallway"
+  door { name: "Flower Hallway" }
+}
+connections {
+  from_room: "Main Area"
+  to_room: "Tower"
+  door { name: "Tower Entrance" }
+}
+connections {
+  from_room: "Main Area"
+  to_room: "Castle"
+  door { name: "Castle" }
+}
+connections {
+  from_room: "Main Area"
+  to_room: "Backside Area"
+  door { name: "Backside Entrance" }
+}
+connections {
+  from_room: "Backside Area"
+  to_room: "Mastery"
+  door { name: "Mastery Door" }
+}
@@ -0,0 +1,161 @@
+doors {
+  name: "Center Building"
+  type: STANDARD
+  receivers: "Components/Doors/demo_1"
+  panels { room: "Main Area" name: "HI" }
+  location_room: "Main Area"
+}
+doors {
+  name: "Flower Hallway"
+  type: STANDARD
+  receivers: "Components/Doors/demo_32"
+  panels { room: "Main Area" name: "TEES" }
+  location_room: "Main Area"
+}
+doors {
+  name: "Center Building Panels"
+  type: LOCATION_ONLY
+  panels { room: "Center Building" name: "WORLD" }
+  panels { room: "Center Building" name: "FUZZIES" }
+  panels { room: "Main Area" name: "COLORFUL" }
+  panels { room: "Main Area" name: "WORD" }
+  location_room: "Center Building"
+  location_name: "COLORFUL, FUZZIES, WORD, WORLD"
+}
+doors {
+  name: "Orange Door"
+  type: LOCATION_ONLY
+  panels { room: "Main Area" name: "HID" }
+  panels { room: "Main Area" name: "MESS" }
+  panels { room: "Main Area" name: "DEN" }
+  panels { room: "Main Area" name: "AGES" }
+  location_room: "Main Area"
+  location_name: "AGES, DEN, HID, MESS"
+}
+doors {
+  name: "Purple Door"
+  type: LOCATION_ONLY
+  panels { room: "Main Area" name: "COUNTER" }
+  panels { room: "Main Area" name: "POSSIBLE" }
+  panels { room: "Main Area" name: "PACES" }
+  panels { room: "Main Area" name: "CLOCKWISE" }
+  location_room: "Main Area"
+  location_name: "CLOCKWISE, COUNTER, PACES, POSSIBLE"
+}
+doors {
+  name: "Yellow Door"
+  type: LOCATION_ONLY
+  panels { room: "Main Area" name: "ANY" }
+  panels { room: "Main Area" name: "RODS" }
+  panels { room: "Main Area" name: "TWO" }
+  panels { room: "Main Area" name: "TALK" }
+  panels { room: "Main Area" name: "SECRETIVE" }
+  panels { room: "Main Area" name: "TOADS" }
+  panels { room: "Main Area" name: "TON" }
+  panels { room: "Main Area" name: "MIND" }
+  panels { room: "Main Area" name: "END" }
+  panels { room: "Main Area" name: "RAD" }
+  panels { room: "Main Area" name: "TOO" }
+  panels { room: "Main Area" name: "STALK" }
+  location_room: "Main Area"
+  location_name: "Yellow Area Puzzles"
+}
+doors {
+  name: "Red Door"
+  type: LOCATION_ONLY
+  panels { room: "Castle" name: "SERIES" }
+  location_room: "Castle"
+  location_name: "SERIES"
+}
+doors {
+  name: "Castle"
+  type: STANDARD
+  receivers: "Components/Doors/demo_15"
+  panels { room: "Main Area" name: "CASTS" }
+  location_room: "Main Area"
+}
+doors {
+  name: "Scavenger Hunt"
+  type: LOCATION_ONLY
+  panels { room: "Main Area" name: "S" }
+  panels { room: "Main Area" name: "C" }
+  panels { room: "Main Area" name: "A" }
+  panels { room: "Main Area" name: "V" }
+  panels { room: "Main Area" name: "E (1)" }
+  panels { room: "Main Area" name: "N" }
+  panels { room: "Castle" name: "G" }
+  panels { room: "Main Area" name: "E (2)" }
+  panels { room: "Main Area" name: "R" }
+  location_room: "Castle"
+}
+doors {
+  name: "Gold Door"
+  type: LOCATION_ONLY
+  panels { room: "Main Area" name: "DISCOVER" }
+  panels { room: "Main Area" name: "FAMILY" }
+  panels { room: "Flower Hallway" name: "LACES" }
+  location_room: "Flower Hallway"
+  location_name: "DISCOVER, FAMILY, LACES"
+}
+doors {
+  name: "Tower Entrance"
+  type: EVENT
+  panels { room: "Main Area" name: "HI" }
+  panels { room: "Main Area" name: "ART" }
+  panels { room: "Main Area" name: "TEES" }
+  panels { room: "Center Building" name: "WORLD" }
+  panels { room: "Center Building" name: "FUZZIES" }
+  panels { room: "Main Area" name: "COLORFUL" }
+  panels { room: "Main Area" name: "WORD" }
+  panels { room: "Main Area" name: "HID" }
+  panels { room: "Main Area" name: "MESS" }
+  panels { room: "Main Area" name: "DEN" }
+  panels { room: "Main Area" name: "AGES" }
+  panels { room: "Main Area" name: "COUNTER" }
+  panels { room: "Main Area" name: "POSSIBLE" }
+  panels { room: "Main Area" name: "PACES" }
+  panels { room: "Main Area" name: "CLOCKWISE" }
+  panels { room: "Main Area" name: "ANY" }
+  panels { room: "Main Area" name: "RODS" }
+  panels { room: "Main Area" name: "TWO" }
+  panels { room: "Main Area" name: "TALK" }
+  panels { room: "Main Area" name: "SECRETIVE" }
+  panels { room: "Main Area" name: "TOADS" }
+  panels { room: "Main Area" name: "TON" }
+  panels { room: "Main Area" name: "MIND" }
+  panels { room: "Main Area" name: "END" }
+  panels { room: "Main Area" name: "RAD" }
+  panels { room: "Main Area" name: "TOO" }
+  panels { room: "Main Area" name: "STALK" }
+  panels { room: "Castle" name: "SERIES" }
+  panels { room: "Main Area" name: "CASTS" }
+  panels { room: "Main Area" name: "HAZES" }
+  panels { room: "Main Area" name: "DAZES" }
+  panels { room: "Main Area" name: "GAZES" }
+  panels { room: "Main Area" name: "S" }
+  panels { room: "Main Area" name: "C" }
+  panels { room: "Main Area" name: "A" }
+  panels { room: "Main Area" name: "V" }
+  panels { room: "Main Area" name: "E (1)" }
+  panels { room: "Main Area" name: "N" }
+  panels { room: "Castle" name: "G" }
+  panels { room: "Main Area" name: "E (2)" }
+  panels { room: "Main Area" name: "R" }
+  panels { room: "Main Area" name: "Blank" }
+  panels { room: "Main Area" name: "DISCOVER" }
+  panels { room: "Main Area" name: "FAMILY" }
+  panels { room: "Flower Hallway" name: "LACES" }
+}
+doors {
+  name: "Backside Entrance"
+  type: EVENT
+  panels { room: "Tower" name: "ENDS (1)" }
+}
+doors {
+  name: "Mastery Door"
+  type: EVENT
+  panels { room: "Backside Area" name: "BACKSIDE" }
+  panels { room: "Backside Area" name: "DOORWAYS" }
+  panels { room: "Backside Area" name: "SEE" }
+  panels { room: "Backside Area" name: "ENDS (2)" }
+}
@@ -0,0 +1,6 @@
+display_name: "Demo"
+type: DEMO
+# This painting is above a panel and can't be entered.
+excluded_nodes: "Meshes/owl"
+# The map's mastery is created at runtime.
+custom_nodes: "Components/Collectables/collectable"
@@ -0,0 +1,25 @@
+name: "Backside Area"
+panels {
+  name: "BACKSIDE"
+  path: "Panels/Endings/demo_41"
+  clue: "backside"
+  answer: "back"
+}
+panels {
+  name: "DOORWAYS"
+  path: "Panels/Endings/demo_42"
+  clue: "doorways"
+  answer: "doors"
+}
+panels {
+  name: "SEE"
+  path: "Panels/Endings/demo_43"
+  clue: "see"
+  answer: "secret"
+}
+panels {
+  name: "ENDS (2)"
+  path: "Panels/Endings/demo_44"
+  clue: "ends"
+  answer: "endings"
+}
@@ -0,0 +1,13 @@
+name: "Castle"
+panels {
+  name: "SERIES"
+  path: "Panels/Red/demo_26"
+  clue: "series"
+  answer: "mysteries"
+}
+panels {
+  name: "G"
+  path: "Panels/Blue/demo_37"
+  clue: "g"
+  answer: "g"
+}
@@ -0,0 +1,13 @@
+name: "Center Building"
+panels {
+  name: "WORLD"
+  path: "Panels/Room 1/demo_3"
+  clue: "world"
+  answer: "word"
+}
+panels {
+  name: "FUZZIES"
+  path: "Panels/Room 1/demo_4"
+  clue: "fuzzies"
+  answer: "puzzles"
+}
@@ -0,0 +1,7 @@
+name: "Flower Hallway"
+panels {
+  name: "LACES"
+  path: "Panels/Gold/demo_47"
+  clue: "laces"
+  answer: "places"
+}
@@ -0,0 +1,241 @@
+name: "Main Area"
+panels {
+  name: "HI"
+  path: "Panels/Entry/demo_1"
+  clue: "hi"
+  answer: "hi"
+}
+panels {
+  name: "ART"
+  path: "Panels/Entry/demo_49"
+  clue: "\"art\""
+  answer: "art"
+}
+panels {
+  name: "TEES"
+  path: "Panels/Entry/demo_50"
+  clue: "tees"
+  answer: "trees"
+}
+panels {
+  name: "COLORFUL"
+  path: "Panels/Room 1/demo_5"
+  clue: "colorful"
+  answer: "colorful"
+}
+panels {
+  name: "WORD"
+  path: "Panels/Room 1/demo_6"
+  clue: "word"
+  answer: "world"
+}
+panels {
+  name: "AGES"
+  path: "Panels/Orange/demo_7"
+  clue: "ages"
+  answer: "messages"
+}
+panels {
+  name: "DEN"
+  path: "Panels/Orange/demo_8"
+  clue: "den"
+  answer: "hidden"
+}
+panels {
+  name: "HID"
+  path: "Panels/Orange/demo_9"
+  clue: "hid"
+  answer: "hidden"
+}
+panels {
+  name: "MESS"
+  path: "Panels/Orange/demo_10"
+  clue: "mess"
+  answer: "messages"
+}
+panels {
+  name: "CLOCKWISE"
+  path: "Panels/Purple/demo_2"
+  clue: "clockwise"
+  answer: "counter"
+}
+panels {
+  name: "POSSIBLE"
+  path: "Panels/Purple/demo_12"
+  clue: "possible"
+  answer: "impossible"
+}
+panels {
+  name: "PACES"
+  path: "Panels/Purple/demo_13"
+  clue: "paces"
+  answer: "spaces"
+}
+panels {
+  name: "COUNTER"
+  path: "Panels/Purple/demo_30"
+  clue: "counter"
+  answer: "clockwise"
+}
+panels {
+  name: "ANY"
+  path: "Panels/Yellow/demo_14"
+  clue: "any"
+  answer: "many"
+}
+panels {
+  name: "RODS"
+  path: "Panels/Yellow/demo_15"
+  clue: "rods"
+  answer: "roads"
+}
+panels {
+  name: "TWO"
+  path: "Panels/Yellow/demo_16"
+  clue: "two"
+  answer: "to"
+}
+panels {
+  name: "TALK"
+  path: "Panels/Yellow/demo_17"
+  clue: "talk"
+  answer: "walk"
+}
+panels {
+  name: "SECRETIVE"
+  path: "Panels/Yellow/demo_18"
+  clue: "secretive"
+  answer: "secret"
+}
+panels {
+  name: "TOADS"
+  path: "Panels/Yellow/demo_19"
+  clue: "toads"
+  answer: "roads"
+}
+panels {
+  name: "TON"
+  path: "Panels/Yellow/demo_20"
+  clue: "ton"
+  answer: "to"
+}
+panels {
+  name: "MIND"
+  path: "Panels/Yellow/demo_21"
+  clue: "mind"
+  answer: "find"
+}
+panels {
+  name: "END"
+  path: "Panels/Yellow/demo_22"
+  clue: "end"
+  answer: "endless"
+}
+panels {
+  name: "RAD"
+  path: "Panels/Yellow/demo_23"
+  clue: "rad"
+  answer: "roads"
+}
+panels {
+  name: "TOO"
+  path: "Panels/Yellow/demo_24"
+  clue: "too"
+  answer: "to"
+}
+panels {
+  name: "STALK"
+  path: "Panels/Yellow/demo_25"
+  clue: "stalk"
+  answer: "walk"
+}
+panels {
+  name: "HAZES"
+  path: "Panels/Green/demo_27"
+  clue: "hazes"
+  answer: "mazes"
+}
+panels {
+  name: "DAZES"
+  path: "Panels/Green/demo_28"
+  clue: "dazes"
+  answer: "mazes"
+}
+panels {
+  name: "GAZES"
+  path: "Panels/Green/demo_29"
+  clue: "gazes"
+  answer: "mazes"
+}
+panels {
+  name: "CASTS"
+  path: "Panels/Green/demo_30"
+  clue: "casts"
+  answer: "castles"
+}
+panels {
+  name: "S"
+  path: "Panels/Blue/demo_31"
+  clue: "s"
+  answer: "s"
+}
+panels {
+  name: "C"
+  path: "Panels/Blue/demo_32"
+  clue: "c"
+  answer: "c"
+}
+panels {
+  name: "A"
+  path: "Panels/Blue/demo_33"
+  clue: "a"
+  answer: "a"
+}
+panels {
+  name: "V"
+  path: "Panels/Blue/demo_34"
+  clue: "v"
+  answer: "v"
+}
+panels {
+  name: "E (1)"
+  path: "Panels/Blue/demo_35"
+  clue: "e"
+  answer: "e"
+}
+panels {
+  name: "N"
+  path: "Panels/Blue/demo_36"
+  clue: "n"
+  answer: "n"
+}
+panels {
+  name: "E (2)"
+  path: "Panels/Blue/demo_38"
+  clue: "e"
+  answer: "e"
+}
+panels {
+  name: "R"
+  path: "Panels/Blue/demo_39"
+  clue: "r"
+  answer: "r"
+}
+panels {
+  name: "Blank"
+  path: "Panels/Blue/demo_40"
+  clue: ""
+  answer: "hunts"
+}
+panels {
+  name: "DISCOVER"
+  path: "Panels/Gold/demo_45"
+  clue: "discover"
+  answer: "rediscover"
+}
+panels {
+  name: "FAMILY"
+  path: "Panels/Gold/demo_46"
+  clue: "family"
+  answer: "familiar"
+}
@@ -0,0 +1,5 @@
+name: "Mastery"
+masteries {
+  name: "MASTERY"
+  path: "Components/Collectables/collectable"
+}
@@ -0,0 +1,7 @@
+name: "Tower"
+panels {
+  name: "ENDS (1)"
+  path: "Panels/Endings/demo_48"
+  clue: "ends"
+  answer: "endings"
+}
@@ -57,6 +57,8 @@ panels {
 }
 ports {
   name: "DAEDALUS"
+  display_name: "Examples Room Worldport"
   path: "Components/Warps/worldport2"
-  orientation: "north"
+  destination { x: 0 y: 0 z: -40.5 }
+  rotation: 180
 }
@@ -57,6 +57,8 @@ panels {
 }
 ports {
   name: "IMPRESSIVE"
+  display_name: "Intensify Room Worldport"
   path: "Components/Warps/worldport"
-  orientation: "south"
+  destination { x: 0 y: 0 z: 6.5 }
+  rotation: 0
 }
@@ -57,6 +57,8 @@ panels {
 }
 ports {
   name: "ENTRY"
+  display_name: "Synonyms Room Worldport"
   path: "Components/Warps/worldport3"
-  orientation: "south"
+  destination { x: 20 y: 0 z: 6.5 }
+  rotation: 0
 }
@@ -57,6 +57,8 @@ panels {
 }
 ports {
   name: "OWL"
+  display_name: "Time Room Worldport"
   path: "Components/Warps/worldport4"
-  orientation: "north"
+  destination { x: 20 y: 0 z: -40.5 }
+  rotation: 180
 }
@@ -0,0 +1,766 @@
+# It is supposed to be in logic to jump from Maze to Maze King Painting, but I
+# find this difficult to do, and unshuffled paintings never requires it, so I am
+# making it not in logic.
+connections {
+  from_room: "Welcome Spine (Obverse)"
+  to_room: "Trans Rights"
+  door { name: "Agender Door" }
+}
+connections {
+  from_room: "Through Woman (Obverse)"
+  to_room: "Welcome Spine (Reverse)"
+  door { name: "Agender Door" }
+  oneway: true
+}
+connections {
+  from_room: "Above Trans Rights"
+  to_room: "Through Woman (Reverse)"
+  door { name: "Agender Door" }
+  oneway: true
+}
+connections {
+  from {
+    painting {
+      room: "Big U"
+      name: "GO3"
+    }
+  }
+  to {
+    painting {
+      room: "Trans Rights"
+      name: "STOP2"
+    }
+  }
+  oneway: true
+}
+connections {
+  from_room: "Spiral Ramp"
+  to_room: "Highest Point"
+  door { name: "Pea Door" }
+}
+connections {
+  from {
+    painting {
+      room: "Fatherland Quicktravel"
+      name: "GO7"
+    }
+  }
+  to {
+    painting {
+      room: "Pillar Ramp"
+      name: "STOP6"
+    }
+  }
+  oneway: true
+}
+connections {
+  from_room: "Maze"
+  to_room: "Mediums Quicktravel"
+  door { name: "Mediums Door" }
+}
+connections {
+  from {
+    painting {
+      room: "Big U"
+      name: "GO1"
+    }
+  }
+  to {
+    painting {
+      room: "Pillar Ramp"
+      name: "STOP10"
+    }
+  }
+  oneway: true
+}
+connections {
+  from_room: "Pillar Ramp"
+  to_room: "Banana Belt Door"
+  door { name: "Asteroid Bunch Door" }
+}
+connections {
+  from_room: "Through Woman (Obverse)"
+  to_room: "Cow Quicktravel"
+  door { name: "Cow Door" }
+}
+connections {
+  from {
+    painting {
+      room: "Welcome Spine Quicktravel"
+      name: "GO5"
+    }
+  }
+  to {
+    painting {
+      room: "Cow Quicktravel"
+      name: "STOP4"
+    }
+  }
+  oneway: true
+}
+connections {
+  from_room: "Through Woman (Obverse)"
+  to_room: "Behind Welcome Spine"
+  door { name: "Ant Door" }
+}
+connections {
+  from_room: "Above Trans Rights"
+  to_room: "Behind Welcome Spine"
+  door { name: "Ant Door" }
+  oneway: true
+}
+connections {
+  from_room: "Through Woman (Obverse)"
+  to_room: "Big U"
+  door { name: "Man Door" }
+}
+connections {
+  from {
+    painting {
+      room: "Trans Rights"
+      name: "GO2"
+    }
+  }
+  to {
+    painting {
+      room: "Big U"
+      name: "STOP1"
+    }
+  }
+  oneway: true
+}
+connections {
+  from {
+    painting {
+      room: "Cow Quicktravel"
+      name: "GO4"
+    }
+  }
+  to {
+    painting {
+      room: "Big U"
+      name: "STOP3"
+    }
+  }
+  oneway: true
+}
+connections {
+  from_room: "Welcome Spine (Obverse)"
+  to_room: "Through Woman (Obverse)"
+  door { name: "Woman Door" }
+}
+connections {
+  from_room: "Fatherland"
+  to_room: "Fatherland Quicktravel"
+  door { name: "Fatherland Door" }
+}
+connections {
+  from {
+    painting {
+      room: "Mini Icarus Sun Loop"
+      name: "GO8"
+    }
+  }
+  to {
+    painting {
+      room: "Fatherland Quicktravel"
+      name: "STOP7"
+    }
+  }
+  oneway: true
+}
+connections {
+  from {
+    painting {
+      room: "Pillar Ramp"
+      name: "GO10"
+    }
+  }
+  to {
+    painting {
+      room: "Mediums Quicktravel"
+      name: "STOP9"
+    }
+  }
+  oneway: true
+}
+connections {
+  from_room: "Mini Icarus Wings Painting"
+  to_room: "Mini Icarus 2"
+  door { name: "Battery Door" }
+  oneway: true
+}
+connections {
+  from_room: "Mini Icarus 2"
+  to_room: "Mini Icarus Sun Loop"
+  door { name: "Battery Door" }
+}
+connections {
+  from {
+    painting {
+      room: "Mediums Quicktravel"
+      name: "GO9"
+    }
+  }
+  to {
+    painting {
+      room: "Mini Icarus Sun Loop"
+      name: "STOP8"
+    }
+  }
+  oneway: true
+}
+connections {
+  from_room: "Mini Icarus 2"
+  to_room: "Mini Icarus 3"
+  door { name: "Animals Door" }
+}
+connections {
+  from_room: "Mini Icarus 2"
+  to_room: "Mini Icarus Wings Painting"
+  door { name: "Troupe Door" }
+}
+connections {
+  from_room: "Mini Icarus 2"
+  to_room: "Mini Icarus Sun Loop"
+  door { name: "Reversed Arrows Door" }
+}
+connections {
+  from_room: "Welcome Spine (Reverse)"
+  to_room: "Welcome Spine Quicktravel"
+  door { name: "Termite Door" }
+}
+connections {
+  from {
+    painting {
+      room: "Pillar Ramp"
+      name: "GO6"
+    }
+  }
+  to {
+    painting {
+      room: "Welcome Spine Quicktravel"
+      name: "STOP5"
+    }
+  }
+  oneway: true
+}
+connections {
+  from {
+    painting {
+      room: "Spiral Ramp"
+      name: "SUN5"
+    }
+  }
+  to {
+    painting {
+      room: "Pillar Ramp"
+      name: "SUN6"
+    }
+  }
+  oneway: true
+}
+connections {
+  from_room: "Pillar Ramp"
+  to_room: "Patricide Room"
+  door { name: "Patricide Door" }
+}
+connections {
+  from_room: "Maze"
+  to_room: "Maze Back"
+  door { name: "These Door" }
+}
+connections {
+  from_room: "Welcome Spine (Reverse)"
+  to_room: "Maze Back"
+  oneway: true
+}
+connections {
+  from_room: "Welcome Spine (Obverse)"
+  to_room: "Through Woman (Reverse)"
+  oneway: true
+}
+connections {
+  from {
+    painting {
+      room: "Through Woman (Obverse)"
+      name: "SUN2"
+    }
+  }
+  to {
+    painting {
+      room: "Above Trans Rights"
+      name: "SUN"
+    }
+  }
+  oneway: true
+}
+connections {
+  from {
+    painting {
+      room: "Maze"
+      name: "WINGS14"
+    }
+  }
+  to {
+    painting {
+      room: "Through Woman (Obverse)"
+      name: "WINGS6"
+    }
+  }
+  oneway: true
+}
+connections {
+  from_room: "Through Woman (Obverse)"
+  to_room: "Behind Welcome Spine"
+  door { name: "Woman Door" }
+  oneway: true
+}
+connections {
+  from {
+    painting {
+      room: "Cow Quicktravel"
+      name: "SUN4"
+    }
+  }
+  to {
+    painting {
+      room: "Highest Point"
+      name: "SUN3"
+    }
+  }
+  oneway: true
+}
+connections {
+  from {
+    painting {
+      room: "Through Woman (Reverse)"
+      name: "WINGS8"
+    }
+  }
+  to {
+    painting {
+      room: "Spiral Ramp"
+      name: "WINGS7"
+    }
+  }
+  oneway: true
+}
+connections {
+  from_room: "Through Woman (Reverse)"
+  to_room: "Big U"
+  oneway: true
+}
+connections {
+  from {
+    painting {
+      room: "Spiral Ramp"
+      name: "WINGS6"
+    }
+  }
+  to {
+    painting {
+      room: "Through Woman (Obverse)"
+      name: "WINGS3"
+    }
+  }
+  # rare two-way painting!
+  bypass_target_door: true
+}
+connections {
+  from_room: "Spiral Ramp"
+  to_room: "Pillar Ramp"
+  oneway: true
+}
+connections {
+  from_room: "Pillar Ramp"
+  to_room: "The Orb"
+}
+connections {
+  from {
+    painting {
+      room: "Banana Belt Door"
+      name: "SUN14"
+    }
+  }
+  to {
+    painting {
+      room: "Above Trans Rights"
+      name: "SUN"
+    }
+  }
+  oneway: true
+}
+connections {
+  from_room: "Trans Rights"
+  to_room: "Mini Icarus Wings Painting"
+  oneway: true
+}
+connections {
+  from {
+    painting {
+      room: "Mini Icarus Wings Painting"
+      name: "WINGS4"
+    }
+  }
+  to {
+    painting {
+      room: "Mini Icarus Sun Loop"
+      name: "TROUBLEDESTINATION"
+    }
+  }
+  oneway: true
+}
+connections {
+  from {
+    painting {
+      room: "Painting Maze 1"
+      name: "SUN9"
+    }
+  }
+  to {
+    painting {
+      room: "Mini Icarus 2"
+      name: "SUN10"
+    }
+  }
+  oneway: true
+}
+connections {
+  from {
+    painting {
+      room: "Mini Icarus 2"
+      name: "SUN11"
+    }
+  }
+  to {
+    painting {
+      room: "Mini Icarus Sun Loop"
+      name: "SUN12"
+    }
+  }
+  oneway: true
+}
+connections {
+  from {
+    painting {
+      room: "Mini Icarus Sun Loop"
+      name: "SUN13"
+    }
+  }
+  to {
+    painting {
+      room: "Maze"
+      name: "SUN14"
+    }
+  }
+  oneway: true
+}
+connections {
+  from_room: "Mini Icarus 3"
+  to_room: "Mini Icarus Sun Loop"
+  door { name: "Battery Door" }
+  oneway: true
+}
+connections {
+  from {
+    painting {
+      room: "Maze"
+      name: "SUN5"
+    }
+  }
+  to {
+    painting {
+      room: "Painting Maze 2"
+      name: "SUN6"
+    }
+  }
+  oneway: true
+}
+connections {
+  from {
+    painting {
+      room: "Maze"
+      name: "WINGS16"
+    }
+  }
+  to {
+    painting {
+      room: "Maze Wings Passage"
+      name: "WINGS12"
+    }
+  }
+  oneway: true
+}
+connections {
+  from {
+    painting {
+      room: "Maze Wings Passage"
+      name: "WINGS12"
+    }
+  }
+  to {
+    painting {
+      room: "Patricide Room"
+      name: "WINGS10"
+    }
+  }
+  oneway: true
+}
+connections {
+  from {
+    painting {
+      room: "Patricide Room"
+      name: "SUN4"
+    }
+  }
+  to {
+    painting {
+      room: "Maze"
+      name: "SUN4"
+    }
+  }
+  oneway: true
+}
+connections {
+  from {
+    painting {
+      room: "Maze"
+      name: "WINGS9"
+    }
+  }
+  to {
+    painting {
+      room: "Patricide Room"
+      name: "WINGS10"
+    }
+  }
+  oneway: true
+}
+connections {
+  from_room: "Maze"
+  to_room: "Maze King Panel"
+  oneway: true
+}
+connections {
+  from_room: "Maze King Painting"
+  to_room: "Maze King Panel"
+  oneway: true
+}
+connections {
+  from {
+    painting {
+      room: "Maze King Painting"
+      name: "WINGS13"
+    }
+  }
+  to {
+    painting {
+      room: "Maze Wings Passage"
+      name: "WINGS12"
+    }
+  }
+  oneway: true
+}
+connections {
+  from {
+    painting {
+      room: "Fatherland"
+      name: "SUN7"
+    }
+  }
+  to {
+    painting {
+      room: "Painting Maze 1"
+      name: "SUN8"
+    }
+  }
+  oneway: true
+}
+connections {
+  from {
+    painting {
+      room: "Painting Maze 2"
+      name: "WINGS11"
+    }
+  }
+  to {
+    painting {
+      room: "Fatherland"
+      name: "WINGS2"
+    }
+  }
+  oneway: true
+}
+connections {
+  from {
+    painting {
+      room: "Painting Maze 1"
+      name: "WINGS3"
+    }
+  }
+  to {
+    painting {
+      room: "Maze Wings Passage"
+      name: "WINGS12"
+    }
+  }
+  oneway: true
+}
+connections {
+  from_room: "Trans Rights"
+  to_room: "Trans Rights Panels"
+  oneway: true
+}
+connections {
+  from_room: "Above Trans Rights"
+  to_room: "Trans Rights Panels"
+  oneway: true
+}
+connections {
+  from_room: "Welcome Spine (Obverse)"
+  to_room: "Mastery"
+  door { name: "Mastery" }
+}
+# It is possible to fall out of the map from every room, which always sends you
+# back to the beginning.
+connections {
+  from_room: "Above Trans Rights"
+  to_room: "Welcome Spine (Obverse)"
+  oneway: true
+}
+connections {
+  from_room: "Banana Belt Door"
+  to_room: "Welcome Spine (Obverse)"
+  oneway: true
+}
+connections {
+  from_room: "Behind Welcome Spine"
+  to_room: "Welcome Spine (Obverse)"
+  oneway: true
+}
+connections {
+  from_room: "Big U"
+  to_room: "Welcome Spine (Obverse)"
+  oneway: true
+}
+connections {
+  from_room: "Cow Quicktravel"
+  to_room: "Welcome Spine (Obverse)"
+  oneway: true
+}
+connections {
+  from_room: "Fatherland Quicktravel"
+  to_room: "Welcome Spine (Obverse)"
+  oneway: true
+}
+connections {
+  from_room: "Fatherland"
+  to_room: "Welcome Spine (Obverse)"
+  oneway: true
+}
+connections {
+  from_room: "Highest Point"
+  to_room: "Welcome Spine (Obverse)"
+  oneway: true
+}
+connections {
+  from_room: "Maze Back"
+  to_room: "Welcome Spine (Obverse)"
+  oneway: true
+}
+connections {
+  from_room: "Maze King Painting"
+  to_room: "Welcome Spine (Obverse)"
+  oneway: true
+}
+connections {
+  from_room: "Maze Wings Passage"
+  to_room: "Welcome Spine (Obverse)"
+  oneway: true
+}
+connections {
+  from_room: "Maze"
+  to_room: "Welcome Spine (Obverse)"
+  oneway: true
+}
+connections {
+  from_room: "Mediums Quicktravel"
+  to_room: "Welcome Spine (Obverse)"
+  oneway: true
+}
+connections {
+  from_room: "Mini Icarus 2"
+  to_room: "Welcome Spine (Obverse)"
+  oneway: true
+}
+connections {
+  from_room: "Mini Icarus 3"
+  to_room: "Welcome Spine (Obverse)"
+  oneway: true
+}
+connections {
+  from_room: "Mini Icarus Sun Loop"
+  to_room: "Welcome Spine (Obverse)"
+  oneway: true
+}
+connections {
+  from_room: "Mini Icarus Wings Painting"
+  to_room: "Welcome Spine (Obverse)"
+  oneway: true
+}
+connections {
+  from_room: "Painting Maze 1"
+  to_room: "Welcome Spine (Obverse)"
+  oneway: true
+}
+connections {
+  from_room: "Painting Maze 2"
+  to_room: "Welcome Spine (Obverse)"
+  oneway: true
+}
+connections {
+  from_room: "Patricide Room"
+  to_room: "Welcome Spine (Obverse)"
+  oneway: true
+}
+connections {
+  from_room: "Pillar Ramp"
+  to_room: "Welcome Spine (Obverse)"
+  oneway: true
+}
+connections {
+  from_room: "Spiral Ramp"
+  to_room: "Welcome Spine (Obverse)"
+  oneway: true
+}
+connections {
+  from_room: "The Orb"
+  to_room: "Welcome Spine (Obverse)"
+  oneway: true
+}
+connections {
+  from_room: "Through Woman (Obverse)"
+  to_room: "Welcome Spine (Obverse)"
+  oneway: true
+}
+connections {
+  from_room: "Through Woman (Reverse)"
+  to_room: "Welcome Spine (Obverse)"
+  oneway: true
+}
+connections {
+  from_room: "Trans Rights"
+  to_room: "Welcome Spine (Obverse)"
+  oneway: true
+}
+connections {
+  from_room: "Welcome Spine (Reverse)"
+  to_room: "Welcome Spine (Obverse)"
+  oneway: true
+}
+connections {
+  from_room: "Welcome Spine Quicktravel"
+  to_room: "Welcome Spine (Obverse)"
+  oneway: true
+}
@@ -0,0 +1,286 @@
+doors {
+  name: "Agender Door"
+  type: STANDARD
+  receivers: "Components/Doors/quicktravel3"
+  panels { room: "Trans Rights Panels" name: "AGENDER" }
+  location_room: "Trans Rights Panels"
+}
+doors {
+  name: "Quick Travel 3"
+  type: ITEM_ONLY
+  receivers: "Components/Paintings/QuickTravel/go3"
+  panels { room: "Trans Rights Panels" name: "AGENDER" }
+}
+doors {
+  name: "Pea Door"
+  type: STANDARD
+  receivers: "Components/Doors/quicktravel5"
+  panels { room: "Pillar Ramp" name: "PEA (1)" }
+  location_room: "Pillar Ramp"
+}
+doors {
+  name: "Quick Travel 7"
+  type: ITEM_ONLY
+  receivers: "Components/Paintings/QuickTravel/go7"
+  panels { room: "Pillar Ramp" name: "PEA (1)" }
+}
+doors {
+  name: "Mediums Door"
+  type: STANDARD
+  receivers: "Components/Doors/quicktravel12"
+  panels { room: "Maze" name: "MEDIUMS" }
+  location_room: "Maze"
+}
+doors {
+  name: "Quick Travel 1"
+  type: ITEM_ONLY
+  receivers: "Components/Paintings/QuickTravel/go1"
+  panels { room: "Maze" name: "MEDIUMS" }
+}
+doors {
+  name: "Asteroid Bunch Door"
+  type: STANDARD
+  receivers: "Components/Doors/quicktravel13"
+  panels { room: "Pillar Ramp" name: "ASTEROID" }
+  panels { room: "Pillar Ramp" name: "BUNCH" }
+  location_room: "Pillar Ramp"
+}
+doors {
+  name: "Cow Door"
+  type: STANDARD
+  receivers: "Components/Doors/quicktravel2"
+  panels { room: "Through Woman (Obverse)" name: "COW" }
+  location_room: "Through Woman (Obverse)"
+}
+doors {
+  name: "Quick Travel 5"
+  type: STANDARD
+  receivers: "Components/Paintings/QuickTravel/go5"
+  panels { room: "Highest Point" name: "QUEEN" }
+  location_room: "Highest Point"
+}
+doors {
+  name: "Ant Door"
+  type: STANDARD
+  receivers: "Components/Doors/by sun"
+  panels { room: "Above Trans Rights" name: "ANT" }
+  location_room: "Above Trans Rights"
+}
+doors {
+  name: "Man Door"
+  type: STANDARD
+  receivers: "Components/Doors/quicktravel"
+  panels { room: "Through Woman (Obverse)" name: "HUMAN (2)" }
+  location_room: "Through Woman (Obverse)"
+}
+doors {
+  name: "Quick Travel 2"
+  type: ITEM_ONLY
+  receivers: "Components/Paintings/QuickTravel/go2"
+  panels { room: "Through Woman (Obverse)" name: "HUMAN (2)" }
+}
+doors {
+  name: "Quick Travel 4"
+  type: STANDARD
+  receivers: "Components/Paintings/QuickTravel/go4"
+  panels { room: "Big U" name: "COLONY" }
+  location_room: "Big U"
+}
+doors {
+  name: "Woman Door"
+  type: STANDARD
+  receivers: "Components/Doors/entry"
+  panels { room: "Welcome Spine (Obverse)" name: "HUMAN (1)" }
+  location_room: "Welcome Spine (Obverse)"
+}
+doors {
+  name: "Fatherland Door"
+  type: STANDARD
+  receivers: "Components/Doors/quicktravel6"
+  panels { room: "Fatherland" name: "FATHERLAND" }
+  location_room: "Fatherland"
+}
+doors {
+  name: "Quick Travel 8"
+  type: ITEM_ONLY
+  receivers: "Components/Paintings/QuickTravel/go8"
+  panels { room: "Fatherland" name: "FATHERLAND" }
+}
+doors {
+  name: "Quick Travel 10"
+  type: ITEM_ONLY
+  receivers: "Components/Paintings/QuickTravel/go10"
+  panels { room: "Fatherland" name: "FATHERLAND" }
+}
+doors {
+  name: "Battery Door"
+  type: STANDARD
+  receivers: "Components/Doors/quicktravel7"
+  panels { room: "Mini Icarus 2" name: "BATTERY" }
+  location_room: "Mini Icarus 2"
+}
+doors {
+  name: "Quick Travel 9"
+  type: ITEM_ONLY
+  receivers: "Components/Paintings/QuickTravel/go9"
+  panels { room: "Mini Icarus 2" name: "BATTERY" }
+}
+doors {
+  name: "Arrows Door"
+  type: LOCATION_ONLY
+  #receivers: "Components/Doors/quicktravel8"
+  panels { room: "Mini Icarus 2" name: "ARROWS" }
+  location_room: "Mini Icarus 2"
+  location_name: "ARROWS"
+}
+doors {
+  name: "Animals Door"
+  type: STANDARD
+  receivers: "Components/Doors/quicktravel8"
+  panels { room: "Mini Icarus 2" name: "ANIMALS" }
+  location_room: "Mini Icarus 2"
+}
+doors {
+  name: "Troupe Door"
+  type: STANDARD
+  receivers: "Components/Doors/quicktravel10"
+  panels { room: "Mini Icarus 2" name: "TROUPE" }
+  location_room: "Mini Icarus 2"
+}
+doors {
+  name: "Reversed Arrows Door"
+  type: STANDARD
+  receivers: "Components/Doors/quicktravel11"
+  panels { room: "Mini Icarus 2" name: "SQUAD" }
+  location_room: "Mini Icarus 2"
+}
+doors {
+  name: "Termite Door"
+  type: STANDARD
+  receivers: "Components/Doors/quicktravel4"
+  panels { room: "Welcome Spine (Reverse)" name: "TERMITE" }
+  location_room: "Welcome Spine (Reverse)"
+}
+doors {
+  name: "Quick Travel 6"
+  type: ITEM_ONLY
+  receivers: "Components/Paintings/QuickTravel/go6"
+  panels { room: "Welcome Spine (Reverse)" name: "TERMITE" }
+}
+doors {
+  name: "Murder Panels"
+  type: LOCATION_ONLY
+  panels { room: "Maze" name: "MANSLAUGHTER" }
+  panels { room: "Pillar Ramp" name: "PATRICIDE" }
+  location_room: "Maze"
+}
+doors {
+  name: "Sun Painting To Drone"
+  type: STANDARD
+  receivers: "Components/Paintings/sun5"
+  panels { room: "Pillar Ramp" name: "DRONE" }
+  location_room: "Pillar Ramp"
+}
+doors {
+  name: "Patricide Door"
+  type: STANDARD
+  receivers: "Components/Doors/quicktravel15"
+  panels { room: "Pillar Ramp" name: "PATRICIDE" }
+  location_room: "Pillar Ramp"
+}
+doors {
+  name: "These Door"
+  type: STANDARD
+  receivers: "Components/Doors/quicktravel14"
+  panels { room: "Maze Back" name: "THESE" }
+  location_room: "Maze Back"
+}
+doors {
+  name: "Orb Panels"
+  type: LOCATION_ONLY
+  panels { room: "The Orb" name: "ADDERS" }
+  panels { room: "The Orb" name: "PUPPY" }
+  panels { room: "The Orb" name: "NEEDLE" }
+  panels { room: "The Orb" name: "US" }
+  panels { room: "The Orb" name: "FISH" }
+  panels { room: "The Orb" name: "DEADLINE" }
+  panels { room: "The Orb" name: "PEA (2)" }
+  panels { room: "The Orb" name: "THESIS" }
+  panels { room: "The Orb" name: "CLUTCH (1)" }
+  panels { room: "The Orb" name: "BASIS (2)" }
+  panels { room: "The Orb" name: "AXIS" }
+  panels { room: "The Orb" name: "STRAIGHT" }
+  panels { room: "The Orb" name: "HISS" }
+  panels { room: "The Orb" name: "DISCUS" }
+  panels { room: "The Orb" name: "SON" }
+  panels { room: "The Orb" name: "CLUTCH (2)" }
+  location_room: "The Orb"
+}
+doors {
+  name: "Near Fireman Wings Painting"
+  type: STANDARD
+  receivers: "Components/Paintings/oneways/wings6"
+  receivers: "Components/Paintings/oneways/wings3"
+  panels { room: "Spiral Ramp" name: "FIREMAN" }
+  location_room: "Spiral Ramp"
+}
+doors {
+  name: "Mastery"
+  type: EVENT
+  panels { room: "Above Trans Rights" name: "ANT" }
+  panels { room: "Big U" name: "DECK" }
+  panels { room: "Big U" name: "COLONY" }
+  panels { room: "Big U" name: "MANOR" }
+  panels { room: "Fatherland" name: "FATHERLAND" }
+  panels { room: "Highest Point" name: "DIAGNOSIS" }
+  panels { room: "Highest Point" name: "QUEEN" }
+  panels { room: "Maze Back" name: "THESE" }
+  panels { room: "Maze King Panel" name: "KING (2)" }
+  panels { room: "Maze" name: "KING (1)" }
+  panels { room: "Maze" name: "ANALYSIS" }
+  panels { room: "Maze" name: "MANSLAUGHTER" }
+  panels { room: "Maze" name: "MEDIUMS" }
+  panels { room: "Maze" name: "BOOKS" }
+  panels { room: "Mini Icarus 2" name: "BATTERY" }
+  panels { room: "Mini Icarus 2" name: "TROUPE" }
+  panels { room: "Mini Icarus 2" name: "ANIMALS" }
+  panels { room: "Mini Icarus 2" name: "ARROWS" }
+  panels { room: "Mini Icarus 2" name: "SQUAD" }
+  panels { room: "Pillar Ramp" name: "ASTEROID" }
+  panels { room: "Pillar Ramp" name: "BUNCH" }
+  panels { room: "Pillar Ramp" name: "PRINCES" }
+  panels { room: "Pillar Ramp" name: "PATRICIDE" }
+  panels { room: "Pillar Ramp" name: "DRONE" }
+  panels { room: "Pillar Ramp" name: "PEA (1)" }
+  panels { room: "Spiral Ramp" name: "FIREMAN" }
+  panels { room: "The Orb" name: "ADDERS" }
+  panels { room: "The Orb" name: "PUPPY" }
+  panels { room: "The Orb" name: "NEEDLE" }
+  panels { room: "The Orb" name: "US" }
+  panels { room: "The Orb" name: "FISH" }
+  panels { room: "The Orb" name: "DEADLINE" }
+  panels { room: "The Orb" name: "PEA (2)" }
+  panels { room: "The Orb" name: "THESIS" }
+  panels { room: "The Orb" name: "CLUTCH (1)" }
+  panels { room: "The Orb" name: "BASIS (2)" }
+  panels { room: "The Orb" name: "AXIS" }
+  panels { room: "The Orb" name: "STRAIGHT" }
+  panels { room: "The Orb" name: "HISS" }
+  panels { room: "The Orb" name: "DISCUS" }
+  panels { room: "The Orb" name: "SON" }
+  panels { room: "The Orb" name: "CLUTCH (2)" }
+  panels { room: "Through Woman (Obverse)" name: "HUMAN (2)" }
+  panels { room: "Through Woman (Obverse)" name: "COW" }
+  panels { room: "Through Woman (Reverse)" name: "PRINCE" }
+  panels { room: "Through Woman (Reverse)" name: "BASIS (1)" }
+  panels { room: "Trans Rights" name: "SERVANT (1)" }
+  panels { room: "Trans Rights" name: "SERVANT (2)" }
+  panels { room: "Trans Rights Panels" name: "AGENDER" }
+  panels { room: "Trans Rights Panels" name: "HUMAN (3)" }
+  panels { room: "Trans Rights Panels" name: "HUMAN (4)" }
+  panels { room: "Welcome Spine (Obverse)" name: "FISHWIFE" }
+  panels { room: "Welcome Spine (Obverse)" name: "HUMAN (1)" }
+  panels { room: "Welcome Spine (Reverse)" name: "FATHER" }
+  panels { room: "Welcome Spine (Reverse)" name: "TERMITE" }
+  panels { room: "Welcome Spine (Reverse)" name: "SISTER" }
+}
@@ -0,0 +1,4 @@
+display_name: "Icarus"
+type: ICARUS
+# The map's mastery is created at runtime.
+custom_nodes: "Components/Collectables/collectable"
@@ -0,0 +1,12 @@
+name: "Above Trans Rights"
+panels {
+  name: "ANT"
+  path: "Panels/Room_1/ant"
+  clue: "ant"
+  answer: "colony"
+  symbols: PLANET
+}
+paintings {
+  name: "SUN"
+  path: "Components/Paintings/sun"
+}
@@ -0,0 +1,5 @@
+name: "Banana Belt Door"
+paintings {
+  name: "SUN14"
+  path: "Components/Paintings/sun14"
+}
@@ -0,0 +1 @@
+name: "Behind Welcome Spine"
@@ -0,0 +1,40 @@
+name: "Big U"
+panels {
+  name: "DECK"
+  path: "Panels/Room_1/deck"
+  clue: "deck"
+  answer: "card"
+  symbols: PLANET
+}
+panels {
+  name: "COLONY"
+  path: "Panels/Room_1/ant2"
+  clue: "colony"
+  answer: "ant"
+  symbols: PLANET
+}
+panels {
+  name: "MANOR"
+  path: "Panels/Room_1/manor"
+  clue: "manor"
+  answer: "mentor"
+  symbols: SPARKLES
+  symbols: PLANET
+}
+paintings {
+  name: "STOP3"
+  path: "Components/Paintings/QuickTravel/stop3"
+}
+paintings {
+  name: "GO3"
+  path: "Components/Paintings/QuickTravel/go3"
+  required_door { name: "Quick Travel 3" }
+}
+paintings {
+  name: "STOP1"
+  path: "Components/Paintings/QuickTravel/stop1"
+}
+paintings {
+  name: "GO1"
+  path: "Components/Paintings/QuickTravel/go1"
+}
@@ -0,0 +1,14 @@
+name: "Cow Quicktravel"
+paintings {
+  name: "SUN4"
+  path: "Components/Paintings/sun4"
+}
+paintings {
+  name: "GO4"
+  path: "Components/Paintings/QuickTravel/go4"
+  required_door { name: "Quick Travel 4" }
+}
+paintings {
+  name: "STOP4"
+  path: "Components/Paintings/QuickTravel/stop4"
+}
@@ -0,0 +1,10 @@
+name: "Fatherland Quicktravel"
+paintings {
+  name: "STOP7"
+  path: "Components/Paintings/QuickTravel/stop7"
+}
+paintings {
+  name: "GO7"
+  path: "Components/Paintings/QuickTravel/go7"
+  required_door { name: "Quick Travel 7" }
+}
@@ -0,0 +1,16 @@
+name: "Fatherland"
+panels {
+  name: "FATHERLAND"
+  path: "Panels/Room_1/fatherland"
+  clue: "fatherland"
+  answer: "homeland"
+  symbols: GENDER
+}
+paintings {
+  name: "SUN7"
+  path: "Components/Paintings/sun7"
+}
+paintings {
+  name: "WINGS2"
+  path: "Components/Paintings/wings2"
+}
@@ -0,0 +1,19 @@
+name: "Highest Point"
+panels {
+  name: "DIAGNOSIS"
+  path: "Panels/Room_1/diagnosis"
+  clue: "diagnosis"
+  answer: "diagnose"
+  symbols: PLANET
+}
+panels {
+  name: "QUEEN"
+  path: "Panels/Room_1/queen"
+  clue: "queen"
+  answer: "ant"
+  symbols: GENDER
+}
+paintings {
+  name: "SUN3"
+  path: "Components/Paintings/sun3"
+}
@@ -0,0 +1,5 @@
+name: "Mastery"
+masteries {
+  name: "MASTERY"
+  path: "Components/Collectables/collectable"
+}
@@ -0,0 +1,8 @@
+name: "Maze Back"
+panels {
+  name: "THESE"
+  path: "Panels/30DegreePanels/thesis"
+  clue: "these"
+  answer: "thesis"
+  symbols: PLANET
+}
@@ -0,0 +1,8 @@
+name: "Maze King Painting"
+paintings {
+  name: "WINGS13"
+  path: "Components/Paintings/30 degrees/wings13"
+  # There's no other entrance to this region (or any entrance at all in vanilla)
+  # so we can't allow this painting to be an entrance.
+  exit_only: true
+}
@@ -0,0 +1,8 @@
+name: "Maze King Panel"
+panels {
+  name: "KING (2)"
+  path: "Panels/Other30degree panels/king2"
+  clue: "king"
+  answer: "royal"
+  symbols: GENDER
+}
@@ -0,0 +1,9 @@
+name: "Maze Wings Passage"
+paintings {
+  name: "WINGS12"
+  path: "Components/Paintings/30 degrees/wings12"
+}
+paintings {
+  name: "WINGS15"
+  path: "Components/Paintings/30 degrees/wings15"
+}
@@ -0,0 +1,60 @@
+name: "Maze"
+panels {
+  name: "KING (1)"
+  path: "Panels/Other30degree panels/king"
+  clue: "king"
+  answer: "ruler"
+  symbols: GENDER
+}
+panels {
+  name: "ANALYSIS"
+  path: "Panels/Room_1/princes2"
+  clue: "analysis"
+  answer: "analyse"
+  symbols: PLANET
+}
+panels {
+  name: "MANSLAUGHTER"
+  path: "Panels/Room_1/manslaughter"
+  clue: "manslaughter"
+  answer: "murder"
+  symbols: GENDER
+}
+panels {
+  name: "MEDIUMS"
+  path: "Panels/Room_1/mediums"
+  clue: "mediums"
+  answer: "media"
+  symbols: PLANET
+}
+panels {
+  name: "BOOKS"
+  path: "Panels/Other30degree panels/books"
+  clue: "books"
+  answer: "library"
+  symbols: PLANET
+}
+paintings {
+  name: "SUN14"
+  path: "Components/Paintings/30 degrees/sun14"
+}
+paintings {
+  name: "WINGS14"
+  path: "Components/Paintings/30 degrees/wings14"
+}
+paintings {
+  name: "SUN5"
+  path: "Components/Paintings/30 degrees/sun5"
+}
+paintings {
+  name: "WINGS9"
+  path: "Components/Paintings/30 degrees/wings9"
+}
+paintings {
+  name: "SUN4"
+  path: "Components/Paintings/30 degrees/sun4"
+}
+paintings {
+  name: "WINGS16"
+  path: "Components/Paintings/30 degrees/wings16"
+}
@@ -0,0 +1,10 @@
+name: "Mediums Quicktravel"
+paintings {
+  name: "STOP9"
+  path: "Components/Paintings/QuickTravel/stop9"
+}
+paintings {
+  name: "GO9"
+  path: "Components/Paintings/QuickTravel/go9"
+  required_door { name: "Quick Travel 9" }
+}
@@ -0,0 +1,45 @@
+name: "Mini Icarus 2"
+panels {
+  name: "BATTERY"
+  path: "Panels/Room_1/battery"
+  clue: "battery"
+  answer: "cell"
+  symbols: PLANET
+}
+panels {
+  name: "TROUPE"
+  path: "Panels/Room_1/troupe"
+  clue: "troupe"
+  answer: "actor"
+  symbols: PLANET
+}
+panels {
+  name: "ANIMALS"
+  path: "Panels/Room_1/animals"
+  clue: "animals"
+  answer: "zoo"
+  symbols: PLANET
+  # Intended to be solved upside down.
+}
+panels {
+  name: "ARROWS"
+  path: "Panels/Room_1/arrow"
+  clue: "arrows"
+  answer: "quiver"
+  symbols: PLANET
+}
+panels {
+  name: "SQUAD"
+  path: "Panels/Room_1/ammo"
+  clue: "squad"
+  answer: "soldier"
+  symbols: PLANET
+}
+paintings {
+  name: "SUN10"
+  path: "Components/Paintings/sun10"
+}
+paintings {
+  name: "SUN11"
+  path: "Components/Paintings/sun11"
+}
@@ -0,0 +1 @@
+name: "Mini Icarus 3"
@@ -0,0 +1,22 @@
+name: "Mini Icarus Sun Loop"
+paintings {
+  name: "GO8"
+  path: "Components/Paintings/QuickTravel/go8"
+  required_door { name: "Quick Travel 8" }
+}
+paintings {
+  name: "STOP8"
+  path: "Components/Paintings/QuickTravel/stop8"
+}
+paintings {
+  name: "TROUBLEDESTINATION"
+  path: "Components/Paintings/TroubleDestination"
+}
+paintings {
+  name: "SUN12"
+  path: "Components/Paintings/sun12"
+}
+paintings {
+  name: "SUN13"
+  path: "Components/Paintings/sun13"
+}
@@ -0,0 +1,5 @@
+name: "Mini Icarus Wings Painting"
+paintings {
+  name: "WINGS4"
+  path: "Components/Paintings/wings4"
+}
@@ -0,0 +1,13 @@
+name: "Painting Maze 1"
+paintings {
+  name: "SUN9"
+  path: "Components/Paintings/sun9"
+}
+paintings {
+  name: "WINGS3"
+  path: "Components/Paintings/wings3"
+}
+paintings {
+  name: "SUN8"
+  path: "Components/Paintings/sun8"
+}
@@ -0,0 +1,13 @@
+name: "Painting Maze 2"
+paintings {
+  name: "WINGS10"
+  path: "Components/Paintings/30 degrees/wings10"
+}
+paintings {
+  name: "WINGS11"
+  path: "Components/Paintings/30 degrees/wings11"
+}
+paintings {
+  name: "SUN6"
+  path: "Components/Paintings/30 degrees/sun6"
+}
@@ -0,0 +1,9 @@
+name: "Patricide Room"
+paintings {
+  name: "WINGS10"
+  path: "Components/Paintings/other 30 degrees/wings10"
+}
+paintings {
+  name: "SUN4"
+  path: "Components/Paintings/other 30 degrees/sun4"
+}
@@ -0,0 +1,65 @@
+name: "Pillar Ramp"
+panels {
+  name: "ASTEROID"
+  path: "Panels/Room_1/asteroid"
+  clue: "asteroid"
+  answer: "belt"
+  symbols: PLANET
+}
+panels {
+  name: "BUNCH"
+  path: "Panels/Room_1/bunch"
+  clue: "bunch"
+  answer: "banana"
+  symbols: PLANET
+}
+panels {
+  name: "PRINCES"
+  path: "Panels/Room_1/princes"
+  clue: "princes"
+  answer: "princess"
+  symbols: PLANET
+}
+panels {
+  name: "PATRICIDE"
+  path: "Panels/Room_1/patricide"
+  clue: "patricide"
+  answer: "murder"
+  symbols: GENDER
+}
+panels {
+  name: "DRONE"
+  path: "Panels/Room_1/ant3"
+  clue: "drone"
+  answer: "ant"
+  symbols: GENDER
+}
+panels {
+  name: "PEA (1)"
+  path: "Panels/Room_1/pea"
+  clue: "pea"
+  answer: "pod"
+  symbols: PLANET
+}
+paintings {
+  name: "SUN6"
+  path: "Components/Paintings/sun6"
+}
+paintings {
+  name: "GO10"
+  path: "Components/Paintings/QuickTravel/go10"
+  required_door { name: "Quick Travel 10" }
+}
+paintings {
+  name: "STOP10"
+  path: "Components/Paintings/QuickTravel/stop10"
+}
+paintings {
+  name: "GO6"
+  path: "Components/Paintings/QuickTravel/go6"
+  required_door { name: "Quick Travel 6" }
+}
+paintings {
+  name: "STOP6"
+  path: "Components/Paintings/QuickTravel/stop6"
+}
@@ -0,0 +1,29 @@
+name: "Spiral Ramp"
+panels {
+  name: "FIREMAN"
+  path: "Panels/Room_1/fireman"
+  clue: "fireman"
+  answer: "firefighter"
+  symbols: GENDER
+}
+paintings {
+  name: "WINGS6"
+  path: "Components/Paintings/oneways/wings6"
+  required_door { name: "Near Fireman Wings Painting" }
+}
+paintings {
+  name: "SUN5"
+  path: "Components/Paintings/sun5"
+  required_door { name: "Sun Painting To Drone" }
+}
+paintings {
+  name: "WINGS7"
+  path: "Components/Paintings/oneways/wings7"
+}
+paintings {
+  name: "WINGS11"
+  path: "Components/Paintings/other 30 degrees/wings11"
+  exit_only: true
+  # There is a ledge near the painting so we might want to turn off exit_only
+  # at some point.
+}
@@ -0,0 +1,117 @@
+name: "The Orb"
+panels {
+  name: "ADDERS"
+  path: "Panels/Room_1/needle2"
+  clue: "adders"
+  answer: "sum"
+  symbols: PLANET
+}
+panels {
+  name: "PUPPY"
+  path: "Panels/Room_1/puppy"
+  clue: "puppy"
+  answer: "garbage"
+  symbols: SUN
+  symbols: PLANET
+}
+panels {
+  name: "NEEDLE"
+  path: "Panels/Room_1/needle"
+  clue: "needle"
+  answer: "needless"
+  symbols: PLANET
+}
+panels {
+  name: "US"
+  path: "Panels/Room_1/us"
+  clue: "us"
+  answer: "mess"
+  symbols: PLANET
+}
+panels {
+  name: "FISH"
+  path: "Panels/Room_1/fish"
+  clue: "fish"
+  answer: "student"
+  symbols: BOXES
+  symbols: PLANET
+}
+panels {
+  name: "DEADLINE"
+  path: "Panels/Room_1/deadline"
+  clue: "deadline"
+  answer: "deadliness"
+  symbols: PLANET
+}
+panels {
+  name: "PEA (2)"
+  path: "Panels/Room_1/pea2"
+  clue: "pea"
+  answer: "dolphin"
+  symbols: PLANET
+}
+panels {
+  name: "THESIS"
+  path: "Panels/Room_1/thesis"
+  clue: "thesis"
+  answer: "these"
+  symbols: PLANET
+}
+panels {
+  name: "CLUTCH (1)"
+  path: "Panels/Room_1/clutch"
+  clue: "clutch"
+  answer: "dude"
+  symbols: PLANET
+  symbols: GENDER
+}
+panels {
+  name: "BASIS (2)"
+  path: "Panels/Room_1/basis2"
+  clue: "basis"
+  answer: "base"
+  symbols: PLANET
+}
+panels {
+  name: "AXIS"
+  path: "Panels/Room_1/axis"
+  clue: "axis"
+  answer: "Axe"
+  symbols: PLANET
+}
+panels {
+  name: "STRAIGHT"
+  path: "Panels/Room_1/straight"
+  clue: "straight"
+  answer: "queer"
+  symbols: GENDER
+}
+panels {
+  name: "HISS"
+  path: "Panels/Room_1/hiss"
+  clue: "hiss"
+  answer: "their"
+  symbols: PLANET
+  symbols: GENDER
+}
+panels {
+  name: "DISCUS"
+  path: "Panels/Room_1/discus"
+  clue: "discus"
+  answer: "discuss"
+  symbols: PLANET
+}
+panels {
+  name: "SON"
+  path: "Panels/Room_1/son"
+  clue: "son"
+  answer: "child"
+  symbols: GENDER
+}
+panels {
+  name: "CLUTCH (2)"
+  path: "Panels/Room_1/clutch2"
+  clue: "clutch"
+  answer: "chick"
+  symbols: PLANET
+}
@@ -0,0 +1,28 @@
+name: "Through Woman (Obverse)"
+panels {
+  name: "HUMAN (2)"
+  path: "Panels/Room_1/human"
+  clue: "human"
+  answer: "man"
+  symbols: GENDER
+}
+panels {
+  name: "COW"
+  path: "Panels/Room_1/cow"
+  clue: "cow"
+  answer: "elephant"
+  symbols: GENDER
+}
+paintings {
+  name: "SUN2"
+  path: "Components/Paintings/sun2"
+}
+paintings {
+  name: "WINGS6"
+  path: "Components/Paintings/wings6"
+}
+paintings {
+  name: "WINGS3"
+  path: "Components/Paintings/oneways/wings3"
+  required_door { name: "Near Fireman Wings Painting" }
+}
@@ -0,0 +1,19 @@
+name: "Through Woman (Reverse)"
+panels {
+  name: "PRINCE"
+  path: "Panels/Room_1/prince"
+  clue: "prince"
+  answer: "princess"
+  symbols: GENDER
+}
+panels {
+  name: "BASIS (1)"
+  path: "Panels/Room_1/basis"
+  clue: "basis"
+  answer: "bases"
+  symbols: PLANET
+}
+paintings {
+  name: "WINGS8"
+  path: "Components/Paintings/oneways/wings8"
+}
@@ -0,0 +1,22 @@
+name: "Trans Rights Panels"
+panels {
+  name: "AGENDER"
+  path: "Panels/Room_1/human4"
+  clue: "agender"
+  answer: "human"
+  symbols: GENDER
+}
+panels {
+  name: "HUMAN (3)"
+  path: "Panels/Room_1/human5"
+  clue: "human"
+  answer: "female"
+  symbols: GENDER
+}
+panels {
+  name: "HUMAN (4)"
+  path: "Panels/Room_1/human6"
+  clue: "human"
+  answer: "male"
+  symbols: GENDER
+}
@@ -0,0 +1,25 @@
+name: "Trans Rights"
+# slay
+panels {
+  name: "SERVANT (1)"
+  path: "Panels/Room_1/servant"
+  clue: "servant"
+  answer: "butler"
+  symbols: GENDER
+}
+panels {
+  name: "SERVANT (2)"
+  path: "Panels/Room_1/servant2"
+  clue: "servant"
+  answer: "maid"
+  symbols: GENDER
+}
+paintings {
+  name: "GO2"
+  path: "Components/Paintings/QuickTravel/go2"
+  required_door { name: "Quick Travel 2" }
+}
+paintings {
+  name: "STOP2"
+  path: "Components/Paintings/QuickTravel/stop2"
+}
@@ -0,0 +1,22 @@
+name: "Welcome Spine (Obverse)"
+panels {
+  name: "FISHWIFE"
+  path: "Panels/Room_1/fishwife"
+  clue: "fishwife"
+  answer: "fishmonger"
+  symbols: GENDER
+}
+panels {
+  name: "HUMAN (1)"
+  path: "Panels/Room_1/human3"
+  clue: "human"
+  answer: "woman"
+  symbols: GENDER
+}
+ports {
+  name: "WORLDPORT"
+  display_name: "Entrance"
+  path: "Components/Signs/worldport"
+  destination { x: 55 y: -3.5 z: 7.75 }
+  rotation: 0
+}
@@ -0,0 +1,22 @@
+name: "Welcome Spine (Reverse)"
+panels {
+  name: "FATHER"
+  path: "Panels/Room_1/father"
+  clue: "father"
+  answer: "parent"
+  symbols: GENDER
+}
+panels {
+  name: "TERMITE"
+  path: "Panels/Room_1/bat"
+  clue: "termite"
+  answer: "colony"
+  symbols: PLANET
+}
+panels {
+  name: "SISTER"
+  path: "Panels/Room_1/sister"
+  clue: "sister"
+  answer: "sibling"
+  symbols: GENDER
+}
@@ -0,0 +1,10 @@
+name: "Welcome Spine Quicktravel"
+paintings {
+  name: "STOP5"
+  path: "Components/Paintings/QuickTravel/stop5"
+}
+paintings {
+  name: "GO5"
+  path: "Components/Paintings/QuickTravel/go5"
+  required_door { name: "Quick Travel 5" }
+}
@@ -0,0 +1,10 @@
+connections {
+  from_room: "Main Area"
+  to_room: "CBA"
+  door { name: "CBA Door" }
+}
+connections {
+  from_room: "CBA"
+  to_room: "Mastery"
+  door { name: "Mastery" }
+}
@@ -0,0 +1,50 @@
+doors {
+  name: "Side Room Puzzles"
+  type: LOCATION_ONLY
+  panels { room: "Main Area" name: "Blank (1)" }
+  panels { room: "Main Area" name: "Blank (2)" }
+  panels { room: "Main Area" name: "Blank (3)" }
+  panels { room: "Main Area" name: "Blank (4)" }
+  panels { room: "Main Area" name: "Blank (5)" }
+  location_room: "Main Area"
+}
+doors {
+  name: "CBA Door"
+  type: EVENT
+  panels { room: "Main Area" name: "Blank (1)" }
+  panels { room: "Main Area" name: "Blank (2)" }
+  panels { room: "Main Area" name: "Blank (3)" }
+  panels { room: "Main Area" name: "Blank (4)" }
+  panels { room: "Main Area" name: "Blank (5)" }
+  panels { room: "Main Area" name: "BIRD" }
+  panels { room: "Main Area" name: "UNBOTTLING" }
+  panels { room: "Main Area" name: "ORGANIZATION" }
+  panels { room: "Main Area" name: "ORDER (1)" }
+  panels { room: "Main Area" name: "ORDER (2)" }
+  panels { room: "Main Area" name: "ORDER (3)" }
+  panels { room: "Main Area" name: "DECK (1)" }
+  panels { room: "Main Area" name: "DECK (2)" }
+  panels { room: "Main Area" name: "DECK (3)" }
+  panels { room: "Main Area" name: "OBSERVE" }
+  panels { room: "Main Area" name: "I" }
+  panels { room: "Main Area" name: "REST" }
+  panels { room: "Main Area" name: "THE" }
+  panels { room: "Main Area" name: "LIVES" }
+  panels { room: "Main Area" name: "DAIRY (1)" }
+  panels { room: "Main Area" name: "DAIRY (2)" }
+  panels { room: "Main Area" name: "DAIRY SAUCE" }
+  panels { room: "Main Area" name: "GULLIBLE (1)" }
+  panels { room: "Main Area" name: "GULLIBLE (2)" }
+  panels { room: "Main Area" name: "GULLIBLE (3)" }
+  panels { room: "Main Area" name: "FRUIT (1)" }
+  panels { room: "Main Area" name: "FRUIT (2)" }
+  panels { room: "Main Area" name: "FRUIT FRUIT" }
+  complete_at: 23 # ????
+}
+doors {
+  name: "Mastery"
+  type: EVENT
+  panels { room: "CBA" name: "CBA (1)" }
+  panels { room: "CBA" name: "CBA (2)" }
+  panels { room: "CBA" name: "CBA (3)" }
+}
@@ -0,0 +1,4 @@
+display_name: "The Advanced"
+type: GIFT_MAP
+# The map's mastery is created at runtime.
+custom_nodes: "Components/Collectables/collectable"
@@ -0,0 +1,22 @@
+name: "CBA"
+panels {
+  name: "CBA (1)"
+  path: "Panels/Room_1/panel_29"
+  clue: ""
+  answer: "chess"
+  symbols: QUESTION
+}
+panels {
+  name: "CBA (2)"
+  path: "Panels/Room_1/panel_30"
+  clue: ""
+  answer: "battle"
+  symbols: QUESTION
+}
+panels {
+  name: "CBA (3)"
+  path: "Panels/Room_1/panel_31"
+  clue: ""
+  answer: "advanced"
+  symbols: QUESTION
+}
@@ -0,0 +1,200 @@
+name: "Main Area"
+panels {
+  name: "OBSERVE"
+  path: "Panels/Room_1/panel_1"
+  clue: "observe"
+  answer: "watch"
+  symbols: SUN
+}
+panels {
+  name: "I"
+  path: "Panels/Room_1/panel_2"
+  clue: "i"
+  answer: "eye"
+  symbols: ZERO
+}
+panels {
+  name: "REST"
+  path: "Panels/Room_1/panel_3"
+  clue: "rest"
+  answer: "sleep"
+  symbols: SUN
+}
+panels {
+  name: "THE"
+  path: "Panels/Room_1/panel_4"
+  clue: "the"
+  answer: "a"
+  symbols: ZERO
+}
+panels {
+  name: "LIVES"
+  path: "Panels/Room_1/panel_5"
+  clue: "lives"
+  answer: "souls"
+  symbols: SUN
+}
+panels {
+  name: "DAIRY (1)"
+  path: "Panels/Room_1/panel_6"
+  clue: "dairy"
+  answer: "cheese"
+  symbols: EXAMPLE
+}
+panels {
+  name: "DAIRY (2)"
+  path: "Panels/Room_1/panel_7"
+  clue: "dairy"
+  answer: "butter"
+  symbols: EXAMPLE
+}
+panels {
+  name: "DAIRY SAUCE"
+  path: "Panels/Room_1/panel_8"
+  clue: "dairy? sauce."
+  answer: "alfredo"
+  symbols: EXAMPLE
+}
+panels {
+  name: "GULLIBLE (1)"
+  path: "Panels/Room_1/panel_9"
+  clue: "gullible"
+  answer: "credulous"
+  symbols: SUN
+}
+panels {
+  name: "GULLIBLE (2)"
+  path: "Panels/Room_1/panel_10"
+  clue: "gullible"
+  answer: "bird"
+  symbols: SPARKLES
+  symbols: EXAMPLE
+}
+panels {
+  name: "GULLIBLE (3)"
+  path: "Panels/Room_1/panel_11"
+  clue: "gullible"
+  answer: "advice"
+  symbols: QUESTION
+}
+panels {
+  name: "FRUIT (1)"
+  path: "Panels/Room_1/panel_12"
+  clue: "fruit"
+  answer: "cherry"
+  symbols: EXAMPLE
+}
+panels {
+  name: "FRUIT (2)"
+  path: "Panels/Room_1/panel_13"
+  clue: "fruit"
+  answer: "banana"
+  symbols: EXAMPLE
+}
+panels {
+  name: "FRUIT FRUIT"
+  path: "Panels/Room_1/panel_14"
+  clue: "fruit? fruit!"
+  answer: "avocado"
+  symbols: EXAMPLE
+}
+panels {
+  name: "BIRD"
+  path: "Panels/Room_1/panel_15"
+  clue: "bird"
+  answer: "canary"
+  symbols: EXAMPLE
+}
+panels {
+  name: "UNBOTTLING"
+  path: "Panels/Room_1/panel_16"
+  clue: "unbottling"
+  answer: "bottling"
+  symbols: SUN
+}
+panels {
+  name: "ORGANIZATION"
+  path: "Panels/Room_1/panel_17"
+  clue: "organization"
+  answer: "association"
+  symbols: SUN
+}
+panels {
+  name: "ORDER (1)"
+  path: "Panels/Room_1/panel_18"
+  clue: "order"
+  answer: "chaos"
+  symbols: SUN
+}
+panels {
+  name: "ORDER (2)"
+  path: "Panels/Room_1/panel_19"
+  clue: "order"
+  answer: "border"
+  symbols: SPARKLES
+}
+panels {
+  name: "ORDER (3)"
+  path: "Panels/Room_1/panel_20"
+  clue: "order"
+  answer: "arrange"
+  symbols: SUN
+}
+panels {
+  name: "DECK (1)"
+  path: "Panels/Room_1/panel_21"
+  clue: "deck"
+  answer: "card"
+  symbols: BOXES
+}
+panels {
+  name: "DECK (2)"
+  path: "Panels/Room_1/panel_22"
+  clue: "deck"
+  answer: "black"
+  symbols: BOXES
+}
+panels {
+  name: "DECK (3)"
+  path: "Panels/Room_1/panel_23"
+  clue: "deck"
+  answer: "ace"
+  symbols: BOXES
+}
+panels {
+  name: "Blank (1)"
+  path: "Panels/Room_1/panel_24"
+  clue: ""
+  answer: "identity"
+}
+panels {
+  name: "Blank (2)"
+  path: "Panels/Room_1/panel_25"
+  clue: ""
+  answer: "theft"
+}
+panels {
+  name: "Blank (3)"
+  path: "Panels/Room_1/panel_26"
+  clue: ""
+  answer: "is"
+}
+panels {
+  name: "Blank (4)"
+  path: "Panels/Room_1/panel_27"
+  clue: ""
+  answer: "a"
+}
+panels {
+  name: "Blank (5)"
+  path: "Panels/Room_1/panel_28"
+  clue: ""
+  answer: "crime"
+}
+ports {
+  name: "WORLDPORT"
+  display_name: "Entrance"
+  path: "Components/Warps/worldport"
+  destination { x: 0 y: 0 z: 9.5 }
+  rotation: 0
+}
@@ -0,0 +1,5 @@
+name: "Mastery"
+masteries {
+  name: "MASTERY"
+  path: "Components/Collectables/collectable"
+}
@@ -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?
 }
@@ -4,4 +4,5 @@ panels {
   path: "Panels/panel_1"
   clue: "this"
   answer: "sphinx"
+  symbols: QUESTION
 }
@@ -263,3 +263,8 @@ connections {
   to_room: "Butterfly Room"
   door { name: "Butterfly Entrance" }
 }
+connections {
+  from_room: "Back Area"
+  to_room: "Tree Entrance"
+  door { name: "Control Center Brown Door" }
+}
@@ -241,6 +241,7 @@ doors {
 doors {
   name: "Control Center Brown Door"
   type: CONTROL_CENTER_COLOR
+  latch: true
   receivers: "Components/Doors/brown_1"
   control_center_color: "brown"
 }
@@ -250,3 +251,18 @@ doors {
   receivers: "Components/Doors/brown_2"
   double_letters: true
 }
+doors {
+  name: "Control Center Color Panel"
+  type: LOCATION_ONLY
+  panels { room: "Back Area" name: "COLOR" }
+  location_room: "Back Area"
+  location_name: "COLOR"
+}
+doors {
+  name: "Butterfly Room Panels"
+  type: LOCATION_ONLY
+  panels { room: "Butterfly Room" name: "DARKNESS" }
+  panels { room: "Butterfly Room" name: "VIBRANT" }
+  location_room: "Butterfly Room"
+  location_name: "DARKNESS, VIBRANT"
+}
@@ -7,13 +7,9 @@ panels {
   symbols: EXAMPLE
 }
 ports {
-  name: "TREE"
-  path: "Components/Warps/worldport3"
-  orientation: "north"
-  required_door { name: "Control Center Brown Door" }
-}
-ports {
   name: "DAEDALUS"
+  display_name: "Dark Hallway"
   path: "Components/Warps/worldport2"
-  orientation: "north"
+  destination { x: 10 y: 0 z: -84.5 }
+  rotation: 180
 }
@@ -57,6 +57,8 @@ panels {
 }
 ports {
   name: "UNYIELDING"
+  display_name: "Main Entrance"
   path: "Components/Warps/worldport"
-  orientation: "east"
+  destination { x: 3 y: 4 z: 15 }
+  rotation: 90
 }
@@ -0,0 +1,8 @@
+name: "Tree Entrance"
+ports {
+  name: "TREE"
+  display_name: "Brown Hallway"
+  path: "Components/Warps/worldport3"
+  destination { x: -19 y: 0 z: -83.5 }
+  rotation: 180
+}
@@ -13,11 +13,15 @@ paintings {
 }
 ports {
   name: "CC"
+  display_name: "Lavender Structure"
   path: "Components/Warps/worldport3"
-  orientation: "north"
+  destination { x: 36 y: 0 z: 1 }
+  rotation: 180
 }
 ports {
   name: "LIVELY"
+  display_name: "Near Painting Worldport"
   path: "Components/Warps/worldport2"
-  orientation: "south"
+  destination { x: 24 y: 0 z: 6.5 }
+  rotation: 0
 }
@@ -197,6 +197,8 @@ panels {
 }
 ports {
   name: "GREAT"
+  display_name: "Salmon Hallway"
   path: "Components/Warps/worldport"
-  orientation: "east"
+  destination { x: -1 y: 0 z: 20 }
+  rotation: 90
 }
@@ -1,6 +1,8 @@
 name: "Plaza Entrance"
 ports {
   name: "PLAZA"
+  display_name: "Trick or Treat Worldport"
   path: "Components/Warps/worldport4"
-  orientation: "north"
+  destination { x: -38 y: 0 z: 1 }
+  rotation: 180
 }
@@ -1,4 +1,3 @@
-# TODO: The gallery painting
 doors {
   name: "Panels"
   type: EVENT
@@ -127,6 +127,8 @@ panels {
 }
 ports {
   name: "GALLERY"
+  display_name: "Worldport"
   path: "Components/Warps/worldport"
-  orientation: "southwest" # uhhhh this is new
+  destination { x: -19 y: 0 z: 19 }
+  rotation: 315
 }
@@ -0,0 +1,35 @@
+connections {
+  from_room: "Main Area"
+  to_room: "Latitude South"
+  door { name: "Latitude South Door" }
+}
+connections {
+  from_room: "Main Area"
+  to_room: "Latitude Middle"
+  door { name: "Latitude Middle Door" }
+}
+connections {
+  from_room: "Main Area"
+  to_room: "Latitude North"
+  door { name: "Latitude North Door" }
+}
+connections {
+  from_room: "Main Area"
+  to_room: "Longitude West"
+  door { name: "Longitude West Door" }
+}
+connections {
+  from_room: "Main Area"
+  to_room: "Longitude Middle"
+  door { name: "Longitude Middle Door" }
+}
+connections {
+  from_room: "Main Area"
+  to_room: "Longitude East"
+  door { name: "Longitude East Door" }
+}
+connections {
+  from_room: "Main Area"
+  to_room: "Mastery"
+  door { name: "Mastery Door" }
+}
@@ -0,0 +1,56 @@
+doors {
+  name: "Latitude South Door"
+  type: EVENT
+  panels { room: "Main Area" name: "TIP" }
+  panels { room: "Main Area" name: "KING" }
+  panels { room: "Main Area" name: "ARC" }
+}
+doors {
+  name: "Latitude Middle Door"
+  type: EVENT
+  panels { room: "Main Area" name: "NAIL" }
+  panels { room: "Main Area" name: "TILE" }
+  panels { room: "Main Area" name: "AQUA" }
+}
+doors {
+  name: "Latitude North Door"
+  type: EVENT
+  panels { room: "Main Area" name: "PINS" }
+  panels { room: "Main Area" name: "IT" }
+  panels { room: "Main Area" name: "HERE" }
+}
+doors {
+  name: "Longitude West Door"
+  type: EVENT
+  panels { room: "Main Area" name: "ARC" }
+  panels { room: "Main Area" name: "AQUA" }
+  panels { room: "Main Area" name: "HERE" }
+}
+doors {
+  name: "Longitude Middle Door"
+  type: EVENT
+  panels { room: "Main Area" name: "KING" }
+  panels { room: "Main Area" name: "TILE" }
+  panels { room: "Main Area" name: "IT" }
+}
+doors {
+  name: "Longitude East Door"
+  type: EVENT
+  panels { room: "Main Area" name: "TIP" }
+  panels { room: "Main Area" name: "NAIL" }
+  panels { room: "Main Area" name: "PINS" }
+}
+doors {
+  name: "Mastery Door"
+  type: EVENT
+  panels { room: "Main Area" name: "HERE" }
+  panels { room: "Main Area" name: "TILE" }
+  panels { room: "Main Area" name: "TIP" }
+  panels { room: "Main Area" name: "Blank" }
+  panels { room: "Latitude South" name: "CHARISMA" }
+  panels { room: "Latitude Middle" name: "FUNNY" }
+  panels { room: "Latitude North" name: "DEPENDABLE" }
+  panels { room: "Longitude West" name: "CREATIVE" }
+  panels { room: "Longitude Middle" name: "INTELLIGENT" }
+  panels { room: "Longitude East" name: "FUN" }
+}
@@ -0,0 +1,4 @@
+display_name: "The Charismatic"
+type: GIFT_MAP
+# The map's mastery is created at runtime.
+custom_nodes: "Components/Collectables/collectable"
@@ -0,0 +1,8 @@
+name: "Latitude Middle"
+panels {
+  name: "FUNNY"
+  path: "Panels/Room 2/panel_h"
+  clue: "funny"
+  answer: "hilarious"
+  symbols: PYRAMID
+}
@@ -0,0 +1,8 @@
+name: "Latitude North"
+panels {
+  name: "DEPENDABLE"
+  path: "Panels/Room 2/panel_r"
+  clue: "dependable"
+  answer: "reliable"
+  symbols: SUN
+}
@@ -0,0 +1,8 @@
+name: "Latitude South"
+panels {
+  name: "CHARISMA"
+  path: "Panels/Room 2/panel_c"
+  clue: "charisma"
+  answer: "charismatic"
+  symbols: QUESTION
+}
@@ -0,0 +1,8 @@
+name: "Longitude East"
+panels {
+  name: "FUN"
+  path: "Panels/Room 2/panel_s2"
+  clue: "fun"
+  answer: "silly"
+  symbols: SUN
+}
@@ -0,0 +1,8 @@
+name: "Longitude Middle"
+panels {
+  name: "INTELLIGENT"
+  path: "Panels/Room 2/panel_s"
+  clue: "intelligent"
+  answer: "smart"
+  symbols: SUN
+}
@@ -0,0 +1,8 @@
+name: "Longitude West"
+panels {
+  name: "CREATIVE"
+  path: "Panels/Room 2/panel_i"
+  clue: "creative"
+  answer: "imaginative"
+  symbols: SUN
+}
@@ -0,0 +1,78 @@
+name: "Main Area"
+panels {
+  name: "ARC"
+  path: "Panels/Room_1/panel_1"
+  clue: "arc"
+  answer: "arctic"
+  symbols: QUESTION
+}
+panels {
+  name: "KING"
+  path: "Panels/Room_1/panel_2"
+  clue: "king"
+  answer: "tacking"
+  symbols: QUESTION
+}
+panels {
+  name: "TIP"
+  path: "Panels/Room_1/panel_3"
+  clue: "tip"
+  answer: "tiptoe"
+  symbols: QUESTION
+}
+panels {
+  name: "AQUA"
+  path: "Panels/Room_1/panel_4"
+  clue: "aqua"
+  answer: "aquatic"
+  symbols: QUESTION
+}
+panels {
+  name: "TILE"
+  path: "Panels/Room_1/panel_5"
+  clue: "tile"
+  answer: "tactile"
+  symbols: QUESTION
+}
+panels {
+  name: "NAIL"
+  path: "Panels/Room_1/panel_6"
+  clue: "nail"
+  answer: "toenail"
+  symbols: QUESTION
+}
+panels {
+  name: "HERE"
+  path: "Panels/Room_1/panel_7"
+  clue: "here"
+  answer: "heretic"
+  symbols: QUESTION
+}
+panels {
+  name: "IT"
+  path: "Panels/Room_1/panel_8"
+  clue: "it"
+  answer: "tacit"
+  symbols: QUESTION
+}
+panels {
+  name: "PINS"
+  path: "Panels/Room_1/panel_9"
+  clue: "pins"
+  answer: "pintoes"
+  symbols: QUESTION
+}
+panels {
+  name: "Blank"
+  path: "Panels/Room 3/panel_10"
+  clue: ""
+  answer: "tactic"
+  symbols: QUESTION
+}
+ports {
+  name: "WORLDPORT"
+  display_name: "Entrance"
+  path: "Components/Warps/worldport"
+  destination { x: 0 y: 0 z: 9.5 }
+  rotation: 0
+}
@@ -0,0 +1,5 @@
+name: "Mastery"
+masteries {
+  name: "MASTERY"
+  path: "Components/Collectables/collectable"
+}
@@ -1,4 +1,3 @@
-# TODO: gallery painting
 doors {
   name: "White Door"
   type: STANDARD
@@ -104,3 +103,10 @@ doors {
   panels { room: "Gray Room" name: "MEND" }
   location_room: "Gray Room"
 }
+doors {
+  name: "Chaos Panel"
+  type: LOCATION_ONLY
+  panels { room: "Cyan Hallway" name: "CHAOS" }
+  location_room: "Cyan Hallway"
+  location_name: "CHAOS"
+}
@@ -23,11 +23,15 @@ panels {
 }
 ports {
   name: "STURDY"
+  display_name: "North Cyan Worldport"
   path: "Components/Warps/worldport3"
-  orientation: "west"
+  destination { x: -17 y: 0 z: -75 }
+  rotation: 270
 }
 ports {
   name: "DARKROOM"
+  display_name: "South Cyan Worldport"
   path: "Components/Warps/worldport2"
-  orientation: "west"
+  destination { x: -17 y: 0 z: -51 }
+  rotation: 270
 }
@@ -8,6 +8,8 @@ panels {
 }
 ports {
   name: "GREAT"
+  display_name: "Main Entrance"
   path: "Components/Warps/worldport"
-  orientation: "west"
+  destination { x: -3.5 y: 0 z: 19 }
+  rotation: 270
 }
@@ -1,12 +1,22 @@
 doors {
   name: "Obverse Magenta Door"
-  type: STANDARD
+  type: ITEM_ONLY
+  legacy_location: true
   receivers: "Components/Doors/magenta_enterer2"
   panels { room: "Main Area" name: "LAKE" }
   panels { room: "Main Area" name: "DIE" }
   location_room: "Main Area"
 }
 doors {
+  name: "Main Area Puzzles"
+  type: LOCATION_ONLY
+  panels { room: "Main Area" name: "LAKE" }
+  panels { room: "Main Area" name: "DIE" }
+  panels { room: "Main Area" name: "LIGHT" }
+  location_room: "Main Area"
+  location_name: "DIE, LAKE, LIGHT"
+}
+doors {
   name: "Flipped Magenta Door"
   type: STANDARD
   receivers: "Components/Doors/magenta_enterer"
@@ -119,7 +129,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"
+  }
 }
@@ -1 +1,5 @@
 display_name: "The Congruent"
+worldport_entrance {
+  room: "Main Area"
+  name: "DARKROOM"
+}
@@ -2,5 +2,4 @@ name: "C Keyholder"
 keyholders {
   name: "C"
   path: "Components/KeyHolders/keyHolder"
-  # TODO: This will need to be modified so that it doesn't actually take the letter.
 }
@@ -2,5 +2,4 @@ name: "G Keyholder"
 keyholders {
   name: "G"
   path: "Components/KeyHolders/keyHolder2"
-  # TODO: This will need to be modified so that it doesn't actually take the letter.
 }
@@ -85,8 +85,10 @@ panels {
 }
 ports {
   name: "DARKROOM"
+  display_name: "Entrance"
   path: "Components/Warps/worldport2"
-  orientation: "north"
+  destination { x: -19 y: 0 z: 7.5 }
+  rotation: 180
 }
 paintings {
   name: "P"
@@ -0,0 +1,26 @@
+connections {
+  from_room: "Main Area"
+  to_room: "Painting Divot"
+  door { name: "Checkpoint Panels" }
+  oneway: true
+}
+connections {
+  from {
+    painting {
+      room: "Painting Divot"
+      name: "SNAKE"
+    }
+  }
+  to {
+    painting {
+      room: "Flip Area"
+      name: "SNAKE2"
+    }
+  }
+  oneway: true
+}
+connections {
+  from_room: "Flip Area"
+  to_room: "Mastery"
+  door { name: "Mastery" }
+}
@@ -0,0 +1,14 @@
+doors {
+  name: "Mastery"
+  type: EVENT
+  panels { room: "Flip Area" name: "SUCCEED" }
+}
+doors {
+  name: "Checkpoint Panels"
+  type: LOCATION_ONLY
+  panels { room: "Main Area" name: "DROP" }
+  panels { room: "Main Area" name: "LEAP" }
+  panels { room: "Main Area" name: "SPIN" }
+  location_room: "Main Area"
+  location_name: "DROP, LEAP, SPIN"
+}
@@ -0,0 +1,4 @@
+display_name: "The Crystalline"
+type: GIFT_MAP
+# The map's mastery is created at runtime.
+custom_nodes: "Components/Collectables/collectable"
@@ -0,0 +1,14 @@
+name: "Flip Area"
+panels {
+  name: "SUCCEED"
+  path: "Panels/Room_1/panel_3"
+  clue: "succeed"
+  answer: "win"
+  symbols: SUN
+}
+paintings {
+  name: "SNAKE2"
+  path: "Components/snake2"
+  exit_only: true
+  gravity: Y_PLUS
+}
@@ -0,0 +1,29 @@
+name: "Main Area"
+panels {
+  name: "LEAP"
+  path: "Panels/Room_1/panel_1"
+  clue: "leap"
+  answer: "jump"
+  symbols: SUN
+}
+panels {
+  name: "DROP"
+  path: "Panels/Room_1/panel_2"
+  clue: "drop"
+  answer: "fall"
+  symbols: SUN
+}
+panels {
+  name: "SPIN"
+  path: "Panels/Room_1/panel_4"
+  clue: "spin"
+  answer: "flip"
+  symbols: SUN
+}
+ports {
+  name: "WORLDPORT"
+  display_name: "Entrance"
+  path: "Components/Warps/worldport"
+  destination { x: 0 y: 0 z: 9.5 }
+  rotation: 0
+}
@@ -0,0 +1,5 @@
+name: "Mastery"
+masteries {
+  name: "MASTERY"
+  path: "Components/Collectables/collectable"
+}
@@ -0,0 +1,5 @@
+name: "Painting Divot"
+paintings {
+  name: "SNAKE"
+  path: "Components/snake"
+}
@@ -1,7 +1,12 @@
 connections {
+  from_room: "First Room"
+  to_room: "First Room Exit"
+  door { name: "Second Room Entrance" }
+}
+connections {
   from {
     port {
-      room: "First Room"
+      room: "First Room Exit"
       name: "NEXT"
     }
   }
@@ -14,9 +19,14 @@ connections {
   oneway: true
 }
 connections {
+  from_room: "Second Room"
+  to_room: "Second Room Exit"
+  door { name: "Third Room Entrance" }
+}
+connections {
   from {
     port {
-      room: "Second Room"
+      room: "Second Room Exit"
       name: "NEXT"
     }
   }
@@ -33,3 +43,18 @@ connections {
   to_room: "S Room"
   door { name: "S1 Door" }
 }
+connections {
+  from_room: "First Room"
+  to_room: "Cyan Hallway"
+  door { name: "Colorful Entrance" }
+}
+connections {
+  from_room: "Second Room"
+  to_room: "Congruent Entrance"
+  door { name: "Congruent Entrance" }
+}
+connections {
+  from_room: "First Room"
+  to_room: "Double Sided Entrance"
+  door { name: "Double Sided Entrance" }
+}
@@ -1,4 +1,3 @@
-# TODO: gallery painting
 doors {
   name: "Double Letter Panel Blockers"
   type: EVENT
@@ -0,0 +1,9 @@
+name: "Congruent Entrance"
+panel_display_name: "Second Room"
+ports {
+  name: "CONGRUENT"
+  display_name: "Second Room Gray Hallway"
+  path: "Components/Warps/worldport7"
+  destination { x: 51.5 y: 0 z: 29 }
+  rotation: 90
+}
@@ -0,0 +1,9 @@
+name: "Cyan Hallway"
+panel_display_name: "First Room"
+ports {
+  name: "COLORFUL"
+  display_name: "First Room Cyan Hallway"
+  path: "Components/Warps/worldport8"
+  destination { x: 20 y: 0 z: -12 }
+  rotation: 180
+}
@@ -0,0 +1,9 @@
+name: "Double Sided Entrance"
+panel_display_name: "First Room"
+ports {
+  name: "DOUBLESIDED"
+  display_name: "First Room White Hallway"
+  path: "Components/Warps/worldport6"
+  destination { x: 15 y: 0 z: 23 }
+  rotation: 90
+}
@@ -0,0 +1,9 @@
+name: "First Room Exit"
+panel_display_name: "First Room"
+ports {
+  name: "NEXT"
+  display_name: "First Room Exit"
+  path: "Components/Warps/worldport2"
+  destination { x: 0 y: 0 z: -15 }
+  rotation: 180
+}
@@ -33,24 +33,8 @@ panels {
 }
 ports {
   name: "ENTRY"
+  display_name: "First Room Entrance"
   path: "Components/Warps/worldport"
-  orientation: "south"
-}
-ports {
-  name: "NEXT"
-  path: "Components/Warps/worldport2"
-  orientation: "north"
-  required_door { name: "Second Room Entrance" }
-}
-ports {
-  name: "COLORFUL"
-  path: "Components/Warps/worldport8"
-  orientation: "north"
-  required_door { name: "Colorful Entrance" }
-}
-ports {
-  name: "DOUBLESIDED"
-  path: "Components/Warps/worldport6"
-  orientation: "east"
-  required_door { name: "Double Sided Entrance" }
+  destination { x: -10 y: 0 z: 10 }
+  rotation: 0
 }
@@ -0,0 +1,9 @@
+name: "Second Room Exit"
+panel_display_name: "Second Room"
+ports {
+  name: "NEXT"
+  display_name: "Second Room Exit"
+  path: "Components/Warps/worldport4"
+  destination { x: 48 y: 0 z: -15 }
+  rotation: 180
+}
@@ -38,18 +38,8 @@ panels {
 }
 ports {
   name: "ENTRY"
+  display_name: "Second Room Entrance"
   path: "Components/Warps/worldport3"
-  orientation: "south"
-}
-ports {
-  name: "NEXT"
-  path: "Components/Warps/worldport4"
-  orientation: "north"
-  required_door { name: "Third Room Entrance" }
-}
-ports {
-  name: "CONGRUENT"
-  path: "Components/Warps/worldport7"
-  orientation: "east"
-  required_door { name: "Congruent Entrance" }
+  destination { x: 38 y: 0 z: 10 }
+  rotation: 0
 }
@@ -65,6 +65,8 @@ panels {
 }
 ports {
   name: "ENTRY"
+  display_name: "Third Room Entrance"
   path: "Components/Warps/worldport5"
-  orientation: "south"
+  destination { x: 97 y: 0 z: 10 }
+  rotation: 0
 }
@@ -24,11 +24,6 @@ connections {
   door { name: "Gallery Entrance" }
 }
 connections {
-  from_room: "Gallery Maze"
-  to_room: "Main Area"
-  oneway: true
-}
-connections {
   from_room: "Tree Area"
   to_room: "Main Area"
   door { name: "Tree Entrance" }
@@ -42,6 +42,7 @@ doors {
 doors {
   name: "Control Center Blue Door"
   type: CONTROL_CENTER_COLOR
+  latch: true
   receivers: "Components/Doors/maze2"
   control_center_color: "blue"
 }
@@ -52,3 +53,10 @@ doors {
   panels { room: "Tree Area" name: "TREE" }
   location_room: "Tree Area"
 }
+doors {
+  name: "Control Center Blue Panel"
+  type: LOCATION_ONLY
+  panels { room: "Main Area" name: "COLOR" }
+  location_room: "Main Area"
+  location_name: "COLOR"
+}
@@ -1,6 +1,8 @@
 name: "Gallery Maze"
 ports {
   name: "GALLERY"
+  display_name: "Gallery Maze Worldport"
   path: "Components/Warps/worldport4"
-  orientation: "east"
+  destination { x: -58 y: 0 z: -76 }
+  rotation: 90
 }
@@ -27,16 +27,22 @@ panels {
 }
 ports {
   name: "ENTRY1"
+  display_name: "Maze NW Worldport"
   path: "Components/Worldports/worldport3"
-  orientation: "west"
+  destination { x: -33 y: 0 z: 28 }
+  rotation: 270
 }
 ports {
   name: "ENTRY2"
+  display_name: "Maze SW Worldport"
   path: "Components/Worldports/worldport"
-  orientation: "south"
+  destination { x: -30 y: 0 z: 51 }
+  rotation: 0
 }
 ports {
   name: "ENTRY3"
+  display_name: "Maze SE Worldport"
   path: "Components/Worldports/worldport2"
-  orientation: "south"
+  destination { x: 0 y: 0 z: 51 }
+  rotation: 0
 }
@@ -8,7 +8,8 @@ panels {
 }
 ports {
   name: "TREE"
+  display_name: "Brown Hallway"
   path: "Components/Worldports/worldport4"
-  orientation: "east"
-  # This is double sided.
+  destination { x: -16 y: 0 z: -31 }
+  rotation: 270
 }
@@ -1,6 +1,8 @@
 name: "Unyielding Entrance"
 ports {
   name: "UNYIELDING"
+  display_name: "Blue Door Worldport"
   path: "Components/Warps/worldport5"
-  orientation: "east"
+  destination { x: 14 y: 0 z: 5 }
+  rotation: 90
 }
@@ -113,3 +113,82 @@ doors {
   # The panel blocks your way; there's no door.
   panels { room: "Flipped Black Area" name: "SEAPLANE" }
 }
+# These locations are kind of deranged but hey. Welcome to The Double Sided.
+doors {
+  name: "5 Panels"
+  type: LOCATION_ONLY
+  panels { room: "Flipped Black Area" name: "SEAPLANE" }
+  panels { room: "Flipped Blue Area" name: "SKY" }
+  panels { room: "Flipped Blue Area" name: "HEAD" }
+  panels { room: "Flipped Green Area" name: "HIGH" }
+  panels { room: "Flipped Orange Area" name: "HEAVEN" }
+  panels { room: "Flipped Purple Area" name: "CEILING" }
+  panels { room: "Flipped Purple Area" name: "LEAVES" }
+  panels { room: "Flipped Red Area" name: "RAISED" }
+  panels { room: "Flipped Yellow Back Area" name: "ANGELS" }
+  panels { room: "Obverse Black Area" name: "MOUNTAIN" }
+  panels { room: "Obverse Black Area" name: "TRAIN" }
+  panels { room: "Obverse Green Area" name: "UPSIDE" }
+  panels { room: "Obverse Orange Back Area" name: "OVER" }
+  panels { room: "Obverse Orange Front Area" name: "UP" }
+  panels { room: "Obverse Orange Isolated Section" name: "TOP" }
+  panels { room: "Obverse Pink Area" name: "CLOUD" }
+  panels { room: "Obverse Purple Area" name: "DRAGON" }
+  panels { room: "Obverse Purple Area" name: "ABOVE" }
+  panels { room: "Start" name: "ATTIC" }
+  panels { room: "Start" name: "FULL" }
+  location_room: "Start"
+  complete_at: 5
+}
+doors {
+  name: "10 Panels"
+  type: LOCATION_ONLY
+  panels { room: "Flipped Black Area" name: "SEAPLANE" }
+  panels { room: "Flipped Blue Area" name: "SKY" }
+  panels { room: "Flipped Blue Area" name: "HEAD" }
+  panels { room: "Flipped Green Area" name: "HIGH" }
+  panels { room: "Flipped Orange Area" name: "HEAVEN" }
+  panels { room: "Flipped Purple Area" name: "CEILING" }
+  panels { room: "Flipped Purple Area" name: "LEAVES" }
+  panels { room: "Flipped Red Area" name: "RAISED" }
+  panels { room: "Flipped Yellow Back Area" name: "ANGELS" }
+  panels { room: "Obverse Black Area" name: "MOUNTAIN" }
+  panels { room: "Obverse Black Area" name: "TRAIN" }
+  panels { room: "Obverse Green Area" name: "UPSIDE" }
+  panels { room: "Obverse Orange Back Area" name: "OVER" }
+  panels { room: "Obverse Orange Front Area" name: "UP" }
+  panels { room: "Obverse Orange Isolated Section" name: "TOP" }
+  panels { room: "Obverse Pink Area" name: "CLOUD" }
+  panels { room: "Obverse Purple Area" name: "DRAGON" }
+  panels { room: "Obverse Purple Area" name: "ABOVE" }
+  panels { room: "Start" name: "ATTIC" }
+  panels { room: "Start" name: "FULL" }
+  location_room: "Start"
+  complete_at: 10
+}
+doors {
+  name: "15 Panels"
+  type: LOCATION_ONLY
+  panels { room: "Flipped Black Area" name: "SEAPLANE" }
+  panels { room: "Flipped Blue Area" name: "SKY" }
+  panels { room: "Flipped Blue Area" name: "HEAD" }
+  panels { room: "Flipped Green Area" name: "HIGH" }
+  panels { room: "Flipped Orange Area" name: "HEAVEN" }
+  panels { room: "Flipped Purple Area" name: "CEILING" }
+  panels { room: "Flipped Purple Area" name: "LEAVES" }
+  panels { room: "Flipped Red Area" name: "RAISED" }
+  panels { room: "Flipped Yellow Back Area" name: "ANGELS" }
+  panels { room: "Obverse Black Area" name: "MOUNTAIN" }
+  panels { room: "Obverse Black Area" name: "TRAIN" }
+  panels { room: "Obverse Green Area" name: "UPSIDE" }
+  panels { room: "Obverse Orange Back Area" name: "OVER" }
+  panels { room: "Obverse Orange Front Area" name: "UP" }
+  panels { room: "Obverse Orange Isolated Section" name: "TOP" }
+  panels { room: "Obverse Pink Area" name: "CLOUD" }
+  panels { room: "Obverse Purple Area" name: "DRAGON" }
+  panels { room: "Obverse Purple Area" name: "ABOVE" }
+  panels { room: "Start" name: "ATTIC" }
+  panels { room: "Start" name: "FULL" }
+  location_room: "Start"
+  complete_at: 15
+}
@@ -1 +1,5 @@
 display_name: "The Double Sided"
+worldport_entrance {
+  room: "Start"
+  name: "DARKROOM"
+}
@@ -15,6 +15,8 @@ panels {
 }
 ports {
   name: "DARKROOM"
+  display_name: "Entrance"
   path: "Components/Warps/worldport"
-  orientation: "west"
+  destination { x: -3 y: 0 z: 8 }
+  rotation: 270
 }
@@ -64,6 +64,16 @@ connections {
   door { name: "Flipped Pyramid Area Entrance" }
 }
 connections {
+  from_room: "Flipped Pyramid Area"
+  to_room: "Liberated Entrance Panel"
+  oneway: true
+}
+connections {
+  from_room: "Flipped Pyramid Area"
+  to_room: "Literate Entrance Panel"
+  oneway: true
+}
+connections {
   from_room: "Right Eye"
   to_room: "Least Blue Last"
   door { name: "Red Blue Area Left Door" }
@@ -97,6 +107,12 @@ connections {
   from_room: "Red Blue Halls"
   to_room: "Wrath Room"
   door { name: "Noon Door" }
+  oneway: true
+}
+connections {
+  from_room: "Wrath Room"
+  to_room: "Least Blue Last"
+  oneway: true
 }
 connections {
   from_room: "Red Blue Halls"
@@ -154,6 +170,11 @@ connections {
   door { name: "Lime Room Entrance" }
 }
 connections {
+  from_room: "Lime Room"
+  to_room: "Revitalized Entrance"
+  door { name: "Revitalized Entrance" }
+}
+connections {
   from { painting { room: "Link Area" name: "NEAR" } }
   to { painting { room: "Flipped Link Area" name: "NEAR" } }
   oneway: true
@@ -172,12 +193,12 @@ connections {
   from_room: "Starting Room"
   to_room: "Digital Entrance"
   door { name: "Second Room Left Door" }
-  oneway: true
 }
 connections {
   from_room: "Digital Entrance"
   to_room: "Starting Room"
   oneway: true
+  vanilla_only: true
 }
 connections {
   from_room: "Starting Room"
@@ -199,3 +220,28 @@ connections {
   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" }
+}
+connections {
+  from_room: "Liberated Entrance"
+  to_room: "Liberated Entrance Panel"
+  oneway: true
+}
+connections {
+  from_room: "Literate Entrance"
+  to_room: "Literate Entrance Panel"
+  oneway: true
+}
@@ -69,20 +69,40 @@ doors {
 # second_right is vanilla because it's like LOST door.
 doors {
   name: "Noon Door"
-  type: STANDARD
+  type: ITEM_ONLY
+  legacy_location: true
   receivers: "Components/Doors/second_right5"
   receivers: "Components/Doors/second_right10"
   panels { room: "Red Blue Halls" name: "CENTER DAY" }
   location_room: "Red Blue Halls"
 }
 doors {
+  name: "Noon Door Panels"
+  type: LOCATION_ONLY
+  panels { room: "Red Blue Halls" name: "CENTER" }
+  panels { room: "Red Blue Halls" name: "DAY" }
+  panels { room: "Red Blue Halls" name: "CENTER DAY" }
+  location_room: "Red Blue Halls"
+  location_name: "CENTER, DAY, CENTER DAY"
+}
+doors {
   name: "Scarf Door"
-  type: STANDARD
+  type: ITEM_ONLY
+  legacy_location: true
   receivers: "Components/Doors/second_right6"
   panels { room: "Red Blue Halls" name: "RAIN WOMAN" }
   location_room: "Red Blue Halls"
 }
 doors {
+  name: "Scarf Door Panels"
+  type: LOCATION_ONLY
+  panels { room: "Red Blue Halls" name: "RAIN" }
+  panels { room: "Red Blue Halls" name: "WOMAN" }
+  panels { room: "Red Blue Halls" name: "RAIN WOMAN" }
+  location_room: "Red Blue Halls"
+  location_name: "RAIN, WOMAN, RAIN WOMAN"
+}
+doors {
   name: "Blue Alcove Entrance"
   type: STANDARD
   receivers: "Components/Doors/second_right9"
@@ -119,7 +139,8 @@ doors {
 }
 doors {
   name: "Red Blue Area Left Door"
-  type: STANDARD
+  type: ITEM_ONLY
+  legacy_location: true
   receivers: "Components/Doors/fourth_right"
   panels { room: "Right Eye" name: "WANDER" }
   location_room: "Right Eye"
@@ -131,14 +152,41 @@ doors {
   panels { room: "Right Eye" name: "WANDER" }
   location_room: "Right Eye"
 }
+doors {
+  name: "Wander Panels"
+  type: LOCATION_ONLY
+  panels { room: "Right Eye" name: "WANDER" }
+  panels { room: "Red Blue Halls" name: "WANDER" }
+  panels { room: "Link Area" name: "WANDER" }
+  panels { room: "Flipped Link Area" name: "WANDER" }
+  location_room: "Flipped Link Area"
+}
+doors {
+  name: "Flipped Right Eye Panels"
+  type: LOCATION_ONLY
+  panels { room: "Flipped Right Eye" name: "HERE" }
+  panels { room: "Flipped Right Eye" name: "WHERE" }
+  location_room: "Flipped Right Eye"
+  location_name: "HERE, WHERE"
+}
+doors {
+  name: "Big Eyes"
+  type: LOCATION_ONLY
+  panels { room: "Starting Room" name: "EYE" }
+  panels { room: "Right Eye" name: "EYE" }
+  location_room: "Right Eye"
+  location_name: "EYE"
+}
 # Components/Doors/back_left_1, _3, _4, _6 are vanilla because they're nothing.
 doors {
   name: "Orange Door Hider"
   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"
@@ -159,6 +207,7 @@ doors {
 doors {
   name: "Control Center White Door"
   type: CONTROL_CENTER_COLOR
+  latch: true
   receivers: "Components/Doors/back_left_7"
   control_center_color: "white"
 }
@@ -209,7 +258,7 @@ doors {
   name: "Liberated Entrance"
   type: STANDARD
   receivers: "Components/Doors/Entry/entry_proxied_10"
-  panels { room: "Flipped Pyramid Area" name: "TURN (1)" }
+  panels { room: "Liberated Entrance Panel" name: "TURN (1)" }
   location_room: "Flipped Pyramid Area"
 }
 doors {
@@ -222,7 +271,7 @@ doors {
   name: "Literate Entrance"
   type: STANDARD
   receivers: "Components/Doors/Entry/entry_proxied_11"
-  panels { room: "Flipped Pyramid Area" name: "TURN (2)" }
+  panels { room: "Literate Entrance Panel" name: "TURN (2)" }
   location_room: "Flipped Pyramid Area"
 }
 doors {
@@ -301,7 +350,6 @@ doors {
 doors {
   name: "Red Room Painting"
   type: STANDARD
-  #move_paintings { room: "Right Eye" name: "PSYCHIC" }
   receivers: "Components/Paintings/psychic/teleportListener"
   panels { room: "Right Eye" name: "FAINT" }
   location_room: "Right Eye"
@@ -309,8 +357,49 @@ doors {
 doors {
   name: "Third Eye Painting"
   type: LOCATION_ONLY
-  # move_paintings { room: "Eye Room" name: "GALLERY" }
   # TODO: ummmm
   panels { room: "Eye Room" name: "I" }
   location_room: "Eye Room"
-}
\ No newline at end of file
+}
+doors {
+  name: "Gift Maps Entrance"
+  type: EVENT
+  receivers: "Components/GiftMapEntrance/PanelTeleporter"
+  double_letters: true
+}
+doors {
+  name: "Least Blue Last"
+  type: LOCATION_ONLY
+  panels { room: "Least Blue Last" name: "CAPABLE (1)" }
+  panels { room: "Least Blue Last" name: "CAPABLE (2)" }
+  panels { room: "Least Blue Last" name: "LUSTRE" }
+  panels { room: "Least Blue Last" name: "WANT" }
+  panels { room: "Least Blue Last" name: "STEALER" }
+  panels { room: "Least Blue Last" name: "OLD" }
+  panels { room: "Least Blue Last" name: "TRUST" }
+  panels { room: "Least Blue Last" name: "LABEL" }
+  panels { room: "Least Blue Last" name: "AIL" }
+  location_room: "Least Blue Last"
+}
+doors {
+  name: "Control Center White Panel"
+  type: LOCATION_ONLY
+  panels { room: "Lime Room" name: "COLOR" }
+  location_room: "Lime Room"
+  location_name: "COLOR"
+}
+doors {
+  name: "Rabbit Hole Blank Puzzle"
+  type: LOCATION_ONLY
+  panels { room: "Rabbit Hole" name: "Blank" }
+  location_room: "Rabbit Hole"
+  location_name: "Blank Puzzle"
+}
+doors {
+  name: "Wrath Room Puzzles"
+  type: LOCATION_ONLY
+  panels { room: "Wrath Room" name: "DICE" }
+  panels { room: "Wrath Room" name: "WREATH" }
+  location_room: "Wrath Room"
+  location_name: "DICE, WRATH"
+}
@@ -11,3 +11,13 @@ excluded_nodes: "Panels/Back Left/backleft_4_proxied_1"
 excluded_nodes: "Panels/Back Left/backleft_4_proxied_2"
 # This is a proxy related to the first panel and it doesn't seem useful.
 excluded_nodes: "Panels/Entry/entry_proxied_fake"
+# The gift map entrance is created by the mod.
+custom_nodes: "Components/GiftMapEntrance/GongusPanel"
+custom_nodes: "Components/GiftMapEntrance/HatkirbyPanel"
+custom_nodes: "Components/GiftMapEntrance/IcelyPanel"
+custom_nodes: "Components/GiftMapEntrance/KirbyPanel"
+custom_nodes: "Components/GiftMapEntrance/KiwiPanel"
+custom_nodes: "Components/GiftMapEntrance/Panel"
+custom_nodes: "Components/GiftMapEntrance/QPanel"
+custom_nodes: "Components/GiftMapEntrance/SouveyPanel"
+custom_nodes: "Components/GiftMapEntrance/StarPanel"
@@ -2,6 +2,8 @@ name: "Composite Room Entrance"
 panel_display_name: "Starting Room"
 ports {
   name: "COMPOSITE"
+  display_name: "Starting Room NE Worldport"
   path: "Components/Warps/worldport12"
-  orientation: "east"
+  destination { x: 16 y: 0 z: -20 }
+  rotation: 90
 }
@@ -2,6 +2,8 @@ name: "Daedalus Entrance"
 panel_display_name: "Starting Room"
 ports {
   name: "DAEDALUS"
+  display_name: "Starting Room North Wall West Worldport"
   path: "Components/Warps/worldport6"
-  orientation: "west"
+  destination { x: -16 y: 0 z: -20 }
+  rotation: 270
 }
@@ -2,6 +2,8 @@ name: "Digital Entrance"
 panel_display_name: "Starting Room"
 ports {
   name: "DIGITAL"
+  display_name: "Second Room Left Worldport"
   path: "Components/Warps/worldport"
-  orientation: "west"
+  destination { x: -78 y: 0 z: -24 }
+  rotation: 270
 }
@@ -2,6 +2,8 @@ name: "Entry Exit"
 panel_display_name: "Starting Room"
 ports {
   name: "GREAT"
+  display_name: "Second Room Right Worldport"
   path: "Components/Warps/worldport2"
-  orientation: "north"
+  destination { x: 18 y: 0 z: -36 }
+  rotation: 180
 }
@@ -31,6 +31,8 @@ paintings {
 }
 ports {
   name: "LIONIZED"
+  display_name: "Eye Room Worldport"
   path: "Components/Warps/worldport10"
-  orientation: "north"
+  destination { x: 18 y: 0 z: -88.5 }
+  rotation: 180
 }
@@ -1,16 +1,6 @@
 name: "Flipped Pyramid Area"
 panel_display_name: "Pyramid Area"
-panels {
-  name: "TURN (1)"
-  path: "Panels/Entry/l_opener_3"
-  clue: "turn"
-  answer: "flip"
-  symbols: SUN
-}
-panels {
-  name: "TURN (2)"
-  path: "Panels/Entry/l_opener_4"
-  clue: "turn"
-  answer: "spin"
-  symbols: SUN
-}
\ No newline at end of file
+# The fact that the doors here cover up the panels once they open is a problem
+# since you're not guaranteed to have access to the lower area if painting
+# shuffle is a thing. So we need to edit these doors so that they don't cover up
+# the panels.
@@ -21,10 +21,3 @@ paintings {
   gravity: Y_PLUS
   display_name: "Eye Painting"
 }
-ports {
-  name: "FOUR"
-  path: "Components/Warps/worldport9"
-  orientation: "south"
-  gravity: Y_PLUS
-  required_door { name: "Flipped Second Room Right Door" }
-}
\ No newline at end of file
@@ -0,0 +1,9 @@
+name: "Four Rooms Entrance"
+ports {
+  name: "FOUR"
+  display_name: "Flipped Second Room Right Worldport"
+  path: "Components/Warps/worldport9"
+  destination { x: -41 y: 6 z: -17.5 }
+  rotation: 0
+  # This isn't actually Y_PLUS gravity! A nearby warp sneakily flips you.
+}
@@ -9,6 +9,8 @@ panels {
 }
 ports {
   name: "GALLERY"
+  display_name: "Gallery Return"
   path: "Components/Warps/worldport4"
-  orientation: "north"
+  destination { x: -38 y: 0 z: 8.5 }
+  rotation: 180
 }
\ No newline at end of file
@@ -72,8 +72,10 @@ panels {
 }
 ports {
   name: "DARKROOM"
+  display_name: "Near L1 Worldport"
   path: "Components/Warps/worldport5"
-  orientation: "south"
+  destination { x: 43 y: 0 z: -10 }
+  rotation: 0
 }
 paintings {
   name: "PAINS"
@@ -0,0 +1,9 @@
+name: "Liberated Entrance Panel"
+panel_display_name: "Pyramid Area"
+panels {
+  name: "TURN (1)"
+  path: "Panels/Entry/l_opener_3"
+  clue: "turn"
+  answer: "flip"
+  symbols: SUN
+}
@@ -0,0 +1,8 @@
+name: "Liberated Entrance"
+ports {
+  name: "BLUE"
+  display_name: "Pyramid Area Blue Worldport"
+  path: "worldport8"
+  destination { x: 18 y: 0 z: 55 }
+  rotation: 270
+}
@@ -19,9 +19,3 @@ panels {
   answer: "white"
   symbols: EXAMPLE
 }
-ports {
-  name: "REVITALIZED"
-  path: "worldport7"
-  orientation: "north"
-  required_door { name: "Revitalized Entrance" }
-}
\ No newline at end of file
@@ -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,9 @@
+name: "Literate Entrance Panel"
+panel_display_name: "Pyramid Area"
+panels {
+  name: "TURN (2)"
+  path: "Panels/Entry/l_opener_4"
+  clue: "turn"
+  answer: "spin"
+  symbols: SUN
+}
@@ -0,0 +1,8 @@
+name: "Literate Entrance"
+ports {
+  name: "BROWN"
+  display_name: "Pyramid Area Brown Worldport"
+  path: "worldport9"
+  destination { x: 39 y: 0 z: 55 }
+  rotation: 90
+}
@@ -9,6 +9,8 @@ panels {
 }
 ports {
   name: "PARTHENON"
+  display_name: "Parthenon Return"
   path: "Components/Warps/worldport8"
-  orientation: "north"
-}
\ No newline at end of file
+  destination { x: -5.5 y: 0 z: 18 }
+  rotation: 180
+}
@@ -1,13 +1,15 @@
 name: "Rabbit Hole"
 panel_display_name: "Red Blue Area"
 panels {
-  name: "PUZZLE"
+  name: "Blank"
   path: "Panels/Back Right/br_6"
   clue: ""
   answer: "down"
 }
 ports {
   name: "HOLE"
+  display_name: "Rabbit Hole"
   path: "worldport4"
-  orientation: "down"
-}
\ No newline at end of file
+  destination { x: 74 y: 0 z: -43 }
+  rotation: 0
+}
@@ -2,6 +2,8 @@ name: "Repetitive Entrance"
 panel_display_name: "Starting Room"
 ports {
   name: "REPETITIVE"
+  display_name: "Starting Room West Wall North Worldport"
   path: "Components/Warps/worldport7"
-  orientation: "north"
+  destination { x: -20 y: 0 z: -16 }
+  rotation: 180
 }
@@ -0,0 +1,9 @@
+name: "Revitalized Entrance"
+panel_display_name: "Colored Doors Area"
+ports {
+  name: "REVITALIZED"
+  display_name: "Plum Hallway"
+  path: "worldport7"
+  destination { x: -58 y: 0 z: 31.5 }
+  rotation: 180
+}
@@ -1,5 +1,5 @@
 name: "Shop Entrance"
-panel_display_name: "Starting Room"
+panel_display_name: "Shop Entrance"
 panels {
   name: "TURN"
   path: "Panels/Entry/l_opener_2"
@@ -9,6 +9,8 @@ panels {
 }
 ports {
   name: "SHOP"
+  display_name: "Shop Entrance"
   path: "Components/Warps/worldport13"
-  orientation: "east"
+  destination { x: 18 y: 0 z: 49 }
+  rotation: 90
 }
\ No newline at end of file
@@ -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"
@@ -44,6 +46,25 @@ panels {
   clue: "than"
   answer: "than"
 }
+panels {
+  name: "Gift Maps"
+  # TODO: exclude from panelsanity
+  path: "Components/GiftMapEntrance/Panel"
+  clue: "player"
+  answer: ""
+  # The puzzle solution doesn't matter. We'll change it to the player's name
+  # for fun.
+  symbols: QUESTION
+  proxies { answer: "gongus" path: "Components/GiftMapEntrance/GongusPanel" }
+  proxies { answer: "hatkirby" path: "Components/GiftMapEntrance/HatkirbyPanel" }
+  proxies { answer: "icely" path: "Components/GiftMapEntrance/IcelyPanel" }
+  proxies { answer: "kirby" path: "Components/GiftMapEntrance/KirbyPanel" }
+  proxies { answer: "kiwi" path: "Components/GiftMapEntrance/KiwiPanel" }
+  proxies { answer: "q" path: "Components/GiftMapEntrance/QPanel" }
+  proxies { answer: "souvey" path: "Components/GiftMapEntrance/SouveyPanel" }
+  proxies { answer: "star" path: "Components/GiftMapEntrance/StarPanel" }
+  required_door { name: "Gift Maps Entrance" }
+}
 letters {
   key: "h"
   path: "Components/Collectables/h"
@@ -2,6 +2,8 @@ name: "White Hallway To Daedalus"
 panel_display_name: "Colored Doors Area"
 ports {
   name: "DAEDALUS"
+  display_name: "White Control Center Hallway"
   path: "Components/Warps/worldport11"
-  orientation: "west"
+  destination { x: -45 y: 0 z: 24 }
+  rotation: 270
 }
@@ -6,6 +6,8 @@ letters {
 }
 ports {
   name: "CC"
+  display_name: "Near X1 Worldport"
   path: "Components/Warps/worldport3"
-  orientation: "west"
+  destination { x: -12.5 y: 0 z: 60 }
+  rotation: 270
 }
@@ -22,7 +22,9 @@ paintings {
 }
 ports {
   name: "GALLERY"
+  display_name: "Engine Room Worldport"
   path: "Components/Warps/worldport2"
   gravity: Z_PLUS
-  # TODO: orientation is not well defined with Z-axis gravity
+  # TODO: entrance shuffling for non Y_MINUS gravity
+  no_shuffle: true
 }
@@ -0,0 +1,5 @@
+connections {
+  from_room: "Main Area"
+  to_room: "Mastery"
+  door { name: "Mastery Door" }
+}
@@ -0,0 +1,29 @@
+doors {
+  name: "Black Panels"
+  type: LOCATION_ONLY
+  panels { room: "Main Area" name: "WHERETO" }
+  panels { room: "Main Area" name: "COMBINED" }
+  location_room: "Main Area"
+}
+doors {
+  name: "Green Panels"
+  type: LOCATION_ONLY
+  panels { room: "Main Area" name: "ACHIEVES" }
+  panels { room: "Main Area" name: "BEFORE" }
+  panels { room: "Main Area" name: "Blank" }
+  panels { room: "Main Area" name: "BOTH" }
+  panels { room: "Main Area" name: "CAGED" }
+  panels { room: "Main Area" name: "DICE" }
+  panels { room: "Main Area" name: "FIRST" }
+  panels { room: "Main Area" name: "FORGED" }
+  panels { room: "Main Area" name: "LOTTO" }
+  panels { room: "Main Area" name: "TOED" }
+  panels { room: "Main Area" name: "TUTU" }
+  panels { room: "Main Area" name: "UNVEILED" }
+  location_room: "Main Area"
+}
+doors {
+  name: "Mastery Door"
+  type: EVENT
+  panels { room: "Main Area" name: "OTHERS" }
+}
@@ -0,0 +1,4 @@
+display_name: "The Fuzzy"
+type: GIFT_MAP
+# The map's mastery is created at runtime.
+custom_nodes: "Components/Collectables/collectable"
@@ -0,0 +1,119 @@
+name: "Main Area"
+panels {
+  name: "Blank"
+  path: "Panels/Room_1/panel_1"
+  clue: ""
+  answer: "2475"
+  symbols: LINGO
+  symbols: QUESTION
+}
+panels {
+  name: "TUTU"
+  path: "Panels/Room_1/panel_2"
+  clue: "tutu"
+  answer: "22"
+  symbols: ZERO
+  symbols: EVAL
+}
+panels {
+  name: "LOTTO"
+  path: "Panels/Room_1/panel_3"
+  clue: "lotto"
+  answer: "22222222"
+  symbols: ZERO
+  symbols: EVAL
+}
+panels {
+  name: "WHERETO"
+  path: "Panels/Room_1/panel_10"
+  clue: "whereto"
+  answer: "sides"
+  symbols: QUESTION
+}
+panels {
+  name: "DICE"
+  path: "Panels/Room_1/panel_11"
+  clue: "dice"
+  answer: "4935"
+  symbols: QUESTION
+}
+panels {
+  name: "CAGED"
+  path: "Panels/Room_1/panel_12"
+  clue: "caged"
+  answer: "31754"
+  symbols: QUESTION
+}
+panels {
+  name: "BEFORE"
+  path: "Panels/Room_1/panel_13"
+  clue: "before"
+  answer: "100"
+  symbols: ZERO
+  symbols: EVAL
+}
+panels {
+  name: "TOED"
+  path: "Panels/Room_1/panel_14"
+  clue: "toed"
+  answer: "108"
+  symbols: ZERO
+  symbols: EVAL
+}
+panels {
+  name: "FORGED"
+  path: "Panels/Room_1/panel_15"
+  clue: "forged"
+  answer: "3016"
+  symbols: ZERO
+  symbols: EVAL
+}
+panels {
+  name: "OTHERS"
+  path: "Panels/Room_1/panel_4"
+  clue: "others"
+  answer: "34390869"
+  symbols: QUESTION
+}
+panels {
+  name: "COMBINED"
+  path: "Panels/Room_1/panel_9"
+  clue: "combined"
+  answer: "added"
+  symbols: SUN
+}
+panels {
+  name: "ACHIEVES"
+  path: "Panels/Room_1/panel_5"
+  clue: "achieves"
+  answer: "4214"
+  symbols: QUESTION
+}
+panels {
+  name: "UNVEILED"
+  path: "Panels/Room_1/panel_6"
+  clue: "unveiled"
+  answer: "12122021"
+  symbols: QUESTION
+}
+panels {
+  name: "FIRST"
+  path: "Panels/Room_1/panel_8"
+  clue: "first"
+  answer: "1"
+  symbols: QUESTION
+}
+panels {
+  name: "BOTH"
+  path: "Panels/Room_1/panel_7"
+  clue: "both"
+  answer: "2"
+  symbols: QUESTION
+}
+ports {
+  name: "WORLDPORT"
+  display_name: "Entrance"
+  path: "Components/Warps/worldport"
+  destination { x: 0 y: 0 z: 9 }
+  rotation: 0
+}
@@ -0,0 +1,5 @@
+name: "Mastery"
+masteries {
+  name: "MASTERY"
+  path: "Components/Collectables/collectable"
+}
@@ -1,9 +1,9 @@
 # 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"
+  receivers: "Components/Listeners/Hint Room/unlockReaderListenerDarkroom"
   panels { map: "the_darkroom" room: "First Room" name: "BISON" }
   panels { map: "the_darkroom" room: "First Room" name: "FISH" }
   panels { map: "the_darkroom" room: "First Room" name: "SHEEP" }
@@ -27,16 +27,16 @@ doors {
 }
 doors {
   name: "Butterfly Painting"
-  type: ITEM_ONLY
+  type: GALLERY_PAINTING
   #move_paintings { room: "Main Area" name: "BUTTERFLY" }
-  receivers: "Components/Paintings/butterfly/teleportListener"
+  receivers: "Components/Listeners/Hint Room/unlockReaderListenerButterfly"
   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"
+  receivers: "Components/Listeners/Hint Room/unlockReaderListenerBetween"
   panels { map: "the_between" room: "Main Area" name: "SUN" }
   panels { map: "the_between" room: "Main Area" name: "KOI" }
   panels { map: "the_between" room: "Main Area" name: "SUN KOI" }
@@ -70,16 +70,16 @@ doors {
 }
 doors {
   name: "Entry Painting"
-  type: ITEM_ONLY
+  type: GALLERY_PAINTING
   #move_paintings { room: "Main Area" name: "ENTRY" }
-  receivers: "Components/Paintings/eyes/teleportListener"
+  receivers: "Components/Listeners/Hint Room/unlockReaderListenerEyes"
   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"
+  receivers: "Components/Listeners/Hint Room/unlockReaderListenerTriangle"
   panels { map: "the_wise" room: "Entry" name: "INK" }
   panels { map: "the_wise" room: "Puzzles" name: "STORY" }
   panels { map: "the_wise" room: "Puzzles" name: "VENTURE" }
@@ -105,9 +105,9 @@ 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"
+  receivers: "Components/Listeners/Hint Room/unlockReaderListenerTree"
   panels { map: "the_tree" room: "Main Area" name: "COLOR" }
   panels { map: "the_tree" room: "Main Area" name: "DAMAGE (1)" }
   panels { map: "the_tree" room: "Main Area" name: "DAMAGE (2)" }
@@ -142,37 +142,37 @@ 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"
+  receivers: "Components/Listeners/Hint Room/unlockReaderListenerUnyielding"
   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"
+  receivers: "Components/Listeners/Endings/unlockReaderListenerGraveyard"
   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"
+  receivers: "Components/Listeners/Endings/unlockReaderListenerDesert"
   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"
+  receivers: "Components/Listeners/Endings/unlockReaderListenerTower"
   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"
+  receivers: "Components/Listeners/Endings/unlockReaderListenerWonderland"
   panels { map: "the_wondrous" room: "Entry" name: "WONDER" }
   panels { map: "the_wondrous" room: "Regular" name: "SHRINK" }
   panels { map: "the_wondrous" room: "Huge" name: "SHRINK" }
@@ -187,44 +187,44 @@ doors {
 }
 doors {
   name: "Rainbow Painting"
-  type: ITEM_ONLY
+  type: GALLERY_PAINTING
   #move_paintings { room: "Main Area" name: "RAINBOW" }
-  receivers: "Components/Paintings/Endings/rainbow/teleportListener"
+  receivers: "Components/Listeners/Endings/unlockReaderListenerRainbow"
   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"
+  receivers: "Components/Listeners/Endings/unlockReaderListenerWords"
   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"
+  receivers: "Components/Listeners/Endings/unlockReaderListenerColorful"
   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"
+  receivers: "Components/Listeners/Endings/unlockReaderListenerCastle"
   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"
+  receivers: "Components/Listeners/Endings/unlockReaderListenerTemple"
   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"
+  receivers: "Components/Listeners/Endings/unlockReaderListenerQuartz"
   rooms { map: "the_ancient" name: "Outside" }
 }
 doors {
@@ -255,7 +255,8 @@ doors {
   doors { name: "Castle Painting" }
   doors { name: "Sun Temple Painting" }
   doors { name: "Ancient Painting" }
-  doors { name: "Gallery Extension" }
+  panels { room: "Daedalus Extension" name: "WHERE" }
+  double_letters: true
 }
 doors {
   name: "Ending Door"
@@ -162,6 +162,8 @@ paintings {
 }
 ports {
   name: "ENTRY"
+  display_name: "Entrance"
   path: "Components/Warps/worldport"
-  orientation: "west"
+  destination { x: -3.5 y: 0 z: 16 }
+  rotation: 270
 }
@@ -0,0 +1,7 @@
+doors {
+  name: "The Panel"
+  type: LOCATION_ONLY
+  panels { room: "The Whole Thing" name: "PANEL" }
+  location_room: "The Whole Thing"
+  location_name: "Panel"
+}
@@ -23,3 +23,10 @@ doors {
   receivers: "Components/Paintings/omrt/teleportListener"
   double_letters: true
 }
+doors {
+  name: "Remember Panel"
+  type: LOCATION_ONLY
+  panels { room: "Inside" name: "REMEMBER" }
+  location_room: "Inside"
+  location_name: "REMEMBER"
+}
@@ -256,3 +256,7 @@ connections {
   to_room: "Zero Room"
   door { name: "Lavender Cube" }
 }
+connections {
+  from_room: "Back Area"
+  to_room: "The Landscapes"
+}
@@ -29,6 +29,15 @@ doors {
   location_room: "Main Area"
 }
 doors {
+  name: "Near Linear Panels"
+  type: LOCATION_ONLY
+  panels { room: "Main Area" name: "DEW" }
+  panels { room: "Main Area" name: "EWE" }
+  panels { room: "Main Area" name: "NO" }
+  location_room: "Main Area"
+  location_name: "DEW, EWE, NO"
+}
+doors {
   name: "Courtyard Entrance"
   type: STANDARD
   receivers: "Components/Doors/entry_1"
@@ -54,19 +63,22 @@ doors {
 doors {
   name: "Control Center Purple Door"
   type: CONTROL_CENTER_COLOR
+  latch: true
   receivers: "Components/Doors/entry_23"
   control_center_color: "purple"
 }
 doors {
   name: "Control Center Gray Door"
   type: CONTROL_CENTER_COLOR
-  receivers: "Components/Doors/Gates/Gate"
+  latch: true
+  receivers: "Components/Doors/Gates/Gate/animationListener"
   control_center_color: "gray"
 }
 doors {
   name: "Control Center Red Door"
   type: CONTROL_CENTER_COLOR
-  receivers: "Components/Doors/Gates/Gate"
+  latch: true
+  receivers: "Components/Doors/entry_18"
   control_center_color: "red"
 }
 doors {
@@ -124,6 +136,7 @@ doors {
   panels { room: "Magnet Room" name: "SAW" }
   panels { room: "Magnet Room" name: "BLENDER" }
   location_room: "Magnet Room"
+  location_name: "Gravestone"
 }
 doors {
   name: "Hive Entrance"
@@ -205,23 +218,25 @@ doors {
   panels { room: "Jail Part 2" name: "GRIMACE" }
   panels { room: "Jail Part 2" name: "COMMENCE" }
   location_room: "Jail Part 2"
+  location_name: "Gravestone"
 }
 doors {
   name: "The Landscapes Gravestone"
   type: GRAVESTONE
-  panels { room: "Back Area" name: "Top Landscape Top" }
-  panels { room: "Back Area" name: "Top Landscape Right" }
-  panels { room: "Back Area" name: "Top Landscape Bottom" }
-  panels { room: "Back Area" name: "Top Landscape Left" }
-  panels { room: "Back Area" name: "Left Landscape Top" }
-  panels { room: "Back Area" name: "Left Landscape Right" }
-  panels { room: "Back Area" name: "Left Landscape Bottom" }
-  panels { room: "Back Area" name: "Left Landscape Left" }
-  panels { room: "Back Area" name: "Right Landscape Top" }
-  panels { room: "Back Area" name: "Right Landscape Right" }
-  panels { room: "Back Area" name: "Right Landscape Bottom" }
-  panels { room: "Back Area" name: "Right Landscape Left" }
-  location_room: "Back Area"
+  panels { room: "The Landscapes" name: "Top Landscape Top" }
+  panels { room: "The Landscapes" name: "Top Landscape Right" }
+  panels { room: "The Landscapes" name: "Top Landscape Bottom" }
+  panels { room: "The Landscapes" name: "Top Landscape Left" }
+  panels { room: "The Landscapes" name: "Left Landscape Top" }
+  panels { room: "The Landscapes" name: "Left Landscape Right" }
+  panels { room: "The Landscapes" name: "Left Landscape Bottom" }
+  panels { room: "The Landscapes" name: "Left Landscape Left" }
+  panels { room: "The Landscapes" name: "Right Landscape Top" }
+  panels { room: "The Landscapes" name: "Right Landscape Right" }
+  panels { room: "The Landscapes" name: "Right Landscape Bottom" }
+  panels { room: "The Landscapes" name: "Right Landscape Left" }
+  location_room: "The Landscapes"
+  location_name: "Gravestone"
 }
 doors {
   name: "Tower Entrance"
@@ -318,6 +333,7 @@ doors {
   panels { room: "Maze Up Area" name: "UP" }
   panels { room: "Maze Wreck Area" name: "WRECK" }
   location_room: "Maze Slice Area"
+  location_name: "Gravestone"
 }
 doors {
   name: "Courtyard Side Door"
@@ -410,7 +426,8 @@ doors {
 }
 doors {
   name: "Question Room Back Door"
-  type: STANDARD
+  type: ITEM_ONLY
+  legacy_location: true
   receivers: "Components/Doors/question_11"
   panels { room: "Behind Question Area" name: "YEW" answer: "ewe" }
   location_room: "Behind Question Area"
@@ -419,10 +436,10 @@ doors {
   name: "Invisible Entrance"
   type: STANDARD
   receivers: "Components/Doors/entry_36"
-  panels { room: "Back Area" name: "Right Landscape Top" answer: "tell" }
-  panels { room: "Back Area" name: "Right Landscape Left" answer: "eyes" }
-  location_room: "Back Area"
-  location_name: "Landscapes Room Alternate Answers"
+  panels { room: "The Landscapes" name: "Right Landscape Top" answer: "tell" }
+  panels { room: "The Landscapes" name: "Right Landscape Left" answer: "eyes" }
+  location_room: "The Landscapes"
+  location_name: "Alternate Answers"
 }
 doors {
   name: "Nature Room Door"
@@ -468,12 +485,17 @@ doors {
   panels { room: "Whole Room" name: "CHIPS" }
   panels { room: "Whole Room" name: "TOWER" }
   location_room: "Whole Room"
+  location_name: "Gravestone"
 }
 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"
@@ -490,6 +512,7 @@ doors {
   panels { room: "Zero Room" name: "MANY" }
   panels { room: "Zero Room" name: "REMAINING" }
   location_room: "Zero Room"
+  location_name: "Panels"
 }
 doors {
   name: "Spiral Painting"
@@ -498,3 +521,110 @@ 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" }
+}
+doors {
+  name: "Why Is It Not Red"
+  type: LOCATION_ONLY
+  panels { room: "Main Area" name: "WHY" }
+  panels { room: "Main Area" name: "IS" }
+  panels { room: "Main Area" name: "IT" }
+  panels { room: "Main Area" name: "NOT" }
+  panels { room: "Main Area" name: "RED" }
+  location_room: "Main Area"
+  location_name: "WHY, IS, IT, NOT, RED"
+}
+doors {
+  name: "Control Center Gray Panel"
+  type: LOCATION_ONLY
+  panels { room: "Main Area" name: "COLOR" }
+  location_room: "Main Area"
+  location_name: "COLOR"
+}
+doors {
+  name: "Control Center Purple Panel"
+  type: LOCATION_ONLY
+  panels { room: "East Landscape" name: "COLOR" }
+  location_room: "East Landscape"
+  location_name: "COLOR"
+}
+doors {
+  name: "Control Center Red Panel"
+  type: LOCATION_ONLY
+  panels { room: "West Side" name: "COLOR" }
+  location_room: "West Side"
+  location_name: "COLOR"
+}
+doors {
+  name: "Mistreat Panel"
+  type: LOCATION_ONLY
+  panels { room: "East Landscape" name: "MISTREAT" }
+  location_room: "East Landscape"
+  location_name: "MISTREAT"
+}
+doors {
+  name: "Tower Panels"
+  type: LOCATION_ONLY
+  panels { room: "Back Area" name: "TOWEL" }
+  panels { room: "Maze Tower" name: "SPIRE" }
+  location_room: "Maze Tower"
+  location_name: "SPIRE, TOWEL"
+}
+doors {
+  name: "Tree Panels"
+  type: LOCATION_ONLY
+  panels { room: "Back Area" name: "PLANT" }
+  panels { room: "Back Area" name: "TREE" }
+  location_room: "Back Area"
+  location_name: "PLANT, TREE"
+}
+doors {
+  name: "Behind Question Room Panels"
+  type: LOCATION_ONLY
+  panels { room: "Behind Question Area" name: "DEW" }
+  panels { room: "Behind Question Area" name: "YEW" answer: "ewe" }
+  panels { room: "Behind Question Area" name: "NO" }
+  location_room: "Behind Question Area"
+  location_name: "DEW, YEW/EWE, NO"
+}
+doors {
+  name: "Broken Shed Panels"
+  type: LOCATION_ONLY
+  panels { room: "North Landscape" name: "LAUGH" }
+  panels { room: "North Landscape" name: "FINISHED" }
+  panels { room: "North Landscape" name: "LAUGH FINISHED" }
+  location_room: "North Landscape"
+  location_name: "LAUGH, FINISHED, LAUGH FINISHED"
+}
+doors {
+  name: "Nature Panels"
+  type: LOCATION_ONLY
+  panels { room: "North Landscape" name: "WEATHER" }
+  panels { room: "North Landscape" name: "ANIMALS" }
+  panels { room: "North Landscape" name: "PLANTS" }
+  location_room: "North Landscape"
+  location_name: "ANIMALS, PLANTS, WEATHER"
+}
+doors {
+  name: "Teal Panel"
+  type: LOCATION_ONLY
+  panels { room: "Maze Wreck Area" name: "MAROON" }
+  location_room: "Maze Wreck Area"
+  location_name: "MAROON"
+}
+doors {
+  name: "Behind Orb Panel"
+  type: LOCATION_ONLY
+  panels { room: "Main Area" name: "BROWN RED ORANGE" }
+  location_room: "Main Area"
+  location_name: "Brown Red Orange"
+}
@@ -28,92 +28,6 @@ panels {
   answer: "tower"
   symbols: SPARKLES
 }
-panels {
-  name: "Top Landscape Top"
-  path: "Panels/Kiwi Room/kiwi_1"
-  clue: ""
-  answer: "one"
-  symbols: QUESTION
-}
-panels {
-  name: "Top Landscape Right"
-  path: "Panels/Kiwi Room/kiwi_2"
-  clue: ""
-  answer: "road"
-  symbols: QUESTION
-}
-panels {
-  name: "Top Landscape Bottom"
-  path: "Panels/Kiwi Room/kiwi_3"
-  clue: ""
-  answer: "many"
-  symbols: QUESTION
-}
-panels {
-  name: "Top Landscape Left"
-  path: "Panels/Kiwi Room/kiwi_4"
-  clue: ""
-  answer: "turns"
-  symbols: QUESTION
-}
-panels {
-  name: "Left Landscape Top"
-  path: "Panels/Kiwi Room/kiwi_5"
-  clue: ""
-  answer: "find"
-  symbols: QUESTION
-}
-panels {
-  name: "Left Landscape Right"
-  path: "Panels/Kiwi Room/kiwi_6"
-  clue: ""
-  answer: "keys"
-  symbols: QUESTION
-}
-panels {
-  name: "Left Landscape Bottom"
-  path: "Panels/Kiwi Room/kiwi_7"
-  clue: ""
-  answer: "write"
-  symbols: QUESTION
-}
-panels {
-  name: "Left Landscape Left"
-  path: "Panels/Kiwi Room/kiwi_8"
-  clue: ""
-  answer: "words"
-  symbols: QUESTION
-}
-panels {
-  name: "Right Landscape Top"
-  path: "Panels/Kiwi Room/kiwi_9"
-  clue: ""
-  answer: "hear"
-  symbols: QUESTION
-  proxies { answer: "tell" path: "Panels/Kiwi Proxies/kiwi_9_proxy_1" }
-}
-panels {
-  name: "Right Landscape Right"
-  path: "Panels/Kiwi Room/kiwi_10"
-  clue: ""
-  answer: "lies"
-  symbols: QUESTION
-}
-panels {
-  name: "Right Landscape Bottom"
-  path: "Panels/Kiwi Room/kiwi_11"
-  clue: ""
-  answer: "the"
-  symbols: QUESTION
-}
-panels {
-  name: "Right Landscape Left"
-  path: "Panels/Kiwi Room/kiwi_12"
-  clue: ""
-  answer: "ears"
-  symbols: QUESTION
-  proxies { answer: "eyes" path: "Panels/Kiwi Proxies/kiwi_12_proxy_1" }
-}
 paintings {
   name: "SPIRAL"
   path: "Components/Paintings/spiral"
@@ -124,23 +38,31 @@ paintings {
 }
 ports {
   name: "UNKEMPT"
+  display_name: "Unkempt Entrance"
   path: "Meshes/Blocks/Warps/worldport5"
-  orientation: "north"
+  destination { x: 72 y: 0 z: 10.5 }
+  rotation: 180
 }
 ports {
   name: "THREEDOORS"
+  display_name: "Three Doors Entrance"
   path: "Meshes/Blocks/Warps/worldport16"
-  orientation: "south"
+  destination { x: 77 y: 0 z: 33.5 }
+  rotation: 0
 }
 ports {
   name: "TOWER"
+  display_name: "Tower Entrance"
   path: "Meshes/Blocks/Warps/worldport10"
-  orientation: "south"
+  destination { x: 0 y: 0 z: 52 }
+  rotation: 0
   required_door { name: "Tower Entrance" }
   # The reverse warp bypasses the door, so there needs to be two oneway connections.
 }
 ports {
   name: "TREE"
+  display_name: "Tree Entrance"
   path: "Meshes/Blocks/Warps/worldport17"
-  orientation: "north"
+  destination { x: 26 y: 0 z: 58 }
+  rotation: 180
 }
@@ -2,6 +2,8 @@ name: "Colorful Entrance"
 panel_display_name: "Pillar Room"
 ports {
   name: "COLORFUL"
+  display_name: "Pillar Room Worldport"
   path: "Meshes/Blocks/Warps/worldport13"
-  orientation: "west"
+  destination { x: -37.5 y: 0 z: 74 }
+  rotation: 270
 }
@@ -9,8 +9,10 @@ panels {
 }
 ports {
   name: "DAEDALUS"
+  display_name: "Daedalus Entrance"
   path: "Meshes/Blocks/Warps/worldport8"
-  orientation: "south"
+  destination { x: 98 y: 2 z: 27.5 }
+  rotation: 0
   required_door { name: "Daedalus Entrance" }
   # The reverse warp bypasses the door, so there needs to be two oneway connections.
 }
@@ -9,6 +9,8 @@ panels {
 }
 ports {
   name: "HIVE"
+  display_name: "Hive Entrance"
   path: "Meshes/Blocks/Warps/worldport19"
-  orientation: "east"
+  destination { x: -91.5 y: 0 z: 37 }
+  rotation: 90
 }
@@ -2,6 +2,8 @@ name: "Jubilant Entrance"
 panel_display_name: "West Side"
 ports {
   name: "JUBILANT"
+  display_name: "Jubilant Entrance"
   path: "Meshes/Blocks/Warps/worldport12"
-  orientation: "east"
+  destination { x: -62 y: 0 z: -19 }
+  rotation: 90
 }
@@ -111,6 +111,7 @@ panels {
   answer: "high"
   symbols: SUN
   symbols: ZERO
+  required_door { name: "Cyan Doors" }
 }
 panels {
   name: "CURT"
@@ -121,27 +122,37 @@ panels {
 }
 ports {
   name: "ENTRY"
+  display_name: "Entry Building"
   path: "Meshes/Blocks/Warps/worldport"
-  orientation: "south"
+  destination { x: 33 y: 0 z: 15 }
+  rotation: 0
 }
 ports {
   name: "KEEN"
+  display_name: "Keen Building Front"
   path: "Meshes/Blocks/Warps/worldport6"
-  orientation: "north"
+  destination { x: 33 y: 0 z: -21 }
+  rotation: 180
 }
 ports {
   name: "ORB"
+  display_name: "Orb Building"
   path: "Meshes/Blocks/Warps/worldport3"
-  orientation: "north"
+  destination { x: 62 y: 0 z: -13 }
+  rotation: 180
 }
 ports {
   name: "LINEAR"
+  display_name: "Keen Building Back"
   path: "Meshes/Blocks/Warps/worldport15"
-  orientation: "south"
+  destination { x: 33 y: 0 z: -42.5 }
+  rotation: 0
 }
 ports {
   name: "DIGITAL"
+  display_name: "Digital Hole"
   path: "Meshes/Blocks/Warps/worldport4"
-  orientation: "down"
+  destination { x: -6.5 y: 0 z: 7.5 }
+  rotation: 0
   required_door { name: "Digital Entrance" }
 }
@@ -1,5 +1,4 @@
 name: "Maze Tower"
-panel_display_name: "Courtyard"
 panels {
   name: "FEEL"
   path: "Panels/Maze/maze_12"
@@ -56,8 +56,9 @@ keyholders {
 }
 ports {
   name: "INVISIBLE"
+  display_name: "Eye Worldport"
   path: "Meshes/Blocks/Warps/worldport20"
-  orientation: "north"
-  # Note that this can be easily entered from the other side.
+  destination { x: 33 y: 0 z: -66.5 }
+  rotation: 0
   required_door { name: "Invisible Entrance" }
 }
@@ -2,6 +2,8 @@ name: "Purple Room"
 panel_display_name: "Main Area"
 ports {
   name: "DAEDALUS"
+  display_name: "Purple Hallway"
   path: "Meshes/Blocks/Warps/worldport18"
-  orientation: "north"
+  destination { x: 158 y: 0 z: 14 }
+  rotation: 180
 }
@@ -2,6 +2,8 @@ name: "Salmon Room"
 panel_display_name: "Main Area"
 ports {
   name: "BETWEEN"
+  display_name: "Salmon Hallway"
   path: "Meshes/Blocks/Warps/worldport11"
-  orientation: "east"
+  destination { x: 83 y: 0 z: -21 }
+  rotation: 90
 }
@@ -2,6 +2,8 @@ name: "Talented Entrance"
 panel_display_name: "Question Room"
 ports {
   name: "TALENTED"
+  display_name: "Under Question Room Worldport"
   path: "Meshes/Blocks/Warps/worldport14"
-  orientation: "south"
+  destination { x: 109 y: -6 z: -26.5 }
+  rotation: 0
 }
@@ -0,0 +1,88 @@
+name: "The Landscapes"
+panel_display_name: "The Landscapes"
+panels {
+  name: "Top Landscape Top"
+  path: "Panels/Kiwi Room/kiwi_1"
+  clue: ""
+  answer: "one"
+  symbols: QUESTION
+}
+panels {
+  name: "Top Landscape Right"
+  path: "Panels/Kiwi Room/kiwi_2"
+  clue: ""
+  answer: "road"
+  symbols: QUESTION
+}
+panels {
+  name: "Top Landscape Bottom"
+  path: "Panels/Kiwi Room/kiwi_3"
+  clue: ""
+  answer: "many"
+  symbols: QUESTION
+}
+panels {
+  name: "Top Landscape Left"
+  path: "Panels/Kiwi Room/kiwi_4"
+  clue: ""
+  answer: "turns"
+  symbols: QUESTION
+}
+panels {
+  name: "Left Landscape Top"
+  path: "Panels/Kiwi Room/kiwi_5"
+  clue: ""
+  answer: "find"
+  symbols: QUESTION
+}
+panels {
+  name: "Left Landscape Right"
+  path: "Panels/Kiwi Room/kiwi_6"
+  clue: ""
+  answer: "keys"
+  symbols: QUESTION
+}
+panels {
+  name: "Left Landscape Bottom"
+  path: "Panels/Kiwi Room/kiwi_7"
+  clue: ""
+  answer: "write"
+  symbols: QUESTION
+}
+panels {
+  name: "Left Landscape Left"
+  path: "Panels/Kiwi Room/kiwi_8"
+  clue: ""
+  answer: "words"
+  symbols: QUESTION
+}
+panels {
+  name: "Right Landscape Top"
+  path: "Panels/Kiwi Room/kiwi_9"
+  clue: ""
+  answer: "hear"
+  symbols: QUESTION
+  proxies { answer: "tell" path: "Panels/Kiwi Proxies/kiwi_9_proxy_1" }
+}
+panels {
+  name: "Right Landscape Right"
+  path: "Panels/Kiwi Room/kiwi_10"
+  clue: ""
+  answer: "lies"
+  symbols: QUESTION
+}
+panels {
+  name: "Right Landscape Bottom"
+  path: "Panels/Kiwi Room/kiwi_11"
+  clue: ""
+  answer: "the"
+  symbols: QUESTION
+}
+panels {
+  name: "Right Landscape Left"
+  path: "Panels/Kiwi Room/kiwi_12"
+  clue: ""
+  answer: "ears"
+  symbols: QUESTION
+  proxies { answer: "eyes" path: "Panels/Kiwi Proxies/kiwi_12_proxy_1" }
+}
@@ -63,17 +63,24 @@ paintings {
 }
 ports {
   name: "IMPRESSIVE"
+  display_name: "Impressive Entrance"
   path: "Meshes/Blocks/Warps/worldport2"
-  orientation: "south"
+  destination { x: -34 y: 0 z: 22.5 }
+  rotation: 0
 }
 ports {
   name: "CC"
+  display_name: "Control Center"
   path: "Meshes/Blocks/Warps/worldport9"
-  orientation: "north"
+  destination { x: -59 y: 0 z: -50.5 }
+  rotation: 180
 }
 ports {
   name: "PARTIAL"
+  display_name: "Red Hallway"
   path: "Meshes/Blocks/Warps/worldport7"
-  orientation: "east"
+  destination { x: -62 y: 0 z: 11 }
+  rotation: 90
   # ER with this is weird; make sure to place on the surface
+  required_door { name: "Partial Entrance" }
 }
@@ -1,5 +1,5 @@
 name: "Whole Room"
-panel_display_name: "North Landscape"
+panel_display_name: "Building Building"
 panels {
   name: "VAULT"
   path: "Panels/Whole Room/whole_1"
@@ -2,11 +2,15 @@ name: "Main Area"
 # I'm probably not going to include any of the panels in here.
 ports {
   name: "RIGHT"
+  display_name: "South Worldport"
   path: "Components/Warps/worldport"
-  orientation: "east"
+  destination { x: 30 y: 0 z: 19 }
+  rotation: 270
 }
 ports {
   name: "LEFT"
+  display_name: "North Worldport"
   path: "Components/Warps/worldport2"
-  orientation: "east"
+  destination { x: 30 y: 0 z: -76 }
+  rotation: 270
 }
@@ -272,21 +272,29 @@ keyholders {
 }
 ports {
   name: "DAED1"
+  display_name: "Blue Area Worldport"
   path: "Components/Warps/worldport"
-  orientation: "west"
+  destination { x: -1.5 y: 0 z: 24 }
+  rotation: 270
 }
 ports {
   name: "DAED2"
+  display_name: "Pink Area South Worldport"
   path: "Components/Warps/worldport2"
-  orientation: "west"
+  destination { x: -26.5 y: 0 z: -22 }
+  rotation: 270
 }
 ports {
   name: "DAED3"
+  display_name: "Lime Area Worldport"
   path: "Components/Warps/worldport3"
-  orientation: "east"
+  destination { x: -44.5 y: 0 z: -13 }
+  rotation: 90
 }
 ports {
   name: "GREAT"
+  display_name: "Pink Area North Worldport"
   path: "Components/Warps/worldport4"
-  orientation: "west"
+  destination { x: -29.5 y: 0 z: -62 }
+  rotation: 270
 }
@@ -30,8 +30,25 @@ doors {
   panels { room: "Green Eye" name: "LEFT" }
 }
 doors {
+  name: "Green Eye Panels"
+  type: LOCATION_ONLY
+  panels { room: "Green Eye" name: "RETURN" }
+  panels { room: "Green Eye" name: "TO" }
+  panels { room: "Green Eye" name: "LEFT" }
+  location_room: "Green Eye"
+  location_name: "RETURN, TO, LEFT"
+}
+doors {
   name: "Control Center Green Door"
   type: CONTROL_CENTER_COLOR
+  latch: true
   receivers: "Components/Doors/entry_2"
   control_center_color: "green"
 }
+doors {
+  name: "Control Center Green Panel"
+  type: LOCATION_ONLY
+  panels { room: "Side Area" name: "COLOR" }
+  location_room: "Side Area"
+  location_name: "COLOR"
+}
@@ -22,6 +22,8 @@ panels {
 }
 ports {
   name: "PLAZA"
+  display_name: "Green Hallway"
   path: "Components/Warps/worldport3"
-  orientation: "east"
+  destination { x: -33 y: 0 z: 1 }
+  rotation: 90
 }
@@ -9,6 +9,8 @@ panels {
 }
 ports {
   name: "GREAT"
+  display_name: "Main Entrance"
   path: "Components/Warps/worldport"
-  orientation: "south"
+  destination { x: 0 y: 0 z: 11.5 }
+  rotation: 0
 }
@@ -9,6 +9,8 @@ panels {
 }
 ports {
   name: "FOURROOMS"
+  display_name: "Four Rooms Entrance"
   path: "Components/Warps/worldport2"
-  orientation: "south"
+  destination { x: -27 y: 0 z: 25.5 }
+  rotation: 0
 }
@@ -8,6 +8,8 @@ panels {
 }
 ports {
   name: "ENTRY"
+  display_name: "Entrance"
   path: "Components/Warps/worldport2"
-  orientation: "north"
+  destination { x: 0 y: 0 z: -57 }
+  rotation: 180
 }
@@ -5,6 +5,9 @@ masteries {
 }
 ports {
   name: "ENTRY"
+  display_name: "Exit"
   path: "Components/Warps/worldport"
-  orientation: "south"
+  # Should this be shuffleable? It skips the maze lol.
+  destination { x: 0 y: 0 z: 9.5 }
+  rotation: 0
 }
@@ -31,3 +31,14 @@ doors {
   panels { room: "Main Area" name: "QUEEN" answer: "jack" }
   location_room: "Main Area"
 }
+doors {
+  name: "Side Room Puzzles"
+  type: LOCATION_ONLY
+  panels { room: "Side Area" name: "CALLBACK" }
+  panels { room: "Side Area" name: "CALL" }
+  panels { room: "Side Area" name: "PUSHBACK" }
+  panels { room: "Side Area" name: "PUSH" }
+  panels { room: "Side Area" name: "FLASHBACK" }
+  panels { room: "Side Area" name: "FLASH" }
+  location_room: "Side Area"
+}
@@ -1 +1,5 @@
 display_name: "The Jubilant"
+worldport_entrance {
+  room: "Main Area"
+  name: "GREAT"
+}
@@ -97,6 +97,8 @@ panels {
 }
 ports {
   name: "GREAT"
+  display_name: "Entrance"
   path: "Components/Warps/worldport"
-  orientation: "west"
+  destination { x: -3 y: 0 z: 9 }
+  rotation: 270
 }
@@ -1 +1,5 @@
 display_name: "The Keen"
+worldport_entrance {
+  room: "Main Area"
+  name: "GREAT"
+}
@@ -69,6 +69,8 @@ panels {
 }
 ports {
   name: "GREAT"
+  display_name: "Entrance"
   path: "Components/Warps/worldport"
-  orientation: "south"
+  destination { x: 0 y: 0 z: 7.5 }
+  rotation: 0
 }
@@ -1 +1,5 @@
 display_name: "The Liberated"
+worldport_entrance {
+  room: "Puzzle Room"
+  name: "ENTRY"
+}
@@ -57,6 +57,8 @@ panels {
 }
 ports {
   name: "ENTRY"
+  display_name: "Entrance"
   path: "Components/Warps/worldport"
-  orientation: "south"
+  destination { x: 0 y: 0 z: 7.5 }
+  rotation: 0
 }
@@ -1 +1,5 @@
 display_name: "The Linear"
+worldport_entrance {
+  room: "Room"
+  name: "GREAT"
+}
@@ -57,6 +57,8 @@ panels {
 }
 ports {
   name: "GREAT"
+  display_name: "Entrance"
   path: "Components/Warps/worldport"
-  orientation: "south"
+  destination { x: 0 y: 0 z: 7.5 }
+  rotation: 0
 }
@@ -1 +1,5 @@
 display_name: "The Lionized"
+worldport_entrance {
+  room: "Puzzle Room"
+  name: "ENTRY"
+}
@@ -57,6 +57,8 @@ panels {
 }
 ports {
   name: "ENTRY"
+  display_name: "Entrance"
   path: "Components/Warps/worldport"
-  orientation: "south"
+  destination { x: 0 y: 0 z: 6.5 }
+  rotation: 0
 }
@@ -1 +1,5 @@
 display_name: "The Literate"
+worldport_entrance {
+  room: "Puzzle Room"
+  name: "ENTRY"
+}
@@ -57,6 +57,8 @@ panels {
 }
 ports {
   name: "ENTRY"
+  display_name: "Entrance"
   path: "Components/Warps/worldport"
-  orientation: "south"
+  destination { x: 0 y: 0 z: 7.5 }
+  rotation: 0
 }
@@ -1 +1,5 @@
 display_name: "The Lively"
+worldport_entrance {
+  room: "Puzzle Room"
+  name: "BETWEEN"
+}
@@ -57,5 +57,8 @@ panels {
 }
 ports {
   name: "BETWEEN"
+  display_name: "Entrance"
   path: "Components/Warps/worldport"
+  destination { x: 0 y: 0 z: 6.5 }
+  rotation: 0
 }
@@ -1,5 +1,5 @@
 doors {
-  name: "Left Room Puzzles"
+  name: "Blue Side Puzzles"
   type: LOCATION_ONLY
   panels { room: "Main Room" name: "HOARSE" }
   panels { room: "Main Room" name: "NAY" }
@@ -11,7 +11,7 @@ doors {
   location_room: "Main Room"
 }
 doors {
-  name: "Right Room Puzzles"
+  name: "Green Side Puzzles"
   type: LOCATION_ONLY
   panels { room: "Main Room" name: "HOSE" }
   panels { room: "Main Room" name: "NIGH" }
@@ -52,3 +52,10 @@ doors {
   panels { room: "Back Room" name: "LIMB" }
   panels { room: "Back Room" name: "SPARE" }
 }
+doors {
+  name: "Stores Panel"
+  type: LOCATION_ONLY
+  panels { room: "Main Room" name: "TORE" }
+  location_room: "Main Room"
+  location_name: "TORE"
+}
@@ -1 +1,5 @@
 display_name: "The Nuanced"
+worldport_entrance {
+  room: "Main Room"
+  name: "UNYIELDING"
+}
@@ -106,8 +106,10 @@ panels {
 }
 ports {
   name: "UNYIELDING"
+  display_name: "Entrance"
   path: "Components/Warps/worldport"
-  orientation: "west"
+  destination { x: -3.5 y: 0 z: 21 }
+  rotation: 270
 }
 keyholders {
   name: "S"
@@ -10,10 +10,20 @@ connections {
 }
 connections {
   from_room: "Main Area"
-  to_room: "B Room"
+  to_room: "Middle Room"
   door { name: "B Puzzles" }
 }
 connections {
+  from_room: "Middle Room"
+  to_room: "B Room"
+  oneway: true
+}
+connections {
+  from_room: "Middle Room"
+  to_room: "Main Area"
+  oneway: true
+}
+connections {
   from_room: "B Room"
   to_room: "Main Area"
   oneway: true
@@ -9,19 +9,10 @@ paintings {
   # TODO: This is too high up to enter. It's also a hint painting.
   exit_only: true
 }
-# TODO: Should these two be independent for shuffling purposes, or always tied
-# to the Main Area's port?
-ports {
-  name: "MID"
-  path: "Components/Warps/worldport4"
-  orientation: "south"
-  # This port is in the room immediately after solving the B puzzles, which
-  # means it seems like it would be inaccessible if you enter the map from the
-  # painting or from the final port, but entering the O or R areas brings you
-  # back to the beginning.
-}
 ports {
   name: "FINAL"
+  display_name: "Final Worldport"
   path: "Components/Warps/worldport5"
-  orientation: "south"
+  destination { x: -69 y: 0 z: 87 }
+  rotation: 90
 }
@@ -85,6 +85,8 @@ panels {
 }
 ports {
   name: "GREAT"
+  display_name: "Main Entrance"
   path: "Components/Warps/worldport"
-  orientation: "south"
+  destination { x: 38 y: 0 z: 39 }
+  rotation: 90
 }
@@ -0,0 +1,12 @@
+name: "Middle Room"
+# This is the room after solving the B puzzles but before getting to B1 itself.
+# It has to be a separate region because if you are shuffling worldports and you
+# warp to the B1 room port, you can't access this port if you're not able to
+# solve the B puzzles.
+ports {
+  name: "MID"
+  display_name: "Middle Worldport"
+  path: "Components/Warps/worldport4"
+  destination { x: -69 y: 0 z: 43 }
+  rotation: 90
+}
@@ -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"
@@ -1,13 +1,15 @@
 doors {
   name: "Brush Door"
-  type: STANDARD
+  type: ITEM_ONLY
+  legacy_location: true
   receivers: "Components/Doors/entry_1"
   panels { room: "R2C2 Top" name: "CRUSH" }
   location_room: "R2C2 Top"
 }
 doors {
   name: "Sky Top Doors"
-  type: STANDARD
+  type: ITEM_ONLY
+  legacy_location: true
   receivers: "Components/Doors/entry_2"
   receivers: "Components/Doors/entry_4"
   panels { room: "R2C1 Left" name: "VERB" }
@@ -15,7 +17,8 @@ doors {
 }
 doors {
   name: "Sky Bottom Doors"
-  type: STANDARD
+  type: ITEM_ONLY
+  legacy_location: true
   receivers: "Components/Doors/entry_3"
   receivers: "Components/Doors/entry_5"
   panels { room: "R2C1 Left" name: "FOIL" }
@@ -23,21 +26,24 @@ doors {
 }
 doors {
   name: "First Room Shortcut"
-  type: STANDARD
+  type: ITEM_ONLY
+  legacy_location: true
   receivers: "Components/Doors/entry_6"
   panels { room: "Connected Area" name: "FIZZLE" }
   location_room: "Connected Area"
 }
 doors {
   name: "First Door"
-  type: STANDARD
+  type: ITEM_ONLY
+  legacy_location: true
   receivers: "Components/Doors/entry_7"
   panels { room: "R2C2 Bottom" name: "FOUL" }
   location_room: "R2C2 Bottom"
 }
 doors {
   name: "Blue Door"
-  type: STANDARD
+  type: ITEM_ONLY
+  legacy_location: true
   receivers: "Components/Doors/entry_8"
   panels { room: "Connected Area" name: "PAST" }
   panels { room: "Connected Area" name: "LAY" }
@@ -59,12 +65,14 @@ doors {
 doors {
   name: "Control Center Magenta Door"
   type: CONTROL_CENTER_COLOR
+  latch: true
   receivers: "Components/Doors/entry_18"
   control_center_color: "magenta"
 }
 doors {
   name: "Sky Owl"
-  type: STANDARD
+  type: ITEM_ONLY
+  legacy_location: true
   receivers: "Components/Owl/Room 1/LB"
   receivers: "Components/Owl/Room 1/LBG"
   receivers: "Components/Owl/Room 2/LB"
@@ -92,7 +100,8 @@ doors {
 }
 doors {
   name: "Gray Owl"
-  type: STANDARD
+  type: ITEM_ONLY
+  legacy_location: true
   receivers: "Components/Owl/Room 1/G"
   receivers: "Components/Owl/Room 1/GG"
   receivers: "Components/Owl/Room 2/G"
@@ -120,7 +129,8 @@ doors {
 }
 doors {
   name: "Orange Owl"
-  type: STANDARD
+  type: ITEM_ONLY
+  legacy_location: true
   receivers: "Components/Owl/Room 1/O"
   receivers: "Components/Owl/Room 1/OG"
   receivers: "Components/Owl/Room 2/O"
@@ -148,7 +158,8 @@ doors {
 }
 doors {
   name: "White Owl"
-  type: STANDARD
+  type: ITEM_ONLY
+  legacy_location: true
   receivers: "Components/Owl/Room 1/W"
   receivers: "Components/Owl/Room 1/WG"
   receivers: "Components/Owl/Room 2/W"
@@ -176,7 +187,8 @@ doors {
 }
 doors {
   name: "Black Owl"
-  type: STANDARD
+  type: ITEM_ONLY
+  legacy_location: true
   receivers: "Components/Owl/Room 1/BK"
   receivers: "Components/Owl/Room 1/BKG"
   receivers: "Components/Owl/Room 2/BK"
@@ -204,7 +216,8 @@ doors {
 }
 doors {
   name: "Blue Owl"
-  type: STANDARD
+  type: ITEM_ONLY
+  legacy_location: true
   receivers: "Components/Owl/Room 1/BL"
   receivers: "Components/Owl/Room 1/BLG"
   receivers: "Components/Owl/Room 2/BL"
@@ -233,20 +246,112 @@ 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" }
+}
+doors {
+  name: "R1C1 Panels"
+  type: LOCATION_ONLY
+  panels { room: "Connected Area" name: "ETCH" }
+  panels { room: "Connected Area" name: "SHOE" }
+  panels { room: "Connected Area" name: "MARKER" }
+  location_room: "Connected Area"
+  location_name: "ETCH, MARKER, SHOE"
+}
+doors {
+  name: "R1C2 Panels"
+  type: LOCATION_ONLY
+  panels { room: "Connected Area" name: "FAINT" }
+  panels { room: "Connected Area" name: "PURE" }
+  panels { room: "Connected Area" name: "MODE" }
+  location_room: "Connected Area"
+  location_name: "FAINT, MODE, PURE"
+}
+doors {
+  name: "Control Center Magenta Panel"
+  type: LOCATION_ONLY
+  panels { room: "Connected Area" name: "COLOR" }
+  location_room: "Connected Area"
+  location_name: "COLOR"
+}
+doors {
+  name: "R1C3 Panels"
+  type: LOCATION_ONLY
+  panels { room: "Connected Area" name: "PENCIL" }
+  panels { room: "Connected Area" name: "WING" }
+  location_room: "Connected Area"
+  location_name: "PENCIL, WING"
+}
+doors {
+  name: "R1C4 Panels"
+  type: LOCATION_ONLY
+  panels { room: "Connected Area" name: "SKETCH" }
+  panels { room: "Connected Area" name: "PHOTO" }
+  panels { room: "R1C4 Left" name: "WALK" }
+  panels { room: "R1C4 Left" name: "STENCIL" }
+  location_room: "R1C4 Left"
+  location_name: "PHOTO, SKETCH, STENCIL, WALK"
+}
+doors {
+  name: "R2C1 Panels"
+  type: LOCATION_ONLY
+  panels { room: "Connected Area" name: "LAY" }
+  panels { room: "Connected Area" name: "PAST" }
+  panels { room: "R2C1 Left" name: "VERB" }
+  panels { room: "R2C1 Left" name: "FOIL" }
+  location_room: "R2C1 Left"
+  location_name: "FOIL, LAY, PAST, VERB"
+}
+doors {
+  name: "R2C2 Panels"
+  type: LOCATION_ONLY
+  panels { room: "R2C2 Bottom" name: "FOUL" }
+  panels { room: "R2C2 Top" name: "CRUSH" }
+  panels { room: "Connected Area" name: "FIZZLE" }
+  location_room: "R2C2 Top"
+  location_name: "CRUSH, FOUL, FIZZLE"
+}
+doors {
+  name: "R2C3 Panels"
+  type: LOCATION_ONLY
+  panels { room: "Connected Area" name: "PRIMARY" }
+  panels { room: "R2C3 Bottom" name: "FIGMENT" }
+  location_room: "R2C3 Bottom"
+  location_name: "FIGMENT, PRIMARY"
+}
+doors {
+  name: "R2C4 Panels"
+  type: LOCATION_ONLY
+  panels { room: "Connected Area" name: "SHOW" }
+  panels { room: "Connected Area" name: "HAD" }
+  panels { room: "Connected Area" name: "HEAVY" }
+  location_room: "Connected Area"
+  location_name: "HAD, HEAVY, SHOW"
+}
+doors {
+  name: "Near Z1 Panel"
+  type: LOCATION_ONLY
+  panels { room: "Z Room" name: "MAZE" }
+  location_room: "Z Room"
+  location_name: "MAZE"
+}
+doors {
+  name: "Double Letters"
+  type: EVENT
+  receivers: "Panels/Warps/magenta/visibilityListener"
+  double_letters: true
 }
@@ -26,6 +26,7 @@ panels {
   clue: "color"
   answer: "magenta"
   symbols: EXAMPLE
+  required_door { name: "Double Letters" }
 }
 panels {
   name: "WHITE"
@@ -149,7 +150,9 @@ paintings {
 }
 ports {
   name: "FOURROOMS"
+  display_name: "Four Rooms Entrance"
   path: "Components/Warps/worldport2"
-  orientation: "east"
+  destination { x: 71.5 y: 0 z: -9 }
+  rotation: 90
   # Note that this is behind teal walls.
 }
@@ -1,6 +1,8 @@
 name: "Magenta Hallway"
 ports {
   name: "STURDY"
+  display_name: "Magenta Hallway"
   path: "Components/Warps/worldport3"
-  orientation: "west"
+  destination { x: 17 y: 0 z: -46 }
+  rotation: 270
 }
@@ -8,8 +8,10 @@ panels {
 }
 ports {
   name: "GALLERY"
+  display_name: "Gallery Worldport"
   path: "Components/Warps/worldport"
-  orientation: "south"
+  destination { x: 0 y: 0 z: 9 }
+  rotation: 0
   # TODO: Note that this port is accessible from the other side in the Z1
   # room. Hmm.
 }
@@ -7,6 +7,7 @@ connections {
   from_room: "Main Area"
   to_room: "Ending"
   door { name: "Ending Door" }
+  cyan_ending: true
 }
 connections {
   from_room: "Main Area"
@@ -13,7 +13,12 @@ doors {
 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"
@@ -38,3 +43,12 @@ doors {
   panels { room: "Main Area" name: "ALEXANDER" answer: "alexander" }
   panels { room: "Main Area" name: "CAESAR" answer: "caesar" }
 }
+doors {
+  name: "Lavender Area Puzzles"
+  type: LOCATION_ONLY
+  panels { room: "Lavender Area" name: "ME" }
+  panels { room: "Lavender Area" name: "SHEEP" }
+  panels { room: "Lavender Area" name: "WOOD" }
+  location_room: "Lavender Area"
+  location_name: "ME, SHEEP, WOOD"
+}
@@ -55,16 +55,22 @@ panels {
 }
 ports {
   name: "GALLERY"
+  display_name: "Columns Worldport"
   path: "Components/Warps/worldport"
-  orientation: "south"
+  destination { x: 0 y: 0 z: 0 }
+  rotation: 0
 }
 ports {
   name: "ENTRY"
+  display_name: "Building Worldport"
   path: "Components/Warps/worldport2"
-  orientation: "south"
+  destination { x: 0 y: 0 z: -21 }
+  rotation: 0
 }
 ports {
   name: "REVITALIZED"
+  display_name: "Plum Hallway"
   path: "Components/Warps/worldport3"
-  orientation: "north"
+  destination { x: -24 y: 0 z: -39 }
+  rotation: 180
 }
@@ -43,14 +43,14 @@ doors {
 doors {
   name: "L Entered"
   type: EVENT
-  # It does this in vanilla, but I'm specifying it so that the Control Center
-  # Entrance door doesn't override it.
+  latch: true
   receivers: "Components/Doors/controlDoor"
   keyholders { room: "Obverse Side" name: "L" key: "l" }
 }
 doors {
   name: "Control Center Entrance"
-  type: LOCATION_ONLY
+  type: EVENT
+  legacy_location: true
   #receivers: "Components/Doors/controlDoor"
   panels { room: "Control Center Entrance" name: "RETURN" }
   location_room: "Control Center Entrance"
@@ -8,6 +8,8 @@ panels {
 }
 ports {
   name: "CC"
+  display_name: "Control Center Connector"
   path: "Components/Warps/worldport2"
-  orientation: "north"
+  destination { x: -19 y: 0 z: 8 }
+  rotation: 180
 }
@@ -99,8 +99,10 @@ panels {
 }
 ports {
   name: "GREAT"
+  display_name: "Main Entrance"
   path: "Components/Warps/worldport"
-  orientation: "west"
+  destination { x: -3 y: 0 z: 20 }
+  rotation: 270
 }
 keyholders {
   # This is one of the ones that's misnamed within the game.
@@ -1 +1,5 @@
 display_name: "The Perceptive"
+worldport_entrance {
+  room: "Main Area"
+  name: "CC"
+}
@@ -1,6 +1,8 @@
 name: "Main Area"
 ports {
   name: "CC"
+  display_name: "Entrance"
   path: "Components/Warps/worldport"
-  orientation: "east"
+  destination { x: 3 y: 0 z: 13 }
+  rotation: 90
 }
@@ -21,22 +21,22 @@ connections {
 connections {
   from_room: "Center Room"
   to_room: "Top Left Room"
-  door { name: "Top Left Door" }
+  door { name: "Northwest Door" }
 }
 connections {
   from_room: "Center Room"
   to_room: "Top Right Room"
-  door { name: "Top Right Door" }
+  door { name: "Northeast Door" }
 }
 connections {
   from_room: "Center Room"
   to_room: "Bottom Left Room"
-  door { name: "Bottom Left Door" }
+  door { name: "Southwest Door" }
 }
 connections {
   from_room: "Center Room"
   to_room: "Bottom Right Room"
-  door { name: "Bottom Right Door" }
+  door { name: "Southeast Door" }
 }
 connections {
   from_room: "Center Room"
@@ -31,7 +31,7 @@ doors {
   location_room: "Main Area"
 }
 doors {
-  name: "Top Left Door"
+  name: "Northwest Door"
   type: STANDARD
   receivers: "Components/Doors/entry_6"
   panels { room: "Center Room" name: "REPORTER" }
@@ -44,7 +44,7 @@ doors {
   location_name: "First Room"
 }
 doors {
-  name: "Top Right Door"
+  name: "Northeast Door"
   type: ITEM_ONLY
   receivers: "Components/Doors/entry_7"
   panels { room: "Center Room" name: "REPORTER" }
@@ -55,7 +55,7 @@ doors {
   panels { room: "Center Room" name: "SQUIRREL" }
 }
 doors {
-  name: "Bottom Left Door"
+  name: "Southwest Door"
   type: ITEM_ONLY
   receivers: "Components/Doors/entry_5"
   panels { room: "Center Room" name: "REPORTER" }
@@ -66,7 +66,7 @@ doors {
   panels { room: "Center Room" name: "SQUIRREL" }
 }
 doors {
-  name: "Bottom Right Door"
+  name: "Southeast Door"
   type: ITEM_ONLY
   receivers: "Components/Doors/entry_4"
   panels { room: "Center Room" name: "REPORTER" }
@@ -77,7 +77,7 @@ doors {
   panels { room: "Center Room" name: "SQUIRREL" }
 }
 doors {
-  name: "Top Left Puzzles"
+  name: "Northwest Puzzles"
   type: LOCATION_ONLY
   panels { room: "Top Left Room" name: "BARE SOD" }
   panels { room: "Top Left Room" name: "SOD" }
@@ -104,7 +104,7 @@ doors {
   location_room: "Top Left Room"
 }
 doors {
-  name: "Top Right Puzzles"
+  name: "Northeast Puzzles"
   type: LOCATION_ONLY
   panels { room: "Top Right Room" name: "RIGHT WING" }
   panels { room: "Top Right Room" name: "WING" }
@@ -130,7 +130,7 @@ doors {
   location_room: "Top Right Room"
 }
 doors {
-  name: "Bottom Left Puzzles"
+  name: "Southwest Puzzles"
   type: LOCATION_ONLY
   panels { room: "Bottom Left Room" name: "SHELL (1)" }
   panels { room: "Bottom Left Room" name: "SHELL (2)" }
@@ -141,7 +141,7 @@ doors {
   location_room: "Bottom Left Room"
 }
 doors {
-  name: "Bottom Right Puzzles"
+  name: "Southeast Puzzles"
   type: LOCATION_ONLY
   panels { room: "Bottom Right Room" name: "FLY" }
   panels { room: "Bottom Right Room" name: "DECLOG" }
@@ -210,3 +210,31 @@ doors {
   panels { room: "Bottom Right Room" name: "HONEY" }
   panels { room: "Bottom Right Room" name: "INJECT" }
 }
+doors {
+  name: "Near Sirenic Panel"
+  type: LOCATION_ONLY
+  panels { room: "Sirenic Entrance" name: "SIREN" }
+  location_room: "Sirenic Entrance"
+  location_name: "SIREN"
+}
+doors {
+  name: "Near Symbolic Panel"
+  type: LOCATION_ONLY
+  panels { room: "Symbolic Entrance" name: "FIGURATIVE" }
+  location_room: "Symbolic Entrance"
+  location_name: "FIGURATIVE"
+}
+doors {
+  name: "Near Repetitive Panel"
+  type: LOCATION_ONLY
+  panels { room: "Repetitive Entrance" name: "TEDIOUS" }
+  location_room: "Repetitive Entrance"
+  location_name: "TEDIOUS"
+}
+doors {
+  name: "Near Broken Portal Panel"
+  type: LOCATION_ONLY
+  panels { room: "Main Area" name: "AFFABLE" }
+  location_room: "Main Area"
+  location_name: "AFFABLE"
+}
@@ -36,16 +36,22 @@ panels {
 }
 ports {
   name: "UNYIELDING"
+  display_name: "Unyielding Hallway"
   path: "Components/Warps/worldport"
-  orientation: "west"
+  destination { x: 1 y: 0 z: 10 }
+  rotation: 270
 }
 ports {
   name: "IMPRESSIVE"
+  display_name: "Impressive Hallway"
   path: "Components/Warps/worldport2"
-  orientation: "west"
+  destination { x: 11 y: 0 z: 10 }
+  rotation: 270
 }
 ports {
   name: "BETWEEN"
+  display_name: "Between Hallway"
   path: "Components/Warps/worldport3"
-  orientation: "west"
+  destination { x: -9 y: 0 z: 10 }
+  rotation: 270
 }
@@ -8,6 +8,8 @@ panels {
 }
 ports {
   name: "REPETITIVE"
+  display_name: "Repetitive Entrance"
   path: "Components/Warps/worldport5"
-  orientation: "north"
+  destination { x: -19 y: 0 z: 16 }
+  rotation: 180
 }
@@ -8,6 +8,8 @@ panels {
 }
 ports {
   name: "SIRENIC"
+  display_name: "Sirenic Entrance"
   path: "Components/Warps/worldport6"
-  orientation: "west"
+  destination { x: -51 y: 0 z: -43 }
+  rotation: 270
 }
@@ -8,6 +8,8 @@ panels {
 }
 ports {
   name: "SYMBOLIC"
+  display_name: "Symbolic Entrance"
   path: "Components/Warps/worldport4"
-  orientation: "south"
+  destination { x: 28 y: 0 z: 4 }
+  rotation: 0
 }
@@ -1 +1,5 @@
 display_name: "The Quiet"
+worldport_entrance {
+  room: "Main Area"
+  name: "DAEDALUS"
+}
@@ -97,6 +97,8 @@ panels {
 }
 ports {
   name: "DAEDALUS"
+  display_name: "Entrance"
   path: "Components/Warps/worldport"
-  orientation: "east"
+  destination { x: 3 y: 0 z: 8 }
+  rotation: 90
 }
@@ -1,6 +1,33 @@
 doors {
-  name: "Left/Turn Door"
+  name: "Turn Only Puzzles"
   type: LOCATION_ONLY
+  panels { room: "Turn Room" name: "HIDE (1)" }
+  panels { room: "Turn Room" name: "HIDE (2)" }
+  panels { room: "Turn Room" name: "MORE" }
+  location_room: "Turn Room"
+}
+doors {
+  name: "Shop Only Puzzles"
+  type: LOCATION_ONLY
+  panels { room: "Shop Room" name: "LEFT (1)" }
+  panels { room: "Shop Room" name: "LEFT (2)" }
+  panels { room: "Shop Room" name: "EXIT (1)" }
+  panels { room: "Shop Room" name: "EXIT (2)" }
+  panels { room: "Shop Room" name: "EXIT (3)" }
+  location_room: "Shop Room"
+}
+doors {
+  name: "Left Only Puzzles"
+  type: LOCATION_ONLY
+  panels { room: "Left Room" name: "HIDE" }
+  panels { room: "Left Room" name: "LEFT" }
+  panels { room: "Left Room" name: "MORE" }
+  location_room: "Left Room"
+}
+doors {
+  name: "Left/Turn Door"
+  type: EVENT
+  legacy_location: true
   panels { room: "Left Room" name: "HIDE" }
   panels { room: "Left Room" name: "LEFT" }
   panels { room: "Left Room" name: "MORE" }
@@ -11,7 +38,8 @@ doors {
 }
 doors {
   name: "Turn/Shop Door"
-  type: LOCATION_ONLY
+  type: EVENT
+  legacy_location: true
   panels { room: "Turn Room" name: "HIDE (1)" }
   panels { room: "Turn Room" name: "HIDE (2)" }
   panels { room: "Turn Room" name: "MORE" }
@@ -7,12 +7,12 @@ connections {
   from_room: "Main Room"
   to_room: "Plaza Connector"
   door { name: "Black Hallway" }
-  oneway: true
 }
 connections {
   from_room: "Plaza Connector"
   to_room: "Main Room"
   oneway: true
+  vanilla_only: true
 }
 connections {
   from_room: "Main Room"
@@ -20,12 +20,21 @@ doors {
 }
 doors {
   name: "Dot Area Entrance"
-  type: STANDARD
+  type: ITEM_ONLY
+  legacy_location: true
   receivers: "Components/Doors/Door8"
   panels { room: "Main Room" name: "HOTS (2)" }
   location_room: "Main Room"
 }
 doors {
+  name: "Hots Panels"
+  type: LOCATION_ONLY
+  panels { room: "Main Room" name: "HOTS (1)" }
+  panels { room: "Main Room" name: "HOTS (2)" }
+  location_room: "Main Room"
+  location_name: "HOTS (1), HOTS (2)"
+}
+doors {
   name: "Lime Door"
   type: STANDARD
   receivers: "Components/Doors/Door9"
@@ -194,3 +203,41 @@ 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"
+}
+doors {
+  name: "H2 Room Puzzles"
+  type: LOCATION_ONLY
+  panels { room: "Main Room" name: "HEIGHT (1)" }
+  panels { room: "Main Room" name: "HEIGHT (2)" }
+  panels { room: "Main Room" name: "HEIGHT (3)" }
+  panels { room: "Main Room" name: "HEIGHT (4)" }
+  panels { room: "Main Room" name: "HEIGHT (5)" }
+  panels { room: "Main Room" name: "HEIGHT (6)" }
+  panels { room: "Main Room" name: "QUESTION" }
+  panels { room: "Main Room" name: "INTUITION" }
+  panels { room: "Main Room" name: "?" }
+  panels { room: "Main Room" name: "HAND" }
+  panels { room: "Main Room" name: "? HAND" }
+  panels { room: "Main Room" name: "RICHES" }
+  panels { room: "Main Room" name: "? RICHES" }
+  panels { room: "Main Room" name: "MISHMASH" }
+  location_room: "Main Room"
+}
+doors {
+  name: "Anti-Collectable Room Panels"
+  type: LOCATION_ONLY
+  panels { room: "Anti Room" name: "EYE (1)" }
+  panels { room: "Anti Room" name: "EYE (2)" }
+  panels { room: "Anti Room" name: "HA (1)" }
+  panels { room: "Anti Room" name: "HA (2)" }
+  panels { room: "Anti Room" name: "HA (3)" }
+  panels { room: "Anti Room" name: "HA (4)" }
+  panels { room: "Anti Room" name: "HA (5)" }
+  panels { room: "Anti Room" name: "TWO" }
+  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,6 +1,8 @@
 name: "Entry Connector"
 ports {
   name: "ENTRY"
+  display_name: "Northwest Worldport"
   path: "Components/Warps/worldport2"
-  orientation: "south"
+  destination { x: -11 y: 0 z: 13 }
+  rotation: 90
 }
@@ -138,6 +138,8 @@ paintings {
 }
 ports {
   name: "CC"
+  display_name: "Southwest Worldport"
   path: "Components/Warps/worldport3"
-  orientation: "east"
+  destination { x: -5.5 y: 0 z: 56 }
+  rotation: 90
 }
@@ -1,6 +1,8 @@
 name: "Plaza Connector"
 ports {
   name: "PLAZA"
+  display_name: "Northeast Worldport"
   path: "Components/Warps/worldport"
-  orientation: "north"
+  destination { x: 15 y: 0 z: 13 }
+  rotation: 0
 }
@@ -8,6 +8,8 @@ panels {
 }
 ports {
   name: "PARTHENON"
+  display_name: "Entrance"
   path: "Components/Warps/worldport"
-  orientation: "south"
+  destination { x: 30 y: 0 z: 16 }
+  rotation: 0
 }
@@ -33,5 +33,8 @@ doors {
 doors {
   name: "N Entered"
   type: EVENT
+  latch: true
+  receivers: "Components/Doors/entry_1"
+  receivers: "Components/Doors/entry_2"
   keyholders { room: "Main Area" name: "N" key: "n" }
 }
@@ -155,7 +155,10 @@ panels {
 }
 ports {
   name: "ENTRY"
+  display_name: "Entrance"
   path: "Components/Warps/worldport"
+  destination { x: 4 y: 0 z: 12 }
+  rotation: 90
 }
 keyholders {
   name: "N"
@@ -1 +1,5 @@
 display_name: "The Sirenic"
+worldport_entrance {
+  room: "Start"
+  name: "PLAZA"
+}
@@ -15,6 +15,8 @@ panels {
 }
 ports {
   name: "PLAZA"
+  display_name: "Entrance"
   path: "Components/Warps/worldport"
-  orientation: "south"
+  destination { x: 0 y: 0 z: 26 }
+  rotation: 0
 }
@@ -0,0 +1,70 @@
+connections {
+  from_room: "Starting Room"
+  to_room: "Connected Area"
+  door { name: "Entrance" }
+}
+connections {
+  from_room: "Connected Area"
+  to_room: "Mastery"
+  door { name: "Mastery Door" }
+}
+connections {
+  from_room: "Connected Area"
+  to_room: "Hi Room"
+  door { name: "Hi Room Front Door" }
+}
+connections {
+  from_room: "Connected Area"
+  to_room: "Hi Room"
+  door { name: "Hi Room Back Door" }
+}
+connections {
+  from_room: "Green Area"
+  to_room: "Connected Area"
+  door { name: "Green Area Door" }
+}
+connections {
+  from_room: "Connected Area"
+  to_room: "Old Crossroads"
+  door { name: "Crossroads Shortcut" }
+}
+connections {
+  from_room: "Connected Area"
+  to_room: "Old Crossroads"
+  oneway: true
+}
+connections {
+  from_room: "Old Crossroads"
+  to_room: "Green Area"
+  oneway: true
+}
+connections {
+  from_room: "Connected Area"
+  to_room: "Red Panel"
+  door { name: "Red Panel" }
+}
+connections {
+  from_room: "Connected Area"
+  to_room: "Orange Panel"
+  door { name: "Orange Panel" }
+}
+connections {
+  from_room: "Connected Area"
+  to_room: "Yellow Panel"
+  door { name: "Yellow Panel" }
+}
+connections {
+  from_room: "Green Area"
+  to_room: "Green Panel"
+  door { name: "Green Panel" }
+}
+connections {
+  from_room: "Connected Area"
+  to_room: "Blue Panel"
+  door { name: "Blue Panel" }
+}
+connections {
+  from_room: "Connected Area"
+  to_room: "Purple Panel"
+  door { name: "Purple Panel" }
+}
@@ -0,0 +1,104 @@
+# Shortcuts from Connected Area -> Starting Room:
+# - Components/Doors/entry_3
+# - Components/Doors/entry_11
+# - Components/Doors/entry_12
+# Unopenable door:
+# - Components/Doors/entry_4
+# - Components/Doors/entry_6
+# - Components/Doors/entry_7
+# This opens and closes automatically:
+# - Components/Doors/entry_5
+doors {
+  name: "Entrance"
+  type: STANDARD
+  receivers: "Components/Doors/entry_1"
+  receivers: "Components/Doors/entry_2"
+  panels { room: "Starting Room" name: "STARLIKE" }
+  location_room: "Starting Room"
+}
+doors {
+  name: "Mastery Door"
+  type: EVENT
+  receivers: "Components/Doors/entry_18"
+  panels { room: "Purple Panel" name: "PURPLE" }
+}
+doors {
+  name: "Hi Room Front Door"
+  type: EVENT
+  receivers: "Components/Doors/entry_21"
+  panels { room: "Connected Area" name: "HI" }
+}
+doors {
+  name: "Hi Room Back Door"
+  type: EVENT
+  receivers: "Components/Doors/entry_20"
+  panels { room: "Hi Room" name: "HI" }
+}
+doors {
+  name: "Green Area Door"
+  type: EVENT
+  receivers: "Components/Doors/entry_15"
+  panels { room: "Green Area" name: "STRAYS" }
+}
+doors {
+  name: "Crossroads Shortcut"
+  type: EVENT
+  receivers: "Components/Doors/entry_14"
+  panels { room: "Old Crossroads" name: "DOORWAY" }
+}
+doors {
+  name: "Red Panel"
+  type: EVENT
+  receivers: "Components/Doors/entry_8"
+  panels { room: "Connected Area" name: "START" }
+}
+doors {
+  name: "Orange Panel"
+  type: EVENT
+  receivers: "Components/Doors/entry_19"
+  panels { room: "Red Panel" name: "RED" }
+}
+doors {
+  name: "Yellow Panel"
+  type: EVENT
+  receivers: "Components/Doors/entry_10"
+  receivers: "Components/Doors/entry_17"
+  panels { room: "Connected Area" name: "START" }
+  panels { room: "Orange Panel" name: "ORANGE" }
+}
+doors {
+  name: "Green Panel"
+  type: EVENT
+  receivers: "Components/Doors/entry_16"
+  panels { room: "Yellow Panel" name: "YELLOW" }
+}
+doors {
+  name: "Blue Panel"
+  type: EVENT
+  receivers: "Components/Doors/entry_9"
+  panels { room: "Green Panel" name: "GREEN" }
+}
+doors {
+  name: "Purple Panel"
+  type: EVENT
+  receivers: "Components/Doors/entry_13"
+  panels { room: "Blue Panel" name: "BLUE" }
+}
+doors {
+  name: "Question Panels"
+  type: LOCATION_ONLY
+  panels { room: "Connected Area" name: "HERE" }
+  panels { room: "Connected Area" name: "WHERE" }
+  panels { room: "Connected Area" name: "QUESTION (1)" }
+  panels { room: "Connected Area" name: "QUESTION (2)" }
+  location_room: "Connected Area"
+}
+doors {
+  name: "Welcome Back Panels"
+  type: LOCATION_ONLY
+  panels { room: "Connected Area" name: "GREETINGS" }
+  panels { room: "Connected Area" name: "BEHIND" }
+  panels { room: "Connected Area" name: "Blank" }
+  location_room: "Connected Area"
+  location_name: "BEHIND, GREETINGS, Blank"
+}
@@ -0,0 +1,6 @@
+display_name: "The Stellar"
+type: GIFT_MAP
+# This panel does not appear to be accessible without sniping.
+excluded_nodes: "Panels/Room_1/panel_2"
+# The map's mastery is created at runtime.
+custom_nodes: "Components/Collectables/collectable"
@@ -0,0 +1,8 @@
+name: "Blue Panel"
+panels {
+  name: "BLUE"
+  path: "Panels/Colors/blue"
+  clue: "blue"
+  answer: "purple"
+  symbols: BOXES
+}
@@ -0,0 +1,63 @@
+name: "Connected Area"
+panels {
+  name: "HERE"
+  path: "Panels/Room_1/panel_3"
+  clue: "here"
+  answer: "where"
+  symbols: SPARKLES
+}
+panels {
+  name: "QUESTION (1)"
+  path: "Panels/Room_1/panel_4"
+  clue: "question"
+  answer: "what"
+  symbols: EXAMPLE
+}
+panels {
+  name: "QUESTION (2)"
+  path: "Panels/Room_1/panel_5"
+  clue: "question"
+  answer: "how"
+  symbols: EXAMPLE
+}
+panels {
+  name: "HI"
+  path: "Panels/Room_1/panel_12"
+  clue: "hi"
+  answer: "hi"
+  symbols: QUESTION
+}
+panels {
+  name: "WHERE"
+  path: "Panels/Room_1/panel_6"
+  clue: "where"
+  answer: "there"
+  symbols: SPARKLES
+}
+panels {
+  name: "GREETINGS"
+  path: "Panels/Room_1/panel_7"
+  clue: "greetings"
+  answer: "welcome"
+  symbols: SUN
+}
+panels {
+  name: "BEHIND"
+  path: "Panels/Room_1/panel_8"
+  clue: "behind"
+  answer: "back"
+  symbols: SUN
+}
+panels {
+  name: "Blank"
+  path: "Panels/Room_1/panel_9"
+  clue: ""
+  answer: "behind"
+}
+panels {
+  name: "START"
+  path: "Panels/Colors/start"
+  clue: "start"
+  answer: "red"
+  symbols: QUESTION
+}
@@ -0,0 +1,8 @@
+name: "Green Area"
+panels {
+  name: "STRAYS"
+  path: "Panels/Room_1/panel_11"
+  clue: "strays"
+  answer: "maze"
+  symbols: ZERO
+}
@@ -0,0 +1,8 @@
+name: "Green Panel"
+panels {
+  name: "GREEN"
+  path: "Panels/Colors/green"
+  clue: "green"
+  answer: "blue"
+  symbols: BOXES
+}
@@ -0,0 +1,8 @@
+name: "Hi Room"
+panels {
+  name: "HI"
+  path: "Panels/Room_1/panel_13"
+  clue: "hi"
+  answer: "hi"
+  symbols: QUESTION
+}
@@ -0,0 +1,5 @@
+name: "Mastery"
+masteries {
+  name: "MASTERY"
+  path: "Components/Collectables/collectable"
+}
@@ -0,0 +1,8 @@
+name: "Old Crossroads"
+panels {
+  name: "DOORWAY"
+  path: "Panels/Room_1/panel_10"
+  clue: "doorway"
+  answer: "hallway"
+  symbols: BOXES
+}
@@ -0,0 +1,8 @@
+name: "Orange Panel"
+panels {
+  name: "ORANGE"
+  path: "Panels/Colors/orange"
+  clue: "orange"
+  answer: "yellow"
+  symbols: BOXES
+}
@@ -0,0 +1,8 @@
+name: "Purple Panel"
+panels {
+  name: "PURPLE"
+  path: "Panels/Colors/purple"
+  clue: "purple"
+  answer: "end"
+  symbols: QUESTION
+}
@@ -0,0 +1,8 @@
+name: "Red Panel"
+panels {
+  name: "RED"
+  path: "Panels/Colors/red"
+  clue: "red"
+  answer: "orange"
+  symbols: BOXES
+}
@@ -0,0 +1,15 @@
+name: "Starting Room"
+panels {
+  name: "STARLIKE"
+  path: "Panels/Room_1/panel_1"
+  clue: "starlike"
+  answer: "stellar"
+  symbols: SUN
+}
+ports {
+  name: "WORLDPORT"
+  display_name: "Entrance"
+  path: "Components/Warps/worldport"
+  destination { x: 0 y: 0 z: 0 }
+  rotation: 0
+}
@@ -0,0 +1,8 @@
+name: "Yellow Panel"
+panels {
+  name: "YELLOW"
+  path: "Panels/Colors/yellow"
+  clue: "yellow"
+  answer: "green"
+  symbols: BOXES
+}
@@ -31,6 +31,8 @@ panels {
 }
 ports {
   name: "ENTRY"
+  display_name: "Worldport"
   path: "Components/Warps/worldport"
-  orientation: "west"
+  destination { x: -8.5 y: 0 z: 6 }
+  rotation: 270
 }
@@ -3,3 +3,8 @@ connections {
   to_room: "S2 Area"
   door { name: "Color Puzzle" }
 }
+connections {
+  from_room: "Main Area"
+  to_room: "Hidden Rainbow"
+  door { name: "Hidden Rainbow" }
+}
@@ -10,3 +10,9 @@ doors {
   panels { room: "Main Area" name: "MOVE (7)" answer: "back" }
   panels { room: "Main Area" name: "MOVE (8)" answer: "down" }
 }
+doors {
+  name: "Hidden Rainbow"
+  type: EVENT
+  panels { room: "Main Area" name: "MOVE (2)" answer: "move" }
+  panels { room: "Main Area" name: "MOVE (4)" answer: "move" }
+}
@@ -1,6 +1,8 @@
 display_name: "The Sturdy"
-# Let's ignore the second half of the rainbow for now.
+# Let's ignore the second half of the rainbows for now.
 #excluded_nodes: "Components/Doors/Rainbow2/Hinge/rainbowMirrored"
-# I don't know why there's a second copy of the rainbow.
-#excluded_nodes: "Components/Doors/Rainbow/Hinge/rainbow"
 #excluded_nodes: "Components/Doors/Rainbow/Hinge/rainbowMirrored"
+# The validator doesn't know that these node exist because they are part of a
+# sub-scene.
+custom_nodes: "Components/Doors/Rainbow/Hinge/rainbow"
+custom_nodes: "Components/Doors/Rainbow2/Hinge/rainbow"
@@ -0,0 +1,6 @@
+name: "Hidden Rainbow"
+paintings {
+  name: "RAINBOW"
+  path: "Components/Doors/Rainbow/Hinge/rainbow"
+  enter_only: true
+}
@@ -105,9 +105,15 @@ panels {
 }
 ports {
   name: "OWL"
+  display_name: "Magenta Hallway"
   path: "Components/Warps/worldport"
+  destination { x: 17 y: 0 z: 41 }
+  rotation: 90
 }
 ports {
   name: "COLORFUL"
+  display_name: "Cyan Hallway"
   path: "Components/Warps/worldport2"
+  destination { x: 17 y: 0 z: -33 }
+  rotation: 90
 }
@@ -12,9 +12,7 @@ letters {
   path: "Components/Collectables/collectable"
 }
 paintings {
-  name: "RAINBOW"
-  # The validator is wrong about this node not existing, because it's in a
-  # sub-scene.
+  name: "RAINBOW2"
   path: "Components/Doors/Rainbow2/Hinge/rainbow"
   enter_only: true
 }
@@ -7,6 +7,7 @@ connections {
   from_room: "Temple"
   to_room: "Ending"
   door { name: "Ending" }
+  purple_ending: true
 }
 connections {
   from_room: "Temple"
@@ -1 +1,5 @@
 display_name: "The Sun Temple"
+worldport_entrance {
+  room: "Entrance"
+  name: "UNKEMPT"
+}
@@ -9,5 +9,8 @@ panels {
 }
 ports {
   name: "UNKEMPT"
+  display_name: "Entrance"
   path: "Components/Warps/worldport"
+  destination { x: 0 y: 0 z: 13 }
+  rotation: 0
 }
@@ -200,9 +200,15 @@ panels {
 }
 ports {
   name: "EXIT1"
+  display_name: "South Worldport"
   path: "Components/Warps/worldport"
+  destination { x: 0 y: 0 z: -11.5 }
+  rotation: 180
 }
 ports {
   name: "EXIT2"
+  display_name: "North Worldport"
   path: "Components/Warps/worldport2"
+  destination { x: 0 y: 0 z: -17.5 }
+  rotation: 0
 }
@@ -1 +1,5 @@
 display_name: "The Symbolic"
+worldport_entrance {
+  room: "White Room"
+  name: "PLAZA"
+}
@@ -7,5 +7,8 @@ panels {
 }
 ports {
   name: "PLAZA"
+  display_name: "Entrance"
   path: "Components/Warps/worldport"
+  destination { x: 0 y: 0 z: 2.5 }
+  rotation: 0
 }
@@ -52,3 +52,10 @@ doors {
   panels { room: "Back Room" name: "RELEVANT" }
   panels { room: "Back Room" name: "LONE" }
 }
+doors {
+  name: "Keyholder Hint Panel"
+  type: LOCATION_ONLY
+  panels { room: "Main Area" name: "EARL" }
+  location_room: "Main Area"
+  location_name: "EARL"
+}
@@ -1 +1,5 @@
 display_name: "The Talented"
+worldport_entrance {
+  room: "Main Area"
+  name: "GREAT"
+}
@@ -111,5 +111,8 @@ keyholders {
 }
 ports {
   name: "GREAT"
+  display_name: "Entrance"
   path: "Components/Warps/worldport"
+  destination { x: -3.5 y: 0 z: 21 }
+  rotation: 270
 }
@@ -6,6 +6,8 @@ doors {
 doors {
   name: "K Entered"
   type: EVENT
+  latch: true
+  receivers: "Components/Doors/entry_6"
   keyholders { room: "Main Area" name: "K" key: "k" }
 }
 doors {
@@ -8,5 +8,8 @@ panels {
 }
 ports {
   name: "CC"
+  display_name: "Control Center Connector"
   path: "Components/Warps/worldport"
+  destination { x: 0 y: 0 z: 10 }
+  rotation: 0
 }
@@ -29,9 +29,15 @@ panels {
 }
 ports {
   name: "BEGIN"
+  display_name: "Door Ways Worldport"
   path: "Components/Warps/worldport6"
+  destination { x: -38 y: 0 z: 41.5 }
+  rotation: 0
 }
 ports {
   name: "BEGIN2"
+  display_name: "Dead End Worldport"
   path: "Components/Warps/worldport5"
+  destination { x: -38 y: 0 z: 27.5 }
+  rotation: 180
 }
@@ -29,9 +29,15 @@ panels {
 }
 ports {
   name: "GREAT"
+  display_name: "First Worldport"
   path: "Components/Warps/worldport"
+  destination { x: -16 y: 0 z: 0.5 }
+  rotation: 180
 }
 ports {
   name: "TTD"
+  display_name: "Second Worldport"
   path: "Components/Warps/worldport2"
+  destination { x: -16 y: 0 z: 14.5 }
+  rotation: 0
 }
@@ -15,5 +15,8 @@ panels {
 }
 ports {
   name: "BEGIN"
+  display_name: "Loose Strings Worldport"
   path: "Components/Warps/worldport7"
+  destination { x: -16 y: 0 z: 41.5 }
+  rotation: 0
 }
@@ -15,5 +15,8 @@ panels {
 }
 ports {
   name: "BEGIN"
+  display_name: "Lone Chance Worldport"
   path: "Components/Warps/worldport8"
+  destination { x: -16 y: 0 z: 27.5 }
+  rotation: 180
 }
@@ -27,9 +27,15 @@ panels {
 }
 ports {
   name: "BEGIN"
+  display_name: "Third Fourth Worldport"
   path: "Components/Warps/worldport3"
+  destination { x: -38 y: 0 z: 14.5 }
+  rotation: 0
 }
 ports {
   name: "NEXT"
+  display_name: "Silver Portal Worldport"
   path: "Components/Warps/worldport4"
+  destination { x: -38 y: 0 z: 0.5 }
+  rotation: 180
 }
@@ -1 +1,5 @@
 display_name: "The Tower"
+worldport_entrance {
+  room: "First Floor"
+  name: "GREAT"
+}
@@ -97,5 +97,8 @@ panels {
 }
 ports {
   name: "GREAT"
+  display_name: "Entrance"
   path: "Components/Warps/worldport"
+  destination { x: -0 y: 0 z: 13 }
+  rotation: 0
 }
@@ -1,6 +1,7 @@
 doors {
   name: "Control Center Brown Door"
   type: CONTROL_CENTER_COLOR
+  latch: true
   receivers: "Components/Doors/entry_1"
   control_center_color: "brown"
 }
@@ -1,5 +1,8 @@
 name: "Bearer Entrance"
 ports {
   name: "BEARER"
+  display_name: "Brown Control Center Hallway"
   path: "Components/Warps/worldport"
+  destination { x: -15.5 y: 0 z: 20 }
+  rotation: 270
 }
@@ -211,19 +211,33 @@ panels {
 }
 ports {
   name: "UNKEMPT"
+  display_name: "SW Worldport"
   path: "Components/Warps/worldport4"
+  destination { x: -21 y: 0 z: 7 }
+  rotation: 0
+  # enterable from either side
 }
 ports {
   name: "DIGITAL"
+  display_name: "NW Worldport"
   path: "Components/Warps/worldport5"
+  destination { x: -21 y: 0 z: -7 }
+  rotation: 180
+  # enterable from either side
 }
 ports {
   name: "GREAT"
+  display_name: "E Worldport"
   path: "Components/Warps/worldport2"
+  destination { x: 21 y: 0 z: -4 }
+  rotation: 180
 }
 ports {
   name: "DAEDALUS"
+  display_name: "NE Worldport"
   path: "Components/Warps/worldport3"
+  destination { x: 15.5 y: 0 z: -19 }
+  rotation: 90
 }
 paintings {
   name: "SEA"
@@ -1,7 +1,7 @@
 connections {
   from_room: "Main Area"
   to_room: "Right Area"
-  door { name: "Right Door" }
+  door { name: "East Door" }
 }
 connections {
   from_room: "Middle Room"
@@ -1,5 +1,5 @@
 doors {
-  name: "Right Door"
+  name: "East Door"
   type: STANDARD
   receivers: "Components/Doors/entry_2"
   panels { room: "Main Area" name: "EYE" }
@@ -48,6 +48,8 @@ doors {
 doors {
   name: "I Entered"
   type: EVENT
+  latch: true
+  receivers: "Components/Doors/entry_4"
   keyholders { room: "Main Area" name: "I" key: "i" }
 }
 doors {
@@ -66,9 +68,9 @@ doors {
 doors {
   name: "Control Center Orange Door"
   type: CONTROL_CENTER_COLOR
+  latch: true
   receivers: "Components/Doors/entry_6"
   receivers: "Components/Doors/entry_13"
-  receivers: "Panels/Assorted/panel_1/teleportListener"
   control_center_color: "orange"
   double_letters: true
 }
@@ -182,3 +184,20 @@ doors {
   panels { room: "Right Area" name: "TOUGH" }
   location_room: "Right Area"
 }
+doors {
+  name: "Near Teal Door Panels"
+  type: LOCATION_ONLY
+  panels { room: "Main Area" name: "I" }
+  panels { room: "Main Area" name: "SPY" }
+  panels { room: "Main Area" name: "HEFT" }
+  panels { room: "Main Area" name: "THEFT" }
+  location_room: "Main Area"
+  location_name: "HEFT, I, SPY, THEFT"
+}
+doors {
+  name: "Control Center Orange Panel"
+  type: LOCATION_ONLY
+  panels { room: "Right Area" name: "COLOR" }
+  location_room: "Right Area"
+  location_name: "COLOR"
+}
@@ -8,5 +8,8 @@ panels {
 }
 ports {
   name: "CC"
+  display_name: "Control Center Connector"
   path: "Components/Warps/worldport2"
+  destination { x: -4.5 y: 0 z: 7 }
+  rotation: 0
 }
@@ -1,5 +1,8 @@
 name: "Daedalus Entrance"
 ports {
   name: "DAEDALUS"
+  display_name: "Orange Hallway"
   path: "Components/Warps/worldport4"
+  destination { x: 33 y: 0 z: -10 }
+  rotation: 90
 }
@@ -216,14 +216,23 @@ keyholders {
 }
 ports {
   name: "GREAT"
+  display_name: "Main Entrance"
   path: "Components/Warps/worldport"
+  destination { x: -3 y: 0 z: 11 }
+  rotation: 270
 }
 ports {
   name: "TREE"
+  display_name: "Brown Hallway"
   path: "Components/Warps/worldport5"
+  destination { x: -34 y: 0 z: 7 }
+  rotation: 270
 }
 ports {
   name: "SUNTEMPLE"
+  display_name: "Sun Temple Entrance"
   path: "Components/Warps/worldport3"
+  destination { x: -42 y: 0 z: -2 }
+  rotation: 270
   required_door { name: "Sun Temple Entrance" }
 }
@@ -159,5 +159,4 @@ panels {
   clue: "color"
   answer: "orange"
   symbols: EXAMPLE
-  required_door { name: "Control Center Orange Door" }
 }
@@ -504,3 +504,42 @@ doors {
   receivers: "Panels/Miscellaneous/entry_3/teleportListener"
   double_letters: true
 }
+doors {
+  name: "Blue D Room Puzzles"
+  type: LOCATION_ONLY
+  panels { room: "Central Connected Area" name: "FOX" }
+  panels { room: "Central Connected Area" name: "LOCKS" }
+  panels { room: "Central Connected Area" name: "BOX" }
+  panels { room: "Central Connected Area" name: "SQUAWKS" }
+  panels { room: "Central Connected Area" name: "HAWKS" }
+  panels { room: "Central Connected Area" name: "TALKS" }
+  location_room: "Central Connected Area"
+}
+doors {
+  name: "Color Hallway Panels"
+  type: LOCATION_ONLY
+  panels { room: "Brown Alcove" name: "BROW" }
+  panels { room: "Central Connected Area" name: "RANGE" }
+  panels { room: "Central Connected Area" name: "WHIT" }
+  panels { room: "Central Connected Area" name: "ALMOND" }
+  panels { room: "Central Connected Area" name: "DAY" }
+  panels { room: "Central Connected Area" name: "REAM" }
+  panels { room: "Central Connected Area" name: "SON (2)" }
+  panels { room: "Central Connected Area" name: "RAY" }
+  panels { room: "Central Connected Area" name: "BURROWING" }
+  panels { room: "Orange Alcove" name: "ON" }
+  panels { room: "Plaza Entrance" name: "GEE" }
+  panels { room: "Plaza Entrance" name: "SEA" }
+  panels { room: "Gray Alcove" name: "GRAVELY" }
+  panels { room: "Cyan Alcove" name: "CAN" }
+  panels { room: "Star Rooms" name: "CYANIDE" }
+  panels { room: "Star Rooms" name: "BACK" }
+  panels { room: "Black Alcove" name: "LACK" }
+  panels { room: "White Corners" name: "ARCH" }
+  panels { room: "White Corners" name: "ZERO" }
+  panels { room: "White Corners" name: "DAM" }
+  panels { room: "White Corners" name: "WHEN" }
+  panels { room: "Hero Room" name: "HER" }
+  panels { room: "Daisy Alcove" name: "CYANIDES" }
+  location_room: "Central Connected Area"
+}
@@ -1,5 +1,8 @@
 name: "Bearer Entrance"
 ports {
   name: "BEARER"
+  display_name: "East of Yellow Worldport"
   path: "Components/Warps/worldport4"
+  destination { x: 23 y: 0 z: -29 }
+  rotation: 90
 }
@@ -8,5 +8,8 @@ panels {
 }
 ports {
   name: "DIGITAL"
+  display_name: "South of Yellow Worldport"
   path: "Components/Warps/worldport"
+  destination { x: 0 y: 0 z: 0 }
+  rotation: 0
 }
@@ -1,5 +1,8 @@
 name: "Nuanced Entrance"
 ports {
   name: "NUANCED"
+  display_name: "West of Yellow Worldport"
   path: "Components/Warps/worldport3"
+  destination { x: -23 y: 0 z: -29 }
+  rotation: 270
 }
@@ -15,5 +15,8 @@ panels {
 }
 ports {
   name: "PLAZA"
+  display_name: "Dark Hallway"
   path: "Components/Warps/worldport5"
+  destination { x: 35 y: 0 z: 44 }
+  rotation: 270
 }
@@ -1 +1,5 @@
 display_name: "The Wondrous"
+worldport_entrance {
+  room: "Entry"
+  name: "DAEDALUS"
+}
@@ -7,5 +7,8 @@ panels {
 }
 ports {
   name: "DAEDALUS"
+  display_name: "Entrance"
   path: "Components/Warps/worldport"
+  destination { x: 18 y: 0 z: 41 }
+  rotation: 180
 }
@@ -57,5 +57,8 @@ panels {
 }
 ports {
   name: "ENTRY"
+  display_name: "Worldport"
   path: "Components/Warps/worldport"
+  destination { x: 0 y: 0 z: 9.5 }
+  rotation: 0
 }
@@ -0,0 +1,56 @@
+version {
+  major: 8
+  minor: 0
+  patch: 1
+}
+# Filler item.
+special_names: "A Job Well Done"
+# Symbol items.
+special_names: "Age Symbol"
+special_names: "Anagram Symbol"
+special_names: "Boxes Symbol"
+special_names: "Cross Symbol"
+special_names: "Eval Symbol"
+special_names: "Example Symbol"
+special_names: "Gender Symbol"
+special_names: "Job Symbol"
+special_names: "Lingo Symbol"
+special_names: "Null Symbol"
+special_names: "Planet Symbol"
+special_names: "Pyramid Symbol"
+special_names: "Question Symbol"
+special_names: "Sound Symbol"
+special_names: "Sparkles Symbol"
+special_names: "Stars Symbol"
+special_names: "Sun Symbol"
+special_names: "Sweet Symbol"
+special_names: "Zero Symbol"
+# Anti collectable traps
+special_names: "Anti A"
+special_names: "Anti B"
+special_names: "Anti C"
+special_names: "Anti D"
+special_names: "Anti E"
+special_names: "Anti F"
+special_names: "Anti G"
+special_names: "Anti H"
+special_names: "Anti I"
+special_names: "Anti J"
+special_names: "Anti K"
+special_names: "Anti L"
+special_names: "Anti M"
+special_names: "Anti N"
+special_names: "Anti O"
+special_names: "Anti P"
+special_names: "Anti Q"
+special_names: "Anti R"
+special_names: "Anti S"
+special_names: "Anti T"
+special_names: "Anti U"
+special_names: "Anti V"
+special_names: "Anti W"
+special_names: "Anti X"
+special_names: "Anti Y"
+special_names: "Anti Z"
+# Numbers for The Fuzzy
+special_names: "Numbers"
@@ -9,3 +9,16 @@ progressives {
   doors { map: "daedalus" name: "Cyan Rainbow Room" }
   doors { map: "daedalus" name: "Brown Rainbow Room" }
 }
+progressives {
+  name: "Icarus Quick Travel"
+  doors { map: "icarus" name: "Quick Travel 2" }
+  doors { map: "icarus" name: "Quick Travel 3" }
+  doors { map: "icarus" name: "Quick Travel 4" }
+  doors { map: "icarus" name: "Quick Travel 5" }
+  doors { map: "icarus" name: "Quick Travel 6" }
+  doors { map: "icarus" name: "Quick Travel 7" }
+  doors { map: "icarus" name: "Quick Travel 8" }
+  doors { map: "icarus" name: "Quick Travel 9" }
+  doors { map: "icarus" name: "Quick Travel 10" }
+  doors { map: "icarus" name: "Quick Travel 1" }
+}
@@ -27,6 +27,9 @@ 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 {
@@ -44,6 +47,16 @@ enum DoorGroupType {
 
   // 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 MapType {
+  NORMAL_MAP = 0;
+  ICARUS = 1;
+  GIFT_MAP = 2;
+  DEMO = 3;
 }
 
 enum AxisDirection {
@@ -81,6 +94,18 @@ enum PuzzleSymbol {
   QUESTION = 19;
 }
 
+message Vec3d {
+  optional double x = 1;
+  optional double y = 2;
+  optional double z = 3;
+}
+
+message VersionNumber {
+  optional uint64 major = 1;
+  optional uint64 minor = 2;
+  optional uint64 patch = 3;
+}
+
 message ProxyIdentifier {
   optional uint64 panel = 1;
   optional string answer = 2;
@@ -103,6 +128,9 @@ message Connection {
   }
 
   optional bool roof_access = 7;
+  optional bool purple_ending = 8;
+  optional bool cyan_ending = 9;
+  optional bool vanilla_only = 10;
 }
 
 message Door {
@@ -119,14 +147,16 @@ message Door {
   optional uint64 complete_at = 12;
 
   optional string control_center_color = 6;
-  repeated string switches = 7;
   repeated KeyholderAnswer keyholders = 13;
   repeated uint64 rooms = 14;
   repeated uint64 doors = 15;
-  repeated uint64 endings = 16;
+  optional bool white_ending = 16;
   optional bool double_letters = 18;
+  repeated string senders = 19;
 
   optional DoorType type = 8;
+  optional bool latch = 20;
+  optional bool legacy_location = 21;
 
   optional string location_name = 17;
 }
@@ -169,12 +199,16 @@ message PaintingData {
 
 message Port {
   optional uint64 id = 1;
+  optional uint64 ap_id = 11;
   optional uint64 room_id = 2;
   optional string name = 3;
 
+  optional string display_name = 10;
   optional string path = 4;
-  optional string orientation = 5;
+  optional Vec3d destination = 5;
+  optional double rotation = 8;
   optional AxisDirection gravity = 7;
+  optional bool no_shuffle = 9;
 
   optional uint64 required_door = 6;
 }
@@ -240,6 +274,8 @@ message Map {
   optional uint64 id = 1;
   optional string name = 2;
   optional string display_name = 3;
+  optional uint64 worldport_entrance = 4;
+  optional MapType type = 5;
 }
 
 message Progressive {
@@ -258,6 +294,8 @@ message DoorGroup {
 }
 
 message AllObjects {
+  optional VersionNumber version = 15;
+
   repeated Map maps = 7;
   repeated Room rooms = 1;
   repeated Door doors = 2;
@@ -66,6 +66,21 @@ 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;
+
+  // This means that the connection should additionally require all purple
+  // letters when the Strict Purple Ending option is on.
+  optional bool purple_ending = 9;
+
+  // This means that the connection should additionally require all cyan letters
+  // when the Strict Cyan Ending option is on.
+  optional bool cyan_ending = 10;
+
+  // This means that the connection only exists when doors are not shuffled.
+  optional bool vanilla_only = 11;
 }
 
 message HumanConnections {
@@ -86,16 +101,29 @@ 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 white_ending = 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;
+
+  // Non-item doors that are latched will stay open once opened, even if the
+  // opening trigger is deactivated. This applies to EVENT/LOCATION_ONLY doors,
+  // as well as item-locked doors when not shuffling doors.
+  optional bool latch = 17;
+
+  // If true, the client will treat this door like a location, even though no
+  // location is created for it in the generator. This helps provide backwards
+  // compatability with older worlds.
+  optional bool legacy_location = 18;
 }
 
 message HumanDoors {
@@ -135,9 +163,16 @@ message HumanPainting {
 
 message HumanPort {
   optional string name = 1;
+  optional string display_name = 8;
   optional string path = 2;
 
-  optional string orientation = 3;
+  optional bool no_shuffle = 7;
+
+  // These specify how the player should be placed when a randomized entrance
+  // sends them to this port. "rotation" is in degrees and is counter-clockwise 
+  // from the positive X axis.
+  optional Vec3d destination = 3;
+  optional double rotation = 6;
   optional AxisDirection gravity = 5 [default = Y_MINUS];
 
   optional DoorIdentifier required_door = 4;
@@ -191,7 +226,18 @@ message HumanRoom {
 
 message HumanMap {
   optional string display_name = 1;
+  optional MapType type = 4;
+
+  optional PortIdentifier worldport_entrance = 3;
+
+  // These two fields are used by the validator and nothing else. excluded_nodes
+  // are objects in the tscn that are intentionally not mentioned in the txtpb.
+  // custom_nodes are the reverse of that; objects that are mentioned in the
+  // txtpb but not present in the tscn. These are generally created dynamically
+  // by the game mod, but may also be used for places where the validator is
+  // just wrong about the contents of the map file.
   repeated string excluded_nodes = 2;
+  repeated string custom_nodes = 5;
 }
 
 message HumanProgressive {
@@ -213,11 +259,17 @@ message HumanDoorGroups {
   repeated HumanDoorGroup door_groups = 1;
 }
 
+message HumanGlobalMetadata {
+  repeated string special_names = 1;
+  optional VersionNumber version = 2;
+}
+
 message IdMappings {
   message RoomIds {
     map<string, uint64> panels = 1;
     map<string, uint64> masteries = 2;
     map<string, uint64> keyholders = 3;
+    map<string, uint64> ports = 4;
   }
 
   message MapIds {
@@ -2,6 +2,7 @@
 #include <google/protobuf/text_format.h>
 
 #include <cstdint>
+#include <filesystem>
 #include <fstream>
 #include <iostream>
 #include <map>
@@ -43,6 +44,7 @@ class AssignIds {
     ProcessSpecialIds();
     ProcessProgressivesFile(datadir_path / "progressives.txtpb");
     ProcessDoorGroupsFile(datadir_path / "door_groups.txtpb");
+    ProcessGlobalMetadataFile(datadir_path / "metadata.txtpb");
 
     WriteIds(ids_path);
 
@@ -63,6 +65,7 @@ class AssignIds {
         UpdateNextId(room.panels());
         UpdateNextId(room.masteries());
         UpdateNextId(room.keyholders());
+        UpdateNextId(room.ports());
       }
     }
 
@@ -109,7 +112,8 @@ class AssignIds {
 
   void ProcessDoor(const HumanDoor& h_door,
                    const std::string& current_map_name) {
-    if (h_door.type() == DoorType::EVENT) {
+    if (h_door.type() == DoorType::EVENT && !h_door.latch() &&
+        !h_door.legacy_location()) {
       return;
     }
 
@@ -243,6 +247,37 @@ class AssignIds {
                                              .at(h_keyholder.name());
       }
     }
+
+    for (const HumanPort& h_port : h_room.ports()) {
+      if (h_port.no_shuffle()) {
+        continue;
+      }
+
+      auto& maps = *output_.mutable_maps();
+      auto& rooms = *maps[current_map_name].mutable_rooms();
+      auto& ports = *rooms[h_room.name()].mutable_ports();
+
+      if (!id_mappings_.maps().contains(current_map_name) ||
+          !id_mappings_.maps()
+               .at(current_map_name)
+               .rooms()
+               .contains(h_room.name()) ||
+          !id_mappings_.maps()
+               .at(current_map_name)
+               .rooms()
+               .at(h_room.name())
+               .ports()
+               .contains(h_port.name())) {
+        ports[h_port.name()] = next_id_++;
+      } else {
+        ports[h_port.name()] = id_mappings_.maps()
+                                   .at(current_map_name)
+                                   .rooms()
+                                   .at(h_room.name())
+                                   .ports()
+                                   .at(h_port.name());
+      }
+    }
   }
 
   void ProcessSpecialIds() {
@@ -287,6 +322,23 @@ class AssignIds {
     }
   }
 
+  void ProcessGlobalMetadataFile(std::filesystem::path path) {
+    if (!std::filesystem::exists(path)) {
+      return;
+    }
+
+    auto h_metadata = ReadMessageFromFile<HumanGlobalMetadata>(path.string());
+    auto& specials = *output_.mutable_special();
+
+    for (const std::string& h_special : h_metadata.special_names()) {
+      if (!id_mappings_.special().contains(h_special)) {
+        specials[h_special] = next_id_++;
+      } else {
+        specials[h_special] = id_mappings_.special().at(h_special);
+      }
+    }
+  }
+
  private:
   void UpdateNextId(const google::protobuf::Map<std::string, uint64_t>& ids) {
     for (const auto& [_, id] : ids) {
@@ -45,6 +45,7 @@ class DataPacker {
     ProcessMaps(datadir_path);
     ProcessProgressivesFile(datadir_path / "progressives.txtpb");
     ProcessDoorGroupsFile(datadir_path / "door_groups.txtpb");
+    ProcessGlobalMetadataFile(datadir_path / "metadata.txtpb");
     ProcessIdsFile(datadir_path / "ids.yaml");
 
     {
@@ -87,9 +88,17 @@ class DataPacker {
     uint64_t map_id = container_.FindOrAddMap(map_name);
     Map& map = *container_.all_objects().mutable_maps(map_id);
 
+    map.set_type(metadata.type());
+
     if (metadata.has_display_name()) {
       map.set_display_name(metadata.display_name());
     }
+
+    if (metadata.has_worldport_entrance()) {
+      map.set_worldport_entrance(container_.FindOrAddPort(
+          map_name, metadata.worldport_entrance().room(),
+          metadata.worldport_entrance().name(), std::nullopt, std::nullopt));
+    }
   }
 
   void ProcessRooms(std::filesystem::path path,
@@ -238,7 +247,14 @@ class DataPacker {
     Port& port = *container_.all_objects().mutable_ports(port_id);
 
     port.set_path(h_port.path());
-    port.set_orientation(h_port.orientation());
+    port.set_display_name(h_port.display_name());
+
+    if (h_port.no_shuffle()) {
+      port.set_no_shuffle(h_port.no_shuffle());
+    } else {
+      *port.mutable_destination() = h_port.destination();
+      port.set_rotation(h_port.rotation());
+    }
 
     // Setting this explicitly because the Godot protobuf doesn't support
     // custom defaults.
@@ -345,8 +361,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 =
@@ -395,8 +411,8 @@ class DataPacker {
           container_.FindOrAddDoor(map_name, di.name(), current_map_name));
     }
 
-    for (const std::string& ending_name : h_door.endings()) {
-      door.add_endings(container_.FindOrAddEnding(ending_name));
+    if (h_door.has_white_ending()) {
+      door.set_white_ending(h_door.white_ending());
     }
 
     if (h_door.has_control_center_color()) {
@@ -416,6 +432,14 @@ class DataPacker {
     if (h_door.has_double_letters()) {
       door.set_double_letters(h_door.double_letters());
     }
+
+    if (h_door.has_latch()) {
+      door.set_latch(h_door.latch());
+    }
+
+    if (h_door.has_legacy_location()) {
+      door.set_legacy_location(h_door.legacy_location());
+    }
   }
 
   void ProcessConnectionsFile(std::filesystem::path path,
@@ -472,6 +496,21 @@ class DataPacker {
       r_connection.set_roof_access(human_connection.roof_access());
     }
 
+    if (human_connection.has_purple_ending()) {
+      f_connection.set_purple_ending(human_connection.purple_ending());
+      r_connection.set_purple_ending(human_connection.purple_ending());
+    }
+
+    if (human_connection.has_cyan_ending()) {
+      f_connection.set_cyan_ending(human_connection.cyan_ending());
+      r_connection.set_cyan_ending(human_connection.cyan_ending());
+    }
+
+    if (human_connection.has_vanilla_only()) {
+      f_connection.set_vanilla_only(human_connection.vanilla_only());
+      r_connection.set_vanilla_only(human_connection.vanilla_only());
+    }
+
     container_.AddConnection(f_connection);
     if (!human_connection.oneway()) {
       container_.AddConnection(r_connection);
@@ -603,6 +642,15 @@ class DataPacker {
     }
   }
 
+  void ProcessGlobalMetadataFile(std::filesystem::path path) {
+    if (!std::filesystem::exists(path)) {
+      return;
+    }
+
+    auto h_metadata = ReadMessageFromFile<HumanGlobalMetadata>(path.string());
+    *container_.all_objects().mutable_version() = h_metadata.version();
+  }
+
   void ProcessIdsFile(std::filesystem::path path) {
     auto ids = ReadIdsFromYaml(path.string());
 
@@ -635,6 +683,12 @@ class DataPacker {
               .mutable_keyholders(keyholder_id)
               ->set_ap_id(ap_id);
         }
+
+        for (const auto& [port_name, ap_id] : room.ports()) {
+          uint64_t port_id = container_.FindOrAddPort(
+              map_name, room_name, port_name, std::nullopt, std::nullopt);
+          container_.all_objects().mutable_ports(port_id)->set_ap_id(ap_id);
+        }
       }
     }
 
@@ -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;
 
@@ -64,6 +64,13 @@ IdMappings ReadIdsFromYaml(const std::string& filename) {
                   keyholder_it.second.as<uint64_t>();
             }
           }
+
+          if (room_it.second["ports"]) {
+            for (const auto& port_it : room_it.second["ports"]) {
+              (*room_ids.mutable_ports())[port_it.first.as<std::string>()] =
+                  port_it.second.as<uint64_t>();
+            }
+          }
         }
       }
 
@@ -146,6 +153,12 @@ void WriteIdsAsYaml(const IdMappings& ids, const std::string& filename) {
                                    keyholder_id;
                              });
 
+          OperateOnSortedMap(
+              room_ids.ports(),
+              [&room_node](const std::string& port_name, uint64_t port_id) {
+                room_node["ports"][port_name] = port_id;
+              });
+
           map_node["rooms"][room_name] = std::move(room_node);
         });
 
@@ -77,6 +77,21 @@ class HumanProcessor {
     for (const std::string& path : metadata.excluded_nodes()) {
       map_info.game_nodes[path].uses++;
     }
+
+    for (const std::string& path : metadata.custom_nodes()) {
+      map_info.game_nodes[path].defined = true;
+    }
+
+    if (metadata.has_worldport_entrance()) {
+      auto port_identifier = GetCompletePortIdentifier(
+          metadata.worldport_entrance(), current_map_name, std::nullopt);
+      if (port_identifier) {
+        PortInfo& port_info = info_.ports[*port_identifier];
+        port_info.map_worldport_entrances.push_back(current_map_name);
+      } else {
+        map_info.malformed_worldport_entrance = metadata.worldport_entrance();
+      }
+    }
   }
 
   void ProcessRooms(std::filesystem::path path,
@@ -358,11 +373,6 @@ class HumanProcessor {
       DoorInfo& other_door_info = info_.doors[complete_door_identifier];
       other_door_info.doors_referenced_by.push_back(door_identifier);
     }
-
-    for (const std::string& ei : h_door.endings()) {
-      EndingInfo& ending_info = info_.endings[ei];
-      ending_info.doors_referenced_by.push_back(door_identifier);
-    }
   }
 
   void ProcessConnectionsFile(std::filesystem::path path,
@@ -394,7 +404,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()) {
@@ -410,8 +422,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()) {
@@ -432,7 +445,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);
@@ -451,6 +464,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
@@ -463,6 +481,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
@@ -480,6 +503,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);
+        }
       }
     }
   }
@@ -542,12 +570,14 @@ class HumanProcessor {
     auto ids = ReadIdsFromYaml(path.string());
 
     DoorIdentifier di;
-    PanelIdentifier pi;
+    PanelIdentifier pai;
+    PortIdentifier poi;
     KeyholderIdentifier ki;
 
     for (const auto& [map_name, map] : ids.maps()) {
       di.set_map(map_name);
-      pi.set_map(map_name);
+      pai.set_map(map_name);
+      poi.set_map(map_name);
       ki.set_map(map_name);
 
       for (const auto& [door_name, ap_id] : map.doors()) {
@@ -558,13 +588,14 @@ class HumanProcessor {
       }
 
       for (const auto& [room_name, room] : map.rooms()) {
-        pi.set_room(room_name);
+        pai.set_room(room_name);
+        poi.set_room(room_name);
         ki.set_room(room_name);
 
         for (const auto& [panel_name, ap_id] : room.panels()) {
-          pi.set_name(panel_name);
+          pai.set_name(panel_name);
 
-          PanelInfo& panel_info = info_.panels[pi];
+          PanelInfo& panel_info = info_.panels[pai];
           panel_info.has_id = true;
         }
 
@@ -578,6 +609,13 @@ class HumanProcessor {
           KeyholderInfo& keyholder_info = info_.keyholders[ki];
           keyholder_info.has_id = true;
         }
+
+        for (const auto& [port_name, ap_id] : room.ports()) {
+          poi.set_name(port_name);
+
+          PortInfo& port_info = info_.ports[poi];
+          port_info.has_id = true;
+        }
       }
     }
 
@@ -27,6 +27,8 @@ struct GameNodeInfo {
 
 struct MapInfo {
   std::map<std::string, GameNodeInfo> game_nodes;
+
+  std::optional<PortIdentifier> malformed_worldport_entrance;
 };
 
 struct RoomInfo {
@@ -54,14 +56,18 @@ struct DoorInfo {
 
 struct PortInfo {
   std::vector<HumanPort> definitions;
+  bool has_id = false;
 
   std::vector<HumanConnection> connections_referenced_by;
+  std::vector<HumanConnection> target_connections_referenced_by;
+  std::vector<std::string> map_worldport_entrances;
 };
 
 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;
 };
 
@@ -79,6 +85,7 @@ struct PanelInfo {
   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;
@@ -101,8 +108,6 @@ struct LetterInfo {
 struct EndingInfo {
   std::vector<RoomIdentifier> defined_in;
   bool has_id = false;
-
-  std::vector<DoorIdentifier> doors_referenced_by;
 };
 
 struct PanelNameInfo {
@@ -69,6 +69,11 @@ class Validator {
                   << " is not defined in the game file." << std::endl;
       }
     }
+
+    if (map_info.malformed_worldport_entrance) {
+      std::cout << "The worldport entrance for map " << map_name
+                << " is malformed." << std::endl;
+    }
   }
 
   void ValidateRoom(const RoomIdentifier& room_identifier,
@@ -106,7 +111,8 @@ class Validator {
       return false;
     }
 
-    if (h_door.keyholders_size() > 0 || h_door.endings_size() > 0) {
+    if (h_door.keyholders_size() > 0 || h_door.white_ending() ||
+        h_door.complete_at() > 0) {
       return true;
     }
 
@@ -219,16 +225,23 @@ class Validator {
                   << " needs an explicit location name." << std::endl;
       }
 
-      if (h_door.double_letters() &&
-          (h_door.type() == DoorType::STANDARD ||
-           h_door.type() == DoorType::LOCATION_ONLY ||
-           h_door.type() == DoorType::GRAVESTONE)) {
-        std::cout << "Door " << door_identifier.ShortDebugString()
-                  << " is a location that depends on double_letters."
-                  << std::endl;
+      if (h_door.type() == DoorType::STANDARD ||
+          h_door.type() == DoorType::LOCATION_ONLY ||
+          h_door.type() == DoorType::GRAVESTONE || h_door.legacy_location()) {
+        if (h_door.double_letters()) {
+          std::cout << "Door " << door_identifier.ShortDebugString()
+                    << " is a location that depends on double_letters."
+                    << std::endl;
+        }
+
+        if (!h_door.has_location_room()) {
+          std::cout << "Door " << door_identifier.ShortDebugString()
+                    << " is missing a location_room." << std::endl;
+        }
       }
 
-      bool needs_id = (h_door.type() != DoorType::EVENT);
+      bool needs_id = (h_door.type() != DoorType::EVENT || h_door.latch() ||
+                       h_door.legacy_location());
       if (door_info.has_id != needs_id) {
         if (needs_id) {
           std::cout << "Door " << door_identifier.ShortDebugString()
@@ -252,10 +265,57 @@ class Validator {
         std::cout << "    CONNECTION " << connection.ShortDebugString()
                   << std::endl;
       }
+
+      for (const std::string& map_name : port_info.map_worldport_entrances) {
+        std::cout << "    MAP (worldport_entrance) " << map_name << std::endl;
+      }
+
+      if (port_info.has_id) {
+        std::cout << "    An AP ID is present." << std::endl;
+      }
     } else if (port_info.definitions.size() > 1) {
       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;
+          }
+        }
+      }
+    }
+
+    for (const HumanPort& port : port_info.definitions) {
+      if (!port.no_shuffle()) {
+        if (!port.has_destination()) {
+          std::cout << "Port " << port_identifier.ShortDebugString()
+                    << " is shuffleable and missing a destination."
+                    << std::endl;
+        }
+        if (!port.has_rotation()) {
+          std::cout << "Port " << port_identifier.ShortDebugString()
+                    << " is shuffleable and missing a rotation." << std::endl;
+        }
+        if (!port_info.has_id) {
+          std::cout << "Port " << port_identifier.ShortDebugString()
+                    << " is missing an AP ID." << std::endl;
+        }
+      } else {
+        if (port_info.has_id) {
+          std::cout << "Port " << port_identifier.ShortDebugString()
+                    << " should not have an AP ID." << std::endl;
+        }
+      }
+    }
   }
 
   void ValidatePainting(const PaintingIdentifier& painting_identifier,
@@ -279,6 +339,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,
@@ -340,6 +416,22 @@ class Validator {
       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,
@@ -410,12 +502,6 @@ class Validator {
       std::cout << "Ending " << ending_name
                 << " has no definition, but was referenced:" << std::endl;
 
-      for (const DoorIdentifier& door_identifier :
-           ending_info.doors_referenced_by) {
-        std::cout << "    DOOR " << door_identifier.ShortDebugString()
-                  << std::endl;
-      }
-
       if (ending_info.has_id) {
         std::cout << "    An AP ID is present." << std::endl;
       }
@@ -1,4 +1,4 @@
-#ifndef TOOLS_VALIDATOR_VALIDATOR_H_
+#ifndef TOOLS_VALIDATOR_VALIDATOR_H
 #define TOOLS_VALIDATOR_VALIDATOR_H
 
 namespace com::fourisland::lingo2_archipelago {
@@ -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"