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 octopus5 extends BApplet {
//
//
// My degree was in sculpture, so cut me some slack.
// Code is far from optimal.  Any suggestions? robert@flight404.com
//
// Generic Inverse Kinematic Segmented Worms
// Spacebar toggles draw mode.

// Worm( total segments, waveSize, increment, red, green, blue)

int xWidth = 600, yHeight = 600;

int totalWorms = 40;
Worm[] worms;

Meander m1 = new Meander();

boolean clear = true;

void setup() {
  size(600,600);
  noBackground();
  noStroke();
  fill(255,255,255);
  rect(0,0,width,height);
  ellipseMode(CENTER_DIAMETER);
  
  worms = new Worm[totalWorms];
  for (int i=0; i<totalWorms; i++){
    worms[i] = new Worm(150, random(5,100), random(0.04f,0.25f));
  }
  
}
 
void loop() {
  drawState();

  for (int i=0; i<totalWorms; i++){
    worms[i].wriggle();
  }
  
  m1.move();
} 

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

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

class Meander {
  float border = 50;
  float left = border, right = width - border, bottom = border, top = height - border;
  float xMax = 5, yMax = 5;
  float xPos = xWidth/2, yPos = yHeight/2;
  float xLimit, yLimit, xSpeed, ySpeed, xDelta, yDelta;
  
  Meander (){}
  
  void move(){
    if (mousePressed){
      left = mouseX;
      right = mouseX;
      bottom = mouseY;
      top = mouseY;
    } else {
      left = border;
      right = width - border;
      bottom = border;
      top = height - border;
    }
  
  
    if (xPos < left){
      xDelta = random(0,1);
    } else if (xPos > right){
      xDelta = random (-1,0);
    } else {
      xDelta = random(-1,1);
    }
    
    if (yPos < bottom){
      yDelta = random(0,1);
    } else if (yPos > top){
      yDelta = random (-1,0);
    } else {
      yDelta = random(-1,1);
    }
    
    xSpeed = xSpeed + xDelta;
    ySpeed = ySpeed + yDelta;
    
    if (xSpeed > xMax){
      xSpeed = xMax;
    } else if (xSpeed < -xMax){
      xSpeed = -xMax;
    }
    
    if (ySpeed > yMax){
      ySpeed = yMax;
    } else if (ySpeed < -yMax){
      ySpeed = -yMax;
    }
    
    xPos = xPos + xSpeed;
    yPos = yPos + ySpeed;
  }
}     

class Worm {
  int total = 200;
  float counter = 1;                 // counter for sine wave offset
  float increment;                   // increment for counter for sine wave offset
  float waveSize;                    // wave size for sine wave offset
  float[] dist = new float[total];   // array for distance between points
  float[] xPos = new float[total];   // array for x positions
  float[] yPos = new float[total];   // array for y positions
  float xpd, xpd2, ypd, ypd2;        // variables for movePoints()
  float acceleration = .6f;
  float friction = .4f;

  float dx, dy, d;                   // variables for IK within setPoints()
  float xp=xWidth/2, yp=yHeight/2, xp2, yp2;    // variables for elasticity()
  
  Worm (int numOfSegments, float ws, float inc) {
    int total = numOfSegments;
    waveSize = ws;
    increment = inc;
  }

  void wriggle(){
    elasticity();
    movePoints();
    pushArray();
    setPoints();
    drawLine();
  }

  void elasticity(){
    xp2 = xp2 * acceleration + (m1.xPos - xp) * friction;
    yp2 = yp2 * acceleration + (m1.yPos - yp) * friction;
    xp = xp + xp2;
    yp = yp + yp2;
  }
  
  void movePoints(){
    for (int i=1; i<=total-1; i++){
      xpd2 = xpd2 * acceleration + (xPos[i] - xPos[i-1]) * friction;
      ypd2 = ypd2 * acceleration + (yPos[i] - yPos[i-1]) * friction;
      xpd = xpd + xpd2;
      ypd = ypd + ypd2;
      xPos[i] = xpd;
      yPos[i] = ypd;
    }
  }

  void pushArray(){
    for (int i=total-2; i>total/2; i--){
      dist[i+1] = dist[i]*.95f;
    }
    for (int i=total/2; i>0; i--){
      dist[i+1] = dist[i]*1.005f;
    }
    dist[1] = (sin(counter) * 3) + 3.1f;
    counter = counter + increment;
  }

  void setPoints(){
    xPos[0] = xp;
    yPos[0] = yp;
    for (int i=1; i<total; i++){
      dx = xPos[i] - xPos[i-1];
      dy = yPos[i] - yPos[i-1];
      d = sqrt(sq(dx) + sq(dy));

      xPos[i] = xPos[i-1] + dx * (dist[i]) / d;
      yPos[i] = yPos[i-1] + dy * (dist[i]) / d;
    }
  }
  
  void drawLine(){
    for (int i=total-1; i>20; i--){
      stroke(0,0,0);
      point(xPos[i], yPos[i]);
    }
  }
} 

}