public static string[,] SolveLabyrinth(string[,] labyrinth)
        {
            var solvedLabyrinth = (string[,])labyrinth.Clone();

            int rows = solvedLabyrinth.GetLength(0);
            int cols = solvedLabyrinth.GetLength(1);

            var startPostitions = GetCells(solvedLabyrinth, "*");
            var cells = new Queue<Cell>(startPostitions);
            while (cells.Count > 0)
            {
                var currentCell = cells.Dequeue();

                int stepNumber;
                string nextSymbol = int.TryParse(currentCell.Symbol, out stepNumber) ? (stepNumber + 1).ToString() : "1";

                if (0 < currentCell.Row && solvedLabyrinth[currentCell.Row - 1, currentCell.Col] == "0")
                {
                    var upCell = new Cell(currentCell.Row - 1, currentCell.Col, nextSymbol);
                    WriteCellInLabyrinth(upCell, solvedLabyrinth);
                    cells.Enqueue(upCell);
                }

                if (currentCell.Row < rows - 1 && solvedLabyrinth[currentCell.Row + 1, currentCell.Col] == "0")
                {
                    var downCell = new Cell(currentCell.Row + 1, currentCell.Col, nextSymbol);
                    WriteCellInLabyrinth(downCell, solvedLabyrinth);
                    cells.Enqueue(downCell);
                }

                if (0 < currentCell.Col && solvedLabyrinth[currentCell.Row, currentCell.Col - 1] == "0")
                {
                    var leftCell = new Cell(currentCell.Row, currentCell.Col - 1, nextSymbol);
                    WriteCellInLabyrinth(leftCell, solvedLabyrinth);
                    cells.Enqueue(leftCell);
                }

                if (currentCell.Col < cols - 1 && solvedLabyrinth[currentCell.Row, currentCell.Col + 1] == "0")
                {
                    var rightCell = new Cell(currentCell.Row, currentCell.Col + 1, nextSymbol);
                    WriteCellInLabyrinth(rightCell, solvedLabyrinth);
                    cells.Enqueue(rightCell);
                }
            }

            var unreachableCells = GetCells(solvedLabyrinth, "0");
            foreach (var cell in unreachableCells)
            {
                solvedLabyrinth[cell.Row, cell.Col] = "u";
            }

            return solvedLabyrinth;
        }
        private bool ExitFound(Cell cell)
        {
            bool exitFound = false;
            if (cell.Row == LABYRINTH_SIZE - 1 ||

                cell.Col == LABYRINTH_SIZE - 1 ||
                cell.Row == 0 ||
                cell.Col == 0)
            {
                exitFound = true;
            }

            return exitFound;
        }
        public Labyrinth(PlayerPosition startPosition, Cell[,] board)
        {
            if (startPosition == null)
            {
                throw new ArgumentNullException("The start position cannot be null");
            }

            if (board == null)
            {
                throw new ArgumentNullException("The board cannot be null");
            }

            this.Position = startPosition;
            this.board = board;
        }
        public bool TryMove(Cell cell, Direction direction)
        {
            int newRow;
            int newCol;
            FindNewCellCoordinates(cell.Row, cell.Col, direction,
                out newRow, out newCol);

            if (newRow < 0 || newCol < 0 ||
                newRow >= labyrinth.GetLength(0) || newCol >= labyrinth.GetLength(1))
            {
                return false;
            }

            if (!labyrinth[newRow, newCol].IsEmpty())
            {

                return false;
            }

            this.labyrinth[newRow, newCol].ValueChar = '*';
            this.labyrinth[cell.Row, cell.Col].ValueChar = '-';
            this.currentCell = labyrinth[newRow, newCol];
            return true;
        }
        public object Clone()
        {
            Cell cloned = new Cell(this.Row, this.Column, this.Value);

            return cloned;
        }
 public Labyrinth(Random rand)
 {
     GenerateLabyrinth(rand);
     currentCell = labyrinth[LabyrintStartRow, LabyrintStartRow];
 }
        private void premestvane(Cell cell, Direction direction,
            Queue<Cell> cellsOrder, HashSet<Cell> visitedCells)
        {
            int newRow;
            int newCol;
            FindNewCellCoordinates(cell.Row, cell.Col, direction,
                out newRow, out newCol);

            if (newRow < 0 || newCol < 0 ||
                newRow >= labyrinth.GetLength(0) || newCol >= labyrinth.GetLength(1))

            {
                return;
            }

            if (visitedCells.Contains(labyrinth[newRow,newCol]))
            {
                return;
            }

            if (labyrinth[newRow, newCol].IsEmpty())
            {
                cellsOrder.Enqueue(labyrinth[newRow, newCol]);
            }
        }
 private static void WriteCellInLabyrinth(Cell cell, string[,] labyrinth)
 {
     labyrinth[cell.Row, cell.Col] = cell.Symbol;
 }
        public Cell[,] Clone()
        {
            Cell[,] cloned = new Cell[LabyrinthSize, LabyrinthSize];

            for (int row = 0; row < LabyrinthSize; row++)
            {
                for (int column = 0; column < LabyrinthSize; column++)
                {
                    cloned[row, column] = this.board[row, column].Clone() as Cell;
                }
            }

            return cloned;
        }
 private void VisitCell(Cell[,] labyrinth, Queue<Cell> visitedCells, 
     int row, int column)
 {
     if (labyrinth[row, column].Value == Cell.Empty || 
         labyrinth[row, column].Value == Cell.Player)
     {
         labyrinth[row, column].Value = Cell.Block;
         visitedCells.Enqueue(labyrinth[row, column]);
     }
 }
Esempio n. 11
0
        public static void FillOutputLabyrinth(Cell startingCell, string[,] outputLabyrinth)
        {
            bool[,] isUsed = new bool[inputLabirinth.GetLength(0), inputLabirinth.GetLength(1)];

            var queue = new Queue<Cell>();

            queue.Enqueue(startingCell);
            isUsed[startingCell.Row, startingCell.Column] = true;
            outputLabyrinth[startingCell.Row, startingCell.Column] = "*";

            while (queue.Count > 0)
            {
                var cell = queue.Dequeue();

                // Check and enqueue left cell
                if (cell.Column > 0 && !isUsed[cell.Row, cell.Column - 1] && inputLabirinth[cell.Row, cell.Column - 1] != "X")
                {
                    var newCell = new Cell() { Column = cell.Column - 1, Row = cell.Row, Step = cell.Step + 1 };
                    queue.Enqueue(newCell);
                    isUsed[newCell.Row, newCell.Column] = true;
                    outputLabyrinth[newCell.Row, newCell.Column] = newCell.Step.ToString();
                }

                // Check and enqueue right cell
                if (cell.Column < inputLabirinth.GetLength(1) - 1 && !isUsed[cell.Row, cell.Column + 1] && inputLabirinth[cell.Row, cell.Column + 1] != "X")
                {
                    var newCell = new Cell() { Column = cell.Column + 1, Row = cell.Row, Step = cell.Step + 1 };
                    queue.Enqueue(newCell);
                    isUsed[newCell.Row, newCell.Column] = true;
                    outputLabyrinth[newCell.Row, newCell.Column] = newCell.Step.ToString();
                }

                // Check and enqueue top cell
                if (cell.Row > 0 && !isUsed[cell.Row - 1, cell.Column] && inputLabirinth[cell.Row - 1, cell.Column] != "X")
                {
                    var newCell = new Cell() { Column = cell.Column, Row = cell.Row - 1, Step = cell.Step + 1 };
                    queue.Enqueue(newCell);
                    isUsed[newCell.Row, newCell.Column] = true;
                    outputLabyrinth[newCell.Row, newCell.Column] = newCell.Step.ToString();
                }

                // Check and enqueue bottom cell
                if (cell.Row < inputLabirinth.GetLength(0) - 1 && !isUsed[cell.Row + 1, cell.Column] && inputLabirinth[cell.Row + 1, cell.Column] != "X")
                {
                    var newCell = new Cell() { Column = cell.Column, Row = cell.Row + 1, Step = cell.Step + 1 };
                    queue.Enqueue(newCell);
                    isUsed[newCell.Row, newCell.Column] = true;
                    outputLabyrinth[newCell.Row, newCell.Column] = newCell.Step.ToString();
                }
            }

            // Fill the missing cells
            for (int row = 0; row < outputLabyrinth.GetLength(0); row++)
            {
                for (int col = 0; col < outputLabyrinth.GetLength(1); col++)
                {
                    if (outputLabyrinth[row, col] == null)
                    {
                        outputLabyrinth[row, col] = "U";
                    }

                    if (inputLabirinth[row, col] == "X")
                    {
                        outputLabyrinth[row, col] = "X";
                    }
                }
            }
        }
Esempio n. 12
0
        public static Cell FindStartingCell()
        {
            var startingCell = new Cell()
            {
                Step = 0
            };
            var haveFoundStartingCell = false;

            for (int row = 0; row < inputLabirinth.GetLength(0); row++)
            {
                for (int col = 0; col < inputLabirinth.GetLength(1); col++)
                {
                    if (inputLabirinth[row, col] == "*")
                    {
                        startingCell.Row = row;
                        startingCell.Column = col;
                        haveFoundStartingCell = true;
                        break;
                    }
                }

                if (haveFoundStartingCell)
                {
                    break;
                }
            }

            return startingCell;
        }