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)
 
 
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])
 
 
func filter_instances(instances:Array, filter_id:String, inventory_manager = null) -> Array:
    var filtered:Array = []
    for instance in instances:
        if not instance is Dictionary:
            continue
        if matches_filter(instance, filter_id, inventory_manager):
            filtered.append(instance)
    return filtered
 
 
func matches_filter(instance:Dictionary, filter_id:String, inventory_manager = null) -> bool:
    var card = card_from_instance(instance)
    match filter_id:
        "duplicates":
            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,
        "values": values
    }
    if icon_callback.is_valid():
        record["icon"] = icon_callback.call(card, instance, int(options.get("icon_size", 38)))
    return record
 
 
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:
    if card_manager == null or not card_manager.has_method("get_card"):
        return instance.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():
        return instance.duplicate(true)
    if modifier_manager != null and modifier_manager.has_method("apply_instance"):
        card = modifier_manager.apply_instance(card, instance)
    return card
 
 
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:
    if card_manager == null or not card_manager.has_method("get_card"):
        return str(instance.get("name", "")).to_lower()
    var base_card = card_manager.get_card(str(instance.get("base_id", instance.get("id", ""))))
    return str(base_card.get("name", "")).to_lower()
 
 
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