grid_world_manager.gd

Go to the documentation of this file.

extends RefCounted
 
 
 
var world_config := {}
var tile_size := 40.0
var blocked_cells_cache:Array = []
var material_nodes_by_cell:Dictionary = {}
var spell_interactions_by_cell:Dictionary = {}
var cache_hits:int = 0
var cache_misses:int = 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))
    _rebuild_runtime_indexes()
 
 
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:
    cache_hits += 1
    return blocked_cells_cache.duplicate()
 
 
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:
    var nodes:Array = material_nodes_by_cell.get(_cell_key(cell), []) if material_nodes_by_cell.get(_cell_key(cell), []) is Array else []
    if nodes.is_empty():
        cache_misses += 1
    else:
        cache_hits += 1
    for node in 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 affected_cell in affected_cells:
        var cell:Vector2i = _cell_from_value(affected_cell)
        var interactions:Array = spell_interactions_by_cell.get(_cell_key(cell), []) if spell_interactions_by_cell.get(_cell_key(cell), []) is Array else []
        if interactions.is_empty():
            cache_misses += 1
        else:
            cache_hits += 1
        for interaction in interactions:
            if not interaction is Dictionary:
                continue
            var id = str(interaction.get("id", ""))
            if id == "" or activated_interactions.has(id):
                continue
            if not _card_matches_interaction(card, interaction):
                continue
            var entry = interaction.duplicate(true)
            entry["activated"] = true
            activated.append(entry)
    return activated
 
 
func get_cache_stats() -> Dictionary:
    return {
        "blocked_cells": blocked_cells_cache.size(),
        "material_cells": material_nodes_by_cell.size(),
        "interaction_cells": spell_interactions_by_cell.size(),
        "cache_hits": cache_hits,
        "cache_misses": cache_misses
    }
 
 
func clear_caches() -> void:
    blocked_cells_cache.clear()
    material_nodes_by_cell.clear()
    spell_interactions_by_cell.clear()
    cache_hits = 0
    cache_misses = 0
 
 
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 _rebuild_runtime_indexes() -> void:
    clear_caches()
    for obstacle in world_config.get("obstacles", []):
        if not obstacle is Dictionary:
            continue
        for cell in cells_from_obstacle(obstacle):
            blocked_cells_cache.append(_cell_from_value(cell))
    for node in world_config.get("material_nodes", []):
        if not node is Dictionary:
            continue
        var node_cell:Vector2i = _cell_from_value(node.get("cell", [0, 0]))
        var material_key:String = _cell_key(node_cell)
        if not material_nodes_by_cell.has(material_key):
            material_nodes_by_cell[material_key] = []
        material_nodes_by_cell[material_key].append(node.duplicate(true))
    for interaction in world_config.get("spell_interactions", []):
        if not interaction is Dictionary:
            continue
        var interaction_cell:Vector2i = _cell_from_value(interaction.get("cell", [0, 0]))
        var interaction_key:String = _cell_key(interaction_cell)
        if not spell_interactions_by_cell.has(interaction_key):
            spell_interactions_by_cell[interaction_key] = []
        spell_interactions_by_cell[interaction_key].append(interaction.duplicate(true))
 
 
func _cell_key(cell:Vector2i) -> String:
    return "%d,%d" % [cell.x, cell.y]
 
 
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