1 files changed, 94 insertions, 11 deletions

@@ -1,10 +1,11 @@
 from typing import Dict, Optional, TYPE_CHECKING
 
 from BaseClasses import Entrance, ItemClassification, Region
-from .datatypes import Room, RoomAndDoor
+from .datatypes import EntranceType, Room, RoomAndDoor
 from .items import LingoItem
 from .locations import LingoLocation
-from .rules import lingo_can_use_entrance, make_location_lambda
+from .options import SunwarpAccess
+from .rules import lingo_can_do_pilgrimage, lingo_can_use_entrance, make_location_lambda
 from .static_logic import ALL_ROOMS, PAINTINGS
 
 if TYPE_CHECKING:
@@ -25,8 +26,20 @@ def create_region(room: Room, world: "LingoWorld") -> Region:
     return new_region
 
 
+def is_acceptable_pilgrimage_entrance(entrance_type: EntranceType, world: "LingoWorld") -> bool:
+    allowed_entrance_types = EntranceType.NORMAL
+
+    if world.options.pilgrimage_allows_paintings:
+        allowed_entrance_types |= EntranceType.PAINTING
+
+    if world.options.pilgrimage_allows_roof_access:
+        allowed_entrance_types |= EntranceType.CROSSROADS_ROOF_ACCESS
+
+    return bool(entrance_type & allowed_entrance_types)
+
+
 def connect_entrance(regions: Dict[str, Region], source_region: Region, target_region: Region, description: str,
-                     door: Optional[RoomAndDoor], world: "LingoWorld"):
+                     door: Optional[RoomAndDoor], entrance_type: EntranceType, pilgrimage: bool, world: "LingoWorld"):
     connection = Entrance(world.player, description, source_region)
     connection.access_rule = lambda state: lingo_can_use_entrance(state, target_region.name, door, world)
 
@@ -38,6 +51,21 @@ def connect_entrance(regions: Dict[str, Region], source_region: Region, target_r
         if door.door not in world.player_logic.item_by_door.get(effective_room, {}):
             for region in world.player_logic.calculate_door_requirements(effective_room, door.door, world).rooms:
                 world.multiworld.register_indirect_condition(regions[region], connection)
+    
+    if not pilgrimage and world.options.enable_pilgrimage and is_acceptable_pilgrimage_entrance(entrance_type, world)\
+            and source_region.name != "Menu":
+        for part in range(1, 6):
+            pilgrimage_descriptor = f" (Pilgrimage Part {part})"
+            pilgrim_source_region = regions[f"{source_region.name}{pilgrimage_descriptor}"]
+            pilgrim_target_region = regions[f"{target_region.name}{pilgrimage_descriptor}"]
+
+            effective_door = door
+            if effective_door is not None:
+                effective_room = target_region.name if door.room is None else door.room
+                effective_door = RoomAndDoor(effective_room, door.door)
+
+            connect_entrance(regions, pilgrim_source_region, pilgrim_target_region,
+                             f"{description}{pilgrimage_descriptor}", effective_door, entrance_type, True, world)
 
 
 def connect_painting(regions: Dict[str, Region], warp_enter: str, warp_exit: str, world: "LingoWorld") -> None:
@@ -48,7 +76,8 @@ def connect_painting(regions: Dict[str, Region], warp_enter: str, warp_exit: str
     source_region = regions[source_painting.room]
 
     entrance_name = f"{source_painting.room} to {target_painting.room} ({source_painting.id} Painting)"
-    connect_entrance(regions, source_region, target_region, entrance_name, source_painting.required_door, world)
+    connect_entrance(regions, source_region, target_region, entrance_name, source_painting.required_door,
+                     EntranceType.PAINTING, False, world)
 
 
 def create_regions(world: "LingoWorld") -> None:
@@ -63,11 +92,26 @@ def create_regions(world: "LingoWorld") -> None:
     for room in ALL_ROOMS:
         regions[room.name] = create_region(room, world)
 
+        if world.options.enable_pilgrimage:
+            for part in range(1, 6):
+                pilgrimage_region_name = f"{room.name} (Pilgrimage Part {part})"
+                regions[pilgrimage_region_name] = Region(pilgrimage_region_name, world.player, world.multiworld)
+
     # Connect all created regions now that they exist.
+    allowed_entrance_types = EntranceType.NORMAL | EntranceType.WARP | EntranceType.CROSSROADS_ROOF_ACCESS
+
+    if not painting_shuffle:
+        # Don't use the vanilla painting connections if we are shuffling paintings.
+        allowed_entrance_types |= EntranceType.PAINTING
+
+    if world.options.sunwarp_access != SunwarpAccess.option_disabled and not world.options.shuffle_sunwarps:
+        # Don't connect sunwarps if sunwarps are disabled or if we're shuffling sunwarps.
+        allowed_entrance_types |= EntranceType.SUNWARP
+
     for room in ALL_ROOMS:
         for entrance in room.entrances:
-            # Don't use the vanilla painting connections if we are shuffling paintings.
-            if entrance.painting and painting_shuffle:
+            effective_entrance_type = entrance.type & allowed_entrance_types
+            if not effective_entrance_type:
                 continue
 
             entrance_name = f"{entrance.room} to {room.name}"
@@ -77,17 +121,56 @@ def create_regions(world: "LingoWorld") -> None:
                 else:
                     entrance_name += f" (through {room.name} - {entrance.door.door})"
 
-            connect_entrance(regions, regions[entrance.room], regions[room.name], entrance_name, entrance.door, world)
+            effective_door = entrance.door
+            if entrance.type == EntranceType.SUNWARP and world.options.sunwarp_access == SunwarpAccess.option_normal:
+                effective_door = None
+
+            connect_entrance(regions, regions[entrance.room], regions[room.name], entrance_name, effective_door,
+                             effective_entrance_type, False, world)
+
+    if world.options.enable_pilgrimage:
+        # Connect the start of the pilgrimage. We check for all sunwarp items here.
+        pilgrim_start_from = regions[world.player_logic.sunwarp_entrances[0]]
+        pilgrim_start_to = regions[f"{world.player_logic.sunwarp_exits[0]} (Pilgrimage Part 1)"]
+
+        if world.options.sunwarp_access >= SunwarpAccess.option_unlock:
+            pilgrim_start_from.connect(pilgrim_start_to, f"Pilgrimage Part 1",
+                                       lambda state: lingo_can_do_pilgrimage(state, world))
+        else:
+            pilgrim_start_from.connect(pilgrim_start_to, f"Pilgrimage Part 1")
 
-    # Add the fake pilgrimage.
-    connect_entrance(regions, regions["Outside The Agreeable"], regions["Pilgrim Antechamber"], "Pilgrimage",
-                     RoomAndDoor("Pilgrim Antechamber", "Pilgrimage"), world)
+        # Create connections between each segment of the pilgrimage.
+        for i in range(1, 6):
+            from_room = f"{world.player_logic.sunwarp_entrances[i]} (Pilgrimage Part {i})"
+            to_room = f"{world.player_logic.sunwarp_exits[i]} (Pilgrimage Part {i+1})"
+            if i == 5:
+                to_room = "Pilgrim Antechamber"
+
+            regions[from_room].connect(regions[to_room], f"Pilgrimage Part {i+1}")
+    else:
+        connect_entrance(regions, regions["Starting Room"], regions["Pilgrim Antechamber"], "Sun Painting",
+                         RoomAndDoor("Pilgrim Antechamber", "Sun Painting"), EntranceType.PAINTING, False, world)
 
     if early_color_hallways:
-        regions["Starting Room"].connect(regions["Outside The Undeterred"], "Early Color Hallways")
+        connect_entrance(regions, regions["Starting Room"], regions["Outside The Undeterred"], "Early Color Hallways",
+                         None, EntranceType.PAINTING, False, world)
 
     if painting_shuffle:
         for warp_enter, warp_exit in world.player_logic.painting_mapping.items():
             connect_painting(regions, warp_enter, warp_exit, world)
 
+    if world.options.shuffle_sunwarps:
+        for i in range(0, 6):
+            if world.options.sunwarp_access == SunwarpAccess.option_normal:
+                effective_door = None
+            else:
+                effective_door = RoomAndDoor("Sunwarps", f"{i + 1} Sunwarp")
+
+            source_region = regions[world.player_logic.sunwarp_entrances[i]]
+            target_region = regions[world.player_logic.sunwarp_exits[i]]
+
+            entrance_name = f"{source_region.name} to {target_region.name} ({i + 1} Sunwarp)"
+            connect_entrance(regions, source_region, target_region, entrance_name, effective_door, EntranceType.SUNWARP,
+                             False, world)
+
     world.multiworld.regions += regions.values()