From eba757d2cd468182f4d0500ab87c45d379b225d2 Mon Sep 17 00:00:00 2001 From: NewSoupVi <57900059+NewSoupVi@users.noreply.github.com> Date: Sat, 24 May 2025 23:02:27 +0200 Subject: [PATCH] Raft: Implement get_filler_item_name and refactor filler item code a bit (#4782) * refactor filler item creation for Raft, implement get_filler_item_name * wrong indent * Update worlds/raft/__init__.py Co-authored-by: Exempt-Medic <60412657+Exempt-Medic@users.noreply.github.com> --------- Co-authored-by: Exempt-Medic <60412657+Exempt-Medic@users.noreply.github.com> --- worlds/raft/__init__.py | 110 +++++++++++++++++++++++----------------- 1 file changed, 64 insertions(+), 46 deletions(-) diff --git a/worlds/raft/__init__.py b/worlds/raft/__init__.py index 3e33b417..74ab9291 100644 --- a/worlds/raft/__init__.py +++ b/worlds/raft/__init__.py @@ -40,6 +40,8 @@ class RaftWorld(World): options_dataclass = RaftOptions options: RaftOptions + extraItemNamePool: list[str] | None = None + required_client_version = (0, 3, 4) def create_items(self): @@ -52,52 +54,52 @@ class RaftWorld(World): pool = [] frequencyItems = [] for item in item_table: - raft_item = self.create_item_replaceAsNecessary(item["name"]) + raft_item = self.create_item(self.replace_item_name_as_necessary(item["name"])) if isFillingFrequencies and "Frequency" in item["name"]: frequencyItems.append(raft_item) else: pool.append(raft_item) - extraItemNamePool = [] + self.extraItemNamePool = [] extras = len(location_table) - len(item_table) - 1 # Victory takes up 1 unaccounted-for slot - if extras > 0: - if (self.options.filler_item_types != self.options.filler_item_types.option_duplicates): # Use resource packs - for packItem in resourcePackItems: - for i in range(minimumResourcePackAmount, maximumResourcePackAmount + 1): - extraItemNamePool.append(createResourcePackName(i, packItem)) - if self.options.filler_item_types != self.options.filler_item_types.option_resource_packs: # Use duplicate items - dupeItemPool = item_table.copy() - # Remove frequencies if necessary - if self.options.island_frequency_locations != self.options.island_frequency_locations.option_anywhere: # Not completely random locations - # If we let frequencies stay in with progressive-frequencies, the progressive-frequency item - # will be included 7 times. This is a massive flood of progressive-frequency items, so we - # instead add progressive-frequency as its own item a smaller amount of times to prevent - # flooding the duplicate item pool with them. - if self.options.island_frequency_locations == self.options.island_frequency_locations.option_progressive: - for _ in range(2): - # Progressives are not in item_pool, need to create faux item for duplicate item pool - # This can still be filtered out later by duplicate_items setting - dupeItemPool.append({ "name": "progressive-frequency", "progression": True }) # Progressive frequencies need to be included - # Always remove non-progressive Frequency items - dupeItemPool = (itm for itm in dupeItemPool if "Frequency" not in itm["name"]) - - # Remove progression or non-progression items if necessary - if (self.options.duplicate_items == self.options.duplicate_items.option_progression): # Progression only - dupeItemPool = (itm for itm in dupeItemPool if itm["progression"] == True) - elif (self.options.duplicate_items == self.options.duplicate_items.option_non_progression): # Non-progression only - dupeItemPool = (itm for itm in dupeItemPool if itm["progression"] == False) - - dupeItemPool = list(dupeItemPool) - # Finally, add items as necessary - if len(dupeItemPool) > 0: - for item in dupeItemPool: - extraItemNamePool.append(item["name"]) + if (self.options.filler_item_types != self.options.filler_item_types.option_duplicates): # Use resource packs + for packItem in resourcePackItems: + for i in range(minimumResourcePackAmount, maximumResourcePackAmount + 1): + self.extraItemNamePool.append(createResourcePackName(i, packItem)) + + if self.options.filler_item_types != self.options.filler_item_types.option_resource_packs: # Use duplicate items + dupeItemPool = item_table.copy() + # Remove frequencies if necessary + if self.options.island_frequency_locations != self.options.island_frequency_locations.option_anywhere: # Not completely random locations + # If we let frequencies stay in with progressive-frequencies, the progressive-frequency item + # will be included 7 times. This is a massive flood of progressive-frequency items, so we + # instead add progressive-frequency as its own item a smaller amount of times to prevent + # flooding the duplicate item pool with them. + if self.options.island_frequency_locations == self.options.island_frequency_locations.option_progressive: + for _ in range(2): + # Progressives are not in item_pool, need to create faux item for duplicate item pool + # This can still be filtered out later by duplicate_items setting + dupeItemPool.append({ "name": "progressive-frequency", "progression": True }) # Progressive frequencies need to be included + # Always remove non-progressive Frequency items + dupeItemPool = (itm for itm in dupeItemPool if "Frequency" not in itm["name"]) + + # Remove progression or non-progression items if necessary + if (self.options.duplicate_items == self.options.duplicate_items.option_progression): # Progression only + dupeItemPool = (itm for itm in dupeItemPool if itm["progression"] == True) + elif (self.options.duplicate_items == self.options.duplicate_items.option_non_progression): # Non-progression only + dupeItemPool = (itm for itm in dupeItemPool if itm["progression"] == False) + + dupeItemPool = list(dupeItemPool) + # Finally, add items as necessary + for item in dupeItemPool: + self.extraItemNamePool.append(self.replace_item_name_as_necessary(item)) - if (len(extraItemNamePool) > 0): - for randomItem in self.random.choices(extraItemNamePool, k=extras): - raft_item = self.create_item_replaceAsNecessary(randomItem) - pool.append(raft_item) + assert self.extraItemNamePool, f"Don't know what extra items to create for {self.player_name}." + + for randomItem in self.random.choices(self.extraItemNamePool, k=extras): + raft_item = self.create_item(randomItem) + pool.append(raft_item) self.multiworld.itempool += pool @@ -108,19 +110,35 @@ class RaftWorld(World): if frequencyItems: self.place_frequencyItems(frequencyItems) + def get_filler_item_name(self) -> str: + # A normal Raft world will have an extraItemNamePool defined after create_items. + if self.extraItemNamePool: + return self.random.choice(self.extraItemNamePool) + + # If this is a "fake" world, e.g. item links with link replacement: Resource packs are always be safe to create + minRPSpecified = self.options.minimum_resource_pack_amount.value + maxRPSpecified = self.options.maximum_resource_pack_amount.value + minimumResourcePackAmount = min(minRPSpecified, maxRPSpecified) + maximumResourcePackAmount = max(minRPSpecified, maxRPSpecified) + resource_amount = self.random.randint(minimumResourcePackAmount, maximumResourcePackAmount) + resource_type = self.random.choice(resourcePackItems) + return createResourcePackName(resource_amount, resource_type) + def set_rules(self): set_rules(self.multiworld, self.player) def create_regions(self): create_regions(self.multiworld, self.player) - - def create_item_replaceAsNecessary(self, name: str) -> Item: - isFrequency = "Frequency" in name - shouldUseProgressive = bool((isFrequency and self.options.island_frequency_locations == self.options.island_frequency_locations.option_progressive) - or (not isFrequency and self.options.progressive_items)) - if shouldUseProgressive and name in progressive_table: - name = progressive_table[name] - return self.create_item(name) + + def replace_item_name_as_necessary(self, name: str) -> str: + if name not in progressive_table: + return name + if "Frequency" in name: + if self.options.island_frequency_locations == self.options.island_frequency_locations.option_progressive: + return progressive_table[name] + elif self.options.progressive_items: + return progressive_table[name] + return name def create_item(self, name: str) -> Item: item = lookup_name_to_item[name]