// // The Grid constructor will populate the 10 by 10 array of GRectangles, which we call // gridRec, and then will go through, and in a second pass, for each rectangle, point // to it's neighbors via a List of GRectangles. // public Grid() { gridRec = new GRectangle[10, 10]; // Must create an instance of gridRec brushgrey = new SolidBrush(Color.DimGray); brushwhite = new SolidBrush(Color.White); blackPen = new Pen(Color.Black, 1); // // Here we initialize the grid, which consists of an array of GRectangles - just // C# Rectangles with some extra properties and methods. // Initially, wall is set to true (all squares are walls), then the Search backtracking // methed will produce the 'free' squares, by setting wall to false. // x = 0; y = 0; width = 45; height = 35; for (int i = gridRec.GetLowerBound(0); i <= gridRec.GetUpperBound(0); i++) { x = 0; for (int j = gridRec.GetLowerBound(1); j <= gridRec.GetUpperBound(1); j++) { gridRec[i, j] = new GRectangle(x, y, width, height, true, i, j); x += 45; } y += 35; } // end of for loop // // Take second pass through the array of GRectangles, to setup the neighbors // A neighbor is merely an adjacent square. x = 0; y = 0; width = 45; height = 35; for (int i = gridRec.GetLowerBound(0); i <= gridRec.GetUpperBound(0); i++) { x = 0; for (int j = gridRec.GetLowerBound(1); j <= gridRec.GetUpperBound(1); j++) { // Up, Down, Left, Right in order for List if (i > 0) { gridRec[i,j].setUp(gridRec[i-1, j]); } if (i < 9) { gridRec[i,j].setDown(gridRec[i+1,j]); } if (j > 0) { gridRec[i,j].setLeft(gridRec[i, j - 1]); } if (j < 9) { gridRec[i,j].setRight(gridRec[i, j + 1]); } x += 45; } y += 35; } //end of second for loop // // // Begin the recursive search for the maze, starting at upper left corner square, which is // position 0,0 rand = new Random(); // Seed a random number generator. int Counter = 0; Search(gridRec[0, 0], ref Counter); // Still in the constructor, we fire off the recursion with this first // call to Search (begin at upper left corner of the grid). }
// // The Grid constructor will populate the 10 by 10 array of GRectangles, which we call // gridRec, and then will go through, and in a second pass, for each rectangle, point // to it's neighbors via a List of GRectangles. // public Grid() { gridRec = new GRectangle[25, 25]; S = new Pair<GRectangle, int>[dimx*dimy]; brushgrey = new SolidBrush(Color.DimGray); brushwhite = new SolidBrush(Color.White); blackPen = new Pen(Color.Black, 1); greyPen = new Pen(Color.DimGray); // // Here we initialize the grid, which consists of an array of GRectangles - just // C# Rectangles with some extra properties and methods. // Initially, wall is set to true (all squares are walls), then the Search backtracking // methed will produce the 'free' squares, by setting wall to false. // x = 0; y = 0; width = 500/dimx; height = 500/dimy; for (int i = gridRec.GetLowerBound(0); i <= gridRec.GetUpperBound(0); i++) { x = 0; for (int j = gridRec.GetLowerBound(1); j <= gridRec.GetUpperBound(1); j++) { gridRec[i, j] = new GRectangle(x, y, width, height, true, i, j); x += width; } y += height; } // end of for loop // // Take second pass through the array of GRectangles, to setup the neighbors // x = 0; y = 0; for (int i = gridRec.GetLowerBound(0); i <= gridRec.GetUpperBound(0); i++) { x = 0; for (int j = gridRec.GetLowerBound(1); j <= gridRec.GetUpperBound(1); j++) { // Up, Down, Left, Right in order for List if (i > 0) { gridRec[i, j].setUp(gridRec[i - 1, j]); } if (i < dimx-1) { gridRec[i, j].setDown(gridRec[i + 1, j]); } if (j > 0) { gridRec[i, j].setLeft(gridRec[i, j - 1]); } if (j < dimy-1) { gridRec[i, j].setRight(gridRec[i, j + 1]); } S[dimx * i + j] = new Pair<GRectangle, int>(); S[dimx * i + j].First = gridRec[i, j]; S[dimx * i + j].Second = -1; x += width; } y += height; } //end of second for loop // }
public void setUp(GRectangle u) { Up = true; Neighbors.Add(u); }
public void setRight(GRectangle u) { Right = true; Neighbors.Add(u); }
public void setLeft(GRectangle u) { Left = true; Neighbors.Add(u); }
public void setDown(GRectangle u) { Down = true; Neighbors.Add(u); }
// // // The method Search will do depth-first search to create the maze. // public void Search(GRectangle r, ref int callcounter) { // // // If the curreent square is not available, we return. But if it's // available, we make it free (change wall to false), and then search // through it's neighbors, calling Search again for each of them. if (r.isAvailable() == false) // Is it available? return; r.makeFree(); // Make it free (no longer a wall). // // The following line is temporary: just for debugging. callcounter will be printed out // in the drawGrid method: it tracks the order in which the squares were 'dug out'. callcounter++; r.setCounter(callcounter); // We house the callcounter in each square, so we can access it later. // // We randomly choose which neighbor of the current square to look at, to get // a more robust maze. testrec is just a copy of the neighbors. Each time we select a neighbor // we remove it from testrec, so we can then get a random integer within the new, smaller range on // the next iteration List<GRectangle> testrec = r.getNeighbors(); // Get a copy of the list of neighbors for r. do { int testidx = rand.Next(testrec.Count); if (testrec[testidx].isWall() == true) // Only walls need to considered to 'burrow through'. { Search(testrec[testidx], ref callcounter); // Here we call Search for each of the remainding neighbors. } testrec.RemoveAt(testidx); // As this one was considered, remove it (so now we have a smaller list). } while (testrec.Count > 0); // end of do while return; }
// // The next four methods merely add neighbors to the Neighbors list, as needed. public void setUp(GRectangle u) { Neighbors.Add(u); }