1 files changed, 148 insertions, 7 deletions

@@ -1,18 +1,40 @@
 """
 Archipelago init file for Lingo 2
 """
-from BaseClasses import ItemClassification, Item
+from typing import ClassVar
+
+from BaseClasses import ItemClassification, Item, Tutorial
+from Options import OptionError
+from settings import Group, UserFilePath
 from worlds.AutoWorld import WebWorld, World
-from .items import Lingo2Item
+from .items import Lingo2Item, ANTI_COLLECTABLE_TRAPS, ALL_LETTERS_UPPER
 from .options import Lingo2Options
 from .player_logic import Lingo2PlayerLogic
-from .regions import create_regions
+from .regions import create_regions, shuffle_entrances, connect_ports_from_ut
 from .static_logic import Lingo2StaticLogic
+from worlds.LauncherComponents import Component, Type, components, launch as launch_component, icon_paths
 
 
 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 Lingo2Settings(Group):
+    class ExecutableFile(UserFilePath):
+        """Path to the Lingo 2 executable"""
+        is_exe = True
+
+    exe_file: ExecutableFile = ExecutableFile()
+    start_game: bool = True
 
 
 class Lingo2World(World):
@@ -24,6 +46,9 @@ class Lingo2World(World):
     game = "Lingo 2"
     web = Lingo2WebWorld()
 
+    settings: ClassVar[Lingo2Settings]
+    settings_key = "lingo2_options"
+
     topology_present = True
 
     options_dataclass = Lingo2Options
@@ -32,18 +57,45 @@ 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
+
+    for_tracker: ClassVar[bool] = False
 
     player_logic: Lingo2PlayerLogic
 
+    port_pairings: dict[int, int]
+
     def generate_early(self):
         self.player_logic = Lingo2PlayerLogic(self)
+        self.port_pairings = {}
+
+        if self.options.restrict_letter_placements:
+            self.options.local_items.value |= set(ALL_LETTERS_UPPER)
 
     def create_regions(self):
+        if hasattr(self.multiworld, "re_gen_passthrough") and "Lingo 2" in self.multiworld.re_gen_passthrough:
+            self.player_logic.rte_mapping = [self.world.static_logic.map_id_by_name[map_name]
+                                             for map_name in self.multiworld.re_gen_passthrough["Lingo 2"]["rte"]]
+
         create_regions(self)
 
-        from Utils import visualize_regions
+    def connect_entrances(self):
+        if self.options.shuffle_worldports:
+            if hasattr(self.multiworld, "re_gen_passthrough") and "Lingo 2" in self.multiworld.re_gen_passthrough:
+                slot_value = self.multiworld.re_gen_passthrough["Lingo 2"]["port_pairings"]
+                self.port_pairings = {
+                    self.static_logic.port_id_by_ap_id[int(fp)]: self.static_logic.port_id_by_ap_id[int(tp)]
+                    for fp, tp in slot_value.items()
+                }
+
+                connect_ports_from_ut(self.port_pairings, self)
+            else:
+                shuffle_entrances(self)
 
-        visualize_regions(self.multiworld.get_region("Menu", self.player), "my_world.puml")
+        #from Utils import visualize_regions
+
+        #visualize_regions(self.multiworld.get_region("Menu", self.player), "my_world.puml")
 
     def create_items(self):
         pool = [self.create_item(name) for name in self.player_logic.real_items]
@@ -51,14 +103,103 @@ class Lingo2World(World):
         total_locations = sum(len(locs) for locs in self.player_logic.locations_by_room.values())
 
         item_difference = total_locations - len(pool)
+
+        if self.options.trap_percentage > 0:
+            num_traps = int(item_difference * self.options.trap_percentage / 100)
+            item_difference = item_difference - num_traps
+
+            trap_names = []
+            trap_weights = []
+            for letter_name, weight in self.static_logic.letter_weights.items():
+                trap_names.append(f"Anti {letter_name}")
+                trap_weights.append(weight)
+
+            bad_letters = self.random.choices(trap_names, weights=trap_weights, k=num_traps)
+            pool += [self.create_item(trap_name) for trap_name in bad_letters]
+
         for i in range(0, item_difference):
-            pool.append(self.create_item("Nothing"))
+            pool.append(self.create_item(self.get_filler_item_name()))
+
+        if not any(ItemClassification.progression in item.classification for item in pool):
+            raise OptionError(f"Lingo 2 player {self.player} has no progression items. Please enable at least one "
+                              f"option that would add progression gating to your world, such as Shuffle Doors or "
+                              f"Shuffle Letters.")
 
         self.multiworld.itempool += pool
 
+        for name in self.player_logic.starting_items:
+            self.push_precollected(self.create_item(name))
+
     def create_item(self, name: str) -> Item:
-        return Lingo2Item(name, ItemClassification.filler if name == "Nothing" else ItemClassification.progression,
+        item = Lingo2Item(name, ItemClassification.filler if name == self.get_filler_item_name() else
+                                ItemClassification.trap if name in ANTI_COLLECTABLE_TRAPS else
+                                ItemClassification.progression,
                           self.item_name_to_id.get(name), self.player)
 
+        item.is_letter = (name in ALL_LETTERS_UPPER)
+        return item
+
     def set_rules(self):
         self.multiworld.completion_condition[self.player] = lambda state: state.has("Victory", self.player)
+
+    def fill_slot_data(self):
+        slot_options = [
+            "cyan_door_behavior",
+            "daedalus_only",
+            "daedalus_roof_access",
+            "enable_gift_maps",
+            "enable_icarus",
+            "endings_requirement",
+            "fast_travel_access",
+            "keyholder_sanity",
+            "masteries_requirement",
+            "shuffle_control_center_colors",
+            "shuffle_doors",
+            "shuffle_gallery_paintings",
+            "shuffle_letters",
+            "shuffle_music",
+            "shuffle_symbols",
+            "shuffle_worldports",
+            "strict_cyan_ending",
+            "strict_purple_ending",
+            "victory_condition",
+        ]
+
+        slot_data: dict[str, object] = {
+            **self.options.as_dict(*slot_options),
+            "custom_mint_ending": self.player_logic.custom_mint_ending or "",
+            "rte": [self.static_logic.objects.maps[map_id].name for map_id in self.player_logic.rte_mapping],
+            "seed": self.random.randint(0, 1000000),
+            "version": self.static_logic.get_data_version(),
+        }
+
+        if self.options.shuffle_worldports:
+            def get_port_ap_id(port_id):
+                return self.static_logic.objects.ports[port_id].ap_id
+
+            slot_data["port_pairings"] = {get_port_ap_id(from_id): get_port_ap_id(to_id)
+                                          for from_id, to_id in self.port_pairings.items()}
+
+        return slot_data
+
+    def get_filler_item_name(self) -> str:
+        return "A Job Well Done"
+
+    # for the universal tracker, doesn't get called in standard gen
+    # docs: https://github.com/FarisTheAncient/Archipelago/blob/tracker/worlds/tracker/docs/re-gen-passthrough.md
+    @staticmethod
+    def interpret_slot_data(slot_data: dict[str, object]) -> dict[str, object]:
+        # returning slot_data so it regens, giving it back in multiworld.re_gen_passthrough
+        # we are using re_gen_passthrough over modifying the world here due to complexities with ER
+        return slot_data
+
+
+def launch_client(*args):
+    from .context import client_main
+    launch_component(client_main, name="Lingo2Client", args=args)
+
+
+icon_paths["lingo2_ico"] = f"ap:{__name__}/logo.png"
+component = Component("Lingo 2 Client", component_type=Type.CLIENT, func=launch_client,
+                      description="Open Lingo 2.", supports_uri=True, game_name="Lingo 2", icon="lingo2_ico")
+components.append(component)