Stardew Valley: 5.x.x - The Allsanity Update (#2764)

Major Content update for Stardew Valley, including the following features

- Major performance improvements all across the Stardew Valley apworld, including a significant reduction in the test time
- Randomized Farm Type
- Bundles rework (Remixed Bundles and Missing Bundle!)
- New Settings:
  * Shipsanity - Shipping individual items
  * Monstersanity - Slaying monsters
  * Cooksanity - Cooking individual recipes
  * Chefsanity - Learning individual recipes
  * Craftsanity - Crafting individual items
- New Goals:
  * Protector of the Valley - Complete every monster slayer goal
  * Full Shipment - Ship every item
  * Craftmaster - Craft every item
  * Gourmet Chef - Cook every recipe
  * Legend - Earn 10 000 000g
  * Mystery of the Stardrops - Find every stardrop (Maguffin Hunt)
  * Allsanity - Complete every check in your slot
- Building Shuffle: Cheaper options
- Tool Shuffle: Cheaper options
- Money rework
- New traps
- New isolated checks and items, including the farm cave, the movie theater, etc
- Mod Support: SVE [Albrekka]
- Mod Support: Distant Lands [Albrekka]
- Mod Support: Hat Mouse Lacey [Albrekka]
- Mod Support: Boarding House [Albrekka]

Co-authored-by: Witchybun <elnendil@gmail.com>
Co-authored-by: Witchybun <96719127+Witchybun@users.noreply.github.com>
Co-authored-by: Jouramie <jouramie@hotmail.com>
Co-authored-by: Alchav <59858495+Alchav@users.noreply.github.com>

worlds/stardew_valley/stardew_rule/state.py

@@ -0,0 +1,140 @@
+from dataclasses import dataclass
+from typing import Iterable, Union, List, Tuple, Hashable
+
+from BaseClasses import ItemClassification, CollectionState
+from .base import BaseStardewRule, CombinableStardewRule
+from .protocol import StardewRule
+from ..items import item_table
+
+
+class TotalReceived(BaseStardewRule):
+    count: int
+    items: Iterable[str]
+    player: int
+
+    def __init__(self, count: int, items: Union[str, Iterable[str]], player: int):
+        items_list: List[str]
+
+        if isinstance(items, Iterable):
+            items_list = [*items]
+        else:
+            items_list = [items]
+
+        assert items_list, "Can't create a Total Received conditions without items"
+        for item in items_list:
+            assert item_table[item].classification & ItemClassification.progression, \
+                f"Item [{item_table[item].name}] has to be progression to be used in logic"
+
+        self.player = player
+        self.items = items_list
+        self.count = count
+
+    def __call__(self, state: CollectionState) -> bool:
+        c = 0
+        for item in self.items:
+            c += state.count(item, self.player)
+            if c >= self.count:
+                return True
+        return False
+
+    def evaluate_while_simplifying(self, state: CollectionState) -> Tuple[StardewRule, bool]:
+        return self, self(state)
+
+    def get_difficulty(self):
+        return self.count
+
+    def __repr__(self):
+        return f"Received {self.count} {self.items}"
+
+
+@dataclass(frozen=True)
+class Received(CombinableStardewRule):
+    item: str
+    player: int
+    count: int
+
+    def __post_init__(self):
+        assert item_table[self.item].classification & ItemClassification.progression, \
+            f"Item [{item_table[self.item].name}] has to be progression to be used in logic"
+
+    @property
+    def combination_key(self) -> Hashable:
+        return self.item
+
+    @property
+    def value(self):
+        return self.count
+
+    def __call__(self, state: CollectionState) -> bool:
+        return state.has(self.item, self.player, self.count)
+
+    def evaluate_while_simplifying(self, state: CollectionState) -> Tuple[StardewRule, bool]:
+        return self, self(state)
+
+    def __repr__(self):
+        if self.count == 1:
+            return f"Received {self.item}"
+        return f"Received {self.count} {self.item}"
+
+    def get_difficulty(self):
+        return self.count
+
+
+@dataclass(frozen=True)
+class Reach(BaseStardewRule):
+    spot: str
+    resolution_hint: str
+    player: int
+
+    def __call__(self, state: CollectionState) -> bool:
+        if self.resolution_hint == 'Region' and self.spot not in state.multiworld.regions.region_cache[self.player]:
+            return False
+        return state.can_reach(self.spot, self.resolution_hint, self.player)
+
+    def evaluate_while_simplifying(self, state: CollectionState) -> Tuple[StardewRule, bool]:
+        return self, self(state)
+
+    def __repr__(self):
+        return f"Reach {self.resolution_hint} {self.spot}"
+
+    def get_difficulty(self):
+        return 1
+
+
+@dataclass(frozen=True)
+class HasProgressionPercent(CombinableStardewRule):
+    player: int
+    percent: int
+
+    def __post_init__(self):
+        assert self.percent > 0, "HasProgressionPercent rule must be above 0%"
+        assert self.percent <= 100, "HasProgressionPercent rule can't require more than 100% of items"
+
+    @property
+    def combination_key(self) -> Hashable:
+        return HasProgressionPercent.__name__
+
+    @property
+    def value(self):
+        return self.percent
+
+    def __call__(self, state: CollectionState) -> bool:
+        stardew_world = state.multiworld.worlds[self.player]
+        total_count = stardew_world.total_progression_items
+        needed_count = (total_count * self.percent) // 100
+        total_count = 0
+        for item in state.prog_items[self.player]:
+            item_count = state.prog_items[self.player][item]
+            total_count += item_count
+            if total_count >= needed_count:
+                return True
+        return False
+
+    def evaluate_while_simplifying(self, state: CollectionState) -> Tuple[StardewRule, bool]:
+        return self, self(state)
+
+    def __repr__(self):
+        return f"HasProgressionPercent {self.percent}"
+
+    def get_difficulty(self):
+        return self.percent