class Attractor  
{  
  Vec pos = new Vec(0,0,0); // current point position of attractor NOT A VECTOR 
  Vec dir; // movement vector for attractor 
  int atrType; // national or foreigner attractor type 
  int xdirection = 2;  // Left or Right 
  int ydirection = 2;  // Up or Down 
  int numPart = 0; // number of particles engaged to static, incremented in particle class 
  int snapCounter=0; // counts time while particle outside of moving aoe for snapping to particle and changing vector, incremented in particle class 
  int snapCount=0; // number of snaps a static attractor has caused, helps determine moving atr deflection 
  int totalSnapCount=0; // total number of snaps moving atr has experienced, helps determine when a pairing leaves the sketch and is "reborn"  
  int rebornCounter=0; // counts how long a pair has moved off screen before resetting it to start conditions 
 
  boolean particle2moving = true; // swaps attraction between particle and moving attractor 
  boolean moving; // true = moving, false = static 
  float aoeAtr; // max distance for child particle to move in before moving particle changes vector 
  float vel; // velocity of movement 
 
  float [] staticSnapCount = new float[NUM_STATIC]; // each moving atr stores an array associated to number of static atr 
 
 
  color c; // attractor color 
  color c1, c2; // lerping colors 
 
  Attractor(float X, float Y, Vec startDir, int moveType, float _vel)   
  {  
    pos.x = X;  
    pos.y = Y; 
    dir = startDir; 
    atrType = moveType; 
    vel=_vel; 
 
    switch(atrType) 
    { 
    case 0: // national 
      aoeAtr=350; // distance after which moving atr (adult) follows particle (child) 
      c = color(255,0,0); // red 
      moving=true; 
      c1= color(200,0,0); // dark red 
      c2= color(255,255,25); //yellow 
      break; 
    case 1: // foreign 
      aoeAtr=160; // distance after which moving atr (adult) follows particle (child) 
      c = color(0,255,0); // green 
      moving=true; 
      c1= color(160,0,160); // dark purple 
      c2= color(0,255,255); //aquamarine 
      break; 
    case 2: // static 
      aoeAtr=0; // static, no such aoe variable 
      c = color(0);  
      moving=false; 
      break; 
    } 
 
    for(int j=0; j<staticSnapCount.length;j++) // give staticAttracted array null values 
    { 
      staticSnapCount[j] = 0;  
    }   
  }  
 
  ///////////////////////////// draw attractor (desired color, moving or not) 
  void drawAtr() 
  {  
    if(visualSwitch==false) 
    { 
      stroke(c); 
      line(pos.x-4, pos.y, pos.x+4, pos.y);  
      line(pos.x, pos.y-4, pos.x, pos.y+4); 
    } 
    if(moving==false) 
    { 
      noFill(); 
      stroke(0,numPart*20); 
      rectMode(CENTER); 
      rect(pos.x, pos.y,8+numPart*5,8+numPart*5);  
    } 
 
    if(moving==true && visualSwitch==false) 
    { 
      if(atrType==0) 
      { 
        noFill(); 
        stroke(c,66); 
        ellipse(pos.x, pos.y, aoeAtr, aoeAtr); 
      } 
      else if(atrType==1) 
      { 
        noFill(); 
        stroke(c,66); 
        ellipse(pos.x, pos.y, aoeAtr, aoeAtr); 
      } 
    } 
  }  
 
  ///////////////////////////// moving attractor on vector, bounce off edges, and deflect off statics 
  void stepAtr() 
  { 
    for(int i=0;i<staticAtr.length;i++) 
    { 
      float d1=pos.distance(staticAtr[i].pos); 
      if(d1<aoeAtr/2 && staticSnapCount[i]>0) 
      { 
        dir.normalize(); // normalize movement vector, just a direction now 
        float ny= (pos.y-staticAtr[i].pos.y)/d1; // normalize vector to static atr 
        float nx= (pos.x-staticAtr[i].pos.x)/d1; // ^^ 
 
        float a1=atan2(nx,ny); // calculate angle to static atr 
        float a2=atan2(dir.x, dir.y); // calculate angle of movement 
        //println(a2); 
        float newA=a1-a2; // difference between two angles 
 
        if(newA>=0) 
        { 
          a2 += radians(staticSnapCount[i]*1); 
        } 
        else if(newA<0) 
        { 
          a2 -= radians(staticSnapCount[i]*1); 
        } 
        dir.rotateVec(a2); 
      } 
    } 
    pos.x += dir.x*vel; 
    pos.y += dir.y*vel; 
 
    if (pos.x > width || pos.x < 0) 
    { 
      if(totalSnapCount<3) dir.x *= -1; 
      else rebornCounter++;  
    } 
    if (pos.y > height || pos.y < 0) 
    { 
      if(totalSnapCount<3) dir.y *= -1; 
      else rebornCounter++;  
    } 
 
  } 
 
  ///////////////////////////// when snap occurs and moving atr follows particle 
  void attractAtr(Particle pW) 
  { 
    float d2=pos.distance(pW.pos); // always calculate associated child particle distance 
    float tempX = pW.pos.x; 
    float tempY = pW.pos.y; 
    pos.x += 1.8 * (tempX-pos.x) / d2; // smaller divider number stronger force of attraction 
    pos.y += 1.8 * (tempY-pos.y) / d2;  
 
    if(visualSwitch==false) 
    { 
      stroke(255,255,0); 
      line(pos.x, pos.y, pW.pos.x, pW.pos.y);  
    } 
  } 
 
  void drawSnap(int i) 
  { 
    for(int k=0; k<10; k++) 
    { 
      stroke(0, (k+1)*10); 
      strokeWeight(totalSnapCount+1); 
      fill(255,66); 
      ellipse(pos.x, pos.y, aoeAtr/2-(k*(aoeAtr/20)), aoeAtr/2-(k*(aoeAtr/20)));   
      strokeWeight(1); 
    } 
    stroke(255); 
    strokeWeight(2); 
    line(pos.x, pos.y, p[i].pos.x, p[i].pos.y); 
    strokeWeight(1); 
  } 
 
  ///////////////////////////// increments values for which static atr have caused snaps 
  void updateStaticSnap(int [] update, float amount) 
  { 
    for(int i=0; i<update.length; i++) 
    { 
      if(update[i]>=0) staticSnapCount[update[i]] += amount; 
    } 
    //println(staticSnapCount); 
  } 
 
}  

class Vislines 
{ 
 
   
  float x1,y1,x2,y2; // start and end coords 
  color c; // stroke color 
  int a; // alpha value 
   
 
  Vislines(float X1, float Y1, float X2, float Y2, int A, color C) 
  { 
    x1=X1; 
    y1=Y1; 
    x2=X2; 
    y2=Y2; 
    c=C; 
    a=A; 
  } 
 
void drawLine() 
{ 
  stroke(c,a); 
  line(x1,y1,x2,y2); 
} 
 
} 

class Particle 
{   
  //Vislines [] particleLines = new Vislines[500]; // array of moving attractors (adult) 
  Vec partMoveDir = new Vec(0,0,0); // sets wandering vector when part/atr snap 
 
  float w,h; // width and height 
  float t=0; // translate smoothing 
  color lineColor = color(0); // line color 
  int lineAlpha = 66; // line alpha 
 
  color c3= color  (130,255,25); //green 
  color c4= color  (0,255,255); //blue 
 
  boolean runOnce = true; // sets values at moment of particle to movingatr swap 
  boolean forgetting =false; // whether particle is looking for static atr or not 
  float xdirection = 1;  // Left or Right 
  float ydirection = 1;  // Top to Bottom 
  float accel=1; // acceleration value 
  float xP, yP;  // start position 
  float aoeAtr=200; // max distance to engage with attractor 
 
  int maxStaticCount=3; // max # of static atr a particle will be attracted too 
  int staticCounter=0; // # of static attractors within particles aoe 
  int [] staticAttracted = new int[maxStaticCount]; // keeps track of which static atr particle is attracted too 
 
  float partMoveX=0; // determines wandering vector 
  float partMoveY=0; // ^^ 
  int partStart; // determines which screen edge particle starts on 
 
  float ty,tx; 
  float angle = 0.0; 
  float speed = .33; 
 
  Vec pos = new Vec(0,0,0); // current point position of particle NOT A VECTOR 
  Vec v = new Vec(0,0,0); // current vector  
 
  Particle(float X, float Y, float W, float H, int _partStart) //constructor 
  { 
    pos.x=X; 
    pos.y=Y; 
    w=W; 
    h=H; 
    partStart=_partStart; 
 
    /*for(int i=0; i<particleLines.length;i++) // give particleLine array null values 
     { 
     particleLines[i]=new Vislines(0,0,0,0,lineAlpha,lineColor);  
     }*/ 
  } 
 
 
 
  ////////////////////////////////////// 
  void step(Attractor [] a, Attractor b) // when particle is following moving and engaging statics 
  { 
    float d1 = 0; // distance from static to particle 
    float d2 = 0;  //distance from associated moving to particle 
    float ax = 0;   
    float ay = 0;  
 
    for(int j=0; j<staticAttracted.length;j++) // give staticAttracted array null values 
    { 
      staticAttracted[j] = -1;  
    } 
 
    ////////////////////// movement due to static attractor//////////////////////////// 
    for (int i=0;i<a.length;i++)   
    {  
      if(staticCounter<3) // only check for static attractors if particle is engaged with less than 2 
      { 
        d1=pos.distance(a[i].pos); 
        if (d1 < aoeAtr/2 && a[i].numPart < 6 ) //if distance is within child particle aoe and less than X particles are engaged at that attractor 
        {  
          a[i].numPart++; 
          if(d1 > (aoeAtr/2)*.75) // if distance is 75% of aoe radius or more, slows down particle movement at first 
          { 
            pos.x +=(a[i].pos.x-pos.x) * d1/2000;  
            pos.y +=(a[i].pos.y-pos.y) * d1/2000; 
          } 
          else 
          { 
            pos.x += (a[i].pos.x-pos.x) * d1/(1000-a[i].numPart*50); // smaller divider number stronger force of attraction 
            pos.y += (a[i].pos.y-pos.y) * d1/(1000-a[i].numPart*50); // as particles accumulate, force stronger 
          } 
          if (visualSwitch==true)  
          {  
            lineColor=color(0);  
            lineAlpha=33; 
            stroke(lineColor, lineAlpha); 
            line(a[i].pos.x, a[i].pos.y, pos.x, pos.y); // line to static 
            //prepLineArray(a[i].pos.x, a[i].pos.y); 
          } 
          else if (visualSwitch==false)  
          {  
            stroke(0); 
            line(pos.x,pos.y, a[i].pos.x, a[i].pos.y); 
          } 
          if(b.snapCounter > SNAP_TIME-1) staticAttracted[staticCounter] = i; // loads all engaged static atr's array position just before snap  
          staticCounter++; 
        }  
      } 
    } 
 
    ////////////////////// movement due to moving attractor//////////////////////////// 
    d2=pos.distance(b.pos); // always calculate associated parent attractor after all statics checked 
    if (d2 < b.aoeAtr/2) // condition 1x - if distance smaller than parent aoe 
    { 
      if (d2 < aoeAtr/2) // condition 1A - if d2 smaller than particle aoe 
      { 
        pos.x += (b.pos.x-pos.x) * d2/1000; // smaller divider number stronger force of attraction 
        pos.y += (b.pos.y-pos.y) * d2/1000;  
        if(staticCounter==0) // if only engaged by moving attractor and no statics, sinusoidal movement 
        { 
 
          curveTrans(100/d2); 
        } 
        if (visualSwitch==true) 
        { 
          lineColor=lerpColor(b.c1,b.c2,d2/(aoeAtr/2)); 
          lineAlpha=80; 
          stroke(lineColor, lineAlpha); 
          line(b.pos.x, b.pos.y, pos.x, pos.y);  
          //prepLineArray(b.pos.x, b.pos.y); 
        } 
        else if (visualSwitch==false)  
        { 
          stroke(b.c); 
          line(pos.x,pos.y, b.pos.x, b.pos.y); 
        } 
      } 
      else if(d2 > aoeAtr/2) // condition 1B - if d2 larger than particle aoe (only possible with national pairs) 
      { 
        if (visualSwitch==true) 
        { 
          lineColor=lerpColor(b.c2,c3,d2/(b.aoeAtr/2)); 
          lineAlpha=80; 
          stroke(lineColor, lineAlpha); 
          line(b.pos.x, b.pos.y, pos.x, pos.y); 
          //prepLineArray(b.pos.x, b.pos.y); 
        } 
        else if (visualSwitch==false)  
        { 
          stroke(0,130,255);  
          //line(pos.x,pos.y, b.pos.x, b.pos.y); 
        } 
      } 
    } 
    else if(d2 > b.aoeAtr/2) // condition 2x - if d2 outside of parent aoe 
    { 
      if(b.particle2moving==true) b.snapCounter++; // only increment when particle following moving 
      if (d2 < aoeAtr/2) // condition 2A - if d2 smaller than child aoe (only possible with foreigner pairs) 
      { 
        pos.x += (b.pos.x-pos.x) * d2/1000; // smaller divider number stronger force of attraction 
        pos.y += (b.pos.y-pos.y) * d2/1000;  
        if(staticCounter==0 && d2<aoeAtr/2 && forgetting==false) // if only engaged by moving attractor (parent), move somewhat freely 
        { 
          curveTrans(100/d2); 
        } 
        if (visualSwitch==true) 
        { 
          lineColor=lerpColor(b.c2,c3,d2/(b.aoeAtr/2)); 
          lineAlpha=80; 
          stroke(lineColor, lineAlpha); 
          line(b.pos.x, b.pos.y, pos.x, pos.y); 
          //prepLineArray(b.pos.x, b.pos.y); 
        } 
        else if (visualSwitch==false)  
        { 
          stroke(0,130,255); 
          line(pos.x,pos.y, b.pos.x, b.pos.y); 
        } 
      } 
      else if(d2 > aoeAtr/2) // condition 2B - if d2 larger than particle aoe (only possible with national pairs) 
      { 
        if (visualSwitch==true) 
        { 
          lineColor=lerpColor(c3,c3,d2/(b.aoeAtr/2)); 
          lineAlpha=80; 
          stroke(lineColor, lineAlpha); 
          line(b.pos.x, b.pos.y, pos.x, pos.y); 
          //prepLineArray(b.pos.x, b.pos.y); 
        } 
        else if (visualSwitch==false)  
        { 
          stroke(0,130,255);  
          line(pos.x,pos.y, b.pos.x, b.pos.y); 
        } 
      } 
    } 
    if (visualSwitch==true) 
    { 
      //for(int i=0; i<particleLines.length;i++) particleLines[i].drawLine(); // draw array of lines 
    } 
    staticCounter=0; 
  } 
 
  ///////////////////////////////////// 
  void setWanderVec() // wandering vector 
  { 
    while(partMoveX < .35 && partMoveX > -.3) partMoveX=random(-1,1); // ensures wandering vector is not too "slow" 
    while(partMoveY < .35 && partMoveY > -.3) partMoveY=random(-1,1); // ^^ 
    partMoveDir = new Vec(partMoveX,partMoveY,0.0); // gives wandering particle new direction vector at moment of snapping 
  } 
 
  ////////////////////////////////////// 
  void wandering(Attractor c) // when particle wandering 
  { 
    float d3=pos.distance(c.pos); // always calculate associated particle/moving atr distance 
    pos.x += partMoveDir.x*xdirection; 
    pos.y += partMoveDir.y*ydirection; 
    if (pos.x > width || pos.x < 0) { 
      xdirection *= -1; 
    } 
    if (pos.y > height || pos.y < 0) { 
      ydirection *= -1; 
    }  
    if(d3>aoeAtr/2 && visualSwitch==true) 
    {  
      stroke(255); 
      strokeWeight(1); 
      line(c.pos.x, c.pos.y, pos.x, pos.y); 
    } 
    if(d3<aoeAtr/2) // if moving atr back within aoe 
    { 
      if (visualSwitch==true) 
      { 
        lineColor=lerpColor(c3,c.c2,d3/(aoeAtr/2)); 
        lineAlpha=80; 
        line(c.pos.x, c.pos.y, pos.x, pos.y); 
        //prepLineArray(c.pos.x, c.pos.y); 
      } 
      else if (visualSwitch==false)  
      { 
        stroke(255,255,0); 
        line(pos.x,pos.y, c.pos.x, c.pos.y); 
      } 
    } 
    if(d3<aoeAtr/6) // if within 1/3 of particle aoe radius reset relation 
    { 
      c.dir.x=partMoveDir.x; // sets moving atr vector to particle vector 
      c.dir.y=partMoveDir.y; 
      c.vel=random(1.5,2.0); 
      partMoveX=0; 
      partMoveY=0; 
      forgetting=true; // sets particle to not look for statics 
    } 
    if (visualSwitch==true) 
    { 
      //for(int i=0; i<particleLines.length;i++) particleLines[i].drawLine(); // draw array of lines 
    } 
  } 
 
  /* ///////////////////////////////////// 
   void prepLineArray(float x2, float y2) 
   { 
   for(int i=1;i<particleLines.length;i++)  
   { 
   float fadeNumber=particleLines.length*.33; //% of line array fades out 
   if(i < int(fadeNumber)) 
   { 
   float alphaChange = 100/fadeNumber;  //amount to fade per increment 
   float actualAlpha = i*alphaChange; // oldest line, i=1, faded the most to newest line, i=fadeNumber, the least 
   particleLines[i].a = int(actualAlpha); 
   } 
   particleLines[i-1]=particleLines[i]; 
   } 
   particleLines[particleLines.length-1]= new Vislines(pos.x, pos.y, x2, y2, lineAlpha, lineColor); 
   }*/ 
 
  ////////////////////////////////////// 
  void curveTrans(float radius) 
  {  
    angle+=speed; 
    float sinval=sin(angle); 
    float ty = sinval * radius; 
    pos.y+=ty; 
    float cosval=cos(angle); 
    float tx = cosval * radius; 
    pos.x+=tx; 
 
  } 
 
  ////////////////////////////////////// 
  void drawParticle() 
  { 
    strokeWeight(1); 
    stroke(0,0,0,33); 
    noFill(); 
    ellipse(pos.x, pos.y,aoeAtr,aoeAtr); 
    noStroke(); 
    fill(0); 
    ellipse(pos.x, pos.y,w,h); 
  }  
} 

//import processing.pdf.*; 
 
int NUM_PAIRS=25; // number of (child) particle and (adult) moving attractors pairs 
int NUM_STATIC=30; // number of static attractors 
int SNAP_TIME=80; // # of frames until part/moving atr snap occurs 
int FORGET_TIME=60; // # of frames particle "forgets" static atr  
int REBIRTH_TIME=60; // # frames until part/moving atr pair reset to start 
boolean visualSwitch = true ; // swaps between behavior and resultant visualizations 
 
float startLx, startLy; // left edge gate 
float startBx, startBy; // bottom edge gate 
float startRx, startRy; // right edge gate 
float startTx, startTy; // top edge gate 
 
Particle [] p = new Particle[NUM_PAIRS]; // array of particles (child) 
Attractor [] movingAtr = new Attractor[NUM_PAIRS]; // array of moving attractors (adult) 
Attractor [] staticAtr = new Attractor[NUM_STATIC]; // array of static attractors (non-adult) 
Attractor [] nullAtr = new Attractor[0]; // array of null statics for particle in "forgetting" phase 
 
Vec nullDir=new Vec(0,0,0); // a no movement vector for static attractors 
Vec moveDir[]= new Vec[NUM_PAIRS]; // initial movement vector for moving attractors 
 
int forgettingCounter=0; // used for how long particle "forgets" to look for static atr 
int counter=0; 
 
void setup() 
{ 
  size(800,800); 
  background(255); 
  smooth(); 
  //beginRecord(PDF, "everything.pdf"); 
 
  setGateways(); // sets random start locations on each edge of screen 
  setParticles(0, p.length); // creates particles in Particle class arreay 
  setMoveAttractors(0, movingAtr.length); // creates movingattractors in Attractor class array 
  setStaticAttractors(); // creates static attractos in Attractor class array 
 
} 
 
void draw() 
{ 
 
  if(visualSwitch == false) background(255); 
  else if(visualSwitch == true) 
  { 
    counter = counter+1;  
    int redrawer = counter%15; // every 4 frames  
    if (redrawer<=0)  
    {  
      fill(255,12);  
      noStroke();  
      rect(0,0,width,height);    
    }  
  } 
 
  for(int i=0; i<NUM_PAIRS; i++) 
  { 
    if(visualSwitch == false) p[i].drawParticle(); 
    if(movingAtr[i].particle2moving==true) // if particle following moving atr 
    { 
      movingAtr[i].stepAtr(); 
      p[i].step(staticAtr, movingAtr[i]); 
    } 
    else if(movingAtr[i].particle2moving==false) // if moving atr following particle 
    { 
      if(p[i].forgetting==false) // if particle is wandering 
      { 
        if(p[i].runOnce==true) // set initial wander vector only once 
        { 
          p[i].setWanderVec(); 
          p[i].runOnce=false; // wont run again until reset 
        } 
        movingAtr[i].snapCounter=0; // reset  
        movingAtr[i].attractAtr(p[i]); // moving atr to particle 
        p[i].wandering(movingAtr[i]); // sets forgetting boolean 
      } 
      else if(p[i].forgetting==true) // if particle disregarding static attractors (forgetting) 
      { 
        movingAtr[i].stepAtr(); // moving atr normal 
        p[i].step(nullAtr, movingAtr[i]); // all statics null to particle 
        forgettingCounter++; 
        if(forgettingCounter>FORGET_TIME) // number of frames in forgetting phase until particle/moving atr reset to initial condition 
        { 
          movingAtr[i].particle2moving=true; // particle following moving atr 
          p[i].runOnce=true; // reset for when next snap occurs 
          p[i].forgetting=false; // particle is looking for static atr 
          forgettingCounter=0; // reset counter for next time 
        } 
      } 
    } 
 
    if(movingAtr[i].snapCounter > SNAP_TIME) // SNAP occurs after a X amount of time 
    { 
      if(visualSwitch==true) // snapping visual 
      { 
        movingAtr[i].drawSnap(i); 
      } 
 
      movingAtr[i].particle2moving=false; // moving atr follows particle now 
      movingAtr[i].totalSnapCount++; 
      for(int j=0; j<movingAtr.length; j++) // tests against all other moving atr 
      { 
        float d1 = movingAtr[i].pos.distance(movingAtr[j].pos); 
        if(d1<movingAtr[i].aoeAtr/2) // if within moving atr aoe 
        { 
          if(j!=i && movingAtr[i].atrType==movingAtr[j].atrType) // update other same type of moving atr by fraction 
          { 
            movingAtr[j].updateStaticSnap(p[i].staticAttracted,.25); // updates moving atr's static atr deflection array 
 
            if(visualSwitch==true) 
            { 
              fill(255,90); 
              stroke(0,90); 
              ellipse(movingAtr[j].pos.x, movingAtr[j].pos.y,15,15); 
            } 
          } 
          else if(j==i) // update current moving atr fully 
          { 
            movingAtr[j].updateStaticSnap(p[i].staticAttracted,1.0); // updates moving atr's static atr deflection array 
          } 
 
        } 
      } 
    } 
 
    if(movingAtr[i].rebornCounter>REBIRTH_TIME) //resets part/moving atr pair 
    { 
      setParticles(i, i+1);  
      setMoveAttractors(i, i+1); 
    } 
 
  } 
  if(visualSwitch == false) drawAtr(); 
  for(int i=0; i<staticAtr.length; i++) staticAtr[i].numPart=0; 
} 
 
void setGateways() // start locations 
{ 
  startLx=0; // left edge 
  startLy=random(height*.1, height-(height*.1)); 
 
  startBx=random(width*.1, width-(width*.1)); // bottom edge 
  startBy=height;  
 
  startRx=width; // right edge 
  startRy=random(height*.1, height-(height*.1)); 
 
  startTx=random(width*.1, width-(width*.1)); // top edge 
  startTy=0;  
} 
 
void setParticles(int forStart, int forUntil) 
{ 
  for(int i=0; i<p.length; i++)  
  { 
    float partStart=random(4); 
    if(partStart<1) partStart=0; 
    if(partStart>=1 && partStart<2) partStart=1; 
    if(partStart>=2 && partStart<3) partStart=2; 
    if(partStart>=3 && partStart<4) partStart=3; 
 
    switch(int(partStart)) 
    { 
    case 0: 
      p[i]= new Particle(startLx,startLy,6,6,0); 
      break; 
    case 1: 
      p[i]= new Particle(startBx,startBy,6,6,1); 
      break; 
    case 2: 
      p[i]= new Particle(startRx,startRy,6,6,2); 
      break; 
    case 3: 
      p[i]= new Particle(startTx,startTy,6,6,3); 
      break; 
    } 
  } 
} 
 
/*void keyPressed()  
{ 
  if (key == 'q')  
  { 
    endRecord(); 
    exit(); 
  } 
}*/ 
 
void setMoveAttractors(int forStart, int forUntil) 
{ 
  float atrType=0; // 0 = national, 1 = foreigner, moving attractor, randomly decided in setup 
 
  /////// MOVING 
  for (int i=0; i<movingAtr.length; i++) 
  { 
    atrType=random(0,1); // randomly generate either foreign or national moving attractors 
    if(atrType<=.5) atrType=0;  
    else atrType=1; 
 
    switch(p[i].partStart) 
    { 
    case 0: 
      moveDir[i] = new Vec(random(.5,2.0),random(-1.5,1.5),0.0); // random starting vector of movement; 
      break; 
    case 1: 
      moveDir[i] = new Vec(random(-1.5,1.5),random(-2.0,-.5),0.0); // random starting vector of movement; 
      break; 
    case 2: 
      moveDir[i] = new Vec(random(-2.0,-.5),random(-1.5,1.5),0.0); // random starting vector of movement; 
      break; 
    case 3: 
      moveDir[i] = new Vec(random(-1.5,1.5),random(.5,2.0),0.0); // random starting vector of movement; 
      break; 
    } 
 
    movingAtr[i]=new Attractor(p[i].pos.x, p[i].pos.y, moveDir[i], int(atrType), random(1.0,2.0)); 
  } 
} 
 
void setStaticAttractors() 
{ 
  ///////// STATIC 
  for (int i=0; i<staticAtr.length; i++) 
  { 
    staticAtr[i]=new Attractor(random(25,width-25), random(25,height-25), nullDir,2,0); 
    for(int j=0; j<i; j++) // tests to make sure no statics are drawn within X distance of any other 
    { 
      if(staticAtr[i].pos.distance(staticAtr[j].pos) < 50) i--; 
    } 
  } 
} 
 
void drawAtr() 
{ 
  for (int i=0; i<movingAtr.length; i++) movingAtr[i].drawAtr(); 
  for (int i=0; i<staticAtr.length; i++) staticAtr[i].drawAtr(); 
} 
 
void mouseClicked() // true shows resultant visualization, false behavior visualization, swaps on mouseclick 
{ 
  if(visualSwitch==true) visualSwitch=false; 
  else if (visualSwitch==false) visualSwitch=true;  
  setup(); 
} 

class Vec 
{ 
  float x,y,z; 
 
  Vec(float X, float Y, float Z) 
  { 
    x=X; 
    y=Y; 
    z=Z; 
  } 
 
  void add(Vec v) 
  { 
    x+=v.x; 
    y+=v.y; 
    z+=v.z; 
  } 
 
  void subtract(Vec v) 
  { 
    x-=v.x; 
    y-=v.y; 
    z-=v.z; 
  } 
 
  // multiply function, divide by using number below 1 
  void multiply(float m) 
  { 
    x*=m; 
    y*=m; 
    z*=m; 
  } 
 
  //distance (to this vector) from calling vector) 
  float distance(Vec v) 
  { 
    float d= sqrt(pow(v.x-x,2) + pow(v.y-y,2) + pow(v.z-z,2));  
    return d; 
  } 
 
  //calculate the magnitude (length) of the vector and return the magnitude of the vector   
  float magnitude() 
  { 
    return (float) sqrt(pow(x,2) + pow(y,2) + pow(z,2) );  
  } 
 
  void rotateVec(float ang) 
  { 
    x=cos(ang); 
    y=sin(ang); 
  } 
 
  void normalize() 
  { 
    x = x/(float) sqrt(pow(x,2) + pow(y,2) + pow(z,2) );  
    y = y/(float) sqrt(pow(x,2) + pow(y,2) + pow(z,2) );  
  } 
 
  //set function values through manual input //change vector parameters without using another function  
  void set (float xx, float yy, float zz)  
  {   
    x=xx;  
    y=yy;  
    z=zz;   
  }  
 
  //set function values with vector values //change vector parameters without using another function 
  void set (Vec v)  
  {   
    x=v.x;  
    y=v.y;  
    z=v.z;   
  }    
}