docs/custom__level__library_8gd_source.html

extends RefCounted


const LevelManager = preload("res://scripts/systems/levelManager/level_manager.gd")


const DEFAULT_ROOT := "res://data/games"


var level_manager = LevelManager.new()


func ensure_root(root_path:String = DEFAULT_ROOT) -> String:

    var root:String = root_path.strip_edges()

    if root == "":

        root = DEFAULT_ROOT

    DirAccess.make_dir_recursive_absolute(ProjectSettings.globalize_path(root))

    return root.trim_suffix("/")


func ensure_game_dir(game_id:String, root_path:String = DEFAULT_ROOT) -> String:

    var dir_path:String = game_dir(game_id, root_path)

    DirAccess.make_dir_recursive_absolute(ProjectSettings.globalize_path(dir_path))

    return dir_path


func game_dir(game_id:String, root_path:String = DEFAULT_ROOT) -> String:

    var safe_game:String = _safe_id(game_id if game_id.strip_edges() != "" else "shared")

    return "%s/%s/custom_levels" % [ensure_root(root_path), safe_game]


func path_for_level(game_id:String, level_id:String, root_path:String = DEFAULT_ROOT) -> String:

    var safe_level:String = _safe_id(level_id if level_id.strip_edges() != "" else "custom_level")

    return "%s/%s.json" % [ensure_game_dir(game_id, root_path), safe_level]


func list_levels(game_types:Array = [], root_path:String = DEFAULT_ROOT) -> Array:

    var root:String = ensure_root(root_path)

    var accepted_types:Array = _normalize_game_types(game_types)

    var rows:Array = []

    _scan_dir(root, accepted_types, rows, root.ends_with("/custom_levels"))

    rows.sort_custom(func(a, b): return str(a.get("name", a.get("id", ""))).to_lower() < str(b.get("name", b.get("id", ""))).to_lower())

    return rows


func save_level(level_data:Dictionary, game_id:String = "", root_path:String = DEFAULT_ROOT) -> String:

    var resolved_game:String = game_id.strip_edges()

    if resolved_game == "":

        resolved_game = _game_id_for_level(level_data)

    var level_id:String = str(level_data.get("id", "custom_level"))

    var file_path:String = path_for_level(resolved_game, level_id, root_path)

    var file = FileAccess.open(file_path, FileAccess.WRITE)

    if file == null:

        return ""

    file.store_string(JSON.stringify(level_data, "\t"))

    return file_path


func load_level_data(file_path:String) -> Dictionary:

    var file = FileAccess.open(file_path, FileAccess.READ)

    if file == null:

        return {}

    var parsed = JSON.parse_string(file.get_as_text())

    return parsed.duplicate(true) if parsed is Dictionary else {}


func get_summary_for_path(file_path:String) -> Dictionary:

    var data:Dictionary = load_level_data(file_path)

    if data.is_empty():

        return {}

    return _summary_for_data(data, file_path)


func _scan_dir(dir_path:String, accepted_types:Array, rows:Array, in_custom_levels := false) -> void:

    var dir = DirAccess.open(dir_path)

    if dir == null:

        return

    dir.list_dir_begin()

    var entry:String = dir.get_next()

    while entry != "":

        if entry.begins_with("."):

            entry = dir.get_next()

            continue

        var child_path:String = "%s/%s" % [dir_path.trim_suffix("/"), entry]

        if dir.current_is_dir():

            _scan_dir(child_path, accepted_types, rows, in_custom_levels or entry == "custom_levels")

        elif in_custom_levels and entry.get_extension().to_lower() == "json":

            var row:Dictionary = get_summary_for_path(child_path)

            if not row.is_empty() and _matches_game_type(row, accepted_types):

                rows.append(row)

        entry = dir.get_next()

    dir.list_dir_end()


func _summary_for_data(data:Dictionary, file_path:String) -> Dictionary:

    var summary:Dictionary = level_manager.get_summary(data)

    var game_type:String = _game_type_for_level(data)

    summary["id"] = str(data.get("id", summary.get("id", file_path.get_file().get_basename())))

    summary["name"] = str(data.get("name", summary.get("name", summary["id"])))

    summary["description"] = str(data.get("description", "Custom level"))

    summary["path"] = file_path

    summary["source"] = "custom"

    summary["custom"] = true

    summary["game_type"] = game_type

    summary["metadata"] = data.get("metadata", {}).duplicate(true) if data.get("metadata", {}) is Dictionary else {}

    var issues:Array = level_manager.validate_level(data)

    summary["valid"] = issues.is_empty()

    summary["issues"] = issues

    return summary


func _game_type_for_level(data:Dictionary) -> String:

    var metadata = data.get("metadata", {})

    if metadata is Dictionary and str(metadata.get("game_type", "")).strip_edges() != "":

        return str(metadata.get("game_type", "shared"))

    return str(data.get("game_type", "shared"))


func _game_id_for_level(data:Dictionary) -> String:

    var metadata = data.get("metadata", {})

    if metadata is Dictionary and str(metadata.get("game_id", "")).strip_edges() != "":

        return str(metadata.get("game_id", "shared"))

    return str(data.get("game_id", _game_type_for_level(data)))


func _matches_game_type(row:Dictionary, accepted_types:Array) -> bool:

    if accepted_types.is_empty():

        return true

    var game_type:String = str(row.get("game_type", "shared")).to_lower()

    return accepted_types.has(game_type)


func _normalize_game_types(game_types:Array) -> Array:

    var normalized:Array = []

    for value in game_types:

        var id:String = str(value).strip_edges().to_lower()

        if id != "" and not normalized.has(id):

            normalized.append(id)

    return normalized


func _safe_id(value:String) -> String:

    var raw:String = value.strip_edges().to_lower()

    var result:String = ""

    for index in range(raw.length()):

        var character:String = raw.substr(index, 1)

        var allowed:bool = (character >= "a" and character <= "z") or (character >= "0" and character <= "9") or character == "_" or character == "-"

        result += character if allowed else "_"

    while result.contains("__"):

        result = result.replace("__", "_")

    result = result.strip_edges().trim_prefix("_").trim_suffix("_")

    return result if result != "" else "custom_level"