Saturday, February 22, 2014

Maze Generation Algorithm

Recently, I had to develop a game that required a random maze to be generated. The logic behind it is not that hard, but some people may have trouble trying to code it, so I decided I would blog about it.

This post is a how-to generate random labyrinths. Keep in mind there are a lot of algorithms and this is not the best neither the most optimized. In my opinion it is the simplest though.


What you will need:

  • lab: an array to store the labyrinth (I'll be using a 2D array);
  • visitedCells: a secondary array to keep record of the visited cells;
  • guideCell: the coordinates of the head of the path;
  • pathHistory: a stack to keep a record of the path taken.

    How the algorithm works:

    • The guide cell starts next to the exit;
    • The guide cell advances to a random unvisited cell;
      • The guide cell keeps advancing until there are no unvisited cells around it;
      • When there are no unvisited cells around, the stack gets useful:
        • back trace to a point of the path where there is at least one unvisited cell and develop the algorithm from there;
    • The maze is completely finished when all cells have been visited.
      • An even easier way to know it is finished is when the stack gets empty.


    • The dimension of the maze needs to be an odd number.

    Detailed Algorithm Analysis

    Let's say we need to generate a 7x7 maze.

    The first step is to fill the 2D array with walls (I'll be using 'X' to display walls). After this we need to free the cells which have odd x and y coordinates, just like the picture below:

    And this is the base matrix where the algorithm will work. That's why the the maze needs to have an odd dimension.
    The next step would be randomly picking one free cell (as long as it is right next to the maze borders) and marking it as the guideCell. After that, place an 'S' on the maze border to mark the exit:

    S: exit
    +: guideCell

    The next step is to create the visitedCells array to keep track of the cells which have been visited or not. This array will not be 7x7 but 3x3. The dimension of the visitedCells array is given by

    visitedCellsDimension = (labDimension - 1) / 2

    Here is the current state of the visitedCells array:

    .: unvisited cell
    +: visited cell

    Ok, by this time we have our lab array and our visitedCell ready. We just need to push the guideCell coords to the stack:

    Now that we have everything ready, let the algorithm start working! Yay! :D

    First we need to generate a random direction and check if that cell has already been visited. If not, the guide cell will advance to that direction.

    Assume that the computer randomly says: "guideCell, go down!". The cell below the guideCell current location has not yet been visited according to the visitedCells array, so this is what will happen:
    • the guideCell coords will be updated and pushed to the stack;
    • the visitedCells matrix will be updated:
      • a '+' will be marked at {2, 1};
    • the lab array will also be updated:
      • the 'X' on {5, 2} will be removed.
    This is how the containers look at this point:

    Ok let's speed up things a little bit. I hope you are catching up with me.

    Let's say the computer generated this directions randomly:
    • right;
    • up;
    • left;
    • down;
    • right.

    The 1st direction (right) will be ignored because the guide cell can not go right! That's the border of the maze!
    The 2nd direction generated (up) will also be ignored because according to the visitedCells, the cell above the guideCell has already been visited. Do you get it? :)
    The 3rd direction is a valid one though! The guideCell can indeed go left. So this is what will happen:

    The 4th direction generated was 'down':

    And finally, the 5th direction generated was 'right':

    Ok, by now you should have realized how the algorithm works.

    Notice what happens now:
    • If the computer generates right or down, the guideCell can not go there because that is the maze borders!
    • If the computer generates left or up, the guideCell can not go there as well because according to the visitedCells array, both cells in that direction have already been visited!
    It is a dead end! So, how do we finish generating the maze? It's not finished yet...

    Well, it's not that hard! This is why we have the stack with the history of the path we took!
    When we run into this problem we just need to back trace the stack and look for a cell that has at least one neighbor that has not yet been visited. When we do find this cell, it becomes our new guideCell.

    Let me use the example we have been working on to illustrate what I mean:
    The current guideCell has no unvisited cells as neighbors, so we need to remove it from the stack. And since we removed it, the top of the stack is {1, 2}, and this cell has at least one neighbor unvisited: This is our new guideCell.

    And since there is only one valid direction (left), the following algorithm iterations will be:

    And at this point, once again, we got to a dead end. What did we do when this happened before? That is right! We popped the stack until we found a cell that had at least one unvisited neighbor.

    This time though, we will pop the stack and won't find a cell that matches this condition. Why? Because all cells have been visited! You can check that by looking to the visitedCells array.
    The program will therefore be popping the stack and eventually empty it.

    And that concludes the algorithm: when the stack gets empty, all the cells have been visited and the maze generation was successfully completed! :)

    Here is an example of a 31x31 maze generated with this algorithm:

    I hope this helped you and was not too confusing... Cheers!

    Tuesday, February 11, 2014

    How to setup Eclipse for Java development

    If you already have Eclipse

    If you have some version of eclipse already installed, you can update it and add Java directly.

    For that you just have to do this:

    • Find your version URL. My eclipse version is Juno, so the URL I will need is:
    • Open Eclipse and go to Help and choose Install New Software;
    • Paste the URL of your version and wait for the list of softwares available to load;

    • Under "Programming Languages" select "Eclipse Java Development Tools";

    • Press Next and after completing the installation you are done.

    If you don't have Eclipse installed

    Windows Users

    Installing JDK

    • Go to the downloads page;
    • Select Accept License Agreement and download the version according to your system (in my case 64-bit);

    • Install JDK using the setup you just downloaded.

    Installing Eclipse

    • Download Eclipse and extract the .zip;
    • You should now have a folder called "eclipse", rename it to "eclipse-java";
    • Copy the folder and paste it to "C:\Program Files" (or "C:\Program Files (x86)" if your system is 32-bit);

    • [Optional] You can now create a shortcut to eclipse. In order to do that, right-click on "eclipse.exe" and select copy. After that go to your desktop, right-click anywhere and click Paste shortcut.

    That's it for Windows users!

    Ubuntu Users

    Installing JDK

    • Ubuntu already comes with JDK installed, so you need not worry about that.

    Installing Eclipse

    • Download Eclipse and extract the .zip;
    • You should now have a folder called "eclipse", copy that folder to /opt/;

    [Optional] You can now create a shortcut to eclipse.
    • Open the Terminal: CTRL + ALT + T;
    • Type:
      • sudo ln -s /opt/eclipse-java/eclipse /usr/bin/eclipse
      • sudo gedit /usr/share/applications/eclipse.desktop
    • After these commands, gedit (text editor) should have opened. Now copy this and paste it there:
    [Desktop Entry]
    Comment=IDE for all seasons
    Exec=env UBUNTU_MENUPROXY=0 /opt/eclipse/eclipse

    • Save the text file and close gedit;
    • This should have successfully created a shortcut. You may have to log off and back in for it to appear.

    And that's it!