diff --git a/game/core/save_manager.gd b/game/core/save_manager.gd index f381145e..5a8a72d1 100644 --- a/game/core/save_manager.gd +++ b/game/core/save_manager.gd @@ -1,5 +1,6 @@ ## VERTICAL SLICE - NOT FOR PRODUCTION -## 存档唯一实现：JSON 单档写入/读回/版本迁移/损坏兜底，Core 层零 UI 零玩法依赖（垂直切片验证：进度跨进程存活）。 +## 存档唯一实现：3 存档位 JSON 承载（激活槽写入/读回/版本迁移/损坏兜底/旧单档一次性迁移）， +## Core 层零 UI 零玩法依赖（垂直切片验证：进度跨进程存活）。 ## 禁 preload/import 任何玩法脚本、禁碰 ConfigDB/RngService——须可独立实例化独立验证。 ## 新增存档键先在序列化函数登记并升版本号；键域内容口径归各 GDD 文档，本类照单承载。 ## 存档键清单的事实源=本类序列化/读回代码，不在任何文档维护第二份键清单。 @@ -12,14 +13,22 @@ const SUMMARY_CAP := 10 # 最近冒险摘要保留条数（最新在前 const TREE_STRUCT_VERSION := 2 # 树结构版本标记（12 节点 v0.8 结构；加载检测缺失 # 或更低 = 换代前结构 → 树域破坏性废弃重置〔契约 4：禁迁移禁折算〕） -var _path: String # 存档文件路径（默认 user://save.json；冒烟注入隔离路径） +const SLOT_COUNT := 3 # 存档位数写死 3（用户裁决 2——禁参数化扩位，扩位=新裁点另立） +const SLOT_PATH_TEMPLATE := "user://save_slot_%d.json" # 槽文件名唯一派生模板（槽 1 禁复用旧单档名——Q1 乙前提防误读；探针面禁各自拼槽名，测试隔离走 attach_slot_template 注入口） +const LEGACY_SAVE_PATH := "user://save.json" # 旧隐式单档路径（Q1 甲：首次启动一次性字节迁入槽 1，此后无任何隐式读写） +const LEGACY_MIGRATED_SUFFIX := ".migrated.bak" # 迁移后旧档改名留痕后缀（字节级留盘不删——处置留痕） + +var _path: String # 当前写盘目标=激活槽文件（或 attach_path 注入路径）；""=无激活态——一切写盘路径拒绝 +var _active_slot := 0 # 激活槽号 1..SLOT_COUNT；0=无激活态（注入非槽派生名路径时亦 0——写盘判定以 _path 非空为准） var _read_only := false # 高版本拒读置位——write_to_disk 一律拒绝（契约 4 禁写） var _data: Dictionary[String, Variant] = {} # 内存数据模型（_init 即内置默认；load 后为档案内容） var _migrations: Dictionary[int, Callable] = {} # from_version → Callable(data)->data（升一版；v1→v6 生产迁移链现行——_init 自注册） +var _slot_template := SLOT_PATH_TEMPLATE # 槽文件名模板（生产=常量；测试经 attach_slot_template 注入隔离命名空间，禁在呈现层/探针各自拼槽名） -func _init(path: String = "user://save.json") -> void: +func _init(path: String = "") -> void: _path = path + _active_slot = _slot_index_of(path) _data = _default_data() # 生产迁移链自注册（v2 起——测试钩 register_migration 仍可叠挂更早版本步骤） register_migration(1, _migrate_v1_v2) @@ -31,21 +40,177 @@ func _init(path: String = "user://save.json") -> void: # autoload 生命周期（SaveManager 为跨场景持有者，仿 RngService 先例： -# 类名加 Core 后缀、autoload 占净名；读盘挂 _ready=autoload 先于主场景就绪）。独立 -# .new() 实例（单测/工具）不入树零 _ready，读盘仍由调用方显式触发。 +# 类名加 Core 后缀、autoload 占净名）。独立 .new() 实例（单测/工具）不入树零 _ready， +# 读盘仍由调用方显式触发。 +# 启动态钉死（卡① sv2）：autoload 启动不读任何槽——内存=默认合法空态（_init 置好）、 +# 无激活态（_path=""，一切写盘路径拒绝并返回 false）；玩家侧经选档界面显式进档/新档后才可写。 +# 旧隐式单档一次性迁入槽 1（Q1 甲，sv12）在本口执行。 func _ready() -> void: - load_from_disk() + _migrate_legacy_save(LEGACY_SAVE_PATH, slot_path(1), LEGACY_SAVE_PATH + LEGACY_MIGRATED_SUFFIX) # 原地重置（探针隔离面，仿 RngService.set_master_seed 单例原地重置： -# 换路径+回默认数据+重读盘；对象引用恒定，MetaProgression 持有的 save 引用零失效） +# 换路径+回默认数据+重读盘；对象引用恒定，MetaProgression 持有的 save 引用零失效）。 +# 三槽化后单路径语义（契约 7）＝注入路径即激活槽文件（写盘落该路径、无激活态时注入即激活）； +# 注入槽派生名时激活号同步记账，注入任意隔离路径时激活号 0（写盘仍合法——隔离面行为零变化）。 func attach_path(path: String) -> void: _path = path _read_only = false + _active_slot = _slot_index_of(path) _data = _default_data() load_from_disk() +# 测试隔离注入口（契约 7 同源——槽文件名模板整体换注，探针/单测经此隔离到自命名空间， +# 禁各自拼槽文件名；换注后回无激活态，槽原语全部落注入命名空间） +func attach_slot_template(template: String) -> void: + _slot_template = template + _path = "" + _active_slot = 0 + _read_only = false + _data = _default_data() + + +# ---- 三存档位承载（卡①：隐式单档 → 3 存档位；位数与文件名口径=SLOT_COUNT/SLOT_PATH_TEMPLATE）---- + +# 槽文件路径唯一派生口（模板单点——禁第二处拼名） +func slot_path(slot: int) -> String: + return _slot_template % slot + + +# 激活槽号查询（0 = 无激活态——启动态钉死后 boot 需经选档显式进档/新档，卡③ Q1 甲） +func active_slot() -> int: + return _active_slot + + +# 写盘目标在位与否（激活槽或注入路径任一；无激活态一切写盘路径拒绝——sv3 判定口） +func has_write_target() -> bool: + return _path != "" + + +# 进档原语（sv5，契约 6/8）：激活槽 N＋读盘，复用 load_from_disk 迁移/兜底链按槽成立。 +# 高版本拒读槽：激活不成立、恢复切换前三态（路径/激活号/禁写位/数据）——防误写他槽； +# 损坏槽：兜底链接管（.corrupt.bak 改名＋空态继续，激活成立）。 +func activate_slot(slot: int) -> bool: + if slot < 1 or slot > SLOT_COUNT: + return false + var prev_path := _path + var prev_slot := _active_slot + var prev_ro := _read_only + var prev_data := _data + _path = slot_path(slot) + _active_slot = slot + _read_only = false + _data = _default_data() + if not load_from_disk(): + _path = prev_path + _active_slot = prev_slot + _read_only = prev_ro + _data = prev_data + return false + return true + + +# 新档原语（sv4）：空槽创建=合法白板态（_default_data 全零可玩纪律），创建即激活并落盘。 +# 生产路径只在空槽调用（有档槽开新局=先删档回空再新档，卡③ 契约 4）；写盘失败回退切换前三态。 +func create_slot(slot: int) -> bool: + if slot < 1 or slot > SLOT_COUNT: + return false + var prev_path := _path + var prev_slot := _active_slot + var prev_ro := _read_only + var prev_data := _data + _path = slot_path(slot) + _active_slot = slot + _read_only = false + _data = _default_data() + if not write_to_disk(): + _path = prev_path + _active_slot = prev_slot + _read_only = prev_ro + _data = prev_data + return false + return true + + +# 删档原语（sv6，契约 8）：该槽文件删除＋盘面即时生效（卡内工程规定，挪用现役断点覆盖流语义） +# ＋无 .tmp 残留；删激活槽时激活指针连清除（内存回默认空态，该槽不再可写——激活态生命周期终点）。 +# .corrupt.bak 损坏备份不追删（用户数据留盘可考；同槽再损坏时兜底流按槽覆盖同名备份）。 +# 删不存在文件的空槽=幂等成功；越界槽号拒绝。 +func delete_slot(slot: int) -> bool: + if slot < 1 or slot > SLOT_COUNT: + return false + var p := slot_path(slot) + if FileAccess.file_exists(p) and not _remove_file(p): + push_error("[存档序列化] 删档失败（文件删除被拒）：%s" % p) + return false + var tmp := p + ".tmp" + if FileAccess.file_exists(tmp): + _remove_file(tmp) # 残留清偿尽力而为（主文件已删即达成空槽语义） + if _active_slot == slot: + _path = "" + _active_slot = 0 + _data = _default_data() + return true + + +# 摘要三项按槽窥视读器（sv7/sv8，契约 5/9）：钥石余额/通关局数/冒险总局数。 +# 只读零副作用：不激活、不写盘、不触发 _corrupt_fallback 改名（.corrupt.bak 只在正式进档路径产生）。 +# 返回 {"readable", "keystone", "cleared", "total"}——readable=true=可读槽（空槽=零值合法态， +# .tmp 残留按空槽——主文件不在即空）；readable=false=不可读槽（损坏/高版本/缺版本字段/打开失败， +# 三值无意义——卡③ Q2 裁甲：UI 按空槽呈现，进档时走正式 load 兜底/拒读链）。 +# 迁移链在此只读推演（生产迁移 Callable 为纯函数，零盘面副作用）。 +func peek_slot_summary(slot: int) -> Dictionary: + if slot < 1 or slot > SLOT_COUNT: + return {"readable": false, "keystone": 0, "cleared": 0, "total": 0} # 越界=非槽位，非空槽 + return _peek_summary_at(slot_path(slot)) + + +# 窥视注入口（契约 7 隔离面同款——测试/探针经路径注入隔离，禁各自拼槽文件名） +func peek_summary_at(path: String) -> Dictionary: + return _peek_summary_at(path) + + +func _peek_summary_at(path: String) -> Dictionary: + var out := {"readable": false, "keystone": 0, "cleared": 0, "total": 0} + if not FileAccess.file_exists(path): + out["readable"] = true # 空槽=可读零值合法态 + return out + var f := FileAccess.open(path, FileAccess.READ) + if f == null: + return out + var text := f.get_as_text() + f.close() + var parsed = JSON.parse_string(text) + if typeof(parsed) != TYPE_DICTIONARY or not parsed.has("version"): + return out + var v := int(parsed["version"]) + if v > SAVE_FORMAT_VERSION: + return out + while v < SAVE_FORMAT_VERSION: + if not _migrations.has(v): + return out + var stepped = _migrations[v].call(parsed) + if typeof(stepped) != TYPE_DICTIONARY: + return out + parsed = stepped + v = int(parsed.get("version", v + 1)) + var norm := _normalize(parsed) + out["readable"] = true + out["keystone"] = int(norm["meta"].get("keystone_balance", 0)) + out["cleared"] = int(norm["meta"].get("adventure_cleared", 0)) + out["total"] = int(norm["meta"].get("adventure_total", 0)) + return out + + +# 注入路径的槽号反查（命中槽派生名返回槽号，否则 0——激活号记账用，写盘判定以 _path 非空为准） +func _slot_index_of(path: String) -> int: + for i in range(1, SLOT_COUNT + 1): + if path == slot_path(i): + return i + return 0 + + # v1→v2：断点域出生（旧档无断点 = 合法空态——「继续上局」隐藏，非损坏非债务） func _migrate_v1_v2(data: Dictionary) -> Dictionary: if not data.has("breakpoint"): @@ -144,7 +309,7 @@ func mark_first_adventure_done() -> void: _data["meta"]["first_adventure_done"] = true -# ---- 读盘（启动时调用）---- +# ---- 读盘（进档/注入时调用；启动态不读——_ready 已钉死不隐式激活）---- # 返回 true = 已就绪可用（含新档/损坏兜底/迁移成功）；false = 高版本拒读（默认数据运行、禁写盘）。 # 损坏兜底：原文件改名 .corrupt.bak（已存在则覆盖）+ push_warning + 默认数据继续——不静默丢档。 func load_from_disk() -> bool: @@ -184,8 +349,12 @@ func load_from_disk() -> bool: # ---- 写盘（tmp + rename 原子写——写一半断电不留烂档）---- +# 无激活态一律拒绝并返回 false（sv3：启动态不隐式激活，盘面零触碰）； # 高版本拒读态一律拒绝（契约 4 禁写）；写失败返回 false。 func write_to_disk() -> bool: + if _path == "": + push_error("[存档序列化] 写盘拒绝——无激活存档位（启动态不隐式激活；经选档进档/新档后落盘）") + return false if _read_only: push_error("[存档序列化] 写盘拒绝——档案版本高于当前（拒读禁写态）") return false @@ -439,6 +608,52 @@ func breakpoint_snapshot() -> Dictionary: # ---- 私有：损坏兜底与文件原语 ---- +# 旧隐式单档一次性迁移（Q1 甲，sv12）：src 字节级原样搬运到 dst（零解析零改造——损坏/高版本 +# 旧档字节原样落槽 1，读取时由正式进档路径的兜底/拒读链接管，不静默丢数据）； +# dst 已存在不重迁（幂等判据——变异④锚点：去判据则重复迁移覆盖槽 1）；迁移成功后 src 改名 +# bak 留痕（不删——处置字节留痕，防再次隐式读写）。任一步失败：源保留原地，下次启动重试。 +# tmp+rename 原子形态与 write_to_disk 同纪律。生产调用=src/dst/bak 为 旧单档/槽 1/留痕名。 +func _migrate_legacy_save(src: String, dst: String, bak: String) -> void: + if not FileAccess.file_exists(src): + return # 执行前置：旧档不存在=无操作 + if FileAccess.file_exists(dst): + return # 幂等判据：槽 1 已存在不重迁 + var tmp := dst + ".tmp" + if not _copy_file(src, tmp): + push_warning("[存档序列化] 旧单档迁移失败（源保留，下次启动重试）：%s → %s" % [src, tmp]) + return + if not _rename_overwrite(tmp, dst): + push_warning("[存档序列化] 旧单档迁移改名失败（tmp 保留待查，源保留重试）：%s → %s" % [tmp, dst]) + return + _rename_overwrite(src, bak) + push_warning("[存档序列化] 旧单档已迁入 %s，原件留痕于 %s" % [dst, bak]) + + +# 字节级文件拷贝（迁移专用——buffer 直拷，零解析零改造） +func _copy_file(from: String, to: String) -> bool: + var src := FileAccess.open(from, FileAccess.READ) + if src == null: + return false + var dst := FileAccess.open(to, FileAccess.WRITE) + if dst == null: + src.close() + return false + while not src.eof_reached(): + var chunk := src.get_buffer(65536) + if chunk.size() > 0: + dst.store_buffer(chunk) + src.close() + dst.close() + return true + + +# 文件删除（删档原语专用——呈现层禁 DirAccess 直删，承载面单点） +func _remove_file(p: String) -> bool: + var dir := DirAccess.open(p.get_base_dir()) + if dir == null: + return false + return dir.remove(p.get_file()) == OK + # 损坏兜底：坏档改名 .corrupt.bak（已存在则覆盖）→ 默认数据继续。不静默丢档（警告留痕）、不 crash。 func _corrupt_fallback(reason: String) -> bool: var bak := _path + ".corrupt.bak" diff --git a/game/smoke/smoke_all.gd b/game/smoke/smoke_all.gd index 7f8cf2e8..c17d8e11 100644 --- a/game/smoke/smoke_all.gd +++ b/game/smoke/smoke_all.gd @@ -264,11 +264,20 @@ func _smoke_boot_chain() -> void: "V2c 启动态 _start_overlay.visible=true（boot 后玩家见菜单）〔装配生命批 V2〕") # ④ 续玩钮可见态==SaveManager 断点在档态 var sm = main.get_node("/root/SaveManager") - # ④-1 boot 路径：boot 时按钮态==真实档断点态（关系判据——与真实档当时内容无关） - var real_bp: bool = sm.has_breakpoint() - check(main._resume_btn.visible == real_bp, - "V2d 续玩钮 boot 态==断点在档态（visible=%s has_breakpoint=%s）〔装配生命批 V2〕" % [ - str(main._resume_btn.visible), str(real_bp)]) + # ④-1 boot 路径：启动态钉死（卡① sv2）——boot 无激活态、断点在档恒否，续玩钮恒隐 + #（原「按钮态==真实档断点态」关系判据随启动态换代改写：test-conventions §9.5 申报在案，卡② mn8 再承接） + check(not sm.has_breakpoint() and not main._resume_btn.visible, + "V2d 续玩钮 boot 态恒隐（无激活态——启动态不隐式激活；断点在档=%s visible=%s）〔装配生命批 V2·卡① sv2 改写〕" % [ + str(sm.has_breakpoint()), str(main._resume_btn.visible)]) + # ④-1b 启动态三断言＋旧单档迁移不变式（卡① sv2/sv12——真实 autoload boot 链） + check(sm.active_slot() == 0 and not sm.has_write_target(), + "V2-s1 boot 后无激活态（active_slot=0、写盘目标空）〔卡① sv2〕") + check(sm.keystone_balance() == 0 and not sm.has_breakpoint() and sm.adventure_total() == 0, + "V2-s2 boot 内存=默认合法空态（钥石/断点/总局数全零值）〔卡① sv2〕") + check(not sm.write_to_disk(), + "V2-s3 boot 无激活写盘拒绝（write_to_disk=false 生产入口）〔卡① sv3〕") + check(not (FileAccess.file_exists("user://save.json") and not FileAccess.file_exists(sm.slot_path(1))), + "V2-s4 旧单档迁移不变式（旧档在则槽 1 必在——Q1 甲一次性迁移已发生）〔卡① sv12〕") # ④-2 隔离新档双向（attach 原地重置——绝不碰真实档 user://save.json；刷新单口与 boot 路径同源） for p in ["user://smoke_boot_chain.json", "user://smoke_boot_chain.json.tmp"]: if FileAccess.file_exists(p): @@ -694,6 +703,7 @@ func _run_core_smoke(db, rng) -> void: _smoke_adventure() _smoke_feats() _smoke_save() + _smoke_save_slots() _smoke_meta() _smoke_tree() _smoke_tree_rules() @@ -6840,3 +6850,164 @@ func _smoke_save() -> void: for p in stale: if FileAccess.file_exists(p): DirAccess.remove_absolute(p) + + +# ---- 三存档位承载（迭代 33 卡①：三槽往返/新档/进档/删档/窥视三态/各槽迁移/旧单档迁移）---- +# 测试文件统一 user://smoke_save_slot_%d.json 模板隔离（attach_slot_template 注入口——禁各自拼槽名）， +# 段首清场+段尾清理——绝不碰 user://save.json 与真实槽 user://save_slot_N.json（红线）。 +func _smoke_save_slots() -> void: + print("--- SaveManager 三存档位承载（迭代 33 卡①）---") + var sm_script = load("res://core/save_manager.gd") + var slot_tpl := "user://smoke_save_slot_%d.json" + var legacy_src := "user://smoke_save_legacy_src.json" + var stale: Array = [] + for i in range(1, 4): + for suf in ["", ".tmp", ".corrupt.bak"]: + stale.append(slot_tpl % i + suf) + stale.append_array([legacy_src, legacy_src + ".migrated.bak"]) + for p in stale: + if FileAccess.file_exists(p): + DirAccess.remove_absolute(p) + + var t = sm_script.new() + t.attach_slot_template(slot_tpl) + + # ① 三槽往返×3＋位间隔离＋进档（sv1/sv5/sv10） + for i in range(1, 4): + check(t.activate_slot(i), "sv5 进档受理·槽 %d（激活+读盘）〔卡① sv5〕" % i) + t.apply_adventure_summary({"result": "completed", "cleared": i == 1, "levels_cleared": i, + "stopped_at": 0, "keystone_total": 100 * i, "master_seed": i}) + check(t.write_to_disk(), "sv3 激活态写盘受理·槽 %d〔卡① sv1〕" % i) + var t2 = sm_script.new() + t2.attach_slot_template(slot_tpl) + for i in range(1, 4): + check(t2.activate_slot(i) and t2.keystone_balance() == 100 * i + and t2.adventure_total() == 1 and t2.adventure_cleared() == (1 if i == 1 else 0), + "sv1 三槽往返一致·槽 %d（异值按位读回）〔卡① sv1〕" % i) + var slot2_before := FileAccess.get_file_as_bytes(slot_tpl % 2) + t.activate_slot(1) + t.add_keystone(7) + check(t.write_to_disk(), "sv3 写盘受理·槽 1 加值后〔卡① sv1〕") + check(FileAccess.get_file_as_bytes(slot_tpl % 2) == slot2_before, + "sv1 位间隔离：改槽 1 槽 2 字节不动〔卡① sv1〕") + + # ② 删档原语（sv6）：删激活槽（指针连清除）→ 删非激活槽（指针保持+他槽字节不动） + check(t.activate_slot(3), "sv5 切激活至槽 3（删激活槽夹具前置）〔卡① sv5〕") + check(t.delete_slot(3), "sv6 删档受理·激活槽 3〔卡① sv6〕") + check(not FileAccess.file_exists(slot_tpl % 3) and not FileAccess.file_exists(slot_tpl % 3 + ".tmp"), + "sv6 删后文件不在盘＋无 .tmp 残留〔卡① sv6〕") + check(t.active_slot() == 0 and not t.has_write_target(), + "sv6 删激活槽激活指针连清除（该槽不再可写）〔卡① sv6〕") + var slot1_before := FileAccess.get_file_as_bytes(slot_tpl % 1) + t.activate_slot(1) + check(t.delete_slot(2), "sv6 删非激活槽受理·槽 2〔卡① sv6〕") + check(not FileAccess.file_exists(slot_tpl % 2) and t.active_slot() == 1, + "sv6 删非激活槽：文件不在盘＋激活指针保持〔卡① sv6〕") + check(FileAccess.get_file_as_bytes(slot_tpl % 1) == slot1_before, + "sv6 删槽 2 槽 1 字节不动（位间互隔离）〔卡① sv6〕") + + # ③ 新档原语（sv4）：空槽创建=全零可玩白板，创建即激活并落盘 + check(t.create_slot(3), "sv4 新档受理·槽 3（创建即激活）〔卡① sv4〕") + check(t.active_slot() == 3 and t.keystone_balance() == 0 and not t.has_breakpoint(), + "sv4 新档=全零可玩合法白板态（激活号 3/钥石 0/无断点）〔卡① sv4〕") + check(FileAccess.file_exists(slot_tpl % 3), "sv4 新档落盘（文件在位）〔卡① sv4〕") + + # ④ 高版本拒读槽按槽成立＋激活失败恢复切换前三态（sv9/sv10） + var fhv := FileAccess.open(slot_tpl % 2, FileAccess.WRITE) + fhv.store_string(JSON.stringify({"version": 99, "meta": {}})) + fhv.close() + var hv = sm_script.new() + hv.attach_slot_template(slot_tpl) + check(hv.activate_slot(1) and hv.keystone_balance() == 107, "sv5 进档槽 1 读回（107）〔卡① sv10〕") + var slot2_hv := FileAccess.get_file_as_bytes(slot_tpl % 2) + check(not hv.activate_slot(2), "sv9 高版本槽进档拒绝（拒读禁写链按槽）〔卡① sv9〕") + check(hv.active_slot() == 1 and hv.keystone_balance() == 107, + "sv10 激活失败恢复切换前三态（路径/激活号/数据归槽 1）〔卡① sv10〕") + hv.add_keystone(1) + check(hv.write_to_disk() and FileAccess.get_file_as_bytes(slot_tpl % 2) == slot2_hv, + "sv10 恢复后写盘落激活槽 1（高版本槽 2 零误写）〔卡① sv10〕") + + # ⑤ 迁移链各槽成立（sv9）：三槽各喂 v5 旧档 → 各自激活读回迁移值 + for i in range(1, 4): + var fm := FileAccess.open(slot_tpl % i, FileAccess.WRITE) + fm.store_string(JSON.stringify({"version": 5, "meta": {"keystone_balance": i * 11}})) + fm.close() + for i in range(1, 4): + var mi = sm_script.new() + mi.attach_slot_template(slot_tpl) + check(mi.activate_slot(i) and mi.keystone_balance() == i * 11 + and mi.write_to_disk(), + "sv9 迁移链按槽成立·槽 %d（v5→v7 各槽独立+写盘 version=7）〔卡① sv9〕" % i) + + # ⑥ 窥视三态零副作用（sv7/sv8）：异值三槽逐槽三项＋空槽零值＋坏/高版本字节 mtime 双比对 + var pv = sm_script.new() + pv.attach_slot_template(slot_tpl) + for i in range(1, 4): + var fp := FileAccess.open(slot_tpl % i, FileAccess.WRITE) + fp.store_string(JSON.stringify({"version": 7, "meta": {"keystone_balance": 200 * i, + "adventure_total": 5 * i, "adventure_cleared": i, + "tree_nodes": {}, "fork_sides": {}, "tree_struct": 2}})) + fp.close() + for i in range(1, 4): + var ps: Dictionary = pv.peek_slot_summary(i) + check(bool(ps.get("readable", false)) and int(ps.get("keystone", -1)) == 200 * i + and int(ps.get("cleared", -1)) == i and int(ps.get("total", -1)) == 5 * i, + "sv7 窥视三项逐槽正确·槽 %d〔卡① sv7〕" % i) + check(pv.delete_slot(3), "sv6 删槽 3 备空槽窥视〔卡① sv6〕") + var pe: Dictionary = pv.peek_slot_summary(3) + check(bool(pe.get("readable", false)) and int(pe.get("keystone", -1)) == 0 + and int(pe.get("cleared", -1)) == 0 and int(pe.get("total", -1)) == 0, + "sv7 空槽窥视=零值合法态〔卡① sv7〕") + var fbad := FileAccess.open(slot_tpl % 1, FileAccess.WRITE) + fbad.store_string("not json{{{") + fbad.close() + var bad_bytes := FileAccess.get_file_as_bytes(slot_tpl % 1) + var bad_mtime := FileAccess.get_modified_time(slot_tpl % 1) + var pb: Dictionary = pv.peek_slot_summary(1) + check(not bool(pb.get("readable", true)), "sv8 坏槽窥视=显式损坏标记〔卡① sv8〕") + check(FileAccess.get_file_as_bytes(slot_tpl % 1) == bad_bytes + and FileAccess.get_modified_time(slot_tpl % 1) == bad_mtime + and not FileAccess.file_exists(slot_tpl % 1 + ".corrupt.bak"), + "sv8 坏槽窥视零副作用（字节+mtime 双比对不变+零 .corrupt.bak 改名）〔卡① sv8〕") + var fhv2 := FileAccess.open(slot_tpl % 2, FileAccess.WRITE) + fhv2.store_string(JSON.stringify({"version": 99, "meta": {}})) + fhv2.close() + var hv_bytes := FileAccess.get_file_as_bytes(slot_tpl % 2) + var hv_mtime := FileAccess.get_modified_time(slot_tpl % 2) + var ph: Dictionary = pv.peek_slot_summary(2) + check(not bool(ph.get("readable", true)), "sv8 高版本槽窥视=不可读标记〔卡① sv8〕") + check(FileAccess.get_file_as_bytes(slot_tpl % 2) == hv_bytes + and FileAccess.get_modified_time(slot_tpl % 2) == hv_mtime, + "sv8 高版本窥视零副作用（字节+mtime 不变+零改名）〔卡① sv8〕") + + # ⑦ 旧单档迁移（sv12）：字节搬运+源改名留痕+幂等+他槽零触碰 + var ml = sm_script.new() + ml.attach_slot_template(slot_tpl) + var fsrc := FileAccess.open(legacy_src, FileAccess.WRITE) + fsrc.store_string(JSON.stringify({"version": 7, "meta": {"keystone_balance": 1234}})) + fsrc.close() + DirAccess.remove_absolute(slot_tpl % 1) + ml._migrate_legacy_save(legacy_src, slot_tpl % 1, legacy_src + ".migrated.bak") + var migrated: Dictionary = JSON.parse_string(FileAccess.get_file_as_string(slot_tpl % 1)) + check(int((migrated.get("meta", {}) as Dictionary).get("keystone_balance", -1)) == 1234, + "sv12 旧档字节迁入槽 1（逐域相等——余额 1234）〔卡① sv12〕") + check(not FileAccess.file_exists(legacy_src) and FileAccess.file_exists(legacy_src + ".migrated.bak"), + "sv12 迁移后源改名留痕（.migrated.bak 在盘、原路径不在）〔卡① sv12〕") + var s2_before := FileAccess.get_file_as_bytes(slot_tpl % 2) + var s3_before := FileAccess.get_file_as_bytes(slot_tpl % 3) + var fsrc2 := FileAccess.open(legacy_src, FileAccess.WRITE) + fsrc2.store_string(JSON.stringify({"version": 7, "meta": {"keystone_balance": 777}})) + fsrc2.close() + ml._migrate_legacy_save(legacy_src, slot_tpl % 1, legacy_src + ".migrated.bak") + var slot1_now: Dictionary = JSON.parse_string(FileAccess.get_file_as_string(slot_tpl % 1)) + check(int((slot1_now.get("meta", {}) as Dictionary).get("keystone_balance", -1)) == 1234 + and FileAccess.file_exists(legacy_src), + "sv12 幂等：槽 1 已存在不重迁（预置 777 零覆盖、源保留）〔卡① sv12〕") + check(FileAccess.get_file_as_bytes(slot_tpl % 2) == s2_before + and FileAccess.get_file_as_bytes(slot_tpl % 3) == s3_before, + "sv12 迁移他槽零触碰（槽 2/3 字节不动）〔卡① sv12〕") + + # 段尾清理（测试文件绝不残留） + for p in stale: + if FileAccess.file_exists(p): + DirAccess.remove_absolute(p) diff --git a/game/tests/run_all.gd b/game/tests/run_all.gd index 9f282a4c..75305397 100644 --- a/game/tests/run_all.gd +++ b/game/tests/run_all.gd @@ -68,6 +68,9 @@ func _suites() -> Array: {"path": "res://tests/unit/core/pool_case_d_test.gd", "expect": 0}, # 池结构案D 行为（V6 令牌三态/V7 曝光槽 2+1 回退/V8 概率上限解耦提前退役） {"path": "res://tests/unit/core/feat_vouchers_test.gd", "expect": 0}, # 凭证五件+留任二件（V9 路由逐件/F-1 存量账/V10 留任路由+AP 属性轴） {"path": "res://tests/unit/core/settle_segments_test.gd", "expect": 0}, # 结算五段 Segment（V4：直接 new/编排器接线/真实一轮走段序） + {"path": "res://tests/unit/core/save_slot_isolation_test.gd", "expect": 0}, # 卡① 三槽位间隔离/进档失败恢复/宿主链引用同一（sv1/sv5/sv9/sv10） + {"path": "res://tests/unit/core/save_boot_no_activate_test.gd", "expect": 0}, # 卡① 启动态类级契约：无激活态/拒写盘面零触碰/越界拒绝（sv2/sv3） + {"path": "res://tests/unit/core/save_slot_summary_test.gd", "expect": 0}, # 卡① 摘要三项按槽窥视：异值/空槽/坏槽三态/零副作用（sv7/sv8） {"path": "res://tests/unit/presentation/modal_flow_test.gd", "expect": 0}, # 模态编排纯逻辑（V6：直接 new/互斥域谓词/三例外锁/演播后排窗） # ---- L2 集成层（跨系统用例，与 unit/ 的隔离断言面分工）---- {"path": "res://tests/integration/save_rng_roundtrip_test.gd", "expect": 0}, # 存档⇄RNG 快照往返（SaveManager 迁移链 × 断点消费 × RNG 续跑 × 停点态确定性） diff --git a/game/tests/unit/core/save_boot_no_activate_test.gd b/game/tests/unit/core/save_boot_no_activate_test.gd new file mode 100644 index 00000000..ea55e691 --- /dev/null +++ b/game/tests/unit/core/save_boot_no_activate_test.gd @@ -0,0 +1,72 @@ +# tests/unit/core/save_boot_no_activate_test.gd — 卡① sv2/sv3：启动态钉死类级契约 +# （无参实例=无激活态、内存=默认合法空态、无激活写盘一律拒绝并返回 false 且盘面零触碰、 +# 访问器 fail-safe 合法空值、越界槽号拒绝。真实 autoload boot 链断言在冒烟 V2-s1..s4 段—— +# --script 模式无 autoload，本套件为类级白盒面，双落点在实现报告实际对照表对账。） +# 载体：run_all 单元套件（显式实例化夹具——--script 模式无 autoload）。 +extends SceneTree + +const SaveManagerScript := preload("res://core/save_manager.gd") +const Kit := preload("res://tests/unit/test_kit.gd") + + +func _init() -> void: + _test_no_arg_instance_has_no_activation() + _test_write_rejected_without_target() + _test_out_of_range_slots_rejected() + quit(Kit.finish("save_boot_no_activate")) + + +# ① 无参实例（autoload 实例化形态）＝无激活态＋默认合法空态（sv2 类级） +func _test_no_arg_instance_has_no_activation() -> void: + var sm := SaveManagerScript.new() + Kit.check_quiet(sm._path == "" and sm.active_slot() == 0 and not sm.has_write_target(), + "sv2 无参实例无激活态（路径空/激活号 0/写盘目标空）〔卡① sv2〕") + Kit.check_quiet(sm.keystone_balance() == 0 and not sm.has_breakpoint() + and sm.adventure_total() == 0 and sm.adventure_cleared() == 0, + "sv2 内存=默认合法空态（钥石/断点/总局数/通关数全零值——访问器 fail-safe）〔卡① sv2〕") + # attach_path 注入任意隔离路径＝注入即激活（契约 7 单路径语义——隔离面行为零变化） + sm.attach_path("user://smoke_boot_noact_iso.json") + Kit.check_quiet(sm.has_write_target() and sm.keystone_balance() == 0, + "sv2 attach_path 注入即激活（写盘目标在位、数据回默认空态）〔卡① sv2/契约7〕") + if FileAccess.file_exists("user://smoke_boot_noact_iso.json"): + DirAccess.remove_absolute("user://smoke_boot_noact_iso.json") + + +# ② 无激活态写盘一律拒绝并返回 false，盘面零触碰（sv3 类级——真实入口=冒烟 V2-s3 生产链） +func _test_write_rejected_without_target() -> void: + var sm := SaveManagerScript.new() + var before := {} + for i in range(1, 4): + var p: String = sm.slot_path(i) + before[i] = [FileAccess.file_exists(p), + FileAccess.get_file_as_bytes(p) if FileAccess.file_exists(p) else PackedByteArray(), + FileAccess.get_modified_time(p) if FileAccess.file_exists(p) else 0] + Kit.check_quiet(not sm.write_to_disk(), + "sv3 无激活写盘拒绝（write_to_disk=false）〔卡① sv3〕") + var unchanged := true + for i in range(1, 4): + var p: String = sm.slot_path(i) + var now_state: Array = [FileAccess.file_exists(p), + FileAccess.get_file_as_bytes(p) if FileAccess.file_exists(p) else PackedByteArray(), + FileAccess.get_modified_time(p) if FileAccess.file_exists(p) else 0] + if now_state[0] != before[i][0] or now_state[1] != before[i][1] \ + or now_state[2] != before[i][2]: + unchanged = false + Kit.check_quiet(unchanged, + "sv3 拒写盘面零触碰（三槽存在性/字节/mtime 全等）〔卡① sv3〕") + # 拒读禁写态语义在位（高版本拒读→写拒绝——既有契约回归锚） + sm._read_only = true + Kit.check_quiet(not sm.write_to_disk(), "sv3 拒读禁写态写盘拒绝（既有契约保持）〔卡① sv3〕") + + +# ③ 越界槽号三原语拒绝＋窥视越界返回不可读（原语边界 fail-safe） +func _test_out_of_range_slots_rejected() -> void: + var sm := SaveManagerScript.new() + sm.attach_slot_template("user://smoke_boot_noact_%d.json") + Kit.check_quiet(not sm.activate_slot(0) and not sm.activate_slot(4) + and not sm.create_slot(0) and not sm.create_slot(4) + and not sm.delete_slot(0) and not sm.delete_slot(4), + "原语边界：槽号 0/4 全拒绝（位数写死 3——契约 1）〔卡① sv1〕") + var out: Dictionary = sm.peek_slot_summary(4) + Kit.check_quiet(not bool(out.get("readable", true)), + "原语边界：越界窥视返回不可读标记〔卡① sv7〕") diff --git a/game/tests/unit/core/save_boot_no_activate_test.gd.uid b/game/tests/unit/core/save_boot_no_activate_test.gd.uid new file mode 100644 index 00000000..0fee5787 --- /dev/null +++ b/game/tests/unit/core/save_boot_no_activate_test.gd.uid @@ -0,0 +1 @@ +uid://ria52wdjq6tj diff --git a/game/tests/unit/core/save_slot_isolation_test.gd b/game/tests/unit/core/save_slot_isolation_test.gd new file mode 100644 index 00000000..ca49a91f --- /dev/null +++ b/game/tests/unit/core/save_slot_isolation_test.gd @@ -0,0 +1,104 @@ +# tests/unit/core/save_slot_isolation_test.gd — 卡① sv1/sv10：三槽承载位间隔离＋切槽实例同一性 +# （三槽往返异值逐域读回、改 A 槽 B 槽字节不动、高版本槽进档失败恢复切换前三态、 +# MetaProgression 宿主链切槽前后引用同一且写盘落当前槽、attach_slot_template 注入语义。 +# 测试隔离：槽模板注入 user://smoke_slotiso_%d.json 命名空间——绝不碰真实槽与 user://save.json。） +# 载体：run_all 单元套件（显式实例化夹具——--script 模式无 autoload）。 +extends SceneTree + +const SaveManagerScript := preload("res://core/save_manager.gd") +const MetaProgressionScript := preload("res://core/meta_progression.gd") +const Kit := preload("res://tests/unit/test_kit.gd") + +const TPL := "user://smoke_slotiso_%d.json" + + +func _init() -> void: + _clear_fixtures() + _test_three_slot_roundtrip_and_isolation() + _test_activate_failure_restores_previous_slot() + _test_metaprogression_reference_identity() + _clear_fixtures() + quit(Kit.finish("save_slot_isolation")) + + +func _clear_fixtures() -> void: + for i in range(1, 4): + for suf in ["", ".tmp", ".corrupt.bak"]: + var p: String = TPL % i + suf + if FileAccess.file_exists(p): + DirAccess.remove_absolute(p) + + +func _write_v7_keystone(path: String, keystone: int) -> void: + var f := FileAccess.open(path, FileAccess.WRITE) + f.store_string(JSON.stringify({"version": 7, "meta": {"keystone_balance": keystone, + "tree_nodes": {}, "fork_sides": {}, "tree_struct": 2}})) + f.close() + + +# ① 三槽往返：各槽写异值 → 写盘 → 新实例按位读回逐域相等；改槽 1 槽 2 字节不动（sv1） +func _test_three_slot_roundtrip_and_isolation() -> void: + var t := SaveManagerScript.new() + t.attach_slot_template(TPL) + for i in range(1, 4): + Kit.check_quiet(t.activate_slot(i), "sv5 进档受理·槽 %d〔卡① sv5〕" % i) + t.add_keystone(100 * i) + t.apply_adventure_summary({"result": "completed", "cleared": i == 1, "levels_cleared": i, + "stopped_at": 0, "keystone_total": 0, "master_seed": i}) + Kit.check_quiet(t.write_to_disk(), "sv3 激活态写盘受理·槽 %d〔卡① sv1〕" % i) + var t2 := SaveManagerScript.new() + t2.attach_slot_template(TPL) + for i in range(1, 4): + Kit.check_quiet(t2.activate_slot(i) and t2.keystone_balance() == 100 * i + and t2.adventure_total() == 1 and t2.adventure_cleared() == (1 if i == 1 else 0), + "sv1 三槽往返一致·槽 %d（异值按位读回）〔卡① sv1〕" % i) + var slot2_before := FileAccess.get_file_as_bytes(TPL % 2) + t.activate_slot(1) + t.add_keystone(7) + Kit.check_quiet(t.write_to_disk(), "sv3 写盘受理·槽 1 加值后〔卡① sv1〕") + Kit.check_quiet(FileAccess.get_file_as_bytes(TPL % 2) == slot2_before, + "sv1 位间隔离：改槽 1 槽 2 字节不动〔卡① sv1〕") + # 激活号记账：activate 槽派生名后 active_slot 同步；attach_path 注入槽名亦然 + Kit.check_quiet(t.active_slot() == 1 and t.has_write_target(), + "sv1 activate 后激活号同步（active_slot=1 写盘目标在位）〔卡① sv1〕") + + +# ② 高版本槽进档失败：拒绝＋恢复切换前三态（路径/激活号/数据）＋拒读槽零误写（sv9/sv10） +func _test_activate_failure_restores_previous_slot() -> void: + var t := SaveManagerScript.new() + t.attach_slot_template(TPL) + _write_v7_keystone(TPL % 1, 311) + _write_v7_keystone(TPL % 2, 422) + var fhv := FileAccess.open(TPL % 3, FileAccess.WRITE) + fhv.store_string(JSON.stringify({"version": 99, "meta": {}})) + fhv.close() + Kit.check_quiet(t.activate_slot(1) and t.keystone_balance() == 311, + "sv5 进档槽 1 读回（311）〔卡① sv10〕") + var slot2_before := FileAccess.get_file_as_bytes(TPL % 2) + Kit.check_quiet(not t.activate_slot(3), "sv9 高版本槽进档拒绝（拒读链按槽）〔卡① sv9〕") + Kit.check_quiet(t.active_slot() == 1 and t.has_write_target() and t.keystone_balance() == 311, + "sv10 激活失败恢复切换前三态（路径/激活号/数据归槽 1）〔卡① sv10〕") + t.add_keystone(1) + Kit.check_quiet(t.write_to_disk(), "sv3 恢复后写盘受理〔卡① sv10〕") + Kit.check_quiet(FileAccess.get_file_as_bytes(TPL % 2) == slot2_before, + "sv10 拒读槽零误写（写盘落激活槽 1，槽 2/3 字节不动）〔卡① sv10〕") + + +# ③ MetaProgression 宿主链切槽：引用同一性保持＋写盘落当前槽（sv10——禁换实例先例） +func _test_metaprogression_reference_identity() -> void: + var t := SaveManagerScript.new() + t.attach_slot_template(TPL) + _write_v7_keystone(TPL % 1, 533) + _write_v7_keystone(TPL % 2, 644) + Kit.check_quiet(t.activate_slot(1), "sv5 进档槽 1〔卡① sv10〕") + var meta := MetaProgressionScript.new(null, t) + Kit.check_quiet(meta.save == t and meta.keystone_balance() == 533, + "sv10 宿主链取数走动态分发（meta.save 同一实例、读槽 1）〔卡① sv10〕") + Kit.check_quiet(t.activate_slot(2) and meta.save == t and meta.keystone_balance() == 644, + "sv10 切槽后引用同一性保持（零换实例）且读数随槽（644）〔卡① sv10〕") + meta.save.add_keystone(6) + Kit.check_quiet(t.write_to_disk() and t.keystone_balance() == 650, + "sv10 宿主链写盘落当前槽 2（650=644+6）〔卡① sv10〕") + Kit.check_quiet(int((JSON.parse_string(FileAccess.get_file_as_string(TPL % 2)) as Dictionary)\ + .get("meta", {}).get("keystone_balance", -1)) == 650, + "sv10 盘面核验：槽 2 文件落 650、槽 1 零触碰〔卡① sv10〕") diff --git a/game/tests/unit/core/save_slot_isolation_test.gd.uid b/game/tests/unit/core/save_slot_isolation_test.gd.uid new file mode 100644 index 00000000..4f5ecf1c --- /dev/null +++ b/game/tests/unit/core/save_slot_isolation_test.gd.uid @@ -0,0 +1 @@ +uid://bsibspaf7delx diff --git a/game/tests/unit/core/save_slot_summary_test.gd b/game/tests/unit/core/save_slot_summary_test.gd new file mode 100644 index 00000000..4d83a816 --- /dev/null +++ b/game/tests/unit/core/save_slot_summary_test.gd @@ -0,0 +1,106 @@ +# tests/unit/core/save_slot_summary_test.gd — 卡① sv7：摘要三项按槽窥视读器 +# （三槽异值逐槽三项正确、空槽零值合法态、坏槽/高版本/缺版本字段=显式损坏标记、 +# 窥视零副作用（字节+mtime 双比对+零 .corrupt.bak 改名+不激活不写内存）、路径注入口 peek_summary_at。 +# 测试隔离：模板注入 user://smoke_slotsum_%d.json 命名空间——绝不碰真实槽与 user://save.json。） +# 载体：run_all 单元套件（显式实例化夹具——--script 模式无 autoload）。 +extends SceneTree + +const SaveManagerScript := preload("res://core/save_manager.gd") +const Kit := preload("res://tests/unit/test_kit.gd") + +const TPL := "user://smoke_slotsum_%d.json" + + +func _init() -> void: + _clear_fixtures() + _test_peek_three_slots_distinct_values() + _test_peek_empty_and_unreadable_states() + _test_peek_zero_side_effect() + _clear_fixtures() + quit(Kit.finish("save_slot_summary")) + + +func _clear_fixtures() -> void: + for i in range(1, 4): + for suf in ["", ".tmp", ".corrupt.bak"]: + var p: String = TPL % i + suf + if FileAccess.file_exists(p): + DirAccess.remove_absolute(p) + + +func _write_slot_json(path: String, content: String) -> void: + var f := FileAccess.open(path, FileAccess.WRITE) + f.store_string(content) + f.close() + + +# ① 三槽异值逐槽三项正确＋不激活不写内存（sv7） +func _test_peek_three_slots_distinct_values() -> void: + var t := SaveManagerScript.new() + t.attach_slot_template(TPL) + for i in range(1, 4): + _write_slot_json(TPL % i, JSON.stringify({"version": 7, "meta": { + "keystone_balance": 200 * i, "adventure_total": 5 * i, "adventure_cleared": i, + "tree_nodes": {}, "fork_sides": {}, "tree_struct": 2}})) + for i in range(1, 4): + var ps: Dictionary = t.peek_slot_summary(i) + Kit.check_quiet(bool(ps.get("readable", false)) and int(ps.get("keystone", -1)) == 200 * i + and int(ps.get("cleared", -1)) == i and int(ps.get("total", -1)) == 5 * i, + "sv7 窥视三项逐槽正确·槽 %d（钥石/通关/总局）〔卡① sv7〕" % i) + Kit.check_quiet(t.active_slot() == 0 and not t.has_write_target() and t.keystone_balance() == 0, + "sv7 窥视不激活不写内存（激活号 0/无写盘目标/内存余额零）〔卡① sv7〕") + # 路径注入口同语义（契约 7 注入面） + var pinj: Dictionary = t.peek_summary_at(TPL % 2) + Kit.check_quiet(bool(pinj.get("readable", false)) and int(pinj.get("keystone", -1)) == 400, + "sv7 peek_summary_at 注入口同语义（槽 2 钥石 400）〔卡① sv7〕") + + +# ② 空槽零值合法态＋不可读三态显式标记（sv7/契约 9） +func _test_peek_empty_and_unreadable_states() -> void: + var t := SaveManagerScript.new() + t.attach_slot_template(TPL) + DirAccess.remove_absolute(TPL % 3) # 清①段残留——空槽夹具 + var pe: Dictionary = t.peek_slot_summary(3) # 槽 3 无文件=空槽 + Kit.check_quiet(bool(pe.get("readable", false)) and int(pe.get("keystone", -1)) == 0 + and int(pe.get("cleared", -1)) == 0 and int(pe.get("total", -1)) == 0, + "sv7 空槽窥视=零值合法态（可读+三项全零）〔卡① sv7〕") + _write_slot_json(TPL % 1, "this is not json{{{") + Kit.check_quiet(not bool(t.peek_slot_summary(1).get("readable", true)), + "sv7 坏槽窥视=显式损坏标记〔卡① sv7〕") + _write_slot_json(TPL % 2, JSON.stringify({"version": 99, "meta": {}})) + Kit.check_quiet(not bool(t.peek_slot_summary(2).get("readable", true)), + "sv7 高版本槽窥视=不可读标记〔卡① sv7〕") + _write_slot_json(TPL % 3, JSON.stringify({"meta": {"keystone_balance": 5}})) # 缺版本字段 + Kit.check_quiet(not bool(t.peek_slot_summary(3).get("readable", true)), + "sv7 缺版本字段槽窥视=不可读标记〔卡① sv7/契约9〕") + + +# ③ 窥视零副作用：字节+mtime 双比对不变＋零 .corrupt.bak 改名（sv8——真实入口冒烟段同判据） +func _test_peek_zero_side_effect() -> void: + var t := SaveManagerScript.new() + t.attach_slot_template(TPL) + _write_slot_json(TPL % 1, "corrupt bytes {{{{") + var bytes_before := FileAccess.get_file_as_bytes(TPL % 1) + var mtime_before := FileAccess.get_modified_time(TPL % 1) + t.peek_slot_summary(1) + t.peek_summary_at(TPL % 1) + Kit.check_quiet(FileAccess.get_file_as_bytes(TPL % 1) == bytes_before + and FileAccess.get_modified_time(TPL % 1) == mtime_before + and not FileAccess.file_exists(TPL % 1 + ".corrupt.bak"), + "sv8 坏槽窥视零副作用（字节+mtime 不变+零 .corrupt.bak 改名）〔卡① sv8〕") + _write_slot_json(TPL % 2, JSON.stringify({"version": 99, "meta": {}})) + var hv_bytes := FileAccess.get_file_as_bytes(TPL % 2) + var hv_mtime := FileAccess.get_modified_time(TPL % 2) + t.peek_slot_summary(2) + Kit.check_quiet(FileAccess.get_file_as_bytes(TPL % 2) == hv_bytes + and FileAccess.get_modified_time(TPL % 2) == hv_mtime + and not FileAccess.file_exists(TPL % 2 + ".corrupt.bak"), + "sv8 高版本窥视零副作用（字节+mtime 不变+零改名）〔卡① sv8〕") + # .tmp 残留按空槽处理（契约 9） + DirAccess.remove_absolute(TPL % 3) # 主文件清场——只留 .tmp 残留 + _write_slot_json(TPL % 3 + ".tmp", "{}") + var pt: Dictionary = t.peek_slot_summary(3) + Kit.check_quiet(bool(pt.get("readable", false)) and int(pt.get("keystone", -1)) == 0, + "sv8 .tmp 残留按空槽处理（主文件不在=空槽零值）〔卡① sv8〕") + if FileAccess.file_exists(TPL % 3 + ".tmp"): + DirAccess.remove_absolute(TPL % 3 + ".tmp") diff --git a/game/tests/unit/core/save_slot_summary_test.gd.uid b/game/tests/unit/core/save_slot_summary_test.gd.uid new file mode 100644 index 00000000..18c99425 --- /dev/null +++ b/game/tests/unit/core/save_slot_summary_test.gd.uid @@ -0,0 +1 @@ +uid://43rqlcpx6ur3