Randy Bennett's Portfolio

I revisited my Charged Particles Simulation (original project listed below) with the intention of applying some things I have learned since its creation. The biggest change is that it now uses an actual point-sprite-based particle system to represent each charged particle. So instead of a cube made of 24 vertices that needs to be lit, there is now a particle system of 20 point sprites that use additive blending to create a cool animated electric charge look. Each point sprite is rendered using HLSL.

With this new, more efficient system, I was able to extend the max number of charged particles from 1000 to 2000 (2000 charged particles means 2000 * 20 = 40,000 point sprites), suggesting that the bottleneck was indeed on the graphics side as opposed to the physics side.

• Sphere-Sphere Collision Response

  The following code is a function which is called whenever two sphere’s collide in 3D space. It receives as arguments an array of Spheres (also referred to as point masses), a 3D Vector representing the distance between the two spheres, a double containing the amount of time which has passed since the last frame, and the indexes of the two colliding point masses within the pt_Masses array.

  Nothing is returned, however the two spheres receive new velocities based on their initial velocities, relative positions, masses, and coefficients of restitution (elasticity).

  Also note that, if the spheres are overlapping, they are each moved apart by half of the distance between them so that they are barely touching.

  ChargedParticlesCollisionCode.zip

  View Code
  

  // FUNCTION HandleCollision() : Handles collisions between spheres void HandleCollision(POINT_MASS pt_Masses[], Vector3D_d &separationDistance, double &changeInTime, int i, int j) { // Create a unit length vector representing the angle of collision: Vector3D_d unitNormal = separationDistance; unitNormal.normalize(); // Find the new velocities of both objects based off of their velocities prior to collision: double velocity_1 = pt_Masses[i].getLinearVelocity().dotProduct(unitNormal); double velocity_2 = pt_Masses[j].getLinearVelocity().dotProduct(unitNormal); // Calculate the average elasticity between the two spheres: double average_E = ( pt_Masses[i].getElasticity() + pt_Masses[j].getElasticity() ) / 2; // Use the equations for elastic collision response to calculate the final velocities: double finalVelocity_1 = ( ( ( pt_Masses[i].getMass() - ( average_E * pt_Masses[j].getMass() ) ) * velocity_1 ) + ( (1 + average_E) * pt_Masses[j].getMass() * velocity_2 ) ) / ( pt_Masses[i].getMass() + pt_Masses[j].getMass() ); double finalVelocity_2 = ( ( ( pt_Masses[j].getMass() - ( average_E * pt_Masses[i].getMass() ) ) * velocity_2 ) + ( (1 + average_E) * pt_Masses[i].getMass() * velocity_1 ) ) / ( pt_Masses[i].getMass() + pt_Masses[j].getMass() ); pt_Masses[i].setLinearVelocity( (finalVelocity_1 - velocity_1) * unitNormal + pt_Masses[i].getLinearVelocity() ); pt_Masses[j].setLinearVelocity( (finalVelocity_2 - velocity_2) * unitNormal + pt_Masses[j].getLinearVelocity() ); // If point masses are overlapping, back them up so that they are barely touching: double minDistance = pt_Masses[i].getBoundingSphereRadius() + pt_Masses[j].getBoundingSphereRadius(); double overlapDistance = minDistance - separationDistance.getNorm(); pt_Masses[i].setLocation( pt_Masses[i].getLocation() + ( 0.5 * unitNormal * overlapDistance) ); pt_Masses[j].setLocation( pt_Masses[j].getLocation() + (-0.5 * unitNormal * overlapDistance) ); }

This Flocking Simulation is an example of an Agent-Based Model. An agent-based model is a simulation of entities acting and interacting according to their own self-contained rules. Each agent (”Boids” as they are classically referred to as), follows three basic rules:

• 3D Space Partitioning for Efficiency

  The following code is a function which is called once per frame. It takes as arguments an array of Boids (where Boid is a class representing one of the birds) and a 2D array of doubly-linked lists of Boid pointers called boidCollection. Here is a brief description of the function’s purpose: It organizes the array of Boids based on their current position in order to provide for extremely efficient comparisons between nearby Boids later on.

  The boidCollection, being a 2D array, “maps” to the space in which the Boids are flying around. The Boid’s position determines what index it will belong to within boidCollection. This way, when it comes time to check for collisions or other comparative operations, a Boid only needs to be compared to the Boids in it’s own partition of space or to those directly surrounding it, and those relevant Boids may be found by moving through the linked lists contained in the Boid’s corresponding boidCollection index and the Lists in the “surrounding” indexes. The reason this function must be called once per frame is because a Boid is always moving and therefore its corresponding index in boidCollection will need to change whenever it crosses over to another partition of space.

  Flocking3DboidCollectionCode.zip

  View Code
  

  // FUNCTION updateBoidCollection(): Called once every frame. Reorganizes the // boidCollection structure based on new positions of Boids. void updateBoidCollection( Boid boidArray[], Array2D< DLinkedList< Boid* > > &boidCollection ) { int oldXTile = 0; // the X tile that the Boid was on in the previous frame int oldZTile = 0; // the Z tile that the Boid was on in the previous frame int newXTile = 0; // the X tile that the Boid will move to int newZTile = 0; // the Z tile that the Boid will move to DListIterator< Boid* > crntBoid; // an iterator that's used to move through every Boid in a given tile for( int i = 0; i < NUM_BOIDS; i++ ) // for all Boids: { // assign old tile and new tile oldXTile = boidArray[i].getXTile(); oldZTile = boidArray[i].getZTile(); newXTile = floor( ( boidArray[i].getXPos() + (0.5 * ROOM_LENGTH) ) / TILE_SIZE); newZTile = floor( ( boidArray[i].getZPos() + (0.5 * ROOM_WIDTH) ) / TILE_SIZE); // if old tile and new tile are not the same then boidCollection needs to reflect this change if( (newXTile != oldXTile) || (newZTile != oldZTile) ) { // assign iterator to the DLinkedList at new tile crntBoid = boidCollection.Get( oldXTile, oldZTile ).GetIterator(); // iterate through the list until you find the Boid while( crntBoid.Item()->getID() != boidArray[i].getID() && crntBoid.Valid() ) { crntBoid.Forth(); } if( crntBoid.Valid() ) // if you found the Boid (which you should unless an error has occurred)... { // remove its node from the list boidCollection.Get( oldXTile, oldZTile ).RemoveWithoutDeleting(crntBoid); } else { cout << "Error in reading a DLinkedList.\n"; } // append the Boid to the list at the new tile's location boidCollection.Get( newXTile, newZTile ).Append( &boidArray[i] ); boidArray[i].setXTile( newXTile ); // give Boid its new tile position boidArray[i].setZTile( newZTile ); } } }

What happens when a thousand particles are given positive and negative charges proportional to their mass and allowed to collide and interact in 3D? Molecules are formed! This simulation demonstrates this on a very rough level, allowing the user to tweak several parameters including the number of particles, what types of charges they have, and the ratio of the repelling force to the attracting force. Under the right conditions an initial group of randomly distributed particles will coalesce, forming balls, strings, rings, and even strands which resemble the double helix structure found in our DNA!

• Sphere-Sphere Collision Response

  The following code is a function which is called whenever two sphere's collide in 3D space. It receives as arguments an array of Spheres (also referred to as point masses), a 3D Vector representing the distance between the two spheres, a double containing the amount of time which has passed since the last frame, and the indexes of the two colliding point masses within the pt_Masses array.

  Nothing is returned, however the two spheres receive new velocities based on their initial velocities, relative positions, masses, and coefficients of restitution (elasticity).

  Also note that, if the spheres are overlapping, they are each moved apart by half of the distance between them so that they are barely touching.

  ChargedParticlesCollisionCode.zip

  View Code
  

  // FUNCTION HandleCollision() : Handles collisions between spheres void HandleCollision(POINT_MASS pt_Masses[], Vector3D_d &separationDistance, double &changeInTime, int i, int j) { // Create a unit length vector representing the angle of collision: Vector3D_d unitNormal = separationDistance; unitNormal.normalize(); // Find the new velocities of both objects based off of their velocities prior to collision: double velocity_1 = pt_Masses[i].getLinearVelocity().dotProduct(unitNormal); double velocity_2 = pt_Masses[j].getLinearVelocity().dotProduct(unitNormal); // Calculate the average elasticity between the two spheres: double average_E = ( pt_Masses[i].getElasticity() + pt_Masses[j].getElasticity() ) / 2; // Use the equations for elastic collision response to calculate the final velocities: double finalVelocity_1 = ( ( ( pt_Masses[i].getMass() - ( average_E * pt_Masses[j].getMass() ) ) * velocity_1 ) + ( (1 + average_E) * pt_Masses[j].getMass() * velocity_2 ) ) / ( pt_Masses[i].getMass() + pt_Masses[j].getMass() ); double finalVelocity_2 = ( ( ( pt_Masses[j].getMass() - ( average_E * pt_Masses[i].getMass() ) ) * velocity_2 ) + ( (1 + average_E) * pt_Masses[i].getMass() * velocity_1 ) ) / ( pt_Masses[i].getMass() + pt_Masses[j].getMass() ); pt_Masses[i].setLinearVelocity( (finalVelocity_1 - velocity_1) * unitNormal + pt_Masses[i].getLinearVelocity() ); pt_Masses[j].setLinearVelocity( (finalVelocity_2 - velocity_2) * unitNormal + pt_Masses[j].getLinearVelocity() ); // If point masses are overlapping, back them up so that they are barely touching: double minDistance = pt_Masses[i].getBoundingSphereRadius() + pt_Masses[j].getBoundingSphereRadius(); double overlapDistance = minDistance - separationDistance.getNorm(); pt_Masses[i].setLocation( pt_Masses[i].getLocation() + ( 0.5 * unitNormal * overlapDistance) ); pt_Masses[j].setLocation( pt_Masses[j].getLocation() + (-0.5 * unitNormal * overlapDistance) ); }

Ricochet is a 2D, tile-based, turn-based strategy game. Players may choose from two character classes and then go head to head or face off against a challenging AI opponent. Each turn, a player may move a certain amount of spaces and perform an attack. The Shooter character class shoots a projectile which can ricochet off of walls multiple times. The Bomber character class throws bombs over walls causing radial damage to a nearby opponent. Players collect upgrades as they play which boost various player stats including Life, Attack Power, Armor, Speed, and Special Attack. Special Attack upgrades a player's given weapon, either allowing for more Ricochets per Shot or more Bounces per Bomb. Players play until one of them reaches zero hit points, at which point the match is over and a new one may begin.

• Random Tile Map Generation Using Recursion

  The following code creates a random tile map using recursion. createRandomMap() is called from main() or some other function. It first defaults the tile map to all wall tiles, and then calls the recursive function, createRandomHall(). createRandomHall() creates a straght hall of open tiles, one tile at a time. After creating each tile, there is a chance that createRandomHall() will call itself, giving the current tile as the new start tile, and using a new random direction. When the parent hall is returned to it will continue growing until a given max length is reached, another open tile is reached, or the edge of the map is reached. Thus, the map grows like a tree, with each hall being a branch, until a given number of open tiles have been created.

  Additionally, there are three key parameters which may be customized when generating a random map: The maximum length of a hall, the number of open tiles, and the map density which controls how often a new hall will branch off.

  RicochetRandomMapCode.zip

  View Code

  const int MAX_HALL_LENGTH 6 // Maximum length a given hall may grow to during random map creation const int NUM_OPEN_TILES 100 // Number of non-wall tiles in a given random map const int MAP_DENSITY 16 // Determines chance of a new hall branching off during random map creation. const bool ADD_OUTER_RING_TO_MAP true // Whether or not an outer ring of open tiles should be added to a map /* . . . */ // FUNCTION clearLevel() : clears every tile in mapArray[][] to a wall tile. void clearLevel() { // clear level to blanks int x, y; for (x = 0; x < NUM_COLS; x++) for (y = 0; y < NUM_ROWS; y++) mapArray[x][y] = 'W'; } // FUNCTION createRandomMap() : Creates a random tile map. void createRandomMap() { // mapNumber serves as an ID for the map being generated. mapNumber++; do { // tileCounter will hold the number of open tiles which have been created tileCounter = 0; // make every tile a wall tile to start. clearLevel(); // generate a random tile and direction to begin "branching out" from int startX = 1 + rand()%(NUM_COLS - 1); int startY = 1 + rand()%(NUM_ROWS - 1); int startDir = rand()%4; // initial call to recursive function: createRandomHall(startX, startY, startDir); // if NUM_OPEN_TILES of open tiles were not created, then try again }while(tileCounter != NUM_OPEN_TILES); // Add an outer ring of open tiles for better map design if(ADD_OUTER_RING_TO_MAP) { addOuterRingToMap(); } } // FUNCTION createRandomHall() : Recursively creates the random halls that make up a map. // PARAMS : startX and startY are where a given hall will begin, startDir is the direction it will "move" in void createRandomHall(int startX, int startY, int startDir) { int randNum = 0; int randTileType = 0; // used to choose a random collectible upgrade to place on certain tiles. int curX = startX; int curY = startY; int curDir = startDir; int hallLength = 0; while( tileCounter < NUM_OPEN_TILES ) { // if the hall hasn't extended too far, and the current tile is a wall tile and is not on the outer edge of the map... if( (hallLength < MAX_HALL_LENGTH) && (mapArray[curX][curY] == 'W') && !( curX <= 0 || curX >= NUM_COLS-1 || curY <= 0 || curY >= NUM_ROWS-1 ) ) { if(tileCounter == 0) { mapArray[curX][curY] = '+'; } // assign Player 1 start position else if(tileCounter == NUM_OPEN_TILES-1) { mapArray[curX][curY] = '-'; }// assign Player 2 start position else { if(tileCounter%20 == 5) // 1 in 20 chance of placing a collectible upgrade at current tile { randTileType = 1 + rand()%5; // choose random upgrade mapArray[curX][curY] = char(int('0') + randTileType); // assign upgrade to this tile } else mapArray[curX][curY] = ' '; // otherwise tile is open without a collectible upgrade } tileCounter++; hallLength++; randNum = rand()%MAP_DENSITY; // make random integer between 0 and MAP_DENSITY // if randNum is between 1 and 4, then branch off switch(randNum) { // branch NORTH case 1: if(curDir != NORTH) { createRandomHall(curX, curY-1, NORTH); } break; // branch EAST case 2: if(curDir != EAST) { createRandomHall(curX+1, curY, EAST); } break; // branch SOUTH case 3: if(curDir != SOUTH) { createRandomHall(curX, curY+1, SOUTH); } break; // branch WEST case 4: if(curDir != WEST) { createRandomHall(curX-1, curY, WEST); } break; default: break; } // if randNum was 5 or higher, or we have returned from a recursive call, we now continue down this hall in the same direction. switch(curDir) { case NORTH: curY--; break; case EAST: curX++; break; case SOUTH: curY++; break; case WEST: curX--; break; } } else { break; } } return; } // FUNCTION addOuterRingToMap() : Adds an outer ring of open tiles for better map design void addOuterRingToMap() { int x = 0, y = 0; for(x = 1; x < NUM_COLS-1; x++) { if(mapArray[x][1] == 'W') // if tile is a wall (and not a start position or collectible upgrade)... mapArray[x][1] = ' '; // make it an open tile if(mapArray[x][NUM_ROWS-2] == 'W') mapArray[x][NUM_ROWS-2] = ' '; } for(y = 1; y < NUM_ROWS-1; y++) { if(mapArray[1][y] == 'W') mapArray[1][y] = ' '; if(mapArray[NUM_COLS-2][y] == 'W') mapArray[NUM_COLS-2][y] = ' '; } }

Safety Last is a series of wacky mini-games involving airplane safety and lack thereof. The games artists and designers modeled the games art after the unique art style of airplane safety pamphlets. It should be noted that only two out of the eight planned mini-games were completed and so Safety Last, as presented here, is technically only a Demo. However the framework of the game, which I designed and programmed, is complete. It includes a completed menu and level selection system, as well as a template of code to use in the creation of future Safety Last mini-games.

The first mini-game consists of strapping together a seat belt for a little girl by using the keyboard. The belt buckles are sensitive though and obtain momentum when you nudge them, and the girl periodically swipes the belts away. Thus the game requires patience and precise control.

In the second mini-game you must place an oxygen mask over a man's face before the plane fills with smoke. The mask will always face towards the mouse pointer. When the mouse is clicked air will shoot out of the mask away from the mouse pointer, thus propelling the mask towards the pointer. The player must guide the mask over the man's head gently while avoiding falling luggage. When the mask is secured the player has won.

Eat Your Words is a cross between Tetris and a Word Search. You are given blocks of letters to rotate and then drop down. The object of the game is to stack your blocks in such a way as to form English words. When a word is formed it is highlighted and then removed. Also if a definition for the word is available then it is provided, thus allowing the player to strengthen her vocabulary while she plays. When a word is removed, any blocks which are now unsupported fall until they have some support (either by the "ground" or by another block). Points are scored according to the length of your word and the rarity of the letters in your word. Once a given amount of words have been made, points are tallied and the game ends.