Clique: Update to new options API (#3759)

worlds/clique/Items.py

@@ -1,6 +1,9 @@
-from typing import Callable, Dict, NamedTuple, Optional
+from typing import Callable, Dict, NamedTuple, Optional, TYPE_CHECKING
 
-from BaseClasses import Item, ItemClassification, MultiWorld
+from BaseClasses import Item, ItemClassification
+
+if TYPE_CHECKING:
+    from . import CliqueWorld
 
 
 class CliqueItem(Item):
@@ -10,7 +13,7 @@ class CliqueItem(Item):
 class CliqueItemData(NamedTuple):
     code: Optional[int] = None
     type: ItemClassification = ItemClassification.filler
-    can_create: Callable[[MultiWorld, int], bool] = lambda multiworld, player: True
+    can_create: Callable[["CliqueWorld"], bool] = lambda world: True
 
 
 item_data_table: Dict[str, CliqueItemData] = {
@@ -21,11 +24,11 @@ item_data_table: Dict[str, CliqueItemData] = {
     "Button Activation": CliqueItemData(
         code=69696968,
         type=ItemClassification.progression,
-        can_create=lambda multiworld, player: bool(getattr(multiworld, "hard_mode")[player]),
+        can_create=lambda world: world.options.hard_mode,
     ),
     "A Cool Filler Item (No Satisfaction Guaranteed)": CliqueItemData(
         code=69696967,
-        can_create=lambda multiworld, player: False  # Only created from `get_filler_item_name`.
+        can_create=lambda world: False  # Only created from `get_filler_item_name`.
     ),
     "The Urge to Push": CliqueItemData(
         type=ItemClassification.progression,

worlds/clique/Locations.py

@@ -1,6 +1,9 @@
-from typing import Callable, Dict, NamedTuple, Optional
+from typing import Callable, Dict, NamedTuple, Optional, TYPE_CHECKING
 
-from BaseClasses import Location, MultiWorld
+from BaseClasses import Location
+
+if TYPE_CHECKING:
+    from . import CliqueWorld
 
 
 class CliqueLocation(Location):
@@ -10,7 +13,7 @@ class CliqueLocation(Location):
 class CliqueLocationData(NamedTuple):
     region: str
     address: Optional[int] = None
-    can_create: Callable[[MultiWorld, int], bool] = lambda multiworld, player: True
+    can_create: Callable[["CliqueWorld"], bool] = lambda world: True
     locked_item: Optional[str] = None
 
 
@@ -22,7 +25,7 @@ location_data_table: Dict[str, CliqueLocationData] = {
     "The Item on the Desk": CliqueLocationData(
         region="The Button Realm",
         address=69696968,
-        can_create=lambda multiworld, player: bool(getattr(multiworld, "hard_mode")[player]),
+        can_create=lambda world: world.options.hard_mode,
     ),
     "In the Player's Mind": CliqueLocationData(
         region="The Button Realm",

worlds/clique/Options.py

@@ -1,6 +1,5 @@
-from typing import Dict
-
-from Options import Choice, Option, Toggle
+from dataclasses import dataclass
+from Options import Choice, Toggle, PerGameCommonOptions, StartInventoryPool
 
 
 class HardMode(Toggle):
@@ -25,10 +24,11 @@ class ButtonColor(Choice):
     option_black = 11
 
 
-clique_options: Dict[str, type(Option)] = {
-    "color": ButtonColor,
-    "hard_mode": HardMode,
+@dataclass
+class CliqueOptions(PerGameCommonOptions):
+    color: ButtonColor
+    hard_mode: HardMode
+    start_inventory_from_pool: StartInventoryPool
 
     # DeathLink is always on. Always.
-    # "death_link": DeathLink,
-}
+    # death_link: DeathLink

worlds/clique/Rules.py

@@ -1,10 +1,13 @@
-from typing import Callable
+from typing import Callable, TYPE_CHECKING
 
-from BaseClasses import CollectionState, MultiWorld
+from BaseClasses import CollectionState
+
+if TYPE_CHECKING:
+    from . import CliqueWorld
 
 
-def get_button_rule(multiworld: MultiWorld, player: int) -> Callable[[CollectionState], bool]:
-    if getattr(multiworld, "hard_mode")[player]:
-        return lambda state: state.has("Button Activation", player)
+def get_button_rule(world: "CliqueWorld") -> Callable[[CollectionState], bool]:
+    if world.options.hard_mode:
+        return lambda state: state.has("Button Activation", world.player)
 
     return lambda state: True

worlds/clique/__init__.py

@@ -1,10 +1,10 @@
-from typing import List
+from typing import List, Dict, Any
 
 from BaseClasses import Region, Tutorial
 from worlds.AutoWorld import WebWorld, World
 from .Items import CliqueItem, item_data_table, item_table
 from .Locations import CliqueLocation, location_data_table, location_table, locked_locations
-from .Options import clique_options
+from .Options import CliqueOptions
 from .Regions import region_data_table
 from .Rules import get_button_rule
 
@@ -38,7 +38,8 @@ class CliqueWorld(World):
 
     game = "Clique"
     web = CliqueWebWorld()
-    option_definitions = clique_options
+    options: CliqueOptions
+    options_dataclass = CliqueOptions
     location_name_to_id = location_table
     item_name_to_id = item_table
 
@@ -48,7 +49,7 @@ class CliqueWorld(World):
     def create_items(self) -> None:
         item_pool: List[CliqueItem] = []
         for name, item in item_data_table.items():
-            if item.code and item.can_create(self.multiworld, self.player):
+            if item.code and item.can_create(self):
                 item_pool.append(self.create_item(name))
 
         self.multiworld.itempool += item_pool
@@ -61,41 +62,40 @@ class CliqueWorld(World):
 
         # Create locations.
         for region_name, region_data in region_data_table.items():
-            region = self.multiworld.get_region(region_name, self.player)
+            region = self.get_region(region_name)
             region.add_locations({
                 location_name: location_data.address for location_name, location_data in location_data_table.items()
-                if location_data.region == region_name and location_data.can_create(self.multiworld, self.player)
+                if location_data.region == region_name and location_data.can_create(self)
             }, CliqueLocation)
             region.add_exits(region_data_table[region_name].connecting_regions)
 
         # Place locked locations.
         for location_name, location_data in locked_locations.items():
             # Ignore locations we never created.
-            if not location_data.can_create(self.multiworld, self.player):
+            if not location_data.can_create(self):
                 continue
 
             locked_item = self.create_item(location_data_table[location_name].locked_item)
-            self.multiworld.get_location(location_name, self.player).place_locked_item(locked_item)
+            self.get_location(location_name).place_locked_item(locked_item)
 
         # Set priority location for the Big Red Button!
-        self.multiworld.priority_locations[self.player].value.add("The Big Red Button")
+        self.options.priority_locations.value.add("The Big Red Button")
 
     def get_filler_item_name(self) -> str:
         return "A Cool Filler Item (No Satisfaction Guaranteed)"
 
     def set_rules(self) -> None:
-        button_rule = get_button_rule(self.multiworld, self.player)
-        self.multiworld.get_location("The Big Red Button", self.player).access_rule = button_rule
-        self.multiworld.get_location("In the Player's Mind", self.player).access_rule = button_rule
+        button_rule = get_button_rule(self)
+        self.get_location("The Big Red Button").access_rule = button_rule
+        self.get_location("In the Player's Mind").access_rule = button_rule
 
         # Do not allow button activations on buttons.
-        self.multiworld.get_location("The Big Red Button", self.player).item_rule =\
-            lambda item: item.name != "Button Activation"
+        self.get_location("The Big Red Button").item_rule = lambda item: item.name != "Button Activation"
 
         # Completion condition.
         self.multiworld.completion_condition[self.player] = lambda state: state.has("The Urge to Push", self.player)
 
-    def fill_slot_data(self):
+    def fill_slot_data(self) -> Dict[str, Any]:
         return {
-            "color": getattr(self.multiworld, "color")[self.player].current_key
+            "color": self.options.color.current_key
         }