docs/action__effect__manager_8gd_source.html

extends RefCounted


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


var actions := {}

var data_cache_manager = DataCacheManager.new()


func load_actions(file_path:String) -> void:

    load_action_data(data_cache_manager.load_json(file_path))


func load_action_data(data:Dictionary) -> void:

    actions.clear()

    for raw_action in data.get("actions", []):

        if not raw_action is Dictionary:

            continue

        var action = normalize_action(raw_action)

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

        if id != "":

            actions[id] = action


func get_action(action_id:String) -> Dictionary:

    return actions.get(action_id, {}).duplicate(true)


func get_actions() -> Array:

    var result := []

    for id in actions.keys():

        result.append(actions[id].duplicate(true))

    return result


func normalize_action(action:Dictionary) -> Dictionary:

    var normalized = action.duplicate(true)

    normalized["id"] = str(normalized.get("id", ""))

    normalized["name"] = str(normalized.get("name", normalized.get("id", "Action")))

    normalized["kind"] = str(normalized.get("kind", "action"))

    normalized["costs"] = _normalize_costs(normalized.get("costs", normalized.get("cost", [])))

    normalized["cooldown"] = max(0.0, float(normalized.get("cooldown", 0.0)))

    normalized["targeting"] = normalized.get("targeting", {}) if normalized.get("targeting", {}) is Dictionary else {}

    normalized["effects"] = _normalize_effects(normalized.get("effects", []))

    return normalized


func can_pay_costs(action:Dictionary, pools:Dictionary) -> bool:

    for cost in _normalize_costs(action.get("costs", action.get("cost", []))):

        var pool = str(cost.get("pool", ""))

        var amount = int(cost.get("amount", 0))

        if pool == "" or amount <= 0:

            continue

        if int(pools.get(pool, 0)) < amount:

            return false

    return true


func apply_costs(action:Dictionary, pools:Dictionary) -> Dictionary:

    var next = pools.duplicate(true)

    for cost in _normalize_costs(action.get("costs", action.get("cost", []))):

        var pool = str(cost.get("pool", ""))

        var amount = int(cost.get("amount", 0))

        if pool == "" or amount <= 0:

            continue

        next[pool] = int(next.get(pool, 0)) - amount

    return next


func is_on_cooldown(action_id:String, cooldowns:Dictionary) -> bool:

    return float(cooldowns.get(action_id, 0.0)) > 0.0


func can_use_action(action:Dictionary, pools:Dictionary = {}, cooldowns:Dictionary = {}) -> Dictionary:

    var action_id = str(action.get("id", ""))

    if action_id != "" and is_on_cooldown(action_id, cooldowns):

        return {"ok": false, "reason": "cooldown", "remaining": float(cooldowns.get(action_id, 0.0))}

    if not can_pay_costs(action, pools):

        return {"ok": false, "reason": "cost"}

    return {"ok": true}


func begin_cooldown(action:Dictionary, cooldowns:Dictionary = {}) -> Dictionary:

    var next = cooldowns.duplicate(true)

    var action_id = str(action.get("id", ""))

    var cooldown = max(0.0, float(action.get("cooldown", 0.0)))

    if action_id != "" and cooldown > 0.0:

        next[action_id] = cooldown

    return next


func tick_cooldowns(cooldowns:Dictionary, delta:float) -> Dictionary:

    var next := {}

    for id in cooldowns.keys():

        var remaining = max(0.0, float(cooldowns[id]) - delta)

        if remaining > 0.0:

            next[str(id)] = remaining

    return next


func resolve_effects(action:Dictionary, context:Dictionary = {}) -> Dictionary:

    var results := []

    for effect in _normalize_effects(action.get("effects", [])):

        var type = str(effect.get("type", "custom"))

        var callback = context.get(type, Callable())

        if callback is Callable and callback.is_valid():

            var resolved = callback.call(effect)

            results.append(resolved if resolved is Dictionary else {"type": type, "ok": true, "value": resolved})

        else:

            results.append({"type": type, "ok": false, "reason": "unhandled", "effect": effect})

    return {

        "action_id": str(action.get("id", "")),

        "results": results,

        "ok": _results_ok(results)

    }


func use_action(action:Dictionary, pools:Dictionary = {}, cooldowns:Dictionary = {}, context:Dictionary = {}) -> Dictionary:

    var availability = can_use_action(action, pools, cooldowns)

    if not bool(availability.get("ok", false)):

        return {

            "ok": false,

            "reason": str(availability.get("reason", "blocked")),

            "pools": pools.duplicate(true),

            "cooldowns": cooldowns.duplicate(true),

            "effects": []

        }

    var next_pools = apply_costs(action, pools)

    var next_cooldowns = begin_cooldown(action, cooldowns)

    var resolved = resolve_effects(action, context)

    return {

        "ok": bool(resolved.get("ok", true)),

        "action_id": str(action.get("id", "")),

        "pools": next_pools,

        "cooldowns": next_cooldowns,

        "effects": resolved.get("results", [])

    }


func _normalize_costs(raw_costs) -> Array:

    var normalized := []

    var costs = raw_costs if raw_costs is Array else [raw_costs]

    for raw_cost in costs:

        if raw_cost is Dictionary:

            var pool = str(raw_cost.get("pool", raw_cost.get("resource", raw_cost.get("id", ""))))

            var amount = int(raw_cost.get("amount", raw_cost.get("value", 0)))

            if pool != "" and amount != 0:

                normalized.append({"pool": pool, "amount": amount})

    return normalized


func _normalize_effects(raw_effects) -> Array:

    var normalized := []

    var effects = raw_effects if raw_effects is Array else [raw_effects]

    for raw_effect in effects:

        if not raw_effect is Dictionary:

            continue

        var effect = raw_effect.duplicate(true)

        effect["type"] = str(effect.get("type", "custom"))

        normalized.append(effect)

    return normalized


func _results_ok(results:Array) -> bool:

    for result in results:

        if result is Dictionary and not bool(result.get("ok", true)):

            return false

    return true


func get_cache_stats() -> Dictionary:

    return data_cache_manager.get_cache_stats()