Files
aetherbound-guild/runtime/tests/fg4/rg04_contract2_boss_test.gd
T

114 lines
8.0 KiB
GDScript

extends SceneTree
const Battle = preload("res://fg4/rg04_contract2_battle_service.gd")
const Contract = preload("res://fg4/rg04_contract2_service.gd")
const Fixture = preload("res://tests/fg4/contract1_fixture.gd")
var failures: Array[String] = []
func _initialize() -> void:
call_deferred("run_test")
func run_test() -> void:
verify_redaction_hart_victory_record_and_region_close()
verify_redaction_hart_permanent_loss_and_recovery()
verify_redaction_hart_tamper_boundaries()
if failures.is_empty():
print("ABG_FG4_RG04_CONTRACT2_BOSS_OK boss=BO-R4-02 plans=safe_rule_seed,reorder_and_interrupt redaction_source=visible omitted_target=visible replay_order=visible reward_coin=0 renown=24 clear=CLEAR-RG04-C02 rg04_records=2 region=closed unlock=RG-05 permanent_loss=true same_muster_recovery=true recovery_cost=34 resurrection=0 exact_once=true")
quit(0)
else:
for failure in failures:
push_error(failure)
quit(1)
func verify_redaction_hart_victory_record_and_region_close() -> void:
var service := Contract.new(Fixture.new().rg04_contract2_boss_muster_snapshot())
expect(service.valid and service.state.current_run.phase == "rg04_contract2_boss_muster", "twelve final RG-04 victories open Redaction Hart Muster")
if not service.valid:
return
var muster: Dictionary = service.state.current_run.boss_muster
expect(muster.boss_id == "BO-R4-02" and muster.plan_ids == ["safe_rule_seed", "reorder_and_interrupt"], "Muster exposes exact Boss and plans")
expect(muster.recorded_rule_count == 6 and muster.replay_order_visible and muster.replay_order.size() == 6, "Muster discloses source count and replay order")
expect(muster.omitted_target_clause == "target_rule" and muster.equivalent_targets, "Muster discloses omitted target behavior")
var renown_before := int(service.state.guild_profile.persistent_renown)
var records_before: int = service.state.guild_profile.company_records.size()
var coin_before := int(service.state.current_run.coin)
var alternate := Contract.new(service.state.snapshot())
var alternate_prepared := alternate.commit_boss_plan("fg4-rg04-boss-alternate-prepare", alternate.state.revision, String(muster.muster_hash), "reorder_and_interrupt")
var alternate_battle := Battle.new(alternate.state.snapshot()).run_to_terminal("reorder_and_interrupt")
expect(alternate_prepared.ok and alternate_battle.ok and alternate_battle.snapshot.outcome == "victory", "normal Company can win by reordering and interrupting")
var prepared := service.commit_boss_plan("fg4-rg04-boss-prepare", service.state.revision, String(muster.muster_hash), "safe_rule_seed")
var battle := Battle.new(service.state.snapshot()).run_to_terminal("safe_rule_seed")
expect(prepared.ok and battle.ok and battle.snapshot.outcome == "victory", "safe rule seeding defeats Redaction Hart: %s" % str(battle))
if not prepared.ok or not battle.ok or battle.snapshot.outcome != "victory":
return
expect(has_event(battle.snapshot.event_log, "redaction_source_disclosed") and has_event(battle.snapshot.event_log, "target_clause_omitted") and has_event(battle.snapshot.event_log, "replay_order_disclosed") and has_event(battle.snapshot.event_log, "safe_rule_seeded"), "Boss exposes redaction and decisive seed events")
var settled := service.settle_boss("fg4-rg04-boss-settle", service.state.revision, battle.snapshot)
expect(settled.ok and service.state.current_run.phase == "rg04_region_result", "Boss victory opens RG-04 Contract result: %s" % str(settled))
if not settled.ok:
return
expect(settled.receipt.reward_coin == 0 and service.state.current_run.coin == coin_before, "Redaction Hart pays no Coin")
var close_id := String(service.state.current_run.pending_boss_result.close_id)
var close_revision := service.state.revision
var closed := service.close_region("fg4-rg04-close", close_revision, close_id)
expect(closed.ok and service.state.current_run.phase == "rg04_region_closed" and service.state.current_run.status == "closed", "Contract closes RG-04 atomically")
expect(service.state.current_run.next_contract_id.is_empty() and "RG-05" in service.state.guild_profile.unlocked_region_ids, "RG-05 unlocks exactly once")
expect(service.state.guild_profile.persistent_renown == renown_before + 24, "first clear grants exact Renown 24")
expect(service.state.guild_profile.company_records.size() == records_before + 1, "second RG-04 Company Record is written")
expect("CLEAR-RG04-C02" in service.state.guild_profile.contract_clear_ids, "RG-04 Contract-2 clear persists")
expect(closed.receipt.record.contract_id == "CTR-R4-02" and closed.receipt.record.route_ids.size() == 12, "record binds twelve Quillroot routes")
var duplicate := service.close_region("fg4-rg04-close", close_revision, close_id)
expect(duplicate.ok and duplicate.duplicate and duplicate.receipt == closed.receipt, "duplicate Contract close is inert")
expect(not service.close_region("fg4-rg04-close-again", service.state.revision, close_id).ok, "new close after Region close rejects")
func verify_redaction_hart_permanent_loss_and_recovery() -> void:
var low_hp := Fixture.new().rg04_contract2_boss_muster_snapshot()
for recruit_id in low_hp.current_run.company:
low_hp.current_run.recruit_records[recruit_id].current_hp = 1
low_hp.current_run.active_artifact_ids = ["AR-024"]
var service := Contract.new(low_hp)
expect(service.valid, "low-HP Redaction Hart fixture remains valid")
if not service.valid:
return
var muster_hash := String(service.state.current_run.boss_muster.muster_hash)
var company_before: int = service.state.current_run.company.size()
var prepared := service.commit_boss_plan("fg4-rg04-boss-loss-prepare", service.state.revision, muster_hash, "safe_rule_seed")
var battle := Battle.new(service.state.snapshot()).run_to_terminal("safe_rule_seed")
expect(prepared.ok and battle.ok and battle.snapshot.outcome == "defeat", "Deep Current makes the safe-seed plan fail")
expect(battle.snapshot.fallen_recruit_ids.size() == 1, "Redaction Hart defeat has one permanent casualty")
var fallen_id := String(battle.snapshot.fallen_recruit_ids[0])
var settled := service.settle_boss("fg4-rg04-boss-loss-settle", service.state.revision, battle.snapshot)
expect(settled.ok and service.state.current_run.phase == "rg04_contract2_boss_recovery", "Boss defeat opens recovery")
expect(service.state.current_run.company.size() == company_before - 1 and fallen_id not in service.state.current_run.company, "Boss casualty is permanent")
var recovered := service.recover_boss("fg4-rg04-boss-loss-recover", service.state.revision, String(battle.snapshot.snapshot_hash), 34)
expect(recovered.ok and service.state.current_run.phase == "rg04_contract2_boss_muster", "Boss recovery returns to same Muster")
expect(service.state.current_run.boss_muster.muster_hash == muster_hash, "Redaction Hart Muster never rerolls")
expect(fallen_id not in service.state.current_run.company, "Boss recovery never resurrects")
func verify_redaction_hart_tamper_boundaries() -> void:
var service := Contract.new(Fixture.new().rg04_contract2_boss_muster_snapshot())
if not service.valid:
return
var muster_hash := String(service.state.current_run.boss_muster.muster_hash)
expect(not service.commit_boss_plan("fg4-rg04-boss-bad-plan", service.state.revision, muster_hash, "unknown").ok, "unknown Boss plan rejects")
var prepared := service.commit_boss_plan("fg4-rg04-boss-tamper-prepare", service.state.revision, muster_hash, "safe_rule_seed")
var battle := Battle.new(service.state.snapshot()).run_to_terminal("safe_rule_seed")
var tampered: Dictionary = battle.snapshot.duplicate(true)
tampered.muster_hash = "0".repeat(64)
expect(prepared.ok and not service.settle_boss("fg4-rg04-boss-tamper-settle", service.state.revision, tampered).ok, "tampered Boss snapshot rejects")
expect(service.state.current_run.phase == "rg04_contract2_boss_prepared", "rejected Boss settlement preserves prepared state")
func has_event(events: Array, kind: String) -> bool:
return events.any(func(event): return String(event.get("kind", "")) == kind)
func expect(condition: bool, message: String) -> void:
if not condition:
failures.append("FG-4 RG-04 Contract-2 Boss: %s" % message)