plantilla_simTrafico.pde

//simulacion de trafico afectado por el cansancio de los conductores
//Encuentro de Processing 30 y 31 de Mayo

//controles globales del circuito
float curv=20;//curvatura del circuito: 100 = curvas muy cerradas, 0 = curvas muy abiertas
float ncurv=0.2;//numero de curvas: solo va bien con los valores 0.2, 0.1 y 0.05
float ancho=3;//distancia entre los dos carriles

//Arrays de los puntos de la carretera
Vertice[] puntosInt=new Vertice[0];//lista que contiene todos los puntos del carril interior
Vertice[] puntosExt=new Vertice[0];//lista que contine todos los puntos del carril exterior

//ArrayLists de los coches
ArrayList<Car>listaCar=new ArrayList<Car>();

////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
void setup() {
  size(600, 600);
  background(0);
  loadRoad();
  calculateCurv();//asigna el atributo de curvatura a cada punto de los carriles del circuito

}


void draw() {
  background(0);
  drawRoad();
  
}
///////////////////////////////////////////////////////////////////
//funciones generales para el setup()
///////////////////////////////////////////////////////////////////

void loadRoad(){//esta funcion define el circuito/carretera para los coches
  float step=PI/100;
  for(float i=0;i<2*PI;i=i+step){
    /////carril interior
    float r=200+curv*sin(i/ncurv);//radio variable
    float x=width/2+r*cos(i);//circunferencia, coordenada x
    float y=height/2+r*sin(i);//circunferencia, coordenada y
    
    PVector loc1=new PVector(x,y,0);
    float curvatura1=0;//despues calcularemos su valor
    String carril1="interior";

    Vertice vertInt=new Vertice(loc1, curvatura1, carril1);
    puntosInt=(Vertice[])append(puntosInt, vertInt);//añade el vertice a la lista de vertices del carril interior
    
    /////carril exterior
    float r2=200+curv*sin(i/ncurv)+ancho;
    float x2=width/2+r2*cos(i);
    float y2=height/2+r2*sin(i);
    
    PVector loc2=new PVector(x2,y2,0);
    float curvatura2=0;//despues calcularemos su valor
    String carril2="exterior";

    Vertice vertExt=new Vertice(loc2, curvatura2, carril2);
    puntosExt=(Vertice[])append(puntosExt, vertExt);//añade el vertice a la lista de vertices del carril interior

    }
 }

 void calculateCurv(){
    //esta funcion calcula la curvatura de cada punto de los carriles del circuito
    //digamos que re-asigna el valor del atributo curvatura que se habia fijado como "0"
 }
 
 void loadCars(){
  //crea instancias de la clase Car y los mete en el ArrayList ListaCar
 }
 
 /////////////////////////////////////////////////////////////////////////
 //funciones generales para el draw()
 ////////////////////////////////////////////////////////////////////////
 
 void drawRoad(){//dibuja la carretera / falta un segemento si alguien lo puede arreglar / gracias!
    stroke(255,100);//color de las lineas
    for(int i=1;i<puntosInt.length;i++){
      Vertice v1=puntosInt[i];
      Vertice v2=puntosInt[i-1];
      line(v1.loc.x,v1.loc.y,v2.loc.x,v2.loc.y);
    }
    for(int i=1;i<puntosExt.length;i++){
      Vertice v1=puntosExt[i];
      Vertice v2=puntosExt[i-1];
      line(v1.loc.x,v1.loc.y,v2.loc.x,v2.loc.y);
    }
 }

class Vertice{
  PVector loc;//coordenadas x y de cada punto del carril
  float curvatura;//curvatura en cada punto del carril
  String carril;//interior o exterior
  
  Vertice(PVector _loc, float _curvatura, String _carril){
    loc=_loc;
    curvatura=_curvatura;
    carril=_carril;
  }
   
}

class Car{
  //parametros propios
  PVector loc;//posicion del coche en cada momento
  PVector vel;//velocidad del coche en cada momento
  PVector acc;//aceleracion del coche en cada momento
  PVector velint;//velocidad [intencionada] deseada por el conductor
  String carril;//izquierdo o derecho
  int coefseg;//distancia de seguridad que procura el conductor, en funcion de la velocidad (a mas velocidad, mas distancia)
  
  //parametros que afectan la atencion
  int cansancio;//nivel de cansancio de 1 a 100
  int time;//tiempo acumulado de conduccion
  
  //parametros de terceros
  int distdel;//distancia percibida del coche de delante
  int distx_tras;//distancia percibida del coche de delante en el otro carril
  int distx_del;//distancia percibida del coche de detras en el otro carril
  PVector veldel;//velocidad percibida del coche de delante
  PVector velx_tras;//velocidad percibida del coche de delante en el otro carril
  PVector velx_del;//velocidad percibida del coche de detras en el otro carril
  
  Car (PVector _loc, PVector _vel, PVector _acc, PVector _velint, String _carril, int _coefseg, int _cansancio, int _time, 
  int _distdel, int _distx_tras, int _distx_del, PVector _veldel, PVector _velx_tras, PVector _velx_del){
    loc=_loc;
    vel=_vel;
    acc=_acc;
    velint=_velint;
    carril=_carril;
    coefseg=_coefseg;
    cansancio=_cansancio;
    time=_time;
    distdel=_distdel;
    distx_tras=_distx_tras;
    distx_del=_distx_del;
    veldel=_veldel;
    velx_tras=_velx_tras;
    velx_del=_velx_del;
  }
  
  void drive(){
    //esta funcion lee los puntos de la curva para obtener la direccion del vector velocidad
    //debe usar la funcion changeLane definida mas abajo
  }
  
  void getFrontInfo(){
    //esta funcion detecta la distancia y la velocidad del coche de delante. Puede introducirse un coeficiente de desviacion en funcion del cansancio
  }
  
  void getxLaneInfo(){
    //esta funcion detecta la distancia y la velocidad del coche de delante y de atras del otro carril. Puede introducirse un coeficiente de desviacion en funcion del cansancio
  }
  
  void adjustSpeed(){
    //esta funcion calcula la magnitud de la velocidad en funcion de:
    // 1. la velocidad deseada
    // 2. la curvatura de la carretera en el punto siguiente (la curvatura se ha definido como un atributo de la clase Vertice)
    // 3. la del coche de delante
  }
  
  void changeLane(){
    //esta funcion hace cambiar al coche de carril, si la velocidad es menor que la deseada cambia al carril izquierdo.
    //para cambiar al carril izquierdo, primero debe comprobar la distancia y velocidad de los coches del carril izquierdo por delante y por detras.
    //una vez cambiado de carril debe volver al derecho cuando le sea posible aplicando la misma comprobacion anterior, añadiendo una condicion: que haya adelantado al menos a un coche.
    
  }
  
  void crash(){
    //detecta cuando un coche ha colisionado con otro... puede dejar una mancha roja en la pantalla y llevar un contador de accidentes,..
  }
  
  void render(){
    //esta funcion dibuja el coche, puede incluir lineas de conexion con otros coches en casos de distancias peligrosas etc,.. tambien se pueden colorear los coches en funcion del cansancio etc..
  }
    
}