1036 lines
45 KiB
GDScript
1036 lines
45 KiB
GDScript
class_name P102RuntimeController
|
|
extends "res://p10_1/runtime_controller.gd"
|
|
|
|
const P101State = preload("res://p10_1/region_run_state.gd")
|
|
const P101Save = preload("res://p10_1/save_v7_service.gd")
|
|
const P102Content = preload("res://p10_2/content_registry.gd")
|
|
const P102BoardService = preload("res://p10_2/market_board_service.gd")
|
|
const P102State = preload("res://p10_2/run_state.gd")
|
|
const P102MarketService = preload("res://p10_2/market_service.gd")
|
|
const P102BattleService = preload("res://p10_2/mid_contract_battle_service.gd")
|
|
const P102ResolutionService = preload("res://p10_2/mid_contract_resolution_service.gd")
|
|
const P102Save = preload("res://p10_2/save_v8_service.gd")
|
|
const P102Motion = preload("res://p10_2/motion_presenter.gd")
|
|
|
|
const P102_SAVE_PATH := "user://aetherbound_guild_p10_2.json"
|
|
const P101_SAVE_PATH := "user://aetherbound_guild_p10_1.json"
|
|
const P102_SCREEN_MARKET := "siltwake_market"
|
|
const P102_SCREEN_PLAN := "siltwake_plan"
|
|
const P102_SCREEN_BATTLE := "siltwake_battle"
|
|
const P102_SCREEN_RECOVERY := "siltwake_recovery"
|
|
const P102_SCREEN_MARKET_5 := "siltwake_market_5"
|
|
|
|
var p102_mode := false
|
|
var p102_catalog: Dictionary = P102Content.snapshot()
|
|
var p102_save = P102Save.new()
|
|
var p102_board = P102BoardService.new()
|
|
var p102_focused_company := ""
|
|
|
|
|
|
func _bootstrap_market() -> void:
|
|
p102_mode = false
|
|
var snapshot := _p102_entry_snapshot()
|
|
if snapshot.is_empty() and persistence_enabled:
|
|
var loaded: Dictionary = p102_save.load_slot(ProjectSettings.globalize_path(P102_SAVE_PATH))
|
|
if loaded.ok:
|
|
snapshot = Dictionary(loaded.snapshot).duplicate(true)
|
|
region_save_sequence = int(loaded.sequence)
|
|
region_save_commit_hash = String(loaded.commit_hash)
|
|
if snapshot.is_empty() and persistence_enabled:
|
|
var legacy: Dictionary = P101Save.new().load_slot(ProjectSettings.globalize_path(P101_SAVE_PATH))
|
|
if legacy.ok:
|
|
snapshot = _migrate_market_two(Dictionary(legacy.snapshot))
|
|
region_save_sequence = int(legacy.get("sequence", 0))
|
|
region_save_commit_hash = ""
|
|
if snapshot.is_empty():
|
|
super._bootstrap_market()
|
|
return
|
|
_activate_p102(snapshot)
|
|
|
|
|
|
func _p102_entry_snapshot() -> Dictionary:
|
|
if String(entry_snapshot.get("state_kind", "")) == P102State.STATE_KIND:
|
|
return entry_snapshot.duplicate(true)
|
|
if String(entry_snapshot.get("state_kind", "")) == P101State.STATE_KIND:
|
|
return _migrate_market_two(entry_snapshot)
|
|
return {}
|
|
|
|
|
|
func _migrate_market_two(snapshot: Dictionary) -> Dictionary:
|
|
var source := P101State.new()
|
|
if not source.restore_snapshot(snapshot):
|
|
return {}
|
|
var run: Dictionary = source.current_run
|
|
if String(run.get("phase", "")) != "market_2" or int(run.get("market_index", -1)) != 2:
|
|
return {}
|
|
var generated: Dictionary = p102_board.generate(String(run.run_seed), 2, 0)
|
|
if not generated.ok:
|
|
return {}
|
|
var migrated := P102State.new()
|
|
return migrated.snapshot() if migrated.initialize_from_p101(source.snapshot(), generated.board) else {}
|
|
|
|
|
|
func _activate_p102(snapshot: Dictionary) -> bool:
|
|
var service = P102MarketService.new(snapshot)
|
|
if not service.valid:
|
|
return false
|
|
region_market = service
|
|
region_mode = true
|
|
p102_mode = true
|
|
region_catalog = p102_catalog
|
|
region_motion = P102Motion.new()
|
|
_prepare_base_content()
|
|
_restore_p102_screen()
|
|
_reset_region_focus()
|
|
p102_focused_company = ""
|
|
last_code = "p102_resumed"
|
|
_queue_render()
|
|
return true
|
|
|
|
|
|
func _restore_region_screen() -> void:
|
|
if not p102_mode:
|
|
super._restore_region_screen()
|
|
return
|
|
_restore_p102_screen()
|
|
|
|
|
|
func _restore_p102_screen() -> void:
|
|
if region_market == null or region_market.state.current_run.is_empty():
|
|
screen = P102_SCREEN_MARKET
|
|
return
|
|
match String(region_market.state.current_run.phase):
|
|
"prepared":
|
|
screen = P102_SCREEN_PLAN
|
|
"recovery":
|
|
screen = P102_SCREEN_RECOVERY
|
|
"market_5":
|
|
screen = P102_SCREEN_MARKET_5
|
|
_:
|
|
screen = P102_SCREEN_MARKET
|
|
|
|
|
|
func _process(delta: float) -> void:
|
|
if not p102_mode:
|
|
super._process(delta)
|
|
return
|
|
if screen == P102_SCREEN_BATTLE and not region_battle_paused:
|
|
region_motion_clock += maxf(0.0, delta)
|
|
if not low_power:
|
|
world_clock += maxf(0.0, delta)
|
|
_update_ambient_actors()
|
|
_animate_region_battle_actors()
|
|
if (
|
|
screen != P102_SCREEN_BATTLE
|
|
or region_battle_complete
|
|
or region_battle_paused
|
|
or not battle_auto_advance
|
|
):
|
|
return
|
|
if region_motion.playback_held(region_motion_clock, reduced_motion):
|
|
return
|
|
region_battle_accumulator += maxf(0.0, delta) * float(region_battle_speed)
|
|
var ticks := int(floor(region_battle_accumulator / REGION_TICK_SECONDS))
|
|
if ticks > 0:
|
|
region_battle_accumulator -= float(ticks) * REGION_TICK_SECONDS
|
|
advance_region_battle_ticks(ticks)
|
|
|
|
|
|
func _render_current() -> void:
|
|
if not p102_mode:
|
|
super._render_current()
|
|
return
|
|
if display_root == null:
|
|
return
|
|
_clear_display()
|
|
line_touch_rects.clear()
|
|
set_meta("visible_world_ratio", 0.88)
|
|
if size.y > size.x:
|
|
_render_rotate_notice()
|
|
else:
|
|
match screen:
|
|
P102_SCREEN_PLAN:
|
|
_render_p102_plan()
|
|
P102_SCREEN_BATTLE:
|
|
_render_region_battle()
|
|
P102_SCREEN_RECOVERY:
|
|
_render_p102_recovery()
|
|
P102_SCREEN_MARKET_5:
|
|
_render_p102_market_five()
|
|
_:
|
|
_render_p102_market()
|
|
_add_settings_button()
|
|
if settings_open:
|
|
_render_settings_band()
|
|
|
|
|
|
func tap_region_recruit(offer_id: String) -> void:
|
|
if not p102_mode:
|
|
super.tap_region_recruit(offer_id)
|
|
return
|
|
if not _p102_market_ready():
|
|
return
|
|
if region_focused_recruit != offer_id:
|
|
region_focused_recruit = offer_id
|
|
region_focused_equipment = ""
|
|
region_focused_route = ""
|
|
last_code = "recruit_inspected"
|
|
_queue_render()
|
|
return
|
|
var offer := _region_offer("recruit", offer_id)
|
|
if offer.is_empty():
|
|
return
|
|
var result: Dictionary = region_market.hire(
|
|
_region_operation("hire", offer_id),
|
|
region_market.state.revision,
|
|
offer_id,
|
|
int(offer.list_price)
|
|
)
|
|
_accept_region_result(result)
|
|
if result.ok:
|
|
region_focused_recruit = ""
|
|
pending_line.assign(region_market.state.current_run.deployed_recruit_ids)
|
|
|
|
|
|
func tap_region_equipment(offer_id: String) -> void:
|
|
if not p102_mode:
|
|
super.tap_region_equipment(offer_id)
|
|
return
|
|
if not _p102_market_ready():
|
|
return
|
|
if region_focused_equipment != offer_id:
|
|
region_focused_equipment = offer_id
|
|
region_focused_recruit = ""
|
|
region_focused_route = ""
|
|
last_code = "equipment_inspected"
|
|
_queue_render()
|
|
return
|
|
var offer := _region_offer("equipment", offer_id)
|
|
if offer.is_empty():
|
|
return
|
|
var result: Dictionary = region_market.buy_equipment(
|
|
_region_operation("buy", offer_id),
|
|
region_market.state.revision,
|
|
offer_id,
|
|
int(offer.list_price)
|
|
)
|
|
_accept_region_result(result)
|
|
if result.ok:
|
|
region_selected_instance = String(result.receipt.instance_id)
|
|
region_focused_equipment = ""
|
|
|
|
|
|
func tap_region_company(recruit_id: String) -> void:
|
|
if not p102_mode:
|
|
super.tap_region_company(recruit_id)
|
|
return
|
|
if not _p102_market_ready() or recruit_id not in region_market.state.current_run.company:
|
|
return
|
|
if not region_selected_instance.is_empty():
|
|
var equipped: Dictionary = region_market.equip(
|
|
_region_operation("equip", recruit_id),
|
|
region_market.state.revision,
|
|
recruit_id,
|
|
region_selected_instance
|
|
)
|
|
_accept_region_result(equipped)
|
|
if equipped.ok:
|
|
region_selected_instance = ""
|
|
p102_focused_company = recruit_id
|
|
return
|
|
var run: Dictionary = region_market.state.current_run
|
|
if p102_focused_company == recruit_id:
|
|
var deployment: Array = Array(run.deployed_recruit_ids).duplicate()
|
|
if recruit_id in deployment and deployment.size() > 1:
|
|
deployment.erase(recruit_id)
|
|
_commit_p102_deployment(deployment, "to-reserve")
|
|
return
|
|
if recruit_id in run.reserve_recruit_ids and deployment.size() < int(run.line_capacity):
|
|
deployment.append(recruit_id)
|
|
_commit_p102_deployment(deployment, "to-line")
|
|
return
|
|
if not p102_focused_company.is_empty() and p102_focused_company != recruit_id:
|
|
var one_deployed: bool = p102_focused_company in run.deployed_recruit_ids
|
|
var other_deployed: bool = recruit_id in run.deployed_recruit_ids
|
|
if one_deployed != other_deployed:
|
|
_swap_deployed_and_reserve(p102_focused_company, recruit_id)
|
|
return
|
|
p102_focused_company = recruit_id
|
|
region_focused_company = recruit_id
|
|
last_code = "company_inspected"
|
|
_queue_render()
|
|
|
|
|
|
func tap_region_route(offer_id: String) -> void:
|
|
if not p102_mode:
|
|
super.tap_region_route(offer_id)
|
|
return
|
|
if not _p102_market_ready():
|
|
return
|
|
region_focused_route = offer_id
|
|
region_focused_recruit = ""
|
|
region_focused_equipment = ""
|
|
last_code = "route_inspected"
|
|
_queue_render()
|
|
|
|
|
|
func commit_region_route() -> void:
|
|
if not p102_mode:
|
|
super.commit_region_route()
|
|
return
|
|
if not _p102_market_ready() or region_focused_route.is_empty():
|
|
return
|
|
var result: Dictionary = region_market.commit_route(
|
|
_region_operation("route", region_focused_route),
|
|
region_market.state.revision,
|
|
region_focused_route,
|
|
String(region_market.state.current_run.market_board.board_hash)
|
|
)
|
|
_accept_region_result(result)
|
|
if result.ok:
|
|
screen = P102_SCREEN_PLAN
|
|
_save_region()
|
|
_queue_render()
|
|
|
|
|
|
func choose_region_plan(plan_id: String) -> void:
|
|
if not p102_mode:
|
|
super.choose_region_plan(plan_id)
|
|
return
|
|
if region_market == null or String(region_market.state.current_run.get("phase", "")) != "prepared":
|
|
return
|
|
var result: Dictionary = P102BattleService.new(region_market.state.snapshot()).run_to_terminal(plan_id)
|
|
last_code = String(result.code)
|
|
if not result.ok:
|
|
_queue_render()
|
|
return
|
|
region_plan_id = plan_id
|
|
region_battle_snapshot = Dictionary(result.snapshot).duplicate(true)
|
|
region_battle_tick = 0
|
|
region_battle_terminal_tick = int(region_battle_snapshot.tick)
|
|
region_battle_accumulator = 0.0
|
|
region_battle_complete = false
|
|
region_battle_paused = false
|
|
region_battle_speed = 1
|
|
region_event_cursor = 0
|
|
region_recent_events.clear()
|
|
region_event_counts.clear()
|
|
region_actor_order = Array(region_market.state.current_run.deployed_recruit_ids).duplicate()
|
|
region_display_hp.clear()
|
|
for recruit_id in region_actor_order:
|
|
region_display_hp[recruit_id] = int(region_market.state.current_run.recruit_records[recruit_id].current_hp)
|
|
region_safe_index = int(region_market.state.current_run.pending_encounter.tide_disclosure.current_safe_index)
|
|
region_motion_clock = 0.0
|
|
region_motion.reset(region_actor_order, region_safe_index)
|
|
screen = P102_SCREEN_BATTLE
|
|
_queue_render()
|
|
|
|
|
|
func advance_region_battle_ticks(ticks: int) -> Dictionary:
|
|
if not p102_mode:
|
|
return super.advance_region_battle_ticks(ticks)
|
|
if screen != P102_SCREEN_BATTLE or region_battle_complete or ticks <= 0:
|
|
return {"ok": false, "code": "battle_inactive", "events": []}
|
|
region_battle_tick = mini(region_battle_terminal_tick, region_battle_tick + ticks)
|
|
var emitted: Array[Dictionary] = []
|
|
var events: Array = region_battle_snapshot.get("event_log", [])
|
|
while region_event_cursor < events.size() and int(events[region_event_cursor].tick) <= region_battle_tick:
|
|
var event: Dictionary = Dictionary(events[region_event_cursor]).duplicate(true)
|
|
region_event_cursor += 1
|
|
emitted.append(event)
|
|
_consume_region_event(event)
|
|
if region_battle_tick >= region_battle_terminal_tick:
|
|
region_battle_complete = true
|
|
last_code = "mid_contract_playback_terminal"
|
|
else:
|
|
last_code = "mid_contract_playing"
|
|
_queue_render()
|
|
return {"ok": true, "code": last_code, "events": emitted, "tick": region_battle_tick}
|
|
|
|
|
|
func toggle_region_battle_pause() -> void:
|
|
if not p102_mode:
|
|
super.toggle_region_battle_pause()
|
|
return
|
|
if screen == P102_SCREEN_BATTLE and not region_battle_complete:
|
|
region_battle_paused = not region_battle_paused
|
|
_queue_render()
|
|
|
|
|
|
func toggle_region_battle_speed() -> void:
|
|
if not p102_mode:
|
|
super.toggle_region_battle_speed()
|
|
return
|
|
if screen == P102_SCREEN_BATTLE and not region_battle_complete:
|
|
region_battle_speed = 2 if region_battle_speed == 1 else 1
|
|
_queue_render()
|
|
|
|
|
|
func settle_region_battle() -> void:
|
|
if not p102_mode:
|
|
super.settle_region_battle()
|
|
return
|
|
if not region_battle_complete or region_battle_snapshot.is_empty():
|
|
return
|
|
var resolver = P102ResolutionService.new(region_market.state.snapshot())
|
|
var result: Dictionary = resolver.settle(
|
|
_region_operation("settle", String(region_battle_snapshot.snapshot_hash).left(8)),
|
|
resolver.state.revision,
|
|
region_battle_snapshot
|
|
)
|
|
last_code = String(result.code)
|
|
if not result.ok:
|
|
_queue_render()
|
|
return
|
|
region_market = P102MarketService.new(result.snapshot)
|
|
_reset_region_focus()
|
|
p102_focused_company = ""
|
|
_save_region()
|
|
_restore_p102_screen()
|
|
_queue_render()
|
|
|
|
|
|
func recover_region_company() -> void:
|
|
if not p102_mode:
|
|
super.recover_region_company()
|
|
return
|
|
if region_market == null or String(region_market.state.current_run.get("phase", "")) != "recovery":
|
|
return
|
|
var run: Dictionary = region_market.state.current_run
|
|
var report: Dictionary = run.last_battle_report
|
|
var resolver = P102ResolutionService.new(region_market.state.snapshot())
|
|
var result: Dictionary = resolver.recover(
|
|
_region_operation("recover", String(report.get("battle_hash", "")).left(8)),
|
|
resolver.state.revision,
|
|
String(report.get("battle_hash", "")),
|
|
int(run.recovery_cost)
|
|
)
|
|
last_code = String(result.code)
|
|
if result.ok:
|
|
region_market = P102MarketService.new(result.snapshot)
|
|
pending_line.assign(region_market.state.current_run.deployed_recruit_ids)
|
|
_reset_region_focus()
|
|
p102_focused_company = ""
|
|
_save_region()
|
|
screen = P102_SCREEN_MARKET
|
|
_queue_render()
|
|
|
|
|
|
func _commit_line_drag(source_id: String, target_id: String) -> void:
|
|
if not p102_mode:
|
|
super._commit_line_drag(source_id, target_id)
|
|
return
|
|
if not _p102_market_ready() or source_id.is_empty() or target_id.is_empty() or source_id == target_id:
|
|
return
|
|
var run: Dictionary = region_market.state.current_run
|
|
var source_deployed: bool = source_id in run.deployed_recruit_ids
|
|
var target_deployed: bool = target_id in run.deployed_recruit_ids
|
|
if source_deployed != target_deployed:
|
|
_swap_deployed_and_reserve(source_id, target_id)
|
|
return
|
|
if not source_deployed:
|
|
return
|
|
var order: Array = Array(run.deployed_recruit_ids).duplicate()
|
|
order.erase(source_id)
|
|
order.insert(order.find(target_id), source_id)
|
|
_commit_p102_deployment(order, "drag")
|
|
|
|
|
|
func _swap_deployed_and_reserve(first_id: String, second_id: String) -> void:
|
|
var run: Dictionary = region_market.state.current_run
|
|
var deployed_id := first_id if first_id in run.deployed_recruit_ids else second_id
|
|
var reserve_id := second_id if deployed_id == first_id else first_id
|
|
if reserve_id not in run.reserve_recruit_ids:
|
|
return
|
|
var order: Array = Array(run.deployed_recruit_ids).duplicate()
|
|
var index := order.find(deployed_id)
|
|
if index < 0:
|
|
return
|
|
order[index] = reserve_id
|
|
_commit_p102_deployment(order, "reserve-swap")
|
|
|
|
|
|
func _commit_p102_deployment(order: Array, suffix: String) -> void:
|
|
var result: Dictionary = region_market.commit_deployment(
|
|
_region_operation("deploy", suffix),
|
|
region_market.state.revision,
|
|
order
|
|
)
|
|
_accept_region_result(result)
|
|
if result.ok:
|
|
pending_line.assign(region_market.state.current_run.deployed_recruit_ids)
|
|
p102_focused_company = ""
|
|
|
|
|
|
func _consume_region_event(event: Dictionary) -> void:
|
|
if not p102_mode:
|
|
super._consume_region_event(event)
|
|
return
|
|
var kind := String(event.get("kind", ""))
|
|
var payload: Dictionary = Dictionary(event.get("payload", {}))
|
|
region_motion.consume(event, region_motion_clock)
|
|
region_actor_order = Array(region_motion.actor_order).duplicate()
|
|
region_event_counts[kind] = int(region_event_counts.get(kind, 0)) + 1
|
|
region_recent_events.append(event.duplicate(true))
|
|
if region_recent_events.size() > 4:
|
|
region_recent_events.pop_front()
|
|
if kind == "tide_shifted":
|
|
region_safe_index = int(payload.get("safe_index", region_safe_index))
|
|
elif kind == "authoritative_damage":
|
|
region_display_hp[String(event.get("target_id", ""))] = int(payload.get("hp_after", 0))
|
|
elif kind == "fallen":
|
|
region_display_hp[String(event.get("target_id", ""))] = 0
|
|
|
|
|
|
func _save_region() -> bool:
|
|
if not p102_mode:
|
|
return super._save_region()
|
|
if not persistence_enabled or region_market == null:
|
|
return true
|
|
var result: Dictionary = p102_save.write_slot(
|
|
ProjectSettings.globalize_path(P102_SAVE_PATH),
|
|
region_market.state.snapshot(),
|
|
region_save_sequence + 1,
|
|
region_save_commit_hash
|
|
)
|
|
if not result.ok:
|
|
last_code = "p102_%s" % String(result.code)
|
|
return false
|
|
region_save_sequence = int(result.sequence)
|
|
region_save_commit_hash = String(result.commit_hash)
|
|
return true
|
|
|
|
|
|
func _region_operation(kind: String, target: String) -> String:
|
|
if not p102_mode:
|
|
return super._region_operation(kind, target)
|
|
operation_index += 1
|
|
return "p102-ui-%s-%d-%d-%s" % [kind, region_market.state.revision, operation_index, target]
|
|
|
|
|
|
func _region_offer(kind: String, offer_id: String) -> Dictionary:
|
|
if not p102_mode:
|
|
return super._region_offer(kind, offer_id)
|
|
if region_market == null or region_market.state.current_run.is_empty():
|
|
return {}
|
|
var field := String({"recruit": "recruit_offers", "equipment": "equipment_offers", "route": "battle_offers"}.get(kind, ""))
|
|
var id_field := "source_offer_id" if kind == "recruit" else "offer_id"
|
|
for offer in region_market.state.current_run.market_board.get(field, []):
|
|
if String(offer.get(id_field, "")) == offer_id:
|
|
return Dictionary(offer).duplicate(true)
|
|
return {}
|
|
|
|
|
|
func _p102_market_ready() -> bool:
|
|
return (
|
|
p102_mode
|
|
and region_market != null
|
|
and not region_market.state.current_run.is_empty()
|
|
and String(region_market.state.current_run.phase) == "market"
|
|
)
|
|
|
|
|
|
func _render_p102_market() -> void:
|
|
_add_siltwake_world()
|
|
var run: Dictionary = region_market.state.current_run
|
|
var tide: Dictionary = run.market_board.tide_disclosure
|
|
_add_header(
|
|
_tr("淤潮地 · 集市 %d" % run.market_index, "SILTWAKE · MARKET %d" % run.market_index),
|
|
_tr("◆%d 战线 %d/%d 预备 %d 安全位 %d→%d" % [run.coin, run.deployed_recruit_ids.size(), run.line_capacity, run.reserve_recruit_ids.size(), tide.current_safe_index, tide.next_safe_index], "◆%d LINE %d/%d RESERVE %d SAFE %d→%d" % [run.coin, run.deployed_recruit_ids.size(), run.line_capacity, run.reserve_recruit_ids.size(), tide.current_safe_index, tide.next_safe_index])
|
|
)
|
|
_render_tide_notches(tide, 0)
|
|
_render_p102_recruit_pier()
|
|
_render_p102_equipment_bank()
|
|
_render_p102_route_posts()
|
|
_render_p102_company()
|
|
_render_p102_context()
|
|
|
|
|
|
func _render_p102_recruit_pier() -> void:
|
|
var run: Dictionary = region_market.state.current_run
|
|
var offers: Array = run.market_board.recruit_offers
|
|
var actor_size := clampf(size.y * 0.18, 58.0, 72.0)
|
|
var caption := _outlined_label(_tr("渡口候选", "FERRY RECRUITS"), 9, GOLD_LIGHT)
|
|
caption.position = Vector2(18, 56)
|
|
caption.size = Vector2(size.x * 0.34, 26)
|
|
display_root.add_child(caption)
|
|
for index in range(offers.size()):
|
|
var offer: Dictionary = offers[index]
|
|
var offer_id := String(offer.source_offer_id)
|
|
var available: bool = offer_id in run.available_recruit_offer_ids
|
|
var x := 18.0 + index * (actor_size + 8.0)
|
|
var y := 82.0
|
|
_add_ground_ring(Vector2(x + actor_size * 0.5, y + actor_size - 3), actor_size * 0.72, GOLD if region_focused_recruit == offer_id else CYAN, "P102RecruitRing_%s" % offer_id)
|
|
var actor := _add_actor(_p100_recruit_rig(offer), Vector2(x, y), actor_size, "P102RecruitActor_%s" % offer_id, true)
|
|
actor.self_modulate = _p100_profession_color(String(offer.profession_id))
|
|
actor.modulate.a = 1.0 if available else 0.24
|
|
if available:
|
|
display_root.add_child(_actor_target("P102RecruitTarget_%s" % offer_id, Vector2(x - 3, y - 4), Vector2(actor_size + 6, actor_size + 38), tap_region_recruit.bind(offer_id)))
|
|
var label := _outlined_label("%s\nLv.%d ◆%d" % [_generated_name(offer).left(10), int(offer.level), int(offer.list_price)], 7, GOLD_LIGHT if region_focused_recruit == offer_id else WHITE)
|
|
label.position = Vector2(x - 7, y + actor_size - 2)
|
|
label.size = Vector2(actor_size + 14, 38)
|
|
label.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
|
|
display_root.add_child(label)
|
|
|
|
|
|
func _render_p102_equipment_bank() -> void:
|
|
var run: Dictionary = region_market.state.current_run
|
|
var offers: Array = run.market_board.equipment_offers
|
|
var x0 := size.x * 0.35
|
|
var width := size.x * 0.36
|
|
var spacing := width / 4.0
|
|
var caption := _outlined_label(_tr("防潮装备", "TIDE GEAR"), 9, GOLD_LIGHT)
|
|
caption.position = Vector2(x0, 56)
|
|
caption.size = Vector2(width, 26)
|
|
display_root.add_child(caption)
|
|
for index in range(offers.size()):
|
|
var offer: Dictionary = offers[index]
|
|
var offer_id := String(offer.offer_id)
|
|
var available: bool = offer_id in run.available_equipment_offer_ids
|
|
var x := x0 + index * spacing
|
|
var color := _equipment_color(String(offer.catalog_id))
|
|
var icon := _outlined_label(_equipment_symbol(String(offer.catalog_id)), 22, color)
|
|
icon.position = Vector2(x, 82)
|
|
icon.size = Vector2(spacing - 4, 48)
|
|
icon.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
|
|
display_root.add_child(icon)
|
|
if available:
|
|
display_root.add_child(_actor_target("P102EquipmentTarget_%s" % offer_id, Vector2(x, 80), Vector2(spacing - 4, 86), tap_region_equipment.bind(offer_id)))
|
|
var label := _outlined_label("%s\n◆%d" % [_region_name(String(offer.catalog_id)).left(8), int(offer.list_price)], 7, GOLD_LIGHT if region_focused_equipment == offer_id else WHITE)
|
|
label.position = Vector2(x - 4, 126)
|
|
label.size = Vector2(spacing + 4, 40)
|
|
label.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
|
|
label.modulate.a = 1.0 if available else 0.3
|
|
display_root.add_child(label)
|
|
|
|
|
|
func _render_p102_route_posts() -> void:
|
|
var offers: Array = region_market.state.current_run.market_board.battle_offers
|
|
var x := size.x - 202.0
|
|
var caption := _outlined_label(_tr("三条水路", "THREE ROUTES"), 9, GOLD_LIGHT)
|
|
caption.position = Vector2(x, 56)
|
|
caption.size = Vector2(184, 26)
|
|
display_root.add_child(caption)
|
|
for index in range(offers.size()):
|
|
var offer: Dictionary = offers[index]
|
|
var offer_id := String(offer.offer_id)
|
|
var y := 82.0 + index * 54.0
|
|
var selected := region_focused_route == offer_id
|
|
var line := ColorRect.new()
|
|
line.name = "P102RouteLine_%s" % offer_id
|
|
line.position = Vector2(x, y + 38)
|
|
line.size = Vector2(174, 4)
|
|
line.color = GOLD if selected else [JADE, CYAN, CORAL][int(offer.risk)]
|
|
line.mouse_filter = Control.MOUSE_FILTER_IGNORE
|
|
display_root.add_child(line)
|
|
var label := _outlined_label(_tr("风险%d %s" % [offer.risk, _region_name(String(offer.route_id))], "RISK %d %s" % [offer.risk, _region_name(String(offer.route_id))]), 8, GOLD_LIGHT if selected else WHITE)
|
|
label.position = Vector2(x, y)
|
|
label.size = Vector2(174, 38)
|
|
label.text_overrun_behavior = TextServer.OVERRUN_TRIM_ELLIPSIS
|
|
display_root.add_child(label)
|
|
display_root.add_child(_actor_target("P102RouteTarget_%s" % offer_id, Vector2(x - 4, y), Vector2(182, 48), tap_region_route.bind(offer_id)))
|
|
|
|
|
|
func _render_p102_company() -> void:
|
|
var run: Dictionary = region_market.state.current_run
|
|
var actor_size := clampf(size.y * 0.15, 52.0, 64.0)
|
|
var y := size.y - 150.0
|
|
var x0 := size.x * 0.20
|
|
var available_width := size.x * 0.52
|
|
var spacing := minf(actor_size + 8.0, available_width / maxf(1.0, float(run.line_capacity)))
|
|
var caption := _outlined_label(_tr("战线 %d/%d · 预备 %d" % [run.deployed_recruit_ids.size(), run.line_capacity, run.reserve_recruit_ids.size()], "LINE %d/%d · RESERVE %d" % [run.deployed_recruit_ids.size(), run.line_capacity, run.reserve_recruit_ids.size()]), 9, GOLD_LIGHT)
|
|
caption.position = Vector2(x0, y - 24)
|
|
caption.size = Vector2(available_width, 22)
|
|
display_root.add_child(caption)
|
|
for slot in range(int(run.line_capacity)):
|
|
var x := x0 + slot * spacing
|
|
_add_ground_ring(Vector2(x + actor_size * 0.5, y + actor_size - 3), actor_size * 0.68, Color(0.36, 0.82, 0.64, 0.36), "P102CapacitySlot_%d" % slot)
|
|
if slot >= run.deployed_recruit_ids.size():
|
|
continue
|
|
var recruit_id := String(run.deployed_recruit_ids[slot])
|
|
_render_p102_company_actor(recruit_id, Vector2(x, y), actor_size, false)
|
|
var reserve_x := size.x * 0.73
|
|
for index in range(run.reserve_recruit_ids.size()):
|
|
var recruit_id := String(run.reserve_recruit_ids[index])
|
|
_render_p102_company_actor(recruit_id, Vector2(reserve_x + index * (actor_size * 0.72), y + 10), actor_size * 0.76, true)
|
|
|
|
|
|
func _render_p102_company_actor(recruit_id: String, position_value: Vector2, actor_size: float, reserve: bool) -> void:
|
|
var run: Dictionary = region_market.state.current_run
|
|
var record: Dictionary = run.recruit_records[recruit_id]
|
|
var prefix := "P102Reserve" if reserve else "P102Company"
|
|
var ring_color := GOLD if p102_focused_company == recruit_id else VIOLET if reserve else JADE
|
|
_add_ground_ring(position_value + Vector2(actor_size * 0.5, actor_size - 3), actor_size * 0.70, ring_color, "%sRing_%s" % [prefix, recruit_id])
|
|
var actor := _add_actor(_p100_recruit_rig(record), position_value, actor_size, "%sActor_%s" % [prefix, recruit_id], true)
|
|
actor.self_modulate = _p100_profession_color(String(record.profession_id))
|
|
var rect := Rect2(position_value - Vector2(3, 4), Vector2(actor_size + 6, actor_size + 34))
|
|
line_touch_rects[recruit_id] = rect
|
|
display_root.add_child(_actor_target("%sTarget_%s" % [prefix, recruit_id], rect.position, rect.size, tap_region_company.bind(recruit_id)))
|
|
var item_id := String(run.equipped_by_recruit.get(recruit_id, ""))
|
|
var catalog_id := String(run.inventory.get(item_id, {}).get("catalog_id", ""))
|
|
var label := _outlined_label("Lv.%d %dHP\n%s" % [record.level, record.current_hp, _region_name(catalog_id).left(7) if catalog_id.begins_with("EQ-") else _short_profession(String(record.profession_id))], 7, WHITE)
|
|
label.position = position_value + Vector2(-6, actor_size - 2)
|
|
label.size = Vector2(actor_size + 12, 36)
|
|
label.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
|
|
display_root.add_child(label)
|
|
|
|
|
|
func _render_p102_context() -> void:
|
|
var band := ColorRect.new()
|
|
band.name = "P102MarketContextBand"
|
|
band.position = Vector2(0, size.y - 58)
|
|
band.size = Vector2(size.x, 58)
|
|
band.color = Color(0.015, 0.035, 0.075, 0.95)
|
|
band.mouse_filter = Control.MOUSE_FILTER_IGNORE
|
|
display_root.add_child(band)
|
|
var context := _outlined_label(_p102_context_text(), 9, WHITE)
|
|
context.position = Vector2(14, size.y - 54)
|
|
context.size = Vector2(size.x - 242, 48)
|
|
context.autowrap_mode = TextServer.AUTOWRAP_WORD_SMART
|
|
display_root.add_child(context)
|
|
var depart := _action_button("P102PrepareRouteButton", _tr("准备第%d轮" % region_market.state.current_run.round_index, "PREPARE ROUND %d" % region_market.state.current_run.round_index), commit_region_route)
|
|
depart.position = Vector2(size.x - 220, size.y - 54)
|
|
depart.size = Vector2(204, 48)
|
|
depart.disabled = region_focused_route.is_empty()
|
|
display_root.add_child(depart)
|
|
|
|
|
|
func _p102_context_text() -> String:
|
|
if not region_selected_instance.is_empty():
|
|
var item: Dictionary = region_market.state.current_run.inventory.get(region_selected_instance, {})
|
|
return _tr("已购买 %s；点战线或预备队员替换其唯一装备。" % _region_name(String(item.get("catalog_id", ""))), "BOUGHT %s; TAP A LINE OR RESERVE RECRUIT TO REPLACE THEIR ONE ITEM." % _region_name(String(item.get("catalog_id", ""))))
|
|
if not region_focused_recruit.is_empty():
|
|
var recruit := _region_offer("recruit", region_focused_recruit)
|
|
return _tr("%s · Lv.%d · ◆%d；再点一次雇佣，超出容量会进入预备队。" % [_generated_name(recruit), recruit.level, recruit.list_price], "%s · LV.%d · ◆%d; TAP AGAIN TO HIRE. OVER CAPACITY ENTERS RESERVE." % [_generated_name(recruit), recruit.level, recruit.list_price])
|
|
if not region_focused_equipment.is_empty():
|
|
var equipment := _region_offer("equipment", region_focused_equipment)
|
|
return _tr("%s · ◆%d；再点购买，然后点队员装备。" % [_region_name(String(equipment.catalog_id)), equipment.list_price], "%s · ◆%d; TAP AGAIN TO BUY, THEN TAP A RECRUIT." % [_region_name(String(equipment.catalog_id)), equipment.list_price])
|
|
if not region_focused_route.is_empty():
|
|
return _route_summary(int(_region_offer("route", region_focused_route).risk))
|
|
if not p102_focused_company.is_empty():
|
|
var run: Dictionary = region_market.state.current_run
|
|
return _tr("已选队员：再点本人切换战线/预备，或点另一侧队员交换。", "RECRUIT SELECTED: TAP AGAIN TO MOVE LINE/RESERVE, OR TAP THE OTHER SIDE TO SWAP.") if p102_focused_company in run.company else ""
|
|
return _tr("先看路线压力，再调整战线、预备队与装备；容量会在第2、4轮后增长。", "READ ROUTE PRESSURE, THEN ADAPT LINE, RESERVE AND GEAR. CAPACITY GROWS AFTER ROUNDS 2 AND 4.")
|
|
|
|
|
|
func _render_p102_plan() -> void:
|
|
_add_siltwake_world()
|
|
var encounter: Dictionary = region_market.state.current_run.pending_encounter
|
|
var tide: Dictionary = encounter.tide_disclosure
|
|
_add_header(_tr("第%d轮 · 选择应对" % encounter.round_index, "ROUND %d · CHOOSE RESPONSE" % encounter.round_index), _tr("%s · 风险%d · 安全位 %d→%d" % [_region_name(String(encounter.route_id)), encounter.risk, tide.current_safe_index, tide.next_safe_index], "%s · RISK %d · SAFE %d→%d" % [_region_name(String(encounter.route_id)), encounter.risk, tide.current_safe_index, tide.next_safe_index]))
|
|
_render_tide_notches(tide, 0)
|
|
_render_plan_company()
|
|
var hint := _outlined_label(_route_summary(int(encounter.risk)), 10, WHITE)
|
|
hint.position = Vector2(size.x * 0.13, 62)
|
|
hint.size = Vector2(size.x * 0.74, 48)
|
|
hint.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
|
|
hint.autowrap_mode = TextServer.AUTOWRAP_WORD_SMART
|
|
display_root.add_child(hint)
|
|
var specs := [
|
|
["hold_line", _tr("稳住战线", "HOLD LINE"), _tr("保持顺序，抵抗拉拽", "KEEP ORDER; RESIST PULL"), GOLD],
|
|
["follow_tide", _tr("顺潮移动", "FOLLOW TIDE"), _tr("保留移动，避开标记", "SAVE MOVEMENT; EVADE MARKS"), CYAN],
|
|
["focus_source", _tr("集火源头", "FOCUS SOURCE"), _tr("先打断治疗或控制", "INTERRUPT HEAL OR CONTROL"), CORAL],
|
|
["guard_center", _tr("守护中位", "GUARD CENTER"), _tr("诱导攻击，抓住显形", "BAIT ATTACK; USE REVEAL"), VIOLET],
|
|
]
|
|
var w := size.x * 0.38
|
|
var h := 62.0
|
|
for index in range(specs.size()):
|
|
var spec: Array = specs[index]
|
|
var at := Vector2(size.x * (0.08 if index % 2 == 0 else 0.54), 188 + int(index / 2) * 72)
|
|
_render_p102_plan_target(String(spec[0]), String(spec[1]), String(spec[2]), at, Vector2(w, h), Color(spec[3]))
|
|
|
|
|
|
func _render_p102_plan_target(plan_id: String, title: String, consequence: String, at: Vector2, target_size: Vector2, color: Color) -> void:
|
|
var line := ColorRect.new()
|
|
line.name = "P102PlanLine_%s" % plan_id
|
|
line.position = Vector2(at.x, at.y + target_size.y - 5)
|
|
line.size = Vector2(target_size.x, 5)
|
|
line.color = color
|
|
line.mouse_filter = Control.MOUSE_FILTER_IGNORE
|
|
display_root.add_child(line)
|
|
var label := _outlined_label("%s\n%s" % [title, consequence], 10, WHITE)
|
|
label.position = at
|
|
label.size = target_size
|
|
label.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
|
|
label.autowrap_mode = TextServer.AUTOWRAP_WORD_SMART
|
|
display_root.add_child(label)
|
|
display_root.add_child(_actor_target("P102PlanTarget_%s" % plan_id, at, target_size, choose_region_plan.bind(plan_id)))
|
|
|
|
|
|
func _render_region_battle() -> void:
|
|
super._render_region_battle()
|
|
var header := display_root.find_child("P100Header", false, false)
|
|
if header != null:
|
|
var title := display_root.get_child(header.get_index() + 1) as Label
|
|
if title != null:
|
|
title.text = _tr("第%d轮 · %s" % [region_market.state.current_run.round_index, _region_name(String(region_market.state.current_run.pending_encounter.route_id))], "ROUND %d · %s" % [region_market.state.current_run.round_index, _region_name(String(region_market.state.current_run.pending_encounter.route_id))])
|
|
|
|
|
|
func _render_region_persistent_feedback() -> void:
|
|
super._render_region_persistent_feedback()
|
|
if not p102_mode:
|
|
return
|
|
var mechanics: Dictionary = region_motion.mechanic_effects(region_motion_clock)
|
|
if not String(mechanics.drownseed.state).is_empty():
|
|
var seed := _motion_sprite("P102DrownseedMarker", PROTECT_ABSORB_VFX, Vector2(38, 38), CORAL if mechanics.drownseed.state == "burst" else GOLD)
|
|
seed.set_meta("target_id", String(mechanics.drownseed.target_id))
|
|
seed.set_meta("mechanic_state", String(mechanics.drownseed.state))
|
|
display_root.add_child(seed)
|
|
if not String(mechanics.medic.state).is_empty():
|
|
var heal := _motion_sprite("P102MedicPulse", PROTECT_GAIN_VFX, Vector2(42, 42), CORAL if mechanics.medic.state == "interrupted" else JADE)
|
|
heal.set_meta("target_id", String(mechanics.medic.target_id))
|
|
heal.set_meta("mechanic_state", String(mechanics.medic.state))
|
|
display_root.add_child(heal)
|
|
if String(mechanics.fogjaw.state) == "revealed":
|
|
var reveal := _motion_sprite("P102FogjawReveal", DAMAGE_VFX, Vector2(48, 48), CYAN)
|
|
reveal.set_meta("target_id", "EN-R2-10")
|
|
display_root.add_child(reveal)
|
|
|
|
|
|
func _animate_region_persistent_feedback() -> void:
|
|
super._animate_region_persistent_feedback()
|
|
for node_name in ["P102DrownseedMarker", "P102MedicPulse", "P102FogjawReveal"]:
|
|
var sprite := display_root.find_child(node_name, false, false) as Sprite2D
|
|
if sprite == null:
|
|
continue
|
|
sprite.position = _region_actor_center(String(sprite.get_meta("target_id", "")))
|
|
var pulse := 0.72 if low_power else 0.68 + sin(region_motion_clock * 8.0) * 0.22
|
|
sprite.modulate.a = pulse
|
|
|
|
|
|
func _render_p102_recovery() -> void:
|
|
_add_siltwake_world()
|
|
var run: Dictionary = region_market.state.current_run
|
|
var report: Dictionary = run.last_battle_report
|
|
_add_header(_tr("第%d轮 · 撤回渡口" % report.round_index, "ROUND %d · FERRY RECOVERY" % report.round_index), _tr("◆%d 救援 ◆%d 信用 %d" % [run.coin, run.recovery_cost, run.replacement_credit], "◆%d RECOVERY ◆%d CREDIT %d" % [run.coin, run.recovery_cost, run.replacement_credit]))
|
|
var title := _outlined_label(_tr("阵亡永久保留，幸存者可恢复", "FALLEN STAY LOST; SURVIVORS CAN RECOVER"), 23, CORAL)
|
|
title.position = Vector2(size.x * 0.10, 76)
|
|
title.size = Vector2(size.x * 0.80, 48)
|
|
title.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
|
|
display_root.add_child(title)
|
|
var body := _outlined_label(_tr("失败原因：%s\n支付救援费后回到同一个集市，路线和商品不会重抽。" % _battle_cause_text(report), "CAUSE: %s\nPAY RECOVERY TO RETURN TO THE SAME MARKET. ROUTES AND OFFERS DO NOT REROLL." % _battle_cause_text(report)), 11, WHITE)
|
|
body.position = Vector2(size.x * 0.16, 128)
|
|
body.size = Vector2(size.x * 0.68, 72)
|
|
body.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
|
|
body.autowrap_mode = TextServer.AUTOWRAP_WORD_SMART
|
|
display_root.add_child(body)
|
|
_render_p102_survivors(Vector2(size.x * 0.24, size.y * 0.54), 68)
|
|
var recover := _action_button("P102RecoverButton", _tr("支付 ◆%d 救援" % run.recovery_cost, "PAY ◆%d TO RECOVER" % run.recovery_cost), recover_region_company)
|
|
recover.position = Vector2(size.x - 236, size.y - 62)
|
|
recover.size = Vector2(220, 52)
|
|
recover.disabled = int(run.coin) < int(run.recovery_cost)
|
|
display_root.add_child(recover)
|
|
|
|
|
|
func _render_p102_market_five() -> void:
|
|
_add_siltwake_world()
|
|
var run: Dictionary = region_market.state.current_run
|
|
_add_header(_tr("淤潮地 · 集市 5", "SILTWAKE · MARKET 5"), _tr("◆%d 战线容量 %d 已保存" % [run.coin, run.line_capacity], "◆%d LINE CAPACITY %d SAVED" % [run.coin, run.line_capacity]))
|
|
var title := _outlined_label(_tr("芦苇渡船已修复", "REED FERRY RESTORED"), 28, GOLD_LIGHT)
|
|
title.position = Vector2(size.x * 0.43, 82)
|
|
title.size = Vector2(size.x * 0.50, 56)
|
|
title.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
|
|
display_root.add_child(title)
|
|
var body := _outlined_label(_tr("四轮已清除 · 战线容量 6 · 队员生命、等级、经验、装备与路线历史均已写入 Save v8。", "FOUR ROUNDS CLEARED · LINE CAPACITY 6 · HP, LEVELS, XP, GEAR AND ROUTE HISTORY ARE SAVED IN V8."), 12, WHITE)
|
|
body.position = Vector2(size.x * 0.45, 142)
|
|
body.size = Vector2(size.x * 0.46, 80)
|
|
body.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
|
|
body.autowrap_mode = TextServer.AUTOWRAP_WORD_SMART
|
|
display_root.add_child(body)
|
|
_render_p102_survivors(Vector2(size.x * 0.07, size.y * 0.46), clampf(size.y * 0.13, 62.0, 92.0))
|
|
var seal := _outlined_label(_tr("中段远征完成 · 后续集市尚未开放", "MID-CONTRACT COMPLETE · LATER MARKETS NOT YET OPEN"), 13, JADE)
|
|
seal.position = Vector2(size.x * 0.44, size.y - 78)
|
|
seal.size = Vector2(size.x * 0.48, 48)
|
|
seal.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
|
|
display_root.add_child(seal)
|
|
|
|
|
|
func _render_p102_survivors(origin: Vector2, actor_size: float) -> void:
|
|
var run: Dictionary = region_market.state.current_run
|
|
for index in range(run.company.size()):
|
|
var recruit_id := String(run.company[index])
|
|
var record: Dictionary = run.recruit_records[recruit_id]
|
|
var actor := _add_actor(_p100_recruit_rig(record), origin + Vector2(index * (actor_size * 0.78), 0), actor_size, "P102Survivor_%s" % recruit_id, true, "victory" if screen == P102_SCREEN_MARKET_5 else "idle")
|
|
actor.self_modulate = _p100_profession_color(String(record.profession_id))
|
|
|
|
|
|
func _add_siltwake_world() -> void:
|
|
super._add_siltwake_world()
|
|
if not p102_mode:
|
|
return
|
|
var restored := region_market != null and bool(region_market.state.current_run.get("reed_ferry_restored", false))
|
|
var ferry_width := size.x * (0.32 if restored else 0.20)
|
|
var ferry_origin := Vector2(size.x * 0.05, size.y * 0.31)
|
|
var hull := Polygon2D.new()
|
|
hull.name = "P102ReedFerryRestored" if restored else "P102ReedFerryScaffold"
|
|
hull.polygon = PackedVector2Array([
|
|
ferry_origin + Vector2(0, 4),
|
|
ferry_origin + Vector2(ferry_width, 0),
|
|
ferry_origin + Vector2(ferry_width - 18, 24),
|
|
ferry_origin + Vector2(18, 28),
|
|
])
|
|
hull.color = Color("#bd873d") if restored else Color(0.34, 0.25, 0.17, 0.62)
|
|
hull.z_index = 5
|
|
display_root.add_child(hull)
|
|
var deck := ColorRect.new()
|
|
deck.name = "P102FerryDeck"
|
|
deck.position = ferry_origin + Vector2(8, -2)
|
|
deck.size = Vector2(ferry_width - 16, 8)
|
|
deck.color = GOLD if restored else Color(0.44, 0.36, 0.24, 0.58)
|
|
deck.rotation = -0.025
|
|
deck.mouse_filter = Control.MOUSE_FILTER_IGNORE
|
|
deck.z_index = 6
|
|
display_root.add_child(deck)
|
|
for index in range(6 if restored else 2):
|
|
var post := ColorRect.new()
|
|
post.name = "P102FerryPost_%d" % index
|
|
post.position = ferry_origin + Vector2(14 + index * (ferry_width - 28) / maxf(1.0, float(5 if restored else 1)), -8)
|
|
post.size = Vector2(4, 24)
|
|
post.color = deck.color
|
|
post.mouse_filter = Control.MOUSE_FILTER_IGNORE
|
|
post.z_index = 7
|
|
display_root.add_child(post)
|
|
if restored:
|
|
var mast := ColorRect.new()
|
|
mast.name = "P102FerryMast"
|
|
mast.position = ferry_origin + Vector2(ferry_width * 0.52, -54)
|
|
mast.size = Vector2(5, 62)
|
|
mast.color = Color("#efd17a")
|
|
mast.mouse_filter = Control.MOUSE_FILTER_IGNORE
|
|
mast.z_index = 7
|
|
display_root.add_child(mast)
|
|
var flag := Polygon2D.new()
|
|
flag.name = "P102FerryFlag"
|
|
flag.polygon = PackedVector2Array([
|
|
mast.position + Vector2(5, 3),
|
|
mast.position + Vector2(42, 12),
|
|
mast.position + Vector2(5, 23),
|
|
])
|
|
flag.color = CYAN
|
|
flag.z_index = 7
|
|
display_root.add_child(flag)
|
|
var lantern := _outlined_label("◆", 18, GOLD_LIGHT)
|
|
lantern.name = "P102FerryLantern"
|
|
lantern.position = mast.position + Vector2(-11, -20)
|
|
lantern.size = Vector2(28, 28)
|
|
lantern.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
|
|
lantern.z_index = 8
|
|
display_root.add_child(lantern)
|
|
|
|
|
|
func _region_event_text(event: Dictionary) -> String:
|
|
if not p102_mode:
|
|
return super._region_event_text(event)
|
|
var kind := String(event.get("kind", "battle_started"))
|
|
var payload: Dictionary = Dictionary(event.get("payload", {}))
|
|
return {
|
|
"battle_started": _tr("第%d轮开始：%s" % [payload.get("round_index", 0), _plan_name(String(payload.get("plan_id", "")))], "ROUND %d: %s" % [payload.get("round_index", 0), _plan_name(String(payload.get("plan_id", "")))]),
|
|
"wave_entered": _tr("%s进入战线" % _region_name(String(event.get("source_id", ""))), "%s ENTERS THE LINE" % _region_name(String(event.get("source_id", "")))),
|
|
"drownseed_placed": _tr("沉籽落地：两拍后爆裂", "DROWNSEED PLACED: BURST IN TWO CADENCES"),
|
|
"drownseed_evaded": _tr("队员移出沉籽标记", "RECRUIT CLEARS THE DROWNSEED MARK"),
|
|
"drownseed_burst": _tr("沉籽爆裂并冲击战线", "DROWNSEED BURSTS INTO THE LINE"),
|
|
"mire_medic_heal": _tr("泥沼医师治疗并缩短迟滞", "MIRE MEDIC HEALS AND SHORTENS HINDRANCE"),
|
|
"source_interrupted": _tr("源头被集火打断", "SOURCE INTERRUPTED BY FOCUS FIRE"),
|
|
"enemy_sustain_resolved": _tr("敌方治疗完整生效", "ENEMY SUSTAIN RESOLVES"),
|
|
"fogjaw_hidden": _tr("雾颚兽藏入雾中，远程无法锁定", "FOGJAW HIDES; LONG REACH CANNOT TARGET"),
|
|
"fogjaw_center_attack": _tr("雾颚兽扑向中位并短暂显形", "FOGJAW STRIKES CENTER AND REVEALS"),
|
|
"center_guarded": _tr("中位守护接住突袭", "CENTER GUARD CATCHES THE STRIKE"),
|
|
"center_exposed": _tr("中位暴露，突袭命中", "CENTER EXPOSED; STRIKE CONNECTS"),
|
|
"rear_pull": _tr("芦钩尝试拉动后排", "REED HOOK PULLS THE REAR"),
|
|
"healing_denial_attached": _tr("泥灯水蛭封锁最低生命队员", "MUDLAMP LEECH BLOCKS THE LOWEST-HP RECRUIT"),
|
|
"indexed_mud_marked": _tr("当前安全位被淤泥标记", "CURRENT SAFE INDEX IS MARKED"),
|
|
"enemy_order_changed": _tr("敌方前后顺序改变", "ENEMY ORDER CHANGES"),
|
|
"tide_shift_warning": _tr("换潮警告：下一安全位已亮起", "TIDE WARNING: NEXT SAFE INDEX LIT"),
|
|
"tide_shifted": _tr("队伍随潮移动", "THE LINE FOLLOWS THE TIDE") if bool(payload.get("followed", false)) else _tr("战线留在原位承受换潮", "THE LINE HOLDS THROUGH THE TIDE"),
|
|
"allied_basic": _tr("队员攻击产生接触", "RECRUIT ATTACK CONNECTS"),
|
|
"authoritative_damage": _tr("伤害 -%d" % int(payload.get("amount", 0)), "DAMAGE -%d" % int(payload.get("amount", 0))),
|
|
"fallen": _tr("一名队员永久阵亡", "A RECRUIT IS PERMANENTLY FALLEN"),
|
|
"prepared_response_succeeded": _tr("战术应对命中关键窗口", "THE RESPONSE HITS THE DECISIVE WINDOW"),
|
|
"battle_terminal": _tr("本轮结果已确定", "ROUND RESULT LOCKED"),
|
|
}.get(kind, kind.replace("_", " ").to_upper())
|
|
|
|
|
|
func _region_event_color(kind: String) -> Color:
|
|
if not p102_mode:
|
|
return super._region_event_color(kind)
|
|
if kind in ["drownseed_burst", "enemy_sustain_resolved", "center_exposed", "authoritative_damage", "fallen"]:
|
|
return CORAL
|
|
if kind in ["drownseed_evaded", "source_interrupted", "center_guarded", "prepared_response_succeeded", "battle_terminal"]:
|
|
return JADE
|
|
return GOLD_LIGHT
|
|
|
|
|
|
func _route_summary(risk: int) -> String:
|
|
if not p102_mode:
|
|
return super._route_summary(risk)
|
|
var offer := _region_offer("route", region_focused_route)
|
|
if offer.is_empty() and region_market != null:
|
|
offer = Dictionary(region_market.state.current_run.get("pending_encounter", {}))
|
|
if offer.is_empty():
|
|
return _tr("比较路线压力与当前战线，再选择应对。", "COMPARE ROUTE PRESSURE WITH THE CURRENT LINE, THEN CHOOSE A RESPONSE.")
|
|
return String(offer.preview) if locale == "en" else _p102_route_hint(String(offer.route_id))
|
|
|
|
|
|
func _p102_route_hint(route_id: String) -> String:
|
|
return {
|
|
"RO-R2-M02-Q0": "稳住后排，让镜像目标保持可预测。",
|
|
"RO-R2-M02-Q1": "集火打断笛手，避免敌方换位后牵引战线。",
|
|
"RO-R2-M02-Q2": "保留一次移动，在沉籽爆裂前离开标记。",
|
|
"RO-R2-M03-Q0": "等待迟滞过半，或先处理泥沼医师。",
|
|
"RO-R2-M03-Q1": "优先打断水蛭或医师，别让治疗反复生效。",
|
|
"RO-R2-M03-Q2": "守住中位，等雾颚兽攻击显形后反击。",
|
|
"RO-R2-M04-Q0": "抵抗拉拽，把移动留给沉籽倒计时。",
|
|
"RO-R2-M04-Q1": "先喂给镜像安全目标，再守住中位显形窗口。",
|
|
"RO-R2-M04-Q2": "先集火医师，再带着可用移动击破沉籽。",
|
|
}.get(route_id, "路线会检验当前战线的站位、目标和时机。")
|
|
|
|
|
|
func _region_name(row_id: String) -> String:
|
|
if not p102_mode:
|
|
return super._region_name(row_id)
|
|
var p102_name := P102Content.localized_name(p102_catalog, row_id, locale)
|
|
return super._region_name(row_id) if p102_name.is_empty() else p102_name
|
|
|
|
|
|
func _equipment_symbol(catalog_id: String) -> String:
|
|
if catalog_id in ["EQ-049", "EQ-050", "EQ-051", "EQ-052", "EQ-053", "EQ-054", "EQ-055", "EQ-056"]:
|
|
return {"EQ-049": "◇", "EQ-050": "▽", "EQ-051": "⊘", "EQ-052": "♨", "EQ-053": "□", "EQ-054": "Ⅲ", "EQ-055": "↔", "EQ-056": "⇥"}[catalog_id]
|
|
return super._equipment_symbol(catalog_id)
|
|
|
|
|
|
func _plan_name(plan_id: String) -> String:
|
|
return {
|
|
"hold_line": _tr("稳住战线", "HOLD LINE"),
|
|
"follow_tide": _tr("顺潮移动", "FOLLOW TIDE"),
|
|
"focus_source": _tr("集火源头", "FOCUS SOURCE"),
|
|
"guard_center": _tr("守护中位", "GUARD CENTER"),
|
|
}.get(plan_id, plan_id)
|
|
|
|
|
|
func _battle_cause_text(report: Dictionary) -> String:
|
|
var event: Dictionary = Dictionary(report.get("first_decisive_event", {}))
|
|
return _region_event_text(event)
|
|
|
|
|
|
func reset_progress() -> void:
|
|
if not p102_mode:
|
|
super.reset_progress()
|
|
return
|
|
if not reset_confirmation:
|
|
reset_confirmation = true
|
|
last_code = "reset_confirmation_required"
|
|
_queue_render()
|
|
return
|
|
for save_name in [P102_SAVE_PATH, P101_SAVE_PATH]:
|
|
for suffix in ["", ".bak", ".candidate"]:
|
|
var path := ProjectSettings.globalize_path(save_name + suffix)
|
|
if FileAccess.file_exists(path):
|
|
DirAccess.remove_absolute(path)
|
|
p102_mode = false
|
|
region_mode = false
|
|
region_market = null
|
|
entry_snapshot = {}
|
|
region_save_sequence = 0
|
|
region_save_commit_hash = ""
|
|
super.reset_progress()
|