import java.util.ArrayList;
import java.awt.Rectangle;

public class TrainerField extends BApplet
{
  Avatar avatar;
  float xAngle, yAngle;
  final int BOARD_SIZE = 400;
  boolean[] pressed = new boolean[128];
  ArrayList blocks;
  ArrayList grubs;
  ArrayList tokens;
  ArrayList helpStrings;
  ArrayList startScreenOptions;
  int lives;
  int time;
  int startScreenOption = 0;
  int state;
  int level;
  int levelStartMillis;
  final int GAME = 0;
  final int HELP_SCREEN = 1;
  final int START_SCREEN = 3;
  final int GAME_OVER = 4;

  void setup()
  {
    framerate(24);
    size(600, 400);
    noSmooth();

    state = START_SCREEN;
    tokens = new ArrayList();
    grubs = new ArrayList();
    blocks = new ArrayList();

    helpStrings = new ArrayList();
    helpStrings.add("use w, a, s, and d to move");
    helpStrings.add("");
    helpStrings.add("press space to jump");
    helpStrings.add("");
    helpStrings.add("drag to rotate board");
    helpStrings.add("");
    helpStrings.add("collect the tokens");
    helpStrings.add(" by moving through them");
    helpStrings.add("");
    helpStrings.add("press escape to quit");
    
    startScreenOptions =  new ArrayList();
    startScreenOptions.add("start game");
    startScreenOptions.add("view help");
  }

  void loop()
  {
    background(90);

    switch(state)
    {
      case START_SCREEN:
      drawStartScreen();
      if(pressed[UP] && startScreenOption > 0)
      {
        startScreenOption--;
        pressed[UP] = false;
      }
      if(pressed[DOWN] && startScreenOption < startScreenOptions.size()-1)
      {
        startScreenOption++;
        pressed[DOWN] = false;
      }
      if(pressed[10])
      {
        pressed[10] = false;
        if(startScreenOption == GAME)
        {
          level = 1;
          lives = 4;
          startLevel(level);
        }
        state = startScreenOption;
      }
      break;


      case HELP_SCREEN:
      float y=30;
      stroke(255);
      for(int i=0; i<helpStrings.size(); i++)
      {
        String s = (String)helpStrings.get(i);
        spell(30, y, s, 14, 16);
        y += 22;
      }
      push();
      stroke(0, 255, 0);
      translate(30, y+30);
      rotateX(radians(millis()/10));
      spell(0, -7, "back", 14, 16);
      pop();
      
      if(pressed[10] || mousePressed)
      {
        pressed[10] = false;
        state = START_SCREEN;
      }
      break;


      case GAME:
      time = (50 + (10 * level)) - (millis()-levelStartMillis)/1000;
      push();
      translate(width/2, height/2, 0);
      rotateX(radians(yAngle));
      rotateZ(radians(-xAngle));
      int owned = drawTokens();
      drawGrubs();
      drawBlocks();
      avatar.move();
      avatar.draw();
      spell(-100, 0, "level "+level, 24, 28);
      pop();
      stroke(255);
      spell(10, 10, "lives: "+lives+"  tokens: "+owned+"/"+tokens.size()+"  time: "+time, 10, 14);
      if(tokens.size() == owned)
      {
        level++;
        startLevel(level);
      }
      if(time < 0 || lives < 1 || pressed[27])
      {
        state = GAME_OVER;
      }
      break;



      case GAME_OVER:
      stroke(255);
      spell(29, 180, "game over", 20, 25);
      push();
      stroke(0, 255, 0);
      translate(30, 240);
      rotateX(radians(millis()/10));
      spell(0, -7, "back", 14, 16);
      pop();
      if(pressed[10] || mousePressed)
      {
        pressed[10] = false;
        state = START_SCREEN;
      }
      break;
    }
  }

  void mouseDragged()
  {
    xAngle += (mouseX - pmouseX)/4;
    yAngle -= (mouseY - pmouseY)/4;
  }

  void keyPressed()
  {
    if(key > 0 && key < pressed.length)
    {
      pressed[key] = true;
    }
  }

  void keyReleased()
  {
    if(key > 0 && key < pressed.length)
    {
      pressed[key] = false;
    }
  }

  void drawStartScreen()
  {
    stroke(255);
    spell(60, 100, "welcome to the game", 20, 25);
    for(int i=0; i<startScreenOptions.size(); i++)
    {
      push();
      String s = (String)startScreenOptions.get(i);
      translate(60, 150 + (30*i));
      
      if(startScreenOption == i)
      {
        push();
        stroke(0, 255, 0);
        rotateX(radians(millis()/10));
        spell(0, -10, s, 15, 20);
        pop();
      }
      else
      {
        stroke(255);
        spell(0, -10, s, 15, 20);
      }
      pop();
    }
  }

  void startLevel(int level)
  {
    makeGrubs(level);
    makeBlocks(level*3);
    makeTokens(3+level);
    levelStartMillis = millis();
    reset();
  }

  void reset()
  {
    avatar = new Avatar(0, 0, 100);
    xAngle = 0;
    yAngle = 60;
  }

  void makeTokens(int numTokens)
  {
    tokens.clear();
    for(int i=0; i<numTokens; i++)
    {
      float x, y;
      boolean intersect;

      // Keep creating new tokens until we create one that is not inside a block.
      do {
        x = random(-BOARD_SIZE/2, BOARD_SIZE/2);
        y = random(-BOARD_SIZE/2, BOARD_SIZE/2);
        int j = 1;
        intersect = false;
        while(j<blocks.size() && !intersect)
        {
          Block b = (Block)blocks.get(j);
          intersect = ( distance(x,y,b.x,b.y) < max(b.w, b.h)+20 );
          j++;
        }
      } while(intersect);

      tokens.add(new Token(x,y,0));
    }
  }

  void makeGrubs(int numGrubs)
  {
    grubs.clear();
    for(int i=0; i<numGrubs; i++)
    {
      float x = random(-BOARD_SIZE/2, BOARD_SIZE/2);
      float y = random(-BOARD_SIZE/2, BOARD_SIZE/2);
      grubs.add(new Grub(x,y));
    }
  }

  void makeBlocks(int numBlocks)
  {
    blocks.clear();
    blocks.add(new Block(0, 0, -5, BOARD_SIZE, BOARD_SIZE, 10, color(140, 140, 140)));
    for(int i=0; i<numBlocks; i++)
    {
      Block b;
      boolean intersect;

      // Keep creating new blocks until we create one that does not intersect with any others.
      do {
        float w = random(10, 80);
        float h = random(10, 60);
        float xBuf = (BOARD_SIZE/2)-(w/2);
        float yBuf = (BOARD_SIZE/2)-(h/2);
        float x = random(-xBuf, xBuf);
        float y = random(-yBuf, yBuf);
        float depth = random(10, 40);
        color c = color(random(50, 255), random(100, 255), random(60, 255), 90);
        b = new Block(x, y, (depth/2)-1, w, h, depth, c);

        // Check whether the block intersects with any others.
        int j = 0;
        intersect = false;
        while(j<blocks.size() && !intersect)
        {
          Block other = (Block)blocks.get(j);
          if(b.r.intersects(other.r))
          {
            intersect = true;
          }
          j++;
        }
      } while(intersect);
      blocks.add(b);
    }
  }

  void drawBlocks()
  {
    for(int i=0; i<blocks.size(); i++)
    {
      Block b = (Block)blocks.get(i);
      if(!pressed['h'] || i==0)
      {
        b.draw();
      }
    }
  }

  void drawGrubs()
  {
    for(int i=0; i<grubs.size(); i++)
    {
      Grub g = (Grub)grubs.get(i);
      g.move();
      g.draw();
    }
  }

  int drawTokens()
  {
    int owned = 0;
    for(int i=0; i<tokens.size(); i++)
    {
      Token t = (Token)tokens.get(i);
      if(t.owned)
      {
        owned++;
      }
      if(!pressed['h'])
      {
        t.draw();
      }
    }
    return owned;
  }

  public float distance(float x1, float y1, float x2, float y2)
  {
    return sqrt(sq(x1-x2) + sq(y1-y2));
  }

  class Token
  {
    float x, y, z, radius, i, velocity, h;
    ArrayList points;
    boolean owned;

    public Token(float x, float y, float z)
    {
      this.x = x;
      this.y = y;
      this.z = z;
      this.h = 7;
      owned = false;
      this.velocity = 0;
      points = new ArrayList();
      i = random(100);
      for(int i=0; i < 15; i++)
      {
        float angle = random(360);
        float px = 10 * sin(angle);
        float py = 10 * cos(angle);
        points.add(new Point3D(px, py, random(1,h), angle));
      }
    }

    public void draw()
    {
      i+=5;
      radius = 10 * sin(radians(i));

      if(owned)
      {
        stroke(255, 255, 20);
      }
      else
      {
        stroke(220, 220, 220);
      }

      push();
      translate(x, y, z);
      for(int i=0; i<points.size(); i++)
      {
        Point3D p = (Point3D)points.get(i);
        float angle = p.rotate(random(5,10));
        p.setX(radius * sin(radians(angle)));
        p.setY(radius * cos(radians(angle)));
        line(p.getX()-1, p.getY(), p.getZ(), p.getX()+1, p.getY(), p.getZ());
        line(p.getX(), p.getY()-1, p.getZ(), p.getX(), p.getY()+1, p.getZ());
        line(p.getX(), p.getY(), p.getZ()-1, p.getX(), p.getY(), p.getZ()+1);
      }
      pop();
    }
    public boolean hit(float x, float y, float z)
    {
      return (distance(this.x, this.y, x, y) <= radius+10);
    }
  }

  class Grub
  {
    float x, y, z, w, h, i, wingz, flapSpeed, angle, velocity;
    Point3D destination;
    final int MAX_VELOCITY = 3;

    public Grub(float x, float y)
    {
      this.x = x;
      this.y = y;
      this.z = 7;
      this.w = 16;
      this.h = 10;
      this.i=0;
      this.angle = random(360);
      this.flapSpeed = random(10, 20);
      destination = null;
    }

    public void move()
    {
      wingz = 10 * sin(radians(i));
      i += flapSpeed;

      if(destination != null && distance(destination.getX(), destination.getY(), x, y) < 5)
      {
        destination = null;
      }

      // Loop through all of the tokens and find one to go to.
      for(int i=0; i<tokens.size(); i++)
      {
        Token t = (Token)tokens.get(i);
        if(distance(x, y, t.x, t.y) < 100 && t.owned)
        {
          destination = new Point3D(t.x, t.y, t.z);
        }

        if(t.hit(x, y, z))
        {
          destination = null;
          t.owned = false;
        }
      }

      if(destination == null)
      {
        float rx = random(-BOARD_SIZE/2, BOARD_SIZE/2);
        float ry = random(-BOARD_SIZE/2, BOARD_SIZE/2);
        destination = new Point3D(rx, ry, this.z);
      }

      // Once we have determined our destination...
      float tangent = -degrees(tan((destination.getY() - y) / (destination.getX() - x)));

      if(angle%360 < tangent)
      {
        angle += (tangent-angle)/10;
      }
      if(angle%360 > tangent)
      {
        angle -= (angle-tangent)/10;
      }

      if(velocity < MAX_VELOCITY)
      {
        velocity+= 0.5;
      }

      x += velocity * sin(radians(angle));
      y += velocity * cos(radians(angle));
    }

    public void draw()
    {
      stroke(0);
      fill(50, 200, 200);
      push();
      translate(x, y, z);
      rotate(radians(-angle));
      beginShape(TRIANGLE_STRIP);
      vertex(0, 0, 0);
      vertex(-w/2, h/2, wingz);
      vertex(-w/2, -h/2, wingz);
      endShape();

      beginShape(TRIANGLE_STRIP);
      vertex(0, 0);
      vertex(w/2, h/2, wingz);
      vertex(w/2, -h/2, wingz);
      endShape();

      pop();

      if(destination != null)
      {
        //line(destination.getX(), destination.getY(), this.z, x, y, this.z);
      }
    }
  }

  class Block
  {
    float x, y, z, w, h, depth;
    color c;
    Rectangle r;

    public Block(float x, float y, float z, float w, float h, float depth, color c)
    {
      this.x = x;
      this.y = y;
      this.z = z;
      this.w = w;
      this.h = h;
      this.depth = depth;
      this.c = c;
      this.r = new Rectangle((int)x, (int)y, (int)w, (int)h);
    }

    public boolean hitXY(float x, float y)
    {
      boolean inY = (y > this.y-(h/2) && y < this.y+(h/2));
      boolean inX = (x > this.x-(w/2) && x < this.x+(w/2));
      return (inX && inY);
    }

    public boolean hitZ(float z)
    {
      return (z > this.z-(depth/2) && z < this.z+(depth/2));
    }

    public boolean hit(float x, float y, float z)
    {
      return (hitXY(x, y) && hitZ(z));
    }

    public void draw()
    {
      stroke(40, 40, 40);
      fill(c);
      push();
      translate(x, y, z);
      box(w, h, depth);
      pop();
    }
  }

  class Point3D
  {
    float x, y, z, angle;

    public Point3D(float x, float y, float z)
    {
      this.x = x;
      this.y = y;
      this.z = z;
      this.angle = 0;
    }
    public Point3D(float x, float y, float z, float angle)
    {
      this.x = x;
      this.y = y;
      this.z = z;
      this.angle = angle;
    }
    public float getX()
    {
      return x;
    }
    public float setX(float x)
    {
      this.x = x;
      return x;
    }
    public float getY()
    {
      return y;
    }
    public float setY(float y)
    {
      this.y = y;
      return y;
    }
    public float getZ()
    {
      return z;
    }
    public float setZ(float Z)
    {
      this.z = z;
      return z;
    }
    public float getAngle()
    {
      return angle;
    }
    public float rotate(float inc)
    {
      angle += inc;
      return angle;
    }
  }

  class Avatar
  {
    float x, y, z, angle, velocity, spin, zvel, w, h, d;
    final float MAX_VELOCITY = 5;    // pixels
    final float MAX_SPIN = 8;  // degrees
    final float VELOCITY_INCREMENT = 0.5;
    final float SPIN_INCREMENT = 4;
    ArrayList trail;
    boolean jumping;

    public Avatar(float x, float y, float z)
    {
      this.x = x;
      this.y = y;
      this.z = z;
      this.velocity = 0;
      this.angle = 0;
      this.spin = 0;
      this.zvel = 0;
      this.trail = new ArrayList();
      this.jumping = true;
      this.w = 12;
      this.h = 30;
      this.d = 10;
    }

    public void senseKeys()
    {
      // Update the angle of the avatar.
      if((pressed['a']||pressed[37]) && spin < MAX_SPIN)
      {
        spin += SPIN_INCREMENT;
      }
      if((pressed['d']||pressed[39]) && spin > -MAX_SPIN)
      {
        spin -= SPIN_INCREMENT;
      }
      if((pressed['w']||pressed[38]) && velocity < MAX_VELOCITY)
      {
        if(jumping)
        {
          velocity += VELOCITY_INCREMENT/2;
        }
        else
        {
          velocity += VELOCITY_INCREMENT;
        }
      }
      if((pressed['s']||pressed[40]) && velocity > -MAX_VELOCITY)
      {
        if(jumping)
        {
          velocity -= VELOCITY_INCREMENT/2;
        }
        else
        {
          velocity -= VELOCITY_INCREMENT;
        }
      }
      if(pressed[' '] && !jumping)
      {
        jumping = true;
        zvel+=6;
      }
    }

    public void doFriction()
    {
      if(velocity > 0)
      {
        velocity -= VELOCITY_INCREMENT/2;
      }
      if(velocity < 0)
      {
        velocity += VELOCITY_INCREMENT/2;
      }
      if(spin > 0)
      {
        spin -= SPIN_INCREMENT/2;
      }
      if(spin < 0)
      {
        spin += SPIN_INCREMENT/2;
      }
    }

    public void move()
    {
      doFriction();
      senseKeys();

      angle += radians(spin);

      float newx = x + sin(angle) * velocity;
      float newy = y + cos(angle) * velocity;
      float newz = z + zvel;
      boolean hit = false;

      for(int i=0; i < blocks.size() && !hit; i++)
      {
        Block b = (Block)blocks.get(i);

        if(b.hit(newx, newy, newz))
        {
          hit = true;
          jumping = false;

          if(z >= b.z+(b.depth/2))
          {
            zvel = 0;
            newz = b.z+(b.depth/2);
          }
          else
          {
            newx = x;
            newy = y;
            newz = z;
            velocity *= -1;
          }
        }
      }

      for(int i=0; i<tokens.size(); i++)
      {
        Token t = (Token)tokens.get(i);
        if(t.hit(x, y, z))
        {
          t.owned = true;
        }
      }

      if(!hit && zvel < 10 && zvel > -10)
      {
        zvel -= VELOCITY_INCREMENT;
      }

      x = newx;
      y = newy;
      z = newz;

      if(abs(velocity) > 0.3 || abs(zvel) > 0.3)
      {
        trail.add(new Point3D(x,y,z));
        if(trail.size() > 30)
        {
          trail.remove(0);
        }
      }
      if(z < -300)
      {
        lives--;
        reset();
      }

      if(z > 200)
      {
        zvel = -1;
      }
    }

    public void draw()
    {
      push();
      translate(x, y, z);
      rotate(-angle);
      stroke(100);
      fill(255);

      beginShape(TRIANGLE_STRIP);
      vertex(0, 0, 0);
      vertex(w/2, -(h/2), 0);
      vertex(0, -d, d);
      vertex(0, 0, 0);
      vertex(-(w/2), -(h/2), 0);
      vertex(0, -d, d);
      vertex(0, -d, d);
      vertex(-(w/2), -(h/2), 0);
      vertex((w/2), -(h/2), 0);
      endShape();

      pop();
      for(int i=0; i<trail.size(); i++)
      {
        Point3D p = (Point3D)trail.get(i);
        point(p.getX(), p.getY(), p.getZ());
      }
    }

    public void drawArrow(float alpha)
    {
      stroke(0, 0, 0, alpha);
      line(0, 0, 0, -10);
      line(0, 0, -3, -3);
      line(0, 0, 3, -3);
    }
  }

  public void spell(float x, float y, String s, float w, float h)
  {
    spell(x, y, 0, s, w, h);
  }

  public void spell(float x, float y, float z, String s, float w, float h)
  {
    noFill();
    push();
    translate(x, y, z);
    for(int i=0; i<s.length(); i++)
    {
      float kerning = w+(w/3);
      switch(s.toLowerCase().charAt(i))
      {
        case '/':
        line(w, 0, 0, h);
        break;
        case '?':
        line(0, 0, w, 0);
        line(w, 0, w, h/2);
        line(w/2, h/2, w, h/2);
        line(w/2, h/2, w/2, h-(h/4));
        rect(3*(w/8), h-(w/4), w/4, w/4);
        break;
        case '.':
        rect(0, h-(w/4), w/4, w/4);
        break;
        case ',':
        line(0, h, w/4, h);
        line(w/4, h, w/4, 3*(h/4));
        kerning = w/3;
        break;
        case ':':
        rect(0, h/4, w/4, w/4);
        rect(0, 3*(h/4), w/4, w/4);
        break;
        case ' ':
        kerning = (w/1.5);
        break;
        case '-':
        line(0, h/2, w, h/2);
        break;
        case '1':
        line(w/2, 0, 0, h/3);
        line(w/2, 0, w/2, h);
        line(0, h, w, h);
        break;
        case '2':
        line(0, 0, w, 0);
        line(w, 0, w, h/2);
        line(0, h/2, w, h/2);
        line(0, h/2, 0, h);
        line(0, h, w, h);
        break;
        case '3':
        line(w, 0, w, h);
        line(0, 0, w, 0);
        line(0, h/2, w, h/2);
        line(0, h, w, h);
        break;
        case '4':
        line(w, 0, w, h);
        line(0, 0, 0, h/2);
        line(0, h/2, w, h/2);
        break;
        case '5':
        line(0, 0, w, 0);
        line(0, 0, 0, 2*(h/3));
        line(0, 2*(h/3), w, 2*(h/3));
        line(w, 2*(h/3), w, h);
        line(0, h, w, h);
        break;
        case '6':
        rect(0, h/2, w, h/2);
        line(0, 0, 0, h/2);
        line(0, 0, w, 0);
        break;
        case '7':
        line(0, 0, w, 0);
        line(w, 0, w/2, h);
        break;
        case 'b':
        case '8':
        rect(0, 0, w, h/2);
        rect(0, h/2, w, h/2);
        break;
        case '9':
        rect(0, 0, w, h/2);
        line(w, h/2, w, h);
        break;
        case '0':
        rect(0, 0, w, h);
        line(w, 0, 0, h);
        break;
        case 'a':
        line(0, 0, w, 0);
        line(0, 0, 0, h);
        line(w, 0, w, h);
        line(0, h/2, w, h/2);
        break;
        case 'c':
        line(0, 0, 0, h);
        line(0, 0, w, 0);
        line(0, h, w, h);
        break;
        case 'd':
        line(0, 0, 0, h);
        line(0, 0, 2*(w/3), 0);
        line(2*(w/3), 0, w, h/4);
        line(w, h/4, w, 3*(h/4));
        line(w, 3*(h/4), 2*(w/3), h);
        line(2*(w/3), h, 0, h);
        break;
        case 'e':
        line(0, 0, 0, h);
        line(0, 0, w, 0);
        line(0, h, w, h);
        line(0, h/2, w, h/2);
        break;
        case 'f':
        line(0, 0, 0, h);
        line(0, 0, w, 0);
        line(0, h/2, w, h/2);
        break;
        case 'g':
        line(0, 0, w, 0);
        line(0, 0, 0, w);
        line(w, 0, w, h/4);
        line(0, 0, 0, h);
        line(0, h, 3*(w/4), h);
        line(3*(w/4), h, w, 3*(h/4));
        line(w, 3*(h/4), w, h/2);
        line(w, h/2, w/2, h/2);
        break;
        case 'h':
        line(0, 0, 0, h);
        line(w, 0, w, h);
        line(0, h/2, w, h/2);
        break;
        case 'i':
        line(0, 0, w, 0);
        line(w/2, 0, w/2, h);
        line(0, h, w, h);
        break;
        case 'j':
        line(w, 0, w, h);
        line(0, h, w, h);
        line(0, 2*(h/3), 0, h);
        break;
        case 'k':
        line(0, 0, 0, h);
        line(0, h/2, w, 0);
        line(0, h/2, w, h);
        break;
        case 'l':
        line(0, 0, 0, h);
        line(0, h, w, h);
        break;
        case 'm':
        line(0, 0, w, 0);
        line(0, 0, 0, h);
        line(w, 0, w, h);
        line(w/2, h/3, w/2, 0);
        break;
        case 'n':
        line(0, 0, 0, h);
        line(0, 0, w, h);
        line(w, 0, w, h);
        break;
        case 'o':
        rect(0, 0, w, h);
        break;
        case 'p':
        rect(0, 0, w, h/2);
        line(0, h/2, 0, h);
        break;
        case 'q':
        rect(0, 0, w, h);
        line(3*(w/4), 3*(h/4), w, h);
        break;
        case 'r':
        rect(0, 0, w, h/2);
        line(0, h/2, 0, h);
        line(0, h/2, w, h);
        break;
        case 's':
        line(0, 0, w, 0);
        line(0, 0, 0, h/3);
        line(0, h/3, w, h/3);
        line(w, h/3, w, h);
        line(0, h, w, h);
        break;
        case 't':
        line(0, 0, w, 0);
        line(w/2, 0, w/2, h);
        break;
        case 'u':
        line(0, 0, 0, h);
        line(w, 0, w, h);
        line(0, h, w, h);
        break;
        case 'v':
        line(0, 0, w/2, h);
        line(w, 0, w/2, h);
        break;
        case 'w':
        line(0, 0, 0, h);
        line(w, 0, w, h);
        line(0, h, w, h);
        line(w/2, h/3, w/2, h);
        break;
        case 'y':
        line(0, 0, w/2, h/2);
        line(w, 0, w/2, h/2);
        line(w/2, h/2, w/2, h);
        break;
        default:
        noStroke();
        fill(0);
        rect(0, 0, w, h);
      }
      translate(kerning+1, 0);
    }
    pop();
  }

}