morgan/Grinch-AP
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
Files
ac2387e17cf4badcae9b543b7fdef4a78991fe8a
Grinch-AP/worlds/stardew_valley/logic.py
agilbert1412 80fed1c6fb Stardew Valley: Fixed potential softlock with walnut purchases if Entrance Randomizer locks access to the field office (#2261) 
* - Added logic rules for reaching, then completing, the field office in order to be allowed to spend significant amounts of walnuts

* - Revert moving a method for some reason
2023-11-30 09:32:32 +01:00

1627 lines
98 KiB
Python
Raw Blame History

from __future__ import annotations
import math
from dataclasses import dataclass, field
from typing import Dict, Union, Optional, Iterable, Sized, List, Set
from .data import all_fish, FishItem, all_purchasable_seeds, SeedItem, all_crops, CropItem
from .data.bundle_data import BundleItem
from .data.crops_data import crops_by_name
from .data.fish_data import island_fish
from .data.museum_data import all_museum_items, MuseumItem, all_museum_artifacts, all_museum_minerals
from .data.recipe_data import all_cooking_recipes, CookingRecipe, RecipeSource, FriendshipSource, QueenOfSauceSource, \
StarterSource, ShopSource, SkillSource
from .data.villagers_data import all_villagers_by_name, Villager
from .items import all_items, Group
from .mods.logic.buildings import get_modded_building_rules
from .mods.logic.quests import get_modded_quest_rules
from .mods.logic.special_orders import get_modded_special_orders_rules
from .mods.logic.skullcavernelevator import has_skull_cavern_elevator_to_floor
from .mods.mod_data import ModNames
from .mods.logic import magic, skills
from .options import Museumsanity, SeasonRandomization, StardewValleyOptions, BuildingProgression, SkillProgression, ToolProgression, Friendsanity, Cropsanity, \
ExcludeGingerIsland, ElevatorProgression, ArcadeMachineLocations, FestivalLocations, SpecialOrderLocations
from .regions import vanilla_regions
from .stardew_rule import False_, Reach, Or, True_, Received, Count, And, Has, TotalReceived, StardewRule
from .strings.animal_names import Animal, coop_animals, barn_animals
from .strings.animal_product_names import AnimalProduct
from .strings.ap_names.buff_names import Buff
from .strings.ap_names.transport_names import Transportation
from .strings.artisan_good_names import ArtisanGood
from .strings.building_names import Building
from .strings.calendar_names import Weekday
from .strings.craftable_names import Craftable
from .strings.crop_names import Fruit, Vegetable, all_fruits, all_vegetables
from .strings.fertilizer_names import Fertilizer
from .strings.festival_check_names import FestivalCheck
from .strings.fish_names import Fish, Trash, WaterItem
from .strings.flower_names import Flower
from .strings.forageable_names import Forageable
from .strings.fruit_tree_names import Sapling
from .strings.generic_names import Generic
from .strings.geode_names import Geode
from .strings.gift_names import Gift
from .strings.ingredient_names import Ingredient
from .strings.material_names import Material
from .strings.machine_names import Machine
from .strings.food_names import Meal, Beverage
from .strings.metal_names import Ore, MetalBar, Mineral, Fossil
from .strings.monster_drop_names import Loot
from .strings.performance_names import Performance
from .strings.quest_names import Quest
from .strings.region_names import Region
from .strings.season_names import Season
from .strings.seed_names import Seed
from .strings.skill_names import Skill, ModSkill
from .strings.special_order_names import SpecialOrder
from .strings.spells import MagicSpell
from .strings.tool_names import Tool, ToolMaterial, APTool
from .strings.tv_channel_names import Channel
from .strings.villager_names import NPC
from .strings.wallet_item_names import Wallet
from .strings.weapon_names import Weapon
MAX_MONTHS = 12
MONEY_PER_MONTH = 15000
MISSING_ITEM = "THIS ITEM IS MISSING"
tool_materials = {
ToolMaterial.copper: 1,
ToolMaterial.iron: 2,
ToolMaterial.gold: 3,
ToolMaterial.iridium: 4
}
tool_upgrade_prices = {
ToolMaterial.copper: 2000,
ToolMaterial.iron: 5000,
ToolMaterial.gold: 10000,
ToolMaterial.iridium: 25000
}
fishing_regions = [Region.beach, Region.town, Region.forest, Region.mountain, Region.island_south, Region.island_west]
@dataclass(frozen=True, repr=False)
class StardewLogic:
player: int
options: StardewValleyOptions
item_rules: Dict[str, StardewRule] = field(default_factory=dict)
sapling_rules: Dict[str, StardewRule] = field(default_factory=dict)
tree_fruit_rules: Dict[str, StardewRule] = field(default_factory=dict)
seed_rules: Dict[str, StardewRule] = field(default_factory=dict)
cooking_rules: Dict[str, StardewRule] = field(default_factory=dict)
crop_rules: Dict[str, StardewRule] = field(default_factory=dict)
fish_rules: Dict[str, StardewRule] = field(default_factory=dict)
museum_rules: Dict[str, StardewRule] = field(default_factory=dict)
building_rules: Dict[str, StardewRule] = field(default_factory=dict)
quest_rules: Dict[str, StardewRule] = field(default_factory=dict)
festival_rules: Dict[str, StardewRule] = field(default_factory=dict)
special_order_rules: Dict[str, StardewRule] = field(default_factory=dict)
def __post_init__(self):
self.fish_rules.update({fish.name: self.can_catch_fish(fish) for fish in all_fish})
self.museum_rules.update({donation.name: self.can_find_museum_item(donation) for donation in all_museum_items})
for recipe in all_cooking_recipes:
can_cook_rule = self.can_cook(recipe)
if recipe.meal in self.cooking_rules:
can_cook_rule = can_cook_rule | self.cooking_rules[recipe.meal]
self.cooking_rules[recipe.meal] = can_cook_rule
self.sapling_rules.update({
Sapling.apple: self.can_buy_sapling(Fruit.apple),
Sapling.apricot: self.can_buy_sapling(Fruit.apricot),
Sapling.cherry: self.can_buy_sapling(Fruit.cherry),
Sapling.orange: self.can_buy_sapling(Fruit.orange),
Sapling.peach: self.can_buy_sapling(Fruit.peach),
Sapling.pomegranate: self.can_buy_sapling(Fruit.pomegranate),
Sapling.banana: self.can_buy_sapling(Fruit.banana),
Sapling.mango: self.can_buy_sapling(Fruit.mango),
})
self.tree_fruit_rules.update({
Fruit.apple: self.can_plant_and_grow_item(Season.fall),
Fruit.apricot: self.can_plant_and_grow_item(Season.spring),
Fruit.cherry: self.can_plant_and_grow_item(Season.spring),
Fruit.orange: self.can_plant_and_grow_item(Season.summer),
Fruit.peach: self.can_plant_and_grow_item(Season.summer),
Fruit.pomegranate: self.can_plant_and_grow_item(Season.fall),
Fruit.banana: self.can_plant_and_grow_item(Season.summer),
Fruit.mango: self.can_plant_and_grow_item(Season.summer),
})
for tree_fruit in self.tree_fruit_rules:
existing_rules = self.tree_fruit_rules[tree_fruit]
sapling = f"{tree_fruit} Sapling"
self.tree_fruit_rules[tree_fruit] = existing_rules & self.has(sapling) & self.has_lived_months(1)
self.seed_rules.update({seed.name: self.can_buy_seed(seed) for seed in all_purchasable_seeds})
self.crop_rules.update({crop.name: self.can_grow_crop(crop) for crop in all_crops})
self.crop_rules.update({
Seed.coffee: (self.has_season(Season.spring) | self.has_season(
Season.summer)) & self.can_buy_seed(crops_by_name[Seed.coffee].seed),
Fruit.ancient_fruit: (self.received("Ancient Seeds") | self.received("Ancient Seeds Recipe")) &
self.can_reach_region(Region.greenhouse) & self.has(Machine.seed_maker),
})
self.item_rules.update({
ArtisanGood.aged_roe: self.can_preserves_jar(AnimalProduct.roe),
AnimalProduct.any_egg: self.has(AnimalProduct.chicken_egg) | self.has(AnimalProduct.duck_egg),
Fish.any: Or([self.can_catch_fish(fish) for fish in all_fish]),
Geode.artifact_trove: self.has(Geode.omni) & self.can_reach_region(Region.desert),
Craftable.bait: (self.has_skill_level(Skill.fishing, 2) & self.has(Loot.bug_meat)) | self.has(Machine.worm_bin),
Fertilizer.basic: (self.has(Material.sap) & self.has_farming_level(1)) | (self.has_lived_months(1) & self.can_spend_money_at(Region.pierre_store, 100)),
Fertilizer.quality: (self.has_farming_level(9) & self.has(Material.sap) & self.has(Fish.any)) | (self.has_year_two() & self.can_spend_money_at(Region.pierre_store, 150)),
Fertilizer.deluxe: False_(),
# self.received("Deluxe Fertilizer Recipe") & self.has(MetalBar.iridium) & self.has(SVItem.sap),
Fertilizer.tree: self.has_skill_level(Skill.foraging, 7) & self.has(Material.fiber) & self.has(Material.stone),
Loot.bat_wing: self.can_mine_in_the_mines_floor_41_80() | self.can_mine_in_the_skull_cavern(),
ArtisanGood.battery_pack: (self.has(Machine.lightning_rod) & self.has_any_season_not_winter()) | self.has(Machine.solar_panel),
Machine.bee_house: self.has_farming_level(3) & self.has(MetalBar.iron) & self.has(ArtisanGood.maple_syrup) & self.has(Material.coal) & self.has(Material.wood),
Beverage.beer: self.can_keg(Vegetable.wheat) | self.can_spend_money_at(Region.saloon, 400),
Forageable.blackberry: self.can_forage(Season.fall),
Craftable.bomb: self.has_skill_level(Skill.mining, 6) & self.has(Material.coal) & self.has(Ore.iron),
Fossil.bone_fragment: self.can_reach_region(Region.dig_site),
Gift.bouquet: self.has_relationship(Generic.bachelor, 8) & self.can_spend_money_at(Region.pierre_store, 100),
Meal.bread: self.can_spend_money_at(Region.saloon, 120),
Trash.broken_cd: self.can_crab_pot(),
Trash.broken_glasses: self.can_crab_pot(),
Loot.bug_meat: self.can_mine_in_the_mines_floor_1_40(),
Forageable.cactus_fruit: self.can_forage(Generic.any, Region.desert),
Machine.cask: self.has_house(3) & self.can_reach_region(Region.cellar) & self.has(Material.wood) & self.has(Material.hardwood),
Forageable.cave_carrot: self.can_forage(Generic.any, Region.mines_floor_10, True),
ArtisanGood.caviar: self.can_preserves_jar(AnimalProduct.sturgeon_roe),
Forageable.chanterelle: self.can_forage(Season.fall, Region.secret_woods),
Machine.cheese_press: self.has_farming_level(6) & self.has(Material.wood) & self.has(Material.stone) & self.has(Material.hardwood) & self.has(MetalBar.copper),
ArtisanGood.cheese: (self.has(AnimalProduct.cow_milk) & self.has(Machine.cheese_press)) | (self.can_reach_region(Region.desert) & self.has(Mineral.emerald)),
Craftable.cherry_bomb: self.has_skill_level(Skill.mining, 1) & self.has(Material.coal) & self.has(Ore.copper),
Animal.chicken: self.can_buy_animal(Animal.chicken),
AnimalProduct.chicken_egg: self.has([AnimalProduct.egg, AnimalProduct.brown_egg, AnimalProduct.large_egg, AnimalProduct.large_brown_egg], 1),
Material.cinder_shard: self.can_reach_region(Region.volcano_floor_5),
WaterItem.clam: self.can_forage(Generic.any, Region.beach),
Material.clay: self.can_reach_any_region([Region.farm, Region.beach, Region.quarry]) & self.has_tool(Tool.hoe),
ArtisanGood.cloth: (self.has(AnimalProduct.wool) & self.has(Machine.loom)) | (self.can_reach_region(Region.desert) & self.has(Mineral.aquamarine)),
Material.coal: self.can_mine_in_the_mines_floor_41_80() | self.can_do_panning(),
WaterItem.cockle: self.can_forage(Generic.any, Region.beach),
Forageable.coconut: self.can_forage(Generic.any, Region.desert),
Beverage.coffee: self.can_keg(Seed.coffee) | self.has(Machine.coffee_maker) | (self.can_spend_money_at(Region.saloon, 300)) | self.has("Hot Java Ring"),
Machine.coffee_maker: self.received(Machine.coffee_maker),
Forageable.common_mushroom: self.can_forage(Season.fall) | (self.can_forage(Season.spring, Region.secret_woods)),
MetalBar.copper: self.can_smelt(Ore.copper),
Ore.copper: self.can_mine_in_the_mines_floor_1_40() | self.can_mine_in_the_skull_cavern() | self.can_do_panning(),
WaterItem.coral: self.can_forage(Generic.any, Region.tide_pools) | self.can_forage(Season.summer, Region.beach),
Animal.cow: self.can_buy_animal(Animal.cow),
AnimalProduct.cow_milk: self.has(AnimalProduct.milk) | self.has(AnimalProduct.large_milk),
Fish.crab: self.can_crab_pot(Region.beach),
Machine.crab_pot: self.has_skill_level(Skill.fishing, 3) & (self.can_spend_money_at(Region.fish_shop, 1500) | (self.has(MetalBar.iron) & self.has(Material.wood))),
Fish.crayfish: self.can_crab_pot(Region.town),
Forageable.crocus: self.can_forage(Season.winter),
Forageable.crystal_fruit: self.can_forage(Season.winter),
Forageable.daffodil: self.can_forage(Season.spring),
Forageable.dandelion: self.can_forage(Season.spring),
Animal.dinosaur: self.has_building(Building.big_coop) & self.has(AnimalProduct.dinosaur_egg),
Forageable.dragon_tooth: self.can_forage(Generic.any, Region.volcano_floor_10),
"Dried Starfish": self.can_fish() & self.can_reach_region(Region.beach),
Trash.driftwood: self.can_crab_pot(),
AnimalProduct.duck_egg: self.has_animal(Animal.duck),
AnimalProduct.duck_feather: self.has_happy_animal(Animal.duck),
Animal.duck: self.can_buy_animal(Animal.duck),
AnimalProduct.egg: self.has_animal(Animal.chicken),
AnimalProduct.brown_egg: self.has_animal(Animal.chicken),
"Energy Tonic": self.can_reach_region(Region.hospital) & self.can_spend_money(1000),
Material.fiber: True_(),
Forageable.fiddlehead_fern: self.can_forage(Season.summer, Region.secret_woods),
"Magic Rock Candy": self.can_reach_region(Region.desert) & self.has("Prismatic Shard"),
"Fishing Chest": self.can_fish_chests(),
Craftable.flute_block: self.has_relationship(NPC.robin, 6) & self.can_reach_region(Region.carpenter) & self.has(Material.wood) & self.has(Ore.copper) & self.has(Material.fiber),
Geode.frozen: self.can_mine_in_the_mines_floor_41_80(),
Machine.furnace: self.has(Material.stone) & self.has(Ore.copper),
Geode.geode: self.can_mine_in_the_mines_floor_1_40(),
Forageable.ginger: self.can_forage(Generic.any, Region.island_west, True),
ArtisanGood.goat_cheese: self.has(AnimalProduct.goat_milk) & self.has(Machine.cheese_press),
AnimalProduct.goat_milk: self.has(Animal.goat),
Animal.goat: self.can_buy_animal(Animal.goat),
MetalBar.gold: self.can_smelt(Ore.gold),
Ore.gold: self.can_mine_in_the_mines_floor_81_120() | self.can_mine_in_the_skull_cavern() | self.can_do_panning(),
Geode.golden_coconut: self.can_reach_region(Region.island_north),
Gift.golden_pumpkin: self.has_season(Season.fall) | self.can_open_geode(Geode.artifact_trove),
WaterItem.green_algae: self.can_fish_in_freshwater(),
ArtisanGood.green_tea: self.can_keg(Vegetable.tea_leaves),
Material.hardwood: self.has_tool(Tool.axe, ToolMaterial.copper) & (self.can_reach_region(Region.secret_woods) | self.can_reach_region(Region.island_south)),
Forageable.hay: self.has_building(Building.silo) & self.has_tool(Tool.scythe),
Forageable.hazelnut: self.can_forage(Season.fall),
Forageable.holly: self.can_forage(Season.winter),
ArtisanGood.honey: self.can_spend_money_at(Region.oasis, 200) | (self.has(Machine.bee_house) & self.has_any_season_not_winter()),
"Hot Java Ring": self.can_reach_region(Region.volcano_floor_10),
Meal.ice_cream: (self.has_season(Season.summer) & self.can_spend_money_at(Region.town, 250)) | self.can_spend_money_at(Region.oasis, 240),
# | (self.can_cook() & self.has_relationship(NPC.jodi, 7) & self.has(AnimalProduct.cow_milk) & self.has(Ingredient.sugar)),
MetalBar.iridium: self.can_smelt(Ore.iridium),
Ore.iridium: self.can_mine_in_the_skull_cavern(),
MetalBar.iron: self.can_smelt(Ore.iron),
Ore.iron: self.can_mine_in_the_mines_floor_41_80() | self.can_mine_in_the_skull_cavern() | self.can_do_panning(),
ArtisanGood.jelly: self.has_jelly(),
Trash.joja_cola: self.can_spend_money_at(Region.saloon, 75),
"JotPK Small Buff": self.has_jotpk_power_level(2),
"JotPK Medium Buff": self.has_jotpk_power_level(4),
"JotPK Big Buff": self.has_jotpk_power_level(7),
"JotPK Max Buff": self.has_jotpk_power_level(9),
ArtisanGood.juice: self.has_juice(),
"Junimo Kart Small Buff": self.has_junimo_kart_power_level(2),
"Junimo Kart Medium Buff": self.has_junimo_kart_power_level(4),
"Junimo Kart Big Buff": self.has_junimo_kart_power_level(6),
"Junimo Kart Max Buff": self.has_junimo_kart_power_level(8),
Machine.keg: self.has_farming_level(8) & self.has(Material.wood) & self.has(MetalBar.iron) & self.has(MetalBar.copper) & self.has(ArtisanGood.oak_resin),
AnimalProduct.large_egg: self.has_happy_animal(Animal.chicken),
AnimalProduct.large_brown_egg: self.has_happy_animal(Animal.chicken),
AnimalProduct.large_goat_milk: self.has_happy_animal(Animal.goat),
AnimalProduct.large_milk: self.has_happy_animal(Animal.cow),
Forageable.leek: self.can_forage(Season.spring),
Craftable.life_elixir: self.has_skill_level(Skill.combat, 2) & self.has(Forageable.red_mushroom) & self.has(Forageable.purple_mushroom) & self.has(Forageable.morel) & self.has(Forageable.chanterelle),
Machine.lightning_rod: self.has_skill_level(Skill.foraging, 6) & self.has(MetalBar.iron) & self.has(MetalBar.quartz) & self.has(Loot.bat_wing),
Fish.lobster: self.can_crab_pot(Region.beach),
Machine.loom: self.has_farming_level(7) & self.has(Material.wood) & self.has(Material.fiber) & self.has(ArtisanGood.pine_tar),
Forageable.magma_cap: self.can_forage(Generic.any, Region.volcano_floor_5),
Geode.magma: self.can_mine_in_the_mines_floor_81_120() | (self.has(Fish.lava_eel) & self.has_building(Building.fish_pond)),
ArtisanGood.maple_syrup: self.has(Machine.tapper),
ArtisanGood.mayonnaise: self.has(Machine.mayonnaise_machine) & self.has(AnimalProduct.chicken_egg),
Machine.mayonnaise_machine: self.has_farming_level(2) & self.has(Material.wood) & self.has(Material.stone) & self.has("Earth Crystal") & self.has(MetalBar.copper),
ArtisanGood.mead: self.can_keg(ArtisanGood.honey),
Craftable.mega_bomb: self.has_skill_level(Skill.mining, 8) & self.has(Ore.gold) & self.has(Loot.solar_essence) & self.has(Loot.void_essence),
Gift.mermaid_pendant: self.can_reach_region(Region.tide_pools) & self.has_relationship(Generic.bachelor, 10) & self.has_house(1) & self.has(Craftable.rain_totem),
AnimalProduct.milk: self.has_animal(Animal.cow),
Craftable.monster_musk: self.has_prismatic_jelly_reward_access() & self.has(Loot.slime) & self.has(Loot.bat_wing),
Forageable.morel: self.can_forage(Season.spring, Region.secret_woods),
"Muscle Remedy": self.can_reach_region(Region.hospital) & self.can_spend_money(1000),
Fish.mussel: self.can_forage(Generic.any, Region.beach) or self.has(Fish.mussel_node),
Fish.mussel_node: self.can_reach_region(Region.island_west),
WaterItem.nautilus_shell: self.can_forage(Season.winter, Region.beach),
ArtisanGood.oak_resin: self.has(Machine.tapper),
Ingredient.oil: self.can_spend_money_at(Region.pierre_store, 200) | (self.has(Machine.oil_maker) & (self.has(Vegetable.corn) | self.has(Flower.sunflower) | self.has(Seed.sunflower))),
Machine.oil_maker: self.has_farming_level(8) & self.has(Loot.slime) & self.has(Material.hardwood) & self.has(MetalBar.gold),
Craftable.oil_of_garlic: (self.has_skill_level(Skill.combat, 6) & self.has(Vegetable.garlic) & self.has(Ingredient.oil)) | (self.can_spend_money_at(Region.mines_dwarf_shop, 3000)),
Geode.omni: self.can_mine_in_the_mines_floor_41_80() | self.can_reach_region(Region.desert) | self.can_do_panning() | self.received(Wallet.rusty_key) | (self.has(Fish.octopus) & self.has_building(Building.fish_pond)) | self.can_reach_region(Region.volcano_floor_10),
Animal.ostrich: self.has_building(Building.barn) & self.has(AnimalProduct.ostrich_egg) & self.has(Machine.ostrich_incubator),
AnimalProduct.ostrich_egg: self.can_forage(Generic.any, Region.island_north, True),
Machine.ostrich_incubator: self.received("Ostrich Incubator Recipe") & self.has(Fossil.bone_fragment) & self.has(Material.hardwood) & self.has(Material.cinder_shard),
Fish.oyster: self.can_forage(Generic.any, Region.beach),
ArtisanGood.pale_ale: self.can_keg(Vegetable.hops),
Gift.pearl: (self.has(Fish.blobfish) & self.has_building(Building.fish_pond)) | self.can_open_geode(Geode.artifact_trove),
Fish.periwinkle: self.can_crab_pot(Region.town),
ArtisanGood.pickles: self.has_pickle(),
Animal.pig: self.can_buy_animal(Animal.pig),
Beverage.pina_colada: self.can_spend_money_at(Region.island_resort, 600),
ArtisanGood.pine_tar: self.has(Machine.tapper),
Meal.pizza: self.can_spend_money_at(Region.saloon, 600),
Machine.preserves_jar: self.has_farming_level(4) & self.has(Material.wood) & self.has(Material.stone) & self.has(Material.coal),
Forageable.purple_mushroom: self.can_forage(Generic.any, Region.mines_floor_95) | self.can_forage(Generic.any, Region.skull_cavern_25),
Animal.rabbit: self.can_buy_animal(Animal.rabbit),
AnimalProduct.rabbit_foot: self.has_happy_animal(Animal.rabbit),
MetalBar.radioactive: self.can_smelt(Ore.radioactive),
Ore.radioactive: self.can_mine_perfectly() & self.can_reach_region(Region.qi_walnut_room),
Forageable.rainbow_shell: self.can_forage(Season.summer, Region.beach),
Craftable.rain_totem: self.has_skill_level(Skill.foraging, 9) & self.has(Material.hardwood) & self.has(ArtisanGood.truffle_oil) & self.has(ArtisanGood.pine_tar),
Machine.recycling_machine: self.has_skill_level(Skill.fishing, 4) & self.has(Material.wood) & self.has(Material.stone) & self.has(MetalBar.iron),
Forageable.red_mushroom: self.can_forage(Season.summer, Region.secret_woods) | self.can_forage(Season.fall, Region.secret_woods),
MetalBar.quartz: self.can_smelt("Quartz") | self.can_smelt("Fire Quartz") |
(self.has(Machine.recycling_machine) & (self.has(Trash.broken_cd) | self.has(Trash.broken_glasses))),
Ingredient.rice: self.can_spend_money_at(Region.pierre_store, 200) | (
self.has_building(Building.mill) & self.has(Vegetable.unmilled_rice)),
AnimalProduct.roe: self.can_fish() & self.has_building(Building.fish_pond),
Meal.salad: self.can_spend_money_at(Region.saloon, 220),
# | (self.can_cook() & self.has_relationship(NPC.emily, 3) & self.has(Forageable.leek) & self.has(Forageable.dandelion) &
# self.has(Ingredient.vinegar)),
Forageable.salmonberry: self.can_forage(Season.spring),
Material.sap: self.can_chop_trees(),
Craftable.scarecrow: self.has_farming_level(1) & self.has(Material.wood) & self.has(Material.coal) & self.has(Material.fiber),
WaterItem.sea_urchin: self.can_forage(Generic.any, Region.tide_pools),
WaterItem.seaweed: (self.can_fish() & self.can_reach_region(Region.beach)) | self.can_reach_region(
Region.tide_pools),
Forageable.secret_note: self.received(Wallet.magnifying_glass) & (self.can_chop_trees() | self.can_mine_in_the_mines_floor_1_40()),
Machine.seed_maker: self.has_farming_level(9) & self.has(Material.wood) & self.has(MetalBar.gold) & self.has(
Material.coal),
Animal.sheep: self.can_buy_animal(Animal.sheep),
Fish.shrimp: self.can_crab_pot(Region.beach),
Loot.slime: self.can_mine_in_the_mines_floor_1_40(),
Weapon.any_slingshot: self.received(Weapon.slingshot) | self.received(Weapon.master_slingshot),
Fish.snail: self.can_crab_pot(Region.town),
Forageable.snow_yam: self.can_forage(Season.winter, Region.beach, True),
Trash.soggy_newspaper: self.can_crab_pot(),
Loot.solar_essence: self.can_mine_in_the_mines_floor_41_80() | self.can_mine_in_the_skull_cavern(),
Machine.solar_panel: self.received("Solar Panel Recipe") & self.has(MetalBar.quartz) & self.has(
MetalBar.iron) & self.has(MetalBar.gold),
Meal.spaghetti: self.can_spend_money_at(Region.saloon, 240),
Forageable.spice_berry: self.can_forage(Season.summer),
Forageable.spring_onion: self.can_forage(Season.spring),
AnimalProduct.squid_ink: self.can_mine_in_the_mines_floor_81_120() | (self.has_building(Building.fish_pond) & self.has(Fish.squid)),
Craftable.staircase: self.has_skill_level(Skill.mining, 2) & self.has(Material.stone),
Material.stone: self.has_tool(Tool.pickaxe),
Meal.strange_bun: self.has_relationship(NPC.shane, 7) & self.has(Ingredient.wheat_flour) & self.has(Fish.periwinkle) & self.has(ArtisanGood.void_mayonnaise),
AnimalProduct.sturgeon_roe: self.has(Fish.sturgeon) & self.has_building(Building.fish_pond),
Ingredient.sugar: self.can_spend_money_at(Region.pierre_store, 100) | (
self.has_building(Building.mill) & self.has(Vegetable.beet)),
Forageable.sweet_pea: self.can_forage(Season.summer),
Machine.tapper: self.has_skill_level(Skill.foraging, 3) & self.has(Material.wood) & self.has(MetalBar.copper),
Vegetable.tea_leaves: self.has(Sapling.tea) & self.has_lived_months(2) & self.has_any_season_not_winter(),
Sapling.tea: self.has_relationship(NPC.caroline, 2) & self.has(Material.fiber) & self.has(Material.wood),
Trash.trash: self.can_crab_pot(),
Beverage.triple_shot_espresso: self.has("Hot Java Ring"),
ArtisanGood.truffle_oil: self.has(AnimalProduct.truffle) & self.has(Machine.oil_maker),
AnimalProduct.truffle: self.has_animal(Animal.pig) & self.has_any_season_not_winter(),
Ingredient.vinegar: self.can_spend_money_at(Region.pierre_store, 200),
AnimalProduct.void_egg: self.can_spend_money_at(Region.sewer, 5000) | (self.has_building(Building.fish_pond) & self.has(Fish.void_salmon)),
Loot.void_essence: self.can_mine_in_the_mines_floor_81_120() | self.can_mine_in_the_skull_cavern(),
ArtisanGood.void_mayonnaise: (self.can_reach_region(Region.witch_swamp) & self.can_fish()) | (self.has(Machine.mayonnaise_machine) & self.has(AnimalProduct.void_egg)),
Ingredient.wheat_flour: self.can_spend_money_at(Region.pierre_store, 100) |
(self.has_building(Building.mill) & self.has(Vegetable.wheat)),
WaterItem.white_algae: self.can_fish() & self.can_reach_region(Region.mines_floor_20),
Forageable.wild_horseradish: self.can_forage(Season.spring),
Forageable.wild_plum: self.can_forage(Season.fall),
Gift.wilted_bouquet: self.has(Machine.furnace) & self.has(Gift.bouquet) & self.has(Material.coal),
ArtisanGood.wine: self.has_wine(),
Forageable.winter_root: self.can_forage(Season.winter, Region.forest, True),
Material.wood: self.has_tool(Tool.axe),
AnimalProduct.wool: self.has_animal(Animal.rabbit) | self.has_animal(Animal.sheep),
Machine.worm_bin: self.has_skill_level(Skill.fishing, 8) & self.has(Material.hardwood) & self.has(MetalBar.gold) & self.has(MetalBar.iron) & self.has(Material.fiber),
})
self.item_rules.update(self.fish_rules)
self.item_rules.update(self.museum_rules)
self.item_rules.update(self.sapling_rules)
self.item_rules.update(self.tree_fruit_rules)
self.item_rules.update(self.seed_rules)
self.item_rules.update(self.crop_rules)
# For some recipes, the cooked item can be obtained directly, so we either cook it or get it
for recipe in self.cooking_rules:
cooking_rule = self.cooking_rules[recipe]
obtention_rule = self.item_rules[recipe] if recipe in self.item_rules else False_()
self.item_rules[recipe] = obtention_rule | cooking_rule
self.building_rules.update({
Building.barn: self.can_spend_money_at(Region.carpenter, 6000) & self.has([Material.wood, Material.stone]),
Building.big_barn: self.can_spend_money_at(Region.carpenter, 12000) & self.has([Material.wood, Material.stone]) & self.has_building(Building.barn),
Building.deluxe_barn: self.can_spend_money_at(Region.carpenter, 25000) & self.has([Material.wood, Material.stone]) & self.has_building(Building.big_barn),
Building.coop: self.can_spend_money_at(Region.carpenter, 4000) & self.has([Material.wood, Material.stone]),
Building.big_coop: self.can_spend_money_at(Region.carpenter, 10000) & self.has([Material.wood, Material.stone]) & self.has_building(Building.coop),
Building.deluxe_coop: self.can_spend_money_at(Region.carpenter, 20000) & self.has([Material.wood, Material.stone]) & self.has_building(Building.big_coop),
Building.fish_pond: self.can_spend_money_at(Region.carpenter, 5000) & self.has([Material.stone, WaterItem.seaweed, WaterItem.green_algae]),
Building.mill: self.can_spend_money_at(Region.carpenter, 2500) & self.has([Material.stone, Material.wood, ArtisanGood.cloth]),
Building.shed: self.can_spend_money_at(Region.carpenter, 15000) & self.has(Material.wood),
Building.big_shed: self.can_spend_money_at(Region.carpenter, 20000) & self.has([Material.wood, Material.stone]) & self.has_building(Building.shed),
Building.silo: self.can_spend_money_at(Region.carpenter, 100) & self.has([Material.stone, Material.clay, MetalBar.copper]),
Building.slime_hutch: self.can_spend_money_at(Region.carpenter, 10000) & self.has([Material.stone, MetalBar.quartz, MetalBar.iridium]),
Building.stable: self.can_spend_money_at(Region.carpenter, 10000) & self.has([Material.hardwood, MetalBar.iron]),
Building.well: self.can_spend_money_at(Region.carpenter, 1000) & self.has(Material.stone),
Building.shipping_bin: self.can_spend_money_at(Region.carpenter, 250) & self.has(Material.wood),
Building.kitchen: self.can_spend_money_at(Region.carpenter, 10000) & self.has(Material.wood) & self.has_house(0),
Building.kids_room: self.can_spend_money_at(Region.carpenter, 50000) & self.has(Material.hardwood) & self.has_house(1),
Building.cellar: self.can_spend_money_at(Region.carpenter, 100000) & self.has_house(2),
})
self.building_rules.update(get_modded_building_rules(self, self.options.mods))
self.quest_rules.update({
Quest.introductions: self.can_reach_region(Region.town),
Quest.how_to_win_friends: self.can_complete_quest(Quest.introductions),
Quest.getting_started: self.has(Vegetable.parsnip) & self.has_tool(Tool.hoe) & self.can_water(0),
Quest.to_the_beach: self.can_reach_region(Region.beach),
Quest.raising_animals: self.can_complete_quest(Quest.getting_started) & self.has_building(Building.coop),
Quest.advancement: self.can_complete_quest(Quest.getting_started) & self.has(Craftable.scarecrow),
Quest.archaeology: (self.has_tool(Tool.hoe) | self.can_mine_in_the_mines_floor_1_40() | self.can_fish()) & self.can_reach_region(Region.museum),
Quest.meet_the_wizard: self.can_reach_region(Region.town) & self.can_reach_region(Region.community_center) & self.can_reach_region(Region.wizard_tower),
Quest.forging_ahead: self.has(Ore.copper) & self.has(Machine.furnace),
Quest.smelting: self.has(MetalBar.copper),
Quest.initiation: self.can_mine_in_the_mines_floor_1_40(),
Quest.robins_lost_axe: self.has_season(Season.spring) & self.can_reach_region(Region.forest) & self.can_meet(NPC.robin),
Quest.jodis_request: self.has_season(Season.spring) & self.has(Vegetable.cauliflower) & self.can_meet(NPC.jodi),
Quest.mayors_shorts: self.has_season(Season.summer) & self.can_reach_region(Region.ranch) &
(self.has_relationship(NPC.marnie, 2) | (magic.can_blink(self))) & self.can_meet(NPC.lewis),
Quest.blackberry_basket: self.has_season(Season.fall) & self.can_meet(NPC.linus),
Quest.marnies_request: self.has_relationship(NPC.marnie, 3) & self.has(Forageable.cave_carrot) & self.can_reach_region(Region.ranch),
Quest.pam_is_thirsty: self.has_season(Season.summer) & self.has(ArtisanGood.pale_ale) & self.can_meet(NPC.pam),
Quest.a_dark_reagent: self.has_season(Season.winter) & self.has(Loot.void_essence) & self.can_meet(NPC.wizard),
Quest.cows_delight: self.has_season(Season.fall) & self.has(Vegetable.amaranth) & self.can_meet(NPC.marnie),
Quest.the_skull_key: self.received(Wallet.skull_key) & self.can_reach_region(Region.skull_cavern_entrance),
Quest.crop_research: self.has_season(Season.summer) & self.has(Fruit.melon) & self.can_meet(NPC.demetrius),
Quest.knee_therapy: self.has_season(Season.summer) & self.has(Fruit.hot_pepper) & self.can_meet(NPC.george),
Quest.robins_request: self.has_season(Season.winter) & self.has(Material.hardwood) & self.can_meet(NPC.robin),
Quest.qis_challenge: self.can_mine_in_the_skull_cavern(),
Quest.the_mysterious_qi: self.can_reach_region(Region.bus_tunnel) & self.has(ArtisanGood.battery_pack) & self.can_reach_region(Region.desert) & self.has(Forageable.rainbow_shell) & self.has(Vegetable.beet) & self.has(Loot.solar_essence),
Quest.carving_pumpkins: self.has_season(Season.fall) & self.has(Vegetable.pumpkin) & self.can_meet(NPC.caroline),
Quest.a_winter_mystery: self.has_season(Season.winter) & self.can_reach_region(Region.town),
Quest.strange_note: self.has(Forageable.secret_note) & self.can_reach_region(Region.secret_woods) & self.has(ArtisanGood.maple_syrup),
Quest.cryptic_note: self.has(Forageable.secret_note) & self.can_reach_region(Region.skull_cavern_100),
Quest.fresh_fruit: self.has_season(Season.spring) & self.has(Fruit.apricot) & self.can_meet(NPC.emily),
Quest.aquatic_research: self.has_season(Season.summer) & self.has(Fish.pufferfish) & self.can_meet(NPC.demetrius),
Quest.a_soldiers_star: self.has_season(Season.summer) & self.has_year_two() & self.has(Fruit.starfruit) & self.can_meet(NPC.kent),
Quest.mayors_need: self.has_season(Season.summer) & self.has(ArtisanGood.truffle_oil) & self.can_meet(NPC.lewis),
Quest.wanted_lobster: self.has_season(Season.fall) & self.has_season(Season.fall) & self.has(Fish.lobster) & self.can_meet(NPC.gus),
Quest.pam_needs_juice: self.has_season(Season.fall) & self.has(ArtisanGood.battery_pack) & self.can_meet(NPC.pam),
Quest.fish_casserole: self.has_relationship(NPC.jodi, 4) & self.has(Fish.largemouth_bass) & self.can_reach_region(Region.sam_house),
Quest.catch_a_squid: self.has_season(Season.winter) & self.has(Fish.squid) & self.can_meet(NPC.willy),
Quest.fish_stew: self.has_season(Season.winter) & self.has(Fish.albacore) & self.can_meet(NPC.gus),
Quest.pierres_notice: self.has_season(Season.spring) & self.has("Sashimi") & self.can_meet(NPC.pierre),
Quest.clints_attempt: self.has_season(Season.winter) & self.has(Mineral.amethyst) & self.can_meet(NPC.emily),
Quest.a_favor_for_clint: self.has_season(Season.winter) & self.has(MetalBar.iron) & self.can_meet(NPC.clint),
Quest.staff_of_power: self.has_season(Season.winter) & self.has(MetalBar.iridium) & self.can_meet(NPC.wizard),
Quest.grannys_gift: self.has_season(Season.spring) & self.has(Forageable.leek) & self.can_meet(NPC.evelyn),
Quest.exotic_spirits: self.has_season(Season.winter) & self.has(Forageable.coconut) & self.can_meet(NPC.gus),
Quest.catch_a_lingcod: self.has_season(Season.winter) & self.has("Lingcod") & self.can_meet(NPC.willy),
Quest.dark_talisman: self.has_rusty_key() & self.can_reach_region(Region.railroad) & self.can_meet(NPC.krobus) & self.can_reach_region(Region.mutant_bug_lair),
Quest.goblin_problem: self.can_reach_region(Region.witch_swamp) & self.has(ArtisanGood.void_mayonnaise),
Quest.magic_ink: self.can_reach_region(Region.witch_hut) & self.can_meet(NPC.wizard),
Quest.the_pirates_wife: self.can_reach_region(Region.island_west) & self.can_meet(NPC.kent) &
self.can_meet(NPC.gus) & self.can_meet(NPC.sandy) & self.can_meet(NPC.george) &
self.can_meet(NPC.wizard) & self.can_meet(NPC.willy),
})
self.quest_rules.update(get_modded_quest_rules(self, self.options.mods))
self.festival_rules.update({
FestivalCheck.egg_hunt: self.has_season(Season.spring) & self.can_reach_region(Region.town) & self.can_win_egg_hunt(),
FestivalCheck.strawberry_seeds: self.has_season(Season.spring) & self.can_reach_region(Region.town) & self.can_spend_money(1000),
FestivalCheck.dance: self.has_season(Season.spring) & self.can_reach_region(Region.forest) & self.has_relationship(Generic.bachelor, 4),
FestivalCheck.rarecrow_5: self.has_season(Season.spring) & self.can_reach_region(Region.forest) & self.can_spend_money(2500),
FestivalCheck.luau_soup: self.has_season(Season.summer) & self.can_reach_region(Region.beach) & self.can_succeed_luau_soup(),
FestivalCheck.moonlight_jellies: self.has_season(Season.summer) & self.can_reach_region(Region.beach),
FestivalCheck.smashing_stone: self.has_season(Season.fall) & self.can_reach_region(Region.town),
FestivalCheck.grange_display: self.has_season(Season.fall) & self.can_reach_region(Region.town) & self.can_succeed_grange_display(),
FestivalCheck.rarecrow_1: self.has_season(Season.fall) & self.can_reach_region(Region.town), # only cost star tokens
FestivalCheck.fair_stardrop: self.has_season(Season.fall) & self.can_reach_region(Region.town), # only cost star tokens
FestivalCheck.spirit_eve_maze: self.has_season(Season.fall) & self.can_reach_region(Region.town),
FestivalCheck.rarecrow_2: self.has_season(Season.fall) & self.can_reach_region(Region.town) & self.can_spend_money(5000),
FestivalCheck.fishing_competition: self.has_season(Season.winter) & self.can_reach_region(Region.forest) & self.can_win_fishing_competition(),
FestivalCheck.rarecrow_4: self.has_season(Season.winter) & self.can_reach_region(Region.forest) & self.can_spend_money(5000),
FestivalCheck.mermaid_pearl: self.has_season(Season.winter) & self.can_reach_region(Region.beach),
FestivalCheck.cone_hat: self.has_season(Season.winter) & self.can_reach_region(Region.beach) & self.can_spend_money(2500),
FestivalCheck.iridium_fireplace: self.has_season(Season.winter) & self.can_reach_region(Region.beach) & self.can_spend_money(15000),
FestivalCheck.rarecrow_7: self.has_season(Season.winter) & self.can_reach_region(Region.beach) & self.can_spend_money(5000) & self.can_donate_museum_artifacts(20),
FestivalCheck.rarecrow_8: self.has_season(Season.winter) & self.can_reach_region(Region.beach) & self.can_spend_money(5000) & self.can_donate_museum_items(40),
FestivalCheck.lupini_red_eagle: self.has_season(Season.winter) & self.can_reach_region(Region.beach) & self.can_spend_money(1200),
FestivalCheck.lupini_portrait_mermaid: self.has_season(Season.winter) & self.can_reach_region(Region.beach) & self.can_spend_money(1200),
FestivalCheck.lupini_solar_kingdom: self.has_season(Season.winter) & self.can_reach_region(Region.beach) & self.can_spend_money(1200),
FestivalCheck.lupini_clouds: self.has_season(Season.winter) & self.can_reach_region(Region.beach) & self.has_year_two() & self.can_spend_money(1200),
FestivalCheck.lupini_1000_years: self.has_season(Season.winter) & self.can_reach_region(Region.beach) & self.has_year_two() & self.can_spend_money(1200),
FestivalCheck.lupini_three_trees: self.has_season(Season.winter) & self.can_reach_region(Region.beach) & self.has_year_two() & self.can_spend_money(1200),
FestivalCheck.lupini_the_serpent: self.has_season(Season.winter) & self.can_reach_region(Region.beach) & self.has_year_three() & self.can_spend_money(1200),
FestivalCheck.lupini_tropical_fish: self.has_season(Season.winter) & self.can_reach_region(Region.beach) & self.has_year_three() & self.can_spend_money(1200),
FestivalCheck.lupini_land_of_clay: self.has_season(Season.winter) & self.can_reach_region(Region.beach) & self.has_year_three() & self.can_spend_money(1200),
FestivalCheck.secret_santa: self.has_season(Season.winter) & self.can_reach_region(Region.town) & self.has_any_universal_love(),
FestivalCheck.legend_of_the_winter_star: self.has_season(Season.winter) & self.can_reach_region(Region.town),
FestivalCheck.all_rarecrows: self.can_reach_region(Region.farm) & self.has_all_rarecrows(),
})
self.special_order_rules.update({
SpecialOrder.island_ingredients: self.can_meet(NPC.caroline) & self.has_island_transport() & self.can_farm_perfectly() &
self.can_ship(Vegetable.taro_root) & self.can_ship(Fruit.pineapple) & self.can_ship(Forageable.ginger),
SpecialOrder.cave_patrol: self.can_meet(NPC.clint) & self.can_mine_perfectly() & self.can_mine_to_floor(120),
SpecialOrder.aquatic_overpopulation: self.can_meet(NPC.demetrius) & self.can_fish_perfectly(),
SpecialOrder.biome_balance: self.can_meet(NPC.demetrius) & self.can_fish_perfectly(),
SpecialOrder.rock_rejuivenation: self.has_relationship(NPC.emily, 4) & self.has(Mineral.ruby) & self.has(Mineral.topaz) &
self.has(Mineral.emerald) & self.has(Mineral.jade) & self.has(Mineral.amethyst) &
self.has(ArtisanGood.cloth) & self.can_reach_region(Region.haley_house),
SpecialOrder.gifts_for_george: self.can_reach_region(Region.alex_house) & self.has_season(Season.spring) & self.has(Forageable.leek),
SpecialOrder.fragments_of_the_past: self.can_reach_region(Region.museum) & self.can_reach_region(Region.dig_site) & self.has_tool(Tool.pickaxe),
SpecialOrder.gus_famous_omelet: self.can_reach_region(Region.saloon) & self.has(AnimalProduct.any_egg),
SpecialOrder.crop_order: self.can_farm_perfectly() & self.can_ship(),
SpecialOrder.community_cleanup: self.can_reach_region(Region.railroad) & self.can_crab_pot(),
SpecialOrder.the_strong_stuff: self.can_reach_region(Region.trailer) & self.can_keg(Vegetable.potato),
SpecialOrder.pierres_prime_produce: self.can_reach_region(Region.pierre_store) & self.can_farm_perfectly(),
SpecialOrder.robins_project: self.can_meet(NPC.robin) & self.can_reach_region(Region.carpenter) & self.can_chop_perfectly() &
self.has(Material.hardwood),
SpecialOrder.robins_resource_rush: self.can_meet(NPC.robin) & self.can_reach_region(Region.carpenter) & self.can_chop_perfectly() &
self.has(Fertilizer.tree) & self.can_mine_perfectly(),
SpecialOrder.juicy_bugs_wanted_yum: self.can_reach_region(Region.beach) & self.has(Loot.bug_meat),
SpecialOrder.tropical_fish: self.can_meet(NPC.willy) & self.received("Island Resort") & self.has_island_transport() &
self.has(Fish.stingray) & self.has(Fish.blue_discus) & self.has(Fish.lionfish),
SpecialOrder.a_curious_substance: self.can_reach_region(Region.wizard_tower) & self.can_mine_perfectly() & self.can_mine_to_floor(80),
SpecialOrder.prismatic_jelly: self.can_reach_region(Region.wizard_tower) & self.can_mine_perfectly() & self.can_mine_to_floor(40),
SpecialOrder.qis_crop: self.can_farm_perfectly() & self.can_reach_region(Region.greenhouse) &
self.can_reach_region(Region.island_west) & self.has_total_skill_level(50) &
self.has(Machine.seed_maker) & self.has_building(Building.shipping_bin),
SpecialOrder.lets_play_a_game: self.has_junimo_kart_max_level(),
SpecialOrder.four_precious_stones: self.has_lived_months(MAX_MONTHS) & self.has("Prismatic Shard") &
self.can_mine_perfectly_in_the_skull_cavern(),
SpecialOrder.qis_hungry_challenge: self.can_mine_perfectly_in_the_skull_cavern() & self.has_max_buffs(),
SpecialOrder.qis_cuisine: self.can_cook() & (self.can_spend_money_at(Region.saloon, 205000) | self.can_spend_money_at(Region.pierre_store, 170000)) &
self.can_ship(),
SpecialOrder.qis_kindness: self.can_give_loved_gifts_to_everyone(),
SpecialOrder.extended_family: self.can_fish_perfectly() & self.has(Fish.angler) & self.has(Fish.glacierfish) &
self.has(Fish.crimsonfish) & self.has(Fish.mutant_carp) & self.has(Fish.legend),
SpecialOrder.danger_in_the_deep: self.can_mine_perfectly() & self.has_mine_elevator_to_floor(120),
SpecialOrder.skull_cavern_invasion: self.can_mine_perfectly_in_the_skull_cavern() & self.has_max_buffs(),
SpecialOrder.qis_prismatic_grange: self.has(Loot.bug_meat) & # 100 Bug Meat
self.can_spend_money_at(Region.saloon, 24000) & # 100 Spaghetti
self.can_spend_money_at(Region.blacksmith, 15000) & # 100 Copper Ore
self.can_spend_money_at(Region.ranch, 5000) & # 100 Hay
self.can_spend_money_at(Region.saloon, 22000) & # 100 Salads
self.can_spend_money_at(Region.saloon, 7500) & # 100 Joja Cola
self.can_spend_money(80000), # I need this extra rule because money rules aren't additive...
})
self.special_order_rules.update(get_modded_special_orders_rules(self, self.options.mods))
def has(self, items: Union[str, (Iterable[str], Sized)], count: Optional[int] = None) -> StardewRule:
if isinstance(items, str):
return Has(items, self.item_rules)
if len(items) == 0:
return True_()
if count is None or count == len(items):
return And(self.has(item) for item in items)
if count == 1:
return Or(self.has(item) for item in items)
return Count(count, (self.has(item) for item in items))
def received(self, items: Union[str, Iterable[str]], count: Optional[int] = 1) -> StardewRule:
if count <= 0 or not items:
return True_()
if isinstance(items, str):
return Received(items, self.player, count)
if count is None:
return And(self.received(item) for item in items)
if count == 1:
return Or(self.received(item) for item in items)
return TotalReceived(count, items, self.player)
def can_reach_region(self, spot: str) -> StardewRule:
return Reach(spot, "Region", self.player)
def can_reach_any_region(self, spots: Iterable[str]) -> StardewRule:
return Or(self.can_reach_region(spot) for spot in spots)
def can_reach_all_regions(self, spots: Iterable[str]) -> StardewRule:
return And(self.can_reach_region(spot) for spot in spots)
def can_reach_all_regions_except_one(self, spots: Iterable[str]) -> StardewRule:
num_required = len(list(spots)) - 1
if num_required <= 0:
num_required = len(list(spots))
return Count(num_required, [self.can_reach_region(spot) for spot in spots])
def can_reach_location(self, spot: str) -> StardewRule:
return Reach(spot, "Location", self.player)
def can_reach_entrance(self, spot: str) -> StardewRule:
return Reach(spot, "Entrance", self.player)
def can_have_earned_total_money(self, amount: int) -> StardewRule:
return self.has_lived_months(min(8, amount // MONEY_PER_MONTH))
def can_spend_money(self, amount: int) -> StardewRule:
if self.options.starting_money == -1:
return True_()
return self.has_lived_months(min(8, amount // (MONEY_PER_MONTH // 5)))
def can_spend_money_at(self, region: str, amount: int) -> StardewRule:
return self.can_reach_region(region) & self.can_spend_money(amount)
def has_tool(self, tool: str, material: str = ToolMaterial.basic) -> StardewRule:
if material == ToolMaterial.basic or tool == Tool.scythe:
return True_()
if self.options.tool_progression == ToolProgression.option_progressive:
return self.received(f"Progressive {tool}", count=tool_materials[material])
return self.has(f"{material} Bar") & self.can_spend_money(tool_upgrade_prices[material])
def can_earn_skill_level(self, skill: str, level: int) -> StardewRule:
if level <= 0:
return True_()
tool_level = (level - 1) // 2
tool_material = ToolMaterial.tiers[tool_level]
months = max(1, level - 1)
months_rule = self.has_lived_months(months)
previous_level_rule = self.has_skill_level(skill, level - 1)
if skill == Skill.fishing:
xp_rule = self.can_get_fishing_xp() & self.has_tool(Tool.fishing_rod, ToolMaterial.tiers[max(tool_level, 3)])
elif skill == Skill.farming:
xp_rule = self.can_get_farming_xp() & self.has_tool(Tool.hoe, tool_material) & self.can_water(tool_level)
elif skill == Skill.foraging:
xp_rule = self.can_get_foraging_xp() & \
(self.has_tool(Tool.axe, tool_material) | magic.can_use_clear_debris_instead_of_tool_level(self, tool_level))
elif skill == Skill.mining:
xp_rule = self.can_get_mining_xp() & \
(self.has_tool(Tool.pickaxe, tool_material) | magic.can_use_clear_debris_instead_of_tool_level(self, tool_level))
elif skill == Skill.combat:
combat_tier = Performance.tiers[tool_level]
xp_rule = self.can_get_combat_xp() & self.can_do_combat_at_level(combat_tier)
else:
xp_rule = skills.can_earn_mod_skill_level(self, skill, level)
return previous_level_rule & months_rule & xp_rule
def has_skill_level(self, skill: str, level: int) -> StardewRule:
if level <= 0:
return True_()
if self.options.skill_progression == SkillProgression.option_progressive:
return self.received(f"{skill} Level", count=level)
return self.can_earn_skill_level(skill, level)
def has_farming_level(self, level: int) -> StardewRule:
return self.has_skill_level(Skill.farming, level)
def has_total_skill_level(self, level: int, allow_modded_skills: bool = False) -> StardewRule:
if level <= 0:
return True_()
if self.options.skill_progression == SkillProgression.option_progressive:
skills_items = ["Farming Level", "Mining Level", "Foraging Level",
"Fishing Level", "Combat Level"]
if allow_modded_skills:
skills.append_mod_skill_level(skills_items, self.options)
return self.received(skills_items, count=level)
months_with_4_skills = max(1, (level // 4) - 1)
months_with_5_skills = max(1, (level // 5) - 1)
rule_with_fishing = self.has_lived_months(months_with_5_skills) & self.can_get_fishing_xp()
if level > 40:
return rule_with_fishing
return self.has_lived_months(months_with_4_skills) | rule_with_fishing
def has_building(self, building: str) -> StardewRule:
carpenter_rule = self.can_reach_region(Region.carpenter)
if not self.options.building_progression == BuildingProgression.option_vanilla:
count = 1
if building in [Building.coop, Building.barn, Building.shed]:
building = f"Progressive {building}"
elif building.startswith("Big"):
count = 2
building = " ".join(["Progressive", *building.split(" ")[1:]])
elif building.startswith("Deluxe"):
count = 3
building = " ".join(["Progressive", *building.split(" ")[1:]])
return self.received(f"{building}", count) & carpenter_rule
return Has(building, self.building_rules) & carpenter_rule
def has_house(self, upgrade_level: int) -> StardewRule:
if upgrade_level < 1:
return True_()
if upgrade_level > 3:
return False_()
if not self.options.building_progression == BuildingProgression.option_vanilla:
return self.received(f"Progressive House", upgrade_level) & self.can_reach_region(Region.carpenter)
if upgrade_level == 1:
return Has(Building.kitchen, self.building_rules)
if upgrade_level == 2:
return Has(Building.kids_room, self.building_rules)
# if upgrade_level == 3:
return Has(Building.cellar, self.building_rules)
def can_complete_quest(self, quest: str) -> StardewRule:
return Has(quest, self.quest_rules)
def can_complete_special_order(self, specialorder: str) -> StardewRule:
return Has(specialorder, self.special_order_rules)
def can_get_farming_xp(self) -> StardewRule:
crop_rules = []
for crop in all_crops:
crop_rules.append(self.can_grow_crop(crop))
return Or(crop_rules)
def can_get_foraging_xp(self) -> StardewRule:
tool_rule = self.has_tool(Tool.axe)
tree_rule = self.can_reach_region(Region.forest) & self.has_any_season_not_winter()
stump_rule = self.can_reach_region(Region.secret_woods) & self.has_tool(Tool.axe, ToolMaterial.copper)
return tool_rule & (tree_rule | stump_rule)
def can_get_mining_xp(self) -> StardewRule:
tool_rule = self.has_tool(Tool.pickaxe)
stone_rule = self.can_reach_any_region([Region.mines_floor_5, Region.quarry, Region.skull_cavern_25, Region.volcano_floor_5])
return tool_rule & stone_rule
def can_get_combat_xp(self) -> StardewRule:
tool_rule = self.has_any_weapon()
enemy_rule = self.can_reach_any_region([Region.mines_floor_5, Region.skull_cavern_25, Region.volcano_floor_5])
return tool_rule & enemy_rule
def can_get_fishing_xp(self) -> StardewRule:
if self.options.skill_progression == SkillProgression.option_progressive:
return self.can_fish() | self.can_crab_pot()
return self.can_fish()
def can_fish(self, difficulty: int = 0) -> StardewRule:
skill_required = max(0, int((difficulty / 10) - 1))
if difficulty <= 40:
skill_required = 0
skill_rule = self.has_skill_level(Skill.fishing, skill_required)
region_rule = self.can_reach_any_region(fishing_regions)
number_fishing_rod_required = 1 if difficulty < 50 else 2
if self.options.tool_progression == ToolProgression.option_progressive:
return self.received("Progressive Fishing Rod", number_fishing_rod_required) & skill_rule & region_rule
return skill_rule & region_rule
def can_fish_in_freshwater(self) -> StardewRule:
return self.can_fish() & self.can_reach_any_region([Region.forest, Region.town, Region.mountain])
def has_max_fishing(self) -> StardewRule:
skill_rule = self.has_skill_level(Skill.fishing, 10)
return self.has_max_fishing_rod() & skill_rule
def can_fish_chests(self) -> StardewRule:
skill_rule = self.has_skill_level(Skill.fishing, 4)
return self.has_max_fishing_rod() & skill_rule
def can_buy_seed(self, seed: SeedItem) -> StardewRule:
if self.options.cropsanity == Cropsanity.option_disabled:
item_rule = True_()
else:
item_rule = self.received(seed.name)
season_rule = self.has_any_season(seed.seasons)
region_rule = self.can_reach_all_regions(seed.regions)
currency_rule = self.can_spend_money(1000)
if seed.name == Seed.pineapple:
currency_rule = self.has(Forageable.magma_cap)
if seed.name == Seed.taro:
currency_rule = self.has(Fossil.bone_fragment)
return season_rule & region_rule & item_rule & currency_rule
def can_buy_sapling(self, fruit: str) -> StardewRule:
sapling_prices = {Fruit.apple: 4000, Fruit.apricot: 2000, Fruit.cherry: 3400, Fruit.orange: 4000,
Fruit.peach: 6000,
Fruit.pomegranate: 6000, Fruit.banana: 0, Fruit.mango: 0}
received_sapling = self.received(f"{fruit} Sapling")
if self.options.cropsanity == Cropsanity.option_disabled:
allowed_buy_sapling = True_()
else:
allowed_buy_sapling = received_sapling
can_buy_sapling = self.can_spend_money_at(Region.pierre_store, sapling_prices[fruit])
if fruit == Fruit.banana:
can_buy_sapling = self.has_island_trader() & self.has(Forageable.dragon_tooth)
elif fruit == Fruit.mango:
can_buy_sapling = self.has_island_trader() & self.has(Fish.mussel_node)
return allowed_buy_sapling & can_buy_sapling
def can_grow_crop(self, crop: CropItem) -> StardewRule:
season_rule = self.has_any_season(crop.farm_growth_seasons)
seed_rule = self.has(crop.seed.name)
farm_rule = self.can_reach_region(Region.farm) & season_rule
tool_rule = self.has_tool(Tool.hoe) & self.has_tool(Tool.watering_can)
region_rule = farm_rule | self.can_reach_region(Region.greenhouse) | self.can_reach_region(Region.island_west)
return seed_rule & region_rule & tool_rule
def can_plant_and_grow_item(self, seasons: Union[str, Iterable[str]]) -> StardewRule:
if isinstance(seasons, str):
seasons = [seasons]
season_rule = self.has_any_season(seasons) | self.can_reach_region(Region.greenhouse) | self.has_island_farm()
farm_rule = self.can_reach_region(Region.farm) | self.can_reach_region(
Region.greenhouse) | self.has_island_farm()
return season_rule & farm_rule
def has_island_farm(self) -> StardewRule:
return self.can_reach_region(Region.island_south)
def can_catch_fish(self, fish: FishItem) -> StardewRule:
region_rule = self.can_reach_any_region(fish.locations)
season_rule = self.has_any_season(fish.seasons)
if fish.difficulty == -1:
difficulty_rule = self.can_crab_pot()
else:
difficulty_rule = self.can_fish(fish.difficulty)
return region_rule & season_rule & difficulty_rule
def can_catch_every_fish(self) -> StardewRule:
rules = [self.has_skill_level(Skill.fishing, 10), self.has_max_fishing_rod()]
for fish in all_fish:
if self.options.exclude_ginger_island == ExcludeGingerIsland.option_true and \
fish in island_fish:
continue
rules.append(self.can_catch_fish(fish))
return And(rules)
def has_max_fishing_rod(self) -> StardewRule:
if self.options.tool_progression == ToolProgression.option_progressive:
return self.received(APTool.fishing_rod, 4)
return self.can_get_fishing_xp()
def can_cook(self, recipe: CookingRecipe = None) -> StardewRule:
cook_rule = self.has_house(1) | self.has_skill_level(Skill.foraging, 9)
if recipe is None:
return cook_rule
learn_rule = self.can_learn_recipe(recipe.source)
ingredients_rule = And([self.has(ingredient) for ingredient in recipe.ingredients])
number_ingredients = sum(recipe.ingredients[ingredient] for ingredient in recipe.ingredients)
time_rule = self.has_lived_months(number_ingredients)
return cook_rule & learn_rule & ingredients_rule & time_rule
def can_learn_recipe(self, source: RecipeSource) -> StardewRule:
if isinstance(source, StarterSource):
return True_()
if isinstance(source, ShopSource):
return self.can_spend_money_at(source.region, source.price)
if isinstance(source, SkillSource):
return self.has_skill_level(source.skill, source.level)
if isinstance(source, FriendshipSource):
return self.has_relationship(source.friend, source.hearts)
if isinstance(source, QueenOfSauceSource):
year_rule = self.has_year_two() if source.year == 2 else self.has_year_three()
return self.can_watch(Channel.queen_of_sauce) & self.has_season(source.season) & year_rule
return False_()
def can_watch(self, channel: str = None):
tv_rule = True_()
if channel is None:
return tv_rule
return self.received(channel) & tv_rule
def can_smelt(self, item: str) -> StardewRule:
return self.has(Machine.furnace) & self.has(item)
def can_do_panning(self, item: str = Generic.any) -> StardewRule:
return self.received("Glittering Boulder Removed")
def can_crab_pot(self, region: str = Generic.any) -> StardewRule:
crab_pot_rule = self.has(Craftable.bait)
if self.options.skill_progression == SkillProgression.option_progressive:
crab_pot_rule = crab_pot_rule & self.has(Machine.crab_pot)
else:
crab_pot_rule = crab_pot_rule & self.can_get_fishing_xp()
if region != Generic.any:
return crab_pot_rule & self.can_reach_region(region)
water_region_rules = self.can_reach_any_region(fishing_regions)
return crab_pot_rule & water_region_rules
# Regions
def can_mine_in_the_mines_floor_1_40(self) -> StardewRule:
return self.can_reach_region(Region.mines_floor_5)
def can_mine_in_the_mines_floor_41_80(self) -> StardewRule:
return self.can_reach_region(Region.mines_floor_45)
def can_mine_in_the_mines_floor_81_120(self) -> StardewRule:
return self.can_reach_region(Region.mines_floor_85)
def can_mine_in_the_skull_cavern(self) -> StardewRule:
return (self.can_progress_in_the_mines_from_floor(120) &
self.can_reach_region(Region.skull_cavern))
def can_mine_perfectly(self) -> StardewRule:
return self.can_progress_in_the_mines_from_floor(160)
def can_mine_perfectly_in_the_skull_cavern(self) -> StardewRule:
return (self.can_mine_perfectly() &
self.can_reach_region(Region.skull_cavern))
def can_farm_perfectly(self) -> StardewRule:
tool_rule = self.has_tool(Tool.hoe, ToolMaterial.iridium) & self.can_water(4)
return tool_rule & self.has_farming_level(10)
def can_fish_perfectly(self) -> StardewRule:
skill_rule = self.has_skill_level(Skill.fishing, 10)
return skill_rule & self.has_max_fishing_rod()
def can_chop_trees(self) -> StardewRule:
return self.has_tool(Tool.axe) & self.can_reach_region(Region.forest)
def can_chop_perfectly(self) -> StardewRule:
magic_rule = (magic.can_use_clear_debris_instead_of_tool_level(self, 3)) & self.has_skill_level(ModSkill.magic, 10)
tool_rule = self.has_tool(Tool.axe, ToolMaterial.iridium)
foraging_rule = self.has_skill_level(Skill.foraging, 10)
region_rule = self.can_reach_region(Region.forest)
return region_rule & ((tool_rule & foraging_rule) | magic_rule)
def has_max_buffs(self) -> StardewRule:
return self.received(Buff.movement, self.options.movement_buff_number.value) & self.received(Buff.luck, self.options.luck_buff_number.value)
def get_weapon_rule_for_floor_tier(self, tier: int):
if tier >= 4:
return self.can_do_combat_at_level(Performance.galaxy)
if tier >= 3:
return self.can_do_combat_at_level(Performance.great)
if tier >= 2:
return self.can_do_combat_at_level(Performance.good)
if tier >= 1:
return self.can_do_combat_at_level(Performance.decent)
return self.can_do_combat_at_level(Performance.basic)
def can_progress_in_the_mines_from_floor(self, floor: int) -> StardewRule:
tier = int(floor / 40)
rules = []
weapon_rule = self.get_weapon_rule_for_floor_tier(tier)
rules.append(weapon_rule)
if self.options.tool_progression == ToolProgression.option_progressive:
rules.append(self.has_tool(Tool.pickaxe, ToolMaterial.tiers[tier]))
if self.options.skill_progression == SkillProgression.option_progressive:
combat_tier = min(10, max(0, tier * 2))
rules.append(self.has_skill_level(Skill.combat, combat_tier))
return And(rules)
def can_progress_easily_in_the_mines_from_floor(self, floor: int) -> StardewRule:
tier = int(floor / 40) + 1
rules = []
weapon_rule = self.get_weapon_rule_for_floor_tier(tier)
rules.append(weapon_rule)
if self.options.tool_progression == ToolProgression.option_progressive:
rules.append(self.has_tool(Tool.pickaxe, ToolMaterial.tiers[tier]))
if self.options.skill_progression == SkillProgression.option_progressive:
combat_tier = min(10, max(0, tier * 2))
rules.append(self.has_skill_level(Skill.combat, combat_tier))
return And(rules)
def has_mine_elevator_to_floor(self, floor: int) -> StardewRule:
if self.options.elevator_progression != ElevatorProgression.option_vanilla:
return self.received("Progressive Mine Elevator", count=int(floor / 5))
return True_()
def can_mine_to_floor(self, floor: int) -> StardewRule:
previous_elevator = max(floor - 5, 0)
previous_previous_elevator = max(floor - 10, 0)
return ((self.has_mine_elevator_to_floor(previous_elevator) &
self.can_progress_in_the_mines_from_floor(previous_elevator)) |
(self.has_mine_elevator_to_floor(previous_previous_elevator) &
self.can_progress_easily_in_the_mines_from_floor(previous_previous_elevator)))
def can_progress_in_the_skull_cavern_from_floor(self, floor: int) -> StardewRule:
tier = floor // 50
rules = []
weapon_rule = self.has_great_weapon()
rules.append(weapon_rule)
rules.append(self.can_cook())
if self.options.tool_progression == ToolProgression.option_progressive:
rules.append(self.received("Progressive Pickaxe", min(4, max(0, tier + 2))))
if self.options.skill_progression == SkillProgression.option_progressive:
skill_tier = min(10, max(0, tier * 2 + 6))
rules.extend({self.has_skill_level(Skill.combat, skill_tier),
self.has_skill_level(Skill.mining, skill_tier)})
return And(rules)
def can_progress_easily_in_the_skull_cavern_from_floor(self, floor: int) -> StardewRule:
return self.can_progress_in_the_skull_cavern_from_floor(floor + 50)
def can_mine_to_skull_cavern_floor(self, floor: int) -> StardewRule:
previous_elevator = max(floor - 25, 0)
previous_previous_elevator = max(floor - 50, 0)
has_mine_elevator = self.has_mine_elevator_to_floor(5) # Skull Cavern Elevator menu needs a normal elevator...
return ((has_skull_cavern_elevator_to_floor(self, previous_elevator) &
self.can_progress_in_the_skull_cavern_from_floor(previous_elevator)) |
(has_skull_cavern_elevator_to_floor(self, previous_previous_elevator) &
self.can_progress_easily_in_the_skull_cavern_from_floor(previous_previous_elevator))) & has_mine_elevator
def has_jotpk_power_level(self, power_level: int) -> StardewRule:
if self.options.arcade_machine_locations != ArcadeMachineLocations.option_full_shuffling:
return True_()
jotpk_buffs = ["JotPK: Progressive Boots", "JotPK: Progressive Gun",
"JotPK: Progressive Ammo", "JotPK: Extra Life", "JotPK: Increased Drop Rate"]
return self.received(jotpk_buffs, power_level)
def has_junimo_kart_power_level(self, power_level: int) -> StardewRule:
if self.options.arcade_machine_locations != ArcadeMachineLocations.option_full_shuffling:
return True_()
return self.received("Junimo Kart: Extra Life", power_level)
def has_junimo_kart_max_level(self) -> StardewRule:
play_rule = self.can_reach_region(Region.junimo_kart_3)
if self.options.arcade_machine_locations != ArcadeMachineLocations.option_full_shuffling:
return play_rule
return self.has_junimo_kart_power_level(8)
def has_traveling_merchant(self, tier: int = 1):
traveling_merchant_days = [f"Traveling Merchant: {day}" for day in Weekday.all_days]
return self.received(traveling_merchant_days, tier)
def can_get_married(self) -> StardewRule:
return self.has_relationship(Generic.bachelor, 10) & self.has(Gift.mermaid_pendant)
def has_children(self, number_children: int) -> StardewRule:
if number_children <= 0:
return True_()
possible_kids = ["Cute Baby", "Ugly Baby"]
return self.received(possible_kids, number_children) & self.has_house(2)
def can_reproduce(self, number_children: int = 1) -> StardewRule:
if number_children <= 0:
return True_()
return self.can_get_married() & self.has_house(2) & self.has_relationship(Generic.bachelor, 12) & self.has_children(number_children - 1)
def has_relationship(self, npc: str, hearts: int = 1) -> StardewRule:
if hearts <= 0:
return True_()
friendsanity = self.options.friendsanity
if friendsanity == Friendsanity.option_none:
return self.can_earn_relationship(npc, hearts)
if npc not in all_villagers_by_name:
if npc == NPC.pet:
if friendsanity == Friendsanity.option_bachelors:
return self.can_befriend_pet(hearts)
return self.received_hearts(NPC.pet, hearts)
if npc == Generic.any or npc == Generic.bachelor:
possible_friends = []
for name in all_villagers_by_name:
if not self.npc_is_in_current_slot(name):
continue
if npc == Generic.any or all_villagers_by_name[name].bachelor:
possible_friends.append(self.has_relationship(name, hearts))
return Or(possible_friends)
if npc == Generic.all:
mandatory_friends = []
for name in all_villagers_by_name:
if not self.npc_is_in_current_slot(name):
continue
mandatory_friends.append(self.has_relationship(name, hearts))
return And(mandatory_friends)
if npc.isnumeric():
possible_friends = []
for name in all_villagers_by_name:
if not self.npc_is_in_current_slot(name):
continue
possible_friends.append(self.has_relationship(name, hearts))
return Count(int(npc), possible_friends)
return self.can_earn_relationship(npc, hearts)
if not self.npc_is_in_current_slot(npc):
return True_()
villager = all_villagers_by_name[npc]
if friendsanity == Friendsanity.option_bachelors and not villager.bachelor:
return self.can_earn_relationship(npc, hearts)
if friendsanity == Friendsanity.option_starting_npcs and not villager.available:
return self.can_earn_relationship(npc, hearts)
is_capped_at_8 = villager.bachelor and friendsanity != Friendsanity.option_all_with_marriage
if is_capped_at_8 and hearts > 8:
return self.received_hearts(villager, 8) & self.can_earn_relationship(npc, hearts)
return self.received_hearts(villager, hearts)
def received_hearts(self, npc: Union[str, Villager], hearts: int) -> StardewRule:
if isinstance(npc, Villager):
return self.received_hearts(npc.name, hearts)
heart_size = self.options.friendsanity_heart_size.value
return self.received(self.heart(npc), math.ceil(hearts / heart_size))
def can_meet(self, npc: str) -> StardewRule:
if npc not in all_villagers_by_name or not self.npc_is_in_current_slot(npc):
return True_()
villager = all_villagers_by_name[npc]
rules = [self.can_reach_any_region(villager.locations)]
if npc == NPC.kent:
rules.append(self.has_year_two())
elif npc == NPC.leo:
rules.append(self.received("Island West Turtle"))
return And(rules)
def can_give_loved_gifts_to_everyone(self) -> StardewRule:
rules = []
for npc in all_villagers_by_name:
if not self.npc_is_in_current_slot(npc):
continue
villager = all_villagers_by_name[npc]
gift_rule = self.has_any_universal_love()
meet_rule = self.can_meet(npc)
rules.append(meet_rule & gift_rule)
loved_gifts_rules = And(rules)
simplified_rules = loved_gifts_rules.simplify()
return simplified_rules
def can_earn_relationship(self, npc: str, hearts: int = 0) -> StardewRule:
if hearts <= 0:
return True_()
heart_size = self.options.friendsanity_heart_size.value
previous_heart = hearts - heart_size
previous_heart_rule = self.has_relationship(npc, previous_heart)
if npc == NPC.pet:
earn_rule = self.can_befriend_pet(hearts)
elif npc == NPC.wizard and ModNames.magic in self.options.mods:
earn_rule = self.can_meet(npc) & self.has_lived_months(hearts)
elif npc in all_villagers_by_name:
if not self.npc_is_in_current_slot(npc):
return previous_heart_rule
villager = all_villagers_by_name[npc]
rule_if_birthday = self.has_season(villager.birthday) & self.has_any_universal_love() & self.has_lived_months(hearts // 2)
rule_if_not_birthday = self.has_lived_months(hearts)
earn_rule = self.can_meet(npc) & (rule_if_birthday | rule_if_not_birthday)
if villager.bachelor:
if hearts > 8:
earn_rule = earn_rule & self.can_date(npc)
if hearts > 10:
earn_rule = earn_rule & self.can_marry(npc)
else:
earn_rule = self.has_lived_months(min(hearts // 2, 8))
return previous_heart_rule & earn_rule
def can_date(self, npc: str) -> StardewRule:
return self.has_relationship(npc, 8) & self.has(Gift.bouquet)
def can_marry(self, npc: str) -> StardewRule:
return self.has_relationship(npc, 10) & self.has(Gift.mermaid_pendant)
def can_befriend_pet(self, hearts: int):
if hearts <= 0:
return True_()
points = hearts * 200
points_per_month = 12 * 14
points_per_water_month = 18 * 14
return self.can_reach_region(Region.farm) & \
((self.can_water(0) & self.has_lived_months(points // points_per_water_month)) |
self.has_lived_months(points // points_per_month))
def can_complete_bundle(self, bundle_requirements: List[BundleItem], number_required: int) -> StardewRule:
item_rules = []
highest_quality_yet = 0
can_speak_junimo = self.can_reach_region(Region.wizard_tower)
for bundle_item in bundle_requirements:
if bundle_item.item.item_id == -1:
return can_speak_junimo & self.can_spend_money(bundle_item.amount)
else:
item_rules.append(bundle_item.item.name)
if bundle_item.quality > highest_quality_yet:
highest_quality_yet = bundle_item.quality
return can_speak_junimo & self.has(item_rules, number_required) & self.can_grow_gold_quality(highest_quality_yet)
def can_grow_gold_quality(self, quality: int) -> StardewRule:
if quality <= 0:
return True_()
if quality == 1:
return self.has_farming_level(5) | (self.has_fertilizer(1) & self.has_farming_level(2)) | (
self.has_fertilizer(2) & self.has_farming_level(1)) | self.has_fertilizer(3)
if quality == 2:
return self.has_farming_level(10) | (self.has_fertilizer(1) & self.has_farming_level(5)) | (
self.has_fertilizer(2) & self.has_farming_level(3)) | (
self.has_fertilizer(3) & self.has_farming_level(2))
if quality >= 3:
return self.has_fertilizer(3) & self.has_farming_level(4)
def has_fertilizer(self, tier: int) -> StardewRule:
if tier <= 0:
return True_()
if tier == 1:
return self.has(Fertilizer.basic)
if tier == 2:
return self.has(Fertilizer.quality)
if tier >= 3:
return self.has(Fertilizer.deluxe)
def can_complete_field_office(self) -> StardewRule:
field_office = self.can_reach_region(Region.field_office)
professor_snail = self.received("Open Professor Snail Cave")
dig_site = self.can_reach_region(Region.dig_site)
tools = self.has_tool(Tool.pickaxe) & self.has_tool(Tool.hoe) & self.has_tool(Tool.scythe)
leg_and_snake_skull = dig_site
ribs_and_spine = self.can_reach_region(Region.island_south)
skull = self.can_open_geode(Geode.golden_coconut)
tail = self.can_do_panning() & dig_site
frog = self.can_reach_region(Region.island_east)
bat = self.can_reach_region(Region.volcano_floor_5)
snake_vertebrae = self.can_reach_region(Region.island_west)
return field_office & professor_snail & tools & leg_and_snake_skull & ribs_and_spine & skull & tail & frog & bat & snake_vertebrae
def can_complete_community_center(self) -> StardewRule:
return (self.can_reach_location("Complete Crafts Room") &
self.can_reach_location("Complete Pantry") &
self.can_reach_location("Complete Fish Tank") &
self.can_reach_location("Complete Bulletin Board") &
self.can_reach_location("Complete Vault") &
self.can_reach_location("Complete Boiler Room"))
def can_finish_grandpa_evaluation(self) -> StardewRule:
# https://stardewvalleywiki.com/Grandpa
rules_worth_a_point = [self.can_have_earned_total_money(50000), # 50 000g
self.can_have_earned_total_money(100000), # 100 000g
self.can_have_earned_total_money(200000), # 200 000g
self.can_have_earned_total_money(300000), # 300 000g
self.can_have_earned_total_money(500000), # 500 000g
self.can_have_earned_total_money(1000000), # 1 000 000g first point
self.can_have_earned_total_money(1000000), # 1 000 000g second point
self.has_total_skill_level(30), # Total Skills: 30
self.has_total_skill_level(50), # Total Skills: 50
self.can_complete_museum(), # Completing the museum for a point
# Catching every fish not expected
# Shipping every item not expected
self.can_get_married() & self.has_house(2),
self.has_relationship("5", 8), # 5 Friends
self.has_relationship("10", 8), # 10 friends
self.has_relationship(NPC.pet, 5), # Max Pet
self.can_complete_community_center(), # Community Center Completion
self.can_complete_community_center(), # CC Ceremony first point
self.can_complete_community_center(), # CC Ceremony second point
self.received(Wallet.skull_key), # Skull Key obtained
self.has_rusty_key(), # Rusty key obtained
]
return Count(12, rules_worth_a_point)
def has_island_transport(self) -> StardewRule:
return self.received(Transportation.island_obelisk) | self.received(Transportation.boat_repair)
def has_any_weapon(self) -> StardewRule:
return self.has_decent_weapon() | self.received(item.name for item in all_items if Group.WEAPON in item.groups)
def has_decent_weapon(self) -> StardewRule:
return (self.has_good_weapon() |
self.received(item.name for item in all_items
if Group.WEAPON in item.groups and
(Group.MINES_FLOOR_50 in item.groups or Group.MINES_FLOOR_60 in item.groups)))
def has_good_weapon(self) -> StardewRule:
return ((self.has_great_weapon() |
self.received(item.name for item in all_items
if Group.WEAPON in item.groups and
(Group.MINES_FLOOR_80 in item.groups or Group.MINES_FLOOR_90 in item.groups))) &
self.received("Adventurer's Guild"))
def has_great_weapon(self) -> StardewRule:
return ((self.has_galaxy_weapon() |
self.received(item.name for item in all_items
if Group.WEAPON in item.groups and Group.MINES_FLOOR_110 in item.groups)) &
self.received("Adventurer's Guild"))
def has_galaxy_weapon(self) -> StardewRule:
return (self.received(item.name for item in all_items
if Group.WEAPON in item.groups and Group.GALAXY_WEAPONS in item.groups) &
self.received("Adventurer's Guild"))
def has_year_two(self) -> StardewRule:
return self.has_lived_months(4)
def has_year_three(self) -> StardewRule:
return self.has_lived_months(8)
def can_speak_dwarf(self) -> StardewRule:
return self.received("Dwarvish Translation Guide")
def can_donate_museum_item(self, item: MuseumItem) -> StardewRule:
return self.can_reach_region(Region.museum) & self.can_find_museum_item(item)
def can_donate_museum_items(self, number: int) -> StardewRule:
return self.can_reach_region(Region.museum) & self.can_find_museum_items(number)
def can_donate_museum_artifacts(self, number: int) -> StardewRule:
return self.can_reach_region(Region.museum) & self.can_find_museum_artifacts(number)
def can_donate_museum_minerals(self, number: int) -> StardewRule:
return self.can_reach_region(Region.museum) & self.can_find_museum_minerals(number)
def can_find_museum_item(self, item: MuseumItem) -> StardewRule:
region_rule = self.can_reach_all_regions_except_one(item.locations)
geodes_rule = And([self.can_open_geode(geode) for geode in item.geodes])
# monster_rule = self.can_farm_monster(item.monsters)
# extra_rule = True_()
pan_rule = False_()
if item.name == "Earth Crystal" or item.name == "Fire Quartz" or item.name == "Frozen Tear":
pan_rule = self.can_do_panning()
return pan_rule | (region_rule & geodes_rule) # & monster_rule & extra_rule
def can_find_museum_artifacts(self, number: int) -> StardewRule:
rules = []
for artifact in all_museum_artifacts:
rules.append(self.can_find_museum_item(artifact))
return Count(number, rules)
def can_find_museum_minerals(self, number: int) -> StardewRule:
rules = []
for mineral in all_museum_minerals:
rules.append(self.can_find_museum_item(mineral))
return Count(number, rules)
def can_find_museum_items(self, number: int) -> StardewRule:
rules = []
for donation in all_museum_items:
rules.append(self.can_find_museum_item(donation))
return Count(number, rules)
def can_complete_museum(self) -> StardewRule:
rules = [self.can_reach_region(Region.museum), self.can_mine_perfectly()]
if self.options.museumsanity != Museumsanity.option_none:
rules.append(self.received("Traveling Merchant Metal Detector", 4))
for donation in all_museum_items:
rules.append(self.can_find_museum_item(donation))
return And(rules)
def has_season(self, season: str) -> StardewRule:
if season == Generic.any:
return True_()
seasons_order = [Season.spring, Season.summer, Season.fall, Season.winter]
if self.options.season_randomization == SeasonRandomization.option_progressive:
return self.received(Season.progressive, seasons_order.index(season))
if self.options.season_randomization == SeasonRandomization.option_disabled:
if season == Season.spring:
return True_()
return self.has_lived_months(1)
return self.received(season)
def has_any_season(self, seasons: Iterable[str]):
if not seasons:
return True_()
return Or([self.has_season(season) for season in seasons])
def has_any_season_not_winter(self):
return self.has_any_season([Season.spring, Season.summer, Season.fall])
def has_all_seasons(self, seasons: Iterable[str]):
if not seasons:
return True_()
return And([self.has_season(season) for season in seasons])
def has_lived_months(self, number: int) -> StardewRule:
number = max(0, min(number, MAX_MONTHS))
return self.received("Month End", number)
def has_rusty_key(self) -> StardewRule:
return self.received(Wallet.rusty_key)
def can_win_egg_hunt(self) -> StardewRule:
number_of_movement_buffs = self.options.movement_buff_number.value
if self.options.festival_locations == FestivalLocations.option_hard or number_of_movement_buffs < 2:
return True_()
return self.received(Buff.movement, number_of_movement_buffs // 2)
def can_succeed_luau_soup(self) -> StardewRule:
if self.options.festival_locations != FestivalLocations.option_hard:
return True_()
eligible_fish = [Fish.blobfish, Fish.crimsonfish, "Ice Pip", Fish.lava_eel, Fish.legend, Fish.angler, Fish.catfish, Fish.glacierfish,
Fish.mutant_carp, Fish.spookfish, Fish.stingray, Fish.sturgeon, "Super Cucumber"]
fish_rule = [self.has(fish) for fish in eligible_fish]
eligible_kegables = [Fruit.ancient_fruit, Fruit.apple, Fruit.banana, Forageable.coconut, Forageable.crystal_fruit, Fruit.mango,
Fruit.melon, Fruit.orange, Fruit.peach, Fruit.pineapple, Fruit.pomegranate, Fruit.rhubarb,
Fruit.starfruit, Fruit.strawberry, Forageable.cactus_fruit,
Fruit.cherry, Fruit.cranberries, Fruit.grape, Forageable.spice_berry, Forageable.wild_plum, Vegetable.hops, Vegetable.wheat]
keg_rules = [self.can_keg(kegable) for kegable in eligible_kegables]
aged_rule = [self.can_age(rule, "Iridium") for rule in keg_rules]
# There are a few other valid items but I don't feel like coding them all
return Or(fish_rule) | Or(aged_rule)
def can_succeed_grange_display(self) -> StardewRule:
if self.options.festival_locations != FestivalLocations.option_hard:
return True_()
animal_rule = self.has_animal(Generic.any)
artisan_rule = self.can_keg(Generic.any) | self.can_preserves_jar(Generic.any)
cooking_rule = True_() # Salads at the bar are good enough
fish_rule = self.can_fish(50)
forage_rule = True_() # Hazelnut always available since the grange display is in fall
mineral_rule = self.can_open_geode(Generic.any) # More than half the minerals are good enough
good_fruits = [Fruit.apple, Fruit.banana, Forageable.coconut, Forageable.crystal_fruit, Fruit.mango, Fruit.orange, Fruit.peach,
Fruit.pomegranate,
Fruit.strawberry, Fruit.melon, Fruit.rhubarb, Fruit.pineapple, Fruit.ancient_fruit, Fruit.starfruit, ]
fruit_rule = Or([self.has(fruit) for fruit in good_fruits])
good_vegetables = [Vegetable.amaranth, Vegetable.artichoke, Vegetable.beet, Vegetable.cauliflower, Forageable.fiddlehead_fern, Vegetable.kale,
Vegetable.radish, Vegetable.taro_root, Vegetable.yam, Vegetable.red_cabbage, Vegetable.pumpkin]
vegetable_rule = Or([self.has(vegetable) for vegetable in good_vegetables])
return animal_rule & artisan_rule & cooking_rule & fish_rule & \
forage_rule & fruit_rule & mineral_rule & vegetable_rule
def can_win_fishing_competition(self) -> StardewRule:
return self.can_fish(60)
def has_any_universal_love(self) -> StardewRule:
return self.has(Gift.golden_pumpkin) | self.has("Magic Rock Candy") | self.has(Gift.pearl) | self.has(
"Prismatic Shard") | self.has(AnimalProduct.rabbit_foot)
def has_jelly(self) -> StardewRule:
return self.can_preserves_jar(Fruit.any)
def has_pickle(self) -> StardewRule:
return self.can_preserves_jar(Vegetable.any)
def can_preserves_jar(self, item: str) -> StardewRule:
machine_rule = self.has(Machine.preserves_jar)
if item == Generic.any:
return machine_rule
if item == Fruit.any:
return machine_rule & self.has(all_fruits, 1)
if item == Vegetable.any:
return machine_rule & self.has(all_vegetables, 1)
return machine_rule & self.has(item)
def has_wine(self) -> StardewRule:
return self.can_keg(Fruit.any)
def has_juice(self) -> StardewRule:
return self.can_keg(Vegetable.any)
def can_keg(self, item: str) -> StardewRule:
machine_rule = self.has(Machine.keg)
if item == Generic.any:
return machine_rule
if item == Fruit.any:
return machine_rule & self.has(all_fruits, 1)
if item == Vegetable.any:
return machine_rule & self.has(all_vegetables, 1)
return machine_rule & self.has(item)
def can_age(self, item: Union[str, StardewRule], quality: str) -> StardewRule:
months = 1
if quality == "Gold":
months = 2
elif quality == "Iridium":
months = 3
if isinstance(item, str):
rule = self.has(item)
else:
rule: StardewRule = item
return self.has(Machine.cask) & self.has_lived_months(months) & rule
def can_buy_animal(self, animal: str) -> StardewRule:
price = 0
building = ""
if animal == Animal.chicken:
price = 800
building = Building.coop
elif animal == Animal.cow:
price = 1500
building = Building.barn
elif animal == Animal.goat:
price = 4000
building = Building.big_barn
elif animal == Animal.duck:
price = 1200
building = Building.big_coop
elif animal == Animal.sheep:
price = 8000
building = Building.deluxe_barn
elif animal == Animal.rabbit:
price = 8000
building = Building.deluxe_coop
elif animal == Animal.pig:
price = 16000
building = Building.deluxe_barn
else:
return True_()
return self.can_spend_money_at(Region.ranch, price) & self.has_building(building)
def has_animal(self, animal: str) -> StardewRule:
if animal == Generic.any:
return self.has_any_animal()
elif animal == Building.coop:
return self.has_any_coop_animal()
elif animal == Building.barn:
return self.has_any_barn_animal()
return self.has(animal)
def has_happy_animal(self, animal: str) -> StardewRule:
return self.has_animal(animal) & self.has(Forageable.hay)
def has_any_animal(self) -> StardewRule:
return self.has_any_coop_animal() | self.has_any_barn_animal()
def has_any_coop_animal(self) -> StardewRule:
coop_rule = Or([self.has_animal(coop_animal) for coop_animal in coop_animals])
return coop_rule
def has_any_barn_animal(self) -> StardewRule:
barn_rule = Or([self.has_animal(barn_animal) for barn_animal in barn_animals])
return barn_rule
def can_open_geode(self, geode: str) -> StardewRule:
blacksmith_access = self.can_reach_region("Clint's Blacksmith")
geodes = [Geode.geode, Geode.frozen, Geode.magma, Geode.omni]
if geode == Generic.any:
return blacksmith_access & Or([self.has(geode_type) for geode_type in geodes])
return blacksmith_access & self.has(geode)
def has_island_trader(self) -> StardewRule:
if self.options.exclude_ginger_island == ExcludeGingerIsland.option_true:
return False_()
return self.can_reach_region(Region.island_trader)
def has_walnut(self, number: int) -> StardewRule:
if self.options.exclude_ginger_island == ExcludeGingerIsland.option_true:
return False_()
if number <= 0:
return True_()
# https://stardewcommunitywiki.com/Golden_Walnut#Walnut_Locations
reach_south = self.can_reach_region(Region.island_south)
reach_north = self.can_reach_region(Region.island_north)
reach_west = self.can_reach_region(Region.island_west)
reach_hut = self.can_reach_region(Region.leo_hut)
reach_southeast = self.can_reach_region(Region.island_south_east)
reach_field_office = self.can_reach_region(Region.field_office)
reach_pirate_cove = self.can_reach_region(Region.pirate_cove)
reach_outside_areas = And(reach_south, reach_north, reach_west, reach_hut)
reach_volcano_regions = [self.can_reach_region(Region.volcano),
self.can_reach_region(Region.volcano_secret_beach),
self.can_reach_region(Region.volcano_floor_5),
self.can_reach_region(Region.volcano_floor_10)]
reach_volcano = Or(reach_volcano_regions)
reach_all_volcano = And(reach_volcano_regions)
reach_walnut_regions = [reach_south, reach_north, reach_west, reach_volcano, reach_field_office]
reach_caves = And(self.can_reach_region(Region.qi_walnut_room), self.can_reach_region(Region.dig_site),
self.can_reach_region(Region.gourmand_frog_cave),
self.can_reach_region(Region.colored_crystals_cave),
self.can_reach_region(Region.shipwreck), self.has(Weapon.any_slingshot))
reach_entire_island = And(reach_outside_areas, reach_field_office, reach_all_volcano,
reach_caves, reach_southeast, reach_pirate_cove)
if number <= 5:
return Or(reach_south, reach_north, reach_west, reach_volcano)
if number <= 10:
return Count(2, reach_walnut_regions)
if number <= 15:
return Count(3, reach_walnut_regions)
if number <= 20:
return And(reach_walnut_regions)
if number <= 50:
return reach_entire_island
gems = [Mineral.amethyst, Mineral.aquamarine, Mineral.emerald, Mineral.ruby, Mineral.topaz]
return reach_entire_island & self.has(Fruit.banana) & self.has(gems) & self.can_mine_perfectly() & \
self.can_fish_perfectly() & self.has(Craftable.flute_block) & self.has(Seed.melon) & self.has(Seed.wheat) & self.has(Seed.garlic) & \
self.can_complete_field_office()
def has_everything(self, all_progression_items: Set[str]) -> StardewRule:
all_regions = [region.name for region in vanilla_regions]
rules = self.received(all_progression_items, len(all_progression_items)) & \
self.can_reach_all_regions(all_regions)
return rules
def heart(self, npc: Union[str, Villager]) -> str:
if isinstance(npc, str):
return f"{npc} <3"
return self.heart(npc.name)
def can_forage(self, season: str, region: str = Region.forest, need_hoe: bool = False) -> StardewRule:
season_rule = self.has_season(season)
region_rule = self.can_reach_region(region)
if need_hoe:
return season_rule & region_rule & self.has_tool(Tool.hoe)
return season_rule & region_rule
def npc_is_in_current_slot(self, name: str) -> bool:
npc = all_villagers_by_name[name]
mod = npc.mod_name
return mod is None or mod in self.options.mods
def can_do_combat_at_level(self, level: str) -> StardewRule:
if level == Performance.basic:
return self.has_any_weapon() | magic.has_any_spell(self)
if level == Performance.decent:
return self.has_decent_weapon() | magic.has_decent_spells(self)
if level == Performance.good:
return self.has_good_weapon() | magic.has_good_spells(self)
if level == Performance.great:
return self.has_great_weapon() | magic.has_great_spells(self)
if level == Performance.galaxy:
return self.has_galaxy_weapon() | magic.has_amazing_spells(self)
def can_water(self, level: int) -> StardewRule:
tool_rule = self.has_tool(Tool.watering_can, ToolMaterial.tiers[level])
spell_rule = (self.received(MagicSpell.water) & magic.can_use_altar(self) & self.has_skill_level(ModSkill.magic, level))
return tool_rule | spell_rule
def has_prismatic_jelly_reward_access(self) -> StardewRule:
if self.options.special_order_locations == SpecialOrderLocations.option_disabled:
return self.can_complete_special_order("Prismatic Jelly")
return self.received("Monster Musk Recipe")
def has_all_rarecrows(self) -> StardewRule:
rules = []
for rarecrow_number in range(1, 9):
rules.append(self.received(f"Rarecrow #{rarecrow_number}"))
return And(rules)
def can_ship(self, item: str = "") -> StardewRule:
shipping_bin_rule = self.has_building(Building.shipping_bin)
if item == "":
return shipping_bin_rule
return shipping_bin_rule & self.has(item)
Reference in New Issue View Git Blame Copy Permalink