"""Offline source-derived progression tests; no clients or game servers.""" from copy import deepcopy from dataclasses import asdict, replace import hashlib import json from pathlib import Path import unittest from unittest.mock import patch import zipfile from ranch_assistant.game_data import ( BATTLES_NAME, DATA_DIR, DATA_NAME, MANIFEST_NAME, ORIGINAL_APK_SHA256, ProgressionData, ProgressionDataError, load_progression_data, ) from ranch_assistant.model import Catalog, Policy, Snapshot from ranch_assistant.progression import ProgressionPlanner, ProgressionPolicy from ranch_assistant.quests import QuestPolicy from tools.build_progression_data import farming_index, summarize_script ROOT = Path(__file__).resolve().parents[2] def step(kind="none", **changes): return {"statusType": kind, "statusValue": {}, "story": "", "afterStory": "", "position": "", "npc": "", "unlockStages": [], "condition": {}, **changes} def task(type_id="100", *, steps=None, **changes): return {"id": type_id, "name": "离线测试任务", "type": 1, "startStep": step(), "steps": [step()] if steps is None else steps, "closed": False, "nextTasks": [], "unlockTasks": [], "unlockStages": [], **changes} def snapshot(**changes): return Snapshot({"master": {"id": 1, "level": 20, "money": 2000, "ti": 50}, "items": [], "monsters": [], "stacks": [], "rooms": [], "teams": [], "history": {"unlockCity": {"1": True}, "unlockStage": {"0101": [1, 2, 3]}, "passStage": {}, "passTask": {}, "unlockTask": {}, "openHardMode": True}, "currentTasks": [{"id": 11, "typeId": "100", "curStep": 1, "stepValue": None}], **changes}) def config(tasks=None, **changes): return {"task_info": tasks or {"100": task()}, "scripts": { "linear": {"supported": True, "answer": None, "dialogue_lines": 5}, "accept": {"supported": True, "answer": True, "dialogue_lines": 3}, "choice": {"supported": False, "answer": None, "block_reasons": ["unsupported command: option"]}}, "game_setting": {"cityInfo": {"1": {"name": "莉莉托斯", "cid": "1"}}}, "setting": {}, "stage_info": {"0101": {"id": "0101", "name": "王城郊外 1-1", "city": 1, "cost": {"ti": 2}, "level": {str(i): {"cost": i, "battle_available": True} for i in (1, 2, 3)}}}, "npc_info": {"nina": {"name": "妮娜"}}, "stage_sp": {}, **changes} class ProgressionTests(unittest.TestCase): @classmethod def setUpClass(cls): cls.catalog = Catalog() def setUp(self): self.policy = ProgressionPolicy(enabled=True) self.ranch = Policy(keep_money=1000) self.snapshot = snapshot() self.planner = ProgressionPlanner(self.catalog, config()) def plan(self): return self.planner.plan(self.snapshot, self.policy, self.ranch) def next(self, kind): planned = self.plan() self.assertTrue(planned) self.assertEqual(planned[0].kind, kind, planned[0].description) return planned[0] def test_policy_defaults_roundtrip_and_validation(self): policy = ProgressionPolicy() self.assertFalse(policy.enabled) self.assertEqual(ProgressionPolicy.from_dict(json.loads(json.dumps(asdict(policy)))), policy) for changes in ({"enabled": "false"}, {"reserve_ti": -1}, {"stop_after_loss": 0}, {"max_money": float("nan")}, {"allow_items": 1}, {"team": ""}, {"team": "has\nnewline"}, {"team": " too much space "}, {"team": "x" * 65}, {"battle_mode": "faithful_estimate"}, {"item_reserves": {"20001": -2}}, {"item_reserves": {"token": 1}}): with self.subTest(changes=changes), self.assertRaises(ValueError): ProgressionPolicy(**changes) with self.assertRaises(ValueError): ProgressionPolicy.from_dict({"session": "must-not-import"}) self.assertEqual(ProgressionPolicy(team="自定义编队").team, "自定义编队") self.assertEqual(ProgressionPolicy(team="bonusTeam4").battle_mode, "original") self.assertEqual(ProgressionPolicy(battle_mode="experimental").to_dict()["battle_mode"], "experimental") self.assertEqual(self.planner.plan(self.snapshot, ProgressionPolicy(), self.ranch), []) def test_nonbattle_server_ack_then_local_complete_then_reward(self): original = deepcopy(self.snapshot.raw) action = self.next("progression_step") self.assertEqual(action.path, "taskService/taskCompleteStep") self.assertEqual(action.payload, {"taskId": 11, "taskTypeId": "100", "removeIds": None}) self.assertNotIn("battleData", action.payload) self.planner.mark_started(self.snapshot, action) self.assertTrue(self.plan()[0].block_reason) self.planner.acknowledge(self.snapshot, action, {"taskStepValue": None}) self.assertFalse(self.planner.acknowledge(self.snapshot, action, {})) local = self.next("progression_local_step") self.assertEqual(local.path, "") self.planner.acknowledge(self.snapshot, local) reward = self.next("progression_complete") self.assertEqual(reward.payload, {"taskId": 11, "taskTypeId": "100"}) self.planner.acknowledge(self.snapshot, reward, {"reward": {}}) self.assertEqual(self.plan(), []) self.assertEqual(self.snapshot.raw, original) def test_ordinary_dialogue_and_navigation_are_logical_and_do_not_submit_twice(self): self.planner = ProgressionPlanner(self.catalog, config({"100": task(steps=[ step(story="linear", afterStory="linear", position="city1_market", npc="nina"), step()])})) nav = self.next("progression_navigate") self.assertEqual(nav.position, "city1_market") self.assertEqual(nav.payload, {}) self.assertEqual(nav.npc_name, "妮娜") self.assertIn("市场", nav.location) self.planner.acknowledge(self.snapshot, nav) before = self.next("progression_dialogue") self.assertEqual(before.phase, "before") self.planner.acknowledge(self.snapshot, before) server = self.next("progression_step") self.assertEqual(self.snapshot.raw["currentTasks"][0]["curStep"], 1) self.planner.acknowledge(self.snapshot, server, {}) after = self.next("progression_dialogue") self.assertEqual(after.phase, "after") self.planner.acknowledge(self.snapshot, after) self.planner.acknowledge(self.snapshot, self.next("progression_local_step")) following = self.next("progression_step") self.assertEqual(following.step_number, 2) self.assertEqual(self.snapshot.raw["currentTasks"][0]["curStep"], 1) def test_empty_before_story_does_not_skip_after_story(self): self.planner = ProgressionPlanner(self.catalog, config({"100": task(steps=[step(afterStory="linear")])})) self.planner.acknowledge(self.snapshot, self.next("progression_step"), {}) self.assertEqual(self.next("progression_dialogue").phase, "after") def test_server_step_advance_does_not_skip_unfinished_acknowledged_after_story(self): self.planner = ProgressionPlanner(self.catalog, config({"100": task(steps=[step(afterStory="linear"), step()])})) self.planner.acknowledge(self.snapshot, self.next("progression_step"), {}) self.snapshot.raw["currentTasks"][0]["curStep"] = 2 self.assertEqual(self.next("progression_dialogue").step_number, 1) def test_finished_received_unlocked_states_deduplicate(self): self.snapshot.raw["history"]["unlockTask"] = {"100": True} rows = self.planner.rows(self.snapshot, self.policy, self.ranch) self.assertEqual(len(rows), 1) self.assertEqual(rows[0]["state"], "received") self.assertEqual(self.next("progression_step").task_id, 11) self.snapshot.raw["history"]["passTask"] = {"100": True} self.assertEqual(self.plan(), []) self.assertEqual(self.planner.rows(self.snapshot, self.policy, self.ranch)[0]["state"], "finished") def test_task_history_id_lists_are_supported_alongside_flag_mappings(self): self.snapshot.raw["currentTasks"] = [] self.snapshot.raw["history"]["unlockTask"] = [100] self.next("progression_accept") self.snapshot.raw["history"]["passTask"] = [100] self.assertEqual(self.plan(), []) def test_accept_uses_verified_payload_and_success_instance(self): self.snapshot.raw["currentTasks"] = [] self.snapshot.raw["history"]["unlockTask"] = {"100": True} accept = self.next("progression_accept") self.assertEqual(accept.path, "taskService/taskReceive") self.assertEqual(accept.payload, {"taskTypeId": "100"}) self.planner.acknowledge(self.snapshot, accept, {"task": {"id": 15, "typeId": "100", "stepValue": None}}) self.assertEqual(self.next("progression_step").task_id, 15) def test_start_answer_is_required_and_choice_scripts_are_blocked(self): self.snapshot.raw["currentTasks"] = [] self.snapshot.raw["history"]["unlockTask"] = {"100": True} for name in ("linear", "choice", "missing"): with self.subTest(name=name): self.planner = ProgressionPlanner(self.catalog, config({"100": task(startStep=step(story=name))})) self.assertTrue(self.plan()[0].block_reason) self.planner = ProgressionPlanner(self.catalog, config({"100": task(startStep=step(story="accept"))})) self.planner.acknowledge(self.snapshot, self.next("progression_dialogue")) self.next("progression_accept") def test_missing_accept_response_never_invents_an_instance(self): self.snapshot.raw["currentTasks"] = [] self.snapshot.raw["history"]["unlockTask"] = {"100": True} action = self.next("progression_accept") self.assertFalse(self.planner.acknowledge(self.snapshot, action, {})) self.assertIn("禁止自动重发", self.plan()[0].block_reason) def test_reward_reply_received_successor_and_unlocked_sidequest(self): self.planner = ProgressionPlanner(self.catalog, config({ "100": task(), "101": task("101"), "200": task("200", type=2)})) self.snapshot.raw["currentTasks"][0]["curStep"] = 2 action = self.next("progression_complete") self.planner.acknowledge(self.snapshot, action, { "nextTasks": [{"id": 12, "typeId": "101", "curStep": 1}], "unlockTasks": ["200"]}) following = self.next("progression_step") self.assertEqual(following.task_type_id, "101") states = {row["task_type_id"]: row["state"] for row in self.planner.rows(self.snapshot, self.policy, self.ranch)} self.assertEqual(states, {"100": "finished", "101": "received", "200": "unlocked"}) def test_graph_repair_uses_explicit_edges_and_three_exact_arrays(self): self.planner = ProgressionPlanner(self.catalog, config({ "100": task(nextTasks=["500", "501"], unlockTasks=["700"]), "500": task("500"), "501": task("501", closed=True), "700": task("700", type=2)})) self.snapshot.raw["currentTasks"] = [] self.snapshot.raw["history"]["passTask"] = {"100": True, "unrelated": False} self.policy.sidequests = True action = self.next("progression_update") self.assertEqual(action.path, "taskService/taskUpdate") self.assertEqual(action.payload, {"receiveTasks": [{"prev": "100", "taskTypeId": "500"}], "unlockTasks": [{"prev": "100", "taskTypeId": "700"}], "removeTasks": []}) self.snapshot.raw["history"]["unlockTask"] = {"500": True, "700": True} self.policy.accept = False self.assertNotIn("progression_update", [action.kind for action in self.plan()]) def test_graph_no_guessed_first_task_and_legacy_root_is_respected(self): self.snapshot.raw["currentTasks"] = [] self.assertEqual(self.plan(), []) data = config({"999": task("999", nextTasks=["100"]), "100": task()}, setting={"useOldNewTaskFunction": True}) self.planner = ProgressionPlanner(self.catalog, data) self.snapshot.raw["history"]["passTask"] = {"999": True} self.assertEqual(self.plan(), []) def test_closed_task_removal_ack_is_not_replayed_on_a_stale_snapshot(self): self.planner = ProgressionPlanner(self.catalog, config({"100": task(closed=True)})) action = self.next("progression_update") self.assertEqual(action.payload, {"unlockTasks": [], "receiveTasks": [], "removeTasks": [11]}) self.planner.acknowledge(self.snapshot, action, {}) self.assertEqual(self.plan(), []) def test_declared_conditions_time_and_loader_anomaly_are_conservative(self): self.assertFalse(self.planner.condition({"minLevel": 21}, self.snapshot)[0]) self.assertFalse(self.planner.condition({"maxLevel": 19}, self.snapshot)[0]) self.assertFalse(self.planner.condition({"close": True}, self.snapshot)[0]) self.assertFalse(self.planner.condition({"unfinishTask": ["100"]}, self.snapshot)[0]) self.assertFalse(self.planner.condition({"passStage": ["0101"]}, self.snapshot)[0]) self.assertTrue(self.planner.condition({"unlockStage": ["0101"]}, self.snapshot)[0]) self.assertFalse(self.planner.condition({"lang": "CN"}, self.snapshot)[0]) self.snapshot.raw["client_context"] = {"lang": "CN", "platform": "ANDROID", "channel": "DYD"} self.assertTrue(self.planner.condition({"lang": "CN", "platform": "ANDROID"}, self.snapshot)[0]) self.assertFalse(self.planner.condition({"futureFlag": True}, self.snapshot)[0]) with patch("ranch_assistant.model.time.time", return_value=1794112200): # 2026-11-08 12:30 UTC+8, Sunday == AS3 day 0. self.assertTrue(self.planner.condition({"week": [0], "startTime": 1230, "endTime": 1230}, self.snapshot)[0]) self.assertFalse(self.planner.condition({"week": [1]}, self.snapshot)[0]) self.assertFalse(self.planner.condition({"endTimestamp": 1}, self.snapshot)[0]) def test_guide_gates_and_special_gacha_stay_blocked(self): self.planner = ProgressionPlanner(self.catalog, config({"100": task(steps=[step(passGuide="minefail")])})) self.assertTrue(self.plan()[0].block_reason) self.snapshot.raw["history"]["guide_record"] = {"minefail": True} self.next("progression_step") self.planner = ProgressionPlanner(self.catalog, config({"1001006": task("1001006", steps=[step()] * 4)})) self.snapshot.raw["currentTasks"] = [{"id": 12, "typeId": "1001006", "curStep": 4}] self.assertIn("特殊抽蛋", self.plan()[0].block_reason) def test_item_reserve_locks_and_exact_remove_ids(self): self.planner = ProgressionPlanner(self.catalog, config({"100": task(steps=[step("getItem", statusValue={"type": 30001, "num": 3, "remove": True})])})) self.snapshot.raw["items"] = [{"id": 1, "typeId": 30001, "num": 2}, {"id": 2, "typeId": 30001, "num": 4}, {"id": 3, "typeId": 30001, "num": 100, "lock": True}] self.assertIn("未启用", self.plan()[0].block_reason) self.policy.allow_items = True self.policy.item_reserves = {"30001": 4} self.assertIn("保留", self.plan()[0].block_reason) self.policy.item_reserves = {"30001": 3} action = self.next("progression_step") self.assertEqual(action.payload["removeIds"], [1, 2]) self.assertEqual(self.snapshot.raw["items"][1]["num"], 4) def test_observation_only_items_still_send_source_ids_without_allowing_consumption(self): self.planner = ProgressionPlanner(self.catalog, config({"100": task(steps=[step("getItem", statusValue={"type": 30001, "num": 2, "remove": False})])})) self.snapshot.raw["items"] = [{"id": 1, "typeId": 30001, "num": 2}] self.policy.item_reserves = {"30001": 100} self.assertEqual(self.next("progression_step").payload["removeIds"], [1]) def test_money_removal_respects_maximum_and_ranch_reserve(self): self.planner = ProgressionPlanner(self.catalog, config({"100": task(steps=[step("getMoney", statusValue={"money": 1200, "remove": True})])})) self.assertIn("上限", self.plan()[0].block_reason) self.policy.max_money = 1200 self.assertIn("保留", self.plan()[0].block_reason) self.snapshot.raw["master"]["money"] = 2200 self.next("progression_step") def test_monster_submission_never_consumes_team_locked_or_reserved_monsters(self): self.planner = ProgressionPlanner(self.catalog, config({"100": task(steps=[step("getMonster", statusValue={"type": 1001010, "num": 1, "mode": 2, "remove": True})])})) base = self.catalog.monster(1001010) monster = {"id": 1, "typeId": 1001010, "mode": 2, "process": 3, "level": 1, **{"g" + stat.capitalize(): base[stat + "_grow_min"] for stat in ("atk", "def", "hp", "dex")}} self.snapshot.raw["monsters"] = [monster] self.policy.allow_monsters = True self.ranch.protect_quality = 5 self.assertEqual(self.next("progression_step").payload["removeIds"], [1]) for changes in ({"lock": True}, {"entangle": True}, {"equip1": 3}, {"inExploreTeam": True}): with self.subTest(changes=changes): self.snapshot.raw["monsters"] = [monster | changes] self.assertTrue(self.plan()[0].block_reason) self.snapshot.raw["monsters"] = [monster] self.snapshot.raw["teams"] = [{"monsters": [1]}] self.assertTrue(self.plan()[0].block_reason) self.snapshot.raw["teams"] = [] self.ranch.reserved_types = [1001010] self.assertTrue(self.plan()[0].block_reason) def test_kill_target_uses_step_value_and_never_configured_relative_count(self): self.planner = ProgressionPlanner(self.catalog, config({"100": task(steps=[step("killMonster", statusValue={"type": 1001010, "num": 2})])})) self.snapshot.raw["currentTasks"][0]["stepValue"] = 150 self.snapshot.raw["history"]["numKillMonsters"] = {"1001010": 149} self.assertTrue(self.plan()[0].block_reason) self.snapshot.raw["history"]["numKillMonsters"]["1001010"] = 150 self.next("progression_step") self.snapshot.raw["currentTasks"][0]["stepValue"] = None self.assertIn("未同步", self.plan()[0].block_reason) def test_pass_stage_and_task_battle_route_are_distinct_and_never_sweeps(self): for kind in ("battle", "passStage"): with self.subTest(kind=kind): value = {"stage": "0101", "level": "1"} if kind == "passStage" else {} self.planner = ProgressionPlanner(self.catalog, config({"100": task(steps=[step(kind, statusValue=value, battle={"teams": [{"mons": []}]})])})) self.snapshot.raw["history"]["passStage"] = {"0101": [1, 2, 3]} action = self.next("progression_battle") self.assertEqual(action.path, "battleService/battleStart") self.assertEqual(action.payload, {"battleType": "task", "taskTypeId": "100"}) self.assertEqual(action.battle_kind, "task" if kind == "battle" else "passStage") self.assertEqual(action.stage_id, "" if kind == "battle" else "0101") self.assertNotIn("battleData", action.payload) self.planner.battle_lost(self.snapshot, action) self.assertIn("战败", self.plan()[0].block_reason) def test_task_pass_stage_stamina_and_hard_mode_gates(self): self.planner = ProgressionPlanner(self.catalog, config({"100": task(steps=[step("passStage", statusValue={"stage": "0101", "level": 2})])})) self.snapshot.raw["history"]["openHardMode"] = False self.assertIn("高难度", self.plan()[0].block_reason) self.snapshot.raw["history"]["openHardMode"] = True self.policy.reserve_ti = 47 self.assertIn("体力", self.plan()[0].block_reason) self.policy.reserve_ti = 46 self.next("progression_battle") def test_battle_start_or_local_win_is_not_a_step_settlement(self): self.planner = ProgressionPlanner(self.catalog, config({"100": task(steps=[step("battle", battle={"teams": []})])})) action = self.next("progression_battle") for response in ({"resCode": 0}, {"win": True}, {"resCode": 1, "reward": {}}): with self.subTest(response=response), self.assertRaises(ValueError): self.planner.acknowledge(self.snapshot, action, response) def test_pass_stage_local_flags_require_confirmed_settlement(self): self.planner = ProgressionPlanner(self.catalog, config({"100": task(steps=[ step("passStage", statusValue={"stage": "0101", "level": 1}), step(condition={"passStage": ["0101"]})])})) action = self.next("progression_battle") self.assertFalse(self.planner.condition({"passStage": ["0101"]}, self.snapshot)[0]) self.planner.acknowledge(self.snapshot, action, {"costTi": 3, "unlockStage": [], "lockStage": []}) self.assertTrue(self.planner.condition({"passStage": ["0101"]}, self.snapshot)[0]) self.planner.acknowledge(self.snapshot, self.next("progression_local_step")) self.assertEqual(self.next("progression_step").step_number, 2) def test_wrong_account_stale_and_invalid_wire_steps_are_not_accepted(self): action = self.next("progression_step") other = snapshot(master={"id": 2}) with self.assertRaises(ValueError): self.planner.acknowledge(other, action, {}) with self.assertRaises(ValueError): self.planner.acknowledge(self.snapshot, replace(action, payload={}), {}) self.snapshot.raw["currentTasks"][0]["curStep"] = 0 self.planner = ProgressionPlanner(self.catalog, config()) self.assertIn("一基步骤", self.plan()[0].block_reason) def test_pending_request_survives_restore_and_is_not_replayed(self): action = self.next("progression_step") self.planner.mark_started(self.snapshot, action) restored = ProgressionPlanner(self.catalog, config()) restored.restore_state(json.loads(json.dumps(self.planner.export_state()))) self.assertTrue(restored.plan(self.snapshot, self.policy, self.ranch)[0].block_reason) self.snapshot.raw["currentTasks"][0]["curStep"] = 2 planned = restored.plan(self.snapshot, self.policy, self.ranch)[0] self.assertEqual(planned.kind, "progression_local_step") def test_local_progress_import_requires_an_actual_step_ack(self): cursor = {"11:100": {"task_id": 11, "task_type_id": "100", "steps": { "1": {"kind": "progression_dialogue", "phase": "before", "acknowledged": True}}}} planned = self.planner.plan(self.snapshot, self.policy, self.ranch, local_progress=cursor) self.assertEqual(planned[0].kind, "progression_step") cursor["11:100"]["steps"]["1"] = {"kind": "progression_step", "acknowledged": True, "response": {"taskStepValue": None}} planned = self.planner.plan(self.snapshot, self.policy, self.ranch, local_progress=cursor) self.assertEqual(planned[0].kind, "progression_local_step") def test_unknown_types_are_visible_and_commissions_are_not_duplicated(self): self.planner = ProgressionPlanner(self.catalog, config({"100": task(type=6), "400": task("400", type=4)})) self.snapshot.raw["currentTasks"].append({"id": 12, "typeId": "400", "curStep": 1}) rows = self.planner.rows(self.snapshot, self.policy, self.ranch) self.assertEqual({row["category"] for row in rows}, {"unknown", "commission"}) self.policy.commissions = True self.assertTrue(all(not action.path for action in self.plan())) self.assertIn("QuestPolicy", next(row for row in rows if row["category"] == "commission")["block_reason"]) class CommissionProgressionTests(unittest.TestCase): @classmethod def setUpClass(cls): cls.catalog = Catalog() def setUp(self): self.snapshot = snapshot(currentTasks=[{"id": 40, "typeId": "400", "curStep": 1}]) self.snapshot.raw["history"].update(loopTaskTime=int(self.snapshot.now), loopTaskNum=6, loopTask={"1": []}) self.quest = QuestPolicy(enabled=True) self.ranch = Policy(keep_money=1000) self.battle_policy = ProgressionPolicy(team="teamB", reserve_ti=5) self.planner = ProgressionPlanner(self.catalog, config({"400": task("400", type=4)})) def plans(self): return self.planner.commission_plan(self.snapshot, self.quest, self.ranch, battle_policy=self.battle_policy) def next(self, kind): actions = self.plans() self.assertTrue(actions) self.assertEqual(actions[0].kind, kind, actions[0].description) return actions[0] def offers(self, values=None): self.snapshot.raw["currentTasks"] = [] self.snapshot.raw["history"]["loopTask"] = {"1": ["400"] if values is None else values} def test_current_commission_uses_full_nonbattle_acknowledgement_flow(self): self.snapshot.raw["history"]["passTask"] = {"400": True} # Prior day's same type. action = self.next("progression_step") self.planner.acknowledge(self.snapshot, action, {}) self.planner.acknowledge(self.snapshot, self.next("progression_local_step")) reward = self.next("progression_complete") self.planner.acknowledge(self.snapshot, reward, {}) self.assertEqual(self.plans(), []) self.assertEqual(self.planner.commission_rows(self.snapshot, self.quest, self.ranch)[0]["state"], "finished") def test_battle_and_pass_stage_use_quest_battle_switch_and_task_route(self): for kind in ("battle", "passStage"): with self.subTest(kind=kind): value = {"stage": "0101", "level": 1} if kind == "passStage" else {} self.planner = ProgressionPlanner(self.catalog, config({"400": task("400", type=4, steps=[ step(kind, battle={"teams": []}, statusValue=value, afterStory="linear")])})) self.quest.battle_tasks = False self.assertIn("战斗开关", self.plans()[0].block_reason) self.quest.battle_tasks = True action = self.next("progression_battle") self.assertEqual(action.payload, {"battleType": "task", "taskTypeId": "400"}) self.assertEqual(action.battle_kind, "task" if kind == "battle" else "passStage") self.assertEqual(action.team, "teamB") self.assertEqual(action.battle_mode, "original") self.planner.acknowledge(self.snapshot, action, {"reward": {}}) self.assertEqual(self.next("progression_dialogue").phase, "after") def test_offer_acceptance_has_exact_loop_payload_and_spends_one_slot_once(self): self.offers() self.snapshot.raw["history"]["loopTaskNum"] = 1 action = self.next("progression_loop_accept") self.assertEqual(action.path, "taskService/taskLoopReceive") self.assertEqual(action.payload, {"taskTypeId": "400", "city": 1}) response = {"task": {"id": 41, "typeId": "400", "curStep": 1}} self.assertTrue(self.planner.acknowledge(self.snapshot, action, response)) self.assertFalse(self.planner.acknowledge(self.snapshot, action, response)) account = next(iter(self.planner.export_state()["accounts"].values())) self.assertEqual(account["commissions"]["remaining"], 0) self.assertEqual(self.next("progression_step").task_id, 41) self.planner.acknowledge(self.snapshot, self.next("progression_step"), {}) self.planner.acknowledge(self.snapshot, self.next("progression_local_step")) self.planner.acknowledge(self.snapshot, self.next("progression_complete"), {}) self.assertEqual(self.plans(), []) def test_quest_enabled_accept_city_and_quota_are_authoritative(self): self.offers() self.quest.enabled = False self.assertEqual(self.plans(), []) self.quest.enabled = True self.quest.accept = False self.assertEqual(self.plans(), []) self.quest.accept = True self.quest.city = 2 self.assertEqual(self.plans(), []) self.quest.city = 1 self.snapshot.raw["history"]["loopTaskNum"] = 0 self.assertEqual(self.plans(), []) self.snapshot.raw["history"]["loopTaskNum"] = 1 self.next("progression_loop_accept") def test_quest_resources_control_offer_acceptance(self): self.planner = ProgressionPlanner(self.catalog, config({"400": task("400", type=4, steps=[ step("getItem", statusValue={"type": 30001, "num": 3, "remove": True}, afterStory="linear")])})) self.offers() self.snapshot.raw["items"] = [{"id": 1, "typeId": 30001, "num": 5}] self.assertEqual(self.plans(), []) self.quest.allow_items = True self.quest.item_reserves = {"30001": 3} self.assertEqual(self.plans(), []) row = self.planner.commission_rows(self.snapshot, self.quest, self.ranch)[0] self.assertIn("保留", row["block_reason"]) self.assertFalse(row["supported"]) self.quest.item_reserves = {"30001": 2} self.next("progression_loop_accept") def test_offer_with_linear_stories_is_accepted_and_choice_is_not(self): self.offers() for name, expected in (("linear", True), ("choice", False)): with self.subTest(name=name): self.planner = ProgressionPlanner(self.catalog, config({"400": task("400", type=4, steps=[step(story=name)])})) self.assertEqual(bool(self.plans()), expected) def test_battle_offers_need_existing_battle_tasks_opt_in(self): self.offers() self.planner = ProgressionPlanner(self.catalog, config({"400": task("400", type=4, steps=[step("battle", battle={"teams": []})])})) self.assertEqual(self.plans(), []) self.quest.battle_tasks = True self.next("progression_loop_accept") def test_reset_expires_old_instance_and_uses_confirmed_new_offers(self): self.snapshot.raw["history"]["loopTaskTime"] -= 86400 self.snapshot.raw["history"]["loopTaskNum"] = 0 action = self.next("progression_loop_reset") self.assertEqual(action.path, "taskService/taskLoopFlush") self.assertEqual(action.payload, {}) self.planner.acknowledge(self.snapshot, action, {"loopTask": {"1": [400]}}) following = self.next("progression_loop_accept") self.assertEqual(following.payload, {"taskTypeId": "400", "city": 1}) account = next(iter(self.planner.export_state()["accounts"].values())) self.assertIn("40", account["commissions"]["expired_ids"]) self.assertEqual(account["commissions"]["remaining"], 6) def test_uncertain_loop_accept_reconciles_without_spending_quota_twice(self): self.offers() self.snapshot.raw["history"]["loopTaskNum"] = 1 action = self.next("progression_loop_accept") self.planner.mark_uncertain(self.snapshot, action) self.assertTrue(self.plans()[0].block_reason) self.snapshot.raw["currentTasks"] = [{"id": 41, "typeId": "400", "curStep": 1}] self.snapshot.raw["history"]["loopTaskNum"] = 0 self.next("progression_step") account = next(iter(self.planner.export_state()["accounts"].values())) self.assertEqual(account["commissions"]["remaining"], 0) def test_cn_reset_uses_ten_second_grace(self): midnight = 1794067200 # 2026-11-08 00:00 UTC+8. with patch("ranch_assistant.model.time.time", return_value=midnight + 5): self.snapshot.raw["history"]["loopTaskTime"] = midnight - 100 self.assertNotEqual(self.plans()[0].kind, "progression_loop_reset") with patch("ranch_assistant.model.time.time", return_value=midnight + 11): self.assertEqual(self.plans()[0].kind, "progression_loop_reset") class RecoveredProgressionDataTests(unittest.TestCase): def test_full_original_tasks_static_manifest_and_battle_archive(self): data = load_progression_data() self.assertEqual(len(data.tasks), 1165) self.assertEqual(sum(len(task["steps"]) for task in data.tasks.values()), 3462) self.assertEqual(len(data.stages), 1178) self.assertEqual(len(data.scripts), 4269) self.assertEqual(data.manifest["source"]["apk_sha256"], ORIGINAL_APK_SHA256) self.assertEqual(len(Catalog().data["task_info"]), 83) self.assertEqual(data.task("1001002")["steps"][0]["story"], "task_1001002") self.assertIs(type(data.task("1001001")["unlockTasks"]), list) self.assertEqual(data.manifest["source"]["amf_reader_sha256"], hashlib.sha256((ROOT / "ranch_assistant/amf.py").read_bytes()).hexdigest()) self.assertTrue(data.script("task_1001002")["supported"]) for name, record in data.manifest["artifacts"].items(): self.assertEqual(hashlib.sha256((DATA_DIR / name).read_bytes()).hexdigest(), record["sha256"]) self.assertLess((DATA_DIR / BATTLES_NAME).stat().st_size, 3_000_000) with zipfile.ZipFile(DATA_DIR / BATTLES_NAME) as archive: self.assertEqual(len(archive.namelist()), 1178) self.assertTrue(all(name.startswith("stages/") and name.endswith(".json") for name in archive.namelist())) self.assertTrue(all(info.date_time == (1980, 1, 1, 0, 0, 0) for info in archive.infolist())) self.assertTrue(data.stage_battle("0101", 1)) self.assertTrue(data.task_battle("1001001", 1)) def test_loader_never_opens_apk_or_eagerly_reads_battles(self): with patch("ranch_assistant.game_data.zipfile.ZipFile", side_effect=AssertionError("eager archive read")): data = ProgressionData() self.assertEqual(len(data.tasks), 1165) def test_artifact_tampering_is_rejected(self): with patch("ranch_assistant.game_data.Path.read_bytes", return_value=b"tampered"): with self.assertRaisesRegex(ProgressionDataError, "hash mismatch"): ProgressionData() def test_shared_static_data_is_not_mutated_by_account_planning(self): data = load_progression_data() before = json.dumps(data.data, sort_keys=True, ensure_ascii=True) planner = ProgressionPlanner(Catalog(), data) planner.rows(snapshot(), ProgressionPolicy(), Policy()) planner.plan(snapshot(master={"id": 2}), ProgressionPolicy(enabled=True), Policy()) self.assertEqual(json.dumps(data.data, sort_keys=True, ensure_ascii=True), before) def test_linear_hide_newlines_and_placeholders_are_presentation(self): expressions = [ {"key": "text", "para": {"text": "[show]你好 [{gn.myName}][r]下一行\n[hide][cm]"}}, {"key": "event", "para": {"event": "GAoEvent", "eventData": "true"}}, ] summary = summarize_script(json.dumps({"exps": expressions}).encode(), "fixture") self.assertTrue(summary["supported"], summary) self.assertTrue(summary["answer"]) self.assertEqual(summary["dialogue_lines"], 1) for expression in ({"key": "option", "para": {"options": []}}, {"key": "jump", "para": {"tag": "x"}}, {"key": "event", "para": {"event": "GAoEvent", "eventData": '{"action":"gacha"}'}}): with self.subTest(expression=expression): summary = summarize_script(json.dumps({"exps": [expression]}).encode(), "fixture") self.assertFalse(summary["supported"]) class FarmingAndAreaTests(unittest.TestCase): @classmethod def setUpClass(cls): cls.catalog = Catalog() def setUp(self): self.snapshot = snapshot() self.policy = ProgressionPolicy(enabled=True) self.ranch = Policy(keep_money=1000) self.data = config(farming={"kills": {"1001010": [{"stage_id": "0101", "difficulty": 1, "configured_enemies": 2}]}, "items": {key: [{"stage_id": "0101", "difficulty": 1}] for key in ("30001", "1001010")}}) def planner(self, current_step): data = deepcopy(self.data) data["task_info"]["100"]["steps"] = [current_step] return ProgressionPlanner(self.catalog, data) def test_kill_farming_has_no_task_wire_context_and_never_uses_sweep(self): planner = self.planner(step("killMonster", statusValue={"type": 1001010, "num": 5})) self.snapshot.raw["currentTasks"][0]["stepValue"] = 5 self.snapshot.raw["history"]["numKillMonsters"] = {"1001010": 0} self.snapshot.raw["history"]["passStage"] = {"0101": [1, 2, 3]} action = planner.plan(self.snapshot, self.policy, self.ranch)[0] self.assertEqual(action.kind, "stage_battle") self.assertEqual(action.battle_kind, "ordinary_stage") self.assertEqual((action.task_id, action.task_type_id), (0, "")) self.assertEqual((action.source_task_id, action.source_task_type_id, action.source_step_number), (11, "100", 1)) self.assertEqual(action.payload, {"stageTypeId": "0101", "stageLevel": "1"}) self.assertEqual(action.path, "stageService/stageStart") with self.assertRaises(ValueError): planner.acknowledge(self.snapshot, action, {"reward": {}}) self.assertEqual(self.snapshot.raw["currentTasks"][0]["curStep"], 1) self.snapshot.raw["history"]["numKillMonsters"]["1001010"] = 5 self.assertEqual(planner.plan(self.snapshot, self.policy, self.ranch)[0].kind, "progression_step") def test_loot_uses_sweep_only_after_three_difficulties_are_cleared(self): planner = self.planner(step("getItem", statusValue={"type": 30001, "num": 3, "remove": False})) self.snapshot.raw["history"]["passStage"] = {"0101": [3]} self.assertEqual(planner.plan(self.snapshot, self.policy, self.ranch)[0].kind, "stage_battle") self.snapshot.raw["history"]["passStage"] = {"0101": [1, 2, 3]} action = planner.plan(self.snapshot, self.policy, self.ranch)[0] self.assertEqual(action.kind, "sweep") self.assertEqual(action.task_id, 0) self.assertEqual(action.source_task_type_id, "100") self.policy.allow_sweep = False self.assertEqual(planner.plan(self.snapshot, self.policy, self.ranch)[0].kind, "stage_battle") def test_egg_farming_and_reserves_wait_for_actual_inventory(self): planner = self.planner(step("getMonster", statusValue={"type": 1001010, "num": 2, "mode": 0, "remove": True})) self.policy.allow_items = True self.policy.item_reserves = {"1001010": 2} self.snapshot.raw["items"] = [{"id": 1, "typeId": 1001010, "num": 3}] self.assertEqual(planner.plan(self.snapshot, self.policy, self.ranch)[0].kind, "stage_battle") self.snapshot.raw["items"][0]["num"] = 4 self.assertEqual(planner.plan(self.snapshot, self.policy, self.ranch)[0].kind, "progression_step") def test_farming_respects_disabled_consumption_stamina_locks_and_premium(self): planner = self.planner(step("getItem", statusValue={"type": 30001, "num": 3, "remove": True})) self.assertTrue(planner.plan(self.snapshot, self.policy, self.ranch)[0].block_reason) self.policy.allow_items = True self.policy.reserve_ti = 48 self.assertTrue(planner.plan(self.snapshot, self.policy, self.ranch)[0].block_reason) self.policy.reserve_ti = 0 self.snapshot.raw["history"]["unlockStage"] = {} self.assertTrue(planner.plan(self.snapshot, self.policy, self.ranch)[0].block_reason) self.snapshot.raw["history"]["unlockStage"] = {"0101": [1]} self.data["stage_info"]["0101"]["cost"]["ke"] = 1 self.assertTrue(self.planner(step("getItem", statusValue={"type": 30001, "num": 1})).plan(self.snapshot, self.policy, self.ranch)[0].block_reason) def test_task_interception_and_auto_farm_switch_are_honored(self): current = step("getItem", statusValue={"type": 30001, "num": 3}) planner = self.planner(current) self.policy.auto_farm = False self.assertTrue(planner.plan(self.snapshot, self.policy, self.ranch)[0].block_reason) self.policy.auto_farm = True data = deepcopy(self.data) data["task_info"]["100"]["steps"] = [current] data["task_info"]["200"] = task("200", type=2, steps=[step(position="city1_wild_stage0101_level1")]) planner = ProgressionPlanner(self.catalog, data) self.snapshot.raw["currentTasks"].append({"id": 12, "typeId": "200", "curStep": 1}) self.assertTrue(planner.plan(self.snapshot, self.policy, self.ranch)[0].block_reason) def test_farming_ticket_locks_and_gift_reserves_are_protected(self): self.data["stage_info"]["0101"]["cost"]["items"] = [{"typeId": 30002, "num": 1}] self.policy.allow_items = True self.snapshot.raw["items"] = [{"id": 2, "typeId": 30002, "num": 1, "sysLock": True}] planner = self.planner(step("getItem", statusValue={"type": 30001, "num": 2})) self.assertTrue(planner.plan(self.snapshot, self.policy, self.ranch)[0].block_reason) self.snapshot.raw["items"][0]["sysLock"] = False self.ranch.gift_items = {"30002": {"enabled": True, "reserve": 1}} self.assertTrue(planner.plan(self.snapshot, self.policy, self.ranch)[0].block_reason) def test_static_index_excludes_juveniles_allies_objects_and_zero_chance(self): monsters = [ {"type": "1001010", "team": 2, "mode": 2}, {"type": "1001020", "team": 2, "mode": 1}, {"type": "1001030", "team": 1, "mode": 2}, {"type": "1001040", "team": 2, "mode": 2, "isObject": True}, ] reward = {"rewards": [ {"item_num": 1, "item_chance": 1, "items": [{"name": "30001,1,2", "value": 1}]}, {"item_num": 1, "item_chance": 0, "items": [{"name": "30002,1,1", "value": 1}]}, {"num": 1, "chance": 1, "monMode": 0, "monsters": [{"name": "1001010", "value": 1}]}, {"num": 1, "chance": 1, "monMode": 2, "monsters": [{"name": "1001020", "value": 1}]}, ]} index = farming_index({"0101": {"level": {"1": {"battle": {"teams": [{"mons": monsters}]}, "reward": reward}}}}) self.assertEqual(set(index["kills"]), {"1001010"}) self.assertEqual(set(index["items"]), {"30001", "1001010"}) def test_area_and_dungeon_navigation_use_recovered_conditions_and_labels(self): self.data["area_info"] = {"areaInfo": {"1f": {"name": "森林", "city": "1", "openStage": "0101"}}, "areaMap": {"1": {"positions": [ {"posId": "city1_wild_1f", "action": "area", "actionPara": {"area": "1f"}, "condition": {"finishTask": ["200"]}}, {"posId": "city1_dungeon1", "action": "dungeon", "actionPara": {"dungeon": "dungeon1"}, "condition": {}}, ]}}} self.data["mine_info"] = {"mines": {"dungeon1": {"pos": "city1_dungeon1", "name": "试炼矿洞"}}} planner = self.planner(step(position="city1_wild_1f", story="linear")) self.assertTrue(planner.plan(self.snapshot, self.policy, self.ranch)[0].block_reason) self.snapshot.raw["history"]["passTask"] = {"200": True} action = planner.plan(self.snapshot, self.policy, self.ranch)[0] self.assertEqual(action.kind, "progression_navigate") self.assertIn("森林", action.location) planner = self.planner(step(position="city1_dungeon1", story="linear")) action = planner.plan(self.snapshot, self.policy, self.ranch)[0] self.assertEqual(action.kind, "progression_navigate") self.assertIn("试炼矿洞", action.location) if __name__ == "__main__": unittest.main()