Maze Rush 0.8.1
January 14, 2012
New version on it's way!
The master branch on the Maze Rush git repository is now updated with loads of new features.
The most important functional feature is the collision handling on the camera. Camera no longer crosses walls: human peeking across walls inside the maze (cheating) no longer allowed!
Also, the player can now choose among several other maze generation algorithms! (inspired by this great slide presentation): prim, kruskal, drunk, dfs, binary, oldest, subdivision, random (uses a random algorithm).
As non-functional features, the code is now much better structured and a decent Makefile has been designed.
No video this time as no great visual improvement was accomplished.
There is still a lot to do!
This version also marks the beginning of the game being released as a PKGBUILD for Arch Linux users.
The PKGBUILD will be maintained on the AUR on the link below:
Other distros users can test the game downloading the source and running make.
Maze Rush 0.8
November 2, 2011
Maze Rush is a game where you race against AI robots towards the end of a maze.
The maze is automatically generated by the program and a new random maze is generated every time the game is launched.
You can configure parameters such as maze generation method, maze size, and smartness of AI robot.
Maze Rush runs on Linux.
Maze Rush is open source at https://github.com/enunes/mazerush
Most of the code is homemade and done for own learning purposes.
This is still a development version with some non-optimized code.
This started and is currently a one man project which was born from boredom at college vacation.
This was initially inspired by http://www.mazeworks.com/mazegen/index.htm .
Most notable functional features accumulated to this release:
- A new, size configurable random maze is generated automatically every time a match begins;
- You can choose between two algorithms for maze generation (Prim and Kruskal);
- You can configure the number of robot enemies, (and their names and colors);
- Three types of robot AI: standard DFS, "smart" search (avoids obvious dead-ends) and dumb (totally random movements);
- Shows ranking of finished racers with time and difference from first;
- Collision handling against walls;
- Player is allowed to freely fly in 3D and explore over the maze after reaching the end of the maze; or also camera-follow other robots.
Free! You can copy, modify and distribute this freely, although I would really like if you let me know what you think :)
- The game is now called Maze Rush (formerly Labyrinth)
- Added restart/new maze buttons.
- Colored player names over their heads.
- Improved sceneries rendering, sky is now open free.
- New textures, and textures are now fixed filenames (making configuration cleaner).
- Shows maze size, rendering fps, timer.
- Human input is now synchronized with game logic. Human player now moves at the exact same speed than the AI.
Multiple keys allowed, no key repeating delay, normalized diagonal speed.
- Finishing time for each robot are colourly presented. Each one after the first also has the time difference from the first place.
- Human gets a big finishing place and time mark on screen.
- Human now "wins" if first, and "loses" if not first to cross the finish line.
- Human are allowed to freely fly in 3D and explore over the maze after he or she reaches the end of the maze.
- The player can also now camera-follow the other robots after he/she finished the maze.
- "Players" are now more abstract in code.
That is, the only difference between Human robot and AI robot is the way the robot receives move commands, but the robot itself is the same.
This allows for easier looping among "all robots", including the Human.
- AI now runs a static path which is built at each robot instancing.
This improves the debugging and predictability of the AI.
It also allows the developer to more easily create more algorithms, because a path can be traced and edited.
- Major rehaul of the whole code, glfw used for OpenGL context, ftgl used for rendering text, more glm features used (and less legacy OpenGL).
- New Robot AI: AI_DUMB . It moves totally random, with no patterns or marks.
Language: C++ ;
Runs on: Linux;
Uses: OpenGL, OpenAL + alut, glfw (window/input), glm (OpenGL Math, matrix library), ftgl (OpenGL fonts rendering library);
Tools used: blender (the robot model), audacity (to make the audio loop that got ripped off on the video), gimp/imagemagick, Linux development environment (vim, make, g++, gdb...), git/github.
New release! (01/08/2011)
Details and source below.
New release of Labyrinth, my little vacation hobby project.
Labyrinth is a game where you race against AI robots towards the end of a maze.
The maze is automatically generated by the program and a new maze is generated every time the game is launched.
Labyrinth runs on Linux.
Labyrinth is open source (link to source below) and most of the code is homemade and done for own learning purposes.
Current release (0.6) features:
- A different random maze generated automatically every time labyrinth is run;
- Maze size is configurable;
- You can choose between two types of maze generation (Prim and Kruskal);
- You can configure the number of robot enemies;
- Two types of robot AI: standard search and "smart" search (avoid dead-ends);
- Shows ranking of finished racers;
Improvements from last release (0.5b):
- Wall detection now works (you don't cross the walls anymore)
- Walls are now stored on OpenGL arrays style instead of old and slower immediate mode;
- Better markings for start of the maze, and reaching the end is now detected;
- 3D meshes now stored as .obj files instead of custom format;
- glm (OpenGL Mathematics) used as matrix/vector library;
- Shows players that finished the maze on the game screen;
- Code somewhat better organized;
- Full source code now available on git: https://github.com/enunes/mazerush
Goals for version 1.0:
- Allow players to start a new match without having to launch the game again;
- Provide a main menu for game start/quit/basic configuration;
- Menu configurations should be number/parameters of enemies, algorithm, size;
I'd really enjoy some feedback at nunes dot erico at gmail :)
BGM Credits: The Dead Rocks - My Nurse Wanna Dance With Me (at http://www.jamendo.com/en/album/86120 )
My 2-week project during vacation bored-time. Not finished!
Current version Labyrinth 0.5b.
It generates a random maze using a selected algorithm and places any user defined number of robots to solve it.
Currently, generates by using either Prim's algorithm or Kruskal's algorithm for minimum spanning tree.
Robots can be either solvers or smartsolvers. Smartsolvers avoid dead-ends and that allows them to solve faster.
You are supposed to play against the Robots and reach the end (green marked point) before they do.
It was written using only Standard C++, OpenGL for graphics and OpenAL for background music. The whole "engine", including mesh format and loader, models, maze generator, solvers, math and whatnot was homemade and done for learning/experience purposes. This only makes use of graphics fixed functionality though because the primary objective was to deal with the game mechanics and not graphics functionality.
Currently works on Linux only. I can distribute it, but I must warn the current source is a bit ugly so it should not be used for learning purposes by anyone else. :P