Welcome to my online portfolio! Click on the projects below for more information and highlights of my contribution to that project.

Redemption: Crysis Mod



Overview

Redemption: Crysis LevelRealistic terrain, vegetation, and object placementRealistic terrain, vegetation, and object placementHand crafted waterfall using basic particlesHand crafted waterfall using basic particlesStrategically placed objectsStrategically placed objectsStrategically placed objectsScripted events and mission systemScripted events and mission systemNatural environmental boundariesNatural environmental boundaries

Redemption is a complete campaign style level I created using the Sandbox2 editor packaged with Crysis. For the environment, I painted my own height map for the terrain of my island, then carefully placed all vegetation and environmental objects to create a realistic feeling island while still guiding the player along a strait forward path towards the mission objectives.

For the mission, I laid out four terminals that the user must access throughout the island. Each terminal is guarded with increasing difficulty from foot soldiers, to soldiers on mounted defensive turrets, to elite stealthed soldiers, to an entire fortress at the end.

For the dramatic finish, after accessing the final terminal, a military helicopter piloted by the computer lands and tells the player to “get in the gunner seat.” The player must then use the mounted machine gun to fend off multiple enemies with anti-aircraft weapons firing throughout the island as they escape to the victory of the level.


Video

Below you can watch a video that contains a full walk through of the level I created using the Sandbox2 editor for Crysis. In addition, the self narration of the video explains my thoughts and the considerations I made along the way, to create the fun and challenging, completely playable, first level: “Redemption.”



Skeeball Arcade Web Game



Overview

I designed and programmed a classic arcade style skeeball game using 3DVIA Studio. In addition to designing and programming, I was responsible for creating the 3D art as well. I was responsible for the design, 3D art, and programming of the game. The real trick to programming this game was translating the player’s mouse input into physics manipulation of the ball in order to make the player feel like they have control of the ball, but still make it challenging.

This game was created in only two weeks, shortly after the 3DVIA Studio game engine launched. Along with creating the game, I did a series of live webinars co-hosted with my colleague Juan Del Rio detailing my development process in creating the game, a sample of which can be found below.

For a list of all the webinar videos and more information, check out this article.


Game

Click the link below to launch the skeeball game directly in your browser.

Note: You will need to install the 3DVIA Player plugin to run the game, and the player is currently not supported on Mac or mobile devices.

Click here to launch game!



3D Engine Tutorials



Overview

I created a lot of “Getting Started” tutorial content to shorten the learning curve on 3DVIA’s 3D game development engine: Studio.

This content consists of over twenty step by step tutorial videos that I created from the ground up, by myself, including: script writing, screen recording, narrating, editing, and publishing.

I also created over fifty documented, engine ready assets that demonstrated key engine features from lighting, to physics, to path finding and more.

In addition, I created several written documents and online articles ranging from step by step tutorials tailored to a complete novice of the engine, to detailed guides on how to master more complex concepts and best practices.


Videos

Below you can find a segment of video taken from the middle of one of my multiple part series on how to script in the 3DVIA Studio game engine.

You can find a full listing of the videos here. I created all of the videos on the page except for the “Studio Minutes” section.


Assets

I created over fifty, drag and drop, engine ready assets demonstrating key principles of 3DVIA Studio. Below you can find a list of links that represents a cross section of the content I created:

The bulk of the content is in the last link, “code snippets” where I demonstrated how to use 3DVIA Studio’s native scripting language (derived from C++) to accomplish common programming needs. Below you can find a code snippet taken directly from the mouse manager example:

// Demonstrates how to "pick" something under the mouse, then change it's properties
task VSLMouseManager::manager
{
  Target {
    VSLMouseManagerPtr be;
  };

  bool Execute(const vkTaskContext& iCtx)
  {
    // Get the user's mouse
    vkMousePtr mouse = vkIODeviceManager::Mouse();
       
    if (mouse.IsButtonToggled(vkMouse::eButtonLeft)){
      // Get the rendermanager
      vkRenderManager& rm = vkRenderManager::Instance();
     
      // Define a RayIntersection
      vkRayIntersection myRayIntersection;

      // Test to see if ray has intersected with anything
      bool intersection;
      intersection = rm.PickAtMouse(myRayIntersection);

      // If ray has intersected with something, we can grab the node from the ray, and perform an action on it (in this example, scale)
      if(intersection) {
          vkNode3DPtr pickedNode = myRayIntersection.node;
          float scale = pickedNode.GetLocalScale();
          pickedNode.Scale((scale * 1.1f));
        }
    }
    return true;
  }
};

Articles

I have written many documents and articles detailing how to use the 3DVIA Studio game engine, from step by step beginner tutorials for new users, to more advanced articles dealing with complex concepts for the veteran users.

Below you can find a series of PDF documents I created to get new users started. These documents were created to help college students learn 3DVIA Studio, so the students could participate in a 3DVIA Studio challenge 3DVIA that took place across several college campuses:

Here you can find some online articles I published for veteran 3DVIA Studio users to master more advanced concepts and techniques:



Tower Defense Game



Overview

This is a game I designed and coded to get familiar with the 3DVIA Studio game engine. It never reached the polish stage with final geometry, textures, and particles but all of the interface and game mechanics are fully coded. See below for a vertical slice of the game play in action.

A lot of time went into not only the obvious core mechanics such as enemy pathing, tower’s tracking enemies, damage, health, shield, and area of effect calculations but also into an easy to use and understand interface.


Tower Code

Below you will find the bulk of the code I wrote to make the towers track, fire, and deal damage to enemies. Some towers required some special functions to handle things like projectiles versus instant damage, and arrays to broadcast the “take damage” event to multiple enemies within range instead of just one, but the principles remain the same.

Main Execute Task

// Main execute loop for towers
task towerProjectileBe::mainExecute
{
  Target {
    towerProjectileBePtr be;
  };
  bool Execute(const vkTaskContext& iCtx)
  {
    // Get global parameters
    GlobalParametersPtr globalParams = be.GetGlobalParameters();
   
    // If game is paused, deactivate turret immediately
    if (globalParams.isPaused)
    {
      deactivate();
    }
   
    // Look for enemy within range
    currentTarget = getTarget();
   
    if (currentTarget)
    {
      // If valid enemy found, activate tower and look at target
      activate();    
      lookAtTarget();
    }
      else
      {
        // If no valid enemy found, deactivate tower
        deactivate();
      }  
    return true;
  }
};

getTarget(); Function

// Iterates through enemy array list and tests to see if any are within firing radius
vkNode3DPtr
towerProjectileBe::getTarget()
{
  // Get global parameters
  GlobalParametersPtr globalParam = this.GetGlobalParameters();
 
  // Iterate through array of all active enemies
  for (int i=0; i < globalParam.enemyList.Size(); i++)
  {
    // Cast enemy actor into node type
    vkNode3DPtr node = globalParam.enemyList[i];
   
    if (node)
    {
      // Check distance between tower and enemy
      float dis = node.GetDistanceFrom(this);
     
      // Divide distance found by the enemies scale factor to get accurate distance ** HALF ALWAYS???
      dis = dis / 0.5;
     
     
     
      if (dis <= iStats.radius)
      {
        // Return first enemy found within radius
        return node;
      }
    }
  }
  // No enemies were found within radius, return null
  vkNode3DPtr node = null;
  return node;
}

lookAtTarget(); Function

// Rotates the tower to look at current enemy in range (vRotation added for towers that have seperate pivot for x and y rotations)
void
towerProjectileBe::lookAtTarget()
{
  hRotation.LookAt(vkVec3(0,0,0), currentTarget);
  vkVec3 hDir;
  hRotation.GetWorldDirection(hDir);
  hRotation.SetOrientationInSpace(vkVec3(hDir.x, 0, hDir.z), vkVec3(0,1,0), null, true);
 
  if (vRotation)
  {
    vRotation.LookAt(vkVec3(0,0,0), currentTarget);
    vkVec3 vDir;
    vRotation.GetWorldDirection(vDir);
    vRotation.SetOrientationInSpace(vDir, vkVec3(0,1,0), null, true); // Up at 0,1,0 makes sure turret is always up right
  }
}

fire(); Function

// Retreives damage from current tower then sends the event to enemy
void
towerConstantBe::fire(float iDamage)
{
  // Declare enemy hit event
  enemyHit event;
 
  // Set damage member of event to the damage of current tower
  event.damage = iDamage;
 
  // Send event to the enemy that was hit
  currentTarget.BroadcastEventInRing(event);
}