Files
aetherbound-guild/runtime/tests/p9_7/battle_settlement_test.gd
T

201 lines
11 KiB
GDScript

extends SceneTree
const Content = preload("res://content/p9_7_content.gd")
const LegacyService = preload("res://p9_3/core_loop_service.gd")
const LegacyState = preload("res://p9_3/core_loop_state.gd")
const MarketService = preload("res://p9_7/market_service.gd")
const MarketState = preload("res://p9_7/market_state.gd")
const BattleService = preload("res://p9_7/battle_service.gd")
const SaveService = preload("res://p9_7/save_service.gd")
var failures: Array[String] = []
func _initialize() -> void:
call_deferred("run_test")
func run_test() -> void:
var legacy := complete_p96()
verify_three_victory_continuation(legacy)
verify_defeat_recovery_and_atomicity(legacy)
if failures.is_empty():
print("ABG_P9_7_BATTLE_SETTLEMENT_OK victories=3 rounds=5,6,7 rewards=28,30,32 xp=20,22,24 clear=7 capacity=7 relay=true market8=stable defeat_reward=0 recovery=8 duplicate_settlement=0 invalid_mutations=0 interruption=checkpoint")
quit(0)
else:
for failure in failures:
push_error(failure)
quit(1)
func verify_three_victory_continuation(legacy: Dictionary) -> void:
var market = MarketService.new(legacy)
var expected_clear := 4
for step in [
{"market": 5, "recruit": "P97-M5-R2", "route": "P97-R5-Q0", "reward": 28, "xp": 20},
{"market": 6, "recruit": "P97-M6-R2", "route": "P97-R6-Q0", "reward": 30, "xp": 22},
{"market": 7, "recruit": "P97-M7-R3", "route": "P97-R7-Q0", "reward": 32, "xp": 24},
]:
expect(int(market.state.current_market) == int(step.market), "Market %d opens before preparation" % int(step.market))
hire_recruit(market, String(step.recruit), "arc-%d" % int(step.market))
var deployment := market.auto_order_candidate()
expect(market.commit_deployment("arc-deploy-%d" % int(step.market), deployment).ok, "Market %d deployment commits" % int(step.market))
expect(market.focus_route(String(step.route)).ok, "Market %d route focuses" % int(step.market))
expect(market.commit_route("arc-route-%d" % int(step.market), String(step.route)).ok, "Market %d route commits" % int(step.market))
var battle = run_battle(market)
expect(battle.state.outcome == "victory", "Round %d controlled route wins" % int(step.market))
var before: Dictionary = market.state.snapshot()
var settlement: Dictionary = market.settle_battle("arc-settle-%d" % int(step.market), battle.state.snapshot())
expect(settlement.ok and not settlement.duplicate, "Round %d settles once" % int(step.market))
if not settlement.ok:
print("P97_SETTLEMENT_REJECT round=%d outcome=%s code=%s" % [int(step.market), battle.state.outcome, settlement.code])
return
expect(int(settlement.receipt.coin_after) - int(settlement.receipt.coin_before) == int(step.reward), "Round %d grants exact Coin" % int(step.market))
expect(int(settlement.receipt.xp_grant) == int(step.xp), "Round %d grants exact living XP" % int(step.market))
for row in settlement.receipt.xp_members:
expect(int(row.grant) == int(step.xp), "Round %d living Recruit receives exact XP" % int(step.market))
for recruit_id in before.deployed_recruit_ids:
expect(int(market.state.member_condition[recruit_id]) == int(battle.state.member_hp[recruit_id]), "Round %d carries %s HP" % [int(step.market), recruit_id])
expected_clear += 1
expect(int(market.state.cleared_rounds) == expected_clear, "Round %d increments clear once" % int(step.market))
var settled_snapshot: Dictionary = market.state.snapshot()
var duplicate: Dictionary = market.settle_battle("arc-settle-%d" % int(step.market), battle.state.snapshot())
expect(duplicate.ok and duplicate.duplicate and market.state.snapshot() == settled_snapshot, "Round %d duplicate settlement is inert" % int(step.market))
var conflict_snapshot: Dictionary = battle.state.snapshot()
conflict_snapshot.tick = int(conflict_snapshot.tick) + 1
var conflict: Dictionary = market.settle_battle("arc-settle-%d" % int(step.market), conflict_snapshot)
expect(not conflict.ok and conflict.code == "operation_id_conflict" and market.state.snapshot() == settled_snapshot, "Round %d conflicting settlement is inert" % int(step.market))
if market.state.recovery_required:
var recovery: Dictionary = market.recover_injured_company("arc-recover-%d" % int(step.market))
expect(recovery.ok, "Round %d fallen Recruit recovery commits" % int(step.market))
if int(market.state.current_market) == 8:
expect(market.state.relay_restored and market.state.continuation_locked, "Round 7 restores Relay and opens explicit continuation threshold")
expect(market.state.market_board == MarketState.continuation_board(), "Market 8 uses exact threshold board")
expect(market.state.available_recruit_offer_ids.is_empty() and market.state.available_equipment_offer_ids.is_empty() and market.state.available_battle_offer_ids.is_empty(), "Market 8 does not invent an ordinary offer board")
expect(not market.focus_route("P97-R7-Q0").ok, "Market 8 cannot reopen an old route")
verify_market8_reload(market.state.snapshot())
func verify_defeat_recovery_and_atomicity(legacy: Dictionary) -> void:
var market = MarketService.new(legacy)
expect(force_market(market, 6), "defeat fixture enters stable Market 6")
hire_recruit(market, "P97-M6-R3", "defeat")
expect(market.commit_deployment("defeat-deploy", market.auto_order_candidate()).ok, "defeat fixture deployment commits")
market.focus_route("P97-R6-Q2")
market.commit_route("defeat-route", "P97-R6-Q2")
var committed_checkpoint: Dictionary = market.state.battle_checkpoint.duplicate(true)
var battle = run_battle(market)
expect(battle.state.outcome == "defeat", "Bellkeeper elite fixture reaches deterministic defeat")
var invalid: Dictionary = battle.state.snapshot()
invalid.member_hp[market.state.deployed_recruit_ids[0]] = 9999
var before_invalid: Dictionary = market.state.snapshot()
var rejected: Dictionary = market.settle_battle("defeat-invalid", invalid)
expect(not rejected.ok and rejected.code == "battle_hp_invalid" and market.state.snapshot() == before_invalid, "invalid terminal HP mutates nothing")
var coin_before: int = market.state.coin
var xp_before := xp_snapshot(market)
var settled: Dictionary = market.settle_battle("defeat-settle", battle.state.snapshot())
expect(settled.ok and settled.receipt.outcome == "defeat", "defeat settles explicitly")
if not settled.ok:
print("P97_DEFEAT_SETTLEMENT_REJECT code=%s outcome=%s" % [settled.code, battle.state.outcome])
return
expect(market.state.coin == coin_before and xp_snapshot(market) == xp_before, "defeat grants no Coin or XP")
expect(int(market.state.cleared_rounds) == 5 and int(market.state.current_market) == 6, "defeat preserves the same Market and clear count")
expect(market.state.recovery_required and market.state.recovery_kind == "defeat" and int(market.state.recovery_cost) == 8, "defeat exposes exact recovery cost")
expect(market.state.retry_route == "P97-R6-Q2", "defeat preserves retry route identity")
expect(market.state.battle_checkpoint.is_empty() and committed_checkpoint.phase == MarketState.Phase.MARKET, "settlement clears transient checkpoint after proving its Market origin")
var blocked_snapshot: Dictionary = market.state.snapshot()
expect(not market.commit_route("blocked-route", "P97-R6-Q2").ok and market.state.snapshot() == blocked_snapshot, "route commit is blocked until recovery")
var recovery: Dictionary = market.recover_injured_company("defeat-recover")
expect(recovery.ok and int(recovery.receipt.cost) == 8, "defeat recovery commits exact Coin once")
if not recovery.ok:
print("P97_RECOVERY_REJECT code=%s" % recovery.code)
return
for recruit_id in recovery.receipt.recruit_ids:
expect(int(market.state.member_condition[recruit_id]) > 0, "recovery restores %s" % recruit_id)
var recovered_snapshot: Dictionary = market.state.snapshot()
var duplicate: Dictionary = market.recover_injured_company("defeat-recover")
expect(duplicate.ok and duplicate.duplicate and market.state.snapshot() == recovered_snapshot, "duplicate recovery is inert")
func verify_market8_reload(snapshot: Dictionary) -> void:
var root := OS.get_environment("ABG_P9_7_SAVE_TEST_ROOT")
if root.is_empty():
root = "/private/tmp/abg-p97-settlement-save"
DirAccess.make_dir_recursive_absolute(root)
var saves = SaveService.new()
saves.save_path = root.path_join("market8.json")
saves.clear()
expect(saves.save_snapshot(snapshot, 8000).ok, "Market 8 save writes")
var loaded: Dictionary = saves.load_snapshot(8060)
expect(loaded.ok and not loaded.battle_interrupted and loaded.snapshot == snapshot, "Market 8 reload is byte-stable at the state boundary")
func hire_recruit(market, recruit_id: String, prefix: String) -> void:
expect(market.focus_recruit_offer(recruit_id).ok, "%s Recruit focuses" % recruit_id)
expect(market.hire("%s-hire-%s" % [prefix, recruit_id], recruit_id).ok, "%s Recruit hires" % recruit_id)
func force_market(market, market_index: int) -> bool:
var raw: Dictionary = market.state.snapshot()
raw.cleared_rounds = market_index - 1
raw.line_capacity = MarketState.capacity_for_clears(raw.cleared_rounds)
raw.current_market = market_index
raw.market_board = Content.snapshot().boards[market_index].duplicate(true)
raw.available_recruit_offer_ids = raw.market_board.recruit_offer_ids.duplicate()
raw.available_equipment_offer_ids = raw.market_board.equipment_offer_ids.duplicate()
raw.available_battle_offer_ids = raw.market_board.battle_offer_ids.duplicate()
return market.state.restore_snapshot(raw)
func run_battle(market):
var battle = BattleService.new()
expect(battle.start_from_market(market.state).ok, "%s battle starts" % market.state.selected_route)
var guard := 0
while not battle.state.terminal and guard < 2000:
battle.advance_ticks(1)
guard += 1
expect(guard < 2000 and battle.state.outcome in ["victory", "defeat"], "%s battle terminates" % market.state.selected_route)
return battle
func xp_snapshot(market) -> Dictionary:
var result := {}
for recruit_id in market.state.company:
result[recruit_id] = {
"level": int(market.state.recruit_records[recruit_id].level),
"xp": int(market.state.recruit_records[recruit_id].xp),
}
return result
func complete_p96() -> Dictionary:
var service = LegacyService.new()
service.enter_hall()
service.focus_offer("Farstring")
service.hire("Farstring")
complete_battle(service, "open_road")
service.focus_offer("Kindhand")
service.hire("Kindhand")
complete_battle(service, "crosswind")
service.focus_equipment("EQ-002")
service.equip_focused("Hearthguard")
complete_battle(service, "bell_breach")
service.choose_rift_tide_plan("press_on")
complete_battle(service, "rift_tide")
return service.state.snapshot()
func complete_battle(service, encounter_id: String) -> void:
service.select_encounter(encounter_id)
service.start_battle()
var guard := 0
while service.state.phase == LegacyState.Phase.BATTLE and guard < 4000:
service.advance_battle_ticks(1)
guard += 1
service.claim_and_return()
func expect(condition: bool, message: String) -> void:
if not condition:
failures.append("P9.7 battle settlement: %s" % message)