boolean taskAtom = false;
boolean taskLive = false;
boolean taskDrone= false;


// screen input ratio------------------------------
int inputW=160;
int inputH=120;
int outputW=800;
int outputH=600;
int ratioScreen=outputW/inputW;
int halfInW=outputW/2;
int halfInH=outputH/2;
int countArray;
float countF=0;
float midiRatio=outputW/128;
// atoms control
boolean done=true;
int counterGen=30;
//
//----------------------------------------------------------------------------------------------

// initialize flowfield--------------------------------------------------------------------
int ratioFlowField=50;
int nodeLength=((outputW/ratioFlowField)*(outputH/ratioFlowField));
Node [] area =new Node[nodeLength];
//-------------------------------------------------------------------------------------
// initialize Atoms ---------------------------------------------------------------------
int atomNum=8;
Atom[] atomArray=new Atom[atomNum];

//--------------------------------------------------------------------------------------
//initialize LiveObject
int liveNum=2;
LiveObject[] liveArray=new LiveObject[liveNum];
//---------------------------------------------------------------------------------------
OscP5 oscFrame;
OscP5 oscR;
OscP5 oscG;
OscP5 oscB;
OscP5 oscTaskAtom;
OscP5 oscTaskLive;
OscP5 oscTaskDrone;
OscP5 oscLiveSendContact;
OscP5 oscDroneSendContact;
OscP5 oscAtomsSendCollision;
OscP5 oscLiveStart;
OscP5 oscLiveCursorSample;

OscP5 oscloadLivePitch;
// ______________________________________________________________
int liNum=9;
//initialize arrays virtual light -------------------------------------
VirtualLight[] redLights= new VirtualLight[liNum];
VirtualLight[] blueLights= new VirtualLight[liNum];
VirtualLight[] greenLights= new VirtualLight[liNum];
//----------------------------------------------------------------------
LightReal[]   lightsOnArray= new LightReal[liNum];
// split address var & arrays
//String redAdd[];
String redAdd;
String blueAdd;
String greenAdd;
int redValue;
int redIndex;
String redProperty;
int greenValue;
int greenIndex;
String greenProperty;
int blueValue;
int blueIndex;
String blueProperty;
//_----------------------------------------------------------------
int globalFrame;
OscBundle osb;
int receiveAtPort;
int sendToPort;
String host;
String oscP5event;
float dimX=0;
float dimY=0;
float dimW=0;
float dimH=0;
float p=0;
void initOsc() {
  receiveAtPort = 2510;
  sendToPort = 5701;
  host = "127.0.0.1";
  //193.179.25.240
  //it host = "193.179.25.240";
  oscP5event = "oscEvent";
  oscFrame= new OscP5(this,host,sendToPort,receiveAtPort,"oscEventFrame");
  oscR = new OscP5(this,host,sendToPort,2501,"oscEventRed");
  oscG = new OscP5(this,host,sendToPort,2503,"oscEventGreen");
  oscB = new OscP5(this,host,sendToPort,2502,"oscEventBlue");

  //task controller: atoms
  oscTaskAtom = new OscP5(this,host,sendToPort,2600,"osc_Atom");
  oscTaskLive = new OscP5(this,host,sendToPort,2700,"osc_Live");
  oscTaskDrone = new OscP5(this,host,sendToPort,2900,"osc_Drone");
  //send out ot max
  oscLiveSendContact=new OscP5(this,"192.168.0.3",2710,2711,"osc_Live");
  oscAtomsSendCollision=new OscP5(this,"192.168.0.3",2611,2612,"osc_Live");
  oscDroneSendContact=new OscP5(this,"192.168.0.3",3710,3711,"osc_sdrone");

  //osc live star-stop recording
  // oscLiveStart=new OscP5(this,host,sendToPort,2701,"osc_LiveStart");
  oscLiveStart=new OscP5(this,host,sendToPort,2701,"osc_LiveStart");
  //osc live
  //oscLiveCursorSample=new OscP5(this,host,sendToPort,2728,"osc_LiveCursorS");
  oscLiveCursorSample=new OscP5(this,host,sendToPort,2728,"osc_LiveCursorS");
  //

  // test object
  oscloadLivePitch= new OscP5(this,host,sendToPort,4000,"osc_loadLivePitch");
}
void osc_loadLivePitch(OscIn oscIn) {
  ArrayList o=oscIn.getDataList();
  int numPitch=o.size();

  //println("ARRIVA");
  if(oscIn.checkAddrPattern("pitch_lp1")) {
    liveArray[0].pArray=new int[numPitch];
    for(int i=0; i<numPitch; i++){
      String pp=String.valueOf(o.get(i));
      liveArray[0].pArray[i]=Integer.parseInt(pp);
    }

    //println("ARRIVA");
    liveArray[0].activeVisual=true;

  } else if (oscIn.checkAddrPattern("pitch_lp2")){
    liveArray[1].pArray=new int[numPitch];
    for(int i=0; i<numPitch; i++){
      String pp=String.valueOf(o.get(i));
      liveArray[1].pArray[i]=Integer.parseInt(pp);
    }
    liveArray[1].activeVisual=true;
  } else if (oscIn.checkAddrPattern("pitch_lp3")){
    liveArray[2].pArray=new int[numPitch];
    for(int i=0; i<numPitch; i++){
      String pp=String.valueOf(o.get(i));
      liveArray[2].pArray[i]=Integer.parseInt(pp);
    }
    liveArray[2].activeVisual=true;
  }
}

void oscEventFrame(OscIn oscIn) {

  float o=oscIn.getInt(0);
  if(oscIn.checkAddrPattern("synchro")) {
    globalFrame=int(o);
  }
}
void oscEventRed(OscIn oscIn) {
  redAdd=oscIn.getAddrPattern();
  // which red virtual light
  redValue=Integer.parseInt(redAdd.substring(1,2));
  // which property light
  redProperty=String(redAdd.substring(2,3));
  // which red virtual light object
  redIndex=redValue-1;
  // update frame num to objetc
  redLights[redIndex]._frame=globalFrame;
  int redInt=int(oscIn.getFloat(0)*5);
  // println(redInt+"_"+redProperty+"-"+redIndex);

  if(redProperty.equals("x")){
    redLights[redIndex]._x=redInt;
  } else if(redProperty.equals("y")){
    redLights[redIndex]._y=redInt;
  } else if(redProperty.equals("w")){
    redLights[redIndex]._width=redInt;
  } else if(redProperty.equals("h")){
    redLights[redIndex]._height=redInt;
  }

}
void oscEventGreen(OscIn oscIn) {
  greenAdd=oscIn.getAddrPattern();
  // which reen virtual light
  greenValue=Integer.parseInt(greenAdd.substring(1,2));
  // which property light
  greenProperty=String(greenAdd.substring(2,3));
  // which blue virtual light object
  greenIndex=greenValue-1;
  // update frame num to objetc
  greenLights[greenIndex]._frame=globalFrame;
  int greenInt=int(oscIn.getFloat(0)*5);
  // println(redInt+"_"+redProperty+"-"+redIndex);

  if(greenProperty.equals("x")){
    greenLights[redIndex]._x=greenInt;
  } else if(greenProperty.equals("y")){
    greenLights[greenIndex]._y=greenInt;
  } else if(greenProperty.equals("w")){
    greenLights[greenIndex]._width=greenInt;
  } else if(greenProperty.equals("h")){
    greenLights[greenIndex]._height=greenInt;
  }

}
void oscEventBlue(OscIn oscIn) {
  blueAdd=oscIn.getAddrPattern();
  // which blue virtual light
  blueValue=Integer.parseInt(blueAdd.substring(1,2));
  // which property light
  blueProperty=String(blueAdd.substring(2,3));
  // which blue virtual light object
  blueIndex=blueValue-1;
  // update frame num to objetc
  blueLights[blueIndex]._frame=globalFrame;
  int blueInt=int(oscIn.getFloat(0)*5);
  // println(redInt+"_"+redProperty+"-"+redIndex);

  if(blueProperty.equals("x")){
    blueLights[redIndex]._x=blueInt;
  } else if(blueProperty.equals("y")){
    blueLights[blueIndex]._y=blueInt;
  } else if(blueProperty.equals("w")){
    blueLights[blueIndex]._width=blueInt;
  } else if(blueProperty.equals("h")){
    blueLights[blueIndex]._height=blueInt;
  }

}
void osc_Atom(OscIn oscIn) {

  int o=oscIn.getInt(0);

  if(oscIn.checkAddrPattern("atoms")) {

    if(o==0){
      taskAtom=false;
    }else{
      taskAtom=true;
    }
  }
}
void osc_Drone(OscIn oscIn) {
  int o=oscIn.getInt(0);

  if(oscIn.checkAddrPattern("drones")) {

    if(o==0){
      taskDrone=false;
    }else{
      taskDrone=true;
    }
  }
}
void osc_Live(OscIn oscIn) {

  int o=oscIn.getInt(0);
  //lp1 lp2 lp3
  if(oscIn.checkAddrPattern("lp1")){
    print("live"+oscIn.getInt(0));
    if(o==0){
      liveArray[0].active=false;
    }else{
      liveArray[0].active=true;
    }
  } else if (oscIn.checkAddrPattern("lp2")){
    if(o==0){
      liveArray[1].active=false;
    }else{
      liveArray[1].active=true;
    }
  }else if (oscIn.checkAddrPattern("lp3")){
    if(o==0){
      liveArray[2].active=false;
    }else{
      liveArray[2].active=true;
    }
  }
}
// send live objects info to max
void simpleOscMessage(String addColor, int numContactLight) {
  // we will send an osc message
  // with the address pattern /test
  // and 3 arguments with the type tag sfi

  // create a new osc message with
  // the address pattern /test
  OscMessage oscMsg = oscLiveSendContact.newMsg(addColor);
   //println(addColor);
  // add a string to the osc message
  //oscMsg.add("abcde");

  // add a float to the osc message
  // oscMsg.add(12.44);

  // add an int to the osc message
  oscMsg.add(numContactLight);

  // send the osc message
  // via the oscP5 bundle
  oscLiveSendContact.sendMsg(oscMsg);
}
// send atom objects collisions info to max
void simpleAtomOscMessage(int atomNameCol, String typeOfColor, int midiPosX) {
  // we will send an osc message
  // with the address pattern /test
  // and 3 arguments with the type tag sfi

  // create a new osc message with
  // the address pattern /test
  OscMessage oscMsg = oscAtomsSendCollision.newMsg("atm_c");

  oscMsg.add(atomNameCol);
  oscMsg.add(typeOfColor);
  oscMsg.add(midiPosX);
  // send the osc message
  // via the oscP5 bundle
  oscAtomsSendCollision.sendMsg(oscMsg);
}
// live start input
void osc_LiveStart(OscIn oscIn) {

  int o=oscIn.getInt(0);

  if(oscIn.checkAddrPattern("rec_lp1")) {
    if(liveArray[0].active){

      if(o==0){
        liveArray[0].record=false;
      }else{
        liveArray[0].record=true;
      }
    }
  } else if (oscIn.checkAddrPattern("rec_lp2")){
    if(liveArray[1].active){

      if(o==0){
        liveArray[1].record=false;
      }else{
        liveArray[1].record=true;
      }
    }

  }else if (oscIn.checkAddrPattern("rec_lp3")){
    if(liveArray[2].active){

      if(o==0){
        liveArray[2].record=false;
      }else{
        liveArray[2].record=true;
      }
    }

  }
}
// live cursor sample position
void osc_LiveCursorS(OscIn oscIn) {
  //println();
  float o=oscIn.getFloat(0);
  //println("hdhfcl");
  if(oscIn.checkAddrPattern("pos_lp1")) {
    if(liveArray[0].active){
      liveArray[0].samplePosition=o;
    }
  } else if (oscIn.checkAddrPattern("pos_lp2")){
    if(liveArray[1].active){
      liveArray[1].samplePosition=o;
    }

  }else if (oscIn.checkAddrPattern("pos_lp3")){
    if(liveArray[2].active){
      liveArray[2].samplePosition=o;
    }

  }
}
void simpleDroneOscMessage(String lightname, int turn_on, float average, int conection) {
  // we will send an osc message
  // with the address pattern /test
  // and 3 arguments with the type tag sfi

  // create a new osc message with
  // the address pattern /test
  OscMessage oscMsg = oscDroneSendContact.newMsg(lightname);

  //oscMsg.add(turn_on);
  oscMsg.add(average);
  //oscMsg.add(conection);
  // send the osc message
  // via the oscP5 bundle
  oscDroneSendContact.sendMsg(oscMsg);
}
void unpackMessage(OscIn oscIn) {
  /*   float o=oscIn.getInt(0);
  if(oscIn.checkAddrPattern("synchro")) {
    globalFrame=int(o);

  }*/

}

void setup(){
  background(0);
  size(outputW, outputH);
  noFill();
  ellipseMode(CENTER_DIAMETER);
  initOsc();

  for(int i=0; i <liNum; i++){
    redLights[i]= new VirtualLight(0,0,0,0,0,'r',i);
    blueLights[i]= new VirtualLight(0,0,0,0,0,'g',i);
    greenLights[i]= new VirtualLight(0,0,0,0,0,'b',i);
    lightsOnArray[i]= new LightReal(0,0,0,0,0,0,'n');
  }
  //
  int na=0;
  for(int i=0; i< 16; i++){
    for(int j=0; j< 12; j++){
      area[na]=new Node(i*16+5,j*12+5);
      na++;
    }
  }
  for(int j=0;j<atomNum;j++){
    atomArray[j]=new Atom(j+1);
  }
  //live object init
  liveArray[0]=new LiveObject(0,0,200,300,1);
  liveArray[1]=new LiveObject(0,0,600,300,2);
  //liveArray[2]=new LiveObject(0,0,300,100,3);
  /*   String g="w";
  if(g=="w"){
  }*/

}
void loop(){
  background(0);
  stroke(255);
  // reset array light
  countArray=0;
  countF+=.01;
  for (int r=0;r<liNum;r++){
    lightsOnArray[r].reset();

  }
  // atom generation dealy
  if(counterGen>0){
      counterGen--;
  } else {
     done=true;
  }
  
  //
  //println("frame"+globalFrame);
  for (int r=0;r<liNum;r++){
    // print("RR"+r);
    redLights[r].update();
    greenLights[r].update();
    blueLights[r].update();
  }
  for (int r=0;r<countArray;r++){
    lightsOnArray[r].calculateAndDraw();

  }
  // object loop
  for(int k=0;k<liveNum;k++){

    liveArray[k].upDate();
  }
  for (int r=0;r<countArray;r++){
    lightsOnArray[r].cleanOldConnection();

  }
  // enable Atom
  if (taskAtom){
    for(int r=0; r < nodeLength; r++){

      area[r].upDate();

    }
    for(int j=0;j<atomNum;j++){
      //println(j);
      atomArray[j].upDate();
    }
    for(int L=0;L<atomNum;L++){
      //println(j);
      if(atomArray[L].active){
      atomArray[L].drawReleations();
     }
    }
  } else {
     for(int j=0;j<atomNum;j++){
      //println(j);
      atomArray[j].deActivate();
    }
  }
  if(false){
  for(int i=0; i <liNum; i++){
    redLights[i].sendDronetoMax();
    blueLights[i].sendDronetoMax();
    greenLights[i].sendDronetoMax();
   }
  }
}

void fillRect(int r, int g, int b) {
  fill(r,g,b);
  // rect(0, 0,width,height);
}
class LightReal{
  int _frame;
  int _x;
  int _y;
  int _width;
  int _height;
  int id;
  char _type;
  boolean active;
  int oldX,oldY;
  // controll live sound object connection 0== not pluged
  int plug;
  boolean plugFrame;
  int nearby;
  LightReal (int xCoor, int yCoor,int oX,int oY, int wi, int he, char type){
    // _frame=fr;
    _x=xCoor;
    _y=yCoor;
    _width=wi;
    _height=he;
    _type=type;
    oldX=oX;
    oldY=oY;
    active=true;
    plug=0;
    plugFrame=false;
    nearby=0;
  }
  void update(int xCoor, int yCoor,int oX,int oY, int wi, int he, char type){
    
    active=true;
    oldX=oX;
    oldY=oY;
    _x=xCoor;
    _y=yCoor;
    _width=wi;
    _height=he;
    id=countArray;
    _type=type;
    nearby=0;
    //println(_x+"___"+_y);
  }
  void nearLive(){
    
    float oldC=1000;
    float disC;
    for(int k=0;k<liveNum;k++){
     disC=Math.abs(dist(_x,_y,liveArray[k]._x,liveArray[k]._y));
     if(disC<oldC){
       oldC=disC;
       
       // nearby == id live obj
       nearby=k+1;
     }
  }
  }
  void cleanOldConnection(){
    if(!plugFrame){
       plug=0;
    }
  }
  void calculateAndDraw(){
    plugFrame=false;
    /* fill(120);
    //rect(_x-(_width*.5)-2, _y+(_height*.5),10,-10);
    fill(200);
    int xf=int( _x-10-(_width*.5));
    int yf=int( _y+10+(_height*.5));
    text("IV",100,200);
    noFill();*/
    int qInx=0;
    int iconX=int(_width*.5)+5;
    int iconY=int(_height*.5)-5;
    stroke(190);
    for(int k=0;k<3;k++){
      for(int j=0;j<3;j++){
        if(qInx<=id){
          rect(_x-iconX-(j*4),_y+iconY-(k*4),2,2);
          qInx++;
        }
      }
    }
    for (int r=0;r<countArray;r++){

      if(lightsOnArray[r].id!=id){

        int ny=lightsOnArray[r]._y;
        int nx=lightsOnArray[r]._x;
        float distanza=dist(_x,_y,nx,ny);
        
        // visualization relations
        if(taskDrone){
        if(distanza<300){
          stroke(255,255,255,50);
          line(_x,_y,nx,ny);
          if(distanza<100){
            stroke(255,255,255,35);
            ellipse((_x+nx)*.5,(_y+ny)*.5,distanza,distanza);
           }
           }
          }
          // atoms generations -----------------------------------------
          if(_type!=lightsOnArray[r]._type){
          if(distanza<80){
             
            int xx=int((_x+lightsOnArray[r]._x)*.5);
            int yy=int((_y+lightsOnArray[r]._y)*.5);
            //done=true;
            for(int jj=0; jj<atomNum; jj++){
              if (done){
               if(atomArray[jj].active==false){
                  atomArray[jj].activate(xx,yy);
                  //println("atom");
                   done=false;
                   counterGen=30;
                }
               }
            }
             
           }
          
          //----------------------------------------------------
        }
      }
    }
    nearLive();
  }
  void reset(){
    active=false;
  }
}
public class VirtualLight{
  int _frame;
  int _x;
  int _y;
  int _width;
  int _height;
  char _type;
  color c;
  boolean active=false;
  int realX,realY;
  int oldX,oldY;
  int halfH,halfW;
  float motionDelay=.3;
  float difX,difY;
  int _id;
  String _name;
  VirtualLight (int fr,int xCoor, int yCoor, int wi, int he, char type,int myid){
    _frame=fr;
    _x=xCoor;
    _y=yCoor;
    _width=wi;
    _height=he;
    _type=type;
    _id=myid+1;
    _name=String(_type+"_"+_id);
   // println(_name);
    // test blobs detection
    resetOld();
    if(_type=='r'){
      c=color(255,255,255,160);
    } else if (_type=='g'){
      c=color(255,255,255,160);
    }else if (_type=='b'){
      c=color(255,255,255,160);
    }

  }
  void update(){
    // println(_x+"_"+_y);
    stroke(c);
    // control last frame
    if(_frame>globalFrame-3){
      active=true;
      //rect(_x,_y,_width,_height);
      drawRect();
      upDateMainArray();
      
    } else {
      active=false;
      resetOld();
    }
    //sendDronetoMax();
  }
  void drawRect(){
    // draw bounding rect
    halfW=Math.abs(int(_width*.5));
    halfH=Math.abs(int(_height*.5));
    realX=_x+halfW;
   //realY=_y-halfH;
   realY=_y;
    line(realX-halfW,realY-halfH,realX-halfW+3,realY-halfH);
    line(realX-halfW,realY-halfH,realX-halfW,realY-halfH+3);
    line(realX-halfW,realY+halfH,realX-halfW+3,realY+halfH);
    line(realX-halfW,realY+halfH,realX-halfW,realY+halfH-3);
    line(realX+halfW,realY-halfH,realX+halfW-3,realY-halfH);
    line(realX+halfW,realY-halfH,realX+halfW,realY-halfH+3);
    line(realX+halfW,realY+halfH,realX+halfW-3,realY+halfH);
    line(realX+halfW,realY+halfH,realX+halfW,realY+halfH-3);
    drawTarget();

  }
  void drawTarget(){
    // draw delay cross
    stroke(255,255,255,100);
    difX=realX-oldX;
    difY=realY-oldY;
    oldY+=int(difY*motionDelay);
    oldX+=int(difX*motionDelay);
    line(oldX-2,oldY,oldX+2,oldY);
    line(oldX,oldY-2,oldX,oldY+2);
    // draw bouncing line
    stroke(255,255,255,100);
    line(oldX,oldY,realX,realY);
  }
  void upDateMainArray(){
    // load data into main array
    if(countArray<liNum){
      lightsOnArray[countArray].update(realX,realY,oldX,oldY,_width,_height,_type);
      countArray++;
    }
  }
  void sendDronetoMax(){
     int turnDrone;
     float average;
     int nEvent=0;
     float nSum=0;
     float distanza=0;
     if(active){
         turnDrone=1;
         for(int i=0; i <liNum; i++){
          if(!((_type=='r')&&(_id==i+1))){
           if(redLights[i].active){
              distanza=Math.abs(dist(realX,realY,redLights[i].realX,redLights[i].realY));
              if(distanza<100){
                 nSum+=(101-distanza)*.01;
                 nEvent++;
              }
            }
          }
          }
          for(int i=0; i <liNum; i++){
          if(!((_type=='g')&&(_id==i+1))){
           if(greenLights[i].active){
              distanza=Math.abs(dist(realX,realY,redLights[i].realX,redLights[i].realY));
              if(distanza<100){
                 nSum+=(101-distanza)*.01;
                 nEvent++;
              }
            }
          }
          }
          for(int i=0; i <liNum; i++){
          if(!((_type=='b')&&(_id==i+1))){
           if(blueLights[i].active){
              distanza=Math.abs(dist(realX,realY,redLights[i].realX,redLights[i].realY));
              if(distanza<100){
                 nSum+=(101-distanza)*.01;
                 nEvent++;
              }
            }
           }
          }
          
          if(nEvent==0){
         average=0;
         } else {
            average=nSum/nEvent;
         }
         simpleDroneOscMessage(_name, turnDrone, average, nEvent);
         //print("drone_"+_name+"_"+turnDrone+"_"+average+"_"+nEvent);
     } else {
        simpleDroneOscMessage(_name, 0, 0.0, 0);
     }
  }
  void resetOld(){
    oldX=halfInW;
    oldY=halfInH;
  }
}

class Node{
  int _x,_y;
  float distCoef;
  float relAng;
  float xVect;
  float yVect;
  float rifX,rifY;
  float distSum;
  Node (int posX,int posY){
    _x=posX+25;
    _y=posY+25;
    xVect=0;
    yVect=0;
  }
  void upDate(){
    vectorDir();
   /* if(distSum<300){
      stroke(60);
    } else {
      stroke(20);
    }
    line(_x,_y,_x+xVect,_y+yVect);*/

  }
  void vectorDir(){
    relAng=0;
    float dif=0;
    distSum=0;

    distSum=noise(_x,_y,countF)*TWO_PI;
    relAng=distSum;

    xVect=cos(relAng)*.1;
    yVect=sin(relAng)*.1;
  }
}
//-------------------------------------------------------------------
class Atom{
  float _x;
  float _y;
  float oldX,oldY;
  float vectX;
  float vectY;
  int checkX,checkY;
  float energy;
  int id;
  boolean active;
  //float counterCollision;
  int idCollision;
  int timer;
  int timerDefault;
  
  boolean born;
  int bornCounter;
  Atom (int myid){
    _x=width*random(1);
    _y=height*random(1);
    vectX=0;
    vectY=0;
    id=myid;
    idCollision=-1;
    active=false;
    timer=0;
    timerDefault=3;
    bornCounter=100;
    born=true;
  }
  void activate(int xx, int yy){
    _x=xx;
    _y=yy;
    vectX=0;
    vectY=0;
    idCollision=-1;
    active=true;
    timer=0;
    bornCounter=100;
    born=true;
  }
  void deActivate(){
     active=false;
  }
  void upDate(){
    if(active){
    if(born){
       bornCounter--;
       if(bornCounter<1){
          born=false;
       }
    
    }
    // controll sound trigger
    if (timer>0){
    timer--;
    }
    checkX=int(floor(_x*.005));
    checkY=int(floor(_y*.005));
    oldX=_x;
    oldY=_y;
    energy=area[checkX*16+checkY].distSum;
    vectX+=area[checkX*16+checkY].xVect*energy;
    vectY+=area[checkX*16+checkY].yVect*energy;
    float lightvectx=0;
    float lightvecty=0;
    // energy=1;
    // vectX+=1;
    // vectY+=1;
    if(idCollision!=-1){
      if(Math.abs(dist(_x,_y,lightsOnArray[idCollision]._x,lightsOnArray[idCollision]._y))>120){
        idCollision=-1;
      }
    }
    for(int n=0; n < countArray; n++){

      float cx=lightsOnArray[n]._x;
      float cy=lightsOnArray[n]._y;
      float ndist=dist(cx,cy,_x,_y);
      float nDistAb=Math.abs(ndist);
      //float newDist=float(Math.abs(Math.sqrt(lightsOnArray[n]._width*lightsOnArray[n]._height)));

      if(idCollision!=n){
        if(nDistAb<Math.abs(lightsOnArray[n]._width)){
          // it was default was 100
          sendDataToMax(n);
         // println(n+"_");
          idCollision=n;
          lightvectx+=(cx-_x)/(nDistAb*.5);
          lightvecty+=(cy-_y)/(nDistAb*.5);
          ellipse(_x,_y,50,50);
         // vectX-=(cx-_x)/nDistAb;
          //vectY-=(cy-_x)/nDistAb;
         // vectX-=(vectX);
          //vectY-=(vectY);
          /*  if(lightsOnArray[n]._type=='r'){
            vectX-=(cx-_x)/nDistAb;
            vectY-=(cy-_y)/nDistAb;
          }else if(lightsOnArray[n]._type=='g'){
            vectX-=(cx-_x)/nDistAb;
            vectY-=(cy-_y)/nDistAb;
          }*/
          //blue  destroy atom
          if((nDistAb<40)&&(lightsOnArray[n]._type=='b')){
             if(!born){
              deActivate();
             // ellipse(_x,_y,50,50);
              }
           }
        }
      }

      for(int k=0;k<liveNum;k++){

        if(liveArray[k].active){

          float lox=liveArray[k]._x;
          float loy=liveArray[k]._y;
          float lodist=dist(lox,lox,_x,_y);
          float loDistAb=Math.abs(lodist);
          if(loDistAb<200){

            /*
            float oldvectX=vectY;
            float oldvectY=vectX;
            vectY=oldvectX;
            vectX=oldvectY;
            if(Math.abs(vectX)==Math.abs(vectY)){
              vectX=-vectX;
              vectY=-vectY;
            }*/

          }

        }
      }
     // _x+=(vectX);
     // _y+=(vectY);
    }
     _x+=(vectX)+lightvectx;
     _y+=(vectY)+lightvecty;
    if(_x<1){
      _x=1;
      vectX=-vectX*.95;

    }
    if(_x>width-1){
      _x=width-1;
      vectX=-vectX*.95;

    }
    if(_y<1){
      _y=1;
      vectY=-vectY*.95;

    }
    if(_y>height-1){
      _y=height-1;
      vectY=-vectY*.95;

    }
   
      generation();
   
    for(int k=0;k<atomNum;k++){
            //println(k);
      if((atomArray[k].active)&&(atomArray[k].id!=id)){
      float px=atomArray[k]._x;
      float py=atomArray[k]._y;
      float distatom=Math.abs(dist(_x,_y,px,py));
      // relations and deactivate();
      
       if(distatom<20){
        atomArray[k].deActivate();
         } 
        
       }
     }
    }
  }
  void sendDataToMax(int indexLight){
  if(timer==0){
     timer=timerDefault;
    String colorLightDet=String(lightsOnArray[indexLight]._type);
    int posXmax=int(Math.floor(_x/midiRatio));
    simpleAtomOscMessage(id,colorLightDet,posXmax );
   //println("_"+id+"_"+colorLightDet+"_"+posXmax);
    }
  }
  void generation(){
  
   if(id==1){
  
      stroke(120);
    //line(_x,_y,oldX,oldY);
    noFill();
    ellipse(_x,_y,10,10);

    fill(120);
    ellipse(_x,_y,5,5);
    float t_ang=atan2(vectY,vectX);
    push();
    translate(_x,_y);
    push();
    rotate(t_ang);
    triangle(10,-3 , 16, 0, 10, 3);
    pop();
    pop();
    noFill();
    } else if(id==2){
   
      stroke(120);
    //line(_x,_y,oldX,oldY);
    

    fill(120);
    ellipse(_x,_y,5,5);
    float t_ang=atan2(vectY,vectX);
    push();
    translate(_x,_y);
    push();
    rotate(t_ang);
    triangle(10,-3 , 16, 0, 10, 3);
    pop();
    pop();
    noFill();
    } else if(id==3){
    
      stroke(120);
    //line(_x,_y,oldX,oldY);
    noFill();
    ellipse(_x,_y,10,10);

    fill(120);
    
    float t_ang=atan2(vectY,vectX);
    push();
    translate(_x,_y);
    push();
    rotate(t_ang);
    triangle(10,-3 , 16, 0, 10, 3);
    pop();
    pop();
    noFill();
    } else if(id==4){
    
      stroke(120);
    //line(_x,_y,oldX,oldY);
    noFill();
    ellipse(_x,_y,10,10);

    fill(120);
    ellipse(_x-3,_y,3,3);
    ellipse(_x+3,_y,3,3);
    ellipse(_x,_y+3,3,3);
    float t_ang=atan2(vectY,vectX);
    push();
    translate(_x,_y);
    push();
    rotate(t_ang);
    triangle(10,-3 , 16, 0, 10, 3);
    pop();
    pop();
    noFill();
    } else if(id==5){
    
      stroke(120);
    //line(_x,_y,oldX,oldY);
    noFill();
    ellipse(_x,_y,10,10);

    fill(120);
    rect(_x-4,_y-4,8,8);
    float t_ang=atan2(vectY,vectX);
    push();
    translate(_x,_y);
    push();
    rotate(t_ang);
    triangle(10,-3 , 16, 0, 10, 3);
    pop();
    pop();
    noFill();
    } else if(id==6){
    
      stroke(120);
    //line(_x,_y,oldX,oldY);
    noFill();
    ellipse(_x,_y,10,10);

    //fill(120);
    rect(_x-4,_y-4,8,8);
    float t_ang=atan2(vectY,vectX);
    push();
    translate(_x,_y);
    push();
    rotate(t_ang);
    triangle(10,-3 , 16, 0, 10, 3);
    pop();
    pop();
    noFill();
    } else if(id==7){
    
      stroke(120);
    //line(_x,_y,oldX,oldY);
    noFill();
    ellipse(_x,_y,10,10);

    fill(120);
    triangle(_x-3,_y-3,_x+3,_y-3,_x,_y+3);
    float t_ang=atan2(vectY,vectX);
    push();
    translate(_x,_y);
    push();
    rotate(t_ang);
    triangle(10,-3 , 16, 0, 10, 3);
    pop();
    pop();
    noFill();
    } else if(id==8){
   
      stroke(120);
    //line(_x,_y,oldX,oldY);
    noFill();
    ellipse(_x,_y,10,10);

    //fill(120);
    triangle(_x-3,_y-3,_x+3,_y-3,_x,_y+3);
    float t_ang=atan2(vectY,vectX);
    push();
    translate(_x,_y);
    push();
    rotate(t_ang);
    triangle(10,-3 , 16, 0, 10, 3);
    pop();
    pop();
    noFill();
    }
  }
  void drawReleations(){
     for(int k=0;k<atomNum;k++){
            //println(k);
      if((atomArray[k].active)&&(atomArray[k].id!=id)){
      float px=atomArray[k]._x;
      float py=atomArray[k]._y;
      float distatom=Math.abs(dist(_x,_y,px,py));
      // relations 
      
       if(distatom<160){
        
          stroke(250,250,250,40);
          line(px,py,_x,_y);
          }
        
       }
     }
  }
}
class LiveObject{
  // sound property
  float amplitude;
  int pitch;
  // visibility
  boolean active;
  // visualization
  int _x;
  int _y;
  int rSum;
  int gSum;
  int bSum;
  int rOld,gOld,bOld;
  int tx,ty;
  float ldist;
  // this name
  int id;
  // recording sample status
  boolean record;
  //cursor position 1.0 to 0.0
  float samplePosition;
  //pitch array
  int[] pArray;
  int[] ampArray;
  boolean activeVisual;
  
  // memory for light "touch"
  boolean touch;

  float rx;
  LiveObject (int ptc, float amp,int x, int y, int my_id){
    amplitude=amp;
    pitch=ptc;
    active=false;
    _x=x;
    _y=y;

    tx=0;
    ty=0;
    rSum=0;
    gSum=0;
    bSum=0;
    rOld=0;
    gOld=0;
    bOld=0;
    ldist=0;
    id= my_id;
    record=false;
    samplePosition=0.0;
    rx=0;
    activeVisual=false;
    touch=false;
  }
  void upDate(){
   if( (rOld==0)&&(bOld==0)&&(gOld==0)){
       touch=false;
    }else{
      touch=true;
    }
    if(active){
       if(touch){
      stroke(70,70,70);
      } else {
        stroke(30,30,30);
      }
      ellipse(_x,_y,200,200);

      if(record){
        // activeVisual=true;
        //recordingOn();
      } else{
        cursorSampleDraw();
      }
      if(activeVisual){
        drawVisual ();
        // println("ACTIVE");
      }
      tx=0;
      ty=0;
      rSum=0;
      gSum=0;
      bSum=0;
      ldist=0;
      for (int r=0;r<countArray;r++){
        tx=lightsOnArray[r]._x;
        ty=lightsOnArray[r]._y;
        ldist=Math.abs(dist(_x,_y,tx,ty));
        if((ldist<350)&&(((lightsOnArray[r].plug==0)&&(lightsOnArray[r].nearby==id))||(lightsOnArray[r].plug==id))){
          
         // print(globalFrame+"_"+r);
          lightsOnArray[r].plug=id;
          lightsOnArray[r].plugFrame=true;
          if(lightsOnArray[r]._type=='r'){
            rSum++;
          } else if (lightsOnArray[r]._type=='g'){
            gSum++;
          } else if (lightsOnArray[r]._type=='b'){
            bSum++;
          }
          stroke(70,70,70);
          line(_x,_y,tx,ty);
        }
      }
      if(rSum!=rOld){
        simpleOscMessage(String("lp"+id+"_rsum"), rSum) ;
        rOld=rSum;
      }
      if(gSum!=gOld){
        simpleOscMessage(String("lp"+id+"_gsum"), gSum) ;
        gOld=gSum;
      }
      if(bSum!=bOld){
        simpleOscMessage(String("lp"+id+"_bsum"), bSum) ;
        bOld=bSum;
      }
    }
    
    
  }
  void recordingOn(){
    ellipse(_x,_y,10,10);
  }
  void cursorSampleDraw(){
    push();
    translate(_x,_y);
    push();
    rotate(samplePosition*TWO_PI);
    triangle(90,-3 , 96, 0, 90, 3);
    pop();
    pop();
    noFill();
  }
  void drawVisual (){
    // if it is recording it draws only pointers
    
      float dvx,dvy,dvz;
      int countArray=pArray.length;
      float sliceY=PI/128;
      float slice=TWO_PI/countArray;
      float container=0;
      stroke(70,70,70);
      rx+=.008;
      push();
      translate(_x,_y);
      push();
      //rotateY(samplePosition*TWO_PI);
      rotateY(samplePosition*TWO_PI);
      push();
      //rotateZ(samplePosition*TWO_PI);
      rotateZ(samplePosition*TWO_PI);
      push();
      // different visualization for each object
      if(record){
       drawCross();
    } else {
      if(id==1){
        beginShape(LINE_STRIP);
        float par;
        for (int i=0; i<countArray; i++){
          if(i!=0){
            par=pArray[i]-pArray[i-1];
          }else {
            par=pArray[i];
          }
          dvx=sin(container*par)*60;
          dvy=cos(slice*par+pArray[i])*60;
          dvz=cos(container*par)*60;
          vertex(dvx,dvy,dvz);

          container+=slice;

        }
        endShape();
      } else {
        beginShape(LINE_STRIP);
        float par;
        for (int i=0; i<countArray; i++){
          if(i!=0){
            par=pArray[i]-pArray[i-1];
          }else {
            par=pArray[i];
          }
          dvx=sin(container*par)*60;
          dvy=cos(slice*par+pArray[i])*60;
          dvz=cos(container*par)*60;
          vertex(dvx,dvy,dvz);

          container+=slice;

        }
        endShape();
      }
      drawCross();
      }
      pop();

      pop();
      pop();
      pop();
    

  }
  void drawCross(){
    float dvx,dvy,dvz;
    int countArray=pArray.length;
    float sliceY=PI/128;
    float slice=TWO_PI/countArray;
    float container=0;
    stroke(110,110,110);
    rx+=.008;
    float par=0;
    for (int i=0; i<countArray; i++){
      if(i!=0){
        par=pArray[i]-pArray[i-1];
      }else {
        par=pArray[i];
      }
      dvx=sin(container*par)*60;
      dvy=cos(slice*par+pArray[i])*60;
      dvz=cos(container*par)*60;
      /* line(dvx-5,dvy,dvz,dvx+5,dvy,dvz);
      line(dvx,dvy-5,dvz,dvx,dvy+5,dvz);
      line(dvx,dvy,dvz-5,dvx,dvy,dvz+5);*/
      // line(dvx,dvy,dvz-5,dvx,dvy,dvz+5)
      fill(120,120,120,60);
      stroke(120,120,120,60);
      /*  beginShape(QUADS);
      vertex(dvx,dvy,dvz) ;
      vertex(dvx+4,dvy,dvz);
      vertex(dvx+4,dvy+4,dvz);
      vertex(dvx,dvy+4,dvz);
      endShape();
      beginShape(QUADS);
      vertex(dvx+4,dvy,dvz+4) ;
      vertex(dvx+4,dvy,dvz-4);
      vertex(dvx+4,dvy+4,dvz-4);
      vertex(dvx+4,dvy+4,dvz+4);
      endShape(); */
      beginShape(TRIANGLES);
      vertex(dvx-4,dvy-4,dvz) ;
      vertex(dvx+4,dvy-4,dvz);
      vertex(dvx,dvy,dvz);

      endShape();
      beginShape(TRIANGLES);
      vertex(dvx,dvy-4,dvz+4) ;
      vertex(dvx,dvy-4,dvz-4);
      vertex(dvx,dvy,dvz);

      endShape();
      noFill();
      container+=slice;

    }
    /* line(dvx-3,dvy,dvz,dvx+3,dvy,dvz);
    line(dvx,dvy-3,dvz,dvx,dvy+3,dvz);
    line(dvx,dvy,dvz-3,dvx,dvy,dvz+3);*/
  }

}