1288 lines
57 KiB
GDScript
1288 lines
57 KiB
GDScript
class_name P101RuntimeController
|
|
extends "res://p10_0/runtime_controller.gd"
|
|
|
|
const BaseContent = preload("res://p10_0/content_registry.gd")
|
|
const RegionContent = preload("res://p10_1/content_registry.gd")
|
|
const RegionState = preload("res://p10_1/region_run_state.gd")
|
|
const RegionMarketService = preload("res://p10_1/region_market_service.gd")
|
|
const RegionBattleService = preload("res://p10_1/first_crossing_battle_service.gd")
|
|
const RegionResolutionService = preload("res://p10_1/first_crossing_resolution_service.gd")
|
|
const RegionSaveService = preload("res://p10_1/save_v7_service.gd")
|
|
const MotionPresenter = preload("res://p10_1/motion_presenter.gd")
|
|
const DAMAGE_VFX = preload("res://assets/vfx/damage_heavy.png")
|
|
const PROTECT_GAIN_VFX = preload("res://assets/vfx/protect_gain.png")
|
|
const PROTECT_ABSORB_VFX = preload("res://assets/vfx/protect_absorb.png")
|
|
|
|
const REGION_SAVE_PATH := "user://aetherbound_guild_p10_1.json"
|
|
const REGION_TICK_SECONDS := 0.10
|
|
const REGION_SCREEN_MARKET := "siltwake_market"
|
|
const REGION_SCREEN_PLAN := "siltwake_plan"
|
|
const REGION_SCREEN_BATTLE := "siltwake_battle"
|
|
const REGION_SCREEN_RECOVERY := "siltwake_recovery"
|
|
const REGION_SCREEN_MARKET_2 := "siltwake_market_2"
|
|
|
|
var region_mode := false
|
|
var region_market
|
|
var region_save = RegionSaveService.new()
|
|
var region_catalog: Dictionary = RegionContent.snapshot()
|
|
var region_equipment_rows: Dictionary = RegionContent.rows_by_id(region_catalog, "equipment")
|
|
var region_enemy_rows: Dictionary = RegionContent.rows_by_id(region_catalog, "enemies")
|
|
var region_route_rows: Dictionary = RegionContent.rows_by_id(region_catalog, "routes")
|
|
var region_focused_recruit := ""
|
|
var region_focused_equipment := ""
|
|
var region_focused_route := ""
|
|
var region_focused_company := ""
|
|
var region_selected_instance := ""
|
|
var region_plan_id := ""
|
|
var region_battle_snapshot: Dictionary = {}
|
|
var region_battle_tick := 0
|
|
var region_battle_terminal_tick := 0
|
|
var region_battle_accumulator := 0.0
|
|
var region_battle_complete := false
|
|
var region_battle_paused := false
|
|
var region_battle_speed := 1
|
|
var region_event_cursor := 0
|
|
var region_recent_events: Array[Dictionary] = []
|
|
var region_event_counts: Dictionary = {}
|
|
var region_actor_order: Array = []
|
|
var region_display_hp: Dictionary = {}
|
|
var region_safe_index := 0
|
|
var region_save_sequence := 0
|
|
var region_save_commit_hash := ""
|
|
var region_motion = MotionPresenter.new()
|
|
var region_motion_clock := 0.0
|
|
|
|
|
|
func _bootstrap_market() -> void:
|
|
region_mode = false
|
|
if _try_restore_region_entry():
|
|
_prepare_base_content()
|
|
_queue_render()
|
|
return
|
|
super._bootstrap_market()
|
|
|
|
|
|
func _try_restore_region_entry() -> bool:
|
|
var snapshot: Dictionary = {}
|
|
if String(entry_snapshot.get("state_kind", "")) == RegionState.STATE_KIND:
|
|
snapshot = entry_snapshot.duplicate(true)
|
|
elif persistence_enabled:
|
|
var loaded: Dictionary = region_save.load_slot(ProjectSettings.globalize_path(REGION_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():
|
|
return false
|
|
region_market = RegionMarketService.new(snapshot)
|
|
if not region_market.valid:
|
|
region_market = null
|
|
return false
|
|
region_mode = true
|
|
last_code = "p101_resumed"
|
|
_restore_region_screen()
|
|
_reset_region_focus()
|
|
return true
|
|
|
|
|
|
func _prepare_base_content() -> void:
|
|
content = BaseContent.snapshot()
|
|
profession_rows = BaseContent.rows_by_id(content, "professions")
|
|
trait_rows = BaseContent.rows_by_id(content, "traits")
|
|
equipment_rows = BaseContent.rows_by_id(content, "equipment")
|
|
enemy_rows = BaseContent.rows_by_id(content, "enemies")
|
|
boss_rows = BaseContent.rows_by_id(content, "bosses")
|
|
contract_rows = BaseContent.rows_by_id(content, "contracts")
|
|
battle_active = false
|
|
battle_result_visible = false
|
|
pending_line.clear()
|
|
if region_market != null and not region_market.state.current_run.is_empty():
|
|
pending_line.assign(region_market.state.current_run.deployed_recruit_ids)
|
|
|
|
|
|
func _restore_region_screen() -> void:
|
|
if region_market == null or region_market.state.current_run.is_empty():
|
|
screen = REGION_SCREEN_MARKET
|
|
return
|
|
match String(region_market.state.current_run.phase):
|
|
"prepared":
|
|
screen = REGION_SCREEN_PLAN
|
|
"recovery":
|
|
screen = REGION_SCREEN_RECOVERY
|
|
"market_2":
|
|
screen = REGION_SCREEN_MARKET_2
|
|
_:
|
|
screen = REGION_SCREEN_MARKET
|
|
|
|
|
|
func _process(delta: float) -> void:
|
|
if not region_mode:
|
|
super._process(delta)
|
|
return
|
|
if screen == REGION_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 != REGION_SCREEN_BATTLE or region_battle_complete or region_battle_paused:
|
|
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:
|
|
return
|
|
region_battle_accumulator -= float(ticks) * REGION_TICK_SECONDS
|
|
advance_region_battle_ticks(ticks)
|
|
|
|
|
|
func _render_current() -> void:
|
|
if not region_mode:
|
|
super._render_current()
|
|
return
|
|
if display_root == null:
|
|
return
|
|
_clear_display()
|
|
line_touch_rects.clear()
|
|
set_meta("visible_world_ratio", 0.86)
|
|
if size.y > size.x:
|
|
_render_rotate_notice()
|
|
else:
|
|
match screen:
|
|
REGION_SCREEN_PLAN:
|
|
_render_region_plan()
|
|
REGION_SCREEN_BATTLE:
|
|
_render_region_battle()
|
|
REGION_SCREEN_RECOVERY:
|
|
_render_region_recovery()
|
|
REGION_SCREEN_MARKET_2:
|
|
_render_region_market_2()
|
|
_:
|
|
_render_region_market()
|
|
_add_settings_button()
|
|
if settings_open:
|
|
_render_settings_band()
|
|
|
|
|
|
func _render_guild_result() -> void:
|
|
super._render_guild_result()
|
|
if not _region_gate_ready():
|
|
return
|
|
var water := ColorRect.new()
|
|
water.name = "P101SiltwakeGateWater"
|
|
water.position = Vector2(size.x * 0.52, size.y * 0.52)
|
|
water.size = Vector2(size.x * 0.43, 5)
|
|
water.color = Color("#63c8c4")
|
|
water.mouse_filter = Control.MOUSE_FILTER_IGNORE
|
|
display_root.add_child(water)
|
|
var enter := _action_button("P101EnterRegionButton", _tr("踏入淤潮地", "ENTER SILTWAKE"), enter_siltwake)
|
|
enter.position = Vector2(size.x - 238, size.y - 66)
|
|
enter.size = Vector2(218, 52)
|
|
display_root.add_child(enter)
|
|
|
|
|
|
func _region_gate_ready() -> bool:
|
|
return (
|
|
market != null
|
|
and not market.state.guild_profile.is_empty()
|
|
and "RG-02" in market.state.guild_profile.unlocked_region_ids
|
|
and market.state.current_run.is_empty()
|
|
and market.state.run_creation_draft.is_empty()
|
|
)
|
|
|
|
|
|
func enter_siltwake() -> void:
|
|
if region_mode or not _region_gate_ready():
|
|
return
|
|
var migrated := RegionState.new()
|
|
if not migrated.initialize_from_p100(market.state.snapshot()):
|
|
last_code = "p101_migration_rejected"
|
|
_queue_render()
|
|
return
|
|
var service = RegionMarketService.new(migrated.snapshot())
|
|
var result: Dictionary = service.begin_region_run("p101-ui-enter-rg02", service.state.revision, selected_difficulty)
|
|
last_code = String(result.code)
|
|
if not result.ok:
|
|
_queue_render()
|
|
return
|
|
region_market = service
|
|
region_mode = true
|
|
screen = REGION_SCREEN_MARKET
|
|
_prepare_base_content()
|
|
_reset_region_focus()
|
|
_save_region()
|
|
_queue_render()
|
|
|
|
|
|
func tap_region_recruit(offer_id: String) -> void:
|
|
if not _region_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 _region_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 _region_market_ready() or recruit_id not in region_market.state.current_run.company:
|
|
return
|
|
if not region_selected_instance.is_empty():
|
|
var result: Dictionary = region_market.equip(
|
|
_region_operation("equip", recruit_id),
|
|
region_market.state.revision,
|
|
recruit_id,
|
|
region_selected_instance
|
|
)
|
|
_accept_region_result(result)
|
|
if result.ok:
|
|
region_selected_instance = ""
|
|
region_focused_company = recruit_id
|
|
return
|
|
region_focused_company = recruit_id
|
|
last_code = "company_inspected"
|
|
_queue_render()
|
|
|
|
|
|
func tap_region_route(offer_id: String) -> void:
|
|
if not _region_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 _region_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 = REGION_SCREEN_PLAN
|
|
_save_region()
|
|
_queue_render()
|
|
|
|
|
|
func choose_region_plan(plan_id: String) -> void:
|
|
if region_market == null or String(region_market.state.current_run.get("phase", "")) != "prepared":
|
|
return
|
|
var result: Dictionary = RegionBattleService.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 = REGION_SCREEN_BATTLE
|
|
_queue_render()
|
|
|
|
|
|
func advance_region_battle_ticks(ticks: int) -> Dictionary:
|
|
if screen != REGION_SCREEN_BATTLE or region_battle_complete or ticks <= 0:
|
|
return {"ok": false, "code": "battle_inactive", "events": []}
|
|
var previous_tick := region_battle_tick
|
|
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 = "first_crossing_playback_terminal"
|
|
elif previous_tick != region_battle_tick:
|
|
last_code = "first_crossing_playing"
|
|
_queue_render()
|
|
return {"ok": true, "code": last_code, "events": emitted, "tick": region_battle_tick}
|
|
|
|
|
|
func toggle_region_battle_pause() -> void:
|
|
if screen != REGION_SCREEN_BATTLE or region_battle_complete:
|
|
return
|
|
region_battle_paused = not region_battle_paused
|
|
_queue_render()
|
|
|
|
|
|
func toggle_region_battle_speed() -> void:
|
|
if screen != REGION_SCREEN_BATTLE or region_battle_complete:
|
|
return
|
|
region_battle_speed = 2 if region_battle_speed == 1 else 1
|
|
_queue_render()
|
|
|
|
|
|
func settle_region_battle() -> void:
|
|
if not region_battle_complete or region_battle_snapshot.is_empty():
|
|
return
|
|
var resolver = RegionResolutionService.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 = RegionMarketService.new(result.snapshot)
|
|
_save_region()
|
|
screen = REGION_SCREEN_MARKET_2 if String(region_market.state.current_run.phase) == "market_2" else REGION_SCREEN_RECOVERY
|
|
_queue_render()
|
|
|
|
|
|
func recover_region_company() -> void:
|
|
if region_market == null or String(region_market.state.current_run.get("phase", "")) != "recovery":
|
|
return
|
|
var report: Dictionary = region_market.state.current_run.last_battle_report
|
|
var cost := int(region_market.state.current_run.recovery_cost)
|
|
var resolver = RegionResolutionService.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", "")),
|
|
cost
|
|
)
|
|
last_code = String(result.code)
|
|
if not result.ok:
|
|
_queue_render()
|
|
return
|
|
region_market = RegionMarketService.new(result.snapshot)
|
|
pending_line.assign(region_market.state.current_run.deployed_recruit_ids)
|
|
_reset_region_focus()
|
|
_save_region()
|
|
screen = REGION_SCREEN_MARKET
|
|
_queue_render()
|
|
|
|
|
|
func _commit_line_drag(source_id: String, target_id: String) -> void:
|
|
if not region_mode:
|
|
super._commit_line_drag(source_id, target_id)
|
|
return
|
|
if not _region_market_ready() or source_id.is_empty() or target_id.is_empty() or source_id == target_id:
|
|
return
|
|
var order: Array = Array(region_market.state.current_run.deployed_recruit_ids).duplicate()
|
|
if source_id not in order or target_id not in order:
|
|
return
|
|
order.erase(source_id)
|
|
order.insert(order.find(target_id), source_id)
|
|
var result: Dictionary = region_market.commit_order(
|
|
_region_operation("order", "drag"),
|
|
region_market.state.revision,
|
|
order
|
|
)
|
|
_accept_region_result(result)
|
|
if result.ok:
|
|
pending_line.assign(region_market.state.current_run.deployed_recruit_ids)
|
|
|
|
|
|
func reset_progress() -> void:
|
|
if not region_mode:
|
|
super.reset_progress()
|
|
return
|
|
if not reset_confirmation:
|
|
reset_confirmation = true
|
|
last_code = "reset_confirmation_required"
|
|
_queue_render()
|
|
return
|
|
for suffix in ["", ".bak", ".candidate"]:
|
|
var path := ProjectSettings.globalize_path(REGION_SAVE_PATH + suffix)
|
|
if FileAccess.file_exists(path):
|
|
DirAccess.remove_absolute(path)
|
|
region_mode = false
|
|
region_market = null
|
|
entry_snapshot = {}
|
|
region_save_sequence = 0
|
|
region_save_commit_hash = ""
|
|
super.reset_progress()
|
|
|
|
|
|
func _accept_region_result(result: Dictionary) -> void:
|
|
last_code = String(result.get("code", ""))
|
|
if result.ok:
|
|
_save_region()
|
|
_queue_render()
|
|
|
|
|
|
func _save_region() -> bool:
|
|
if not persistence_enabled or region_market == null:
|
|
return true
|
|
var next_sequence := region_save_sequence + 1
|
|
var result: Dictionary = region_save.write_slot(
|
|
ProjectSettings.globalize_path(REGION_SAVE_PATH),
|
|
region_market.state.snapshot(),
|
|
next_sequence,
|
|
region_save_commit_hash
|
|
)
|
|
if not result.ok:
|
|
last_code = "p101_%s" % String(result.code)
|
|
return false
|
|
region_save_sequence = int(result.sequence)
|
|
region_save_commit_hash = String(result.commit_hash)
|
|
return true
|
|
|
|
|
|
func _region_market_ready() -> bool:
|
|
return (
|
|
region_mode
|
|
and region_market != null
|
|
and not region_market.state.current_run.is_empty()
|
|
and String(region_market.state.current_run.phase) == "market"
|
|
)
|
|
|
|
|
|
func _region_operation(kind: String, target: String) -> String:
|
|
operation_index += 1
|
|
var revision := int(region_market.state.revision) if region_market != null else -1
|
|
return "p101-ui-%s-%d-%d-%s" % [kind, revision, operation_index, target]
|
|
|
|
|
|
func _reset_region_focus() -> void:
|
|
region_focused_recruit = ""
|
|
region_focused_equipment = ""
|
|
region_focused_route = ""
|
|
region_focused_company = ""
|
|
region_selected_instance = ""
|
|
|
|
|
|
func _region_offer(kind: String, offer_id: String) -> Dictionary:
|
|
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 _consume_region_event(event: Dictionary) -> void:
|
|
var kind := String(event.kind)
|
|
region_motion.consume(event, region_motion_clock)
|
|
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 == "pull_committed":
|
|
region_actor_order = Array(event.order_after).duplicate()
|
|
elif kind == "tide_followed" or kind == "tide_shifted_while_holding":
|
|
region_safe_index = int(event.safe_index)
|
|
elif kind == "authoritative_damage":
|
|
region_display_hp[String(event.target_id)] = int(event.hp_after)
|
|
elif kind == "recruit_fallen":
|
|
region_display_hp[String(event.recruit_id)] = 0
|
|
|
|
|
|
func _render_region_market() -> void:
|
|
_add_siltwake_world()
|
|
var run: Dictionary = region_market.state.current_run
|
|
var tide: Dictionary = run.market_board.tide_disclosure
|
|
_add_header(
|
|
_tr("淤潮地 · 集市 1", "SILTWAKE · MARKET 1"),
|
|
_tr("◆%d 队伍 %d/4 安全位 %d→%d 5.0秒后换潮" % [run.coin, run.company.size(), tide.current_safe_index, tide.next_safe_index], "◆%d COMPANY %d/4 SAFE %d→%d TIDE 5.0s" % [run.coin, run.company.size(), tide.current_safe_index, tide.next_safe_index])
|
|
)
|
|
_render_tide_notches(tide, 0)
|
|
_render_region_recruit_pier()
|
|
_render_region_equipment_bank()
|
|
_render_region_route_posts()
|
|
_render_region_company_line()
|
|
_render_region_context()
|
|
|
|
|
|
func _render_region_recruit_pier() -> void:
|
|
var run: Dictionary = region_market.state.current_run
|
|
var offers: Array = run.market_board.recruit_offers
|
|
var x0 := 20.0
|
|
var actor_size := clampf(size.y * 0.20, 64.0, 82.0)
|
|
var y := 88.0
|
|
var caption := _outlined_label(_tr("渡口候选 · 点选查看，再点一次雇佣", "FERRY RECRUITS · TAP TO INSPECT, AGAIN TO HIRE"), 9, GOLD_LIGHT)
|
|
caption.position = Vector2(x0, 56)
|
|
caption.size = Vector2(size.x * 0.38, 28)
|
|
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 := x0 + index * (actor_size + 8.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, "P101RecruitRing_%s" % offer_id)
|
|
var actor := _add_actor(_p100_recruit_rig(offer), Vector2(x, y), actor_size, "P101RecruitActor_%s" % offer_id, true)
|
|
actor.self_modulate = _p100_profession_color(String(offer.profession_id))
|
|
actor.modulate.a = 1.0 if available else 0.28
|
|
if available:
|
|
display_root.add_child(_actor_target("P101RecruitTarget_%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\n%s ◆%d" % [_generated_name(offer).left(12), _short_profession(String(offer.profession_id)), int(offer.list_price)], 7, GOLD_LIGHT if region_focused_recruit == offer_id else WHITE)
|
|
label.position = Vector2(x - 8, y + actor_size - 2)
|
|
label.size = Vector2(actor_size + 16, 42)
|
|
label.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
|
|
label.autowrap_mode = TextServer.AUTOWRAP_WORD_SMART
|
|
display_root.add_child(label)
|
|
|
|
|
|
func _render_region_equipment_bank() -> void:
|
|
var run: Dictionary = region_market.state.current_run
|
|
var offers: Array = run.market_board.equipment_offers
|
|
var x0 := size.x * 0.39
|
|
var width := size.x * 0.34
|
|
var spacing := width / 4.0
|
|
var caption := _outlined_label(_tr("防潮装备 · 购买后点队员装备", "TIDE GEAR · BUY, THEN TAP A RECRUIT"), 9, GOLD_LIGHT)
|
|
caption.position = Vector2(x0, 56)
|
|
caption.size = Vector2(width, 28)
|
|
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 + 4
|
|
var post := ColorRect.new()
|
|
post.name = "P101EquipmentPost_%s" % offer_id
|
|
post.position = Vector2(x + spacing * 0.45, 90)
|
|
post.size = Vector2(4, 62)
|
|
post.color = _equipment_color(String(offer.catalog_id))
|
|
post.mouse_filter = Control.MOUSE_FILTER_IGNORE
|
|
display_root.add_child(post)
|
|
var icon := _outlined_label(_equipment_symbol(String(offer.catalog_id)), 23, _equipment_color(String(offer.catalog_id)))
|
|
icon.position = Vector2(x, 82)
|
|
icon.size = Vector2(spacing - 4, 44)
|
|
icon.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
|
|
display_root.add_child(icon)
|
|
if available:
|
|
display_root.add_child(_actor_target("P101EquipmentTarget_%s" % offer_id, Vector2(x, 80), Vector2(spacing - 4, 92), tap_region_equipment.bind(offer_id)))
|
|
var label := _outlined_label("%s\n◆%d" % [_region_name(String(offer.catalog_id)).left(9), int(offer.list_price)], 7, GOLD_LIGHT if region_focused_equipment == offer_id else WHITE)
|
|
label.position = Vector2(x - 4, 128)
|
|
label.size = Vector2(spacing + 4, 40)
|
|
label.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
|
|
label.autowrap_mode = TextServer.AUTOWRAP_WORD_SMART
|
|
label.modulate.a = 1.0 if available else 0.35
|
|
display_root.add_child(label)
|
|
|
|
|
|
func _render_region_route_posts() -> void:
|
|
var run: Dictionary = region_market.state.current_run
|
|
var offers: Array = run.market_board.battle_offers
|
|
var x := size.x - 204.0
|
|
var caption := _outlined_label(_tr("三条水路", "THREE CROSSINGS"), 9, GOLD_LIGHT)
|
|
caption.position = Vector2(x, 56)
|
|
caption.size = Vector2(184, 28)
|
|
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 := 84.0 + index * 58.0
|
|
var selected := region_focused_route == offer_id
|
|
var line := ColorRect.new()
|
|
line.name = "P101RouteLine_%s" % offer_id
|
|
line.position = Vector2(x, y + 40)
|
|
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, 40)
|
|
label.text_overrun_behavior = TextServer.OVERRUN_TRIM_ELLIPSIS
|
|
display_root.add_child(label)
|
|
display_root.add_child(_actor_target("P101RouteTarget_%s" % offer_id, Vector2(x - 4, y), Vector2(182, 48), tap_region_route.bind(offer_id)))
|
|
|
|
|
|
func _render_region_company_line() -> void:
|
|
var run: Dictionary = region_market.state.current_run
|
|
var company: Array = run.company
|
|
var actor_size := clampf(size.y * 0.17, 56.0, 70.0)
|
|
var y := size.y - 132.0
|
|
var x0 := size.x * 0.30
|
|
var spacing := minf(actor_size + 12, (size.x * 0.40) / maxf(1.0, float(company.size())))
|
|
var caption := _outlined_label(_tr("队伍战线 · 拖动调整前后顺序", "COMPANY LINE · DRAG TO REORDER"), 9, GOLD_LIGHT)
|
|
caption.position = Vector2(x0, y - 25)
|
|
caption.size = Vector2(size.x * 0.43, 24)
|
|
display_root.add_child(caption)
|
|
for index in range(company.size()):
|
|
var recruit_id := String(run.deployed_recruit_ids[index])
|
|
var record: Dictionary = run.recruit_records[recruit_id]
|
|
var x := x0 + index * spacing
|
|
_add_ground_ring(Vector2(x + actor_size * 0.5, y + actor_size - 3), actor_size * 0.72, GOLD if region_focused_company == recruit_id else JADE, "P101CompanyRing_%s" % recruit_id)
|
|
var actor := _add_actor(_p100_recruit_rig(record), Vector2(x, y), actor_size, "P101CompanyActor_%s" % recruit_id, true)
|
|
actor.self_modulate = _p100_profession_color(String(record.profession_id))
|
|
var target_rect := Rect2(Vector2(x - 3, y - 4), Vector2(actor_size + 6, actor_size + 35))
|
|
line_touch_rects[recruit_id] = target_rect
|
|
display_root.add_child(_actor_target("P101CompanyTarget_%s" % recruit_id, target_rect.position, target_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("%dHP\n%s" % [record.current_hp, _region_name(catalog_id).left(8) if catalog_id.begins_with("EQ-04") else _short_profession(String(record.profession_id))], 7, WHITE)
|
|
label.position = Vector2(x - 6, y + actor_size - 2)
|
|
label.size = Vector2(actor_size + 12, 38)
|
|
label.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
|
|
display_root.add_child(label)
|
|
|
|
|
|
func _render_region_context() -> void:
|
|
var band := ColorRect.new()
|
|
band.name = "P101MarketContextBand"
|
|
band.position = Vector2(0, size.y - 62)
|
|
band.size = Vector2(size.x, 62)
|
|
band.color = Color(0.015, 0.035, 0.075, 0.94)
|
|
band.mouse_filter = Control.MOUSE_FILTER_IGNORE
|
|
display_root.add_child(band)
|
|
var text := _region_context_text()
|
|
var context := _outlined_label(text, 9, WHITE)
|
|
context.position = Vector2(14, size.y - 58)
|
|
context.size = Vector2(size.x - 250, 52)
|
|
context.autowrap_mode = TextServer.AUTOWRAP_WORD_SMART
|
|
display_root.add_child(context)
|
|
var depart := _action_button("P101PrepareRouteButton", _tr("准备穿越", "PREPARE CROSSING"), commit_region_route)
|
|
depart.position = Vector2(size.x - 224, size.y - 58)
|
|
depart.size = Vector2(208, 48)
|
|
depart.disabled = region_focused_route.is_empty() or region_market.state.current_run.company.size() < 2
|
|
display_root.add_child(depart)
|
|
|
|
|
|
func _region_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 RECRUIT TO EQUIP IT." % _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 · %s · ◆%d。再点一次确认雇佣。" % [_generated_name(recruit), _short_profession(String(recruit.profession_id)), int(recruit.list_price)], "%s · %s · ◆%d. TAP AGAIN TO HIRE." % [_generated_name(recruit), _short_profession(String(recruit.profession_id)), int(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)), int(equipment.list_price)], "%s · ◆%d. TAP AGAIN TO BUY, THEN TAP A RECRUIT." % [_region_name(String(equipment.catalog_id)), int(equipment.list_price)])
|
|
if not region_focused_route.is_empty():
|
|
var route := _region_offer("route", region_focused_route)
|
|
return _route_summary(int(route.risk))
|
|
if region_market.state.current_run.company.size() < 2:
|
|
return _tr("先在左侧雇佣两名队员。潮水将在战斗第50刻移动安全位置。", "HIRE TWO RECRUITS ON THE LEFT. THE SAFE POSITION SHIFTS AT BATTLE TICK 50.")
|
|
return _tr("选择装备与水路；前后顺序会改变拉拽后的受击关系。", "CHOOSE GEAR AND A CROSSING; LINE ORDER CHANGES WHO IS EXPOSED AFTER A PULL.")
|
|
|
|
|
|
func _render_region_plan() -> void:
|
|
_add_siltwake_world()
|
|
var encounter: Dictionary = region_market.state.current_run.pending_encounter
|
|
var tide: Dictionary = encounter.tide_disclosure
|
|
_add_header(_tr("穿越前战术", "CROSSING PLAN"), _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 center_y := size.y * 0.55
|
|
_render_plan_target("hold_line", Vector2(size.x * 0.08, center_y), Vector2(size.x * 0.36, 92), GOLD)
|
|
_render_plan_target("follow_tide", Vector2(size.x * 0.56, center_y), Vector2(size.x * 0.36, 92), CYAN)
|
|
var hint := _outlined_label(_route_summary(int(encounter.risk)), 10, WHITE)
|
|
hint.position = Vector2(size.x * 0.16, 88)
|
|
hint.size = Vector2(size.x * 0.68, 58)
|
|
hint.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
|
|
hint.autowrap_mode = TextServer.AUTOWRAP_WORD_SMART
|
|
display_root.add_child(hint)
|
|
|
|
|
|
func _render_plan_company() -> void:
|
|
var run: Dictionary = region_market.state.current_run
|
|
var actor_size := clampf(size.y * 0.13, 58.0, 96.0)
|
|
var spacing := actor_size + 8.0
|
|
var total := maxf(actor_size, actor_size + spacing * float(run.deployed_recruit_ids.size() - 1))
|
|
var x0 := (size.x - total) * 0.5
|
|
for index in range(run.deployed_recruit_ids.size()):
|
|
var recruit_id := String(run.deployed_recruit_ids[index])
|
|
var record: Dictionary = run.recruit_records[recruit_id]
|
|
var actor := _add_actor(_p100_recruit_rig(record), Vector2(x0 + index * spacing, size.y * 0.31), actor_size, "P101PlanActor_%s" % recruit_id, true, "advance")
|
|
actor.self_modulate = _p100_profession_color(String(record.profession_id))
|
|
|
|
|
|
func _render_plan_target(plan_id: String, at: Vector2, target_size: Vector2, color: Color) -> void:
|
|
var selected_name := _tr("守住战线", "HOLD LINE") if plan_id == "hold_line" else _tr("顺潮移动", "FOLLOW TIDE")
|
|
var consequence := _tr("保持攻击节奏，依靠站位和抗拉装备。", "KEEP TEMPO; RELY ON ORDER AND PULL RESIST.") if plan_id == "hold_line" else _tr("第50刻随安全位移动，牺牲一次行动节奏。", "MOVE AT TICK 50; GIVE UP ONE ACTION CADENCE.")
|
|
var line := ColorRect.new()
|
|
line.name = "P101PlanLine_%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" % [selected_name, consequence], 11, 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("P101PlanTarget_%s" % plan_id, at, target_size, choose_region_plan.bind(plan_id)))
|
|
|
|
|
|
func _render_region_battle() -> void:
|
|
_add_siltwake_world()
|
|
var encounter: Dictionary = region_market.state.current_run.pending_encounter
|
|
var tide: Dictionary = encounter.tide_disclosure
|
|
var countdown := maxf(0.0, float(int(tide.shift_tick) - region_battle_tick) * REGION_TICK_SECONDS)
|
|
_add_header(
|
|
_tr("淤潮穿越 · %s" % _region_name(String(encounter.route_id)), "SILTWAKE CROSSING · %s" % _region_name(String(encounter.route_id))),
|
|
_tr("第%d刻 换潮 %.1f秒 安全位 %d" % [region_battle_tick, countdown, region_safe_index], "TICK %d TIDE %.1fs SAFE %d" % [region_battle_tick, countdown, region_safe_index])
|
|
)
|
|
var battle_status := display_root.get_child(display_root.get_child_count() - 1) as Label
|
|
if battle_status != null:
|
|
battle_status.name = "P101BattleStatus"
|
|
battle_status.size.x = maxf(100.0, size.x * 0.32)
|
|
_render_tide_notches(tide, region_battle_tick)
|
|
_render_region_battle_line()
|
|
_render_region_persistent_feedback()
|
|
_render_region_motion_effects()
|
|
_render_region_event_feedback()
|
|
var pause := _secondary_button("P101PauseButton", "▶" if region_battle_paused else "Ⅱ", toggle_region_battle_pause)
|
|
pause.position = Vector2(size.x - 166, 1)
|
|
pause.size = Vector2(48, 48)
|
|
display_root.add_child(pause)
|
|
var speed := _secondary_button("P101SpeedButton", "%dx" % region_battle_speed, toggle_region_battle_speed)
|
|
speed.position = Vector2(size.x - 112, 1)
|
|
speed.size = Vector2(48, 48)
|
|
display_root.add_child(speed)
|
|
if region_battle_complete:
|
|
_render_region_battle_result()
|
|
|
|
|
|
func _render_region_battle_line() -> void:
|
|
var run: Dictionary = region_market.state.current_run
|
|
var actor_size := clampf(size.y * 0.22, 70.0, 88.0)
|
|
var ally_y := size.y * 0.48
|
|
var lane := ColorRect.new()
|
|
lane.name = "P101BattleLane"
|
|
lane.position = Vector2(0, ally_y - 18)
|
|
lane.size = Vector2(size.x, actor_size + 42)
|
|
lane.color = Color(0.015, 0.04, 0.055, 0.22)
|
|
lane.mouse_filter = Control.MOUSE_FILTER_IGNORE
|
|
display_root.add_child(lane)
|
|
var ally_spacing := minf(actor_size + 8.0, size.x * 0.30 / maxf(1.0, float(region_actor_order.size() - 1)))
|
|
for index in range(region_actor_order.size()):
|
|
var recruit_id := String(region_actor_order[index])
|
|
var record: Dictionary = run.recruit_records.get(recruit_id, {})
|
|
if record.is_empty():
|
|
continue
|
|
var base := Vector2(size.x * 0.48 - actor_size - index * ally_spacing, ally_y)
|
|
var rig := _p100_recruit_rig(record)
|
|
var visual: Dictionary = region_motion.actor_visual(recruit_id, index, -ally_spacing, region_motion_clock, reduced_motion, low_power)
|
|
_add_ground_ring(base + Vector2(actor_size * 0.5, actor_size - 3), actor_size * 0.62, JADE, "P101BattleGround_%s" % recruit_id)
|
|
var actor := _add_actor(rig, base, actor_size, "P101BattleActor_%s" % recruit_id, false, _motion_actor_animation(rig, String(visual.state)))
|
|
actor.self_modulate = _p100_profession_color(String(record.profession_id))
|
|
actor.set_meta("base_position", base)
|
|
actor.set_meta("region_actor_id", recruit_id)
|
|
actor.set_meta("slot_index", index)
|
|
actor.set_meta("slot_step", -ally_spacing)
|
|
battle_actors[recruit_id] = actor
|
|
_apply_region_actor_visual(actor, visual, rig)
|
|
_add_region_hp_bar(recruit_id, actor, int(region_display_hp.get(recruit_id, record.current_hp)), int(record.max_hp), false)
|
|
var all_enemies: Array = run.pending_encounter.enemy_ids
|
|
var enemies: Array = region_motion.visible_enemy_ids.duplicate()
|
|
var enemy_spacing := minf(actor_size + 8.0, size.x * 0.30 / maxf(1.0, float(all_enemies.size() - 1)))
|
|
for index in range(enemies.size()):
|
|
var enemy_id := String(enemies[index])
|
|
var base := Vector2(size.x * 0.52 + index * enemy_spacing, ally_y - 8)
|
|
var visual: Dictionary = region_motion.enemy_visual(enemy_id, region_motion_clock, reduced_motion, low_power)
|
|
_add_ground_ring(base + Vector2((actor_size + 6) * 0.5, actor_size + 3), actor_size * 0.66, CORAL, "P101BattleEnemyGround_%s" % enemy_id)
|
|
var enemy := _add_actor("Riftblade", base, actor_size + 6, "P101BattleEnemy_%s" % enemy_id, false, String(visual.state))
|
|
enemy.self_modulate = _region_enemy_color(enemy_id)
|
|
enemy.set_meta("base_position", base)
|
|
enemy.set_meta("region_actor_id", enemy_id)
|
|
enemy.set_meta("enemy_actor", true)
|
|
battle_actors[enemy_id] = enemy
|
|
_apply_region_actor_visual(enemy, visual, "Riftblade")
|
|
var name := _outlined_label(_region_name(enemy_id).left(12), 7, CORAL)
|
|
name.name = "P101BattleEnemyName_%s" % enemy_id
|
|
name.position = Vector2(base.x - 12, base.y + actor_size - 2)
|
|
name.size = Vector2(actor_size + 30, 28)
|
|
name.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
|
|
name.set_meta("actor_id", enemy_id)
|
|
display_root.add_child(name)
|
|
|
|
|
|
func _render_region_persistent_feedback() -> void:
|
|
if not region_motion.healing_denied_target.is_empty():
|
|
var tether := ColorRect.new()
|
|
tether.name = "P101HealingDenialTether"
|
|
tether.color = Color(0.70, 0.35, 0.88, 0.78)
|
|
tether.mouse_filter = Control.MOUSE_FILTER_IGNORE
|
|
display_root.add_child(tether)
|
|
var seal := _motion_sprite("P101HealingDenialSeal", PROTECT_ABSORB_VFX, Vector2(32, 32), VIOLET)
|
|
seal.set_meta("target_id", region_motion.healing_denied_target)
|
|
display_root.add_child(seal)
|
|
if region_motion.mud_index >= 0:
|
|
var mud := _motion_sprite("P101IndexedMudMarker", PROTECT_ABSORB_VFX, Vector2(48, 22), Color("#7b8455"))
|
|
mud.set_meta("position_index", region_motion.mud_index)
|
|
display_root.add_child(mud)
|
|
|
|
|
|
func _render_region_motion_effects() -> void:
|
|
var effects: Array[Dictionary] = region_motion.active_effects(region_motion_clock)
|
|
for index in range(effects.size()):
|
|
var effect: Dictionary = effects[index]
|
|
var kind := String(effect.kind)
|
|
var suffix := "%02d_%s" % [index, kind]
|
|
if kind == "allied_basic":
|
|
var source_id := String(effect.get("actor_id", ""))
|
|
var rig := _recruit_rig(source_id)
|
|
var texture := PROTECT_GAIN_VFX if rig in ["Farstring", "Kindhand"] else DAMAGE_VFX
|
|
var projectile := _motion_sprite("P101MotionProjectile_%s" % suffix, texture, Vector2(26, 18), CYAN if rig == "Farstring" else GOLD_LIGHT)
|
|
projectile.set_meta("effect", effect)
|
|
display_root.add_child(projectile)
|
|
elif kind in ["enemy_basic_damage", "authoritative_damage"]:
|
|
var value := _outlined_label("-%d" % int(effect.get("amount", effect.get("damage", 0))), 21, CORAL)
|
|
value.name = "P101MotionDamage_%s" % suffix
|
|
value.size = Vector2(80, 38)
|
|
value.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
|
|
value.mouse_filter = Control.MOUSE_FILTER_IGNORE
|
|
value.z_index = 26
|
|
value.set_meta("effect", effect)
|
|
display_root.add_child(value)
|
|
var impact := _motion_sprite("P101MotionImpact_%s" % suffix, DAMAGE_VFX, Vector2(30, 30), CORAL)
|
|
impact.set_meta("effect", effect)
|
|
display_root.add_child(impact)
|
|
elif kind in ["healing_applied", "healing_converted_to_enemy_guard"]:
|
|
var healing := _motion_sprite("P101MotionHealing_%s" % suffix, PROTECT_GAIN_VFX if kind == "healing_applied" else PROTECT_ABSORB_VFX, Vector2(40, 40), JADE if kind == "healing_applied" else VIOLET)
|
|
healing.set_meta("effect", effect)
|
|
display_root.add_child(healing)
|
|
|
|
|
|
func _motion_sprite(node_name: String, texture: Texture2D, display_size: Vector2, tint: Color) -> Sprite2D:
|
|
var node := Sprite2D.new()
|
|
node.name = node_name
|
|
node.texture = texture
|
|
var source_size := texture.get_size()
|
|
node.scale = Vector2(display_size.x / maxf(1.0, source_size.x), display_size.y / maxf(1.0, source_size.y))
|
|
node.set_meta("base_scale", node.scale)
|
|
node.texture_filter = CanvasItem.TEXTURE_FILTER_NEAREST
|
|
node.self_modulate = tint
|
|
node.z_index = 24
|
|
return node
|
|
|
|
|
|
func _add_region_hp_bar(actor_id: String, actor: TextureRect, hp: int, max_hp: int, enemy: bool) -> void:
|
|
var bar := ColorRect.new()
|
|
bar.name = "P101Hp_%s" % actor_id
|
|
bar.position = Vector2(actor.position.x + 4, actor.position.y - 8)
|
|
bar.size = Vector2(actor.size.x - 8, 5)
|
|
bar.color = Color(0.02, 0.03, 0.05, 0.88)
|
|
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), 3)
|
|
fill.color = CORAL if enemy else JADE
|
|
fill.mouse_filter = Control.MOUSE_FILTER_IGNORE
|
|
bar.add_child(fill)
|
|
bar.set_meta("actor_id", actor_id)
|
|
battle_hp_bars[actor_id] = bar
|
|
|
|
|
|
func _render_region_event_feedback() -> void:
|
|
var latest: Dictionary = region_recent_events[-1] if not region_recent_events.is_empty() else {}
|
|
var kind := String(latest.get("kind", "battle_started"))
|
|
var feedback := _outlined_label(_region_event_text(latest), 17, _region_event_color(kind))
|
|
feedback.name = "P101BattleFeedback"
|
|
feedback.position = Vector2(size.x * 0.29, 92)
|
|
feedback.size = Vector2(size.x * 0.42, 62)
|
|
feedback.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
|
|
feedback.autowrap_mode = TextServer.AUTOWRAP_WORD_SMART
|
|
display_root.add_child(feedback)
|
|
|
|
|
|
func _render_region_battle_result() -> void:
|
|
var victory := String(region_battle_snapshot.outcome) == "victory"
|
|
var band := ColorRect.new()
|
|
band.name = "P101BattleResultBand"
|
|
band.position = Vector2(0, size.y - 70)
|
|
band.size = Vector2(size.x, 70)
|
|
band.color = Color(0.015, 0.035, 0.075, 0.96)
|
|
band.mouse_filter = Control.MOUSE_FILTER_IGNORE
|
|
display_root.add_child(band)
|
|
var result := _outlined_label(
|
|
_tr("穿越成功 · ◆+%d" % int(region_battle_snapshot.reward_coin), "CROSSING WON · ◆+%d" % int(region_battle_snapshot.reward_coin)) if victory else _tr("穿越失败 · 永久阵亡 %d" % region_battle_snapshot.fallen_recruit_ids.size(), "CROSSING LOST · PERMANENT FALLEN %d" % region_battle_snapshot.fallen_recruit_ids.size()),
|
|
19,
|
|
GOLD_LIGHT if victory else CORAL
|
|
)
|
|
result.position = Vector2(16, size.y - 66)
|
|
result.size = Vector2(size.x - 250, 56)
|
|
display_root.add_child(result)
|
|
var settle := _action_button("P101SettleButton", _tr("确认结果", "SETTLE RESULT"), settle_region_battle)
|
|
settle.position = Vector2(size.x - 222, size.y - 61)
|
|
settle.size = Vector2(206, 50)
|
|
display_root.add_child(settle)
|
|
|
|
|
|
func _render_region_recovery() -> void:
|
|
_add_siltwake_world()
|
|
var run: Dictionary = region_market.state.current_run
|
|
var report: Dictionary = run.last_battle_report
|
|
_add_header(_tr("幸存者回到渡口", "SURVIVORS RETURN TO THE FERRY"), _tr("◆%d 救援费用 ◆%d" % [run.coin, run.recovery_cost], "◆%d RECOVERY ◆%d" % [run.coin, run.recovery_cost]))
|
|
var title := _outlined_label(_tr("阵亡不会复活", "THE FALLEN DO NOT RETURN"), 26, CORAL)
|
|
title.position = Vector2(size.x * 0.12, 74)
|
|
title.size = Vector2(size.x * 0.76, 52)
|
|
title.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
|
|
display_root.add_child(title)
|
|
var body := _outlined_label(_tr("错误应对让队伍在换潮时失去治疗窗口。支付救援费可让幸存者恢复至40%%，回到同一集市重新整备。", "THE RESPONSE LOST THE HEALING WINDOW AT THE TIDE SHIFT. PAY TO RESTORE SURVIVORS TO 40%% AND REPREPARE THE SAME MARKET."), 12, WHITE)
|
|
body.position = Vector2(size.x * 0.18, 126)
|
|
body.size = Vector2(size.x * 0.64, 76)
|
|
body.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
|
|
body.autowrap_mode = TextServer.AUTOWRAP_WORD_SMART
|
|
display_root.add_child(body)
|
|
_render_survivor_row(Vector2(size.x * 0.30, size.y * 0.54), 70)
|
|
var fallen_count: int = report.get("fallen_recruit_ids", []).size()
|
|
var fallen := _outlined_label(_tr("永久阵亡：%d人" % fallen_count, "PERMANENT FALLEN: %d" % fallen_count), 10, CORAL)
|
|
fallen.position = Vector2(18, size.y - 60)
|
|
fallen.size = Vector2(size.x - 260, 48)
|
|
display_root.add_child(fallen)
|
|
var recover := _action_button("P101RecoverButton", _tr("支付 ◆%d 救援" % run.recovery_cost, "PAY ◆%d TO RECOVER" % run.recovery_cost), recover_region_company)
|
|
recover.position = Vector2(size.x - 232, size.y - 62)
|
|
recover.size = Vector2(216, 52)
|
|
recover.disabled = int(run.coin) < int(run.recovery_cost)
|
|
display_root.add_child(recover)
|
|
|
|
|
|
func _render_region_market_2() -> void:
|
|
_add_siltwake_world()
|
|
var run: Dictionary = region_market.state.current_run
|
|
var handoff: Dictionary = run.market_2_handoff
|
|
_add_header(_tr("淤潮地 · 集市 2", "SILTWAKE · MARKET 2"), _tr("◆%d 已保存" % run.coin, "◆%d SAVED" % run.coin))
|
|
_render_survivor_row(Vector2(size.x * 0.12, size.y * 0.43), 78)
|
|
var title := _outlined_label(_tr("第一道水路已穿越", "FIRST CROSSING COMPLETE"), 27, GOLD_LIGHT)
|
|
title.position = Vector2(size.x * 0.47, size.y * 0.24)
|
|
title.size = Vector2(size.x * 0.46, 62)
|
|
title.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
|
|
display_root.add_child(title)
|
|
var body := _outlined_label(_tr("奖励 ◆%d 已结算一次。队伍、生命、装备与前后顺序已写入 Save v7；后续集市尚未开放。" % int(handoff.get("reward_coin", 0)), "REWARD ◆%d SETTLED ONCE. COMPANY, VITALITY, GEAR AND ORDER ARE SAVED IN V7; LATER MARKETS ARE NOT OPEN YET." % int(handoff.get("reward_coin", 0))), 12, WHITE)
|
|
body.position = Vector2(size.x * 0.49, size.y * 0.40)
|
|
body.size = Vector2(size.x * 0.42, 100)
|
|
body.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
|
|
body.autowrap_mode = TextServer.AUTOWRAP_WORD_SMART
|
|
display_root.add_child(body)
|
|
var seal := _outlined_label(_tr("MARKET 2 · 存档完成", "MARKET 2 · SAVE COMPLETE"), 14, JADE)
|
|
seal.position = Vector2(size.x * 0.55, size.y - 76)
|
|
seal.size = Vector2(size.x * 0.34, 48)
|
|
seal.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
|
|
display_root.add_child(seal)
|
|
|
|
|
|
func _render_survivor_row(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 + 10), 0), actor_size, "P101Survivor_%s" % recruit_id, true, "victory" if screen == REGION_SCREEN_MARKET_2 else "idle")
|
|
actor.self_modulate = _p100_profession_color(String(record.profession_id))
|
|
|
|
|
|
func _add_siltwake_world() -> void:
|
|
_add_background(WINDGLASS_BACKGROUND)
|
|
var wash := ColorRect.new()
|
|
wash.name = "P101WaterLayer"
|
|
wash.position = Vector2(0, 50)
|
|
wash.size = Vector2(size.x, size.y - 50)
|
|
wash.color = Color(0.03, 0.22, 0.24, 0.36)
|
|
wash.mouse_filter = Control.MOUSE_FILTER_IGNORE
|
|
display_root.add_child(wash)
|
|
for index in range(4):
|
|
var channel := ColorRect.new()
|
|
channel.name = "P101Channel_%d" % (index + 1)
|
|
channel.position = Vector2(size.x * (0.18 + 0.17 * index), 52)
|
|
channel.size = Vector2(3, size.y - 116)
|
|
channel.color = Color(0.55, 0.92, 0.88, 0.24)
|
|
channel.mouse_filter = Control.MOUSE_FILTER_IGNORE
|
|
display_root.add_child(channel)
|
|
for index in range(7):
|
|
var reed := ColorRect.new()
|
|
reed.name = "P101ReedLayer_%d" % index
|
|
reed.position = Vector2(8 + index * (size.x - 26) / 6.0, size.y - 106 - (index % 3) * 10)
|
|
reed.size = Vector2(3, 42 + (index % 3) * 9)
|
|
reed.color = Color("#99c66b")
|
|
reed.mouse_filter = Control.MOUSE_FILTER_IGNORE
|
|
display_root.add_child(reed)
|
|
var bank := ColorRect.new()
|
|
bank.name = "P101ForegroundBank"
|
|
bank.position = Vector2(0, size.y - 68)
|
|
bank.size = Vector2(size.x, 68)
|
|
bank.color = Color(0.08, 0.13, 0.10, 0.48)
|
|
bank.mouse_filter = Control.MOUSE_FILTER_IGNORE
|
|
display_root.add_child(bank)
|
|
|
|
|
|
func _render_tide_notches(tide: Dictionary, tick: int) -> void:
|
|
var current := int(tide.current_safe_index) if tick < int(tide.shift_tick) else int(tide.next_safe_index)
|
|
var next := int(tide.next_safe_index)
|
|
var x0 := size.x * 0.40
|
|
var spacing := minf(54.0, size.x * 0.25 / 4.0)
|
|
for index in range(1, 5):
|
|
var notch := ColorRect.new()
|
|
notch.name = "P101TideNotch_%d" % index
|
|
notch.position = Vector2(x0 + (index - 1) * spacing, 55)
|
|
notch.size = Vector2(spacing - 8, 5)
|
|
notch.color = GOLD if index == current else CYAN if index == next else Color(0.7, 0.8, 0.8, 0.30)
|
|
notch.mouse_filter = Control.MOUSE_FILTER_IGNORE
|
|
display_root.add_child(notch)
|
|
|
|
|
|
func _animate_region_battle_actors() -> void:
|
|
if screen != REGION_SCREEN_BATTLE:
|
|
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 rig := String(actor.get_meta("rig", "Hearthguard"))
|
|
var visual: Dictionary
|
|
if bool(actor.get_meta("enemy_actor", false)):
|
|
visual = region_motion.enemy_visual(String(actor_id), region_motion_clock, reduced_motion, low_power)
|
|
else:
|
|
visual = region_motion.actor_visual(
|
|
String(actor_id),
|
|
int(actor.get_meta("slot_index", 0)),
|
|
float(actor.get_meta("slot_step", -68.0)),
|
|
region_motion_clock,
|
|
reduced_motion,
|
|
low_power
|
|
)
|
|
_apply_region_actor_visual(actor, visual, rig)
|
|
if battle_hp_bars.has(actor_id):
|
|
var bar: ColorRect = battle_hp_bars[actor_id]
|
|
bar.position = Vector2(actor.position.x + 4, actor.position.y - 8)
|
|
bar.modulate.a = float(visual.alpha)
|
|
var enemy_name := display_root.find_child("P101BattleEnemyName_%s" % String(actor_id), false, false) as Label
|
|
if enemy_name != null:
|
|
enemy_name.position = Vector2(actor.position.x - 12, actor.position.y + actor.size.y - 2)
|
|
enemy_name.modulate.a = float(visual.alpha)
|
|
_animate_region_persistent_feedback()
|
|
_animate_region_motion_effects()
|
|
|
|
|
|
func _apply_region_actor_visual(actor: TextureRect, visual: Dictionary, rig: String) -> void:
|
|
var camera: Vector2 = region_motion.camera_offset(region_motion_clock, reduced_motion, low_power)
|
|
actor.position = Vector2(actor.get_meta("base_position")) + Vector2(visual.offset) + camera
|
|
actor.pivot_offset = actor.size * 0.5
|
|
actor.scale = Vector2(visual.scale)
|
|
actor.rotation = float(visual.rotation)
|
|
actor.modulate.a = float(visual.alpha)
|
|
var semantic_state := String(visual.state)
|
|
var animation_state := semantic_state if rig == "Riftblade" else _motion_actor_animation(rig, semantic_state)
|
|
actor.set_meta("animation_state", animation_state)
|
|
actor.set_meta("motion_state", semantic_state)
|
|
actor.texture = animation.texture(rig, animation_state, float(visual.animation_time))
|
|
|
|
|
|
func _motion_actor_animation(rig: String, semantic_state: String) -> String:
|
|
match semantic_state:
|
|
"attack":
|
|
return {"Hearthguard": "basic_attack", "Wayrunner": "evade_counter", "Farstring": "draw_release", "Kindhand": "lantern_heal"}.get(rig, "idle")
|
|
"heal", "healed":
|
|
return "lantern_heal" if rig == "Kindhand" else "guard" if rig == "Hearthguard" else "idle"
|
|
"hit", "guard":
|
|
return "guard" if rig == "Hearthguard" else "evade_counter" if rig == "Wayrunner" else "idle"
|
|
"victory":
|
|
return {"Hearthguard": "victory", "Wayrunner": "evade_counter", "Farstring": "draw_release", "Kindhand": "lantern_heal"}.get(rig, "idle")
|
|
"fallen":
|
|
return "idle"
|
|
_:
|
|
return semantic_state
|
|
|
|
|
|
func _animate_region_persistent_feedback() -> void:
|
|
var tether := display_root.find_child("P101HealingDenialTether", false, false) as ColorRect
|
|
if tether != null:
|
|
_set_motion_line(tether, _region_actor_center(region_motion.healing_denial_source), _region_actor_center(region_motion.healing_denied_target), 3.0)
|
|
var pulse := 0.72 if low_power else 0.58 + sin(region_motion_clock * 8.0) * 0.18
|
|
tether.modulate.a = pulse
|
|
var seal := display_root.find_child("P101HealingDenialSeal", false, false) as Sprite2D
|
|
if seal != null:
|
|
seal.position = _region_actor_center(String(seal.get_meta("target_id", "")))
|
|
seal.modulate.a = 0.78 if low_power else 0.68 + sin(region_motion_clock * 7.0) * 0.22
|
|
var mud := display_root.find_child("P101IndexedMudMarker", false, false) as Sprite2D
|
|
if mud != null:
|
|
var index := int(mud.get_meta("position_index", 1))
|
|
mud.position = Vector2(size.x * 0.48 - float(index - 1) * 34.0, size.y * 0.67)
|
|
mud.modulate.a = 0.72
|
|
|
|
|
|
func _animate_region_motion_effects() -> void:
|
|
for child in display_root.get_children():
|
|
if not child.has_meta("effect"):
|
|
continue
|
|
var canvas := child as CanvasItem
|
|
if canvas == null:
|
|
continue
|
|
var effect: Dictionary = child.get_meta("effect")
|
|
var duration := maxf(0.01, float(effect.get("duration", 0.78)))
|
|
var progress := clampf((region_motion_clock - float(effect.get("started", region_motion_clock))) / duration, 0.0, 1.0)
|
|
canvas.visible = progress < 1.0
|
|
if not canvas.visible:
|
|
continue
|
|
if child.name.begins_with("P101MotionProjectile"):
|
|
var projectile := child as Sprite2D
|
|
var source := _region_actor_center(String(effect.get("actor_id", "")))
|
|
var target := _region_actor_center(region_motion.front_visible_enemy())
|
|
var flight := clampf(progress / 0.58, 0.0, 1.0)
|
|
projectile.position = source.lerp(target, flight)
|
|
projectile.position.y -= sin(flight * PI) * (3.0 if reduced_motion else 16.0)
|
|
projectile.rotation = (target - source).angle()
|
|
projectile.modulate.a = 1.0 - maxf(0.0, (flight - 0.78) / 0.22)
|
|
elif child.name.begins_with("P101MotionDamage"):
|
|
var damage_label := child as Label
|
|
var target_id := String(effect.get("target_id", ""))
|
|
var center := _region_actor_center(target_id)
|
|
damage_label.position = center + Vector2(-damage_label.size.x * 0.5, -38.0 - progress * (9.0 if reduced_motion else 28.0))
|
|
damage_label.modulate.a = 1.0 - progress
|
|
elif child.name.begins_with("P101MotionImpact"):
|
|
var impact := child as Sprite2D
|
|
var impact_center := _region_actor_center(String(effect.get("target_id", "")))
|
|
impact.position = impact_center
|
|
var pulse := sin(clampf(progress / 0.48, 0.0, 1.0) * PI)
|
|
impact.scale = Vector2(impact.get_meta("base_scale")) * (0.65 + pulse * (0.20 if reduced_motion else 0.70))
|
|
impact.modulate.a = 1.0 - progress
|
|
elif child.name.begins_with("P101MotionHealing"):
|
|
var healing := child as Sprite2D
|
|
var healing_center := _region_actor_center(String(effect.get("target_id", "")))
|
|
healing.position = healing_center + Vector2(0, -progress * (5.0 if reduced_motion else 18.0))
|
|
healing.modulate.a = 1.0 - progress
|
|
|
|
|
|
func _region_actor_center(actor_id: String) -> Vector2:
|
|
if actor_id.is_empty() or not battle_actors.has(actor_id):
|
|
return Vector2(size.x * 0.5, size.y * 0.53)
|
|
var actor: TextureRect = battle_actors[actor_id]
|
|
return actor.position + actor.size * 0.5
|
|
|
|
|
|
func _set_motion_line(line: ColorRect, start: Vector2, finish: Vector2, width: float) -> void:
|
|
var delta := finish - start
|
|
line.position = start
|
|
line.size = Vector2(maxf(1.0, delta.length()), width)
|
|
line.pivot_offset = Vector2(0, width * 0.5)
|
|
line.rotation = delta.angle()
|
|
|
|
|
|
func _region_actor_state(recruit_id: String) -> String:
|
|
if int(region_display_hp.get(recruit_id, 1)) <= 0:
|
|
return "idle"
|
|
if region_recent_events.is_empty():
|
|
return "advance"
|
|
var event: Dictionary = region_recent_events[-1]
|
|
if String(event.get("actor_id", event.get("source_id", ""))) == recruit_id:
|
|
return "draw_release" if _recruit_rig(recruit_id) == "Farstring" else "lantern_heal" if _recruit_rig(recruit_id) == "Kindhand" else "basic_attack"
|
|
return "advance"
|
|
|
|
|
|
func _region_enemy_state(enemy_id: String) -> String:
|
|
if region_recent_events.is_empty():
|
|
return "advance"
|
|
var event: Dictionary = region_recent_events[-1]
|
|
return "attack" if String(event.get("enemy_id", "")) == enemy_id or String(event.kind) in ["enemy_basic_damage", "pull_committed", "healing_denial_attached"] else "advance"
|
|
|
|
|
|
func _region_event_text(event: Dictionary) -> String:
|
|
var kind := String(event.get("kind", "battle_started"))
|
|
return {
|
|
"battle_started": _tr("队伍踏入淤潮水路", "THE COMPANY ENTERS SILTWAKE"),
|
|
"wave_entered": _tr("敌群从芦苇间出现", "A WAVE EMERGES FROM THE REEDS"),
|
|
"healing_denial_attached": _tr("泥灯水蛭封锁治疗", "MUDLAMP LEECH BLOCKS HEALING"),
|
|
"healing_converted_to_enemy_guard": _tr("治疗被转化为敌方护盾", "HEALING BECOMES ENEMY GUARD"),
|
|
"indexed_bank_marked": _tr("堤岸位置被标记", "BANK POSITION MARKED"),
|
|
"pull_committed": _tr("芦钩拉乱了战线", "REED HOOK PULLS THE LINE"),
|
|
"pull_resisted": _tr("队伍抵抗了拉拽", "THE COMPANY RESISTS THE PULL"),
|
|
"indexed_mud_created": _tr("跨位留下减速淤泥", "CROSSING LEAVES HINDERING MUD"),
|
|
"tide_shift_warning": _tr("换潮警告：准备移动", "TIDE WARNING: PREPARE TO MOVE"),
|
|
"tide_followed": _tr("队伍顺潮进入新安全位", "THE COMPANY FOLLOWS THE TIDE"),
|
|
"tide_shifted_while_holding": _tr("队伍留在原地并被潮水浸湿", "THE LINE HOLDS AND BECOMES WET"),
|
|
"allied_basic": _tr("队员发起攻击", "A RECRUIT ATTACKS"),
|
|
"enemy_basic_damage": _tr("敌人击中前线", "THE ENEMY HITS THE FRONT"),
|
|
"authoritative_damage": _tr("结算伤害 -%d" % int(event.get("amount", 0)), "DAMAGE SETTLED -%d" % int(event.get("amount", 0))),
|
|
"recruit_fallen": _tr("一名队员永久阵亡", "A RECRUIT IS PERMANENTLY FALLEN"),
|
|
"battle_terminal": _tr("穿越结果已确定", "THE CROSSING RESULT IS SET"),
|
|
}.get(kind, kind.replace("_", " ").to_upper())
|
|
|
|
|
|
func _region_event_color(kind: String) -> Color:
|
|
if kind in ["healing_denial_attached", "healing_converted_to_enemy_guard", "pull_committed", "indexed_mud_created", "enemy_basic_damage", "authoritative_damage", "recruit_fallen"]:
|
|
return CORAL
|
|
if kind in ["pull_resisted", "tide_followed", "battle_terminal"]:
|
|
return JADE
|
|
return GOLD_LIGHT
|
|
|
|
|
|
func _route_summary(risk: int) -> String:
|
|
return [
|
|
_tr("低风险：拉拽会改变邻位受击；稳住前后顺序更省生命。", "LOW RISK: PULL CHANGES ADJACENCY; A STABLE LINE PRESERVES MORE VITALITY."),
|
|
_tr("中风险：先处理治疗封锁，并等迟滞过半后再净化。", "MEDIUM RISK: REMOVE HEALING DENIAL AND WAIT PAST THE HINDRANCE MIDPOINT."),
|
|
_tr("高风险：换潮时留在原地会失去治疗窗口；顺潮移动更安全。", "HIGH RISK: HOLDING THROUGH THE TIDE LOSES THE HEALING WINDOW; FOLLOWING IT IS SAFER."),
|
|
][clampi(risk, 0, 2)]
|
|
|
|
|
|
func _region_name(row_id: String) -> String:
|
|
if row_id.is_empty():
|
|
return ""
|
|
var regional := RegionContent.localized_name(region_catalog, row_id, locale)
|
|
if not regional.is_empty():
|
|
return regional
|
|
return _row_name(row_id, "equipment" if row_id.begins_with("EQ-") else "enemy")
|
|
|
|
|
|
func _equipment_symbol(catalog_id: String) -> String:
|
|
return {"EQ-041": "▰", "EQ-042": "◒", "EQ-043": "◎", "EQ-044": "⚑", "EQ-045": "Ⅱ", "EQ-046": "+", "EQ-047": "▱", "EQ-048": "◁"}.get(catalog_id, "◇")
|
|
|
|
|
|
func _region_enemy_color(enemy_id: String) -> Color:
|
|
var number := int(enemy_id.trim_prefix("EN-R2-"))
|
|
return [Color("#b5e3b2"), VIOLET, Color("#c6a3de"), Color("#9dbd78"), GOLD_LIGHT, CYAN, CORAL][number % 7]
|