Before we get started with this tutorial you need to download and be familiar with the software I am going to use.

We'll be using Unity 3D game engine to create this maze generator , so that you can use this system to create your own game. Click here to download it

We all know what a maze is "its is a network of paths and hedges designed as a puzzle through which one has to find a way."(according our friend GOOGLE)

What we are going to create is a "

Which wall belong to which cell.

We'll be using Unity 3D game engine to create this maze generator , so that you can use this system to create your own game. Click here to download it

We all know what a maze is "its is a network of paths and hedges designed as a puzzle through which one has to find a way."(according our friend GOOGLE)

What we are going to create is a "

**Perfect maze**".*A perfect is a maze with no circular paths and there's only one path from one point of the maze to other.**Here are some pictures to explain it.*

**This is not a perfect maze.**

*This is a perfect maze.*

Programming a system the creates mazes for you is not very difficult and to make it easier we will be using the simplest algorithm

*"Depth first search"*.
But before we get started with the algorithm , we need to set up our scene.

Create a closed grid filled with walls.

Each square in this grid is a cell and all the lines represent the walls of the cells.

**Now we need to remember some information.**

Which wall belong to which cell.

Is that cell has been visited by the system?.

*Now to do this you can use data structures or simple classes.*

here's an example.

public class Cell { public bool visited public GameObject north; public GameObject east; public GameObject west; public GameObject south; public Cell (){ north = null; east = null; west = null; south = null; } }

Once you've assigned everything to the Cell classes you can continue with with algorithm.

###

Here's how it works.

Here's the complete video series :

###
**Depth first search or (DFS)**

Here's how it works.

- We will choose a random cell and mark it as visited
- Look for a random neighbor cell you haven't visited yet.
- If you find one then remove or destroy the wall between the current cell and random neighbor then move in to that neighbor cell and mark it as visited.If you don't find one then back up to the previous cell.
- Repeat the 2 and 3 step until you've been to every cell.

*Here's the pseudo-code for the Depth first search or (DFS) algorithm.*

create a array or list to hold a list of last visited cells and call it lastCell,we will use it as a stack. int totalCells = total number of cells present. int currentCell = 0; int visitedCells = 0; currentCell = choose a cell at random. visitedCells++; increment the value of visitedCells while visitedCells < totalCells find all neighbors of currentCell which haven't visited yet. if one or more found choose one at random destroy or remove the wall between it and currentCell add currentCell location on the lastCell. make that random neighbor cell currentCell visitedCells++ else get the most recent entry off the lastCell make it currentCell endIf endWhile

When the

*"**while*loop terminates, the algorithm is completed.Because we've visited every cell we already know that no cell is inaccessible,This algorithm prevents the creation of the circular paths.`"`
We can now put the start and the endpoint wherever we want.