11 files changed, 330 insertions, 39 deletions

@@ -0,0 +1,48 @@
+# Lingo 2 Apworld
+
+The Lingo 2 Apworld allows you to generate Archipelago Multiworlds containing
+Lingo 2.
+
+## Installation
+
+1. Download the Lingo 2 Apworld from
+   [the releases page](https://code.fourisland.com/lingo2-archipelago/about/apworld/CHANGELOG.md).
+2. If you do not already have it, download and install the
+   [Archipelago software](https://github.com/ArchipelagoMW/Archipelago/releases/).
+3. Double click on `lingo2.apworld` to install it, or copy it manually to the
+   `custom_worlds` folder of your Archipelago installation.
+
+## Running from source
+
+The apworld is mostly written in Python, which does not need to be compiled.
+However, there are two files that need to be generated before the apworld can be
+used.
+
+The first file is `data.binpb`, the datafile containing the randomizer logic.
+You can read about how to generate it on
+[its own README page](https://code.fourisland.com/lingo2-archipelago/about/data/README.md).
+Once you have it, put it in a subfolder of `apworld` called `generated`.
+
+The second generated file is `data_pb2.py`. This file allows Archipelago to read
+the datafile. We use `protoc`, the Protocol Buffer compiler, to generate it. As
+of 0.6.3, Archipelago has protobuf 3.20.3 packaged with it, which means we need
+to compile our proto file with a similar version.
+
+If you followed the steps to generate `data.binpb` and compiled the `datapacker`
+tool yourself, you will already have protobuf version 3.21.12 installed through
+vcpkg. You can then run a command similar to this in order to generate the
+python file.
+
+```shell
+.\out\build\x64-Debug\vcpkg_installed\x64-windows\tools\protobuf\protoc.exe -Iproto\ ^
+  --python_out=apworld\generated\ .\proto\data.proto
+```
+
+The exact path to `protoc.exe` is going to depend on where vcpkg installed its
+packages. The above location is where Visual Studio will probably put it.
+
+After generating those two files, the apworld should be functional. You can copy
+it into an Archipelago source tree (rename the folder `apworld` to `lingo2` if
+you do so) if you want to edit/debug the code. Otherwise, you can zip up the
+folder and rename it to `lingo2.apworld` in order to package it for
+distribution.
@@ -1,18 +1,27 @@
 """
 Archipelago init file for Lingo 2
 """
-from BaseClasses import ItemClassification, Item
+from BaseClasses import ItemClassification, Item, Tutorial
 from worlds.AutoWorld import WebWorld, World
 from .items import Lingo2Item
 from .options import Lingo2Options
 from .player_logic import Lingo2PlayerLogic
 from .regions import create_regions
 from .static_logic import Lingo2StaticLogic
+from .version import APWORLD_VERSION
 
 
 class Lingo2WebWorld(WebWorld):
     rich_text_options_doc = True
     theme = "grass"
+    tutorials = [Tutorial(
+        "Multiworld Setup Guide",
+        "A guide to playing Lingo 2 with Archipelago.",
+        "English",
+        "en_Lingo_2.md",
+        "setup/en",
+        ["hatkirby"]
+    )]
 
 
 class Lingo2World(World):
@@ -32,6 +41,8 @@ class Lingo2World(World):
     static_logic = Lingo2StaticLogic()
     item_name_to_id = static_logic.item_name_to_id
     location_name_to_id = static_logic.location_name_to_id
+    item_name_groups = static_logic.item_name_groups
+    location_name_groups = static_logic.location_name_groups
 
     player_logic: Lingo2PlayerLogic
 
@@ -71,12 +82,15 @@ class Lingo2World(World):
             "keyholder_sanity",
             "shuffle_control_center_colors",
             "shuffle_doors",
+            "shuffle_gallery_paintings",
             "shuffle_letters",
+            "shuffle_symbols",
             "victory_condition",
         ]
 
         slot_data = {
             **self.options.as_dict(*slot_options),
+            "version": [self.static_logic.get_data_version(), APWORLD_VERSION],
         }
 
         return slot_data
@@ -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,29 @@
+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",
+}
@@ -1,9 +1,9 @@
 from dataclasses import dataclass
 
-from Options import PerGameCommonOptions, Toggle, Choice
+from Options import PerGameCommonOptions, Toggle, Choice, DefaultOnToggle
 
 
-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,14 @@ 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 KeyholderSanity(Toggle):
     """
     If enabled, 26 locations will be created for placing each key into its respective Green Ending keyholder.
@@ -80,7 +93,23 @@ class DaedalusRoofAccess(Toggle):
 
 
 class VictoryCondition(Choice):
-    """Victory condition."""
+    """
+    This option determines what your goal is.
+    
+    - **Gray Ending** (The Colorful)
+    - **Purple Ending** (The Sun Temple). This ordinarily requires all level 1 (purple) letters.
+    - **Mint Ending** (typing EXIT into the keyholders in Control Center)
+    - **Black Ending** (The Graveyard)
+    - **Blue Ending** (The Words)
+    - **Cyan Ending** (The Parthenon). This ordinarily requires almost all level 2 (cyan) letters.
+    - **Red Ending** (The Tower)
+    - **Plum Ending** (The Wondrous / The Door)
+    - **Orange Ending** (the castle in Daedalus)
+    - **Gold Ending** (The Gold). This involves going through the color rooms in Daedalus.
+    - **Yellow Ending** (The Gallery). This requires unlocking all gallery paintings.
+    - **Green Ending** (The Ancient). This requires filling all keyholders with specific letters.
+    - **White Ending** (Control Center). This combines every other ending.
+    """
     display_name = "Victory Condition"
     option_gray_ending = 0
     option_purple_ending = 1
@@ -101,7 +130,9 @@ 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
     cyan_door_behavior: CyanDoorBehavior
     daedalus_roof_access: DaedalusRoofAccess
@@ -1,6 +1,7 @@
 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
@@ -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,9 +67,6 @@ 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)
 
@@ -60,6 +75,70 @@ 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 self.complete_at is None)
+
+    def __eq__(self, other: "AccessRequirements"):
+        return (self.items == other.items and self.progressives == other.progressives and self.rooms == other.rooms and
+                self.letters == other.letters and self.cyans == other.cyans and self.or_logic == other.or_logic and
+                self.complete_at == other.complete_at and self.possibilities == other.possibilities)
+
+    def simplify(self):
+        resimplify = False
+
+        if len(self.or_logic) > 0:
+            old_or_logic = self.or_logic
+
+            def remove_redundant(sub_reqs: "AccessRequirements"):
+                sub_reqs.letters = {l: v for l, v in sub_reqs.letters.items() if self.letters.get(l, 0) < v}
+
+            self.or_logic = []
+            for disjunction in old_or_logic:
+                new_disjunction = []
+                for ssr in disjunction:
+                    remove_redundant(ssr)
+                    if not ssr.is_empty():
+                        new_disjunction.append(ssr)
+                    else:
+                        new_disjunction.clear()
+                        break
+                if len(new_disjunction) == 1:
+                    self.merge(new_disjunction[0])
+                    resimplify = True
+                elif len(new_disjunction) > 1:
+                    if all(cjr == new_disjunction[0] for cjr in new_disjunction):
+                        self.merge(new_disjunction[0])
+                        resimplify = True
+                    else:
+                        self.or_logic.append(new_disjunction)
+
+        if resimplify:
+            self.simplify()
+
     def __repr__(self):
         parts = []
         if len(self.items) > 0:
@@ -68,14 +147,16 @@ 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}")
+        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)})"
 
 
@@ -158,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)
@@ -231,6 +315,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:
@@ -253,25 +341,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)
@@ -294,18 +392,26 @@ 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.
@@ -316,7 +422,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
@@ -335,12 +442,18 @@ class Lingo2PlayerLogic:
 
         for ending_id in door.endings:
             ending = self.world.static_logic.objects.endings[ending_id]
-            reqs.items.add(f"{ending.name.capitalize()} Ending (Achieved)")
+
+            if self.world.options.victory_condition.current_key.removesuffix("_ending").upper() == ending.name:
+                reqs.items.add("Victory")
+            else:
+                reqs.items.add(f"{ending.name.capitalize()} Ending (Achieved)")
 
         for sub_door_id in door.doors:
             sub_reqs = self.get_door_open_reqs(sub_door_id)
             reqs.merge(sub_reqs)
 
+        reqs.simplify()
+
         return reqs
 
     # This gets the requirements to open a door within the world. When a door is shuffled, this means having the item
@@ -11,12 +11,18 @@ if TYPE_CHECKING:
 
 
 def create_region(room, world: "Lingo2World") -> Region:
-    new_region = Region(world.static_logic.get_room_region_name(room.id), world.player, world.multiworld)
+    return Region(world.static_logic.get_room_region_name(room.id), world.player, world.multiworld)
 
+
+def create_locations(room, new_region: Region, world: "Lingo2World", regions: dict[str, Region]):
     for location in world.player_logic.locations_by_room.get(room.id, {}):
+        reqs = location.reqs.copy()
+        if new_region.name in reqs.rooms:
+            reqs.rooms.remove(new_region.name)
+
         new_location = Lingo2Location(world.player, world.static_logic.location_id_to_name[location.code],
                                       location.code, new_region)
-        new_location.access_rule = make_location_lambda(location.reqs, world)
+        new_location.access_rule = make_location_lambda(reqs, world, regions)
         new_region.locations.append(new_location)
 
     for event_name, item_name in world.player_logic.event_loc_item_by_room.get(room.id, {}).items():
@@ -25,17 +31,23 @@ def create_region(room, world: "Lingo2World") -> Region:
         new_location.place_locked_item(event_item)
         new_region.locations.append(new_location)
 
-    return new_region
-
-
 def create_regions(world: "Lingo2World"):
     regions = {
         "Menu": Region("Menu", world.player, world.multiworld)
     }
 
+    region_and_room = []
+
+    # Create the regions in two stages. First, make the actual region objects and memoize them. Then, add all of the
+    # locations. This allows us to reference the actual region objects in the access rules for the locations, which is
+    # faster than having to look them up during access checking.
     for room in world.static_logic.objects.rooms:
         region = create_region(room, world)
         regions[region.name] = region
+        region_and_room.append((region, room))
+
+    for (region, room) in region_and_room:
+        create_locations(room, region, world, regions)
 
     regions["Menu"].connect(regions["The Entry - Starting Room"], "Start Game")
 
@@ -82,14 +94,18 @@ def create_regions(world: "Lingo2World"):
             else:
                 connection_name = f"{connection_name} (via panel {panel.name})"
 
+        reqs.simplify()
+
         if from_region in regions and to_region in regions:
             connection = Entrance(world.player, connection_name, regions[from_region])
-            connection.access_rule = make_location_lambda(reqs, world)
+            connection.access_rule = make_location_lambda(reqs, world, regions)
 
             regions[from_region].exits.append(connection)
             connection.connect(regions[to_region])
 
             for region in reqs.rooms:
+                if region == from_region:
+                    continue
                 world.multiworld.register_indirect_condition(regions[region], connection)
 
     world.multiworld.regions += regions.values()
@@ -1 +1 @@
-protobuf==3.20.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,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,4 +1,5 @@
 from .generated import data_pb2 as data_pb2
+from .items import SYMBOL_ITEMS
 import pkgutil
 
 class Lingo2StaticLogic:
@@ -8,9 +9,14 @@ 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]]
+
     def __init__(self):
         self.item_id_to_name = {}
         self.location_id_to_name = {}
+        self.item_name_groups = {}
+        self.location_name_groups = {}
 
         file = pkgutil.get_data(__name__, "generated/data.binpb")
         self.objects = data_pb2.AllObjects()
@@ -29,17 +35,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,9 +61,13 @@ 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"
 
+        for symbol_name in SYMBOL_ITEMS.values():
+            self.item_id_to_name[self.objects.special_ids[symbol_name]] = symbol_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()}
 
@@ -80,7 +94,7 @@ class Lingo2StaticLogic:
         if door.type != data_pb2.DoorType.STANDARD:
             return None
 
-        if len(door.keyholders) > 0 or len(door.endings) > 0:
+        if len(door.keyholders) > 0 or len(door.endings) > 0 or not door.HasField("complete_at"):
             return None
 
         if len(door.panels) > 4:
@@ -140,3 +154,6 @@ class Lingo2StaticLogic:
             return f"{game_map.display_name} ({room.panel_display_name})"
         else:
             return game_map.display_name
+
+    def get_data_version(self) -> int:
+        return self.objects.version
@@ -0,0 +1 @@
+APWORLD_VERSION = 2