build_profile_manager.gd

Go to the documentation of this file.

extends RefCounted
 
 
 
const DataCacheManager = preload("res://scripts/systems/dataCacheManager/data_cache_manager.gd")
 
var profiles := {}
var data_cache_manager = DataCacheManager.new()
 
 
 
func load_profiles(directory_path:String = "res://data/build_profiles") -> Array:
    profiles.clear()
    var loaded_ids := []
    var dir = DirAccess.open(directory_path)
    if dir == null:
        return loaded_ids
    dir.list_dir_begin()
    var file_name = dir.get_next()
    while file_name != "":
        if not dir.current_is_dir() and file_name.ends_with(".json"):
            var profile = load_profile("%s/%s" % [directory_path.trim_suffix("/"), file_name])
            if not profile.is_empty():
                loaded_ids.append(str(profile.get("game_id", "")))
        file_name = dir.get_next()
    dir.list_dir_end()
    return loaded_ids
 
 
 
func load_profile(file_path:String) -> Dictionary:
    var data:Dictionary = data_cache_manager.load_json(file_path)
    var profile = normalize_profile(data)
    if str(profile.get("game_id", "")) != "":
        profiles[str(profile["game_id"])] = profile
    return profile
 
 
 
func get_profile(game_id:String) -> Dictionary:
    return profiles.get(game_id, {}).duplicate(true)
 
 
 
func get_profile_ids() -> Array:
    var ids = profiles.keys()
    ids.sort()
    return ids
 
 
 
func get_profile_options(include_all_demos:bool = true) -> Array:
    var rows := []
    for id in get_profile_ids():
        if not include_all_demos and str(id) == "all_demos":
            continue
        var profile = profiles[id]
        var metadata = profile.get("metadata", {}) if profile.get("metadata", {}) is Dictionary else {}
        rows.append({
            "id": str(id),
            "label": str(profile.get("label", id)),
            "menu_label": str(metadata.get("menu_label", profile.get("label", id))),
            "menu_route": str(profile.get("menu_route", id)),
            "menu_order": int(metadata.get("menu_order", 999)),
            "sprite_id": str(metadata.get("sprite_id", "")),
            "description": str(metadata.get("description", "")),
            "start_scene": str(profile.get("start_scene", "")),
            "entry_scene": str(profile.get("entry_scene", profile.get("start_scene", ""))),
            "launch_scene": str(profile.get("launch_scene", profile.get("start_scene", ""))),
            "output_name": str(profile.get("output_name", id)),
            "platforms": profile.get("platforms", {}).keys()
        })
    rows.sort_custom(func(a, b): return int(a.get("menu_order", 999)) < int(b.get("menu_order", 999)))
    return rows
 
 
 
func get_sprite_map_options(games_directory_path:String = "res://data/games") -> Array:
    var rows := []
    var discovered_paths := {}
    for profile_option in get_profile_options(false):
        var game_id := str(profile_option.get("id", ""))
        var sprite_path := "%s/%s/sprites.json" % [games_directory_path.trim_suffix("/"), game_id]
        if game_id == "" or not FileAccess.file_exists(sprite_path):
            continue
        rows.append({
            "id": game_id,
            "label": str(profile_option.get("label", game_id.capitalize())),
            "path": sprite_path
        })
        discovered_paths[sprite_path] = true
 
    var directory := DirAccess.open(games_directory_path)
    if directory != null:
        directory.list_dir_begin()
        var game_directory := directory.get_next()
        while game_directory != "":
            if directory.current_is_dir() and not game_directory.begins_with("."):
                var sprite_path := "%s/%s/sprites.json" % [games_directory_path.trim_suffix("/"), game_directory]
                if FileAccess.file_exists(sprite_path) and not discovered_paths.has(sprite_path):
                    rows.append({
                        "id": game_directory,
                        "label": game_directory.capitalize().replace("_", " "),
                        "path": sprite_path
                    })
                    discovered_paths[sprite_path] = true
            game_directory = directory.get_next()
        directory.list_dir_end()
 
    return rows
 
 
 
func normalize_profile(profile:Dictionary) -> Dictionary:
    var normalized = profile.duplicate(true)
    normalized["game_id"] = str(normalized.get("game_id", ""))
    normalized["label"] = str(normalized.get("label", normalized.get("game_id", "")))
    normalized["start_scene"] = str(normalized.get("start_scene", "res://scenes/splash_screen.tscn"))
    normalized["entry_scene"] = str(normalized.get("entry_scene", normalized.get("start_scene", "res://scenes/splash_screen.tscn")))
    normalized["launch_scene"] = str(normalized.get("launch_scene", normalized.get("start_scene", "res://scenes/start_menu.tscn")))
    normalized["menu_route"] = str(normalized.get("menu_route", normalized.get("game_id", "")))
    normalized["output_name"] = str(normalized.get("output_name", normalized.get("game_id", "game")))
    normalized["include_roots"] = _string_array(normalized.get("include_roots", []))
    normalized["shared_roots"] = _string_array(normalized.get("shared_roots", []))
    normalized["exclude_roots"] = _string_array(normalized.get("exclude_roots", []))
    normalized["exclude_game_ids"] = _string_array(normalized.get("exclude_game_ids", []))
    normalized["platforms"] = normalized.get("platforms", {}) if normalized.get("platforms", {}) is Dictionary else {}
    normalized["metadata"] = normalized.get("metadata", {}) if normalized.get("metadata", {}) is Dictionary else {}
    return normalized
 
 
 
func validate_profile(profile:Dictionary) -> Array:
    var normalized = normalize_profile(profile)
    var issues := []
    for field in ["game_id", "label", "start_scene", "output_name"]:
        if str(normalized.get(field, "")).strip_edges() == "":
            issues.append(_issue("missing_field", field, "Build profile is missing '%s'." % field))
    if not FileAccess.file_exists(str(normalized.get("start_scene", ""))):
        issues.append(_issue("missing_scene", "start_scene", "Start scene does not exist."))
    if str(normalized.get("entry_scene", "")).strip_edges() != "" and not FileAccess.file_exists(str(normalized.get("entry_scene", ""))):
        issues.append(_issue("missing_scene", "entry_scene", "Entry scene does not exist."))
    if str(normalized.get("launch_scene", "")).strip_edges() != "" and not FileAccess.file_exists(str(normalized.get("launch_scene", ""))):
        issues.append(_issue("missing_scene", "launch_scene", "Launch scene does not exist."))
    if normalized.get("include_roots", []).is_empty():
        issues.append(_issue("missing_include_roots", "include_roots", "At least one game include root is required."))
    if normalized.get("platforms", {}).is_empty():
        issues.append(_issue("missing_platforms", "platforms", "At least one platform artifact definition is required."))
    for root in get_all_include_roots(normalized):
        if not _resource_exists(root):
            issues.append(_issue("missing_include_root", root, "Included resource root does not exist."))
    for platform_id in normalized.get("platforms", {}).keys():
        var platform = normalized["platforms"][platform_id]
        if not platform is Dictionary:
            issues.append(_issue("invalid_platform", str(platform_id), "Platform entry must be an object."))
            continue
        if str(platform.get("preset", "")).strip_edges() == "":
            issues.append(_issue("missing_platform_preset", str(platform_id), "Platform entry is missing export preset name."))
        if str(platform.get("artifact", "")).strip_edges() == "":
            issues.append(_issue("missing_platform_artifact", str(platform_id), "Platform entry is missing artifact path."))
    return issues
 
 
 
func get_all_include_roots(profile:Dictionary) -> Array:
    var roots := []
    for root in _string_array(profile.get("shared_roots", [])) + _string_array(profile.get("include_roots", [])):
        if root != "" and not roots.has(root):
            roots.append(root)
    return roots
 
 
 
func get_exclude_roots(profile:Dictionary, all_game_ids:Array = []) -> Array:
    var normalized = normalize_profile(profile)
    var excludes := _string_array(normalized.get("exclude_roots", []))
    var ids = _string_array(normalized.get("exclude_game_ids", []))
    if ids.is_empty():
        for game_id in _string_array(all_game_ids):
            if game_id != str(normalized.get("game_id", "")):
                ids.append(game_id)
    for game_id in ids:
        var root = "res://data/games/%s" % game_id
        if not excludes.has(root):
            excludes.append(root)
    return excludes
 
 
 
func get_platform_artifacts(profile:Dictionary) -> Dictionary:
    var normalized = normalize_profile(profile)
    var output_name = str(normalized.get("output_name", "Game"))
    var artifacts := {}
    for platform_id in normalized.get("platforms", {}).keys():
        var platform = normalized["platforms"][platform_id]
        if not platform is Dictionary:
            continue
        var row = platform.duplicate(true)
        if str(row.get("artifact", "")) == "":
            row["artifact"] = "builds/%s/%s" % [str(platform_id), output_name]
        artifacts[str(platform_id)] = row
    return artifacts
 
 
 
func get_export_plan(profile:Dictionary, all_game_ids:Array = []) -> Dictionary:
    var normalized = normalize_profile(profile)
    return {
        "game_id": normalized.get("game_id", ""),
        "label": normalized.get("label", ""),
        "start_scene": normalized.get("start_scene", ""),
        "entry_scene": normalized.get("entry_scene", ""),
        "launch_scene": normalized.get("launch_scene", ""),
        "menu_route": normalized.get("menu_route", ""),
        "include_roots": get_all_include_roots(normalized),
        "exclude_roots": get_exclude_roots(normalized, all_game_ids),
        "platforms": get_platform_artifacts(normalized),
        "metadata": normalized.get("metadata", {})
    }
 
 
 
func audit_single_game_profile(profile:Dictionary, all_game_ids:Array = [], required_shared_roots:Array = [], required_game_roots:Array = []) -> Dictionary:
    var normalized:Dictionary = normalize_profile(profile)
    var game_id:String = str(normalized.get("game_id", ""))
    var include_roots:Array = get_all_include_roots(normalized)
    var exclude_roots:Array = get_exclude_roots(normalized, all_game_ids)
    var missing_shared_roots:Array = []
    var missing_game_roots:Array = []
    var missing_exclude_roots:Array = []
    var unexpected_game_data_includes:Array = []
    for root_value in _string_array(required_shared_roots):
        if not include_roots.has(str(root_value)):
            missing_shared_roots.append(str(root_value))
    for root_value in _string_array(required_game_roots):
        if not include_roots.has(str(root_value)):
            missing_game_roots.append(str(root_value))
    for other_game_id_value in _string_array(all_game_ids):
        var other_game_id:String = str(other_game_id_value)
        if other_game_id == "" or other_game_id == game_id or other_game_id == "all_demos":
            continue
        var other_data_root:String = "res://data/games/%s" % other_game_id
        if include_roots.has(other_data_root):
            unexpected_game_data_includes.append(other_data_root)
        if not exclude_roots.has(other_data_root):
            missing_exclude_roots.append(other_data_root)
    return {
        "game_id": game_id,
        "include_roots": include_roots,
        "exclude_roots": exclude_roots,
        "missing_shared_roots": missing_shared_roots,
        "missing_game_roots": missing_game_roots,
        "missing_exclude_roots": missing_exclude_roots,
        "unexpected_game_data_includes": unexpected_game_data_includes,
        "valid": missing_shared_roots.is_empty() and missing_game_roots.is_empty() and missing_exclude_roots.is_empty() and unexpected_game_data_includes.is_empty()
    }
 
 
 
func audit_single_game_profiles(profile_ids:Array = [], required_shared_roots_by_game:Dictionary = {}, required_game_roots_by_game:Dictionary = {}) -> Dictionary:
    var ids:Array = _string_array(profile_ids)
    if ids.is_empty():
        ids = get_profile_ids()
    var all_game_ids:Array = []
    for id_value in ids:
        var profile_id:String = str(id_value)
        if profile_id != "" and profile_id != "all_demos":
            all_game_ids.append(profile_id)
    var audits := {}
    var valid := true
    for id_value in all_game_ids:
        var game_id:String = str(id_value)
        var profile:Dictionary = get_profile(game_id)
        if profile.is_empty():
            audits[game_id] = {
                "game_id": game_id,
                "valid": false,
                "missing_profile": true
            }
            valid = false
            continue
        var shared_roots:Array = _string_array(required_shared_roots_by_game.get(game_id, []))
        var game_roots:Array = _string_array(required_game_roots_by_game.get(game_id, []))
        var audit:Dictionary = audit_single_game_profile(profile, all_game_ids, shared_roots, game_roots)
        audits[game_id] = audit
        if not bool(audit.get("valid", false)):
            valid = false
    return {
        "valid": valid,
        "audits": audits,
        "game_ids": all_game_ids
    }
 
 
func _resource_exists(path:String) -> bool:
    if path == "":
        return false
    if FileAccess.file_exists(path):
        return true
    return DirAccess.open(path) != null
 
 
func get_cache_stats() -> Dictionary:
    return data_cache_manager.get_cache_stats()
 
 
func _string_array(value) -> Array:
    var result := []
    if not value is Array:
        return result
    for item in value:
        result.append(str(item))
    return result
 
 
func _issue(type:String, path:String, message:String) -> Dictionary:
    return {"type": type, "path": path, "message": message}