card_modifier_manager.gd

Go to the documentation of this file.

extends RefCounted
 
 
 
const MODIFIERS := {
    "metal": {
        "name": "Metal",
        "rarity": "Common",
        "health": 0,
        "attack": 0,
        "defense": 3,
        "description": "+3 DEF"
    },
    "sharp": {
        "name": "Sharp",
        "rarity": "Common",
        "health": 0,
        "attack": 3,
        "defense": 0,
        "description": "+3 ATK"
    },
    "hardy": {
        "name": "Hardy",
        "rarity": "Common",
        "health": 6,
        "attack": 0,
        "defense": 0,
        "description": "+6 HP"
    },
    "blessed": {
        "name": "Blessed",
        "rarity": "Rare",
        "health": 3,
        "attack": 3,
        "defense": 3,
        "description": "+3 all stats"
    },
    "giant": {
        "name": "Giant",
        "rarity": "Rare",
        "health": 10,
        "attack": 2,
        "defense": 0,
        "description": "+10 HP, +2 ATK"
    },
    "mythic": {
        "name": "Mythic",
        "rarity": "Ultra Rare",
        "health": 8,
        "attack": 4,
        "defense": 4,
        "description": "+8 HP, +4 ATK, +4 DEF"
    }
}
 
const MAX_MERGES_BY_RARITY := {
    "Common": 5,
    "Rare": 4,
    "Epic": 3,
    "Legendary": 2
}
const GLOBAL_MAX_LEVEL := 5
 
var next_uid := 1
 
 
 
func make_card_instance(base_card:Dictionary, modifier_ids:Array = [], level:int = 1) -> Dictionary:
    var instance = {
        "uid": _make_uid(),
        "base_id": str(base_card.get("id", "")),
        "modifier_ids": modifier_ids.duplicate(),
        "level": max(1, level)
    }
    return apply_instance(base_card, instance)
 
 
 
func roll_card_instance(base_card:Dictionary) -> Dictionary:
    return make_card_instance(base_card, _roll_modifiers())
 
 
 
func apply_instance(base_card:Dictionary, instance:Dictionary) -> Dictionary:
    var card = base_card.duplicate(true)
    var level = max(1, int(instance.get("level", 1)))
    var modifier_ids = instance.get("modifier_ids", [])
    card["uid"] = str(instance.get("uid", ""))
    card["base_id"] = str(instance.get("base_id", card.get("id", "")))
    card["base_card_id"] = str(card.get("base_id", card.get("id", "")))
    card["modifier_ids"] = modifier_ids.duplicate()
    card["level"] = level
    card["locked"] = bool(instance.get("locked", false))
    card["health"] = int(card.get("health", 0)) + ((level - 1) * 4)
    card["attack"] = int(card.get("attack", 0)) + (level - 1)
    card["defense"] = int(card.get("defense", 0)) + int((level - 1) / 2)
    for modifier_id in modifier_ids:
        var modifier = MODIFIERS.get(str(modifier_id), {})
        card["health"] = int(card.get("health", 0)) + int(modifier.get("health", 0))
        card["attack"] = int(card.get("attack", 0)) + int(modifier.get("attack", 0))
        card["defense"] = int(card.get("defense", 0)) + int(modifier.get("defense", 0))
    card["value"] = _calculate_value(base_card, card, level, modifier_ids)
    card["name"] = _format_instance_name(base_card, level, modifier_ids)
    return card
 
 
 
func get_modifier_names(modifier_ids:Array) -> Array:
    var names = []
    for modifier_id in modifier_ids:
        var modifier = MODIFIERS.get(str(modifier_id), {})
        if not modifier.is_empty():
            names.append(str(modifier.get("name", modifier_id)))
    return names
 
 
 
func get_modifier_summary(modifier_ids:Array) -> String:
    var parts = []
    for modifier_id in modifier_ids:
        var modifier = MODIFIERS.get(str(modifier_id), {})
        if not modifier.is_empty():
            parts.append("%s (%s)" % [modifier.get("name", modifier_id), modifier.get("description", "")])
    return ", ".join(parts) if not parts.is_empty() else "None"
 
 
 
func get_instance_record(card:Dictionary) -> Dictionary:
    return {
        "uid": str(card.get("uid", "")),
        "base_id": str(card.get("base_id", card.get("base_card_id", card.get("id", "")))),
        "modifier_ids": card.get("modifier_ids", []).duplicate(),
        "level": int(card.get("level", 1)),
        "locked": bool(card.get("locked", false))
    }
 
 
 
func get_max_merges(base_card:Dictionary) -> int:
    return int(MAX_MERGES_BY_RARITY.get(str(base_card.get("rarity", "Common")), 1))
 
 
 
func get_max_level(base_card:Dictionary) -> int:
    return min(get_max_merges(base_card) + 1, GLOBAL_MAX_LEVEL)
 
 
 
func can_upgrade(base_card:Dictionary, instance:Dictionary) -> bool:
    return int(instance.get("level", 1)) < get_max_level(base_card)
 
 
 
func preview_upgrade(base_card:Dictionary, instance:Dictionary, material_instance:Dictionary = {}) -> Dictionary:
    var preview = instance.duplicate(true)
    var material_level = int(material_instance.get("level", 1))
    preview["level"] = min(int(preview.get("level", 1)) + material_level, get_max_level(base_card))
    return apply_instance(base_card, preview)
 
 
func reset_counter() -> void:
    next_uid = 1
 
 
func sync_counter(instances:Array) -> void:
    var highest := 0
    for instance in instances:
        var uid = str(instance.get("uid", ""))
        if uid.begins_with("card_"):
            highest = max(highest, int(uid.trim_prefix("card_")))
    next_uid = highest + 1
 
 
func _roll_modifiers() -> Array:
    var roll = randi_range(1, 100)
    if roll <= 70:
        return []
    if roll <= 92:
        return [[ "metal", "sharp", "hardy" ].pick_random()]
    if roll <= 99:
        return [[ "blessed", "giant" ].pick_random()]
    return ["mythic", [ "metal", "sharp", "hardy" ].pick_random()]
 
 
func _make_uid() -> String:
    var uid = "card_%d" % next_uid
    next_uid += 1
    return uid
 
 
func _format_instance_name(base_card:Dictionary, level:int, modifier_ids:Array) -> String:
    var names = get_modifier_names(modifier_ids)
    var prefix = " ".join(names)
    var base_name = str(base_card.get("name", "Card"))
    var level_suffix = " +%d" % (level - 1) if level > 1 else ""
    return ("%s %s%s" % [prefix, base_name, level_suffix]).strip_edges()
 
 
func _calculate_value(base_card:Dictionary, card:Dictionary, level:int, modifier_ids:Array) -> int:
    var base_value = int(base_card.get("value", 0))
    var stat_gain = max(0, int(card.get("health", 0)) - int(base_card.get("health", 0)))
    stat_gain += max(0, int(card.get("attack", 0)) - int(base_card.get("attack", 0))) * 8
    stat_gain += max(0, int(card.get("defense", 0)) - int(base_card.get("defense", 0))) * 8
    return int(round((base_value + stat_gain + (modifier_ids.size() * 12)) * (1.0 + ((level - 1) * 0.25))))