achievement_screen.gd

Go to the documentation of this file.

extends RefCounted
 
 
 
var layout_manager
var settings_manager
var ui_flow_manager
var default_size := Vector2i(340, 500)
var global_achievement_path := ""
 
 
func configure(layout, settings = null, ui_flow = null, options:Dictionary = {}) -> void:
    layout_manager = layout
    settings_manager = settings
    ui_flow_manager = ui_flow
    default_size = _coerce_size(options.get("size", default_size), default_size)
    global_achievement_path = str(options.get("global_achievement_path", global_achievement_path))
 
 
 
func show_popup(parent:Node, stats_manager, filters:Dictionary = {}, options:Dictionary = {}) -> PopupPanel:
    var popup = PopupPanel.new()
    popup.name = str(options.get("name", "AchievementsOverlay"))
    var popup_size = _coerce_size(options.get("size", _popup_size(parent, options)), default_size)
    popup.size = popup_size
    popup.min_size = _coerce_size(options.get("minimum", Vector2i(280, 220)), Vector2i(280, 220))
    var margin := int(options.get("margin", 14))
    var content_options := options.duplicate(true)
    content_options["popup_owner"] = popup
    var content = _build_content(stats_manager, filters, content_options)
    content.set_anchors_preset(Control.PRESET_FULL_RECT)
    content.offset_left = margin
    content.offset_top = margin
    content.offset_right = -margin
    content.offset_bottom = -margin
    popup.add_child(content)
    if parent != null:
        parent.add_child(popup)
    if layout_manager != null:
        layout_manager.apply_theme(popup, str(_settings_value("theme", "dark")))
    if settings_manager != null and settings_manager.has_method("apply_text_size"):
        settings_manager.apply_text_size(popup)
    _fit_content(popup, popup_size, margin)
    if bool(options.get("auto_popup", true)) and popup.is_inside_tree():
        popup_centered(popup, _parent_viewport_size(parent), {
            "size": popup_size,
            "minimum": popup.min_size,
            "content_margin": margin
        })
    call_deferred("_focus_popup", popup)
    return popup
 
 
 
func render_page(parent:Node, stats_manager, filters:Dictionary = {}, options:Dictionary = {}) -> VBoxContainer:
    var content = _build_content(stats_manager, filters, options)
    content.name = str(options.get("name", "AchievementsPage"))
    _fit_page_content(parent, content, options)
    if parent != null:
        parent.add_child(content)
    if layout_manager != null and parent != null:
        layout_manager.apply_theme(parent, str(_settings_value("theme", "dark")))
    if settings_manager != null and settings_manager.has_method("apply_text_size") and parent != null:
        settings_manager.apply_text_size(parent)
    call_deferred("_focus_popup", content)
    return content
 
 
 
func update_popup(popup:PopupPanel, stats_manager, filters:Dictionary = {}, options:Dictionary = {}) -> void:
    if popup == null or not is_instance_valid(popup):
        return
    var margin := int(options.get("margin", 14))
    for child in popup.get_children():
        popup.remove_child(child)
        child.queue_free()
    var content_options := options.duplicate(true)
    content_options["popup_owner"] = popup
    var content = _build_content(stats_manager, filters, content_options)
    content.set_anchors_preset(Control.PRESET_FULL_RECT)
    content.offset_left = margin
    content.offset_top = margin
    content.offset_right = -margin
    content.offset_bottom = -margin
    popup.add_child(content)
    if layout_manager != null:
        layout_manager.apply_theme(popup, str(_settings_value("theme", "dark")))
    if settings_manager != null and settings_manager.has_method("apply_text_size"):
        settings_manager.apply_text_size(popup)
    _fit_content(popup, _coerce_size(options.get("size", popup.size), popup.size), margin)
    call_deferred("_focus_popup", 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:Vector2i
    if layout_manager != null and layout_manager.has_method("popup_centered_standard"):
        layout_manager.popup_centered_standard(popup, viewport_size, options)
        popup_size = popup.size
    else:
        popup_size = _fallback_fit_popup(popup, viewport_size, options)
        popup.size = popup_size
    _fit_content(popup, popup_size, int(options.get("content_margin", options.get("margin", 14))))
    if (layout_manager == null or not layout_manager.has_method("popup_centered_standard")) and popup.is_inside_tree():
        popup.popup_centered(popup_size)
 
 
func _focus_popup(popup:Node) -> void:
    if is_instance_valid(popup) and popup.is_inside_tree() and ui_flow_manager != null and ui_flow_manager.has_method("focus_first"):
        ui_flow_manager.focus_first(popup)
 
 
func _build_content(stats_manager, filters:Dictionary, options:Dictionary) -> VBoxContainer:
    _refresh_global_achievement_state(stats_manager)
    var content = VBoxContainer.new()
    content.name = "Content"
    content.size_flags_horizontal = Control.SIZE_EXPAND_FILL
    content.size_flags_vertical = Control.SIZE_EXPAND_FILL
    content.add_theme_constant_override("separation", int(options.get("separation", 8)))
 
    var title = Label.new()
    title.name = "Title"
    title.text = str(options.get("title", "Achievements"))
    title.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
    title.autowrap_mode = TextServer.AUTOWRAP_WORD_SMART
    title.size_flags_horizontal = Control.SIZE_EXPAND_FILL
    title.add_theme_font_size_override("font_size", int(options.get("title_size", 20)))
    content.add_child(title)
 
    if options.has("filter_options") and layout_manager != null:
        var filter_options:Dictionary = options.get("filter_options", {})
        var filter_callback:Callable = options.get("filter_callback", Callable())
        var filter_bar = layout_manager.create_achievement_filter_bar(filter_options, filters, filter_callback)
        filter_bar.name = "Filters"
        content.add_child(filter_bar)
 
    if layout_manager != null and stats_manager != null:
        var collection_options:Dictionary = options.get("collection_options", {})
        var collection = layout_manager.create_achievement_collection(stats_manager.get_achievement_collection(filters), collection_options)
        collection.name = "Collection"
        var collection_min_height := float(options.get("collection_min_height", collection_options.get("min_height", 220.0)))
        collection.custom_minimum_size = Vector2(0, maxf(120.0, collection_min_height))
        collection.size_flags_horizontal = Control.SIZE_EXPAND_FILL
        collection.size_flags_vertical = Control.SIZE_EXPAND_FILL
        content.add_child(collection)
 
    var back = Button.new()
    back.name = "Back"
    back.text = str(options.get("back_label", "Back"))
    back.custom_minimum_size = Vector2(0, int(options.get("button_height", 44)))
    back.size_flags_horizontal = Control.SIZE_EXPAND_FILL
    var back_callback:Callable = options.get("back_callback", Callable())
    back.pressed.connect(func():
        if options.has("popup_owner") and options["popup_owner"] is PopupPanel:
            options["popup_owner"].hide()
        if back_callback.is_valid():
            back_callback.call()
    )
    content.add_child(back)
    return content
 
 
func _refresh_global_achievement_state(stats_manager) -> void:
    if stats_manager != null and stats_manager.has_method("load_global_achievement_state"):
        if global_achievement_path != "":
            stats_manager.load_global_achievement_state(global_achievement_path)
        else:
            stats_manager.load_global_achievement_state()
 
 
func _fit_page_content(parent:Node, content:Control, options:Dictionary) -> void:
    if content == null:
        return
    var viewport_size := _parent_viewport_size(parent)
    var width := float(options.get("page_width", 0.0))
    var height := float(options.get("page_height", 0.0))
    if viewport_size != Vector2.ZERO:
        var margin_x := float(options.get("page_margin_x", 48.0))
        var margin_y := float(options.get("page_margin_y", 220.0))
        width = maxf(width, viewport_size.x - margin_x)
        height = maxf(height, viewport_size.y - margin_y)
    content.custom_minimum_size = Vector2(maxf(280.0, width), maxf(320.0, height))
    content.size_flags_horizontal = Control.SIZE_EXPAND_FILL
    content.size_flags_vertical = Control.SIZE_EXPAND_FILL
    var collection = content.get_node_or_null("Collection")
    if collection is Control:
        var reserved_height := float(options.get("reserved_height", 156.0))
        var collection_min := float(options.get("collection_min_height", 0.0))
        if viewport_size != Vector2.ZERO:
            collection_min = maxf(collection_min, viewport_size.y - float(options.get("page_margin_y", 220.0)) - reserved_height)
        collection.custom_minimum_size.y = maxf(180.0, collection_min)
 
 
func _popup_size(parent:Node, options:Dictionary) -> Vector2i:
    var requested = _coerce_size(options.get("size", default_size), default_size)
    var viewport_size := _parent_viewport_size(parent)
    if viewport_size != Vector2.ZERO:
        var available_width:int = max(260, int(viewport_size.x) - int(options.get("viewport_margin_x", 24)))
        var available_height:int = max(260, int(viewport_size.y) - int(options.get("viewport_margin_y", 24)))
        return Vector2i(
            min(requested.x, available_width),
            min(requested.y, available_height)
        )
    return requested
 
 
func _parent_viewport_size(parent:Node) -> Vector2:
    if parent is Control and parent.is_inside_tree():
        return parent.get_viewport_rect().size
    if parent != null and parent.is_inside_tree():
        var viewport := parent.get_viewport()
        if viewport != null:
            return viewport.get_visible_rect().size
    return Vector2.ZERO
 
 
func _fallback_fit_popup(popup:PopupPanel, viewport_size:Vector2, options:Dictionary) -> Vector2i:
    var requested = _coerce_size(options.get("size", popup.size), default_size)
    var minimum = _coerce_size(options.get("minimum", popup.min_size), Vector2i(260, 180))
    var margin := int(options.get("margin", 24))
    var available = Vector2i(max(1, int(viewport_size.x) - margin), max(1, int(viewport_size.y) - margin))
    var effective_min = Vector2i(min(minimum.x, available.x), min(minimum.y, available.y))
    return Vector2i(
        clamp(requested.x, effective_min.x, available.x),
        clamp(requested.y, effective_min.y, available.y)
    )
 
 
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 _fit_content(popup:PopupPanel, popup_size:Vector2i, margin:int) -> void:
    if popup == null or not is_instance_valid(popup):
        return
    var content = popup.get_node_or_null("Content")
    if content is Control:
        content.set_anchors_preset(Control.PRESET_FULL_RECT)
        content.offset_left = margin
        content.offset_top = margin
        content.offset_right = -margin
        content.offset_bottom = -margin
    var collection = popup.get_node_or_null("Content/Collection")
    if collection is Control:
        collection.custom_minimum_size = Vector2(0, 0)
        collection.size_flags_vertical = Control.SIZE_EXPAND_FILL
 
 
func _settings_value(key:String, default_value):
    if settings_manager != null and settings_manager.has_method("get_settings"):
        return settings_manager.get_settings().get(key, default_value)
    return default_value