Projects by JT Schafer

Tea Time (2014)

Recently I decided to learn Unity3D because I needed a cross platform engine for a future project. Tea Time is my currently my work-in-progress game as I learn the engine. Tea Time is a wave based co-op first person shooter which takes place on a rooftop in New York City. Successive waves of alien ships spawn at the edges of the map and make their way towards the players. The game currently has 25 waves and will have more variety in the near future as I add more enemies and implement the tea consumption mechanic.

I created all of the models for the game using Lightwave 3D and Sculptris. The textures were generated procedurally with MaPZone and the lightmaps were baked in Lightwave.

The free version of Unity does not allow for a very wide range of effects but does allow the use of custom shaders with materials. Tea Time uses an entirely custom set of shaders which I wrote for simulating the rain effect. I wasn’t able to use any post processing with the free version but I managed to get around that limitation and implemented raindrops on the camera lens by using sprites and additive blending.

Since Unity supports web deployment, you can play the work-in-progress version in a browser here.

Silo (2012)

For a software engineering class at Johns Hopkins University, I worked with a team of five to build a first person puzzle/horror game called Silo on a custom engine. The instructors called our final product the most impressive project they had ever seen in the course. Silo is based around the collection and dispersion of light in the game world. The player character has an item which is able to gather light from sources in the game and place that light in other areas. We use this mechanic to construct puzzles using surfaces that are only visible in either light or darkness. We also have glass which prevents collecting light but does not prevent light shining through. There are also monsters in the game which will avoid light. Since there is no combat in the game, the player must use light defensively as well as for solving the puzzles. The monsters will kill the player on contact.

This project was for a software engineering class so we came up with a very flexible component based design for our engine. Our game editor allows the user to build entities by selecting components and editing their properties in real time. The editor saves text files that allow multiple people to collaborate easily on levels through subversion.

Since the game is based around the manipulation of light, I decided to build a deferred renderer to efficiently handle the variable number of lights. The game also has glass refraction and volumetric light effects so there are multiple rendering passes that occur after the initial deferred rendering that get composited in based on depth.

You can visit our page on the JHU course website here.

Zombie Wrangler (2012)

I built Zombie Wrangler with a team of two other programmers and one artist for a video game design class at Johns Hopkins University. In the game, the main character Dr. Grudge has accidentally created a virus that has zombified most of the population. He is exiled to a zombie quarantine area for punishment but he escapes by using his own zombies as a weapon. The gameplay is focused around luring these zombies to the player to gather an army. The zombies can be used to attack foes such as bears and hillbillies. This causes the enemies (even the bears) to become zombified and join your army.

The design off the game called for hundreds of characters interacting with each other on screen at once. We addressed this with very efficient collision detection and AI systems. The zombies can easily navigate through the world by querying the terrain for information about slopes, obstacles and other characters in the area.

The game editor makes it incredibly easy to create and play a level. The world is defined by terrain points which can affect the type of terrain in a varying vicinity. The user can select different terrain effects like ice or toxic waste and can adjust falloff and noise levels per area. This all happens in real time. Entities can be dragged and dropped into the world. The editor also includes a wiki browser which automatically populates with information about the properties of the selected entity.

Even though zombie wrangler is a 2D game, we decided early on that we wanted a full 24 hour day/night cycle with shadows varying accordingly. Zombie wrangler actually allows the placement of lights in the world that support full 3D normal mapping in the 2D world.

You can visit our game wiki here.

Waddy (2011)

I built Waddy with two other programmers and an artist for the introductory video game design course at Johns Hopkins University. It’s a simple top-down shooter with the twist that about half the game takes place in the complete dark. The player is a dolphin named Waddy who has the ability to use echolocation to see in these areas. Waddy has escaped from a government run dolphin training and weaponization facility and is on a search to find his family. During the course of the game he encounters many submarines and sea monsters.

The echolocation mechanic works by illuminating an expanding area around the player for about a second. Some enemies charge their attacks, creating a bright light that can be used to evade them. Other times the player must use the sonar to avoid running into hidden enemies.

The game design course required us to build our game using pygame which doesn’t support lighting effects. We were able to get around this by using some tricky blending techniques and image processing to emulate a full lighting system in pygame.

I also composed the soundtrack for the game which you can find on our development blog here.

The Second to Last Stand (2010)

I built The Second to Last Stand for Microsoft’s Dream Build Play competition. It’s a third person action game that runs on Xbox 360 using XNA and is designed for local co-op play. The game uses the player’s Xbox LIVE avatar as the main character and gives them ridiculous weapons such as massive hammers, banana peels and jars of scary spiders.

The game uses real time area lighting on Xbox 360. Enemies use A* pathfinding to navigate through the world. The game supports in-editor scripting through the use of trigger areas which can activate or deactivate entities.

Enceladus (2008)

Enceladus was my attempt at a survival horror game for Xbox 360. I entered it in the 2008 Dream Build Play competition. It didn’t succeed in being scary but it did succeed on a purely technical level with the implementation of my first deferred renderer with advanced post processing and some early experiments in AI navigation.

The game was originally designed to have an in game computer system using a real emulator for a custom architecture. I built the emulator along with an assembler and an extremely simple compiler but the feature never actually made it into the gameplay.

Space Planets (2008)

In 2008 before I fully started working on my actual Dream Build Play entry (Enceladus), I experimented with making a real-time spaceship strategy game where the player also had a more powerful, directly controllable spaceship that could be used to sway the outcome of a battle. The player’s ship is responsible for issuing orders to the other ships and stations. The player can perform special functions that are only available when navigating to the area using their personal ship. I might revisit this game in the future to add online multiplayer so that there’s someone to fight in the game.

Space Planets uses a real-time volume raytracer to render the ships. The reason for this is to allow real-time damage maps to uniquely affect the appearance of ships in the game. It also allows the ships to be modeled with many millions of polygons and then baked into a texture. In Space Planets, ships don’t have health numbers. Instead their functionality is determined what percentage of the ship’s surface area has sustained damage. The player can judge the health of a ship simply by looking at it.

BAUNDO! (2007)

BAUNDO is a physics based platformer for Xbox 360. One of the first games I ever made when I was a kid was an extremely simple platformer with a blue ball navigating through a maze. Over the years I would occasionally remake that game again and again with better controls, level design, graphics and physics. BAUNDO is the fifth version of that game.

It now has a 4-player arcade mode with many competitive, cooperative and mixed minigames. It has a 15 level campaign with drop in and drop out co-op support. It also includes an in-game level editor where all 4 players can test levels. The game can also randomly generate many different types of levels and populate them with powerups.

The Peanut Butter Hunter (2006)

The Peanut Butter Hunter was the first 3D game I built on my own engine. It’s the “tie-in” game for a 3-minute home movie of the same name. The game is a linear first person shooter where balls of peanut butter attack the player at all times. The game includes a few very cool weapons like the black hole gun (a gun that launches mini black holes that suck up everything around them but miraculously bounce off of walls), the ULR (shoots through walls), hyper grenades (cause an explosion the size of a large room) and bouncy ammo (can obliterate enemies by ricocheting off of walls at a rapid rate).

Back in early 2006 the game’s rendering engine was very advanced. It utilized normal mapping on all surfaces and even rendered peanut butter balls and explosions volumetrically. The levels were actually designed pixel by pixel in MSPaint where each pixel represented a 1x1 meter area of the floor and the color of the pixel affected what would be in the part of the level. The game was able to stream different areas of the image and create level geometry from them.