projectile_lifecycle_manager.gd

Go to the documentation of this file.

extends RefCounted
 
 
 
 
func should_queue(card:Dictionary, direction:Vector2i, affected_cells:Array) -> bool:
    if direction == Vector2i.ZERO or affected_cells.is_empty():
        return false
    var targeting = _targeting(card)
    var type = str(targeting.get("type", "projectile"))
    if card.has("compound") and str(card.get("manifestation", "")) == "":
        return false
    return type in ["projectile", "lob"]
 
 
func create_effect(card:Dictionary, origin_cell:Vector2i, affected_cells:Array, used_slot:int, direction:Vector2i, options:Dictionary = {}) -> Dictionary:
    var targeting = _targeting(card)
    var type = str(targeting.get("type", "projectile"))
    var travel_seconds = max(0.08, float(options.get("travel_ms", 520)) / 1000.0)
    var end_cell = _impact_cell(card, origin_cell, affected_cells, direction)
    return {
        "card": card.duplicate(true),
        "used_slot": used_slot,
        "card_id": str(card.get("id", "")),
        "type": type,
        "shape": str(card.get("visual", {}).get("shape", type)),
        "origin_cell": origin_cell,
        "end_cell": end_cell,
        "direction": direction,
        "affected_cells": affected_cells.duplicate(true),
        "age": 0.0,
        "duration": travel_seconds,
        "color": str(card.get("visual", {}).get("color", options.get("color", "#ffffff")))
    }
 
 
func step_effects(active_effects:Array, delta:float) -> Dictionary:
    var active := []
    var ready := []
    for raw_effect in active_effects:
        if not raw_effect is Dictionary:
            continue
        var effect = raw_effect.duplicate(true)
        effect["age"] = float(effect.get("age", 0.0)) + delta
        if float(effect.get("age", 0.0)) >= float(effect.get("duration", 0.1)):
            ready.append(effect)
        else:
            active.append(effect)
    return {
        "active": active,
        "ready": ready
    }
 
 
func resolve_cells(effect:Dictionary, resolver:Callable = Callable()) -> Array:
    if resolver.is_valid():
        var resolved = resolver.call(
            effect.get("card", {}),
            _cell_from_any(effect.get("origin_cell", Vector2i.ZERO)),
            _cell_from_any(effect.get("direction", Vector2i.ZERO))
        )
        if resolved is Array:
            return resolved.duplicate(true)
    var cells = effect.get("affected_cells", [])
    return cells.duplicate(true) if cells is Array else []
 
 
func _impact_cell(card:Dictionary, origin_cell:Vector2i, affected_cells:Array, direction:Vector2i) -> Vector2i:
    var targeting = _targeting(card)
    var type = str(targeting.get("type", "projectile"))
    if type == "lob" and direction != Vector2i.ZERO:
        return origin_cell + direction * int(targeting.get("range", 1))
    if affected_cells.is_empty():
        return origin_cell
    return _cell_from_any(affected_cells[affected_cells.size() - 1])
 
 
func _targeting(card:Dictionary) -> Dictionary:
    var targeting = card.get("targeting", {})
    return targeting if targeting is Dictionary else {}
 
 
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