int MAX_TARGETS = 32;
int targetCount = 0;

int MAX_CREEPY_CRAWLIES = 3;
CreepyCrawly[] cc;
Coord2D[] targets; // User-defined spots dropped onto the world.
Coord2D[] randomTargets; // target spots which perform random walk around the world, to be aimed at if no other target presents itself. 1 per creature.
float fRandomWanderDirection = PI;

void setup()
{
  size(400, 400);
  background(255);
  fill(255);
  smooth();
  stroke(0);
  frameRate(25);  
  cc = new CreepyCrawly[MAX_CREEPY_CRAWLIES];
  cc[0] = new CreepyCrawly(8, 20, 50, 10);
  cc[0].SetColor(255, 127, 100);
  
  cc[1] = new CreepyCrawly(10, 300, 250, 6);
  cc[1].SetColor(100, 127, 250);
  
  cc[2] = new CreepyCrawly(6, 100, 400, 6);
  cc[2].SetColor(200, 127, 160);
  
  targets = new Coord2D[MAX_TARGETS];
  randomTargets = new Coord2D[MAX_CREEPY_CRAWLIES];
  for(int i=0; i<MAX_CREEPY_CRAWLIES; i++)
  {
    randomTargets[i] = new Coord2D(random(50, width - 50), random(50, height - 50));
  }
}

void draw()
{
  background(255);
  stroke(0);

  if( mousePressed && targetCount < MAX_TARGETS)
  {
    Coord2D mouseLocation = new Coord2D(mouseX, mouseY);
    targets[targetCount++] = mouseLocation;
  }

  for(int i=0; i<targetCount; i++)
  {
    fill(0);
    ellipse(targets[i].x(), targets[i].y(), 2, 2);
  }

  for(int creature=0; creature < MAX_CREEPY_CRAWLIES; creature++)
  {
    cc[creature].Draw();
    int targetID = 0;
  
    for(int i=0; i<targetCount; i++) // Find the target which is closest to the creature's head.
    {
      if(targets[i].DistanceFrom(cc[creature].HeadLocation()) < targets[targetID].DistanceFrom(cc[creature].HeadLocation()))
      {
        targetID = i;
      }
    }
  
//    println("cc " + creature + ", targetCount = " + targetCount + ", targetID = " + targetID);
    if(targetCount > 0) // If there are targets to move towards, move towards them.
    {
      if(targets[targetID].DistanceFrom(cc[creature].HeadLocation()) > 4)
      { 
        cc[creature].MoveTowards(2, targets[targetID]);
      }
      else // already very close, so eat it.
      {
        for(int i=targetID + 1; i<targetCount; i++)
        {
          targets[i-1] = targets[i];
        }
        targetCount--;
      }
    }
    else // If no clear target, move towards somewhere random which will then move around
    {
      cc[creature].MoveTowards(2, randomTargets[creature]);
      randomTargets[creature].Move(3, fRandomWanderDirection); // move the target a bit for next time.
      fRandomWanderDirection += PI/100;
      if(fRandomWanderDirection >= TWO_PI)
      {
        fRandomWanderDirection -= TWO_PI;
      }
      if(random(100) < 5) // jump it to somewhere totally new
      {
        randomTargets[creature] = new Coord2D(random(width), random(height));
      }
    }
  }
}

class Coord2D
{
  float m_x;
  float m_y;
  
  Coord2D()
  {
    m_x = m_y = 0;
  }
  
  Coord2D(float x, float y)
  {
    m_x = x;
    m_y = y;
  }
  
  float x()
  {
    return m_x;
  }
  
  float y()
  {
    return m_y;
  }
  
  void SetX(float x)
  {
    m_x = x;
  }

  void SetY(float y)
  {
    m_y = y;
  }
  
  float DistanceFrom(Coord2D otherCoord)
  {
    return dist(otherCoord.m_x, otherCoord.m_y, m_x, m_y);
  }
  
  void Move(float fDistance, float fDirection) // direction measured +ve clockwise, zero in +ve y direction.
  {
    m_x += fDistance * sin(fDirection);
    m_y += fDistance * cos(fDirection);
  }
  
  void MoveTowards(float fDistance, Coord2D target)
  {
    float fDirection = atan((target.m_x - m_x) / (target.m_y - m_y));

    if(target.m_y < m_y)
    {
      fDirection += PI;
    }
    
    Move(fDistance, fDirection);
  }
  
}


class CreepyCrawly
{
  int m_BodySegments;
  float[]   m_fBodySegmentRadius;
  Coord2D[] m_BodySegmentLocation;  // Element 0 is the head.
  int m_Red;  int m_Green;  int m_Blue;
  
  CreepyCrawly()
  {
    m_BodySegments = 1;
    m_fBodySegmentRadius = new float[1];
    m_BodySegmentLocation = new Coord2D[1];
    m_Red = m_Green = m_Blue = 0;
  }
  
  CreepyCrawly(int nBodySegments)
  {
    m_BodySegments = nBodySegments;
    m_fBodySegmentRadius = new float[nBodySegments];
    m_BodySegmentLocation = new Coord2D[nBodySegments];
    m_Red = m_Green = m_Blue = 0;
  }
  
  CreepyCrawly(int nBodySegments, float HeadX, float HeadY, float HeadRadius)
  {
    m_BodySegments = nBodySegments;
    m_fBodySegmentRadius = new float[nBodySegments];
    m_BodySegmentLocation = new Coord2D[nBodySegments];
    float fDirection = 0;
    for(int i=0; i<m_BodySegments; i++)
    {
      m_fBodySegmentRadius[i] = HeadRadius;
      m_BodySegmentLocation[i] = new Coord2D();
      if(i==0)
      {
        m_BodySegmentLocation[i].SetX(HeadX);
        m_BodySegmentLocation[i].SetY(HeadY);
      }
      else
      {
        m_BodySegmentLocation[i].SetX(m_BodySegmentLocation[i-1].x());
        m_BodySegmentLocation[i].SetY(m_BodySegmentLocation[i-1].y());
        m_BodySegmentLocation[i].Move(max(m_fBodySegmentRadius[i-1], m_fBodySegmentRadius[i]), fDirection);
        fDirection += PI / 8;
      }
    }
  }
  
  void SetColor(int Red, int Green, int Blue)
  {
    m_Red = Red;
    m_Green = Green;
    m_Blue = Blue;
  }
  
  void Draw()
  {
    fill(m_Red, m_Green, m_Blue);
    for(int i=m_BodySegments-1; i>=0; i--) // Draw from the tail towards the head.
    {
      ellipse(m_BodySegmentLocation[i].x(), m_BodySegmentLocation[i].y(), m_fBodySegmentRadius[i] * 2, m_fBodySegmentRadius[i] * 2);
    }
  }
  
  Coord2D HeadLocation()
  {
    return m_BodySegmentLocation[0];
  }
  
  void MoveTowards(float fDistance, Coord2D target)
  {
    for(int i=0; i<m_BodySegments; i++)
    {
      if(i==0)
      {
//        stroke(0, 0, 128);
//        line(m_BodySegmentLocation[0].m_x, m_BodySegmentLocation[0].m_y, target.m_x, target.m_y);
        m_BodySegmentLocation[i].MoveTowards(fDistance, target);
      }
      else
      {
//        stroke(128, 0, 0);
//        line(m_BodySegmentLocation[i].m_x, m_BodySegmentLocation[i].m_y, m_BodySegmentLocation[i-1].m_x, m_BodySegmentLocation[i-1].m_y);
        if(m_BodySegmentLocation[i].DistanceFrom(m_BodySegmentLocation[i-1]) > max(m_fBodySegmentRadius[i], m_fBodySegmentRadius[i-1]))
        {
          m_BodySegmentLocation[i].MoveTowards(fDistance, m_BodySegmentLocation[i-1]);
        }
      }
    }    
  }
}