// Koipond 1.0
// 
// The fish runs away from the mouse.
// Use this to guide it towards good, green food...
// ... and away from harmful red food.
// 
// Sarah Gould
// 28 May 2007
//
// Some rights reserved:
// http://creativecommons.org/licenses/by-nc-sa/3.0/

// *********** //

// General setup
int fieldSize = 300;
color backgroundColor = color(0, 0, 51);

PFont font;

// Fish setup
float x = fieldSize/2;
float y = fieldSize/2;
float bigness = 20;
float speed = .75;
float turnSpeed = 1;
float angle = 0;
float goalAngle = 0;
float sensitivity = 100;

// Ripples setup
int ripples = 10;
float ripplesX[] = new float[ripples];
float ripplesY[] = new float[ripples];
float ripplesSize[] = new float[ripples];
float maxRippleSize = 100;
float rippleSpeed = .6;

// Food-eaten bubble setup
boolean burstExists = false;
float burstX;
float burstY;
float burstSize = 0;
float maxBurstSize = 100;
float burstSpeed = 3;
color burstColor;

// Foods setup
int foods = 1;
int goodFoods = 0;
int maxFoods = 255;
float foodsX[] = new float[maxFoods];
float foodsY[] = new float[maxFoods];
int foodsType[] = new int[maxFoods];
float foodsSize = 7;
float percentBad = .4;

int score = 0;
int bonus = 1;

void setup() {
  size(fieldSize, fieldSize);
  smooth();
  
  // Load the font
  font = loadFont("Ziggurat-HTF-Black-32.vlw");
  textFont(font, 24);
  
  // Initialize the foods
  for(int i=0; i<foods; i++) {
    newFoods(i);
  }
}

void draw() {
  background(backgroundColor);
  
  // Draw the title and the score
  noStroke();
  fill(50, 200, 255, 100);
  text("koipod", 10, 24);
  fill(50, 200, 255, 200);
  text(str(score), 10, 48);
  
  // Draw and update foods and check if they've been eaten
  drawFoods();
  eatFoods();
  
  // Draw and update the fish
  moveKoi();
  drawKoi();
  
  // Draw the food-eaten bubble if food has been eaten recently
  if(burstExists) {
    foodBurst();
  }
  
  // Draw ripples coming from the mouse
  ripples();
}

void moveKoi() {
  float distance = dist(mouseX, mouseY, x, y);
  
  if(distance < sensitivity) {
    // Move away from the mouse if it is close...
    float dx = mouseX - x;
    float dy = mouseY - y;
    angle = atan2(dy, dx);
  }
  else if(abs(goalAngle - angle) < radians(10)) {
    // ... or select a new angle to aim for if the fish is close to the old one...
    goalAngle = random(radians(0), radians(360));
  }
  else {
    // ... or turn toward the same angle
    angle = angle + radians(turnSpeed) * (goalAngle - angle)/abs(goalAngle - angle);
  }
  
  // Move in the direction the fish is facing
  x = x - (speed * cos(angle));
  y = y - (speed * sin(angle));
  
  // Transport the fish if it's at the edge of the screen
  if(x <  0) { x = fieldSize; }
  if(y <  0) { y = fieldSize; }
  if(x >  fieldSize) { x = 0; }
  if(y >  fieldSize) { y = 0; }
}

void drawKoi() {
  noStroke();
  fill(255, 200, 50);
  
  // Draw the torpedo body
  float segments = 6;
  float adjustedBigness = bigness/segments;
  
  for(float i=0; i<segments; i++) {
    float dx = i * adjustedBigness * cos(angle);
    float dy = i * adjustedBigness * sin(angle);

    float iAngle = radians(i*(90/segments));
    float diameter = bigness * cos(iAngle);

    ellipse(x+dx, y+dy, diameter, diameter);
    ellipse(x-dx, y-dy, diameter, diameter);
  }
  
  // Draw the tail
  float ax = 0.8 * bigness * cos(angle);
  float ay = 0.8 * bigness * sin(angle);
  float bx = (1.6*ax) + 6*cos(angle+radians(90));
  float by = (1.6*ay) + 6*sin(angle+radians(90));
  float cx = (1.6*ax) + 6*cos(angle-radians(90));
  float cy = (1.6*ay) + 6*sin(angle-radians(90));
  triangle(x+ax, y+ay, x+bx, y+by, x+cx, y+cy);
}

void drawFoods() {
  noStroke();
  
  // Shift the foods around
  for(int i=0; i<foods; i++) {
    if(random(0, 1) < .1) {
      foodsX[i] = foodsX[i] + random(-1, 1);
      foodsY[i] = foodsY[i] + random(-1, 1);
    }
    
    // Draw the foods in appropriate colors
    if(foodsType[i] == 0) {
      fill(50, 255, 50);
    }
    else {
      fill(255, 100, 50);
    }
    ellipse(foodsX[i], foodsY[i], foodsSize, foodsSize);
  }
}

void eatFoods() {
  int newFoodsNumber = foods;
  
  for(int i=0; i<foods; i++) {
    float distance = dist(foodsX[i], foodsY[i], x, y);
    
    // If the food is eaten...
    if(distance < bigness/2) {
      // Start the food-eaten bubble
      burstExists = true;
      burstX = foodsX[i];
      burstY = foodsY[i];
      burstSize = 0;
      
      if(foodsType[i] == 1) {
        // If the food is bad, reduce score, cancel bonus, and don't replace food
        burstColor = color(255, 0, 0);
        
        foodsX[i] = foodsX[newFoodsNumber-1];
        foodsY[i] = foodsY[newFoodsNumber-1];
        foodsType[i] = foodsType[newFoodsNumber-1];
        newFoodsNumber = max(1, newFoodsNumber - 1);
        
        score = max(0, score - 1);
        bonus = 1;
      }
      else {
        // If the food is good, add to score and bonus, replace and add another food
        burstColor = color(255, 255, 255);
        
        goodFoods--;
        newFoods(i);
        
        if(newFoodsNumber < maxFoods) {
          newFoods(newFoodsNumber);
          newFoodsNumber++;
        }
        
        score = score + bonus;
        bonus++;
      }
    }
  }
  
  foods = newFoodsNumber;
}

void newFoods(int i) {
  // Add a new food to the screen at a random location and of a random type
  foodsX[i] = random(bigness, fieldSize-bigness);
  foodsY[i] = random(bigness, fieldSize-bigness);
  
  float type = random(0, 1);
  if((type < percentBad) && (goodFoods >= 1)) {
    foodsType[i] = 1;
  }
  else {
    foodsType[i] = 0;
    goodFoods++;
  }
}

void foodBurst() {
  // Draw the food burst, increasing in size and decreasing in opacity
  noStroke();
  fill(burstColor, 200 - (burstSize * 200/maxBurstSize));
  
  burstSize = burstSize + burstSpeed;
  ellipse(burstX, burstY, burstSize, burstSize);
  
  if(burstSize > maxBurstSize) {
    burstExists = false;
  }
}

void ripples() {
  // Draw each ripple bigger and more transparent, and add a new one at the mouse
  strokeWeight(2);
  noFill();
  
  for(int i=0; i<ripples; i++) {
    ripplesSize[i] = ripplesSize[i] + rippleSpeed;
    stroke(255, 255 - (ripplesSize[i] * 255/maxRippleSize));
    ellipse(ripplesX[i], ripplesY[i], ripplesSize[i], ripplesSize[i]);
  }
  
  if(ripplesSize[ripples-1] > maxRippleSize/ripples) {
    for(int i=1; i<ripples; i++) {
      ripplesX[i-1] = ripplesX[i];
      ripplesY[i-1] = ripplesY[i];
      ripplesSize[i-1] = ripplesSize[i];
    }
    ripplesX[ripples-1] = mouseX;
    ripplesY[ripples-1] = mouseY;
    ripplesSize[ripples-1] = 0;
  }
}