combat_card_factory.gd

Go to the documentation of this file.

extends RefCounted
 
 
 
const DataCacheManager = preload("res://scripts/systems/dataCacheManager/data_cache_manager.gd")
 
var cards := {}
var manifestations := {}
var modifiers := {}
var elements := {}
var compounds := {}
var composition_rules := {}
var data_cache_manager = DataCacheManager.new()
 
 
 
func load_catalog(file_path:String) -> void:
    cards.clear()
    manifestations.clear()
    modifiers.clear()
    composition_rules.clear()
    load_catalog_data(data_cache_manager.load_json(file_path))
 
 
 
func load_catalog_data(data) -> void:
    cards.clear()
    manifestations.clear()
    modifiers.clear()
    composition_rules.clear()
    if not data is Dictionary:
        return
    composition_rules = data.get("composition", {}).duplicate(true)
    for manifestation in data.get("manifestations", []):
        if manifestation is Dictionary:
            var id = str(manifestation.get("id", ""))
            if id != "":
                manifestations[id] = manifestation.duplicate(true)
    for modifier in data.get("modifiers", []):
        if modifier is Dictionary:
            var id = str(modifier.get("id", ""))
            if id != "":
                modifiers[id] = modifier.duplicate(true)
    for card in data.get("cards", []):
        if card is Dictionary:
            var id = str(card.get("id", ""))
            if id != "":
                cards[id] = card.duplicate(true)
 
 
 
func load_definitions(file_path:String) -> void:
    elements.clear()
    compounds.clear()
    load_definition_data(data_cache_manager.load_json(file_path))
 
 
 
func get_cache_stats() -> Dictionary:
    return data_cache_manager.get_cache_stats()
 
 
 
func load_definition_data(data) -> void:
    elements.clear()
    compounds.clear()
    if not data is Dictionary:
        return
    for element in data.get("elements", []):
        if element is Dictionary:
            var id = str(element.get("id", ""))
            if id != "":
                elements[id] = element.duplicate(true)
    for compound in data.get("compounds", []):
        if compound is Dictionary:
            var id = str(compound.get("id", ""))
            if id != "":
                compounds[id] = compound.duplicate(true)
 
 
 
func get_card(card_id:String) -> Dictionary:
    return cards.get(card_id, {}).duplicate(true)
 
 
 
func get_compound_definition(compound_id:String) -> Dictionary:
    return _compound_definition(compound_id)
 
 
 
func register_card(card:Dictionary) -> bool:
    var id = str(card.get("id", ""))
    if id == "":
        return false
    cards[id] = card.duplicate(true)
    return true
 
 
 
func unregister_card(card_id:String) -> bool:
    if not cards.has(card_id):
        return false
    cards.erase(card_id)
    return true
 
 
 
func get_cards_for_unlocks(unlocked_ids:Array, fallback_ids:Array = []) -> Array:
    var rows := []
    var seen := {}
    for id in fallback_ids:
        var key = str(id)
        if cards.has(key) and not seen.has(key):
            rows.append(cards[key].duplicate(true))
            seen[key] = true
    for id in unlocked_ids:
        var key = str(id)
        if cards.has(key) and not seen.has(key):
            rows.append(cards[key].duplicate(true))
            seen[key] = true
    return rows
 
 
 
func get_cards_for_reaction(reaction:Dictionary) -> Array:
    return get_cards_for_unlocks(reaction.get("unlocks_cards", []))
 
 
 
func get_missing_unlocks(unlocked_ids:Array) -> Array:
    var missing := []
    for id in unlocked_ids:
        var key = str(id)
        if key != "" and not cards.has(key):
            missing.append(key)
    missing.sort()
    return missing
 
 
 
func compose_card(compound, manifestation_id:String, modifier_ids:Array = [], options:Dictionary = {}) -> Dictionary:
    var compound_def = _compound_definition(compound)
    var compound_id = str(compound_def.get("id", ""))
    if compound_id == "" or not manifestations.has(manifestation_id):
        return {}
    var manifestation = manifestations[manifestation_id]
    var clean_modifiers := []
    for id in modifier_ids:
        var key = str(id)
        if modifiers.has(key) and not clean_modifiers.has(key):
            clean_modifiers.append(key)
    var tier = int(compound_def.get("tier", 0))
    var energy = int(composition_rules.get("base_energy", 1)) + int(manifestation.get("energy_delta", 0))
    var damage = int(composition_rules.get("base_damage", 6)) + tier * int(composition_rules.get("damage_per_tier", 4)) + int(manifestation.get("damage_bonus", 0))
    var card_range = int(manifestation.get("range", composition_rules.get("default_range", 4)))
    var aoe_radius = int(manifestation.get("aoe_radius", composition_rules.get("default_aoe_radius", 1)))
    var duration = float(manifestation.get("duration", 0.24))
    for id in clean_modifiers:
        var modifier = modifiers[id]
        energy += int(modifier.get("energy_delta", 0))
        damage += int(modifier.get("damage_delta", 0))
        card_range += int(modifier.get("range_delta", 0))
        aoe_radius += int(modifier.get("aoe_delta", 0))
        duration += float(modifier.get("duration_delta", 0.0))
    energy = max(0, energy)
    damage = max(1, damage)
    card_range = max(0, card_range)
    aoe_radius = max(0, aoe_radius)
    duration = max(0.05, duration)
    var modifier_names := []
    for id in clean_modifiers:
        modifier_names.append(str(modifiers[id].get("name", id)))
    var compound_name = str(compound_def.get("name", compound_id.capitalize()))
    var manifestation_name = str(manifestation.get("name", manifestation_id.capitalize()))
    var card_name = "%s %s" % [compound_name, manifestation_name]
    if not modifier_names.is_empty():
        card_name = "%s %s" % [" ".join(modifier_names), card_name]
    var card_id = str(options.get("id", _composed_card_id(compound_id, manifestation_id, clean_modifiers)))
    var targeting = {
        "type": str(manifestation.get("targeting_type", manifestation_id)),
        "requires_direction": bool(manifestation.get("requires_direction", true)),
        "range": card_range
    }
    if aoe_radius > 0:
        targeting["aoe_radius"] = aoe_radius
    return {
        "id": card_id,
        "name": card_name,
        "compound": compound_id,
        "manifestation": manifestation_id,
        "modifiers": clean_modifiers,
        "targeting": targeting,
        "visual": {
            "color": str(compound_def.get("color", composition_rules.get("default_color", "#f5d36a"))),
            "shape": str(manifestation.get("shape", targeting["type"])),
            "duration": duration
        },
        "energy": energy,
        "damage": damage,
        "description": _composition_description(compound_def, manifestation, clean_modifiers),
        "source_recipe": {
            "compound": compound_id,
            "manifestation": manifestation_id,
            "modifiers": clean_modifiers
        },
        "composed": true
    }
 
 
func preview_composition(compound, manifestation_id:String, modifier_ids:Array = []) -> Dictionary:
    var card = compose_card(compound, manifestation_id, modifier_ids)
    if not card.is_empty():
        card["preview"] = true
    return card
 
 
func get_composition_issues(compound_ids:Array = []) -> Array:
    var issues := []
    for id in compound_ids:
        var key = str(id)
        if key != "" and _compound_definition(key).is_empty():
            issues.append({"type": "missing_compound", "id": key})
    for id in manifestations.keys():
        var manifestation = manifestations[id]
        if not manifestation.has("targeting_type"):
            issues.append({"type": "missing_targeting_type", "id": id})
    for id in modifiers.keys():
        var modifier = modifiers[id]
        if not modifier.has("description"):
            issues.append({"type": "missing_modifier_description", "id": id})
    return issues
 
 
func get_state() -> Dictionary:
    return {
        "cards": cards.duplicate(true),
        "manifestations": manifestations.duplicate(true),
        "modifiers": modifiers.duplicate(true),
        "elements": elements.duplicate(true),
        "compounds": compounds.duplicate(true),
        "composition_rules": composition_rules.duplicate(true)
    }
 
 
func apply_state(state:Dictionary) -> void:
    cards = state.get("cards", {}).duplicate(true)
    manifestations = state.get("manifestations", {}).duplicate(true)
    modifiers = state.get("modifiers", {}).duplicate(true)
    elements = state.get("elements", {}).duplicate(true)
    compounds = state.get("compounds", {}).duplicate(true)
    composition_rules = state.get("composition_rules", {}).duplicate(true)
 
 
func _compound_definition(compound) -> Dictionary:
    if compound is Dictionary:
        return compound.duplicate(true)
    var id = str(compound)
    if compounds.has(id):
        return compounds[id].duplicate(true)
    if elements.has(id):
        return elements[id].duplicate(true)
    return {}
 
 
func _composed_card_id(compound_id:String, manifestation_id:String, modifier_ids:Array) -> String:
    var parts := ["crafted", compound_id, manifestation_id]
    var sorted_modifiers = modifier_ids.duplicate()
    sorted_modifiers.sort()
    for id in sorted_modifiers:
        parts.append(str(id))
    return "_".join(parts)
 
 
func _composition_description(compound:Dictionary, manifestation:Dictionary, modifier_ids:Array) -> String:
    var text = "%s expressed as %s." % [
        str(compound.get("name", compound.get("id", "Compound"))),
        str(manifestation.get("name", manifestation.get("id", "Form"))).to_lower()
    ]
    if not modifier_ids.is_empty():
        var names := []
        for id in modifier_ids:
            names.append(str(modifiers[id].get("name", id)))
        text += " Modified by %s." % ", ".join(names)
    return text