Thomas Jones

TEK

TEK is a two semester project currently under development since Sept. 2008. There are four programmers, including myself, as well as three artists working on the project. TEK introduces a unique new control scheme for manipulating a melee weapon in combat. Slashes are created by mouse motions, and the direction the mouse is moved when attacking translates into a slash vector in that direction within the game. By holding the attack and moving the mouse, the slash direction can be altered. The same is true for blocking, in which holding the block and moving the mouse in the direction of an incoming block will result in blocking the attack. The animation is procedurally generated with inverse kinematics, and the collision is per body part. Thus, there are no issues with animations getting out of sync with the underlying logic, what is visible in the animation directly reflects the underlying physical representation. The game itself comes in two modes: Gladiator mode consists of continually fighting more difficult waves of enemies while King of the Hill involves attempting to capture and maintain some position in the world.

My role has been that of lead designer and lead programmer. I have been responsible for the low-level system implementations for input, serialization, graphics using deferred shading, particle systems, core architecture, object management, ensuring compatibility between modules, and interface-based propagation of subsystem events. I have also architected the component system in which child objects can easily attach to parent objects and maintain their own local transformations. Furthermore, I created internal utility structures such as delegates, timed functions, and game iterators to make coding the high-level behaviors of the game easier for all the team members. Finally, I have designed and coded the HUD and a good portion of the high-level fighter and weapon logic.

More info, screenshots, and videos can be found at the TEK webpage.

Features:

• Third-person melee combat with unique mouse-driven control for specifying attack and block directions.
• Gladiator and King of the Hill game modes.
• Deferred shading with normal mapping, post processing.
• Component-based, data-driven architecture with data-inheritance.
• Procedural animation through inverse kinematics.
• Newtonian physics and ragdoll simulation.
• AI A* pathing, formations, and state machines.

Drones

Drones was a semester-long project from January to April of 2008 in which myself and three other teammates designed and implemented a game up to a first-playable version. The idea for what would eventually become Drones began as an idea of mine for intuitively controlling multiple units quickly and easy in an RTS setting a few months before I began attending DigiPen. The main idea was to use a gesture-based selection and pathing system in which the user would draw a selection area and then a path for the selected objects to follow, similar to if one was selecting objects on a sheet of paper. One of the main design challenges was attempting to create a game to showcase this new mechanic, and ultimately we focused on a topological puzzle-based approach in which the point of the game is to progress the drone units through an environment consisting of locked doors. The player could hold some doors open with some drones while gaining access to other buttons to hold doors open to allow the first group to pass.

My responsibilities in this project were as the technical director, in which I created the rendering system, high-level serialization and object creation system, a component-based game object architecture, input system, menu, and game-state systems. Also, as the designer of the control mechanic, I was responsible for implementing the gesture selection and path creation as well as the underlying flocking mechanism of the units as they traversed the path. Since my time and effort was divided among so many tasks, I was not capable of fully fleshing out the gesture mechanic fully. As such, it is a topic I plan on returning to in the near future for my own personal project.

Features:

• Intuitive, gesture-based object selection and movement.
• Shader-enabled rendering using DirectX 9.
• Component-based, data-driven architecture.
• Translational physics using Axis-Aligned Bounding Boxes.
• Level editor, allowing to easily modify level geometry.

Recursive Ray-Tracer

The ray-tracer was written over the course of an entire semester and was developed incrementally. The first step was to get the inital framework set up and the initial shape intersections working, with no concern for illumination or recursion. Next, global and local illumination were implemented. Local illumination consisted of determing diffuse and specular lighting on a surface, given that the surface was not shadowed. Global illumination took the form of recursively applying reflections. Transmission and refraction were implemented using the Fresnel equations in order to accurately model the contributions due to transmission versus reflection. The final step was to implement anti-aliasing and extra features. The extra-feature impelmented here was constructive solid geometry, the ability to apply boolean operations on sets of simple shapes to form more complex ones.

It was important for me to quickly be able to modify external options for testing the ray-tracer, so I opted to use .NET WinForms as the GUI frontend for the ray-tracer. The frontend was created quickly in Managed C++, instantiating and communicating with the native ray-tracer library through interop. A separate thread is created to render the scene in order to prevent the frontend from locking up while waiting for the scene to finish rendering. Ultimately this allowed me the freedom to add new GUI options very quickly, and eventually I was able to add extra GUI features such as the ability to pop out the current scene into another window, save the scene as an image, and debug a given pixel's color at each level in the recursion.

Features:

• Various primitive shape intersections: sphere, ellipsoid, box, polygon.
• Constructive solid geometry: boolean operations on collections of shapes for differences, unions, and intersections.
• Transmission, reflection, refraction, and attenuation.
• Anti-aliasing through uniform and jittered super-sampling.
• Robust front-end WinForm allows for easy loading of scenes, saving the rendered image, re-sizing, and setting options.
• Pixel debugger outputs the data for each recursion and final color of a clicked pixel.
• Native C++ library interacting with Managed C++ WinForm frontend via interop.

Tera One

The second game-related task assigned was to create an engine proof for a 2D platformer with one other teammate. This project was also to be completed using XNA Game Studio Express for C# for its rapid development time and ease of use and was created in just over a month. I approached this project with the intent of creating a generic 3D engine framework that I could use the following semester for a more fully-fleshed out game. Ultimately, my teammate and I strove for more than just an engine proof and produced what more resembled a first-playable. I ended up implementing most low-level systems such as object management, physics, input, and overall architecture while my teammate focused on the higher-level gameplay and visuals.

Features:

• Underlying 3D framework.
• Translational physics using Axis-Aligned Bounding Boxes.
• Ability to rotate the world.
• Editor mode - allowed placement of arbitrarily sized platforms and enemies.
• XBox 360 controller support.

Beshaped

Bejeweled is a casual puzzle game in which the user uses the mouse to swap two particular objects in an attempt to get 3 or more of the same object in a row, at which point the pieces disappear, points are awarded, and more jewels fall in place. One of the first game-related tasks assigned was to recreate Bejeweled, my version of which I dubbed Beshaped, using XNA Game Studio Express for C#. It was created over the span of about three weeks.

Features:

• Strongly object-oriented.
• Multiple playable boards.
• 2D and 3D jewel-tokens.
• Smoothly interpolated motion, scaling, and text.
• Detects no-more moves / game-over case.
• Editor mode - allows arbitrary placement of pieces for robust testing.

Download the executable here. Source code samples are available upon request.