adventure_manager.gd

Go to the documentation of this file.

extends RefCounted
 
 
 
const DataCacheManager = preload("res://scripts/systems/dataCacheManager/data_cache_manager.gd")
 
var adventures := {}
var data_cache_manager = DataCacheManager.new()
 
 
 
func load_adventure(file_path:String) -> bool:
    return load_adventure_data(data_cache_manager.load_json(file_path))
 
 
 
func get_cache_stats() -> Dictionary:
    return data_cache_manager.get_cache_stats()
 
 
 
func load_adventure_data(data) -> bool:
    if not data is Dictionary:
        return false
    return register_adventure(data)
 
 
 
func load_adventures(file_paths:Array) -> int:
    var loaded := 0
    for file_path in file_paths:
        if load_adventure(str(file_path)):
            loaded += 1
    return loaded
 
 
 
func load_adventures_data(adventure_rows:Array) -> int:
    var loaded := 0
    for adventure_data in adventure_rows:
        if load_adventure_data(adventure_data):
            loaded += 1
    return loaded
 
 
 
func register_adventure(data:Dictionary) -> bool:
    var id = str(data.get("id", ""))
    if id == "" or not (data.get("levels", []) is Array) or data.get("levels", []).is_empty():
        return false
    adventures[id] = data.duplicate(true)
    return true
 
 
func has_adventure(id:String) -> bool:
    return adventures.has(id)
 
 
func get_adventure(id:String) -> Dictionary:
    return adventures.get(id, {}).duplicate(true)
 
 
func list_adventures() -> Array:
    var rows := []
    for id in adventures.keys():
        var adventure = adventures[id]
        rows.append({
            "id": id,
            "name": str(adventure.get("name", id)),
            "description": str(adventure.get("description", "")),
            "level_count": adventure.get("levels", []).size(),
            "estimated_minutes": int(adventure.get("estimated_minutes", 0)),
            "rewards": adventure.get("rewards", {}).duplicate(true)
        })
    rows.sort_custom(func(a, b): return str(a.get("name", "")) < str(b.get("name", "")))
    return rows
 
 
func get_level(adventure_id:String, level_index:int) -> Dictionary:
    var levels = adventures.get(adventure_id, {}).get("levels", [])
    if level_index < 0 or level_index >= levels.size():
        return {}
    return levels[level_index].duplicate(true)
 
 
 
func validate_adventure(adventure_id:String) -> Array:
    var issues := []
    var adventure = adventures.get(adventure_id, {})
    if adventure.is_empty():
        return ["Missing adventure: %s" % adventure_id]
    if str(adventure.get("id", "")) == "":
        issues.append("Adventure is missing id.")
    var levels = adventure.get("levels", [])
    if not (levels is Array) or levels.is_empty():
        issues.append("Adventure has no levels.")
    for index in range(levels.size()):
        var level = levels[index]
        if not level is Dictionary:
            issues.append("Level %d is not a dictionary." % index)
            continue
        if str(level.get("id", "")) == "":
            issues.append("Level %d is missing id." % index)
        if str(level.get("name", "")) == "":
            issues.append("Level %d is missing name." % index)
        if not level.has("layout") and not level.has("procedural_template"):
            issues.append("Level %d needs layout or procedural_template." % index)
        if not (level.get("objectives", []) is Array) or level.get("objectives", []).is_empty():
            issues.append("Level %d has no objectives." % index)
        if not (level.get("exits", []) is Array) or level.get("exits", []).is_empty():
            issues.append("Level %d has no exits." % index)
        if not level.has("player_spawn"):
            issues.append("Level %d has no player_spawn." % index)
    return issues
 
 
 
func create_run_state(adventure_id:String) -> Dictionary:
    if not adventures.has(adventure_id):
        return {}
    return {
        "adventure_id": adventure_id,
        "level_index": 0,
        "completed_objectives": {},
        "completed_levels": [],
        "collected_rewards": {},
        "finished": false
    }
 
 
func get_current_level(run_state:Dictionary) -> Dictionary:
    return get_level(str(run_state.get("adventure_id", "")), int(run_state.get("level_index", 0)))
 
 
func complete_objective(run_state:Dictionary, objective_id:String) -> Dictionary:
    var next_state = run_state.duplicate(true)
    var level = get_current_level(next_state)
    if level.is_empty() or objective_id == "":
        return next_state
    var level_id = str(level.get("id", ""))
    var completed = next_state.get("completed_objectives", {}).duplicate(true)
    var level_completed = completed.get(level_id, [])
    if not level_completed.has(objective_id):
        level_completed.append(objective_id)
    completed[level_id] = level_completed
    next_state["completed_objectives"] = completed
    return next_state
 
 
func is_current_level_complete(run_state:Dictionary) -> bool:
    var level = get_current_level(run_state)
    if level.is_empty():
        return false
    var required := []
    for objective in level.get("objectives", []):
        if objective is Dictionary and bool(objective.get("required", true)):
            required.append(str(objective.get("id", "")))
    var completed = run_state.get("completed_objectives", {}).get(str(level.get("id", "")), [])
    for objective_id in required:
        if objective_id != "" and not completed.has(objective_id):
            return false
    return true
 
 
func get_progress_summary(run_state:Dictionary) -> Dictionary:
    var adventure_id = str(run_state.get("adventure_id", ""))
    var adventure = get_adventure(adventure_id)
    var levels = adventure.get("levels", [])
    var level_index = clamp(int(run_state.get("level_index", 0)), 0, max(0, levels.size() - 1))
    var level = get_level(adventure_id, level_index)
    var completed = run_state.get("completed_objectives", {}).get(str(level.get("id", "")), [])
    var required_total := 0
    var optional_total := 0
    var required_done := 0
    var optional_done := 0
    for objective in level.get("objectives", []):
        if not objective is Dictionary:
            continue
        var objective_id = str(objective.get("id", ""))
        if bool(objective.get("required", true)):
            required_total += 1
            if completed.has(objective_id):
                required_done += 1
        else:
            optional_total += 1
            if completed.has(objective_id):
                optional_done += 1
    return {
        "adventure_id": adventure_id,
        "adventure_name": str(adventure.get("name", adventure_id)),
        "level_index": level_index,
        "level_count": levels.size(),
        "level_id": str(level.get("id", "")),
        "level_name": str(level.get("name", "")),
        "required_done": required_done,
        "required_total": required_total,
        "optional_done": optional_done,
        "optional_total": optional_total,
        "finished": bool(run_state.get("finished", false))
    }
 
 
 
func get_pacing_summary(adventure_id:String) -> Dictionary:
    var adventure = get_adventure(adventure_id)
    var levels = adventure.get("levels", [])
    var estimated_minutes = int(adventure.get("estimated_minutes", 0))
    var required_objectives := 0
    var optional_objectives := 0
    var encounter_count := 0
    var material_count := 0
    for level in levels:
        if not level is Dictionary:
            continue
        for objective in level.get("objectives", []):
            if not objective is Dictionary:
                continue
            if bool(objective.get("required", true)):
                required_objectives += 1
            else:
                optional_objectives += 1
        var explicit_encounters = 0
        if level.get("enemies", []) is Array:
            explicit_encounters += level.get("enemies", []).size()
        if level.get("bosses", []) is Array:
            explicit_encounters += level.get("bosses", []).size()
        var procedural_budget = int(level.get("procedural_template", {}).get("enemy_budget", 0)) if level.get("procedural_template", {}) is Dictionary else 0
        encounter_count += max(explicit_encounters, procedural_budget)
        if level.get("procedural_template", {}) is Dictionary:
            material_count += int(level.get("procedural_template", {}).get("material_nodes", 0))
        for object in level.get("objects", []):
            if object is Dictionary and str(object.get("kind", "")) == "resource":
                material_count += int(object.get("amount", 1))
    return {
        "adventure_id": adventure_id,
        "estimated_minutes": estimated_minutes,
        "level_count": levels.size(),
        "required_objectives": required_objectives,
        "optional_objectives": optional_objectives,
        "encounter_count": encounter_count,
        "material_count": material_count,
        "mvp_length_ready": estimated_minutes >= 8 and estimated_minutes <= 12,
        "has_required_objectives": required_objectives > 0,
        "has_completion_encounter": encounter_count > 0
    }
 
 
func advance_level(run_state:Dictionary) -> Dictionary:
    var next_state = run_state.duplicate(true)
    if not is_current_level_complete(next_state):
        return next_state
    var adventure = get_adventure(str(next_state.get("adventure_id", "")))
    var current_index = int(next_state.get("level_index", 0))
    var completed_levels = next_state.get("completed_levels", []).duplicate()
    var current_level = get_level(str(next_state.get("adventure_id", "")), current_index)
    var level_id = str(current_level.get("id", ""))
    if level_id != "" and not completed_levels.has(level_id):
        completed_levels.append(level_id)
    next_state["completed_levels"] = completed_levels
    if current_index + 1 >= adventure.get("levels", []).size():
        next_state["finished"] = true
    else:
        next_state["level_index"] = current_index + 1
    return next_state