Генерация точек и пути между ними

//Matrix values:
    //0 - Empty cell
    //1 - Bomb
    //2 - Pont (Start and Finish)
    //3 - Way
 
const int SIZE = 4;
int[,] mapData = new int[SIZE , SIZE];

(int, int) GetFirstPoint(int sizeRows)
    {
        Random random = new Random(DateTime.Now.Second);
 
        //Generate first random point
        return (random.Next(SIZE), random.Next(SIZE));
    }
 
(int, int) point = GetFirstPoint(sizeRows);
        mapData[point.Item1, point.Item2] = 2;

mapData[nextPoint.Item1, nextPoint.Item2] = 3;

using System;
 
class Program
{
    static void Main()
    {
        int[,] arr;        // поле
        (int, int) point1; // 1-ая точка
        (int, int) point2; // 2-ая точка (также сгенерировано рандомно)
    }
 
    static bool Check(int[,] arr, (int, int) point1, (int, int) point2)
    {
        bool check = true;
        const int DISTANCE = 2; // минимальное допустимое растояние между точками
 
        Foo(point1.Item1, point1.Item2); // запуск рекурсии от 1-ой точки
 
        // level - уровень спуска по рекурсии
        void Foo(int x, int y, int level = 0)
        {
            if (!check) return;
 
            if (x == point2.Item1 && y == point2.Item2)
            {
                check = false;
                return;
            }
 
            if (level == DISTANCE) return;
 
            if (y > 0)                    Foo(x, y - 1, level + 1); // вверх
            if (x < arr.GetLength(0) - 1) Foo(x + 1, y, level + 1); // вправо
            if (y < arr.GetLength(1) - 1) Foo(x, y + 1, level + 1); // вниз
            if (x > 0)                    Foo(x - 1, y, level + 1); // влево
        }
 
        return check;
    }
}

using System;
using System.Collections.Generic;
 
class Demo
{
    public void Start()
    {
        Console.Write("Field size: ");
        size = int.Parse(Console.ReadLine());
        Console.Write("Bombs: ");
        int bombs = int.Parse(Console.ReadLine());
        Console.Write("Minimal path (0 for unlimited): ");
        int minimalPath = int.Parse(Console.ReadLine());
        Console.WriteLine("Generator attempts: {0}", Generate(bombs, minimalPath));
        Paint();
    }
 
    Random rnd = new Random();
    int size;
    char[] symbols = new char[] { '.', 'O', '*', 'S', 'F', '#' };
    int[] mx = new int[] { 0, 1, 0, -1 };
    int[] my = new int[] { -1, 0, 1, 0 };
 
    (int x, int y) start, finish;
    int[,] field;
 
    bool CoordsIsValid((int x, int y) coords) => coords.x >= 0 && coords.y >= 0 && coords.x < size && coords.y < size;
    (int x, int y) NewCoords() => (rnd.Next(size), rnd.Next(size));
 
    int Generate(int bombs, int minimalPath)
    {
        int count = 0;
        int path;
 
        do
        {
            count++;
            field = new int[size, size];
            start = NewCoords();
            field[start.x, start.y] = 3;
 
            do
                finish = NewCoords();
            while (Math.Max(Math.Abs(start.x - finish.x), Math.Abs(start.y - finish.y)) < 2);
 
            field[finish.x, finish.y] = 4;
 
            (int x, int y) bomb;
 
            for (int i = 0; i < bombs; i++)
            {
                do
                    bomb = NewCoords();
                while (field[bomb.x, bomb.y] != 0);
 
                field[bomb.x, bomb.y] = 1;
            }
 
            path = SearchPath();
        }
        while (path == -1 || (minimalPath != 0 && path < minimalPath));
 
        return count;
    }
 
    int SearchPath()
    {
        int[,] map = new int[size, size];
        bool success = false;
        var active = new List<(int x, int y)>() { finish };
        (int x, int y) newCoords;
 
        for (int dist = 1; !success && active.Count != 0; dist++)
        {
            var newActive = new List<(int x, int y)>();
 
            foreach (var coords in active)
            {
                for (int i = 0; !success && i < 4; i++)
                {
                    newCoords = (coords.x + mx[i], coords.y + my[i]);
 
                    if (!CoordsIsValid(newCoords))
                        continue;
 
                    if (field[newCoords.x, newCoords.y] == 3)
                    {
                        success = true;
                        map[newCoords.x, newCoords.y] = dist;
                        break;
                    }
 
                    if (field[newCoords.x, newCoords.y] == 1 || map[newCoords.x, newCoords.y] != 0 && map[newCoords.x, newCoords.y] <= dist)
                        continue;
 
                    map[newCoords.x, newCoords.y] = dist;
                    newActive.Add(newCoords);
                }
 
                if (success)
                    break;
            }
 
            active = newActive;
        }
 
        if (!success)
            return -1;
 
        (int x, int y) currentCoords = start;
        
        while (true)
        {
            (int x, int y) coords;
            newCoords = currentCoords;
 
            for (int i = 0; i < 4; i++)
            {
                coords = (currentCoords.x + mx[i], currentCoords.y + my[i]);
 
                if (!CoordsIsValid(coords))
                    continue;
 
                if (field[coords.x, coords.y] == 4)
                    return map[start.x, start.y];
 
                if (map[coords.x, coords.y] != 0 && map[coords.x, coords.y] < map[newCoords.x, newCoords.y])
                    newCoords = coords;
            }
 
            currentCoords = newCoords;
            field[currentCoords.x, currentCoords.y] = 5;
        }
    }
 
    void Paint()
    {
        for (int i = 0; i < size; i++)
        {
            for (int j = 0; j < size; j++)
                Console.Write($"{symbols[field[i, j]]} ");
 
            Console.WriteLine();
        }
    }
}
 
class Program
{
    static void Main()
    {
        Demo demo = new Demo();
        demo.Start();
        Console.ReadKey();
    }
}

(int, int)[] neighbours = new (int, int)[4];
        neighbours[0] = (point.Item1, point.Item2 + 1); //RIGHT
        neighbours[1] = (point.Item1, point.Item2 - 1); //LEFT
        neighbours[2] = (point.Item1 + 1, point.Item2); //DOWN
        neighbours[3] = (point.Item1 - 1, point.Item2); //UP

foreach(var neighbour in neighbours)
{
            //Check bounds
            if (neighbour.Item2 < 0 || neighbour.Item2 >= field.GetLength(0))
                continue;
            if (neighbour.Item1 < 0 || neighbour.Item1 >= field.GetLength(1))
                continue;
            //Check visit
            if (field[neighbour.Item1, neighbour.Item2] != 0)
                continue;
}