targeting_manager.gd

Go to the documentation of this file.

extends RefCounted
 
 
 
const DEFAULT_CONFIG := {
    "tile_size": 40.0,
    "projectile_range": 6,
    "aoe_radius": 1
}
 
 
 
func get_target_cells(card:Dictionary, origin:Vector2i, direction:Vector2i, bounds:Rect2, blocked_cells:Array, config := {}, primary_target = null) -> Array:
    var targeting = card.get("targeting", {})
    if not targeting is Dictionary:
        targeting = {}
    var merged = _merged_config(config)
    var type = str(targeting.get("type", "projectile"))
    var max_range = int(targeting.get("range", merged.get("projectile_range", DEFAULT_CONFIG["projectile_range"])))
    if card.has("compound") and str(card.get("manifestation", "")) == "":
        type = "projectile"
        max_range = 1
    match type:
        "aoe":
            return cells_in_radius(origin, int(targeting.get("aoe_radius", merged.get("aoe_radius", DEFAULT_CONFIG["aoe_radius"]))), bounds, merged)
        "homing":
            if primary_target == null:
                return []
            return [_cell_from_any(primary_target)]
        "lob":
            if direction == Vector2i.ZERO:
                return []
            var landing = origin + direction * max_range
            return cells_in_radius(landing, int(targeting.get("aoe_radius", merged.get("aoe_radius", DEFAULT_CONFIG["aoe_radius"]))), bounds, merged)
        _:
            if direction == Vector2i.ZERO:
                return []
            return trace_grid_line(origin, direction, max_range, bounds, blocked_cells, merged)
 
 
 
func cells_in_radius(center:Vector2i, radius:int, bounds:Rect2, config := {}) -> Array:
    var cells := []
    var merged = _merged_config(config)
    for y in range(center.y - radius, center.y + radius + 1):
        for x in range(center.x - radius, center.x + radius + 1):
            var cell = Vector2i(x, y)
            if abs(x - center.x) + abs(y - center.y) <= radius and _cell_in_bounds(cell, bounds, merged):
                cells.append(cell)
    return cells
 
 
 
func trace_grid_line(origin:Vector2i, direction:Vector2i, max_range:int, bounds:Rect2, blocked_cells:Array, config := {}) -> Array:
    var cells := []
    var current = origin
    var merged = _merged_config(config)
    for _index in range(max(0, max_range)):
        current += direction
        if not _cell_in_bounds(current, bounds, merged) or _cell_blocked(current, blocked_cells):
            break
        cells.append(current)
    return cells
 
 
 
func get_attack_trace_cells(actions:Array, bounds:Rect2, blocked_cells:Array, config := {}) -> Array:
    var cells := []
    for action in actions:
        if not action is Dictionary or str(action.get("type", "")) != "attack":
            continue
        var from_cell = _cell_from_any(action.get("from", Vector2i.ZERO))
        var target_cell = _cell_from_any(action.get("target", Vector2i.ZERO))
        if str(action.get("attack_type", "")) == "beam":
            var direction = Vector2i(sign(target_cell.x - from_cell.x), sign(target_cell.y - from_cell.y))
            if direction != Vector2i.ZERO:
                for cell in trace_grid_line(from_cell, direction, _grid_distance(from_cell, target_cell), bounds, blocked_cells, config):
                    cells.append(cell)
        else:
            cells.append(target_cell)
    return cells
 
 
 
func get_targeting_summary(card:Dictionary, config := {}) -> Dictionary:
    var targeting = card.get("targeting", {})
    if not targeting is Dictionary:
        targeting = {}
    var merged = _merged_config(config)
    var type = str(targeting.get("type", "projectile"))
    var attack_range = int(targeting.get("range", merged.get("projectile_range", DEFAULT_CONFIG["projectile_range"])))
    var radius = int(targeting.get("aoe_radius", merged.get("aoe_radius", DEFAULT_CONFIG["aoe_radius"])))
    var mode := "Projectile"
    var range_text := "%d squares ahead" % attack_range
    if card.has("compound") and str(card.get("manifestation", "")) == "":
        type = "element"
        attack_range = 1
        range_text = "1 tile ahead"
    match type:
        "element":
            mode = "Element"
        "aoe":
            mode = "AOE"
            range_text = "radius %d" % radius
        "beam":
            mode = "Beam"
            range_text = "%d squares ahead" % attack_range
        "lob":
            mode = "Lob"
            range_text = "%d squares, radius %d" % [attack_range, radius]
        "homing":
            mode = "Homing"
            range_text = "nearest target"
    return {
        "mode": mode,
        "range": attack_range,
        "radius": radius,
        "range_text": range_text,
        "label": "%s | %s" % [mode, range_text]
    }
 
 
 
func format_card_summary(card:Dictionary, config := {}) -> String:
    var targeting = get_targeting_summary(card, config)
    return "%d energy | %d damage | %s" % [
        int(card.get("energy", 1)),
        int(card.get("damage", 0)),
        str(targeting.get("label", "Projectile"))
    ]
 
 
func _cell_in_bounds(cell:Vector2i, bounds:Rect2, config:Dictionary) -> bool:
    var tile_size = max(1.0, float(config.get("tile_size", DEFAULT_CONFIG["tile_size"])))
    var world_position = Vector2(float(cell.x) * tile_size + tile_size * 0.5, float(cell.y) * tile_size + tile_size * 0.5)
    return bounds.has_point(world_position)
 
 
func _cell_blocked(cell:Vector2i, blocked_cells:Array) -> bool:
    for blocked in blocked_cells:
        if _cell_from_any(blocked) == cell:
            return true
    return false
 
 
func _grid_distance(a:Vector2i, b:Vector2i) -> int:
    return abs(a.x - b.x) + abs(a.y - b.y)
 
 
func _cell_from_any(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_any(value.get("cell"))
    return Vector2i.ZERO
 
 
func _merged_config(config:Dictionary) -> Dictionary:
    var merged = DEFAULT_CONFIG.duplicate(true)
    for key in config.keys():
        merged[key] = config[key]
    return merged