Particle[] p = new Particle[100]; //particle array
Vec testVector; //vector
Vec [] attractor = new Vec[5];

////////////////////////////////////////////////////////////////////////////////////////////////////////

void setup()
{
  size(900,250); //canvas
  
  testVector= new Vec(10,10,0); //vector
  
  for(int i=0; i<100; i++)
  {
    p[i]= new Particle (50,50,5,5,30);    
  }
  
  for (int i=0; i<5; i++) attractor[i] = new Vec (random(width), random (height), 0);

  int q = 0;
  
  for (int i = 0; i < 10; i++)
  {
    for(int j = 0; j < 10; j++)
      {
        p[q].pos.x = i*width/9;
        p[q].pos.y = j*height/9;
        q++;
      }
   }
}

////////////////////////////////////////////////////////////////////////////////////////////////////////

void draw()
{
  //background(0);
  fill(0,35); // higher the transformation dissipates quicker
  noStroke();
  rect(0,0, width, height);
  fill(#111111);
  stroke(255);

////////////////////////////////////////////////////////////////////////////////////////////////////
                           //vector...
stroke(255);
fill(255);

 Vec v1=new Vec (20,20,0);
  
  Vec v2=new Vec (30,30,0);
  
  v1.add(v2);
  
//ellipse(v1.x, v1.y, 10, 10); 

// .() dot operator gives access to the properties of an object, but only when you create a class for it
// or when the object is and instance for it...

///////////////////////////////////////////////////////////////////////////////////////////////////
  
  for(int i=0; i<100; i++)
  {
  p[i].xp=100;
  p[i].yp=100;
  float distance = sqrt(pow(mouseX-p[i].pos.x, 2) + pow(mouseY - p[i].pos.y, 2));
    if(distance < 200)
    {
    p[i].colorT+=.01;
    p[i].checkColor(color(255,0,0), color(255));
    p[i].curveTranslate(p[i].pos.x, p[i].pos.y, noise(.8, 2), 1.5, 3, 3, .4);
    }
    else
    {
    //p[i].colorT-=.01;
    p[i].curveTranslate(p[i].pos.x, p[i].pos.y, .2, 1.5, 3, 3, .1);
    Vec aPoint= new Vec(width/2, height/2, 0);
    
    p[i].attract( attractor);
    }
    
  p[i].drawParticle();
  }
}  

  class Vec{
  float x, y, z;
  
  Vec(float X, float Y, float Z)
  {
    x = X;
    y = Y;
    z = Z;
  }
 
   void add (Vec v)
   {
     x = x + v.x;
     y = y + v.y;
     z = z + v.z;
   }

void subtract(Vec v)
    {
     x = x - v.x;
     y = y - v.y;
     z = z - v.z;
    }
    
void multiply (float m)
  {
    x = x*m;
    y = y*m;
    z = z*m;
  }
  
float distance (Vec v)
  {
    float d = sqrt (pow(v.x-x, 2) + pow(v.y-y, 2) + pow(v.z-z, 2));
    return d;
  }
    
//magnitude
float magnitute ()
  {
    float d = sqrt (pow(x, 2) + pow(y,2 ) + pow(z, 2));
    return d;
  }

//set
void set(float xx, float yy, float zz)
  {
  x = xx;
  y = yy;
  z = zz;
  }
/*  
  void set(Vec v)
  {
  x = v.x;
  y = v.y;
  z = v.z;
  }  
*/   
}

  class Particle //class = composite of data; Particle = name of class    
{
  float w; //radius1
  float h; //radius2
  Vec pos = new Vec(0,0,0); //center
  float accel = 1; //particle acceleratioin
  float r;  //rotation      
  float xp, yp;// to help determine the ellipse last location
  float t=0;  //start
  float sinTranslatecount=0;
  float curveTranslateCount=0; // global called in order to start the count...
  float colorT=0;
  
  color c= color(255,0);
  color c1=color(#CEA9A9);
  color c2=color(#00AFD8);
  int colorCount=0;

  Vec v= new Vec(5,5,0);
  Vec ppos;

  float inc1 = 0.1;  // 
  float n1 = 0.09;  // speed of vibration
  float inc2 = .1;  //
  float n2 = 0.09;  // speed of vibration

////////////////////////////////////////////////////////////////
  Particle(float X, float Y, float W, float H, float R)
  {
    pos.x=X; //definition
    pos.y=Y; //definition
    w=W; //definition
    h=H; //definition
    r=R; //definition
  }

  ///////////////////////////////////////////////////////////////////////////////////////////////////////

  void inflate(float rate) // first function
  {
    w=w*rate; 
    h=h*rate;
  } 

  ////////////////////////////////////////////////////////////////////////////////////////////////////  
  void attract(Vec [] a)
  {
    for(int i=0; i <a.length; i++)
    {
      float d =pos.distance(a[i]);

      if (d < 10)
      {
        v.x += accel * (a[i].x - pos.x) / pos.distance(a[i]);
        v.y += accel * (a[i].y - pos.y) / pos.distance(a[i]); 
      }
      else
      {
        v.x += accel * (a[i].x - pos.x) / pos.distance(a[i])/10;
        v.y += accel * (a[i].y - pos.y) / pos.distance(a[i])/10; 
      }


      if (d <2) accel=.995;//look here....................................
      else accel=1.02;
    }

    v.multiply(.98);

  }
  ///////////////////////////////////////////////////////////////////////////////////////////////////////

  void checkColor(color c1, color c2) //c1 temp colour, c2 default colour
  {
    if(c != color (255))
    {
      colorCount++;
    }
    if (colorCount>60)
    {
      c=c2; //make it it's default color
      colorCount=0;
    }
    if (colorT<0) colorT=0;    
    if (colorT>1) colorT=1;        
  }

  ///////////////////////////////////////////////////////////////////////////////////////////////////////

  void sinTranslate(float xt, float yt, float rt) //future locations are xt, yt; rt future rotate
  {
    pos.x=(1-t)*xp+t*xt;
    pos.y=(1-t)*yp+t*yt;
    t=t+.01;
    t= sin(sinTranslatecount);
    sinTranslatecount= sinTranslatecount+0.1; //.01 is the speed. bigger number means faster
  }

  ///////////////////////////////////////////////////////////////////////////////////////////////////////

  void translate(float xt, float yt, float rt) //future locations are xt, yt; rt future rotate
  {
    if(t<=1)
    {
      pos.x=(1-t)*xp+t*xt;
      pos.y=(1-t)*yp+t*yt;
      t=t+1;    
    }
  }

  ///////////////////////////////////////////////////////////////////////////////////////////////////////

  //courveTranslate (center x, center y, curve deviation x, curve deviation y, radius x, radius y, motion speed)
  void curveTranslate(float xx, float yy, float sx, float sy, float rx, float ry, float speed)
  {
    curveTranslateCount+=speed; 
    pos.x = xx+(cos(curveTranslateCount*sx)* rx); //multiply the angle to get motion..
    pos.y = yy+(sin(curveTranslateCount*sy)* ry);
  }

  ///////////////////////////////////////////////////////////////////////////////////////////////////////

  void drawParticle() // rotate function
  {
    checkColor(color(255,0,0), color(255));
    float s= 20/(w+h);

    pos.add(v);
    /////////////////////////////////////////////////////////////////    
    strokeWeight(1); 
    float y1 = (noise(n1) - 0.5) * 55.0;  // values -15 to 15
    float y2 = (noise(n2) - 0.5) * 55.0;  // values -15 to 15
    line(pos.x-10, pos.y + y1, pos.x, pos.y);  // line(x1, y1, x2, y2)
    line(pos.x+10, pos.y + y2, pos.x, pos.y);  // line (x3, y3, x4, y4)      
    n1 += inc1;
    n2 += inc2;      
    /////////////////////////////////////////////////////////////////  
    stroke(lerpColor(c1,c2,constrain(colorT,0,1)));

  }
}