docs/menu__manager_8gd_source.html

extends RefCounted


const DataCacheManager = preload("res://scripts/systems/dataCacheManager/data_cache_manager.gd")


var config := {}

var current_screen_id := ""

var context := {}

var screen_stack := []

var data_cache_manager = DataCacheManager.new()


func load_menu(file_path:String) -> void:

    var data = data_cache_manager.load_json(file_path)

    config = data if data is Dictionary else {}

    current_screen_id = str(config.get("start_screen", ""))

    screen_stack.clear()


func get_cache_stats() -> Dictionary:

    return data_cache_manager.get_cache_stats()


func set_context(values:Dictionary) -> void:

    context = values.duplicate(true)


func update_context(values:Dictionary) -> void:

    for key in values.keys():

        context[key] = values[key]


func show_screen(screen_id:String, add_to_stack:bool = true) -> bool:

    if not get_screens().has(screen_id):

        return false

    if add_to_stack and current_screen_id != "":

        screen_stack.append(current_screen_id)

    current_screen_id = screen_id

    return true


func go_back() -> bool:

    if screen_stack.is_empty():

        return false

    current_screen_id = str(screen_stack.pop_back())

    return true


func get_current_screen() -> Dictionary:

    return get_screen(current_screen_id)


func get_screen(screen_id:String) -> Dictionary:

    return get_screens().get(screen_id, {})


func get_screens() -> Dictionary:

    return config.get("screens", {})


func get_current_screen_id() -> String:

    return current_screen_id


func get_render_items(screen_id:String = "") -> Array:

    var screen = get_current_screen() if screen_id == "" else get_screen(screen_id)

    var items = []

    for raw_item in screen.get("items", []):

        if not raw_item is Dictionary:

            continue

        for expanded_item in expand_item(raw_item):

            if not is_item_visible(expanded_item):

                continue

            expanded_item["disabled"] = is_item_disabled(expanded_item)

            expanded_item["display_label"] = format_item_label(expanded_item)

            items.append(expanded_item)

    return items


func expand_item(item:Dictionary) -> Array:

    var template_id = str(item.get("template", ""))

    if template_id == "":

        return [item.duplicate(true)]

    if template_id == "save_slots":

        return _expand_save_slots(item)

    if template_id == "game_profiles":

        return _expand_game_profiles(item)

    if template_id == "platformer_levels":

        return _expand_platformer_levels(item)

    var templates = config.get("templates", {})

    if templates.has(template_id) and templates[template_id] is Array:

        var expanded = []

        for template_item in templates[template_id]:

            if template_item is Dictionary:

                expanded.append(_merge_template_item(template_item, item))

        return expanded

    return []


func is_item_visible(item:Dictionary) -> bool:

    if not item.has("visible_when"):

        return true

    return _evaluate_condition(item.get("visible_when", {}))


func is_item_disabled(item:Dictionary) -> bool:

    if not item.has("disabled_when"):

        return false

    return _evaluate_condition(item.get("disabled_when", {}))


func format_item_label(item:Dictionary) -> String:

    var label = str(item.get("label", "Menu Item"))

    var formatter = str(item.get("metadata_formatter", ""))

    if formatter == "":

        return label

    var data = item.get("metadata", context.get(formatter, {}))

    if data is Dictionary and not data.is_empty():

        return label + "\n" + _format_metadata(data)

    return label


func get_confirmation(item:Dictionary) -> Dictionary:

    var confirm = item.get("confirm", {})

    return confirm if confirm is Dictionary else {}


func get_item_sprite_id(item:Dictionary) -> String:

    var explicit = str(item.get("sprite_id", "")).strip_edges()

    if explicit != "":

        return explicit

    var icons = config.get("icons", {})

    if not icons is Dictionary:

        return ""

    var label_icons = icons.get("labels", {})

    if label_icons is Dictionary:

        var label_key = str(item.get("label", item.get("display_label", ""))).strip_edges().to_lower()

        if label_icons.has(label_key):

            return str(label_icons[label_key])

    var action = str(item.get("action", ""))

    var action_icons = icons.get("actions", {})

    if action_icons is Dictionary and action_icons.has(action):

        return str(action_icons[action])

    if action == "screen":

        var target = str(item.get("target", ""))

        var target_icons = icons.get("targets", {})

        if target_icons is Dictionary and target_icons.has(target):

            return str(target_icons[target])

    return str(icons.get("fallback", ""))


func _format_metadata(data:Dictionary) -> String:

    if data.has("status"):

        return str(data["status"])

    if data.has("money") or data.has("cards") or data.has("wins") or data.has("losses"):

        var updated = str(data.get("updated_label", ""))

        var lines = [

            "$%d | %d cards" % [int(data.get("money", 0)), int(data.get("cards", 0))],

            "%dW / %dL" % [int(data.get("wins", 0)), int(data.get("losses", 0))]

        ]

        if updated != "":

            lines.append("Updated %s" % updated)

        return "\n".join(lines)

    var parts = []

    for key in data.keys():

        if str(key) in ["empty", "updated_at", "slot"]:

            continue

        parts.append("%s: %s" % [str(key).capitalize(), str(data[key])])

    return " | ".join(parts)


func _evaluate_condition(rule) -> bool:

    if rule is Array:

        for child_rule in rule:

            if _evaluate_condition(child_rule):

                return true

        return false

    if not rule is Dictionary:

        return false

    if rule.has("all"):

        for child_rule in rule["all"]:

            if not _evaluate_condition(child_rule):

                return false

        return true

    if rule.has("any"):

        for child_rule in rule["any"]:

            if _evaluate_condition(child_rule):

                return true

        return false

    if rule.has("not"):

        return not _evaluate_condition(rule["not"])

    var key = str(rule.get("key", ""))

    var value = _get_context_value(key)

    if rule.has("equals"):

        return value == rule["equals"]

    if rule.has("not_equals"):

        return value != rule["not_equals"]

    if rule.has("greater_than"):

        return float(value) > float(rule["greater_than"])

    if rule.has("less_than"):

        return float(value) < float(rule["less_than"])

    if rule.has("at_least"):

        return float(value) >= float(rule["at_least"])

    if rule.has("at_most"):

        return float(value) <= float(rule["at_most"])

    if rule.has("missing"):

        return bool(rule["missing"]) and (value == null or value == false)

    if rule.has("present"):

        return bool(rule["present"]) and value != null and value != false

    return false


func _get_context_value(path:String):

    if path == "":

        return null

    var parts = path.split(".")

    var value = context

    for part in parts:

        if value is Dictionary and value.has(part):

            value = value[part]

        else:

            return null

    return value


func _expand_save_slots(item:Dictionary) -> Array:

    var slots = context.get(str(item.get("source", "save_slots")), [])

    var expanded = []

    for slot in slots:

        if not slot is Dictionary:

            continue

        var slot_item = item.duplicate(true)

        slot_item.erase("template")

        slot_item["label"] = _format_template(str(item.get("label_template", "Slot {slot}")), slot)

        slot_item["metadata"] = slot

        slot_item["action"] = str(item.get("slot_action", item.get("action", "save_slot")))

        slot_item["slot"] = int(slot.get("slot", 0))

        slot_item["empty"] = bool(slot.get("empty", false))

        if bool(slot.get("empty", false)):

            slot_item["display_state"] = "empty"

        expanded.append(slot_item)

    return expanded


func _expand_game_profiles(item:Dictionary) -> Array:

    var profiles = context.get(str(item.get("source", "game_profiles")), [])

    var expanded = []

    for profile in profiles:

        if not profile is Dictionary:

            continue

        var profile_item = item.duplicate(true)

        profile_item.erase("template")

        profile_item["label"] = str(profile.get("menu_label", profile.get("label", profile.get("id", "Game"))))

        profile_item["action"] = str(profile.get("action", item.get("profile_action", "screen")))

        profile_item["target"] = str(profile.get("target", profile.get("menu_route", profile.get("id", ""))))

        profile_item["game_id"] = str(profile.get("id", profile.get("game_id", "")))

        profile_item["metadata"] = profile.duplicate(true)

        if profile.has("sprite_id"):

            profile_item["sprite_id"] = str(profile["sprite_id"])

        if profile.has("description"):

            profile_item["description"] = str(profile["description"])

        expanded.append(profile_item)

    return expanded


func _expand_platformer_levels(item:Dictionary) -> Array:

    var levels = context.get(str(item.get("source", "platformer_levels")), [])

    var expanded := []

    for level in levels:

        if not level is Dictionary:

            continue

        var level_item = item.duplicate(true)

        level_item.erase("template")

        level_item["label"] = str(level.get("display_label", level.get("name", level.get("id", "Level"))))

        level_item["action"] = str(item.get("level_action", "platformer_select_level"))

        level_item["level_id"] = str(level.get("id", ""))

        level_item["metadata"] = level.duplicate(true)

        if bool(level.get("locked", false)):

            level_item["disabled_when"] = {"key": "platformer_level_locks.%s" % str(level.get("id", "")), "equals": true}

        level_item["sprite_id"] = "lock" if bool(level.get("locked", false)) else ("check" if bool(level.get("cleared", false)) else "play")

        expanded.append(level_item)

    return expanded


func _format_template(template:String, values:Dictionary) -> String:

    var formatted = template

    for key in values.keys():

        formatted = formatted.replace("{%s}" % str(key), str(values[key]))

    return formatted


func _merge_template_item(template_item:Dictionary, source_item:Dictionary) -> Dictionary:

    var merged = template_item.duplicate(true)

    for key in source_item.keys():

        if key != "template":

            merged[key] = source_item[key]

    return merged

menu_manager.bool
bool
Set current screen id when it exists.
Definition menu_manager.gd:47