results_screen_controller.gd

Go to the documentation of this file.

extends RefCounted
 
 
 
 
 
func create(summary:Dictionary, actions:Array = [], options:Dictionary = {}) -> Control:
    var root = VBoxContainer.new()
    root.name = str(options.get("name", "ResultsScreen"))
    root.size_flags_horizontal = Control.SIZE_EXPAND_FILL
    root.size_flags_vertical = Control.SIZE_EXPAND_FILL
    root.custom_minimum_size = options.get("minimum_size", Vector2.ZERO)
    root.add_theme_constant_override("separation", int(options.get("separation", 10)))
    var title = Label.new()
    title.name = "Title"
    title.text = str(options.get("title", _title_for(summary)))
    title.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
    title.add_theme_font_size_override("font_size", int(options.get("title_size", 22)))
    root.add_child(title)
    var message = Label.new()
    message.name = "Message"
    message.text = str(options.get("message", summary.get("result", {}).get("message", "")))
    message.autowrap_mode = TextServer.AUTOWRAP_WORD_SMART
    message.horizontal_alignment = int(options.get("message_alignment", HORIZONTAL_ALIGNMENT_LEFT))
    message.visible = message.text != ""
    var details_scroll = ScrollContainer.new()
    details_scroll.name = "DetailsScroll"
    details_scroll.size_flags_horizontal = Control.SIZE_EXPAND_FILL
    details_scroll.size_flags_vertical = Control.SIZE_EXPAND_FILL
    details_scroll.horizontal_scroll_mode = ScrollContainer.SCROLL_MODE_DISABLED
    root.add_child(details_scroll)
    var details = VBoxContainer.new()
    details.name = "Details"
    details.size_flags_horizontal = Control.SIZE_EXPAND_FILL
    details.add_theme_constant_override("separation", int(options.get("detail_separation", 8)))
    details_scroll.add_child(details)
    details.add_child(message)
    if bool(options.get("show_sections", true)):
        details.add_child(_section("Counters", _format_counts(summary.get("counters", {}), "No counters recorded.")))
        details.add_child(_section("Collected", _format_counts(summary.get("collected", {}), "Nothing collected.")))
        details.add_child(_section("Rewards", _format_counts(summary.get("rewards", {}), "No rewards earned.")))
        var objective_text = "%d / %d required objectives" % [
            int(summary.get("completed_required_objectives", 0)),
            int(summary.get("required_objectives", 0))
        ]
        details.add_child(_section("Objectives", objective_text))
    var action_row = HBoxContainer.new()
    action_row.name = "Actions"
    action_row.size_flags_horizontal = Control.SIZE_EXPAND_FILL
    action_row.add_theme_constant_override("separation", 8)
    var free_on_action := bool(options.get("free_on_action", false))
    for action in actions:
        if not action is Dictionary:
            continue
        var button = Button.new()
        button.name = str(action.get("name", _node_name(str(action.get("id", "Action")))))
        button.text = str(action.get("label", action.get("id", "Action")))
        button.disabled = bool(action.get("disabled", false))
        button.size_flags_horizontal = Control.SIZE_EXPAND_FILL
        button.custom_minimum_size = Vector2(0, int(options.get("action_button_height", 44)))
        var callback = action.get("callback", Callable())
        button.pressed.connect(func():
            _close_parent_popup(button, free_on_action)
            if callback is Callable and callback.is_valid():
                callback.call()
        )
        action_row.add_child(button)
    root.add_child(action_row)
    return root
 
 
 
func create_popup(owner:Node, summary:Dictionary, actions:Array = [], options:Dictionary = {}) -> PopupPanel:
    var popup = PopupPanel.new()
    popup.name = str(options.get("popup_name", "ResultsPopup"))
    popup.size = _coerce_size(options.get("size", Vector2i(360, 320)), Vector2i(360, 320))
    var content_options = options.duplicate(true)
    content_options["name"] = str(options.get("content_name", "Content"))
    content_options["minimum_size"] = options.get("minimum_size", Vector2.ZERO)
    var content = create(summary, actions, content_options)
    content.set_anchors_preset(Control.PRESET_FULL_RECT)
    content.offset_left = int(options.get("margin", 18))
    content.offset_top = int(options.get("margin", 18))
    content.offset_right = -int(options.get("margin", 18))
    content.offset_bottom = -int(options.get("margin", 18))
    content.custom_minimum_size = Vector2.ZERO
    popup.add_child(content)
    if owner != null:
        owner.add_child(popup)
    return popup
 
 
func popup_centered(popup:PopupPanel, viewport_size:Vector2, options:Dictionary = {}) -> void:
    if popup == null or not is_instance_valid(popup):
        return
    var popup_size = fit_popup_to_viewport(popup, viewport_size, options)
    popup.size = popup_size
    _fit_content(popup, popup_size, int(options.get("content_margin", 18)))
    if popup.is_inside_tree():
        popup.popup_centered(popup_size)
 
 
 
func show_popup(owner:Node, summary:Dictionary, actions:Array = [], options:Dictionary = {}) -> PopupPanel:
    var popup:PopupPanel = create_popup(owner, summary, actions, options)
    var viewport_size:Vector2 = _coerce_vector2(options.get("viewport_size", Vector2.ZERO), Vector2.ZERO)
    if viewport_size == Vector2.ZERO and owner != null and owner.is_inside_tree():
        viewport_size = owner.get_viewport_rect().size
    if viewport_size == Vector2.ZERO:
        var fallback_size:Vector2i = _coerce_size(options.get("size", Vector2i(360, 320)), Vector2i(360, 320))
        viewport_size = Vector2(float(fallback_size.x), float(fallback_size.y))
    popup_centered(popup, viewport_size, options)
    apply_theme_and_focus(
        popup,
        options.get("layout_manager", null),
        options.get("settings_manager", null),
        options.get("ui_flow_manager", null),
        str(options.get("theme_id", "dark")),
        options
    )
    return popup
 
 
 
func fit_popup_to_viewport(popup:PopupPanel, viewport_size:Vector2, options:Dictionary = {}) -> Vector2i:
    var requested = _coerce_size(options.get("size", popup.size), Vector2i(360, 320))
    var margin := int(options.get("margin", 24))
    var min_size = _coerce_size(options.get("minimum", Vector2i(260, 180)), Vector2i(260, 180))
    var available = Vector2i(max(1, int(viewport_size.x) - margin), max(1, int(viewport_size.y) - margin))
    var effective_min = Vector2i(min(min_size.x, available.x), min(min_size.y, available.y))
    var popup_size = Vector2i(
        clamp(requested.x, effective_min.x, available.x),
        clamp(requested.y, effective_min.y, available.y)
    )
    popup.min_size = Vector2i(min(min_size.x, popup_size.x), min(min_size.y, popup_size.y))
    return popup_size
 
 
func _fit_content(popup:PopupPanel, popup_size:Vector2i, content_margin:int) -> void:
    if popup == null or not is_instance_valid(popup):
        return
    var content = popup.get_node_or_null("Content")
    if not content is Control:
        return
    content.set_anchors_preset(Control.PRESET_FULL_RECT)
    content.offset_left = content_margin
    content.offset_top = content_margin
    content.offset_right = -content_margin
    content.offset_bottom = -content_margin
    content.custom_minimum_size = Vector2.ZERO
    content.size_flags_horizontal = Control.SIZE_EXPAND_FILL
    content.size_flags_vertical = Control.SIZE_EXPAND_FILL
    var details_scroll = content.get_node_or_null("DetailsScroll")
    if details_scroll is Control:
        details_scroll.size_flags_vertical = Control.SIZE_EXPAND_FILL
 
 
func apply_theme_and_focus(popup:PopupPanel, layout_manager, settings_manager = null, ui_flow_manager = null, theme_id:String = "dark", options:Dictionary = {}) -> void:
    if popup == null or not is_instance_valid(popup):
        return
    if layout_manager is Object and layout_manager.has_method("apply_theme"):
        layout_manager.apply_theme(popup, theme_id)
    if settings_manager is Object and settings_manager.has_method("apply_text_size"):
        settings_manager.apply_text_size(popup)
    if not (ui_flow_manager is Object):
        return
    if options.has("focus_node") and ui_flow_manager.has_method("focus_named"):
        ui_flow_manager.focus_named(popup, str(options.get("focus_node", "")))
    elif options.has("focus_labels") and ui_flow_manager.has_method("focus_button_by_text"):
        ui_flow_manager.focus_button_by_text(popup, options.get("focus_labels", []))
    elif ui_flow_manager.has_method("focus_first"):
        ui_flow_manager.focus_first(popup)
 
 
func _title_for(summary:Dictionary) -> String:
    var mode = str(summary.get("mode", "Run")).replace("_", " ").capitalize()
    var status = str(summary.get("status", "complete")).replace("_", " ").capitalize()
    return "%s %s" % [mode, status]
 
 
func _section(title_text:String, body_text:String) -> Control:
    var panel = VBoxContainer.new()
    panel.name = _node_name(title_text)
    panel.add_theme_constant_override("separation", 2)
    var title = Label.new()
    title.name = "Title"
    title.text = title_text
    title.add_theme_font_size_override("font_size", 16)
    panel.add_child(title)
    var body = Label.new()
    body.name = "Body"
    body.text = body_text
    body.autowrap_mode = TextServer.AUTOWRAP_WORD_SMART
    panel.add_child(body)
    return panel
 
 
func _format_counts(counts, empty_label:String) -> String:
    if not counts is Dictionary:
        return empty_label
    var parts := []
    var keys = counts.keys()
    keys.sort()
    for key in keys:
        var amount = int(counts[key])
        if amount <= 0:
            continue
        parts.append("%dx %s" % [amount, str(key).replace("_", " ").capitalize()])
    return empty_label if parts.is_empty() else ", ".join(parts)
 
 
func _node_name(value:String) -> String:
    var parts = value.replace("-", "_").replace(" ", "_").split("_")
    var text := ""
    for part in parts:
        text += str(part).capitalize()
    return text if text != "" else "Node"
 
 
func _coerce_size(value, fallback:Vector2i) -> Vector2i:
    if value is Vector2i:
        return value
    if value is Vector2:
        return Vector2i(int(value.x), int(value.y))
    if value is Dictionary:
        return Vector2i(int(value.get("x", fallback.x)), int(value.get("y", fallback.y)))
    return fallback
 
 
func _coerce_vector2(value, fallback:Vector2) -> Vector2:
    if value is Vector2:
        return value
    if value is Vector2i:
        return Vector2(float(value.x), float(value.y))
    if value is Dictionary:
        return Vector2(float(value.get("x", fallback.x)), float(value.get("y", fallback.y)))
    return fallback
 
 
func _close_parent_popup(node:Node, should_free:bool = false) -> void:
    if node == null or not is_instance_valid(node):
        return
    var current = node
    while current != null:
        if current is PopupPanel:
            current.hide()
            if should_free:
                current.queue_free()
            return
        current = current.get_parent()