fix: keep automatic cultivation on one stable primary per species

This commit is contained in:
AttilaNet
2026-11-13 08:51:03 +08:00
parent 01ad2e3ab9
commit 4fbe895999
35 changed files with 2069 additions and 322 deletions
@@ -1,6 +1,8 @@
import copy
import json
import time
import unittest
from unittest.mock import patch
from ranch_assistant.breakthrough import POTENTIAL_PATH
from ranch_assistant.engine import Engine
@@ -20,6 +22,17 @@ def raw(catalog):
return value
def species_monster(catalog, mid, grades, *, level=10, species=1030010, **values):
row = catalog.monster(species)
mon = {"id": mid, "typeId": species, "process": 3, "mode": 2, "level": level,
"exp": 0, "potentialLevel": 2, "tpLevel": 4, "tpExp": 9999,
"feel": 0, "giftTime": 0, "entangleLevel": 0, "lock": 0, "roomId": 1}
for stat, grade in zip(("atk", "def", "hp", "dex"), grades):
low, high = row[stat + "_grow_min"], row[stat + "_grow_max"]
mon["g" + stat.capitalize()] = low + (high - low) * {"C": .1, "B": .375, "A": .625, "S": .9}[grade]
return mon | values
class FakeClient:
def __init__(self, value):
self.value, self.calls = value, []
@@ -35,18 +48,170 @@ class FakeClient:
return copy.deepcopy(self.response)
class StatefulRanchClient(FakeClient):
def call(self, path, payload):
super().call(path, copy.deepcopy(payload))
monsters = {int(mon["id"]): mon for mon in self.value["monsters"]}
removed = []
if path == "monsterService/monsterSell":
removed = payload["monsterIds"]
elif path == "stackService/stackTransferMonster":
for data in payload["datas"]:
for mid in data["monsterId"]:
monsters[mid].update(process=3, roomId=data["roomId"])
for stack in self.value["stacks"]:
if stack.get("monsterId") == mid:
stack["monsterId"] = 0
elif path == "monsterService/monsterIntensify":
removed = payload["foods"]
elif path == "monsterService/monsterSendGift":
mon = monsters[payload["monsterId"]]
mon.update(feel=int(mon.get("feel") or 0) + 1, giftTime=int(time.time() * 1000))
return {"feel": mon["feel"], "giftDate": mon["giftTime"]}
elif path == POTENTIAL_PATH:
mon = monsters[payload["monId"]]
stat = "p" + payload["monsterAttr"].capitalize()
mon[stat] += 1
else:
raise AssertionError(f"Unexpected offline ranch operation: {path}")
self.value["monsters"] = [mon for mon in self.value["monsters"] if mon["id"] not in removed]
for stack in self.value["stacks"]:
if stack.get("monsterId") in removed:
stack["monsterId"] = 0
return {"resCode": 0}
class RanchAutomationIntegrationTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.catalog = Catalog()
def engine(self, folder, value=None):
client = FakeClient(value or raw(self.catalog))
def engine(self, folder, value=None, client_type=FakeClient):
client = client_type(value or raw(self.catalog))
engine = Engine(self.catalog, client, folder / "budget.json")
engine.master_sync.settle = lambda *args: None
engine.settle_pending_growth = lambda *args, **kwargs: False
return engine, client
def test_screenshot_lv20_sass_primary_never_spends_on_four_lesser_duplicates(self):
primary = species_monster(self.catalog, 900, "SASS", level=20,
pAtk=44, pDef=10, pHp=180, pDex=9)
primary["feel"] = self.catalog.max_feel(primary)
duplicates = [species_monster(self.catalog, 901 + index, grades, level=9 + index % 2,
tpLevel=0, tpExp=0, pAtk=1, pDef=1, pHp=1, pDex=1)
for index, grades in enumerate(("SAAA", "ASAS", "AASS", "AAAS"))]
duplicate_ids = {mon["id"] for mon in duplicates}
cases = [({}, False, {}), ({"900": 1, "901": 2, "902": 3, "903": 4, "904": 5}, False, {}),
({}, True, {}), ({}, False, {"901": 1})]
for feed_targets, manual_gifts, potential_targets in cases:
with self.subTest(feed_targets=feed_targets, manual_gifts=manual_gifts, potential_targets=potential_targets):
with workspace_temp() as folder:
value = raw(self.catalog)
value.update(monsters=copy.deepcopy([primary, *duplicates]),
items=[{"id": 600, "typeId": 30058, "num": 100},
{"id": 601, "typeId": 30005, "num": 10}])
engine, client = self.engine(folder, value, StatefulRanchClient)
engine.policy = Policy(enabled=True, dispatch=True, feed=True, manual_eggs=True,
fill=False, protect_star=4, protect_quality=5, keep_better_quality=False,
egg_rules={"1030010": {"enabled": True, "action": "feed", "keep_count": 1}},
feed_targets=feed_targets, breakthrough_targets=potential_targets,
gift_enabled=manual_gifts, gift_auto_representative=not manual_gifts,
gift_targets={str(mid): mid for mid in duplicate_ids | {900}},
gift_liked_only=False, gift_items={"30005": {"enabled": True}})
engine.planner.managed.update(duplicate_ids | {900})
engine.auto = True
_, plans, _ = engine.poll()
for path, payload in client.calls:
target = payload.get("targetId", payload.get("monsterId", payload.get("monId")))
self.assertNotIn(target, duplicate_ids, (path, payload))
self.assertNotIn(900, payload.get("foods", []) + payload.get("monsterIds", []))
for action in plans:
if action.kind in ("feed", "gift", "potential", "breakthrough"):
target = action.payload.get("targetId", action.payload.get("monsterId", action.payload.get("monId")))
self.assertNotIn(target, duplicate_ids, action)
self.assertIn(900, engine.snapshot.monsters)
def test_existing_enabled_duplicates_cleanup_without_managed_and_preserve_constraints(self):
for constraint in (None, "lock", "sysLock", "equip1", "team", "entangle", "inExploreTeam", "inBuild", "unknown_quality", "active_exploration_team", "active_exploration_team_csv", "stale_targets_high_rarity"):
with self.subTest(constraint=constraint):
with workspace_temp() as folder:
value = raw(self.catalog)
stale_targets = constraint == "stale_targets_high_rarity"
species = next(int(key) for key, row in self.catalog.monsters.items()
if row.get("star") == 5 and not row.get("npc")
and all(row.get(stat + "_grow_min") is not None for stat in ("atk", "def", "hp", "dex"))) if stale_targets else 1030010
rows = [species_monster(self.catalog, 900, "SASS", level=20, species=species)]
rows += [species_monster(self.catalog, mid, "CCCC", species=species) for mid in range(901, 905)]
rows += [species_monster(self.catalog, 950 + index, "CCCC", species=species)
for index, species in enumerate((1030012, 1030013, 1030014))]
value.update(monsters=rows, teams=[])
if constraint == "team":
value["teams"] = [{"monsters": [901]}]
elif constraint in ("active_exploration_team", "active_exploration_team_csv"):
value["exploreTeams"][0].update(status=1,
monsters="901" if constraint.endswith("_csv") else [901], endTime=9999999999999)
elif constraint == "unknown_quality":
rows[1]["gAtk"] = None
elif constraint and not stale_targets:
rows[1][constraint] = 1
engine, client = self.engine(folder, value, StatefulRanchClient)
engine.policy = Policy(manual_eggs=True, fill=False, protect_star=4, protect_quality=5,
keep_better_quality=False, gift_auto_representative=False,
egg_rules={str(species): {"enabled": True, "action": "sell", "keep_count": 0}},
feed_targets={str(mid): mid for mid in range(900, 905)} if stale_targets else {},
gift_targets={str(mid): mid for mid in range(900, 905)} if stale_targets else {},
breakthrough_targets={str(mid): mid for mid in range(900, 905)} if stale_targets else {})
self.assertEqual(engine.planner.managed, set())
engine.auto = True
for _ in range(5):
engine.poll()
expected = {900, 950, 951, 952} | ({901} if constraint and not stale_targets else set())
self.assertEqual(set(engine.snapshot.monsters), expected)
self.assertTrue(client.calls)
self.assertTrue(all(path == "monsterService/monsterSell" for path, _ in client.calls))
if constraint and not stale_targets:
self.assertTrue(engine.planner.statuses.get(901))
if constraint == "lock":
self.assertEqual(engine.snapshot.monsters[901]["lock"], 1)
if constraint in ("active_exploration_team", "active_exploration_team_csv"):
client.value["exploreTeams"][0]["status"] = 0
engine.poll()
self.assertEqual(set(engine.snapshot.monsters), {900, 950, 951, 952})
self.assertEqual(client.calls[-1], ("monsterService/monsterSell", {"monsterIds": [901]}))
def test_successive_quality_backups_replace_before_collect_and_new_mature_ties_dispatch(self):
with workspace_temp() as folder:
value = raw(self.catalog)
room_type = next(key for key, row in self.catalog.data["room_info"].items() if row.get("maxNum", 0) >= 2)
value.update(monsters=[species_monster(self.catalog, 900, "SASS", level=20, lock=1),
species_monster(self.catalog, 901, "SSSA"),
species_monster(self.catalog, 902, "SSSS", level=1, process=2, roomId=None)],
rooms=[{"id": 1, "typeId": int(room_type)}],
stacks=[{"id": 1, "position": 0, "monsterId": 902}])
row = self.catalog.monster(1030010)
for stat, scale in zip(("atk", "def", "hp", "dex"), (.95, .95, .95, .7)):
value["monsters"][1]["g" + stat.capitalize()] = row[stat + "_grow_min"] + scale * (row[stat + "_grow_max"] - row[stat + "_grow_min"])
engine, client = self.engine(folder, value, StatefulRanchClient)
engine.policy = Policy(manual_eggs=True, fill=False, protect_star=4, protect_quality=5,
keep_better_quality=False, gift_auto_representative=False,
egg_rules={"1030010": {"enabled": True, "action": "sell", "keep_count": 4}})
engine.auto = True
with patch.dict(self.catalog.data["room_info"][room_type], {"maxNum": 2}):
engine.poll()
self.assertEqual(client.calls, [("monsterService/monsterSell", {"monsterIds": [901]})])
engine.poll()
self.assertEqual(client.calls[-1], ("stackService/stackTransferMonster",
{"datas": [{"monsterId": [902], "roomId": 1}]}))
self.assertEqual(set(engine.snapshot.monsters), {900, 902})
client.value["monsters"].insert(0,
species_monster(self.catalog, 903, "SSSS", level=1, process=2, roomId=None))
client.value["stacks"][0]["monsterId"] = 903
engine.poll()
self.assertEqual(client.calls[-1], ("monsterService/monsterSell", {"monsterIds": [903]}))
self.assertEqual(set(engine.snapshot.monsters), {900, 902})
engine.poll()
self.assertEqual(len(client.calls), 3)
def test_breakthrough_targets_execute_and_require_new_snapshot_before_repeat(self):
with workspace_temp() as folder:
engine, client = self.engine(folder)