class Enemy { 
   
  int mySize = 4; 
  public float x; 
  public float y; 
  public float speed; 
   
  public Enemy(float xPos, float yPos, float sp) { 
    x = xPos; 
    y = yPos; 
    speed = sp; 
  } 
   
  public void draw() { 
    ellipse(x, y, mySize, mySize); 
  } 
   
  public void moveTowards(float xPos, float yPos) 
  { 
  } 
} 

class Player  
{ 
  //Player member variables, passed to constructor 
  private int mySize; 
  private float speed; 
  private float easing; 
  public float x; 
  public float y; 
   
  //Player member variables, set in constructor (but not passed in) 
  private float arcX; 
  private float arcY; 
  private float targetX; 
  private float targetY; 
  private float theta; 
   
  public Player(float xPos, float yPos, float sp, float ease, int pSize)  
  { 
    x = xPos; 
    y = yPos; 
    speed = sp; 
    easing = ease; 
    mySize = pSize; 
     
    arcX = 0; 
    arcY = 0; 
    targetX = xPos; 
    targetY = yPos; 
    theta = 0.0; 
  } 
   
  public void draw()  
  { 
    move(); 
  } 
   
  //Move the player based on key presses and orbit parameters 
  //Return true if the player is pressing a key, false otherwise 
  public void move() 
  {  
    if (keyPressed) { 
      if (key == CODED) { 
        progress = sORp; 
        if (keyCode == UP) { 
          targetY -= speed; 
          if (targetY < 0) targetY = 0; 
        } 
        if (keyCode == DOWN) { 
          targetY += speed; 
          if (targetY > height) targetY = height; 
        } 
        if (keyCode == LEFT) { 
          targetX -= speed; 
          if (targetX < 0) targetX = 0; 
        } 
        if (keyCode == RIGHT) { 
          targetX += speed; 
          if (targetX > width) targetX = width; 
        }  
      } 
    } 
    else 
    { 
      progress = !sORp; 
    } 
   
    float d = dist(centerX, centerY, targetX, targetY); 
    if (d > 1.0) { 
      x += (targetX - x) * easing; 
      y += (targetY - y) * easing; 
    } 
   
    theta += .1; 
    if (theta > TWO_PI) { 
      theta = 0; 
      if (!progress) { 
        time++; 
      } 
      else { 
        //Trigger the tick sound effect 
        tick.trigger(); 
      } 
     
      fill(255); 
      text(time, width - 75, 50); 
    } 
   
    arcX = x + mySize*cos(theta); 
    arcY = y + mySize*sin(theta); 
   
    fill(255, 255, 255); 
    ellipse(arcX, arcY, mySize, mySize); 
  } 
   
  public void collide(float x1, float y1) 
  { 
    if (dist(x1, y1, arcX, arcY) <= (mySize + enemySize)/2) { 
      collided = true; 
      setupGame(); 
    }  
  } 
   
  public void reset() 
  { 
    time = 0; 
    x = centerX; 
    y = centerY; 
    targetX = x; 
    targetY = y; 
  } 
} 

/* Author: Joshua Fishburn 
 * Date: 8/11/2009 
 * Survive/Progress Version 0.1 
 * - Combining the functionality of Survive and Progress into one game 
 * - Allow the player to choose which version to play 
 * - Track record times for both versions of the game 
 * 
 * Date: 08/11/2009 
 * Survive Version 0.4 
 * - Condensed createEnemies function so that it works with only one for loop 
 * 
 * Date: 08/10/2009 
 * Survive Version 0.3 
 * - Separated functionality out to Enemy and Player classes 
 * - Added comments and cleaned up unnecessary variables 
 */ 
  
//Import for minim sound library 
import ddf.minim.*; 
import ddf.minim.signals.*; 
 
//Define the sound objects we need for the beep 
Minim minim; 
AudioSample tick; 
AudioOutput out; 
 
//Font for displaying stuff on the screen 
PFont font; 
 
//Main control variables for the win/lose survive/progress conditions 
boolean sORp; 
boolean progress; 
boolean collided = true; 
 
//The center of the game screen, no matter the resolution 
int centerX; 
int centerY; 
 
//The radii and other parameters of both Player and Enemy 
int playerSize = 8; 
float playerSpeed = 2.0; 
float playerEasing = 0.05; 
int enemySize = 4; 
 
//Record keeping 
int time = 0; 
int timePreviousProgress = 0; 
int timePreviousSurvive = 0; 
int timeRecordProgress = 0; 
int timeRecordSurvive = 0; 
 
//Enemy Waves - Allows for dynamic addition of enemy waves with the numWaves variable 
int numEnemies = 25; 
int numWaves = 5; 
int numTotalEnemies = (int)(numEnemies*(pow(2, numWaves) - 1)); 
int enemyRadii; 
 
//Setup a main array to hold all enemies, regardless of location (distribution of enemies is a MAIN-specific algorithm) 
Enemy[] enemies = new Enemy[numTotalEnemies]; 
 
//The main player object 
Player player; 
 
void setup() { 
  size(800, 600); 
  centerX = width/2; 
  centerY = height/2; 
  noStroke(); 
  smooth(); 
  ellipseMode(CENTER); 
  font = loadFont("Krungthep-48.vlw"); 
   
  //Pick a random mode to start the game in (Between Survive and Progress) 
  int rand = int(random(2)); 
  if (rand == 1) sORp = true; else sORp = false; 
   
  progress = sORp; 
  //sORp = boolean(int(random(2))); 
   
  //Setup audio sample for beep 
  minim = new Minim(this); 
  tick = minim.loadSample("hospital_monitor_beep.mp3", 8192);   
  if ( tick == null ) println("Didn't get tick!"); 
  out = minim.getLineOut(Minim.STEREO);   
   
  //Create the player instance 
  player = new Player(centerX, centerY, playerSpeed, playerEasing, playerSize); 
} 
 
void draw() { 
  // Create the background 
  fill(0, 12); 
  rect(0, 0, width, height); 
   
  if (!collided) 
  { 
    // Move the circle 
    player.draw(); 
   
    // Move Lines to attack circle 
    moveEnemies(); 
  } 
  else 
  { 
    fill(255); 
    textFont(font, 45); 
    //Display different text depending on the player's game choice 
    if (sORp) 
    { 
      text("Use Arrow Keys to SURVIVE", centerX - 350, centerY - 50); 
    } 
    else 
    { 
      text("Use Arrow Keys to PROGRESS", centerX - 350, centerY - 50); 
    } 
    textFont(font, 25); 
    text("Press 'M' to Switch Game Modes", centerX - 200, centerY); 
    text("Press 'S' to Start a New Game", centerX - 200, centerY + 30); 
    if (sORp) 
    { 
      text("Previous time was " + timePreviousSurvive, centerX-200, centerY + 60); 
      text("Record time is " + timeRecordSurvive, centerX - 200, centerY + 90); 
    } 
    else 
    { 
      text("Previous time was " + timePreviousProgress, centerX-200, centerY + 60); 
      text("Record time is " + timeRecordProgress, centerX - 200, centerY + 90); 
    } 
  } 
} 
 
void keyReleased() 
{ 
  if (key == 's' || key == 'S') { 
    collided = false; 
    //Setup all of the enemies and player position 
    setupGame(); 
  } 
  if (key == 'm' || key == 'M') { 
    //Switch between Survive and Progress gameplay 
    if (sORp) sORp = false; else sORp = true; 
  } 
} 
 
void createEnemies()  
{ 
  numEnemies = 25; 
  enemyRadii = 200; 
  float increment = TWO_PI/numEnemies; 
  float theta = 0; 
  int i = 0; 
  int iterations = 1; 
  int speed = 1000; 
   
  for (i = 0; i < numTotalEnemies; i++) 
  { 
    // Get the coordinates around the circle 
    float nx = enemyRadii*cos(theta) + centerX; 
    float ny = enemyRadii*sin(theta) + centerY; 
 
    enemies[i] = new Enemy(nx, ny, random(speed) + 100); 
     
    //Increment theta 
    theta += increment; 
     
    //If we filled the circle, then reset and push out the radius for the next wave 
    if (theta > TWO_PI) 
    { 
      theta = 0; 
      numEnemies *= 2; 
      enemyRadii *= 4; 
      increment = TWO_PI/numEnemies; 
      speed -= 250/iterations; 
      iterations++; 
    } 
  } 
} 
 
//For each enemy, chase the player by finding the distance from it to the player and following that line 
void moveEnemies() { 
  fill(255); 
  for (int i = 0; i < numTotalEnemies; i++) { 
     
    if (!progress) { 
      //Now, move along that line with the appropriate speed 
      float dx = enemies[i].x - player.x; 
      float dy = enemies[i].y - player.y; 
     
      enemies[i].x -= dx/enemies[i].speed; 
      enemies[i].y -= dy/enemies[i].speed; 
    } 
     
    enemies[i].draw(); 
    player.collide(enemies[i].x, enemies[i].y); 
  } 
} 
 
void setupGame() { 
  //Reset the time, record the new record, reset the player to the center, and recreate the waves of enemies 
  if (sORp)  
  { 
    timePreviousSurvive = time; 
    if (timePreviousSurvive > timeRecordSurvive) timeRecordSurvive = timePreviousSurvive; 
  } 
  else  
  { 
    timePreviousProgress = time; 
    if (timePreviousProgress > timeRecordProgress) timeRecordProgress = timePreviousProgress; 
  } 
  player.reset();  
  //Pick a random mode to start the game in (Between Survive and Progress) 
  createEnemies(); 
} 
 
//Properly close out the sound objects 
void stop() 
{ 
  tick.close(); 
   
  out.close(); 
   
  minim.stop(); 
   
  super.stop(); 
}