Hey everyone!

Today I've got a special treat for you guys, I spent about a couple hours searching through my Harddrive, and I found a few old version of the Dogfight Engine, and I decided to write up a history of the A22 Engine, complete with diagrams and figures! I also have a few other things to talk about, so for today I'm going to borrow Mark's fancy horizontal line thing to seperate the sections....




The Evolution of the A22 Engine
This is a little history I put together that documents the evolution of the A22 engine, from its humble physics test beginnings, to its full-fledged engine status today.

The Concept Test
The first iteration of the (eventual) A22 Engine was the concept test I wrote up in a class period last year. Essentially, I wanted to see if the 2D heightmap was feasible (given my experience), and to start a codebase for my eventual project (at this point I had no idea). As you can see below, this was a relatively simple program, which generated heightpoints at random, and drew them on the screen.


Interesting Note: I have yet to touch that initial heightpoint code, it worked fine then, and it works great now...

The Extended Concept Test
After I was content with how well the Concept Test was working, I decided to start extending the test and including some basic stuff you need in a game. First off, I created way to color in the heightpoints, and thanks to OpenGL's built in shading model, it looked pretty good... Ok, it looked better, as you can see below:

The next step involved figuring out how to decide if something has collided with the heightmap. This finally came to me when I was at work one day. Essentially, whenever an objects wants to know if it has hit the ground, it fires a vertical line down it's xposition. Then, a line intersection test is performed, and the yposition of the intersection between the vertical line, and the segment of heightmap below it is returned. Then, the object checks to see if it's yposition is greater than the intersection yposition (ie. the object is above the heightmap), or else it is below the heightmap, and can act accordingly. Thats a pretty odd explanation, so I drew up this diagram:


The Physics Test
Now that I had a way to properly test collisions in the heighmap, I decided my next course of action was to get some bouncy physics working. Luckily, I was taking Pre-Calculus at the time, and we just happened to be going over vectors, so I had all the know-how and formulas I needed to get the bouncing stuff to... bounce. I created a new object called a "Chunk", which would fall from wherever it was dropped, and bounce once it hit the ground. The neat thing about these objects was that they bounced according to what type of slope they hit, so if a chunk hit a steep slope, it would react differently from if it had hit a shallow slope. I threw these into the game, and let the player spew these chunks from the mouse's location.
Interesting Note #2 I haven't touched the physics code either[grin]

Here's a screeny showing the flaming "chunks" on the heightmap....


The First Game
It was at this point that I came up with my first game idea that would utilize the growing A22 Engine (or as it was called then, the Dogfight Engine). This game was called "Partisan 3", or "Partisan Online", or "Dogfight Online"... we never really decided on a name, but the game was essentially a simple networked multiplayer version of Angels 20, ableit with the heightmap terrain I had been working on. The whole game was created without any actual textures, everything was just different colored primitives, which meant Mark was out of a job for awhile[grin] Eventually, I got the game to a working state, and we played it quite a bit for a couple days at school, but the code was crappy, the game was laggy (even on the school's LAN), and it really wasn't that fun, so we scrapped the project, but as you can see in the screen below, it was actually starting to come along nicely...



The beginning of Angels 22
After I scrapped the multiplayer game we were working on, I took a break from the Dogfight Engine, and Mark and I worked on our Space Strategy Game: Axis Shift. On the side however, I was extending and modifying the Dogfight Engine to create one of my dream projects, a 2D "Crimson Skies"-type game. I had added support for trees and buildings, and I had also created a new technique to texture the heightmap with, which is described in the diagram below:

With my new terrain in place, I began creating an algorithm that would randomly generate terrain. I never got that far, and it never really progressed past looking really jagged, but it allowed me to mess with the engine and not worry about making a new level everytime I added something new. Axis Shift was still our main project, so I was on my own when it came to drawing up images for the game (Mark was still pumping out spaceship textures for AS), and it really showed in this version, although I was starting to like the simple look of the game. It was in this iteration of the engine that I started making some of the cool features that are now prevalent in the Angels 22 Engine, such as modular weapons objects, hardcore polymorphic design, and the use of STL components. It seemed like I was making cool new features everyday, such as the Runways, Bombs, Animations, and even stuff that acted behind the scenes, like a TextureManager class that I've been using ever since. I was creating cool weather effects like a madman, and the engine was growing greatly in size daily. I even created an underlying Network engine called DENet (Dogfight Engine Network), and Mark and I even played some multiplayer games over the actually internet (DENet is still built into the engine, which is good news if we ever want to make A22 multiplayer....[grin]). Everything was coming together nicely, and then, it all stopped. I hit one of those development ruts, and I didn't touch the thing for weeks. It took the announcement of the new 4E5 elements to really kickstart the development again...

Dogfight Engine as it appeared before I stopped working on it...


Angels 20 II
After the elements were announced, Mark and I were talking on the phone about if we wanted to do it or not, when one of us(I don't remember who) mentioned re-doing Angels 20 and making it fit with the 4 elements. Well, this set both of us off, and we began one of those "Holy Sh*t you know it would be awesome if...." conversations, which went on for about an hour. We finally decided that if we were going to make a sequel to Angels 20, we would have to go back, and fix everything we had done wrong, and do everything we wish we had done with the original concept. Luckily for us, we had a working engine sitting on my HD, just waiting to be used, but the one thing we didn't have was a name. Throughout the entire conversation, we kept calling the game "Angels 20 II", as in "Angels Twenty: Two". We decided that this was really annoying (Rainbow Six: Three anyone?), so we condensed it into Angels 22, and the name stuck. As it turns out, the Dogfight Engine was exactly what we needed to expedite development of Angels 22, as Angels 22 was essentially the 2D Crimson-Skies game I always wanted to make, albeit with high-performance jets instead of cool retro 1930's airplanes. Now that Mark was on-board, I could finally start getting rid of my crappy/nostalgic graphics, and replace them with Mark's incredibly detailed works of pixel art. It was at this point that we seriously started development on Angels 22, and we shelved Axis Shift to work on our new project. At this point in development, stuff was still getting completed at an extremely fast rate, I created a Level Editor in a day, Mark was drawing up incredibly detailed graphics at an unbelievable rate, and everything was going great.

One of my favorite screenshots from the early Angels 22


Angels 22 Today
As of today, Angels 22 is quickly progressing from "cool screenshot generator" to "playable game". There are 24 generic types of objects that can be put in the game, including Airplanes, Helicopters, Trees, Buildings, Flak, Ships, etc, and each type has many different sub-types associated with it (ie. we have over 20 different types of tree to choose from). We have a simple scripting language I wrote that allows us to do all kinds of cool stuff, from cueing dialog, to spawning enemies. The source code is over 16,000 lines long and consists of over 120 source files. We have a working Level Editor that allows us the freedom to create a map, play it right after, and tweak it as we play the map. All in all, the project is coming along extremely well, and hopefully we can finish it in time to enter it in the 4E5 contest. Thanks for reading this not-so brief history of Angels 22, the support we recieve from the gamedev community is what keeps us going... that and Mountain Dew[wink]

Angels 22 as seen today...




The Carrier Part II
My project as of late has been getting the Aircraft Carrier logic to work, and I'm almost done with it. The Aircraft Carrier acts as your mobile airfield, allowing you to rearm and get repaired, even if your mission takes place far from a friendly airfield. While the Carrier in Angels 20 allowed you to land and takeoff vertically on it, the new jets in A22 lacks this ability, so you must land conventionally, and catch a wire with your tailhook. I know some of you are thinking, "Oh hell, I can't even hit the damn flak with a bomb, how am I supposed to land on a little aircraft carrier...", well don't worry. We have visual cues for you to fly through, and a flightpath line that allows you to see where you are going to land, so the whole procedure is relatively easy. Once you land on the carrier, you cease to be able to control the plane, and it is rolled back, and taken down an elevator to the bottom of the ship. At this point, a dialog pops up asking you whether you want to change your loadout, or just takeoff. If you choose to change your loadout, you go to the weapons select screen, and if you choose to takeoff, your plane goes back up the elevator, and automatically gets ready to launch. At this point, the aircrafts wings unfold, and the blast deflector comes up on the carrier. You then initiate the launch by pressing the up button. The carrier then launches you off the flight deck, and automatically climbs the plane, and retracts the landing gear, before you are allowed to fly the plane. It's a pretty complex process of paper (and in code...), but its really straightforward in game, as you can see in this video I took earlier in the week (Note the lack of blast deflector, and dialog box)

Carrier Landing and Launching

Recording the Game
This has been my side project since yesterday. I was playing IL2 Sturmovik (the greatest flight simulator of all time[grin]), and I realized how cool it is to be able to record a mission, and then have it play over again like a movie, so I got to work planning a way to implement it in A22. I haven't gotten very far, but as soon as I do, you'll be the semi-first to know!

Well, thats all I've got for you guys right now, check back soon and I should have some cool new features to talk about, Peace Out!