1 files changed, 47 insertions, 6 deletions

@@ -62,6 +62,9 @@ def create_regions(world: "Lingo2World"):
     # 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))
@@ -97,7 +100,7 @@ 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
@@ -132,6 +135,12 @@ def create_regions(world: "Lingo2World"):
         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)
 
@@ -150,14 +159,46 @@ def shuffle_entrances(world: "Lingo2World"):
 
     port_id_by_name: dict[str, int] = {}
 
-    for port in world.static_logic.objects.ports:
-        if port.no_shuffle:
-            continue
+    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.name}"
+        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)
@@ -195,7 +236,7 @@ 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.name}", from_region)
+        connection = Entrance(world.player, f"{from_region_name} - {from_port.display_name}", from_region)
 
         reqs = AccessRequirements()
         if from_port.HasField("required_door"):