int xSize   = 600;
int ySize   = 400;
int xMid    = xSize/2;
int yMid    = ySize/2;

int tTotal  = 0;
int tMax    = 100;
Tentacle[] tentacle;

Meander meander;

boolean clear = true;
boolean click = false;

int counter = 0;

float myAngle;
float mouseAngle;
float HOffset = 100.0;
float H,S,B,A;

void setup() {
  size(xSize,ySize);
  //smooth();
  colorMode(HSB,360);
  background(166,200,51);
  
  ellipseMode(CENTER_DIAMETER);
  tentacle =  new Tentacle[tMax];
  meander = new Meander(xMid, yMid, 3);

  for (int i=0; i<tMax; i++){
    tentacle[i] = new Tentacle(i);
  }
}
 
void loop() {
  background(166,200,55);
  meander.exist();
  for (int i=0; i<tTotal; i++){
    tentacle[i].exist();
  }
  
  noStroke();

  for (int t=1; t<tTotal; t++){
    beginShape(TRIANGLE_STRIP);
    for (int n=1; n<tentacle[t].numNodes; n++){
      myAngle     = abs(atan2((tentacle[t].y[n] - tentacle[t-1].y[n]), (tentacle[t].x[n] - tentacle[t-1].x[n]))) * 100.0;
      mouseAngle  = abs(atan2((tentacle[t].y[n] - mouseY), (tentacle[t].x[n] - mouseX))) * 100.0;
      H           = myAngle/15.0 + HOffset;
      S           = 150.0;
      B           = 360 - myAngle;
      A           = 100;
      
      if (myAngle > 100 && myAngle < 150){
        B += (25 - abs(125 - myAngle)) * 5.0;
      }
      
      if ((myAngle - mouseAngle) > 90 && (myAngle - mouseAngle) < 140){
        B += (25 - abs(115 - (myAngle - mouseAngle))) * 5.0;
      }
      
      if (n == 1 || t == tTotal-1){
        A = 250;
      }
      
      fill(H,S,B,A);
      vertex(tentacle[t-1].x[n], tentacle[t-1].y[n]);
      
      fill(H,S,B,A);
      vertex(tentacle[t].x[n], tentacle[t].y[n]);
    }
    endShape();
  }

  counter ++;
  
  if(tTotal >= tMax){
    tentacle[tMax-1] = new Tentacle(tMax-1);
    for (int i=1; i<tMax; i++){
      tentacle[i-1] = tentacle[i];
    }
    tTotal = tMax;
  } else {
    tTotal ++;
  }
  
  if (meander.outOfBounds){
    meander.x[0] = xMid;
    meander.x[1] = xMid;
    meander.y[0] = yMid;
    meander.y[1] = yMid;
    
    for (int t=0; t<tTotal; t++){
      tentacle[t].init();
    }
    HOffset = random(300.0) - 100.0;
    meander.outOfBounds = false;
  }
}





class Meander {
  boolean outOfBounds;
  float[] x;
  float[] y;
  float v;
  float xv;
  float yv;
  
  float theta;
  float angle;
  float angleDelta;
  float noiseVal;
  float noiseCount;
  float noiseScale = 0.009;
  
  Meander (int xSent, int ySent, int vSent){
    x = new float[2];
    y = new float[2];
  
    for (int i=0; i<=1; i++){
      x[i] = xSent;
      y[i] = ySent;
    }
    v = vSent;
  }
  
  void exist(){
    findVelocity();
    move();

  }
  
  void findVelocity(){
    noiseCount += noiseScale;
    noiseVal = noise((x[0] + noiseCount) * noiseScale, (y[0] + noiseCount) * noiseScale, noiseCount);
    angle   -= (angle - noiseVal * 1440.0f) * .3f;
    theta    = -radians(angle);
    xv       = cos(theta) * v;
    yv       = sin(theta) * v;
  }
  
  
  void move(){
    x[1] = x[0];
    y[1] = y[0];
    
    if (mousePressed){
      x[0] -= (x[0] - mouseX) * .1;
      y[0] -= (y[0] - mouseY) * .1;
    } else {
      x[0] -= xv;
      y[0] -= yv;
    }
    
    if (x[0] < -150 || x[0] > xSize + 150 || y[0] < -150 || y[0] > ySize + 150){
      outOfBounds = true;
    }
  }
}


class Tentacle {
  int index;

  int numNodes           = 50;
  float head             = 1;
  float girth            = 1;

  float muscleRange      = 45;
  float muscleFreq       = .3;
  
  float theta;
  float thetaMuscle;
  float count = 0;
  float[] x;
  float[] y;
  float tv;
  float angle;
  float xOffset = xMid;
  float yOffset = yMid;
  boolean visible = true;

  Tentacle (int sentIndex) {
    index = sentIndex;
    x = new float[numNodes];
    y = new float[numNodes];
  }

  void exist(){
    if (count == 0){
      init();
    }
    move();
    //render();
  }
  
  void init(){
    x[0] = meander.x[0];
    y[0] = meander.y[0];
    angle = atan2((meander.y[0] - meander.y[1]), (meander.x[0] - meander.x[1]));
      
    for (int i=0; i<numNodes; i++){

      x[i] = meander.x[0];
      y[i] = meander.y[0];
    } 
  }

  void move () {
    girth -= .01;

    angle = atan2((meander.y[0] - meander.y[1]), (meander.x[0] - meander.x[1]));
    x[0]         += head * cos(angle);
    y[0]         += head * sin(angle);
    count        += muscleFreq;
    thetaMuscle   = muscleRange * sin(count);
    x[1]         += (-head * cos((angle + thetaMuscle)));
    y[1]         += (-head * sin((angle + thetaMuscle)));

    for (int i=2; i<numNodes; i++){
      float dx = x[i] - x[i-2];
      float dy = y[i] - y[i-2];
      float d = sqrt(sq(dx) + sq(dy));
  
      float noiseVar = noise((x[i] + meander.noiseCount) * meander.noiseScale, (y[i] + meander.noiseCount) * meander.noiseScale, meander.noiseCount) * 720.0;
      float xVar = cos(radians(noiseVar)) * 3.5;
      float yVar = sin(radians(noiseVar)) * 3.5;
      x[i] -= (x[i] - ((x[i-1] + (dx * girth) / d) + xVar)) * .2;
      y[i] -= (y[i] - ((y[i-1] + (dy * girth) / d) + yVar)) * .2;
      

    }
  }
  
  void render(){  
    noFill();
    beginShape(TRIANGLE_STRIP);
    for (int i=2; i<numNodes; i++){
      float myAngle = atan2((y[i] - y[i-1]), (x[i] - x[i-1]));
      float H = constrain(abs((myAngle * 100.0) - 122), 150, 225);
      float S = 50.0;
      float B = constrain(255 - abs((myAngle * 150.0) - 122), 0, 255);
      float A = 100 - count*10.0;
      //float A = 75;
      
      if (B > 100 && B < 120){
        B = 255;
        A *= 2.0;
      } else if (B > 225 && B < 255){
        H = 150;
        B = 200;
        A *= 2.0;
      } else {
        H = 150;
        B = (B + 50.0)/2.0;
      }
      
      stroke(H,S,B,A);
      vertex(x[i], y[i]);
    }
    endShape();
  }
}