Пример #1
0
 //später noch auf Diagonale Zellen erweitern, bis jetzt noch keine Diagonalen
 /// <summary>
 /// function to update the Walls of two neighbour Cells 
 /// </summary>
 /// <param name="akt">reference of current cell</param>
 /// <param name="next">reference of next cell</param>
 /// <param name="index">index which cell to update</param>
 private void updateWall(ref Cell akt, ref Cell next, int index)
 {
     if (next == null)
     {
         if(akt != null)
         {
             akt.setWall(index, false);
         }
     }
     else if (akt == null)
     {
         if (index == (int)neighbour.up)
         {
             next.setWall((int)neighbour.down, false);
         }
         else if (index == (int)neighbour.down)
         {
             next.setWall((int)neighbour.up, false);
         }
         else if (index == (int)neighbour.left)
         {
             next.setWall((int)neighbour.right, false);
         }
         else if (index == (int)neighbour.right)
         {
             next.setWall((int)neighbour.left, false);
         }
     }
     else
     {
         akt.setWall(index, false);
         if (index == (int)neighbour.up)
         {
             next.setWall((int)neighbour.down, false);
         }
         else if (index == (int)neighbour.down)
         {
             next.setWall((int)neighbour.up, false);
         }
         else if (index == (int)neighbour.left)
         {
             next.setWall((int)neighbour.right, false);
         }
         else if (index == (int)neighbour.right)
         {
             next.setWall((int)neighbour.left, false);
         }
     }
 }
Пример #2
0
        /// <summary>
        /// function to update the map with the Walls of the Cell
        /// </summary>
        /// <param name="cell">cell with which map is updated</param>
        private void updateMap(Cell cell)
        {
            int x = cell.getMapIndexX();
            int y = cell.getMapIndexY();

            mapType[x, y] = (int)tiles.floor;

            mapType[x - 1, y] = cell.getWall((int)neighbour.up) == true ? 1 : 0;
            mapType[x + 1, y] = cell.getWall((int)neighbour.down) == true ? 1 : 0;
            mapType[x, y - 1] = cell.getWall((int)neighbour.left) == true ? 1 : 0;
            mapType[x, y + 1] = cell.getWall((int)neighbour.right) == true ? 1 : 0;
            mapType[x - 1, y - 1] = cell.getWall((int)neighbour.upLeft) == true ? 1 : 0;
            mapType[x - 1, y + 1] = cell.getWall((int)neighbour.upRight) == true ? 1 : 0;
            mapType[x + 1, y + 1] = cell.getWall((int)neighbour.downRight) == true ? 1 : 0;
            mapType[x + 1, y - 1] = cell.getWall((int)neighbour.downLeft) == true ? 1 : 0;
        }
Пример #3
0
 /// <summary>
 /// function which returns number of not visited neighbour cells
 /// </summary>
 /// <param name="maze">Double Array with all Cells in it </param>
 /// <param name="cell">current Cell</param>
 /// <returns>integer</returns>
 private int numOfNotVisited(Cell[,] maze, Cell cell)
 {
     int result = 0;
     for(int i = 0; i < 4; i++)
     {
         if(getNext(maze, cell, i) != null)
         {
             if(getNext(maze, cell, i).getVisited() == false)
             {
                 result++;
             }
         }
     }
     return result;
 }
Пример #4
0
 /// <summary>
 /// function which returns an array with the indices of all neighbour cells which have not been visited yet 
 /// </summary>
 /// <param name="maze">double array with all cells </param>
 /// <param name="cell">current cell</param>
 /// <param name="length">number of neighbour cells which have not been visited yet </param>
 /// <returns>array of integer</returns>
 private int[] notVisited(Cell[,] maze, Cell cell, int length)
 {
     int[] result= new int[length];
     int index = 0;
     for (int i = 0; i < 4; i++ )
     {
         if(getNext(maze, cell, i) != null)
         {
             if(getNext(maze, cell,i).getVisited() == false)
             {
                 result[index] = i;
                 index++;
             }
         }
     }
     return result;
 }
Пример #5
0
 /// <summary>
 /// function which returns the next cell in a given direction
 /// </summary>
 /// <param name="maze">double array with all cells</param>
 /// <param name="cell">current cell</param>
 /// <param name="index">index in which directio next Cell lies </param>
 /// <returns>neighbour Cell in wanted direction</returns>
 private Cell getNext(Cell[,] maze, Cell cell, int index)
 {
     int newX = 0;
     int newY = 0;
     if (index == (int)neighbour.up && cell.getCellIndexX() - 1 >= 0)
     {
         newX = cell.getCellIndexX() - 1;
         newY = cell.getCellindexY();
         return maze[newX, newY];
     }
     else if (index == (int)neighbour.down && cell.getCellIndexX() + 1 < maze.GetLength(0))
     {
         newX = cell.getCellIndexX() + 1;
         newY = cell.getCellindexY();
         return maze[newX, newY];
     }
     else if (index == (int)neighbour.left && cell.getCellindexY() - 1 >= 0)
     {
         newX = cell.getCellIndexX();
         newY = cell.getCellindexY() - 1;
         return maze[newX, newY];
     }
     else if (index == (int)neighbour.right && cell.getCellindexY() + 1 < maze.GetLength(1))
     {
         newX = cell.getCellIndexX();
         newY = cell.getCellindexY() + 1;
         return maze[newX, newY];
     }
     else if (index == (int)neighbour.upLeft && cell.getCellIndexX() - 1 >= 0 && cell.getCellindexY() - 1 >= 0)
     {
         newX = cell.getCellIndexX() - 1;
         newY = cell.getCellindexY() - 1;
         return maze[newX, newY];
     }
     else if (index == (int)neighbour.upRight && cell.getCellIndexX() - 1 >= 0 && cell.getCellindexY() + 1 < maze.GetLength(1))
     {
         newX = cell.getCellIndexX() - 1;
         newY = cell.getCellindexY() + 1;
         return maze[newX, newY];
     }
     else if (index == (int)neighbour.downRight && cell.getCellIndexX() + 1 < maze.GetLength(0) && cell.getCellindexY() + 1 < maze.GetLength(1))
     {
         newX = cell.getCellIndexX() + 1;
         newY = cell.getCellindexY() + 1;
         return maze[newX, newY];
     }
     else if (index == (int)neighbour.downLeft && cell.getCellIndexX() + 1 < maze.GetLength(0) && cell.getCellindexY() - 1 >= 0)
     {
         newX = cell.getCellIndexX() + 1;
         newY = cell.getCellindexY() - 1;
         return maze[newX, newY];
     }
     else
     {
         newX = cell.getCellIndexX() + 1;
         newY = cell.getCellindexY();
         return null;
     }
 }
Пример #6
0
        /// <summary>
        /// function to create random maze, only works with the inner part, 
        /// </summary>
        private void createMaze()
        {
            int numCellsX = 0;
            int numCellsY = 0;

            //determine number of cells depending on even or odd size of maze
            if (Settings.getMapSizeX() % 2 == 1)
                numCellsX = (Settings.getMapSizeX() - 1) / 2;
            else
                numCellsX = (Settings.getMapSizeX() - 2) / 2;

            if (Settings.getMapSizeZ() % 2 == 1)
                numCellsY = (Settings.getMapSizeZ() - 1) / 2;
            else
                numCellsY = (Settings.getMapSizeZ() - 2) / 2;

            // Array to store the Cells in
            Cell[,] maze = new Cell[numCellsX, numCellsY];

            int MapIndexX = 1;
            int MapIndexY = 1;

            //initialize all Cells
            for (int i = 0; i < numCellsX; i++)
            {
                for (int j = 0; j < numCellsY; j++)
                {
                    maze[i, j] = new Cell(MapIndexX, MapIndexY, i, j, true, true, true, true, true, true, true, true);
                    MapIndexY += 2;

                }
                MapIndexY = 1;
                MapIndexX += 2;
            }

            //find random begin in the middleof the map
            int thirdX = numCellsX / 3;
            int thirdY = numCellsY / 3;
            int StartX = rnd.Next(thirdX) + thirdX;
            int StartY = rnd.Next(thirdY) + thirdY;

            Cell akt = maze[StartX, StartY];
            akt.setVisited(true);

            Stack<Cell> stack = new Stack<Cell>();
            stack.Push(akt);
            int lastTurn = 0;

            while (stack.Count != 0)//stack.Count != 0)
            {
                akt = stack.Peek();
                int n = numOfNotVisited(maze, akt);
                if (n == 0)
                {
                    updateMap(akt);
                    stack.Pop();
                }
                else if(n == 1)
                {
                    int[] index = notVisited(maze, akt, n);
                    int finaleIndex = index[0];
                    lastTurn = finaleIndex;
                    Cell next = getNext(maze, akt, finaleIndex);
                    next.setVisited(true);
                    updateWall(ref akt, ref next, finaleIndex);
                    updateMap(akt);
                    stack.Push(next);
                }
                else
                {
                    // find next neighbour
                    int[] index = notVisited(maze, akt, n);
                    int random = rnd.Next(n - 1);
                    int finaleIndex = index[random];

                    while(finaleIndex == lastTurn)
                    {
                        finaleIndex = (index[random + 1 % n]);
                    }

                    Cell next = getNext(maze, akt, finaleIndex);
                    next.setVisited(true);

                    // Wand von eigener & next updaten
                    updateWall(ref akt, ref next, finaleIndex);

                    updateMap(akt);
                    stack.Push(next);

                }
            }
        }