Apocalypse

By Emma Spindler, Rohan Gholkar, Parker Patterson

Demos

APOCALYPSE.mov

Code

Laser (main code)

Vec2 userPos, userVel, cannonTip;float rad, userSpeed, laserSpeed, cannonLength, cannonAngle;ArrayList<Vec2> laserPos, laserVel;float particleR = 4; // radius of laserbeam particlesFlock f;PImage fog;PImage GameOver;float Useradius = 20; //radius of userBoolean Userdead = false;int usernumHits;int userHealth = 1;
void initGame(){ userPos = new Vec2(width/2, height/2); //initialize user location in center of screen userVel = new Vec2(0, 0); //initialize user velocity to 0 Userdead = false; usernumHits = 0; f = new Flock();}
void setup(){ fog = loadImage("fog.jpg"); Zombie = loadImage("zombie.png"); GameOver = loadImage("GameOver.jpg"); size(1000,700,P3D); surface.setTitle("Final Project");
initGame();
rad = Useradius; //radius of user is 20 userSpeed = 100;
laserPos = new ArrayList<Vec2>(); //Laser particle system laserVel = new ArrayList<Vec2>(); laserSpeed = 200;
cannonLength = 30; //Cannon setup cannonAngle = 0; cannonTip = new Vec2(cos(cannonAngle)*cannonLength, sin(cannonAngle)*cannonLength).plus(userPos);}
void printUserControls() { println("CSCI 5611 Final Project"); println("--------------------------------"); println("User Controls:"); println(" You can use the agent to evade the Zombies and shoot them"); println(" 'mouse click' shoot's laser in the direction of where you clicked "); println(" 'arrow keys' makes the agent move in the direction of the arrows"); println(" 'a w s d' make the agent move in directions similar to arrows "); println(" 'r' resets the game");}
boolean leftPressed, rightPressed, upPressed, downPressed; //keypress checksvoid keyPressed(){ if (key == 'a' || key == 'A' || keyCode == LEFT) leftPressed = true; if (key == 'd' || key == 'D' || keyCode == RIGHT) rightPressed = true; if (key == 'w' || key == 'W' || keyCode == UP) upPressed = true; if (key == 's' || key == 'S' || keyCode == DOWN) downPressed = true; if (key == 'r' || key == 'R') initGame();}void keyReleased(){ if (key == 'a' || key == 'A' || keyCode == LEFT) leftPressed = false; if (key == 'd' || key == 'D' || keyCode == RIGHT) rightPressed = false; if (key == 'w' || key == 'W' || keyCode == UP) upPressed = false; if (key == 's' || key == 'S' || keyCode == DOWN) downPressed = false;}
//user movementvoid updateUser(float dt){
userPos.add(userVel.times(dt)); //updates user position userVel = new Vec2(0, 0); if(leftPressed) //WASD movement userVel.add(new Vec2(-userSpeed,0)); if(rightPressed) userVel.add(new Vec2(userSpeed,0)); if(upPressed) userVel.add(new Vec2(0,-userSpeed)); if(downPressed) userVel.add(new Vec2(0,userSpeed));
userVel.normalized().mul(userSpeed);
//keeps user in window if(userPos.x >= width - rad){ userPos.x = width - rad; } if(userPos.x <= rad){ userPos.x = rad; } if(userPos.y >= height - rad){ userPos.y = height - rad; } if(userPos.y <= rad){ userPos.y = rad; }
}
//rotates cannon to follow mousevoid updateCannon(){ Vec2 goal = new Vec2(mouseX, mouseY); Vec2 startToGoal, startToTip; float dotProd, angleDiff;
//math startToGoal = goal.minus(userPos); startToTip = cannonTip.minus(userPos); dotProd = dot(startToGoal.normalized(), startToTip.normalized()); dotProd = clamp(dotProd, -1, 1); angleDiff = acos(dotProd); if(cross(startToGoal, startToTip) < 0) cannonAngle += min(angleDiff, PI/20); else cannonAngle -= min(angleDiff, PI/20);
cannonTip = new Vec2(cos(cannonAngle)*cannonLength, sin(cannonAngle)*cannonLength).plus(userPos);}
void updateLaser(float dt){ for(int i = 0; i < laserPos.size(); i++){ //updates laser positon laserPos.get(i).add(laserVel.get(i).times(dt));
//removes particles as they leave the window if(laserPos.get(i).x >= width || laserPos.get(i).x <= 0 || laserPos.get(i).y >= height || laserPos.get(i).y <= 0){ laserPos.remove(i); laserVel.remove(i); i--; } }}
//"shoots" new laser particlevoid mousePressed(){ Vec2 newLaserPos = new Vec2(cannonTip.x, cannonTip.y); Vec2 newLaserVel = new Vec2(cannonTip.x - userPos.x, cannonTip.y - userPos.y); newLaserVel.normalize(); newLaserVel.mul(laserSpeed); laserPos.add(newLaserPos); laserVel.add(newLaserVel);}

void draw(){ updateUser(1.0/frameRate); updateCannon(); updateLaser(1.0/frameRate); f.update(1.0/frameRate);
if (Userdead) { background(0); image(GameOver, (width - GameOver.width)/2, (height - GameOver.height)/2); textSize(32); fill(255); text("Press r to play again", width/2 - 155, height/2 + GameOver.height); text("SCORE: ",width/2-70,height/3+GameOver.height+40); text(scoreBoard,width/2+60,height/3+GameOver.height+40); } else { background(0); image(fog,0,0,width,height); textSize(32); fill(205,0,0); text("SCORE: ",width-275,height/1.5+GameOver.height); text(scoreBoard,width-155,height/1.5+GameOver.height); stroke(153, 176, 170); //user strokeWeight(2); fill(240,240,230); pushMatrix(); translate(userPos.x, userPos.y); rotate(cannonAngle); //user rotates with mouse (will matter if user is textured) circle(0, 0, rad*2); popMatrix(); f.draw(); //laser stroke(255, 10, 10); fill(240, 220, 220); for(int i = 0; i < laserPos.size(); i++){ pushMatrix(); translate(laserPos.get(i).x, laserPos.get(i).y); float angle = acos(laserVel.get(i).normalized().x); if(cross(laserVel.get(i), new Vec2(1,0)) < 0) rotate(angle); else rotate(-angle); rect(-particleR*2, -particleR/2, particleR*4, particleR, 7); popMatrix(); } stroke(0); //cannon fill(0); pushMatrix(); translate(userPos.x, userPos.y); if (usernumHits > 1){ tint(color(255-usernumHits*45,0,0));} rotate(cannonAngle); rect(0, -2.5, cannonLength, 5); popMatrix(); noTint(); }}

Vec2 Library

//Vector Library [2D]//CSCI 5611 Vector 2 Library [Solution]
//Instructions: Implement all of the following vector operations--//Influenced by://CSCI 5611 Mouse Following with Vec2 [Starter]// Stephen J. Guy <sjguy@umn.edu>
public class Vec2 { public float x; public float y;
public Vec2(float x, float y){ this.x = x; this.y = y; }
public float theta(){ // returns the vector's angle in radians return atan2(y,x); }
public String toString(){ return "(" + x+ ", " + y +")"; }
public float length(){ return sqrt(x*x + y*y); }
public Vec2 plus(Vec2 rhs){ return new Vec2(x+rhs.x,y+rhs.y); }
public void add(Vec2 rhs){ x += rhs.x; y += rhs.y; }
public Vec2 minus(Vec2 rhs){ return new Vec2(x-rhs.x,y-rhs.y); }
public void subtract(Vec2 rhs){ x -= rhs.x; y -= rhs.y; }
public Vec2 times(float rhs){ return new Vec2(x*rhs, y*rhs); }
public void mul(float rhs){ x *= rhs; y *= rhs; }
public void normalize(){ float magnitude = sqrt(x*x + y*y); x /= magnitude; y /= magnitude; }
public Vec2 normalized(){ float magnitude = sqrt(x*x + y*y); return new Vec2(x/magnitude, y/magnitude); }
public float distanceTo(Vec2 rhs){ float dx = rhs.x - x; float dy = rhs.y - y; return sqrt(dx*dx + dy*dy); }}

Vec2 interpolate(Vec2 a, Vec2 b, float t){ return a.plus((b.minus(a)).times(t));}
float interpolate(float a, float b, float t){ return a+((b-a)*t);}
float cross(Vec2 a, Vec2 b){ return a.x*b.y - a.y*b.x;}
float dot(Vec2 a, Vec2 b){ return a.x*b.x + a.y*b.y;}
Vec2 projAB(Vec2 a, Vec2 b){ return b.times(a.x*b.x +a.y*b.y);}
float clamp(float f, float min, float max){ if (f < min) return min; if (f > max) return max; return f;}

Enemy Class

float enemySize = 60;float enemyStartDistance = 100; // how far away enemies start from the userint numEnemies = 20;float goalSpeed = 10; //increase to make zombies move fasterfloat goalAccel = 30;final float COR = 0.8;int scoreBoard = 0;
PImage Zombie;
//Boolean squareCircleCollision(Vec2 sqpos, float sqsz, Vec2 circpos, float rad){// float s = sqsz / 2;// float leftEdge = sqpos.x - s;// float rightEdge = sqpos.x + s;// float botEdge = sqpos.y + s;// float topEdge = sqpos.y - s;// float circTop = circpos.y - rad;// float circBot = circpos.y + rad;// float circLeft = circpos.x - rad;// float circRight = circpos.x + rad;// if ((circBot > topEdge && circTop < botEdge) &&// (circRight > leftEdge && circLeft < rightEdge)){// return true;// }// return false;//}Boolean squareCircleCollision(Vec2 sqpos, float sqsz, Vec2 circpos, float rad){ return circpos.distanceTo(sqpos) < sqsz/2 + rad;}
class Enemy { //attributes int id; Vec2 pos; Vec2 vel; Vec2 acc; Boolean dying = false; // when true, changes how the enemy is drawn. Boolean dead = false; // when true, Enemy should be removed from the flock. Vec2 vertexPos[]; float vSpeed = 1; // vertex speed -- used for squishing behavior int numHits = 0; int health = 5;
//methods Enemy(float x, float y, int id){ this.id = id; pos = new Vec2(x, y); vel = new Vec2(-1+random(2),-1+random(2)); acc = new Vec2(0, 0); vertexPos = new Vec2[4]; float s = enemySize / 2; vertexPos[0] = new Vec2(-s, -s); // top left vertexPos[1] = new Vec2(-s, s); // bottom left vertexPos[2] = new Vec2(s, s); // bottom right vertexPos[3] = new Vec2(s, -s); // top right }
void update(float dt){ int i; if ((i = hasBeenShot()) >= 0){ numHits++; laserPos.remove(i); laserVel.remove(i); } if (numHits == health) dying = true; if (dying) squish(); if (hasBitUser()){ usernumHits ++; //vel = vel.times(-0.9); //pos.x = pos.x * 1.01; //pos.y = pos.y * 1.01; Vec2 temp = vel; temp.times(2); //temp.times(2*COR); vel.minus(temp); } if (usernumHits == userHealth) Userdead = true;
// FORCES //attraction force Vec2 dir = userPos.minus(pos).normalized(); float dist = userPos.distanceTo(pos); pos.add(dir.times(goalSpeed*dt)); vel = dir.times(goalSpeed);
//collision force Vec2 leftWallNormal = new Vec2(1, 0); Vec2 rightWallNormal = new Vec2(-1, 0); Vec2 topWallNormal = new Vec2(0, 1); Vec2 bottomWallNormal = new Vec2(0, -1);
//right wall if (pos.x+enemySize > width){ pos.x = width - enemySize * 1.01; Vec2 temp = rightWallNormal; temp.times(dot(vel,rightWallNormal)); temp.times(2*COR); vel.minus(temp); } //left wall if (pos.x+enemySize < 0){ pos.x = width * 1.01; Vec2 temp = leftWallNormal; temp.times(dot(vel,leftWallNormal)); temp.times(2*COR); vel.minus(temp); } //top wall if (pos.y+enemySize > height){ pos.y = height - enemySize * 1.01; Vec2 temp = topWallNormal; temp.times(dot(vel,topWallNormal)); temp.times(2*COR); vel.minus(temp); } //bottom wall if (pos.y+enemySize < 0){ pos.y = enemySize * 1.01; Vec2 temp = bottomWallNormal; temp.times(dot(vel,bottomWallNormal)); temp.times(2*COR); vel.minus(temp); } }
void draw(){ fill(120,120,34); //fill(255,0,0); noStroke(); pushMatrix(); translate(pos.x, pos.y); //rotate(PI); beginShape(QUADS); if (numHits > 1){ tint(color(255-numHits*45,0,0));} texture(Zombie); vertex(vertexPos[0].x, vertexPos[0].y, 0, 0); // top left vertex(vertexPos[1].x, vertexPos[1].y, 0, Zombie.height); // bottom left vertex(vertexPos[2].x, vertexPos[2].y, Zombie.width, Zombie.height); // bottom right vertex(vertexPos[3].x, vertexPos[3].y, Zombie.width, 0); // top right endShape(CLOSE); popMatrix(); noTint(); }
void squish(){ // modifies the position of the vertices to emulate squishing if (vertexPos[0].y >= vertexPos[1].y || vertexPos[3].y >= vertexPos[2].y){ dying = false; dead = true; } else { vSpeed *= 1.01; vertexPos[0].x -= vSpeed; vertexPos[0].y += vSpeed; vertexPos[1].x -= vSpeed; vertexPos[1].y -= vSpeed; vertexPos[2].x += vSpeed; vertexPos[2].y -= vSpeed; vertexPos[3].x += vSpeed; vertexPos[3].y += vSpeed; } } Boolean hasBitUser(){//check to see if zombie hit user return (squareCircleCollision(pos, enemySize, userPos, Useradius)); } int hasBeenShot(){ // checks whether any of the laser particles in laserPos are intersecting // returns the index of the particle that intersected so that it can be removed from laserPos; // edges: float s = enemySize / 2; float leftEdge = pos.x - s; float rightEdge = pos.x + s; float botEdge = pos.y + s; float topEdge = pos.y - s; for (int i = 0; i < laserPos.size(); i++){ Vec2 p = laserPos.get(i); if ((p.x >= leftEdge && p.x <= rightEdge) && (p.y >= topEdge && p.y <= botEdge)) { return i; } } return -1; }}

Flock Class

class Flock { // attributes ArrayList<Enemy> enemies; Vec2 pos[] = new Vec2[numEnemies]; Vec2 vel[] = new Vec2[numEnemies]; Vec2 acc[] = new Vec2[numEnemies];
final float maxSpeed = 20; final float targetSpeed = 10; final float maxForce = 10; final float radius = 6;
// methods Flock() { // constructor enemies = new ArrayList<Enemy>(numEnemies); for (int i = 0; i < numEnemies; i++){ float randx = random(width); float randy = random(height); // this inner loop makes sure new enemies don't overlap with anything already in the sim for(int j = 0; j < i; j++){ Enemy e = enemies.get(j); if ((abs(randx - e.pos.x) < enemySize && abs(randy - e.pos.y) < enemySize) || (abs(randx - userPos.x) < rad + enemyStartDistance && abs(randy - userPos.y) < rad + enemyStartDistance)) { randx = random(width); randy = random(height); j = 0; } } enemies.add(new Enemy(randx, randy, i)); } }
void update(float dt){ for (int i = 0; i < enemies.size(); i++){ Enemy e = enemies.get(i); if (e.dead) { enemies.remove(i); scoreBoard++; i--; } else { e.update(dt); } } if(millis() % 100 == 0){ spawn(); } }
void spawn(){ float randx = random(width); float randy = random(height); // this inner loop makes sure new enemies don't overlap with anything already in the sim for(int j = 0; j < enemies.size(); j++){ Enemy e = enemies.get(j); if ((abs(randx - e.pos.x) < enemySize && abs(randy - e.pos.y) < enemySize) || (abs(randx - userPos.x) < rad + enemyStartDistance && abs(randy - userPos.y) < rad + enemyStartDistance)) { randx = random(width); randy = random(height); } } enemies.add(new Enemy(randx, randy, enemies.size() - 1)); } void draw(){ float dt = 1/(frameRate*60); for (Enemy e : enemies){ e.draw(); } }}

Report

About Apocalypse

Apocalypse is a game about shooting zombies with a laser. Our game is similar to the classic arcade game, Asteroid, but with a modern twist. Instead of flying through space and blasting asteroids, in Apocalypse, the user takes control of a motile, robotic laser turret and tries to shoot their way through the hordes of oncoming zombies. Unlike asteroids, these zombies have a taste for (machine) blood, so they actively seek out their target. In this sense, the enemies in our game are more similar to the zombies of Call of Duty’s famous zombie mode than they are to the lifeless rocks in Asteroid.

CSci 5611 Topics

Our game incorporates several of the topics covered in Dr. Guy’s 5611 course: our laserbeam is implemented using a basic particle system; enemies move through the simulation according to flocking principles; firing the turret involves inverse kinematics; orienting laserbeam particles involves planning rotation; and, finally, we used squash and stretch to enhance the liveliness of enemies’ death animation. We would have liked to incorporate even more 5611 topics such as sound, 3D rendering, and improved animations for the user’s in-game agent, but, due to the condensed timeframe of the course, we did not have time to implement these features.

Key Algorithms

Among the 5611 topics we incorporated into Apocalypse, there are a few “key” algorithms that make our code function, including Eulerian integration, inverse kinematics, collision detection, planning rotation, and an algorithm for visually-pleasing squashing animations. With the exception of Eulerian integration and inverse kinematics, all algorithms used were designed by team members specifically for this project.

Eulerian integration is used to achieve realistic motion for the enemies as well as the user. Inverse kinematics algorithms were necessary to implement user-directed laser fire. A naive approach to collision detection was used initially, wherein the positions of the edges of the shapes in question were checked against one another. Later on, we settled on a better collision-detection algorithm involving our Vec2 library function distanceTo(). Our squashing algorithm modifies the positions of the enemy’s vertices exponentially, killing the enemy once it has been squashed flat.

Design Process

Although a longer project timeframe would have allowed us to manifest a bit more creativity in our work, we are pleased with Apocalypse. Some things worked well and some things did not, but, ultimately, our group’s strong communication allowed us to overcome obstacles and arrive at satisfactory solutions. We consider the project to be a true team effort, but we also wanted to include this list of some of the individual contributions we made that we’re particularly proud of:

Individual Contributions That We’re Proud of

Rohan Gholkar

Dynamic laserbeam orientation
Planning rotation
Laser and cannon code
Inverse kinematics
Laserbeam visual design
User input handling

Emma Spindler

Enhanced visuals
Modified enemy flocking behavior
User death
Game over screen
Simulation reset

Parker Patterson

Enemy and Flock class framework
Enemy health and death system
Squash animation code
Game over screen
Simulation reset

What didn’t work

One of the greatest barriers we faced in the early stages of development was that portions of our code had been developed independently and, in one portion, object-oriented paradigms were used, while, in the other portion, a more C-like programming style was used. These differences proved troublesome, as different members of our group had differing levels of fluency with object-oriented programming practices. Ultimately, we all agreed that the programming paradigm we used was less important than the fact that the simulation worked, so, rather than attempting to unify our programming paradigm, we kept it as-is. The intermingling of C-like and OO code lead to some confusion at times, but we all have a deeper understanding of the Java/Processing language as a result.

Many of our initial approaches to problems throughout the development of Apocalypse proved to be ineffectual and were later replaced with more sophisticated solutions. For example, initially, our cannon would fire a continuous stream of particles as long as the user held down on the mouse button. There were many things we liked about this approach, both aesthetically and practically, but, in the end, we decided to limit the number of shots to one per click. This decision was made to allow for more detailed rendering of the laserbeam particles as well as to simplify and speed up the simulation overall.

At one point during the development of the laserbeam particles, we tried to use Processing’s delay() function call to limit the number of laser particles on-screen, however, we were unable to find a satisfying way to use delay(), since it would pause the entire simulation whenever it was called. Finding a way to achieve delay in a simulation like ours was an interesting problem, and, ultimately we decided to sidestep it rather than address it directly, largely due to time constraints.

Another approach that was eventually scrapped was the use of traditional flocking behavior for enemy movement. Initially, our idea was that the enemies would be flying around the screen in swarms, irrespective of the user’s position. However, as we were implementing flocking behavior, we realized that we could modify the flocking code so that the enemies would be drawn to the user. After seeing the terrifying, slow crawl of the enemies (squares, at the time) toward the user’s position, we were inspired to change the rendering of the enemies from plain quads to zombies.

What Worked

We’re quite proud of some of our solutions to the design challenges we encountered. We used inverse kinematics to inform the simulation as to the trajectory of new laserbeam particles. First, two vectors were created: one from the user position to the mouse position and another from the user position to the end of the cannon. By taking the inverse cosine of the dot product of the two vectors, we determined the angle the cannon needed to rotate in order to align with the mouse. The laser particles had their positions initialized at the end of the cannon and had a constant velocity that was parallel to the cannon. In order to give the laser particle a more laser-like appearance, we decided to make rectangles rather than circles. However, an issue came up regarding the orientation of rectangles. All of the rectangles had the same orientation despite their differing velocities. This was solved by using simple trigonometry to find the angle of each laser particle’s velocity. The rectangle was then rotated by this angle so its long edge is parallel to its velocity.

One strategy that ultimately worked in our favor was to give the enemy and flock classes their own update and draw methods. Once we all got on the same page about OOP, having the code organized this way was a real timesaver.

We were very happy with the way that we were able to modify flocking behavior to give our zombies their zombie-like movement. Initially, it was not our intention to draw the enemies toward the user, but once we realized how easy it was to implement this behavior using our existing flocking code, we decided to add it to the simulation, and it became an integral part of the game.

Closing Remarks

We hoped you’ve enjoyed learning a bit about our design process. It certainly was a satisfying way to test the new knowledge we gained in CSci 5611. We finish our report with a few comments about the computational bottlenecks in our simulation and a discussion of the limits to scaling our project up.

Computational bottlenecks and limits to scaling up

One of the most computation-heavy portions of our code is the setup function. The main slowdowns in this section are loading the images we used, and, perhaps more significantly, when the Flock’s constructor is called, we use a doubly nested loop to ensure that new enemies are not spawning on top of other enemies. We were unable to think of a more efficient way to perform this check.

There are some potentially computationally heavy function calls related to trigonometry and algebra, but we did our best to minimize the use of such functions, so, overall, they shouldn’t present much of a barrier to scaling the project up.

One theoretical bottleneck in the code is our collision detection. To check whether or not enemies have been hit by the laser, we iterate over every laser particle in the simulation for every enemy, each timestep. This part of the simulation runs in O(m * n), where m is the number of enemies, and n is the number of laser particles onscreen. Although we mitigated this bottleneck somewhat by reducing the number of particles on screen at a given time, we did not find a solution to the underlying problem of having to iterate through n particles for all m enemies.

Tools and References

UMN CSCi 5611 with Dr. Guy
https://processing.org/reference/
Processing Flocking Example: https://processing.org/examples/flocking.html
Flocking tutorial: https://www.youtube.com/watch?v=dQw4w9WgXcQ
Vec2 Library (included in Code section)
my brain, my brain, and my brain
Referenced Joints.pde for inverse kinematics
Fog: https://www.youtube.com/watch?v=Gec6XaH1VnY
Zombie: https://www.kissclipart.com/zombie-cartoon-clipart-zombie-cartoon-drawing-oe9bsi/
Picture on the top of the site: https://www.aquiziam.com/is-a-zombie-apocalypse-really-possible/
Special thanks to Chris Kauffman

Page updated

Google Sites

Report abuse