path finding

/// @description

var unitPathExists = false;
var playerPathExists = true;
var player = instance_find(objPlayer, instance_number(objPlayer)-1);
if instance_exists(objUnit) {
    with (objUnit) {
        if path_exists(gridPath) unitPathExists = true;
    }
}

// Если все юниты походили - проверяем, есть ли путь у игрока. Если да, то двигаем его.
if !(unitPathExists) {
    // Если игрок есть и у него активен путь
    if player != noone {
        // Если нужно двигаться и путь рассчитан (и активного пути нет) - двигаемся к первой точке пути
        if player.pathActive = true and array_length(player.path) > 0 {
            with (player) {
                if !path_exists(gridPath) {
                    var start = scr_move_to_point(path[0], global.grid);
                }
            }
        }

        with (player) {
            if (!path_exists(gridPath) and keyboard_check(vk_space)) playerPathExists = false;
            if playerPathExists {
                // Если игрок находится в финальной точке пути - путь удаляется и возвращается true
                if scr_unit_at_point(x, y) {
                    event_user(0); // Обновление видимости
                    playerPathExists = false;
                    array_delete(path, 0, 1);
                    if array_length(path) == 0 {
                        pathActive = false;
                    }
                    else {
                        path = scr_find_path([x div CELL_WIDTH, y div CELL_HEIGHT], path[array_length(path)-1], global.grid,, visLines);
                    }
                    event_user(1); // Обновление отрисовки пути
                }
            }
        }
    }
}

// Теперь двигаем других микрочелов :)
if instance_exists(objUnit) and !playerPathExists {
    with objUnit {
        event_user(0);
    }
}


// Стартуем путь до точки. True - если путь начали, false - если нет.
function scr_move_to_point(point, grid){
    var cell = scr_cell_coords(point, grid);
    var _x = cell[0] * CELL_WIDTH;
    var _y = cell[1] * CELL_HEIGHT;

    if !(path_exists(gridPath)) {
        gridPath = path_add();
        path_set_closed(gridPath, false);
        path_add_point(gridPath, x, y, 1);
        path_add_point(gridPath, _x, _y, 1);
        path_start(gridPath, 320, path_action_stop, false);
    }
}

// Удаляем путь, если дошли до точки
function scr_unit_at_point(_x, _y) {
    if !path_exists(gridPath) return false
    if path_get_x(gridPath, 1) == _x and path_get_y(gridPath, 1) == _y {
        path_delete(gridPath);
        return true
    }
    return false
}


// objUnit event_user 0
/// @description

var ox = x div CELL_WIDTH;
var oy = y div CELL_HEIGHT;
var maxX = ds_grid_width(global.grid);

#region Логика ИИ.

#region Поиск пути
if (unitType == unitTypes.enemy) {
    var find = noone;
    if instance_exists(objPlayer) {
        find = scr_find_in_array(visLines, [objPlayer.x div CELL_WIDTH, objPlayer.y div CELL_HEIGHT]);
        if (find != noone) target = objPlayer;
    }

    var nbs = scr_neighbors([ox, oy], global.grid,,,,,,true );
    if target != noone  {
        if scr_find_in_array(nbs, target.x div CELL_WIDTH + target.y div CELL_HEIGHT * maxX) == noone {
            if find != noone {
                path = scr_find_path([ox, oy], [target.x div CELL_WIDTH, target.y div CELL_HEIGHT], global.grid, false);
            }
        }
        else path = [];
    }
}
#endregion

#region Движение по пути
if array_length(path) > 0 {
    gridPath = path_add();
    var cell = scr_cell_coords(path[0], global.grid);
    var _x = cell[0] * CELL_WIDTH;
    var _y = cell[1] * CELL_HEIGHT;
    gridPath = path_add();
    path_set_closed(gridPath, false);
    path_add_point(gridPath, x, y, 1);
    path_add_point(gridPath, _x, _y, 1);
    path_start(gridPath, 320, path_action_stop, false);
}
#endregion

#endregion



function scr_neighbors(start, grid, CW = CELL_WIDTH, CH = CELL_HEIGHT, getClosed = false, fourSides = false, ignoreBlocks = false, ignoreUnits = false)
{
    var cellx, celly, cells;
    var neighborsAr = array_create(0, 0)
    // start - это порядковый номер графа
    // Следовательно, нам нужно найти и вернуть соседей при условии, что мы можем по ним пройти
    var maxX = ds_grid_width(grid);
    if is_array(start) {
        cellx = start[0];
        celly = start[1];
    }
    else {
        cellx = start mod maxX;
        celly = start div maxX;
    }
    // Следовательно, нам нужны: [[-1, -1], [0, -1], [1, -1], [-1, 0], [1, 0], [-1, 1], [0, 1], [1, 1]]
    if fourSides
        cells = [[cellx-1, celly], [cellx, celly-1], [cellx+1, celly], [cellx, celly+1]]
    else
        cells = [[cellx -1, celly-1], [cellx, celly-1], [cellx+1, celly-1], [cellx-1, celly], [cellx+1, celly], [cellx-1, celly+1], [cellx, celly+1], [cellx+1, celly+1]]

    for (var i = 0; i < array_length(cells); ++i)
    {
        if cells[i][0] > -1 and cells[i][0] < room_width div CW
        and cells[i][1] > -1 and cells[i][1] < room_height div CH
        {
            var meetUnit = position_meeting(cells[i][0] * CW, cells[i][1] * CH, objUnit)
            var meetPlayer = position_meeting(cells[i][0] * CW, cells[i][1] * CH, objPlayer)
            var meetStorage = position_meeting(cells[i][0] * CW, cells[i][1] * CH, objStorage)
            var cellInUnitPath = false;
            with (objUnit) {
                if array_length(path) > 0 and ((cells[i][0] + cells[i][1] * maxX) == path[0]) {
                    cellInUnitPath = true;
                }
            }
            var meetUnit = instance_position(cells[i][0] * CW, cells[i][1] * CH, objUnit)
            // Если нам нужно отслеживать юнитов
            if !ignoreUnits {
                // Если в клетке есть кто-то из юнитов - игнор
                if (meetUnit)
                or (meetPlayer)
                or (meetStorage)
                or cellInUnitPath {
                    continue
                }
            }

            // Если отслеживаем закрытые клетки и текущая клетка НЕ закрыта - игнор
            if getClosed {
                if ds_grid_get(grid, cells[i][0], cells[i][1] != 0)
                    continue
            }
            else // Если отслеживаем открытые клетки, а текущая закрыта - игнор
            {
                if (!ignoreBlocks and ds_grid_get(grid, cells[i][0], cells[i][1]) == 0) {
                    continue
                }
            }
            array_push(neighborsAr, cells[i][0] + cells[i][1] * maxX)
        }
    }
    // Возвращаем список доступных соседей
    return neighborsAr
}