Add offline battle estimates and passive phone sample analysis

This commit is contained in:
AttilaNet
2026-11-08 16:50:14 +08:00
parent 45a7f2dfa4
commit 79b7672471
10 changed files with 1142 additions and 5 deletions
@@ -0,0 +1,205 @@
import copy
from contextlib import redirect_stdout
import io
import json
from types import SimpleNamespace
import unittest
from unittest.mock import patch
from ranch_assistant.api import DEFAULT_KEY, encode
from ranch_assistant.tests.test_core import workspace_temp
from tools.capture_battle_proxy import BattleCapture
from tools.compare_battle_v12 import compare, main, observations
END = "battleService/battleEnd"
def battle():
return {"battlePosition": {"battleType": "stage", "stageId": "0101", "stageLevel": "1"},
"battleMonIds": [11, 12], "win": True, "leftTime": 275000, "aliveNum": 2,
"apLeft": 5, "killMonster": {"1001010": 5}, "cheatNum": 0}
def events(value=None, code=0):
return [{"kind": "request", "operation": END, "request_id": "fixture-1", "capture_origin": "phone_proxy",
"body": {"battleData": battle() if value is None else value, "token": "sensitive-token"}},
{"kind": "response", "operation": END, "request_id": "fixture-1", "body": {"resCode": code, "costTi": 10}}]
def estimate(ids=(11, 12)):
return {"format": "myrzx-offline-basic-attack-estimate", "stage": {"id": "0101", "difficulty": "1"},
"players": [{"instance_id": mid} for mid in ids], "configured_time_limit_seconds": 300,
"duration_seconds_by_predicted_outcome": {"win": {"median": 20, "p10": 18, "p90": 23}}}
class Message:
def __init__(self, content):
self.content = content
def get_content(self):
return self.content
def flow(request, response, url="https://prod-dyd-1.dydab.com:9091/" + END):
req = Message(request)
req.pretty_url = url
res = Message(response)
res.status_code = 200
return SimpleNamespace(id="fixture-flow", request=req, response=res)
class BattleCaptureTests(unittest.TestCase):
def test_encrypted_capture_decodes_redacts_and_never_changes_or_sends_the_flow(self):
with workspace_temp() as folder, patch("socket.socket", side_effect=AssertionError("Unexpected network")):
capture = BattleCapture(folder, DEFAULT_KEY)
exchange = flow(encode({"token": "capture-private-token", "battleData": battle()}, DEFAULT_KEY),
encode({"resCode": 0, "reward": {}}, DEFAULT_KEY))
before = (exchange.request.content, exchange.response.content)
capture.request(exchange)
capture.response(exchange)
self.assertEqual((exchange.request.content, exchange.response.content), before)
text = capture.trace.path.read_text(encoding="utf-8")
self.assertNotIn("capture-private-token", text)
self.assertNotIn(DEFAULT_KEY, text)
rows = [json.loads(line) for line in text.splitlines()]
self.assertEqual(rows[0]["body"]["battleData"], battle())
samples, diagnostics = observations(rows)
self.assertEqual(len(samples), 1)
self.assertEqual(diagnostics, {})
def test_plain_json_is_supported_and_query_strings_are_not_saved(self):
with workspace_temp() as folder:
capture = BattleCapture(folder)
exchange = flow(json.dumps({"battleData": battle()}).encode(), b'{"resCode":0}',
url="https://prod-dyd-1.dydab.com:9091/" + END + "?token=query-secret")
capture.request(exchange)
self.assertNotIn("query-secret", capture.trace.path.read_text(encoding="utf-8"))
def test_other_hosts_login_and_payment_paths_are_ignored(self):
with workspace_temp() as folder:
capture = BattleCapture(folder)
for url in ("https://prod-dyd-1.dydab.com.evil.test/" + END,
"https://unrelated.test/" + END,
"https://prod-dyd-1.dydab.com:9091/userServerService/loginUser",
"https://prod-dyd-1.dydab.com:9091/paymentService/pay"):
exchange = flow(b'{"token":"secret"}', b'{}', url)
capture.request(exchange)
capture.response(exchange)
self.assertFalse(capture.trace.events)
self.assertFalse(capture.trace.path.exists())
def test_decode_failure_does_not_retain_raw_body(self):
with workspace_temp() as folder:
capture = BattleCapture(folder)
capture.request(flow(b"raw-private-body", b"{}"))
text = capture.trace.path.read_text(encoding="utf-8")
self.assertNotIn("raw-private-body", text)
self.assertEqual(capture.trace.events[0]["kind"], "error")
def test_pause_marker_stops_recording_without_modifying_the_flow(self):
with workspace_temp() as folder:
capture = BattleCapture(folder)
exchange = flow(b'{"battleData":{}}', b'{"resCode":0}')
capture.trace.path.with_name("capture.paused").touch()
capture.request(exchange)
capture.response(exchange)
self.assertFalse(capture.trace.events)
self.assertEqual(exchange.request.content, b'{"battleData":{}}')
def test_readiness_probe_decodes_but_retains_no_game_or_account_body(self):
with workspace_temp() as folder:
capture = BattleCapture(folder)
exchange = flow(encode({"token": "probe-token", "masterId": 1234567}, DEFAULT_KEY),
encode({"resCode": 0, "private": "probe-private-data"}, DEFAULT_KEY),
url="https://prod-dyd-1.dydab.com:9091/heartBeatService/keepAlive")
capture.request(exchange)
capture.response(exchange)
rows = list(capture.trace.events)
self.assertTrue(all(row["kind"] == "diagnostic" and row["decoded"] for row in rows))
self.assertEqual(rows[1]["resCode"], 0)
text = capture.trace.path.read_text(encoding="utf-8")
for value in ("probe-token", "1234567", "probe-private-data", '"body"'):
self.assertNotIn(value, text)
class BattleComparisonTests(unittest.TestCase):
def test_successful_request_and_response_are_paired_without_mutation_or_secrets(self):
source = events()
before = copy.deepcopy(source)
samples, diagnostics = observations(source)
self.assertEqual(source, before)
self.assertEqual(diagnostics, {})
self.assertEqual(len(samples), 1)
self.assertNotIn("sensitive-token", json.dumps(samples))
def test_missing_or_failed_response_is_not_a_confirmed_sample(self):
self.assertEqual(observations(events()[:1])[0], [])
self.assertEqual(observations(events(code=997))[0], [])
def test_sweep_shaped_data_cannot_be_used_as_a_real_battle_sample(self):
value = battle()
value.update(leftTime=0, aliveNum=0, apLeft=0, killMonster={})
samples, diagnostics = observations(events(value))
self.assertEqual(samples, [])
self.assertEqual(diagnostics["sweep_or_ambiguous_empty_result"], 1)
def test_duplicate_flow_is_not_counted_twice(self):
source = events()
samples, diagnostics = observations(source + source)
self.assertEqual(len(samples), 1)
self.assertEqual(diagnostics["duplicate_request"], 1)
def test_elapsed_time_is_derived_from_millisecond_combat_clock(self):
sample = observations(events())[0][0]
result = compare(estimate(), sample, client_variant="original")
self.assertEqual(result["status"], "compared")
self.assertEqual(result["observed_clock_elapsed_seconds"], 25)
self.assertEqual(result["absolute_time_error_seconds"], 5)
self.assertAlmostEqual(result["relative_time_error"], .2)
self.assertFalse(result["same_attributes_and_resource_version_verified"])
def test_other_rosters_stages_and_task_contexts_are_not_mixed(self):
sample = observations(events())[0][0]
self.assertEqual(compare(estimate((99,)), sample)["status"], "different_roster")
other = estimate()
other["stage"]["difficulty"] = "2"
self.assertEqual(compare(other, sample)["status"], "different_stage_or_difficulty")
sample["position"]["battleType"] = "task"
self.assertEqual(compare(estimate(), sample)["status"], "task_context_requires_separate_mapping")
def test_missing_roster_identity_is_only_an_exploratory_comparison(self):
result = compare(estimate((None, None)), observations(events())[0][0], client_variant="original")
self.assertEqual(result["status"], "exploratory_roster_unverified")
def test_missing_and_out_of_range_timing_is_rejected(self):
sample = observations(events())[0][0]
for remaining in (None, -1, 300001, float("nan")):
sample["reported"]["leftTime"] = remaining
self.assertEqual(compare(estimate(), sample)["status"], "invalid_or_missing_timing")
def test_modified_client_is_retained_as_protocol_evidence_without_timing_comparison(self):
sample = observations(events())[0][0]
result = compare(estimate(), sample, client_variant="modified")
self.assertEqual(result["status"], "modified_client_not_calibratable")
self.assertNotIn("relative_time_error", result)
def test_unverified_client_is_not_counted_as_an_aligned_comparison(self):
result = compare(estimate(), observations(events())[0][0])
self.assertEqual(result["status"], "exploratory_client_unverified")
def test_protocol_only_cli_keeps_variant_and_samples_without_network_or_model(self):
with workspace_temp() as folder, patch("socket.socket", side_effect=AssertionError("Unexpected network")):
capture, output = folder / "capture.jsonl", folder / "report.json"
capture.write_text("\n".join(json.dumps(row) for row in events()), encoding="utf-8")
with redirect_stdout(io.StringIO()):
code = main(["--capture", str(capture), "--client-variant", "modified", "--output", str(output)])
report = json.loads(output.read_text(encoding="utf-8"))
self.assertEqual(code, 0)
self.assertEqual(report["capture_client_variant"], "modified")
self.assertEqual(report["accepted_settlement_sample_count"], 1)
self.assertEqual(report["aligned_roster_comparison_count"], 0)
self.assertIsNone(report["median_relative_time_error"])
if __name__ == "__main__":
unittest.main()
@@ -0,0 +1,129 @@
from contextlib import redirect_stdout
from dataclasses import asdict, replace
import io
import json
import unittest
from unittest.mock import patch
from tools.battle_estimate_v12 import Fighter, Rules, demo_player, hit_damage, main, simulate
from ranch_assistant.tests.test_core import workspace_temp
class MidpointRandom:
def __init__(self, critical=False):
self.critical = critical
def random(self):
return 0 if self.critical else .99
def uniform(self, low, high):
return (low + high) / 2
def fighter(**changes):
return replace(Fighter(1001010, "fixture", 100, 100, 20, 10, 1000), **changes)
RULES = Rules(.95, .25, 1.5, 1.15, {1: 2, 2: 4, 3: 1, 4: 3, 5: 0})
class BattleEstimateTests(unittest.TestCase):
def test_base_damage_matches_source_formula_at_midpoint(self):
# 100 * .95 - 20 * (.25 * .75 + .25 * .125) = 90.625.
self.assertEqual(hit_damage(fighter(), fighter(), RULES, MidpointRandom()), 91)
def test_critical_attack_is_applied_before_the_defense_roll(self):
self.assertEqual(hit_damage(fighter(), fighter(), RULES, MidpointRandom(True)), 138)
def test_dex_advantage_and_disadvantage_change_the_damage_range(self):
self.assertEqual(hit_damage(fighter(dex=50), fighter(), RULES, MidpointRandom()), 98)
self.assertEqual(hit_damage(fighter(dex=0), fighter(dex=40), RULES, MidpointRandom()), 84)
def test_extreme_dex_difference_is_capped(self):
rng = MidpointRandom()
self.assertEqual(hit_damage(fighter(dex=90), fighter(), RULES, rng),
hit_damage(fighter(dex=900), fighter(), RULES, rng))
def test_high_defense_cannot_reduce_base_damage_below_one(self):
self.assertEqual(hit_damage(fighter(atk=1), fighter(defense=100000), RULES, MidpointRandom()), 1)
def test_element_counter_uses_the_attacker_element(self):
attack = fighter(element=1)
self.assertGreater(hit_damage(attack, fighter(element=2), RULES, MidpointRandom()),
hit_damage(attack, fighter(element=3), RULES, MidpointRandom()))
def test_win_is_derived_from_kills_and_credits_only_actual_hp_lost(self):
strong = fighter(hp=10000, atk=10000, attack_ms=100)
result = simulate([strong], [fighter()], RULES, seed=1, timeout_ms=10000, enemy_capacity=1)
self.assertEqual(result["predicted_outcome"], "win")
self.assertEqual(result["enemy_kills"], 1)
self.assertEqual(result["player_damage"], 100)
self.assertEqual(result["model_duration_seconds"], .1)
def test_a_weak_roster_can_lose(self):
result = simulate([fighter(hp=1, atk=1)], [fighter(hp=10000)], RULES,
seed=1, timeout_ms=10000, enemy_capacity=1)
self.assertEqual(result["predicted_outcome"], "loss")
self.assertEqual(result["player_survivors"], 0)
def test_timeout_happens_before_an_attack_at_the_same_deadline(self):
result = simulate([fighter(atk=100000)], [fighter()], RULES,
seed=1, timeout_ms=1000, enemy_capacity=1)
self.assertEqual(result["predicted_outcome"], "timeout")
self.assertEqual(result["resolved_hits"], 0)
def test_wave_gap_and_enemy_capacity_are_respected(self):
result = simulate([fighter(hp=10000, atk=10000, attack_ms=100)],
[fighter(), fighter(), fighter(wave=2)], RULES, seed=1, timeout_ms=10000, enemy_capacity=1)
self.assertEqual(result["enemy_kills"], 3)
self.assertEqual(result["model_duration_seconds"], 1.0)
def test_fixed_seed_is_reproducible_and_does_not_mutate_roster(self):
team, enemies = [fighter()], [fighter()]
before = [asdict(x) for x in team + enemies]
first = simulate(team, enemies, RULES, seed=12, timeout_ms=10000, enemy_capacity=1)
self.assertEqual(first, simulate(team, enemies, RULES, seed=12, timeout_ms=10000, enemy_capacity=1))
self.assertEqual([asdict(x) for x in team + enemies], before)
def test_invalid_units_and_empty_teams_are_rejected(self):
for field, value in (("hp", 0), ("attack_ms", 0), ("atk", float("nan")), ("crit", float("inf"))):
with self.assertRaises(ValueError):
fighter(**{field: value})
with self.assertRaises(ValueError):
simulate([], [fighter()], RULES, seed=1, timeout_ms=1000, enemy_capacity=1)
def test_catalog_example_uses_mean_growth_without_changing_source(self):
row = {"type": 1, "name": "fixture", "element": 5, "spd_atk": 1600,
**{key: 10 for key in ("atk", "def", "hp", "dex")},
**{key + suffix: value for key in ("atk", "def", "hp", "dex")
for suffix, value in (("_grow_min", 2), ("_grow_max", 4))}}
before = dict(row)
unit = demo_player(row, 3)
self.assertEqual((unit.atk, unit.defense, unit.hp, unit.dex), (16, 16, 16, 16))
self.assertEqual(unit.attack_ms, 1588)
self.assertEqual(row, before)
def test_cli_cannot_call_network_and_labels_results_as_uncalibrated_estimates(self):
tables = {"monster_info": {"1": {"type": 1, "name": "fixture", "element": 5, "spd_atk": 1000, "skill_1": 3,
**{key: 100 for key in ("atk", "def", "hp", "dex")},
**{key + suffix: 1 for key in ("atk", "def", "hp", "dex") for suffix in ("_grow_min", "_grow_max")}}}}
scenario = (tables, {}, {"name": "fixture"}, [fighter()], RULES, 10000, 1, set())
with workspace_temp() as folder, patch("tools.battle_estimate_v12.load_scenario", return_value=scenario), \
patch("socket.socket", side_effect=AssertionError("Offline model attempted a socket")), redirect_stdout(io.StringIO()):
output = folder / "estimate.json"
self.assertEqual(main(["--apk", "fixture.apk", "--species", "1", "--trials", "2", "--output", str(output)]), 0)
report = json.loads(output.read_text(encoding="utf-8"))
self.assertTrue(report["approximate"])
self.assertFalse(report["calibrated_against_original_runtime"])
self.assertNotIn("battleData", report)
self.assertNotIn("token", report)
self.assertEqual(sum(v["count"] for v in report["duration_seconds_by_predicted_outcome"].values()), 2)
team = folder / "team.json"
team.write_text(json.dumps([asdict(fighter(species=1))]), encoding="utf-8")
self.assertEqual(main(["--apk", "fixture.apk", "--team", str(team), "--trials", "2", "--output", str(output)]), 0)
report = json.loads(output.read_text(encoding="utf-8"))
self.assertEqual(report["ignored_skill_ids_from_catalog"], [3])
if __name__ == "__main__":
unittest.main()