chris pruett projects | personal | games | links  

Professional Projects
Spider-Man 3 PS2/PSP/Wii (2007)
X-Men Legends 2 PSP (2005)
Spider-Man 2 PSP (2004)
Brother Bear (2003)
Finding Nemo (2003)
Crash 2: N-Tranced (2002)
SpongeBob Squarepants (2002)
Frogger Advance (2002)
Crash Bandicoot (2002)
Power Rangers Time Force (2001)
   Personal Projects
Horror Game Demo (2004)
Voxel Engine (2002)
JamMaster (2001)
C Compiler (2001)
Pfhortran Scripting Language (2000)
Marathon Process Manager (2000)
x86 Assembler (2000)
3D Chess (1999)
SortWatch (1999)
Fire Screen Saver (1999)
Bakudanjin (1998)
STLI Edit (1997)

Spider-Man 3 Wii Box Spider-Man 3 PS2/PSP/Wii     Spring 2007
Spider-Man 3 was a large project. I acted as the West Coast Lead Programmer, and was responsible for implementing a variety of systems, notably player handling, animation, and asset conditioning. I spent a lot of time writing Spidey's swinging system, which was designed to subtly change behavior depending on the way the player was moving through the world. As a lead, I was also responsible for running a team of other programmers. At peak, I had about twelve guys reporting to me, which was a much larger group of people than I've previously managed. Spider-Man 3 was met with pretty mixed reviews, but the swinging system was one of the things that most reviewers enjoyed, so I feel pretty good about my work on the project.

X-Men Legends 2 PSP Box X-Men Legends 2 PSP     Spring 2005
Created by Raven Software using VV's Alchemy graphics technology, X-Men Legends 2 is an excellent RPG/brawler. Our task was to port the game to PSP and add content (new levels and characters) to Raven's game. My job was to optimize the game data so that the original Playstation2 assets could be used on the Playstation Portable. This was a difficult and frustrating task, but in the end the game turned out pretty well. Gamerankings shows an aggregate review score of 86%.

Spider-Man 2 PSP Box Spider-Man 2 PSP     Spring 2004
I only had one task on Spider-Man 2 PSP: I wrote a boss fight between Spidey and The Vulture. Still, this project was interesting because I got to work with somebody else's AI system. It's also nice to be able to say that I worked on a PSP launch title, even if my role was exceedingly minor.

Brother Bear GBA Box Brother Bear     Summer 2003
Hot on the heals of Finding Nemo, I went to work on another animated Disney property: Brother Bear. As lead programmer on the project, I ended up touching almost all of the game systems in one way or another. For this project we were able to develop some cool new technology, and I spent a lot of time integrating this tech with the handling and AI.

Nintendo Power gave Brother Bear a 3.3 out of 5, and GameZone Online gave it an 8 out of 10.

Finding Nemo GBA Box Finding Nemo     Spring 2003
Finding Nemo was an interesting project. In addition to incorporating visuals and plot elements from Pixar's film, we needed to create a game that was both non-violent and challenging. My role on Finding Nemo was as a game play programmer; I developed the player handling, AI, and mini games.

Nintendo Power gave Finding Nemo a 3.8 out of 5. I am very proud of this game: it has sold over a million copies since its release.

Crash Bandicoot 2: N-Tranced     Fall 2002
Crash 2 was my second project as a lead programmer at Vicarious Visions. Building off of the first Crash GBA title, we were charged with adding a bunch of new features and options. We ended up creating all new levels, enemies, and crate types, new multiplayer games, a realtime 3D Atlasphere game mode, improved handling, a new level progression system, new playable characters, and new vehicles for Crash to ride around in.

I had a good time with this project because it allowed me to explore AI and handling design in detail.

SpongeBob Squarepants: Revenge of the Flying Dutchman     Summer 2002
Ok, so my role in SpongeBob wasn't as large as in Frogger or Crash 2, but I am very glad I got to work on this project. Developed at Vicarious Visions, Inc., SpongeBob's second GBA title rocks.

My duties included engine maintenance and updating, AI system support, and simple game mechanics work.

Frogger Advance: The Great Quest     Spring 2002
Frogger Advance is a Game Boy Advance title based around Konami's Frogger licence that was developed by Vicarious Visions, Inc. I acted as the lead programmer on the project, developing the game logic and mechanics, character handling, AI system, visual effects, game progression, and several of the boss encounters. This was an interesting project because it is a departure from previous Frogger games: instead of the top-down street crossing mechanic Frogger is famous for, we were asked to develop a side scrolling platformer. The end result was a pretty cool adventure game aimed squarely at kids age six to ten.

Frogger received a 7 / 10 score from, and a 8 / 10 at Frogger also received the All Star Award from the Children's Software Revue magazine, a bimonthly magazine the focuses on software for children.

Crash Bandicoot: The Huge Adventure     Spring 2002
Developed by Vicarious Visions, The Huge Adventure is the first Crash Bandicoot game to be developed for the Game Boy Advance. My role in the project included boss AI programming, character handling improvements, background animation implementation, cut scene progression logic, and a Japanese localization system.

The Huge Adventure received very high praise from a number of reviewers. The game scored 9 / 10 at, and a 7.4 / 10 at

Power Rangers Time Force     Fall 2001
My first project a Vicarious Visions, Power Rangers Time Force was a neat way to get aquatinted with the GBA hardware. The game itself is a side-scrolling action game, reproducing characters from the TV series. My job was to create a couple of boss encounters and to make the introductory animation sequence. I also was in charge of localization of the game into several different languages.

Horror Game Demo     Spring 2004
Those who know me know that I am a die-hard fan of horror games. In 2004 a friend of mine and I decided to throw together a basic horror game engine to see how hard this format of game might be to build. We dubbed our demo Terminal Station after a 1954 film by Vittorio De Sica. We were working in our free time, off the company clock, so in total we probably spent around three weeks of work on this project (over the course of two months). In the end we had a pretty cool demo: a character who could walk around a series of rooms, complete with camera cuts, tracking cameras, film grain, Devil May Cry-style controls, point lighting, and shadows. The demo ran on PC and PS2 (total frame time of 4ms!) with place-holder art.

Nothing ever happened with the demo after that--it remained just a tech demo. But I did learn a lot about how third-person adventure games, particularly those with fixed camera systems, might be built in a very short amount of time. I'd really like to work on this style of game for real one day.

  • Check out screenshots of Terminal Station in action: 1, 2, 3, 4, 5
Voxel Engine     Summer 2002
All programmers, especially game programmers, are required to write a voxel engine once in their life. This is mine. It was ok, but it never really took off. Later versions had a sky box.

JamMaster     Spring 2001
I built JamMaster with a friend for an interface design class. We combined MacZoop, a cool MacOS application framework, and GLaM!, an example program for animating Meshwork models in OpenGL, to make an "interactive dance simulator." Since this was for an interface design class, we only spent enough time to get the basic controls working: many of the dialogs and text boxes are just for show. However, the program does allow you to select a dance and watch the model perform it. The camera controls also work, so you can spin the character around and step through each keyframe in the animation. In addition to being a fun project and a chance to work with OpenGL, JamMaster also allowed us to make fun of a particular teacher, which was really invaluable.

    C Compiler     Spring 2001
Another school project, I implemented a C compiler to match a spec provided by the course instructor. Written in C, the program parsed a simplified C grammar and generated "quad" pseudo-instructions. The quad file could then be run through an interpreter and executed.

Though my implementation did not cover the entire C grammar, it correctly generated quads for array referencing/assignment, variables, functions, logical operators, ifs, fors, local and global scopes, and the basic arithmetic operators. Writing a compiler taught me a lot of cool stuff about C and was a fun and difficult project.

Pfhortran Scripting Language     Summer 2000
Pfhortran is a simple scripting language built on the Marathon Open Source Engine. Marathon is a game engine by Bungie Software (now Bungie Studios) that was released as open source in early 2000. Pfhortran allows map makers to exercise precise control over the camera, game environment, and player information as the game is played. Written in C, Pfhortran is now part of the Marathon CVS code, which is commonly known as Aleph One. Pfhortran's language features include relative jumps, variable management, camera animation and interpolation, and fast execution. Finally, an complete manual and tutorial for beginning Pfhortran scripters is available at, the Aleph One Project hub site.

Marathon Process Manager     Spring 2000
Another project based on the Marathon 2 source, Marathon Process Manager is an attempt to implement a Macintosh version of Dennis Chao's Doom-based process management system for Linux (which can be found at The idea is that each process running on the machine is represented in the game world as a monster, and that by killing the monster the player also kills the process associated with it. Though not quite as effective as Chao's implementation (due mostly to the cooperative multitasking nature of pre-OS X Macs), Marathon Process Manager works pretty well.

Marathon Process Manager was written in Spring 2000 for an Operating Systems class at Pacific University.

    x86 Assembler     Spring 2000
As the main focus of a System Design course in early 2000, each student wrote a two pass x86 Assembler. Though the basic lexicon, directives, and object module layout were decided by the class as a whole, actual design and implementation of the assembler was an individual project. Our lexicon supported most of the basic 286 assembly instructions, and our object module structure was a simplified version of Microsoft's .obj format generated by MASM.

My implementation was able to build object modules from simple assembly source that could be linked up into an executable by Microsoft's Link. As long as the source was relatively simple, my assembler was usually capable of parsing the assembly and outputting an accurate object module file.

3D Chess Demo     Spring 1999
A project that never got finished, 3D Chess Demo was my first foray into 3D. Using Apple's QuickDraw 3D API and the Queeg game development library, I attempted to build a simple 3D Chess game. I modelled chess pieces with the excellent tool Meshwork, and wrote enough code to move a single piece around on the board before I quit.

SortWatch     Fall 1999
I wrote SortWatch in the fall of 1999 at the request of one of my computer science professors. We were in the middle of an algorithms class and the teacher wanted an application that students could use to visualize how various sorting algorithms worked. The students wrote the algorithms such that a data file showing the data set at each step in the sorting process was output. SortWatch took this data file and graphed it on the screen for the students, allowing them to observe the differences between Quicksort, Mergesort, Heapsort, Shellsort, or any other kind of sorting algorithm they could come up with.

SortWatch was written with RealBasic, and was developed in about 4 hours. Thanks to the versatility of RealBasic, SortWatch runs on both Mac and Windows platforms.

Fire Screen Saver     Fall 1999
The Fire Screen Saver was written as the final project in an x86 assembly class at Pacific University in fall 1999. The executable generates algorithmic fire using a method similar to Brian Stone's Campfire averaging example. The program also read simple data files off the disk, and suggested that the teacher of the course be "fired."

Bakudanjin     Fall 1997 - Fall 1998
Bakudanjin is a game I wrote with a couple of friends back in 1997. I wrote the game engine, Genki Mine and Sean Robitaille drew the graphics, and Andrew Leung created the music. The game is very reminiscent of Hudson Soft's Bomberman series, but it has some unique twists and stands on its own. Thanks to school and such, Bakudanjin took over a year and a half to complete, though most of the core graphics and code were finished in the first two weeks.

Bakudanjin was written in Pascal, and was the first big project that I actually finished. Bakudanjin is now for sale as a shareware product on our web site. If you have a Mac, you should check out the demo.

STLI Edit     Spring 1998
STLI Edit is a very simple application I whipped up in the spring of 1998. At the time I was very interested in hacking Bungie Software's Myth game files. Myth uses a complicated patch system, where small patch files containing headers and data can be used to override the normal Myth game data. Though everything from monster animation and movement to the layout of the map can be changed, STLI Edit was built for the sole purpose of editing text string patches.

STLI Edit became quite irrelevant when Bungie released their game building tools along with Myth II. You can check out the (incredibly out of date) STLI Edit web site and download it if you like, but unless you are into hacking Myth I, it won't do you much good.