// car accidents
// Written June 2006 by Jarek Rossignac

import krister.Ess.*;
import java.util.ArrayList;

float t=0, t0=0, d=2000.0; // time measured in miliseconds, aniamtion start time, duration
boolean run = false;
color red=color(256,100,100), green=color(100,256,100), blue=color(100,100,256), yellow=color(256,230,100), grey=color(100,100,100);
int nr=6; 
car C [] = new car [nr];
int ns=6; 
street S [] = new street [ns];
vec I=new vec (1,0);

//===============================
AudioChannel myChannel;
int mode = -1;
int playback_mode = 0;   
int selectedCar = -1;
int step = 0;
CubicBezier pathCurve;
pt draggedCP = null;
int cam = 2 * nr;
ArrayList collisions = new ArrayList();
//===============================

void setup()
{
  Ess.start(this);
  myChannel = new AudioChannel("crash.mp3");
  framerate(40);
  
  size(1000, 800, P3D);
  createCars ();
  createStreets();
  //loadAccident(1);
}

void createCars () {
  C[0] = new car(760,300,2*PI/3,red);  
  C[1] = new car(690,520,3*PI/2,green);  
  C[2] = new car(780,500,3*PI/2,blue);  
  C[3] = new car(450,310,0,grey);  
  C[4] = new car(940,220,PI,grey);  
  C[5] = new car(600,60,PI/2,grey);  
}

void createStreets () {
  S[0] = new street(650,50,650,750,90);
  S[1] = new street(740,50,740,750,90);
  S[2] = new street(50,270,950,270,90);
  S[3] = new street(200,50,200,750,90);
  S[4] = new street(310,620,440,450,70);
  S[5] = new street(290,610,460,720,70);
}

public void stop()
{
  Ess.stop();
  super.stop();
}

void draw()  
{
  //===============================
  if(run)
    checkForCollisions();
    
  if(cam == 2 * nr)
    camera();
  else if(cam % 2 == 0)
  {
    int cameraCar = cam / 2;
    pt lookFrom = C[cameraCar].F.make();
    pt lookAt = lookFrom.make();
    lookAt.x += 100;
    lookAt.turnAround(lookFrom, -(C[cameraCar].a));
    camera(lookFrom.x, lookFrom.y, 2 * C[cameraCar].h / 3, lookAt.x, lookAt.y, 2 * C[cameraCar].h / 3, 0, 0, -1);
  }
  else
  {
    int cameraCar = cam / 2;
    pt lookFrom = C[cameraCar].F.make();
    pt lookAt = lookFrom.make();
    lookAt.x += 100;
    lookAt.turnAround(lookFrom, -(C[cameraCar].a));
    vec behind = lookAt.vecTo(lookFrom);
    behind.unit();
    behind.mul(2 * C[cameraCar].w);
    lookFrom.addVec(behind);
    camera(lookFrom.x, lookFrom.y, C[cameraCar].w, lookAt.x, lookAt.y, 2 * C[cameraCar].h / 3, 0, 0, -1);
  }
    
  lights();
  //===============================

  background (255);
  rectMode(CENTER);  
  for (int i=0; i<ns; i++) {
    S[i].paint();
  }; 
  stroke(255,245,200);
  for (int i=0; i<ns; i++) {
    S[i].paintLine();
  }; 
  if (run) { 
    t=millis()-t0;  
    if (t>d) {
      t=d;
    };
  }    // time during animation
  else {
    t = 0;
  };
  for (int i=0; i<nr; i++) {
    if (C[i].picked) {
      fill(200,100,100);
    }
    else {
      fill(100,200,100);
    };
    if(run) {
      C[i].animate(t/d, playback_mode);
    }
    C[i].paint(selectedCar == i);
  }; 
  if(keyPressed&&(key=='g')) {
    for (int i=0; i<ns; i++) {
      S[i].paintDots();
    };
    for (int i=0; i<nr; i++) {
      C[i].paintDots();
    };
  };
  
  //===============================
  //Draw collisions
  for(int k = 0; k < collisions.size(); k ++)
  {
    collision c = (collision)(collisions.get(k));
    if(c != null && c.radius > 0)
    {
      println("yo");
      fill(255, 255, 255, 127);
      noStroke();
      ellipse(c.position.x, c.position.y, 2 * c.radius, 2 * c.radius);
      c.radius -= 10;
    }
  }
  //===============================
}

void mousePressed()
{
  if(mode == -1)
    return;

  if (mouseButton == LEFT)
  {
    //===============================
    //Added so we cannot move cars or streets while we're defining a path
    if(selectedCar > -1)
      return;
    //===============================

    boolean found=false; 

    //===============================
    for(int i = nr - 1; i >= 0; i--)
    {
      if(C[i].path[mode] != null)
      {
        // p1 for ith car
        vec distanceVec = C[i].path[mode].p1.vecTo(mouse());
        if(distanceVec.norm() <= 3)
        {
          println("CP 1 of path of car " + i + " has been selected");
          found = true;
          draggedCP = C[i].path[mode].p1;
        }
        // p2 for ith car
        distanceVec = C[i].path[mode].p2.vecTo(mouse());
        if(distanceVec.norm() <= 3)
        {
          println("CP 2 of path of car " + i + " has been selected");
          found = true;
          draggedCP = C[i].path[mode].p2;
        }
        // p3 for ith car
        distanceVec = C[i].path[mode].p3.vecTo(mouse());
        if(distanceVec.norm() <= 3)
        {
          println("CP 3 of path of car " + i + " has been selected");
          found = true;
          draggedCP = C[i].path[mode].p3;
        }
      }
    }
    //===============================
    for (int i=nr-1; i>=0; i--)
    {
      if (!found)
      {
        if(C[i].selected())
        {
          found=true;
        };
      };
    };
    for (int i=ns-1; i>=0; i--)
    {
      if (!found)
      {
        if(S[i].selected())
        {
          found=true;
        };
      };
    };
  }//if (mouseButton == LEFT)
  else
  {
    if(selectedCar > -1) // there is a car selected for path design
    {
      switch(step)
      {
      case 1:
        //Special case: the second control point determines the tangent on the first endpoint
        //I will make it so that the position of the mouse simply specifies the distance from
        //the car along the long axis of the car
        vec carVec = C[selectedCar].B.vecTo(C[selectedCar].F);
        carVec.unit();
        carVec.mul(dot(pathCurve.p0.vecTo(mouse()), carVec));
        pt p1 = C[selectedCar].F.make();
        p1.addVec(carVec);
        pathCurve.p1.setTo(p1);
        println("Point 1: (" + pathCurve.p1.x + ", " + pathCurve.p1.y + ")");
        step++;
        break;
      case 2:
        pathCurve.p2.setTo(mouse());
        println("Point 2: (" + pathCurve.p2.x + ", " + pathCurve.p2.y + ")");
        step++;
        break;
      case 3:
        pathCurve.p3.setTo(mouse());
        println("Point 3: (" + pathCurve.p3.x + ", " + pathCurve.p3.y + ")");
        C[selectedCar].path[mode] = pathCurve.make();
        println("Car " + selectedCar + "'s path has been finished.");
        step = 0;
        selectedCar = -1;
        break;
      default:
        println("ERROR 1");
        break;
      }
    }//if(selectedCar > 0)
    else                // there are no selected cars
    {
      for (int i=nr-1; i>=0; i--)
      {
        if(C[i].selected2())
        {
          if(C[i].path[mode] != null)
            return;
          selectedCar = i;
          println("Car " + selectedCar + " has been selected for path design.");
          pathCurve = new CubicBezier();
          pathCurve.p0.setTo(C[selectedCar].F);
          println("Point 0: (" + pathCurve.p0.x + ", " + pathCurve.p0.y + ")");
          step = 1;
          break;
        }
      }
    }//else
  }//else
} 

void mouseDragged()
{
  if(mode == -1)
    return; 
  if(draggedCP != null)
  {
    draggedCP.setTo(mouse());
    return;
  }
  for (int i=0; i<nr; i++)
  {
    if(C[i].picked)
    {
      for(int k = 0; k < 3; k++)
        C[i].path[k] = null;
      C[i].track();
    };
  };
  for (int i=0; i<ns; i++)
  {
    if(S[i].picked)
    {
      S[i].track();
      S[i].snap();
    };
  };
}

void mouseReleased()
{
  if(mode == -1)
    return;
  if(draggedCP != null)
  {
    draggedCP = null;
    return;
  }
  for (int i=0; i<nr; i++)
  {
    C[i].picked=false;
  }; 
  for (int i=0; i<ns; i++)
  {
    S[i].pickedF=false;
    S[i].pickedB=false;
    S[i].picked=false;
  }; 
};

void keyPressed() {
  if (key==' ') { 
    if(mode == -1) {
      return;
    }; 
    if (!run) {
      run=true; 
      t0=millis(); 
      playback_mode = mode; 
      for(int x=0; x<nr; x++) {
        C[x].Br.setTo(C[x].B); 
        C[x].Fr.setTo(C[x].F);
      };
    };
  };
  if (key=='c') {
    createCars();
  };
  if (key=='s') {
    createStreets();
  };
  if (key=='1') {
    loadAccident(1);
  };
  if (key=='2') {
    loadAccident(2);
  };
  if (key=='3') {
    loadAccident(3);
  };
  if (key=='4') {
    loadAccident(4);
  };
  if (key=='5') {
    loadAccident(5);
  };
  if (key=='6') {
    loadAccident(6);
  };
  if (key=='S') {
    saveAccident();
  };
  if (key=='q') {
    mode = 0; 
    playback_mode = mode; 
    println("Edit mode 1");
  }
  if (key=='w') {
    mode = -1; 
    playback_mode = mode; 
    println("Playback mode");
  }
  if (key=='e') {
    mode = 2; 
    playback_mode = mode; 
    println("Edit mode 3");
  }
  if (key=='r') {
    mode = 1; 
    playback_mode = mode; 
    println("Edit mode 2");
  }
  if (key=='a') { 
    if (!run) {
      run=true; 
      t0=millis(); 
      playback_mode = 0; 
      for(int x=0; x<nr; x++) {
        C[x].Br.setTo(C[x].B); 
        C[x].Fr.setTo(C[x].F);
      };
    };
  };
  if (key=='d') { 
    if (!run) {
      run=true; 
      t0=millis(); 
      playback_mode = 2;  
      for(int x=0; x<nr; x++) {
        C[x].Br.setTo(C[x].B); 
        C[x].Fr.setTo(C[x].F);
      };
    };
  };
  if (key=='f') { 
    if (!run) {
      run=true; 
      t0=millis(); 
      playback_mode = 1;  
      for(int x=0; x<nr; x++) {
        C[x].Br.setTo(C[x].B); 
        C[x].Fr.setTo(C[x].F);
      };
    };
  };
  if(key == '[')
  {
    cam += (2 * nr + 1);
    cam--;
    cam %= (2 * nr + 1);
  }
  if(key == ']')
  {
    cam += (2 * nr + 1);
    cam++;
    cam %= (2 * nr + 1);
  }
}

void keyReleased() {
  if(run) {
    run=false; 
    t=0; 
    for(int x=0; x<nr; x++) {
      C[x].B.setTo(C[x].Br); 
      C[x].F.setTo(C[x].Fr); 
      C[x].animate(t, playback_mode);
    };
  };
}  // stop animation

void loadAccident(int accidentNumber) {
  println("Loading accident: " + accidentNumber);
  String accidentStrings[] = loadStrings("accident" + accidentNumber + ".txt");
  int index = 0;
  for(int x=0; x < ns; x++)
  {
    index = x*5;
    S[x] = new street(float(accidentStrings[index]), 
    float(accidentStrings[index+1]),
    float(accidentStrings[index+2]),
    float(accidentStrings[index+3]),
    float(accidentStrings[index+4]));
  }
  for(int x=0; x < nr; x++)
  {
    index = ns*5 + x*33;
    C[x] = new car(float(accidentStrings[index]),
    float(accidentStrings[index+1]),
    float(accidentStrings[index+2]),
    color(float(accidentStrings[index+3]), float(accidentStrings[index+4]), float(accidentStrings[index+5])));
    if(int(accidentStrings[index+6]) == 1) {
      pt pt1 = new pt(float(accidentStrings[index+7]),float(accidentStrings[index+8]));
      pt pt2 = new pt(float(accidentStrings[index+9]),float(accidentStrings[index+10]));
      pt pt3 = new pt(float(accidentStrings[index+11]),float(accidentStrings[index+12]));
      pt pt4 = new pt(float(accidentStrings[index+13]),float(accidentStrings[index+14]));
      C[x].setPath(new CubicBezier(pt1, pt2, pt3, pt4), 0);
    }
    if(int(accidentStrings[index+15]) == 1) {
      pt pt1 = new pt(float(accidentStrings[index+16]),float(accidentStrings[index+17]));
      pt pt2 = new pt(float(accidentStrings[index+18]),float(accidentStrings[index+19]));
      pt pt3 = new pt(float(accidentStrings[index+20]),float(accidentStrings[index+21]));
      pt pt4 = new pt(float(accidentStrings[index+22]),float(accidentStrings[index+23]));
      C[x].setPath(new CubicBezier(pt1, pt2, pt3, pt4), 1);
    }
    if(int(accidentStrings[index+24]) == 1) {
      pt pt1 = new pt(float(accidentStrings[index+25]),float(accidentStrings[index+26]));
      pt pt2 = new pt(float(accidentStrings[index+27]),float(accidentStrings[index+28]));
      pt pt3 = new pt(float(accidentStrings[index+29]),float(accidentStrings[index+30]));
      pt pt4 = new pt(float(accidentStrings[index+31]),float(accidentStrings[index+32]));
      C[x].setPath(new CubicBezier(pt1, pt2, pt3, pt4), 2);      
    }
  }
}

void saveAccident() {
  String accidentString = "";
  println("Saving current accident to Accident 6 slot.");
  for (int y=0; y < ns; y++) {
    accidentString = accidentString + S[y].toString() + " ";
  }
  for (int x=0; x < nr; x++) {
    accidentString = accidentString + C[x].toString() + " ";
  }
  saveStrings("accident6.txt", split(accidentString));
}

void checkForCollisions()
{
  if(nr < 2)
    return;
  pt collisionPoint = null;
  for(int i = 0; i < nr; i++)
    for(int j = i + 1; j < nr; j++)
    {
      collisionPoint = checkForCollision(C[i], C[j]);
      if(collisionPoint != null)
      {
        //println("Crash between cars " + i + " and " + j + "!");
        //Show hit
        collisions.add(new collision(collisionPoint, 90));
        //Play crash sound
        myChannel.play();          
        break;
      }
    }
}
// pt checkForCollision(car M, car N) is in car.pde

class collision
{
  pt position;
  int radius;
  
  collision(pt _position, int _radius)
  {
    position = _position;
    radius = _radius;
  }
}