grid_combat_manager.gd

Go to the documentation of this file.

extends RefCounted
 
 
 
const DataCacheManager = preload("res://scripts/systems/dataCacheManager/data_cache_manager.gd")
 
var enemies := []
var damage_log := []
var archetypes := {}
var active_projectiles := []
var floating_numbers := []
var action_log := []
var data_cache_manager = DataCacheManager.new()
 
 
func load_archetypes(file_path:String) -> void:
    archetypes.clear()
    load_archetype_data(data_cache_manager.load_json(file_path))
 
 
func get_cache_stats() -> Dictionary:
    return data_cache_manager.get_cache_stats()
 
 
func load_archetype_data(data) -> void:
    archetypes.clear()
    if not data is Dictionary:
        return
    for archetype in data.get("archetypes", []):
        if not archetype is Dictionary:
            continue
        var id = str(archetype.get("id", ""))
        if id != "":
            archetypes[id] = archetype.duplicate(true)
 
 
func configure(next_enemies:Array) -> void:
    enemies.clear()
    damage_log.clear()
    action_log.clear()
    active_projectiles.clear()
    floating_numbers.clear()
    for enemy in next_enemies:
        if not enemy is Dictionary:
            continue
        var entry = _with_archetype(enemy)
        entry["hp"] = int(entry.get("hp", 1))
        entry["max_hp"] = int(entry.get("max_hp", entry.get("hp", 1)))
        entry["alive"] = int(entry.get("hp", 1)) > 0
        entry["cooldown_remaining"] = int(entry.get("cooldown_remaining", 0))
        entry["alerted"] = bool(entry.get("alerted", false))
        enemies.append(entry)
 
 
func step(delta:float) -> void:
    _tick_timed(active_projectiles, delta)
    _tick_timed(floating_numbers, delta)
 
 
func resolve_card(card:Dictionary, affected_cells:Array, origin_cell := Vector2i.ZERO, direction := Vector2i.ZERO) -> Dictionary:
    var damage = int(card.get("damage", 0))
    var hits := []
    for index in range(enemies.size()):
        var enemy = enemies[index]
        if not bool(enemy.get("alive", true)):
            continue
        var enemy_cell = _cell_from_value(enemy.get("cell", [0, 0]))
        if affected_cells.has(enemy_cell):
            var dealt = max(0, damage - int(enemy.get("defense", 0)))
            enemy["hp"] = max(0, int(enemy.get("hp", 0)) - dealt)
            enemy["alive"] = int(enemy.get("hp", 0)) > 0
            enemy["alerted"] = true
            enemies[index] = enemy
            var hit = {
                "enemy_id": str(enemy.get("id", "")),
                "name": str(enemy.get("name", "Enemy")),
                "damage": dealt,
                "remaining_hp": int(enemy.get("hp", 0)),
                "defeated": not bool(enemy.get("alive", true)),
                "cell": enemy_cell
            }
            hits.append(hit)
            damage_log.append(hit.duplicate(true))
            floating_numbers.append({
                "text": "-%d" % dealt,
                "cell": enemy_cell,
                "age": 0.0,
                "duration": 0.9,
                "color": "#ffdf6b"
            })
    _spawn_projectile(card, affected_cells, origin_cell, direction, hits)
    return {
        "card_id": str(card.get("id", "")),
        "hits": hits,
        "hit": not hits.is_empty(),
        "affected_cells": affected_cells.duplicate()
    }
 
 
func take_enemy_turn(player_cell:Vector2i, bounds:Rect2, blocked_cells:Array, config := {}) -> Dictionary:
    var actions := []
    var total_damage := 0
    for index in range(enemies.size()):
        var enemy = enemies[index]
        if not bool(enemy.get("alive", true)):
            continue
        if int(enemy.get("cooldown_remaining", 0)) > 0:
            enemy["cooldown_remaining"] = int(enemy.get("cooldown_remaining", 0)) - 1
            enemies[index] = enemy
            continue
        var action = _enemy_action(enemy, player_cell, bounds, blocked_cells, config)
        if action.is_empty():
            continue
        if str(action.get("type", "")) == "move":
            enemy["cell"] = action.get("to", enemy.get("cell", [0, 0]))
            enemies[index] = enemy
        elif str(action.get("type", "")) == "attack":
            total_damage += int(action.get("damage", 0))
            floating_numbers.append({
                "text": "-%d" % int(action.get("damage", 0)),
                "cell": player_cell,
                "age": 0.0,
                "duration": 0.9,
                "color": "#ff7777"
            })
            active_projectiles.append({
                "card_id": "enemy_attack",
                "type": str(action.get("attack_type", "melee")),
                "shape": str(action.get("attack_type", "melee")),
                "color": str(action.get("color", "#ff7777")),
                "origin_cell": action.get("from", player_cell),
                "end_cell": player_cell,
                "direction": Vector2i.ZERO,
                "affected_cells": [player_cell],
                "age": 0.0,
                "duration": 0.28
            })
        enemy["cooldown_remaining"] = _cooldown_for(enemy)
        enemies[index] = enemy
        actions.append(action)
        action_log.append(action.duplicate(true))
    return {
        "actions": actions,
        "damage": total_damage
    }
 
 
func get_enemies() -> Array:
    return enemies.duplicate(true)
 
 
func get_alive_enemies() -> Array:
    var alive := []
    for enemy in enemies:
        if bool(enemy.get("alive", true)):
            alive.append(enemy.duplicate(true))
    return alive
 
 
func get_active_projectiles() -> Array:
    return active_projectiles.duplicate(true)
 
 
func get_floating_numbers() -> Array:
    return floating_numbers.duplicate(true)
 
 
func get_damage_log() -> Array:
    return damage_log.duplicate(true)
 
 
func get_action_log() -> Array:
    return action_log.duplicate(true)
 
 
func get_primary_enemy() -> Dictionary:
    for enemy in enemies:
        if bool(enemy.get("alive", true)):
            return enemy.duplicate(true)
    if enemies.is_empty():
        return {}
    return enemies[0].duplicate(true)
 
 
func get_summary() -> Dictionary:
    var alive := 0
    var defeated := 0
    for enemy in enemies:
        if bool(enemy.get("alive", true)):
            alive += 1
        else:
            defeated += 1
    return {
        "enemy_count": enemies.size(),
        "alive": alive,
        "defeated": defeated,
        "damage_events": damage_log.size(),
        "actions": action_log.size()
    }
 
 
 
func collect_defeat_rewards(hits:Array) -> Dictionary:
    var gained := {}
    var enemy_lookup := {}
    for enemy in enemies:
        if enemy is Dictionary:
            enemy_lookup[str(enemy.get("id", ""))] = enemy
    for hit in hits:
        if not hit is Dictionary or not bool(hit.get("defeated", false)):
            continue
        var enemy_id = str(hit.get("enemy_id", ""))
        var enemy = enemy_lookup.get(enemy_id, {})
        for drop in enemy.get("drops", []):
            if not drop is Dictionary:
                continue
            var chance = float(drop.get("chance", 1.0))
            if chance < 1.0 and randf() > chance:
                continue
            var id = str(drop.get("id", ""))
            var amount = int(drop.get("amount", 1))
            if id == "" or amount <= 0:
                continue
            gained[id] = int(gained.get(id, 0)) + amount
    return gained
 
 
func get_state() -> Dictionary:
    return {
        "enemies": enemies.duplicate(true),
        "damage_log": damage_log.duplicate(true),
        "action_log": action_log.duplicate(true),
        "active_projectiles": active_projectiles.duplicate(true),
        "floating_numbers": floating_numbers.duplicate(true)
    }
 
 
func apply_state(state:Dictionary) -> void:
    enemies = state.get("enemies", []).duplicate(true)
    damage_log = state.get("damage_log", []).duplicate(true)
    action_log = state.get("action_log", []).duplicate(true)
    active_projectiles = state.get("active_projectiles", []).duplicate(true)
    floating_numbers = state.get("floating_numbers", []).duplicate(true)
 
 
func _with_archetype(enemy:Dictionary) -> Dictionary:
    var archetype_id = str(enemy.get("archetype", ""))
    var entry := {}
    if archetypes.has(archetype_id):
        entry = archetypes[archetype_id].duplicate(true)
    for key in enemy.keys():
        entry[key] = enemy[key]
    if not entry.has("max_hp") and entry.has("hp"):
        entry["max_hp"] = entry["hp"]
    return entry
 
 
func _spawn_projectile(card:Dictionary, affected_cells:Array, origin_cell:Vector2i, direction:Vector2i, hits:Array) -> void:
    var targeting = card.get("targeting", {})
    var visual = card.get("visual", {})
    var type = str(targeting.get("type", "projectile"))
    var duration = float(visual.get("duration", 0.25))
    var end_cell = origin_cell
    if not hits.is_empty():
        end_cell = _cell_from_value(hits[0].get("cell", origin_cell))
    elif not affected_cells.is_empty():
        end_cell = _cell_from_value(affected_cells[affected_cells.size() - 1])
    active_projectiles.append({
        "card_id": str(card.get("id", "")),
        "type": type,
        "shape": str(visual.get("shape", type)),
        "color": str(visual.get("color", "#ffffff")),
        "origin_cell": origin_cell,
        "end_cell": end_cell,
        "direction": direction,
        "affected_cells": affected_cells.duplicate(),
        "age": 0.0,
        "duration": max(0.05, duration)
    })
 
 
func _enemy_action(enemy:Dictionary, player_cell:Vector2i, bounds:Rect2, blocked_cells:Array, config:Dictionary) -> Dictionary:
    var enemy_cell = _cell_from_value(enemy.get("cell", [0, 0]))
    var behavior = enemy.get("behavior", {})
    var behavior_type = str(behavior.get("type", "guard"))
    var distance = _grid_distance(enemy_cell, player_cell)
    var attack_range = int(behavior.get("range", 1))
    var aggro_range = int(behavior.get("aggro_range", attack_range))
    var alerted = bool(enemy.get("alerted", false)) or distance <= aggro_range
    if alerted and not bool(enemy.get("alerted", false)):
        enemy["alerted"] = true
    if not alerted:
        return _wander_action(enemy, enemy_cell, bounds, blocked_cells, config)
    if behavior_type == "ranged" and _has_line(enemy_cell, player_cell, attack_range, blocked_cells):
        return _attack_action(enemy, enemy_cell, player_cell, "beam")
    if distance <= attack_range and behavior_type != "ranged":
        return _attack_action(enemy, enemy_cell, player_cell, "melee")
    if behavior_type == "chase" or behavior_type == "ranged":
        var move_distance = int(behavior.get("move_distance", 1))
        if move_distance <= 0:
            return {}
        var next_cell = _step_toward(enemy_cell, player_cell, bounds, blocked_cells, config)
        if next_cell != enemy_cell:
            return {
                "type": "move",
                "enemy_id": str(enemy.get("id", "")),
                "name": str(enemy.get("name", "Enemy")),
                "from": enemy_cell,
                "to": next_cell
            }
    return {}
 
 
func _wander_action(enemy:Dictionary, enemy_cell:Vector2i, bounds:Rect2, blocked_cells:Array, config:Dictionary) -> Dictionary:
    var behavior = enemy.get("behavior", {})
    if not bool(behavior.get("wander", true)):
        return {}
    var move_distance = int(behavior.get("move_distance", 1))
    if move_distance <= 0:
        return {}
    var directions = [Vector2i.LEFT, Vector2i.RIGHT, Vector2i.UP, Vector2i.DOWN]
    var start_index = randi() % directions.size()
    for offset in range(directions.size()):
        var direction = directions[(start_index + offset) % directions.size()]
        var candidate = enemy_cell + direction
        if not _cell_blocked(candidate, bounds, blocked_cells, config, enemy_cell):
            return {
                "type": "move",
                "mode": "wander",
                "enemy_id": str(enemy.get("id", "")),
                "name": str(enemy.get("name", "Enemy")),
                "from": enemy_cell,
                "to": candidate
            }
    return {}
 
 
func _attack_action(enemy:Dictionary, enemy_cell:Vector2i, player_cell:Vector2i, attack_type:String) -> Dictionary:
    return {
        "type": "attack",
        "attack_type": attack_type,
        "enemy_id": str(enemy.get("id", "")),
        "name": str(enemy.get("name", "Enemy")),
        "from": enemy_cell,
        "target": player_cell,
        "damage": int(enemy.get("attack", 1)),
        "color": str(enemy.get("color", "#ff7777"))
    }
 
 
func _cooldown_for(enemy:Dictionary) -> int:
    var behavior = enemy.get("behavior", {})
    if behavior is Dictionary:
        return max(0, int(behavior.get("cooldown_turns", 0)))
    return 0
 
 
func _step_toward(from_cell:Vector2i, target_cell:Vector2i, bounds:Rect2, blocked_cells:Array, config:Dictionary) -> Vector2i:
    var candidates := []
    var delta = target_cell - from_cell
    if abs(delta.x) >= abs(delta.y):
        candidates.append(Vector2i(sign(delta.x), 0))
        candidates.append(Vector2i(0, sign(delta.y)))
    else:
        candidates.append(Vector2i(0, sign(delta.y)))
        candidates.append(Vector2i(sign(delta.x), 0))
    for fallback in [Vector2i.LEFT, Vector2i.RIGHT, Vector2i.UP, Vector2i.DOWN]:
        if not candidates.has(fallback):
            candidates.append(fallback)
    for direction in candidates:
        if direction == Vector2i.ZERO:
            continue
        var candidate = from_cell + direction
        if candidate == target_cell:
            continue
        if not _cell_blocked(candidate, bounds, blocked_cells, config, from_cell):
            return candidate
    return from_cell
 
 
func _cell_blocked(cell:Vector2i, bounds:Rect2, blocked_cells:Array, config:Dictionary, moving_from:Vector2i) -> bool:
    var tile_size = max(1.0, float(config.get("tile_size", 40.0)))
    var world_position = Vector2(float(cell.x) * tile_size + tile_size * 0.5, float(cell.y) * tile_size + tile_size * 0.5)
    if not bounds.has_point(world_position):
        return true
    for blocked in blocked_cells:
        if _cell_from_value(blocked) == cell:
            return true
    for enemy in enemies:
        if not bool(enemy.get("alive", true)):
            continue
        var enemy_cell = _cell_from_value(enemy.get("cell", [0, 0]))
        if enemy_cell != moving_from and enemy_cell == cell:
            return true
    return false
 
 
func _has_line(from_cell:Vector2i, target_cell:Vector2i, max_range:int, blocked_cells:Array) -> bool:
    var delta = target_cell - from_cell
    if delta.x != 0 and delta.y != 0:
        return false
    var distance = _grid_distance(from_cell, target_cell)
    if distance > max_range:
        return false
    var direction = Vector2i(sign(delta.x), sign(delta.y))
    var current = from_cell
    for _index in range(distance - 1):
        current += direction
        if blocked_cells.has(current):
            return false
    return true
 
 
func _grid_distance(a:Vector2i, b:Vector2i) -> int:
    return abs(a.x - b.x) + abs(a.y - b.y)
 
 
func _tick_timed(items:Array, delta:float) -> void:
    for index in range(items.size() - 1, -1, -1):
        var item = items[index]
        item["age"] = float(item.get("age", 0.0)) + delta
        items[index] = item
        if float(item.get("age", 0.0)) >= float(item.get("duration", 0.1)):
            items.remove_at(index)
 
 
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]))
    return Vector2i.ZERO