// =========================================================================
// Markus Lerner
// http://www.markuslerner.com
// 2003-10-28
//
// Behavior: Mechanical vs. Organic
// =========================================================================

BImage bgImage;

int num = 25;
int hSpacing = 20;
float friction = 0.8f;
boolean gLock;
boolean tFixed;

SpringPoint p[];

// button vars
int buttonNum, state;
Button[] buttons;
BFont univers;

// setup ===================================================================
void setup() {
  size(600, 300);
  background(0,0,0);
  // smooth();
  framerate(60);
  ellipseMode(CENTER_DIAMETER);

  bgImage = loadImage("bg_be.jpg");
  image(bgImage, 0, 0);

  p = new SpringPoint[num];

  for(int i=0; i<num; i++) {
    if(i == 0 || i == num-1) {
      tFixed = true;
    }
    else {
      tFixed = false;
      }
    p[i]= new SpringPoint(50 + i*hSpacing, 140, 8, i, tFixed);
  }

  // create buttons
  buttonNum=2;
  buttons=new Button[buttonNum];
  buttons[0]=new Button(20,275, 7,7, 0);
  buttons[1]=new Button(40,275, 7,7, 1);
  for(int i=0; i<buttonNum; i++) buttons[i].setColor(255,255,255, 128,128,128);
  state = 0;

  univers = loadFont("Univers55.vlw.gz");
}

// loop ====================================================================
void loop() {
  // draw background
  background(0,0,0);
  image(bgImage, 0, 0);

  // draw SpringPoints
  for(int i=0; i<num; i++) p[i].loop();

  // draw buttons
  for(int i=0; i<buttonNum; i++) buttons[i].draw();

  fill(255, 255, 255);
  textFont(univers, 15);
  text("MODE", 20, 265);
}

// key methods =============================================================
void keyReleased() {
  if(key == ' ') {
    state ++;
    if(state >= buttonNum) {
      state = 0;
    }
  }
}

// mouse methods ===========================================================
void mousePressed() {
  for(int i=0; i<buttonNum; i++) buttons[i].check(mouseX,mouseY);
}

// SpringPoint class =======================================================
class SpringPoint {
  Vec2D past[];
  int pastNum = 20;
  int waitCount = 0;

  float x, y, size;
  float anchorX, anchorY;
  float overExpansion = 2;
  float speed = 3;
  int id;
  boolean fixed;
  boolean over = false;
  boolean pressed = false;
  boolean lock = false;
  //color baseColor = color(125, 0, 0);
  color baseColor = color(255, 255, 255);
  //color highlightColor = color(255, 200, 180);
  color highlightColor = color(255, 180, 160);
  color currentColor = baseColor;
  Vec2D pos, target, dir;

  SpringPoint(float _x, float _y, float _size, int _id, boolean _fixed) {
    pos = new Vec2D(_x, _y);
    size = _size;
    id = _id;
    fixed = _fixed;
    if(fixed) {
      setTarget();
    }
    past = new Vec2D[pastNum];
    for(int i=0; i<pastNum; i++) past[i] = new Vec2D();
  }

  boolean overCircle() {
    float disX = pos.x - mouseX;
    float disY = pos.y - mouseY;
    if(sqrt(sq(disX) + sq(disY)) < size/2*overExpansion ) {
      return true;
    } else {
      return false;
    }
  }

  void move(){
    float speedX = (p[id-1].pos.x + p[id+1].pos.x) / 2 - pos.x;
    float speedY = (p[id-1].pos.y + p[id+1].pos.y) / 2 - pos.y;
    pos.x += speedX * friction;
    pos.y += speedY * friction;
  }
  void setTarget() {
    target = new Vec2D(random(width), random(height));
  }
  void moveFixed(){
    dir = new Vec2D(target);
    dir.sub(pos);
    dir.normalise();
    dir.mult(speed);
    pos.add(dir);
  }

  void loop(){
    if(!mousePressed) {
      lock = false;
      gLock = false;
    }
    if(overCircle()) {
      over = true;
      currentColor = highlightColor;
      if(mousePressed && !lock && !gLock) {
        lock = true;
        gLock = true;
        anchorX = mouseX - pos.x;
        anchorY = mouseY - pos.y;
      }
    }
    else {
      over = false;
      currentColor = baseColor;
    }
    if(lock) {
      pos.x = mouseX - anchorX;
      pos.y = mouseY - anchorY;
    }
    if(!fixed && !lock) {
      move();
    }
    // only if this point is a fixed point
    if(fixed) {
      if(dist(pos.x, pos.y, target.x, target.y) < speed) {
        setTarget();
      }
      moveFixed();
      // target
      // fill(0,0,0);
      // noStroke();
      // ellipse(target.x, target.y, size/2, size/2);
    }
    // save Past
    waitCount++;
    if(waitCount == 1) {
      for(int i=pastNum-1; i>0; i--) past[i].set(past[i-1]);
      past[0].set(pos.x, pos.y);
      waitCount = 0;
    }
    if(state == 1) {
      drawPast();
    }
    draw();
  }
  void drawPast() {
    noStroke();
    for(int i=0; i<pastNum-1; i++) {
      float scale = 1-float(i)/float(pastNum);
      fill(red(currentColor), green(currentColor), blue(currentColor), scale*100);
      ellipse(past[i].x, past[i].y, size*scale, size*scale);

      stroke(red(baseColor), green(baseColor), blue(baseColor), scale*100);
      if(id != 0) line(p[id-1].past[i].x, p[id-1].past[i].y, past[i].x, past[i].y);
    }
  }
  void draw(){
    stroke(baseColor);
    if(id != 0) line(p[id-1].pos.x, p[id-1].pos.y, pos.x, pos.y);
    noStroke();
    fill(currentColor);
    ellipse(pos.x, pos.y, size, size);
  }
}

// General class for buttons ===============================================
class Button {
  int x,y,w,h;
  int id;
  color activeCol,inactiveCol;

  Button(int _x,int _y,int _w,int _h, int _id) {
    x=_x;
    y=_y;
    w=_w;
    h=_h;
	id=_id;
  }

  void setColor(int r1,int g1,int b1, int r2,int g2,int b2) {
    activeCol=color(r1,g1,b1);
    inactiveCol=color(r2,g2,b2);
  }

  void draw() {
		noFill();
		stroke(activeCol);
		line(x,y, x+w,y);
		line(x+w,y, x+w,y+h);
		line(x+w,y+h, x,y+h);
		line(x,y+h, x,y);

	 if(state == id) {
	  fill(activeCol);
      rect(x,y,w,h);
	}
  }

  void check(int mx,int my) {
    if(mx>=x && mx<=x+w && my>=y && my<=my+h) state = id;
  }
}

// General vector class for 2D vectors =====================================
class Vec2D {
  float x,y;

// Constructor with no parameters
  Vec2D() {
    x=0;
    y=0;
  }

  Vec2D(float _x,float _y) {
    x=_x;
    y=_y;
  }

  Vec2D(Vec2D v) {
    x=v.x;
    y=v.y;
  }

  void set(float _x,float _y) {
    x=_x;
    y=_y;
  }

  void set(Vec2D v) {
    x=v.x;
    y=v.y;
  }

  void add(float _x,float _y) {
    x+=_x;
    y+=_y;
  }

  void add(Vec2D v) {
    x+=v.x;
    y+=v.y;
  }

  void sub(float _x,float _y) {
    x-=_x;
    y-=_y;
  }

  void sub(Vec2D v) {
    x-=v.x;
    y-=v.y;
  }

  void mult(float m) {
    x*=m;
    y*=m;
  }

  void div(float m) {
    x/=m;
    y/=m;
  }

  float length() {
    return sqrt(x*x+y*y);
  }

  float angle() {
    return atan2(y,x);
  }

  void normalise() {
    float l=length();
    if(l!=0) {
      x/=l;
      y/=l;
    }
  }

  Vec2D tangent() {
    return new Vec2D(-y,x);
  }

  void rotate(float val) {
    // Due to float not being precise enough, double is used for the calculations
    double cosval=Math.cos(val);
    double sinval=Math.sin(val);
    double tmpx=x*cosval - y*sinval;
    double tmpy=x*sinval + y*cosval;

    x=(float)tmpx;
    y=(float)tmpy;
  }
}