Fish doodle - OpenProcessing

mySketch
xxxxxxxxxx
 
int[] center = new int[2];
FishPart fishhead;
FishPart[] fishbody = new FishPart[8];
int fishtailLength = 8;
int fishtailSections = 6;
FishPart[] fishtail = new FishPart[fishtailLength * fishtailSections];
int fishfinLowLength = 3;
int fishfinLowSections = 4;
FishPart[] fishfinLow = new FishPart[fishfinLowLength * fishfinLowSections];
int eyeSize = 10;
​
void setup(){
  //size(800, 600);
  fullScreen();
  
  center[0] = width/2;
  center[1] = height/2;
  
  fishhead = new FishPart(center[0], center[1], 6);
  for(int i = 0; i < fishbody.length; i++){
    fishbody[i] = new FishPart(center[0], center[1], int(30 * (sin(i * 0.5) + 1)));
  }
  
  for(int j = 0; j < fishtailSections; j++){
    for(int i = 0; i < fishtailLength; i++){
      fishtail[fishtailLength * j + i] = new FishPart(center[0], center[1], int((30 - j*5) * (sin(i * 0.3) + 1)));
    }
  }
  
  for(int j = 0; j < fishfinLowSections; j++){
    for(int i = 0; i < fishfinLowLength; i++){
      fishfinLow[fishfinLowLength * j + i] = new FishPart(center[0], center[1], int((20 - j*5) * (sin(i * 0.2) + 1)));
    }
  }
  
  //printArray(fishfinLow);
}
​
void draw (){
  background(255);
  stroke(0);
  strokeWeight(2);
  strokeCap(SQUARE);
  noFill();
​
  for(int i = fishbody.length - 1; i >= 0; i--){
    if(i == 0){
      fishbody[i].seek(fishhead.position);
      //fishbody[i].close();
      fishbody[i].display(fishhead.position, fishhead.size);
    } else{
      fishbody[i].seek(fishbody[i-1].position);
      fishbody[i].display(fishbody[i - 1].position, fishbody[i - 1].size);
    }
    fishbody[i].update();
  }
  
  for(int j = 0; j < fishtailSections; j++){
    for(int i = fishtailLength - 1; i >= 0; i--){
      if(i == 0){
        fishtail[fishtailLength * j + i].seek(fishbody[fishbody.length - 1].position);
        fishtail[fishtailLength * j + i].display(
          fishbody[fishbody.length - 1].position, 
          fishbody[fishbody.length - 1]. size - j * 3);
      } else{
        fishtail[fishtailLength * j + i].seek(fishtail[i-1].position);
        fishtail[fishtailLength * j + i].display(
          fishtail[fishtailLength * j + i - 1].position, 
          fishtail[fishtailLength * j + i - 1].size);
      }
      //fishtail[fishtailLength * j + i].turbulence();
      fishtail[fishtailLength * j + i].sine(i);
      fishtail[fishtailLength * j + i].update();
    }
  }
  
  for(int j = 0; j < fishfinLowSections; j++){
    for(int i = fishfinLowLength - 1; i >= 0; i--){
      if(i == 0){
        float finOffset = 0;
        if(fishhead.position.x < fishbody[1].position.x - 1){
          finOffset = fishbody[2].size / 3;
        }
        if(fishhead.position.x > fishbody[1].position.x + 1){
          finOffset = -fishbody[2].size / 3;
        }
        PVector target = new PVector(
          fishbody[2].position.x + finOffset,
          fishbody[2].position.y + fishbody[2].size / 2);
        fishfinLow[fishfinLowLength * j + i].seek(target);
        fishfinLow[fishfinLowLength * j + i].display(target, fishbody[2].size / 3 - (j + 1) * 3);
      } else{
        fishfinLow[fishfinLowLength * j + i].seek(fishfinLow[i-1].position);
        fishfinLow[fishfinLowLength * j + i].display(
          fishfinLow[fishfinLowLength * j + i - 1].position, 
          fishfinLow[fishfinLowLength * j + i - 1].size);
      }
      //fishfinLow[fishfinLowLength * j + i].turbulence();
      fishfinLow[fishfinLowLength * j + i].sine(i);
      fishfinLow[fishfinLowLength * j + i].update();
    }
  }
  
  PVector mousePos = new PVector(mouseX, mouseY);
  fishhead.seek(mousePos);
  fishhead.close(mousePos);
  fishhead.update();
  
  float eyeSizeScaled = abs(fishhead.position.x - fishbody[1].position.x) < eyeSize ? 
    eyeSizeScaled = abs(fishhead.position.x - fishbody[1].position.x):
    eyeSize;
  if(fishhead.position.x < fishbody[1].position.x - 1){
    ellipse(fishbody[1].position.x + eyeSize, fishbody[1].position.y - eyeSize * 2, eyeSizeScaled, eyeSize);
  }
  if(fishhead.position.x > fishbody[1].position.x + 1){
    ellipse(fishbody[1].position.x - eyeSize, fishbody[1].position.y - eyeSize * 2, eyeSizeScaled, eyeSize);
  }
}
​
class FishPart {
  PVector position;
  PVector velocity;
  PVector acceleration;
  int size;
  float maxspeed;
  float maxforce;
​
  FishPart(int posX, int posY, int _size) {
    position = new PVector(posX, posY);
    velocity = new PVector(0, 0);
    acceleration = new PVector(0, 0);
    size = _size;
    maxspeed = 3;
    maxforce = 0.1;
  }
​
  void update() {
    velocity.add(acceleration);
    position.add(velocity);
    acceleration.mult(0);
  }
​
  void applyForce(PVector force) {
    acceleration.add(force);
  }
​
​
  void seek(PVector target) {
    PVector desired = PVector.sub(target, position);  // A vector pointing from the position to the target  
    float d = desired.mag();
    if(d < size/2){
      float m = map(d, 0, size/2, 0, maxspeed);
      desired.setMag(m);
    } else{
      desired.setMag(maxspeed);
    }
​
    PVector steer = PVector.sub(desired, velocity);
    steer.limit(maxforce);
    applyForce(steer);
  }
  
  void turbulence(){
    position.x += (-0.5 + noise(position.x, size, millis() * 0.001)) * 3;
    position.y += (-0.5 + noise(position.y, size, millis() * 0.001)) * 3;
  }
  
  void sine(int offset){
    float movX = sin(millis() * 0.002 + offset + 200) * 0.5;
    position.x += movX;
    float movY = sin(millis() * 0.001 + offset);
    position.y += movY;
  }
​
  void display(PVector targetPos, float targetScale) {
    line(position.x, position.y + size, targetPos.x, targetPos.y + targetScale);
    line(position.x, position.y - size, targetPos.x, targetPos.y - targetScale);
    //point(position.x, position.y + size);
    //point(position.x, position.y - size);
    if(position.x > targetPos.x + 1){
      line(position.x + size/2, position.y, targetPos.x + targetScale/2, targetPos.y);
      //point(position.x + size/2, position.y);
    }
    if(position.x < targetPos.x - 1){
      line(position.x - size/2, position.y, targetPos.x - targetScale/2, targetPos.y);
      //point(position.x - size/2, position.y);
    }
  }
  
  void close(PVector target) {
    int dir = position.x > target.x ? 1 : -1;
    line(position.x, position.y + size, position.x, position.y - size);
    line(position.x + size/2 * dir, position.y, position.x, position.y);
  }
}