fix(web): finalize quick battle and commission procurement for 2.0.9

This commit is contained in:
AttilaNet
2026-11-13 11:28:14 +08:00
parent cfce3e0bc5
commit 7845751cf6
21 changed files with 2442 additions and 117 deletions
@@ -0,0 +1,393 @@
"""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()