monorail
/
Archipelago
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Core: recontextualize `CollectionState.collect` (#3723) 

* Core: renamed `CollectionState.collect` arg from `event` to `prevent_sweep` and remove forced collection

* Update TestDungeon.py

---------

Co-authored-by: NewSoupVi <57900059+NewSoupVi@users.noreply.github.com>
This commit is contained in:
Aaron Wagener 2024-08-13 15:28:05 -05:00 committed by GitHub
parent dcaa2f7b97
commit 96d48a923a
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
19 changed files with 146 additions and 150 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
BaseClasses.py
View File

@ -863,19 +863,15 @@ class CollectionState():
)
# Item related
def collect(self, item: Item, event: bool = False, location: Optional[Location] = None) -> bool:
def collect(self, item: Item, prevent_sweep: bool = False, location: Optional[Location] = None) -> bool:
if location:
self.locations_checked.add(location)
changed = self.multiworld.worlds[item.player].collect(self, item)
if not changed and event:
self.prog_items[item.player][item.name] += 1
changed = True
self.stale[item.player] = True
if changed and not event:
if changed and not prevent_sweep:
self.sweep_for_events()
return changed

2
test/bases.py
View File

@ -23,7 +23,7 @@ class TestBase(unittest.TestCase):
state = CollectionState(self.multiworld)
for item in items:
item.classification = ItemClassification.progression
state.collect(item, event=True)
state.collect(item, prevent_sweep=True)
state.sweep_for_events()
state.update_reachable_regions(1)
self._state_cache[self.multiworld, tuple(items)] = state

4
worlds/alttp/test/dungeons/TestDungeon.py
View File

@ -54,7 +54,7 @@ class TestDungeon(LTTPTestBase):
for item in items:
item.classification = ItemClassification.progression
state.collect(item, event=True) # event=True prevents running sweep_for_events() and picking up
state.collect(item, prevent_sweep=True) # prevent_sweep=True prevents running sweep_for_events() and picking up
state.sweep_for_events() # key drop keys repeatedly
self.assertEqual(self.multiworld.get_location(location, 1).can_reach(state), access, f"failed {self.multiworld.get_location(location, 1)} with: {item_pool}")
self.assertEqual(self.multiworld.get_location(location, 1).can_reach(state), access, f"failed {self.multiworld.get_location(location, 1)} with: {item_pool}")

2
worlds/oot/EntranceShuffle.py
View File

@ -796,7 +796,7 @@ def validate_world(ootworld, entrance_placed, locations_to_ensure_reachable, all
if ootworld.shuffle_interior_entrances or ootworld.shuffle_overworld_entrances or ootworld.spawn_positions:
time_travel_state = none_state.copy()
time_travel_state.collect(ootworld.create_item('Time Travel'), event=True)
time_travel_state.collect(ootworld.create_item('Time Travel'), prevent_sweep=True)
time_travel_state._oot_update_age_reachable_regions(player)
# Unless entrances are decoupled, we don't want the player to end up through certain entrances as the wrong age

2
worlds/oot/__init__.py
View File

@ -1388,7 +1388,7 @@ class OOTWorld(World):
self.multiworld.worlds[item.player].collect(all_state, item)
# If free_scarecrow give Scarecrow Song
if self.free_scarecrow:
all_state.collect(self.create_item("Scarecrow Song"), event=True)
all_state.collect(self.create_item("Scarecrow Song"), prevent_sweep=True)
all_state.stale[self.player] = True
return all_state

8
worlds/stardew_valley/test/TestCrops.py
View File

@ -11,10 +11,10 @@ class TestCropsanityRules(SVTestBase):
harvest_cactus = self.world.logic.region.can_reach_location("Harvest Cactus Fruit")
self.assert_rule_false(harvest_cactus, self.multiworld.state)
self.multiworld.state.collect(self.world.create_item("Cactus Seeds"), event=False)
self.multiworld.state.collect(self.world.create_item("Shipping Bin"), event=False)
self.multiworld.state.collect(self.world.create_item("Desert Obelisk"), event=False)
self.multiworld.state.collect(self.world.create_item("Cactus Seeds"), prevent_sweep=False)
self.multiworld.state.collect(self.world.create_item("Shipping Bin"), prevent_sweep=False)
self.multiworld.state.collect(self.world.create_item("Desert Obelisk"), prevent_sweep=False)
self.assert_rule_false(harvest_cactus, self.multiworld.state)
self.multiworld.state.collect(self.world.create_item("Greenhouse"), event=False)
self.multiworld.state.collect(self.world.create_item("Greenhouse"), prevent_sweep=False)
self.assert_rule_true(harvest_cactus, self.multiworld.state)

34
worlds/stardew_valley/test/TestDynamicGoals.py
View File

@ -12,29 +12,29 @@ from ..strings.wallet_item_names import Wallet
def collect_fishing_abilities(tester: SVTestBase):
for i in range(4):
tester.multiworld.state.collect(tester.world.create_item(APTool.fishing_rod), event=False)
tester.multiworld.state.collect(tester.world.create_item(APTool.pickaxe), event=False)
tester.multiworld.state.collect(tester.world.create_item(APTool.axe), event=False)
tester.multiworld.state.collect(tester.world.create_item(APWeapon.weapon), event=False)
tester.multiworld.state.collect(tester.world.create_item(APTool.fishing_rod), prevent_sweep=False)
tester.multiworld.state.collect(tester.world.create_item(APTool.pickaxe), prevent_sweep=False)
tester.multiworld.state.collect(tester.world.create_item(APTool.axe), prevent_sweep=False)
tester.multiworld.state.collect(tester.world.create_item(APWeapon.weapon), prevent_sweep=False)
for i in range(10):
tester.multiworld.state.collect(tester.world.create_item("Fishing Level"), event=False)
tester.multiworld.state.collect(tester.world.create_item("Combat Level"), event=False)
tester.multiworld.state.collect(tester.world.create_item("Mining Level"), event=False)
tester.multiworld.state.collect(tester.world.create_item("Fishing Level"), prevent_sweep=False)
tester.multiworld.state.collect(tester.world.create_item("Combat Level"), prevent_sweep=False)
tester.multiworld.state.collect(tester.world.create_item("Mining Level"), prevent_sweep=False)
for i in range(17):
tester.multiworld.state.collect(tester.world.create_item("Progressive Mine Elevator"), event=False)
tester.multiworld.state.collect(tester.world.create_item("Spring"), event=False)
tester.multiworld.state.collect(tester.world.create_item("Summer"), event=False)
tester.multiworld.state.collect(tester.world.create_item("Fall"), event=False)
tester.multiworld.state.collect(tester.world.create_item("Winter"), event=False)
tester.multiworld.state.collect(tester.world.create_item(Transportation.desert_obelisk), event=False)
tester.multiworld.state.collect(tester.world.create_item("Railroad Boulder Removed"), event=False)
tester.multiworld.state.collect(tester.world.create_item("Island North Turtle"), event=False)
tester.multiworld.state.collect(tester.world.create_item("Island West Turtle"), event=False)
tester.multiworld.state.collect(tester.world.create_item("Progressive Mine Elevator"), prevent_sweep=False)
tester.multiworld.state.collect(tester.world.create_item("Spring"), prevent_sweep=False)
tester.multiworld.state.collect(tester.world.create_item("Summer"), prevent_sweep=False)
tester.multiworld.state.collect(tester.world.create_item("Fall"), prevent_sweep=False)
tester.multiworld.state.collect(tester.world.create_item("Winter"), prevent_sweep=False)
tester.multiworld.state.collect(tester.world.create_item(Transportation.desert_obelisk), prevent_sweep=False)
tester.multiworld.state.collect(tester.world.create_item("Railroad Boulder Removed"), prevent_sweep=False)
tester.multiworld.state.collect(tester.world.create_item("Island North Turtle"), prevent_sweep=False)
tester.multiworld.state.collect(tester.world.create_item("Island West Turtle"), prevent_sweep=False)
def create_and_collect(tester: SVTestBase, item_name: str) -> StardewItem:
item = tester.world.create_item(item_name)
tester.multiworld.state.collect(item, event=False)
tester.multiworld.state.collect(item, prevent_sweep=False)
return item

2
worlds/stardew_valley/test/TestLogic.py
View File

@ -12,7 +12,7 @@ from ..options import BundleRandomization
def collect_all(mw):
for item in mw.get_items():
mw.state.collect(item, event=True)
mw.state.collect(item, prevent_sweep=True)
class LogicTestBase(RuleAssertMixin, TestCase):

8
worlds/stardew_valley/test/__init__.py
View File

@ -257,16 +257,16 @@ class SVTestBase(RuleAssertMixin, WorldTestBase, SVTestCase):
return super().run_default_tests
def collect_lots_of_money(self):
self.multiworld.state.collect(self.world.create_item("Shipping Bin"), event=False)
self.multiworld.state.collect(self.world.create_item("Shipping Bin"), prevent_sweep=False)
required_prog_items = int(round(self.multiworld.worlds[self.player].total_progression_items * 0.25))
for i in range(required_prog_items):
self.multiworld.state.collect(self.world.create_item("Stardrop"), event=False)
self.multiworld.state.collect(self.world.create_item("Stardrop"), prevent_sweep=False)
def collect_all_the_money(self):
self.multiworld.state.collect(self.world.create_item("Shipping Bin"), event=False)
self.multiworld.state.collect(self.world.create_item("Shipping Bin"), prevent_sweep=False)
required_prog_items = int(round(self.multiworld.worlds[self.player].total_progression_items * 0.95))
for i in range(required_prog_items):
self.multiworld.state.collect(self.world.create_item("Stardrop"), event=False)
self.multiworld.state.collect(self.world.create_item("Stardrop"), prevent_sweep=False)
def collect_everything(self):
non_event_items = [item for item in self.multiworld.get_items() if item.code]

4
worlds/stardew_valley/test/assertion/world_assert.py
View File

@ -33,14 +33,14 @@ class WorldAssertMixin(RuleAssertMixin, TestCase):
self.assert_can_reach_victory(multiworld)
multiworld.state.remove(item)
self.assert_cannot_reach_victory(multiworld)
multiworld.state.collect(item, event=False)
multiworld.state.collect(item, prevent_sweep=False)
self.assert_can_reach_victory(multiworld)
def assert_item_was_not_necessary_for_victory(self, item: StardewItem, multiworld: MultiWorld):
self.assert_can_reach_victory(multiworld)
multiworld.state.remove(item)
self.assert_can_reach_victory(multiworld)
multiworld.state.collect(item, event=False)
multiworld.state.collect(item, prevent_sweep=False)
self.assert_can_reach_victory(multiworld)
def assert_can_win(self, multiworld: MultiWorld):

52
worlds/stardew_valley/test/rules/TestArcades.py
View File

@ -19,8 +19,8 @@ class TestArcadeMachinesLogic(SVTestBase):
life = self.create_item("JotPK: Extra Life")
drop = self.create_item("JotPK: Increased Drop Rate")
self.multiworld.state.collect(boots, event=True)
self.multiworld.state.collect(gun, event=True)
self.multiworld.state.collect(boots, prevent_sweep=True)
self.multiworld.state.collect(gun, prevent_sweep=True)
self.assertTrue(self.world.logic.region.can_reach("JotPK World 1")(self.multiworld.state))
self.assertFalse(self.world.logic.region.can_reach("JotPK World 2")(self.multiworld.state))
self.assertFalse(self.world.logic.region.can_reach("JotPK World 3")(self.multiworld.state))
@ -28,8 +28,8 @@ class TestArcadeMachinesLogic(SVTestBase):
self.remove(boots)
self.remove(gun)
self.multiworld.state.collect(boots, event=True)
self.multiworld.state.collect(boots, event=True)
self.multiworld.state.collect(boots, prevent_sweep=True)
self.multiworld.state.collect(boots, prevent_sweep=True)
self.assertTrue(self.world.logic.region.can_reach("JotPK World 1")(self.multiworld.state))
self.assertFalse(self.world.logic.region.can_reach("JotPK World 2")(self.multiworld.state))
self.assertFalse(self.world.logic.region.can_reach("JotPK World 3")(self.multiworld.state))
@ -37,10 +37,10 @@ class TestArcadeMachinesLogic(SVTestBase):
self.remove(boots)
self.remove(boots)
self.multiworld.state.collect(boots, event=True)
self.multiworld.state.collect(gun, event=True)
self.multiworld.state.collect(ammo, event=True)
self.multiworld.state.collect(life, event=True)
self.multiworld.state.collect(boots, prevent_sweep=True)
self.multiworld.state.collect(gun, prevent_sweep=True)
self.multiworld.state.collect(ammo, prevent_sweep=True)
self.multiworld.state.collect(life, prevent_sweep=True)
self.assertTrue(self.world.logic.region.can_reach("JotPK World 1")(self.multiworld.state))
self.assertTrue(self.world.logic.region.can_reach("JotPK World 2")(self.multiworld.state))
self.assertFalse(self.world.logic.region.can_reach("JotPK World 3")(self.multiworld.state))
@ -50,13 +50,13 @@ class TestArcadeMachinesLogic(SVTestBase):
self.remove(ammo)
self.remove(life)
self.multiworld.state.collect(boots, event=True)
self.multiworld.state.collect(gun, event=True)
self.multiworld.state.collect(gun, event=True)
self.multiworld.state.collect(ammo, event=True)
self.multiworld.state.collect(ammo, event=True)
self.multiworld.state.collect(life, event=True)
self.multiworld.state.collect(drop, event=True)
self.multiworld.state.collect(boots, prevent_sweep=True)
self.multiworld.state.collect(gun, prevent_sweep=True)
self.multiworld.state.collect(gun, prevent_sweep=True)
self.multiworld.state.collect(ammo, prevent_sweep=True)
self.multiworld.state.collect(ammo, prevent_sweep=True)
self.multiworld.state.collect(life, prevent_sweep=True)
self.multiworld.state.collect(drop, prevent_sweep=True)
self.assertTrue(self.world.logic.region.can_reach("JotPK World 1")(self.multiworld.state))
self.assertTrue(self.world.logic.region.can_reach("JotPK World 2")(self.multiworld.state))
self.assertTrue(self.world.logic.region.can_reach("JotPK World 3")(self.multiworld.state))
@ -69,17 +69,17 @@ class TestArcadeMachinesLogic(SVTestBase):
self.remove(life)
self.remove(drop)
self.multiworld.state.collect(boots, event=True)
self.multiworld.state.collect(boots, event=True)
self.multiworld.state.collect(gun, event=True)
self.multiworld.state.collect(gun, event=True)
self.multiworld.state.collect(gun, event=True)
self.multiworld.state.collect(gun, event=True)
self.multiworld.state.collect(ammo, event=True)
self.multiworld.state.collect(ammo, event=True)
self.multiworld.state.collect(ammo, event=True)
self.multiworld.state.collect(life, event=True)
self.multiworld.state.collect(drop, event=True)
self.multiworld.state.collect(boots, prevent_sweep=True)
self.multiworld.state.collect(boots, prevent_sweep=True)
self.multiworld.state.collect(gun, prevent_sweep=True)
self.multiworld.state.collect(gun, prevent_sweep=True)
self.multiworld.state.collect(gun, prevent_sweep=True)
self.multiworld.state.collect(gun, prevent_sweep=True)
self.multiworld.state.collect(ammo, prevent_sweep=True)
self.multiworld.state.collect(ammo, prevent_sweep=True)
self.multiworld.state.collect(ammo, prevent_sweep=True)
self.multiworld.state.collect(life, prevent_sweep=True)
self.multiworld.state.collect(drop, prevent_sweep=True)
self.assertTrue(self.world.logic.region.can_reach("JotPK World 1")(self.multiworld.state))
self.assertTrue(self.world.logic.region.can_reach("JotPK World 2")(self.multiworld.state))
self.assertTrue(self.world.logic.region.can_reach("JotPK World 3")(self.multiworld.state))

14
worlds/stardew_valley/test/rules/TestBuildings.py
View File

@ -23,11 +23,11 @@ class TestBuildingLogic(SVTestBase):
self.assertFalse(big_coop_blueprint_rule(self.multiworld.state),
f"Rule is {repr(self.multiworld.get_location('Big Coop Blueprint', self.player).access_rule)}")
self.multiworld.state.collect(self.create_item("Can Construct Buildings"), event=True)
self.multiworld.state.collect(self.create_item("Can Construct Buildings"), prevent_sweep=True)
self.assertFalse(big_coop_blueprint_rule(self.multiworld.state),
f"Rule is {repr(self.multiworld.get_location('Big Coop Blueprint', self.player).access_rule)}")
self.multiworld.state.collect(self.create_item("Progressive Coop"), event=False)
self.multiworld.state.collect(self.create_item("Progressive Coop"), prevent_sweep=False)
self.assertTrue(big_coop_blueprint_rule(self.multiworld.state),
f"Rule is {repr(self.multiworld.get_location('Big Coop Blueprint', self.player).access_rule)}")
@ -35,13 +35,13 @@ class TestBuildingLogic(SVTestBase):
self.assertFalse(self.world.logic.region.can_reach_location("Deluxe Coop Blueprint")(self.multiworld.state))
self.collect_lots_of_money()
self.multiworld.state.collect(self.create_item("Can Construct Buildings"), event=True)
self.multiworld.state.collect(self.create_item("Can Construct Buildings"), prevent_sweep=True)
self.assertFalse(self.world.logic.region.can_reach_location("Deluxe Coop Blueprint")(self.multiworld.state))
self.multiworld.state.collect(self.create_item("Progressive Coop"), event=True)
self.multiworld.state.collect(self.create_item("Progressive Coop"), prevent_sweep=True)
self.assertFalse(self.world.logic.region.can_reach_location("Deluxe Coop Blueprint")(self.multiworld.state))
self.multiworld.state.collect(self.create_item("Progressive Coop"), event=True)
self.multiworld.state.collect(self.create_item("Progressive Coop"), prevent_sweep=True)
self.assertTrue(self.world.logic.region.can_reach_location("Deluxe Coop Blueprint")(self.multiworld.state))
def test_big_shed_blueprint(self):
@ -53,10 +53,10 @@ class TestBuildingLogic(SVTestBase):
self.assertFalse(big_shed_rule(self.multiworld.state),
f"Rule is {repr(self.multiworld.get_location('Big Shed Blueprint', self.player).access_rule)}")
self.multiworld.state.collect(self.create_item("Can Construct Buildings"), event=True)
self.multiworld.state.collect(self.create_item("Can Construct Buildings"), prevent_sweep=True)
self.assertFalse(big_shed_rule(self.multiworld.state),
f"Rule is {repr(self.multiworld.get_location('Big Shed Blueprint', self.player).access_rule)}")
self.multiworld.state.collect(self.create_item("Progressive Shed"), event=True)
self.multiworld.state.collect(self.create_item("Progressive Shed"), prevent_sweep=True)
self.assertTrue(big_shed_rule(self.multiworld.state),
f"Rule is {repr(self.multiworld.get_location('Big Shed Blueprint', self.player).access_rule)}")

32
worlds/stardew_valley/test/rules/TestCookingRecipes.py
View File

@ -17,14 +17,14 @@ class TestRecipeLearnLogic(SVTestBase):
rule = self.world.logic.region.can_reach_location(location)
self.assert_rule_false(rule, self.multiworld.state)
self.multiworld.state.collect(self.create_item("Progressive House"), event=False)
self.multiworld.state.collect(self.create_item("Radish Seeds"), event=False)
self.multiworld.state.collect(self.create_item("Spring"), event=False)
self.multiworld.state.collect(self.create_item("Summer"), event=False)
self.multiworld.state.collect(self.create_item("Progressive House"), prevent_sweep=False)
self.multiworld.state.collect(self.create_item("Radish Seeds"), prevent_sweep=False)
self.multiworld.state.collect(self.create_item("Spring"), prevent_sweep=False)
self.multiworld.state.collect(self.create_item("Summer"), prevent_sweep=False)
self.collect_lots_of_money()
self.assert_rule_false(rule, self.multiworld.state)
self.multiworld.state.collect(self.create_item("The Queen of Sauce"), event=False)
self.multiworld.state.collect(self.create_item("The Queen of Sauce"), prevent_sweep=False)
self.assert_rule_true(rule, self.multiworld.state)
@ -42,21 +42,21 @@ class TestRecipeReceiveLogic(SVTestBase):
rule = self.world.logic.region.can_reach_location(location)
self.assert_rule_false(rule, self.multiworld.state)
self.multiworld.state.collect(self.create_item("Progressive House"), event=False)
self.multiworld.state.collect(self.create_item("Radish Seeds"), event=False)
self.multiworld.state.collect(self.create_item("Summer"), event=False)
self.multiworld.state.collect(self.create_item("Progressive House"), prevent_sweep=False)
self.multiworld.state.collect(self.create_item("Radish Seeds"), prevent_sweep=False)
self.multiworld.state.collect(self.create_item("Summer"), prevent_sweep=False)
self.collect_lots_of_money()
self.assert_rule_false(rule, self.multiworld.state)
spring = self.create_item("Spring")
qos = self.create_item("The Queen of Sauce")
self.multiworld.state.collect(spring, event=False)
self.multiworld.state.collect(qos, event=False)
self.multiworld.state.collect(spring, prevent_sweep=False)
self.multiworld.state.collect(qos, prevent_sweep=False)
self.assert_rule_false(rule, self.multiworld.state)
self.multiworld.state.remove(spring)
self.multiworld.state.remove(qos)
self.multiworld.state.collect(self.create_item("Radish Salad Recipe"), event=False)
self.multiworld.state.collect(self.create_item("Radish Salad Recipe"), prevent_sweep=False)
self.assert_rule_true(rule, self.multiworld.state)
def test_get_chefsanity_check_recipe(self):
@ -64,20 +64,20 @@ class TestRecipeReceiveLogic(SVTestBase):
rule = self.world.logic.region.can_reach_location(location)
self.assert_rule_false(rule, self.multiworld.state)
self.multiworld.state.collect(self.create_item("Spring"), event=False)
self.multiworld.state.collect(self.create_item("Spring"), prevent_sweep=False)
self.collect_lots_of_money()
self.assert_rule_false(rule, self.multiworld.state)
seeds = self.create_item("Radish Seeds")
summer = self.create_item("Summer")
house = self.create_item("Progressive House")
self.multiworld.state.collect(seeds, event=False)
self.multiworld.state.collect(summer, event=False)
self.multiworld.state.collect(house, event=False)
self.multiworld.state.collect(seeds, prevent_sweep=False)
self.multiworld.state.collect(summer, prevent_sweep=False)
self.multiworld.state.collect(house, prevent_sweep=False)
self.assert_rule_false(rule, self.multiworld.state)
self.multiworld.state.remove(seeds)
self.multiworld.state.remove(summer)
self.multiworld.state.remove(house)
self.multiworld.state.collect(self.create_item("The Queen of Sauce"), event=False)
self.multiworld.state.collect(self.create_item("The Queen of Sauce"), prevent_sweep=False)
self.assert_rule_true(rule, self.multiworld.state)

26
worlds/stardew_valley/test/rules/TestCraftingRecipes.py
View File

@ -25,7 +25,7 @@ class TestCraftsanityLogic(SVTestBase):
self.collect_all_the_money()
self.assert_rule_false(rule, self.multiworld.state)
self.multiworld.state.collect(self.create_item("Marble Brazier Recipe"), event=False)
self.multiworld.state.collect(self.create_item("Marble Brazier Recipe"), prevent_sweep=False)
self.assert_rule_true(rule, self.multiworld.state)
def test_can_learn_crafting_recipe(self):
@ -38,16 +38,16 @@ class TestCraftsanityLogic(SVTestBase):
def test_can_craft_festival_recipe(self):
recipe = all_crafting_recipes_by_name["Jack-O-Lantern"]
self.multiworld.state.collect(self.create_item("Pumpkin Seeds"), event=False)
self.multiworld.state.collect(self.create_item("Torch Recipe"), event=False)
self.multiworld.state.collect(self.create_item("Pumpkin Seeds"), prevent_sweep=False)
self.multiworld.state.collect(self.create_item("Torch Recipe"), prevent_sweep=False)
self.collect_lots_of_money()
rule = self.world.logic.crafting.can_craft(recipe)
self.assert_rule_false(rule, self.multiworld.state)
self.multiworld.state.collect(self.create_item("Fall"), event=False)
self.multiworld.state.collect(self.create_item("Fall"), prevent_sweep=False)
self.assert_rule_false(rule, self.multiworld.state)
self.multiworld.state.collect(self.create_item("Jack-O-Lantern Recipe"), event=False)
self.multiworld.state.collect(self.create_item("Jack-O-Lantern Recipe"), prevent_sweep=False)
self.assert_rule_true(rule, self.multiworld.state)
@ -62,16 +62,16 @@ class TestCraftsanityWithFestivalsLogic(SVTestBase):
def test_can_craft_festival_recipe(self):
recipe = all_crafting_recipes_by_name["Jack-O-Lantern"]
self.multiworld.state.collect(self.create_item("Pumpkin Seeds"), event=False)
self.multiworld.state.collect(self.create_item("Fall"), event=False)
self.multiworld.state.collect(self.create_item("Pumpkin Seeds"), prevent_sweep=False)
self.multiworld.state.collect(self.create_item("Fall"), prevent_sweep=False)
self.collect_lots_of_money()
rule = self.world.logic.crafting.can_craft(recipe)
self.assert_rule_false(rule, self.multiworld.state)
self.multiworld.state.collect(self.create_item("Jack-O-Lantern Recipe"), event=False)
self.multiworld.state.collect(self.create_item("Jack-O-Lantern Recipe"), prevent_sweep=False)
self.assert_rule_false(rule, self.multiworld.state)
self.multiworld.state.collect(self.create_item("Torch Recipe"), event=False)
self.multiworld.state.collect(self.create_item("Torch Recipe"), prevent_sweep=False)
self.assert_rule_true(rule, self.multiworld.state)
@ -92,7 +92,7 @@ class TestNoCraftsanityLogic(SVTestBase):
def test_can_craft_festival_recipe(self):
recipe = all_crafting_recipes_by_name["Jack-O-Lantern"]
self.multiworld.state.collect(self.create_item("Pumpkin Seeds"), event=False)
self.multiworld.state.collect(self.create_item("Pumpkin Seeds"), prevent_sweep=False)
self.collect_lots_of_money()
rule = self.world.logic.crafting.can_craft(recipe)
result = rule(self.multiworld.state)
@ -113,11 +113,11 @@ class TestNoCraftsanityWithFestivalsLogic(SVTestBase):
def test_can_craft_festival_recipe(self):
recipe = all_crafting_recipes_by_name["Jack-O-Lantern"]
self.multiworld.state.collect(self.create_item("Pumpkin Seeds"), event=False)
self.multiworld.state.collect(self.create_item("Fall"), event=False)
self.multiworld.state.collect(self.create_item("Pumpkin Seeds"), prevent_sweep=False)
self.multiworld.state.collect(self.create_item("Fall"), prevent_sweep=False)
self.collect_lots_of_money()
rule = self.world.logic.crafting.can_craft(recipe)
self.assert_rule_false(rule, self.multiworld.state)
self.multiworld.state.collect(self.create_item("Jack-O-Lantern Recipe"), event=False)
self.multiworld.state.collect(self.create_item("Jack-O-Lantern Recipe"), prevent_sweep=False)
self.assert_rule_true(rule, self.multiworld.state)

6
worlds/stardew_valley/test/rules/TestDonations.py
View File

@ -18,7 +18,7 @@ class TestDonationLogicAll(SVTestBase):
for donation in locations_by_tag[LocationTags.MUSEUM_DONATIONS]:
self.assertFalse(self.world.logic.region.can_reach_location(donation.name)(self.multiworld.state))
self.multiworld.state.collect(self.create_item(railroad_item), event=False)
self.multiworld.state.collect(self.create_item(railroad_item), prevent_sweep=False)
for donation in locations_by_tag[LocationTags.MUSEUM_DONATIONS]:
self.assertTrue(self.world.logic.region.can_reach_location(donation.name)(self.multiworld.state))
@ -39,7 +39,7 @@ class TestDonationLogicRandomized(SVTestBase):
for donation in donation_locations:
self.assertFalse(self.world.logic.region.can_reach_location(donation.name)(self.multiworld.state))
self.multiworld.state.collect(self.create_item(railroad_item), event=False)
self.multiworld.state.collect(self.create_item(railroad_item), prevent_sweep=False)
for donation in donation_locations:
self.assertTrue(self.world.logic.region.can_reach_location(donation.name)(self.multiworld.state))
@ -58,7 +58,7 @@ class TestDonationLogicMilestones(SVTestBase):
for donation in locations_by_tag[LocationTags.MUSEUM_MILESTONES]:
self.assertFalse(self.world.logic.region.can_reach_location(donation.name)(self.multiworld.state))
self.multiworld.state.collect(self.create_item(railroad_item), event=False)
self.multiworld.state.collect(self.create_item(railroad_item), prevent_sweep=False)
for donation in locations_by_tag[LocationTags.MUSEUM_MILESTONES]:
self.assertTrue(self.world.logic.region.can_reach_location(donation.name)(self.multiworld.state))

34
worlds/stardew_valley/test/rules/TestFriendship.py
View File

@ -11,34 +11,34 @@ class TestFriendsanityDatingRules(SVTestBase):
def test_earning_dating_heart_requires_dating(self):
self.collect_all_the_money()
self.multiworld.state.collect(self.create_item("Fall"), event=False)
self.multiworld.state.collect(self.create_item("Beach Bridge"), event=False)
self.multiworld.state.collect(self.create_item("Progressive House"), event=False)
self.multiworld.state.collect(self.create_item("Fall"), prevent_sweep=False)
self.multiworld.state.collect(self.create_item("Beach Bridge"), prevent_sweep=False)
self.multiworld.state.collect(self.create_item("Progressive House"), prevent_sweep=False)
for i in range(3):
self.multiworld.state.collect(self.create_item("Progressive Pickaxe"), event=False)
self.multiworld.state.collect(self.create_item("Progressive Weapon"), event=False)
self.multiworld.state.collect(self.create_item("Progressive Axe"), event=False)
self.multiworld.state.collect(self.create_item("Progressive Barn"), event=False)
self.multiworld.state.collect(self.create_item("Progressive Pickaxe"), prevent_sweep=False)
self.multiworld.state.collect(self.create_item("Progressive Weapon"), prevent_sweep=False)
self.multiworld.state.collect(self.create_item("Progressive Axe"), prevent_sweep=False)
self.multiworld.state.collect(self.create_item("Progressive Barn"), prevent_sweep=False)
for i in range(10):
self.multiworld.state.collect(self.create_item("Foraging Level"), event=False)
self.multiworld.state.collect(self.create_item("Farming Level"), event=False)
self.multiworld.state.collect(self.create_item("Mining Level"), event=False)
self.multiworld.state.collect(self.create_item("Combat Level"), event=False)
self.multiworld.state.collect(self.create_item("Progressive Mine Elevator"), event=False)
self.multiworld.state.collect(self.create_item("Progressive Mine Elevator"), event=False)
self.multiworld.state.collect(self.create_item("Foraging Level"), prevent_sweep=False)
self.multiworld.state.collect(self.create_item("Farming Level"), prevent_sweep=False)
self.multiworld.state.collect(self.create_item("Mining Level"), prevent_sweep=False)
self.multiworld.state.collect(self.create_item("Combat Level"), prevent_sweep=False)
self.multiworld.state.collect(self.create_item("Progressive Mine Elevator"), prevent_sweep=False)
self.multiworld.state.collect(self.create_item("Progressive Mine Elevator"), prevent_sweep=False)
npc = "Abigail"
heart_name = f"{npc} <3"
step = 3
self.assert_can_reach_heart_up_to(npc, 3, step)
self.multiworld.state.collect(self.create_item(heart_name), event=False)
self.multiworld.state.collect(self.create_item(heart_name), prevent_sweep=False)
self.assert_can_reach_heart_up_to(npc, 6, step)
self.multiworld.state.collect(self.create_item(heart_name), event=False)
self.multiworld.state.collect(self.create_item(heart_name), prevent_sweep=False)
self.assert_can_reach_heart_up_to(npc, 8, step)
self.multiworld.state.collect(self.create_item(heart_name), event=False)
self.multiworld.state.collect(self.create_item(heart_name), prevent_sweep=False)
self.assert_can_reach_heart_up_to(npc, 10, step)
self.multiworld.state.collect(self.create_item(heart_name), event=False)
self.multiworld.state.collect(self.create_item(heart_name), prevent_sweep=False)
self.assert_can_reach_heart_up_to(npc, 14, step)
def assert_can_reach_heart_up_to(self, npc: str, max_reachable: int, step: int):

2
worlds/stardew_valley/test/rules/TestShipping.py
View File

@ -76,7 +76,7 @@ class TestShipsanityEverything(SVTestBase):
with self.subTest(location.name):
self.remove(bin_item)
self.assertFalse(self.world.logic.region.can_reach_location(location.name)(self.multiworld.state))
self.multiworld.state.collect(bin_item, event=False)
self.multiworld.state.collect(bin_item, prevent_sweep=False)
shipsanity_rule = self.world.logic.region.can_reach_location(location.name)
self.assert_rule_true(shipsanity_rule, self.multiworld.state)
self.remove(bin_item)

40
worlds/stardew_valley/test/rules/TestTools.py
View File

@ -21,30 +21,30 @@ class TestProgressiveToolsLogic(SVTestBase):
self.assert_rule_false(sturgeon_rule, self.multiworld.state)
summer = self.create_item("Summer")
self.multiworld.state.collect(summer, event=False)
self.multiworld.state.collect(summer, prevent_sweep=False)
self.assert_rule_false(sturgeon_rule, self.multiworld.state)
fishing_rod = self.create_item("Progressive Fishing Rod")
self.multiworld.state.collect(fishing_rod, event=False)
self.multiworld.state.collect(fishing_rod, event=False)
self.multiworld.state.collect(fishing_rod, prevent_sweep=False)
self.multiworld.state.collect(fishing_rod, prevent_sweep=False)
self.assert_rule_false(sturgeon_rule, self.multiworld.state)
fishing_level = self.create_item("Fishing Level")
self.multiworld.state.collect(fishing_level, event=False)
self.multiworld.state.collect(fishing_level, prevent_sweep=False)
self.assert_rule_false(sturgeon_rule, self.multiworld.state)
self.multiworld.state.collect(fishing_level, event=False)
self.multiworld.state.collect(fishing_level, event=False)
self.multiworld.state.collect(fishing_level, event=False)
self.multiworld.state.collect(fishing_level, event=False)
self.multiworld.state.collect(fishing_level, event=False)
self.multiworld.state.collect(fishing_level, prevent_sweep=False)
self.multiworld.state.collect(fishing_level, prevent_sweep=False)
self.multiworld.state.collect(fishing_level, prevent_sweep=False)
self.multiworld.state.collect(fishing_level, prevent_sweep=False)
self.multiworld.state.collect(fishing_level, prevent_sweep=False)
self.assert_rule_true(sturgeon_rule, self.multiworld.state)
self.remove(summer)
self.assert_rule_false(sturgeon_rule, self.multiworld.state)
winter = self.create_item("Winter")
self.multiworld.state.collect(winter, event=False)
self.multiworld.state.collect(winter, prevent_sweep=False)
self.assert_rule_true(sturgeon_rule, self.multiworld.state)
self.remove(fishing_rod)
@ -53,24 +53,24 @@ class TestProgressiveToolsLogic(SVTestBase):
def test_old_master_cannoli(self):
self.multiworld.state.prog_items = {1: Counter()}
self.multiworld.state.collect(self.create_item("Progressive Axe"), event=False)
self.multiworld.state.collect(self.create_item("Progressive Axe"), event=False)
self.multiworld.state.collect(self.create_item("Summer"), event=False)
self.multiworld.state.collect(self.create_item("Progressive Axe"), prevent_sweep=False)
self.multiworld.state.collect(self.create_item("Progressive Axe"), prevent_sweep=False)
self.multiworld.state.collect(self.create_item("Summer"), prevent_sweep=False)
self.collect_lots_of_money()
rule = self.world.logic.region.can_reach_location("Old Master Cannoli")
self.assert_rule_false(rule, self.multiworld.state)
fall = self.create_item("Fall")
self.multiworld.state.collect(fall, event=False)
self.multiworld.state.collect(fall, prevent_sweep=False)
self.assert_rule_false(rule, self.multiworld.state)
tuesday = self.create_item("Traveling Merchant: Tuesday")
self.multiworld.state.collect(tuesday, event=False)
self.multiworld.state.collect(tuesday, prevent_sweep=False)
self.assert_rule_false(rule, self.multiworld.state)
rare_seed = self.create_item("Rare Seed")
self.multiworld.state.collect(rare_seed, event=False)
self.multiworld.state.collect(rare_seed, prevent_sweep=False)
self.assert_rule_true(rule, self.multiworld.state)
self.remove(fall)
@ -80,11 +80,11 @@ class TestProgressiveToolsLogic(SVTestBase):
green_house = self.create_item("Greenhouse")
self.collect(self.create_item(Event.fall_farming))
self.multiworld.state.collect(green_house, event=False)
self.multiworld.state.collect(green_house, prevent_sweep=False)
self.assert_rule_false(rule, self.multiworld.state)
friday = self.create_item("Traveling Merchant: Friday")
self.multiworld.state.collect(friday, event=False)
self.multiworld.state.collect(friday, prevent_sweep=False)
self.assertTrue(self.multiworld.get_location("Old Master Cannoli", 1).access_rule(self.multiworld.state))
self.remove(green_house)
@ -111,7 +111,7 @@ class TestToolVanillaRequiresBlacksmith(SVTestBase):
for material in [ToolMaterial.copper, ToolMaterial.iron, ToolMaterial.gold, ToolMaterial.iridium]:
self.assert_rule_false(self.world.logic.tool.has_tool(tool, material), self.multiworld.state)
self.multiworld.state.collect(self.create_item(railroad_item), event=False)
self.multiworld.state.collect(self.create_item(railroad_item), prevent_sweep=False)
for tool in [Tool.pickaxe, Tool.axe, Tool.hoe, Tool.trash_can, Tool.watering_can]:
for material in [ToolMaterial.copper, ToolMaterial.iron, ToolMaterial.gold, ToolMaterial.iridium]:
@ -125,7 +125,7 @@ class TestToolVanillaRequiresBlacksmith(SVTestBase):
for fishing_rod_level in [3, 4]:
self.assert_rule_false(self.world.logic.tool.has_fishing_rod(fishing_rod_level), self.multiworld.state)
self.multiworld.state.collect(self.create_item(railroad_item), event=False)
self.multiworld.state.collect(self.create_item(railroad_item), prevent_sweep=False)
for fishing_rod_level in [3, 4]:
self.assert_rule_true(self.world.logic.tool.has_fishing_rod(fishing_rod_level), self.multiworld.state)

16
worlds/stardew_valley/test/rules/TestWeapons.py
View File

@ -10,16 +10,16 @@ class TestWeaponsLogic(SVTestBase):
}
def test_mine(self):
self.multiworld.state.collect(self.create_item("Progressive Pickaxe"), event=True)
self.multiworld.state.collect(self.create_item("Progressive Pickaxe"), event=True)
self.multiworld.state.collect(self.create_item("Progressive Pickaxe"), event=True)
self.multiworld.state.collect(self.create_item("Progressive Pickaxe"), event=True)
self.multiworld.state.collect(self.create_item("Progressive House"), event=True)
self.multiworld.state.collect(self.create_item("Progressive Pickaxe"), prevent_sweep=True)
self.multiworld.state.collect(self.create_item("Progressive Pickaxe"), prevent_sweep=True)
self.multiworld.state.collect(self.create_item("Progressive Pickaxe"), prevent_sweep=True)
self.multiworld.state.collect(self.create_item("Progressive Pickaxe"), prevent_sweep=True)
self.multiworld.state.collect(self.create_item("Progressive House"), prevent_sweep=True)
self.collect([self.create_item("Combat Level")] * 10)
self.collect([self.create_item("Mining Level")] * 10)
self.collect([self.create_item("Progressive Mine Elevator")] * 24)
self.multiworld.state.collect(self.create_item("Bus Repair"), event=True)
self.multiworld.state.collect(self.create_item("Skull Key"), event=True)
self.multiworld.state.collect(self.create_item("Bus Repair"), prevent_sweep=True)
self.multiworld.state.collect(self.create_item("Skull Key"), prevent_sweep=True)
self.GiveItemAndCheckReachableMine("Progressive Sword", 1)
self.GiveItemAndCheckReachableMine("Progressive Dagger", 1)
@ -43,7 +43,7 @@ class TestWeaponsLogic(SVTestBase):
def GiveItemAndCheckReachableMine(self, item_name: str, reachable_level: int):
item = self.multiworld.create_item(item_name, self.player)
self.multiworld.state.collect(item, event=True)
self.multiworld.state.collect(item, prevent_sweep=True)
rule = self.world.logic.mine.can_mine_in_the_mines_floor_1_40()
if reachable_level > 0:
self.assert_rule_true(rule, self.multiworld.state)