class Matrix
    {
        private struct Size // Использование структур поможет убрать большое кол-во переменных и значительно упростит жизнь при обмене информацией между функциями.
            public int Width { get; set; }
            public int Height { get; set; }
        }
        readonly Size _size; // Размер лабиринта
        readonly Texture2D[,] _maze; // Массив текстур клеток массива
        public Matrix(Maze.Cells size , Texture2D[,] cell2D)
        {
            _maze = cell2D;
            _size.Width = size.X;
            _size.Height = size.Y;
        }

        public void Draw(SpriteBatch spriteBatch) // Начинаем рисовать начальную матрицу
        {
            for (var i = 0; i < _size.Height; i++)
            {
                for (var j = 0; j < _size.Width; j++)
                {
                    if ((i % 2 != 0 && j % 2 != 0) && (i < _size.Height - 1 && j < _size.Width - 1))  //если ячейка нечетная по x и y, и не выходит за границы лабиринта
                    {
                        spriteBatch.Draw(_maze[i, j], new Rectangle(i * 10, j * 10, 10, 10), Color.White); // То это клетка
                    }
                    else
                    {
                        spriteBatch.Draw(_maze[i, j], new Rectangle(i * 10, j * 10, 10, 10), Color.White); // в остальных случаях это стена
                    }
                }
            }
        }
    }

        public struct Cells
        {
            public int X;
            public int Y;

            public Cells(int newX, int newY)
            {
                X = newX;
                Y = newY;
            }
        }

        private SpriteBatch _spriteBatch;
        private readonly Texture2D[,] _maze; // Массив клеток
        private Cells _size; // Размер лабиринта
        private readonly Cells _start;
        private readonly Cells _finish;
        private int _cell; // Клетка
        private int _wall; // Стена
        private int _visited; // Посещенная клетка
        private readonly List<Cells> _neighbours; // Список соседей
        private readonly Stack<Cells> _path; // Стэк путей лабиринта
        private int _status; // Статус готовности лабиринта
        public Maze(List<Cells> neighbours, Stack<Cells> path)
        {
            _neighbours = neighbours;
            _path = path;
            var graphics = new GraphicsDeviceManager(this);
            Content.RootDirectory = "Content";
            var winWidth = graphics.PreferredBackBufferWidth = 210;
            var winHeight = graphics.PreferredBackBufferHeight = 210;
            _size = new Cells(winWidth/10, winHeight/10);
            _start = new Cells(1, 1);
            _finish = new Cells(_size.X - 2, _size.Y - 2);
            _maze = new Texture2D[_size.X, _size.Y];
            _path.Push(_start);
            IsMouseVisible = true;
        }

        protected override void LoadContent()
        {
            _spriteBatch = new SpriteBatch(GraphicsDevice);
            for (var i = 0; i < _size.Y; i++)
            {
                for (var j = 0; j < _size.X; j++)
                {
                    if ((i%2 != 0 && j%2 != 0) && (i < _size.Y - 1 && j < _size.X - 1)) // Способ анологичен с генерацией матрицы. Если ячейка нечетная по x и y, и  находится в пределах размера лабиринта
                    {
                        _maze[i, j] = Content.Load<Texture2D>("flat"); // Загружаем пол
                        _cell = _maze[i, j].GetHashCode(); // Нужно для распознавания типа клетки.
                    }
                    else
                    {
                        _maze[i, j] = Content.Load<Texture2D>("wall");// Загружаем стену
                        _wall = _maze[i, j].GetHashCode();
                    }
                }
            }
      }

_wall = _maze[i, j].GetHashCode();
_cell = _maze[i, j].GetHashCode();

        private void DrawMaze()
        {
            if (_path.Count != 0) // Если стек не пуст , есть непосещенные клетки
            {
                GetNeighbours(_path.Peek()); // Получаем соседей Верхнего элемента стека, текущей клетки
                if (_neighbours.Count != 0) // Проверяем список соседий , если есть сосед(и)
                {
                    var a = _neighbours[new Random().Next(0, _neighbours.Count)]; // Получаем случайног ососеда
                    RemoteWall(_path.Peek(), a); // Убираем стену между текущей клеткой и соседом
                    _path.Push(a); // Продвигаем соседа в стек и делаем его активной клеткой
                    _neighbours.Clear(); // очищаем список соседий
                }
                else
                {
                    _path.Pop(); // если нет соседий , перейти на предыдущую клетку
                }
            }
            else // Если стек пуст и нет непосещенных клеток
            {
                MainPoint(); // Рисуем точки старт и финиш
                _status = 1; // Передаем статус созданного лабиринта
            }
        }

        private void GetNeighbours(Cells localcell) // Получаем соседа текущей клетки
        {
            var x = localcell.X;
            var y = localcell.Y;
            const int distance = 2; 
            var d = new[] // Список всех возможных соседий
            {
                new Cells(x, y - distance), // Up
                new Cells(x + distance, y), // Right
                new Cells(x, y + distance), // Down
                new Cells(x - distance, y) // Left
            };
            for (var i = 0; i < 4; i++) // Проверяем все 4 направления
            {
                var s = d[i];
                if (s.X <= 0 || s.X >= _size.X || s.Y <= 0 || s.Y >= _size.Y) continue; // Если сосед не выходит за стенки лабиринта
                if (_maze[s.X, s.Y].GetHashCode() == _wall || _maze[s.X, s.Y].GetHashCode() == _visited) continue; // И не является стеной или уже посещенной клеткой
                _neighbours.Add(s); // добовляем соседа в Лист соседей
            }
        }

        private void RemoteWall(Cells first, Cells second) // Убираем стену между 2 клетками
        {
            var xDiff = second.X - first.X;
            var yDiff = second.Y - first.Y;
            Cells target;
            Cells newCells;
            var addX = (xDiff != 0) ? xDiff/Math.Abs(xDiff) : 0; // Узнаем направление удаления стены
            var addY = (yDiff != 0) ? yDiff/Math.Abs(yDiff) : 0;
            target.X = first.X + addX; // Координаты удаленной стены
            target.Y = first.Y + addY;
            _maze[target.X, target.Y] = Content.Load<Texture2D>("visited"); // Загружаем в клетку соседней стены - посещенную клетку
            _maze[_path.Peek().X, _path.Peek().Y] = Content.Load<Texture2D>("visited"); // Загружаем в текущую клетку - посещенную клетку
            _visited = _maze[target.X, target.Y].GetHashCode(); // Получаем Hash Code посещенной стены
            newCells.X = first.X + 2*addX;
            newCells.Y = first.Y + 2*addY;
            _path.Push(newCells); // Загружаем в стек новую клетку 
            _maze[_path.Peek().X, _path.Peek().Y] = Content.Load<Texture2D>("visited"); // Загружаем в новую клетку - посещенную клетку
        }