Author: Cygon

I just couldn’t stop thinking how cool it would be if the walls of the maze would cast realistic shadows, so on Day 7, I began implementing stencil shadow volumes in my little game. Generating the silhouettes, something I was scared of, has been extremely easy since all you need to do is find all neighboring triangles in a mesh where one triangle is facing away from the light source and the other is facing towards the light source.

Generating quads for the silhouette edges wasn’t exactly difficult either after I already generated the entire maze geometry programmatically. However, I didn’t know what to do about the shadow caps, so I just left them be. This is not a problem because the camera will never enter a shadow volume and the caps will always be clipped by the Z buffer.

Finally, it was time to start with the gameplay code. I still needed to a main menu, level selector, the game itself, maze/ball collision detection and some dummy physics to make the ball behave in a realistic manner.

If you’re wondering why this screenshot now shows a Windows Vista frame, this afternoon Windows XP self-destructed and took the whole partition with it. Forced to reinstall from scratch, I decided to check out Windows Vista RC2…

On day 7, I finally completed the scene graph component. With this component, it is easy to place the meshes of my game in relation to each other. For example, the physics for the ball in my game are actually 2D (the ball will never hop, no matter how quick or hard you tilt the maze). The ball will be a child of the maze scene node. That means I only need to modify the ball scene node’s position and do not have to take into account the maze’s current rotation or where in the scene the box is placed. The scene graph handles that automatically and efficiently for me.

There also is a new component to manage effect files: The EffectManagerComponent. It loads and compiles effect files so I don’t have to do it all manually.

I spent some time cleaning up what I had so far. The GameComponents now make proper use of the GameServices concept and can handle device resets as well as do clean shutdowns. Models can now release their resources and will do so when it is required. All this has been implemented in a way that I can still develop care-free and happens seemingly on its own.

My texture coordinates had some minor issues as well. Thanks to the “show normals” shader in ATI RenderMonkey I was able to visually verify that all normals and texture coordinates are continuous and correct.

I also spent some time writing code to generate the tilt knobs that will be on the sides of my mounting box and added code to generate polygons for the underside of the maze. So theoretically, you could now view the maze from below as well. This also makes my entire geometry solid, meaning that there are no leaks where you could see ‘inside’ an object, which is important if I decide to try myself at shadow volumes later in the project.

For the rest of the day, I’ve been improving on my usage of the XNA model classes and then designed a little scene graph system, as seen from the current state of things, this is the cleanest way to decouple the scene from the game logic. I need the scene building stuff separate because I want to create a cool level selection system which renders previews of the maze. It wouldn’t be the best thing to always have the game logic all over the place when I just need an image of the maze!

The wall generation code has finally taken shape and generates the vertices for the walls exactly like it was meant to be. Vertices are optimally shared between the walls and no polygons are ever generated that the user wouldn’t be able to see. The code also avoids T vertices in order to prevent flickering pixels at the wall junctions.

Nevertheless, I fear I will have to change this code soon. It currently doesn’t generate texture coordinates and the shared vertices will become a problem if I want a continuous surface on my maze walls (which I plan to do by calculating u,v as x+z,y – which doesn’t work for the top of the walls since y [==v] would be the same everywhere).

Plus, the current code generates normals that are diagonally pointing away from the walls. If I would use these normals for ligthing, the walls would look as if they were rounded. I’ll still have to see whether I’m going to use normal-based lighting at all.

After finishing up the level parser with some minor tweaks and writing some unit tests which immediately highlighted several mistakes I then fixed, I began with the geometry building code.

The level file format is really easy and anyone should be able to create his own mazes. For example, this simple text file will be enough to have my game make a nice, textured 3D maze board of it:

###############
#O            #
# + +-+-+-+-+ #
# |    O      #
# + +-+-+ + +-#
# |       |   #
# +-+-+ + + + #
#     | | | |O#
#-+-+ + + + + #
#       | | | #
# + +-+-+ + + #
#F|       |   #
# + +-+-+ +-+ #
#        O|S  #
###############

After taking an in-depth look at the XNA model classes, I decided to build a special MazeModel class that would construct a model from a maze provided to it in its constructor.

That took most of day 2. While writing the mesh generation code, I noticed that my original idea with equally sized tiles and walls that only used a fraction of the tile they were on didn’t work out. But because I had already made the decision to limit the tiles walls can be on, it was not a drastic change to use alternating tile sizes.

It took me some time to figure out how to organize my code so it fits in with the XNA framework design. Because the game is so small, I did this by building some dummy classes and that I renamed and moved around in the project tree until I had reached an adequate design.

Maybe some people would have used an UML prototyping tool, but I am used to thinking in terms of design and code, so, just like a good chess player, I can see when a design will work out or when it will blow up.

Then I identified the hardest, probably most demotivating task at hand. If you can, I think it’s always good to start there because this is likely the point where you would "postpone" working on the project for the rest of eternity.

The hardest part in this project seemed to be the dynamic construction of the level’s 3D model out of a simple text file that defines the maze using pure ascii characters. You have to create a bullet-proof parser and then somehow build a contiguous vertex array for all the walls, floor plates and holes in pure code.

So day 1 ended with me writing a parser for the textual level file format I have layed out before.

Today, I started development on my first XNA game. It will be a rather simple game, the real-world version of which I once played in my childhood. This should allow me to get up to speed with the state of the art in 3D accelerated rendering again.

Because I have a job that requires me to sit in front of a PC for more than 9 hours a day, my interest in development at home is fading a bit. I hope this game will rekindle my interest for game development!

Back to the game, what I decided on is a simple game of balance where you have to carefully tilt the game board to maneuver a little ball around obstacles to the finish:

Because this is such a simple game, I will release it for free and in full, that means with all notes and its source code!