level_editor_manager.gd

Go to the documentation of this file.

extends RefCounted
 
 
 
const TOOLS := ["tile", "object", "erase"]
 
 
func create_history(max_entries:int = 40) -> Dictionary:
    return {
        "undo": [],
        "redo": [],
        "max_entries": max(1, max_entries),
        "restoring": false
    }
 
 
func push_history(history:Dictionary, level_data:Dictionary) -> void:
    if bool(history.get("restoring", false)) or level_data.is_empty():
        return
    var undo:Array = history.get("undo", [])
    undo.append(level_data.duplicate(true))
    var max_entries = int(history.get("max_entries", 40))
    while undo.size() > max_entries:
        undo.pop_front()
    history["undo"] = undo
    history["redo"] = []
 
 
func can_undo(history:Dictionary) -> bool:
    return not (history.get("undo", []) as Array).is_empty()
 
 
func can_redo(history:Dictionary) -> bool:
    return not (history.get("redo", []) as Array).is_empty()
 
 
func undo(history:Dictionary, current_data:Dictionary) -> Dictionary:
    var undo_stack:Array = history.get("undo", [])
    if undo_stack.is_empty():
        return {}
    var redo_stack:Array = history.get("redo", [])
    redo_stack.append(current_data.duplicate(true))
    history["redo"] = redo_stack
    history["undo"] = undo_stack
    return undo_stack.pop_back()
 
 
func redo(history:Dictionary, current_data:Dictionary) -> Dictionary:
    var redo_stack:Array = history.get("redo", [])
    if redo_stack.is_empty():
        return {}
    var undo_stack:Array = history.get("undo", [])
    undo_stack.append(current_data.duplicate(true))
    history["undo"] = undo_stack
    history["redo"] = redo_stack
    return redo_stack.pop_back()
 
 
func normalized_rows(rows, width:int, height:int, fill_tile := ".") -> Array:
    var result := []
    for y in range(max(0, height)):
        var row = str(rows[y]) if rows is Array and y < rows.size() else ""
        if row.length() < width:
            row += fill_tile.repeat(width - row.length())
        elif row.length() > width:
            row = row.substr(0, width)
        result.append(row)
    return result
 
 
func dimensions_from_level(level_data:Dictionary) -> Vector2i:
    var layers = get_layers(level_data)
    if layers.is_empty():
        var legacy_tiles = level_data.get("tiles", [])
        if legacy_tiles is Array and not legacy_tiles.is_empty():
            return Vector2i(str(legacy_tiles[0]).length(), legacy_tiles.size())
        return Vector2i.ZERO
    var rows = layers[0].get("tiles", [])
    if rows is Array and not rows.is_empty():
        return Vector2i(str(rows[0]).length(), rows.size())
    return Vector2i.ZERO
 
 
func cell_in_bounds(level_data:Dictionary, cell:Vector2i) -> bool:
    var dimensions = dimensions_from_level(level_data)
    return cell.x >= 0 and cell.y >= 0 and cell.x < dimensions.x and cell.y < dimensions.y
 
 
func clamp_cell(level_data:Dictionary, cell:Vector2i) -> Vector2i:
    var dimensions = dimensions_from_level(level_data)
    if dimensions == Vector2i.ZERO:
        return Vector2i.ZERO
    return Vector2i(
        clampi(cell.x, 0, max(0, dimensions.x - 1)),
        clampi(cell.y, 0, max(0, dimensions.y - 1))
    )
 
 
func get_layers(level_data:Dictionary) -> Array:
    if not level_data.get("layers", []) is Array:
        level_data["layers"] = []
    return level_data.get("layers", [])
 
 
func get_objects(level_data:Dictionary) -> Array:
    if not level_data.get("objects", []) is Array:
        level_data["objects"] = []
    return level_data.get("objects", [])
 
 
func resize_layers(level_data:Dictionary, width:int, height:int) -> Dictionary:
    var result = level_data.duplicate(true)
    var layers = get_layers(result)
    for i in range(layers.size()):
        var layer = layers[i]
        layer["tiles"] = normalized_rows(layer.get("tiles", []), width, height)
        result["layers"][i] = layer
    return result
 
 
func set_tile(level_data:Dictionary, cell:Vector2i, tile:String, layer_index:int, width:int, height:int) -> Dictionary:
    var result = level_data.duplicate(true)
    if not cell_in_bounds(result, cell):
        return result
    var layers = get_layers(result)
    if layers.is_empty():
        result["layers"] = [{"id": "terrain", "type": "tiles", "collision": true, "visible": true, "tiles": []}]
        layers = get_layers(result)
    layer_index = clampi(layer_index, 0, layers.size() - 1)
    var layer = layers[layer_index]
    var rows = normalized_rows(layer.get("tiles", []), width, height)
    var row = str(rows[cell.y])
    rows[cell.y] = row.substr(0, cell.x) + tile.substr(0, 1) + row.substr(cell.x + 1)
    layer["tiles"] = rows
    result["layers"][layer_index] = layer
    return result
 
 
func remove_objects_at_cell(level_data:Dictionary, cell:Vector2i) -> Dictionary:
    var result = level_data.duplicate(true)
    var objects := []
    for object in get_objects(result):
        if object is Dictionary and cell_from_tile(object.get("tile", [])) == cell:
            continue
        objects.append(object)
    result["objects"] = objects
    return result
 
 
func remove_object_by_id(level_data:Dictionary, object_id:String) -> Dictionary:
    var result = level_data.duplicate(true)
    var objects := []
    for object in get_objects(result):
        if object is Dictionary and str(object.get("id", "")) != object_id:
            objects.append(object)
    result["objects"] = objects
    return result
 
 
func fill_tiles(level_data:Dictionary, start:Vector2i, selected_tile:String, layer_index:int, width:int, height:int) -> Dictionary:
    var result = level_data.duplicate(true)
    var layers = get_layers(result)
    if layers.is_empty():
        return {"changed": false, "level_data": result, "count": 0, "picked_tile": ""}
    layer_index = clampi(layer_index, 0, layers.size() - 1)
    var layer = layers[layer_index]
    var rows = normalized_rows(layer.get("tiles", []), width, height)
    if start.y < 0 or start.y >= rows.size():
        return {"changed": false, "level_data": result, "count": 0, "picked_tile": ""}
    var start_row = str(rows[start.y])
    if start.x < 0 or start.x >= start_row.length():
        return {"changed": false, "level_data": result, "count": 0, "picked_tile": ""}
    var target_tile = start_row[start.x]
    if target_tile == selected_tile:
        return {"changed": false, "level_data": result, "count": 0, "picked_tile": target_tile}
    var visited := {}
    var queue := [start]
    while not queue.is_empty():
        var cell:Vector2i = queue.pop_front()
        var key = "%d,%d" % [cell.x, cell.y]
        if visited.has(key) or cell.x < 0 or cell.y < 0 or cell.y >= rows.size() or cell.x >= start_row.length():
            continue
        var row = str(rows[cell.y])
        if row[cell.x] != target_tile:
            continue
        visited[key] = true
        rows[cell.y] = row.substr(0, cell.x) + selected_tile.substr(0, 1) + row.substr(cell.x + 1)
        queue.append(cell + Vector2i.LEFT)
        queue.append(cell + Vector2i.RIGHT)
        queue.append(cell + Vector2i.UP)
        queue.append(cell + Vector2i.DOWN)
    layer["tiles"] = rows
    result["layers"][layer_index] = layer
    return {"changed": true, "level_data": result, "count": visited.size(), "picked_tile": target_tile}
 
 
func pick_tile(level_data:Dictionary, cell:Vector2i, layer_index:int, width:int, height:int) -> String:
    var layers = get_layers(level_data)
    if layers.is_empty():
        return ""
    layer_index = clampi(layer_index, 0, layers.size() - 1)
    var rows = normalized_rows(layers[layer_index].get("tiles", []), width, height)
    if cell.y < 0 or cell.y >= rows.size():
        return ""
    var row = str(rows[cell.y])
    if cell.x < 0 or cell.x >= row.length():
        return ""
    return row[cell.x]
 
 
func cycle_tool(current_tool:String, delta:int = 1) -> String:
    var index = TOOLS.find(current_tool)
    return str(TOOLS[posmod(max(0, index) + delta, TOOLS.size())])
 
 
func palette_visibility(tool:String) -> Dictionary:
    return {
        "tiles": tool == "tile",
        "objects": tool == "object",
        "object_panel": tool == "object"
    }
 
 
func input_badges(controller_active:bool) -> Array:
    var place = "A" if controller_active else "Enter"
    var erase = "X" if controller_active else "2"
    var tool = "Y" if controller_active else "3"
    var save = "B" if controller_active else "4"
    var palette = "LB/RB" if controller_active else "PgUp/PgDn"
    return [
        {"text": "✚", "tooltip": "Move cursor"},
        {"text": "%s ◆" % place, "tooltip": "Place"},
        {"text": "%s ⌫" % erase, "tooltip": "Erase"},
        {"text": "%s ⚒" % tool, "tooltip": "Cycle tool"},
        {"text": "%s ▦" % palette, "tooltip": "Cycle palette"},
        {"text": "F ▣", "tooltip": "Fill area"},
        {"text": "Q ◉", "tooltip": "Pick tile"},
        {"text": "Ctrl+Z ↶", "tooltip": "Undo"},
        {"text": "Ctrl+Y ↷", "tooltip": "Redo"},
        {"text": "%s ▤" % save, "tooltip": "Save"}
    ]
 
 
func cell_from_tile(tile_value) -> Vector2i:
    if tile_value is Vector2i:
        return tile_value
    if tile_value is Vector2:
        return Vector2i(int(tile_value.x), int(tile_value.y))
    if tile_value is Array and tile_value.size() >= 2:
        return Vector2i(int(tile_value[0]), int(tile_value[1]))
    return Vector2i.ZERO