Stardew Valley 6.x.x: The Content Update (#3478)

Focus of the Update: Compatibility with Stardew Valley 1.6 Released on March 19th 2024
This includes randomization for pretty much all of the new content, including but not limited to
- Raccoon Bundles
- Booksanity
- Skill Masteries
- New Recipes, Craftables, Fish, Maps, Farm Type, Festivals and Quests

This also includes a significant reorganisation of the code into "Content Packs", to allow for easier modularity of various game mechanics between the settings and the supported mods. This improves maintainability quite a bit.

In addition to that, a few **very** requested new features have been introduced, although they weren't the focus of this update
- Walnutsanity
- Player Buffs
- More customizability in settings, such as shorter special orders, ER without farmhouse
- New Remixed Bundles
This commit is contained in:
agilbert1412
2024-07-07 16:04:25 +03:00
committed by GitHub
parent f99ee77325
commit 9b22458f44
210 changed files with 10298 additions and 4540 deletions

View File

@@ -1,12 +1,13 @@
from unittest import TestCase
import typing
import unittest
from unittest import TestCase, SkipTest
from . import setup_solo_multiworld, allsanity_options_with_mods
from .assertion import RuleAssertMixin
from BaseClasses import MultiWorld
from . import RuleAssertMixin, setup_solo_multiworld, allsanity_mods_6_x_x, minimal_locations_maximal_items
from .. import StardewValleyWorld
from ..data.bundle_data import all_bundle_items_except_money
multi_world = setup_solo_multiworld(allsanity_options_with_mods(), _cache={})
world = multi_world.worlds[1]
logic = world.logic
from ..logic.logic import StardewLogic
from ..options import BundleRandomization
def collect_all(mw):
@@ -14,77 +15,91 @@ def collect_all(mw):
mw.state.collect(item, event=True)
collect_all(multi_world)
class LogicTestBase(RuleAssertMixin, TestCase):
options: typing.Dict[str, typing.Any] = {}
multiworld: MultiWorld
logic: StardewLogic
world: StardewValleyWorld
@classmethod
def setUpClass(cls) -> None:
if cls is LogicTestBase:
raise SkipTest("Not running test on base class.")
def setUp(self) -> None:
self.multiworld = setup_solo_multiworld(self.options, _cache={})
collect_all(self.multiworld)
self.world = typing.cast(StardewValleyWorld, self.multiworld.worlds[1])
self.logic = self.world.logic
class TestLogic(RuleAssertMixin, TestCase):
def test_given_bundle_item_then_is_available_in_logic(self):
for bundle_item in all_bundle_items_except_money:
if not bundle_item.can_appear(self.world.content, self.world.options):
continue
with self.subTest(msg=bundle_item.item_name):
self.assertIn(bundle_item.item_name, logic.registry.item_rules)
self.assertIn(bundle_item.get_item(), self.logic.registry.item_rules)
def test_given_item_rule_then_can_be_resolved(self):
for item in logic.registry.item_rules.keys():
for item in self.logic.registry.item_rules.keys():
with self.subTest(msg=item):
rule = logic.registry.item_rules[item]
self.assert_rule_can_be_resolved(rule, multi_world.state)
rule = self.logic.registry.item_rules[item]
self.assert_rule_can_be_resolved(rule, self.multiworld.state)
def test_given_building_rule_then_can_be_resolved(self):
for building in logic.registry.building_rules.keys():
for building in self.logic.registry.building_rules.keys():
with self.subTest(msg=building):
rule = logic.registry.building_rules[building]
self.assert_rule_can_be_resolved(rule, multi_world.state)
rule = self.logic.registry.building_rules[building]
self.assert_rule_can_be_resolved(rule, self.multiworld.state)
def test_given_quest_rule_then_can_be_resolved(self):
for quest in logic.registry.quest_rules.keys():
for quest in self.logic.registry.quest_rules.keys():
with self.subTest(msg=quest):
rule = logic.registry.quest_rules[quest]
self.assert_rule_can_be_resolved(rule, multi_world.state)
rule = self.logic.registry.quest_rules[quest]
self.assert_rule_can_be_resolved(rule, self.multiworld.state)
def test_given_special_order_rule_then_can_be_resolved(self):
for special_order in logic.registry.special_order_rules.keys():
for special_order in self.logic.registry.special_order_rules.keys():
with self.subTest(msg=special_order):
rule = logic.registry.special_order_rules[special_order]
self.assert_rule_can_be_resolved(rule, multi_world.state)
def test_given_tree_fruit_rule_then_can_be_resolved(self):
for tree_fruit in logic.registry.tree_fruit_rules.keys():
with self.subTest(msg=tree_fruit):
rule = logic.registry.tree_fruit_rules[tree_fruit]
self.assert_rule_can_be_resolved(rule, multi_world.state)
def test_given_seed_rule_then_can_be_resolved(self):
for seed in logic.registry.seed_rules.keys():
with self.subTest(msg=seed):
rule = logic.registry.seed_rules[seed]
self.assert_rule_can_be_resolved(rule, multi_world.state)
rule = self.logic.registry.special_order_rules[special_order]
self.assert_rule_can_be_resolved(rule, self.multiworld.state)
def test_given_crop_rule_then_can_be_resolved(self):
for crop in logic.registry.crop_rules.keys():
for crop in self.logic.registry.crop_rules.keys():
with self.subTest(msg=crop):
rule = logic.registry.crop_rules[crop]
self.assert_rule_can_be_resolved(rule, multi_world.state)
rule = self.logic.registry.crop_rules[crop]
self.assert_rule_can_be_resolved(rule, self.multiworld.state)
def test_given_fish_rule_then_can_be_resolved(self):
for fish in logic.registry.fish_rules.keys():
for fish in self.logic.registry.fish_rules.keys():
with self.subTest(msg=fish):
rule = logic.registry.fish_rules[fish]
self.assert_rule_can_be_resolved(rule, multi_world.state)
rule = self.logic.registry.fish_rules[fish]
self.assert_rule_can_be_resolved(rule, self.multiworld.state)
def test_given_museum_rule_then_can_be_resolved(self):
for donation in logic.registry.museum_rules.keys():
for donation in self.logic.registry.museum_rules.keys():
with self.subTest(msg=donation):
rule = logic.registry.museum_rules[donation]
self.assert_rule_can_be_resolved(rule, multi_world.state)
rule = self.logic.registry.museum_rules[donation]
self.assert_rule_can_be_resolved(rule, self.multiworld.state)
def test_given_cooking_rule_then_can_be_resolved(self):
for cooking_rule in logic.registry.cooking_rules.keys():
for cooking_rule in self.logic.registry.cooking_rules.keys():
with self.subTest(msg=cooking_rule):
rule = logic.registry.cooking_rules[cooking_rule]
self.assert_rule_can_be_resolved(rule, multi_world.state)
rule = self.logic.registry.cooking_rules[cooking_rule]
self.assert_rule_can_be_resolved(rule, self.multiworld.state)
def test_given_location_rule_then_can_be_resolved(self):
for location in multi_world.get_locations(1):
for location in self.multiworld.get_locations(1):
with self.subTest(msg=location.name):
rule = location.access_rule
self.assert_rule_can_be_resolved(rule, multi_world.state)
self.assert_rule_can_be_resolved(rule, self.multiworld.state)
class TestAllSanityLogic(LogicTestBase):
options = allsanity_mods_6_x_x()
@unittest.skip("This test does not pass because some content is still not in content packs.")
class TestMinLocationsMaxItemsLogic(LogicTestBase):
options = minimal_locations_maximal_items()
options[BundleRandomization.internal_name] = BundleRandomization.default