grid_world_manager.gd

Go to the documentation of this file.

extends RefCounted
 
 
 
var world_config := {}
var tile_size := 40.0
 
 
 
func configure(config:Dictionary, next_tile_size := 40.0) -> void:
    world_config = config.duplicate(true)
    tile_size = max(1.0, float(next_tile_size))
 
 
func get_grid_size() -> Vector2i:
    return _cell_from_value(world_config.get("grid_size", [12, 12]))
 
 
func get_bounds() -> Rect2:
    return Rect2(Vector2.ZERO, Vector2(get_grid_size()) * tile_size)
 
 
func get_blocked_cells() -> Array:
    var cells := []
    for obstacle in world_config.get("obstacles", []):
        if not obstacle is Dictionary:
            continue
        for cell in cells_from_obstacle(obstacle):
            cells.append(cell)
    return cells
 
 
func get_movement_blocked_cells(occupied_cells:Array) -> Array:
    var cells = get_blocked_cells()
    for cell in occupied_cells:
        cells.append(_cell_from_value(cell))
    return cells
 
 
func cells_from_obstacle(obstacle:Dictionary) -> Array:
    var cells := []
    if obstacle.has("cells"):
        for cell in obstacle.get("cells", []):
            cells.append(_cell_from_value(cell))
    elif obstacle.has("rect"):
        cells = rect_to_cells(_rect_from_value(obstacle.get("rect", [])))
    return cells
 
 
func rect_to_cells(rect:Rect2) -> Array:
    var min_cell = Vector2i(int(floor(rect.position.x / tile_size)), int(floor(rect.position.y / tile_size)))
    var max_cell = Vector2i(
        int(floor((rect.position.x + max(0.0, rect.size.x - 0.01)) / tile_size)),
        int(floor((rect.position.y + max(0.0, rect.size.y - 0.01)) / tile_size))
    )
    var cells := []
    for y in range(min_cell.y, max_cell.y + 1):
        for x in range(min_cell.x, max_cell.x + 1):
            cells.append(Vector2i(x, y))
    return cells
 
 
 
func collect_material_at(cell:Vector2i, collected_nodes:Dictionary) -> Dictionary:
    for node in world_config.get("material_nodes", []):
        if not node is Dictionary:
            continue
        var node_id = str(node.get("id", ""))
        if node_id == "" or collected_nodes.has(node_id):
            continue
        if _cell_from_value(node.get("cell", [0, 0])) != cell:
            continue
        return {
            "collected": true,
            "node_id": node_id,
            "element": str(node.get("element", "")),
            "amount": int(node.get("amount", 1))
        }
    return {"collected": false}
 
 
 
func resolve_spell_interactions(card:Dictionary, affected_cells:Array, activated_interactions:Dictionary) -> Array:
    var activated := []
    for interaction in world_config.get("spell_interactions", []):
        if not interaction is Dictionary:
            continue
        var id = str(interaction.get("id", ""))
        if id == "" or activated_interactions.has(id):
            continue
        var cell = _cell_from_value(interaction.get("cell", [0, 0]))
        if not affected_cells.has(cell):
            continue
        if not _card_matches_interaction(card, interaction):
            continue
        var entry = interaction.duplicate(true)
        entry["activated"] = true
        activated.append(entry)
    return activated
 
 
func _rect_from_value(value) -> Rect2:
    if value is Rect2:
        return value
    if value is Array and value.size() >= 4:
        return Rect2(Vector2(float(value[0]), float(value[1])), Vector2(float(value[2]), float(value[3])))
    return Rect2()
 
 
func _cell_from_value(value) -> Vector2i:
    if value is Vector2i:
        return value
    if value is Vector2:
        return Vector2i(int(value.x), int(value.y))
    if value is Array and value.size() >= 2:
        return Vector2i(int(value[0]), int(value[1]))
    if value is Dictionary and value.has("cell"):
        return _cell_from_value(value.get("cell"))
    return Vector2i.ZERO
 
 
func _card_matches_interaction(card:Dictionary, interaction:Dictionary) -> bool:
    var requires = interaction.get("requires", {})
    if not requires is Dictionary or requires.is_empty():
        return true
    for key in requires.keys():
        var expected = requires[key]
        if key == "compound" and str(card.get("compound", "")) != str(expected):
            return false
        if key == "manifestation" and str(card.get("manifestation", "")) != str(expected):
            return false
        if key == "card_id" and str(card.get("id", "")) != str(expected):
            return false
        if key == "modifier" and not card.get("modifiers", []).has(str(expected)):
            return false
    return true