246 lines
11 KiB
GDScript
246 lines
11 KiB
GDScript
# 双实现对拍配对套件（注册面批同代测速循环批 v1.1——帧相位等价的执行化证据）：
|
||
# 产品码（process_frame 信号步进状态机）vs 夹具（现行 await 形态逐字副本——循环内 await＋收尾四语句在 run() 尾）。
|
||
# 五面对拍（帧索引序列／运行态序列／进度串序列／stats 六键／报告全文）逐位相等＝
|
||
# 每步恰一帧＋相位同点＋输出逐字的当轮真实执行证据（测量语义逐点等价四判据的落码面）。
|
||
# 拓扑钉死：测试宿主先连 process_frame 帧计数、后启动两形态——两形态下「计数先于步进体」相对次序同构，序列可比。
|
||
# n=3 常规案＋n=0 退化案（同步收尾零帧——_mean/_p90 空守卫渲染面）。
|
||
# 运行：godot --headless --path game --script res://tests/unit/presentation/tune_sim_batch_parity_test.gd（expect 0）
|
||
extends SceneTree
|
||
|
||
const Kit := preload("res://tests/unit/test_kit.gd")
|
||
const TuneSimScript := preload("res://presentation/tune_sim_controller.gd")
|
||
|
||
|
||
# 假调试面板（wd8 同形 setter 面＋进度/运行态/报告三记录数组供序列对拍）
|
||
class FakePanel extends Node:
|
||
var running := false
|
||
var progress := ""
|
||
var report := ""
|
||
var atk := 0
|
||
var hp := 0
|
||
var progress_log: Array[String] = []
|
||
var report_log: Array[String] = []
|
||
var running_log: Array[bool] = []
|
||
|
||
func atk_pct() -> int:
|
||
return atk
|
||
|
||
func hp_pct() -> int:
|
||
return hp
|
||
|
||
func set_sim_running(r: bool) -> void:
|
||
running = r
|
||
running_log.append(r)
|
||
|
||
func set_sim_progress(t: String) -> void:
|
||
progress = t
|
||
progress_log.append(t)
|
||
|
||
func set_sim_report(t: String) -> void:
|
||
report = t
|
||
report_log.append(t)
|
||
|
||
|
||
# 假自动策略（固定返回值两档 victory/defeat 交替——wd8 :53-55 同款取值，零随机；
|
||
# 逐局记录帧索引与运行态读数——帧索引经宿主注入的计数 Callable 读取）
|
||
class FakeDriver extends RefCounted:
|
||
var ctrl
|
||
var frame_counter: Callable # 宿主帧计数（0 参 Callable——拓扑钉死：计数先于步进体）
|
||
var seen: Array[bool] = []
|
||
var frames: Array[int] = []
|
||
var calls := 0
|
||
|
||
func run_level(_db: Variant, _seed: int, _level: int, _atk: int, _hp: int, _other: bool, _logger: Variant) -> Dictionary:
|
||
calls += 1
|
||
seen.append(ctrl.is_running())
|
||
frames.append(int(frame_counter.call()))
|
||
if calls % 2 == 1:
|
||
return {"hero_dmg": 12.0, "rounds": 4, "result": "victory", "hp_left": 3.0, "hp_at_boss": 5.0}
|
||
return {"hero_dmg": 6.0, "rounds": 2, "result": "defeat",
|
||
"defeat_node_index": 3, "defeat_node_type": "battle", "hp_left": 0.0, "hp_at_boss": 0.0}
|
||
|
||
|
||
# 假配置库（TuneSimController 只读 db.run.action_economy.ap_per_round——wd8 同款最小域对象图）
|
||
class FakeActionEconomy:
|
||
var ap_per_round := 2
|
||
|
||
|
||
class FakeRun:
|
||
var action_economy := FakeActionEconomy.new()
|
||
|
||
|
||
class FakeDB:
|
||
var run := FakeRun.new()
|
||
|
||
|
||
# 现行 await 形态逐字副本（tune_sim_controller.gd run(n) 改形前形态——循环内 await＋收尾四语句在 run() 尾；
|
||
# 全仓唯一在测夹具——产品码禁留第二实现，tests/ 不在 S13/S8/S9/S10 扫描面、夹具内循环 await 合法在册）。
|
||
# 与产品码新形态的申报差异仅一处：批末把 stats 六键束存 out_stats 成员供对拍读取
|
||
# （产品码 stats 经报告公开面观测——内部字段直查受控例外申报在卡 §17）。
|
||
class AwaitLoopRunner extends RefCounted:
|
||
const SEED_BASE := 4200
|
||
const ParityLogger := preload("res://presentation/playtest_logger.gd")
|
||
var db
|
||
var panel
|
||
var _base_hp := 0
|
||
var _driver = null
|
||
var _running := false
|
||
var out_stats: Dictionary = {}
|
||
|
||
func _init(db_ref, panel_ref, base_hp: int, driver = null) -> void:
|
||
db = db_ref
|
||
panel = panel_ref
|
||
_base_hp = base_hp
|
||
_driver = driver
|
||
|
||
func is_running() -> bool:
|
||
return _running
|
||
|
||
func run(n: int) -> void:
|
||
_running = true
|
||
var logger = ParityLogger.new()
|
||
logger.ap_per_round = int(db.run.action_economy.ap_per_round)
|
||
logger.start_session(SEED_BASE)
|
||
panel.set_sim_running(true)
|
||
panel.set_sim_progress("模拟中：0/%d …" % n)
|
||
var stats := {"wins": 0, "dmg_all": [], "hp_left_win": [], "hp_boss": [], "rounds_all": [], "death_nodes": {}}
|
||
var autoplay = _driver
|
||
for i in range(n):
|
||
_run_one_level(autoplay, stats, i, panel, logger)
|
||
panel.set_sim_progress("模拟中：%d/%d …" % [i + 1, n])
|
||
await panel.get_tree().process_frame
|
||
logger.close_session()
|
||
panel.set_sim_report(HudPresenter.tune_sim_report(n, panel.atk_pct(), panel.hp_pct(), stats, _base_hp))
|
||
panel.set_sim_running(false)
|
||
_running = false
|
||
out_stats = stats
|
||
|
||
func _run_one_level(autoplay, stats: Dictionary, i: int, panel, logger) -> void: # type-hint: ignore（驱动/面板/日志件鸭子型注入——同产品码构造缝）
|
||
var st = autoplay.run_level(db, SEED_BASE + i, 1, panel.atk_pct(), panel.hp_pct(), false, logger)
|
||
(stats["dmg_all"] as Array).append(st.hero_dmg)
|
||
(stats["rounds_all"] as Array).append(st.rounds)
|
||
if st.result == "victory":
|
||
stats["wins"] = int(stats["wins"]) + 1
|
||
(stats["hp_left_win"] as Array).append(st.hp_left)
|
||
(stats["hp_boss"] as Array).append(st.hp_at_boss)
|
||
elif st.result == "defeat":
|
||
var key := "%d.%s" % [st.defeat_node_index, st.defeat_node_type]
|
||
stats["death_nodes"][key] = int(stats["death_nodes"].get(key, 0)) + 1
|
||
|
||
|
||
func _init() -> void:
|
||
var frame_idx := {"i": -1} # 帧计数（宿主最先连——拓扑钉死「计数先于步进体」）
|
||
process_frame.connect(func() -> void: frame_idx["i"] += 1)
|
||
await process_frame # 树初始化就绪帧（SceneTree._init 时点 root 未挂树——面板 get_tree() 首帧后才有效；wd8 同款先例：panel 段前有 await 过帧）
|
||
var r3 := await _run_pair(3, frame_idx)
|
||
_check_n3(r3)
|
||
var r0 := await _run_pair(0, frame_idx)
|
||
_check_n0(r0)
|
||
quit(Kit.finish("tune_sim_batch_parity"))
|
||
|
||
|
||
# 对拍驱动：两形态各经 run(n) 真实入口（同参假面板/假驱动各自实例）；先启动两形态、后分别 await——
|
||
# 两形态在调用点同一同步段内先后挂起（并行于同一帧时钟），驱动协程返回 int 承接 void run 的可等待面
|
||
func _run_pair(n: int, frame_idx: Dictionary) -> Dictionary:
|
||
# 两形态串行驱动（各经 run(n) 真实入口 await 调用——GDScript 协程动态调用必须 await，
|
||
# 无并行启动形态）：帧序列各自记录、断言按相对首帧偏移归一后逐位比对——拓扑不变式
|
||
# 「计数先连、启动后于计数、计数先于步进体」在两形态下相对次序同构，等价证据结构不变。
|
||
var panel_a := FakePanel.new()
|
||
root.add_child(panel_a)
|
||
var drv_a := FakeDriver.new()
|
||
var a: Variant = TuneSimScript.new(FakeDB.new(), panel_a, 100, drv_a)
|
||
drv_a.ctrl = a
|
||
drv_a.frame_counter = func() -> int: return frame_idx["i"]
|
||
await a.run(n)
|
||
var panel_b := FakePanel.new()
|
||
root.add_child(panel_b)
|
||
var drv_b := FakeDriver.new()
|
||
var b: Variant = AwaitLoopRunner.new(FakeDB.new(), panel_b, 100, drv_b)
|
||
drv_b.ctrl = b
|
||
drv_b.frame_counter = func() -> int: return frame_idx["i"]
|
||
await b.run(n)
|
||
return {"a": a, "b": b, "pa": panel_a, "pb": panel_b, "da": drv_a, "db": drv_b}
|
||
|
||
|
||
func _check_n3(r: Dictionary) -> void:
|
||
var pa: FakePanel = r["pa"]
|
||
var pb: FakePanel = r["pb"]
|
||
var da: FakeDriver = r["da"]
|
||
var drv_b: FakeDriver = r["db"]
|
||
var a = r["a"]
|
||
var b = r["b"]
|
||
Kit.check("n=3 帧序列相对偏移逐位相等（%s vs %s）＋相邻差恒一（每步恰一帧）〔测速 V1〕",
|
||
str(_norm(da.frames)) == str(_norm(drv_b.frames)) and da.frames.size() == 3
|
||
and _consecutive(da.frames) and _consecutive(drv_b.frames))
|
||
Kit.check("n=3 运行态读数序列逐位相等＋收尾双运行态假＋面板置假序列同构〔测速 V2〕",
|
||
str(da.seen) == str(drv_b.seen) and da.seen == [true, true, true]
|
||
and not a.is_running() and not b.is_running()
|
||
and not pa.running and not pb.running
|
||
and str(pa.running_log) == str(pb.running_log))
|
||
Kit.check("n=3 进度串序列逐位相等（%d 段）〔测速 V3〕",
|
||
str(pa.progress_log) == str(pb.progress_log) and pa.progress_log.size() == 4)
|
||
var got: Dictionary = r["b"].out_stats
|
||
var deaths: Dictionary = got.get("death_nodes", {})
|
||
Kit.check("n=3 夹具 stats 六键与按假驱动固定返回值重算的期望逐键相等〔测速 V4〕",
|
||
int(got.get("wins", -1)) == 2
|
||
and _arr_eq(got.get("dmg_all"), [12.0, 6.0, 12.0])
|
||
and _arr_eq(got.get("hp_left_win"), [3.0, 3.0])
|
||
and _arr_eq(got.get("hp_boss"), [5.0, 5.0])
|
||
and _arr_eq(got.get("rounds_all"), [4, 2, 4])
|
||
and deaths.size() == 1 and int(deaths.get("3.battle", -1)) == 1)
|
||
Kit.check("n=3 报告全文逐字相等且含渲染面四关键串〔测速 V5〕",
|
||
pa.report == pb.report and pa.report != ""
|
||
and pa.report.contains("关卡完成率") and pa.report.contains("关卡完成剩余 HP 均")
|
||
and pa.report.contains("败北节点") and pa.report.contains("N=3"))
|
||
|
||
|
||
func _check_n0(r: Dictionary) -> void:
|
||
var pa: FakePanel = r["pa"]
|
||
var pb: FakePanel = r["pb"]
|
||
var da: FakeDriver = r["da"]
|
||
var drv_b: FakeDriver = r["db"]
|
||
var a = r["a"]
|
||
var b = r["b"]
|
||
Kit.check("n=0 退化：两形态驱动零回调、帧索引序列空（同步收尾零帧）〔测速 V1〕",
|
||
da.frames.is_empty() and drv_b.frames.is_empty() and da.calls == 0 and drv_b.calls == 0)
|
||
Kit.check("n=0 运行态置假序列 [true, false] 双形态同构＋收尾双假〔测速 V2〕",
|
||
str(pa.running_log) == str(pb.running_log) and pa.running_log == [true, false]
|
||
and not a.is_running() and not b.is_running())
|
||
Kit.check("n=0 进度串单段逐字相等〔测速 V3〕",
|
||
str(pa.progress_log) == str(pb.progress_log) and pa.progress_log == ["模拟中：0/0 …"])
|
||
Kit.check("n=0 夹具 stats 六键零计〔测速 V4〕",
|
||
int((r["b"].out_stats as Dictionary).get("wins", -1)) == 0
|
||
and ((r["b"].out_stats as Dictionary).get("dmg_all") as Array).is_empty()
|
||
and ((r["b"].out_stats as Dictionary).get("hp_left_win") as Array).is_empty()
|
||
and ((r["b"].out_stats as Dictionary).get("hp_boss") as Array).is_empty()
|
||
and ((r["b"].out_stats as Dictionary).get("rounds_all") as Array).is_empty()
|
||
and ((r["b"].out_stats as Dictionary).get("death_nodes") as Dictionary).is_empty())
|
||
Kit.check("n=0 报告全文逐字相等且非空（空 stats 渲染面）〔测速 V5〕",
|
||
pa.report == pb.report and pa.report != "")
|
||
|
||
# 帧序列归一（相对首帧偏移——串行驱动下两形态帧段错位、结构可比性归一承载）
|
||
func _norm(fr: Array) -> Array:
|
||
var out: Array = []
|
||
var base := int(fr[0]) if fr.size() > 0 else 0
|
||
for i in fr.size():
|
||
out.append(int(fr[i]) - base)
|
||
return out
|
||
|
||
|
||
# 相邻差恒一（每步恰占一帧——判据①的序列面证据）
|
||
func _consecutive(fr: Array) -> bool:
|
||
for i in range(1, fr.size()):
|
||
if int(fr[i]) - int(fr[i - 1]) != 1:
|
||
return false
|
||
return true
|
||
|
||
# 数组逐元素浮点比对（stats 桶重算期望——类型化比较，消 str 形态歧义）
|
||
func _arr_eq(a, b: Array) -> bool:
|
||
var aa := a as Array
|
||
if aa == null or aa.size() != b.size():
|
||
return false
|
||
for i in b.size():
|
||
if absf(float(aa[i]) - float(b[i])) > 0.0001:
|
||
return false
|
||
return true
|