Screenshots

Still working on core mechanics overhauls, this shot shows the stand-in title screen fading into the action screen. This represents some serious work on the state management of the game that had me just sitting and thinking for weeks before i ever touched the code. The game is getting really big and the architecture needs to be flexible enough to handle much more expansion. State management was one of the heavier things to program, but it came out fairly well. There are currently two screen-swipe effects: fade-to-black and crossfading. Both are ubercool :-P

This shows off the new blitting routines, including special blending effects like additive lighting. This adds so much to the visuals off the game, it's amazing. There is an awefull lot of backend mechanics being worked on at this point though; Major overhauls in the core system. These two shots also show the new primitive GUI: the new version on top and the old version of the widgets on the bottom. All the meters actually work and respond to the player's status. You can also see the FTGL font rendering on them.

For OpenGL text rendering, it's not as simple as with SDL. I started trying to shoehorn in an external library called FTGL which i'll be using for font rendering, but it's set up differently than my game. As you can see, everything was mirror-flipped and took me a while to figure out how to fix it. "FART" by the way, is the universal testing / bug-hunting word. It's easy to spot. Right about now, audio is always being incorporated into the design, but audio doesn't make good screenshots.

Here is another shot that shows off the underlying geometry again. Always interesting to see.

This is the first time the BasicLaserShot was ever combined with the Player object. Now you can jump around and actually shoot at things. It was so easy in fact, i also programmed a "fireflower" attack which shoots off 16 lasers in a ring, (and you know i also tried up to 48 at once :-). It's so very cool. It won't make it into the final game, but i might leave it in as an easter egg. Right about now, it's actually starting to come together into an actual "game". Testing is fun.

Here we have the first glimpse of the Player object: just a simple stickman at this point. But he jumps and runs around and bounces off the balls. However, there is a certain problem: stickman only knows how to interact with orthogonal objects. Interacting with anything that is a slope is a HUGE problem, and remains so. Of all the problems this project has faced, this one has been the hardest to solve, hands down.

A demonstration of some less-fun code, this is a visual graph of time deltas. As you can see, the time it takes to render each frame is usually the same, but the timer trying to keep it in sync is actually rather inaccurate. This graph shows regular spikes in the time deltas which leads to jerky movement. I really slick time delta "smoother" function was programmed, but it may or may not be usefull. It is interesting though.

A "quadtree" structure was concocted in order to maintain speed in the collision system. This shot shows a few hundred of those wily happy faces happily bouncing around inside a huge chamber (goes way offscreen). You can see the node-structure with the orange lines. This also means that a proper GameSpace class was programmed; a very significant achievement codewise.

This is a very crude display of some code written by Oliii to handle polygon-based collision detection. I mangled and tailored the code to my needs. Here you see some movable user-controlled polygons moving inside a boxed-in area. It also shows a colored line i was also trying to develop (alas, for ever-coolor particle trailers).

This shows a novel improvement over the basic laser shot: directional based firing. Although the player in the final game will only be able to shoot in 8 directions (it's just easier that way), the actual code will let you fire in any direction. You can also see here the underlying geometry in the collision detection system.

The is the first image of a laser shot. It just travels from one point on the screen and across to the other side. It strikes a moving block. Not really very fancy, but already it has a muzzle flash and particles that come off when it hits something.

Here are two more shots that show all of the programmed effects so for created in their new OpenGL glory: massive showers of particles, expanding explosions (dynamically configured!), moving blocks, textured walls, and a new "LightFlare" class which puts a really nice touch on anything that explodes ;-) The background and wall textures where all painstakingly done by yours truly.

This shot was a stress test on the system to see how many objects it could actually update without getting too bogged down. It did MUCH better than the old SDL system could ever handle.

This is a particle explosion but with several layers. You can see the main layer and the white ring layer. This led to other interesting explosions including the time-delayed multi-componant explosion with 2 blast rings on the finisher ;-) This screenshot is special however, because it's the first screenshot of the new OpenGL-based rendering system. It was a switch from SDL-based graphics and was fortunately done early in the project. I've never looked back. Yeah OpenGL! If you look closely, you'll notice that the particle trails are solid lines instead of stippled points like in the previous SDL design.

In order to test me skills with action-based game programming, i wanted to do a little collision detection. The goal was to get a simple box-shaped room and bounce some happy faces around inside of it. There were also some angry faces which exploded violently on contact with the happy faces. You can also see here an image based particle (instead of the "standard issue" pixel-based particle). It blinks and fades out. Pretty cool. There are also displayed: an image background, an animated 16-frame explosion, simple text output, and block objects to bounce off of.

The entire project got started because i was tired of programming a strategy game and wanted to program some cool explosions. So the first thing i did was design a simple particle and a simple object processor to update and draw the particles. This is a MachineExplosion, the code for which is still in use. The basic design pattern the object processor was made with is also still in use and is the true core of this program.