/*Update to version 2.0.1
-- Added AphidPop class to define parameters for entire population of aphids
-- Added focus to ladybug.  Ladybug now only eats the aphid that it has targetted, as opposed to all aphids in view
-- Changed Lesson 3 to show effects of variation on evolution.
-- Added Lessons 4 and 5 to show effects of heritability and selection on evolution
*/

int VARIATION_MASK = 0x00000001;
int INHERITANCE_MASK = 0x00000002;
int SELECTION_MASK = 0x00000004;

color debugcolor;
//07 Broad-Leaved Woodland_ Late Sprin.m4a
ladybug ladyleft, ladyright, ladyall;
int numAphids = 30;
int maxAphids = 30;
int numWeights = 10;  // 3 inputs * 2 outputs
int maxDrift = 10;
boolean ladyleftAutonomous = true;
AphidPop aphidsLeft = new AphidPop(maxAphids,1);
AphidPop aphidsRight = new AphidPop(maxAphids,0);
AphidPop aphidsAll = new AphidPop(maxAphids,2);


bug[] aphidsleft = new bug[maxAphids];
bug[] aphidsright = new bug[maxAphids];
bug[] aphidsall = new bug[maxAphids];
PFont fontScore,fontWin,fontData;
int score = 0;
float aphidsPerSecond = 0;
int flag = 1;
int avgAge = 0;
int maxAge = 0;
int boardWidth = 500;
int sideWidth = 500;
int boardHeight = 500;
int boarder = 5;
int numLeaves = 2000;

int numLeftRed,numLeftBlue,numLeftGreen;
int numRightRed,numRightBlue,numRightGreen;
int numAllRed,numAllBlue,numAllGreen;

PGraphics leavesPGleft,leavesPGright,leavesPGall;
PGraphics color_wheel;
int ladybugBehavior = 1;
color targetColor;
//int aphidCaptureCount = 0; // counts aphids per 10 seconds
//float aphidsPerMinute = 0;
//float aphidPerMinuteStart = 0; // counts 10 seconds
int buttonBox = 100;

boolean PAUSE = false;
boolean showLeft = true, showRight = true;
PGraphics pg;
boolean mutateAlpha = false; // flag to control whether alpha mutates

boolean startWindow = true;
int lessonNum = 0;
int numLessons = 5;
float hideChanceAvgLeft = 0;
float hideChanceAvgRight = 0;

int frameParamsRight = (0 | INHERITANCE_MASK | VARIATION_MASK | SELECTION_MASK);
int frameParamsLeft = (0 | INHERITANCE_MASK | VARIATION_MASK | SELECTION_MASK);

int H = 0;
int S = 1;
int V = 2;
int R = 0;
int G = 1;
int B = 2;

int wheel_radius = 40;

color leavesLeft;
color leavesRight;
color leavesAll;

void setup(){  
  pg = createGraphics(sideWidth,boardHeight/3,P2D);
  frameRate(30);
  noiseSeed(0);
  size(2*boardWidth+boarder*3,boardHeight+2*boarder+buttonBox);
  background(255,255,255);
  ladyleft = new ladybug(250,250,40,1); 
  ladyright = new ladybug(750,250,40,0);
  ladyall = new ladybug(500,250,40,2);
  for(int i =0; i <numAphids; i++){
     aphidsleft[i] = new bug(1);
     aphidsright[i] = new bug(0);
     aphidsall[i] = new bug(2);
  }
  for(int i =numAphids; i <maxAphids; i++){
      aphidsleft[i] = null;
      aphidsright[i] = null;
      aphidsall[i] = null;
  }
  leavesPGleft = createGraphics(boardWidth,boardHeight,P2D);
  addLeaves(leavesPGleft,color(100,20,20),1);
  leavesPGright = createGraphics(boardWidth,boardHeight,P2D);
  addLeaves(leavesPGright,color(100,20,20),1);
  leavesPGall = createGraphics(boardWidth*2+10,boardHeight,P2D);
  addLeaves(leavesPGall,color(20,200,20),2);
//  fontWin = createFont("Arial-Black", 30);
//  fontScore = createFont("Arial-Black", 24);
//  fontData = createFont("ArialNarrow", 14);
  fontWin = loadFont("Arial-Black-30.vlw");
  fontScore = loadFont("Arial-Black-24.vlw"); 
  fontData = loadFont("ArialNarrow-14.vlw");
  textFont(fontScore);
//  oldMX = mouseX;
 // oldMY = mouseY; 
  color_wheel = createGraphics(wheel_radius*2, wheel_radius*2,P2D);
  draw_HSVCW(color_wheel,wheel_radius,wheel_radius,wheel_radius);
}

void draw(){
  textAlign(CENTER);
  background(255,255,255);
  switch(lessonNum){
    case 0:
      displayLesson1(); // looks good
      break;
    case 1:
      displayLesson1();
      break;
    case 2:
      displayLesson2();
      break;
    case 3:
      displayLesson3();
      break;
    case 4:
      displayLesson4();
      break;
    case 5:
      displayLesson5();
      break;
  }
  /*
  if(showLeft){
    image(leavesPGleft,boarder,boarder);
  }
  if(showRight){
    image(leavesPGright,boarder*2+boardWidth,boarder);
  }
  textFont(fontScore);
  fill(100,100,100);
  text(ladyleft.get_aphidsCaught(),boarder+boardWidth/2-10,30);
  text(ladyright.get_aphidsCaught(),boardWidth+2*boarder+boardWidth/2-10,30);
  */
  
  /*
  for(int i = 0; i < maxAphids;i++){
    if(aphidsleft[i] != null){
      if(!PAUSE){
        aphidsleft[i].move(ladyleft);
      }
      aphidsleft[i].display();
    }
    else{   
      aphidsleft[i] = new bug(1);
      aphidsleft[i].replace(aphidsleft);
    }
    
    if(aphidsright[i] != null){
      if(!PAUSE){
        aphidsright[i].move(ladyright);
      }
      aphidsright[i].display();
    }
    else{
      aphidsright[i] = new bug(0);
      aphidsright[i].replace(aphidsright);
    }
  }
  ladyleft.displaylady();
  ladyright.displaylady();
  strokeWeight(boarder);
  noFill();
  stroke(0,0,0);
  rect(boarder/2,boarder/2,boardWidth*2+boarder*2,boardHeight+boarder);
  line(boardWidth+boarder+2,0,boardWidth+boarder+2,boardHeight+boarder);
  line(boardWidth+2,0,boardWidth+2,boardHeight+boarder);
  line(boardWidth+2*boarder+2,0,boardWidth+2*boarder+2,boardHeight+boarder);
  strokeWeight(1);
  fill(255,255,255);
  rect(0,boardHeight+2*boarder,boardWidth*2+boarder*3,buttonBox);
  
//  image(pg,boardWidth,boardHeight-200);
  ladybugBehaviorButtons();
//  checkHover(); // must come after all other data drawing to avoid being hidden
  colorCount();
  */
  if(startWindow == true){
    drawStartWindow();
  }
  
}

/////////////////////  Displays by lesson ////////////////////////////

void displayLesson1(){
 
  image(leavesPGall,boarder,boarder);
  ladyall.displaylady();
  if(!PAUSE){
    ladyall.behaviorMove(aphidsAll.pop);
    ladyall.eat(aphidsAll.pop);
  }

/*
  for(int i = 0; i < maxAphids;i++){
    if(aphidsall[i] != null){
      if(!PAUSE){
        aphidsall[i].move(ladyall);
      }
      aphidsall[i].display();
    }
    else{   
      aphidsall[i] = new bug(1);
      aphidsall[i].replace(aphidsall);
    }
  }
*/  
  aphidsAll.move(ladyall);
  strokeWeight(boarder);
  noFill();
  stroke(0,0,0);
  rect(boarder/2,boarder/2,boardWidth*2+boarder*2,boardHeight+boarder);
//  line(boardWidth+boarder+2,0,boardWidth+boarder+2,boardHeight+boarder);
//  line(boardWidth+2,0,boardWidth+2,boardHeight+boarder);
//  line(boardWidth+2*boarder+2,0,boardWidth+2*boarder+2,boardHeight+boarder);
  strokeWeight(1);
  fill(255,255,255);
  rect(0,boardHeight+2*boarder,boardWidth*2+boarder*3,buttonBox);
  textFont(fontScore);
  fill(100,100,100);
  text(ladyall.get_aphidsCaught(),boarder+boardWidth-10,30);
//  image(pg,boardWidth,boardHeight-200);
//  ladybugBehaviorButtons();
//  checkHover(); // must come after all other data drawing to avoid being hidden
  colorCount();
  showColorCount(false);
  showBackgroundColor(false); // false, not splitscreen
  menuButtons();
  showFrameParams(0,frameParamsLeft);
}

void displayLesson2(){
  if(showLeft){
    image(leavesPGleft,boarder,boarder);
  }
  if(showRight){
    image(leavesPGright,boarder*2+boardWidth,boarder);
  }
  if(!PAUSE){
    ladyleft.behaviorMove(aphidsLeft.pop);
    ladyleft.eat(aphidsLeft.pop);
    ladyright.behaviorMove(aphidsRight.pop);
    ladyright.eat(aphidsRight.pop);
  }
  textFont(fontScore);
  fill(100,100,100);
  text(ladyleft.get_aphidsCaught(),boarder+boardWidth/2-10,30);
  text(ladyright.get_aphidsCaught(),boardWidth+2*boarder+boardWidth/2-10,30);
  aphidsLeft.move(ladyleft);
  aphidsRight.move(ladyright);
  ladyleft.displaylady();
  ladyright.displaylady();
  strokeWeight(boarder);
  noFill();
  stroke(0,0,0);
  rect(boarder/2,boarder/2,boardWidth*2+boarder*2,boardHeight+boarder);
  line(boardWidth+boarder+2,0,boardWidth+boarder+2,boardHeight+boarder);
  line(boardWidth+2,0,boardWidth+2,boardHeight+boarder);
  line(boardWidth+2*boarder+2,0,boardWidth+2*boarder+2,boardHeight+boarder);
  strokeWeight(1);
  fill(255,255,255);
  rect(0,boardHeight+2*boarder,boardWidth*2+boarder*3,buttonBox);
  showBackgroundColor(true); // true split screen
  showColorCount(true);
  menuButtons();
  colorCount();
  showFrameParams(0,frameParamsLeft);
  showFrameParams(1,frameParamsRight);  
}

void displayLesson3(){

  if(showLeft){
    image(leavesPGleft,boarder,boarder);
  }
  if(showRight){
    image(leavesPGright,boarder*2+boardWidth,boarder);
  }
  if(!PAUSE){
    ladyleft.behaviorMove(aphidsLeft.pop);
    ladyleft.eat(aphidsLeft.pop);
    ladyright.behaviorMove(aphidsRight.pop);
    ladyright.eat(aphidsRight.pop);
  }
  textFont(fontScore);
  fill(100,100,100);
  text(ladyleft.get_aphidsCaught(),boarder+boardWidth/2-10,30);
  text(ladyright.get_aphidsCaught(),boardWidth+2*boarder+boardWidth/2-10,30);
  aphidsLeft.move(ladyleft);
  aphidsRight.move(ladyright);
  ladyleft.displaylady();
  ladyright.displaylady();
  strokeWeight(boarder);
  noFill();
  stroke(0,0,0);
  rect(boarder/2,boarder/2,boardWidth*2+boarder*2,boardHeight+boarder);
  line(boardWidth+boarder+2,0,boardWidth+boarder+2,boardHeight+boarder);
  line(boardWidth+2,0,boardWidth+2,boardHeight+boarder);
  line(boardWidth+2*boarder+2,0,boardWidth+2*boarder+2,boardHeight+boarder);
  strokeWeight(1);
  fill(255,255,255);
  rect(0,boardHeight+2*boarder,boardWidth*2+boarder*3,buttonBox);
  showBackgroundColor(true); // true split screen
  showColorCount(true);
  menuButtons();
  colorCount();
  showFrameParams(0,frameParamsLeft);
  showFrameParams(1,frameParamsRight);  
}

void displayLesson4(){
  if(showLeft){
    image(leavesPGleft,boarder,boarder);
  }
  if(showRight){
    image(leavesPGright,boarder*2+boardWidth,boarder);
  }
  if(!PAUSE){
    ladyleft.behaviorMove(aphidsLeft.pop);
    ladyleft.eat(aphidsLeft.pop);
    ladyright.behaviorMove(aphidsRight.pop);
    ladyright.eat(aphidsRight.pop);
  }
  textFont(fontScore);
  fill(100,100,100);
  text(ladyleft.get_aphidsCaught(),boarder+boardWidth/2-10,30);
  text(ladyright.get_aphidsCaught(),boardWidth+2*boarder+boardWidth/2-10,30);
/*
  for(int i = 0; i < maxAphids;i++){
    if(aphidsleft[i] != null){
      if(!PAUSE){
        aphidsleft[i].move(ladyleft);
      }
      aphidsleft[i].display();
    }
    else{   
      aphidsleft[i] = new bug(1);
      aphidsleft[i].replace(aphidsleft);
    }
    
    if(aphidsright[i] != null){
      if(!PAUSE){
        aphidsright[i].move(ladyright);
      }
      aphidsright[i].display();
    }
    else{
      aphidsright[i] = new bug(0);
      aphidsright[i].replace(aphidsright);
    }
  }
  */
  aphidsLeft.move(ladyleft);
  aphidsRight.move(ladyright);
  ladyleft.displaylady();
  ladyright.displaylady();
  strokeWeight(boarder);
  noFill();
  stroke(0,0,0);
  rect(boarder/2,boarder/2,boardWidth*2+boarder*2,boardHeight+boarder);
  line(boardWidth+boarder+2,0,boardWidth+boarder+2,boardHeight+boarder);
  line(boardWidth+2,0,boardWidth+2,boardHeight+boarder);
  line(boardWidth+2*boarder+2,0,boardWidth+2*boarder+2,boardHeight+boarder);
  strokeWeight(1);
  fill(255,255,255);
  rect(0,boardHeight+2*boarder,boardWidth*2+boarder*3,buttonBox);
  showBackgroundColor(true); // true split screen
  showColorCount(true);
  menuButtons();
//  image(pg,boardWidth,boardHeight-200);
  //ladybugBehaviorButtons();
//  checkHover(); // must come after all other data drawing to avoid being hidden
  colorCount();
  showFrameParams(0,frameParamsLeft);
  showFrameParams(1,frameParamsRight);  
}

void displayLesson5(){
  if(showLeft){
    image(leavesPGleft,boarder,boarder);
  }
  if(showRight){
    image(leavesPGright,boarder*2+boardWidth,boarder);
  }
  if(!PAUSE){
    ladyleft.behaviorMove(aphidsLeft.pop);
    ladyleft.eat(aphidsLeft.pop);
    ladyright.behaviorMove(aphidsRight.pop);
    ladyright.eat(aphidsRight.pop);
  }
  textFont(fontScore);
  fill(100,100,100);
  text(ladyleft.get_aphidsCaught(),boarder+boardWidth/2-10,30);
  text(ladyright.get_aphidsCaught(),boardWidth+2*boarder+boardWidth/2-10,30);
/*
  for(int i = 0; i < maxAphids;i++){
    if(aphidsleft[i] != null){
      if(!PAUSE){
        aphidsleft[i].move(ladyleft);
      }
      aphidsleft[i].display();
    }
    else{   
      aphidsleft[i] = new bug(1);
      aphidsleft[i].replace(aphidsleft);
    }
    
    if(aphidsright[i] != null){
      if(!PAUSE){
        aphidsright[i].move(ladyright);
      }
      aphidsright[i].display();
    }
    else{
      aphidsright[i] = new bug(0);
      aphidsright[i].replace(aphidsright);
    }
  }
  */
  aphidsLeft.move(ladyleft);
  aphidsRight.move(ladyright);
  ladyleft.displaylady();
  ladyright.displaylady();
  strokeWeight(boarder);
  noFill();
  stroke(0,0,0);
  rect(boarder/2,boarder/2,boardWidth*2+boarder*2,boardHeight+boarder);
  line(boardWidth+boarder+2,0,boardWidth+boarder+2,boardHeight+boarder);
  line(boardWidth+2,0,boardWidth+2,boardHeight+boarder);
  line(boardWidth+2*boarder+2,0,boardWidth+2*boarder+2,boardHeight+boarder);
  strokeWeight(1);
  fill(255,255,255);
  rect(0,boardHeight+2*boarder,boardWidth*2+boarder*3,buttonBox);
  showBackgroundColor(true); // true split screen
  showColorCount(true);
  menuButtons();
//  image(pg,boardWidth,boardHeight-200);
  //ladybugBehaviorButtons();
//  checkHover(); // must come after all other data drawing to avoid being hidden
  colorCount();
  showFrameParams(0,frameParamsLeft);
  showFrameParams(1,frameParamsRight);  
}

void showColorCount(boolean splitscreen){
  fill(0,0,0);
  textFont(fontData);
  int textLeft = 10;
  int textHeight = boardHeight + 40;
  int buttonHeight = 20;
  int barHeight = boardHeight+30;
  color b_col;
  textAlign(CENTER);
  text("Aphid", textLeft+65, textHeight-buttonHeight);
  text("Background", textLeft+160, textHeight-buttonHeight);
  textAlign(LEFT);
  text("Red: ", textLeft, textHeight);
  text("Green: ", textLeft, textHeight+buttonHeight);
  text("Blue: ", textLeft, textHeight+buttonHeight*2);
  if(splitscreen){
    textAlign(CENTER);
    text("Aphid", width/2+textLeft+65, textHeight-buttonHeight);
    text("Background", width/2+textLeft+160, textHeight-buttonHeight);
    textAlign(LEFT);
    text("Red: ", width/2+textLeft, textHeight);
    text("Green: ", width/2+textLeft, textHeight+buttonHeight);
    text("Blue: ", width/2+textLeft, textHeight+buttonHeight*2);
    fill(255,0,0);
    rect(textLeft+35,barHeight,int(aphidsLeft.rel_colors[0]*80),5);
    rect(textLeft+120+(80-int(red(leavesLeft)*80.0 / 255.0)),barHeight,int(red(leavesLeft)*80.0/255.0),5);
    rect(width/2+textLeft+35,barHeight,int(aphidsRight.rel_colors[0]*80),5);
    rect(width/2+textLeft+120+(80-int(red(leavesRight)*80.0 / 255.0)),barHeight,int(red(leavesRight)*80.0/255.0),5);
    fill(0,255,0);
    rect(textLeft+35,barHeight+buttonHeight,int(aphidsLeft.rel_colors[1]*80),5);
    rect(textLeft+120+(80-int(green(leavesLeft)*80.0 / 255.0)),barHeight+buttonHeight,int(green(leavesLeft)*80.0/255.0),5);
    rect(width/2+textLeft+35,barHeight+buttonHeight,int(aphidsRight.rel_colors[1]*80),5);
    rect(width/2+textLeft+120+(80-int(green(leavesRight)*80.0 / 255.0)),barHeight+buttonHeight,int(green(leavesRight)*80.0/255.0),5);
    fill(0,0,255);
    rect(textLeft+35,barHeight+buttonHeight*2,int(aphidsLeft.rel_colors[2]*80),5);
    rect(textLeft+120+(80-int(blue(leavesLeft)*80.0 / 255.0)),barHeight+buttonHeight*2,int(blue(leavesLeft)*80.0/255.0),5);
    rect(width/2+textLeft+35,barHeight+buttonHeight*2,int(aphidsRight.rel_colors[2]*80),5);
    rect(width/2+textLeft+120+(80-int(blue(leavesRight)*80.0 / 255.0)),barHeight+buttonHeight*2,int(blue(leavesRight)*80.0/255.0),5);
    fill(0,0,0);
    text("Average chance to see an aphid: " + ((int(hideChanceAvgLeft*100) > 1)?(int(hideChanceAvgLeft*100)):"< 1") + "%", buttonHeight*1.5+150, boardHeight+35+buttonHeight*3.5);
    text("Average chance to see an aphid: " + ((int(hideChanceAvgRight*100) > 1)?(int(hideChanceAvgRight*100)):"< 1") + "%", width/2+buttonHeight*1.5+150, boardHeight+35+buttonHeight*3.5);
  }
  
  else{
    fill(255,0,0);
    rect(textLeft+50,barHeight,int(aphidsAll.rel_colors[0]*80),5);
    rect(textLeft+120+(80-int(red(leavesAll)*80.0 / 255.0)),barHeight,int(red(leavesAll)*80.0/255.0),5);
    fill(0,255,0);
    rect(textLeft+50,barHeight+buttonHeight,int(aphidsAll.rel_colors[1]*80),5);
    rect(textLeft+120+(80-int(green(leavesAll)*80.0 / 255.0)),barHeight+buttonHeight,int(green(leavesAll)*80.0/255.0),5);
    fill(0,0,255);
    rect(textLeft+50,barHeight+buttonHeight*2,int(aphidsAll.rel_colors[2]*80),5);
    rect(textLeft+120+(80-int(blue(leavesAll)*80.0 / 255.0)),barHeight+buttonHeight*2,int(blue(leavesAll)*80.0/255.0),5);
  }
}

/////////////// Buttons /////////////////////////////////////////////

void showBackgroundColor(boolean splitscreen){
 // color buttons
 // Changing this to a HSV color "wheel", white in center, black at outside

 // Create concentric "circles" of increasing saturation, then decreasing value

 color c1;
 if(splitscreen == true){
   image(color_wheel,boardWidth*.5-wheel_radius,boardHeight + 50-wheel_radius);
   image(color_wheel,boardWidth*1.5+boarder*3-wheel_radius,boardHeight + 50-wheel_radius);
 }
 else{
   image(color_wheel,width*.5-wheel_radius,boardHeight + 60-wheel_radius);
 }
 
}
///////////////////////////////////////////////////////////////////////

void menuButtons() {
  fill(100,100,100);
  rect(width/2 - 100,height - 25,60,20);   // back button
  textAlign(CENTER);
  fill(0);
  text("Back",width/2 - 70,height - 10);  
  fill(100,100,100);
  rect(width/2+40,height - 25,60,20);   // pause button
  textAlign(CENTER);
  fill(0);
  text("Pause",width/2 + 70,height - 10);  
}

void lessonWindowCheckButtons() {
  if(mouseX > (width/2-100) && mouseX < (width/2-40) && mouseY > height-25 && mouseY < height-5){ // bac button
    if (lessonNum > 1) {
      aphidsLeft = new AphidPop(maxAphids, 1);
      aphidsRight = new AphidPop(maxAphids, 0);
    }
    else {
      aphidsAll = new AphidPop(maxAphids,2);
    }
    lessonNum = 1;
    startWindow = true;
    reset();
  }
  else if(mouseX > (width/2+40) && mouseX < (width/2+100) && mouseY > height-25 && mouseY < height-5){ // pause button
    PAUSE = !PAUSE;
  }

}


///////////////////////////////////////////////////////////////////////
void colorCount(){
/*
  numLeftRed = numLeftBlue=numLeftGreen = 0;
  numRightRed = numRightBlue=numRightGreen = 0;
  numAllRed = numAllBlue=numAllGreen = 0;
  
  for(int i = 0; i < maxAphids; i++){
      if(aphidsleft[i] != null){
        if(red(aphidsleft[i].c) > green(aphidsleft[i].c) && red(aphidsleft[i].c) > blue(aphidsleft[i].c))
           numLeftRed++;
        if(green(aphidsleft[i].c) > red(aphidsleft[i].c) && green(aphidsleft[i].c) > blue(aphidsleft[i].c))
           numLeftGreen++;
        if(blue(aphidsleft[i].c) > green(aphidsleft[i].c) && blue(aphidsleft[i].c) > red(aphidsleft[i].c))
           numLeftBlue++;
      }
      if(aphidsright[i] != null){
        if(red(aphidsright[i].c) > green(aphidsright[i].c) && red(aphidsright[i].c) > blue(aphidsright[i].c))
           numRightRed++;
        if(green(aphidsright[i].c) > red(aphidsright[i].c) && green(aphidsright[i].c) > blue(aphidsright[i].c))
           numRightGreen++;
        if(blue(aphidsright[i].c) > green(aphidsright[i].c) && blue(aphidsright[i].c) > red(aphidsright[i].c))
           numRightBlue++;
      }
      if(aphidsall[i] != null){
        if(red(aphidsall[i].c) > green(aphidsall[i].c) && red(aphidsall[i].c) > blue(aphidsall[i].c))
           numAllRed++;
        if(green(aphidsall[i].c) > red(aphidsall[i].c) && green(aphidsall[i].c) > blue(aphidsall[i].c))
           numAllGreen++;
        if(blue(aphidsall[i].c) > green(aphidsall[i].c) && blue(aphidsall[i].c) > red(aphidsall[i].c))
           numAllBlue++;
      }
  }
  */
  if (lessonNum == 1) {
    aphidsAll.colorCount();
  }
  else {
    aphidsLeft.colorCount();
    aphidsRight.colorCount();
  }
}
/*
void checkHover(){
  if(mouseX < boardWidth) // not over data region
     return;
  if(mouseY > (2*(boardHeight/3))){ // bottom 3rd
     textFont(fontData);
     fill(255,255,255,100);
     rect(boardWidth+sideWidth/3, 4*(boardHeight/5),sideWidth/3+20,40);
     fill(0,0,0);
     text("Historical Aphid Data and\n Average Transparency (black line)", boardWidth+sideWidth/3+10, 4*(boardHeight/5)+18);
  }
    else if(mouseY > ((boardHeight/3))){ // middle 3rd
     textFont(fontData);
     fill(255,255,255,100);
     rect(boardWidth+sideWidth/4, (boardHeight/2)-20,sideWidth/2,40);
     fill(0,0,0);
     text("Lines are avg. aphid Red, Blue, Green levels \n Background is avg. aphid color", boardWidth+sideWidth/4+10, (boardHeight/2)-20+18);
  }
}
*/
void mousePressed(){
  if(startWindow == true){  // if start window is open
    startWindowCheckButtons();  // check those buttons
    return;   // skip the regular buttons
  }
  else {
    lessonWindowCheckButtons();
  }
  int leftXedge = boardWidth+5;
  int buttonHeight = 40;
  int numButtons = 4;
  int buttonWidth = (sideWidth-10)/numButtons;
  // reset button
  // boardWidth+boarder*1.5 - (buttonWidth/2), boardHeight+15, buttonWidth,buttonHeight
  if(mouseX < boardWidth+boarder*1.5 + (buttonWidth/2) && mouseX > boardWidth+boarder*1.5 - (buttonWidth/2)){
     if( mouseY < boardHeight+15+buttonHeight && mouseY > boardHeight+15){
       reset();
     }
  }
    // pause button
    /*
  if(mouseX < boardWidth+boarder*1.5 + (buttonWidth/2) && mouseX > boardWidth+boarder*1.5 - (buttonWidth/2)){
    if( mouseY < boardHeight+15+buttonHeight*2 && mouseY > boardHeight+15+buttonHeight){
     PAUSE = !PAUSE;
     if(!PAUSE){
       showLeft = showRight = true;
     }
    }
  }
  */
  // pause button
  /*
  if(mouseY< ((boardHeight/3) - buttonHeight-15) || mouseY> ((boardHeight/3)-15)){ // see ladybugBehaviorButtons
      return;
  }
*/
// color
  if(mouseX > boardWidth*.5-wheel_radius+boarder && 
     mouseX < boardWidth*.5+boarder+wheel_radius &&
     mouseY > boardHeight+50 - wheel_radius && 
     mouseY < boardHeight+50 + wheel_radius &&
     lessonNum > 1){
    leavesLeft = get(mouseX,mouseY);
    addLeaves(leavesPGleft,leavesLeft,1);
    
  }
  if(mouseX > boardWidth*1.5-wheel_radius+boarder*3 && 
     mouseX < boardWidth*1.5+3*boarder+wheel_radius &&
     mouseY > boardHeight+50 - wheel_radius && 
     mouseY < boardHeight+50 + wheel_radius&&
     lessonNum > 1){
    leavesRight = get(mouseX,mouseY);
    addLeaves(leavesPGright,leavesRight,1);
  }
  if(mouseX > width*.5-wheel_radius && 
     mouseX < width*.5+wheel_radius &&
     mouseY > boardHeight+50 - wheel_radius && 
     mouseY < boardHeight+50 + wheel_radius&&
     lessonNum == 1){
    leavesAll = get(mouseX,mouseY);
    addLeaves(leavesPGall,leavesAll,2);
  }
  // user controlled
  if(mouseX < 20+buttonHeight*.5 && mouseX > 20){
    if(mouseY < boardHeight+15+buttonHeight*.5 && mouseY > boardHeight+15){
      if(ladyleftAutonomous){  // 1 - user, 3 = autonomous
        ladyleftAutonomous = false;
        ladyleft.setBehavior(1);
      }
      else{
        ladyleftAutonomous = true;
        ladyleft.setBehavior(3);
      }
    }
  }
  // show/hide background
  if(PAUSE){
    if(mouseX < 20+buttonHeight*.5 && mouseX > 20){
      if(mouseY < boardHeight+15+buttonHeight+5 && mouseY > boardHeight+15+buttonHeight*.5+5){
        showLeft = !showLeft;
      }
    }
  }
  if(PAUSE){
    if(mouseX < 2*boardWidth-20+buttonHeight*.5 && mouseX > 2*boardWidth-20){
      if(mouseY < boardHeight+15+buttonHeight+5 && mouseY > boardHeight+15+buttonHeight*.5+5){
        showRight = !showRight;
      }
    }
  }
}

void ladybugBehaviorButtons(){  // draws buttons
  int numButtons = 4;
  int leftXedge = boardWidth+5;
  int buttonHeight = 40;
  int buttonTop = (boardHeight/3) - buttonHeight - 15;
  int buttonWidth = (sideWidth-10)/numButtons;
  // reset button
  fill(100,255,100);
  rect(boardWidth+boarder*1.5 - (buttonWidth/2), boardHeight+15, buttonWidth,buttonHeight);
  // pause button
  rect(boardWidth+boarder*1.5 - (buttonWidth/2), boardHeight+buttonHeight+ 15+ 10, buttonWidth,buttonHeight);
  color c1 = color(0,0,0);
  // color buttons
  /*for(int x = boardWidth/2-buttonWidth/2; x <boardWidth/2+buttonWidth/2; x++){
    for(int y = boardHeight+15; y < boardHeight+15+buttonHeight; y++){
      c1 = color((255.0/buttonWidth)*(x-(boardWidth/2-buttonWidth/2)),(255.0/buttonHeight)*(y-(boardHeight+15)),(2*((255.0/buttonWidth)*(x-(boardWidth/2-buttonWidth/2)))%255));
      set(x,y,c1);
    }
  }
  for(int x = int(boardWidth*1.5-buttonWidth/2); x <boardWidth*1.5+buttonWidth/2; x++){
    for(int y = boardHeight+15; y < boardHeight+15+buttonHeight; y++){
      c1 = color((255.0/buttonWidth)*(x-(boardWidth*1.5-buttonWidth/2)),(255.0/buttonHeight)*(y-(boardHeight+15)),(2*((255.0/buttonWidth)*(x-(boardWidth*1.5-buttonWidth/2)))%255));
      set(x,y,c1);
    }
  }
  */
  // behavior checkbox
  noFill();
  strokeWeight(2);
  rect(20,boardHeight+15,buttonHeight*.5,buttonHeight*.5);
  if(!ladyleftAutonomous){
    line(20,boardHeight+15,20+buttonHeight*.5,boardHeight+15+buttonHeight*.5);
    line(20,boardHeight+15+buttonHeight*.5,20+buttonHeight*.5,boardHeight+15);
  }   
  // show/hide background
  if(PAUSE){
    rect(20,boardHeight+15+buttonHeight*.5+5,buttonHeight*.5,buttonHeight*.5);
    fill(0,0,0);
    textFont(fontData);
    text("Hide Background", 20+45+buttonHeight*.5,boardHeight+15+20+buttonHeight*.5);
    if(!showLeft){
      line(20,boardHeight+15+buttonHeight*.5+5,20+buttonHeight*.5,boardHeight+15+buttonHeight+5);
      line(20,boardHeight+15+buttonHeight+5,20+buttonHeight*.5,boardHeight+15+buttonHeight*.5+5);
    }
  }
  if(PAUSE){
    noFill();
    rect(2*boardWidth-20,boardHeight+15+buttonHeight*.5+5,buttonHeight*.5,buttonHeight*.5);
    fill(0,0,0);
    textFont(fontData);
    text("Hide Background", 2*boardWidth - (45+buttonHeight*.5),boardHeight+15+20+buttonHeight*.5);
    if(!showRight){
      line(2*boardWidth-20,boardHeight+15+buttonHeight*.5+5,2*boardWidth-20+buttonHeight*.5,boardHeight+15+buttonHeight+5);
      line(2*boardWidth-20,boardHeight+15+buttonHeight+5,2*boardWidth-20+buttonHeight*.5,boardHeight+15+buttonHeight*.5+5);
    }
  }
  fill(0,0,0);
  textFont(fontData);
//  text("Select ladybug behavior:", leftXedge+5, buttonTop-8);
  text("User Controlled", 20+40+buttonHeight*.5,boardHeight+15+15);
//  text("Autonomous", leftXedge+buttonWidth+5, buttonTop+buttonHeight/2+5);
//  text("Left/Right", leftXedge+2*buttonWidth+5, buttonTop+buttonHeight/2+5);
  text("Background Color", boardWidth/2, boardHeight+buttonHeight+35);
  text("Background Color", boardWidth*1.5, boardHeight+buttonHeight+35);
  text("Reset", boardWidth+boarder*1.5, boardHeight+10+buttonHeight*.75);
  if(!PAUSE){
    text("Pause", boardWidth+boarder*1.5, boardHeight+20+buttonHeight*1.75);
  }
  else{
    text("Unpause", boardWidth+boarder*1.5, boardHeight+20+buttonHeight*1.75);
  }
}

  void reset(){
    score = 0;
    ladyall.set_aphidsCaught(0);
    ladyleft.set_aphidsCaught(0);
    ladyright.set_aphidsCaught(0);
//    records = 0;
//    aphidCaptureCount = 0;
//    aphidPerMinuteStart = millis(); // restart timer
  }

int maxCol(color c) {
  float mc = max(red(c),green(c),blue(c));
  if (mc == red(c)) return 0;
  else if (mc == green(c)) return 1;
  return 2;
}
  
class bug{
  float theta;
  float v;
  float maxV;
  float frequency;
  float x;
  float y;
  float radius;
  int age;
  color c;
  int alphaC;
  int side;  // 0-right, 1-left, 2-both
  float[] weights;
  boolean isTarget;
  
  bug(int s){
    weights = new float[numWeights];
    // initialize aphids
    side = s;
    if(s == 1){  // left
       x=random(0,boardWidth);
    }
    if(s == 0){  // right
       x=random(boardWidth,2*boardWidth);
    }
    if(s == 2){  // all
       x=random(0,2*boardWidth);
    }
    y=random(0,height);
    radius = 17;
    age = 0;
    v = random(0.5,2.0);
    maxV = random(2.0,8.0);
    theta = random(0,2*PI);
    c = color(random(0,255),random(0,255),random(0,255));
//    c = color(0,0,0);
    if(mutateAlpha){
      alphaC = 50+int(random(0,205));
    }
    else{
      alphaC = 255; 
    }
    for(int i =0; i < numWeights; i++){
      weights[i] = random(-10.0,10.0);
    }
    weights[0] = 0.1; // start moving
    isTarget = false;
  }
  
  void setTarget(boolean tVal) {
    isTarget = tVal;
  }

  float chanceToHide(){
    
    // hiding philosophy:  Aphid needs to "match" the background color.
    // -- difference starts at 0
    // -- Dominant color should be the same as background
    // -- if same, calculate "base" difference as follows: 
    // ---- Secondary color should be the same as background secondary
    // ---- if same, add squared difference of ratios [0..1]
    // ---- else add 1
    // ---- ratios of other colors to dominant should be roughly equal
    // ---- add squared difference of ratios together [0..2]
    // -- else base difference = 3
    // Now factor in difference in average color intensity
    // -- Average the background and aphid colors, square the difference [0 .. 255^2]
    // -- multiply this by the base calculated above
    // Normalize by dividing by (3*255*255)
    
    
    color col;
    if (side == 1) 
      col = leavesPGleft.get(int(x),int(y));
    else if (side == 0)
      col = leavesPGright.get(int(x-boardWidth),int(y));
    else 
      col = leavesPGall.get(int(x),int(y));
    float diffcolor = 0;

/*
    int domColBack = maxCol(col);
    int domColAph = maxCol(c);
    boolean secRatBack = true;
    boolean secRatAph = true;
    float priColBack = 1;
    float priColAph = 1;
    float secColBack = 1;
    float secColAph = 1;
    float terColBack = 1;
    float terColAph = 1;
    float aphRat, backRat;
    float avgAph, avgBack;
    if (domColBack != domColAph) diffcolor = 3;
    else {
      switch (domColBack) {
        case 0:
          priColBack = red(col);
          priColAph = red(col);
          secRatBack = (green(col) > blue(col));
          secRatAph = (green(col) > blue(col));
          if (secRatBack) {
            secColBack = green(col);
            terColBack = blue(col);
          }
          else {
            secColBack = blue(col);
            terColBack = green(col);
          }
          if (secRatAph) {
            secColAph = green(col);
            terColAph = blue(col);
          }
          else {
            secColAph = blue(col);
            terColAph = green(col);
          }
          break;
        case 1:
          priColBack = green(col);
          priColAph = green(col);
          secRatBack = (red(col) > blue(col));
          secRatAph = (red(col) > blue(col));
          if (secRatBack) {
            secColBack = red(col);
            terColBack = blue(col);
          }
          else {
            secColBack = blue(col);
            terColBack = red(col);
          }
          if (secRatAph) {
            secColAph = red(col);
            terColAph = blue(col);
          }
          else {
            secColAph = blue(col);
            terColAph = red(col);
          }
          break;
        case 2:
          priColBack = blue(col);
          priColAph = blue(col);
          secRatBack = (green(col) > red(col));
          secRatAph = (green(col) > red(col));
          if (secRatBack) {
            secColBack = green(col);
            terColBack = red(col);
          }
          else {
            secColBack = red(col);
            terColBack = green(col);
          }
          if (secRatAph) {
            secColAph = green(col);
            terColAph = red(col);
          }
          else {
            secColAph = red(col);
            terColAph = green(col);
          }
          break;
      }
      if (secRatBack != secRatAph) diffcolor = 1;
      else {
        aphRat = terColAph / (secColAph+1.0);
        backRat = terColBack / (secColBack+1.0);
        diffcolor += sqrt((aphRat - backRat) * (aphRat - backRat));
      }
      aphRat = terColAph / (priColAph+1.0);
      backRat = terColBack / (priColBack+1.0);
      diffcolor += sqrt((aphRat - backRat) * (aphRat - backRat));
      aphRat = secColAph / (priColAph+1.0);
      backRat = secColBack / (priColBack+1.0);
      diffcolor += sqrt((aphRat - backRat) * (aphRat - backRat));
    }
    avgAph = (red(c)+green(c)+blue(c)) / 3.0;
    avgBack = (red(col)+green(col)+blue(col)) / 3.0;
    if (isTarget) print("DC: " + diffcolor + "   AvgB: " + avgBack + "   AvgA: " + avgAph);
    diffcolor = diffcolor * sqrt(((avgAph -avgBack)*(avgAph - avgBack)));
    diffcolor /= (3*255.0); // to normalize
*/

// Euclidean distance -- not working well!

    diffcolor = sqrt( (red(c)-red(col))*(red(c)-red(col)) + (green(c)-green(col))*(green(c)-green(col)) + (blue(c)-blue(col))*(blue(c)-blue(col)) );


    diffcolor /= sqrt(3*255.0*255); // to normalize
 //   if (isTarget) println("    Final diff: " + diffcolor);
 //   diffcolor *= ((255-aphids[a].alphaC)/255.0); // account for transparency
  //  print(diffcolor + "\n");
    return (diffcolor);
  }



  void runNN(ladybug lady){
    float[] inputs = {1,0,0,0,0}; // first input is fixed (threshold) the rest are inputs 
    inputs[1] = 2.0/(1.0 + exp(-1*theta)) -1.0; 
    inputs[2] = 2.0/(1.0 + exp(-1*v)) -1.0;
    float dx,dy;
    dx = lady.x-x;
    dy = lady.y-y;
    float distance = sqrt(dx*dx+dy*dy);
    float angle = atan(dx/dy);
    if(dy<0)
       angle=angle+PI;
    inputs[3] = 1.0/(1.0 + exp(-1*distance)); 
    inputs[4] = 2.0/(1.0 + exp(-1*angle)) -1.0;
    
    float dv = 0; // change in velocity
    float dtheta = 0;
    float temp = 0;
    for(int i = 0;i < 5; i++)
        temp += inputs[i]*weights[i];
    dv = 2.0/(1 + exp(-1*(temp))) - 1.0;
    temp = 0;
    for(int i = 0;i < 5; i++)
        temp += inputs[i]*weights[5+i];
    dtheta = 2.0/(1 + exp(-1*(temp))) - 1.0;
    dtheta*=0.1;
    theta+=dtheta;
    v = abs(dv*maxV);
   }
  
  void mutCopy(bug s, int var){
    x=s.x;
    y=s.y;
    side = s.side;
    age = 0;
    for(int i =0; i < numWeights; i++)
       weights[i] = s.weights[i] + var * random(-1.0, 1.0);
    frequency = s.frequency+ var * random(-0.1,0.1);
    radius = s.radius+ var * random(-0.5,0.5);
    if(radius < 3)
       radius = 3;  // minimum radius 
 //   v = s.v + random(-2.0,2.0);
    maxV = s.maxV + var * random(-2.0,2.0);
    if(maxV > 10)
       maxV = 10;
 //   if(v < 0)
 //      v *=-1;  // maintain positive speed
    if(random(0,1.0) < 0.5)
       theta = s.theta + PI/4;
    else 
       theta = s.theta - PI/4;
    int crange = 8;
    float newRed,newBlue,newGreen;
    
    newRed = red(s.c)+ var * random(-1*crange,crange)*random(-1*crange,crange);
    if(newRed < 0)
      newRed = 0;
    if(newRed > 255)
      newRed = 255;
    
    newGreen = green(s.c)+ var * random(-1*crange,crange)*random(-1*crange,crange);
    if(newGreen < 0)
      newGreen = 0;
    if(newGreen > 255)
      newGreen = 255;
    
    newBlue = blue(s.c)+ var * random(-1*crange,crange)*random(-1*crange,crange);
    if(newBlue < 0)
      newBlue = 0;
    if(newBlue > 255)
      newBlue = 255;
    
    c = color(newRed,newGreen,newBlue);
    if(mutateAlpha){
        alphaC = alphaC+ var * int(random(-1*crange,crange));
    }
    if(alphaC < 10)
        alphaC = 10;  // can't go completely invisible
    if(alphaC > 255)
        alphaC = 255;
   }
  
  float get_radius(){
    return radius;
  }
  
  void replace(AphidPop pop, boolean variation){
    bug[] aphids = pop.pop;
    int parent;
    int flag=0;
    int var = 0;
    boolean allGone = true;

    if (variation) var = 1;

    for(int i =0; i < pop.popsize; i++){
      if(aphids[i] != null){
         allGone = false;
         break;
      }
    }
    if(allGone == true)
      return;  // no aphids left, keep playing until restart
    do{
      parent = int(random(pop.popsize-1));
      if(aphids[parent] != null && aphids[parent] != this){
//        if(random(maxAge) < (aphids[parent].age+1))
           flag = 1;
      }
    }while(flag == 0);
    //if (pop.variationOn == 0)
      //println("copying bug " + parent);
      
    if (pop.heritabilityOn) mutCopy(aphids[parent], var);
  }
  
  void move(ladybug lady){   
      runNN(lady);
      age++;
      x+=(v*sin(theta));
      y+=(v*cos(theta));
      if(side == 1){//left
        if(x < boarder)
           x = boardWidth+boarder;
        if(x>boardWidth+boarder)
           x = boarder;
      }
      if(side == 0){//right
        if(x < boardWidth+2*boarder)
           x = 2*boardWidth+2*boarder;
        if(x>2*boardWidth+2*boarder)
           x = boardWidth+2*boarder;
      }
      if(side == 2){ // full screen
        if(x < 0)
           x = 2*boardWidth+2*boarder;
        if(x>2*boardWidth+2*boarder)
           x = boarder;
      }
      if(y < boarder)
         y = boardHeight+boarder;
      if(y>boardHeight+boarder)
         y = boarder;
  }
  
  void display(){
    color b_col;
    noStroke();
    int inv_col;
    if (isTarget) {
      if (lessonNum == 1) b_col = leavesAll;
      else {
        if (side == 1) b_col = leavesLeft;
        else b_col = leavesRight;
      }
      inv_col = (int((red(b_col) + blue(b_col) + green(b_col)) / 3) > 127)?0:255;
      fill(inv_col,inv_col,inv_col,alphaC);
      ellipse(x,y,radius+5,radius+5);
    }
    fill(0,0,0,alphaC);
    ellipse(x+(radius*0.5)*sin(theta-0.2),y+(radius*0.5)*cos(theta-0.2),radius*.25,radius*.25);
    ellipse(x+(radius*0.5)*sin(theta+0.2),y+(radius*0.5)*cos(theta+0.2),radius*.25,radius*.25);
    fill(c,alphaC);
    ellipse(x,y,radius,radius);
      
  } 
}
      // ---------------------------------------------------------------------------------

class AphidPop {
  public bug[] pop;
  private int popsize;
  private boolean heritabilityOn;
  private boolean variationOn;
  private int side;
  public int[] colors;
  public float[] rel_colors;
//  PopData[] data;

  AphidPop(int n, int s){
    popsize = n;
    heritabilityOn = true;
    variationOn = true;
    side = s;
    colors = new int[3];
    rel_colors = new float[3];
    pop = new bug[popsize];
    for (int i = 0; i < popsize; i++) {
      pop[i] = new bug(side);
    }
//    colorCount();    
  }

  void move (ladybug lady) {
    for(int i = 0; i < popsize;i++){
      if(pop[i] != null){
        if(!PAUSE){
          pop[i].move(lady);
        }
        pop[i].display();
      }
      else{   
        pop[i] = new bug(side);
        //if (variationOn == 0)
          //println("creating new bug, id = " + i);
        pop[i].replace(this, variationOn);
      }
    }
  }

  void colorCount(){  
    colors[0] = colors[1] = colors[2] = 0;
    rel_colors[0] = rel_colors[1] = rel_colors[2] = 0;
    int count = 0;
    
    for(int i = 0; i < popsize; i++){
      if(pop[i] != null){
        count++;
        rel_colors[0] += red(pop[i].c);
        rel_colors[1] += green(pop[i].c);
        rel_colors[2] += blue(pop[i].c);
        if(red(pop[i].c) > green(pop[i].c) && red(pop[i].c) > blue(pop[i].c))
           colors[0]++;
        else if(green(pop[i].c) > red(pop[i].c) && green(pop[i].c) > blue(pop[i].c))
           colors[1]++;
        else
           colors[2]++;
      }
    }
    if (count > 0) {
      rel_colors[0] /= (count*255);
      rel_colors[1] /= (count*255);
      rel_colors[2] /= (count*255);      
    }
  }


  
  void ToggleH() {
    heritabilityOn = !heritabilityOn;
  }
  void ToggleV() {
      variationOn = !variationOn;
  }
}  

class PopData {
  int numRed;
  int numBlue;
  int numGreen;
  color avgColor;
  float avgSpeed;
  float avgAlpha;
}
      // ---------------------------------------------------------------------------------
      
class ladybug{
  float dx;
  float dy;
  float x;
  float y;
  float tx, ty;
  float angle;
  float radius;
  float circleAngle = 0;
  float circleRadius = boardWidth/3;
  float deltaRadius = -0.5;
  float maxSpeed;
  int behavior;
  int ladybugSide = 1; // 1=left, 0=right, 2 = both
  int aphidsCaught;
  int targetAphid;
  
  ladybug(float ix,float iy, float ir,int s){
    // initialize the ladybug
     x = ix;
     y=iy;
     tx = -1;
     ty = -1;
     radius = ir;
     maxSpeed = 10;
     behavior = 3; // 3 = autonomous, 1 = user
     ladybugSide = s;
     aphidsCaught = 0;
     targetAphid = -1;
  }
  
  int get_aphidsCaught(){
    return(aphidsCaught);
  }
  
  void set_aphidsCaught(int a){
    aphidsCaught = a;
  }
  
  
  void setBehavior(int b){
    behavior = b;
  }
  
  int getBehavior(){
    return behavior;
  }
  
  void behaviorMove(bug[] aphids){
    switch(behavior){
      case 1:
        userMove();
        break;
      case 2:
        forwardAphidMove(aphids);
        break;
      case 3:
        forwardAphidMove(aphids);
        break;
      default:
        forwardAphidMove(aphids);
    }
    move();
  }
  
  void move(){
    if(dx > maxSpeed)
       dx = maxSpeed;
     if(dx < -1*maxSpeed)
        dx = -1*maxSpeed;
     if(dy > maxSpeed)
       dy = maxSpeed;
     if(dy < -1 * maxSpeed)
       dy = -1 * maxSpeed;
     x += dx; 
     y += dy; 
     if(ladybugSide == 1){ // left
       if(x < boarder || x > (boardWidth-boarder)){
         dx *=-1;
          x += dx;
       }
     }
     if(ladybugSide == 0){ // right
       if(x < (boardWidth+4*boarder) || x > (2*boardWidth+2*boarder)){
         dx *=-1;
         x += dx;
       }
     }
     if(ladybugSide == 2){ // all
       if(x < boarder || x > (2*boarder+2*boardWidth)){
         dx *=-1;
          x += dx;
       }
     }
     if(y < boarder || y > boardHeight+boarder){
       dy *=-1;
        y += dy;
     }
  }
  
  void ChooseTarget(bug[] aphids) {
    float angle = atan(dx/dy);   // calculate the ladybug angle
    float aphidAngle;
    float deltaX,deltaY;
    float probOfSeen;
    float distance,closestDistance = 1000;
    int closest = -1;
    int currTarget = targetAphid;
    int hc = 0;
    float hp = 0;
    float hpSum = 0;
    int buttonHeight = 20;
    if(dy<0)
       angle=angle+PI;

    if ((currTarget != -1) && (aphids[currTarget] != null)) aphids[currTarget].setTarget(false);
/*
    if (behavior == 2) {
      if ((targetAphid == -1) || (random(1) > .99)) {
        targetAphid = int(random(maxAphids));
      }
    }
*/
//    else {
        for(int i =0; i < maxAphids; i++){
          if(aphids[i] != null){
            hp = aphids[i].chanceToHide();
            hpSum+=hp;
            hc++;
            deltaX = (aphids[i].x-x);
            deltaY = (aphids[i].y-y);
            aphidAngle = atan(deltaX/deltaY);  // calculate aphid angle
            if(deltaY<0)
              aphidAngle+= PI;
            if(abs(angle-aphidAngle) < PI*0.75){  // nearly forward, ok to be closest
              if (behavior == 2) probOfSeen = 1.0;
              else probOfSeen = hp;
              if(i == targetAphid){  // same as last seen
                probOfSeen *= 5.0; // much more likely to see same aphid
              }
           /*
           if(probOfSeen > obviousness){
             mostObvious = i;
             obviousness = probOfSeen;
           }
           */
              if(random(0.0,1.0) < (probOfSeen)){  // can it hide
                distance = sqrt(deltaX*deltaX+deltaY*deltaY);
                if(distance < closestDistance){
                  closestDistance = distance;
                  closest = i;
                }
              }
           
            }
          } 
        }
        targetAphid = closest;
//      }
    if ((targetAphid != -1) && (aphids[targetAphid] != null)) aphids[targetAphid].setTarget(true);
    
    if ((ladybugSide == 1) && (behavior != 2)) {
      if (hc != 0)    
        hideChanceAvgLeft = hpSum/hc;
      else
        hideChanceAvgLeft = 0;
    }
    else if (behavior != 2) {
      if (hc != 0)    
        hideChanceAvgRight = hpSum/hc;
      else
        hideChanceAvgRight = 0;
    }
  }
  
  void forwardAphidMove(bug[] aphids){ 
    maxSpeed = 10; // how fast the aphid can move;
    float deltaX,deltaY;
    ChooseTarget(aphids);
    if((targetAphid != -1) && (aphids[targetAphid] != null)){
      deltaX = (aphids[targetAphid].x-x);
      deltaY = (aphids[targetAphid].y-y);
      dx = maxSpeed * deltaX * (deltaX*deltaX)/((deltaX*deltaX)+(deltaY*deltaY));
      dy = maxSpeed * deltaY * (deltaY*deltaY)/((deltaX*deltaX)+(deltaY*deltaY));
    }
  }

  void userMove(){ 
    maxSpeed = 20;  
    int adjustMouseX = mouseX;
    boolean targetFound = false;
    float diffX, diffY;
    
    for (int i = 0; !targetFound && (i < maxAphids); i++) {
      aphidsAll.pop[i].isTarget = false;
      diffX = aphidsAll.pop[i].x - mouseX;
      diffY = aphidsAll.pop[i].y - mouseY;
      if (sqrt(diffX*diffX + diffY*diffY) < aphidsAll.pop[i].radius) {
        targetFound = true;
        aphidsAll.pop[i].isTarget = true;
      }
    }
    if(ladybugSide == 1){
       if(adjustMouseX > boardWidth)
          adjustMouseX = boardWidth;  // avoids ladybug wrapping right
    }
    if(ladybugSide == 2){
       if(adjustMouseX > width)
          adjustMouseX = width;  // avoids ladybug wrapping right
    }
    dx=0.3*(adjustMouseX-x);
    dy=0.3*(mouseY-y);
  }
  
  void randomMove() {    
    float deltaX,deltaY;
    
    if ((tx < 0) || (ty < 0)) { // Set new target location
      tx = random(boardWidth);
      ty = random(boardHeight);
    }
    else {
      tx += random(-1*maxDrift, maxDrift);
      ty += random(-1*maxDrift, maxDrift);
    }
    deltaX = tx-x;
    deltaY = ty-y;
    if (tx > boardWidth) tx = -1;
    if (ty > boardHeight) ty = -1;
    if (random(1) > .95) tx = -1;
    dx = maxSpeed * deltaX * (deltaX*deltaX)/((deltaX*deltaX)+(deltaY*deltaY));
    dy = maxSpeed * deltaY * (deltaY*deltaY)/((deltaX*deltaX)+(deltaY*deltaY));
  }
  
  void eat(bug[] aphids){
    float dist;
    for(int i = 0; i < maxAphids;i++){
      if(aphids[i] !=null){
          dist = ((aphids[i].x-x)*(aphids[i].x-x)+(aphids[i].y-y)*(aphids[i].y-y));
      //    if(aphids[i].isTarget && (sqrt(dist)<(radius*0.8))){
          if((sqrt(dist)<(radius*0.8)) && (  aphids[i].isTarget || (behavior == 1))){
            aphids[i] = null; // erase old aphid
            //score++;
            aphidsCaught++;
          }
      }
    }
  }
  
  float get_radius(){
    return radius;
  }
  
  void displaylady (){
    if(dy == 0.0)
       dy = 0.0001;
    float angle = atan(dx/dy);
    if(dy<0)
       angle=angle+PI;
    stroke(0,0,0);
    fill(255,0,0);
    
    ellipse(x,y,radius,radius);
    line(x+(radius-1)/2*sin(angle),y+(radius-1)/2*cos(angle),x-(radius-1)/2*sin(angle),y-(radius-1)/2*cos(angle));
    fill(0,0,0);
    ellipse(x+(radius*0.5)*sin(angle),y+(radius*0.5)*cos(angle),radius*.25,radius*.25);
    ellipse(x+(radius)/4*sin(angle+PI/3),y+(radius)/4*cos(angle+PI/3),radius/5,radius/5);
    ellipse(x+(radius)/4*sin(angle-PI/3),y+(radius)/4*cos(angle-PI/3),radius/5,radius/5);
    ellipse(x+(radius)/4*sin(angle+2*PI/3),y+(radius)/4*cos(angle+2*PI/3),radius/5,radius/5);
    ellipse(x+(radius)/4*sin(angle-2*PI/3),y+(radius)/4*cos(angle-2*PI/3),radius/5,radius/5);
    
 //   stroke(255,255,255);
 //   line(x,y,x + 400*sin(angle-PI/4),y + 400*cos(angle-PI/4));
 //   line(x,y,x + 400*sin(angle+PI/4),y + 400*cos(angle+PI/4));
    
  } 
} 
      
      //---------------------------------------------------
   
void addLeaves(PGraphics leavesPG, color baseC,int imageScale){
    float x,y,r1,r2;
    int c1;
    color c;
    leavesPG.beginDraw();
    leavesPG.stroke(baseC);
    leavesPG.fill(baseC);
    leavesPG.rect(0,0,boardWidth,height);
    for(int i =0; i < numLeaves; i++){
        x = random(-10,boardWidth*imageScale);
        y = random(-10,height);
        r1 = random(50,100);
        r2 = random(50,100);
   //     c = color(int(random(0,50)),int(random(180,220)),int(random(0,50)));
   //c1 = 40; // int(random(20,80));
        c = color(red(baseC)+int(random(-20,20)),green(baseC)+int(random(-20,20)),blue(baseC)+int(random(-20,20)));
        leavesPG.stroke(c);
        leavesPG.fill(c);
        leavesPG.ellipse(x,y,r1,r2);
    }
    leavesPG.endDraw();
  }
  
///////////////   Start Windows Code ////////////////////

int boxSize = 20;

void drawStartWindow(){
  stroke(0,255,0);
  strokeWeight(3);
  fill(100,100,100,180);
  rect(50,50,width-100,height-200);
  stroke(0);
  strokeWeight(1);
  for(int i = 0; i < numLessons; i++){
    rect(100,100+i*2*boxSize,boxSize,boxSize);
  }
  fill(0,0,0,255);
  textFont(fontData);
  textAlign(LEFT);
  int textLeft = 130;
  int textHeight = 115;
  text("Lesson 1 - Introduction: Control the Ladybug to capture aphids.", textLeft, textHeight);
  text("Lesson 2 - Evolution in action: Compare evolution in different environments.", textLeft, textHeight+2*boxSize);
  text("Lesson 3 - Variation: Mutation is turned off in the left hand environment.", textLeft, textHeight+4*boxSize);
  text("Lesson 4 - Inheritance: Inheitiance is turned off in the left hand environment.", textLeft, textHeight+6*boxSize);
  text("Lesson 5 - Selection: In the left hand environment, the Ladybug ignores aphid colors.", textLeft, textHeight+8*boxSize);
//  text("Lesson 6 - Experiment (not implemented)", textLeft, textHeight+10*boxSize);
  if(lessonNum != 0){
    strokeWeight(2);
    int step = (lessonNum-1)*2*boxSize;
    line(100,100+step,100+boxSize,100+step+boxSize);
    strokeWeight(2);
    line(100,100+step+boxSize,100+boxSize,100+step);
  }
  fill(100,100,100);
  rect(200,height-250,100,20);   // start button
  textAlign(CENTER);
  fill(0);
  text("Start",250,height-235);
}

void startWindowCheckButtons(){
  if(mouseX > 200 && mouseX < 300 && mouseY > height-250 && mouseY < height-230){ // start button
    if(lessonNum >= 1 && lessonNum <= numLessons){
      startWindow = false;
      setUp();
    }
  }
  if(mouseX<100 || mouseX > 100+boxSize){
    return; // not in right column
  }
  if(mouseY > 100+0*boxSize && mouseY < 100+1*boxSize){
    lessonNum = 1;
  }
  if(mouseY > 100+2*boxSize && mouseY < 100+3*boxSize){
    lessonNum = 2;
  }
  if(mouseY > 100+4*boxSize && mouseY < 100+5*boxSize){
    lessonNum = 3;
  }
  if(mouseY > 100+6*boxSize && mouseY < 100+7*boxSize){
    lessonNum = 4;
  }
  if(mouseY > 100+8*boxSize && mouseY < 100+9*boxSize){
    lessonNum = 5;
  }
  /*
  if(mouseY > 100+10*boxSize && mouseY < 100+11*boxSize){
    lessonNum = 6;
  }
  */
}

void setUpPop(boolean left_var, boolean right_var, boolean left_her, boolean right_her) {
  if (aphidsLeft.variationOn != left_var) aphidsLeft.ToggleV();
  if (aphidsRight.variationOn != right_var) aphidsRight.ToggleV();
  if (aphidsLeft.heritabilityOn != left_her) aphidsLeft.ToggleH();
  if (aphidsRight.heritabilityOn != right_her) aphidsRight.ToggleH();
  
}

void setUp(){
  switch(lessonNum){
    case 1:
      frameParamsLeft = (0 | INHERITANCE_MASK | VARIATION_MASK | SELECTION_MASK);
      ladyall.setBehavior(1);
      aphidsAll = new AphidPop(maxAphids,2);
      reset();
      leavesAll = color(20,200,20);
      addLeaves(leavesPGall,leavesAll,2);
      showBackgroundColor(false);
      break;
    case 2:
      frameParamsRight = (0 | INHERITANCE_MASK | VARIATION_MASK | SELECTION_MASK);
      frameParamsLeft = (0 | INHERITANCE_MASK | VARIATION_MASK | SELECTION_MASK);
      setUpPop(true,true,true,true);
      leavesLeft = color(200,20,20);
      leavesRight = color(20,200,20);
      addLeaves(leavesPGright,leavesRight,1);
      addLeaves(leavesPGleft,leavesLeft,1);
      ladyleft.setBehavior(0);
      ladyright.setBehavior(0);
      break;
    case 3:
      frameParamsRight = (0 | INHERITANCE_MASK | VARIATION_MASK | SELECTION_MASK);
      frameParamsLeft = (0 | INHERITANCE_MASK | SELECTION_MASK);
      leavesLeft = color(20,200,20);
      leavesRight = color(20,200,20);
      addLeaves(leavesPGright,leavesRight,1);
      addLeaves(leavesPGleft,leavesLeft,1);
      setUpPop(false,true,true,true);
      ladyleft.setBehavior(0);
      ladyright.setBehavior(0);
      showBackgroundColor(true);
      break;
    case 4:
      frameParamsRight = (0 | INHERITANCE_MASK | VARIATION_MASK | SELECTION_MASK);
      frameParamsLeft = (0 | VARIATION_MASK | SELECTION_MASK);
      leavesLeft = color(200,20,20);
      leavesRight = color(200,20,20);
      addLeaves(leavesPGright,leavesRight,1);
      addLeaves(leavesPGleft,leavesLeft,1);
      setUpPop(true,true,false,true);
      ladyleft.setBehavior(0);
      ladyright.setBehavior(0);
      showBackgroundColor(true);
      break;
    case 5:       
      frameParamsRight = (0 | INHERITANCE_MASK | VARIATION_MASK | SELECTION_MASK);
      frameParamsLeft = (0 | INHERITANCE_MASK | VARIATION_MASK);
      leavesLeft = color(20,20,200);
      leavesRight = color(20,20,200);
      addLeaves(leavesPGright,leavesRight,1);
      addLeaves(leavesPGleft,leavesLeft,1);
      setUpPop(true,true,true,true);
      ladyleft.setBehavior(2);
      ladyright.setBehavior(0);
      showBackgroundColor(true);
      break;
      default:
      // error, quit
  }
}

void showFrameParams(int side, int params) {
  int buttonHeight = 20;
  int textLeft = 350;
  int textHeight = boardHeight + 24;

  fill(0,0,0,255);
  textFont(fontData);
  textAlign(LEFT);
  
  text("Inheritance: " + (((params & INHERITANCE_MASK) > 0)?"ON":"OFF"), textLeft+(boardWidth*side), textHeight);
  text("Variation: " + (((params & VARIATION_MASK) > 0)?"ON":"OFF"), textLeft+(boardWidth*side), textHeight+buttonHeight);
  text("Color Selection: " + (((params & SELECTION_MASK) > 0)?"ON":"OFF"), textLeft+(boardWidth*side), textHeight+(buttonHeight*2));
}

void draw_HSVCW(PGraphics target, float cx, float cy, float r) {
  float[] HSV = new float[3];
  float[] RGB = new float[3];
  float theta,dx,dy;
  color col;
  float r_p = r*.95;
  target.beginDraw();
  for (float rad = 0.0; rad < r_p; rad += .5) {
    //HSV[S] = rad / 100.0;
    HSV[S] = ((rad*2.0) <= r)?((rad*2) / r):1.0;
    HSV[V] = ((rad*2.0) <= r)?1.0:((r-rad)*2.0/r);
    for (float deg = 0.0; deg < 360.0; deg += .5) {
      //HSV[V] = 1.0;
      HSV[H] = deg;
      theta = deg * PI / 180.0;
      RGB = HSV2RGB(HSV);
      dx = rad * cos(theta);
      dy = rad * sin(theta);
      col = color(RGB[R]*255,RGB[G]*255,RGB[B]*255);
      target.set(int(cx+dx),int(cy+dy),col);
    }
  }
  target.endDraw();
}

float[] HSV2RGB(float[] HSV) {
  float H_prime;
  float c, x, m;
  float[] RGB_col = new float[3];
  RGB_col[R] = RGB_col[G] = RGB_col[B] = 0.0;
//  println(HSV[H] + " " + HSV[S] + " " + HSV[V]);
  if(HSV[V] >= 0.0) {
    H_prime = HSV[H] / 60.0;
    c = HSV[S] * HSV[V];
    m = HSV[V] - c;
    x = c * (1-(abs((H_prime % 2.0) - 1.0)));
//    println(HSV[H] + " " + HSV[S] + " " + HSV[V] + " " + H_prime + " " + c + " " + x + " " + m);
    switch (int(H_prime)) {
      case 0:
        RGB_col[R] = c;
        RGB_col[G] = x;
        break;
      case 1:
        RGB_col[G] = c;
        RGB_col[R] = x;
        break;
      case 2:
        RGB_col[G] = c;
        RGB_col[B] = x;
        break;
      case 3:
        RGB_col[B] = c;
        RGB_col[G] = x;
        break;
      case 4:
        RGB_col[B] = c;
        RGB_col[R] = x;
         break;
     case 5:
        RGB_col[R] = c;
        RGB_col[B] = x;
        break;
      default:
        break;
    }
    for (int i = 0; i < 3; i++) RGB_col[i] = (RGB_col[i]+m);
  }
  return RGB_col;
}

void DrawControlBox() {
  showFrameParams(0,frameParamsLeft);
  showFrameParams(1,frameParamsRight);
  showBackgroundColor(true);
}