Name:	Jordan Massey
Position:	Technical Director
Website:	http://www.jdmassey.net
Email:	jmassey@digipen.edu

Jordan is the team's Technical Director. This project is his third consecutive project as TD. One of his main responsibilities was maintaining the fabulous Helios engine which parabellum was built on. This engine was created over a year ago by Jordan and Derrick for Dusty, their junior game, and was carried over to use for Parabellum. Some of the updates to the engine included removing all the old, unused modules, and adding features to the renderer such as HDR post processing for bloom effects.

Jordan's largest contribution to Parabellum is the M-system technique used to represent and grow ships procedurally, using a simple database of parts describing their shape and where they can link, and a set of rules describing which parts may link to one another. This system was based largely on L-systems, a simple rule system originally used to model the growth of organic lifeforms like plants. A cool demonstration of animated L-systems can be found at L-Garden, a site that couples L-systems with genetic algorithms to try to create sweet looking plants. Unfortunately, due to large-scale and frequent changes to the design of Parabellum throughout the months of its development, M-systems ended up not seeing much use. The full system still exists in the game engine, but is currently only used to grow a simple snake that adds new parts one by one at the tail. Still, it was an enjoyable challenge to implement.

In addition to M-systems, Jordan's other implementations include deferred shading, fog rendering, and the game's world editor tool. Deferred shading allows many small lights to exist in the scene at once, which provides the perfect atmosphere for Parabellum as it allows all of the fireflies and plants and anything else we feel like to cast light and really bring the environment to life. The world editor is simply a program written entirely using the game's engine, with a windows dialog box for interacting with game data. It's currently the longest file in the project at 2,894 lines. Whoo!

Name:	Derrick Readinger
Position:	Designer
Website:	http://www.unwieldyfork.net
Email:	dreadin2@digipen.edu

Aside from handling the design aspects, Derrick is in charge of many programming aspects of Parabellum. Derrick helps maintain and extend the core game engine from the previous year (Derrick is extremely proud of his command-based input subsystem). Derrick is also in charge of writing the AI architecture, steering behaviors, physics, and game play features.

The largest contribution Derrick made to the project is with his behavior tree API. Behavior trees are a hierarchical form of reflexive logic that promotes code reuse and modularity in agent architecture. Basically, that boils down to linking simple actions (like follow, reach, wait, etc.) in a tree-based fashion. The actions should be written generically enough that each action can be plugged into any agent tree at any point and run successfully for the duration of the AI. Unfortunately, no editor was ever programmed, so that meant the agent logic was built in a C++ file with a tree builder which made heavy use of templates, however, given the simplistic nature of Parabellum, this was not a hindrance.

By far the coolest thing Derrick contributed to Parabellum is the environmental ambience achieved through the growing plants, seaweed and jellyfish.

The plants are defined as a set of control points (generated from sine curves, golden spirals, and spirals) and nodes which represent branches and junctions for the plants. The only rules for the plants are as follows: the root of the plant must be a junction; junctions may have an arbitrary number of branches as children; branches may have an arbitrary number of branches or junctions as children. By using the aforementioned rules and applying hierarchical transforms to the branches and junctions, the plants can grow, animate and illuminate the world of Parabellum.

The seaweed and jellyfish are created in a similar fashion, except instead of being rigid entities with predefined animations; these entities use spring physics to achieve fluid motion within the world. This form of procedural animation gives both the ambience and game play a huge boost. Watching these entities wiggle and wobble is always entertaining.

Name:	Jason Kilkenny
Position:	Producer/Product Manageer
Website:	http://www.jasonkilkenny.com
Email:	jkilkenn@digipen.edu

Jason is the team's Producer and Product Manager. As the Producer, his job was the manage the team and schedule to get the product out in time for Gold submission as well as lead presentations. As the Product Manager, he managed play testing and assets. He also helped with updating the Helios engine by replacing the particle engine with one that could support many more particles, as well as making it data-driven.

Jason's largest contribution to Parabellum is the spline renderer used by a majority of the entities within the game. It uses triangle strips to draw smooth Bezier splines, allowing the creation of beautiful art without actually having artists. Originally, this system was meant to be used for drawing 'sticky' lasers that would attach onto enemies and bend based on the player's and the enemy's movement. After going through some design changes and from playing with what this system could do, we realized that it made really cool art similar to vector graphics and decided that the 'trees' made with the splines should attribute to the overall design. From there, we ended up with what we currently have. This technique was actually quite simple to implement and was easy to extend to get more functionality out of it.

In addition to the spline renderer, Jason also created a data-driven weapons system used in the initial game design as well as some of the enemy AI, using Derrick's Behavior Tree implementation. He also created the Genetics system, which would have been used to make the game a new experience with each play. It's purpose was to select the enemies that did the best in the last generation by weighing attributes, combine them together in different ways, and use those 'offspring' as the next generation of enemies. As the game went in a calmer direction, the need for this system went the way of the Dodo. Maybe next time!