Adam
Holcombe
Adam
Holcombe
Embark on an adventure of discovering and identifier plants, navigating with map and compass, and face off against your arch-nemesis, Dr. Parsnip. This educational game was made for a class at University of Wisconsin - Stout.
Trapped at the bottom of a large cenote, basically a pit in the ground, you must find a way to climb out. But soon you'll learn starving isn't the only danger to you as lava begins to fill the cenote. Rush to the top as quickly as you can before you reach certain death from the lava. No two playthroughs will be identical, as the cenote is procedurally generated each time.
Zipping around the galaxy isn't all fun and games. Sometimes you just have to erradicate a peace loving space police. Destroy your enemies, upgrade your ship, and most importantly, achieve Full Steam mode.
Steve is a ghost, and like all ghosts, he loves to garden. Unfortunately, evil forces are taking control of his plants if he's not careful enough. Control Steve, and rush to take care of his garden before the inevitable evil forces can overcome you.
Command your legion to victory in this battle for the most coveted base in the war. Fight your rivals for ultimate control by taking over the control points and holding them against your opponent. Strategize to win, using the terrain for ambushes and reinforcement. Only the best commander can win. Video demos of our current progress can be viewed here.
Immerse yourself using the Oculus Rift as you are trapped inside of an ancient school, but you are not alone. Becareful, because around any corner there could be a monster lurking, one that can search you out by smell alone. This game was made for the Global Game Jam 2015. Supports the Oculus Rift Dev Kit 2.
The Genesis Engine is UW - Stout's first process at building their own in-house proprietary engine to be used for future classes. The first iteration of this project is to construct a basic 2D game engine with an easy to use UI and scripting. This game engine is written from scratch and uses OpenGl.
Another project I worked on at RealityWorks was creating an application for students to learn important skills for measuring and construction. The project is built for the Chippewa Valley Technical College to be tested out at several different schools in the area. The project focuses on how to read a Caliper, Micrometer, and a Ruler. This project can be provided upon request due to confidentiality.
While working at RealityWorks, I developed a prototype for learning to convert 2D to 3D by looking at a blueprint and walking through a house as it's being built using the Oculus Rift and Razer Hydra to create an immersive environment. Our Director of Marketing then created slides to show off our prototype to prospective clients. This project is still ongoing as we experiment further into the project including transporting a model house designed by an architect. The slides can be seen here. Andy Uchytil was the artist working on this project and I was the only programmer.
/**
* Detect the collisions between the player and enemy projectiles, the player and enemies,
* and enemies and player projectiles.
*
* Params: player - Instance of the player's avatar in the game.
* projectiles - List of projectiles currently on screen.
* enemies - List of enemies on the screen.
**/
public static void DetectCollision(Player player,
List < Projectile > projectiles,
List < EnemyInterface > enemies) {
for (int i = 0; i < projectiles.Count; i++) {
// Register the projectiles to their corresponding buckets.
RegisterProjectile(projectiles[i]);
}
// Declare collision rectangles, set the player's right away
// since it won't change during the check
Rectangle playerRectangle = new Rectangle((int)(player.Position.X - player.Width / 2),
(int)(player.Position.Y - player.Height / 2),
player.Width,
player.Height);
Rectangle enemyRectangle;
Rectangle projectileRectangle;
// Compile a list of Projectiles within colliding distance of the player
List collidingProjectiles = GetNearbyProjectiles(player);
// Check the rectangle collision between the player and the projectiles
foreach(Projectile projectile in collidingProjectiles) {
if (projectile.EnemyProjectile) {
// Create the projectile's bounding rectangle
projectileRectangle = new Rectangle((int) projectile.Position.X,
(int) projectile.Position.Y,
projectile.Width,
projectile.Height);
// Check if the rectangles intersect.
if (projectileRectangle.Intersects(playerRectangle)) {
// If they do, subtract the player's health and deactivate the projectile.
player.Health -= projectile.Damage;
projectile.Active = false;
}
}
}
// ------------------------------------
// Player projectile vs Enemy collision
// ------------------------------------
// Clear the collidingProjectiles list.
collidingProjectiles = new List();
foreach(EnemyInterface enemy in enemies) {
// Compile a list of Projects within colliding distance of the enemies
collidingProjectiles = GetNearbyProjectiles(enemy);
// Create the enemyRectangle so we only have to do this once per an enemy
enemyRectangle = new Rectangle((int)(enemy.Position.X - enemy.Width / 2),
(int)(enemy.Position.Y - enemy.Height / 2),
enemy.Width,
enemy.Height);
// Run through the projectiles and check their collisions.
foreach(Projectile projectile in collidingProjectiles) {
// Check if the projectile is fired from the Player
if (!projectile.EnemyProjectile) {
// Create the projectile's bounding rectangle.
projectileRectangle = new Rectangle((int) projectile.Position.X,
(int) projectile.Position.Y,
projectile.Width,
projectile.Height);
// Check if the bounds intersect.
if (projectileRectangle.Intersects(enemyRectangle)) {
// If so, lower enemy health and deactivate projectile
enemy.Health -= projectile.Damage;
projectile.Active = false;
}
}
}
}
// -------------------------
// Enemy vs Player collision
// -------------------------
// First, we must register the enemies
foreach(EnemyInterface enemy in enemies) {
RegisterEnemy(enemy);
}
// Retrieve a list of nearby enemies
List collidingEnemies = GetNearbyEnemies(player);
foreach(EnemyInterface enemy in collidingEnemies) {
// Construct the enemy's bounding rectangle
enemyRectangle = new Rectangle((int)(enemy.Position.X - enemy.Width / 2),
(int)(enemy.Position.Y - enemy.Height / 2),
enemy.Width,
enemy.Height);
// Check if the bounding rectangles intersect.
if (enemyRectangle.Intersects(playerRectangle)) {
// Subtract the health from the player based on
// the enemy damage
player.Health -= enemy.Damage;
// Since the enemy collided with the player
// destroy it
enemy.Health = 0;
// If the player health is less than zero we died
if (player.Health <= 0) {
player.Active = false;
}
}
}
}
I am a part time indie game programmer at Screen Burn Games, LLC and I work full time at at ACUITY, a Mutual Insurance Company. I graduated from UW - Stout with a major in Game Design and Development and a major in Applied Math and Computer Science. I've had a desire to create games since I was in sixth grade, and found an equally great love for programming them when I reached college. I aspire to create great games that people will love. I am unashamedly Team Iron Man!