Core: Plando Items "rewrite"

BaseClasses.py

@@ -426,7 +426,7 @@ def get_entrance(self, entrance_name: str, player: int) -> Entrance:
     def get_location(self, location_name: str, player: int) -> Location:
         return self.regions.location_cache[player][location_name]
 
-    def get_all_state(self, use_cache: bool) -> CollectionState:
+    def get_all_state(self, use_cache: bool, collect_pre_fill_items: bool = True) -> CollectionState:
         cached = getattr(self, "_all_state", None)
         if use_cache and cached:
             return cached.copy()
@@ -435,10 +435,11 @@ def get_all_state(self, use_cache: bool) -> CollectionState:
 
         for item in self.itempool:
             self.worlds[item.player].collect(ret, item)
-        for player in self.player_ids:
-            subworld = self.worlds[player]
-            for item in subworld.get_pre_fill_items():
-                subworld.collect(ret, item)
+        if collect_pre_fill_items:
+            for player in self.player_ids:
+                subworld = self.worlds[player]
+                for item in subworld.get_pre_fill_items():
+                    subworld.collect(ret, item)
         ret.sweep_for_advancements()
 
         if use_cache:

Generate.py

@@ -490,8 +490,6 @@ def roll_settings(weights: dict, plando_options: PlandoOptions = PlandoOptions.b
         if option_key in {"triggers", *valid_keys}:
             continue
         logging.warning(f"{option_key} is not a valid option name for {ret.game} and is not present in triggers.")
-    if PlandoOptions.items in plando_options:
-        ret.plando_items = copy.deepcopy(game_weights.get("plando_items", []))
     if ret.game == "A Link to the Past":
         roll_alttp_settings(ret, game_weights)
 

Options.py

@@ -1409,6 +1409,98 @@ def verify(self, world: typing.Type[World], player_name: str, plando_options: "P
             link["item_pool"] = list(pool)
 
 
+class PlandoItem(typing.NamedTuple):
+    items: typing.Union[typing.List[str], typing.Dict[str, typing.Any]]
+    locations: typing.Optional[typing.List[str]]
+    world: typing.Union[int, str, bool, None, typing.Iterable[str], typing.Set[int]] = False
+    from_pool: bool = True
+    force: typing.Union[bool, typing.Literal["silent"]] = "silent"
+    count: typing.Union[int, bool, typing.Dict[str, int]] = False
+    percentage: int = 100
+
+
+class PlandoItems(Option[typing.List[PlandoItem]]):
+    """Generic items plando."""
+    default = ()
+    supports_weighting = False
+    display_name = "Plando Items"
+
+    def __init__(self, value: typing.Iterable[PlandoItem]) -> None:
+        self.value = list(deepcopy(value))
+        super().__init__()
+
+    @classmethod
+    def from_any(cls, data: typing.Any) -> Option[typing.List[PlandoItem]]:
+        if not isinstance(data, typing.Iterable):
+            raise Exception(f"Cannot create plando items from non-Iterable type, got {type(data)}")
+
+        value: typing.List[PlandoItem] = []
+        for item in data:
+            if isinstance(item, typing.Mapping):
+                percentage = item.get("percentage", 100)
+                if random.random() < float(percentage / 100):
+                    count = item.get("count", False)
+                    items = item.get("items", [])
+                    if not items:
+                        items = item.get("item", None)  # explcitly throw an error here if not present
+                        if not items:
+                            raise Exception("You must specify at least one item to place items with plando.")
+                        items = [items]
+                    locations = item.get("locations", [])
+                    if not locations:
+                        locations = item.get("location", None)
+                        if locations:
+                            locations = [locations]
+                    world = item.get("world", False)
+                    from_pool = item.get("from_pool", True)
+                    force = item.get("force", "silent")
+                    value.append(PlandoItem(items, locations, world, from_pool, force, count, percentage))
+            elif isinstance(item, PlandoItem):
+                if random.random() < float(item.percentage / 100):
+                    value.append(item)
+            else:
+                raise Exception(f"Cannot create plando item from non-Dict type, got {type(item)}.")
+        return cls(value)
+
+    def verify(self, world: typing.Type[World], player_name: str, plando_options: "PlandoOptions") -> None:
+        if not self.value:
+            return
+        from BaseClasses import PlandoOptions
+        if not (PlandoOptions.items & plando_options):
+            # plando is disabled but plando options were given so overwrite the options
+            self.value = []
+            logging.warning(f"The plando items module is turned off, "
+                            f"so items for {player_name} will be ignored.")
+        else:
+            # filter down item groups
+            for plando in self.value:
+                items_copy = plando.items.copy()
+                if isinstance(plando.items, dict):
+                    for item in items_copy:
+                        if item in world.item_name_groups:
+                            value = plando.items.pop(item)
+                            plando.items.update({key: value for key in world.item_name_groups[item]})
+                else:
+                    assert isinstance(plando.items, list)  # pycharm can't figure out the hinting without the hint
+                    for item in items_copy:
+                        if item in world.item_name_groups:
+                            plando.items.remove(item)
+                            plando.items.extend(sorted(world.item_name_groups[item]))
+
+    @classmethod
+    def get_option_name(cls, value: typing.List[PlandoItem]) -> str:
+        return ", ".join(["%s-%s" % (item.items, item.locations) for item in value])  #TODO: see what a better way to display would be
+
+    def __getitem__(self, index: typing.SupportsIndex) -> PlandoItem:
+        return self.value.__getitem__(index)
+
+    def __iter__(self) -> typing.Iterator[PlandoItem]:
+        yield from self.value
+
+    def __len__(self) -> int:
+        return len(self.value)
+
+
 class Removed(FreeText):
     """This Option has been Removed."""
     rich_text_doc = True
@@ -1431,6 +1523,7 @@ class PerGameCommonOptions(CommonOptions):
     exclude_locations: ExcludeLocations
     priority_locations: PriorityLocations
     item_links: ItemLinks
+    plando_items: PlandoItems
 
 
 @dataclass

test/general/test_implemented.py

@@ -1,7 +1,8 @@
 import unittest
 
-from Fill import distribute_items_restrictive
+from Fill import distribute_items_restrictive, distribute_planned
 from NetUtils import encode
+from Options import PlandoItem
 from worlds.AutoWorld import AutoWorldRegister, call_all
 from worlds import failed_world_loads
 from . import setup_solo_multiworld
@@ -52,3 +53,19 @@ def test_slot_data(self):
     def test_no_failed_world_loads(self):
         if failed_world_loads:
             self.fail(f"The following worlds failed to load: {failed_world_loads}")
+
+    def test_prefill_items(self):
+        """Test that every world can reach every location from allstate before pre_fill."""
+        for gamename, world_type in AutoWorldRegister.world_types.items():
+            if gamename not in ("Archipelago", "Sudoku", "Final Fantasy", "Test Game"):
+                with self.subTest(gamename):
+                    multiworld = setup_solo_multiworld(world_type, ("generate_early", "create_regions", "create_items",
+                                                                    "set_rules", "generate_basic"))
+                    allstate = multiworld.get_all_state(False)
+                    locations = multiworld.get_locations()
+                    reachable = multiworld.get_reachable_locations(allstate)
+                    unreachable = [location for location in locations if location not in reachable]
+
+                    self.assertTrue(not unreachable,
+                                    f"Locations were not reachable with all state before prefill: "
+                                    f"{unreachable}")

worlds/alttp/__init__.py

@@ -497,29 +497,29 @@ def collect_item(self, state: CollectionState, item: Item, remove=False):
     def pre_fill(self):
         from Fill import fill_restrictive, FillError
         attempts = 5
-        world = self.multiworld
-        player = self.player
-        all_state = world.get_all_state(use_cache=True)
+        all_state = self.multiworld.get_all_state(use_cache=True).copy()
         crystals = [self.create_item(name) for name in ['Red Pendant', 'Blue Pendant', 'Green Pendant', 'Crystal 1', 'Crystal 2', 'Crystal 3', 'Crystal 4', 'Crystal 7', 'Crystal 5', 'Crystal 6']]
-        crystal_locations = [world.get_location('Turtle Rock - Prize', player),
-                             world.get_location('Eastern Palace - Prize', player),
-                             world.get_location('Desert Palace - Prize', player),
-                             world.get_location('Tower of Hera - Prize', player),
-                             world.get_location('Palace of Darkness - Prize', player),
-                             world.get_location('Thieves\' Town - Prize', player),
-                             world.get_location('Skull Woods - Prize', player),
-                             world.get_location('Swamp Palace - Prize', player),
-                             world.get_location('Ice Palace - Prize', player),
-                             world.get_location('Misery Mire - Prize', player)]
+        for crystal in crystals:
+            all_state.remove(crystal)
+        crystal_locations = [self.multiworld.get_location('Turtle Rock - Prize', self.player),
+                             self.multiworld.get_location('Eastern Palace - Prize', self.player),
+                             self.multiworld.get_location('Desert Palace - Prize', self.player),
+                             self.multiworld.get_location('Tower of Hera - Prize', self.player),
+                             self.multiworld.get_location('Palace of Darkness - Prize', self.player),
+                             self.multiworld.get_location('Thieves\' Town - Prize', self.player),
+                             self.multiworld.get_location('Skull Woods - Prize', self.player),
+                             self.multiworld.get_location('Swamp Palace - Prize', self.player),
+                             self.multiworld.get_location('Ice Palace - Prize', self.player),
+                             self.multiworld.get_location('Misery Mire - Prize', self.player)]
         placed_prizes = {loc.item.name for loc in crystal_locations if loc.item}
         unplaced_prizes = [crystal for crystal in crystals if crystal.name not in placed_prizes]
         empty_crystal_locations = [loc for loc in crystal_locations if not loc.item]
         for attempt in range(attempts):
             try:
                 prizepool = unplaced_prizes.copy()
                 prize_locs = empty_crystal_locations.copy()
-                world.random.shuffle(prize_locs)
-                fill_restrictive(world, all_state, prize_locs, prizepool, True, lock=True,
+                self.multiworld.random.shuffle(prize_locs)
+                fill_restrictive(self.multiworld, all_state, prize_locs, prizepool, True, lock=True,
                                  name="LttP Dungeon Prizes")
             except FillError as e:
                 lttp_logger.exception("Failed to place dungeon prizes (%s). Will retry %s more times", e,
@@ -530,10 +530,10 @@ def pre_fill(self):
             break
         else:
             raise FillError('Unable to place dungeon prizes')
-        if world.mode[player] == 'standard' and world.small_key_shuffle[player] \
-                and world.small_key_shuffle[player] != small_key_shuffle.option_universal and \
-                world.small_key_shuffle[player] != small_key_shuffle.option_own_dungeons:
-            world.local_early_items[player]["Small Key (Hyrule Castle)"] = 1
+        if self.multiworld.mode[self.player] == 'standard' and self.multiworld.small_key_shuffle[self.player] \
+                and self.multiworld.small_key_shuffle[self.player] != small_key_shuffle.option_universal and \
+                self.multiworld.small_key_shuffle[self.player] != small_key_shuffle.option_own_dungeons:
+            self.multiworld.local_early_items[self.player]["Small Key (Hyrule Castle)"] = 1
 
     @classmethod
     def stage_pre_fill(cls, world):
@@ -805,12 +805,15 @@ def get_filler_item_name(self) -> str:
         return GetBeemizerItem(self.multiworld, self.player, item)
 
     def get_pre_fill_items(self):
-        res = []
+        res = [self.create_item(name) for name in ('Red Pendant', 'Blue Pendant', 'Green Pendant', 'Crystal 1',
+                                                   'Crystal 2', 'Crystal 3', 'Crystal 4', 'Crystal 7', 'Crystal 5',
+                                                   'Crystal 6')]
         if self.dungeon_local_item_names:
             for dungeon in self.dungeons.values():
                 for item in dungeon.all_items:
                     if item.name in self.dungeon_local_item_names:
                         res.append(item)
+
         return res
 
     def fill_slot_data(self):

worlds/blasphemous/__init__.py

@@ -212,7 +212,7 @@ def create_items(self):
 
         if self.options.thorn_shuffle == "local_only":
             self.options.local_items.value.add("Thorn Upgrade")
-        
+
 
     def place_items_from_set(self, location_set: Set[str], name: str):
         for loc in location_set:

worlds/hylics2/__init__.py

@@ -127,6 +127,10 @@ def pre_fill(self):
                 tv = tvs.pop()
                 self.get_location(tv).place_locked_item(self.create_item(gesture))
 
+    def get_pre_fill_items(self) -> List["Item"]:
+        if self.options.gesture_shuffle:
+            return [self.create_item(gesture["name"]) for gesture in Items.gesture_item_table.values()]
+        return []
 
     def fill_slot_data(self) -> Dict[str, Any]:
         slot_data: Dict[str, Any] = {

worlds/kh2/__init__.py

@@ -420,10 +420,14 @@ def keyblade_pre_fill(self):
         Fills keyblade slots with abilities determined on player's setting
         """
         keyblade_locations = [self.multiworld.get_location(location, self.player) for location in Keyblade_Slots.keys()]
-        state = self.multiworld.get_all_state(False)
+        state = self.multiworld.get_all_state(False, False)
         keyblade_ability_pool_copy = self.keyblade_ability_pool.copy()
         fill_restrictive(self.multiworld, state, keyblade_locations, keyblade_ability_pool_copy, True, True, allow_excluded=True)
 
+    def get_pre_fill_items(self) -> List["Item"]:
+        return [self.create_item(item) for item in [*DonaldAbility_Table.keys(), *GoofyAbility_Table.keys(),
+                                                    *SupportAbility_Table.keys()]]
+
     def starting_invo_verify(self):
         """
         Making sure the player doesn't put too many abilities in their starting inventory.

worlds/ladx/test/testShop.py

@@ -1,6 +1,7 @@
 from typing import Optional
 
 from Fill import distribute_planned
+from Options import PlandoItems
 from test.general import setup_solo_multiworld
 from worlds.AutoWorld import call_all
 from . import LADXTestBase
@@ -19,13 +20,13 @@ class PlandoTest(LADXTestBase):
             ],
         }],
     }
-    
+
     def world_setup(self, seed: Optional[int] = None) -> None:
         self.multiworld = setup_solo_multiworld(
             LinksAwakeningWorld,
             ("generate_early", "create_regions", "create_items", "set_rules", "generate_basic")
         )
-        self.multiworld.plando_items[1] = self.options["plando_items"]
+        self.multiworld.worlds[1].options.plando_items = PlandoItems.from_any(self.options["plando_items"])
         distribute_planned(self.multiworld)
         call_all(self.multiworld, "pre_fill")
 

worlds/oot/__init__.py

@@ -32,7 +32,7 @@
 
 from settings import get_settings
 from BaseClasses import MultiWorld, CollectionState, Tutorial, LocationProgressType
-from Options import Range, Toggle, VerifyKeys, Accessibility, PlandoConnections
+from Options import Range, Toggle, VerifyKeys, Accessibility, PlandoConnections, PlandoItems
 from Fill import fill_restrictive, fast_fill, FillError
 from worlds.generic.Rules import exclusion_rules, add_item_rule
 from worlds.AutoWorld import World, AutoLogicRegister, WebWorld
@@ -214,6 +214,8 @@ def generate_early(self):
                 option_value = result.value
             elif isinstance(result, PlandoConnections):
                 option_value = result.value
+            elif isinstance(result, PlandoItems):
+                option_value = result.value
             else:
                 option_value = result.current_key
             setattr(self, option_name, option_value)

worlds/pokemon_emerald/__init__.py

@@ -489,7 +489,7 @@ def pre_fill(self) -> None:
                     if location.progress_type == LocationProgressType.EXCLUDED \
                     else location.progress_type
 
-            collection_state = self.multiworld.get_all_state(False)
+            collection_state = self.multiworld.get_all_state(False, False)
 
             # If HM shuffle is on, HMs are not placed and not in the pool, so
             # `get_all_state` did not contain them. Collect them manually for
@@ -548,7 +548,7 @@ def pre_fill(self) -> None:
                     if location.progress_type == LocationProgressType.EXCLUDED \
                     else location.progress_type
 
-            collection_state = self.multiworld.get_all_state(False)
+            collection_state = self.multiworld.get_all_state(False, False)
 
             # In specific very constrained conditions, fill_restrictive may run
             # out of swaps before it finds a valid solution if it gets unlucky.
@@ -568,6 +568,16 @@ def pre_fill(self) -> None:
                     logging.debug(f"Failed to shuffle HMs for player {self.player}. Retrying.")
                     continue
 
+    def get_pre_fill_items(self) -> List[PokemonEmeraldItem]:
+        pool = []
+        if self.options.badges == RandomizeBadges.option_shuffle:
+            pool.extend(badge for _, badge in self.badge_shuffle_info)
+
+        if self.options.hms == RandomizeHms.option_shuffle:
+            pool.extend(hm for _, hm in self.hm_shuffle_info)
+
+        return pool
+
     def generate_output(self, output_directory: str) -> None:
         self.modified_trainers = copy.deepcopy(emerald_data.trainers)
         self.modified_tmhm_moves = copy.deepcopy(emerald_data.tmhm_moves)

worlds/pokemon_rb/__init__.py

@@ -404,7 +404,7 @@ def pre_fill(self) -> None:
 
         # Delete evolution events for Pokémon that are not in logic in an all_state so that accessibility check does not
         # fail. Re-use test_state from previous final loop.
-        all_state = self.multiworld.get_all_state(False)
+        all_state = self.multiworld.get_all_state(False, False)
         evolutions_region = self.multiworld.get_region("Evolution", self.player)
         for location in evolutions_region.locations.copy():
             if not all_state.can_reach(location, player=self.player):
@@ -460,7 +460,7 @@ def pre_fill(self) -> None:
 
         self.local_locs = locs
 
-        all_state = self.multiworld.get_all_state(False)
+        all_state = self.multiworld.get_all_state(False, False)
 
         reachable_mons = set()
         for mon in poke_data.pokemon_data:
@@ -520,6 +520,12 @@ def pre_fill(self) -> None:
                     else:
                         raise Exception("Failed to remove corresponding item while deleting unreachable Dexsanity location")
 
+    def get_pre_fill_items(self) -> typing.List["Item"]:
+        pool = [self.create_item(mon) for mon in poke_data.pokemon_data]
+        return pool
+
+
+
     @classmethod
     def stage_post_fill(cls, multiworld):
         # Convert all but one of each instance of a wild Pokemon to useful classification.