208 lines
8.4 KiB
GDScript
208 lines
8.4 KiB
GDScript
class_name ABGBattleLivePageController
|
|
extends RefCounted
|
|
|
|
## UI-independent BAT-002 Live Battle view-data assembly.
|
|
##
|
|
## BattleService remains responsible for observation preview/commit, snapshot
|
|
## retry, settlement and every receipt boundary. This controller only validates
|
|
## and copies the facts that the existing Live Battle View is allowed to show.
|
|
|
|
const VALID_STATES: Array[String] = [
|
|
"waiting_for_next_event",
|
|
"event_forecast",
|
|
"action_committed",
|
|
"event_resolving",
|
|
"event_resolved",
|
|
"paused",
|
|
"inspect_handoff",
|
|
"pause_controls_handoff",
|
|
"outcome_locked",
|
|
"invalid_event_data",
|
|
"snapshot_retrying",
|
|
"loading_resume",
|
|
"interrupted_background",
|
|
"no_resumable_battle",
|
|
]
|
|
|
|
|
|
func snapshot(
|
|
company: Dictionary,
|
|
battle: Dictionary,
|
|
observation: Dictionary,
|
|
current_event: Dictionary,
|
|
state := "waiting_for_next_event",
|
|
resume_state := "waiting_for_next_event",
|
|
paused := true,
|
|
speed := 1.0,
|
|
notice := "",
|
|
error_code := "",
|
|
interruption: Dictionary = {},
|
|
pause_log_open := false,
|
|
locale := "zh_CN"
|
|
) -> Dictionary:
|
|
if company.is_empty():
|
|
return {"ok": false, "code": "COMPANY_REQUIRED"}
|
|
var raw_contract = company.get("active_contract", {})
|
|
if not raw_contract is Dictionary or Dictionary(raw_contract).is_empty():
|
|
return {"ok": false, "code": "LIVE_CONTRACT_REQUIRED"}
|
|
if battle.is_empty():
|
|
return {"ok": false, "code": "LIVE_BATTLE_REQUIRED"}
|
|
if String(battle.get("status", "")) not in ["active", "outcome_locked"]:
|
|
return {"ok": false, "code": "LIVE_BATTLE_INVALID"}
|
|
if state not in VALID_STATES or resume_state not in VALID_STATES:
|
|
return {"ok": false, "code": "LIVE_STATE_INVALID"}
|
|
var raw_observation = observation
|
|
if not raw_observation is Dictionary or Dictionary(raw_observation).is_empty():
|
|
return {"ok": false, "code": "LIVE_OBSERVATION_REQUIRED"}
|
|
var copied_observation: Dictionary = Dictionary(raw_observation).duplicate(true)
|
|
var operation_id := String(battle.get("operation_id", ""))
|
|
if operation_id.is_empty() or String(copied_observation.get("operation_id", "")) != operation_id:
|
|
return {"ok": false, "code": "LIVE_OPERATION_MISMATCH"}
|
|
var battle_snapshot_hash := String(battle.get("snapshot_hash", ""))
|
|
var observation_snapshot_hash := String(copied_observation.get("snapshot_hash", ""))
|
|
if not battle_snapshot_hash.is_empty() and not observation_snapshot_hash.is_empty() and battle_snapshot_hash != observation_snapshot_hash:
|
|
return {"ok": false, "code": "LIVE_SNAPSHOT_MISMATCH"}
|
|
if String(copied_observation.get("status", "")) not in ["waiting_for_next_event", "outcome_locked"]:
|
|
return {"ok": false, "code": "LIVE_OBSERVATION_INVALID"}
|
|
if state == "outcome_locked" and String(battle.get("status", "")) != "outcome_locked" and String(copied_observation.get("status", "")) != "outcome_locked":
|
|
return {"ok": false, "code": "LIVE_OUTCOME_LOCK_MISSING"}
|
|
var contract: Dictionary = Dictionary(raw_contract).duplicate(true)
|
|
var members := _members_by_id(company.get("owned_recruits", []))
|
|
var party_ids = battle.get("front_to_rear_ids", [])
|
|
if not party_ids is Array or party_ids.is_empty():
|
|
return {"ok": false, "code": "LIVE_PARTY_INVALID"}
|
|
var party_validation := _validate_ids(party_ids, members)
|
|
if not party_validation.ok:
|
|
return party_validation
|
|
var enemy_ids = battle.get("enemy_ids", [])
|
|
if not enemy_ids is Array or enemy_ids.is_empty():
|
|
return {"ok": false, "code": "LIVE_ENEMY_LINE_INVALID"}
|
|
var copied_event := Dictionary(current_event).duplicate(true)
|
|
var copied_events := _copy_array(battle.get("phase_events", []))
|
|
var copied_interrupt := Dictionary(interruption).duplicate(true)
|
|
var ordered_recruits: Array[Dictionary] = []
|
|
for position in range(party_validation.ids.size()):
|
|
var recruit_id := String(party_validation.ids[position])
|
|
ordered_recruits.append({
|
|
"position": position,
|
|
"recruit_id": recruit_id,
|
|
"recruit": Dictionary(members[recruit_id]).duplicate(true),
|
|
})
|
|
var copied_battle: Dictionary = battle.duplicate(true)
|
|
var state_flags := _state_flags(state)
|
|
var commands := _commands_for_state(state)
|
|
return {
|
|
"ok": true,
|
|
"page_id": "battle_live",
|
|
"locale": String(locale),
|
|
"company": {
|
|
"company_id": String(company.get("company_id", "")),
|
|
"owned_count": members.size(),
|
|
"line_capacity": int(contract.get("line_capacity", party_validation.ids.size())),
|
|
},
|
|
"contract": {
|
|
"contract_id": String(contract.get("contract_id", "")),
|
|
"run_id": String(contract.get("run_id", "")),
|
|
"contract_hash": String(contract.get("contract_hash", "")),
|
|
},
|
|
"battle": {
|
|
"operation_id": operation_id,
|
|
"battle_hash": String(battle.get("battle_hash", "")),
|
|
"status": String(battle.get("status", "")),
|
|
"snapshot_id": String(battle.get("snapshot_id", "")),
|
|
"snapshot_hash": battle_snapshot_hash,
|
|
"front_to_rear_ids": party_validation.ids.duplicate(true),
|
|
"enemy_ids": _copy_array(enemy_ids),
|
|
"phase_index": int(battle.get("phase_index", 0)),
|
|
"total_phases": int(battle.get("total_phases", 0)),
|
|
"phase_events": copied_events,
|
|
"copy": copied_battle,
|
|
},
|
|
"observation": copied_observation,
|
|
"party": {
|
|
"front_to_rear_ids": party_validation.ids.duplicate(true),
|
|
"ordered_recruits": ordered_recruits,
|
|
},
|
|
"enemies": {
|
|
"ids": _copy_array(enemy_ids),
|
|
"count": enemy_ids.size(),
|
|
},
|
|
"event": copied_event,
|
|
"recent_events": copied_events.slice(maxi(0, copied_events.size() - 4), copied_events.size()),
|
|
"state": {
|
|
"name": String(state),
|
|
"resume_state": String(resume_state),
|
|
"paused": bool(paused),
|
|
"speed": maxf(1.0, float(speed)),
|
|
"notice": String(notice),
|
|
"error_code": String(error_code),
|
|
"pause_log_open": bool(pause_log_open),
|
|
"interruption": copied_interrupt,
|
|
"flags": state_flags,
|
|
},
|
|
"commands": commands,
|
|
}
|
|
|
|
|
|
func _state_flags(state: String) -> Dictionary:
|
|
return {
|
|
"waiting": state == "waiting_for_next_event",
|
|
"event_active": state in ["event_forecast", "action_committed", "event_resolving", "event_resolved"],
|
|
"paused": state in ["paused", "inspect_handoff", "pause_controls_handoff"],
|
|
"inspect": state == "inspect_handoff",
|
|
"pause_controls": state == "pause_controls_handoff",
|
|
"outcome_locked": state == "outcome_locked",
|
|
"interrupted": state == "interrupted_background",
|
|
"invalid": state in ["invalid_event_data", "no_resumable_battle"],
|
|
"loading": state in ["snapshot_retrying", "loading_resume"],
|
|
}
|
|
|
|
|
|
func _commands_for_state(state: String) -> Dictionary:
|
|
var controls_locked := state in ["outcome_locked", "invalid_event_data", "snapshot_retrying", "loading_resume", "interrupted_background", "no_resumable_battle"]
|
|
return {
|
|
"pause_enabled": not controls_locked and state not in ["inspect_handoff", "pause_controls_handoff"],
|
|
"speed_enabled": not controls_locked and state not in ["action_committed", "event_resolving", "inspect_handoff", "pause_controls_handoff"],
|
|
"inspect_enabled": state not in ["outcome_locked", "invalid_event_data", "snapshot_retrying", "loading_resume", "interrupted_background", "no_resumable_battle", "pause_controls_handoff"],
|
|
"settings_enabled": state not in ["invalid_event_data", "snapshot_retrying", "loading_resume", "interrupted_background", "no_resumable_battle"],
|
|
"next_boundary_enabled": state not in ["action_committed", "event_resolving", "invalid_event_data", "snapshot_retrying", "loading_resume", "no_resumable_battle"],
|
|
"retry_snapshot_enabled": state == "invalid_event_data",
|
|
"safe_exit_enabled": state in ["invalid_event_data", "interrupted_background", "no_resumable_battle"],
|
|
"outcome_handoff_enabled": state == "outcome_locked",
|
|
"interruption_review_enabled": state == "interrupted_background",
|
|
}
|
|
|
|
|
|
func _validate_ids(values: Array, members: Dictionary) -> Dictionary:
|
|
var ids: Array = []
|
|
for value in values:
|
|
var recruit_id := String(value)
|
|
if not members.has(recruit_id):
|
|
return {"ok": false, "code": "LIVE_RECRUIT_UNKNOWN"}
|
|
if recruit_id in ids:
|
|
return {"ok": false, "code": "LIVE_RECRUIT_DUPLICATE"}
|
|
ids.append(recruit_id)
|
|
return {"ok": true, "code": "LIVE_PARTY_VALID", "ids": ids}
|
|
|
|
|
|
func _members_by_id(values) -> Dictionary:
|
|
var result := {}
|
|
if not values is Array:
|
|
return result
|
|
for value in values:
|
|
if value is Dictionary:
|
|
var copied: Dictionary = Dictionary(value).duplicate(true)
|
|
var recruit_id := String(copied.get("recruit_id", ""))
|
|
if not recruit_id.is_empty():
|
|
result[recruit_id] = copied
|
|
return result
|
|
|
|
|
|
func _copy_array(values) -> Array:
|
|
var result: Array = []
|
|
if not values is Array:
|
|
return result
|
|
for value in values:
|
|
result.append(value.duplicate(true) if value is Dictionary or value is Array else value)
|
|
return result
|