putt_putt_course_manager.gd

Go to the documentation of this file.

extends RefCounted
 
 
 
const DEFAULT_MODULES_PATH := "res://data/games/putt_putt_roguelike/course_modules.json"
const DEFAULT_PALETTE_PATH := "res://data/games/putt_putt_roguelike/editor_palette.json"
 
var modules:Array = []
var pieces:Array = []
var piece_generation:Dictionary = {}
var collision_shapes:Dictionary = {}
var tile_lookup:Dictionary = {}
var object_lookup:Dictionary = {}
 
 
func load_catalogs(options:Dictionary = {}) -> Dictionary:
    var module_path:String = str(options.get("modules", DEFAULT_MODULES_PATH))
    var palette_path:String = str(options.get("palette", DEFAULT_PALETTE_PATH))
    var module_data:Dictionary = _load_dictionary(module_path)
    var palette_data:Dictionary = _load_dictionary(palette_path)
    modules = module_data.get("modules", []) if module_data.get("modules", []) is Array else []
    pieces = module_data.get("pieces", []) if module_data.get("pieces", []) is Array else []
    piece_generation = module_data.get("piece_generation", {}) if module_data.get("piece_generation", {}) is Dictionary else {}
    collision_shapes.clear()
    for shape in module_data.get("collision_shapes", []):
        if shape is Dictionary and str(shape.get("id", "")) != "":
            collision_shapes[str(shape.get("id", ""))] = shape.duplicate(true)
    tile_lookup.clear()
    for tile in palette_data.get("tiles", []):
        if tile is Dictionary and str(tile.get("tile", "")) != "":
            tile_lookup[str(tile.get("tile", ""))] = tile.duplicate(true)
    object_lookup.clear()
    for object_def in palette_data.get("objects", []):
        if object_def is Dictionary and str(object_def.get("id", "")) != "":
            object_lookup[str(object_def.get("id", ""))] = object_def.duplicate(true)
    return {
        "modules": modules.size(),
        "pieces": pieces.size(),
        "collision_shapes": collision_shapes.size(),
        "tiles": tile_lookup.size(),
        "objects": object_lookup.size()
    }
 
 
func build_course(options:Dictionary = {}) -> Dictionary:
    if modules.is_empty():
        load_catalogs()
    if str(options.get("mode", "grid")) != "vertical" and not pieces.is_empty() and not piece_generation.is_empty():
        return _build_grid_course(options)
    return _build_vertical_course(options)
 
 
func validate_catalog() -> Array:
    var issues:Array = []
    if pieces.is_empty():
        issues.append(_issue("missing_pieces", "Putt-Putt catalog has no course pieces."))
    if piece_generation.is_empty():
        issues.append(_issue("missing_piece_generation", "Putt-Putt catalog has no piece_generation rules."))
    var valid_sides:Array = ["up", "down", "left", "right"]
    for piece in pieces:
        if not piece is Dictionary:
            issues.append(_issue("invalid_piece", "Course piece rows must be dictionaries."))
            continue
        var piece_id:String = str(piece.get("id", ""))
        if piece_id == "":
            issues.append(_issue("missing_piece_id", "Course piece is missing an id."))
        var rows:Array = piece.get("tiles", []) if piece.get("tiles", []) is Array else []
        var size:Array = piece.get("size", []) if piece.get("size", []) is Array else []
        var width:int = int(size[0]) if size.size() >= 1 else _piece_width_from_rows(rows)
        var height:int = int(size[1]) if size.size() >= 2 else rows.size()
        if width <= 0 or height <= 0:
            issues.append(_issue("invalid_piece_size", "Course piece %s has an invalid size." % piece_id, piece_id))
        if rows.size() != height:
            issues.append(_issue("piece_height_mismatch", "Course piece %s row count does not match size." % piece_id, piece_id))
        for y in range(rows.size()):
            var row_text:String = str(rows[y])
            if row_text.length() != width:
                issues.append(_issue("piece_width_mismatch", "Course piece %s row %d width does not match size." % [piece_id, y], piece_id))
            for x in range(row_text.length()):
                var symbol:String = row_text.substr(x, 1)
                if not tile_lookup.has(symbol):
                    issues.append(_issue("unknown_tile_symbol", "Course piece %s uses unknown tile '%s'." % [piece_id, symbol], piece_id))
        var connections:Array = _string_array(piece.get("connections", []))
        for side in connections:
            if not valid_sides.has(str(side)):
                issues.append(_issue("invalid_connection", "Course piece %s has invalid connection '%s'." % [piece_id, str(side)], piece_id))
        for object_row in piece.get("objects", []):
            if not object_row is Dictionary:
                issues.append(_issue("invalid_piece_object", "Course piece %s has a non-dictionary object." % piece_id, piece_id))
                continue
            var object_id:String = str(Dictionary(object_row).get("id", "object"))
            if Dictionary(object_row).has("position"):
                var position:Array = Dictionary(object_row).get("position", []) if Dictionary(object_row).get("position", []) is Array else []
                if position.size() < 2:
                    issues.append(_issue("invalid_object_position", "Object %s in %s has an invalid position." % [object_id, piece_id], piece_id))
                elif float(position[0]) < 0.0 or float(position[1]) < 0.0 or float(position[0]) > float(max(1, width)) or float(position[1]) > float(max(1, height)):
                    issues.append(_issue("object_position_out_of_bounds", "Object %s in %s is outside the piece bounds." % [object_id, piece_id], piece_id))
            else:
                var cell:Array = Dictionary(object_row).get("tile", []) if Dictionary(object_row).get("tile", []) is Array else []
                if cell.size() < 2:
                    issues.append(_issue("invalid_object_tile", "Object %s in %s has no tile or position." % [object_id, piece_id], piece_id))
                elif int(cell[0]) < 0 or int(cell[1]) < 0 or int(cell[0]) >= max(1, width) or int(cell[1]) >= max(1, height):
                    issues.append(_issue("object_tile_out_of_bounds", "Object %s in %s is outside the piece bounds." % [object_id, piece_id], piece_id))
    _validate_piece_generation_rules(issues)
    return issues
 
 
func _build_vertical_course(options:Dictionary = {}) -> Dictionary:
    var seed:int = int(options.get("seed", Time.get_unix_time_from_system()))
    var middle_count:int = max(1, int(options.get("middle_count", 1)))
    var rng := RandomNumberGenerator.new()
    rng.seed = seed
    var selected:Array = []
    var finish:Dictionary = _first_module_with_role("finish")
    var start:Dictionary = _first_module_with_role("start")
    if not finish.is_empty():
        selected.append(finish)
    var middle_modules:Array = _modules_with_role("middle")
    for _index in range(middle_count):
        if not middle_modules.is_empty():
            selected.append(middle_modules[rng.randi_range(0, middle_modules.size() - 1)])
    if not start.is_empty():
        selected.append(start)
    selected.reverse()
    return _compose_vertical(selected, seed)
 
 
func get_tile_definition(tile_symbol:String) -> Dictionary:
    return tile_lookup.get(tile_symbol, {}).duplicate(true) if tile_lookup.get(tile_symbol, {}) is Dictionary else {}
 
 
func get_object_definition(object_id:String) -> Dictionary:
    return object_lookup.get(object_id, {}).duplicate(true) if object_lookup.get(object_id, {}) is Dictionary else {}
 
 
func build_object_from_palette(object_id:String, overrides:Dictionary = {}) -> Dictionary:
    var definition:Dictionary = get_object_definition(object_id)
    if definition.is_empty():
        return overrides.duplicate(true)
    var object:Dictionary = {}
    var defaults:Dictionary = definition.get("defaults", {}) if definition.get("defaults", {}) is Dictionary else {}
    object.merge(defaults.duplicate(true), true)
    object["id"] = str(overrides.get("id", definition.get("id", object_id)))
    object["kind"] = str(overrides.get("kind", definition.get("kind", "object")))
    if str(definition.get("sprite", "")) != "":
        object["sprite_id"] = str(definition.get("sprite", ""))
    if str(definition.get("label", "")) != "":
        object["display_name"] = str(definition.get("label", ""))
    object.merge(overrides.duplicate(true), true)
    return object
 
 
func get_collision_shape(shape_id:String) -> Dictionary:
    return collision_shapes.get(shape_id, {}).duplicate(true) if collision_shapes.get(shape_id, {}) is Dictionary else {}
 
 
func _compose_vertical(selected:Array, seed:int) -> Dictionary:
    var width:int = 0
    for module in selected:
        if module is Dictionary:
            var size:Array = module.get("size", []) if module.get("size", []) is Array else []
            if size.size() >= 1:
                width = max(width, int(size[0]))
    var rows:Array[String] = []
    var objects:Array = []
    var tee:Array = []
    var cup:Array = []
    var module_ranges:Array = []
    var y_offset:int = 0
    for module in selected:
        if not module is Dictionary:
            continue
        var module_size:Array = module.get("size", []) if module.get("size", []) is Array else []
        var module_width:int = int(module_size[0]) if module_size.size() >= 1 else 0
        var x_offset:int = int(floor(float(width - module_width) / 2.0))
        var module_rows:Array = module.get("tiles", []) if module.get("tiles", []) is Array else []
        var start_y:int = y_offset
        for raw_row in module_rows:
            var row_text:String = str(raw_row)
            rows.append(_pad_row(row_text, width, x_offset))
            y_offset += 1
        for object_row in module.get("objects", []):
            if object_row is Dictionary:
                var object_copy:Dictionary = object_row.duplicate(true)
                object_copy["tile"] = _offset_cell(object_copy.get("tile", [0, 0]), x_offset, start_y)
                objects.append(object_copy)
        if module.has("tee"):
            tee = _offset_cell(module.get("tee", [0, 0]), x_offset, start_y)
        if module.has("cup"):
            cup = _offset_cell(module.get("cup", [0, 0]), x_offset, start_y)
        module_ranges.append({
            "id": str(module.get("id", "")),
            "role": str(module.get("role", "")),
            "y": start_y,
            "height": module_rows.size()
        })
    return {
        "schema_version": 1,
        "generation_mode": "vertical_modules",
        "seed": seed,
        "size": [width, rows.size()],
        "tiles": rows,
        "objects": objects,
        "tee": tee,
        "cup": cup,
        "modules": module_ranges
    }
 
 
func _build_grid_course(options:Dictionary = {}) -> Dictionary:
    var seed:int = int(options.get("seed", Time.get_unix_time_from_system()))
    var rng := RandomNumberGenerator.new()
    rng.seed = seed
    var grid_size:Array = piece_generation.get("normal_grid_size", [3, 3]) if piece_generation.get("normal_grid_size", []) is Array else [3, 3]
    var piece_size:Array = piece_generation.get("piece_size", [5, 4]) if piece_generation.get("piece_size", []) is Array else [5, 4]
    var grid_width:int = max(1, int(grid_size[0]) if grid_size.size() >= 1 else 3)
    var grid_height:int = max(1, int(grid_size[1]) if grid_size.size() >= 2 else 3)
    var piece_width:int = max(1, int(piece_size[0]) if piece_size.size() >= 1 else 5)
    var piece_height:int = max(1, int(piece_size[1]) if piece_size.size() >= 2 else 4)
    var role_rows:Array = piece_generation.get("normal_roles", []) if piece_generation.get("normal_roles", []) is Array else []
    var selected_grid:Array = []
    for y in range(grid_height):
        var selected_row:Array = []
        for x in range(grid_width):
            var role:String = _role_at(role_rows, x, y)
            var required_connections:Array = _required_connections_for_slot(role_rows, x, y)
            selected_row.append(_select_piece(role, required_connections, rng))
        selected_grid.append(selected_row)
    return _compose_piece_grid(selected_grid, seed, piece_width, piece_height, int(options.get("hole_index", 0)) + 1)
 
 
func _compose_piece_grid(selected_grid:Array, seed:int, piece_width:int, piece_height:int, run_hole:int = 1) -> Dictionary:
    var rng := RandomNumberGenerator.new()
    rng.seed = seed + 17013
    var grid_height:int = selected_grid.size()
    var grid_width:int = selected_grid[0].size() if grid_height > 0 and selected_grid[0] is Array else 0
    var width:int = grid_width * piece_width
    var height:int = grid_height * piece_height
    var rows:Array[String] = []
    for _row_index in range(height):
        var row_text:String = ""
        for _column_index in range(width):
            row_text += " "
        rows.append(row_text)
    var objects:Array = []
    var tee:Array = []
    var cup:Array = []
    var module_ranges:Array = []
    for gy in range(grid_height):
        var selected_row:Array = selected_grid[gy] if selected_grid[gy] is Array else []
        for gx in range(grid_width):
            var piece:Dictionary = selected_row[gx] if gx < selected_row.size() and selected_row[gx] is Dictionary else {}
            if piece.is_empty():
                continue
            var x_offset:int = gx * piece_width
            var y_offset:int = gy * piece_height
            _blit_piece_tiles(rows, piece, x_offset, y_offset, piece_width, piece_height)
            var source_size:Array = piece.get("size", [piece_width, piece_height]) if piece.get("size", []) is Array else [piece_width, piece_height]
            for object_row in piece.get("objects", []):
                if object_row is Dictionary:
                    var object_copy:Dictionary = object_row.duplicate(true)
                    if object_copy.has("position"):
                        object_copy["position"] = _offset_position(_scale_piece_position(object_copy.get("position", [0.5, 0.5]), source_size, piece_width, piece_height), x_offset, y_offset)
                    else:
                        object_copy["tile"] = _offset_cell(_scale_piece_cell(object_copy.get("tile", [0, 0]), source_size, piece_width, piece_height), x_offset, y_offset)
                    object_copy["source_piece"] = str(piece.get("id", ""))
                    objects.append(object_copy)
            if piece.has("tee"):
                tee = _offset_cell(_scale_piece_cell(piece.get("tee", [0, 0]), source_size, piece_width, piece_height), x_offset, y_offset)
            if piece.has("cup"):
                cup = _offset_cell(_scale_piece_cell(piece.get("cup", [0, 0]), source_size, piece_width, piece_height), x_offset, y_offset)
            module_ranges.append({
                "id": str(piece.get("id", "")),
                "role": str(piece.get("role", "")),
                "grid_cell": [gx, gy],
                "x": x_offset,
                "y": y_offset,
                "width": piece_width,
                "height": piece_height,
                "connections": _string_array(piece.get("connections", []))
            })
    objects.append_array(_scatter_random_objects(rows, rng, run_hole))
    return {
        "schema_version": 1,
        "generation_mode": "grid_pieces",
        "seed": seed,
        "grid_size": [grid_width, grid_height],
        "piece_size": [piece_width, piece_height],
        "size": [width, rows.size()],
        "tiles": rows,
        "objects": objects,
        "tee": tee,
        "cup": cup,
        "modules": module_ranges
    }
 
 
func _first_module_with_role(role:String) -> Dictionary:
    for module in modules:
        if module is Dictionary and str(module.get("role", "")) == role:
            return module.duplicate(true)
    return {}
 
 
func _modules_with_role(role:String) -> Array:
    var found:Array = []
    for module in modules:
        if module is Dictionary and str(module.get("role", "")) == role:
            found.append(module.duplicate(true))
    return found
 
 
func _role_at(role_rows:Array, x:int, y:int) -> String:
    if y < 0 or y >= role_rows.size() or not role_rows[y] is Array:
        return "void"
    var row:Array = role_rows[y]
    if x < 0 or x >= row.size():
        return "void"
    return str(row[x])
 
 
func _required_connections_for_slot(role_rows:Array, x:int, y:int) -> Array:
    var role:String = _role_at(role_rows, x, y)
    if role == "void":
        return []
    var required:Array = []
    for side in ["up", "down", "left", "right"]:
        var offset:Vector2i = _side_offset(side)
        if _role_at(role_rows, x + offset.x, y + offset.y) != "void":
            required.append(side)
    return required
 
 
func _select_piece(role:String, required_connections:Array, rng:RandomNumberGenerator) -> Dictionary:
    var candidates:Array = []
    for piece in pieces:
        if not piece is Dictionary:
            continue
        if bool(piece.get("disabled", false)):
            continue
        if str(piece.get("role", "green")) != role:
            continue
        if _piece_has_connections(piece, required_connections):
            candidates.append(piece.duplicate(true))
    if candidates.is_empty() and role != "void":
        for piece in pieces:
            if piece is Dictionary and not bool(piece.get("disabled", false)) and str(piece.get("role", "")) == role:
                candidates.append(piece.duplicate(true))
    if candidates.is_empty():
        for piece in pieces:
            if piece is Dictionary and not bool(piece.get("disabled", false)) and str(piece.get("role", "")) == "void":
                return piece.duplicate(true)
        return {}
    return candidates[rng.randi_range(0, candidates.size() - 1)]
 
 
func _piece_has_connections(piece:Dictionary, required_connections:Array) -> bool:
    var connections:Array = _string_array(piece.get("connections", []))
    for side in required_connections:
        if not connections.has(str(side)):
            return false
    return true
 
 
func _side_offset(side:String) -> Vector2i:
    match side:
        "up":
            return Vector2i(0, -1)
        "down":
            return Vector2i(0, 1)
        "left":
            return Vector2i(-1, 0)
        "right":
            return Vector2i(1, 0)
        _:
            return Vector2i.ZERO
 
 
func _blit_piece_tiles(rows:Array[String], piece:Dictionary, x_offset:int, y_offset:int, piece_width:int, piece_height:int) -> void:
    var piece_rows:Array = piece.get("tiles", []) if piece.get("tiles", []) is Array else []
    var source_height:int = max(1, piece_rows.size())
    var source_width:int = 1
    var piece_size:Array = piece.get("size", []) if piece.get("size", []) is Array else []
    if piece_size.size() >= 1:
        source_width = max(1, int(piece_size[0]))
    else:
        for piece_row in piece_rows:
            source_width = max(source_width, str(piece_row).length())
    for local_y in range(piece_height):
        var source_y:int = clampi(floori((float(local_y) + 0.5) / float(piece_height) * float(source_height)), 0, source_height - 1)
        var source_row:String = str(piece_rows[source_y]) if source_y < piece_rows.size() else ""
        while source_row.length() < source_width:
            source_row += " "
        var target_y:int = y_offset + local_y
        if target_y < 0 or target_y >= rows.size():
            continue
        var target_row:String = rows[target_y]
        for local_x in range(piece_width):
            var source_x:int = clampi(floori((float(local_x) + 0.5) / float(piece_width) * float(source_width)), 0, source_width - 1)
            var target_x:int = x_offset + local_x
            if target_x < 0 or target_x >= target_row.length():
                continue
            target_row = target_row.substr(0, target_x) + source_row.substr(source_x, 1) + target_row.substr(target_x + 1)
        rows[target_y] = target_row
 
 
func _string_array(raw) -> Array:
    var result:Array = []
    if not raw is Array:
        return result
    for value in raw:
        result.append(str(value))
    return result
 
 
func _pad_row(row_text:String, width:int, x_offset:int) -> String:
    var prefix:String = ""
    for _index in range(max(0, x_offset)):
        prefix += " "
    var row:String = prefix + row_text
    while row.length() < width:
        row += " "
    return row.substr(0, width)
 
 
func _offset_cell(raw, x_offset:int, y_offset:int) -> Array:
    if raw is Array and raw.size() >= 2:
        return [int(raw[0]) + x_offset, int(raw[1]) + y_offset]
    return [x_offset, y_offset]
 
 
func _offset_position(raw, x_offset:int, y_offset:int) -> Array:
    if raw is Array and raw.size() >= 2:
        return [float(raw[0]) + float(x_offset), float(raw[1]) + float(y_offset)]
    return [float(x_offset), float(y_offset)]
 
 
func _scale_piece_cell(raw, source_size:Array, target_width:int, target_height:int) -> Array:
    if not raw is Array or raw.size() < 2:
        return [0, 0]
    var source_width:int = max(1, int(source_size[0]) if source_size.size() >= 1 else target_width)
    var source_height:int = max(1, int(source_size[1]) if source_size.size() >= 2 else target_height)
    var x:int = clampi(floori((float(int(raw[0])) + 0.5) / float(source_width) * float(target_width)), 0, target_width - 1)
    var y:int = clampi(floori((float(int(raw[1])) + 0.5) / float(source_height) * float(target_height)), 0, target_height - 1)
    return [x, y]
 
 
func _scale_piece_position(raw, source_size:Array, target_width:int, target_height:int) -> Array:
    if not raw is Array or raw.size() < 2:
        return [0.5, 0.5]
    var source_width:int = max(1, int(source_size[0]) if source_size.size() >= 1 else target_width)
    var source_height:int = max(1, int(source_size[1]) if source_size.size() >= 2 else target_height)
    return [
        (float(raw[0]) + 0.5) / float(source_width) * float(target_width) - 0.5,
        (float(raw[1]) + 0.5) / float(source_height) * float(target_height) - 0.5
    ]
 
 
func _scatter_random_objects(rows:Array[String], rng:RandomNumberGenerator, run_hole:int) -> Array:
    var result:Array = []
    var random_objects:Array = piece_generation.get("random_objects", []) if piece_generation.get("random_objects", []) is Array else []
    if random_objects.is_empty():
        return result
    var candidates:Array = []
    for y in range(rows.size()):
        var row_text:String = str(rows[y])
        for x in range(row_text.length()):
            var symbol:String = row_text.substr(x, 1)
            var tile:Dictionary = get_tile_definition(symbol)
            var metadata:Dictionary = tile.get("metadata", {}) if tile.get("metadata", {}) is Dictionary else {}
            if str(metadata.get("type", "")) in ["solid", "hazard", "void"] or symbol in ["T", "C", "#", " ", "/", "\\", "1", "2"]:
                continue
            candidates.append(Vector2i(x, y))
    for definition in random_objects:
        if not definition is Dictionary:
            continue
        if run_hole < int(definition.get("min_hole", 1)):
            continue
        for index in range(max(0, int(definition.get("count", 1)))):
            if candidates.is_empty():
                return result
            var candidate_index:int = rng.randi_range(0, candidates.size() - 1)
            var cell:Vector2i = candidates[candidate_index]
            candidates.remove_at(candidate_index)
            var palette_id:String = str(definition.get("palette_id", definition.get("object_id", definition.get("id", ""))))
            var object_copy:Dictionary = build_object_from_palette(palette_id, definition.duplicate(true))
            object_copy["id"] = "%s_%d" % [str(definition.get("id", "random_object")), result.size()]
            object_copy["position"] = [
                float(cell.x) + rng.randf_range(0.25, 0.75),
                float(cell.y) + rng.randf_range(0.25, 0.75)
            ]
            object_copy["placement"] = "random_green"
            object_copy.erase("count")
            object_copy.erase("min_hole")
            object_copy.erase("palette_id")
            object_copy.erase("object_id")
            result.append(object_copy)
    return result
 
 
func _validate_piece_generation_rules(issues:Array) -> void:
    if piece_generation.is_empty():
        return
    var role_rows:Array = piece_generation.get("normal_roles", []) if piece_generation.get("normal_roles", []) is Array else []
    var grid_size:Array = piece_generation.get("normal_grid_size", [3, 3]) if piece_generation.get("normal_grid_size", []) is Array else [3, 3]
    var grid_width:int = max(1, int(grid_size[0]) if grid_size.size() >= 1 else 3)
    var grid_height:int = max(1, int(grid_size[1]) if grid_size.size() >= 2 else 3)
    if role_rows.size() != grid_height:
        issues.append(_issue("role_grid_height_mismatch", "Putt-Putt normal_roles height does not match normal_grid_size."))
    for y in range(grid_height):
        var row:Array = role_rows[y] if y < role_rows.size() and role_rows[y] is Array else []
        if row.size() != grid_width:
            issues.append(_issue("role_grid_width_mismatch", "Putt-Putt normal_roles row %d width does not match normal_grid_size." % y))
        for x in range(grid_width):
            var role:String = _role_at(role_rows, x, y)
            var required_connections:Array = _required_connections_for_slot(role_rows, x, y)
            if _candidate_count_for_role(role, required_connections) == 0:
                issues.append(_issue("missing_piece_candidate", "No enabled Putt-Putt piece can fill %s slot %d,%d with required connections %s." % [role, x, y, str(required_connections)]))
 
 
func _candidate_count_for_role(role:String, required_connections:Array) -> int:
    var count:int = 0
    for piece in pieces:
        if not piece is Dictionary:
            continue
        if bool(piece.get("disabled", false)):
            continue
        if str(piece.get("role", "green")) != role:
            continue
        if _piece_has_connections(piece, required_connections):
            count += 1
    return count
 
 
func _piece_width_from_rows(rows:Array) -> int:
    var width:int = 0
    for row in rows:
        width = max(width, str(row).length())
    return width
 
 
func _issue(issue_type:String, message:String, piece_id:String = "") -> Dictionary:
    var issue:Dictionary = {
        "type": issue_type,
        "message": message
    }
    if piece_id != "":
        issue["piece_id"] = piece_id
    return issue
 
 
func _load_dictionary(path:String) -> Dictionary:
    if not FileAccess.file_exists(path):
        return {}
    var file := FileAccess.open(path, FileAccess.READ)
    if file == null:
        return {}
    var parsed = JSON.parse_string(file.get_as_text())
    return parsed if parsed is Dictionary else {}