// Cassini
//
// Author: Mario Klingemann
// mario@quasimondo.com
// http://incubator.quasimondo.com
//
//
//
// THIS CODE IS PROVIDED UNDER THE TERMS OF THE 
// CREATIVE COMMONS PUBLIC LICENSE ("CCPL" OR "LICENSE"). 
// THE WORK IS PROTECTED BY COPYRIGHT AND/OR OTHER 
// APPLICABLE LAW. ANY USE OF THE WORK OTHER THAN 
// AS AUTHORIZED UNDER THIS LICENSE OR COPYRIGHT LAW 
// IS PROHIBITED. 
//
// You are free:
//
// to copy, distribute, display, and perform the work 
// to make derivative works
// to make commercial use of the work 
// Under the following conditions:

// Attribution. You must give the original author credit. 

// For any reuse or distribution, you must make clear to others the license terms of this work. 
// Any of these conditions can be waived if you get permission from the copyright holder. 
// Your fair use and other rights are in no way affected by the above.
//
// Details: http://creativecommons.org/licenses/by/2.0/legalcode

Particle[] dots;
int count;
int iMax;

Gradient grad;
int closest;
boolean hasClosest=false;

void setup(){

  size(300,400);

  int c2=0xfff7f4;
  int c1=0x505b57;

  grad=new Gradient(c1,c1);
  grad.addMarker(0.14,c1);
  grad.addMarker(0.2,c2);
  grad.addMarker(0.6,c2);
  grad.addMarker(0.66,c1);
  iMax=width*height;

  count=5;
  dots=new Particle[count];
  for (int i=0;i<count;i++){
    dots[i]=new Particle(width,height);
  }
  resetParticleRelations();

}


void loop(){

  int i;

  for (i=0;i<count;i++){
    dots[i].move();
  }
  for (i=0;i<count;i++){
    dots[i].apply();
  }

  if (mousePressed){
    if (!hasClosest) getClosest();
    dots[closest].x=mouseX;
    dots[closest].y=mouseY;
    dots[closest].ix=mouseX;
    dots[closest].iy=mouseY;
  }

  render();
  grad.shift(-1);
}

void render(){
  int i=width*height;

  float d;
  float dx,dy;
  int b,p;

  for (float y=height;--y>-1.0;)
  {
    for (float x=width;--x>-1.0;)
    {
      i--;
      d=1;
      for (p=count;--p>-1;)
      {
        dx=x-dots[p].ix;
        dy=y-dots[p].iy;
        d*=(1+dx*dx+dy*dy)/1000.0;
      }

     if (d>70000000.0) d=70000000.0;
      pixels[i]=grad.getColor((int)(pow(d,0.4))&255);
      

    }
  }
}



void getClosest(){
  int mind=100000;
  for (int i=count;--i>-1;){
    int dx=mouseX+dots[i].ix;
    int dy=mouseY+dots[i].iy;
    int d=dx*dx+dy*dy;
    if (d<mind){
      mind=d;
      closest=i;
    }
  }
  hasClosest=true;
}

void resetParticleRelations(){
  for (int i=0;i<count;i++){
    dots[i].resetRelationships();
    for (int e=0;e<int(random(count));e++){
      int o=int(random(count));
      if (o!=i){
        dots[i].addEnemy(dots[o]);
      }
    }

    for (int t=0;t<int(random(count));t++){
      int o=int(random(count));
      if (o!=i){
        dots[i].addTarget(dots[o]);
      }
    }
  }
}

void mouseReleased(){
  hasClosest=false;
}

void keyReleased(){
  resetParticleRelations();
}


class Particle
{

  float x,y,nx,ny;
  int ix,iy,ip;
  float vx,vy;
  float speed;
  float targetSpeed;
  float angle;
  float targetAngle;
  float cx,cy;
  float MAXSPEED=5;
  float ENEMY_ZONE=30;
  float TARGET_ZONE=20;
  float AVOID_ZONE=10;
  float BORDER=40;
  float CONSTRAIN_RADIUS=0;
  float INNER_CONSTRAIN_RADIUS=60;
  boolean friendDetected=false;
  boolean enemyDetected=false;
  int fd;
  int ed;
  Particle[] targets;
  Particle[] enemies;

  Particle(int w,int h)
  {
    cx=float(w)/2;
    cy=float(h)/2;
    x=random(w);
    y=random(h);
    vx=0;
    vy=0;
    targetSpeed=speed=2;
    targetAngle=angle=random(TWO_PI);
    targets=new Particle[0];
    enemies=new Particle[0];
    ENEMY_ZONE*=ENEMY_ZONE;
    TARGET_ZONE*=TARGET_ZONE;
    AVOID_ZONE*=AVOID_ZONE;
    CONSTRAIN_RADIUS=min(width,height)/2-BORDER;
    CONSTRAIN_RADIUS*=CONSTRAIN_RADIUS;
  }

  void setXY(int xs,int ys)
  {
    x=xs;
    y=ys;
  }

  void resetRelationships()
  {
    targets=new Particle[0];
    enemies=new Particle[0];
  }

  void addTarget(Particle t)
  {
    for (int i=0;i<targets.length;i++){
      if (targets[i]==t){
        return;
      }
    }
    for (int i=0;i<enemies.length;i++){
      if (enemies[i]==t){
        return;
      }
    }
    Particle[] tempTargets=new Particle[targets.length+1];
    System.arraycopy(targets, 0, tempTargets, 0, targets.length);
    tempTargets[targets.length]=t;
    targets=tempTargets;
  }

  void addEnemy(Particle t)
  {
    for (int i=0;i<enemies.length;i++){
      if (enemies[i]==t){
        return;
      }
    }
    for (int i=0;i<targets.length;i++){
      if (targets[i]==t){
        return;
      }
    }
    Particle[] tempEnemies=new Particle[enemies.length+1];
    System.arraycopy(enemies, 0, tempEnemies, 0, enemies.length);
    tempEnemies[enemies.length]=t;
    enemies=tempEnemies;
  }

  void move()
  {
    this.updateDirection();
    this.checkTargets();
    this.checkContraints();
    this.updateSpeed();
    nx=x+vx;
    ny=y+vy;
  }

  void checkContraints()
  {

    if (x<BORDER || y<BORDER || x>width-BORDER || y>height-BORDER){
      targetAngle=atan2(height/2-y,width/2-x);
      angle=turn(angle,targetAngle,.1);
    }

  }

  void updateDirection()
  {
    targetAngle=random(TWO_PI);
    angle=turn(angle,targetAngle,.01);
  }

  void checkTargets()
  {
    float dMin=TARGET_ZONE+1;
    float pointAngle=angle;
    friendDetected=false;
    for (int i=0;i<targets.length;i++){
      float dx=targets[i].x-x;
      float dy=targets[i].y-y;
      float d=dx*dx+dy*dy;
      if (d<=TARGET_ZONE && d<dMin){
        if (d>AVOID_ZONE){
          dMin=d;
          pointAngle=atan2(dy,dx);
        } else {
          speed*=1.02;
        }
        fd=i;
        friendDetected=true;
      }
    }

    dMin=TARGET_ZONE+1;

    if (friendDetected){
      angle=turn(angle,pointAngle,.1);
      speed*=.99;
    } else {
      speed*=1.01;
    }

  }

  void updateSpeed()
  {
    speed=min(speed,MAXSPEED);
    vx=cos(angle)*speed;
    vy=sin(angle)*speed;
  }

  void apply()
  {
    x=nx;
    y=ny;
    ix=int(x);
    iy=int(y);
    ip=ix+iy*width;
  }

  float turn(float currentAngle,float targetAngle,float percent)
  {
    float aDif=targetAngle-currentAngle;
    if (aDif>PI){
      aDif=-(TWO_PI-aDif);
    } else if (aDif<-PI){
      aDif=TWO_PI+aDif;
    }
    return currentAngle+aDif*percent;
  }

}

class Gradient
{
  int shift=0;
  Marker[] markers;
  color[] palette;
  Gradient(color c1,color c2){
    markers=new Marker[2];
    markers[0]=new Marker(0,c1);
    markers[1]=new Marker(1,c2);
    palette=new color[256];
    this.updatePalette();
  }

  void addMarker(float p,color c)
  {
    Marker[] tempMarkers=new Marker[markers.length+1];
    int iAdd=0;
    for (int i=0;i<markers.length;i++){
      if (markers[i].position<p || iAdd==1){
        tempMarkers[i+iAdd]=markers[i];
      } else  {
        tempMarkers[i+iAdd]=new Marker(p,c);
        iAdd=1;
        tempMarkers[i+iAdd]=markers[i];
      }
    }
    markers=tempMarkers;
    this.updatePalette();
  }

  void updatePalette()
  {
    int p1,p2,p,r,g,b,step,steps;
    Marker currentMarker,nextMarker;
    for (int i=0;i<markers.length-1;i++){
      currentMarker=markers[i];
      nextMarker=markers[i+1];
      p1=currentMarker.getPalettePos();
      p2=nextMarker.getPalettePos();
      steps=p2-p1;
      step=0;
      for (p=p1;p<=p2;p++){
        r=((currentMarker.col & 0xff0000)*(steps-step) + (nextMarker.col & 0xff0000)*(step))/steps;
        g=((currentMarker.col & 0x00ff00)*(steps-step) + (nextMarker.col & 0x00ff00)*(step))/steps;
        b=((currentMarker.col & 0x0000ff)*(steps-step) + (nextMarker.col & 0x0000ff)*(step))/steps;
        palette[p]=0xff000000 | (r & 0xff0000) | (g & 0x00ff00) | (b & 0x0000ff);
        step++;
      }
    }
  }

  color getColor(int c)
  {
    c=(c+shift+255)%256;
    return palette[c];
  }
  
  void shift(int n){
    shift=(shift+n)%256;
  }

  void trace()
  {
    for (int i = 0;i<256;i++){
      println(i+": "+getColor(i));
    }
  }

}

class Marker
{
  float position;
  color col;
  Marker(float p,color c){
    position=p;
    col=c;
  }

  int getPalettePos(){
    return int(position*255);
  }
}