AstarGrid2D

extends Node2D
 
@onready var tile_map: TileMap = $TileMap
@onready var label_1: Label = $Label1
@onready var label_2: Label = $Label2
 
var units_data = {
    "unit1": {"texture": preload("res://u1.png"), "move": 3},
    "unit2": {"texture": preload("res://u2.png"), "move": 4},
    "unit3": {"texture": preload("res://u2.png"), "move": 5}
}
var slots = {1: "unit1", 2: "unit2", 3: null, 4: "unit3"}
 
var astar = AStarGrid2D.new()
var unit_nodes = {} # Словарь для хранения Sprite2D юнитов
var current_slot_index = 0
var slot_keys = []
var active_unit_id = ""
var is_moving = false
 
func _ready():
    slot_keys = slots.keys()
    slot_keys.sort()
    setup_astar()
    spawn_units()
    next_turn()
 
func setup_astar():
    var map_limits = tile_map.get_used_rect()
    astar.region = map_limits
    astar.cell_size = tile_map.tile_set.tile_size
    astar.diagonal_mode = AStarGrid2D.DIAGONAL_MODE_NEVER # Ход только по горизонтали/вертикали
    astar.update()
    
    # Помечаем непроходимыми все клетки, кроме ID = 0
    for x in range(map_limits.position.x, map_limits.end.x):
        for y in range(map_limits.position.y, map_limits.end.y):
            var coords = Vector2i(x, y)
            var data = tile_map.get_cell_source_id(0, coords)
            if data != 0:
                astar.set_point_solid(coords, true)
 
func spawn_units():
    for slot in slots:
        var unit_id = slots[slot]
        if unit_id == null: continue
        
        var sprite = Sprite2D.new()
        sprite.texture = units_data[unit_id]["texture"]
        sprite.centered = false
        # Размещаем в (1, номер слота)
        var grid_pos = Vector2i(1, slot)
        sprite.position = tile_map.map_to_local(grid_pos) - (astar.cell_size / 2.0)
        add_child(sprite)
        unit_nodes[unit_id] = sprite
        # Юниты блокируют клетки для AStar
        astar.set_point_solid(grid_pos, true)
 
func next_turn():
    clear_highlight()
    
    # Поиск следующего живого слота
    var attempts = 0
    while attempts < slot_keys.size():
        var key = slot_keys[current_slot_index]
        active_unit_id = slots[key]
        current_slot_index = (current_slot_index + 1) % slot_keys.size()
        
        if active_unit_id != null:
            show_move_range()
            return
        attempts += 1
 
func show_move_range():
    var start_pos = tile_map.local_to_map(unit_nodes[active_unit_id].position)
    var move_dist = units_data[active_unit_id]["move"]
    
    label_1.text ="Ходит "+str(active_unit_id)+"- из координат "+str(start_pos)
    #наложим маркер на текущего юнита
    tile_map.set_cell(1, start_pos, 2, Vector2i(0,0)) # Слой 1, ID тайла 1
    # Временно открываем клетку юнита для расчета путей
    astar.set_point_solid(start_pos, false)
    
    for x in range(start_pos.x - move_dist, start_pos.x + move_dist + 1):
        for y in range(start_pos.y - move_dist, start_pos.y + move_dist + 1):
            var target = Vector2i(x, y)
            if not astar.is_in_boundsv(target) or astar.is_point_solid(target):
                continue
            
            var path = astar.get_id_path(start_pos, target)
            if path.size() > 1 and path.size() <= move_dist + 1:
                tile_map.set_cell(1, target, 1, Vector2i(0,0)) # Слой 1, ID тайла 1
    
    astar.set_point_solid(start_pos, true)
 
func clear_highlight():
    tile_map.clear_layer(1)
 
func _input(event):
    if is_moving or not event is InputEventMouseButton: return
    if event.button_index == MOUSE_BUTTON_LEFT and event.pressed:
        var target_map_pos = tile_map.local_to_map(get_global_mouse_position())
        process_move(target_map_pos)
 
func process_move(target_pos: Vector2i):
    var unit_sprite = unit_nodes[active_unit_id]
    var start_pos = tile_map.local_to_map(unit_sprite.position)
    var move_dist = units_data[active_unit_id]["move"]
    
    # Проверка на другого юнита
    var target_unit_id = ""
    for id in unit_nodes:
        if tile_map.local_to_map(unit_nodes[id].position) == target_pos:
            target_unit_id = id
            break
    
    astar.set_point_solid(start_pos, false)
    var path = astar.get_id_path(start_pos, target_pos)
    astar.set_point_solid(start_pos, true)
    
    if path.is_empty() or path.size() - 1 > move_dist:
        label_1.text = "клик за пределом хода"
        return
 
    if target_unit_id != "" and target_unit_id != active_unit_id:
        label_1.text = "начало атаки"
        path.remove_at(path.size() - 1) # Останавливаемся перед целью
    else:
        label_1.text = ""
 
    if path.size() > 1:
        label_2.text = str(path)
        move_along_path(path)
    else:
        next_turn()
 
func move_along_path(path: Array):
    is_moving = true
    clear_highlight()
    
    var old_pos = path[0]
    var new_pos = path[-1]
    
    astar.set_point_solid(old_pos, false)
    
    for i in range(1, path.size()):
        var target_world = tile_map.map_to_local(path[i]) - (astar.cell_size / 2.0)
        var tween = create_tween()
        tween.tween_property(unit_nodes[active_unit_id], "position", target_world, 0.2)
        await tween.finished
        await get_tree().create_timer(0.05).timeout # Небольшая задержка
    
    astar.set_point_solid(new_pos, true)
    is_moving = false
    next_turn()