card_inventory_adapter.gd

Go to the documentation of this file.

extends RefCounted
 
 
 
const DEFAULT_RARITY_ORDER := {
    "Common": 0,
    "Rare": 1,
    "Epic": 2,
    "Legendary": 3
}
 
var card_manager
var modifier_manager
var rarity_order := DEFAULT_RARITY_ORDER.duplicate(true)
var resolved_card_cache:Dictionary = {}
var base_name_cache:Dictionary = {}
var cache_hits:int = 0
var cache_misses:int = 0
 
 
func configure(next_card_manager, next_modifier_manager = null, options:Dictionary = {}) -> void:
    card_manager = next_card_manager
    modifier_manager = next_modifier_manager
    rarity_order = DEFAULT_RARITY_ORDER.duplicate(true)
    for key in options.get("rarity_order", {}).keys():
        rarity_order[str(key)] = int(options["rarity_order"][key])
    clear_caches()
 
 
func filter_instances(instances:Array, filter_id:String, inventory_manager = null) -> Array:
    var filtered:Array = []
    var base_counts:Dictionary = _base_counts_for_instances(instances) if filter_id == "duplicates" else {}
    for instance in instances:
        if not instance is Dictionary:
            continue
        if _matches_filter_with_counts(instance, filter_id, inventory_manager, base_counts):
            filtered.append(instance)
    return filtered
 
 
func matches_filter(instance:Dictionary, filter_id:String, inventory_manager = null) -> bool:
    return _matches_filter_with_counts(instance, filter_id, inventory_manager, {})
 
 
func _matches_filter_with_counts(instance:Dictionary, filter_id:String, inventory_manager = null, base_counts:Dictionary = {}) -> bool:
    var card = card_from_instance(instance)
    match filter_id:
        "duplicates":
            if not base_counts.is_empty():
                return int(base_counts.get(str(instance.get("base_id", "")), 0)) > 1
            if inventory_manager != null and inventory_manager.has_method("count_card"):
                return inventory_manager.count_card(str(instance.get("base_id", ""))) > 1
            return false
        "upgraded":
            return int(instance.get("level", 1)) > 1 or has_boosted_stats(card) or not instance.get("modifier_ids", []).is_empty()
        "locked":
            return bool(instance.get("locked", false))
    return true
 
 
func sort_instances(instances:Array, sort_key:String = "rarity", ascending:bool = true) -> Array:
    var sorted:Array = instances.duplicate(true)
    sorted.sort_custom(func(a, b): return compare_instances(a, b, sort_key, ascending))
    return sorted
 
 
func compare_instances(a:Dictionary, b:Dictionary, sort_key:String = "rarity", ascending:bool = true) -> bool:
    var card_a = card_from_instance(a)
    var card_b = card_from_instance(b)
    var result := 0
    match sort_key:
        "name":
            result = compare_values(instance_base_name(a), instance_base_name(b))
        "sell":
            result = compare_values(int(card_a.get("value", 0)), int(card_b.get("value", 0)))
        "stats":
            result = compare_values(card_stat_total(card_a), card_stat_total(card_b))
        "hp":
            result = compare_values(int(card_a.get("health", 0)), int(card_b.get("health", 0)))
        "atk":
            result = compare_values(int(card_a.get("attack", 0)), int(card_b.get("attack", 0)))
        "def":
            result = compare_values(int(card_a.get("defense", 0)), int(card_b.get("defense", 0)))
        "rarity":
            result = compare_values(rarity_rank(card_a), rarity_rank(card_b))
            if result == 0:
                result = compare_values(instance_base_name(a), instance_base_name(b))
        _:
            result = compare_values(instance_base_name(a), instance_base_name(b))
    if result == 0:
        result = compare_values(str(a.get("uid", "")), str(b.get("uid", "")))
    return result < 0 if ascending else result > 0
 
 
func table_record(instance:Dictionary, options:Dictionary = {}) -> Dictionary:
    var card = card_from_instance(instance)
    var selected_id := str(options.get("selected_id", ""))
    var include_sell := bool(options.get("include_sell", true))
    var text_color:Color = options.get("text_color", Color.WHITE)
    var muted_color:Color = options.get("muted_color", Color(0.7, 0.7, 0.7))
    var accent_color:Color = options.get("accent_color", Color(0.95, 0.78, 0.42))
    var boost_color:Color = options.get("boost_color", Color(0.33, 0.85, 0.47))
    var icon_callback:Callable = options.get("icon_callback", Callable())
    var uid := str(instance.get("uid", ""))
    var values = {
        "name": {
            "text": "%s%s" % ["Selected: " if uid == selected_id and not include_sell else "", format_card_name(card)],
            "color": accent_color if uid == selected_id and not include_sell else text_color
        },
        "rarity": {"text": format_rarity_effects(card), "color": accent_color if bool(instance.get("locked", false)) else boost_color if has_boosted_stats(card) else muted_color},
        "hp": {"text": str(int(card.get("health", 0))), "color": stat_display_color(card, "health", text_color, boost_color), "align": HORIZONTAL_ALIGNMENT_CENTER},
        "atk": {"text": str(int(card.get("attack", 0))), "color": stat_display_color(card, "attack", text_color, boost_color), "align": HORIZONTAL_ALIGNMENT_CENTER},
        "def": {"text": str(int(card.get("defense", 0))), "color": stat_display_color(card, "defense", text_color, boost_color), "align": HORIZONTAL_ALIGNMENT_CENTER}
    }
    if include_sell:
        values["sell"] = {"text": "$%d" % int(card.get("value", 0)), "color": accent_color, "align": HORIZONTAL_ALIGNMENT_RIGHT}
    var border:Color = options.get("border_color", Color(0.25, 0.25, 0.25))
    if bool(instance.get("locked", false)):
        border = accent_color
    elif has_boosted_stats(card):
        border = boost_color
    var record := {
        "id": uid,
        "selected": uid == selected_id,
        "border_color": border,
        "tooltip": _card_tooltip(card),
        "values": values
    }
    if icon_callback.is_valid():
        record["icon"] = icon_callback.call(card, instance, int(options.get("icon_size", 38)))
    return record
 
 
func _card_tooltip(card:Dictionary) -> String:
    var lines := [
        format_card_name(card),
        "%s | HP %d | ATK %d | DEF %d" % [
            format_rarity_effects(card),
            int(card.get("health", 0)),
            int(card.get("attack", 0)),
            int(card.get("defense", 0))
        ]
    ]
    var description := str(card.get("description", "")).strip_edges()
    if description != "":
        lines.append(description)
    return "\n".join(lines)
 
 
func table_records(instances:Array, options:Dictionary = {}) -> Array:
    var records:Array = []
    for instance in instances:
        if instance is Dictionary:
            records.append(table_record(instance, options))
    return records
 
 
func card_from_instance(instance:Dictionary) -> Dictionary:
    var cache_key:String = _instance_cache_key(instance)
    if resolved_card_cache.has(cache_key):
        cache_hits += 1
        return resolved_card_cache[cache_key].duplicate(true)
    cache_misses += 1
    if card_manager == null or not card_manager.has_method("get_card"):
        var fallback:Dictionary = instance.duplicate(true)
        resolved_card_cache[cache_key] = fallback
        return fallback.duplicate(true)
    var base_id = str(instance.get("base_id", instance.get("id", "")))
    var card = card_manager.get_card(base_id).duplicate(true)
    if card.is_empty():
        var missing:Dictionary = instance.duplicate(true)
        resolved_card_cache[cache_key] = missing
        return missing.duplicate(true)
    if modifier_manager != null and modifier_manager.has_method("apply_instance"):
        card = modifier_manager.apply_instance(card, instance)
    resolved_card_cache[cache_key] = card
    return card.duplicate(true)
 
 
func base_card_for(card:Dictionary) -> Dictionary:
    if card_manager == null or not card_manager.has_method("get_card"):
        return {}
    var base_id = str(card.get("base_id", card.get("base_card_id", card.get("id", ""))))
    return card_manager.get_card(base_id)
 
 
func has_boosted_stats(card:Dictionary) -> bool:
    var base_card = base_card_for(card)
    if base_card.is_empty():
        return false
    return int(card.get("health", 0)) > int(base_card.get("health", 0)) \
        or int(card.get("attack", 0)) > int(base_card.get("attack", 0)) \
        or int(card.get("defense", 0)) > int(base_card.get("defense", 0))
 
 
func stat_display_color(card:Dictionary, stat:String, normal_color:Color, boost_color:Color) -> Color:
    var base_card = base_card_for(card)
    if not base_card.is_empty() and int(card.get(stat, 0)) > int(base_card.get(stat, 0)):
        return boost_color
    return normal_color
 
 
func format_card_name(card:Dictionary) -> String:
    return str(card.get("name", "Card"))
 
 
func format_rarity_effects(card:Dictionary) -> String:
    var parts:Array = [str(card.get("rarity", "Common"))]
    var level := int(card.get("level", 1))
    if level > 1:
        parts.append("+%d" % (level - 1))
    var modifier_names:Array = []
    if modifier_manager != null and modifier_manager.has_method("get_modifier_names"):
        modifier_names = modifier_manager.get_modifier_names(card.get("modifier_ids", []))
    for name in modifier_names:
        parts.append(str(name))
    return ", ".join(parts)
 
 
func card_stat_total(card:Dictionary) -> int:
    return int(card.get("health", 0)) + int(card.get("attack", 0)) + int(card.get("defense", 0))
 
 
func instance_base_name(instance:Dictionary) -> String:
    var base_id:String = str(instance.get("base_id", instance.get("id", "")))
    if base_name_cache.has(base_id):
        cache_hits += 1
        return str(base_name_cache[base_id])
    cache_misses += 1
    if card_manager == null or not card_manager.has_method("get_card"):
        var fallback_name:String = str(instance.get("name", "")).to_lower()
        base_name_cache[base_id] = fallback_name
        return fallback_name
    var base_card = card_manager.get_card(base_id)
    var name:String = str(base_card.get("name", "")).to_lower()
    base_name_cache[base_id] = name
    return name
 
 
func rarity_rank(card:Dictionary) -> int:
    return int(rarity_order.get(str(card.get("rarity", "Common")), 99))
 
 
func compare_values(a, b) -> int:
    if a < b:
        return -1
    if a > b:
        return 1
    return 0
 
 
func clear_caches() -> void:
    resolved_card_cache.clear()
    base_name_cache.clear()
    cache_hits = 0
    cache_misses = 0
 
 
func get_cache_stats() -> Dictionary:
    return {
        "resolved_cards": resolved_card_cache.size(),
        "base_names": base_name_cache.size(),
        "cache_hits": cache_hits,
        "cache_misses": cache_misses
    }
 
 
func _base_counts_for_instances(instances:Array) -> Dictionary:
    var counts:Dictionary = {}
    for instance in instances:
        if not instance is Dictionary:
            continue
        var base_id:String = str(Dictionary(instance).get("base_id", Dictionary(instance).get("id", "")))
        if base_id == "":
            continue
        counts[base_id] = int(counts.get(base_id, 0)) + 1
    return counts
 
 
func _instance_cache_key(instance:Dictionary) -> String:
    var modifier_ids:Array = instance.get("modifier_ids", []) if instance.get("modifier_ids", []) is Array else []
    var modifier_parts:Array = []
    for id in modifier_ids:
        modifier_parts.append(str(id))
    modifier_parts.sort()
    return "%s|%s|%d|%s|%s" % [
        str(instance.get("uid", "")),
        str(instance.get("base_id", instance.get("id", ""))),
        int(instance.get("level", 1)),
        "1" if bool(instance.get("locked", false)) else "0",
        ",".join(modifier_parts)
    ]