Welcome

Hello there all.

This is a blog of my projects, both personal and those related to university.
A project blog, a prog?

I thought it would be prudent to keep a log of progress and interesting for others to follow the development of games and other applications.

The projects covered by this blog are primarily games, however other applications or related tools may be developed along side these projects over time. Demos and periodic releases shall be published along side progress blogs as soon as I can acquire some free hosting space.

Anyways, here is an overview of my current projects and their current progress.


Project: Shockwave
Platform: XNA Framework, C#

This is a project for university. I, and a small team of others are to produce a game that is addictive, simple and fun.
The game concept we have gone with is a platform game where the player has to out run rising water and escape a building. The player is also an electrician who can take time out to disable fuse boxes to prevent the water from becoming electrified and more deadly. This is done by playing a small mini-game. While this goes on the water keeps rising.
The player also has to avoid being munched by an angry dog and piranha (who comes active once the water rises over his bowl).



The game is roughly about 50% complete but we are rapidly running out of time :s.
To get out of having to build a tool set for the team and cut down the amount of work needed to do level design the game has completely procedurally generated levels. Currently it generates a level to fill the screen (640 x 480) and cover 4 floors. Platforms can be anywhere between 32 pixels wide and 640 pixels wide with steps of 32. This is because the system runs off of tiles of 32 x 32.
The bottom floor is always the width of the screen, this is to make player starting positions easier to calculate. It also gives a nice starting position.

After the platforms have been generated, ladders connecting the platforms are generated. These are placed as far apart from each other as possible to prevent the game from being too easy. The distance the player can jump is taken into account when checking if the player can reach the platform.

Decoration for the map is now generated. This is simply the random selection of a theme from a list. The theme is made of a texture for the back wall, a collection of textures to represent furniture in the 'room' and a number representing the likelihood of a piece of furniture being spawned.
For each platform on a floor a 'dice' is rolled to see if a piece of furniture is spawned on each segment of the platform and then a random piece is selected from the list of furniture textures in the theme assigned to the floor.

Finally tokens are placed in the level. This is quite smiler to the decoration but without the theme and a guaranteed number of tokens placed. Tokens are anything like power ups, points bonuses and fuse boxes.

Currently there are a number of issues that need sorting out with the level generation.
The ladder placement sometimes ignores platforms that are reachable, also the collision detection is odd where the player is able to climb down and fall off the bottom of the platform.
The ladder generation stops the rest of the generation taking place until it is able to spawn enough ladders to reach the top of the screen. This requires a platform segment to be reachable by the player and have a platform segment above it for the ladder to lead to. Sometimes the program takes some time to generate a collection of platforms that allow the player to get to the top, creating a long delay on start up. It is also suspected that infinite loops can be entered into :(
Additionally the fuse boxes (the only tokens able to be spawned so far) appear in front of furniture. It would be better to have them appear instead of a furniture item.

The rising water works correctly and the potential drowning of the player is also correctly detected. However this is just a giant pixel stretched across the screen and doesn't look very good. It is also rendered under the player too. It will eventually have a wavy texture placed along the top and possibly a texture for the main body.
As the water is part of the map structure (which is rendered before the player) a separate render call will need to be made to draw the water over the player.

The mini-games are an extremely primitive component right now :(. There are around 16 designed but only 1 prototype game exists so far. The player has to move a yellow square into a slightly larger read square around a wall. The positions of the wall and boxes are randomly generated each time. The wall is made to go between the two boxes to prevent direct movement. However there is a bug that occurs where the wall and target box can be spawned, intersecting each other making the task completion impossible (the player box can't move past the wall to sit inside the target box). This is despite having validation code existing that demands the puzzle regenerate if the wall intersect any of the boxes.

The latest addition to the game is animations! The player can now actually walk and climb ladders now :D This is a simple system involving sprite sheets for each animation and a display rectangle.
Each creature in the game will have the option for animations to be displayed for a number of states. Currently the animations exist off of the existing state system (moving, in the air, etc) but I suspect a more extensive state system may be needed for some of the other animations (difference between jumping and falling, etc).


Project: Vendor/Builder Engine
Platform: DirectX 9.0c, C++
This is an extension of my undergraduate FYP. It is built on the same engine base but the engine has been upgraded and developed extensively. It is aimed to be the centre of my portfolio when I go for game industry jobs.
The engine is the main development focus at the moment as every time I come to develop parts of the game and do game play programming I find either that the current framework features are inadequate or I think of a new feature I want to add to the engine.

The game, called Vendor for now is a game where a player managers a vending machine. Buying parts, stock, upgrades, etc. It is going to have a bit of a surreal edge to it to make it interesting (locations include a sports centre, university, fantasy RPG, war zone, etc).
The game originally associated with the engine was going to be a kind of city building game like SimCity 4 but with features and ideas I think would make such a game better. It turns out this was a bit too much for my skill level so this game should bee easier to put together.



Features in the engine so far include a resource management system, 2D display system, 3D model viewing and a resource loading script (builder script, looks a bit like XML).

The current development area is the expansion of the 2D display system to provide a nicly opperating user interface. Specifically I am working on component collection management and user screens.

Project: Alpha
Platform: OpenGL, C++

This is the latest addition to my list of projects. A bit of a pet project. Currently this exists as a text based prototype but I am experimenting with OpenGL.



This is a game about the management of a nomadic gnoll clan. The design is in early stages at the moment but will be somewhere between Dogz and Dwarf Fortress.
The gameplay is the main project with this over graphics. It is being developed in order of game progress. So far the player can pick their initial clan and vehicles. I am working on the part to allow the player to pick equipment.



Because the structure of the program is very similar to the Builder engine, integrating the engine would be reletivly easy. However I wish to take this as an opportunity to learn OpenGL. I will try and keep a similar structure however as I wish to make use of sections of the Builder engine- the scripting system and resource management system would be very useful.