import java.applet.*; 
import java.awt.*; 
import java.awt.image.*; 
import java.awt.event.*; 
import java.io.*; 
import java.net.*; 
import java.text.*; 
import java.util.*; 
import java.util.zip.*; 

public class levitatedTentacle10 extends BApplet {


 
// Set the font and its size (in units of pixels) 

int xWidth = 800, yHeight = 400;

int total = 0;
Tentacle[] tentacle =  new Tentacle[1000];

boolean clear = true;
boolean click = false;

int counter = 0;

void setup() {

  for (int i=0; i<tentacle.length; i++){
    tentacle[i] = new Tentacle();
  }
  size(800,400);
  noBackground();
  noStroke();
  fill(51);
  rect(0,0,width,height);
  ellipseMode(CENTER_DIAMETER);
}
 
void loop() {
  drawState();

  for (int i=0; i<total; i++){
    tentacle[i].move();
  }
} 

void mouseDragged () {
  counter = counter + 1;
  if(total >= 500){
    total = 500;
  } else {
    if (counter > 0){
      counter = 0;
      total = total + 1;
    }
  }
}

void drawState(){
  if (clear){
    fill(51);
    noStroke();
    rect(0,0,width,height);
  }
}

void keyReleased () {
  if (key == ' ' && clear) { 
    clear = false;
  } else if (key == ' ' && !clear) {
    clear = true;
  }
}

class Tentacle {
  int numNodes = 100;
  float head = 1;
  float girth = random(1,2);
  float speedCoefficient = random(0.5f,0.7f);
  float friction = random(0.95f,0.999f);
  float muscleRange = 45;
  float muscleFreq = random(0.005f,0.9f);
  float theta;
  float thetaMuscle;
  float count = 0;
  float xPos, yPos;
  float tv;
  float angle;
  float xOffset = width/2;
  float yOffset = height/2;

  SnakeHead[] node = new SnakeHead[numNodes];

  Tentacle () {

  }

  void move () {
    if(count == 0){
      xPos = mouseX;
      yPos = mouseY;
      for (int n=0; n<numNodes; n++){
        SnakeHead sh = new SnakeHead();   
        node[n] = sh;

        if (n > 0){
          node[n].setX(((pmouseX - mouseX)*(n/numNodes)) + mouseX);
          node[n].setY(((pmouseY - mouseY)*(n/numNodes)) + mouseY);
        } else {
          node[n].setX(mouseX);
          node[n].setY(mouseY);
        }
      } 
      angle = atan2((mouseY-pmouseY), (mouseX-pmouseX));
      theta = angle * (180/PI);
    }
    
    tv = tv + random(-10,10);
    theta = theta + tv;
    tv = tv * friction;
      
    if (node[0].getX() > width*4){
      xPos = xPos - (width*5);
      for (int n=0; n<numNodes; n++){
        node[n].setX(node[n].getX() - (width*5));
      }
    } else if (node[0].getX() < -width*3){
      xPos = xPos + (width*5);
      for (int n=0; n<numNodes; n++){
        node[n].setX(node[n].getX() + (width*5));
      }
    } else {
      node[0].setX(head * cos(PI/180 * theta) + xPos);
      count = count + muscleFreq;
      thetaMuscle = muscleRange * sin(count);
      node[1].setX(-head * cos(PI/180 * (theta+thetaMuscle)) + xPos);
    }
    
    if (node[0].getY() > height*4){
      yPos = yPos - (height*5);
      for (int n=0; n<numNodes; n++){
        node[n].setY(node[n].getY() - (height*5));
      }
    } else if (node[0].getY() < -height*3){
      yPos = yPos + (height*5);
      for (int n=0; n<numNodes; n++){
        node[n].setY(node[n].getY() + (height*5));
      }
    } else {
      node[0].setY(head * sin(PI/180 * theta) + yPos);
      count = count + muscleFreq;
      thetaMuscle = muscleRange * sin(count);
      node[1].setY(-head * sin(PI/180 * (theta+thetaMuscle)) + yPos);
    }
    
    
    for (int i=2; i<numNodes; i++){
      float dx = node[i].getX() - node[i-2].getX();
      float dy = node[i].getY() - node[i-2].getY();
      float d = sqrt(sq(dx) + sq(dy));
      
      node[i].setX(node[i-1].getX() + (dx * girth) / d);
      node[i].setY(node[i-1].getY() + (dy * girth) / d);
      
      if (i == 2){
        xPos = xPos - dx * speedCoefficient;
        yPos = yPos - dy * speedCoefficient;
        
        //if ((xPos<100) || (xPos>500) || (yPos<100) || (yPos>500)){
        //  destroy();
        //}
      }
    }

    for (int i=2; i<numNodes; i++){
      stroke(0,(numNodes-i)*2 + 51,0);
      point(node[i].getX(), node[i].getY());
    }

    noStroke();
    fill(255,255,0);
    ellipse(node[2].getX(), node[2].getY(),2,2);
  }
  
  void destroy () {
    numNodes = 0;
    head = 0;
    girth = 0;
    speedCoefficient = 0;
    friction = 0;
    muscleRange = 0;
    muscleFreq = 0;
    theta = 0;
    node = null;
  }
}

class SnakeHead {
  float x;
  float y;
  float getX () {
    return x;
  }
  float getY () {
    return y;
  }
  void setX (float val) {
    x = val;
  }
  void setY (float val) {
    y = val;
  }
}


}