Files
Grinch-AP/worlds/stardew_valley/logic/tool_logic.py
Jérémie Bolduc ee9bcb84b7 Stardew Valley: Move progressive tool options handling in features (#4374)
* create tool progression feature and unwrap option

* replace option usage with calling feature

* add comment explaining why some logic is a weird place

* replace item creation logic with feature

* self review and add unit tests

* rename test cuz I named them too long

* add a test for the trash can useful stuff cuz I thought there was a bug but turns out it works

* self review again

* remove price_multiplier, turns out it's unused during generation

* damn it 3.11 why are you like this

* use blacksmith region when checking vanilla tools

* fix rule

* move can mine using in tool logic

* remove changes to performance test

* properly set the option I guess

* properly set options 2

* that's what happen when you code too late
2025-03-08 11:19:29 -05:00

118 lines
4.8 KiB
Python

from typing import Union, Iterable, Tuple
from Utils import cache_self1
from .base_logic import BaseLogicMixin, BaseLogic
from .has_logic import HasLogicMixin
from .money_logic import MoneyLogicMixin
from .received_logic import ReceivedLogicMixin
from .region_logic import RegionLogicMixin
from .season_logic import SeasonLogicMixin
from ..mods.logic.magic_logic import MagicLogicMixin
from ..stardew_rule import StardewRule, True_, False_
from ..strings.ap_names.skill_level_names import ModSkillLevel
from ..strings.region_names import Region, LogicRegion
from ..strings.spells import MagicSpell
from ..strings.tool_names import ToolMaterial, Tool, APTool
fishing_rod_prices = {
3: 1800,
4: 7500,
}
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
}
class ToolLogicMixin(BaseLogicMixin):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.tool = ToolLogic(*args, **kwargs)
class ToolLogic(BaseLogic[Union[ToolLogicMixin, HasLogicMixin, ReceivedLogicMixin, RegionLogicMixin, SeasonLogicMixin, MoneyLogicMixin, MagicLogicMixin]]):
def has_all_tools(self, tools: Iterable[Tuple[str, str]]):
return self.logic.and_(*(self.logic.tool.has_tool(tool, material) for tool, material in tools))
# Should be cached
def has_tool(self, tool: str, material: str = ToolMaterial.basic) -> StardewRule:
if tool == Tool.fishing_rod:
return self.logic.tool.has_fishing_rod(tool_materials[material])
if tool == Tool.pan and material == ToolMaterial.basic:
material = ToolMaterial.copper # The first Pan is the copper one, so the basic one does not exist
if material == ToolMaterial.basic or tool == Tool.scythe:
return True_()
if self.content.features.tool_progression.is_progressive:
return self.logic.received(f"Progressive {tool}", tool_materials[material])
can_upgrade_rule = self.logic.tool._can_purchase_upgrade(material)
if tool == Tool.pan:
has_base_pan = self.logic.received("Glittering Boulder Removed") & self.logic.region.can_reach(Region.mountain)
if material == ToolMaterial.copper:
return has_base_pan
return has_base_pan & can_upgrade_rule
return can_upgrade_rule
@cache_self1
def can_mine_using(self, material: str) -> StardewRule:
if material == ToolMaterial.basic:
return self.logic.true_
if self.content.features.tool_progression.is_progressive:
return self.logic.received(APTool.pickaxe, tool_materials[material])
else:
return self.logic.tool._can_purchase_upgrade(material)
@cache_self1
def _can_purchase_upgrade(self, material: str) -> StardewRule:
return self.logic.region.can_reach(LogicRegion.blacksmith_upgrade(material))
def can_use_tool_at(self, tool: str, material: str, region: str) -> StardewRule:
return self.has_tool(tool, material) & self.logic.region.can_reach(region)
@cache_self1
def has_fishing_rod(self, level: int) -> StardewRule:
assert 1 <= level <= 4, "Fishing rod 0 isn't real, it can't hurt you. Training is 1, Bamboo is 2, Fiberglass is 3 and Iridium is 4."
if self.content.features.tool_progression.is_progressive:
return self.logic.received(APTool.fishing_rod, level)
if level <= 2:
# We assume you always have access to the Bamboo pole, because mod side there is a builtin way to get it back.
return self.logic.region.can_reach(Region.beach)
return self.logic.money.can_spend_at(Region.fish_shop, fishing_rod_prices[level])
# Should be cached
def can_forage(self, season: Union[str, Iterable[str]], region: str = Region.forest, need_hoe: bool = False) -> StardewRule:
season_rule = False_()
if isinstance(season, str):
season_rule = self.logic.season.has(season)
elif isinstance(season, Iterable):
season_rule = self.logic.season.has_any(season)
region_rule = self.logic.region.can_reach(region)
if need_hoe:
return season_rule & region_rule & self.logic.tool.has_tool(Tool.hoe)
return season_rule & region_rule
@cache_self1
def can_water(self, level: int) -> StardewRule:
tool_rule = self.logic.tool.has_tool(Tool.watering_can, ToolMaterial.tiers[level])
spell_rule = self.logic.received(MagicSpell.water) & self.logic.magic.can_use_altar() & self.logic.received(ModSkillLevel.magic_level, level)
return tool_rule | spell_rule