1518 lines
64 KiB
GDScript
1518 lines
64 KiB
GDScript
class_name P100RuntimeController
|
|
extends "res://p9_7/runtime_controller.gd"
|
|
|
|
const P100Content = preload("res://p10_0/content_registry.gd")
|
|
const P100MarketService = preload("res://p10_0/market_service.gd")
|
|
const P100BattleService = preload("res://p10_0/wave_battle_service.gd")
|
|
const P100ResolutionService = preload("res://p10_0/resolution_service.gd")
|
|
const P100ContractService = preload("res://p10_0/contract_service.gd")
|
|
const P100BossBattleService = preload("res://p10_0/boss_battle_service.gd")
|
|
const P100SaveService = preload("res://p10_0/save_service.gd")
|
|
|
|
const SAVE_PATH := "user://aetherbound_guild_p10.json"
|
|
const TOUCH_DRAG_SLOP := 18.0
|
|
const DIFFICULTIES := ["wayfinder", "standard", "stormbound", "iron_oath"]
|
|
const ROLE_RIGS := {
|
|
"front_hold": "Hearthguard",
|
|
"single_pressure": "Wayrunner",
|
|
"reach_control": "Farstring",
|
|
"reorder": "Wayrunner",
|
|
"projectile": "Farstring",
|
|
"area": "Farstring",
|
|
"restore": "Kindhand",
|
|
"enable": "Hearthguard",
|
|
"construct": "Hearthguard",
|
|
"impair": "Wayrunner",
|
|
"tempo": "Wayrunner",
|
|
"supply": "Kindhand",
|
|
}
|
|
|
|
var profession_rows: Dictionary = {}
|
|
var trait_rows: Dictionary = {}
|
|
var equipment_rows: Dictionary = {}
|
|
var enemy_rows: Dictionary = {}
|
|
var boss_rows: Dictionary = {}
|
|
var contract_rows: Dictionary = {}
|
|
var screen := "title"
|
|
var selected_difficulty := "standard"
|
|
var opening_selection: Array[String] = []
|
|
var focused_recruit_offer := ""
|
|
var focused_equipment_offer := ""
|
|
var focused_battle_offer := ""
|
|
var focused_company_actor := ""
|
|
var focused_boss_plan := ""
|
|
var pending_line: Array[String] = []
|
|
var boss_battle
|
|
var boss_battle_active := false
|
|
var battle_snapshot: Dictionary = {}
|
|
var battle_event_cursor := 0
|
|
var recent_events: Array[Dictionary] = []
|
|
var save_sequence := 0
|
|
var save_commit_hash := ""
|
|
var settings_open := false
|
|
var reset_confirmation := false
|
|
var input_touch_count := 0
|
|
var input_drag_count := 0
|
|
var drag_source_recruit := ""
|
|
var drag_start := Vector2.ZERO
|
|
var drag_active := false
|
|
var suppress_actor_tap_until_frame := -1
|
|
var line_touch_rects: Dictionary = {}
|
|
var save_path := SAVE_PATH
|
|
var owned_touch_index := -1
|
|
var owned_touch_button: Button
|
|
var owned_touch_mouse_filter := Control.MOUSE_FILTER_STOP
|
|
var owned_touch_start := Vector2.ZERO
|
|
var owned_touch_dragged := false
|
|
var drag_touch_index := -1
|
|
|
|
|
|
func _bootstrap_market() -> void:
|
|
content = P100Content.snapshot()
|
|
profession_rows = P100Content.rows_by_id(content, "professions")
|
|
trait_rows = P100Content.rows_by_id(content, "traits")
|
|
equipment_rows = P100Content.rows_by_id(content, "equipment")
|
|
enemy_rows = P100Content.rows_by_id(content, "enemies")
|
|
boss_rows = P100Content.rows_by_id(content, "bosses")
|
|
contract_rows = P100Content.rows_by_id(content, "contracts")
|
|
saves = P100SaveService.new()
|
|
market = P100MarketService.new()
|
|
var restored := false
|
|
if not entry_snapshot.is_empty():
|
|
restored = market.restore_snapshot(entry_snapshot)
|
|
elif persistence_enabled:
|
|
var loaded: Dictionary = saves.load_slot(ProjectSettings.globalize_path(save_path))
|
|
if loaded.ok:
|
|
restored = market.restore_snapshot(loaded.snapshot)
|
|
save_sequence = int(loaded.sequence)
|
|
save_commit_hash = String(loaded.commit_hash)
|
|
if not entry_snapshot.is_empty() and not restored:
|
|
last_code = "p100_snapshot_invalid"
|
|
screen = "title"
|
|
elif restored:
|
|
last_code = "p100_resumed"
|
|
_restore_runtime_phase()
|
|
else:
|
|
last_code = "p100_title_ready"
|
|
screen = "title"
|
|
opening_selection.clear()
|
|
focused_recruit_offer = ""
|
|
focused_equipment_offer = ""
|
|
focused_battle_offer = ""
|
|
focused_company_actor = ""
|
|
focused_boss_plan = ""
|
|
battle_active = false if screen != "battle" else battle_active
|
|
battle_result_visible = false
|
|
pending_line.assign(market.state.current_run.get("deployed_recruit_ids", []))
|
|
_queue_render()
|
|
|
|
|
|
func _restore_runtime_phase() -> void:
|
|
if not market.state.run_creation_draft.is_empty():
|
|
screen = "opening"
|
|
opening_selection.assign(market.state.run_creation_draft.selected_offer_ids)
|
|
return
|
|
if market.state.current_run.is_empty():
|
|
screen = "guild" if not market.state.guild_profile.company_records.is_empty() else "title"
|
|
return
|
|
var phase := String(market.state.current_run.phase)
|
|
if phase == "encounter":
|
|
battle = P100BattleService.new(market.state.snapshot())
|
|
boss_battle_active = false
|
|
_start_visible_battle()
|
|
elif phase == "boss_encounter":
|
|
boss_battle = P100BossBattleService.new(market.state.snapshot())
|
|
boss_battle_active = true
|
|
_start_visible_battle()
|
|
elif phase == "boss_muster":
|
|
screen = "boss_muster"
|
|
elif phase == "contract_result":
|
|
screen = "contract_result"
|
|
else:
|
|
screen = "reward" if not market.state.current_run.pending_reward.is_empty() else "market"
|
|
|
|
|
|
func _process(delta: float) -> void:
|
|
if not low_power:
|
|
world_clock += maxf(0.0, delta)
|
|
_update_ambient_actors()
|
|
_animate_runtime_battle_actors()
|
|
if not battle_active or battle_result_visible or battle_paused or not battle_auto_advance:
|
|
return
|
|
battle_tick_accumulator += maxf(0.0, delta) * float(battle_speed)
|
|
var ticks := int(floor(battle_tick_accumulator / 0.10))
|
|
if ticks <= 0:
|
|
return
|
|
battle_tick_accumulator -= float(ticks) * 0.10
|
|
advance_battle_ticks(ticks)
|
|
|
|
|
|
func _input(event: InputEvent) -> void:
|
|
if event is InputEventScreenTouch:
|
|
var touch := event as InputEventScreenTouch
|
|
if touch.pressed:
|
|
input_touch_count += 1
|
|
if owned_touch_index >= 0:
|
|
return
|
|
owned_touch_index = touch.index
|
|
owned_touch_button = _button_at_point(touch.position)
|
|
if owned_touch_button != null:
|
|
owned_touch_mouse_filter = owned_touch_button.mouse_filter
|
|
owned_touch_button.mouse_filter = Control.MOUSE_FILTER_IGNORE
|
|
owned_touch_start = touch.position
|
|
owned_touch_dragged = false
|
|
drag_start = touch.position
|
|
drag_source_recruit = _recruit_at_point(touch.position)
|
|
drag_touch_index = touch.index if not drag_source_recruit.is_empty() else -1
|
|
drag_active = false
|
|
if owned_touch_button != null or drag_touch_index >= 0:
|
|
get_viewport().set_input_as_handled()
|
|
else:
|
|
_clear_touch_ownership()
|
|
elif touch.index == owned_touch_index:
|
|
get_viewport().set_input_as_handled()
|
|
var release_button := _button_at_point(touch.position, owned_touch_button)
|
|
var activate_button := (
|
|
not touch.canceled
|
|
and not owned_touch_dragged
|
|
and owned_touch_button != null
|
|
and is_instance_valid(owned_touch_button)
|
|
and not owned_touch_button.is_queued_for_deletion()
|
|
and release_button == owned_touch_button
|
|
)
|
|
var button_to_activate := owned_touch_button
|
|
var button_instance_id := button_to_activate.get_instance_id() if is_instance_valid(button_to_activate) else 0
|
|
var mouse_filter_to_restore := owned_touch_mouse_filter
|
|
if not drag_source_recruit.is_empty() and touch.index == drag_touch_index:
|
|
if drag_active:
|
|
var target: String = _recruit_at_point(touch.position)
|
|
_commit_line_drag(drag_source_recruit, target)
|
|
suppress_actor_tap_until_frame = Engine.get_process_frames() + 1
|
|
_clear_touch_ownership()
|
|
call_deferred("_restore_touch_button_mouse_filter", button_instance_id, mouse_filter_to_restore)
|
|
if activate_button and is_instance_valid(button_to_activate):
|
|
button_to_activate.emit_signal(&"pressed")
|
|
elif event is InputEventScreenDrag and event.index == owned_touch_index:
|
|
var drag := event as InputEventScreenDrag
|
|
get_viewport().set_input_as_handled()
|
|
if drag.position.distance_to(owned_touch_start) >= TOUCH_DRAG_SLOP:
|
|
owned_touch_dragged = true
|
|
if drag_touch_index == drag.index and not drag_source_recruit.is_empty():
|
|
input_drag_count += 1
|
|
if drag.position.distance_to(drag_start) >= TOUCH_DRAG_SLOP:
|
|
drag_active = true
|
|
|
|
|
|
func begin_expedition() -> void:
|
|
if screen != "title" and screen != "guild":
|
|
return
|
|
var contract_id: String = "CTR-R1-02" if "CLEAR-RG01-C01" in market.state.guild_profile.contract_clear_ids and "CLEAR-RG01-C02" not in market.state.guild_profile.contract_clear_ids else "CTR-R1-01"
|
|
var begun: Dictionary = market.begin_run_creation(_operation("run", "begin"), market.state.revision, contract_id, selected_difficulty)
|
|
if not begun.ok:
|
|
last_code = String(begun.code)
|
|
_queue_render()
|
|
return
|
|
var draft_id := String(market.state.run_creation_draft.draft_id)
|
|
var materialized: Dictionary = market.materialize_opening_offers(_operation("run", "offers"), market.state.revision, draft_id)
|
|
last_code = String(materialized.code)
|
|
if materialized.ok:
|
|
screen = "opening"
|
|
opening_selection.clear()
|
|
if persistence_enabled and not _save_stable():
|
|
last_code = "p100_opening_save_failed"
|
|
_queue_render()
|
|
|
|
|
|
func choose_difficulty(difficulty: String) -> void:
|
|
if difficulty in DIFFICULTIES and screen in ["title", "guild"]:
|
|
selected_difficulty = difficulty
|
|
last_code = "difficulty_selected"
|
|
_queue_render()
|
|
|
|
|
|
func tap_opening_offer(offer_id: String) -> void:
|
|
if screen != "opening" or market.state.run_creation_draft.is_empty():
|
|
return
|
|
if offer_id in opening_selection:
|
|
opening_selection.erase(offer_id)
|
|
elif opening_selection.size() < 2:
|
|
opening_selection.append(offer_id)
|
|
else:
|
|
opening_selection.pop_front()
|
|
opening_selection.append(offer_id)
|
|
last_code = "opening_selection_local"
|
|
if opening_selection.size() == 2:
|
|
var selected: Dictionary = market.set_opening_selection(_operation("run", "selection"), market.state.revision, opening_selection)
|
|
last_code = String(selected.code)
|
|
if selected.ok:
|
|
opening_selection.assign(market.state.run_creation_draft.selected_offer_ids)
|
|
_save_stable()
|
|
_queue_render()
|
|
|
|
|
|
func commit_opening_company() -> void:
|
|
if screen != "opening" or opening_selection.size() != 2 or market.state.run_creation_draft.is_empty():
|
|
return
|
|
var draft: Dictionary = market.state.run_creation_draft
|
|
var result: Dictionary = market.commit_run_creation(
|
|
_operation("run", "commit"),
|
|
market.state.revision,
|
|
String(draft.draft_id),
|
|
int(draft.selection_revision),
|
|
opening_selection,
|
|
String(draft.opening_offer_set_hash)
|
|
)
|
|
last_code = String(result.code)
|
|
if result.ok:
|
|
screen = "market"
|
|
pending_line.assign(market.state.current_run.deployed_recruit_ids)
|
|
_save_stable()
|
|
_queue_render()
|
|
|
|
|
|
func tap_recruit_offer(offer_id: String) -> void:
|
|
if not _market_ready():
|
|
return
|
|
var offer_result: Dictionary = market.inspect_recruit_offer(offer_id)
|
|
if not offer_result.ok:
|
|
last_code = String(offer_result.code)
|
|
_queue_render()
|
|
return
|
|
if focused_recruit_offer != offer_id:
|
|
focused_recruit_offer = offer_id
|
|
focused_equipment_offer = ""
|
|
focused_battle_offer = ""
|
|
last_code = "recruit_offer_inspected"
|
|
_queue_render()
|
|
return
|
|
var offer: Dictionary = offer_result.receipt
|
|
var hired: Dictionary = market.hire(_operation("hire", offer_id), market.state.revision, offer_id, int(offer.list_price), true)
|
|
last_code = String(hired.code)
|
|
if hired.ok:
|
|
focused_recruit_offer = ""
|
|
pending_line.assign(market.state.current_run.formation_proposal)
|
|
_save_stable()
|
|
_queue_render()
|
|
|
|
|
|
func tap_equipment_offer(offer_id: String) -> void:
|
|
if not _market_ready():
|
|
return
|
|
var inspected: Dictionary = market.inspect_equipment_offer(offer_id)
|
|
last_code = String(inspected.code)
|
|
if inspected.ok:
|
|
focused_equipment_offer = offer_id
|
|
focused_recruit_offer = ""
|
|
focused_battle_offer = ""
|
|
_queue_render()
|
|
|
|
|
|
func tap_company_actor(recruit_id: String) -> void:
|
|
if Engine.get_process_frames() <= suppress_actor_tap_until_frame or not _market_ready() or recruit_id not in market.state.current_run.company:
|
|
return
|
|
if not focused_equipment_offer.is_empty():
|
|
_buy_and_equip(focused_equipment_offer, recruit_id)
|
|
return
|
|
if focused_company_actor != recruit_id:
|
|
focused_company_actor = recruit_id
|
|
last_code = "company_actor_inspected"
|
|
else:
|
|
if recruit_id in pending_line:
|
|
if pending_line.size() > 1:
|
|
pending_line.erase(recruit_id)
|
|
last_code = "line_member_moved_to_reserve"
|
|
else:
|
|
if pending_line.size() < int(market.state.current_run.line_capacity):
|
|
pending_line.append(recruit_id)
|
|
last_code = "reserve_member_added"
|
|
_queue_render()
|
|
|
|
|
|
func commit_pending_line() -> void:
|
|
if not _market_ready() or pending_line.is_empty():
|
|
return
|
|
var committed: Dictionary = market.commit_deployment(_operation("deploy", "line"), market.state.revision, pending_line)
|
|
last_code = String(committed.code)
|
|
if committed.ok:
|
|
pending_line.assign(market.state.current_run.deployed_recruit_ids)
|
|
_save_stable()
|
|
_queue_render()
|
|
|
|
|
|
func use_automatic_line() -> void:
|
|
if not _market_ready():
|
|
return
|
|
pending_line.assign(market.automatic_formation_candidate())
|
|
commit_pending_line()
|
|
|
|
|
|
func refresh_market() -> void:
|
|
if not _market_ready():
|
|
return
|
|
var cost: int = P100MarketService.refresh_cost(int(market.state.current_run.refresh_count), market.state.current_run.locks.size())
|
|
var refreshed: Dictionary = market.refresh_market(_operation("market", "refresh"), market.state.revision, cost)
|
|
last_code = String(refreshed.code)
|
|
if refreshed.ok:
|
|
focused_recruit_offer = ""
|
|
focused_equipment_offer = ""
|
|
_save_stable()
|
|
_queue_render()
|
|
|
|
|
|
func tap_battle_offer(offer_id: String) -> void:
|
|
if not _market_ready():
|
|
return
|
|
var preview: Dictionary = market.preview_battle_offer(offer_id)
|
|
if not preview.ok:
|
|
last_code = String(preview.code)
|
|
_queue_render()
|
|
return
|
|
if focused_battle_offer != offer_id:
|
|
focused_battle_offer = offer_id
|
|
focused_recruit_offer = ""
|
|
focused_equipment_offer = ""
|
|
last_code = "battle_offer_inspected"
|
|
_queue_render()
|
|
return
|
|
var committed: Dictionary = market.commit_battle_offer(_operation("battle", offer_id), market.state.revision, offer_id, String(market.state.current_run.market_board.board_hash))
|
|
last_code = String(committed.code)
|
|
if committed.ok:
|
|
battle = P100BattleService.new(market.state.snapshot())
|
|
boss_battle_active = false
|
|
_start_visible_battle()
|
|
_save_stable()
|
|
_queue_render()
|
|
|
|
|
|
func enter_boss_muster() -> void:
|
|
if not _market_ready() or int(market.state.current_run.cleared_rounds) != 12:
|
|
return
|
|
var contract := P100ContractService.new(market.state.snapshot())
|
|
var entered := contract.enter_boss_muster(_operation("boss", "muster"), contract.state.revision)
|
|
last_code = String(entered.code)
|
|
if entered.ok and _replace_market_snapshot(entered.snapshot):
|
|
screen = "boss_muster"
|
|
focused_boss_plan = ""
|
|
_save_stable()
|
|
_queue_render()
|
|
|
|
|
|
func tap_boss_plan(plan_id: String) -> void:
|
|
if market == null or market.state.current_run.is_empty() or String(market.state.current_run.phase) != "boss_muster":
|
|
return
|
|
if focused_boss_plan != plan_id:
|
|
focused_boss_plan = plan_id
|
|
last_code = "boss_plan_inspected"
|
|
_queue_render()
|
|
return
|
|
var contract := P100ContractService.new(market.state.snapshot())
|
|
var committed := contract.commit_boss_plan(_operation("boss", plan_id), contract.state.revision, String(contract.state.current_run.boss_muster.muster_hash), plan_id)
|
|
last_code = String(committed.code)
|
|
if committed.ok and _replace_market_snapshot(committed.snapshot):
|
|
boss_battle = P100BossBattleService.new(market.state.snapshot())
|
|
boss_battle_active = true
|
|
_start_visible_battle()
|
|
_save_stable()
|
|
_queue_render()
|
|
|
|
|
|
func advance_battle_ticks(ticks: int) -> Dictionary:
|
|
if not battle_active or battle_result_visible:
|
|
return {"ok": false, "code": "battle_inactive", "snapshot": battle_snapshot}
|
|
var result: Dictionary = boss_battle.advance_ticks(ticks) if boss_battle_active else battle.advance_ticks(ticks)
|
|
last_code = String(result.code)
|
|
if result.ok:
|
|
battle_snapshot = Dictionary(result.snapshot).duplicate(true)
|
|
_consume_battle_events()
|
|
battle_result_visible = bool(battle_snapshot.terminal)
|
|
_queue_render()
|
|
return result
|
|
|
|
|
|
func request_retreat() -> void:
|
|
if not battle_active or battle_result_visible or boss_battle_active:
|
|
return
|
|
var result: Dictionary = battle.begin_retreat(int(battle_snapshot.tick))
|
|
last_code = String(result.code)
|
|
if result.ok:
|
|
battle_snapshot = result.snapshot
|
|
_consume_battle_events()
|
|
_queue_render()
|
|
|
|
|
|
func settle_and_return() -> void:
|
|
if not battle_active or not bool(battle_snapshot.get("terminal", false)):
|
|
return
|
|
var result: Dictionary
|
|
if boss_battle_active:
|
|
var contract := P100ContractService.new(market.state.snapshot())
|
|
result = contract.settle_boss(_operation("boss", "settle"), contract.state.revision, String(battle_snapshot.snapshot_hash), battle_snapshot)
|
|
else:
|
|
var resolver := P100ResolutionService.new(market.state.snapshot())
|
|
result = resolver.settle_battle(_operation("battle", "settle"), resolver.state.revision, String(battle_snapshot.snapshot_hash), battle_snapshot)
|
|
last_code = String(result.code)
|
|
if not result.ok or not _replace_market_snapshot(result.snapshot):
|
|
_queue_render()
|
|
return
|
|
battle_active = false
|
|
boss_battle_active = false
|
|
battle_result_visible = false
|
|
battle_snapshot = {}
|
|
recent_events.clear()
|
|
pending_line.assign(market.state.current_run.get("deployed_recruit_ids", []))
|
|
_restore_runtime_phase()
|
|
_save_stable()
|
|
_queue_render()
|
|
|
|
|
|
func claim_reward_card(card_id: String, artifact_id: String = "") -> void:
|
|
if market.state.current_run.is_empty() or market.state.current_run.pending_reward.is_empty():
|
|
return
|
|
var resolver := P100ResolutionService.new(market.state.snapshot())
|
|
var draft: Dictionary = resolver.state.current_run.pending_reward
|
|
var selected_artifact := artifact_id
|
|
if not selected_artifact.is_empty() and selected_artifact in resolver.state.current_run.active_artifact_ids:
|
|
selected_artifact = ""
|
|
var replace_id := ""
|
|
if not selected_artifact.is_empty() and resolver.state.current_run.active_artifact_ids.size() >= 3:
|
|
replace_id = String(resolver.state.current_run.active_artifact_ids[0])
|
|
var claimed := resolver.claim_reward(_operation("reward", card_id), resolver.state.revision, String(draft.draft_hash), card_id, selected_artifact, replace_id)
|
|
last_code = String(claimed.code)
|
|
if claimed.ok and _replace_market_snapshot(claimed.snapshot):
|
|
screen = "market"
|
|
_save_stable()
|
|
_queue_render()
|
|
|
|
|
|
func close_contract() -> void:
|
|
if market.state.current_run.is_empty() or String(market.state.current_run.phase) != "contract_result":
|
|
return
|
|
var contract := P100ContractService.new(market.state.snapshot())
|
|
var close_id := String(contract.state.current_run.pending_close.close_id)
|
|
var closed := contract.close_contract(_operation("contract", "close"), contract.state.revision, close_id)
|
|
last_code = String(closed.code)
|
|
if closed.ok and _replace_market_snapshot(closed.snapshot):
|
|
screen = "guild"
|
|
_save_stable()
|
|
_queue_render()
|
|
|
|
|
|
func toggle_settings() -> void:
|
|
settings_open = not settings_open
|
|
reset_confirmation = false
|
|
_queue_render()
|
|
|
|
|
|
func toggle_locale() -> void:
|
|
locale = "en" if locale != "en" else "zh_CN"
|
|
_queue_render()
|
|
|
|
|
|
func toggle_text_scale() -> void:
|
|
text_scale = 1.0 if text_scale > 1.0 else 1.3
|
|
_queue_render()
|
|
|
|
|
|
func toggle_reduced_motion() -> void:
|
|
reduced_motion = not reduced_motion
|
|
_queue_render()
|
|
|
|
|
|
func toggle_mute() -> void:
|
|
muted = not muted
|
|
_queue_render()
|
|
|
|
|
|
func toggle_low_power() -> void:
|
|
low_power = not low_power
|
|
_queue_render()
|
|
|
|
|
|
func reset_progress() -> void:
|
|
if not reset_confirmation:
|
|
reset_confirmation = true
|
|
_queue_render()
|
|
return
|
|
var absolute := ProjectSettings.globalize_path(save_path)
|
|
for path in [absolute, "%s.bak" % absolute, "%s.candidate" % absolute]:
|
|
if FileAccess.file_exists(path):
|
|
DirAccess.remove_absolute(path)
|
|
market = P100MarketService.new()
|
|
save_sequence = 0
|
|
save_commit_hash = ""
|
|
screen = "title"
|
|
settings_open = false
|
|
reset_confirmation = false
|
|
last_code = "progress_reset"
|
|
_queue_render()
|
|
|
|
|
|
func _start_visible_battle() -> void:
|
|
battle_active = true
|
|
battle_result_visible = false
|
|
battle_paused = false
|
|
battle_speed = 1
|
|
battle_tick_accumulator = 0.0
|
|
battle_event_cursor = 0
|
|
recent_events.clear()
|
|
battle_snapshot = boss_battle.snapshot() if boss_battle_active else battle.snapshot()
|
|
_consume_battle_events()
|
|
screen = "battle"
|
|
|
|
|
|
func _buy_and_equip(offer_id: String, recruit_id: String) -> void:
|
|
var inspected: Dictionary = market.inspect_equipment_offer(offer_id)
|
|
if not inspected.ok:
|
|
last_code = String(inspected.code)
|
|
_queue_render()
|
|
return
|
|
var offer: Dictionary = inspected.receipt
|
|
var bought: Dictionary = market.buy_equipment(_operation("equipment", "buy"), market.state.revision, offer_id, int(offer.list_price))
|
|
if not bought.ok:
|
|
last_code = String(bought.code)
|
|
_queue_render()
|
|
return
|
|
var instance_id := String(bought.receipt.instance_id)
|
|
var previous := String(market.state.current_run.equipped_by_recruit.get(recruit_id, ""))
|
|
var equipped: Dictionary = market.equip(_operation("equipment", "equip"), market.state.revision, recruit_id, instance_id, previous)
|
|
last_code = String(equipped.code)
|
|
if equipped.ok:
|
|
focused_equipment_offer = ""
|
|
focused_company_actor = recruit_id
|
|
_save_stable()
|
|
_queue_render()
|
|
|
|
|
|
func _commit_line_drag(source_id: String, target_id: String) -> void:
|
|
if not _market_ready() or source_id.is_empty() or target_id.is_empty() or source_id == target_id:
|
|
return
|
|
var ordered: Array = market.state.current_run.deployed_recruit_ids.duplicate()
|
|
if source_id not in ordered or target_id not in ordered:
|
|
return
|
|
ordered.erase(source_id)
|
|
ordered.insert(ordered.find(target_id), source_id)
|
|
var result: Dictionary = market.commit_deployment(_operation("deploy", "drag"), market.state.revision, ordered)
|
|
last_code = String(result.code)
|
|
if result.ok:
|
|
pending_line.assign(market.state.current_run.deployed_recruit_ids)
|
|
_save_stable()
|
|
_queue_render()
|
|
|
|
|
|
func _recruit_at_point(point: Vector2) -> String:
|
|
var canvas_point := _canvas_point(point)
|
|
for recruit_id in line_touch_rects:
|
|
if Rect2(line_touch_rects[recruit_id]).has_point(canvas_point):
|
|
return String(recruit_id)
|
|
return ""
|
|
|
|
|
|
func _button_at_point(point: Vector2, allowed_ignored_button: Button = null) -> Button:
|
|
if display_root == null or not is_instance_valid(display_root):
|
|
return null
|
|
var canvas_point := _canvas_point(point)
|
|
var best: Button
|
|
var best_z := -2147483648
|
|
for node in display_root.find_children("*", "Button", true, false):
|
|
var button := node as Button
|
|
if button == null or button.disabled:
|
|
continue
|
|
if button.mouse_filter == Control.MOUSE_FILTER_IGNORE and button != allowed_ignored_button:
|
|
continue
|
|
if not button.is_visible_in_tree() or button.is_queued_for_deletion():
|
|
continue
|
|
if settings_open and _effective_z_index(button) < 79:
|
|
continue
|
|
if not button.get_global_rect().has_point(canvas_point):
|
|
continue
|
|
var effective_z := _effective_z_index(button)
|
|
if best == null or effective_z >= best_z:
|
|
best = button
|
|
best_z = effective_z
|
|
return best
|
|
|
|
|
|
func _canvas_point(viewport_point: Vector2) -> Vector2:
|
|
return get_viewport().get_final_transform().affine_inverse() * viewport_point
|
|
|
|
|
|
func _effective_z_index(item: CanvasItem) -> int:
|
|
var result := item.z_index
|
|
var ancestor := item.get_parent()
|
|
while item.z_as_relative and ancestor is CanvasItem:
|
|
var canvas_ancestor := ancestor as CanvasItem
|
|
result += canvas_ancestor.z_index
|
|
item = canvas_ancestor
|
|
ancestor = item.get_parent()
|
|
return result
|
|
|
|
|
|
func _clear_touch_ownership() -> void:
|
|
owned_touch_index = -1
|
|
owned_touch_button = null
|
|
owned_touch_mouse_filter = Control.MOUSE_FILTER_STOP
|
|
owned_touch_start = Vector2.ZERO
|
|
owned_touch_dragged = false
|
|
drag_touch_index = -1
|
|
drag_source_recruit = ""
|
|
drag_active = false
|
|
|
|
|
|
func _restore_touch_button_mouse_filter(instance_id: int, mouse_filter: int) -> void:
|
|
var button := instance_from_id(instance_id) as Button if instance_id > 0 else null
|
|
if button != null and not button.is_queued_for_deletion():
|
|
button.mouse_filter = mouse_filter
|
|
|
|
|
|
func _consume_battle_events() -> void:
|
|
var events: Array = battle_snapshot.get("event_log", [])
|
|
while battle_event_cursor < events.size():
|
|
var event: Dictionary = events[battle_event_cursor]
|
|
var kind := String(event.kind)
|
|
presented_event_counts[kind] = int(presented_event_counts.get(kind, 0)) + 1
|
|
var retained := event.duplicate(true)
|
|
retained["expires"] = world_clock + (0.8 if reduced_motion else 1.2)
|
|
recent_events.append(retained)
|
|
battle_event_cursor += 1
|
|
while recent_events.size() > 6:
|
|
recent_events.pop_front()
|
|
|
|
|
|
func _save_stable() -> bool:
|
|
if not persistence_enabled or market == null:
|
|
return false
|
|
var next_sequence := save_sequence + 1
|
|
var saved: Dictionary = saves.write_slot(ProjectSettings.globalize_path(save_path), market.state.snapshot(), next_sequence, save_commit_hash)
|
|
if saved.ok:
|
|
save_sequence = next_sequence
|
|
save_commit_hash = String(saved.commit_hash)
|
|
return bool(saved.ok)
|
|
|
|
|
|
func _replace_market_snapshot(snapshot: Dictionary) -> bool:
|
|
var replacement := P100MarketService.new()
|
|
if not replacement.restore_snapshot(snapshot):
|
|
last_code = "%s_restore_failed" % last_code
|
|
return false
|
|
market = replacement
|
|
return true
|
|
|
|
|
|
func _operation(kind: String, target: String) -> String:
|
|
operation_index += 1
|
|
return "p100-ui-%s-%d-%d-%s" % [kind, market.state.revision, operation_index, target]
|
|
|
|
|
|
func _market_ready() -> bool:
|
|
return market != null and not battle_active and not market.state.current_run.is_empty() and String(market.state.current_run.phase) == "market" and market.state.current_run.pending_reward.is_empty()
|
|
|
|
|
|
func _render_current() -> void:
|
|
if display_root == null:
|
|
return
|
|
_clear_display()
|
|
line_touch_rects.clear()
|
|
set_meta("visible_world_ratio", 0.84)
|
|
if size.y > size.x:
|
|
_render_rotate_notice()
|
|
return
|
|
match screen:
|
|
"title":
|
|
_render_title()
|
|
"opening":
|
|
_render_opening()
|
|
"battle":
|
|
_render_battle()
|
|
"reward":
|
|
_render_reward()
|
|
"boss_muster":
|
|
_render_boss_muster()
|
|
"contract_result":
|
|
_render_contract_result()
|
|
"guild":
|
|
_render_guild_result()
|
|
_:
|
|
_render_market()
|
|
_add_settings_button()
|
|
if settings_open:
|
|
_render_settings_band()
|
|
|
|
|
|
func _render_title() -> void:
|
|
_add_background(HALL_BACKGROUND)
|
|
var veil := ColorRect.new()
|
|
veil.name = "P100TitleVeil"
|
|
veil.position = Vector2.ZERO
|
|
veil.size = Vector2(size.x * 0.52, size.y)
|
|
veil.color = Color(0.015, 0.035, 0.075, 0.66)
|
|
veil.mouse_filter = Control.MOUSE_FILTER_IGNORE
|
|
display_root.add_child(veil)
|
|
var title := _outlined_label(_tr("以太边境公会", "AETHERBOUND GUILD"), 30, GOLD_LIGHT)
|
|
title.name = "P100Title"
|
|
title.position = Vector2(28, 42)
|
|
title.size = Vector2(size.x * 0.52 - 44, 62)
|
|
display_root.add_child(title)
|
|
var subtitle := _outlined_label(_tr("组建无名佣兵队 · 穿越风晶荒野 · 让每次损失改变下一次选择", "BUILD A COMPANY · CROSS THE WINDGLASS · LET EVERY LOSS CHANGE THE NEXT CHOICE"), 12, WHITE)
|
|
subtitle.name = "P100TitleSubtitle"
|
|
subtitle.position = Vector2(30, 102)
|
|
subtitle.size = Vector2(size.x * 0.49 - 40, 70)
|
|
subtitle.autowrap_mode = TextServer.AUTOWRAP_WORD_SMART
|
|
display_root.add_child(subtitle)
|
|
for index in range(4):
|
|
var rig: String = ["Hearthguard", "Wayrunner", "Farstring", "Kindhand"][index]
|
|
var actor := _add_actor(rig, Vector2(size.x * 0.54 + index * 68.0, size.y * 0.42 + (index % 2) * 8.0), 76, "P100TitleActor_%d" % index, true, "advance")
|
|
actor.self_modulate = [GOLD_LIGHT, CORAL, CYAN, JADE][index]
|
|
var difficulty_title := _outlined_label(_tr("远征誓约", "EXPEDITION OATH"), 11, GOLD_LIGHT)
|
|
difficulty_title.position = Vector2(28, size.y - 146)
|
|
difficulty_title.size = Vector2(150, 26)
|
|
display_root.add_child(difficulty_title)
|
|
for index in range(DIFFICULTIES.size()):
|
|
var difficulty := String(DIFFICULTIES[index])
|
|
var button := _secondary_button("P100Difficulty_%s" % difficulty, _difficulty_label(difficulty), choose_difficulty.bind(difficulty))
|
|
button.position = Vector2(28 + index * 116.0, size.y - 116)
|
|
button.size = Vector2(108, 48)
|
|
if difficulty == selected_difficulty:
|
|
button.add_theme_stylebox_override("normal", _flat_style(Color(0.32, 0.20, 0.05, 0.94), GOLD_LIGHT, 3, 4))
|
|
display_root.add_child(button)
|
|
var start := _action_button("P100NewExpeditionButton", _tr("开始远征", "NEW EXPEDITION"), begin_expedition)
|
|
start.position = Vector2(size.x - 232, size.y - 66)
|
|
start.size = Vector2(212, 52)
|
|
display_root.add_child(start)
|
|
|
|
|
|
func _render_opening() -> void:
|
|
_add_background(HALL_BACKGROUND)
|
|
_add_header(_tr("从四名候选人中选两名", "CHOOSE TWO OF FOUR RECRUITS"), _tr("已选择 %d / 2" % opening_selection.size(), "%d / 2 SELECTED" % opening_selection.size()))
|
|
var offers: Array = market.state.run_creation_draft.get("opening_offers", [])
|
|
var lane_left := 34.0
|
|
var lane_width := size.x - 68.0
|
|
var spacing := lane_width / 4.0
|
|
for index in range(offers.size()):
|
|
var offer: Dictionary = offers[index]
|
|
var offer_id := String(offer.source_offer_id)
|
|
var selected := offer_id in opening_selection
|
|
var actor_size := clampf(size.y * 0.30, 84.0, 118.0)
|
|
var x := lane_left + spacing * index + (spacing - actor_size) * 0.5
|
|
var y := size.y * 0.23
|
|
_add_ground_ring(Vector2(x + actor_size * 0.5, y + actor_size - 4), actor_size * 0.72, GOLD if selected else CYAN, "P100OpeningRing_%s" % offer_id)
|
|
var actor := _add_actor(_p100_recruit_rig(offer), Vector2(x, y), actor_size, "P100OpeningActor_%s" % offer_id, true)
|
|
actor.self_modulate = GOLD_LIGHT if selected else _p100_profession_color(String(offer.profession_id))
|
|
display_root.add_child(_actor_target("P100OpeningTarget_%s" % offer_id, Vector2(x - 6, y - 6), Vector2(actor_size + 12, actor_size + 66), tap_opening_offer.bind(offer_id)))
|
|
var label := _outlined_label("%s\n%s · Lv.%d\n%s" % [_generated_name(offer), _row_name(String(offer.profession_id), "profession"), int(offer.level), _row_name(String(offer.trait_id), "trait")], 9, GOLD_LIGHT if selected else WHITE)
|
|
label.position = Vector2(x - 18, y + actor_size - 2)
|
|
label.size = Vector2(actor_size + 36, 70)
|
|
label.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
|
|
label.autowrap_mode = TextServer.AUTOWRAP_WORD_SMART
|
|
display_root.add_child(label)
|
|
var consequence := _outlined_label(_tr("未选择者不会保留。系统会按职业自动排定前后顺序。", "UNCHOSEN RECRUITS LEAVE. THE SYSTEM SETS THE FIRST LINE ORDER."), 10, WHITE)
|
|
consequence.position = Vector2(24, size.y - 58)
|
|
consequence.size = Vector2(size.x - 280, 48)
|
|
consequence.autowrap_mode = TextServer.AUTOWRAP_WORD_SMART
|
|
display_root.add_child(consequence)
|
|
var commit := _action_button("P100CommitRunButton", _tr("组建队伍", "FORM COMPANY"), commit_opening_company)
|
|
commit.position = Vector2(size.x - 238, size.y - 62)
|
|
commit.size = Vector2(218, 52)
|
|
commit.disabled = opening_selection.size() != 2
|
|
display_root.add_child(commit)
|
|
|
|
|
|
func _render_market() -> void:
|
|
_add_background(WINDGLASS_BACKGROUND)
|
|
if market.state.current_run.is_empty():
|
|
screen = "guild"
|
|
_render_guild_result()
|
|
return
|
|
var run: Dictionary = market.state.current_run
|
|
_add_header(
|
|
_tr("%s · 集市 %d" % [_contract_name(String(run.contract_id)), int(run.market_index)], "%s · MARKET %d" % [_contract_name(String(run.contract_id)), int(run.market_index)]),
|
|
_tr("◆%d 信用%d 战线%d/%d 胜利%d/12" % [run.coin, run.replacement_credit, run.deployed_recruit_ids.size(), run.line_capacity, run.cleared_rounds], "◆%d CREDIT %d LINE %d/%d CLEARS %d/12" % [run.coin, run.replacement_credit, run.deployed_recruit_ids.size(), run.line_capacity, run.cleared_rounds])
|
|
)
|
|
if int(run.cleared_rounds) == 12:
|
|
if bool(run.recovery_required):
|
|
_render_market_recruits()
|
|
_render_market_equipment()
|
|
else:
|
|
_render_boss_gate_in_market()
|
|
_render_company_line()
|
|
_render_market_context()
|
|
return
|
|
_render_market_recruits()
|
|
_render_market_equipment()
|
|
_render_battle_gates()
|
|
_render_company_line()
|
|
_render_market_context()
|
|
|
|
|
|
func _render_market_recruits() -> void:
|
|
var offers: Array = market.state.current_run.market_board.recruit_offers
|
|
var available: Array = market.state.current_run.available_recruit_offer_ids
|
|
for index in range(offers.size()):
|
|
var offer: Dictionary = offers[index]
|
|
var offer_id := String(offer.source_offer_id)
|
|
if offer_id not in available:
|
|
continue
|
|
var actor_size := 58.0
|
|
var x := 18.0 + index * 82.0
|
|
var y := 62.0
|
|
var focused := focused_recruit_offer == offer_id
|
|
var protected := offer_id == String(market.state.current_run.get("protected_recovery_offer_id", ""))
|
|
_add_ground_ring(Vector2(x + 29, y + 54), 46, GOLD if focused else JADE if protected else CYAN, "P100RecruitRing_%s" % offer_id)
|
|
var actor := _add_actor(_p100_recruit_rig(offer), Vector2(x, y), actor_size, "P100RecruitActor_%s" % offer_id, true)
|
|
actor.self_modulate = GOLD_LIGHT if focused else _p100_profession_color(String(offer.profession_id))
|
|
display_root.add_child(_actor_target("P100RecruitTarget_%s" % offer_id, Vector2(x - 4, y - 4), Vector2(66, 102), tap_recruit_offer.bind(offer_id)))
|
|
var offer_label := _short_profession(String(offer.profession_id))
|
|
if protected:
|
|
offer_label = _tr("救援 · %s" % offer_label, "RECOVERY · %s" % offer_label)
|
|
var label := _outlined_label("%s\n◆%d" % [offer_label, int(offer.list_price)], 8, WHITE)
|
|
label.position = Vector2(x - 12, y + 54)
|
|
label.size = Vector2(82, 38)
|
|
label.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
|
|
display_root.add_child(label)
|
|
|
|
|
|
func _render_market_equipment() -> void:
|
|
var offers: Array = market.state.current_run.market_board.equipment_offers
|
|
var available: Array = market.state.current_run.available_equipment_offer_ids
|
|
for index in range(offers.size()):
|
|
var offer: Dictionary = offers[index]
|
|
var offer_id := String(offer.offer_id)
|
|
if offer_id not in available:
|
|
continue
|
|
var x := 272.0 + index * 66.0
|
|
var focused := focused_equipment_offer == offer_id
|
|
var pedestal := TextureRect.new()
|
|
pedestal.name = "P100EquipmentObject_%s" % offer_id
|
|
pedestal.texture = _equipment_texture(String(offer.catalog_id))
|
|
pedestal.expand_mode = TextureRect.EXPAND_IGNORE_SIZE
|
|
pedestal.stretch_mode = TextureRect.STRETCH_KEEP_ASPECT_CENTERED
|
|
pedestal.position = Vector2(x, 70)
|
|
pedestal.size = Vector2(48, 48)
|
|
pedestal.self_modulate = GOLD_LIGHT if focused else _equipment_color(String(offer.catalog_id))
|
|
pedestal.mouse_filter = Control.MOUSE_FILTER_IGNORE
|
|
display_root.add_child(pedestal)
|
|
display_root.add_child(_actor_target("P100EquipmentTarget_%s" % offer_id, Vector2(x - 5, 62), Vector2(58, 96), tap_equipment_offer.bind(offer_id)))
|
|
var label := _outlined_label("%s\n◆%d" % [String(offer.catalog_id), int(offer.list_price)], 8, WHITE)
|
|
label.position = Vector2(x - 10, 116)
|
|
label.size = Vector2(68, 38)
|
|
label.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
|
|
display_root.add_child(label)
|
|
|
|
|
|
func _render_battle_gates() -> void:
|
|
var offers: Array = market.state.current_run.market_board.battle_offers
|
|
var available: Array = market.state.current_run.available_battle_offer_ids
|
|
var x := size.x - 176.0
|
|
for index in range(offers.size()):
|
|
var offer: Dictionary = offers[index]
|
|
var offer_id := String(offer.offer_id)
|
|
if offer_id not in available:
|
|
continue
|
|
var y := 58.0 + index * 68.0
|
|
var focused := focused_battle_offer == offer_id
|
|
var gate := _secondary_button("P100BattleTarget_%s" % offer_id, _tr("风险 %d · %d 波" % [int(offer.risk), int(offer.wave_count)], "RISK %d · %d WAVES" % [int(offer.risk), int(offer.wave_count)]), tap_battle_offer.bind(offer_id))
|
|
gate.position = Vector2(x, y)
|
|
gate.size = Vector2(158, 58)
|
|
gate.add_theme_stylebox_override("normal", _flat_style(_risk_color(int(offer.risk), focused), GOLD_LIGHT if focused else WHITE, 2, 4))
|
|
display_root.add_child(gate)
|
|
|
|
|
|
func _render_company_line() -> void:
|
|
var run: Dictionary = market.state.current_run
|
|
var company: Array = run.company
|
|
var line_right := size.x - 190.0
|
|
var actor_size := clampf((line_right - 30.0) / maxf(6.0, float(company.size())), 44.0, 64.0)
|
|
var spacing := (line_right - 28.0 - actor_size) / maxf(1.0, float(company.size() - 1))
|
|
var y := size.y - 152.0
|
|
for index in range(company.size()):
|
|
var recruit_id := String(company[index])
|
|
var record: Dictionary = run.recruit_records[recruit_id]
|
|
var in_line := recruit_id in pending_line
|
|
var x := 16.0 + index * spacing
|
|
var actor_y := y if in_line else y + 14.0
|
|
_add_ground_ring(Vector2(x + actor_size * 0.5, actor_y + actor_size - 3), actor_size * 0.70, GOLD if in_line else CYAN, "P100LineRing_%s" % recruit_id)
|
|
var actor := _add_actor(_p100_recruit_rig(record), Vector2(x, actor_y), actor_size, "P100CompanyActor_%s" % recruit_id, true)
|
|
actor.self_modulate = GOLD_LIGHT if focused_company_actor == recruit_id else _p100_profession_color(String(record.profession_id))
|
|
var rect := Rect2(Vector2(x - 3, actor_y - 4), Vector2(actor_size + 6, actor_size + 30))
|
|
line_touch_rects[recruit_id] = rect
|
|
display_root.add_child(_actor_target("P100CompanyTarget_%s" % recruit_id, rect.position, rect.size, tap_company_actor.bind(recruit_id)))
|
|
var state_text := _tr("战", "LINE") if in_line else _tr("备", "RES")
|
|
var label := _outlined_label("%s Lv%d\n%d/%d" % [state_text, int(record.level), int(record.current_hp), int(record.max_hp)], 7, WHITE)
|
|
label.position = Vector2(x - 5, actor_y + actor_size - 1)
|
|
label.size = Vector2(actor_size + 10, 32)
|
|
label.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
|
|
display_root.add_child(label)
|
|
|
|
|
|
func _render_market_context() -> void:
|
|
var band := ColorRect.new()
|
|
band.name = "P100MarketContextBand"
|
|
band.position = Vector2(0, size.y - 68)
|
|
band.size = Vector2(size.x, 68)
|
|
band.color = Color(0.015, 0.035, 0.075, 0.94)
|
|
band.mouse_filter = Control.MOUSE_FILTER_IGNORE
|
|
display_root.add_child(band)
|
|
var detail := _outlined_label(_market_context_text(), 9, WHITE)
|
|
detail.name = "P100ContextText"
|
|
detail.position = Vector2(14, size.y - 64)
|
|
detail.size = Vector2(size.x - 400, 58)
|
|
detail.autowrap_mode = TextServer.AUTOWRAP_WORD_SMART
|
|
display_root.add_child(detail)
|
|
var auto_line := _secondary_button("P100AutoLineButton", _tr("自动排阵", "AUTO LINE"), use_automatic_line)
|
|
auto_line.position = Vector2(size.x - 380, size.y - 62)
|
|
auto_line.size = Vector2(110, 52)
|
|
display_root.add_child(auto_line)
|
|
var commit := _action_button("P100CommitLineButton", _tr("确认战线", "COMMIT LINE"), commit_pending_line)
|
|
commit.position = Vector2(size.x - 262, size.y - 62)
|
|
commit.size = Vector2(136, 52)
|
|
commit.disabled = pending_line == run_deployed()
|
|
display_root.add_child(commit)
|
|
var refresh_cost := P100MarketService.refresh_cost(int(market.state.current_run.refresh_count), market.state.current_run.locks.size())
|
|
var refresh := _secondary_button("P100RefreshButton", _tr("刷新 ◆%d" % refresh_cost, "REFRESH ◆%d" % refresh_cost), refresh_market)
|
|
refresh.position = Vector2(size.x - 120, size.y - 62)
|
|
refresh.size = Vector2(112, 52)
|
|
refresh.disabled = int(market.state.current_run.coin) < refresh_cost
|
|
display_root.add_child(refresh)
|
|
|
|
|
|
func _render_boss_gate_in_market() -> void:
|
|
var boss_id := String(contract_rows[String(market.state.current_run.contract_id)].boss_id)
|
|
var boss := _add_actor("Riftblade", Vector2(size.x * 0.64, size.y * 0.28), 132, "P100BossGateActor", true, "telegraph")
|
|
boss.self_modulate = VIOLET
|
|
var title := _outlined_label(_tr("区域首领：%s" % _row_name(boss_id, "boss"), "REGION BOSS: %s" % _row_name(boss_id, "boss")), 21, GOLD_LIGHT)
|
|
title.position = Vector2(size.x * 0.43, 72)
|
|
title.size = Vector2(size.x * 0.52, 54)
|
|
display_root.add_child(title)
|
|
var enter := _action_button("P100EnterBossButton", _tr("进入集结", "ENTER MUSTER"), enter_boss_muster)
|
|
enter.position = Vector2(size.x - 230, size.y * 0.56)
|
|
enter.size = Vector2(206, 54)
|
|
display_root.add_child(enter)
|
|
|
|
|
|
func _render_reward() -> void:
|
|
_add_background(WINDGLASS_BACKGROUND)
|
|
_add_header(_tr("战利品已落地", "REWARD LANDED"), _tr("只选择一项", "CHOOSE ONE"))
|
|
_render_surviving_company(Vector2(22, size.y * 0.42), 58)
|
|
var draft: Dictionary = market.state.current_run.pending_reward
|
|
var cards: Array = draft.cards
|
|
var start_x := size.x * 0.47
|
|
var width := (size.x * 0.50 - 24.0) / maxf(1.0, float(cards.size()))
|
|
for index in range(cards.size()):
|
|
var card: Dictionary = cards[index]
|
|
var card_id := String(card.card_id)
|
|
var x := start_x + index * width
|
|
var object := TextureRect.new()
|
|
object.name = "P100RewardObject_%s" % card_id
|
|
object.texture = _equipment_texture(String(card.get("catalog_id", "EQ-002")))
|
|
object.position = Vector2(x + width * 0.20, size.y * 0.35)
|
|
object.size = Vector2(width * 0.60, 70)
|
|
object.expand_mode = TextureRect.EXPAND_IGNORE_SIZE
|
|
object.stretch_mode = TextureRect.STRETCH_KEEP_ASPECT_CENTERED
|
|
object.self_modulate = _reward_color(String(card.kind))
|
|
object.mouse_filter = Control.MOUSE_FILTER_IGNORE
|
|
display_root.add_child(object)
|
|
if String(card.kind) == "artifact":
|
|
for option_index in range(card.artifact_ids.size()):
|
|
var artifact_id := String(card.artifact_ids[option_index])
|
|
var option := _secondary_button("P100RewardArtifact_%s" % artifact_id, artifact_id, claim_reward_card.bind(card_id, artifact_id))
|
|
option.position = Vector2(x + 2, size.y - 64 - option_index * 50)
|
|
option.size = Vector2(width - 8, 46)
|
|
display_root.add_child(option)
|
|
else:
|
|
var label := _reward_label(card)
|
|
var choose := _action_button("P100RewardTarget_%s" % card_id, label, claim_reward_card.bind(card_id, ""))
|
|
choose.position = Vector2(x + 2, size.y - 66)
|
|
choose.size = Vector2(width - 8, 52)
|
|
display_root.add_child(choose)
|
|
|
|
|
|
func _render_boss_muster() -> void:
|
|
_add_background(WINDGLASS_BACKGROUND)
|
|
var muster: Dictionary = market.state.current_run.boss_muster
|
|
var boss_id := String(muster.boss_id)
|
|
_add_header(_tr("首领集结：%s" % _row_name(boss_id, "boss"), "BOSS MUSTER: %s" % _row_name(boss_id, "boss")), _tr("选择一个战术并再次确认", "INSPECT, THEN CONFIRM A PLAN"))
|
|
_render_surviving_company(Vector2(24, size.y * 0.48), 64)
|
|
var boss := _add_actor("Riftblade", Vector2(size.x * 0.70, size.y * 0.25), 150, "P100MusterBoss", true, "telegraph")
|
|
boss.self_modulate = VIOLET
|
|
for index in range(muster.plans.size()):
|
|
var plan_id := String(muster.plans[index])
|
|
var plan := _secondary_button("P100BossPlan_%s" % plan_id, _boss_plan_label(plan_id), tap_boss_plan.bind(plan_id))
|
|
plan.position = Vector2(size.x - 330 + index * 158, size.y - 78)
|
|
plan.size = Vector2(148, 58)
|
|
if focused_boss_plan == plan_id:
|
|
plan.add_theme_stylebox_override("normal", _flat_style(Color(0.30, 0.18, 0.05, 0.94), GOLD_LIGHT, 3, 4))
|
|
display_root.add_child(plan)
|
|
|
|
|
|
func _render_battle() -> void:
|
|
_add_background(WINDGLASS_BACKGROUND)
|
|
var boss_id := String(battle_snapshot.get("boss_id", ""))
|
|
var heading := _row_name(boss_id, "boss") if boss_battle_active else _tr("第 %d 集市 · 风险 %d" % [int(battle_snapshot.get("market_index", 0)), int(battle_snapshot.get("risk", 0))], "MARKET %d · RISK %d" % [int(battle_snapshot.get("market_index", 0)), int(battle_snapshot.get("risk", 0))])
|
|
_add_header(heading, _tr("第 %d 刻" % int(battle_snapshot.get("tick", 0)), "TICK %d" % int(battle_snapshot.get("tick", 0))))
|
|
var allies: Array = battle_snapshot.get("ally_order", [])
|
|
var actor_rows: Dictionary = battle_snapshot.get("actors", {})
|
|
var ally_spacing := minf(64.0, (size.x * 0.46 - 50.0) / maxf(1.0, float(allies.size())))
|
|
for index in range(allies.size()):
|
|
var recruit_id := String(allies[index])
|
|
if not actor_rows.has(recruit_id):
|
|
continue
|
|
_add_runtime_battle_actor(recruit_id, actor_rows[recruit_id], Vector2(34 + index * ally_spacing, size.y * 0.48), false)
|
|
if boss_battle_active:
|
|
_add_runtime_boss(Vector2(size.x * 0.72, size.y * 0.34))
|
|
else:
|
|
var enemies: Array = battle_snapshot.get("enemy_order", [])
|
|
var enemy_spacing := minf(70.0, (size.x * 0.42 - 30.0) / maxf(1.0, float(enemies.size())))
|
|
for index in range(enemies.size()):
|
|
var enemy_id := String(enemies[index])
|
|
if actor_rows.has(enemy_id):
|
|
_add_runtime_battle_actor(enemy_id, actor_rows[enemy_id], Vector2(size.x - 84 - index * enemy_spacing, size.y * 0.43), true)
|
|
_render_recent_feedback()
|
|
var pause := _secondary_button("P100PauseButton", "▶" if battle_paused else "Ⅱ", toggle_battle_pause)
|
|
pause.position = Vector2(size.x - 166, 1)
|
|
pause.size = Vector2(48, 48)
|
|
display_root.add_child(pause)
|
|
var speed := _secondary_button("P100SpeedButton", "%dx" % battle_speed, toggle_battle_speed)
|
|
speed.position = Vector2(size.x - 112, 1)
|
|
speed.size = Vector2(48, 48)
|
|
display_root.add_child(speed)
|
|
if not boss_battle_active and not battle_result_visible:
|
|
var retreat := _secondary_button("P100RetreatButton", _tr("撤退", "RETREAT"), request_retreat)
|
|
retreat.position = Vector2(12, size.y - 58)
|
|
retreat.size = Vector2(92, 48)
|
|
retreat.disabled = int(battle_snapshot.get("retreat_requested_tick", -1)) >= 0
|
|
display_root.add_child(retreat)
|
|
if battle_result_visible:
|
|
_render_battle_result_band()
|
|
|
|
|
|
func _render_contract_result() -> void:
|
|
_add_background(WINDGLASS_BACKGROUND)
|
|
var pending: Dictionary = market.state.current_run.pending_close
|
|
_render_surviving_company(Vector2(24, size.y * 0.46), 66)
|
|
var title := _outlined_label(_tr("契约完成", "CONTRACT COMPLETE"), 28, GOLD_LIGHT)
|
|
title.position = Vector2(size.x * 0.48, size.y * 0.24)
|
|
title.size = Vector2(size.x * 0.48, 62)
|
|
title.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
|
|
display_root.add_child(title)
|
|
var body := _outlined_label(_tr("首领 %s 已击败\n首次通关声望 +%d\n幸存队伍将写入公会记录" % [_row_name(String(pending.boss_id), "boss"), int(pending.first_clear_renown)], "BOSS %s DEFEATED\nFIRST-CLEAR RENOWN +%d\nSURVIVORS ENTER THE COMPANY RECORD" % [_row_name(String(pending.boss_id), "boss"), int(pending.first_clear_renown)]), 13, WHITE)
|
|
body.position = Vector2(size.x * 0.51, size.y * 0.41)
|
|
body.size = Vector2(size.x * 0.42, 110)
|
|
body.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
|
|
body.autowrap_mode = TextServer.AUTOWRAP_WORD_SMART
|
|
display_root.add_child(body)
|
|
var close := _action_button("P100CloseContractButton", _tr("登记通关", "RECORD CLEAR"), close_contract)
|
|
close.position = Vector2(size.x - 238, size.y - 66)
|
|
close.size = Vector2(218, 52)
|
|
display_root.add_child(close)
|
|
|
|
|
|
func _render_guild_result() -> void:
|
|
_add_background(HALL_BACKGROUND)
|
|
var profile: Dictionary = market.state.guild_profile
|
|
var clears: Array = profile.contract_clear_ids
|
|
_add_header(_tr("风晶公会记录", "WINDGLASS GUILD RECORD"), _tr("声望 %d · 通关 %d/2" % [profile.persistent_renown, clears.size()], "RENOWN %d · CLEARS %d/2" % [profile.persistent_renown, clears.size()]))
|
|
for index in range(profile.company_records.size()):
|
|
var record: Dictionary = profile.company_records[index]
|
|
var seal := ColorRect.new()
|
|
seal.name = "P100CompanyRecord_%d" % index
|
|
seal.position = Vector2(34 + index * 260, 92)
|
|
seal.size = Vector2(224, 6)
|
|
seal.color = GOLD if index == 0 else CYAN
|
|
seal.mouse_filter = Control.MOUSE_FILTER_IGNORE
|
|
display_root.add_child(seal)
|
|
var contract_name := _contract_name(String(record.contract_id))
|
|
var label := _outlined_label(_tr("队伍记录 %d\n幸存 %d · 阵亡 %d\n%s" % [index + 1, record.survivors.size(), record.fallen_total, contract_name], "COMPANY RECORD %d\nSURVIVORS %d · FALLEN %d\n%s" % [index + 1, record.survivors.size(), record.fallen_total, contract_name]), 12, WHITE)
|
|
label.position = Vector2(34 + index * 260, 104)
|
|
label.size = Vector2(224, 100)
|
|
label.autowrap_mode = TextServer.AUTOWRAP_WORD_SMART
|
|
display_root.add_child(label)
|
|
var rg2_visible: bool = "RG-02" in profile.unlocked_region_ids
|
|
var region := _outlined_label(_tr("RG-02 已显现\n下一地区尚未开放" if rg2_visible else "第二份风晶契约已开放", "RG-02 REVEALED\nNEXT REGION NOT YET PLAYABLE" if rg2_visible else "SECOND WINDGLASS CONTRACT OPEN"), 22, GOLD_LIGHT if rg2_visible else CYAN)
|
|
region.name = "P100RegionSeal_RG-02" if rg2_visible else "P100ContractTwoSeal"
|
|
region.position = Vector2(size.x * 0.56, size.y * 0.30)
|
|
region.size = Vector2(size.x * 0.38, 112)
|
|
region.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
|
|
region.autowrap_mode = TextServer.AUTOWRAP_WORD_SMART
|
|
display_root.add_child(region)
|
|
if not rg2_visible:
|
|
var next := _action_button("P100NextContractButton", _tr("开始第二契约", "START CONTRACT TWO"), begin_expedition)
|
|
next.position = Vector2(size.x - 246, size.y - 68)
|
|
next.size = Vector2(226, 54)
|
|
display_root.add_child(next)
|
|
|
|
|
|
func _render_battle_result_band() -> void:
|
|
var band := ColorRect.new()
|
|
band.name = "P100BattleResultBand"
|
|
band.position = Vector2(0, size.y - 72)
|
|
band.size = Vector2(size.x, 72)
|
|
band.color = Color(0.015, 0.035, 0.075, 0.95)
|
|
band.mouse_filter = Control.MOUSE_FILTER_IGNORE
|
|
display_root.add_child(band)
|
|
var victory := String(battle_snapshot.outcome) == "victory"
|
|
var fallen_count: int = battle_snapshot.get("fallen_recruit_ids", []).size()
|
|
var label := _outlined_label(_tr("胜利" if victory else "战斗结束", "VICTORY" if victory else "BATTLE ENDED") + _tr(" · 永久阵亡 %d" % fallen_count, " · PERMANENT FALLEN %d" % fallen_count), 19, GOLD_LIGHT if victory else CORAL)
|
|
label.position = Vector2(18, size.y - 66)
|
|
label.size = Vector2(size.x - 260, 56)
|
|
display_root.add_child(label)
|
|
var settle := _action_button("P100SettleButton", _tr("结算后返回", "SETTLE RESULT"), settle_and_return)
|
|
settle.position = Vector2(size.x - 230, size.y - 62)
|
|
settle.size = Vector2(212, 52)
|
|
display_root.add_child(settle)
|
|
|
|
|
|
func _render_surviving_company(origin: Vector2, actor_size: float) -> void:
|
|
if market.state.current_run.is_empty():
|
|
return
|
|
var company: Array = market.state.current_run.company
|
|
var spacing := minf(actor_size + 4, size.x * 0.43 / maxf(1.0, float(company.size())))
|
|
for index in range(company.size()):
|
|
var recruit_id := String(company[index])
|
|
var record: Dictionary = market.state.current_run.recruit_records[recruit_id]
|
|
var actor := _add_actor(_p100_recruit_rig(record), origin + Vector2(index * spacing, 0), actor_size, "P100Survivor_%s" % recruit_id, true)
|
|
actor.self_modulate = _p100_profession_color(String(record.profession_id))
|
|
|
|
|
|
func _add_runtime_battle_actor(actor_id: String, row: Dictionary, at: Vector2, enemy: bool) -> void:
|
|
var rig := "Riftblade" if enemy else _p100_recruit_rig(row)
|
|
var actor_size := 68.0 if enemy else 64.0
|
|
var state_name := _battle_state_for(actor_id, enemy)
|
|
var actor := _add_actor(rig, at, actor_size, "P100BattleActor_%s" % actor_id, false, state_name)
|
|
actor.self_modulate = _enemy_color(String(row.get("blueprint_id", ""))) if enemy else _p100_profession_color(String(row.get("profession_id", "")))
|
|
actor.set_meta("base_position", at)
|
|
actor.set_meta("rig", rig)
|
|
actor.set_meta("animation_state", state_name)
|
|
battle_actors[actor_id] = actor
|
|
_add_hp_bar(actor_id, actor, int(row.hp), int(row.max_hp), enemy)
|
|
|
|
|
|
func _add_runtime_boss(at: Vector2) -> void:
|
|
var actor := _add_actor("Riftblade", at, 128, "P100BattleBoss", false, "attack" if not battle_result_visible else "death")
|
|
actor.self_modulate = VIOLET
|
|
actor.set_meta("base_position", at)
|
|
actor.set_meta("rig", "Riftblade")
|
|
actor.set_meta("animation_state", "attack")
|
|
battle_actors[String(battle_snapshot.boss_id)] = actor
|
|
_add_hp_bar(String(battle_snapshot.boss_id), actor, int(battle_snapshot.boss_hp), int(battle_snapshot.boss_max_hp), true)
|
|
|
|
|
|
func _add_hp_bar(actor_id: String, actor: TextureRect, hp: int, max_hp: int, enemy: bool) -> void:
|
|
var bar := ColorRect.new()
|
|
bar.name = "P100HP_%s" % actor_id
|
|
bar.position = actor.position + Vector2(4, -7)
|
|
bar.size = Vector2(actor.size.x - 8, 7)
|
|
bar.color = Color(0.01, 0.02, 0.04, 0.94)
|
|
bar.mouse_filter = Control.MOUSE_FILTER_IGNORE
|
|
display_root.add_child(bar)
|
|
var fill := ColorRect.new()
|
|
fill.name = "Fill"
|
|
fill.position = Vector2(1, 1)
|
|
fill.size = Vector2((bar.size.x - 2) * clampf(float(hp) / maxf(1.0, float(max_hp)), 0.0, 1.0), 5)
|
|
fill.color = CORAL if enemy else JADE
|
|
fill.mouse_filter = Control.MOUSE_FILTER_IGNORE
|
|
bar.add_child(fill)
|
|
battle_hp_bars[actor_id] = bar
|
|
var name := _outlined_label(_battle_actor_name(actor_id), 7, WHITE)
|
|
name.position = actor.position + Vector2(-8, actor.size.y - 4)
|
|
name.size = Vector2(actor.size.x + 16, 24)
|
|
name.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
|
|
name.text_overrun_behavior = TextServer.OVERRUN_TRIM_ELLIPSIS
|
|
display_root.add_child(name)
|
|
|
|
|
|
func _render_recent_feedback() -> void:
|
|
for event in recent_events:
|
|
if float(event.get("expires", 0.0)) < world_clock:
|
|
continue
|
|
var kind := String(event.kind)
|
|
var target_id := String(event.get("target_id", ""))
|
|
var actor: TextureRect = battle_actors.get(target_id)
|
|
if actor == null:
|
|
continue
|
|
var detail: Dictionary = event.get("detail", {})
|
|
var value := ""
|
|
var color := WHITE
|
|
if kind == "damage":
|
|
value = "-%d" % int(detail.get("effective", detail.get("amount", 0)))
|
|
color = CORAL
|
|
elif kind == "heal":
|
|
value = "+%d" % int(detail.get("amount", 0))
|
|
color = JADE
|
|
elif kind == "fallen":
|
|
value = _tr("阵亡", "FALLEN")
|
|
color = CORAL
|
|
elif kind in ["guard", "intercept", "push_resisted"]:
|
|
value = _tr("守护", "GUARD")
|
|
color = CYAN
|
|
if value.is_empty():
|
|
continue
|
|
var label := _outlined_label(value, 14, color)
|
|
label.name = "P100Feedback_%s" % String(event.event_id)
|
|
label.position = actor.position + Vector2(-10, -34)
|
|
label.size = Vector2(actor.size.x + 20, 30)
|
|
label.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
|
|
label.z_index = 30
|
|
display_root.add_child(label)
|
|
|
|
|
|
func _animate_runtime_battle_actors() -> void:
|
|
if reduced_motion or battle_actors.is_empty():
|
|
return
|
|
for actor_id in battle_actors:
|
|
var actor: TextureRect = battle_actors[actor_id]
|
|
if not is_instance_valid(actor) or not actor.has_meta("base_position"):
|
|
continue
|
|
var base: Vector2 = actor.get_meta("base_position")
|
|
var phase := float(abs(String(actor_id).hash()) % 17) * 0.17
|
|
actor.position = base + Vector2(sin(world_clock * 2.6 + phase) * 2.0, sin(world_clock * 5.2 + phase) * 1.5)
|
|
actor.texture = animation.texture(String(actor.get_meta("rig", "Hearthguard")), String(actor.get_meta("animation_state", "idle")), world_clock)
|
|
|
|
|
|
func _add_header(title_text: String, status_text: String) -> void:
|
|
var header := ColorRect.new()
|
|
header.name = "P100Header"
|
|
header.position = Vector2.ZERO
|
|
header.size = Vector2(size.x, 50)
|
|
header.color = Color(0.015, 0.035, 0.075, 0.90)
|
|
header.mouse_filter = Control.MOUSE_FILTER_IGNORE
|
|
display_root.add_child(header)
|
|
var title := _outlined_label(title_text, 15, GOLD_LIGHT)
|
|
title.position = Vector2(14, 3)
|
|
title.size = Vector2(size.x * 0.52, 43)
|
|
title.text_overrun_behavior = TextServer.OVERRUN_TRIM_ELLIPSIS
|
|
display_root.add_child(title)
|
|
var status := _outlined_label(status_text, 10, WHITE)
|
|
status.position = Vector2(size.x * 0.48, 3)
|
|
status.size = Vector2(size.x * 0.45 - 8, 43)
|
|
status.horizontal_alignment = HORIZONTAL_ALIGNMENT_RIGHT
|
|
status.text_overrun_behavior = TextServer.OVERRUN_TRIM_ELLIPSIS
|
|
display_root.add_child(status)
|
|
|
|
|
|
func _add_settings_button() -> void:
|
|
var button := _secondary_button("P100SettingsButton", "⚙", toggle_settings)
|
|
button.position = Vector2(size.x - 52, 1)
|
|
button.size = Vector2(48, 48)
|
|
button.tooltip_text = _tr("设置", "SETTINGS")
|
|
display_root.add_child(button)
|
|
|
|
|
|
func _render_settings_band() -> void:
|
|
var scrim := ColorRect.new()
|
|
scrim.name = "P100SettingsScrim"
|
|
scrim.position = Vector2.ZERO
|
|
scrim.size = size
|
|
scrim.color = Color(0.01, 0.025, 0.05, 0.92)
|
|
scrim.z_index = 79
|
|
scrim.mouse_filter = Control.MOUSE_FILTER_STOP
|
|
display_root.add_child(scrim)
|
|
var band := ColorRect.new()
|
|
band.name = "P100SettingsBand"
|
|
band.position = Vector2(size.x * 0.18, 54)
|
|
band.size = Vector2(size.x * 0.64, size.y - 108)
|
|
band.color = Color(0.015, 0.035, 0.075, 1.0)
|
|
band.z_index = 80
|
|
band.mouse_filter = Control.MOUSE_FILTER_STOP
|
|
display_root.add_child(band)
|
|
var title := _outlined_label(_tr("设置", "SETTINGS"), 21, GOLD_LIGHT)
|
|
title.position = band.position + Vector2(18, 10)
|
|
title.size = Vector2(180, 42)
|
|
title.z_index = 81
|
|
display_root.add_child(title)
|
|
var values := [
|
|
[_tr("语言", "LANGUAGE"), "中文" if locale != "en" else "EN", toggle_locale],
|
|
[_tr("文字", "TEXT"), "130%" if text_scale > 1.0 else "100%", toggle_text_scale],
|
|
[_tr("动态", "MOTION"), _tr("减少", "REDUCED") if reduced_motion else _tr("完整", "FULL"), toggle_reduced_motion],
|
|
[_tr("声音", "AUDIO"), _tr("静音", "MUTED") if muted else _tr("开启", "ON"), toggle_mute],
|
|
[_tr("功耗", "POWER"), _tr("低", "LOW") if low_power else _tr("标准", "NORMAL"), toggle_low_power],
|
|
]
|
|
for index in range(values.size()):
|
|
var row: Array = values[index]
|
|
var button := _secondary_button("P100Setting_%d" % index, "%s %s" % [row[0], row[1]], row[2])
|
|
button.position = band.position + Vector2(18 + (index % 3) * ((band.size.x - 48) / 3.0), 60 + int(index / 3) * 60)
|
|
button.size = Vector2((band.size.x - 66) / 3.0, 50)
|
|
button.z_index = 82
|
|
display_root.add_child(button)
|
|
var reset := _secondary_button("P100ResetButton", _tr("再次确认重置" if reset_confirmation else "重置进度", "CONFIRM RESET" if reset_confirmation else "RESET PROGRESS"), reset_progress)
|
|
reset.position = band.position + Vector2(18, band.size.y - 62)
|
|
reset.size = Vector2(174, 48)
|
|
reset.z_index = 82
|
|
display_root.add_child(reset)
|
|
var close := _action_button("P100CloseSettingsButton", _tr("返回", "BACK"), toggle_settings)
|
|
close.position = band.position + Vector2(band.size.x - 152, band.size.y - 62)
|
|
close.size = Vector2(134, 48)
|
|
close.z_index = 82
|
|
display_root.add_child(close)
|
|
|
|
|
|
func _market_context_text() -> String:
|
|
if not focused_recruit_offer.is_empty():
|
|
var offer: Dictionary = market.inspect_recruit_offer(focused_recruit_offer)
|
|
if offer.ok:
|
|
return _tr("再次点选招募：%s · %s · %s · ◆%d" % [_generated_name(offer.receipt), _row_name(String(offer.receipt.profession_id), "profession"), _row_name(String(offer.receipt.trait_id), "trait"), int(offer.receipt.list_price)], "TAP AGAIN TO HIRE: %s · %s · %s · ◆%d" % [_generated_name(offer.receipt), _row_name(String(offer.receipt.profession_id), "profession"), _row_name(String(offer.receipt.trait_id), "trait"), int(offer.receipt.list_price)])
|
|
if not focused_equipment_offer.is_empty():
|
|
var offer: Dictionary = market.inspect_equipment_offer(focused_equipment_offer)
|
|
if offer.ok:
|
|
return _tr("选择一名队员购买并装备 %s · ◆%d" % [_row_name(String(offer.receipt.catalog_id), "equipment"), int(offer.receipt.list_price)], "CHOOSE A RECRUIT TO BUY AND EQUIP %s · ◆%d" % [_row_name(String(offer.receipt.catalog_id), "equipment"), int(offer.receipt.list_price)])
|
|
if not focused_battle_offer.is_empty():
|
|
var offer: Dictionary = market.preview_battle_offer(focused_battle_offer)
|
|
if offer.ok:
|
|
return _tr("再次点选出发：风险 %d · %d 波 · 敌人 %s" % [int(offer.receipt.risk), int(offer.receipt.wave_count), ", ".join(offer.receipt.enemy_ids)], "TAP AGAIN TO DEPART: RISK %d · %d WAVES · %s" % [int(offer.receipt.risk), int(offer.receipt.wave_count), ", ".join(offer.receipt.enemy_ids)])
|
|
if not focused_company_actor.is_empty():
|
|
var record: Dictionary = market.state.current_run.recruit_records[focused_company_actor]
|
|
return "%s · %s · %s · Lv.%d %d/%dHP" % [_generated_name(record), _row_name(String(record.profession_id), "profession"), _row_name(String(record.trait_id), "trait"), int(record.level), int(record.current_hp), int(record.max_hp)]
|
|
if bool(market.state.current_run.get("recovery_required", false)):
|
|
return _tr("阵亡不会复活。先点选救援招募查看，再点一次用信用与金币补员；然后重新确认战线。", "FALLEN RECRUITS DO NOT RETURN. INSPECT THE PROTECTED RECRUIT, TAP AGAIN TO HIRE WITH CREDIT/COIN, THEN RECOMMIT THE LINE.")
|
|
return _tr("点角色查看，再点一次切换战线/预备；拖动战线角色可重排。点商品后再点角色可装备。", "TAP A RECRUIT TO INSPECT, AGAIN TO MOVE LINE/RESERVE. DRAG LINE RECRUITS TO REORDER. SELECT GEAR, THEN A RECRUIT.")
|
|
|
|
|
|
func run_deployed() -> Array:
|
|
return Array(market.state.current_run.deployed_recruit_ids).duplicate()
|
|
|
|
|
|
func _battle_state_for(actor_id: String, enemy: bool) -> String:
|
|
for event_index in range(recent_events.size() - 1, -1, -1):
|
|
var event: Dictionary = recent_events[event_index]
|
|
if String(event.get("source_id", "")) != actor_id:
|
|
continue
|
|
if enemy:
|
|
return "attack"
|
|
var record: Dictionary = battle_snapshot.get("actors", {}).get(actor_id, {})
|
|
var rig: String = _p100_recruit_rig(record)
|
|
if String(event.kind) == "heal":
|
|
return "lantern_heal" if rig == "Kindhand" else "idle"
|
|
return "draw_release" if rig == "Farstring" else "evade_counter" if rig == "Wayrunner" else "basic_attack"
|
|
return "advance"
|
|
|
|
|
|
func _reward_label(card: Dictionary) -> String:
|
|
match String(card.kind):
|
|
"coin":
|
|
return _tr("金币 +%d" % int(card.amount), "COIN +%d" % int(card.amount))
|
|
"credit":
|
|
return _tr("信用 +%d" % int(card.amount), "CREDIT +%d" % int(card.amount))
|
|
"equipment":
|
|
return _row_name(String(card.catalog_id), "equipment")
|
|
return String(card.kind).to_upper()
|
|
|
|
|
|
func _reward_color(kind: String) -> Color:
|
|
return {"coin": GOLD_LIGHT, "credit": CYAN, "equipment": WHITE, "artifact": VIOLET}.get(kind, WHITE)
|
|
|
|
|
|
func _difficulty_label(value: String) -> String:
|
|
return {
|
|
"wayfinder": _tr("引路者", "WAYFINDER"),
|
|
"standard": _tr("远征者", "STANDARD"),
|
|
"stormbound": _tr("逐风者", "STORMBOUND"),
|
|
"iron_oath": _tr("铁誓", "IRON OATH"),
|
|
}.get(value, value)
|
|
|
|
|
|
func _contract_name(contract_id: String) -> String:
|
|
return _row_name(contract_id, "contract")
|
|
|
|
|
|
func _boss_plan_label(plan_id: String) -> String:
|
|
return {
|
|
"turn_panes": _tr("转动镜片", "TURN PANES"),
|
|
"brace_sweep": _tr("稳守横扫", "BRACE SWEEP"),
|
|
"break_spindle": _tr("击断主轴", "BREAK SPINDLE"),
|
|
"hold_line": _tr("守住战线", "HOLD LINE"),
|
|
}.get(plan_id, plan_id.replace("_", " ").to_upper())
|
|
|
|
|
|
func _generated_name(record: Dictionary) -> String:
|
|
var tokens: Array = record.get("display_name_tokens", [])
|
|
if tokens.is_empty():
|
|
return String(record.get("recruit_id", "Recruit")).left(8)
|
|
var names: Array[String] = []
|
|
for token in tokens:
|
|
var raw := String(token)
|
|
names.append(raw.get_slice(".", raw.get_slice_count(".") - 1))
|
|
return (" · " if locale != "en" else " ").join(names)
|
|
|
|
|
|
func _row_name(row_id: String, family: String) -> String:
|
|
if row_id.is_empty():
|
|
return ""
|
|
var localized: String = P100Content.localized_name(content, row_id, locale)
|
|
if not localized.is_empty():
|
|
return localized
|
|
var rows: Dictionary = {
|
|
"profession": profession_rows,
|
|
"trait": trait_rows,
|
|
"equipment": equipment_rows,
|
|
"enemy": enemy_rows,
|
|
"boss": boss_rows,
|
|
"contract": contract_rows,
|
|
}.get(family, {})
|
|
return String(rows.get(row_id, {}).get("name", row_id))
|
|
|
|
|
|
func _short_profession(profession_id: String) -> String:
|
|
return _row_name(profession_id, "profession").left(10)
|
|
|
|
|
|
func _p100_recruit_rig(record: Dictionary) -> String:
|
|
var profession_id := String(record.get("profession_id", "PF-B01"))
|
|
var tags: Array = profession_rows.get(profession_id, {}).get("semantic_tags", [])
|
|
for role in ROLE_RIGS:
|
|
if role in tags:
|
|
return String(ROLE_RIGS[role])
|
|
return "Hearthguard"
|
|
|
|
|
|
func _p100_profession_color(profession_id: String) -> Color:
|
|
var number := int(profession_id.trim_prefix("PF-B").trim_prefix("PF-A"))
|
|
return [GOLD_LIGHT, CORAL, CYAN, JADE, Color("#78bfff"), VIOLET][number % 6]
|
|
|
|
|
|
func _recruit_record(recruit_id: String) -> Dictionary:
|
|
if market != null and not market.state.current_run.is_empty() and market.state.current_run.recruit_records.has(recruit_id):
|
|
return market.state.current_run.recruit_records[recruit_id]
|
|
return {}
|
|
|
|
|
|
func _recruit_rig(recruit_id: String) -> String:
|
|
return _p100_recruit_rig(_recruit_record(recruit_id))
|
|
|
|
|
|
func _recruit_color(recruit_id: String) -> Color:
|
|
return _p100_profession_color(String(_recruit_record(recruit_id).get("profession_id", "PF-B01")))
|
|
|
|
|
|
func _equipment_name(catalog_id: String) -> String:
|
|
return _row_name(catalog_id, "equipment")
|
|
|
|
|
|
func _equipment_color(catalog_id: String) -> Color:
|
|
var number := int(catalog_id.trim_prefix("EQ-"))
|
|
return [WHITE, CYAN, GOLD_LIGHT, VIOLET, JADE, CORAL][number % 6]
|
|
|
|
|
|
func _enemy_color(enemy_id: String) -> Color:
|
|
var number := int(enemy_id.trim_prefix("EN-R1-"))
|
|
return [Color("#d2ecf3"), CYAN, Color("#e7b779"), CORAL, Color("#a9c0db"), JADE, VIOLET][number % 7]
|
|
|
|
|
|
func _battle_actor_name(actor_id: String) -> String:
|
|
if actor_id.begins_with("W"):
|
|
var row: Dictionary = battle_snapshot.get("actors", {}).get(actor_id, {})
|
|
return _row_name(String(row.get("blueprint_id", "")), "enemy")
|
|
if actor_id.begins_with("BO-"):
|
|
return _row_name(actor_id, "boss")
|
|
var record := _recruit_record(actor_id)
|
|
return _short_profession(String(record.get("profession_id", "")))
|
|
|
|
|
|
func _battle_event_word(event_id: String) -> String:
|
|
return {
|
|
"wave_arrived": _tr("敌军抵达", "WAVE ARRIVED"),
|
|
"intercept": _tr("拦截", "INTERCEPT"),
|
|
"push": _tr("推位", "PUSH"),
|
|
"reorder": _tr("换位", "REORDER"),
|
|
"fallen": _tr("阵亡", "FALLEN"),
|
|
"guard": _tr("守护", "GUARD"),
|
|
"hinder": _tr("迟滞", "HINDER"),
|
|
}.get(event_id, event_id.replace("_", " ").to_upper().left(14))
|