Sam Perry
490 lines
16 KiB
Plaintext
490 lines
16 KiB
Plaintext
/*
|
|
* IDMT Mini-Assignment 2
|
|
*
|
|
* Tank Wars: a simple game of throwing projectiles
|
|
* This is a skeleton with a few basic pieces filled
|
|
* in. You will need to fill in the rest to make the
|
|
* game work.
|
|
*/
|
|
|
|
// Basic information on the terrain and the tanks
|
|
|
|
float[] groundLevel; // Y coordinate of the ground for each X coordinate
|
|
float tank1X, tank1Y, tank2X, tank2Y; // Positions of the two tanks
|
|
float tankDiameter = 30; // Diameter of the tanks
|
|
float cannonLength = 25; // How long the cannon on each tank extends
|
|
float tank1CannonX1, tank1CannonX2, tank1CannonY1, tank1CannonY2;
|
|
float tank2CannonX1, tank2CannonX2, tank2CannonY1, tank2CannonY2;
|
|
float gravity = 0.05; // Strength of gravity
|
|
// Store velocity of projectile
|
|
float velocity;
|
|
// Store value for if projectile has collided with the ground or a tank
|
|
boolean contactMade = false;
|
|
// Store the diameter of the projectile
|
|
int projectileSize = 8;
|
|
|
|
// Current state of the game
|
|
|
|
int playerHasWon = 0; // 1 if player 1 wins, 2 if player 2 wins, 0 if game in progress
|
|
boolean player1Turn = true; // true if it's player 1's turn; false otherwise
|
|
float tank1CannonAngle = PI/2, tank2CannonAngle = PI/2; // Direction the tank cannons are pointing
|
|
float tank1CannonStrength = 3, tank2CannonStrength = 3; // Strength of intended projectile launch
|
|
|
|
// Location of the projectile
|
|
|
|
// Store the state of the projectile
|
|
boolean projectileInMotion = false;
|
|
// Store projectile position and velocity values on screen
|
|
float projectilePositionX, projectilePositionY;
|
|
float projectileVelocityX, projectileVelocityY;
|
|
|
|
// Image object to encapsulate the background image
|
|
PImage bg;
|
|
|
|
// Terrain generation function adapted from: http://www.redblobgames.com/articles/noise/introduction.html
|
|
// Generate varying hills and valleys for terrain.
|
|
void GenerateTerain() {
|
|
// Store amplitudes (randomly generated within arbritrary limits) for each
|
|
// sine wave
|
|
float amp[] = {random(1.5,2.5), random(0.8,1.4), random(0.1, 0.3), random(0.0001, 0.002), 0.01, 0.01};
|
|
// Store frequencies (Hz) for each sine wave
|
|
int frequency[] = {1, 2, 4, 8, 16, 32};
|
|
// generate a random phase for sine waves
|
|
float phase = random(0, 2*PI);
|
|
|
|
// Initialize all values of groundLevel to 0
|
|
for(int i = 0; i < width; i++) {
|
|
groundLevel[i] = 0;
|
|
}
|
|
// for every ground level array element
|
|
for(int i = 0; i < width; i++) {
|
|
// for all sine components to be accumulated
|
|
for(int j = 0; j < frequency.length; j++) {
|
|
// generate the current sample value for the current sine wave
|
|
groundLevel[i] += (sin(2*PI * frequency[j]*i/width + phase)*amp[j])*30;
|
|
}
|
|
}
|
|
// Apply an arbitrary offset to place terrain at appropriate level on
|
|
// screen
|
|
for(int i = 0; i < width; i++) {
|
|
groundLevel[i] += height - (height / 3.5);
|
|
}
|
|
}
|
|
|
|
void setup() {
|
|
size(960, 480); // Set the screen size
|
|
// Background image taken from https://www.behance.net/gallery/31516629/CARTOON-BACKGROUNDS
|
|
// Load the background image into object
|
|
bg = loadImage("background.png");
|
|
|
|
// Initialize the ground level
|
|
groundLevel = new float[width];
|
|
// Fill groundLevel array with values
|
|
GenerateTerain();
|
|
// set the height of the tanks relative to the generated ground level
|
|
float player1Height = groundLevel[int(width*0.1)];
|
|
float player2Height = groundLevel[int(width*0.9)];
|
|
|
|
// Set the location of the two tanks so they rest on the ground at opposite
|
|
// sides
|
|
tank1X = width * 0.1;
|
|
tank1Y = player1Height;
|
|
tank2X = width * 0.9;
|
|
tank2Y = player2Height;
|
|
}
|
|
|
|
void draw() {
|
|
// Main draw loop. Farm out the individual tasks to other functions for
|
|
// clarity (though it could be equivalently implemented entirely in this
|
|
// function.)
|
|
|
|
// Set the background to the picture provided
|
|
background(bg);
|
|
|
|
// run draw functions for respective elements of the game
|
|
drawTanks();
|
|
drawGround();
|
|
drawProjectile();
|
|
drawStatus();
|
|
|
|
// draw projectiles at new positions and run collision detection for
|
|
// projectiles
|
|
updateProjectilePositionAndCheckCollision();
|
|
}
|
|
|
|
// Draw the terrain under the tanks
|
|
void drawGround() {
|
|
/* TO IMPLEMENT IN STEP 1 */
|
|
strokeWeight(5);
|
|
// Draw ground using a single custom shape using vertex functions
|
|
beginShape();
|
|
int idx;
|
|
// for each groundLevel array element
|
|
for(idx = 0; idx < groundLevel.length; idx++){
|
|
// create a vertex point at the position on the screen determined by the
|
|
// array index position at the height of the element in the array
|
|
vertex(idx, groundLevel[idx]);
|
|
}
|
|
// Apply two final vertices to fill space below generated vertices
|
|
vertex(idx, height);
|
|
vertex(0, height);
|
|
|
|
// Colour ground
|
|
fill(250, 236, 157);
|
|
endShape();
|
|
|
|
// Set future shapes to not have a border
|
|
noStroke();
|
|
// create layered ground with different colour and dimensions for aesthetic
|
|
// effect
|
|
// Logic is essentially the same as above
|
|
beginShape();
|
|
for(idx = 0; idx < groundLevel.length; idx++){
|
|
vertex(idx, (groundLevel[idx] * 0.85)+70);
|
|
}
|
|
vertex(idx, height);
|
|
vertex(0, height);
|
|
fill(235, 222, 137);
|
|
endShape();
|
|
strokeWeight(5);
|
|
|
|
// See the groundLevel[] variable to know where to draw the ground
|
|
// Ground should be drawn in a dark grey
|
|
|
|
}
|
|
|
|
// Draw the two tanks (including cannons)
|
|
void drawTanks() {
|
|
/* TO IMPLEMENT IN STEP 1 */
|
|
|
|
// Draw the two tanks as semicircles using the positions and sizes at the top
|
|
// of the file
|
|
// Tanks should be different colours
|
|
// Also be sure to draw the cannons, using the angles given at the top of the
|
|
// file
|
|
|
|
// Draw tank 1
|
|
|
|
// Set size of border to 10 pixels
|
|
strokeWeight(10);
|
|
|
|
// set variable for placing tank 1 cannon at the centre of the tank
|
|
tank1CannonX1 = tank1X;
|
|
// set variable for placing the tip of the cannon at the angle and length
|
|
// specified
|
|
tank1CannonX2 = tank1X + (cannonLength * cos(tank1CannonAngle));
|
|
// similar to above...
|
|
tank1CannonY1 = tank1Y;
|
|
tank1CannonY2 = tank1Y - (cannonLength * sin(tank1CannonAngle));
|
|
|
|
// draw tank cannon at position specified
|
|
line(tank1CannonX1, tank1CannonY1, tank1CannonX2, tank1CannonY2);
|
|
// Make cannon square
|
|
strokeCap(SQUARE);
|
|
|
|
// Set global border size to 5 pixels
|
|
strokeWeight(5);
|
|
fill(255, 0, 0);
|
|
// draw 1 tank body
|
|
// arc was replaced with ellipse to account for more detailed varying ground
|
|
// level
|
|
ellipse(tank1X, tank1Y, tankDiameter, tankDiameter);
|
|
|
|
// Draw tank 2
|
|
// Exactly the same as tank 1
|
|
strokeWeight(10);
|
|
tank2CannonX1 = tank2X;
|
|
tank2CannonX2 = tank2X + (cannonLength * cos(tank2CannonAngle));
|
|
tank2CannonY1 = tank2Y;
|
|
tank2CannonY2 = tank2Y - (cannonLength * sin(tank2CannonAngle));
|
|
line(tank2CannonX1, tank2CannonY1, tank2CannonX2, tank2CannonY2);
|
|
strokeWeight(5);
|
|
fill(0, 0, 255);
|
|
ellipse(tank2X, tank2Y, tankDiameter, tankDiameter);
|
|
}
|
|
|
|
// Draw the projectile, if one is currently in motion
|
|
void drawProjectile() {
|
|
// Don't draw anything if there's no projectile in motion and the projectile
|
|
// isn't exploding
|
|
if(!projectileInMotion && !contactMade)
|
|
return;
|
|
// if projectile has exploded enough then stop
|
|
else if(contactMade && projectileSize > 32) {
|
|
// Set projectile state so that it no longer expands
|
|
contactMade = false;
|
|
// toggle to next player's turn
|
|
nextPlayersTurn();
|
|
}
|
|
// Save the current global stroke colour
|
|
// (Hacky workaround due to everything being in the global namespace)
|
|
int strokeColourVar = g.strokeColor;
|
|
noStroke();
|
|
// Set projectile colour to yellow
|
|
fill(255, 255, 0);
|
|
// Set the position and size of projectile
|
|
ellipse(projectilePositionX, projectilePositionY, projectileSize, projectileSize);
|
|
// Recover previously set stroke colour
|
|
stroke(strokeColourVar);
|
|
}
|
|
|
|
// Draw the status text on the top of the screen
|
|
void drawStatus() {
|
|
// Temporarily save global variables locally
|
|
float strokeWeightVar = g.strokeWeight;
|
|
int strokeColourVar = g.strokeColor;
|
|
// Set shape border size to 2 pixels
|
|
strokeWeight(2);
|
|
// Set stroke colour RGB
|
|
stroke(230, 249, 211);
|
|
// Set shape fill colour RGB
|
|
fill(201, 246, 203);
|
|
// Draw a background rectangular box to separate information bar from
|
|
// background
|
|
rect(0, 0, width, 45);
|
|
// reset global values to their originals, avoiding unexpected behaviour in
|
|
// other functions
|
|
strokeWeight(strokeWeightVar);
|
|
stroke(strokeColourVar);
|
|
|
|
// Set text size and alignment parameters for info bar
|
|
textSize(24);
|
|
textAlign(LEFT);
|
|
fill(0);
|
|
|
|
// Based on current state of game, display relevant information in
|
|
// information bar
|
|
if(playerHasWon == 1)
|
|
text("Player 1 Wins!", 10, 30);
|
|
else if(playerHasWon == 2)
|
|
text("Player 2 Wins!", 10, 30);
|
|
else if(player1Turn) { // player1Turn == true means it's player 1's turn
|
|
text("Player 1's turn |", 10, 30);
|
|
textAlign(RIGHT);
|
|
text("| Angle: " + tank1CannonAngle + " | Strength: " + tank1CannonStrength, width - 10, 30);
|
|
}
|
|
else { // player1Turn == false
|
|
text("Player 2's turn |", 10, 30);
|
|
textAlign(RIGHT);
|
|
text("| Angle: " + tank2CannonAngle + " | Strength: " + tank2CannonStrength, width - 10, 30);
|
|
}
|
|
}
|
|
|
|
// Move the projectile and check for a collision
|
|
void updateProjectilePositionAndCheckCollision() {
|
|
// If projectile has finished all actions (moving and exploding)
|
|
if(!projectileInMotion && !contactMade) {
|
|
projectileSize = 8;
|
|
return;
|
|
}
|
|
// Check for player's turn
|
|
// This implementation could be vastly improved by creating a generic
|
|
// function that applies operations to either player 1 or 2 based on this
|
|
// boolean. An object oriented approach or a way of passing variables by
|
|
// reference to a generic function would achieve this.
|
|
if(player1Turn) {
|
|
/* TO IMPLEMENT IN STEP 3: UPDATE POSITION */
|
|
|
|
// If the projectile is in motion...
|
|
if(!contactMade) {
|
|
// Tasks: increment the position according to the velocity
|
|
// For later: the velocity according to gravity (and optionally wind)
|
|
projectilePositionX += tank1CannonStrength * cos(tank1CannonAngle);
|
|
projectilePositionY += (velocity * -sin(tank1CannonAngle));
|
|
}
|
|
else {
|
|
// If the projectile has collided with an object, increment it's size
|
|
projectileSize += 1;
|
|
}
|
|
|
|
/* TO IMPLEMENT IN STEP 4: GRAVITY */
|
|
// Update the velocity of the projectile according to the value of gravity
|
|
// at the top of the file
|
|
velocity -= gravity;
|
|
|
|
/* TO IMPLEMENT IN STEP 5: COLLISION DETECTION */
|
|
// Compare the location of the projectile to the ground and to the two
|
|
// tanks
|
|
// (Conditions ordered to avoid indexing error in final condition)
|
|
|
|
// When the projectile hits the ground, it's the next player's turn
|
|
if(round(projectilePositionX) >= width || round(projectilePositionX) <= 0) {
|
|
// When the projectile hits something, it stops moving (change
|
|
// projectileInMotion)
|
|
// As projectile has finished moving and exploding, set all relevant
|
|
// booleans to false, ready for next player's turn
|
|
projectileInMotion = false;
|
|
contactMade = false;
|
|
nextPlayersTurn();
|
|
|
|
}
|
|
// If projectile has collided with an object but hasn't exploded...
|
|
else if (projectilePositionY > groundLevel[round(projectilePositionX)]) {
|
|
// Set boolean values accordingly
|
|
projectileInMotion = false;
|
|
contactMade = true;
|
|
}
|
|
|
|
}
|
|
// Same as for player 1
|
|
else {
|
|
|
|
/* TO IMPLEMENT IN STEP 3: UPDATE POSITION */
|
|
|
|
// Tasks: increment the position according to the velocity
|
|
// For later: the velocity according to gravity (and optionally wind)
|
|
if(!contactMade) {
|
|
// Tasks: increment the position according to the velocity
|
|
// For later: the velocity according to gravity (and optionally wind)
|
|
projectilePositionX += tank2CannonStrength * cos(tank2CannonAngle);
|
|
projectilePositionY += (velocity * -sin(tank2CannonAngle));
|
|
}
|
|
else {
|
|
projectileSize += 1;
|
|
}
|
|
velocity -= gravity;
|
|
|
|
/* TO IMPLEMENT IN STEP 5: COLLISION DETECTION */
|
|
// Compare the location of the projectile to the ground and to the two
|
|
// tanks
|
|
|
|
// When the projectile hits the ground, it's the next player's turn
|
|
if(projectilePositionX >= width || projectilePositionX <= 0) {
|
|
// When the projectile hits something, it stops moving (change
|
|
// projectileInMotion)
|
|
projectileInMotion = false;
|
|
contactMade = false;
|
|
nextPlayersTurn();
|
|
|
|
}
|
|
else if (projectilePositionY > groundLevel[round(projectilePositionX)]) {
|
|
projectileInMotion = false;
|
|
contactMade = true;
|
|
}
|
|
}
|
|
// When the projectile hits a tank, the other player wins
|
|
if(dist(projectilePositionX, projectilePositionY, tank2X, tank2Y) < (tankDiameter/2.0) + (projectileSize / 2)) {
|
|
projectileInMotion = false;
|
|
contactMade = true;
|
|
// If projectile shape comes into contact with player 2's tank, player 1
|
|
// wins
|
|
playerHasWon = 1;
|
|
}
|
|
else if(dist(projectilePositionX, projectilePositionY, tank1X, tank1Y) < (tankDiameter/2.0) + (projectileSize / 2)) {
|
|
projectileInMotion = false;
|
|
contactMade = true;
|
|
// Vice versa
|
|
playerHasWon = 2;
|
|
}
|
|
}
|
|
|
|
// Advance the turn to the next player
|
|
void nextPlayersTurn() {
|
|
player1Turn = !player1Turn;
|
|
}
|
|
|
|
// Check angle is limited from 9 o'clock to 3 o'clock
|
|
float validateAngle(float angle) {
|
|
if(angle > PI)
|
|
{
|
|
angle = PI;
|
|
}
|
|
else if(angle < 0)
|
|
{
|
|
angle = 0.0;
|
|
}
|
|
// return angle within limited range
|
|
return angle;
|
|
}
|
|
|
|
// Limit strength to within reasonable values
|
|
float validateStrength(float strength) {
|
|
if(strength > 10.0)
|
|
{
|
|
strength = 10.0;
|
|
}
|
|
else if(strength < 1.0)
|
|
{
|
|
strength = 1.0;
|
|
}
|
|
return strength;
|
|
}
|
|
// Handle a key press: update the status of the current player's tank
|
|
void keyPressed() {
|
|
if(playerHasWon != 0) // Stop the game when someone has won
|
|
return;
|
|
if(projectileInMotion) // No keys respond while the projectile is firing
|
|
return;
|
|
|
|
|
|
/* TO IMPLEMENT IN STEP 2 */
|
|
|
|
// Use the key variable to check which key was pressed.
|
|
// Arrow keys don't have a printable character, so they show up as CODED
|
|
// Use the left and right arrows to adjust the angle, the up and down arrows
|
|
// to adjust strength.
|
|
|
|
// Specify cases based on the key that has been pressed
|
|
switch(key) {
|
|
// If key is a special character
|
|
case CODED:
|
|
if(player1Turn) {
|
|
// Specify actions for up, down left and right
|
|
switch(keyCode) {
|
|
// Left and right increment/decrement cannon angle by 1 radian
|
|
case LEFT: tank1CannonAngle += PI/180.0;
|
|
break;
|
|
case RIGHT: tank1CannonAngle -= PI/180.0;
|
|
break;
|
|
// Up and down increment/decrement cannon strength by 1.0
|
|
case UP: tank1CannonStrength += 1;
|
|
break;
|
|
case DOWN: tank1CannonStrength -= 1;
|
|
break;
|
|
}
|
|
// Ensure updated values are within preset ranges
|
|
tank1CannonAngle = validateAngle(tank1CannonAngle);
|
|
tank1CannonStrength = validateStrength(tank1CannonStrength);
|
|
}
|
|
else
|
|
{
|
|
switch(keyCode) {
|
|
case LEFT: tank2CannonAngle += PI/180.0;
|
|
break;
|
|
case RIGHT: tank2CannonAngle -= PI/180.0;
|
|
break;
|
|
case UP: tank2CannonStrength += 1;
|
|
break;
|
|
case DOWN: tank2CannonStrength -= 1;
|
|
break;
|
|
}
|
|
tank2CannonAngle = validateAngle(tank2CannonAngle);
|
|
tank2CannonStrength = validateStrength(tank2CannonStrength);
|
|
}
|
|
break;
|
|
|
|
// Space bar fires the projectile. Initially in step 2, just have it switch
|
|
// to the next player.
|
|
case ' ':
|
|
// Set boolean variables and projectile positions relative to the current
|
|
// player's tank.
|
|
if(player1Turn) {
|
|
projectileInMotion = true;
|
|
projectilePositionX = tank1CannonX2;
|
|
projectilePositionY = tank1CannonY2;
|
|
velocity = tank1CannonStrength;
|
|
// Generate projectile based on global variables
|
|
drawProjectile();
|
|
}
|
|
else {
|
|
projectileInMotion = true;
|
|
projectilePositionX = tank2CannonX2;
|
|
projectilePositionY = tank2CannonY2;
|
|
velocity = tank2CannonStrength;
|
|
drawProjectile();
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|