trying something cc-colors

1 files changed, 54 insertions, 21 deletions

@@ -6,14 +6,14 @@ from entrance_rando import randomize_entrances
 from .items import Lingo2Item
 from .locations import Lingo2Location
 from .player_logic import AccessRequirements
-from .rules import make_location_lambda
+from .rules import make_location_lambda, Lingo2Entrance, ControlCenterColor, CONTROL_CENTER_COLOR_NAMES, Lingo2Region
 
 if TYPE_CHECKING:
     from . import Lingo2World
 
 
 def create_region(room, world: "Lingo2World") -> Region:
-    return Region(world.static_logic.get_room_region_name(room.id), world.player, world.multiworld)
+    return Lingo2Region(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]):
@@ -53,7 +53,7 @@ def create_locations(room, new_region: Region, world: "Lingo2World", regions: di
 
 def create_regions(world: "Lingo2World"):
     regions = {
-        "Menu": Region("Menu", world.player, world.multiworld)
+        "Menu": Lingo2Region("Menu", world.player, world.multiworld)
     }
 
     region_and_room = []
@@ -69,7 +69,10 @@ def create_regions(world: "Lingo2World"):
     for (region, room) in region_and_room:
         create_locations(room, region, world, regions)
 
-    regions["Menu"].connect(regions["The Entry - Starting Room"], "Start Game")
+    start_game = Lingo2Entrance(world.player, "Start Game", regions["Menu"])
+    start_game.set_lingo2_rule(world, regions, AccessRequirements(), ControlCenterColor.ALL)
+    regions["Menu"].exits.append(start_game)
+    start_game.connect(regions["The Entry - Starting Room"])
 
     for connection in world.static_logic.objects.connections:
         if connection.roof_access and not world.options.daedalus_roof_access:
@@ -87,6 +90,7 @@ def create_regions(world: "Lingo2World"):
         connection_name = f"{from_region} -> {to_region}"
 
         reqs = AccessRequirements()
+        control_center_colors = ControlCenterColor.ALL
 
         if connection.HasField("required_door"):
             reqs.merge(world.player_logic.get_door_open_reqs(connection.required_door))
@@ -95,6 +99,10 @@ def create_regions(world: "Lingo2World"):
             wmap = world.static_logic.objects.maps[door.map_id]
             connection_name = f"{connection_name} (using {wmap.name} - {door.name})"
 
+            if door.HasField("control_center_color"):
+                control_center_colors = control_center_colors & CONTROL_CENTER_COLOR_NAMES.get(
+                    door.control_center_color, ControlCenterColor.NONE)
+
         if connection.HasField("port"):
             port = world.static_logic.objects.ports[connection.port]
             connection_name = f"{connection_name} (via {port.display_name})"
@@ -105,6 +113,11 @@ def create_regions(world: "Lingo2World"):
             if port.HasField("required_door"):
                 reqs.merge(world.player_logic.get_door_open_reqs(port.required_door))
 
+                req_door = world.static_logic.objects.doors[port.required_door]
+                if req_door.HasField("control_center_color"):
+                    control_center_colors = control_center_colors & CONTROL_CENTER_COLOR_NAMES.get(
+                        req_door.control_center_color, ControlCenterColor.NONE)
+
         if connection.HasField("painting"):
             painting = world.static_logic.objects.paintings[connection.painting]
             connection_name = f"{connection_name} (via painting {painting.name})"
@@ -112,6 +125,11 @@ def create_regions(world: "Lingo2World"):
             if painting.HasField("required_door"):
                 reqs.merge(world.player_logic.get_door_open_reqs(painting.required_door))
 
+                req_door = world.static_logic.objects.doors[painting.required_door]
+                if req_door.HasField("control_center_color"):
+                    control_center_colors = control_center_colors & CONTROL_CENTER_COLOR_NAMES.get(
+                        req_door.control_center_color, ControlCenterColor.NONE)
+
         if connection.HasField("panel"):
             proxy = connection.panel
             reqs.merge(world.player_logic.get_panel_reqs(proxy.panel,
@@ -132,14 +150,14 @@ def create_regions(world: "Lingo2World"):
         reqs.simplify()
         reqs.remove_room(from_region)
 
-        connection = Entrance(world.player, connection_name, regions[from_region])
-        connection.access_rule = make_location_lambda(reqs, world, regions)
+        entrance = Lingo2Entrance(world.player, connection_name, regions[from_region])
+        entrance.set_lingo2_rule(world, regions, reqs, control_center_colors)
 
-        regions[from_region].exits.append(connection)
-        connection.connect(regions[to_region])
+        regions[from_region].exits.append(entrance)
+        entrance.connect(regions[to_region])
 
         for region in reqs.get_referenced_rooms():
-            world.multiworld.register_indirect_condition(regions[region], connection)
+            world.multiworld.register_indirect_condition(regions[region], entrance)
 
     world.multiworld.regions += regions.values()
 
@@ -160,19 +178,29 @@ def shuffle_entrances(world: "Lingo2World"):
         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 = Lingo2Entrance(world.player, connection_name)
+        entrance.connect(port_region)
         entrance.randomization_type = BaseClasses.EntranceType.TWO_WAY
 
-        er_exit = port_region.create_exit(connection_name)
+        er_exit = Lingo2Entrance(world.player, connection_name, port_region)
+        port_region.exits.append(er_exit)
         er_exit.randomization_type = BaseClasses.EntranceType.TWO_WAY
 
+        door_reqs = AccessRequirements()
+        control_center_colors = ControlCenterColor.ALL
         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)
+            req_door = world.static_logic.objects.doors[port.required_door]
+            if req_door.HasField("control_center_color"):
+                control_center_colors = CONTROL_CENTER_COLOR_NAMES.get(req_door.control_center_color,
+                                                                       ControlCenterColor.NONE)
+
+        er_exit.set_lingo2_rule(world, None, door_reqs, control_center_colors)
+
+        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)
@@ -195,21 +223,26 @@ def connect_ports_from_ut(port_pairings: dict[int, int], world: "Lingo2World"):
         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)
+        connection = Lingo2Entrance(world.player, f"{from_region_name} - {from_port.display_name}", from_region)
 
         reqs = AccessRequirements()
+        control_center_colors = ControlCenterColor.ALL
         if from_port.HasField("required_door"):
             reqs = world.player_logic.get_door_open_reqs(from_port.required_door).copy()
 
+            req_door = world.static_logic.objects.doors[from_port.required_door]
+            if req_door.HasField("control_center_color"):
+                control_center_colors = CONTROL_CENTER_COLOR_NAMES.get(req_door.control_center_color,
+                                                                       ControlCenterColor.NONE)
+
         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)
+        connection.set_lingo2_rule(world, None, reqs, control_center_colors)
 
-            for region in reqs.get_referenced_rooms():
-                world.multiworld.register_indirect_condition(world.multiworld.get_region(region, world.player),
-                                                             connection)
+        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)