394 lines
21 KiB
Python
394 lines
21 KiB
Python
"""Offline task procurement replay: all writes go to the fake below."""
|
|
from copy import deepcopy
|
|
from pathlib import Path
|
|
import tempfile
|
|
import unittest
|
|
from unittest.mock import patch
|
|
|
|
from ranch_assistant.engine import Engine
|
|
from ranch_assistant.game_data import ProgressionData
|
|
from ranch_assistant.model import Catalog, Policy, Snapshot
|
|
from ranch_assistant.progression import ProgressionPlanner, ProgressionPolicy
|
|
from ranch_assistant.quests import QuestPolicy
|
|
from ranch_assistant.tests.test_progression import config, snapshot, step, task
|
|
|
|
|
|
EGG = "1030010"
|
|
|
|
|
|
def requirement(kind="getMonster", count=1, key=EGG):
|
|
return step(kind, statusValue={"type": key, "num": count, "mode": 2 if kind == "getMonster" else 0, "remove": True})
|
|
|
|
|
|
def monster(catalog, mid, **changes):
|
|
row = catalog.monster(EGG)
|
|
return {"id": mid, "typeId": int(EGG), "mode": 2, "process": 3, "level": 1, "roomId": 1,
|
|
**{"g" + stat.capitalize(): row[stat + "_grow_min"] for stat in ("atk", "def", "hp", "dex")}, **changes}
|
|
|
|
|
|
class OfflineProcurementClient:
|
|
def __init__(self, raw, catalog):
|
|
self.raw, self.catalog, self.writes = deepcopy(raw), catalog, []
|
|
self.timeout = False
|
|
|
|
def snapshot(self):
|
|
return Snapshot(deepcopy(self.raw))
|
|
|
|
def call(self, path, payload):
|
|
self.writes.append((path, deepcopy(payload)))
|
|
if self.timeout:
|
|
raise TimeoutError("offline fake lost reply")
|
|
if path == "gachaService/gachaGetEggs":
|
|
count = payload["num"]
|
|
self.raw["master"]["money"] -= self.catalog.data["markets"][payload["id"]]["money"] * count
|
|
existing = next((i for i in self.raw["items"] if str(i["typeId"]) == EGG), None)
|
|
if existing:
|
|
existing["num"] += count
|
|
else:
|
|
self.raw["items"].append({"id": 500, "typeId": int(EGG), "num": count})
|
|
return {"resCode": 0, "eggs": [{"typeId": int(EGG), "num": count}]}
|
|
if path == "stackService/stackAddMonster":
|
|
for egg in payload["eggs"]:
|
|
item = next(i for i in self.raw["items"] if i["id"] == egg["itemId"])
|
|
item["num"] -= 1
|
|
mid = max([m["id"] for m in self.raw["monsters"]] + [900]) + 1
|
|
self.raw["monsters"].append(monster(self.catalog, mid, mode=0, process=2,
|
|
timeStart=self.snapshot().now * 1000, roomId=0))
|
|
next(s for s in self.raw["stacks"] if s["id"] == egg["stackId"])["monsterId"] = mid
|
|
return {"resCode": 0}
|
|
if path == "stackService/stackTransferMonster":
|
|
for data in payload["datas"]:
|
|
for mid in data["monsterId"]:
|
|
next(m for m in self.raw["monsters"] if m["id"] == mid).update(process=3, roomId=data["roomId"])
|
|
for stack in self.raw["stacks"]:
|
|
if stack["monsterId"] == mid:
|
|
stack["monsterId"] = 0
|
|
return {"resCode": 0}
|
|
if path == "taskService/taskLoopReceive":
|
|
received = {"id": 51, "typeId": payload["taskTypeId"], "curStep": 1}
|
|
self.raw["currentTasks"].append(received)
|
|
self.raw["history"]["loopTaskNum"] -= 1
|
|
return {"resCode": 0, "task": deepcopy(received)}
|
|
if path == "taskService/taskCompleteStep":
|
|
for mid in payload.get("removeIds") or []:
|
|
self.raw["monsters"] = [m for m in self.raw["monsters"] if m["id"] != mid]
|
|
for stack in self.raw["stacks"]:
|
|
if stack["monsterId"] == mid:
|
|
stack["monsterId"] = 0
|
|
next(t for t in self.raw["currentTasks"] if t["id"] == payload["taskId"])["curStep"] += 1
|
|
return {"resCode": 0, "taskStepValue": None}
|
|
if path == "taskService/taskComplete":
|
|
self.raw["currentTasks"] = [t for t in self.raw["currentTasks"] if t["id"] != payload["taskId"]]
|
|
return {"resCode": 0, "reward": {"ke": 20}}
|
|
raise AssertionError("Unexpected fake write: " + path)
|
|
|
|
|
|
class CommissionProcurementTests(unittest.TestCase):
|
|
def setUp(self):
|
|
self.catalog = Catalog()
|
|
# Keep a real gold market and real growth/protection rules; make the
|
|
# offline draw deterministic without asserting real RNG outcomes.
|
|
self.catalog.data["markets"]["sc_city1"]["eggs"] = {"2": [int(EGG)]}
|
|
self.tasks = {"400": task("400", type=4, reward={"ke": 20}, steps=[requirement()]),
|
|
"401": task("401", type=4, reward={"ke": 15})}
|
|
self.data = ProgressionData(config(self.tasks))
|
|
self.raw = snapshot(currentTasks=[]).raw
|
|
self.raw["master"]["money"] = 10000
|
|
self.raw["history"].update(loopTaskTime=snapshot().now, loopTaskNum=4, loopTask={"2": ["400"], "1": ["401"]}, unlockCity={"1": True, "2": True})
|
|
self.raw["stacks"] = [{"id": i + 1, "position": i % 3, "monsterId": 0} for i in range(10)]
|
|
self.quest = QuestPolicy(enabled=True, allow_monsters=True, allow_items=True)
|
|
self.ranch = Policy(buy=True, allow_single_draw=True, buy_batch=5)
|
|
self.folder = tempfile.TemporaryDirectory()
|
|
self.addCleanup(self.folder.cleanup)
|
|
|
|
def engine(self, *, raw=None, folder=None):
|
|
client = OfflineProcurementClient(raw or self.raw, self.catalog)
|
|
engine = Engine(self.catalog, client, Path(folder or self.folder.name) / "budget.json", game_data=self.data)
|
|
engine.snapshot = client.snapshot()
|
|
engine.policy, engine.quest_policy = deepcopy(self.ranch), deepcopy(self.quest)
|
|
engine._refresh_progression_cache(force=True)
|
|
self.assertEqual(engine._progression_error, "")
|
|
return engine, client
|
|
|
|
def sync(self, engine, client):
|
|
engine.snapshot = client.snapshot()
|
|
engine._refresh_progression_cache(force=True)
|
|
|
|
def intent(self, engine):
|
|
return next(i for i in engine._progression_intents if not i.block_reason)
|
|
|
|
def test_cross_city_twenty_buy_hatch_wait_submit_complete_replay(self):
|
|
engine, client = self.engine()
|
|
buy = self.intent(engine)
|
|
self.assertEqual((buy.kind, buy.phase, buy.source_task_type_id), ("progression_procure", "buy", "400"))
|
|
self.assertEqual(buy.payload["num"], 1)
|
|
offer = next(r for r in engine.commission_offer_diagnostics() if r["task_type_id"] == "400")
|
|
self.assertFalse(offer["eligible"])
|
|
self.assertTrue(offer["preparable"])
|
|
self.assertEqual(offer["resources"][0]["available"], 0)
|
|
engine._run_progression_intent(buy)
|
|
self.assertIsNone(engine.battle_journal.pending(engine.snapshot))
|
|
hatch = self.intent(engine)
|
|
self.assertEqual(hatch.phase, "hatch")
|
|
engine._run_progression_intent(hatch)
|
|
self.assertEqual(engine.snapshot.raw["history"]["loopTaskNum"], 4)
|
|
self.assertFalse(any(not i.block_reason for i in engine._progression_intents))
|
|
for _ in range(3):
|
|
self.sync(engine, client)
|
|
self.assertEqual([p for p, _ in client.writes], ["gachaService/gachaGetEggs", "stackService/stackAddMonster"])
|
|
client.raw["monsters"][0].update(mode=2)
|
|
self.sync(engine, client)
|
|
accept = self.intent(engine)
|
|
self.assertEqual((accept.kind, accept.payload["city"]), ("progression_loop_accept", 2))
|
|
engine._run_progression_intent(accept)
|
|
for _ in range(3):
|
|
engine._run_progression_intent(self.intent(engine))
|
|
self.assertEqual(engine.commission_history()["summary"]["confirmed_ke"], 20)
|
|
self.assertEqual(client.raw["history"]["loopTaskNum"], 3)
|
|
|
|
def test_one_missing_ten_empty_slots_thousand_eggs_hatches_only_one(self):
|
|
self.raw["items"] = [{"id": 500, "typeId": int(EGG), "num": 1000}]
|
|
engine, client = self.engine()
|
|
intent = self.intent(engine)
|
|
self.assertEqual(len(intent.payload["eggs"]), 1)
|
|
engine._run_progression_intent(intent)
|
|
self.assertEqual(sum(bool(s["monsterId"]) for s in client.raw["stacks"]), 1)
|
|
self.assertEqual(client.raw["items"][0]["num"], 999)
|
|
self.assertFalse(any(not i.block_reason for i in engine._progression_intents))
|
|
self.assertFalse(any(a.kind in ("buy", "hatch") for a in engine.plans()))
|
|
self.assertEqual(engine.pending_hatches, [])
|
|
|
|
def test_quota_zero_never_procures_or_accepts(self):
|
|
self.raw["history"]["loopTaskNum"] = 0
|
|
engine, client = self.engine()
|
|
engine._run_progression_intent()
|
|
self.assertEqual(client.writes, [])
|
|
self.assertTrue(all(r["reason_kind"] == "quota" and not r["preparable"] for r in engine.commission_offer_diagnostics()))
|
|
|
|
def test_existing_eggs_and_incubator_count_before_buy(self):
|
|
self.tasks["400"]["steps"] = [requirement(count=3)]
|
|
self.raw["items"] = [{"id": 500, "typeId": int(EGG), "num": 1}]
|
|
self.raw["monsters"] = [monster(self.catalog, 901, mode=0, process=2, timeStart=snapshot().now * 1000)]
|
|
self.raw["stacks"][0]["monsterId"] = 901
|
|
engine, client = self.engine()
|
|
engine._run_progression_intent(self.intent(engine)) # reuse the egg
|
|
buy = self.intent(engine)
|
|
self.assertEqual(buy.phase, "buy")
|
|
self.assertEqual(buy.payload["num"], 1)
|
|
engine._run_progression_intent(buy)
|
|
self.assertEqual(sum(p == "gachaService/gachaGetEggs" for p, _ in client.writes), 1)
|
|
|
|
def test_shared_eggs_user_reserve_and_multistep_demands_are_not_double_counted(self):
|
|
self.tasks["400"]["steps"] = [requirement("getItem", 1), requirement("getItem", 1), requirement(count=1)]
|
|
self.raw["items"] = [{"id": 500, "typeId": int(EGG), "num": 5}]
|
|
self.ranch.reserved_eggs = {EGG: 2}
|
|
engine, client = self.engine()
|
|
self.assertEqual(self.intent(engine).phase, "hatch")
|
|
engine._run_progression_intent(self.intent(engine))
|
|
self.assertEqual(client.raw["items"][0]["num"], 4) # 2 task eggs + 2 user reserve
|
|
self.assertFalse(any(not i.block_reason for i in engine._progression_intents))
|
|
self.assertFalse(any(path == "gachaService/gachaGetEggs" for path, _ in client.writes))
|
|
|
|
def test_multistep_adult_removals_cannot_reuse_one_monster(self):
|
|
self.tasks["400"]["steps"] = [requirement(), requirement()]
|
|
self.raw["monsters"] = [monster(self.catalog, 901)]
|
|
engine, _ = self.engine()
|
|
buy = self.intent(engine)
|
|
self.assertEqual(buy.payload["num"], 1)
|
|
self.assertEqual(engine.commission_offer_diagnostics()[0]["resources"][0]["needed"], 2)
|
|
|
|
def test_active_same_species_steps_buy_remaining_deficit_and_advance(self):
|
|
self.tasks["400"]["steps"] = [requirement(), requirement()]
|
|
for cursor in (1, 2):
|
|
with self.subTest(cursor=cursor), tempfile.TemporaryDirectory(dir=self.folder.name) as folder:
|
|
raw = deepcopy(self.raw)
|
|
raw["currentTasks"] = [{"id": 51, "typeId": "400", "curStep": cursor}]
|
|
engine, client = self.engine(raw=raw, folder=folder)
|
|
deficit = 3 - cursor
|
|
buy = self.intent(engine)
|
|
self.assertEqual((buy.kind, buy.phase, buy.source_task_id), ("progression_procure", "buy", 51))
|
|
self.assertEqual(buy.payload["num"], deficit)
|
|
engine._run_progression_intent(buy)
|
|
self.assertEqual(client.writes, [("gachaService/gachaGetEggs", buy.payload)])
|
|
self.assertIsNone(engine.battle_journal.pending(engine.snapshot))
|
|
for _ in range(deficit):
|
|
hatch = self.intent(engine)
|
|
self.assertEqual((hatch.kind, hatch.phase), ("progression_procure", "hatch"))
|
|
engine._run_progression_intent(hatch)
|
|
self.assertIsNone(engine.battle_journal.pending(engine.snapshot))
|
|
for _ in range(3):
|
|
engine._run_progression_intent()
|
|
self.assertEqual(len(client.writes), 1 + deficit)
|
|
self.assertEqual(client.raw["currentTasks"][0]["curStep"], cursor)
|
|
for growing in client.raw["monsters"]:
|
|
growing["mode"] = 2
|
|
self.sync(engine, client)
|
|
submitted = []
|
|
for number in range(cursor, 3):
|
|
submit = self.intent(engine)
|
|
self.assertEqual((submit.kind, submit.step_number), ("progression_step", number))
|
|
submitted.extend(submit.payload["removeIds"])
|
|
engine._run_progression_intent(submit)
|
|
self.assertEqual(client.raw["currentTasks"][0]["curStep"], number + 1)
|
|
local = self.intent(engine)
|
|
self.assertEqual(local.kind, "progression_local_step")
|
|
engine._run_progression_intent(local)
|
|
self.assertEqual(len(set(submitted)), deficit)
|
|
complete = self.intent(engine)
|
|
self.assertEqual(complete.kind, "progression_complete")
|
|
engine._run_progression_intent(complete)
|
|
purchases = [payload["num"] for path, payload in client.writes if path == "gachaService/gachaGetEggs"]
|
|
self.assertEqual(purchases, [deficit])
|
|
self.assertEqual(client.raw["currentTasks"], [])
|
|
self.assertEqual(client.raw["history"]["loopTaskNum"], 4)
|
|
self.assertEqual(engine.commission_history()["summary"]["confirmed_ke"], 20)
|
|
|
|
def test_active_procurement_keeps_future_handin_money_in_both_checks(self):
|
|
handin = 500
|
|
self.tasks["400"]["steps"] = [requirement(count=2),
|
|
step("getMoney", statusValue={"money": handin, "remove": True})]
|
|
self.raw["currentTasks"] = [{"id": 51, "typeId": "400", "curStep": 1}]
|
|
self.quest.max_money = handin
|
|
price = self.catalog.data["markets"]["sc_city1"]["money"]
|
|
self.raw["master"]["money"] = self.ranch.keep_money + handin + price
|
|
engine, client = self.engine()
|
|
buy = self.intent(engine)
|
|
self.assertEqual((buy.kind, buy.phase, buy.payload["num"]), ("progression_procure", "buy", 1))
|
|
engine._run_progression_intent(buy)
|
|
self.assertEqual(client.writes, [("gachaService/gachaGetEggs", buy.payload)])
|
|
self.assertEqual(client.raw["master"]["money"], self.ranch.keep_money + handin)
|
|
self.assertIsNone(engine.battle_journal.pending(engine.snapshot))
|
|
self.assertEqual(client.raw["currentTasks"][0]["curStep"], 1)
|
|
|
|
def test_protected_duplicates_are_reported_and_not_submitted(self):
|
|
self.raw["monsters"] = [monster(self.catalog, 1, lock=True), monster(self.catalog, 2),
|
|
monster(self.catalog, 3), monster(self.catalog, 4)]
|
|
self.raw["teams"] = [{"name": "teamA", "monsters": [2]}]
|
|
self.ranch.feed_targets = {"3": 1}
|
|
engine, client = self.engine()
|
|
info = self.data.task("400")
|
|
ready, ids, reason = engine.progression_planner.requirement(engine.snapshot, info["steps"][0], {},
|
|
engine._intent_policy({"task_type_id": "400"}), engine.policy)
|
|
self.assertTrue(ready)
|
|
self.assertEqual(ids, [4])
|
|
self.assertIn("保护3", reason)
|
|
self.assertIn("已锁定", reason)
|
|
engine._run_progression_intent(self.intent(engine))
|
|
engine._run_progression_intent(self.intent(engine))
|
|
self.assertEqual({m["id"] for m in client.raw["monsters"]}, {1, 2, 3})
|
|
|
|
def test_protected_star_species_cannot_be_procured_by_unprotecting(self):
|
|
self.ranch.protect_star = 2
|
|
engine, client = self.engine()
|
|
row = engine.commission_offer_diagnostics()[0]
|
|
self.assertFalse(row["eligible"] or row["preparable"])
|
|
self.assertIn("新孵魔物也受", row["reason"])
|
|
self.assertFalse(any(i.kind == "progression_procure" for i in engine._progression_intents))
|
|
self.assertEqual(client.writes, [])
|
|
|
|
def test_coin_reserve_daily_budget_and_ten_draw_rule_remain_enforced(self):
|
|
for changes in ({"daily_buy_money": 0}, {"keep_money": 10000}, {"allow_single_draw": False}):
|
|
with self.subTest(changes=changes):
|
|
self.ranch = Policy(buy=True, allow_single_draw=True, **{k: v for k, v in changes.items() if k != "allow_single_draw"})
|
|
if "allow_single_draw" in changes:
|
|
self.ranch.allow_single_draw = False
|
|
engine, client = self.engine()
|
|
self.assertFalse(any(i.kind == "progression_procure" for i in engine._progression_intents))
|
|
self.assertEqual(client.writes, [])
|
|
|
|
def test_stop_and_changed_offer_cancel_before_dispatch(self):
|
|
for change in (lambda e: e.cancel_progression(), lambda e: e.snapshot.raw["history"].update(loopTaskNum=0),
|
|
lambda e: e.snapshot.raw["history"].update(loopTask={}),
|
|
lambda e: e.snapshot.raw["currentTasks"].append({"id": 52, "typeId": "401", "curStep": 1})):
|
|
with self.subTest(change=change):
|
|
engine, client = self.engine()
|
|
intent = self.intent(engine)
|
|
original = engine._journal_commission
|
|
def change_before_dispatch(record, incoming):
|
|
original(record, incoming)
|
|
change(engine)
|
|
with patch.object(engine, "_journal_commission", side_effect=change_before_dispatch):
|
|
engine._execute_procurement(intent)
|
|
self.assertEqual(client.writes, [])
|
|
self.assertIsNone(engine.battle_journal.pending(engine.snapshot))
|
|
|
|
def test_active_task_changed_before_dispatch_is_cancelled(self):
|
|
self.raw["currentTasks"] = [{"id": 51, "typeId": "400", "curStep": 1}]
|
|
engine, client = self.engine()
|
|
intent = self.intent(engine)
|
|
original = engine._journal_commission
|
|
def replace_task(record, incoming):
|
|
original(record, incoming)
|
|
engine.snapshot.raw["currentTasks"] = [{"id": 52, "typeId": "400", "curStep": 1}]
|
|
with patch.object(engine, "_journal_commission", side_effect=replace_task):
|
|
engine._execute_procurement(intent)
|
|
self.assertEqual(client.writes, [])
|
|
self.assertIsNone(engine.battle_journal.pending(engine.snapshot))
|
|
|
|
def test_hard_prerequisite_is_not_misreported_as_preparable(self):
|
|
self.tasks["400"]["steps"][0]["condition"] = {"finishTask": ["999"]}
|
|
engine, client = self.engine()
|
|
row = engine.commission_offer_diagnostics()[0]
|
|
self.assertFalse(row["eligible"] or row["preparable"])
|
|
self.assertEqual(row["reason_kind"], "prerequisite")
|
|
self.assertFalse(any(i.kind == "progression_procure" for i in engine._progression_intents))
|
|
self.assertEqual(client.writes, [])
|
|
|
|
def test_ten_draw_cost_uses_verified_unit_price_without_fictitious_discount(self):
|
|
self.tasks["400"]["steps"] = [requirement(count=10)]
|
|
price = self.catalog.data["markets"]["sc_city1"]["money"]
|
|
self.ranch.daily_buy_money = price * 10
|
|
self.raw["master"]["money"] = self.ranch.keep_money + price * 10
|
|
engine, _ = self.engine()
|
|
buy = self.intent(engine)
|
|
self.assertEqual(buy.payload["num"], 10)
|
|
engine._run_progression_intent(buy)
|
|
self.assertEqual(engine.purchase_budget.spent(engine.snapshot.now), price * 10)
|
|
|
|
def test_unknown_buy_survives_restart_and_account_isolation(self):
|
|
engine, client = self.engine()
|
|
client.timeout = True
|
|
with self.assertRaises(TimeoutError):
|
|
engine._execute_procurement(self.intent(engine))
|
|
self.assertEqual(len(client.writes), 1)
|
|
restored, second = self.engine()
|
|
restored._run_progression_intent()
|
|
self.assertEqual(second.writes, [])
|
|
self.assertIsNotNone(restored.battle_journal.pending(restored.snapshot))
|
|
other = deepcopy(self.raw)
|
|
other["master"]["id"] = 2
|
|
isolated, _ = self.engine(raw=other)
|
|
self.assertIsNone(isolated.battle_journal.pending(isolated.snapshot))
|
|
with self.assertRaises(ValueError):
|
|
isolated._execute_procurement(self.intent(engine))
|
|
|
|
def test_mainline_confirmed_unlock_changes_offer_eligibility(self):
|
|
self.tasks["100"] = task("100", steps=[step()])
|
|
data = config(self.tasks)
|
|
data["game_setting"]["cityInfo"]["2"] = {"name": "测试城", "openTask": "100"}
|
|
planner = ProgressionPlanner(self.catalog, data)
|
|
raw = deepcopy(self.raw)
|
|
raw["history"]["unlockCity"]["2"] = False
|
|
raw["currentTasks"] = [{"id": 11, "typeId": "100", "curStep": 2}]
|
|
raw["monsters"] = [monster(self.catalog, 901)]
|
|
snap = Snapshot(raw)
|
|
before = planner.commission_offers(snap, self.quest, self.ranch)[0]
|
|
self.assertEqual(before["reason_kind"], "city_locked")
|
|
self.assertIn("测试城", before["reason"])
|
|
finish = planner.plan(snap, ProgressionPolicy(enabled=True), self.ranch)[0]
|
|
planner.acknowledge(snap, finish, {"reward": {}})
|
|
self.assertTrue(planner.commission_offers(snap, self.quest, self.ranch)[0]["eligible"])
|
|
|
|
def test_material_shortage_uses_real_supported_sweep_source(self):
|
|
self.tasks["400"]["steps"] = [requirement("getItem", 3, "30054")]
|
|
data = config(self.tasks, farming={"items": {"30054": [{"stage_id": "0101", "difficulty": 1}]}})
|
|
self.raw["history"]["passStage"] = {"0101": [1, 2, 3]}
|
|
planner = ProgressionPlanner(self.catalog, data)
|
|
actions = planner.commission_plan(Snapshot(self.raw), self.quest, self.ranch)
|
|
self.assertEqual(actions[0].kind, "sweep")
|
|
self.assertEqual(actions[0].source_task_type_id, "400")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|