16 files changed, 292 insertions, 41 deletions

@@ -9,14 +9,43 @@ 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.
 
-There are multiple parts of this project:
+## How To Play
 
-- [Client](https://code.fourisland.com/lingo2-archipelago/about/client/README.md)
-- [Apworld](https://code.fourisland.com/lingo2-archipelago/about/apworld/README.md)
-- [Data](https://code.fourisland.com/lingo2-archipelago/about/data/README.md)
+Here are the components needed in order to play:
+
+- **Apworld**: This is used by Archipelago to generate randomized Lingo 2
+  worlds.
+    - [Installation & FAQ](https://code.fourisland.com/lingo2-archipelago/about/apworld/README.md)
+    - [Downloads](https://code.fourisland.com/lingo2-archipelago/about/apworld/CHANGELOG.md)
+- **Client**: This is how Lingo 2 connects to an Archipelago multiworld.
+    - [Installation & FAQ](https://code.fourisland.com/lingo2-archipelago/about/client/README.md)
+    - [Downloads](https://code.fourisland.com/lingo2-archipelago/about/client/CHANGELOG.md)
 
 ## Frequently Asked Questions
 
+### Why aren't the starting room letters shuffled?
+
+The letter requirements for solving puzzles are very restrictive, especially in
+the early game. It is possible for the generator to find some subset of letters
+and doors to place in the starting room such that you are not trapped, but this
+places a lot of strain on generation and leads to significantly more generation
+failures.
+
+As a result, the starting room letters (H1, I1, N1, and T1) are always present
+in the starting room, even when remote letter shuffle is enabled. These letters
+will _also_ count as clearing a check, so you will send out another item at the
+same time as collecting the letter.
+
+### What areas are randomized?
+
+Almost all maps that you can access from the base game are randomized. The
+exceptions are:
+
+- Icarus (this will be randomized at some point, although it will be optional)
+- Demo
+- The Hinterlands (this will probably be repurposed)
+- The beta tester gift maps
+
 ### What about wall snipes?
 
 "Wall sniping" refers to the fact that you are able to solve puzzles on the
@@ -64,3 +93,11 @@ disappears. You can retrieve your letter immediately by pressing C or G again
 while standing in the same position, as the keyholder is still there, just
 invisible. If you have already left the room, though, there is an easier way to
 get your letters back: just use the Key Return in The Entry.
+
+## Project Details
+
+There are multiple parts of this project:
+
+- [Client](https://code.fourisland.com/lingo2-archipelago/about/client/README.md)
+- [Apworld](https://code.fourisland.com/lingo2-archipelago/about/apworld/README.md)
+- [Data](https://code.fourisland.com/lingo2-archipelago/about/data/README.md)
@@ -0,0 +1,13 @@
+# lingo2-archipelago Apworld Releases
+
+## 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)
@@ -82,6 +82,7 @@ class Lingo2World(World):
             "keyholder_sanity",
             "shuffle_control_center_colors",
             "shuffle_doors",
+            "shuffle_gallery_paintings",
             "shuffle_letters",
             "shuffle_symbols",
             "victory_condition",
@@ -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
@@ -125,6 +130,7 @@ class VictoryCondition(Choice):
 class Lingo2Options(PerGameCommonOptions):
     shuffle_doors: ShuffleDoors
     shuffle_control_center_colors: ShuffleControlCenterColors
+    shuffle_gallery_paintings: ShuffleGalleryPaintings
     shuffle_letters: ShuffleLetters
     shuffle_symbols: ShuffleSymbols
     keyholder_sanity: KeyholderSanity
@@ -30,6 +30,11 @@ class AccessRequirements:
     # 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()
@@ -37,6 +42,20 @@ class AccessRequirements:
         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:
@@ -56,9 +75,69 @@ class AccessRequirements:
         for disjunction in other.or_logic:
             self.or_logic.append(disjunction)
 
+        if other.complete_at is not None:
+            # Merging multiple requirements that use complete_at sucks, and is part of why we want to minimize use of
+            # it. If both requirements use complete_at, we will cheat by using the or_logic field, which supports
+            # conjunctions of requirements.
+            if self.complete_at is not None:
+                print("Merging requirements with complete_at > 1. This is messy and should be avoided!")
+
+                left_req = AccessRequirements()
+                left_req.complete_at = self.complete_at
+                left_req.possibilities = self.possibilities
+                self.or_logic.append([left_req])
+
+                self.complete_at = None
+                self.possibilities = list()
+
+                right_req = AccessRequirements()
+                right_req.complete_at = other.complete_at
+                right_req.possibilities = other.possibilities
+                self.or_logic.append([right_req])
+            else:
+                self.complete_at = other.complete_at
+                self.possibilities = other.possibilities
+
     def is_empty(self) -> bool:
         return (len(self.items) == 0 and len(self.progressives) == 0 and len(self.rooms) == 0 and len(self.letters) == 0
-                and not self.cyans and len(self.or_logic) == 0)
+                and not self.cyans and len(self.or_logic) == 0 and self.complete_at is None)
+
+    def __eq__(self, other: "AccessRequirements"):
+        return (self.items == other.items and self.progressives == other.progressives and self.rooms == other.rooms and
+                self.letters == other.letters and self.cyans == other.cyans and self.or_logic == other.or_logic and
+                self.complete_at == other.complete_at and self.possibilities == other.possibilities)
+
+    def simplify(self):
+        resimplify = False
+
+        if len(self.or_logic) > 0:
+            old_or_logic = self.or_logic
+
+            def remove_redundant(sub_reqs: "AccessRequirements"):
+                sub_reqs.letters = {l: v for l, v in sub_reqs.letters.items() if self.letters.get(l, 0) < v}
+
+            self.or_logic = []
+            for disjunction in old_or_logic:
+                new_disjunction = []
+                for ssr in disjunction:
+                    remove_redundant(ssr)
+                    if not ssr.is_empty():
+                        new_disjunction.append(ssr)
+                    else:
+                        new_disjunction.clear()
+                        break
+                if len(new_disjunction) == 1:
+                    self.merge(new_disjunction[0])
+                    resimplify = True
+                elif len(new_disjunction) > 1:
+                    if all(cjr == new_disjunction[0] for cjr in new_disjunction):
+                        self.merge(new_disjunction[0])
+                        resimplify = True
+                    else:
+                        self.or_logic.append(new_disjunction)
+
+        if resimplify:
+            self.simplify()
 
     def __repr__(self):
         parts = []
@@ -74,6 +153,10 @@ class AccessRequirements:
             parts.append(f"cyans=True")
         if len(self.or_logic) > 0:
             parts.append(f"or_logic={self.or_logic}")
+        if self.complete_at is not None:
+            parts.append(f"complete_at={self.complete_at}")
+        if len(self.possibilities) > 0:
+            parts.append(f"possibilities={self.possibilities}")
         return f"AccessRequirements({", ".join(parts)})"
 
 
@@ -156,6 +239,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)
@@ -306,7 +392,6 @@ 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)
@@ -323,8 +408,10 @@ class Lingo2PlayerLogic:
             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.
@@ -365,6 +452,8 @@ class Lingo2PlayerLogic:
             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
@@ -11,12 +11,18 @@ if TYPE_CHECKING:
 
 
 def create_region(room, world: "Lingo2World") -> Region:
-    new_region = Region(world.static_logic.get_room_region_name(room.id), world.player, world.multiworld)
+    return Region(world.static_logic.get_room_region_name(room.id), world.player, world.multiworld)
 
+
+def create_locations(room, new_region: Region, world: "Lingo2World", regions: dict[str, Region]):
     for location in world.player_logic.locations_by_room.get(room.id, {}):
+        reqs = location.reqs.copy()
+        if new_region.name in reqs.rooms:
+            reqs.rooms.remove(new_region.name)
+
         new_location = Lingo2Location(world.player, world.static_logic.location_id_to_name[location.code],
                                       location.code, new_region)
-        new_location.access_rule = make_location_lambda(location.reqs, world)
+        new_location.access_rule = make_location_lambda(reqs, world, regions)
         new_region.locations.append(new_location)
 
     for event_name, item_name in world.player_logic.event_loc_item_by_room.get(room.id, {}).items():
@@ -25,17 +31,23 @@ def create_region(room, world: "Lingo2World") -> Region:
         new_location.place_locked_item(event_item)
         new_region.locations.append(new_location)
 
-    return new_region
-
-
 def create_regions(world: "Lingo2World"):
     regions = {
         "Menu": Region("Menu", world.player, world.multiworld)
     }
 
+    region_and_room = []
+
+    # Create the regions in two stages. First, make the actual region objects and memoize them. Then, add all of the
+    # locations. This allows us to reference the actual region objects in the access rules for the locations, which is
+    # faster than having to look them up during access checking.
     for room in world.static_logic.objects.rooms:
         region = create_region(room, world)
         regions[region.name] = region
+        region_and_room.append((region, room))
+
+    for (region, room) in region_and_room:
+        create_locations(room, region, world, regions)
 
     regions["Menu"].connect(regions["The Entry - Starting Room"], "Start Game")
 
@@ -82,14 +94,18 @@ def create_regions(world: "Lingo2World"):
             else:
                 connection_name = f"{connection_name} (via panel {panel.name})"
 
+        reqs.simplify()
+
         if from_region in regions and to_region in regions:
             connection = Entrance(world.player, connection_name, regions[from_region])
-            connection.access_rule = make_location_lambda(reqs, world)
+            connection.access_rule = make_location_lambda(reqs, world, regions)
 
             regions[from_region].exits.append(connection)
             connection.connect(regions[to_region])
 
             for region in reqs.rooms:
+                if region == from_region:
+                    continue
                 world.multiworld.register_indirect_condition(regions[region], connection)
 
     world.multiworld.regions += regions.values()
@@ -1,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,6 +19,9 @@ 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
 
+    if not all(state.can_reach(region) for region in regions):
+        return False
+
     for letter_key, letter_level in reqs.letters.items():
         if not state.has(letter_key, world.player, letter_level):
             return False
@@ -28,11 +32,32 @@ 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]) -> Callable[[CollectionState], bool]:
+    # Replace required rooms with regions for the top level requirement, which saves looking up the regions during rule
+    # checking.
+    required_regions = [regions[room_name] for room_name in reqs.rooms]
+    new_reqs = reqs.copy()
+    new_reqs.rooms.clear()
+    return lambda state: lingo2_can_satisfy_requirements(state, new_reqs, required_regions, world)
@@ -1 +1 @@
-APWORLD_VERSION = 1
+APWORLD_VERSION = 2
@@ -1,6 +1,6 @@
 extends Node
 
-const MOD_VERSION = 1
+const MOD_VERSION = 2
 
 var SCRIPT_client
 var SCRIPT_keyboard
@@ -41,11 +41,13 @@ const kCYAN_DOOR_BEHAVIOR_H2 = 0
 const kCYAN_DOOR_BEHAVIOR_DOUBLE_LETTER = 1
 const kCYAN_DOOR_BEHAVIOR_ITEM = 2
 
+var apworld_version = [0, 0]
 var cyan_door_behavior = kCYAN_DOOR_BEHAVIOR_H2
 var daedalus_roof_access = false
 var keyholder_sanity = false
 var shuffle_control_center_colors = false
 var shuffle_doors = false
+var shuffle_gallery_paintings = false
 var shuffle_letters = kSHUFFLE_LETTERS_VANILLA
 var shuffle_symbols = false
 var victory_condition = -1
@@ -361,10 +363,14 @@ func _client_connected(slot_data):
         keyholder_sanity = bool(slot_data.get("keyholder_sanity", false))
         shuffle_control_center_colors = bool(slot_data.get("shuffle_control_center_colors", false))
         shuffle_doors = bool(slot_data.get("shuffle_doors", false))
+        shuffle_gallery_paintings = bool(slot_data.get("shuffle_gallery_paintings", false))
         shuffle_letters = int(slot_data.get("shuffle_letters", 0))
         shuffle_symbols = bool(slot_data.get("shuffle_symbols", false))
         victory_condition = int(slot_data.get("victory_condition", 0))
 
+        if slot_data.has("version"):
+                apworld_version = [int(slot_data["version"][0]), int(slot_data["version"][1])]
+
         # Set up item locks.
         _item_locks = {}
 
@@ -399,6 +405,11 @@ func _client_connected(slot_data):
                                 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:
@@ -100,6 +100,10 @@ func _ready():
         $Panel/player_box.add_theme_font_size_override("font_size", 36)
         $Panel/password_box.add_theme_font_size_override("font_size", 36)
 
+        # Set up version mismatch dialog.
+        $Panel/VersionMismatch.connect("confirmed", startGame)
+        $Panel/VersionMismatch.get_cancel_button().pressed.connect(versionMismatchDeclined)
+
 
 # Adapted from https://gitlab.com/Delta-V-Modding/Mods/-/blob/main/game/ModLoader.gd
 func installScriptExtension(childScript: Resource):
@@ -129,6 +133,33 @@ func connectionStatus(message):
 
 func connectionSuccessful():
         var ap = global.get_node("Archipelago")
+        var gamedata = global.get_node("Gamedata")
+
+        # Check for major version mismatch.
+        if ap.apworld_version[0] != gamedata.objects.get_version():
+                $Panel/AcceptDialog.exclusive = false
+
+                var popup = self.get_node("Panel/VersionMismatch")
+                popup.title = "Version Mismatch!"
+                popup.dialog_text = (
+                        "This slot was generated using v%d.%d of the Lingo 2 apworld,\nwhich has a different major version than this client (v%d.%d).\nIt is highly recommended to play using the correct version of the client.\nYou may experience bugs or logic issues if you continue."
+                        % [
+                                ap.apworld_version[0],
+                                ap.apworld_version[1],
+                                gamedata.objects.get_version(),
+                                ap.MOD_VERSION
+                        ]
+                )
+                popup.exclusive = true
+                popup.popup_centered()
+
+                return
+
+        startGame()
+
+
+func startGame():
+        var ap = global.get_node("Archipelago")
 
         # Save connection details
         var connection_details = [ap.ap_server, ap.ap_user, ap.ap_pass]
@@ -193,6 +224,10 @@ func connectionUnsuccessful(error_message):
         popup.popup_centered()
 
 
+func versionMismatchDeclined():
+        $Panel/AcceptDialog.hide()
+
+
 func historySelected(index):
         var ap = global.get_node("Archipelago")
         var details = ap.connection_history[index]
@@ -0,0 +1,11 @@
+# lingo2-archipelago Client Releases
+
+## 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)
@@ -150,6 +150,10 @@ caret_blink = true
 offset_right = 83.0
 offset_bottom = 58.0
 
+[node name="VersionMismatch" type="ConfirmationDialog" parent="Panel"]
+offset_right = 83.0
+offset_bottom = 58.0
+
 [node name="connection_history" type="MenuButton" parent="Panel"]
 offset_left = 1239.0
 offset_top = 276.0
@@ -195,8 +195,8 @@ doors {
 }
 doors {
   name: "Welcome Back Door"
-  type: STANDARD
-  receivers: "Components/Doors/Entry/entry_14"
+  type: LOCATION_ONLY
+  #receivers: "Components/Doors/Entry/entry_14"
   panels { room: "Welcome Back Area" name: "GREETINGS OLD FRIEND" }
   location_room: "Welcome Back Area"
 }
@@ -1,7 +1,7 @@
 # The Gallery is interesting because there's so many cross-map requirements.
 doors {
   name: "Darkroom Painting"
-  type: ITEM_ONLY
+  type: GALLERY_PAINTING
   #move_paintings { room: "Main Area" name: "DARKROOM" }
   receivers: "Components/Paintings/darkroom/teleportListener"
   panels { map: "the_darkroom" room: "First Room" name: "BISON" }
@@ -27,14 +27,14 @@ doors {
 }
 doors {
   name: "Butterfly Painting"
-  type: ITEM_ONLY
+  type: GALLERY_PAINTING
   #move_paintings { room: "Main Area" name: "BUTTERFLY" }
   receivers: "Components/Paintings/butterfly/teleportListener"
   rooms { map: "the_butterfly" name: "Main Area" }
 }
 doors {
   name: "Between Painting"
-  type: ITEM_ONLY
+  type: GALLERY_PAINTING
   #move_paintings { room: "Main Area" name: "BETWEEN" }
   receivers: "Components/Paintings/between/teleportListener"
   panels { map: "the_between" room: "Main Area" name: "SUN" }
@@ -70,14 +70,14 @@ doors {
 }
 doors {
   name: "Entry Painting"
-  type: ITEM_ONLY
+  type: GALLERY_PAINTING
   #move_paintings { room: "Main Area" name: "ENTRY" }
   receivers: "Components/Paintings/eyes/teleportListener"
   panels { map: "the_entry" room: "Eye Room" name: "I" }
 }
 doors {
   name: "Wise Painting"
-  type: ITEM_ONLY
+  type: GALLERY_PAINTING
   #move_paintings { room: "Main Area" name: "WISE" }
   receivers: "Components/Paintings/triangle/teleportListener"
   panels { map: "the_wise" room: "Entry" name: "INK" }
@@ -105,7 +105,7 @@ doors {
 }
 doors {
   name: "Tree Painting"
-  type: ITEM_ONLY
+  type: GALLERY_PAINTING
   #move_paintings { room: "Main Area" name: "TREE" }
   receivers: "Components/Paintings/Clue Maps/tree/teleportListener"
   panels { map: "the_tree" room: "Main Area" name: "COLOR" }
@@ -142,35 +142,35 @@ doors {
 }
 doors {
   name: "Unyielding Painting"
-  type: ITEM_ONLY
+  type: GALLERY_PAINTING
   #move_paintings { room: "Main Area" name: "UNYIELDING" }
   receivers: "Components/Paintings/Clue Maps/unyielding/teleportListener"
   rooms { map: "the_unyielding" name: "Digital Entrance" }
 }
 doors {
   name: "Graveyard Painting"
-  type: ITEM_ONLY
+  type: GALLERY_PAINTING
   #move_paintings { room: "Main Area" name: "GRAVEYARD" }
   receivers: "Components/Paintings/Endings/grave/teleportListener"
   rooms { map: "the_graveyard" name: "Outside" }
 }
 doors {
   name: "Control Center Painting"
-  type: ITEM_ONLY
+  type: GALLERY_PAINTING
   #move_paintings { room: "Main Area" name: "CC" }
   receivers: "Components/Paintings/Endings/desert/teleportListener"
   rooms { map: "the_impressive" name: "M2 Room" }
 }
 doors {
   name: "Tower Painting"
-  type: ITEM_ONLY
+  type: GALLERY_PAINTING
   #move_paintings { room: "Main Area" name: "TOWER" }
   receivers: "Components/Paintings/Endings/red/teleportListener"
   rooms { map: "the_tower" name: "First Floor" }
 }
 doors {
   name: "Wondrous Painting"
-  type: ITEM_ONLY
+  type: GALLERY_PAINTING
   #move_paintings { room: "Main Area" name: "WONDROUS" }
   receivers: "Components/Paintings/Endings/window/teleportListener"
   panels { map: "the_wondrous" room: "Entry" name: "WONDER" }
@@ -187,42 +187,42 @@ doors {
 }
 doors {
   name: "Rainbow Painting"
-  type: ITEM_ONLY
+  type: GALLERY_PAINTING
   #move_paintings { room: "Main Area" name: "RAINBOW" }
   receivers: "Components/Paintings/Endings/rainbow/teleportListener"
   rooms { map: "daedalus" name: "Rainbow Start" }
 }
 doors {
   name: "Words Painting"
-  type: ITEM_ONLY
+  type: GALLERY_PAINTING
   #move_paintings { room: "Main Area" name: "WORDS" }
   receivers: "Components/Paintings/Endings/words/teleportListener"
   rooms { map: "the_words" name: "Main Area" }
 }
 doors {
   name: "Colorful Painting"
-  type: ITEM_ONLY
+  type: GALLERY_PAINTING
   #move_paintings { room: "Main Area" name: "COLORFUL" }
   receivers: "Components/Paintings/Endings/colorful/teleportListener"
   rooms { map: "the_colorful" name: "White Room" }
 }
 doors {
   name: "Castle Painting"
-  type: ITEM_ONLY
+  type: GALLERY_PAINTING
   #move_paintings { room: "Main Area" name: "CASTLE" }
   receivers: "Components/Paintings/Endings/castle/teleportListener"
   rooms { map: "daedalus" name: "Castle" }
 }
 doors {
   name: "Sun Temple Painting"
-  type: ITEM_ONLY
+  type: GALLERY_PAINTING
   #move_paintings { room: "Main Area" name: "SUNTEMPLE" }
   receivers: "Components/Paintings/Endings/temple/teleportListener"
   rooms { map: "the_sun_temple" name: "Entrance" }
 }
 doors {
   name: "Ancient Painting"
-  type: ITEM_ONLY
+  type: GALLERY_PAINTING
   #move_paintings { room: "Main Area" name: "ANCIENT" }
   receivers: "Components/Paintings/Endings/cubes/teleportListener"
   rooms { map: "the_ancient" name: "Outside" }
@@ -1,4 +1,4 @@
-version: 2
+version: 3
 # Filler item.
 special_names: "A Job Well Done"
 # Symbol items.
@@ -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 {