2328 lines
95 KiB
GDScript
2328 lines
95 KiB
GDScript
extends Control
|
||
|
||
const OpeningGuideScript := preload("res://scripts/ui/inn_opening_guide.gd")
|
||
const OperatingLedgerPanelScript := preload("res://scripts/ui/operating_ledger_panel.gd")
|
||
const StaffManagementPanelScript := preload("res://scripts/ui/staff_management_panel.gd")
|
||
const SupplyManagementPanelScript := preload("res://scripts/ui/supply_management_panel.gd")
|
||
const BusinessManagementPanelScript := preload("res://scripts/ui/business_management_panel.gd")
|
||
const WorldPreviewScript := preload("res://scenes/main/world_preview.gd")
|
||
const DefaultVisualTheme := preload("res://assets/themes/japanese_fantasy/visual-theme-v1.tres")
|
||
const MANUAL_SAVE_PATH := "user://saves/manual_ui"
|
||
const MVP_FACILITY_IDS: Array[StringName] = [
|
||
&"reception",
|
||
&"standard_room",
|
||
&"cafeteria",
|
||
&"warehouse",
|
||
&"kitchen",
|
||
&"public_bath",
|
||
&"staff_waiting_room",
|
||
&"security_station",
|
||
&"tavern",
|
||
&"massage_room",
|
||
&"guest_elevator",
|
||
&"service_elevator",
|
||
&"staff_door",
|
||
&"guest_corridor",
|
||
&"service_corridor",
|
||
&"adult_private_room",
|
||
]
|
||
const FACILITY_STATE_NAMES := [
|
||
"故障",
|
||
"到達不能",
|
||
"魔力不足",
|
||
"人員不足",
|
||
"閉鎖中",
|
||
"低下運転",
|
||
"営業中",
|
||
]
|
||
const ELEVATOR_PHASE_NAMES := {&"IDLE": "待機", &"PICKUP": "迎車中", &"BOARDING": "乗車中", &"TRAVEL": "運行中", &"ALIGHTING": "降車中"}
|
||
const FACILITY_REASON_NAMES := {
|
||
&"BROKEN": "故障",
|
||
&"NO_ACCESS": "経路なし",
|
||
&"NO_POWER": "魔力供給なし",
|
||
&"NO_STAFF": "必要人員不足",
|
||
&"CLOSED_BY_OPERATOR": "手動閉鎖",
|
||
&"OUTSIDE_OPENING_HOURS": "営業時間外",
|
||
&"LOW_DURABILITY": "耐久度低下",
|
||
}
|
||
const PREVIEW_REASON_NAMES := {
|
||
"INVALID_DEFINITION": "施設データが不正です",
|
||
"MISSING_DEPENDENCY": "建設システムを利用できません",
|
||
"OUT_OF_BOUNDS": "世界の範囲外です",
|
||
"ZONE_MISMATCH": "地上・境界・地下の条件が合いません",
|
||
"LAYER_MISMATCH": "表層／裏層が合いません",
|
||
"OVERLAP": "ほかの施設または工事と重なります",
|
||
"UNSUPPORTED": "構造を支えられません",
|
||
"INSUFFICIENT_RESOURCES": "建設資源が不足しています",
|
||
}
|
||
const EXCAVATION_REASON_NAMES := {
|
||
&"OUT_OF_BOUNDS": "世界の範囲外です",
|
||
&"NOT_UNDERGROUND": "地下のマスだけ掘削できます",
|
||
&"ALREADY_EXCAVATED": "すでに掘削済みです",
|
||
&"ALREADY_RESERVED": "このマスは掘削中です",
|
||
&"NO_EXCAVATED_NEIGHBOR": "掘削済みの隣接マスから延ばしてください",
|
||
&"NO_ENTRANCE_CONNECTION": "地上入口までつながる経路がありません",
|
||
&"SUPPORT_REQUIRED": "硬い地盤を支える補強施設が必要です",
|
||
&"INSUFFICIENT_RESOURCES": "掘削資源が不足しています",
|
||
&"MISSING_DEPENDENCY": "掘削システムを利用できません",
|
||
}
|
||
const EVENT_CHOICE_NAMES := {
|
||
&"event.relationship.threshold.acknowledge": "向き合う",
|
||
&"event.relationship.threshold.defer": "今は保留する",
|
||
}
|
||
const STAFF_ROLE_NAMES := {
|
||
&"attendant": "接客",
|
||
&"bartender": "酒場",
|
||
&"clerk": "会計",
|
||
&"cleaner": "清掃",
|
||
&"cook": "調理",
|
||
&"guard": "警備",
|
||
&"maintenance": "保守",
|
||
&"masseur": "施術",
|
||
&"medic": "医療",
|
||
&"porter": "物流",
|
||
&"receptionist": "受付",
|
||
}
|
||
const STAFF_SHIFT_NAMES := {
|
||
&"day": "日勤",
|
||
&"night": "夜勤",
|
||
&"any": "柔軟勤務",
|
||
}
|
||
const STAFF_SKILL_NAMES := {
|
||
&"service": "接客",
|
||
&"operation": "運営",
|
||
&"combat": "戦闘",
|
||
&"underworld": "裏社会",
|
||
}
|
||
|
||
@export var visual_theme: VisualThemeProfile = DefaultVisualTheme
|
||
var manual_save_path := MANUAL_SAVE_PATH
|
||
|
||
var time_label: Label
|
||
var phase_label: Label
|
||
var guest_count_label: Label
|
||
var lodging_count_label: Label
|
||
var alert_count_label: Label
|
||
var alert_icon_node: TextureRect
|
||
var resource_labels: Dictionary = {}
|
||
var resource_icon_nodes: Dictionary = {}
|
||
var world_preview: WorldPreview
|
||
var front_button: Button
|
||
var back_button: Button
|
||
var excavation_button: Button
|
||
var pause_button: Button
|
||
var speed_buttons: Dictionary = {}
|
||
var dashboard_summary_label: Label
|
||
var foreground_event_panel: VBoxContainer
|
||
var foreground_event_label: Label
|
||
var foreground_event_choices: VBoxContainer
|
||
var staff_management_panel: VBoxContainer
|
||
var staff_management_toggle_button: Button
|
||
var _staff_management_panel_open := false
|
||
var staff_candidate_panel: VBoxContainer
|
||
var staff_candidate_summary_label: Label
|
||
var staff_candidate_toggle_button: Button
|
||
var staff_candidate_buttons: Dictionary = {}
|
||
var selected_heading_label: Label
|
||
var selected_detail_label: Label
|
||
var selected_entity_icon: TextureRect
|
||
var selected_elevator_controls: VBoxContainer
|
||
var elevator_operation_button: Button
|
||
var elevator_operation_hint: Label
|
||
var build_status_label: Label
|
||
var build_buttons: Dictionary = {}
|
||
var navigation_buttons: Dictionary = {}
|
||
var opening_guide: Control
|
||
var operating_ledger_panel: VBoxContainer
|
||
var supply_management_panel: VBoxContainer
|
||
var business_management_panel: VBoxContainer
|
||
var _business_panel_open := false
|
||
var _supply_panel_open := false
|
||
var operations_controls: VBoxContainer
|
||
var _ledger_panel_open := false
|
||
var management_panel: Control
|
||
var management_toggle_button: Button
|
||
var palette_scroll: ScrollContainer
|
||
var palette_toggle_button: Button
|
||
var _management_panel_open := false
|
||
var _build_palette_open := false
|
||
|
||
var _runtime: Variant = null
|
||
var _selected_entity_id: StringName = &""
|
||
var _selected_entity_kind: StringName = &""
|
||
var _selected_definition_id: StringName = &""
|
||
var _selected_definition: Variant = null
|
||
var _build_rotation := 0
|
||
var _build_sequence := 1
|
||
var _excavation_sequence := 1
|
||
var _hire_sequence := 1
|
||
var _elevator_sequence := 1
|
||
var _pending_elevator_commands: Dictionary = {}
|
||
var _pending_build_commands: Dictionary = {}
|
||
var _excavation_mode := false
|
||
var _pending_excavation_commands: Dictionary = {}
|
||
var _pending_hire_commands: Dictionary = {}
|
||
var _staff_candidate_panel_open := false
|
||
var _operations_start_report: Dictionary = {}
|
||
|
||
|
||
func _ready() -> void:
|
||
_runtime = get_node_or_null("/root/SimulationRuntime")
|
||
_pause_fresh_opening()
|
||
if _runtime != null and _runtime.has_method("enable_production_save_policy"):
|
||
_runtime.enable_production_save_policy()
|
||
if _runtime != null \
|
||
and _runtime.has_method("get_operations_report") \
|
||
and _runtime.has_method("enable_production_operations"):
|
||
var current_operations: Dictionary = _runtime.call(&"get_operations_report")
|
||
if not bool(current_operations.get(&"enabled", false)):
|
||
_operations_start_report = _runtime.call(&"enable_production_operations")
|
||
_synchronize_ui_command_state()
|
||
_build_interface()
|
||
_connect_signals()
|
||
_populate_build_palette()
|
||
_populate_staff_candidates()
|
||
_on_time_changed(GameClock.day, GameClock.get_hour(), GameClock.get_minute())
|
||
_on_phase_changed(GameClock.get_phase())
|
||
for resource_name: StringName in GameState.resources:
|
||
_on_resource_changed(resource_name, GameState.get_resource(resource_name))
|
||
_set_layer(GameState.active_layer)
|
||
_update_pause_and_speed()
|
||
_refresh_dashboard()
|
||
if not _operations_start_report.is_empty() \
|
||
and not bool(_operations_start_report.get(&"ok", false)):
|
||
_set_status(
|
||
"本番運営を開始できませんでした: %s" % _result_message(_operations_start_report),
|
||
false
|
||
)
|
||
|
||
|
||
func _pause_fresh_opening() -> void:
|
||
if _runtime == null or GameClock.absolute_minute != 360:
|
||
return
|
||
if not (_runtime.get(&"latest_restore_safety_report") as Dictionary).is_empty():
|
||
return
|
||
var operations: Dictionary = _runtime.call(&"get_operations_report")
|
||
if bool(operations.get(&"enabled", false)):
|
||
return
|
||
if not _call_array(_service(&"construction_service"), &"get_facilities").is_empty() \
|
||
or not _call_array(_service(&"construction_service"), &"get_jobs").is_empty() \
|
||
or not _call_array(_service(&"staff_service"), &"get_staff_members").is_empty():
|
||
return
|
||
var queue: Variant = _runtime.get(&"command_queue")
|
||
if queue != null and not queue.get_accepted_command_metadata().is_empty():
|
||
return
|
||
GameClock.set_paused(true)
|
||
|
||
|
||
func _unhandled_key_input(event: InputEvent) -> void:
|
||
if not event.pressed or event.echo:
|
||
return
|
||
var handled := true
|
||
match event.keycode:
|
||
KEY_ESCAPE:
|
||
_clear_active_tool()
|
||
KEY_E:
|
||
_toggle_excavation_mode()
|
||
KEY_H:
|
||
_toggle_staff_candidate_panel()
|
||
KEY_B:
|
||
_toggle_build_palette()
|
||
KEY_I:
|
||
_set_management_panel_open(not _management_panel_open)
|
||
KEY_SPACE:
|
||
_toggle_pause()
|
||
KEY_TAB:
|
||
_set_layer(1 - world_preview.layer_mode)
|
||
KEY_1:
|
||
_set_speed(1)
|
||
KEY_2:
|
||
_set_speed(2)
|
||
KEY_4:
|
||
_set_speed(4)
|
||
KEY_R:
|
||
if _selected_definition == null:
|
||
handled = false
|
||
else:
|
||
_rotate_build_preview()
|
||
_:
|
||
handled = false
|
||
if handled:
|
||
get_viewport().set_input_as_handled()
|
||
|
||
|
||
func _build_interface() -> void:
|
||
var background := ColorRect.new()
|
||
background.color = _visual_color(&"window_background", Color("24170f"))
|
||
background.set_anchors_and_offsets_preset(Control.PRESET_FULL_RECT)
|
||
background.mouse_filter = Control.MOUSE_FILTER_IGNORE
|
||
add_child(background)
|
||
|
||
var root_margin := MarginContainer.new()
|
||
root_margin.add_theme_constant_override("margin_left", 6)
|
||
root_margin.add_theme_constant_override("margin_top", 6)
|
||
root_margin.add_theme_constant_override("margin_right", 6)
|
||
root_margin.add_theme_constant_override("margin_bottom", 6)
|
||
root_margin.set_anchors_and_offsets_preset(Control.PRESET_FULL_RECT)
|
||
add_child(root_margin)
|
||
|
||
var layout := VBoxContainer.new()
|
||
layout.add_theme_constant_override("separation", 4)
|
||
root_margin.add_child(layout)
|
||
layout.add_child(_create_top_bar())
|
||
|
||
var content := HBoxContainer.new()
|
||
content.name = "MainContent"
|
||
content.size_flags_vertical = Control.SIZE_EXPAND_FILL
|
||
content.add_theme_constant_override("separation", 4)
|
||
layout.add_child(content)
|
||
content.add_child(_create_navigation_rail())
|
||
|
||
var map_panel := PanelContainer.new()
|
||
map_panel.name = "MapPanel"
|
||
map_panel.size_flags_horizontal = Control.SIZE_EXPAND_FILL
|
||
map_panel.size_flags_vertical = Control.SIZE_EXPAND_FILL
|
||
map_panel.add_theme_stylebox_override(
|
||
"panel",
|
||
_themed_panel_style(&"panel_outer", _visual_color(&"window_background", Color("1e1712")), _visual_color(&"border_gold", Color("9b6a32")), 8, 5)
|
||
)
|
||
content.add_child(map_panel)
|
||
world_preview = WorldPreviewScript.new()
|
||
world_preview.name = "WorldPreview"
|
||
world_preview.custom_minimum_size = Vector2(600, 380)
|
||
world_preview.size_flags_horizontal = Control.SIZE_EXPAND_FILL
|
||
world_preview.size_flags_vertical = Control.SIZE_EXPAND_FILL
|
||
world_preview.set_visual_theme(visual_theme)
|
||
map_panel.add_child(world_preview)
|
||
opening_guide = OpeningGuideScript.new()
|
||
world_preview.add_child(opening_guide)
|
||
opening_guide.setup(_runtime, GameClock)
|
||
opening_guide.position = Vector2(8, 8)
|
||
opening_guide.size = Vector2(302, 0)
|
||
opening_guide.action_requested.connect(_on_opening_action)
|
||
# The inspector overlays the map only when requested, leaving the full
|
||
# cross-section available while watching the simulation.
|
||
management_panel = _create_side_panel()
|
||
world_preview.add_child(management_panel)
|
||
management_panel.set_anchors_and_offsets_preset(Control.PRESET_RIGHT_WIDE)
|
||
management_panel.offset_left = -320
|
||
management_panel.offset_right = -8
|
||
management_panel.offset_top = 8
|
||
management_panel.offset_bottom = -8
|
||
management_panel.visible = false
|
||
|
||
layout.add_child(_create_bottom_bar())
|
||
|
||
|
||
func _create_top_bar() -> Control:
|
||
var panel := PanelContainer.new()
|
||
panel.name = "TopBar"
|
||
panel.custom_minimum_size.y = 46
|
||
panel.add_theme_stylebox_override("panel", _themed_panel_style(&"panel_wood", _visual_color(&"dark_panel", Color("6b3e1d")), _visual_color(&"border_gold", Color("d5a552")), 8, 8))
|
||
var row := HBoxContainer.new()
|
||
row.add_theme_constant_override("separation", 7)
|
||
panel.add_child(row)
|
||
|
||
var title_box := VBoxContainer.new()
|
||
title_box.add_theme_constant_override("separation", 0)
|
||
row.add_child(title_box)
|
||
var title := Label.new()
|
||
title.text = "THE TREE"
|
||
title.custom_minimum_size.x = 98
|
||
title.add_theme_font_size_override("font_size", 17)
|
||
title.add_theme_color_override("font_color", Color("fff0c8"))
|
||
title_box.add_child(title)
|
||
var subtitle := Label.new()
|
||
subtitle.text = "世界樹の宿"
|
||
subtitle.add_theme_font_size_override("font_size", 10)
|
||
subtitle.add_theme_color_override("font_color", Color("e5c992"))
|
||
title_box.add_child(subtitle)
|
||
|
||
row.add_child(VSeparator.new())
|
||
time_label = Label.new()
|
||
time_label.custom_minimum_size.x = 104
|
||
time_label.add_theme_font_size_override("font_size", 12)
|
||
time_label.add_theme_color_override("font_color", Color("fff5d9"))
|
||
row.add_child(time_label)
|
||
phase_label = Label.new()
|
||
phase_label.custom_minimum_size.x = 48
|
||
phase_label.add_theme_font_size_override("font_size", 12)
|
||
phase_label.add_theme_color_override("font_color", Color("ffd37a"))
|
||
row.add_child(phase_label)
|
||
|
||
guest_count_label = _hud_value_label("来客 0人", 72)
|
||
lodging_count_label = _hud_value_label("宿泊 0人", 72)
|
||
row.add_child(guest_count_label)
|
||
row.add_child(lodging_count_label)
|
||
for resource_name: StringName in [&"gold", &"mana", &"materials", &"faith"]:
|
||
var resource_block := HBoxContainer.new()
|
||
resource_block.add_theme_constant_override("separation", 2)
|
||
var resource_icon := TextureRect.new()
|
||
resource_icon.name = "%sIcon" % String(resource_name).capitalize()
|
||
resource_icon.texture = visual_theme.resource_icon(resource_name) if visual_theme != null else null
|
||
resource_icon.custom_minimum_size = Vector2(16, 16)
|
||
resource_icon.expand_mode = TextureRect.EXPAND_IGNORE_SIZE
|
||
resource_icon.stretch_mode = TextureRect.STRETCH_KEEP_ASPECT_CENTERED
|
||
resource_icon.mouse_filter = Control.MOUSE_FILTER_IGNORE
|
||
resource_icon_nodes[resource_name] = resource_icon
|
||
resource_block.add_child(resource_icon)
|
||
var label := _hud_value_label("", 54)
|
||
label.horizontal_alignment = HORIZONTAL_ALIGNMENT_RIGHT
|
||
resource_labels[resource_name] = label
|
||
resource_block.add_child(label)
|
||
row.add_child(resource_block)
|
||
alert_count_label = _hud_value_label("警戒 0", 64)
|
||
alert_count_label.add_theme_color_override("font_color", Color("ffb095"))
|
||
alert_icon_node = _icon_rect(visual_theme.control_icon(&"alert") if visual_theme != null else null, 20)
|
||
alert_icon_node.name = "AlertIcon"
|
||
row.add_child(alert_icon_node)
|
||
row.add_child(alert_count_label)
|
||
var spacer := Control.new()
|
||
spacer.size_flags_horizontal = Control.SIZE_EXPAND_FILL
|
||
row.add_child(spacer)
|
||
pause_button = _button("停止", _toggle_pause, 52)
|
||
row.add_child(pause_button)
|
||
for value: int in [1, 2, 4]:
|
||
var speed_button := _button("x%d" % value, _set_speed.bind(value), 42)
|
||
speed_button.toggle_mode = true
|
||
speed_buttons[value] = speed_button
|
||
row.add_child(speed_button)
|
||
return panel
|
||
|
||
|
||
func _create_navigation_rail() -> Control:
|
||
var panel := PanelContainer.new()
|
||
panel.name = "NavigationRail"
|
||
panel.custom_minimum_size.x = 64
|
||
panel.size_flags_vertical = Control.SIZE_EXPAND_FILL
|
||
panel.add_theme_stylebox_override("panel", _themed_panel_style(&"panel_leather", _visual_color(&"dark_panel_alt", Color("513018")), _visual_color(&"border_gold", Color("bd8540")), 8, 7))
|
||
var column := VBoxContainer.new()
|
||
column.add_theme_constant_override("separation", 4)
|
||
panel.add_child(column)
|
||
var entries := [
|
||
[&"staff", "従業員"],
|
||
[&"facility", "施設"],
|
||
[&"product", "商品"],
|
||
[&"business", "営業"],
|
||
[&"explore", "探索"],
|
||
[&"investment", "投資"],
|
||
[&"ledger", "帳簿"],
|
||
]
|
||
for entry: Array in entries:
|
||
var mode := StringName(entry[0])
|
||
var button := _button(String(entry[1]), _activate_management_mode.bind(mode), 50)
|
||
button.custom_minimum_size.y = 46
|
||
button.toggle_mode = true
|
||
button.add_theme_font_size_override("font_size", 12)
|
||
_apply_button_icon(button, visual_theme.navigation_icon(&"ledger" if mode == &"business" else mode) if visual_theme != null else null, 16)
|
||
navigation_buttons[mode] = button
|
||
column.add_child(button)
|
||
var nav_spacer := Control.new()
|
||
nav_spacer.size_flags_vertical = Control.SIZE_EXPAND_FILL
|
||
column.add_child(nav_spacer)
|
||
var layer_hint := Label.new()
|
||
layer_hint.text = "TAB\n表 / 裏"
|
||
layer_hint.tooltip_text = "ホイール: 拡大縮小\n中ボタンドラッグ: 移動\nHome: 全体表示"
|
||
layer_hint.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
|
||
layer_hint.add_theme_font_size_override("font_size", 10)
|
||
layer_hint.add_theme_color_override("font_color", Color("e2c38c"))
|
||
column.add_child(layer_hint)
|
||
return panel
|
||
|
||
|
||
func _create_side_panel() -> Control:
|
||
var panel := PanelContainer.new()
|
||
panel.name = "SidePanel"
|
||
panel.custom_minimum_size.x = 312
|
||
panel.size_flags_vertical = Control.SIZE_EXPAND_FILL
|
||
panel.add_theme_stylebox_override("panel", _themed_panel_style(&"panel_parchment", _visual_color(&"light_panel", Color("f4e3bd")), _visual_color(&"border_gold", Color("a96f2f")), 8, 10))
|
||
var scroll := ScrollContainer.new()
|
||
scroll.horizontal_scroll_mode = ScrollContainer.SCROLL_MODE_DISABLED
|
||
scroll.size_flags_vertical = Control.SIZE_EXPAND_FILL
|
||
panel.add_child(scroll)
|
||
var column := VBoxContainer.new()
|
||
column.custom_minimum_size.x = 278
|
||
column.size_flags_horizontal = Control.SIZE_EXPAND_FILL
|
||
column.add_theme_constant_override("separation", 8)
|
||
scroll.add_child(column)
|
||
var root_column := column
|
||
|
||
var inspector_heading := HBoxContainer.new()
|
||
var inspector_title := _section_heading("運営状況")
|
||
inspector_title.size_flags_horizontal = Control.SIZE_EXPAND_FILL
|
||
inspector_heading.add_child(inspector_title)
|
||
inspector_heading.add_child(_button("閉じる I", _set_management_panel_open.bind(false), 64))
|
||
column.add_child(inspector_heading)
|
||
dashboard_summary_label = Label.new()
|
||
dashboard_summary_label.autowrap_mode = TextServer.AUTOWRAP_WORD_SMART
|
||
dashboard_summary_label.add_theme_color_override("font_color", Color("4d341f"))
|
||
dashboard_summary_label.add_theme_font_size_override("font_size", 13)
|
||
column.add_child(dashboard_summary_label)
|
||
foreground_event_panel = VBoxContainer.new()
|
||
foreground_event_panel.name = "ForegroundEventPanel"
|
||
foreground_event_panel.add_theme_constant_override("separation", 6)
|
||
foreground_event_panel.visible = false
|
||
column.add_child(foreground_event_panel)
|
||
foreground_event_panel.add_child(_section_heading("要対応イベント"))
|
||
foreground_event_label = Label.new()
|
||
foreground_event_label.autowrap_mode = TextServer.AUTOWRAP_WORD_SMART
|
||
foreground_event_label.add_theme_color_override("font_color", Color("8f3f29"))
|
||
foreground_event_label.add_theme_font_size_override("font_size", 13)
|
||
foreground_event_panel.add_child(foreground_event_label)
|
||
foreground_event_choices = VBoxContainer.new()
|
||
foreground_event_choices.name = "ForegroundEventChoices"
|
||
foreground_event_choices.add_theme_constant_override("separation", 5)
|
||
foreground_event_panel.add_child(foreground_event_choices)
|
||
column.add_child(HSeparator.new())
|
||
operations_controls = VBoxContainer.new()
|
||
operations_controls.name = "OperationsControls"
|
||
operations_controls.add_theme_constant_override("separation", 8)
|
||
column.add_child(operations_controls)
|
||
column = operations_controls
|
||
|
||
var candidate_heading_row := HBoxContainer.new()
|
||
candidate_heading_row.add_child(_section_heading("スタッフ"))
|
||
var candidate_heading_spacer := Control.new()
|
||
candidate_heading_spacer.size_flags_horizontal = Control.SIZE_EXPAND_FILL
|
||
candidate_heading_row.add_child(candidate_heading_spacer)
|
||
staff_management_toggle_button = _button("雇用済み", _toggle_staff_management_panel, 62)
|
||
staff_management_toggle_button.name = "StaffManagementToggleButton"
|
||
staff_management_toggle_button.toggle_mode = true
|
||
candidate_heading_row.add_child(staff_management_toggle_button)
|
||
staff_candidate_toggle_button = _button(
|
||
"候補を見る H",
|
||
_toggle_staff_candidate_panel,
|
||
108
|
||
)
|
||
staff_candidate_toggle_button.name = "StaffCandidateToggleButton"
|
||
candidate_heading_row.add_child(staff_candidate_toggle_button)
|
||
column.add_child(candidate_heading_row)
|
||
staff_management_panel = StaffManagementPanelScript.new()
|
||
staff_management_panel.configure(_runtime, _apply_button_style)
|
||
staff_management_panel.status_requested.connect(_on_staff_management_status)
|
||
staff_management_panel.visible = false
|
||
column.add_child(staff_management_panel)
|
||
staff_candidate_panel = VBoxContainer.new()
|
||
staff_candidate_panel.name = "StaffCandidatePanel"
|
||
staff_candidate_panel.visible = false
|
||
staff_candidate_panel.add_theme_constant_override("separation", 7)
|
||
column.add_child(staff_candidate_panel)
|
||
staff_candidate_summary_label = Label.new()
|
||
staff_candidate_summary_label.name = "StaffCandidateSummary"
|
||
staff_candidate_summary_label.autowrap_mode = TextServer.AUTOWRAP_WORD_SMART
|
||
staff_candidate_summary_label.add_theme_color_override("font_color", Color("765438"))
|
||
staff_candidate_summary_label.add_theme_font_size_override("font_size", 12)
|
||
staff_candidate_panel.add_child(staff_candidate_summary_label)
|
||
var candidate_list := VBoxContainer.new()
|
||
candidate_list.name = "StaffCandidateList"
|
||
candidate_list.add_theme_constant_override("separation", 7)
|
||
staff_candidate_panel.add_child(candidate_list)
|
||
column.add_child(HSeparator.new())
|
||
|
||
selected_heading_label = _section_heading("選択中の施設")
|
||
column.add_child(selected_heading_label)
|
||
var selected_row := HBoxContainer.new()
|
||
selected_row.add_theme_constant_override("separation", 8)
|
||
column.add_child(selected_row)
|
||
selected_entity_icon = TextureRect.new()
|
||
selected_entity_icon.name = "SelectedEntityIcon"
|
||
selected_entity_icon.custom_minimum_size = Vector2(24, 24)
|
||
selected_entity_icon.expand_mode = TextureRect.EXPAND_IGNORE_SIZE
|
||
selected_entity_icon.stretch_mode = TextureRect.STRETCH_KEEP_ASPECT_CENTERED
|
||
selected_entity_icon.mouse_filter = Control.MOUSE_FILTER_IGNORE
|
||
selected_row.add_child(selected_entity_icon)
|
||
selected_detail_label = Label.new()
|
||
selected_detail_label.text = "地図上の施設をクリックすると、営業状態を確認できます。"
|
||
selected_detail_label.custom_minimum_size.y = 112
|
||
selected_detail_label.size_flags_horizontal = Control.SIZE_EXPAND_FILL
|
||
selected_detail_label.autowrap_mode = TextServer.AUTOWRAP_WORD_SMART
|
||
selected_detail_label.add_theme_color_override("font_color", Color("4d341f"))
|
||
selected_detail_label.add_theme_font_size_override("font_size", 13)
|
||
selected_row.add_child(selected_detail_label)
|
||
selected_elevator_controls = VBoxContainer.new()
|
||
selected_elevator_controls.name = "SelectedElevatorControls"
|
||
selected_elevator_controls.visible = false
|
||
column.add_child(selected_elevator_controls)
|
||
elevator_operation_button = _button("昇降機を停止", _on_elevator_operation_pressed, 160)
|
||
elevator_operation_button.name = "ElevatorOperationButton"
|
||
selected_elevator_controls.add_child(elevator_operation_button)
|
||
elevator_operation_hint = Label.new()
|
||
elevator_operation_hint.autowrap_mode = TextServer.AUTOWRAP_WORD_SMART
|
||
elevator_operation_hint.add_theme_font_size_override("font_size", 12)
|
||
elevator_operation_hint.add_theme_color_override("font_color", Color("654d37"))
|
||
selected_elevator_controls.add_child(elevator_operation_hint)
|
||
|
||
operating_ledger_panel = OperatingLedgerPanelScript.new()
|
||
root_column.add_child(operating_ledger_panel)
|
||
operating_ledger_panel.setup(_runtime, GameClock)
|
||
operating_ledger_panel.visible = false
|
||
supply_management_panel = SupplyManagementPanelScript.new()
|
||
supply_management_panel.configure(_runtime, _apply_button_style)
|
||
supply_management_panel.status_requested.connect(_on_staff_management_status)
|
||
supply_management_panel.action_requested.connect(_activate_management_mode)
|
||
supply_management_panel.visible = false
|
||
root_column.add_child(supply_management_panel)
|
||
business_management_panel = BusinessManagementPanelScript.new()
|
||
business_management_panel.configure(_runtime, _apply_button_style)
|
||
business_management_panel.status_requested.connect(_on_staff_management_status)
|
||
business_management_panel.action_requested.connect(_activate_management_mode)
|
||
business_management_panel.visible = false
|
||
root_column.add_child(business_management_panel)
|
||
return panel
|
||
|
||
|
||
func _create_bottom_bar() -> Control:
|
||
var panel := PanelContainer.new()
|
||
panel.name = "BottomBar"
|
||
panel.add_theme_stylebox_override("panel", _themed_panel_style(&"panel_wood", _visual_color(&"dark_panel", Color("24382e")), _visual_color(&"border_gold", Color("7d8862")), 0, 5))
|
||
var column := VBoxContainer.new()
|
||
column.add_theme_constant_override("separation", 4)
|
||
panel.add_child(column)
|
||
var row := HBoxContainer.new()
|
||
row.add_theme_constant_override("separation", 5)
|
||
column.add_child(row)
|
||
|
||
palette_toggle_button = _button("建築 B", _toggle_build_palette, 76)
|
||
palette_toggle_button.name = "BuildPaletteToggleButton"
|
||
palette_toggle_button.toggle_mode = true
|
||
row.add_child(palette_toggle_button)
|
||
front_button = _button("客用・表層", _set_layer.bind(0), 96)
|
||
back_button = _button("裏方・裏層", _set_layer.bind(1), 96)
|
||
_apply_button_icon(front_button, visual_theme.control_icon(&"front_layer") if visual_theme != null else null, 16)
|
||
_apply_button_icon(back_button, visual_theme.control_icon(&"back_layer") if visual_theme != null else null, 16)
|
||
front_button.toggle_mode = true
|
||
back_button.toggle_mode = true
|
||
row.add_child(front_button)
|
||
row.add_child(back_button)
|
||
excavation_button = _button("掘削 E", _toggle_excavation_mode, 72)
|
||
excavation_button.name = "ExcavationButton"
|
||
excavation_button.toggle_mode = true
|
||
_apply_button_icon(excavation_button, visual_theme.control_icon(&"excavate") if visual_theme != null else null, 16)
|
||
row.add_child(excavation_button)
|
||
row.add_child(VSeparator.new())
|
||
var rotate_button := _button("回転 R", _rotate_build_preview, 72)
|
||
_apply_button_icon(rotate_button, visual_theme.control_icon(&"rotate") if visual_theme != null else null, 16)
|
||
row.add_child(rotate_button)
|
||
row.add_child(_button("解除 Esc", _clear_active_tool, 80))
|
||
var spacer := Control.new()
|
||
spacer.size_flags_horizontal = Control.SIZE_EXPAND_FILL
|
||
row.add_child(spacer)
|
||
management_toggle_button = _button("運営 I", _toggle_management_panel, 72)
|
||
management_toggle_button.name = "ManagementToggleButton"
|
||
management_toggle_button.toggle_mode = true
|
||
row.add_child(management_toggle_button)
|
||
var save_button := _button("保存", _save_manual, 62)
|
||
_apply_button_icon(save_button, visual_theme.control_icon(&"save") if visual_theme != null else null, 16)
|
||
row.add_child(save_button)
|
||
row.add_child(_button("読込", _load_manual, 56))
|
||
|
||
palette_scroll = ScrollContainer.new()
|
||
palette_scroll.name = "BuildPaletteScroll"
|
||
palette_scroll.horizontal_scroll_mode = ScrollContainer.SCROLL_MODE_AUTO
|
||
palette_scroll.vertical_scroll_mode = ScrollContainer.SCROLL_MODE_DISABLED
|
||
palette_scroll.custom_minimum_size.y = 62
|
||
palette_scroll.visible = false
|
||
column.add_child(palette_scroll)
|
||
var grid := GridContainer.new()
|
||
grid.name = "BuildPalette"
|
||
grid.columns = MVP_FACILITY_IDS.size()
|
||
grid.add_theme_constant_override("h_separation", 4)
|
||
grid.add_theme_constant_override("v_separation", 0)
|
||
palette_scroll.add_child(grid)
|
||
|
||
build_status_label = Label.new()
|
||
build_status_label.name = "BuildStatusLabel"
|
||
build_status_label.size_flags_horizontal = Control.SIZE_EXPAND_FILL
|
||
build_status_label.text_overrun_behavior = TextServer.OVERRUN_TRIM_ELLIPSIS
|
||
build_status_label.add_theme_font_size_override("font_size", 11)
|
||
build_status_label.add_theme_color_override("font_color", Color("c7d3a8"))
|
||
column.add_child(build_status_label)
|
||
return panel
|
||
|
||
|
||
func _toggle_build_palette() -> void:
|
||
_set_build_palette_open(not _build_palette_open)
|
||
|
||
|
||
func _set_build_palette_open(open: bool) -> void:
|
||
_build_palette_open = open
|
||
if palette_scroll != null:
|
||
palette_scroll.visible = open
|
||
if palette_toggle_button != null:
|
||
palette_toggle_button.set_pressed_no_signal(open)
|
||
palette_toggle_button.text = "建築を閉じる B" if open else "建築 B"
|
||
|
||
|
||
func _toggle_management_panel() -> void:
|
||
_set_management_panel_open(not _management_panel_open)
|
||
|
||
|
||
func _set_management_panel_open(open: bool) -> void:
|
||
_management_panel_open = open
|
||
if management_panel != null:
|
||
management_panel.visible = open
|
||
if management_toggle_button != null:
|
||
management_toggle_button.set_pressed_no_signal(open)
|
||
if not open:
|
||
_set_staff_candidate_panel_open(false)
|
||
_set_staff_management_panel_open(false)
|
||
_set_ledger_panel_open(false)
|
||
_set_supply_panel_open(false)
|
||
_set_business_panel_open(false)
|
||
|
||
|
||
func _activate_management_mode(mode: StringName) -> void:
|
||
_set_management_panel_open(mode != &"facility")
|
||
_set_supply_panel_open(mode == &"product")
|
||
_set_business_panel_open(mode == &"business")
|
||
_set_ledger_panel_open(mode == &"ledger")
|
||
for raw_mode: Variant in navigation_buttons:
|
||
(navigation_buttons[raw_mode] as Button).set_pressed_no_signal(StringName(raw_mode) == mode)
|
||
match mode:
|
||
&"staff":
|
||
_set_staff_management_panel_open(true)
|
||
&"facility":
|
||
_set_build_palette_open(true)
|
||
_set_staff_candidate_panel_open(false)
|
||
_set_status("建築する施設を下のパレットから選んでください。", true, true)
|
||
&"business":
|
||
_set_status("施設ごとの料金と新規受付の開閉を設定できます。", true, true)
|
||
&"product":
|
||
_set_status("倉庫への仕入れ、厨房の自動生産、施設への配送を確認できます。", true, true)
|
||
&"explore":
|
||
_set_status("探索管理は一覧画面の実装準備中です。", true, true)
|
||
&"investment":
|
||
_set_status("投資管理は一覧画面の実装準備中です。", true, true)
|
||
&"ledger":
|
||
_set_status("本日の資金増減と、06:00に確定した営業日の損益を表示します。", true, true)
|
||
|
||
|
||
func _set_ledger_panel_open(open: bool) -> void:
|
||
_ledger_panel_open = open
|
||
if open:
|
||
_set_supply_panel_open(false)
|
||
_set_business_panel_open(false)
|
||
if operating_ledger_panel != null:
|
||
operating_ledger_panel.visible = open
|
||
if open:
|
||
operating_ledger_panel.refresh()
|
||
if operations_controls != null:
|
||
operations_controls.visible = not open and not _supply_panel_open and not _business_panel_open
|
||
if dashboard_summary_label != null:
|
||
dashboard_summary_label.visible = not open and not _supply_panel_open and not _business_panel_open
|
||
if open:
|
||
_set_staff_candidate_panel_open(false)
|
||
_set_staff_management_panel_open(false)
|
||
|
||
|
||
func _set_supply_panel_open(open: bool) -> void:
|
||
_supply_panel_open = open
|
||
if open:
|
||
_set_business_panel_open(false)
|
||
_set_ledger_panel_open(false)
|
||
_set_staff_candidate_panel_open(false)
|
||
_set_staff_management_panel_open(false)
|
||
if supply_management_panel != null:
|
||
supply_management_panel.visible = open
|
||
if open:
|
||
supply_management_panel.refresh()
|
||
if operations_controls != null:
|
||
operations_controls.visible = not open and not _ledger_panel_open and not _business_panel_open
|
||
if dashboard_summary_label != null:
|
||
dashboard_summary_label.visible = not open and not _ledger_panel_open and not _business_panel_open
|
||
|
||
|
||
func _set_business_panel_open(open: bool) -> void:
|
||
_business_panel_open = open
|
||
if open:
|
||
_set_ledger_panel_open(false)
|
||
_set_supply_panel_open(false)
|
||
_set_staff_candidate_panel_open(false)
|
||
_set_staff_management_panel_open(false)
|
||
if business_management_panel != null:
|
||
business_management_panel.visible = open
|
||
if open:
|
||
business_management_panel.refresh()
|
||
if operations_controls != null:
|
||
operations_controls.visible = not open and not _ledger_panel_open and not _supply_panel_open
|
||
if dashboard_summary_label != null:
|
||
dashboard_summary_label.visible = not open and not _ledger_panel_open and not _supply_panel_open
|
||
|
||
|
||
func _on_opening_action(action: StringName) -> void:
|
||
match action:
|
||
&"build_reception", &"build_room", &"build_corridor":
|
||
_set_ledger_panel_open(false)
|
||
_set_management_panel_open(false)
|
||
_set_build_palette_open(true)
|
||
var definitions := {&"build_reception": &"reception", &"build_room": &"standard_room", &"build_corridor": &"guest_corridor"}
|
||
_select_build_definition(definitions[action])
|
||
&"staff":
|
||
_activate_management_mode(&"staff")
|
||
if _call_array(_service(&"staff_service"), &"get_staff_members").is_empty():
|
||
_set_staff_candidate_panel_open(true)
|
||
&"resume":
|
||
if GameClock.paused:
|
||
_toggle_pause()
|
||
&"ledger":
|
||
_activate_management_mode(&"ledger")
|
||
|
||
|
||
func _connect_signals() -> void:
|
||
GameClock.time_changed.connect(_on_time_changed)
|
||
GameClock.phase_changed.connect(_on_phase_changed)
|
||
GameState.resource_changed.connect(_on_resource_changed)
|
||
world_preview.facility_selected.connect(_on_facility_selected)
|
||
world_preview.construction_selected.connect(_on_construction_selected)
|
||
world_preview.cell_clicked.connect(_on_map_cell_clicked)
|
||
world_preview.build_preview_changed.connect(_on_build_preview_changed)
|
||
world_preview.excavation_preview_changed.connect(_on_excavation_preview_changed)
|
||
if _runtime != null and _runtime is Object:
|
||
if _runtime.has_signal(&"snapshot_published"):
|
||
_runtime.connect(&"snapshot_published", Callable(self, "_on_snapshot_published"))
|
||
if _runtime.has_signal(&"command_completed"):
|
||
_runtime.connect(&"command_completed", Callable(self, "_on_command_completed"))
|
||
|
||
|
||
func _populate_build_palette() -> void:
|
||
var palette := find_child("BuildPalette", true, false) as GridContainer
|
||
if palette == null:
|
||
return
|
||
var registry: Variant = _service(&"definition_registry")
|
||
for definition_id: StringName in MVP_FACILITY_IDS:
|
||
var definition: Variant = null
|
||
if registry != null and registry.has_method(&"get_facility"):
|
||
definition = registry.call(&"get_facility", definition_id)
|
||
if definition == null:
|
||
continue
|
||
var button := Button.new()
|
||
button.toggle_mode = true
|
||
button.custom_minimum_size = Vector2(116, 50)
|
||
button.text = _build_button_text(definition)
|
||
button.tooltip_text = String(_definition_value(definition, &"description", ""))
|
||
button.add_theme_font_size_override("font_size", 12)
|
||
_apply_button_icon(button, visual_theme.facility_icon(definition_id) if visual_theme != null else null, 22)
|
||
_apply_button_style(button)
|
||
button.toggled.connect(_on_build_button_toggled.bind(definition_id))
|
||
build_buttons[definition_id] = button
|
||
palette.add_child(button)
|
||
if build_buttons.is_empty():
|
||
_set_status("施設定義を読み込めませんでした。", false)
|
||
else:
|
||
_set_status("B 建築 / H 雇用 / I 運営 ホイール 拡大縮小・中ボタン 移動・Home 全体表示", true, true)
|
||
|
||
|
||
func _populate_staff_candidates() -> void:
|
||
var list := find_child("StaffCandidateList", true, false) as VBoxContainer
|
||
if list == null:
|
||
return
|
||
for child: Node in list.get_children():
|
||
list.remove_child(child)
|
||
child.queue_free()
|
||
staff_candidate_buttons.clear()
|
||
var summaries := _staff_candidate_summaries()
|
||
for summary: Dictionary in summaries:
|
||
var candidate_id := StringName(summary.get(&"candidate_id", &""))
|
||
if candidate_id.is_empty():
|
||
continue
|
||
var card := PanelContainer.new()
|
||
card.name = "Candidate_%s" % String(candidate_id)
|
||
card.add_theme_stylebox_override(
|
||
"panel",
|
||
_themed_panel_style(&"panel_leather", Color("132630"), Color("31505d"), 7, 8)
|
||
)
|
||
var content := VBoxContainer.new()
|
||
content.add_theme_constant_override("separation", 4)
|
||
card.add_child(content)
|
||
var detail := Label.new()
|
||
detail.name = "CandidateDetail_%s" % String(candidate_id)
|
||
detail.text = _staff_candidate_text(summary)
|
||
detail.autowrap_mode = TextServer.AUTOWRAP_WORD_SMART
|
||
detail.add_theme_color_override("font_color", Color("c8d7dc"))
|
||
detail.add_theme_font_size_override("font_size", 12)
|
||
content.add_child(detail)
|
||
var hire_button := Button.new()
|
||
hire_button.name = "Hire_%s" % String(candidate_id)
|
||
hire_button.text = "雇用する"
|
||
hire_button.custom_minimum_size.y = 30
|
||
_apply_button_style(hire_button)
|
||
hire_button.pressed.connect(_hire_staff_candidate.bind(candidate_id))
|
||
content.add_child(hire_button)
|
||
staff_candidate_buttons[candidate_id] = hire_button
|
||
list.add_child(card)
|
||
_refresh_staff_candidates()
|
||
|
||
|
||
func _staff_candidate_summaries() -> Array[Dictionary]:
|
||
if _runtime == null or not _runtime.has_method(&"get_mvp_staff_candidate_summaries"):
|
||
return []
|
||
var value: Variant = _runtime.call(&"get_mvp_staff_candidate_summaries")
|
||
var result: Array[Dictionary] = []
|
||
if value is Array:
|
||
for item: Variant in value:
|
||
if item is Dictionary:
|
||
result.append((item as Dictionary).duplicate(true))
|
||
return result
|
||
|
||
|
||
func _staff_candidate_text(summary: Dictionary) -> String:
|
||
var candidate_id := StringName(summary.get(&"candidate_id", &""))
|
||
var display_name := String(summary.get(&"display_name", candidate_id))
|
||
var role_id := StringName(summary.get(&"role_id", &""))
|
||
var shift_id := StringName(summary.get(&"preferred_shift", &"any"))
|
||
var skills_value: Variant = summary.get(&"skills", {})
|
||
var skills: Dictionary = skills_value if skills_value is Dictionary else {}
|
||
var skill_parts: Array[String] = []
|
||
for skill_id: StringName in [&"service", &"operation", &"combat", &"underworld"]:
|
||
skill_parts.append("%s%d" % [
|
||
String(STAFF_SKILL_NAMES.get(skill_id, String(skill_id))),
|
||
int(skills.get(skill_id, 0)),
|
||
])
|
||
return "%s（%d歳） %s / %s\n契約 G%d 日給 G%d\n技能 %s" % [
|
||
display_name,
|
||
int(summary.get(&"age", 0)),
|
||
String(STAFF_ROLE_NAMES.get(role_id, String(role_id))),
|
||
String(STAFF_SHIFT_NAMES.get(shift_id, String(shift_id))),
|
||
int(summary.get(&"signing_cost", 0)),
|
||
int(summary.get(&"daily_wage", 0)),
|
||
"・".join(skill_parts),
|
||
]
|
||
|
||
|
||
func _toggle_staff_management_panel() -> void:
|
||
_set_staff_management_panel_open(not _staff_management_panel_open)
|
||
|
||
|
||
func _set_staff_management_panel_open(open: bool) -> void:
|
||
_staff_management_panel_open = open
|
||
if staff_management_panel != null:
|
||
staff_management_panel.visible = open
|
||
if staff_management_toggle_button != null:
|
||
staff_management_toggle_button.set_pressed_no_signal(open)
|
||
if open:
|
||
_set_ledger_panel_open(false)
|
||
_set_supply_panel_open(false)
|
||
_set_business_panel_open(false)
|
||
_set_staff_candidate_panel_open(false)
|
||
_set_management_panel_open(true)
|
||
staff_management_panel.refresh()
|
||
_set_status("従業員を選び、配属先と毎日の勤務帯を変更できます。", true, true)
|
||
|
||
|
||
func _on_staff_management_status(message: String, success: bool) -> void:
|
||
_set_status(message, success)
|
||
|
||
|
||
func _toggle_staff_candidate_panel() -> void:
|
||
_set_staff_candidate_panel_open(not _staff_candidate_panel_open)
|
||
|
||
|
||
func _set_staff_candidate_panel_open(open: bool) -> void:
|
||
_staff_candidate_panel_open = open
|
||
if staff_candidate_panel != null:
|
||
staff_candidate_panel.visible = open
|
||
_refresh_staff_candidates()
|
||
if open:
|
||
_set_ledger_panel_open(false)
|
||
_set_supply_panel_open(false)
|
||
_set_business_panel_open(false)
|
||
_set_staff_management_panel_open(false)
|
||
_set_management_panel_open(true)
|
||
_set_status("雇用候補を選んでください。契約金と日給は確定前に表示されます。", true, true)
|
||
|
||
|
||
func _refresh_staff_candidates() -> void:
|
||
if staff_candidate_panel == null or staff_candidate_summary_label == null:
|
||
return
|
||
var summaries := _staff_candidate_summaries()
|
||
var hired_count := 0
|
||
for summary: Dictionary in summaries:
|
||
var candidate_id := StringName(summary.get(&"candidate_id", &""))
|
||
var hired := bool(summary.get(&"hired", false))
|
||
if hired:
|
||
hired_count += 1
|
||
var button := staff_candidate_buttons.get(candidate_id) as Button
|
||
if button == null:
|
||
continue
|
||
var pending := _pending_hire_commands.values().has(candidate_id)
|
||
button.disabled = hired or pending
|
||
button.text = "雇用済み" if hired else "手続き中…" if pending else "雇用する"
|
||
staff_candidate_summary_label.text = "未雇用 %d人 / 雇用済み %d人" % [
|
||
maxi(summaries.size() - hired_count, 0),
|
||
hired_count,
|
||
]
|
||
if staff_candidate_toggle_button != null:
|
||
staff_candidate_toggle_button.text = (
|
||
"候補を閉じる H" if _staff_candidate_panel_open
|
||
else "候補を見る H（%d）" % maxi(summaries.size() - hired_count, 0)
|
||
)
|
||
|
||
|
||
func _hire_staff_candidate(candidate_id: StringName) -> void:
|
||
if _runtime == null or not _runtime.has_method(&"submit_command"):
|
||
_set_status("雇用手続きを送信できません。", false)
|
||
return
|
||
if _pending_hire_commands.values().has(candidate_id):
|
||
_set_status("この候補の雇用手続きはすでに受理されています。", false)
|
||
return
|
||
var summaries := _staff_candidate_summaries()
|
||
var selected: Dictionary = {}
|
||
for summary: Dictionary in summaries:
|
||
if StringName(summary.get(&"candidate_id", &"")) == candidate_id:
|
||
selected = summary
|
||
break
|
||
if selected.is_empty():
|
||
_set_status("雇用候補を読み込めませんでした。", false)
|
||
return
|
||
if bool(selected.get(&"hired", false)):
|
||
_set_status("%sはすでに雇用済みです。" % String(selected.get(&"display_name", candidate_id)), false)
|
||
_refresh_staff_candidates()
|
||
return
|
||
var sequence := _hire_sequence
|
||
_hire_sequence += 1
|
||
var idempotency_key := StringName(
|
||
"ui.hire.%s.%08d" % [String(candidate_id), sequence]
|
||
)
|
||
var result: Variant = _runtime.call(
|
||
&"submit_command",
|
||
&"hire_staff_candidate",
|
||
{&"candidate_id": candidate_id},
|
||
&"player",
|
||
candidate_id,
|
||
75,
|
||
-1,
|
||
idempotency_key
|
||
)
|
||
if result == null or not result.has_method(&"is_success"):
|
||
_set_status("雇用手続きへ応答がありません。", false)
|
||
return
|
||
if not bool(result.call(&"is_success")):
|
||
_set_status(_hire_failure_message(result), false)
|
||
_refresh_staff_candidates()
|
||
return
|
||
var display_name := String(selected.get(&"display_name", candidate_id))
|
||
if result.details is Dictionary and result.details.has(&"staff_id"):
|
||
_set_status("%sを雇用しました（契約 G%d / 日給 G%d）。" % [
|
||
display_name,
|
||
int(selected.get(&"signing_cost", 0)),
|
||
int(selected.get(&"daily_wage", 0)),
|
||
], true)
|
||
else:
|
||
_pending_hire_commands[int(result.command_id)] = candidate_id
|
||
_set_status("%sの雇用手続きを受理しました。" % display_name, true)
|
||
_refresh_dashboard()
|
||
|
||
|
||
func _hire_failure_message(result: Variant) -> String:
|
||
var details: Variant = result.details
|
||
if details is Dictionary:
|
||
var reason := StringName(details.get(&"reason", &""))
|
||
match reason:
|
||
&"ARREARS_REMAIN":
|
||
return "雇用不可: 未払給与 G%dを清算してください。" % int(details.get(&"arrears_total", 0))
|
||
&"BANKRUPT":
|
||
return "雇用不可: 資金破綻後は新しい契約を結べません。"
|
||
&"EXTERNAL_ROLLBACK_FAILED":
|
||
return "雇用不可: 運営データの復旧が必要です。"
|
||
var message := String(result.message).to_lower()
|
||
if int(result.code) == int(CommandResult.Code.DUPLICATE_COMMAND_ID):
|
||
return "この候補はすでに雇用済みです。"
|
||
if "insufficient" in message or "balance" in message:
|
||
return "雇用不可: 契約金が不足しています。"
|
||
return _command_failure_message(result)
|
||
|
||
|
||
func _build_button_text(definition: Variant) -> String:
|
||
var name := String(_definition_value(definition, &"display_name", _definition_value(definition, &"id", "施設")))
|
||
var cost_value: Variant = _definition_value(definition, &"construction_cost", {})
|
||
var gold := 0
|
||
var materials := 0
|
||
if cost_value is Dictionary:
|
||
gold = int(cost_value.get(&"gold", cost_value.get("gold", 0)))
|
||
materials = int(cost_value.get(&"materials", cost_value.get("materials", 0)))
|
||
return "%s\nG %d / 資材 %d" % [name, gold, materials]
|
||
|
||
|
||
func _on_build_button_toggled(pressed: bool, definition_id: StringName) -> void:
|
||
if not pressed:
|
||
if _selected_definition_id == definition_id:
|
||
_clear_build_selection()
|
||
return
|
||
_select_build_definition(definition_id)
|
||
|
||
|
||
func _select_build_definition(definition_id: StringName) -> void:
|
||
var registry: Variant = _service(&"definition_registry")
|
||
if registry == null or not registry.has_method(&"get_facility"):
|
||
_set_status("建設パレットを利用できません。", false)
|
||
return
|
||
var definition: Variant = registry.call(&"get_facility", definition_id)
|
||
if definition == null:
|
||
_set_status("選択した施設定義が見つかりません。", false)
|
||
return
|
||
_set_excavation_mode(false, false)
|
||
_selected_definition_id = definition_id
|
||
_selected_definition = definition
|
||
_build_rotation = 0
|
||
for raw_id: Variant in build_buttons:
|
||
(build_buttons[raw_id] as Button).set_pressed_no_signal(StringName(raw_id) == definition_id)
|
||
var target_layer := clampi(int(_definition_value(definition, &"layer", 0)), 0, 1)
|
||
_set_layer(target_layer)
|
||
world_preview.set_build_definition(definition, _build_rotation)
|
||
_set_status("%sを選択中。配置するマスをクリックしてください。" % String(_definition_value(definition, &"display_name", definition_id)), true, true)
|
||
|
||
|
||
func _clear_build_selection(announce := true) -> void:
|
||
_selected_definition_id = &""
|
||
_selected_definition = null
|
||
_build_rotation = 0
|
||
for button_value: Variant in build_buttons.values():
|
||
(button_value as Button).set_pressed_no_signal(false)
|
||
if world_preview != null:
|
||
world_preview.clear_build_definition()
|
||
if announce:
|
||
_set_status("建設選択を解除しました。", true, true)
|
||
|
||
|
||
func _clear_active_tool() -> void:
|
||
if _supply_panel_open or _business_panel_open:
|
||
_set_management_panel_open(false)
|
||
return
|
||
if _staff_management_panel_open:
|
||
_set_staff_management_panel_open(false)
|
||
return
|
||
if _staff_candidate_panel_open:
|
||
_set_staff_candidate_panel_open(false)
|
||
return
|
||
if _excavation_mode:
|
||
_set_excavation_mode(false)
|
||
return
|
||
_clear_build_selection()
|
||
_set_build_palette_open(false)
|
||
_set_management_panel_open(false)
|
||
|
||
|
||
func _toggle_excavation_mode() -> void:
|
||
_set_excavation_mode(not _excavation_mode)
|
||
|
||
|
||
func _set_excavation_mode(enabled: bool, announce := true) -> void:
|
||
_excavation_mode = enabled
|
||
if excavation_button != null:
|
||
excavation_button.set_pressed_no_signal(_excavation_mode)
|
||
if world_preview != null:
|
||
world_preview.set_excavation_mode(_excavation_mode)
|
||
if not _excavation_mode:
|
||
if announce:
|
||
_set_status("掘削モードを解除しました。", true, true)
|
||
return
|
||
_clear_build_selection(false)
|
||
_selected_entity_id = &""
|
||
_selected_entity_kind = &""
|
||
world_preview.selected_entity_id = &""
|
||
selected_heading_label.text = "掘削モード"
|
||
selected_detail_label.text = "地下のマスにカーソルを合わせると、費用と所要時間を確認できます。"
|
||
var gate_message := _excavation_gate_message()
|
||
_set_status(
|
||
gate_message if not gate_message.is_empty() else "地下の掘削候補を選んでください。FRONT / BACKは同時に開通します。",
|
||
gate_message.is_empty(),
|
||
true
|
||
)
|
||
|
||
|
||
func _rotate_build_preview() -> void:
|
||
if _selected_definition == null:
|
||
_set_status("先に建設する施設を選択してください。", false, true)
|
||
return
|
||
var allowed_value: Variant = _definition_value(_selected_definition, &"allowed_rotations", [0])
|
||
var allowed: Array[int] = []
|
||
if allowed_value is Array:
|
||
for rotation_value: Variant in allowed_value:
|
||
allowed.append(int(rotation_value))
|
||
allowed.sort()
|
||
if allowed.is_empty():
|
||
allowed = [0]
|
||
var index := allowed.find(_build_rotation)
|
||
_build_rotation = allowed[(index + 1) % allowed.size()]
|
||
world_preview.set_build_rotation(_build_rotation)
|
||
_set_status("回転 %d°。地図のマスをクリックして建設します。" % _build_rotation, true, true)
|
||
|
||
|
||
func _on_map_cell_clicked(cell: Vector3i) -> void:
|
||
if _excavation_mode:
|
||
_start_excavation(cell)
|
||
return
|
||
if _selected_definition == null:
|
||
_selected_entity_id = &""
|
||
_selected_entity_kind = &""
|
||
world_preview.selected_entity_id = &""
|
||
selected_elevator_controls.visible = false
|
||
selected_entity_icon.texture = null
|
||
selected_heading_label.text = "選択中のマス"
|
||
selected_detail_label.text = "座標 (%d, %d)\nレイヤー %s\n\n施設のないマスです。" % [cell.x, cell.y, "FRONT / 表層" if cell.z == 0 else "BACK / 裏層"]
|
||
return
|
||
var preview := world_preview.get_build_preview_report(cell)
|
||
if not bool(preview.get(&"can_build", false)):
|
||
_set_status(_preview_failure_message(preview), false)
|
||
return
|
||
if _runtime == null or not _runtime.has_method(&"submit_command"):
|
||
_set_status("Simulation Runtimeへ接続できません。", false)
|
||
return
|
||
var idempotency_key := StringName("ui.build.%08d" % _build_sequence)
|
||
_build_sequence += 1
|
||
var result: Variant = _runtime.call(
|
||
&"submit_command",
|
||
&"build_facility",
|
||
{&"definition_id": _selected_definition_id, &"origin": cell, &"rotation": _build_rotation},
|
||
&"player",
|
||
&"",
|
||
50,
|
||
-1,
|
||
idempotency_key
|
||
)
|
||
if result == null or not result.has_method(&"is_success"):
|
||
_set_status("建設指示を送信できませんでした。", false)
|
||
return
|
||
if not bool(result.call(&"is_success")):
|
||
_set_status(_command_failure_message(result), false)
|
||
return
|
||
var name := String(_definition_value(_selected_definition, &"display_name", _selected_definition_id))
|
||
if result.details is Dictionary and result.details.has(&"job_id"):
|
||
_set_status("%sの建設を開始しました（%d, %d / %d°）。" % [name, cell.x, cell.y, _build_rotation], true)
|
||
else:
|
||
_pending_build_commands[int(result.command_id)] = _selected_definition_id
|
||
_set_status("%sの建設指示を受理しました（%d, %d / %d°）。" % [name, cell.x, cell.y, _build_rotation], true)
|
||
_refresh_dashboard()
|
||
|
||
|
||
func _on_build_preview_changed(report: Dictionary) -> void:
|
||
if _selected_definition == null or world_preview.get_hovered_cell() == null:
|
||
return
|
||
if bool(report.get(&"can_build", false)):
|
||
var cell: Vector3i = world_preview.get_hovered_cell()
|
||
_set_status("配置可能 (%d, %d)・%d° — クリックで建設" % [cell.x, cell.y, _build_rotation], true, true)
|
||
else:
|
||
_set_status(_preview_failure_message(report), false, true)
|
||
|
||
|
||
func _on_excavation_preview_changed(report: Dictionary) -> void:
|
||
if not _excavation_mode or world_preview.get_hovered_cell() == null:
|
||
return
|
||
var gate_message := _excavation_gate_message()
|
||
if not gate_message.is_empty():
|
||
_set_status("掘削不可: %s%s" % [gate_message, _excavation_cost_and_time(report)], false, true)
|
||
return
|
||
var cell: Vector3i = world_preview.get_hovered_cell()
|
||
if bool(report.get(&"ok", false)):
|
||
_set_status(
|
||
"掘削可能 (%d, %d)・%s%s — クリックでFRONT / BACKを開通" % [
|
||
cell.x,
|
||
cell.y,
|
||
"FRONT / 表層" if cell.z == 0 else "BACK / 裏層",
|
||
_excavation_cost_and_time(report),
|
||
],
|
||
true,
|
||
true
|
||
)
|
||
else:
|
||
_set_status(_excavation_failure_message(report), false, true)
|
||
|
||
|
||
func _start_excavation(cell: Vector3i) -> void:
|
||
var report := world_preview.get_excavation_preview_report(cell)
|
||
var gate_message := _excavation_gate_message()
|
||
if not gate_message.is_empty():
|
||
_set_status("掘削不可: %s%s" % [gate_message, _excavation_cost_and_time(report)], false)
|
||
return
|
||
if not bool(report.get(&"ok", false)):
|
||
_set_status(_excavation_failure_message(report), false)
|
||
return
|
||
if _runtime == null or not _runtime.has_method(&"submit_command"):
|
||
_set_status("Simulation Runtimeへ接続できません。", false)
|
||
return
|
||
var spatial_position := Vector2i(cell.x, cell.y)
|
||
if _pending_excavation_commands.values().has(spatial_position):
|
||
_set_status("このマスの掘削指示はすでに受理されています。", false)
|
||
return
|
||
var idempotency_key := _excavation_idempotency_key(cell)
|
||
var result: Variant = _runtime.call(
|
||
&"submit_command",
|
||
&"start_excavation",
|
||
{&"cell": Vector3i(cell.x, cell.y, world_preview.layer_mode)},
|
||
&"player",
|
||
&"",
|
||
50,
|
||
-1,
|
||
idempotency_key
|
||
)
|
||
if result == null or not result.has_method(&"is_success"):
|
||
_set_status("掘削指示を送信できませんでした。", false)
|
||
return
|
||
if not bool(result.call(&"is_success")):
|
||
_set_status(_excavation_command_failure_message(result), false)
|
||
return
|
||
if result.details is Dictionary and result.details.has(&"job_id"):
|
||
_select_excavation_job(StringName(result.details.get(&"job_id", &"")))
|
||
_set_status("掘削を開始しました（%d, %d / FRONT・BACK）。" % [cell.x, cell.y], true)
|
||
else:
|
||
_pending_excavation_commands[int(result.command_id)] = spatial_position
|
||
_set_status("掘削指示を受理しました（%d, %d / FRONT・BACK）。" % [cell.x, cell.y], true)
|
||
_refresh_dashboard()
|
||
|
||
|
||
func _excavation_idempotency_key(cell: Vector3i) -> StringName:
|
||
# One click gets one stable retry identity. A later player retry receives a
|
||
# new sequence so a previously cached validation failure cannot block it.
|
||
var sequence := _excavation_sequence
|
||
_excavation_sequence += 1
|
||
return StringName(
|
||
"ui.excavation.%d.%d.%08d" % [cell.x, cell.y, sequence]
|
||
)
|
||
|
||
|
||
func _on_facility_selected(instance_id: StringName) -> void:
|
||
_set_ledger_panel_open(false)
|
||
_set_supply_panel_open(false)
|
||
_set_management_panel_open(true)
|
||
_set_excavation_mode(false, false)
|
||
_selected_entity_id = instance_id
|
||
_selected_entity_kind = &"facility"
|
||
_refresh_selected_entity()
|
||
|
||
|
||
func _on_construction_selected(job_id: StringName) -> void:
|
||
_set_ledger_panel_open(false)
|
||
_set_supply_panel_open(false)
|
||
_set_management_panel_open(true)
|
||
_set_excavation_mode(false, false)
|
||
_selected_entity_id = job_id
|
||
_selected_entity_kind = &"construction"
|
||
_refresh_selected_entity()
|
||
|
||
|
||
func _refresh_dashboard() -> void:
|
||
var guests := _call_array(_service(&"guest_service"), &"get_guests")
|
||
var queued_guests := 0
|
||
var served_guests := 0
|
||
for guest: Variant in guests:
|
||
if guest == null:
|
||
continue
|
||
if int(guest.state) == 4:
|
||
queued_guests += 1
|
||
elif int(guest.state) == 5:
|
||
served_guests += 1
|
||
var staff_members := _call_array(_service(&"staff_service"), &"get_staff_members")
|
||
var available_staff := 0
|
||
var working_staff := 0
|
||
for staff: Variant in staff_members:
|
||
if staff == null:
|
||
continue
|
||
if int(staff.state) == 2:
|
||
available_staff += 1
|
||
elif int(staff.state) in [3, 4]:
|
||
working_staff += 1
|
||
var event_service: Variant = _service(&"event_service")
|
||
var events := _call_array(event_service, &"get_instances")
|
||
var active_events := 0
|
||
for event_instance: Variant in events:
|
||
if event_instance != null and int(event_instance.state) in [0, 1, 2, 7]:
|
||
active_events += 1
|
||
var active_jobs := 0
|
||
for job: Variant in _call_array(_service(&"construction_service"), &"get_jobs"):
|
||
if job != null and int(job.state) not in [2, 3]:
|
||
active_jobs += 1
|
||
var heat_text := "—"
|
||
var heat_value := 0
|
||
var authority: Variant = _service(&"authority_service")
|
||
if authority != null and authority.has_method(&"get_authority_state"):
|
||
var heat_state: Variant = authority.call(&"get_authority_state")
|
||
if heat_state != null:
|
||
heat_value = int(heat_state.heat)
|
||
heat_text = "%d / 100" % heat_value
|
||
var foreground_text := "なし"
|
||
if event_service != null and event_service.has_method(&"get_foreground_instance"):
|
||
var foreground: Variant = event_service.call(&"get_foreground_instance")
|
||
if foreground != null:
|
||
foreground_text = String(foreground.resolved_event_id)
|
||
_refresh_foreground_event(event_service)
|
||
var operations_text := _operations_dashboard_text()
|
||
dashboard_summary_label.text = (
|
||
"客 %d人（待機 %d / 利用 %d）\n" % [guests.size(), queued_guests, served_guests]
|
||
+ "従業員 %d人（待機 %d / 作業 %d）\n" % [staff_members.size(), available_staff, working_staff]
|
||
+ "イベント %d件 前景: %s\n" % [active_events, foreground_text]
|
||
+ "警戒度 %s 建設中 %d件" % [heat_text, active_jobs]
|
||
+ operations_text
|
||
)
|
||
if guest_count_label != null:
|
||
guest_count_label.text = "来客 %d人" % guests.size()
|
||
if lodging_count_label != null:
|
||
var lodging_guests := 0
|
||
for guest: Variant in guests:
|
||
if guest != null and int(guest.planned_exit_at) >= GameClock.absolute_minute + 360:
|
||
lodging_guests += 1
|
||
lodging_count_label.text = "宿泊 %d人" % lodging_guests
|
||
if alert_count_label != null:
|
||
alert_count_label.text = "警戒 %d" % heat_value
|
||
alert_count_label.add_theme_color_override(
|
||
"font_color",
|
||
Color("ffb498") if heat_value >= 60 else Color("ebca84") if heat_value >= 30 else Color("c7d3a8")
|
||
)
|
||
_refresh_staff_candidates()
|
||
_refresh_selected_entity()
|
||
_update_pause_and_speed()
|
||
if opening_guide != null:
|
||
opening_guide.refresh()
|
||
if operating_ledger_panel != null and _ledger_panel_open:
|
||
operating_ledger_panel.refresh()
|
||
|
||
|
||
func _refresh_foreground_event(event_service: Variant) -> void:
|
||
if foreground_event_panel == null \
|
||
or foreground_event_label == null \
|
||
or foreground_event_choices == null:
|
||
return
|
||
for child: Node in foreground_event_choices.get_children():
|
||
foreground_event_choices.remove_child(child)
|
||
child.queue_free()
|
||
var foreground: Variant = null
|
||
if event_service != null and event_service.has_method(&"get_foreground_instance"):
|
||
foreground = event_service.call(&"get_foreground_instance")
|
||
if foreground == null or int(foreground.state) != 2:
|
||
foreground_event_panel.visible = false
|
||
return
|
||
foreground_event_panel.visible = true
|
||
_set_ledger_panel_open(false)
|
||
_set_supply_panel_open(false)
|
||
_set_management_panel_open(true)
|
||
var actors: Array[String] = []
|
||
for actor_value: Variant in foreground.actor_ids:
|
||
actors.append(String(actor_value))
|
||
foreground_event_label.text = (
|
||
"%s\n関係者: %s" % [
|
||
String(foreground.resolved_event_id),
|
||
"・".join(actors) if not actors.is_empty() else "なし",
|
||
]
|
||
)
|
||
var definition: Variant = null
|
||
if event_service.has_method(&"get_definition"):
|
||
definition = event_service.call(&"get_definition", foreground.resolved_event_id)
|
||
var choices_value: Variant = _definition_value(definition, &"choices", [])
|
||
if not choices_value is Array:
|
||
return
|
||
for choice: Variant in choices_value:
|
||
if choice == null:
|
||
continue
|
||
var choice_id := StringName(_definition_value(choice, &"choice_id", &""))
|
||
if choice_id.is_empty():
|
||
continue
|
||
var choice_button := Button.new()
|
||
choice_button.text = _event_choice_button_text(choice)
|
||
choice_button.custom_minimum_size.y = 34
|
||
_apply_button_style(choice_button)
|
||
choice_button.autowrap_mode = TextServer.AUTOWRAP_WORD_SMART
|
||
choice_button.pressed.connect(
|
||
_submit_foreground_event_choice.bind(
|
||
foreground.event_instance_id,
|
||
foreground.choice_instance_id,
|
||
choice_id
|
||
)
|
||
)
|
||
foreground_event_choices.add_child(choice_button)
|
||
|
||
|
||
func _event_choice_button_text(choice: Variant) -> String:
|
||
var choice_id := StringName(_definition_value(choice, &"choice_id", &""))
|
||
var text_key := StringName(_definition_value(choice, &"text_key", choice_id))
|
||
var title := String(EVENT_CHOICE_NAMES.get(text_key, String(choice_id)))
|
||
var cost_value: Variant = _definition_value(choice, &"cost", {})
|
||
if not cost_value is Dictionary or cost_value.is_empty():
|
||
return title
|
||
var cost_parts: Array[String] = []
|
||
var cost_keys: Array = cost_value.keys()
|
||
cost_keys.sort_custom(func(left: Variant, right: Variant) -> bool:
|
||
return String(left) < String(right)
|
||
)
|
||
for raw_key: Variant in cost_keys:
|
||
cost_parts.append("%s %d" % [String(raw_key), int(cost_value[raw_key])])
|
||
return "%s（%s）" % [title, " / ".join(cost_parts)]
|
||
|
||
|
||
func _submit_foreground_event_choice(
|
||
event_instance_id: StringName,
|
||
choice_instance_id: StringName,
|
||
choice_id: StringName
|
||
) -> void:
|
||
if _runtime == null or not _runtime.has_method(&"submit_command"):
|
||
_set_status("イベント選択を送信できません。", false)
|
||
return
|
||
var idempotency_key := StringName(
|
||
"ui.event.choice.%s.%s" % [String(choice_instance_id), String(choice_id)]
|
||
)
|
||
var result: Variant = _runtime.call(
|
||
&"submit_command",
|
||
&"submit_event_choice",
|
||
{
|
||
&"event_instance_id": event_instance_id,
|
||
&"choice_instance_id": choice_instance_id,
|
||
&"choice_id": choice_id,
|
||
},
|
||
&"player",
|
||
event_instance_id,
|
||
100,
|
||
-1,
|
||
idempotency_key
|
||
)
|
||
var succeeded: bool = result != null \
|
||
and result.has_method(&"is_success") \
|
||
and bool(result.call(&"is_success"))
|
||
_set_status(
|
||
"イベントの選択を確定しました。" if succeeded \
|
||
else _command_failure_message(result) if result != null else "イベント選択に失敗しました。",
|
||
succeeded
|
||
)
|
||
_refresh_dashboard()
|
||
_update_pause_and_speed()
|
||
|
||
|
||
func _operations_dashboard_text() -> String:
|
||
if _runtime == null or not _runtime.has_method(&"get_operations_report"):
|
||
return ""
|
||
var report_value: Variant = _runtime.call(&"get_operations_report")
|
||
if not report_value is Dictionary:
|
||
return ""
|
||
var report: Dictionary = report_value
|
||
if not bool(report.get(&"enabled", false)):
|
||
return "\n運営日次処理 未開始"
|
||
var coordinator_value: Variant = report.get(&"coordinator", {})
|
||
var coordinator: Dictionary = coordinator_value if coordinator_value is Dictionary else {}
|
||
var terminal := StringName(coordinator.get(&"terminal_state", &"RUNNING"))
|
||
var state_text := "営業中"
|
||
if terminal == &"BANKRUPT":
|
||
state_text = "破綻（終了）"
|
||
elif bool(report.get(&"runtime_failure_latched", false)):
|
||
state_text = "処理失敗・再試行待ち"
|
||
elif bool(report.get(&"tick_blocked", false)):
|
||
state_text = "確認待ち"
|
||
var day_profit_text := "未確定"
|
||
var summaries_value: Variant = coordinator.get(&"day_summaries", [])
|
||
if summaries_value is Array and not summaries_value.is_empty():
|
||
var latest_value: Variant = summaries_value.back()
|
||
if latest_value is Dictionary:
|
||
day_profit_text = "G %+d" % int(latest_value.get(&"net_profit", 0))
|
||
return (
|
||
"\n行動点 %d / 6 未払給与 G %d\n" % [
|
||
int(report.get(&"personal_action_points", 0)),
|
||
int(coordinator.get(&"arrears_total", 0)),
|
||
]
|
||
+ "運営状態 %s 前日損益 %s" % [state_text, day_profit_text]
|
||
)
|
||
|
||
|
||
func _refresh_selected_entity() -> void:
|
||
selected_elevator_controls.visible = false
|
||
if _selected_entity_id.is_empty():
|
||
_move_selected_detail_first(false)
|
||
selected_entity_icon.texture = null
|
||
selected_heading_label.text = "掘削モード" if _excavation_mode else "選択中の施設"
|
||
selected_detail_label.text = (
|
||
"地下のマスにカーソルを合わせると、費用と所要時間を確認できます。"
|
||
if _excavation_mode else "地図上の施設をクリックすると、営業状態を確認できます。"
|
||
)
|
||
return
|
||
if _selected_entity_kind == &"construction":
|
||
_move_selected_detail_first(false)
|
||
_refresh_selected_construction()
|
||
return
|
||
if _selected_entity_kind == &"excavation":
|
||
_move_selected_detail_first(false)
|
||
_refresh_selected_excavation()
|
||
return
|
||
var shaft := _selected_elevator_report()
|
||
if not shaft.is_empty():
|
||
_refresh_selected_elevator(shaft)
|
||
return
|
||
_move_selected_detail_first(false)
|
||
var facility_service: Variant = _service(&"facility_service")
|
||
if facility_service == null or not facility_service.has_method(&"get_instance"):
|
||
selected_detail_label.text = "施設サービスを利用できません。"
|
||
return
|
||
var facility: Variant = facility_service.call(&"get_instance", _selected_entity_id)
|
||
if facility == null:
|
||
var construction_facility := _construction_facility(_selected_entity_id)
|
||
if construction_facility.is_empty():
|
||
_selected_entity_id = &""
|
||
_selected_entity_kind = &""
|
||
world_preview.selected_entity_id = &""
|
||
selected_heading_label.text = "選択中の施設"
|
||
selected_detail_label.text = "選択していた施設は現在の世界に存在しません。"
|
||
selected_entity_icon.texture = null
|
||
return
|
||
var construction_definition_id := StringName(construction_facility.get(&"definition_id", &""))
|
||
selected_heading_label.text = String(construction_definition_id)
|
||
selected_entity_icon.texture = visual_theme.facility_icon(construction_definition_id) if visual_theme != null else null
|
||
selected_detail_label.text = "施設データを運営サービスへ同期しています。"
|
||
return
|
||
var definition: Variant = _facility_definition(facility.definition_id)
|
||
selected_entity_icon.texture = visual_theme.facility_icon(facility.definition_id) if visual_theme != null else null
|
||
var display_name := String(_definition_value(definition, &"display_name", facility.definition_id))
|
||
var state_index := clampi(int(facility.state), 0, FACILITY_STATE_NAMES.size() - 1)
|
||
var reasons := _facility_reasons(facility.state_reasons)
|
||
var queue_count: int = facility.queue_entries.size()
|
||
var service_count: int = facility.active_services.size()
|
||
var staff_count: int = facility.active_staff_ids.size()
|
||
var occupied_slots: int = service_count
|
||
selected_heading_label.text = display_name
|
||
selected_detail_label.text = (
|
||
"状態 %s%s\n" % [FACILITY_STATE_NAMES[state_index], "（%s）" % reasons if not reasons.is_empty() else ""]
|
||
+ "待機列 %d / %d サービス %d / %d\n" % [queue_count, int(facility.queue_capacity), occupied_slots, int(facility.capacity)]
|
||
+ "配置人員 %d / 必要 %d 耐久 %d%%\n" % [staff_count, int(facility.staff_min), int(facility.durability) / 100]
|
||
+ "基本料金 G %d 所要 %d分\n" % [int(facility.base_price), int(facility.base_service_minutes)]
|
||
+ "座標 (%d, %d) %s" % [facility.origin.x, facility.origin.y, "FRONT" if facility.origin.z == 0 else "BACK"]
|
||
)
|
||
|
||
|
||
func _selected_elevator_report() -> Dictionary:
|
||
if _selected_entity_kind != &"facility" or _selected_entity_id.is_empty():
|
||
return {}
|
||
var transport: Variant = _service(&"elevators")
|
||
if transport == null or not transport.has_method(&"get_report"):
|
||
return {}
|
||
for shaft: Dictionary in transport.call(&"get_report").get(&"shafts", []):
|
||
if (shaft.get(&"module_ids", []) as Array).has(_selected_entity_id):
|
||
return shaft
|
||
return {}
|
||
|
||
|
||
func _refresh_selected_elevator(shaft: Dictionary) -> void:
|
||
_move_selected_detail_first(true)
|
||
var construction_facility := _construction_facility(_selected_entity_id)
|
||
var definition_id := StringName(construction_facility.get(&"definition_id", &"guest_elevator"))
|
||
var definition: Variant = _facility_definition(definition_id)
|
||
selected_heading_label.text = String(_definition_value(definition, &"display_name", "昇降機"))
|
||
selected_entity_icon.texture = visual_theme.facility_icon(definition_id) if visual_theme != null else null
|
||
var powered := bool(shaft.get(&"powered", true))
|
||
var operator_open := bool(shaft.get(&"operator_open", true))
|
||
var state_text := String(ELEVATOR_PHASE_NAMES.get(StringName(shaft.get(&"phase", &"IDLE")), "待機"))
|
||
if not operator_open:
|
||
state_text = "手動停止"
|
||
elif not powered:
|
||
state_text = "魔力供給なし"
|
||
var floor_index := int(shaft.get(&"current_floor", 0))
|
||
var target_index := int(shaft.get(&"boarding_floor", floor_index) if StringName(shaft.get(&"phase", &"IDLE")) == &"PICKUP" else shaft.get(&"target_floor", floor_index))
|
||
var stops: Array = shaft.get(&"stops", [])
|
||
var stop_text := "—"
|
||
if not stops.is_empty():
|
||
stop_text = "%s 〜 %s" % [_elevator_floor_name(stops.front().y), _elevator_floor_name(stops.back().y)]
|
||
selected_detail_label.text = (
|
||
"状態 %s\n" % state_text
|
||
+ "現在階 %s 目的階 %s\n" % [_elevator_floor_name(floor_index), _elevator_floor_name(target_index)]
|
||
+ "乗客 %d / %d人 待機 %d人\n" % [int(shaft.get(&"passenger_count", 0)), int(shaft.get(&"capacity", 0)), int(shaft.get(&"waiting_count", 0))]
|
||
+ "停止階 %s\n" % stop_text
|
||
+ "魔力 %s %s" % ["供給中" if powered else "不足", "客・従業員用" if definition_id == &"guest_elevator" else "従業員・物資用"]
|
||
)
|
||
selected_elevator_controls.visible = true
|
||
elevator_operation_button.disabled = _pending_elevator_commands.values().has(shaft.get(&"shaft_id", &""))
|
||
elevator_operation_button.text = "指示を受理済み…" if elevator_operation_button.disabled else ("昇降機を停止" if operator_open else "運行を再開")
|
||
elevator_operation_hint.text = "停止すると最寄りの階で降車し、待機中の呼び出しを解除します。" if operator_open else ("再開すると新しい呼び出しを受け付けます。" if powered else "魔力が供給されると運行を再開できます。")
|
||
|
||
|
||
func _move_selected_detail_first(first: bool) -> void:
|
||
var column := selected_heading_label.get_parent()
|
||
var selected_row := selected_detail_label.get_parent()
|
||
# The transport action fits without scrolling; other management views keep
|
||
# their existing staff-first layout.
|
||
var desired_index := 0 if first else column.get_child_count()-3
|
||
if selected_heading_label.get_index() == desired_index:
|
||
return
|
||
column.move_child(selected_heading_label, 0 if first else -1)
|
||
column.move_child(selected_row, 1 if first else -1)
|
||
column.move_child(selected_elevator_controls, 2 if first else -1)
|
||
|
||
|
||
func _elevator_floor_name(floor_index: int) -> String:
|
||
return "%dF" % (floor_index+1) if floor_index >= 0 else "B%d" % -floor_index
|
||
|
||
|
||
func _on_elevator_operation_pressed() -> void:
|
||
var shaft := _selected_elevator_report()
|
||
if shaft.is_empty() or _runtime == null:
|
||
return
|
||
var shaft_id := StringName(shaft[&"shaft_id"])
|
||
if _pending_elevator_commands.values().has(shaft_id):
|
||
return
|
||
var key := StringName("ui.elevator.%08d" % _elevator_sequence)
|
||
_elevator_sequence += 1
|
||
var open_value := not bool(shaft.get(&"operator_open", true))
|
||
var result: Variant = _runtime.call(&"submit_command", &"set_elevator_operation", {&"shaft_id": shaft_id, &"operator_open": open_value}, &"player", &"", 50, -1, key)
|
||
if result == null or not result.is_success():
|
||
_set_status("昇降機の指示を反映できませんでした。", false)
|
||
return
|
||
if not result.details.has(&"shaft_id"):
|
||
_pending_elevator_commands[int(result.command_id)] = shaft_id
|
||
_set_status("昇降機の運行指示を受理しました。", true)
|
||
else:
|
||
var message := "昇降機を停止しました。"
|
||
if open_value:
|
||
message = "昇降機の運行を再開しました。" if bool(shaft.get(&"powered", true)) else "運行を許可しました。魔力の供給待ちです。"
|
||
_set_status(message, true)
|
||
_refresh_selected_entity()
|
||
|
||
|
||
func _synchronize_elevator_pending() -> void:
|
||
var queue: Variant = _service(&"command_queue")
|
||
if queue == null:
|
||
return
|
||
if queue.pending_count() == 0:
|
||
_pending_elevator_commands.clear()
|
||
return
|
||
_pending_elevator_commands.clear()
|
||
for command: Dictionary in queue.create_snapshot().get("pending", []):
|
||
if StringName(command.get("command_type", &"")) == &"set_elevator_operation":
|
||
_pending_elevator_commands[int(command.get("command_id", 0))] = StringName((command.get("payload", {}) as Dictionary).get(&"shaft_id", &""))
|
||
|
||
|
||
func _refresh_selected_construction() -> void:
|
||
var construction: Variant = _service(&"construction_service")
|
||
if construction == null or not construction.has_method(&"get_job"):
|
||
selected_detail_label.text = "建設サービスを利用できません。"
|
||
return
|
||
var job: Variant = construction.call(&"get_job", _selected_entity_id)
|
||
if job == null:
|
||
_selected_entity_id = &""
|
||
_selected_entity_kind = &""
|
||
world_preview.selected_entity_id = &""
|
||
selected_heading_label.text = "選択中の施設"
|
||
selected_detail_label.text = "選択していた工事は現在の世界に存在しません。"
|
||
selected_entity_icon.texture = null
|
||
return
|
||
var definition: Variant = _facility_definition(job.definition_id)
|
||
selected_entity_icon.texture = visual_theme.facility_icon(job.definition_id) if visual_theme != null else null
|
||
var display_name := String(_definition_value(definition, &"display_name", job.definition_id))
|
||
var state_names := ["計画済み", "建設中", "完成", "中止", "停止中"]
|
||
var job_state := clampi(int(job.state), 0, state_names.size() - 1)
|
||
selected_heading_label.text = "%s（工事）" % display_name
|
||
selected_detail_label.text = (
|
||
"状態 %s\n" % state_names[job_state]
|
||
+ "進捗 %d%% 予定 %d分\n" % [int(job.progress) / 100, int(job.build_minutes)]
|
||
+ "座標 (%d, %d) %s\n" % [job.origin.x, job.origin.y, "FRONT" if int(job.layer) == 0 else "BACK"]
|
||
+ ("停止理由 %s" % String(job.state_reason) if not String(job.state_reason).is_empty() else "建設はシミュレーション時間とともに進みます。")
|
||
)
|
||
|
||
|
||
func _select_excavation_job(job_id: StringName) -> void:
|
||
if job_id.is_empty():
|
||
return
|
||
_selected_entity_id = job_id
|
||
_selected_entity_kind = &"excavation"
|
||
world_preview.selected_entity_id = &""
|
||
world_preview.clear_hovered_cell()
|
||
_refresh_selected_excavation()
|
||
|
||
|
||
func _refresh_selected_excavation() -> void:
|
||
selected_entity_icon.texture = visual_theme.control_icon(&"excavate") if visual_theme != null else null
|
||
var excavation: Variant = _service(&"excavation_service")
|
||
if excavation == null or not excavation.has_method(&"get_job"):
|
||
selected_detail_label.text = "掘削サービスを利用できません。"
|
||
return
|
||
var job_value: Variant = excavation.call(&"get_job", _selected_entity_id)
|
||
if not job_value is Dictionary or job_value.is_empty():
|
||
_selected_entity_id = &""
|
||
_selected_entity_kind = &""
|
||
selected_heading_label.text = "掘削モード" if _excavation_mode else "選択中の施設"
|
||
selected_detail_label.text = "選択していた掘削作業は現在の世界に存在しません。"
|
||
return
|
||
var job: Dictionary = job_value
|
||
var state := StringName(job.get(&"state", &""))
|
||
var state_text := "掘削中"
|
||
if state == &"PAUSED":
|
||
state_text = "一時停止"
|
||
elif state == &"COMPLETED":
|
||
state_text = "完了"
|
||
var position: Vector2i = job.get(&"position", Vector2i.ZERO)
|
||
var cost_value: Variant = job.get(&"cost", {})
|
||
var cost: Dictionary = cost_value if cost_value is Dictionary else {}
|
||
var guidance := "両レイヤーが開通しました。"
|
||
if state == &"ACTIVE":
|
||
guidance = "掘削はシミュレーション時間とともに進みます。"
|
||
elif state == &"PAUSED":
|
||
guidance = "停止理由 %s" % String(job.get(&"state_reason", ""))
|
||
selected_heading_label.text = "地下掘削（%d, %d）" % [position.x, position.y]
|
||
selected_detail_label.text = (
|
||
"状態 %s 進捗 %d%%\n" % [state_text, clampi(int(job.get(&"progress", 0)) / 100, 0, 100)]
|
||
+ "所要 %d分 費用 G %d / 資材 %d\n" % [
|
||
int(job.get(&"build_minutes", 0)),
|
||
int(cost.get(&"gold", cost.get("gold", 0))),
|
||
int(cost.get(&"materials", cost.get("materials", 0))),
|
||
]
|
||
+ "対象 FRONT / 表層・BACK / 裏層\n"
|
||
+ guidance
|
||
)
|
||
|
||
|
||
func _preview_failure_message(report: Dictionary) -> String:
|
||
var codes_value: Variant = report.get(&"error_codes", [])
|
||
if codes_value is Array and not codes_value.is_empty():
|
||
var code := String(codes_value[0])
|
||
return "配置不可: %s" % PREVIEW_REASON_NAMES.get(code, code)
|
||
var reasons_value: Variant = report.get(&"reasons", [])
|
||
if reasons_value is Array and not reasons_value.is_empty() and reasons_value[0] is Dictionary:
|
||
return "配置不可: %s" % String(reasons_value[0].get(&"message", "条件を満たしていません"))
|
||
return "このマスには配置できません。"
|
||
|
||
|
||
func _excavation_failure_message(report: Dictionary) -> String:
|
||
var errors_value: Variant = report.get(&"errors", [])
|
||
var reason := "条件を満たしていません"
|
||
if errors_value is Array and not errors_value.is_empty():
|
||
var code := StringName(errors_value[0])
|
||
reason = String(EXCAVATION_REASON_NAMES.get(code, String(code)))
|
||
if code == &"INSUFFICIENT_RESOURCES":
|
||
var missing_value: Variant = report.get(&"missing_resources", {})
|
||
if missing_value is Dictionary and not missing_value.is_empty():
|
||
var missing: Dictionary = missing_value
|
||
reason += "（不足: G %d / 資材 %d）" % [
|
||
int(missing.get(&"gold", missing.get("gold", 0))),
|
||
int(missing.get(&"materials", missing.get("materials", 0))),
|
||
]
|
||
return "掘削不可: %s%s" % [reason, _excavation_cost_and_time(report)]
|
||
|
||
|
||
func _excavation_cost_and_time(report: Dictionary) -> String:
|
||
var cost_value: Variant = report.get(&"cost", {})
|
||
var cost: Dictionary = cost_value if cost_value is Dictionary else {}
|
||
var minutes := int(report.get(&"build_minutes", 0))
|
||
if cost.is_empty() and minutes <= 0:
|
||
return ""
|
||
return "（費用 G %d / 資材 %d・所要 %d分）" % [
|
||
int(cost.get(&"gold", cost.get("gold", 0))),
|
||
int(cost.get(&"materials", cost.get("materials", 0))),
|
||
minutes,
|
||
]
|
||
|
||
|
||
func _excavation_gate_message() -> String:
|
||
var progression: Variant = _service(&"progression_service")
|
||
if progression == null:
|
||
return "世界樹ランクを確認できません"
|
||
var current_rank := int(_definition_value(progression, &"current_rank", 1))
|
||
if current_rank < 2:
|
||
return "世界樹ランク2で地下掘削が解禁されます（現在ランク%d）" % current_rank
|
||
if _runtime == null or not _runtime.has_method(&"get_operations_report"):
|
||
return "運営状態を確認できません"
|
||
var report_value: Variant = _runtime.call(&"get_operations_report")
|
||
if not report_value is Dictionary:
|
||
return "運営状態を確認できません"
|
||
var report: Dictionary = report_value
|
||
if not bool(report.get(&"enabled", false)):
|
||
return "本番運営が始まるまで掘削できません"
|
||
var coordinator_value: Variant = report.get(&"coordinator", {})
|
||
var coordinator: Dictionary = coordinator_value if coordinator_value is Dictionary else {}
|
||
if StringName(coordinator.get(&"terminal_state", &"RUNNING")) == &"BANKRUPT":
|
||
return "資金破綻により新しい掘削を開始できません"
|
||
if bool(coordinator.get(&"external_quarantined", false)):
|
||
return "運営データの復旧が必要なため掘削を開始できません"
|
||
var arrears := int(coordinator.get(&"arrears_total", 0))
|
||
if arrears > 0:
|
||
return "未払給与 G %dを清算するまで掘削できません" % arrears
|
||
return ""
|
||
|
||
|
||
func _excavation_command_failure_message(result: Variant) -> String:
|
||
var details: Variant = result.details
|
||
if details is Dictionary:
|
||
var report_value: Variant = details.get(&"report", null)
|
||
if report_value is Dictionary:
|
||
return _excavation_failure_message(report_value)
|
||
var reason := StringName(details.get(&"reason", &""))
|
||
match reason:
|
||
&"ARREARS_REMAIN":
|
||
return "掘削不可: 未払給与 G %dを清算してください" % int(details.get(&"arrears_total", 0))
|
||
&"BANKRUPT":
|
||
return "掘削不可: 資金破綻により新しい工事は開始できません"
|
||
&"EXTERNAL_ROLLBACK_FAILED":
|
||
return "掘削不可: 運営データの復旧が必要です"
|
||
if details.has(&"required_rank"):
|
||
return "掘削不可: 世界樹ランク%dが必要です（現在ランク%d）" % [
|
||
int(details.get(&"required_rank", 2)),
|
||
int(details.get(&"current_rank", 1)),
|
||
]
|
||
if int(result.code) == int(CommandResult.Code.DUPLICATE_IDEMPOTENCY_KEY):
|
||
return "この掘削指示はすでに受理されています。"
|
||
return _command_failure_message(result)
|
||
|
||
|
||
func _command_failure_message(result: Variant) -> String:
|
||
var message := String(result.message)
|
||
var details: Variant = result.details
|
||
if details is Dictionary:
|
||
var report_value: Variant = details.get(&"placement_report", null)
|
||
if report_value is Dictionary:
|
||
return _preview_failure_message(report_value)
|
||
return "操作に失敗しました: %s" % (message if not message.is_empty() else "不明なエラー")
|
||
|
||
|
||
func _save_manual() -> void:
|
||
if _runtime == null or not _runtime.has_method(&"save_to_path"):
|
||
_set_status("保存サービスへ接続できません。", false)
|
||
return
|
||
var directory_error := DirAccess.make_dir_recursive_absolute(ProjectSettings.globalize_path(manual_save_path).get_base_dir())
|
||
if directory_error != OK and directory_error != ERR_ALREADY_EXISTS:
|
||
_set_status("保存フォルダを作成できませんでした。", false)
|
||
return
|
||
var result: Variant = _runtime.call(&"save_to_path", manual_save_path, {&"display_name": "手動保存"})
|
||
if result is Dictionary and bool(result.get(&"ok", false)):
|
||
_set_status("手動セーブを保存しました。", true)
|
||
else:
|
||
_set_status("保存に失敗しました: %s" % _result_message(result), false)
|
||
|
||
|
||
func _load_manual() -> void:
|
||
if _runtime == null or (
|
||
not _runtime.has_method(&"load_with_recovery")
|
||
and not _runtime.has_method(&"load_from_path")
|
||
):
|
||
_set_status("読込サービスへ接続できません。", false)
|
||
return
|
||
var result: Variant = (
|
||
_runtime.call(&"load_with_recovery", manual_save_path)
|
||
if _runtime.has_method(&"load_with_recovery")
|
||
else _runtime.call(&"load_from_path", manual_save_path)
|
||
)
|
||
if result is Dictionary and bool(result.get(&"ok", false)):
|
||
_pending_build_commands.clear()
|
||
_pending_excavation_commands.clear()
|
||
_pending_hire_commands.clear()
|
||
_pending_elevator_commands.clear()
|
||
_synchronize_ui_command_state()
|
||
if staff_management_panel != null:
|
||
staff_management_panel.refresh()
|
||
if supply_management_panel != null:
|
||
supply_management_panel.refresh()
|
||
if business_management_panel != null:
|
||
business_management_panel.refresh()
|
||
_selected_entity_id = &""
|
||
_selected_entity_kind = &""
|
||
world_preview.selected_entity_id = &""
|
||
world_preview.queue_redraw()
|
||
_refresh_dashboard()
|
||
_update_pause_and_speed()
|
||
_set_status("手動セーブを読み込みました。", true)
|
||
else:
|
||
_set_status("読み込みに失敗しました: %s" % _result_message(result), false)
|
||
|
||
|
||
func _result_message(result: Variant) -> String:
|
||
if result is Dictionary:
|
||
var message := String(result.get(&"message", result.get(&"code", "保存データがありません")))
|
||
return message if not message.is_empty() else "保存データがありません"
|
||
return "サービスから応答がありません"
|
||
|
||
|
||
func _synchronize_ui_command_state() -> void:
|
||
if _runtime == null:
|
||
return
|
||
var queue: Variant = _runtime.get(&"command_queue")
|
||
if queue == null:
|
||
return
|
||
if queue.has_method(&"get_accepted_command_metadata"):
|
||
var metadata_value: Variant = queue.call(&"get_accepted_command_metadata")
|
||
if metadata_value is Array:
|
||
for raw_metadata: Variant in metadata_value:
|
||
if not raw_metadata is Dictionary:
|
||
continue
|
||
_advance_ui_sequence_from_key(String(raw_metadata.get("idempotency_key", "")))
|
||
if not queue.has_method(&"create_snapshot"):
|
||
return
|
||
var snapshot_value: Variant = queue.call(&"create_snapshot")
|
||
if not snapshot_value is Dictionary:
|
||
return
|
||
var pending_value: Variant = snapshot_value.get("pending", [])
|
||
if not pending_value is Array:
|
||
return
|
||
for raw_pending: Variant in pending_value:
|
||
if not raw_pending is Dictionary:
|
||
continue
|
||
var command_id := int(raw_pending.get("command_id", 0))
|
||
var command_type := StringName(raw_pending.get("command_type", &""))
|
||
var payload_value: Variant = raw_pending.get("payload", {})
|
||
var payload: Dictionary = payload_value if payload_value is Dictionary else {}
|
||
if command_id <= 0:
|
||
continue
|
||
match command_type:
|
||
&"set_elevator_operation":
|
||
_pending_elevator_commands[command_id] = StringName(payload.get(&"shaft_id", &""))
|
||
&"build_facility":
|
||
var definition_id := StringName(payload.get(&"definition_id", payload.get("definition_id", &"")))
|
||
if not definition_id.is_empty():
|
||
_pending_build_commands[command_id] = definition_id
|
||
&"start_excavation":
|
||
var cell_value: Variant = payload.get(&"cell", payload.get("cell", null))
|
||
if cell_value is Vector3i:
|
||
_pending_excavation_commands[command_id] = Vector2i(cell_value.x, cell_value.y)
|
||
&"hire_staff_candidate":
|
||
var candidate_id := StringName(payload.get(&"candidate_id", payload.get("candidate_id", &"")))
|
||
if not candidate_id.is_empty():
|
||
_pending_hire_commands[command_id] = candidate_id
|
||
|
||
|
||
func _advance_ui_sequence_from_key(key: String) -> void:
|
||
if key.is_empty():
|
||
return
|
||
var parts := key.split(".")
|
||
if parts.is_empty():
|
||
return
|
||
var suffix := String(parts[parts.size() - 1])
|
||
if not suffix.is_valid_int():
|
||
return
|
||
var next_sequence := int(suffix) + 1
|
||
if key.begins_with("ui.build."):
|
||
_build_sequence = maxi(_build_sequence, next_sequence)
|
||
elif key.begins_with("ui.excavation."):
|
||
_excavation_sequence = maxi(_excavation_sequence, next_sequence)
|
||
elif key.begins_with("ui.hire."):
|
||
_hire_sequence = maxi(_hire_sequence, next_sequence)
|
||
elif key.begins_with("ui.elevator."):
|
||
_elevator_sequence = maxi(_elevator_sequence, next_sequence)
|
||
|
||
|
||
func _on_snapshot_published(_snapshot: Dictionary, _digest: String) -> void:
|
||
_synchronize_elevator_pending()
|
||
_refresh_dashboard()
|
||
_update_pause_and_speed()
|
||
|
||
|
||
func _on_command_completed(result: Variant) -> void:
|
||
if result == null:
|
||
return
|
||
if _pending_elevator_commands.has(int(result.command_id)):
|
||
_pending_elevator_commands.erase(int(result.command_id))
|
||
_set_status("昇降機の運行設定を反映しました。" if result.is_success() else "昇降機の運行設定を反映できませんでした。", result.is_success())
|
||
_refresh_selected_entity()
|
||
return
|
||
if _pending_hire_commands.has(int(result.command_id)):
|
||
var candidate_id := StringName(_pending_hire_commands[int(result.command_id)])
|
||
_pending_hire_commands.erase(int(result.command_id))
|
||
var display_name := String(candidate_id)
|
||
for summary: Dictionary in _staff_candidate_summaries():
|
||
if StringName(summary.get(&"candidate_id", &"")) == candidate_id:
|
||
display_name = String(summary.get(&"display_name", candidate_id))
|
||
break
|
||
if bool(result.call(&"is_success")):
|
||
_set_status("%sを雇用しました。" % display_name, true)
|
||
else:
|
||
_set_status(_hire_failure_message(result), false)
|
||
_refresh_dashboard()
|
||
return
|
||
if _pending_excavation_commands.has(int(result.command_id)):
|
||
var position: Vector2i = _pending_excavation_commands[int(result.command_id)]
|
||
_pending_excavation_commands.erase(int(result.command_id))
|
||
if bool(result.call(&"is_success")):
|
||
_select_excavation_job(StringName(result.details.get(&"job_id", &"")))
|
||
_set_status("掘削を開始しました（%d, %d / FRONT・BACK）。" % [position.x, position.y], true)
|
||
else:
|
||
_set_status(_excavation_command_failure_message(result), false)
|
||
return
|
||
if not _pending_build_commands.has(int(result.command_id)):
|
||
return
|
||
var definition_id := StringName(_pending_build_commands[int(result.command_id)])
|
||
_pending_build_commands.erase(int(result.command_id))
|
||
if bool(result.call(&"is_success")):
|
||
var definition: Variant = _facility_definition(definition_id)
|
||
_set_status("%sの建設を開始しました。" % String(_definition_value(definition, &"display_name", definition_id)), true)
|
||
else:
|
||
_set_status(_command_failure_message(result), false)
|
||
|
||
|
||
func _set_layer(value: int) -> void:
|
||
var normalized := clampi(value, 0, 1)
|
||
if world_preview != null:
|
||
world_preview.layer_mode = normalized
|
||
GameState.active_layer = normalized
|
||
if front_button != null:
|
||
front_button.set_pressed_no_signal(normalized == 0)
|
||
if back_button != null:
|
||
back_button.set_pressed_no_signal(normalized == 1)
|
||
EventBus.layer_changed.emit(normalized)
|
||
|
||
|
||
func _toggle_pause() -> void:
|
||
var event_service: Variant = _service(&"event_service")
|
||
if event_service != null and event_service.has_method(&"get_foreground_instance"):
|
||
var foreground: Variant = event_service.call(&"get_foreground_instance")
|
||
if foreground != null and int(foreground.state) == 2:
|
||
GameClock.set_paused(true)
|
||
_set_status("先に要対応イベントの選択肢を決めてください。", false)
|
||
_update_pause_and_speed()
|
||
return
|
||
if _runtime != null \
|
||
and _runtime.has_method(&"get_operations_report") \
|
||
and _runtime.has_method(&"acknowledge_operations_pause"):
|
||
var report_value: Variant = _runtime.call(&"get_operations_report")
|
||
if report_value is Dictionary:
|
||
var report: Dictionary = report_value
|
||
var coordinator_value: Variant = report.get(&"coordinator", {})
|
||
var coordinator: Dictionary = (
|
||
coordinator_value if coordinator_value is Dictionary else {}
|
||
)
|
||
if StringName(coordinator.get(&"terminal_state", &"RUNNING")) == &"BANKRUPT":
|
||
_set_status("資金破綻により運営は終了しています。", false)
|
||
return
|
||
if bool(report.get(&"enabled", false)) \
|
||
and int(report.get(&"deferred_runtime_minute", -1)) >= 0:
|
||
var retry_value: Variant = _runtime.call(&"acknowledge_operations_pause")
|
||
var retry_ok := retry_value is Dictionary and bool(retry_value.get(&"ok", false))
|
||
_set_status(
|
||
"運営処理を再開しました。" if retry_ok \
|
||
else "運営処理を再開できません: %s" % _result_message(retry_value),
|
||
retry_ok
|
||
)
|
||
_refresh_dashboard()
|
||
_update_pause_and_speed()
|
||
return
|
||
GameClock.toggle_pause()
|
||
_update_pause_and_speed()
|
||
|
||
|
||
func _set_speed(value: int) -> void:
|
||
GameClock.set_speed(value)
|
||
_update_pause_and_speed()
|
||
|
||
|
||
func _update_pause_and_speed() -> void:
|
||
var operations_deferred := false
|
||
var operations_terminal := false
|
||
var event_waiting := false
|
||
if _runtime != null and _runtime.has_method(&"get_operations_report"):
|
||
var report_value: Variant = _runtime.call(&"get_operations_report")
|
||
if report_value is Dictionary:
|
||
operations_deferred = bool(report_value.get(&"enabled", false)) \
|
||
and int(report_value.get(&"deferred_runtime_minute", -1)) >= 0
|
||
var coordinator_value: Variant = report_value.get(&"coordinator", {})
|
||
if coordinator_value is Dictionary:
|
||
operations_terminal = StringName(
|
||
coordinator_value.get(&"terminal_state", &"RUNNING")
|
||
) == &"BANKRUPT"
|
||
var event_service: Variant = _service(&"event_service")
|
||
if event_service != null and event_service.has_method(&"get_foreground_instance"):
|
||
var foreground: Variant = event_service.call(&"get_foreground_instance")
|
||
event_waiting = foreground != null and int(foreground.state) == 2
|
||
if phase_label != null:
|
||
if operations_terminal:
|
||
phase_label.text = "運営終了"
|
||
elif operations_deferred:
|
||
phase_label.text = "要確認"
|
||
elif event_waiting:
|
||
phase_label.text = "選択待ち"
|
||
else:
|
||
phase_label.text = "停止中" if GameClock.paused else _phase_name(GameClock.get_phase())
|
||
phase_label.add_theme_color_override("font_color", Color("e88972") if GameClock.paused else Color("f0c574"))
|
||
if pause_button != null:
|
||
pause_button.text = (
|
||
"破綻"
|
||
if operations_terminal else (
|
||
"運営再試行"
|
||
if operations_deferred else (
|
||
"イベント待ち"
|
||
if event_waiting else ("再開" if GameClock.paused else "停止")
|
||
)
|
||
)
|
||
)
|
||
pause_button.disabled = operations_terminal or event_waiting
|
||
for raw_speed: Variant in speed_buttons:
|
||
var button := speed_buttons[raw_speed] as Button
|
||
button.set_pressed_no_signal(not GameClock.paused and int(raw_speed) == GameClock.speed)
|
||
|
||
|
||
func _on_time_changed(current_day: int, hour: int, minute: int) -> void:
|
||
time_label.text = "%d日目 %02d:%02d" % [current_day, hour, minute]
|
||
_update_pause_and_speed()
|
||
|
||
|
||
func _on_phase_changed(phase: GameClock.Phase) -> void:
|
||
if not GameClock.paused:
|
||
phase_label.text = _phase_name(phase)
|
||
|
||
|
||
func _phase_name(phase: GameClock.Phase) -> String:
|
||
match phase:
|
||
GameClock.Phase.MORNING:
|
||
return "朝"
|
||
GameClock.Phase.DAY:
|
||
return "昼"
|
||
GameClock.Phase.EVENING:
|
||
return "夕方"
|
||
_:
|
||
return "夜"
|
||
|
||
|
||
func _on_resource_changed(resource_name: StringName, value: int) -> void:
|
||
if not resource_labels.has(resource_name):
|
||
return
|
||
var titles := {
|
||
&"gold": "所持金",
|
||
&"mana": "マナ",
|
||
&"materials": "資材",
|
||
&"faith": "信仰",
|
||
}
|
||
(resource_labels[resource_name] as Label).text = "%s %d" % [titles[resource_name], value]
|
||
|
||
|
||
func _button(text_value: String, callback: Callable, minimum_width := 82) -> Button:
|
||
var button := Button.new()
|
||
button.text = text_value
|
||
button.custom_minimum_size = Vector2(minimum_width, 28)
|
||
button.add_theme_font_size_override("font_size", 12)
|
||
button.pressed.connect(callback)
|
||
_apply_button_style(button)
|
||
return button
|
||
|
||
|
||
func _hud_value_label(text_value: String, minimum_width: float) -> Label:
|
||
var label := Label.new()
|
||
label.text = text_value
|
||
label.custom_minimum_size.x = minimum_width
|
||
label.vertical_alignment = VERTICAL_ALIGNMENT_CENTER
|
||
label.add_theme_font_size_override("font_size", 12)
|
||
label.add_theme_color_override("font_color", _visual_color(&"text_light", Color("fff2d0")))
|
||
return label
|
||
|
||
|
||
func _icon_rect(icon_texture: Texture2D, side: float) -> TextureRect:
|
||
var icon := TextureRect.new()
|
||
icon.texture = icon_texture
|
||
icon.custom_minimum_size = Vector2(side, side)
|
||
icon.expand_mode = TextureRect.EXPAND_IGNORE_SIZE
|
||
icon.stretch_mode = TextureRect.STRETCH_KEEP_ASPECT_CENTERED
|
||
icon.mouse_filter = Control.MOUSE_FILTER_IGNORE
|
||
return icon
|
||
|
||
|
||
func _apply_button_icon(button: Button, icon_texture: Texture2D, maximum_width: int) -> void:
|
||
if icon_texture == null:
|
||
return
|
||
button.icon = icon_texture
|
||
button.add_theme_constant_override("icon_max_width", maximum_width)
|
||
button.expand_icon = true
|
||
|
||
|
||
func _apply_button_style(button: Button) -> void:
|
||
button.add_theme_color_override("font_color", _visual_color(&"text_light", Color("fff0c8")))
|
||
button.add_theme_color_override("font_hover_color", Color("fff8e5"))
|
||
button.add_theme_color_override("font_pressed_color", Color("fff8e5"))
|
||
button.add_theme_color_override("font_disabled_color", Color("a98e68"))
|
||
button.add_theme_stylebox_override("normal", _themed_panel_style(&"button_normal", _visual_color(&"button_normal", Color("75451f")), _visual_color(&"border_gold", Color("b77b37")), 7, 7))
|
||
button.add_theme_stylebox_override("hover", _themed_panel_style(&"button_hover", _visual_color(&"button_hover", Color("8d5628")), _visual_color(&"border_gold", Color("e4b45c")), 7, 7))
|
||
button.add_theme_stylebox_override("pressed", _themed_panel_style(&"button_pressed", _visual_color(&"button_pressed", Color("496528")), _visual_color(&"border_gold", Color("d8bd61")), 7, 7))
|
||
button.add_theme_stylebox_override("focus", _themed_panel_style(&"button_pressed", _visual_color(&"button_pressed", Color("496528")), _visual_color(&"border_gold", Color("f2d97d")), 7, 7))
|
||
button.add_theme_stylebox_override("disabled", _themed_panel_style(&"button_disabled", _visual_color(&"button_disabled", Color("574334")), Color("7b6955"), 7, 7))
|
||
|
||
|
||
func _section_heading(text_value: String) -> Label:
|
||
var heading := Label.new()
|
||
heading.text = text_value
|
||
heading.add_theme_font_size_override("font_size", 14)
|
||
heading.add_theme_color_override("font_color", _visual_color(&"text_dark", Color("55371e")))
|
||
return heading
|
||
|
||
|
||
func _panel_style(color: Color, border_color: Color, radius := 8, margin := 12) -> StyleBoxFlat:
|
||
var style := StyleBoxFlat.new()
|
||
style.bg_color = color
|
||
style.border_color = border_color
|
||
style.set_border_width_all(1)
|
||
style.set_corner_radius_all(mini(radius, 1))
|
||
style.set_content_margin_all(margin)
|
||
style.shadow_size = 0
|
||
return style
|
||
|
||
|
||
func _themed_panel_style(_skin_id: StringName, color: Color, border_color: Color, radius := 0, margin := 5) -> StyleBox:
|
||
# Small flat frames keep attention on the animated cross-section.
|
||
return _panel_style(color, border_color, mini(radius, 1), mini(margin, 6))
|
||
|
||
|
||
func _set_status(message: String, success: bool, quiet := false) -> void:
|
||
if build_status_label == null:
|
||
return
|
||
build_status_label.text = message
|
||
build_status_label.tooltip_text = message
|
||
if quiet:
|
||
build_status_label.add_theme_color_override("font_color", Color("c7d3a8") if success else Color("ffb498"))
|
||
else:
|
||
build_status_label.add_theme_color_override("font_color", Color("d8e8ad") if success else Color("ffb498"))
|
||
|
||
|
||
func _visual_color(property_name: StringName, fallback: Color) -> Color:
|
||
var interface_colors := {
|
||
&"window_background": Color("17261f"),
|
||
&"dark_panel": Color("24392e"),
|
||
&"dark_panel_alt": Color("20342a"),
|
||
&"light_panel": Color("e9e6cd"),
|
||
&"border_gold": Color("778267"),
|
||
&"text_light": Color("eae7cc"),
|
||
&"text_dark": Color("344838"),
|
||
&"button_normal": Color("354b39"),
|
||
&"button_hover": Color("4c6246"),
|
||
&"button_pressed": Color("79623c"),
|
||
&"button_disabled": Color("354135"),
|
||
}
|
||
if interface_colors.has(property_name):
|
||
return interface_colors[property_name]
|
||
if visual_theme == null:
|
||
return fallback
|
||
var value: Variant = visual_theme.get(property_name)
|
||
return value if value is Color else fallback
|
||
|
||
|
||
func _service(property_name: StringName) -> Variant:
|
||
if _runtime == null or not _runtime is Object:
|
||
return null
|
||
for property: Dictionary in _runtime.get_property_list():
|
||
if StringName(property.get(&"name", &"")) == property_name:
|
||
return _runtime.get(property_name)
|
||
return null
|
||
|
||
|
||
func _call_array(service: Variant, method_name: StringName) -> Array:
|
||
if service == null or not service.has_method(method_name):
|
||
return []
|
||
var result: Variant = service.call(method_name)
|
||
return result if result is Array else []
|
||
|
||
|
||
func _facility_definition(definition_id: StringName) -> Variant:
|
||
var registry: Variant = _service(&"definition_registry")
|
||
if registry == null or not registry.has_method(&"get_facility"):
|
||
return null
|
||
return registry.call(&"get_facility", definition_id)
|
||
|
||
|
||
func _construction_facility(instance_id: StringName) -> Dictionary:
|
||
var construction: Variant = _service(&"construction_service")
|
||
if construction == null or not construction.has_method(&"get_facility"):
|
||
return {}
|
||
var result: Variant = construction.call(&"get_facility", instance_id)
|
||
return result if result is Dictionary else {}
|
||
|
||
|
||
func _facility_reasons(reasons_value: Variant) -> String:
|
||
if not reasons_value is Array:
|
||
return ""
|
||
var names: Array[String] = []
|
||
for reason_value: Variant in reasons_value:
|
||
var reason := StringName(reason_value)
|
||
names.append(String(FACILITY_REASON_NAMES.get(reason, reason)))
|
||
return "・".join(names)
|
||
|
||
|
||
func _definition_value(source: Variant, property_name: StringName, fallback: Variant) -> Variant:
|
||
if source is Dictionary:
|
||
return source.get(property_name, source.get(String(property_name), fallback))
|
||
if source == null or not source is Object:
|
||
return fallback
|
||
for property: Dictionary in source.get_property_list():
|
||
if StringName(property.get(&"name", &"")) == property_name:
|
||
return source.get(property_name)
|
||
return fallback
|