dancer a;
dancer b;
dancer d;
dancer e;
dancer f;
dancer g;
dancer u;
dancer v;
formation A;
formation B;
formation C;
formation D;
formation E; 
int speed = 4;
int s = 10; // size of dancers
int m = 40; // no. of panels
boolean nextAction = false;
int start;
int action = 0;

import ddf.minim.*;

AudioPlayer player;
Minim minim;

void setup()
{
  size(screen.width,screen.height);
  background(#a0a0a0);
  a = new dancer(color(50,50,50));
  b = new dancer(color(50,50,50));
  f = new dancer(color(200,0,150));
  g = new dancer(color(100,0,250));
  e = new dancer(color(200,150,0));
  d = new dancer(color(0,250,150));
  u = new dancer(color(200,0,150));
  v = new dancer(color(100,0,250));
  A = new formation();
  B = new formation();
  C = new formation();
  D = new formation();
  E = new formation();
  C.setLeaderFormation(A);
  C.setFollowerFormation(B);
  A.setLeaderDancer(d);
  A.setFollowerDancer(e);
  B.setLeaderDancer(f);
  B.setFollowerDancer(g);
  A.setDir(1);
  B.setDir(1);
  C.setDir(-1);
  
  minim = new Minim(this);
  player = minim.loadFile("nutcracker.mp3");
  player.play();
  player.loop(1);
}

void stop()
{
  player.close();
  minim.stop();
  super.stop();
}

void draw()
{
  background(#a0a0a0);
  D.draw(width/3,height/2,0);
    C.draw(2*width/3,height/2,0);
    E.draw(width/2,-height,0);
  if (frameCount % 107 == 0 && nextAction)
  {
    nextAction = false;
    action++;
    switch(action) {
      case 1:
        C.EckmannHilton();
        break;
      case 2:
        C.EckmannHilton();
        break;
      case 3:
        C.reset(0);
        C.setLeaderDancer(f);
        C.setFollowerDancer(g);
        C.setDir(1);
        D.reset(0);
        D.setLeaderDancer(u);
        D.setFollowerDancer(v);
        D.setDir(1);
        E.setLeaderDancer(e);
        E.setFollowerDancer(d);
        break;
      case 4: 
        C.setLeaderFormation(A);
        C.setFollowerFormation(B);
        A.setLeaderDancer(a);
        A.setFollowerDancer(f);
        B.setLeaderDancer(g);
        B.setFollowerDancer(b);
        C.lineUpChildren();
        A.setDir(-1);
        B.setDir(-1);
        break;
      case 5:
        C.EckmannHilton();
        break;
      case 6:
        C.setLeaderDancer(g);
        C.setFollowerDancer(f);
        E.setLeaderDancer(a);
        E.setFollowerDancer(b);
        break;
      case 7:
        action = 2;
        break;
    }
  }
}

void keyPressed()
{
  switch (key) {
  case 'a':
    speed = speed/2;
    break;
  case 'z':
    speed = speed*2;
    break;
  default:
    nextAction = true;
  }
}

void mousePressed()
{
  nextAction = true;
}


class dancer
{
  float mx; // current coordinate
  float my;
  float mt;
  float d; // direction
  float t; // angle
  float tp; // parent angle
  color c; // colour
  
  dancer(color ic)
  {
    mx = width/2;
    my = 0;
    d = 0;
    t = 0;
    c = ic;
  }
  
  void reset ()
  {
    d = 0;
    t = 0;
  }
  
  void draw(float cx, float cy, float pt)
  {
    float dx = cx - mx;
    float dy = cy - my;
    float dl = sqrt(sq(dx) + sq(dy));
    if (dl > 10) {
      cx = mx + 10*dx/dl;
      cy = my + 10*dy/dl;
    }
    mx = cx;
    my = cy;
    t = t+d/speed;
    noStroke();
    for (int i=0;i<m;i++)
    {
      float a = i;
      a = 2*a;
      a = a%m;
      a = (abs(a - m/2))/(m/2);
      a = sqrt(a);
      color cd = lerpColor(c,#000000,a);
      fill(cd);
      triangle(cx,cy,
      cx+4*s*sin(2*PI*(i+t+pt)/m),cy+4*s*cos(2*PI*(i+t+pt)/m),
      cx+4*s*sin(2*PI*(i+1+t+pt)/m),cy+4*s*cos(2*PI*(i+1+t+pt)/m)
      );
    }
    fill(c);
    ellipse(cx,cy,2*s,2*s);
  }
  
  void setDir(int id)
  {
    d = id % 2;
  }
  
  void toggleDir()
  {
    d = -d;
  }
  
  int qSize ()
  {
    return 1;
  }
}

class formation
{
  float lx; // leader centre
  float ly;
  float fx; // follower centre
  float fy;
  float d; // direction
  float t; // angle
  float tp; // parent angle
  int s; //size
  formation p; // parent formation
  formation l; // leader formation
  formation f; // follower formation
  dancer ld; //lead dancer
  dancer fd; //follow dancer
  boolean leaderIsFormation;
  boolean followerIsFormation;
  boolean hasFollower;
  boolean hasLeader;
    
  void draw(float px, float py, float pt)
  {
    if (!hasFollower || !hasLeader) {
      return;
    }
    t = t+d/speed;
    pt=pt/2;
    lx = px;
    ly = py;
    fx = px + 50*this.qSize()*cos(-2*PI*(t+pt)/m);
    fy = py + 50*this.qSize()*sin(-2*PI*(t+pt)/m);
    if (leaderIsFormation) 
    {
      l.draw(lx,ly,t+pt);
    } else {
      ld.draw(lx,ly,t+pt);
    }
    if (followerIsFormation)
    {
      f.draw(fx,fy,t+pt);
    } else {
      fd.draw(fx,fy,t+pt);
    }

  }
  
  void reset(float rt)
  {
    t = rt;
    d = 0;
  }
  
  void setDir(int id)
  {
    d = id % 2;
  }

  void toggleDir()
  {
    d = -d;
  }

  void setLeaderFormation (formation il)
  {
    leaderIsFormation = true;
    hasLeader = true;
    l = il;
  }
  
  void setFollowerFormation (formation inf)
  {
    followerIsFormation = true;
    hasFollower = true;
    f = inf;
  }
  
  void setLeaderDancer (dancer il)
  {
    leaderIsFormation = false;
    hasLeader = true;
    ld = il;
  }
  
  void setFollowerDancer (dancer inf)
  {
    followerIsFormation = false;
    hasFollower = true;
    fd = inf;
  }
  
  int qSize ()
  {
    int mySize = 0;
    if (hasLeader) {
    if (leaderIsFormation) 
    {
      mySize = l.qSize();
    } else {
      mySize = ld.qSize();
    }
    }
    if (hasFollower) {
    if (followerIsFormation)
    {
      mySize += f.qSize();
    } else {
      mySize += fd.qSize();
    }
    }
    return mySize;
  }

  void toggleLeaderDir ()
  {
    if (leaderIsFormation) 
    {
      l.toggleDir();
    } else {
      ld.toggleDir();
    }
  }
  
  void toggleFollowerDir ()
  {
    if (followerIsFormation) 
    {
      f.toggleDir();
    } else {
      fd.toggleDir();
    }
  }

  void lineUpChildren ()
  {
    if (followerIsFormation)
    {
      f.reset(-t);
    }
    if (leaderIsFormation)
    {
      l.reset(-t);
    }
  }

  void EckmannHilton()
  {
    if (followerIsFormation && leaderIsFormation)
    {
      toggleDir();
      toggleLeaderDir();
      toggleFollowerDir();
      formation leadF = l.f;
      formation follL = f.l;
      dancer leadFd = l.fd;
      dancer follLd = f.ld;
      if (l.followerIsFormation)
      {
        f.setLeaderFormation(leadF);
      } else {
        f.setLeaderDancer(leadFd);
      }
      if (f.leaderIsFormation)
      {
        l.setFollowerFormation(follL);
      } else {
        l.setFollowerDancer(follLd);
      }
    }
  }

}