stats_manager.gd

Go to the documentation of this file.

extends RefCounted
 
 
 
const GLOBAL_ACHIEVEMENT_PATH := "user://global_achievements.cfg"
const DataCacheManager = preload("res://scripts/systems/dataCacheManager/data_cache_manager.gd")
 
var counters := {}
var records := {}
var flags := {}
var derived_stats := {}
var run_summaries := []
var achievements := {}
var achievement_unlock_times := {}
 
var data_cache_manager = DataCacheManager.new()
 
 
 
func load_achievements(file_path:String, game_id:String = "") -> void:
    load_achievement_data(data_cache_manager.load_json(file_path), game_id)
 
 
 
func load_achievement_data(data, game_id:String = "") -> void:
    if not data is Dictionary:
        return
    for achievement in data.get("achievements", []):
        if not achievement is Dictionary:
            continue
        var id = str(achievement.get("id", ""))
        if id == "":
            continue
        var definition = achievement.duplicate(true)
        definition.erase("id")
        if definition.has("conditions") and definition["conditions"] is Dictionary:
            for key in definition["conditions"].keys():
                if not definition.has(key):
                    definition[key] = definition["conditions"][key]
            definition.erase("conditions")
        if game_id != "" and not definition.has("game_id"):
            definition["game_id"] = game_id
        register_achievement(id, definition)
 
 
 
func set_counter(id:String, value:int) -> void:
    counters[id] = value
 
 
 
func increment(id:String, amount:int = 1) -> int:
    var value = int(counters.get(id, 0)) + amount
    counters[id] = value
    return value
 
 
 
func record_events(events:Array, evaluate:bool = true) -> Array:
    for event in events:
        if not event is Dictionary:
            continue
        var id := str(event.get("id", ""))
        if id == "":
            continue
        match str(event.get("type", "counter")):
            "counter":
                increment(id, int(event.get("amount", 1)))
            "set_counter":
                set_counter(id, int(event.get("value", 0)))
            "record_high":
                record_high(id, int(event.get("value", 0)))
            "record_low":
                record_low(id, int(event.get("value", 0)))
            "flag":
                set_flag(id, bool(event.get("value", true)))
    return evaluate_achievements() if evaluate else []
 
 
 
func get_counter(id:String, default_value:int = 0) -> int:
    return int(counters.get(id, default_value))
 
 
 
func record_high(id:String, value:int) -> bool:
    if value <= int(records.get(id, value - 1)):
        return false
    records[id] = value
    return true
 
 
 
func record_low(id:String, value:int) -> bool:
    if records.has(id) and value >= int(records[id]):
        return false
    records[id] = value
    return true
 
 
 
func get_record(id:String, default_value:int = 0) -> int:
    return int(records.get(id, default_value))
 
 
 
func set_flag(id:String, value:bool = true) -> void:
    flags[id] = value
    if id.begins_with("achievement_"):
        var achievement_id = id.trim_prefix("achievement_")
        if value:
            if not achievement_unlock_times.has(achievement_id):
                achievement_unlock_times[achievement_id] = Time.get_unix_time_from_system()
        else:
            achievement_unlock_times.erase(achievement_id)
 
 
 
func get_flag(id:String, default_value:bool = false) -> bool:
    return bool(flags.get(id, default_value))
 
 
 
func register_derived_stat(id:String, definition:Dictionary) -> void:
    derived_stats[id] = definition.duplicate(true)
 
 
 
func get_derived_stat(id:String, default_value = 0):
    if not derived_stats.has(id):
        return default_value
    var definition = derived_stats[id]
    var op = str(definition.get("op", "sum"))
    var fields = definition.get("fields", [])
    var values = []
    for field in fields:
        values.append(_get_numeric_stat(str(field)))
    match op:
        "sum":
            var total = 0
            for value in values:
                total += value
            return total
        "difference":
            return (values[0] if values.size() > 0 else 0) - (values[1] if values.size() > 1 else 0)
        "ratio":
            var denominator = values[1] if values.size() > 1 else 0
            return default_value if denominator == 0 else float(values[0]) / float(denominator)
        "percent":
            var denominator = values[1] if values.size() > 1 else 0
            return default_value if denominator == 0 else (float(values[0]) / float(denominator)) * 100.0
        "max":
            return values.max() if not values.is_empty() else default_value
        "min":
            return values.min() if not values.is_empty() else default_value
    return default_value
 
 
 
func add_run_summary(summary:Dictionary, max_entries:int = 20) -> void:
    var entry = summary.duplicate(true)
    if not entry.has("ended_at"):
        entry["ended_at"] = Time.get_unix_time_from_system()
    run_summaries.append(entry)
    while run_summaries.size() > max_entries:
        run_summaries.pop_front()
 
 
 
func get_run_summaries() -> Array:
    return run_summaries.duplicate(true)
 
 
 
func register_achievement(id:String, definition:Dictionary) -> void:
    achievements[id] = definition.duplicate(true)
 
 
 
func get_achievements() -> Dictionary:
    return achievements.duplicate(true)
 
 
 
func get_achievement_collection(filters:Dictionary = {}) -> Array:
    var collection = []
    for id in achievements.keys():
        var achievement = achievements[id].duplicate(true)
        achievement["id"] = id
        achievement["unlocked"] = get_flag("achievement_%s" % id)
        if achievement_unlock_times.has(id):
            achievement["unlocked_at"] = achievement_unlock_times[id]
        if not _achievement_matches_filters(achievement, filters):
            continue
        collection.append(achievement)
    return collection
 
 
 
func load_global_achievement_state(path:String = GLOBAL_ACHIEVEMENT_PATH) -> void:
    var file = ConfigFile.new()
    if file.load(path) != OK:
        return
    var global_flags = file.get_value("achievements", "flags", {})
    var global_times = file.get_value("achievements", "unlock_times", {})
    merge_achievement_state({"flags": global_flags, "achievement_unlock_times": global_times})
 
 
 
func save_global_achievement_state(path:String = GLOBAL_ACHIEVEMENT_PATH) -> void:
    var file = ConfigFile.new()
    file.load(path)
    var global_flags = file.get_value("achievements", "flags", {})
    var global_times = file.get_value("achievements", "unlock_times", {})
    if not global_flags is Dictionary:
        global_flags = {}
    if not global_times is Dictionary:
        global_times = {}
    for flag_id in flags.keys():
        if not str(flag_id).begins_with("achievement_") or not bool(flags[flag_id]):
            continue
        global_flags[str(flag_id)] = true
        var achievement_id = str(flag_id).trim_prefix("achievement_")
        if achievement_unlock_times.has(achievement_id):
            global_times[achievement_id] = achievement_unlock_times[achievement_id]
        elif not global_times.has(achievement_id):
            global_times[achievement_id] = Time.get_unix_time_from_system()
    file.set_value("achievements", "flags", global_flags)
    file.set_value("achievements", "unlock_times", global_times)
    file.save(path)
 
 
 
func merge_achievement_state(state:Dictionary) -> void:
    var source_flags = state.get("flags", {})
    if source_flags is Dictionary:
        for flag_id in source_flags.keys():
            if str(flag_id).begins_with("achievement_") and bool(source_flags[flag_id]):
                flags[str(flag_id)] = true
    var source_times = state.get("achievement_unlock_times", {})
    if source_times is Dictionary:
        for achievement_id in source_times.keys():
            if int(source_times[achievement_id]) > 0:
                achievement_unlock_times[str(achievement_id)] = source_times[achievement_id]
 
 
 
func get_achievement_filter_options() -> Dictionary:
    var game_ids := {"all": true}
    var categories := {"all": true}
    for achievement in achievements.values():
        if not achievement is Dictionary:
            continue
        game_ids[str(achievement.get("game_id", "all"))] = true
        categories[str(achievement.get("category", "general"))] = true
    return {
        "game_ids": game_ids.keys(),
        "categories": categories.keys(),
        "states": ["all", "locked", "unlocked"]
    }
 
 
 
func get_achievement_summary() -> Dictionary:
    var by_game := {}
    var by_category := {}
    for achievement in achievements.values():
        if not achievement is Dictionary:
            continue
        var game_id := str(achievement.get("game_id", "all"))
        var category := str(achievement.get("category", "general"))
        by_game[game_id] = int(by_game.get(game_id, 0)) + 1
        by_category[category] = int(by_category.get(category, 0)) + 1
    return {
        "total": achievements.size(),
        "by_game": by_game,
        "by_category": by_category
    }
 
 
 
func get_cache_stats() -> Dictionary:
    return data_cache_manager.get_cache_stats()
 
 
 
func evaluate_achievements() -> Array:
    var unlocked = []
    for id in achievements.keys():
        var flag_id = "achievement_%s" % id
        if get_flag(flag_id):
            continue
        if _achievement_condition_met(achievements[id]):
            set_flag(flag_id, true)
            unlocked.append(id)
    if not unlocked.is_empty():
        save_global_achievement_state()
    return unlocked
 
 
 
func get_state() -> Dictionary:
    return {
        "counters": counters.duplicate(true),
        "records": records.duplicate(true),
        "flags": flags.duplicate(true),
        "derived_stats": derived_stats.duplicate(true),
        "run_summaries": run_summaries.duplicate(true),
        "achievements": achievements.duplicate(true),
        "achievement_unlock_times": achievement_unlock_times.duplicate(true)
    }
 
 
 
func apply_state(state:Dictionary) -> void:
    counters = state.get("counters", {}).duplicate(true)
    records = state.get("records", {}).duplicate(true)
    flags = state.get("flags", {}).duplicate(true)
    derived_stats = state.get("derived_stats", {}).duplicate(true)
    run_summaries = state.get("run_summaries", []).duplicate(true)
    achievement_unlock_times = state.get("achievement_unlock_times", {}).duplicate(true)
    var registered_achievements = achievements.duplicate(true)
    var saved_achievements = state.get("achievements", {})
    if registered_achievements.is_empty() and saved_achievements is Dictionary:
        achievements = saved_achievements.duplicate(true)
    elif saved_achievements is Dictionary:
        for id in saved_achievements.keys():
            if not achievements.has(id):
                achievements[id] = saved_achievements[id]
 
 
 
func reset() -> void:
    counters.clear()
    records.clear()
    flags.clear()
    derived_stats.clear()
    run_summaries.clear()
    achievements.clear()
    achievement_unlock_times.clear()
 
 
func _get_numeric_stat(id:String) -> int:
    if counters.has(id):
        return int(counters[id])
    if records.has(id):
        return int(records[id])
    return 0
 
 
func _achievement_condition_met(definition:Dictionary) -> bool:
    for id in definition.get("counter_at_least", {}).keys():
        if get_counter(str(id)) < int(definition["counter_at_least"][id]):
            return false
    for id in definition.get("record_at_least", {}).keys():
        if get_record(str(id)) < int(definition["record_at_least"][id]):
            return false
    for id in definition.get("record_at_most", {}).keys():
        if get_record(str(id), 999999999) > int(definition["record_at_most"][id]):
            return false
    for id in definition.get("flag", []):
        if not get_flag(str(id)):
            return false
    return true
 
 
func _achievement_matches_filters(achievement:Dictionary, filters:Dictionary) -> bool:
    if filters.has("game_id") and not _filter_value_matches(achievement.get("game_id", ""), filters["game_id"]):
        return false
    if filters.has("category") and not _filter_value_matches(achievement.get("category", ""), filters["category"]):
        return false
    if filters.has("locked") and bool(filters["locked"]) == bool(achievement.get("unlocked", false)):
        return false
    if filters.has("unlocked") and bool(filters["unlocked"]) != bool(achievement.get("unlocked", false)):
        return false
    if filters.has("state"):
        var state = str(filters["state"])
        if state == "all":
            return true
        if state == "locked" and bool(achievement.get("unlocked", false)):
            return false
        if state == "unlocked" and not bool(achievement.get("unlocked", false)):
            return false
    return true
 
 
func _filter_value_matches(value, filter_value) -> bool:
    if filter_value is Array:
        for accepted in filter_value:
            if str(value) == str(accepted):
                return true
        return false
    return str(value) == str(filter_value)