/*************************************************************************************
Neon Tower Defence

Designed, Programmed and Tested by:
Kyle Budge
For additional notes or for rough sketches see attached pages.
 
Created as Assignment #3 (Object-Oriented Interactive Toy) for:
Nicolas Hesler
Introduction to Media Computation
 
Designed, programmed and tested with Processing v3.2.1
*************************************************************************************/

/*
Instructions:
1. Pick up towers by clicking on a button at the bottom of the screen.
  Each button is a seperate tower.
  The towers on the left are weak, the towers on the right are strong.
  Use SHIFT to return a tower to storage BEFORE placing it on the grid.
2. Place tower on the grid in desired location.
  Don't worry about overlapping anything, the game handles that.
3. Place as many towers as you want in as many locations as you want.
4. Press CONTROL when ready to start your first wave!
  While wave is running you can not place new towers.
5. When the wave is over you may place more towers and start a new wave.
*/

/*
Programmer Notes
A very ambitious project that is still a day or two away from complete implementation.
Things which were not included due to time constraints are health systems for enemies,
tower's causing actual damage, a limit to the number of towers that can be placed, and
a procedural difficulty system that adjusts as you play.
Most of this can be found in pieces through variables or functions.
As of now, the toy is designed to look pretty on the first wave.
*/

//Global Variables

//Grid Object Variables
Grid[] verticalGrid = new Grid[34];
Grid[] horizontalGrid = new Grid[26];
boolean initialGridRequired=true;

//Pathway Object Variables
int[] pathwayBoundaryX = {125,200,150,200,50,150,50,100,100,300,250,300,300,450,400,450,450,550,500,550,550,650,600,650,650,750,700,750};
int[] pathwayBoundaryY = {350,400,200,350,200,250,50,200,50,100,100,350,300,350,200,300,200,250,100,200,100,150,150,400,350,400,125,350};
int[] pathwayCheckpointsX = {175,175,75,75,275,275,425,425,525,525,625,625,725,725};
int[] pathwayCheckpointsY = {375,225,225,75,75,325,325,225,225,125,125,375,375,75};
Pathway[] enemyPathway = new Pathway[14];
boolean initialPathwayRequired=true;

//Start and End House Variables
House startHouse = new House(0);
House endHouse = new House(1);

//Tower Storage Box Variables
TowerStorageBox[] towerStorageBoxArray = new TowerStorageBox[3];
boolean initialTowerStorageBoxRequired=true;

//Tower Variables
LightTower[] lightTowers = new LightTower[0];
LightTower[] lightTowerButtons = new LightTower[6];
int lightTowerPressedButton;
MediumTower[] mediumTowers = new MediumTower[0];
MediumTower[] mediumTowerButtons = new MediumTower[6];
int mediumTowerPressedButton;
HeavyTower[] heavyTowers = new HeavyTower[0];
HeavyTower[] heavyTowerButtons = new HeavyTower[6];
int heavyTowerPressedButton;
char towerType;
boolean initialTowerButtonsRequired=true;

//Enemy Variables
EasyEnemy[] easyEnemies = new EasyEnemy[0];
int easyEnemiesDefeated=0;
MediumEnemy[] mediumEnemies = new MediumEnemy[0];
int mediumEnemiesDefeated=0;
HardEnemy[] hardEnemies = new HardEnemy[0];
int hardEnemiesDefeated=0;

int waveDifficulty=50;
int easyEnemiesToCreate=0;
int mediumEnemiesToCreate=0;
int hardEnemiesToCreate=0;
int startTimer=millis();
boolean creatingEnemies=false;
boolean timeToCreateEnemy=false;
boolean waveRunning=false;

//General Variables
boolean pulsing = false;
int glowFrame = 0;
int strkWght=7;
boolean mouseIsFree=true;

//Setting up basic requirements and modes for the program.
void setup(){
  size(800,600);
  frameRate(60);
  smooth(2);
  rectMode(CORNERS);
  ellipseMode(CORNERS);
  colorMode(HSB,360,100,100,100);
  println("Place towers by clicking on one of the buttons at the bottom of the screen.");
  println("Place the tower anywhere on the grid, place as many towers as you like!");
  println("Use SHIFT to return a tower to storage before placing on the grid");
  println("Press CONTROL when you've placed enough towers to start the wave of enemies!");
}

//Run the entire program through main functions which call and build all the objects.
//All functions run "on initialization" for the first time using a boolean.
//This populates all the arrays while the funtion then keeps drawing everything on subsequent passes.
void draw(){
  background(262,66,36,100);
  glowAnimation();
  constructGrid();
  constructPathway();
  drawEnemies();
  startHouse.build();
  endHouse.build();
  constructTowerStorageBox();
  constructTowerButtons();
  constructTowers();
  buildAllTowers();
  allTowersAttack();
  
}

//Simple function to create a glow variable used when drawing all the objects.
void glowAnimation(){
  if(!pulsing){
    if (glowFrame<30){
      glowFrame++;
    } else if (glowFrame>=30){
      pulsing=true;
    }
  } else if(pulsing){
    if(glowFrame>0){
      glowFrame--;
    } else if(glowFrame<=0){
      pulsing=false;
    }
  }  
}

//Function that uses loops to create all of the grid lines in the background.
void constructGrid(){
  if (initialGridRequired){
    for (int lineCounter = 1;lineCounter<verticalGrid.length;lineCounter++){
      if (lineCounter<=horizontalGrid.length){
        verticalGrid[lineCounter-1]=new Grid(0,lineCounter);
        horizontalGrid[lineCounter-1]=new Grid(1,lineCounter);
      } else {
         verticalGrid[lineCounter-1]=new Grid(0,lineCounter);
      }
    }
    initialGridRequired=false;
  } else {
    for (int gridConstructor=0;gridConstructor<verticalGrid.length-1;gridConstructor++){
      if (gridConstructor<horizontalGrid.length-1){
      verticalGrid[gridConstructor].construct();
      horizontalGrid[gridConstructor].construct();
    } else {
      verticalGrid[gridConstructor].construct();
      }
    }
  }
}

//Function to create all of the pathway using smaller rectangles.
void constructPathway(){
  if (initialPathwayRequired){
    for (int pathwayCounter=0;pathwayCounter<pathwayBoundaryX.length;pathwayCounter+=2){
      enemyPathway[pathwayCounter/2]=new Pathway(pathwayCounter);
    }
    initialPathwayRequired=false;
  } else {
    for (int pathwayCounter=0;pathwayCounter<enemyPathway.length;pathwayCounter++){
      enemyPathway[pathwayCounter].build();
    }
  }
}

//Creates the boxes at the bottom of the screen to house to tower buttons.
//Does NOT create tower buttons.
void constructTowerStorageBox(){
  if (initialTowerStorageBoxRequired){
    for(int towerStorageBoxCounter=0;towerStorageBoxCounter<towerStorageBoxArray.length;towerStorageBoxCounter++){
      towerStorageBoxArray[towerStorageBoxCounter]=new TowerStorageBox(towerStorageBoxCounter);
    }
    initialTowerStorageBoxRequired=false;
  } else {
    for(int towerStorageBoxCounter=0;towerStorageBoxCounter<towerStorageBoxArray.length;towerStorageBoxCounter++){
      towerStorageBoxArray[towerStorageBoxCounter].build();
    }
  }
}

//Creates all of the buttons used to create the towers.
//Buttons are all scaled to be 50px by 50px instead of the usual tower size.
void constructTowerButtons(){
  if (initialTowerButtonsRequired){
    for (int towerButtonCounter=0;towerButtonCounter<lightTowerButtons.length;towerButtonCounter++){
      if (towerButtonCounter<=2){
        lightTowerButtons[towerButtonCounter] = new LightTower(towerButtonCounter,55+(80*towerButtonCounter),495);
        mediumTowerButtons[towerButtonCounter] = new MediumTower(towerButtonCounter,330+(80*towerButtonCounter),505);
        heavyTowerButtons[towerButtonCounter] = new HeavyTower(towerButtonCounter,580+(80*towerButtonCounter),495);
      } else {
        lightTowerButtons[towerButtonCounter] = new LightTower(towerButtonCounter,55+(80*(towerButtonCounter-3)),565);
        mediumTowerButtons[towerButtonCounter] = new MediumTower(towerButtonCounter,330+(80*(towerButtonCounter-3)),575);
        heavyTowerButtons[towerButtonCounter] = new HeavyTower(towerButtonCounter,580+(80*(towerButtonCounter-3)),565);
      }
    }
    initialTowerButtonsRequired=false;
  } else {
    for (int towerButtonCounter=0;towerButtonCounter<lightTowerButtons.length;towerButtonCounter++){
      lightTowerButtons[towerButtonCounter].buildButton(towerButtonCounter);
      mediumTowerButtons[towerButtonCounter].buildButton(towerButtonCounter);
      heavyTowerButtons[towerButtonCounter].buildButton(towerButtonCounter);
    }
  }
}

//This function is used by the buttons to actually create a tower when clicking on a button.
//Checks to see which button is pressed and creates a tower accordingly at regular size.
//Tower is erased and recreated in the array at the correct location to get the placement variables correct.
void constructTowers(){
  int placementXPosition=0;
  int placementYPosition=0;
  if (mouseIsFree){
    for (int towerButtonPressed=0;towerButtonPressed<lightTowerButtons.length;towerButtonPressed++){
      if (mousePressed && !waveRunning &&
          mouseX>=lightTowerButtons[towerButtonPressed].xBounding1 && mouseX<=lightTowerButtons[towerButtonPressed].xBounding2 && 
          mouseY>=lightTowerButtons[towerButtonPressed].yBounding1 && mouseY<=lightTowerButtons[towerButtonPressed].yBounding2){
        mouseIsFree=false;
        lightTowers = (LightTower[])append(lightTowers,new LightTower(towerButtonPressed,-100,-100));
        lightTowers[lightTowers.length-1].isBoundToMouse = true;
        lightTowerPressedButton=towerButtonPressed;
        towerType='l';
      }
      if (mousePressed && !waveRunning &&
          mouseX>=mediumTowerButtons[towerButtonPressed].buttonXBounding1 && mouseX<=mediumTowerButtons[towerButtonPressed].buttonXBounding2 && 
          mouseY>=mediumTowerButtons[towerButtonPressed].buttonYBounding1 && mouseY<=mediumTowerButtons[towerButtonPressed].buttonYBounding2){
        mouseIsFree=false;
        mediumTowers = (MediumTower[])append(mediumTowers,new MediumTower(towerButtonPressed,-100,-100));
        mediumTowers[mediumTowers.length-1].isBoundToMouse = true;
        mediumTowerPressedButton=towerButtonPressed;
        towerType='m';
      }
      if (mousePressed && !waveRunning &&
          mouseX>=heavyTowerButtons[towerButtonPressed].buttonXBounding1 && mouseX<=heavyTowerButtons[towerButtonPressed].buttonXBounding2 && 
          mouseY>=heavyTowerButtons[towerButtonPressed].buttonYBounding1 && mouseY<=heavyTowerButtons[towerButtonPressed].buttonYBounding2){
        mouseIsFree=false;
        heavyTowers = (HeavyTower[])append(heavyTowers,new HeavyTower(towerButtonPressed,-100,-100));
        heavyTowers[heavyTowers.length-1].isBoundToMouse = true;
        heavyTowerPressedButton=towerButtonPressed;
        towerType='h';
      }
    }
    //This little section binds everything to the grid correctly.
    //No matter where you wish to place the tower it will always snap to the closest grid location.
  } else if (!mouseIsFree) {
    if (mouseX%25<=12){
      placementXPosition=mouseX-(mouseX%25);
    } else {
      placementXPosition=mouseX+(25-(mouseX%25));
    }
    if (mouseY%25<=12){
      placementYPosition=mouseY-(mouseY%25);
    } else {
      placementYPosition=mouseY+(25-(mouseY%25));
    }
    //You will notice a call to a boolean function in here "isIntersecting", this will be explained in more detail at that function.
    //This call is to ensure that you aren't trying to place your tower over any other object.
    if(towerType=='l'){
      lightTowers[lightTowers.length-1].constructTower(lightTowerPressedButton);
      if (lightTowers[lightTowers.length-1].isBoundToMouse==true && mousePressed && !isInterecting(towerType,placementXPosition,placementYPosition)){
        mouseIsFree=true;
        lightTowers[lightTowers.length-1].isBoundToMouse=false;
        lightTowers[lightTowers.length-1] = new LightTower(lightTowerPressedButton,placementXPosition,placementYPosition);
      }
    }
    if(towerType=='m'){
      mediumTowers[mediumTowers.length-1].constructTower(mediumTowerPressedButton);
      if (mediumTowers[mediumTowers.length-1].isBoundToMouse==true && mousePressed && !isInterecting(towerType,placementXPosition,placementYPosition)){
        mouseIsFree=true;
        mediumTowers[mediumTowers.length-1].isBoundToMouse=false;
        mediumTowers[mediumTowers.length-1] = new MediumTower(mediumTowerPressedButton,placementXPosition,placementYPosition);
      }
    }
    if(towerType=='h'){
      heavyTowers[heavyTowers.length-1].constructTower(heavyTowerPressedButton);
      if (heavyTowers[heavyTowers.length-1].isBoundToMouse==true && mousePressed && !isInterecting(towerType,placementXPosition,placementYPosition)){
        mouseIsFree=true;
        heavyTowers[heavyTowers.length-1].isBoundToMouse=false;
        heavyTowers[heavyTowers.length-1] = new HeavyTower(heavyTowerPressedButton,placementXPosition,placementYPosition);
      }
    }
    //This "drops" your tower that you are holding back into storage, in case you want to pick a different tower.
    if (keyPressed && keyCode==SHIFT){
      mouseIsFree=true;
      if (towerType=='l'){
        lightTowers = (LightTower[])shorten(lightTowers);
      }
      if (towerType=='m'){
        mediumTowers = (MediumTower[])shorten(mediumTowers);
      }
      if (towerType=='h'){
        heavyTowers = (HeavyTower[])shorten(heavyTowers);
      }
    }
  }
}


//Function that scrolls through all of the tower arrays and draws the objects to the screen in the correct locations.
void buildAllTowers(){
  for (int towerNumber=0;towerNumber<lightTowers.length;towerNumber++){
    lightTowers[towerNumber].build(lightTowers[towerNumber].lightTowerVersion);
  }
  for (int towerNumber=0;towerNumber<mediumTowers.length;towerNumber++){
    mediumTowers[towerNumber].build(mediumTowers[towerNumber].mediumTowerVersion);
  }
  for (int towerNumber=0;towerNumber<heavyTowers.length;towerNumber++){
    heavyTowers[towerNumber].build(heavyTowers[towerNumber].heavyTowerVersion);
  }
}


//This function is multi-layered.
//First it scrolls through all of the tower arrays and all of the created enemy arrays.
//It compares the distance between the vectors for all of the objects and decides which objects are "within range".
//Enemies within range of the tower are shot at.
//When the towers shoot function is called it's passed the details of the enemy it is firing at to make sure it's using the right information.
void allTowersAttack(){
  //This runs the check for all the light towers.
  if(lightTowers.length>0){
    int enemyClass=0;
    int arrayPosition=0;
    for (int enemyFinderTower=0;enemyFinderTower<lightTowers.length;enemyFinderTower++){
      if (!lightTowers[enemyFinderTower].enemyLockedOn){
        for (int enemyFinderEnemy=0;enemyFinderEnemy<easyEnemies.length;enemyFinderEnemy++){
          if (lightTowers[enemyFinderTower].bulletLocation.dist(easyEnemies[enemyFinderEnemy].centerPoint)<lightTowers[enemyFinderTower].firingRadius){
            enemyClass=1;
            arrayPosition=enemyFinderEnemy;
            lightTowers[enemyFinderTower].enemyLockedOn=true;
          }
        }
        for (int enemyFinderEnemy=0;enemyFinderEnemy<mediumEnemies.length;enemyFinderEnemy++){
          if (lightTowers[enemyFinderTower].bulletLocation.dist(mediumEnemies[enemyFinderEnemy].centerPoint)<lightTowers[enemyFinderTower].firingRadius){
            enemyClass=2;
            arrayPosition=enemyFinderEnemy;
            lightTowers[enemyFinderTower].enemyLockedOn=true;
          }
        }
        for (int enemyFinderEnemy=0;enemyFinderEnemy<hardEnemies.length;enemyFinderEnemy++){
          if (lightTowers[enemyFinderTower].bulletLocation.dist(hardEnemies[enemyFinderEnemy].centerPoint)<lightTowers[enemyFinderTower].firingRadius){
            enemyClass=3;
            arrayPosition=enemyFinderEnemy;
            lightTowers[enemyFinderTower].enemyLockedOn=true;
          }
        }
      }
      if (lightTowers[enemyFinderTower].enemyLockedOn){
        lightTowers[enemyFinderTower].shootEnemy(enemyClass,arrayPosition);
      }
    }
  }
  //This runs the check for all the medium towers.
  if(mediumTowers.length>0){
    int enemyClass=0;
    int arrayPosition=0;
    for (int enemyFinderTower=0;enemyFinderTower<mediumTowers.length;enemyFinderTower++){
      if (!mediumTowers[enemyFinderTower].enemyLockedOn){
        for (int enemyFinderEnemy=0;enemyFinderEnemy<easyEnemies.length;enemyFinderEnemy++){
          if (mediumTowers[enemyFinderTower].bulletLocation.dist(easyEnemies[enemyFinderEnemy].centerPoint)<mediumTowers[enemyFinderTower].firingRadius){
            enemyClass=1;
            arrayPosition=enemyFinderEnemy;
            mediumTowers[enemyFinderTower].enemyLockedOn=true;
          }
        }
        for (int enemyFinderEnemy=0;enemyFinderEnemy<mediumEnemies.length;enemyFinderEnemy++){
          if (mediumTowers[enemyFinderTower].bulletLocation.dist(mediumEnemies[enemyFinderEnemy].centerPoint)<mediumTowers[enemyFinderTower].firingRadius){
            enemyClass=2;
            arrayPosition=enemyFinderEnemy;
            mediumTowers[enemyFinderTower].enemyLockedOn=true;
          }
        }
        for (int enemyFinderEnemy=0;enemyFinderEnemy<hardEnemies.length;enemyFinderEnemy++){
          if (mediumTowers[enemyFinderTower].bulletLocation.dist(hardEnemies[enemyFinderEnemy].centerPoint)<mediumTowers[enemyFinderTower].firingRadius){
            enemyClass=3;
            arrayPosition=enemyFinderEnemy;
            mediumTowers[enemyFinderTower].enemyLockedOn=true;
          }
        }
      }
      if (mediumTowers[enemyFinderTower].enemyLockedOn){
        mediumTowers[enemyFinderTower].shootEnemy(enemyClass,arrayPosition);
      }
    }
  }
  //This runs the check for all the heavy towers.
  if(heavyTowers.length>0){
    int enemyClass=0;
    int arrayPosition=0;
    for (int enemyFinderTower=0;enemyFinderTower<heavyTowers.length;enemyFinderTower++){
      if (!heavyTowers[enemyFinderTower].enemyLockedOn){
        for (int enemyFinderEnemy=0;enemyFinderEnemy<easyEnemies.length;enemyFinderEnemy++){
          if (heavyTowers[enemyFinderTower].bulletLocation.dist(easyEnemies[enemyFinderEnemy].centerPoint)<heavyTowers[enemyFinderTower].firingRadius){
            enemyClass=1;
            arrayPosition=enemyFinderEnemy;
            heavyTowers[enemyFinderTower].enemyLockedOn=true;
          }
        }
        for (int enemyFinderEnemy=0;enemyFinderEnemy<mediumEnemies.length;enemyFinderEnemy++){
          if (heavyTowers[enemyFinderTower].bulletLocation.dist(mediumEnemies[enemyFinderEnemy].centerPoint)<heavyTowers[enemyFinderTower].firingRadius){
            enemyClass=2;
            arrayPosition=enemyFinderEnemy;
            heavyTowers[enemyFinderTower].enemyLockedOn=true;
          }
        }
        for (int enemyFinderEnemy=0;enemyFinderEnemy<hardEnemies.length;enemyFinderEnemy++){
          if (heavyTowers[enemyFinderTower].bulletLocation.dist(hardEnemies[enemyFinderEnemy].centerPoint)<heavyTowers[enemyFinderTower].firingRadius){
            enemyClass=3;
            arrayPosition=enemyFinderEnemy;
            heavyTowers[enemyFinderTower].enemyLockedOn=true;
          }
        }
      }
      if (heavyTowers[enemyFinderTower].enemyLockedOn){
        heavyTowers[enemyFinderTower].shootEnemy(enemyClass,arrayPosition);
      }
    }
  }
}

//First this function checks to see if you want to start running the wave of enemies by pressing CONTROL.
//Then the function creates a new enemy based on a set of parameters in each of the enemy classes (easy, medium, hard).
//Once all the enemies are created it keeps them moving through the pathway towards the end.
void drawEnemies(){
  //This section starts the enemies flowing.
  if (keyPressed && keyCode==CONTROL && !waveRunning){
    creatingEnemies=true;
    waveRunning=true;
    easyEnemiesToCreate=waveDifficulty/2;
    mediumEnemiesToCreate=waveDifficulty/5;
    hardEnemiesToCreate=waveDifficulty/10;
  }
  //This is a mini timer to make sure enemies don't spawn all at once on top of each other
  if (creatingEnemies){
    if (millis()-startTimer>=1000 && !timeToCreateEnemy){
      timeToCreateEnemy=true;
      startTimer=millis();
    }
    if (timeToCreateEnemy){
      timeToCreateEnemy=false;
      if (hardEnemiesToCreate>0 && mediumEnemiesToCreate==0 && easyEnemiesToCreate==0 ){
        hardEnemies = (HardEnemy[])append(hardEnemies,new HardEnemy(floor(random(0,3))));
        hardEnemiesToCreate--;
      }
      if (mediumEnemiesToCreate>0 && easyEnemiesToCreate==0){
        mediumEnemies = (MediumEnemy[])append(mediumEnemies,new MediumEnemy(floor(random(0,4))));
        mediumEnemiesToCreate--;
      }
      if (easyEnemiesToCreate>0){
        easyEnemies = (EasyEnemy[])append(easyEnemies,new EasyEnemy(floor(random(0,6))));
        easyEnemiesToCreate--;
      }
      if (easyEnemiesToCreate==0 && mediumEnemiesToCreate==0 && hardEnemiesToCreate==0){
        creatingEnemies=false;
      }
    }
  }
  if (waveRunning){
    //Drawing all of the enemies for each enemy class, if they hit the end they are removed from the window until every enemy reaches the end.
    if (easyEnemies.length>0){
      for (int easyEnemyNumber=0;easyEnemyNumber<easyEnemies.length;easyEnemyNumber++){
        easyEnemies[easyEnemyNumber].move();
        easyEnemies[easyEnemyNumber].build(easyEnemies[easyEnemyNumber].easyEnemyType);
        if (easyEnemies[easyEnemyNumber].centerPoint.x==pathwayCheckpointsX[13] && easyEnemies[easyEnemyNumber].centerPoint.y==pathwayCheckpointsY[13]){
          easyEnemies[easyEnemyNumber].centerPoint.x=-200;
          easyEnemies[easyEnemyNumber].centerPoint.y=-200;
          easyEnemiesDefeated++;
          if (waveDifficulty>1){
            waveDifficulty--;
          }
          if (easyEnemiesDefeated==easyEnemies.length){
            easyEnemies = new EasyEnemy[0];
          }
        }
      }
    }
    if (mediumEnemies.length>0){
      for (int mediumEnemyNumber=0;mediumEnemyNumber<mediumEnemies.length;mediumEnemyNumber++){
        mediumEnemies[mediumEnemyNumber].move();
        mediumEnemies[mediumEnemyNumber].build(mediumEnemies[mediumEnemyNumber].mediumEnemyType);
        if (mediumEnemies[mediumEnemyNumber].centerPoint.x==pathwayCheckpointsX[13] && mediumEnemies[mediumEnemyNumber].centerPoint.y==pathwayCheckpointsY[13]){
          mediumEnemies[mediumEnemyNumber].centerPoint.x=-200;
          mediumEnemies[mediumEnemyNumber].centerPoint.y=-200;
          mediumEnemiesDefeated++;
          if (waveDifficulty>2){
            waveDifficulty-=2;
          }
          if (mediumEnemiesDefeated==mediumEnemies.length){
            mediumEnemies = new MediumEnemy[0];
          }
        }
      }
    }
    if (hardEnemies.length>0){
      for (int hardEnemyNumber=0;hardEnemyNumber<hardEnemies.length;hardEnemyNumber++){
        hardEnemies[hardEnemyNumber].move();
        hardEnemies[hardEnemyNumber].build(hardEnemies[hardEnemyNumber].hardEnemyType);
        if (hardEnemies[hardEnemyNumber].centerPoint.x==pathwayCheckpointsX[13] && hardEnemies[hardEnemyNumber].centerPoint.y==pathwayCheckpointsY[13]){
          hardEnemies[hardEnemyNumber].centerPoint.x=-200;
          hardEnemies[hardEnemyNumber].centerPoint.y=-200;
          hardEnemiesDefeated++;
          if (waveDifficulty>3){
            waveDifficulty-=3;
          }
          if (hardEnemiesDefeated==hardEnemies.length){
            hardEnemies = new HardEnemy[0];
          }
        }
      }
    }
  }  
  
  if (easyEnemies.length==0 && mediumEnemies.length==0 && hardEnemies.length==0){
    waveRunning=false;
  }
}


//This function is only ever when placing a tower.
//Checks to make sure you can't place your tower on any other object.
//Cycles through all objects in all arrays to ensure accuracy.
//Even if more objects are added the function handles the new array sizes properly.
boolean isInterecting(char towerType, int currentX, int currentY){
  int upperLeftX = 0, upperLeftY = 0, lowerRightX = 0, lowerRightY = 0;
  //This section lets you place the tower so the corner can overlap in some spots.
  //Makes it so you don't have to leave a full square empty between objects.
  switch(towerType){
    case 'l':
      upperLeftX = currentX-24;
      upperLeftY = currentY-24;
      lowerRightX = currentX+24;
      lowerRightY = currentY+24;
      break;
    case 'm':
      upperLeftX = currentX-49;
      upperLeftY = currentY-49;
      lowerRightX = currentX+24;
      lowerRightY = currentY+24;
      break;
    case 'h':
      upperLeftX = currentX-49;
      upperLeftY = currentY-49;
      lowerRightX = currentX+49;
      lowerRightY = currentY+49;
      break;
  }
  //Checks intersections for all possible light towers.
  for (int towerCounter=0;towerCounter<lightTowers.length;towerCounter++){
    if (upperLeftX>=lightTowers[towerCounter].xBounding1 && upperLeftX<=lightTowers[towerCounter].xBounding2 && 
        upperLeftY>=lightTowers[towerCounter].yBounding1 && upperLeftY<=lightTowers[towerCounter].yBounding2){
      return true;
    }
    if (lowerRightX>=lightTowers[towerCounter].xBounding1 && lowerRightX<=lightTowers[towerCounter].xBounding2 && 
        lowerRightY>=lightTowers[towerCounter].yBounding1 && lowerRightY<=lightTowers[towerCounter].yBounding2){
      return true;
    }
    if (currentX>=lightTowers[towerCounter].xBounding1 && currentX<=lightTowers[towerCounter].xBounding2 && 
        currentY>=lightTowers[towerCounter].yBounding1 && currentY<=lightTowers[towerCounter].yBounding2){
      return true;
    }
  }
  //Checks intersections for all possible medium towers.
  for (int towerCounter=0;towerCounter<mediumTowers.length;towerCounter++){
    if (upperLeftX>=mediumTowers[towerCounter].xBounding1 && upperLeftX<=mediumTowers[towerCounter].xBounding2 && 
        upperLeftY>=mediumTowers[towerCounter].yBounding1 && upperLeftY<=mediumTowers[towerCounter].yBounding2){
      return true;
    }
    if (lowerRightX>=mediumTowers[towerCounter].xBounding1 && lowerRightX<=mediumTowers[towerCounter].xBounding2 && 
        lowerRightY>=mediumTowers[towerCounter].yBounding1 && lowerRightY<=mediumTowers[towerCounter].yBounding2){
      return true;
    }
    if (currentX>=mediumTowers[towerCounter].xBounding1 && currentX<=mediumTowers[towerCounter].xBounding2 && 
        currentY>=mediumTowers[towerCounter].yBounding1 && currentY<=mediumTowers[towerCounter].yBounding2){
      return true;
    }
  }
  //Checks intersections for all possible heavy towers.
  for (int towerCounter=0;towerCounter<heavyTowers.length;towerCounter++){
    if (upperLeftX>=heavyTowers[towerCounter].xBounding1 && upperLeftX<=heavyTowers[towerCounter].xBounding2 && 
        upperLeftY>=heavyTowers[towerCounter].yBounding1 && upperLeftY<=heavyTowers[towerCounter].yBounding2){
      return true;
    }
    if (lowerRightX>=heavyTowers[towerCounter].xBounding1 && lowerRightX<=heavyTowers[towerCounter].xBounding2 && 
        lowerRightY>=heavyTowers[towerCounter].yBounding1 && lowerRightY<=heavyTowers[towerCounter].yBounding2){
      return true;
    }
    if (currentX>=heavyTowers[towerCounter].xBounding1 && currentX<=heavyTowers[towerCounter].xBounding2 && 
        currentY>=heavyTowers[towerCounter].yBounding1 && currentY<=heavyTowers[towerCounter].yBounding2){
      return true;
    }
  }
  
  //Checks intersections will all sections of the entire pathway.
  for (int pathwayCounter=0;pathwayCounter<enemyPathway.length;pathwayCounter++){
    if (upperLeftX>=enemyPathway[pathwayCounter].startingX && upperLeftX<=enemyPathway[pathwayCounter].endingX &&
        upperLeftY>=enemyPathway[pathwayCounter].startingY && upperLeftY<=enemyPathway[pathwayCounter].endingY){
      return true;
    }
    if (lowerRightX>=enemyPathway[pathwayCounter].startingX && lowerRightX<=enemyPathway[pathwayCounter].endingX &&
        lowerRightY>=enemyPathway[pathwayCounter].startingY && lowerRightY<=enemyPathway[pathwayCounter].endingY){
      return true;
    }
    if (currentX>=enemyPathway[pathwayCounter].startingX && currentX<=enemyPathway[pathwayCounter].endingX &&
        currentY>=enemyPathway[pathwayCounter].startingY && currentY<=enemyPathway[pathwayCounter].endingY){
      return true;
    }
  }
  
  //Checks intersections with all of the tower storage boxes.
  for (int towerStorageBoxCounter=0;towerStorageBoxCounter<towerStorageBoxArray.length;towerStorageBoxCounter++){
    if (upperLeftX>=towerStorageBoxArray[towerStorageBoxCounter].startingX && upperLeftX<=towerStorageBoxArray[towerStorageBoxCounter].endingX &&
        upperLeftY>=towerStorageBoxArray[towerStorageBoxCounter].startingY && upperLeftY<=towerStorageBoxArray[towerStorageBoxCounter].endingY){
      return true;
    }
    if (lowerRightX>=towerStorageBoxArray[towerStorageBoxCounter].startingX && lowerRightX<=towerStorageBoxArray[towerStorageBoxCounter].endingX &&
        lowerRightY>=towerStorageBoxArray[towerStorageBoxCounter].startingY && lowerRightY<=towerStorageBoxArray[towerStorageBoxCounter].endingY){
      return true;
    }
    if (currentX>=towerStorageBoxArray[towerStorageBoxCounter].startingX && currentX<=towerStorageBoxArray[towerStorageBoxCounter].endingX &&
        currentY>=towerStorageBoxArray[towerStorageBoxCounter].startingY && currentY<=towerStorageBoxArray[towerStorageBoxCounter].endingY){
      return true;
    }
  }
  
  //Checks intersections with the start and end zones.
  if (upperLeftX>=startHouse.startingX && upperLeftX<=startHouse.endingX &&
      upperLeftY>=startHouse.startingY && upperLeftY<=startHouse.endingY){
    return true; 
  }
  if (lowerRightX>=startHouse.startingX && lowerRightX<=startHouse.endingX &&
      lowerRightY>=startHouse.startingY && lowerRightY<=startHouse.endingY){
    return true;
  }
  if (currentX>=startHouse.startingX && currentX<=startHouse.endingX &&
      currentY>=startHouse.startingY && currentY<=startHouse.endingY){
    return true;
  }
  
  if (upperLeftX>=endHouse.startingX && upperLeftX<=endHouse.endingX &&
      upperLeftY>=endHouse.startingY && upperLeftY<=endHouse.endingY){
    return true;
  }
  if (lowerRightX>=endHouse.startingX && lowerRightX<=endHouse.endingX &&
      lowerRightY>=endHouse.startingY && lowerRightY<=endHouse.endingY){
    return true;
  }
  if (currentX>=endHouse.startingX && currentX<=endHouse.endingX &&
      currentY>=endHouse.startingY && currentY<=endHouse.endingY){
    return true;
  }
  
  //Checks to make sure the entire tower is still within the window frame.
  if (currentX==250 || currentX==500 || currentX==775){
    if (currentY==450){
      return true;
    }
  }
  if (currentX>775 || currentX<=10){
    return true;
  }
  if (currentY<=10 || currentY>=600){
    return true;
  }
  return false;
}

//This class handles everything about the Easy Enemy class.
//Has a method to draw the enemy and update the position of the enemy. 

class EasyEnemy{
  float currentHealth;
  int easyEnemyType;
  int easyEnemyColour = 60;
  
  PVector centerPoint;
  float boundingDistance = 25/2;
  int movementSpeed = 1;
  PVector moveRightLeft= new PVector(movementSpeed,0);
  PVector moveUpDown= new PVector(0,movementSpeed);
  boolean movingRight=false;
  boolean movingLeft=false;
  boolean movingUp=false;
  boolean movingDown=false;
  
  EasyEnemy(int enemyType){
    centerPoint= new PVector(75,375);
    currentHealth = 10;
    easyEnemyType=enemyType;
  }
  
  void build(int enemyType){
    for(int lineNumber=1;lineNumber<=3;lineNumber++){
      noFill();
      strokeWeight((strkWght-2)-(2*(lineNumber-1)));
      stroke(easyEnemyColour,((30*lineNumber)-glowFrame),99,((30*lineNumber)-glowFrame));
      if (enemyType==0){
        if(movingRight){
          triangle(centerPoint.x-boundingDistance,centerPoint.y-boundingDistance,centerPoint.x-boundingDistance,centerPoint.y+boundingDistance,centerPoint.x+boundingDistance,centerPoint.y);
        } else if (movingLeft){
          triangle(centerPoint.x-boundingDistance,centerPoint.y,centerPoint.x+boundingDistance,centerPoint.y-boundingDistance,centerPoint.x+boundingDistance,centerPoint.y+boundingDistance);
        } else if (movingUp){
          triangle(centerPoint.x-boundingDistance,centerPoint.y+boundingDistance,centerPoint.x,centerPoint.y-boundingDistance,centerPoint.x+boundingDistance,centerPoint.y+boundingDistance);
        } else if (movingDown){
          triangle(centerPoint.x-boundingDistance,centerPoint.y-boundingDistance,centerPoint.x,centerPoint.y+boundingDistance,centerPoint.x+boundingDistance,centerPoint.y-boundingDistance);
        }
      } else if (enemyType==1){
        rect(centerPoint.x-boundingDistance,centerPoint.y-boundingDistance,centerPoint.x+boundingDistance,centerPoint.y+boundingDistance);
      } else if (enemyType==2){
        rect(centerPoint.x-boundingDistance,centerPoint.y-boundingDistance,centerPoint.x+boundingDistance,centerPoint.y+boundingDistance);
        line(centerPoint.x-boundingDistance,centerPoint.y-boundingDistance,centerPoint.x+boundingDistance,centerPoint.y+boundingDistance);
        line(centerPoint.x-boundingDistance,centerPoint.y+boundingDistance,centerPoint.x+boundingDistance,centerPoint.y-boundingDistance);
      } else if (enemyType==3){
        if(movingRight || movingLeft){
          quad(centerPoint.x-boundingDistance,centerPoint.y-boundingDistance,centerPoint.x+boundingDistance,centerPoint.y+boundingDistance,centerPoint.x-boundingDistance,centerPoint.y+boundingDistance,centerPoint.x+boundingDistance,centerPoint.y-boundingDistance);
        } else if (movingUp || movingDown){
          quad(centerPoint.x-boundingDistance,centerPoint.y-boundingDistance,centerPoint.x-boundingDistance,centerPoint.y+boundingDistance,centerPoint.x+boundingDistance,centerPoint.y-boundingDistance,centerPoint.x+boundingDistance,centerPoint.y+boundingDistance);
        }
      } else if (enemyType==4){
        if (movingRight || movingLeft){
          quad(centerPoint.x-boundingDistance,centerPoint.y-boundingDistance,centerPoint.x-boundingDistance,centerPoint.y+boundingDistance,centerPoint.x+boundingDistance,centerPoint.y-boundingDistance,centerPoint.x+boundingDistance,centerPoint.y+boundingDistance);
        } else if (movingUp || movingDown){
          quad(centerPoint.x-boundingDistance,centerPoint.y-boundingDistance,centerPoint.x+boundingDistance,centerPoint.y+boundingDistance,centerPoint.x-boundingDistance,centerPoint.y+boundingDistance,centerPoint.x+boundingDistance,centerPoint.y-boundingDistance);
        }
      } else if (enemyType==5){
        line(centerPoint.x-boundingDistance,centerPoint.y-boundingDistance,centerPoint.x+boundingDistance,centerPoint.y+boundingDistance);
        line(centerPoint.x-boundingDistance,centerPoint.y+boundingDistance,centerPoint.x+boundingDistance,centerPoint.y-boundingDistance);
      } else if (enemyType==6){
        ellipse(centerPoint.x-boundingDistance,centerPoint.y-boundingDistance,centerPoint.x+boundingDistance,centerPoint.y+boundingDistance);
      }
    }
  }
  
  void move(){
    if(centerPoint.x==75 && centerPoint.y==375){
      movingUp=false;
      movingDown=false;
      movingLeft=false;
      movingRight=true;
    }
    
    for(int pathwayCounter=0;pathwayCounter<pathwayCheckpointsX.length;pathwayCounter++){
      if (centerPoint.x==pathwayCheckpointsX[pathwayCounter] && centerPoint.y==pathwayCheckpointsY[pathwayCounter]){
        if (pathwayCounter==0 || pathwayCounter==2 || pathwayCounter==6 || pathwayCounter==8 || pathwayCounter==12){
          movingUp=true;
          movingDown=false;
          movingLeft=false;
          movingRight=false;
        } else if (pathwayCounter==4 || pathwayCounter==10){
          movingUp=false;
          movingDown=true;
          movingLeft=false;
          movingRight=false;
        } else if (pathwayCounter==1){
          movingUp=false;
          movingDown=false;
          movingLeft=true;
          movingRight=false;
        } else if (pathwayCounter==3 || pathwayCounter==5 || pathwayCounter==7 || pathwayCounter==9 || pathwayCounter==11){
          movingUp=false;
          movingDown=false;
          movingLeft=false;
          movingRight=true;
        } else if (pathwayCounter==13){
          movingUp=false;
          movingDown=false;
          movingLeft=false;
          movingRight=false;
        }
      }
    }
    
    if(movingRight){
      centerPoint.add(moveRightLeft);
    } else if (movingLeft){
      centerPoint.sub(moveRightLeft);
    } else if (movingUp){
      centerPoint.sub(moveUpDown);
    } else if (movingDown){
      centerPoint.add(moveUpDown);
    }
  }
}

//This class handles everything to do with the grid lines and drawing them.

class Grid{
  //Class Variables
  int startingX;
  int startingY;
  int endingX;
  int endingY;
  
  Grid(int verticalHorizontal, int lineNumber){
    if (verticalHorizontal==0){
      startingX=25*(lineNumber-1);
      endingX=startingX;
      startingY=0;
      endingY=height;
    } else if (verticalHorizontal==1){
      startingX=0;
      endingX=width;
      startingY=25*(lineNumber-1);
      endingY=startingY;
    }    
  }
  
  void construct(){
    for(int lineLayer=1;lineLayer<=4;lineLayer++){
      strokeWeight(strkWght-(2*(lineLayer-1)));
      stroke(0,0,50,30*lineLayer);
      line(startingX,startingY,endingX,endingY);
    }
  }
}

//This class handles everything about the Hard Enemy class.
//Has a method to draw the enemy and update the position of the enemy.

class HardEnemy{
  float currentHealth;
  int hardEnemyType;
  int hardEnemyColour = 0;
  
  PVector centerPoint;
  float boundingDistance = 25;
  int movementSpeed = 1;
  PVector moveRightLeft= new PVector(movementSpeed,0);
  PVector moveUpDown= new PVector(0,movementSpeed);
  boolean movingRight=false;
  boolean movingLeft=false;
  boolean movingUp=false;
  boolean movingDown=false;
  
  HardEnemy(int enemyType){
    centerPoint= new PVector(75,375);
    currentHealth = 40;
    hardEnemyType=enemyType;
  }
  
  void build(int enemyType){
    for(int lineNumber=1;lineNumber<=3;lineNumber++){
      noFill();
      strokeWeight((strkWght-2)-(2*(lineNumber-1)));
      stroke(hardEnemyColour,((30*lineNumber)-glowFrame),99,((30*lineNumber)-glowFrame));
      if (enemyType==0){
        rect(centerPoint.x-boundingDistance,centerPoint.y-boundingDistance,centerPoint.x+boundingDistance,centerPoint.y+boundingDistance);
      } else if (enemyType==1){
        line(centerPoint.x-boundingDistance,centerPoint.y-boundingDistance,centerPoint.x+boundingDistance,centerPoint.y+boundingDistance);
        line(centerPoint.x-boundingDistance,centerPoint.y+boundingDistance,centerPoint.x+boundingDistance,centerPoint.y-boundingDistance);
        quad(centerPoint.x-boundingDistance,centerPoint.y,centerPoint.x,centerPoint.y-boundingDistance,centerPoint.x+boundingDistance,centerPoint.y,centerPoint.x,centerPoint.y+boundingDistance);
      } else if (enemyType==2){
        line(centerPoint.x-boundingDistance,centerPoint.y-boundingDistance,centerPoint.x+boundingDistance,centerPoint.y+boundingDistance);
        line(centerPoint.x-boundingDistance,centerPoint.y+boundingDistance,centerPoint.x+boundingDistance,centerPoint.y-boundingDistance);
      } else if (enemyType==3){
        ellipse(centerPoint.x-boundingDistance,centerPoint.y-boundingDistance,centerPoint.x,centerPoint.y);
        ellipse(centerPoint.x,centerPoint.y-boundingDistance,centerPoint.x+boundingDistance,centerPoint.y);
        ellipse(centerPoint.x-boundingDistance,centerPoint.y,centerPoint.x,centerPoint.y+boundingDistance);
        ellipse(centerPoint.x,centerPoint.y,centerPoint.x+boundingDistance,centerPoint.y+boundingDistance);
      }
    }
  }
  
  void move(){
    if(centerPoint.x==75 && centerPoint.y==375){
      movingUp=false;
      movingDown=false;
      movingLeft=false;
      movingRight=true;
    }
    
    for(int pathwayCounter=0;pathwayCounter<pathwayCheckpointsX.length;pathwayCounter++){
      if (centerPoint.x==pathwayCheckpointsX[pathwayCounter] && centerPoint.y==pathwayCheckpointsY[pathwayCounter]){
        if (pathwayCounter==0 || pathwayCounter==2 || pathwayCounter==6 || pathwayCounter==8 || pathwayCounter==12){
          movingUp=true;
          movingDown=false;
          movingLeft=false;
          movingRight=false;
        } else if (pathwayCounter==4 || pathwayCounter==10){
          movingUp=false;
          movingDown=true;
          movingLeft=false;
          movingRight=false;
        } else if (pathwayCounter==1){
          movingUp=false;
          movingDown=false;
          movingLeft=true;
          movingRight=false;
        } else if (pathwayCounter==3 || pathwayCounter==5 || pathwayCounter==7 || pathwayCounter==9 || pathwayCounter==11){
          movingUp=false;
          movingDown=false;
          movingLeft=false;
          movingRight=true;
        } else if (pathwayCounter==13){
          movingUp=false;
          movingDown=false;
          movingLeft=false;
          movingRight=false;
        }
      }
    }
    
    if(movingRight){
      centerPoint.add(moveRightLeft);
    } else if (movingLeft){
      centerPoint.sub(moveRightLeft);
    } else if (movingUp){
      centerPoint.sub(moveUpDown);
    } else if (movingDown){
      centerPoint.add(moveUpDown);
    }
  }
}

//This class handles everything to do with the Heavy Tower's class.
//Has a method to construct the tower, draw the tower, draw the tower's button and shoot from the tower.

class HeavyTower{
  int xPoint1, yPoint1;
  int xPoint2, yPoint2;
  int xPoint3, yPoint3;
  int xPoint4, yPoint4;
  int xPoint5, yPoint5;
  int xPoint6, yPoint6;
  int xPoint7, yPoint7;
  int xPoint8, yPoint8;
  int xPoint9, yPoint9;
  int xPoint10, yPoint10;
  int xPoint11, yPoint11;
  int xPoint12, yPoint12;
  int xBounding1, yBounding1;
  int xBounding2, yBounding2;
  
  float buttonXPoint1, buttonYPoint1;
  float buttonXPoint2, buttonYPoint2;
  float buttonXPoint3, buttonYPoint3;
  float buttonXPoint4, buttonYPoint4;
  float buttonXPoint5, buttonYPoint5;
  float buttonXPoint6, buttonYPoint6;
  float buttonXPoint7, buttonYPoint7;
  float buttonXPoint8, buttonYPoint8;
  float buttonXPoint9, buttonYPoint9;
  float buttonXPoint10, buttonYPoint10;
  float buttonXPoint11, buttonYPoint11;
  float buttonXPoint12, buttonYPoint12;
  float buttonXBounding1, buttonYBounding1;
  float buttonXBounding2, buttonYBounding2;
  
  float shrinkMultiplier = 0.5;
  
  float bulletDamage;
  int firingRadius;
  boolean enemyLockedOn;
  PVector bulletLocation;
  int heavyTowerColour = 283;
  boolean isBoundToMouse=false;
  int heavyTowerVersion;
  
  HeavyTower(int towerVersion, int referencePointX, int referencePointY){
    if (towerVersion==0){
      xPoint1 = referencePointX-50;
      buttonXPoint1 = referencePointX-(50*shrinkMultiplier);
      yPoint1 = referencePointY-50;
      buttonYPoint1 = referencePointY-(50*shrinkMultiplier);
      xPoint2 = referencePointX;
      buttonXPoint2 = referencePointX;
      yPoint2 = referencePointY+50;
      buttonYPoint2 = referencePointY+(50*shrinkMultiplier);
      xPoint3 = referencePointX;
      buttonXPoint3 = referencePointX;
      yPoint3 = referencePointY-50;
      buttonYPoint3 = referencePointY-(50*shrinkMultiplier);
      xPoint4 = referencePointX+50;
      buttonXPoint4 = referencePointX+(50*shrinkMultiplier);
      yPoint4 = referencePointY+50;
      buttonYPoint4 = referencePointY+(50*shrinkMultiplier);
      xPoint5 = referencePointX-25;
      buttonXPoint5 = referencePointX-(25*shrinkMultiplier);
      yPoint5 = referencePointY-50;
      buttonYPoint5 = referencePointY-(50*shrinkMultiplier);
      xPoint6 = referencePointX+25;
      buttonXPoint6 = referencePointX+(25*shrinkMultiplier);
      yPoint6 = referencePointY+50;
      buttonYPoint6 = referencePointY+(50*shrinkMultiplier);
      xPoint7 = referencePointX-50;
      buttonXPoint7 = referencePointX-(50*shrinkMultiplier);
      yPoint7 = referencePointY-25;
      buttonYPoint7 = referencePointY-(25*shrinkMultiplier);
      xPoint8 = referencePointX+50;
      buttonXPoint8 = referencePointX+(50*shrinkMultiplier);
      yPoint8 = referencePointY+25;
      buttonYPoint8 = referencePointY+(25*shrinkMultiplier);
      xPoint9 = referencePointX-50;
      buttonXPoint9 = referencePointX-(50*shrinkMultiplier);
      yPoint9 = referencePointY;
      buttonYPoint9 = referencePointY;
      xPoint10 = referencePointX+50;
      buttonXPoint10 = referencePointX+(50*shrinkMultiplier);
      yPoint10 = referencePointY;
      buttonYPoint10 = referencePointY;
    } else if (towerVersion==1){
      xPoint1 = referencePointX-50;
      buttonXPoint1 = referencePointX-(50*shrinkMultiplier);
      yPoint1 = referencePointY-50;
      buttonYPoint1 = referencePointY-(50*shrinkMultiplier);
      xPoint2 = referencePointX-25;
      buttonXPoint2 = referencePointX-(25*shrinkMultiplier);;
      yPoint2 = referencePointY-25;
      buttonYPoint2 = referencePointY-(25*shrinkMultiplier);
      xPoint3 = referencePointX+25;
      buttonXPoint3 = referencePointX+(25*shrinkMultiplier);
      yPoint3 = referencePointY-50;
      buttonYPoint3 = referencePointY-(50*shrinkMultiplier);
      xPoint4 = referencePointX+50;
      buttonXPoint4 = referencePointX+(50*shrinkMultiplier);
      yPoint4 = referencePointY-25;
      buttonYPoint4 = referencePointY-(25*shrinkMultiplier);
      xPoint5 = referencePointX-50;
      buttonXPoint5 = referencePointX-(50*shrinkMultiplier);
      yPoint5 = referencePointY+25;
      buttonYPoint5 = referencePointY+(25*shrinkMultiplier);
      xPoint6 = referencePointX-25;
      buttonXPoint6 = referencePointX-(25*shrinkMultiplier);
      yPoint6 = referencePointY+50;
      buttonYPoint6 = referencePointY+(50*shrinkMultiplier);
      xPoint7 = referencePointX+25;
      buttonXPoint7 = referencePointX+(25*shrinkMultiplier);
      yPoint7 = referencePointY+25;
      buttonYPoint7 = referencePointY+(25*shrinkMultiplier);
      xPoint8 = referencePointX+50;
      buttonXPoint8 = referencePointX+(50*shrinkMultiplier);
      yPoint8 = referencePointY+50;
      buttonYPoint8 = referencePointY+(50*shrinkMultiplier);
      xPoint9 = referencePointX-25;
      buttonXPoint9 = referencePointX-(25*shrinkMultiplier);
      yPoint9 = referencePointY-25;
      buttonYPoint9 = referencePointY-(25*shrinkMultiplier);
      xPoint10 = referencePointX+25;
      buttonXPoint10 = referencePointX+(25*shrinkMultiplier);
      yPoint10 = referencePointY+25;
      buttonYPoint10 = referencePointY+(25*shrinkMultiplier);
    } else if (towerVersion==2){
      xPoint1 = referencePointX;
      buttonXPoint1 = referencePointX;
      yPoint1 = referencePointY-50;
      buttonYPoint1 = referencePointY-(50*shrinkMultiplier);
      xPoint2 = referencePointX+50;
      buttonXPoint2 = referencePointX+(50*shrinkMultiplier);
      yPoint2 = referencePointY;
      buttonYPoint2 = referencePointY;
      xPoint3 = referencePointX-50;
      buttonXPoint3 = referencePointX-(50*shrinkMultiplier);
      yPoint3 = referencePointY;
      buttonYPoint3 = referencePointY;
      xPoint4 = referencePointX;
      buttonXPoint4 = referencePointX;
      yPoint4 = referencePointY+50;
      buttonYPoint4 = referencePointY+(50*shrinkMultiplier);
    } else if (towerVersion==3){
      xPoint1 = referencePointX-50;
      buttonXPoint1 = referencePointX-(50*shrinkMultiplier);
      yPoint1 = referencePointY-25;
      buttonYPoint1 = referencePointY-(25*shrinkMultiplier);
      xPoint2 = referencePointX-25;
      buttonXPoint2 = referencePointX-(25*shrinkMultiplier);
      yPoint2 = referencePointY;
      buttonYPoint2 = referencePointY;
      xPoint3 = referencePointX;
      buttonXPoint3 = referencePointX;
      yPoint3 = referencePointY+25;
      buttonYPoint3 = referencePointY+(25*shrinkMultiplier);
      xPoint4 = referencePointX+25;
      buttonXPoint4 = referencePointX+(25*shrinkMultiplier);
      yPoint4 = referencePointY+50;
      buttonYPoint4 = referencePointY+(50*shrinkMultiplier);
      xPoint5 = referencePointX-50;
      buttonXPoint5 = referencePointX-(50*shrinkMultiplier);
      yPoint5 = referencePointY+25;
      buttonYPoint5 = referencePointY+(25*shrinkMultiplier);
      xPoint6 = referencePointX-25;
      buttonXPoint6 = referencePointX-(25*shrinkMultiplier);
      yPoint6 = referencePointY+50;
      buttonYPoint6 = referencePointY+(50*shrinkMultiplier);
      xPoint7 = referencePointX-25;
      buttonXPoint7 = referencePointX-(25*shrinkMultiplier);
      yPoint7 = referencePointY;
      buttonYPoint7 = referencePointY;
      xPoint8 = referencePointX;
      buttonXPoint8 = referencePointX;
      yPoint8 = referencePointY+25;
      buttonYPoint8 = referencePointY+(25*shrinkMultiplier);
      xPoint9 = referencePointX;
      buttonXPoint9 = referencePointX;
      yPoint9 = referencePointY-25;
      buttonYPoint9 = referencePointY-(25*shrinkMultiplier);
      xPoint10 = referencePointX+25;
      buttonXPoint10 = referencePointX+(25*shrinkMultiplier);
      yPoint10 = referencePointY;
      buttonYPoint10 = referencePointY;
      xPoint11 = referencePointX+25;
      buttonXPoint11 = referencePointX+(25*shrinkMultiplier);
      yPoint11 = referencePointY-50;
      buttonYPoint11 = referencePointY-(50*shrinkMultiplier);
      xPoint12 = referencePointX+50;
      buttonXPoint12 = referencePointX+(50*shrinkMultiplier);
      yPoint12 = referencePointY-25;
      buttonYPoint12 = referencePointY-(25*shrinkMultiplier);
    } else if (towerVersion==4){
      xPoint1 = referencePointX-50;
      buttonXPoint1 = referencePointX-(50*shrinkMultiplier);
      yPoint1 = referencePointY-50;
      buttonYPoint1 = referencePointY-(50*shrinkMultiplier);
      xPoint2 = referencePointX+50;
      buttonXPoint2 = referencePointX+(50*shrinkMultiplier);
      yPoint2 = referencePointY+50;
      buttonYPoint2 = referencePointY+(50*shrinkMultiplier);
      xPoint3 = referencePointX-25;
      buttonXPoint3 = referencePointX-(25*shrinkMultiplier);
      yPoint3 = referencePointY-25;
      buttonYPoint3 = referencePointY-(25*shrinkMultiplier);
      xPoint4 = referencePointX+25;
      buttonXPoint4 = referencePointX+(25*shrinkMultiplier);
      yPoint4 = referencePointY+25;
      buttonYPoint4 = referencePointY+(25*shrinkMultiplier);
    } else if (towerVersion==5){
      xPoint1 = referencePointX-50;
      buttonXPoint1 = referencePointX-(50*shrinkMultiplier);
      yPoint1 = referencePointY-50;
      buttonYPoint1 = referencePointY-(50*shrinkMultiplier);
      xPoint2 = referencePointX;
      buttonXPoint2 = referencePointX;
      yPoint2 = referencePointY;
      buttonYPoint2 = referencePointY;
      xPoint3 = referencePointX;
      buttonXPoint3 = referencePointX;
      yPoint3 = referencePointY-50;
      buttonYPoint3 = referencePointY-(50*shrinkMultiplier);
      xPoint4 = referencePointX+50;
      buttonXPoint4 = referencePointX+(50*shrinkMultiplier);
      yPoint4 = referencePointY;
      buttonYPoint4 = referencePointY;
      xPoint5 = referencePointX-50;
      buttonXPoint5 = referencePointX-(50*shrinkMultiplier);
      yPoint5 = referencePointY;
      buttonYPoint5 = referencePointY;
      xPoint6 = referencePointX;
      buttonXPoint6 = referencePointX;
      yPoint6 = referencePointY+50;
      buttonYPoint6 = referencePointY+(50*shrinkMultiplier);
      xPoint7 = referencePointX;
      buttonXPoint7 = referencePointX;
      yPoint7 = referencePointY;
      buttonYPoint7 = referencePointY;
      xPoint8 = referencePointX+50;
      buttonXPoint8 = referencePointX+(50*shrinkMultiplier);
      yPoint8 = referencePointY+50;
      buttonYPoint8 = referencePointY+(50*shrinkMultiplier);
      xPoint9 = referencePointX-25;
      buttonXPoint9 = referencePointX-(25*shrinkMultiplier);
      yPoint9 = referencePointY-25;
      buttonYPoint9 = referencePointY-(25*shrinkMultiplier);
      xPoint10 = referencePointX+25;
      buttonXPoint10 = referencePointX+(25*shrinkMultiplier);
      yPoint10 = referencePointY+25;
      buttonYPoint10 = referencePointY+(25*shrinkMultiplier);
    }
    xBounding1 = referencePointX-50;
    yBounding1 = referencePointY-50;
    xBounding2 = referencePointX+50;
    yBounding2 = referencePointY+50;
    buttonXBounding1 = referencePointX-(50*shrinkMultiplier);
    buttonYBounding1 = referencePointY-(50*shrinkMultiplier);
    buttonXBounding2 = referencePointX+(50*shrinkMultiplier);
    buttonYBounding2 = referencePointY+(50*shrinkMultiplier);
    heavyTowerVersion=towerVersion;
    bulletDamage=8/60;
    firingRadius=200;
    enemyLockedOn=false;
    bulletLocation= new PVector(referencePointX,referencePointY);
  }
  
  void build(int towerVersion){
    for(int lineNumber=1;lineNumber<=4;lineNumber++){
      noFill();
      strokeWeight(strkWght-(2*(lineNumber-1)));
      stroke(heavyTowerColour,((30*lineNumber)-glowFrame),99,((30*lineNumber)-glowFrame));
      if (towerVersion==0){
        rect(xPoint1,yPoint1,xPoint2,yPoint2);
        rect(xPoint3,yPoint3,xPoint4,yPoint4);
        rect(xPoint5,yPoint5,xPoint6,yPoint6);
        rect(xPoint7,yPoint7,xPoint8,yPoint8);
        line(xPoint9,yPoint9,xPoint10,yPoint10);
      } else if (towerVersion==1){
        rect(xPoint1,yPoint1,xPoint2,yPoint2);
        rect(xPoint3,yPoint3,xPoint4,yPoint4);
        rect(xPoint5,yPoint5,xPoint6,yPoint6);
        rect(xPoint7,yPoint7,xPoint8,yPoint8);
        rect(xPoint9,yPoint9,xPoint10,yPoint10);
      } else if (towerVersion==2){
        rect(xPoint1,yPoint1,xPoint2,yPoint2);
        rect(xPoint3,yPoint3,xPoint4,yPoint4);
      } else if (towerVersion==3){
        rect(xPoint1,yPoint1,xPoint2,yPoint2);
        rect(xPoint3,yPoint3,xPoint4,yPoint4);
        rect(xPoint5,yPoint5,xPoint6,yPoint6);
        rect(xPoint7,yPoint7,xPoint8,yPoint8);
        rect(xPoint9,yPoint9,xPoint10,yPoint10);
        rect(xPoint11,yPoint11,xPoint12,yPoint12);
      } else if (towerVersion==4){
        ellipse(xPoint1,yPoint1,xPoint2,yPoint2);
        ellipse(xPoint3,yPoint3,xPoint4,yPoint4);
      } else if (towerVersion==5){
        ellipse(xPoint1,yPoint1,xPoint2,yPoint2);
        ellipse(xPoint3,yPoint3,xPoint4,yPoint4);
        ellipse(xPoint5,yPoint5,xPoint6,yPoint6);
        ellipse(xPoint7,yPoint7,xPoint8,yPoint8);
        ellipse(xPoint9,yPoint9,xPoint10,yPoint10);
      }
    } 
  }
  
  void buildButton(int towerVersion){
    for(int lineNumber=1;lineNumber<=4;lineNumber++){
      noFill();
      strokeWeight(strkWght-(2*(lineNumber-1)));
      stroke(heavyTowerColour,((30*lineNumber)),99,((30*lineNumber)));
      if (towerVersion==0){
        rect(buttonXPoint1,buttonYPoint1,buttonXPoint2,buttonYPoint2);
        rect(buttonXPoint3,buttonYPoint3,buttonXPoint4,buttonYPoint4);
        rect(buttonXPoint5,buttonYPoint5,buttonXPoint6,buttonYPoint6);
        rect(buttonXPoint7,buttonYPoint7,buttonXPoint8,buttonYPoint8);
        line(buttonXPoint9,buttonYPoint9,buttonXPoint10,buttonYPoint10);
      } else if (towerVersion==1){
        rect(buttonXPoint1,buttonYPoint1,buttonXPoint2,buttonYPoint2);
        rect(buttonXPoint3,buttonYPoint3,buttonXPoint4,buttonYPoint4);
        rect(buttonXPoint5,buttonYPoint5,buttonXPoint6,buttonYPoint6);
        rect(buttonXPoint7,buttonYPoint7,buttonXPoint8,buttonYPoint8);
        rect(buttonXPoint9,buttonYPoint9,buttonXPoint10,buttonYPoint10);
      } else if (towerVersion==2){
        rect(buttonXPoint1,buttonYPoint1,buttonXPoint2,buttonYPoint2);
        rect(buttonXPoint3,buttonYPoint3,buttonXPoint4,buttonYPoint4);
      } else if (towerVersion==3){
        rect(buttonXPoint1,buttonYPoint1,buttonXPoint2,buttonYPoint2);
        rect(buttonXPoint3,buttonYPoint3,buttonXPoint4,buttonYPoint4);
        rect(buttonXPoint5,buttonYPoint5,buttonXPoint6,buttonYPoint6);
        rect(buttonXPoint7,buttonYPoint7,buttonXPoint8,buttonYPoint8);
        rect(buttonXPoint9,buttonYPoint9,buttonXPoint10,buttonYPoint10);
        rect(buttonXPoint11,buttonYPoint11,buttonXPoint12,buttonYPoint12);
      } else if (towerVersion==4){
        ellipse(buttonXPoint1,buttonYPoint1,buttonXPoint2,buttonYPoint2);
        ellipse(buttonXPoint3,buttonYPoint3,buttonXPoint4,buttonYPoint4);
      } else if (towerVersion==5){
        ellipse(buttonXPoint1,buttonYPoint1,buttonXPoint2,buttonYPoint2);
        ellipse(buttonXPoint3,buttonYPoint3,buttonXPoint4,buttonYPoint4);
        ellipse(buttonXPoint5,buttonYPoint5,buttonXPoint6,buttonYPoint6);
        ellipse(buttonXPoint7,buttonYPoint7,buttonXPoint8,buttonYPoint8);
        ellipse(buttonXPoint9,buttonYPoint9,buttonXPoint10,buttonYPoint10);
        }
      } 
    }
  
  void constructTower(int towerVersion){
    if (isBoundToMouse){
      for(int lineNumber=1;lineNumber<=4;lineNumber++){
        noFill();
        strokeWeight(strkWght-(2*(lineNumber-1)));
        stroke(heavyTowerColour,30*lineNumber,99,30*lineNumber);
        if (towerVersion==0){
          rect(mouseX-50,mouseY-50,mouseX,mouseY+50);
          rect(mouseX,mouseY-50,mouseX+50,mouseY+50);
          rect(mouseX-25,mouseY-50,mouseX+25,mouseY+50);
          rect(mouseX-50,mouseY-25,mouseX+50,mouseY+25);
          line(mouseX-50,mouseY,mouseX+50,mouseY);
        } else if (towerVersion==1){
          rect(mouseX-50,mouseY-50,mouseX-25,mouseY-25);
          rect(mouseX+25,mouseY-50,mouseX+50,mouseY-25);
          rect(mouseX-50,mouseY+25,mouseX-25,mouseY+50);
          rect(mouseX+25,mouseY+25,mouseX+50,mouseY+50);
          rect(mouseX-25,mouseY-25,mouseX+25,mouseY+25);
        } else if (towerVersion==2){
          rect(mouseX,mouseY-50,mouseX+50,mouseY);
          rect(mouseX-50,mouseY,mouseX,mouseY+50);
        } else if (towerVersion==3){
          rect(mouseX-50,mouseY-25,mouseX-25,mouseY);
          rect(mouseX,mouseY+25,mouseX+25,mouseY+50);
          rect(mouseX-50,mouseY+25,mouseX-25,mouseY+50);
          rect(mouseX-25,mouseY,mouseX,mouseY+25);
          rect(mouseX,mouseY-25,mouseX+25,mouseY);
          rect(mouseX+25,mouseY-50,mouseX+50,mouseY-25);
        } else if (towerVersion==4){
          ellipse(mouseX-50,mouseY-50,mouseX+50,mouseY+50);
          ellipse(mouseX-25,mouseY-25,mouseX+25,mouseY+25);
        } else if (towerVersion==5){
          ellipse(mouseX-50,mouseY-50,mouseX,mouseY);
          ellipse(mouseX,mouseY-50,mouseX+50,mouseY);
          ellipse(mouseX-50,mouseY,mouseX,mouseY+50);
          ellipse(mouseX,mouseY,mouseX+50,mouseY+50);
          ellipse(mouseX-25,mouseY-25,mouseX+25,mouseY+25);
        }
      }
    }
  }
  
  void shootEnemy(int enemyClass, int arrayPosition){
    strokeWeight(5);
    stroke(360);
    if (enemyClass==1){
      line(this.bulletLocation.x,this.bulletLocation.y,easyEnemies[arrayPosition].centerPoint.x,easyEnemies[arrayPosition].centerPoint.y);
    } else if (enemyClass==2){
      line(this.bulletLocation.x,this.bulletLocation.y,mediumEnemies[arrayPosition].centerPoint.x,mediumEnemies[arrayPosition].centerPoint.y);
    } else if (enemyClass==3){
      line(this.bulletLocation.x,this.bulletLocation.y,hardEnemies[arrayPosition].centerPoint.x,hardEnemies[arrayPosition].centerPoint.y);
    }
    this.enemyLockedOn=false;
  }
}

//This class handles everything with the start and end zones, or "houses".

class House{
  int startingX;
  int startingY;
  int endingX;
  int endingY;
  
  House(int startEnd){
    if (startEnd == 0){
      startingX = 0;
      startingY = 325;
      endingX = 125;
      endingY = 450;
    } else if (startEnd == 1){
      startingX = 675;
      startingY = 0;
      endingX = 800;
      endingY = 125;
    }
  }
  
  void build(){
    noStroke();
    fill(267,59,70,100);
    rect(startingX,startingY,endingX,endingY);
  }
}

//This class handles everything to do with the Light Tower's class.
//Has a method to construct the tower, draw the tower, draw the tower's button and shoot from the tower.

class LightTower{
  int xPoint1, yPoint1;
  int xPoint2, yPoint2;
  int xPoint3, yPoint3;
  int xPoint4, yPoint4;
  int xPoint5, yPoint5;
  int xPoint6, yPoint6;
  int xBounding1, yBounding1;
  int xBounding2, yBounding2;
  float bulletDamage;
  int firingRadius;
  boolean enemyLockedOn;
  PVector bulletLocation;
  int lightTowerColour = 122;
  boolean isBoundToMouse=false;
  int lightTowerVersion;
  
  
  LightTower(int towerVersion, int referencePointX, int referencePointY){
    if (towerVersion==0){
      xPoint1 = referencePointX-25;
      yPoint1 = referencePointY-25;
      xPoint2 = referencePointX+25;
      yPoint2 = referencePointY+25;
      xPoint3 = referencePointX;
      yPoint3 = referencePointY-25;
      xPoint4 = referencePointX;
      yPoint4 = referencePointY+25;
      xPoint5 = referencePointX-25;
      yPoint5 = referencePointY;
      xPoint6 = referencePointX+25;
      yPoint6 = referencePointY;
    } else if (towerVersion==1){
      xPoint1 = referencePointX-25;
      yPoint1 = referencePointY-25;
      xPoint2 = referencePointX+25;
      yPoint2 = referencePointY+25;
      xPoint3 = referencePointX-25;
      yPoint3 = referencePointY-25;
      xPoint4 = referencePointX+25;
      yPoint4 = referencePointY+25;
      xPoint5 = referencePointX-25;
      yPoint5 = referencePointY+25;
      xPoint6 = referencePointX+25;
      yPoint6 = referencePointY-25;
    } else if (towerVersion==2){
      xPoint1 = referencePointX;
      yPoint1 = referencePointY-25;
      xPoint2 = referencePointX-25;
      yPoint2 = referencePointY;
      xPoint3 = referencePointX;
      yPoint3 = referencePointY+25;
      xPoint4 = referencePointX+25;
      yPoint4 = referencePointY;
    } else if (towerVersion==3){
      xPoint1 = referencePointX-25;
      yPoint1 = referencePointY-25;
      xPoint2 = referencePointX+25;
      yPoint2 = referencePointY+25;
      xPoint3 = referencePointX;
      yPoint3 = referencePointY-25;
      xPoint4 = referencePointX-25;
      yPoint4 = referencePointY;
      xPoint5 = referencePointX;
      yPoint5 = referencePointY+25;
      xPoint6 = referencePointX+25;
      yPoint6 = referencePointY;
    } else if (towerVersion==4){
      xPoint1 = referencePointX-25;
      yPoint1 = referencePointY-25;
      xPoint2 = referencePointX;
      yPoint2 = referencePointY;
      xPoint3 = referencePointX+25;
      yPoint3 = referencePointY+25;
    } else if (towerVersion==5){
      xPoint1 = referencePointX-25;
      yPoint1 = referencePointY-25;
      xPoint2 = referencePointX+25;
      yPoint2 = referencePointY+25;
    }
    xBounding1 = referencePointX-25;
    yBounding1 = referencePointY-25;
    xBounding2 = referencePointX+25;
    yBounding2 = referencePointY+25;
    lightTowerVersion=towerVersion;
    bulletDamage=2/60;
    firingRadius=100;
    enemyLockedOn=false;
    bulletLocation= new PVector(referencePointX,referencePointY);
  }
  
  void build(int towerVersion){
    for(int lineNumber=1;lineNumber<=4;lineNumber++){
      noFill();
      strokeWeight(strkWght-(2*(lineNumber-1)));
      stroke(lightTowerColour,((30*lineNumber)-glowFrame),99,((30*lineNumber)-glowFrame));
      if (towerVersion==0 || towerVersion==1){
        rect(xPoint1,yPoint1,xPoint2,yPoint2);
        line(xPoint3,yPoint3,xPoint4,yPoint4);
        line(xPoint5,yPoint5,xPoint6,yPoint6);
      } else if (towerVersion==2){
        line(xPoint1,yPoint1,xPoint2,yPoint2);
        line(xPoint2,yPoint2,xPoint3,yPoint3);
        line(xPoint3,yPoint3,xPoint4,yPoint4);
        line(xPoint4,yPoint4,xPoint1,yPoint1);
      } else if (towerVersion==3){
        rect(xPoint1,yPoint1,xPoint2,yPoint2);
        line(xPoint3,yPoint3,xPoint4,yPoint4);
        line(xPoint4,yPoint4,xPoint5,yPoint5);
        line(xPoint5,yPoint5,xPoint6,yPoint6);
        line(xPoint6,yPoint6,xPoint3,yPoint3);
      } else if (towerVersion==4){
        rect(xPoint1,yPoint1,xPoint2,yPoint2);
        rect(xPoint2,yPoint2,xPoint3,yPoint3);
      } else if (towerVersion==5){
        ellipse(xPoint1,yPoint1,xPoint2,yPoint2);
      }
    } 
  }
  
  void buildButton(int towerVersion){
    for(int lineNumber=1;lineNumber<=4;lineNumber++){
      noFill();
      strokeWeight(strkWght-(2*(lineNumber-1)));
      stroke(lightTowerColour,30*lineNumber,99,30*lineNumber);
      if (towerVersion==0 || towerVersion==1){
        rect(xPoint1,yPoint1,xPoint2,yPoint2);
        line(xPoint3,yPoint3,xPoint4,yPoint4);
        line(xPoint5,yPoint5,xPoint6,yPoint6);
      } else if (towerVersion==2){
        line(xPoint1,yPoint1,xPoint2,yPoint2);
        line(xPoint2,yPoint2,xPoint3,yPoint3);
        line(xPoint3,yPoint3,xPoint4,yPoint4);
        line(xPoint4,yPoint4,xPoint1,yPoint1);
      } else if (towerVersion==3){
        rect(xPoint1,yPoint1,xPoint2,yPoint2);
        line(xPoint3,yPoint3,xPoint4,yPoint4);
        line(xPoint4,yPoint4,xPoint5,yPoint5);
        line(xPoint5,yPoint5,xPoint6,yPoint6);
        line(xPoint6,yPoint6,xPoint3,yPoint3);
      } else if (towerVersion==4){
        rect(xPoint1,yPoint1,xPoint2,yPoint2);
        rect(xPoint2,yPoint2,xPoint3,yPoint3);
      } else if (towerVersion==5){
        ellipse(xPoint1,yPoint1,xPoint2,yPoint2);
      }
    } 
  }
  
  void constructTower(int towerVersion){
    if (isBoundToMouse){
      for(int lineNumber=1;lineNumber<=4;lineNumber++){
        noFill();
        strokeWeight(strkWght-(2*(lineNumber-1)));
        stroke(lightTowerColour,30*lineNumber,99,30*lineNumber);
        if (towerVersion==0){
          rect(mouseX-25,mouseY-25,mouseX+25,mouseY+25);
          line(mouseX,mouseY-25,mouseX,mouseY+25);
          line(mouseX-25,mouseY,mouseX+25,mouseY);
        } else if (towerVersion==1){
          rect(mouseX-25,mouseY-25,mouseX+25,mouseY+25);
          line(mouseX-25,mouseY-25,mouseX+25,mouseY+25);
          line(mouseX+25,mouseY-25,mouseX-25,mouseY+25);
        } else if (towerVersion==2){
          line(mouseX,mouseY-25,mouseX-25,mouseY);
          line(mouseX-25,mouseY,mouseX,mouseY+25);
          line(mouseX,mouseY+25,mouseX+25,mouseY);
          line(mouseX+25,mouseY,mouseX,mouseY-25);
        } else if (towerVersion==3){
          rect(mouseX-25,mouseY-25,mouseX+25,mouseY+25);
          line(mouseX,mouseY-25,mouseX-25,mouseY);
          line(mouseX-25,mouseY,mouseX,mouseY+25);
          line(mouseX,mouseY+25,mouseX+25,mouseY);
          line(mouseX+25,mouseY,mouseX,mouseY-25);
        } else if (towerVersion==4){
          rect(mouseX-25,mouseY-25,mouseX,mouseY);
          rect(mouseX,mouseY,mouseX+25,mouseY+25);
        } else if (towerVersion==5){
          ellipse(mouseX-25,mouseY-25,mouseX+25,mouseY+25);
        }
      }
    }
  }
  
  void shootEnemy(int enemyClass, int arrayPosition){
    strokeWeight(5);
    stroke(360);
    if (enemyClass==1){
      line(this.bulletLocation.x,this.bulletLocation.y,easyEnemies[arrayPosition].centerPoint.x,easyEnemies[arrayPosition].centerPoint.y);
    } else if (enemyClass==2){
      line(this.bulletLocation.x,this.bulletLocation.y,mediumEnemies[arrayPosition].centerPoint.x,mediumEnemies[arrayPosition].centerPoint.y);
    } else if (enemyClass==3){
      line(this.bulletLocation.x,this.bulletLocation.y,hardEnemies[arrayPosition].centerPoint.x,hardEnemies[arrayPosition].centerPoint.y);
    }
    this.enemyLockedOn=false;
  }
}

//This class handles everything about the Medium Enemy class.
//Has a method to draw the enemy and update the position of the enemy.

class MediumEnemy{
  float currentHealth;
  int mediumEnemyType;
  int mediumEnemyColour = 30;
  
  PVector centerPoint;
  float boundingDistanceX = 25/2;
  float boundingDistanceY = 50/2;
  int movementSpeed = 1;
  PVector moveRightLeft= new PVector(movementSpeed,0);
  PVector moveUpDown= new PVector(0,movementSpeed);
  boolean movingRight=false;
  boolean movingLeft=false;
  boolean movingUp=false;
  boolean movingDown=false;
  
  MediumEnemy(int enemyType){
    centerPoint= new PVector(75,375);
    currentHealth = 20;
    mediumEnemyType=enemyType;
  }
  
  void build(int enemyType){
    for(int lineNumber=1;lineNumber<=3;lineNumber++){
      noFill();
      strokeWeight((strkWght-2)-(2*(lineNumber-1)));
      stroke(mediumEnemyColour,((30*lineNumber)-glowFrame),99,((30*lineNumber)-glowFrame));
      if (enemyType==0){
        if(movingRight || movingLeft){
          rect(centerPoint.x-boundingDistanceX,centerPoint.y-boundingDistanceY,centerPoint.x+boundingDistanceX,centerPoint.y+boundingDistanceY);
          line(centerPoint.x-boundingDistanceX,centerPoint.y,centerPoint.x+boundingDistanceX,centerPoint.y);
        } else if (movingUp || movingDown){
          rect(centerPoint.x-boundingDistanceY,centerPoint.y-boundingDistanceX,centerPoint.x+boundingDistanceY,centerPoint.y+boundingDistanceX);
          line(centerPoint.x,centerPoint.y-boundingDistanceX,centerPoint.x,centerPoint.y+boundingDistanceX);
        }
      } else if (enemyType==1){
        if(movingRight || movingLeft){
          rect(centerPoint.x-boundingDistanceX,centerPoint.y-boundingDistanceY,centerPoint.x+boundingDistanceX,centerPoint.y+boundingDistanceY);
          line(centerPoint.x-boundingDistanceX,centerPoint.y-boundingDistanceY,centerPoint.x+boundingDistanceX,centerPoint.y);
          line(centerPoint.x-boundingDistanceX,centerPoint.y,centerPoint.x+boundingDistanceX,centerPoint.y-boundingDistanceY);
          line(centerPoint.x-boundingDistanceX,centerPoint.y,centerPoint.x+boundingDistanceX,centerPoint.y+boundingDistanceY);
          line(centerPoint.x-boundingDistanceX,centerPoint.y+boundingDistanceY,centerPoint.x+boundingDistanceX,centerPoint.y);
        } else if (movingUp || movingDown){
          rect(centerPoint.x-boundingDistanceY,centerPoint.y-boundingDistanceX,centerPoint.x+boundingDistanceY,centerPoint.y+boundingDistanceX);
          line(centerPoint.x-boundingDistanceY,centerPoint.y-boundingDistanceX,centerPoint.x,centerPoint.y+boundingDistanceX);
          line(centerPoint.x-boundingDistanceY,centerPoint.y+boundingDistanceX,centerPoint.x,centerPoint.y-boundingDistanceX);
          line(centerPoint.x,centerPoint.y-boundingDistanceX,centerPoint.x+boundingDistanceY,centerPoint.y+boundingDistanceX);
          line(centerPoint.x,centerPoint.y+boundingDistanceX,centerPoint.x+boundingDistanceY,centerPoint.y-boundingDistanceX);
        }
      } else if (enemyType==2){
        if(movingRight){
          triangle(centerPoint.x-boundingDistanceX,centerPoint.y-boundingDistanceY,centerPoint.x+boundingDistanceX,centerPoint.y,centerPoint.x-boundingDistanceX,centerPoint.y+boundingDistanceY);
        } else if (movingLeft){
          triangle(centerPoint.x+boundingDistanceX,centerPoint.y-boundingDistanceY,centerPoint.x-boundingDistanceX,centerPoint.y,centerPoint.x+boundingDistanceX,centerPoint.y+boundingDistanceY);
        } else if (movingUp){
          triangle(centerPoint.x-boundingDistanceY,centerPoint.y+boundingDistanceX,centerPoint.x,centerPoint.y-boundingDistanceX,centerPoint.x+boundingDistanceY,centerPoint.y+boundingDistanceX);
        } else if (movingDown){
          triangle(centerPoint.x-boundingDistanceY,centerPoint.y-boundingDistanceX,centerPoint.x,centerPoint.y+boundingDistanceX,centerPoint.x+boundingDistanceY,centerPoint.y-boundingDistanceX);
        }
      } else if (enemyType==3){
        if(movingRight){
          triangle(centerPoint.x-boundingDistanceX,centerPoint.y-boundingDistanceY,centerPoint.x+boundingDistanceX,centerPoint.y,centerPoint.x+boundingDistanceX,centerPoint.y-boundingDistanceY);
          triangle(centerPoint.x-boundingDistanceX,centerPoint.y+boundingDistanceY,centerPoint.x+boundingDistanceX,centerPoint.y,centerPoint.x+boundingDistanceX,centerPoint.y+boundingDistanceY);
        } else if (movingLeft){
          triangle(centerPoint.x-boundingDistanceX,centerPoint.y-boundingDistanceY,centerPoint.x-boundingDistanceX,centerPoint.y,centerPoint.x+boundingDistanceX,centerPoint.y-boundingDistanceY);
          triangle(centerPoint.x-boundingDistanceX,centerPoint.y+boundingDistanceY,centerPoint.x-boundingDistanceX,centerPoint.y,centerPoint.x+boundingDistanceX,centerPoint.y+boundingDistanceY);
        } else if (movingUp){
          triangle(centerPoint.x-boundingDistanceY,centerPoint.y-boundingDistanceX,centerPoint.x-boundingDistanceY,centerPoint.y+boundingDistanceX,centerPoint.x,centerPoint.y-boundingDistanceX);
          triangle(centerPoint.x+boundingDistanceY,centerPoint.y-boundingDistanceX,centerPoint.x+boundingDistanceY,centerPoint.y+boundingDistanceX,centerPoint.x,centerPoint.y-boundingDistanceX);
        } else if (movingDown){
          triangle(centerPoint.x-boundingDistanceY,centerPoint.y-boundingDistanceX,centerPoint.x-boundingDistanceY,centerPoint.y+boundingDistanceX,centerPoint.x,centerPoint.y+boundingDistanceX);
          triangle(centerPoint.x+boundingDistanceY,centerPoint.y-boundingDistanceX,centerPoint.x+boundingDistanceY,centerPoint.y+boundingDistanceX,centerPoint.x,centerPoint.y+boundingDistanceX);
        }
      } else if (enemyType==4){
        if (movingRight || movingLeft){
          ellipse(centerPoint.x-boundingDistanceX,centerPoint.y-boundingDistanceY,centerPoint.x+boundingDistanceX,centerPoint.y);
          ellipse(centerPoint.x-boundingDistanceX,centerPoint.y,centerPoint.x+boundingDistanceX,centerPoint.y+boundingDistanceY);
        } else if (movingUp || movingDown){
          ellipse(centerPoint.x-boundingDistanceY,centerPoint.y-boundingDistanceX,centerPoint.x,centerPoint.y+boundingDistanceX);
          ellipse(centerPoint.x,centerPoint.y-boundingDistanceX,centerPoint.x+boundingDistanceY,centerPoint.y+boundingDistanceX);
        }
      }
    }
  }
  
  void move(){
    if(centerPoint.x==75 && centerPoint.y==375){
      movingUp=false;
      movingDown=false;
      movingLeft=false;
      movingRight=true;
    }
    
    for(int pathwayCounter=0;pathwayCounter<pathwayCheckpointsX.length;pathwayCounter++){
      if (centerPoint.x==pathwayCheckpointsX[pathwayCounter] && centerPoint.y==pathwayCheckpointsY[pathwayCounter]){
        if (pathwayCounter==0 || pathwayCounter==2 || pathwayCounter==6 || pathwayCounter==8 || pathwayCounter==12){
          movingUp=true;
          movingDown=false;
          movingLeft=false;
          movingRight=false;
        } else if (pathwayCounter==4 || pathwayCounter==10){
          movingUp=false;
          movingDown=true;
          movingLeft=false;
          movingRight=false;
        } else if (pathwayCounter==1){
          movingUp=false;
          movingDown=false;
          movingLeft=true;
          movingRight=false;
        } else if (pathwayCounter==3 || pathwayCounter==5 || pathwayCounter==7 || pathwayCounter==9 || pathwayCounter==11){
          movingUp=false;
          movingDown=false;
          movingLeft=false;
          movingRight=true;
        } else if (pathwayCounter==13){
          movingUp=false;
          movingDown=false;
          movingLeft=false;
          movingRight=false;
        }
      }
    }
    
    if(movingRight){
      centerPoint.add(moveRightLeft);
    } else if (movingLeft){
      centerPoint.sub(moveRightLeft);
    } else if (movingUp){
      centerPoint.sub(moveUpDown);
    } else if (movingDown){
      centerPoint.add(moveUpDown);
    }
  }
}

//This class handles everything to do with the Medium Tower's class.
//Has a method to construct the tower, draw the tower, draw the tower's button and shoot from the tower.

class MediumTower{
  int xPoint1, yPoint1;
  int xPoint2, yPoint2;
  int xPoint3, yPoint3;
  int xPoint4, yPoint4;
  int xPoint5, yPoint5;
  int xPoint6, yPoint6;
  int xPoint7, yPoint7;
  int xPoint8, yPoint8;
  int xPoint9, yPoint9;
  int xPoint10, yPoint10;
  int xBounding1, yBounding1;
  int xBounding2, yBounding2;
  
  float buttonXPoint1, buttonYPoint1;
  float buttonXPoint2, buttonYPoint2;
  float buttonXPoint3, buttonYPoint3;
  float buttonXPoint4, buttonYPoint4;
  float buttonXPoint5, buttonYPoint5;
  float buttonXPoint6, buttonYPoint6;
  float buttonXPoint7, buttonYPoint7;
  float buttonXPoint8, buttonYPoint8;
  float buttonXPoint9, buttonYPoint9;
  float buttonXPoint10, buttonYPoint10;
  float buttonXBounding1, buttonYBounding1;
  float buttonXBounding2, buttonYBounding2;
  
  float shrinkMultiplier = 0.66;
  
  float bulletDamage;
  int firingRadius;
  boolean enemyLockedOn;
  PVector bulletLocation;
  int mediumTowerColour = 190;
  boolean isBoundToMouse=false;
  int mediumTowerVersion;
  
  MediumTower(int towerVersion, int referencePointX, int referencePointY){
    if (towerVersion==0){
      xPoint1 = referencePointX-50;
      buttonXPoint1 = referencePointX-(50*shrinkMultiplier);
      yPoint1 = referencePointY-50;
      buttonYPoint1 = referencePointY-(50*shrinkMultiplier);
      xPoint2 = referencePointX+25;
      buttonXPoint2 = referencePointX+(25*shrinkMultiplier);
      yPoint2 = referencePointY+25;
      buttonYPoint2 = referencePointY+(25*shrinkMultiplier);
      xPoint3 = referencePointX-50;
      buttonXPoint3 = referencePointX-(50*shrinkMultiplier);
      yPoint3 = referencePointY-25;
      buttonYPoint3 = referencePointY-(25*shrinkMultiplier);
      xPoint4 = referencePointX+25;
      buttonXPoint4 = referencePointX+(25*shrinkMultiplier);
      yPoint4 = referencePointY;
      buttonYPoint4 = referencePointY;
      xPoint5 = referencePointX-25;
      buttonXPoint5 = referencePointX-(25*shrinkMultiplier);
      yPoint5 = referencePointY-50;
      buttonYPoint5 = referencePointY-(50*shrinkMultiplier);
      xPoint6 = referencePointX;
      buttonXPoint6 = referencePointX;
      yPoint6 = referencePointY+25;
      buttonYPoint6 = referencePointY+(25*shrinkMultiplier);
    } else if (towerVersion==1){
      xPoint1 = referencePointX-25;
      buttonXPoint1 = referencePointX-(25*shrinkMultiplier);
      yPoint1 = referencePointY-50;
      buttonYPoint1 = referencePointY-(50*shrinkMultiplier);
      xPoint2 = referencePointX;
      buttonXPoint2 = referencePointX;
      yPoint2 = referencePointY+25;
      buttonYPoint2 = referencePointY+(25*shrinkMultiplier);
      xPoint3 = referencePointX-50;
      buttonXPoint3 = referencePointX-(50*shrinkMultiplier);
      yPoint3 = referencePointY-25;
      buttonYPoint3 = referencePointY-(25*shrinkMultiplier);
      xPoint4 = referencePointX+25;
      buttonXPoint4 = referencePointX+(25*shrinkMultiplier);
      yPoint4 = referencePointY;
      buttonYPoint4 = referencePointY;
    } else if (towerVersion==2){
      xPoint1 = referencePointX-50;
      buttonXPoint1 = referencePointX-(50*shrinkMultiplier);
      yPoint1 = referencePointY-50;
      buttonYPoint1 = referencePointY-(50*shrinkMultiplier);
      xPoint2 = referencePointX-25;
      buttonXPoint2 = referencePointX-(25*shrinkMultiplier);
      yPoint2 = referencePointY-25;
      buttonYPoint2 = referencePointY-(25*shrinkMultiplier);
      xPoint3 = referencePointX;
      buttonXPoint3 = referencePointX;
      yPoint3 = referencePointY-50;
      buttonYPoint3 = referencePointY-(50*shrinkMultiplier);
      xPoint4 = referencePointX+25;
      buttonXPoint4 = referencePointX+(25*shrinkMultiplier);
      yPoint4 = referencePointY-25;
      buttonYPoint4 = referencePointY-(25*shrinkMultiplier);
      xPoint5 = referencePointX-50;
      buttonXPoint5 = referencePointX-(50*shrinkMultiplier);
      yPoint5 = referencePointY;
      buttonYPoint5 = referencePointY;
      xPoint6 = referencePointX-25;
      buttonXPoint6 = referencePointX-(25*shrinkMultiplier);
      yPoint6 = referencePointY+25;
      buttonYPoint6 = referencePointY+(25*shrinkMultiplier);
      xPoint7 = referencePointX;
      buttonXPoint7 = referencePointX;
      yPoint7 = referencePointY;
      buttonYPoint7 = referencePointY;
      xPoint8 = referencePointX+25;
      buttonXPoint8 = referencePointX+(25*shrinkMultiplier);
      yPoint8 = referencePointY+25;
      buttonYPoint8 = referencePointY+(25*shrinkMultiplier);
      xPoint9 = referencePointX-25;
      buttonXPoint9 = referencePointX-(25*shrinkMultiplier);
      yPoint9 = referencePointY-25;
      buttonYPoint9 = referencePointY-(25*shrinkMultiplier);
      xPoint10 = referencePointX;
      buttonXPoint10 = referencePointX;
      yPoint10 = referencePointY;
      buttonYPoint10 = referencePointY;
    } else if (towerVersion==3){
      xPoint1 = referencePointX-50;
      buttonXPoint1 = referencePointX-(50*shrinkMultiplier);
      yPoint1 = referencePointY-50;
      buttonYPoint1 = referencePointY-(50*shrinkMultiplier);
      xPoint2 = referencePointX-25;
      buttonXPoint2 = referencePointX-(25*shrinkMultiplier);
      yPoint2 = referencePointY-25;
      buttonYPoint2 = referencePointY-(25*shrinkMultiplier);
      xPoint3 = referencePointX;
      buttonXPoint3 = referencePointX;
      yPoint3 = referencePointY-50;
      buttonYPoint3 = referencePointY-(50*shrinkMultiplier);
      xPoint4 = referencePointX+25;
      buttonXPoint4 = referencePointX+(25*shrinkMultiplier);
      yPoint4 = referencePointY-25;
      buttonYPoint4 = referencePointY-(25*shrinkMultiplier);
      xPoint5 = referencePointX-50;
      buttonXPoint5 = referencePointX-(50*shrinkMultiplier);
      yPoint5 = referencePointY;
      buttonYPoint5 = referencePointY;
      xPoint6 = referencePointX-25;
      buttonXPoint6 = referencePointX-(25*shrinkMultiplier);
      yPoint6 = referencePointY+25;
      buttonYPoint6 = referencePointY+(25*shrinkMultiplier);
      xPoint7 = referencePointX;
      buttonXPoint7 = referencePointX;
      yPoint7 = referencePointY;
      buttonYPoint7 = referencePointY;
      xPoint8 = referencePointX+25;
      buttonXPoint8 = referencePointX+(25*shrinkMultiplier);
      yPoint8 = referencePointY+25;
      buttonYPoint8 = referencePointY+(25*shrinkMultiplier);
    } else if (towerVersion==4){
      xPoint1 = referencePointX-50;
      buttonXPoint1 = referencePointX-(50*shrinkMultiplier);
      yPoint1 = referencePointY-50;
      buttonYPoint1 = referencePointY-(50*shrinkMultiplier);
      xPoint2 = referencePointX+25;
      buttonXPoint2 = referencePointX+(25*shrinkMultiplier);
      yPoint2 = referencePointY+25;
      buttonYPoint2 = referencePointY+(25*shrinkMultiplier);
      xPoint3 = referencePointX-25;
      buttonXPoint3 = referencePointX-(25*shrinkMultiplier);
      yPoint3 = referencePointY-25;
      buttonYPoint3 = referencePointY-(25*shrinkMultiplier);
      xPoint4 = referencePointX;
      buttonXPoint4 = referencePointX;
      yPoint4 = referencePointY;
      buttonYPoint4 = referencePointY;
    } else if (towerVersion==5){
      xPoint1 = referencePointX-50;
      buttonXPoint1 = referencePointX-(50*shrinkMultiplier);
      yPoint1 = referencePointY-50;
      buttonYPoint1 = referencePointY-(50*shrinkMultiplier);
      xPoint2 = referencePointX;
      buttonXPoint2 = referencePointX;
      yPoint2 = referencePointY;
      buttonYPoint2 = referencePointY;
      xPoint3 = referencePointX-25;
      buttonXPoint3 = referencePointX-(25*shrinkMultiplier);
      yPoint3 = referencePointY-50;
      buttonYPoint3 = referencePointY-(50*shrinkMultiplier);
      xPoint4 = referencePointX+25;
      buttonXPoint4 = referencePointX+(25*shrinkMultiplier);
      yPoint4 = referencePointY;
      buttonYPoint4 = referencePointY;
      xPoint5 = referencePointX-50;
      buttonXPoint5 = referencePointX-(50*shrinkMultiplier);
      yPoint5 = referencePointY-25;
      buttonYPoint5 = referencePointY-(25*shrinkMultiplier);
      xPoint6 = referencePointX;
      buttonXPoint6 = referencePointX;
      yPoint6 = referencePointY+25;
      buttonYPoint6 = referencePointY+(25*shrinkMultiplier);
      xPoint7 = referencePointX-25;
      buttonXPoint7 = referencePointX-(25*shrinkMultiplier);
      yPoint7 = referencePointY-25;
      buttonYPoint7 = referencePointY-(25*shrinkMultiplier);
      xPoint8 = referencePointX+25;
      buttonXPoint8 = referencePointX+(25*shrinkMultiplier);
      yPoint8 = referencePointY+25;
      buttonYPoint8 = referencePointY+(25*shrinkMultiplier);
    }
    xBounding1 = referencePointX-50;
    yBounding1 = referencePointY-50;
    xBounding2 = referencePointX+25;
    yBounding2 = referencePointY+25;
    buttonXBounding1 = referencePointX-(50*shrinkMultiplier);
    buttonYBounding1 = referencePointY-(50*shrinkMultiplier);
    buttonXBounding2 = referencePointX+(25*shrinkMultiplier);
    buttonYBounding2 = referencePointY+(25*shrinkMultiplier);
    mediumTowerVersion=towerVersion;
    bulletDamage=4/60;
    firingRadius=150;
    enemyLockedOn=false;
    bulletLocation= new PVector(referencePointX,referencePointY);
  }
  
  void build(int towerVersion){
    for(int lineNumber=1;lineNumber<=4;lineNumber++){
      noFill();
      strokeWeight(strkWght-(2*(lineNumber-1)));
      stroke(mediumTowerColour,((30*lineNumber)-glowFrame),99,((30*lineNumber)-glowFrame));
      if (towerVersion==0){
        rect(xPoint1,yPoint1,xPoint2,yPoint2);
        rect(xPoint3,yPoint3,xPoint4,yPoint4);
        rect(xPoint5,yPoint5,xPoint6,yPoint6);
      } else if (towerVersion==1){
        rect(xPoint1,yPoint1,xPoint2,yPoint2);
        rect(xPoint3,yPoint3,xPoint4,yPoint4);
      } else if (towerVersion==2){
        rect(xPoint1,yPoint1,xPoint2,yPoint2);
        rect(xPoint3,yPoint3,xPoint4,yPoint4);
        rect(xPoint5,yPoint5,xPoint6,yPoint6);
        rect(xPoint7,yPoint7,xPoint8,yPoint8);
        rect(xPoint9,yPoint9,xPoint10,yPoint10);
      } else if (towerVersion==3){
        rect(xPoint1,yPoint1,xPoint2,yPoint2);
        rect(xPoint3,yPoint3,xPoint4,yPoint4);
        rect(xPoint5,yPoint5,xPoint6,yPoint6);
        rect(xPoint7,yPoint7,xPoint8,yPoint8);
      } else if (towerVersion==4){
        rect(xPoint1,yPoint1,xPoint2,yPoint2);
        rect(xPoint3,yPoint3,xPoint4,yPoint4);
      } else if (towerVersion==5){
        ellipse(xPoint1,yPoint1,xPoint2,yPoint2);
        ellipse(xPoint3,yPoint3,xPoint4,yPoint4);
        ellipse(xPoint5,yPoint5,xPoint6,yPoint6);
        ellipse(xPoint7,yPoint7,xPoint8,yPoint8);
      }
    } 
  }
  
  void buildButton(int towerVersion){
    for(int lineNumber=1;lineNumber<=4;lineNumber++){
      noFill();
      strokeWeight(strkWght-(2*(lineNumber-1)));
      stroke(mediumTowerColour,((30*lineNumber)),99,((30*lineNumber)));
      if (towerVersion==0){
        rect(buttonXPoint1,buttonYPoint1,buttonXPoint2,buttonYPoint2);
        rect(buttonXPoint3,buttonYPoint3,buttonXPoint4,buttonYPoint4);
        rect(buttonXPoint5,buttonYPoint5,buttonXPoint6,buttonYPoint6);
      } else if (towerVersion==1){
        rect(buttonXPoint1,buttonYPoint1,buttonXPoint2,buttonYPoint2);
        rect(buttonXPoint3,buttonYPoint3,buttonXPoint4,buttonYPoint4);
      } else if (towerVersion==2){
        rect(buttonXPoint1,buttonYPoint1,buttonXPoint2,buttonYPoint2);
        rect(buttonXPoint3,buttonYPoint3,buttonXPoint4,buttonYPoint4);
        rect(buttonXPoint5,buttonYPoint5,buttonXPoint6,buttonYPoint6);
        rect(buttonXPoint7,buttonYPoint7,buttonXPoint8,buttonYPoint8);
        rect(buttonXPoint9,buttonYPoint9,buttonXPoint10,buttonYPoint10);
      } else if (towerVersion==3){
        rect(buttonXPoint1,buttonYPoint1,buttonXPoint2,buttonYPoint2);
        rect(buttonXPoint3,buttonYPoint3,buttonXPoint4,buttonYPoint4);
        rect(buttonXPoint5,buttonYPoint5,buttonXPoint6,buttonYPoint6);
        rect(buttonXPoint7,buttonYPoint7,buttonXPoint8,buttonYPoint8);
      } else if (towerVersion==4){
        rect(buttonXPoint1,buttonYPoint1,buttonXPoint2,buttonYPoint2);
        rect(buttonXPoint3,buttonYPoint3,buttonXPoint4,buttonYPoint4);
      } else if (towerVersion==5){
        ellipse(buttonXPoint1,buttonYPoint1,buttonXPoint2,buttonYPoint2);
        ellipse(buttonXPoint3,buttonYPoint3,buttonXPoint4,buttonYPoint4);
        ellipse(buttonXPoint5,buttonYPoint5,buttonXPoint6,buttonYPoint6);
        ellipse(buttonXPoint7,buttonYPoint7,buttonXPoint8,buttonYPoint8);
        }
      } 
    }
  
  void constructTower(int towerVersion){
    if (isBoundToMouse){
      for(int lineNumber=1;lineNumber<=4;lineNumber++){
        noFill();
        strokeWeight(strkWght-(2*(lineNumber-1)));
        stroke(mediumTowerColour,30*lineNumber,99,30*lineNumber);
        if (towerVersion==0){
          rect(mouseX-50,mouseY-50,mouseX+25,mouseY+25);
          rect(mouseX-25,mouseY-50,mouseX,mouseY+25);
          rect(mouseX-50,mouseY-25,mouseX+25,mouseY);
        } else if (towerVersion==1){
          rect(mouseX-25,mouseY-50,mouseX,mouseY+25);
          rect(mouseX-50,mouseY-25,mouseX+25,mouseY);
        } else if (towerVersion==2){
          rect(mouseX-50,mouseY-50,mouseX-25,mouseY-25);
          rect(mouseX,mouseY-50,mouseX+25,mouseY-25);
          rect(mouseX-50,mouseY,mouseX-25,mouseY+25);
          rect(mouseX,mouseY,mouseX+25,mouseY+25);
          rect(mouseX-25,mouseY-25,mouseX,mouseY);
        } else if (towerVersion==3){
          rect(mouseX-50,mouseY-50,mouseX-25,mouseY-25);
          rect(mouseX,mouseY-50,mouseX+25,mouseY-25);
          rect(mouseX-50,mouseY,mouseX-25,mouseY+25);
          rect(mouseX,mouseY,mouseX+25,mouseY+25);
        } else if (towerVersion==4){
          rect(mouseX-50,mouseY-50,mouseX+25,mouseY+25);
          rect(mouseX-25,mouseY-25,mouseX,mouseY);
        } else if (towerVersion==5){
          ellipse(mouseX-50,mouseY-50,mouseX,mouseY);
          ellipse(mouseX-25,mouseY-50,mouseX+25,mouseY);
          ellipse(mouseX-50,mouseY-25,mouseX,mouseY+25);
          ellipse(mouseX-25,mouseY-25,mouseX+25,mouseY+25);
        }
      }
    }
  }
  
  void shootEnemy(int enemyClass, int arrayPosition){
    strokeWeight(5);
    stroke(360);
    if (enemyClass==1){
      line(this.bulletLocation.x,this.bulletLocation.y,easyEnemies[arrayPosition].centerPoint.x,easyEnemies[arrayPosition].centerPoint.y);
    } else if (enemyClass==2){
      line(this.bulletLocation.x,this.bulletLocation.y,mediumEnemies[arrayPosition].centerPoint.x,mediumEnemies[arrayPosition].centerPoint.y);
    } else if (enemyClass==3){
      line(this.bulletLocation.x,this.bulletLocation.y,hardEnemies[arrayPosition].centerPoint.x,hardEnemies[arrayPosition].centerPoint.y);
    }
    this.enemyLockedOn=false;
  }
}

//This class handles everything with drawing the pathway that the enemies follow.
//Uses the arrays in the global variables as those values are also used elsewhere.

class Pathway{
  int startingX;
  int startingY;
  int endingX;
  int endingY;
  
  Pathway(int coordinateValue){
    startingX = pathwayBoundaryX[coordinateValue];
    startingY = pathwayBoundaryY[coordinateValue];
    endingX = pathwayBoundaryX[coordinateValue+1];
    endingY = pathwayBoundaryY[coordinateValue+1];
  }
  
  void build(){
    noStroke();
    fill(0,0,0,100);
    rect(startingX,startingY,endingX,endingY);
  }
}

//Handles everything to do with creating the tower storage boxes.
//Has nothing to do with drawing the buttons within the storage boxes.

class TowerStorageBox{
  int startingX;
  int startingY;
  int endingX;
  int endingY;
  
  TowerStorageBox(int boxNumber){
    startingY=457;
    endingY=600;
    if (boxNumber==0){
      startingX=5;
      endingX=270;
    } else if (boxNumber==1){
      startingX=281;
      endingX=520;
    } else if (boxNumber==2){
      startingX=531;
      endingX=795;
    }
  }
  
  void build(){
    noStroke();
    fill(262,88,50,100);
    rect(startingX,startingY,endingX,endingY);
  }
}