1 files changed, 51 insertions, 2 deletions

@@ -2,17 +2,20 @@ from typing import TYPE_CHECKING
 
 from BaseClasses import Region
 from .locations import Lingo2Location
+from .player_logic import AccessRequirements
+from .rules import make_location_lambda
 
 if TYPE_CHECKING:
     from . import Lingo2World
 
 
 def create_region(room, world: "Lingo2World") -> Region:
-    new_region = Region(room.name, world.player, world.multiworld)
+    new_region = Region(world.static_logic.get_room_region_name(room.id), world.player, world.multiworld)
 
     for location in world.player_logic.locations_by_room.get(room.id, {}):
         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_region.locations.append(new_location)
 
     return new_region
@@ -24,6 +27,52 @@ def create_regions(world: "Lingo2World"):
     }
 
     for room in world.static_logic.objects.rooms:
-        regions[room.name] = create_region(room, world)
+        region = create_region(room, world)
+        regions[region.name] = region
+
+    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:
+        from_region = world.static_logic.get_room_region_name(connection.from_room)
+        to_region = world.static_logic.get_room_region_name(connection.to_room)
+        connection_name = f"{from_region} -> {to_region}"
+
+        reqs = AccessRequirements()
+
+        if connection.HasField("required_door"):
+            reqs.merge(world.player_logic.get_door_reqs(connection.required_door))
+
+            door = world.static_logic.objects.doors[connection.required_door]
+            wmap = world.static_logic.objects.maps[door.map_id]
+            connection_name = f"{connection_name} (using {wmap.name} - {door.name})"
+
+        if connection.HasField("port"):
+            port = world.static_logic.objects.ports[connection.port]
+            connection_name = f"{connection_name} (via port {port.name})"
+
+            if port.HasField("required_door"):
+                reqs.merge(world.player_logic.get_door_reqs(port.required_door))
+
+        if connection.HasField("painting"):
+            painting = world.static_logic.objects.paintings[connection.painting]
+            connection_name = f"{connection_name} (via painting {painting.name})"
+
+            if painting.HasField("required_door"):
+                reqs.merge(world.player_logic.get_door_reqs(painting.required_door))
+
+        if connection.HasField("panel"):
+            proxy = connection.panel
+            reqs.merge(world.player_logic.get_panel_reqs(proxy.panel,
+                                                         proxy.answer if proxy.HasField("answer") else None))
+
+            panel = world.static_logic.objects.panels[proxy.panel]
+            if proxy.HasField("answer"):
+                connection_name = f"{connection_name} (via panel {panel.name}/{proxy.answer})"
+            else:
+                connection_name = f"{connection_name} (via panel {panel.name})"
+
+        if from_region in regions and to_region in regions:
+            regions[from_region].connect(regions[to_region], connection_name, make_location_lambda(reqs, world))
 
     world.multiworld.regions += regions.values()