PSystem ps;

final int WORLD_SIZE = 300;
final int PARTICLE_SIZE = 14;
final int DRIFT = 8;
final int VALUE_RANGE = 350;
final int TRANSPARENCY = 200;
final int RATE = 30;
final int FENCE = 25;

final float WALL_REPEL = 50;
final float influence = 0.5;
final float LOCALITY_MUTATION_RATE = 0.01;
final float LOCALITY_SIZE = 50;
final float MUTATION_RATE = 0.001;
final float SPEED = 5;

boolean MUTATE_LOCALITY = false;
boolean rectangle = false;
boolean test = false;

int numParticles = 150;
int numConnectors = ((numParticles*(numParticles-1))/2);
int x1;
int x2;
int y1;
int y2;

Agent agents[]=new Agent[numParticles];

void setup() {

  framerate(RATE);
  size(300,300);

  ps = (PSystem)loadPlugin("PSystem");
  ps.setGravity(0);
  ps.drag = 0.001;

  ellipseMode(CENTER_DIAMETER);
  rectMode(CORNERS);
  colorMode(HSB, 300);
  for (int i=0;i<numParticles;i++) {
    agents[i]=new Agent();
    ps.addParticle(agents[i]);
    agents[i].initialize();
    agents[i].enableCollision();
  }
}

void loop() {

  background(300);
  noStroke();
  ps.draw();

  if (rectangle == true){
    drawRectangle();
  }

  for (int i=0;i<numParticles;i++) {
    agents[i].doInfluence();
  }
  if (MUTATE_LOCALITY==true){
    if (random(1) < LOCALITY_MUTATION_RATE) {
      mutateLocation();
    }
  }

}

class Agent extends Particle {

  float h;
  float s;
  float b;
  float nextH;

  Agent() {
    super();
  }

  void initialize(){
    pos[0] = random((PARTICLE_SIZE/2),(width - (PARTICLE_SIZE/2)));
    pos[1] = random((PARTICLE_SIZE/2),(height - (PARTICLE_SIZE/2)));
    velocity[0] = random(-SPEED,SPEED);
    velocity[1] = random(-SPEED,SPEED);
    nextH = random(VALUE_RANGE);
    s = random(VALUE_RANGE);
    b = random(VALUE_RANGE);
  }

  boolean hit(Agent p) {

    float distance = dist(p.pos[0], p.pos[1], pos[0], pos[1]);
    return distance <= PARTICLE_SIZE;

  }

  void doInfluence() {

    for (int i = 0; i < numParticles; i++) {
      if (agents[i] != this) {
        if (hit(agents[i])) {
          nextH = h + influence * (agents[i].h - h);
        }
      }

    }
  }

  void calculate(){

    h = constrain(h,0,VALUE_RANGE);
    s = constrain(s,0,VALUE_RANGE);
    b = constrain(b,0,VALUE_RANGE);

    //the DRIFT algorithms:
    int f = int(random(2));
    if (f==1){
      nextH=h + random(DRIFT);
    } else {
      nextH=h- random(DRIFT);
    }

    if (random(1) < MUTATION_RATE) {
      nextH = random(VALUE_RANGE);
    }

    s = 200;
    b = 200;

    /*int c = int(random(2));
    if (c==1){
      s=s+DRIFT;
    } else {
      s=s-DRIFT;
    }

    int m = int(random(2));
    if (m==1){
      b=b+DRIFT;
    } else {
      b=b-DRIFT;
    }*/
  }

  void calculateNext(float step) {
    h = nextH;
    calculate();

    if (pos[0] - PARTICLE_SIZE/2 < 0 || pos[0] + PARTICLE_SIZE/2 > width) {
      velocity[0] = -velocity[0];
    }
    if (pos[1] - PARTICLE_SIZE/2 < 0 || pos[1] + PARTICLE_SIZE/2 > height) {
      velocity[1] = -velocity[1];
    }

    if (pos[0] - PARTICLE_SIZE/2 < 0) {
      pos[0] = PARTICLE_SIZE/2 + 1;
    }
    if (pos[0] + PARTICLE_SIZE/2 > width) {
      pos[0] = width - (PARTICLE_SIZE/2 + 1);
    }
    if (pos[1]  - PARTICLE_SIZE/2 < 0) {
      pos[1] = PARTICLE_SIZE/2 + 1;
    }
    if (pos[1] + PARTICLE_SIZE/2 > height) {
      pos[1] = height - (PARTICLE_SIZE/2 + 1);
    }

    if (rectangle == true){
      if (pos[0] > x1 && pos[0] < x2 && pos[1] > y1 && pos[1] < y2) {
        if (pos[0] - (PARTICLE_SIZE/2 + FENCE) < x1 || pos[0] + (PARTICLE_SIZE/2 + FENCE) > x2 || pos[1] - (PARTICLE_SIZE/2 + FENCE) < y1 || pos[1] + (PARTICLE_SIZE/2 + FENCE) > y2){
          velocity[0] = -velocity[0];
          velocity[1] = -velocity[1];
        }
        if (abs(pos[0]-x1)<FENCE) {
          pos[0]-=PARTICLE_SIZE/2;
        }
        if (abs(pos[0]-x2)<FENCE) {
          pos[0]+=PARTICLE_SIZE/2;
        }
        if (abs(pos[1]-y1)<FENCE) {
          pos[1]-=PARTICLE_SIZE/2;
        }
        if (abs(pos[1]-y2)<FENCE) {
          pos[1]+=PARTICLE_SIZE/2;
        }

      }

    }

    super.calculateNext(step);
  }

  void draw(){

    //stroke(0);
    noStroke();
    fill(h,s,b,TRANSPARENCY);
    ellipse(pos[0],pos[1],PARTICLE_SIZE*1.2,PARTICLE_SIZE*1.2);
  }

}

void mutateLocation() {

  float x = random(width);
  float y = random(height);
  float h = random(VALUE_RANGE);

  for (int i = 0; i < numParticles; i++) {
    if (dist(x, y, agents[i].pos[0], agents[i].pos[1]) < LOCALITY_SIZE) {
      agents[i].nextH = h;
    }
  }
}

void drawRectangle() {
  fill(200,100);
  rect(x1,y1,x2,y2);
}

void mousePressed () {

  if (rectangle == false){
    if (test == false){
      x1 = mouseX;
      y1 = mouseY;
      test = true;
    } else if (test == true){
      x2 = mouseX;
      y2 = mouseY;
      rectangle = true;
    }
  } else if (rectangle == true){
    x1 = 0;
    y1 = 0;
    x2 = 0;
    y2 = 0;
    rectangle = false;
    test = false;
  }
}