////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
///////Dear Marker, this is a little 'table of contents'////////
////////type thing to help you find the lines that you//////////
///////////////need to mark. You're welcome.////////////////////
////////////////////////////////////////////////////////////////
///////------------------------------------------------/////////
///////Player circular movment               | 107-109 /////////
///////Player changes direction on key press | 498     /////////
///////Creation of wormhole                  | 123-145 /////////
///////Collision with wormhole               | 427-432 /////////
///////Size changes of wormhole              | 124-127 /////////
///////Stary background creation             | 400-402 /////////
///////Warping of stars                      | 419-422 /////////
///////Score display                         | 407-410 /////////
///////Parallax of the stars                 | 586-596 /////////
///////warp() function                       | 25-27   /////////
///////blackHoleAt() function                | 29-46   /////////
///////blackHoleAt() calls                   | 489-490 /////////
///////------------------------------------------------/////////
////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////


boolean warp() {
  return playerCollision(wHoles.get(0)); //The first element will always be the original wormhole
}

void blackHoleAt(float holeX, float holeY) { //also handles blcak hole collisions
  BlackHole b = new BlackHole(holeX, holeY);
  b.blit();

  if (playerCollision(b)) {b.onPlayerCollision();}
}


////////////////////////////////////////////////////////
//////////////////////MAIN CLASSES//////////////////////
////////////////////////////////////////////////////////


class Entity { //A base class for everything that will be drawn on screen
  color colour;
  color strk;
  int   strkw;
  float size;
  float posx;
  float posy;


  Entity(float posx_, float posy_, int size_, color colour_, color strk_, int strkw_) {
    posx   = posx_;
    posy   = posy_;
    size   = size_;
    colour = colour_;
    strk   = strk_;
    strkw  = strkw_;
  }

  void update() {} //a function for overriding
  void onPlayerCollision() {}
  void collisions() {}

  void blit() {
    fill(colour);
    strokeWeight(strkw);
    stroke(strk);
    ellipse(posx, posy, size, size);
    update();
  }
}


class Player extends Entity {
  float direction;
  float diameter;
  float speed;
  float jetsAngle;
  int   score;
  int   smoke;

  Entity[] lSmoke;
  Entity[] rSmoke;

  Player(float posx_, float posy_) {
    super(posx_, posy_, 20, color(19,  232, 141), color(188, 198, 255), 4);
    direction = 0.0;
    diameter  = 5.0;
    speed     = 0.03;
    score     = 0;
    smoke     = 20;
    jetsAngle = 0.6;

    lSmoke = new Entity[smoke];
    rSmoke = new Entity[smoke];

    lSmoke[0] = new Entity(posx, posy, smoke, color(188, 198, 255, 0), color(255, 255, 255, 100), 1);
    rSmoke[0] = new Entity(posx, posy, smoke, color(188, 198, 255, 0), color(255, 255, 255, 100), 1);
    for (int i=1; i<smoke; i++) {
      lSmoke[i] = new Entity(posx, posy, smoke-i, color(188, 198, 255, (1-(float(i))/smoke)*150), color(255, 255, 255, 0), 1);
      rSmoke[i] = new Entity(posx, posy, smoke-i, color(188, 198, 255, (1-(float(i))/smoke)*150), color(255, 255, 255, 0), 1);
    }
  }

  void collision() {
    if (player.posx < 0)      {player.posx = width;}
    if (player.posx > width)  {player.posx = 0;}
    if (player.posy < 0)      {player.posy = height;}
    if (player.posy > height) {player.posy = 0;}
  }

  void update() {
    collision();
    posx += diameter * cos(direction);
    posy += diameter * sin(direction);
    direction += speed;
  }

  void blit() {
    float g;
    float a;

    BlackHole b1 = new BlackHole(100.0, 40.0);
    BlackHole b2 = new BlackHole(400.0, 500.0);
    bHoles.add(b1);
    bHoles.add(b2);

    lSmoke[0].posx = posx+(size/4.0*cos(direction+ HALF_PI+jetsAngle));
    lSmoke[0].posy = posy+(size/2*  sin(direction+ HALF_PI+jetsAngle));
    rSmoke[0].posx = posx+(size/4.0*cos(direction-(HALF_PI+jetsAngle)));
    rSmoke[0].posy = posy+(size/2*  sin(direction-(HALF_PI+jetsAngle)));
    lSmoke[0].blit();
    rSmoke[0].blit();
    for (int i=smoke-1; i>0; i--) {
      lSmoke[i].posx = lSmoke[i-1].posx;
      lSmoke[i].posy = lSmoke[i-1].posy;

      rSmoke[i].posx = rSmoke[i-1].posx;
      rSmoke[i].posy = rSmoke[i-1].posy;

      if (i != 0) { //gravity handel
        for (Entity h : bHoles) {
          g = h.size*160/pow(dist(lSmoke[i].posx, lSmoke[i].posy, h.posx, h.posy), 2);
          a = getAngle(int(lSmoke[i].posx), int(lSmoke[i].posy), int(h.posx), int(h.posy));
          lSmoke[i].posx += cos(a)*g;
          lSmoke[i].posy += sin(a)*g;

          g = h.size*160/pow(dist(rSmoke[i].posx, rSmoke[i].posy, h.posx, h.posy), 2);
          a = getAngle(int(rSmoke[i].posx), int(rSmoke[i].posy), int(h.posx), int(h.posy));
          rSmoke[i].posx += cos(a)*g;
          rSmoke[i].posy += sin(a)*g;
        }
        lSmoke[i].blit();
        rSmoke[i].blit();
      }
    }
    bHoles.remove(b1);
    bHoles.remove(b2);

    fill(colour);
    strokeWeight(strkw);
    stroke(strk);
    ellipse(posx, posy, size, size);

    noStroke();
    lSmoke[0].strk = color(255, 255, 255, 0);
    rSmoke[0].strk = color(255, 255, 255, 0);
    lSmoke[0].blit();
    rSmoke[0].blit();
    ellipse(posx, posy, size, size);

    update();
  }

}

class WormHole extends Entity {
  float expansion;

  WormHole(float posx_, float posy_) {
    super(posx_, posy_, 0, color(137, 49, 193), color(46, 100, 70), 3);
    expansion = 1;
  }

  void onPlayerCollision() {
    posx = int(random(width));
    posy = int(random(height));
    shuffleStars();
    player.score += (dificulty+1);
  }

  void update() {
    //the first 2 lines are for linear expansion, the second 2 are for sinosoidal expansion

    //size += expansion;
    //if (size > 80 || size == 0) {expansion *= -1;}
    size = map(sin(expansion), -1, 1, 0, 80);
    expansion += 0.04;

  }

  void blit() {
    float n = 6.0; //how many variations of the colour you get. higher n means smother gradient.

    fill(colour, 0);
    strokeWeight(strkw);
    stroke(strk);
    ellipse(posx, posy, size, size);
    noStroke();
    for (float i=1.0; i<n+1; i++) {
      fill(colour, 70);
      ellipse(posx, posy, (i/n)*size, (i/n)*size);
    }

    update();
  }

}

class BlackHole extends Entity {
  int jiggle1;
  int jiggle2;

  BlackHole(float posx_, float posy_) {
    super(posx_, posy_, (dificulty+3)*13, color(0), color(255), 20+dificulty*5); //the effective size of the hole will be size-strkw
    jiggle1 = int(random(-5, 6));
    jiggle2 = int(random(-5, 6));
  }

  void onPlayerCollision() {state = "dead";}

  void blit() {
    noStroke();
    for (float i=size+strkw; i>0; i--) {
      fill(255, 255, 255, (1-(i/(size+strkw)))*170.0);
      ellipse(posx, posy, i+jiggle1, i+jiggle2);
    }
    fill(0, 0, 0);
    ellipse(posx, posy, size, size);

    update();
  }

  void update() {
    jiggle1 = int(random(-5, 6));
    jiggle2 = int(random(-5, 6));
  }

}

class Star extends Entity {
  int   speedx;
  int   speedy;
  Entity[] tail;

  Star(float posx_, float posy_) {
    super(posx_, posy_, 2, color(255), color(255), 1);
    speedx = 0;
    speedy = 0;
    tail   = new Entity[4];

    for (int i=0; i<tail.length; i++) {
      tail[i] = new Entity(posx, posy, 2, color(255), color(255, 255, 255, 0), 1);
    }
  }

  void collisions() {
    if (posx < 0)      {posx = width;  posy = int(random(height));}
    if (posx > width)  {posx = 0;      posy = int(random(height));}
    if (posy < 0)      {posy = height; posx = int(random(width));}
    if (posy > height) {posy = 0;      posx = int(random(width));}
  }

  void update() {
    posx += speedx;
    posy += speedy;
  }

  void blit() {
    tail[0].posx = posx;
    tail[0].posy = posy;
    tail[0].blit();
    for (int i=tail.length-1; i>0; i--) {
      tail[i].posx = tail[i-1].posx;
      tail[i].posy = tail[i-1].posy;
      tail[i].blit();
    }

    fill(colour);
    noStroke();
    ellipse(posx, posy, size, size);
    update();
    collisions();
  }
}

class Score {
  String name;
  int    score;

  Score(String name_, int score_) {
    name  = name_;
    score = score_;
  }
}

class ScoreList {
  float   posx;
  float   posy;
  float   speed;
  Score[] scores;

  ScoreList(float posx_, float posy_, Score[] scores_) {
    posx   = posx_;
    posy   = posy_;
    scores = scores_;
    speed  = 0;
  }

  void update() {
    posy += speed;

    if (posy > 10) {posy = 10;}
    if (posy < -25*(scores.length)) {posy = -25*(scores.length);}
  }

  void blit() {
    textSize(20);
    fill(255);
    textAlign(LEFT, TOP);
    text("NAME:",  posx,    posy);
    text("SCORE:", posx+70, posy);
    for (int i=0; i<scores.length; i++) {
      text(scores[i].name,  posx,    posy+(25*(i+1)));
      text(scores[i].score, posx+70, posy+(25*(i+1)));
    }
    update();
  }
}

//////////////////////////////////////////////
/////////////////Power Ups////////////////////
//////////////////////////////////////////////

class PowerUp extends Entity {
  char    letter;
  color   letterColour;
  int     lifeSpan;
  int     lifeCount;
  int     effectSpan;
  int     effectCount;
  boolean effective;
  float   rate;

  PowerUp(float posx_, float posy_, char letter_, color letterColour_, float rate_) {
    super(posx_, posy_, 25, color(255, 255, 255, 0), color(200, 255, 0), 3);
    letter       = letter_;
    letterColour = letterColour_;
    lifeSpan     = 60*5; //5 seconds
    lifeCount    = 0;
    effectSpan   = lifeSpan;
    effectCount  = 0;
    effective    = false;
    rate         = rate_;
  }

  void effect(){}
  void defect(){}
  void extra(){}

  void update() {
    if (effective) {
      effectCount++;
      extra();
    }
    else {
      lifeCount++;
    }
  }

  void blit() {
    if (!effective) {
      fill(255, 255, 255, 255/3);
      noStroke();
      arc(posx, posy, size, size, -HALF_PI, (float(lifeCount)/lifeSpan)*TWO_PI-HALF_PI, PIE);

      fill(colour);
      strokeWeight(strkw);
      stroke(strk);
      ellipse(posx, posy, size, size);

      fill(letterColour);
      textSize(15);
      textAlign(CENTER, CENTER);
      text(letter, posx, posy-2);
    }

  update();
  }
}

class SpeedUp extends PowerUp {
  SpeedUp(float posx_, float posy_) {
    super(posx_, posy_, 'F', color(100, 100, 220), 1.7);
  }

  void effect() {
    player.speed    *= rate;
    player.diameter *= rate;
  }

  void defect() {
    player.speed    /= rate;
    player.diameter /= rate;
  }

}

class SlowDown extends PowerUp {
  SlowDown(float posx_, float posy_) {
    super(posx_, posy_, 'S', color(255, 200, 225), 1.7);
  }

  void effect() {
    player.speed    /= rate;
    player.diameter /= rate;
  }

  void defect() {
    player.speed    *= rate;
    player.diameter *= rate;
  }

}

class Reverse extends PowerUp {
  Reverse(float posx_, float posy_) {
    super(posx_, posy_, 'R', color(242, 162, 0), 1);
  }

  void effect() {
    player.speed    *= -rate;
    player.diameter *= -rate;
  }

  void defect() {
    effect();
  }

}

class Grow extends PowerUp {
  Grow(float posx_, float posy_) {
    super(posx_, posy_, 'G', color(40, 215, 230), 15);
  }

  void effect() {
    player.size += rate;
  }

  void defect() {
    player.size -= rate;
  }

}

class Shrink extends PowerUp {
  Shrink(float posx_, float posy_) {
    super(posx_, posy_, 'D', color(100, 40, 230), 15);
  }

  void effect() {
    player.size -= rate;
  }

  void defect() {
    player.size += rate;
  }

}

class Protect extends PowerUp {
  Protect(float posx_, float posy_) {
    super(posx_, posy_, 'P', color(0, 210, 0), 20);
  }

  void extra() {
    fill(0, 0, 0, 0);

    for (float i=0; i<rate; i++) { //draws halo around player
      stroke(0, 210, 0, 12);
      strokeWeight(i);
      ellipse(player.posx-(player.diameter * cos(player.direction)), player.posy-(player.diameter * sin(player.direction)), player.size*2, player.size*2);
    }

    while (playerCollision(new BlackHole(100, 40))) {
      player.update();
    }
    while (playerCollision(new BlackHole(400, 500))) {
      player.update();
    }
    for (Entity hole : bHoles) {
      while (playerCollision(hole)) {
        player.update();
      }
    }
  }
}

class ExtraBHole extends PowerUp {
  BlackHole hole;

  ExtraBHole(float posx_, float posy_) {
    super(posx_, posy_, 'B', color(160, 160, 160), 15);
    hole = new BlackHole(random(width), random(height));
  }

  void effect() {
    bHoles.add(hole);
  }

  void defect() {
    bHoles.remove(hole);
  }
}

class ExtraWHole extends PowerUp {
  WormHole hole;

  ExtraWHole(float posx_, float posy_) {
    super(posx_, posy_, 'W', wHoles.get(0).colour, 15);
    hole = new WormHole(random(width), random(height));
  }

  void effect() {
    wHoles.add(hole);
  }

  void defect() {
    wHoles.remove(hole);
  }
}


//////////////////////////////////////////////
////////////////BUTTON CLASSES////////////////
//////////////////////////////////////////////

class Button {
  int     sizex;
  int     sizey;
  String  textt;
  color   colour;
  boolean hover;

  Button(String textt_, int sizex_, int sizey_) {
    sizex = sizex_;
    sizey = sizey_;
    textt = textt_;
  }

  void update(float posx, float posy) {
    if (mouseX >= posx-sizex/2 && mouseX <= posx+sizex/2 && mouseY >= posy-sizey/2 && mouseY <= posy+sizey/2) {
      colour = color(255, 255, 255, 127);
      if (mouseClick) { //Only executes on mouseClicked as opposed to mousePressed
        exec();
      }
    }
    else {
      colour = color(255, 255, 255, 0);
    }
  }

  void blit(float posx, float posy) {
    update(posx, posy);
    fill(colour);
    stroke(255);
    strokeWeight(3);
    rect(posx-sizex/2, posy-sizey/2, sizex, sizey, 10);

    fill(255);
    textSize(40);
    textAlign(CENTER, CENTER);
    text(textt, posx, posy-7);
  }

  void exec() {
  //This function differes from button to button
  };

}

class AgainButton extends Button {
  AgainButton(String textt_) {
    super(textt_, 150, 50);
  }

  void exec() { //resets the game
    state    = "game";
    player   = new Player(width/2, height/2);
    submited = false;
    powers   = new ArrayList<PowerUp>();
    wHoles.clear();
    bHoles.clear();
    wHoles.add(new WormHole(int(random(width)), int(random(height))));
    shuffleStars();
  }
}

class ExitButton extends Button {
  ExitButton() {
    super("Exit", 150, 50);
  }

  void exec() {
    exit();
  }
}

class StateButton extends Button {
  String newState;
  StateButton(String textt_, String state_) {
    super(textt_, 150, 50);
    newState = state_;
  }

  void exec() {
    state    = newState;
  }
}

class ScoreButton extends Button {
  ScoreButton() {
    super("Scores", 150, 50);
  }

  void exec() {
    state  = "high";
    scores = new ScoreList(width*(2/3.0), 10, quickSort(loadScores()));
  }
}

class SubmitButton extends Button {
  SubmitButton() {
    super("Submit", 170, 50);
  }

  void exec() {
    if (name.length() != 0) {
      submited = true;
      appendToFile("scores.txt", name+'|'+str(player.score));
    }
  }
}

class ChDiffButton extends Button {
  int change;

  ChDiffButton(String textt_, int change_) {
    super(textt_, 30, 50);
    change = change_;
  }

  void exec() {
    dificulty += change;
    if      (dificulty > diffs.length-1) {dificulty = 0;}
    else if (dificulty < 0)              {dificulty = diffs.length-1;}
  }
}



//////////////////////////////////////////////
////////////////MAIN PROGRAM//////////////////
//////////////////////////////////////////////


//globals
String    state     = "menu";
String    name      = "";
String[]  diffs     = {"Easy", "Med", "Hard"};
boolean   submited  = false;
Star[]    stars     = new Star[100];
int       dificulty = 1;
Player    player;
ScoreList scores;

ArrayList <PowerUp> powers = new ArrayList<PowerUp>();
ArrayList <Entity>  bHoles = new ArrayList<Entity>();
ArrayList <Entity>  wHoles = new ArrayList<Entity>();

ArrayList <PowerUp> referances = new ArrayList<PowerUp>();
referances.add(new SpeedUp   (width/3, height-200));
referances.add(new SlowDown  (width/3, height-250));
referances.add(new Reverse   (width/3, height-300));
referances.add(new Shrink    (width/3, height-350));
referances.add(new Grow      (width/3, height-400));
referances.add(new Protect   (width/3, height-450));
referances.add(new ExtraBHole(width/3, height-500));
referances.add(new ExtraWHole(width/3, height-550));

boolean mouseClick;

//constant
String instruction = "You are the pilot of a circular space shuttle that is on a\nmission to enter as many wormholes as possible.\nYour shuttle can only fly in circles, but as the pilot, you\ncan change the direction by pressing any key on your\nkeyboard.\nThe wormhole pulsates (increases and decreases in size)\nso timing is important too.\nReaching the wormhole will increase your score and send\nyou off into a different part of space where the wormhole\nis in a different position.\nBeware though! Space is forever hunted by black holes\nwho’s position never change relative to us due to a tear in\nthe space time continuum.\nRemember that when you hit the edge of space,\nyour shuttle will always appear on the opposite edge.";

//game functions

Score[] loadScores() {
  String[] lines = loadStrings("scores.txt");
  Score[] scores = new Score[lines.length];

  for (int i=0; i<lines.length; i++) {
    String[] t = split(lines[i], "|");
    scores[i]  = new Score(t[0], int(t[1]));
  }
  return scores;
}

float getAngle(int fromx, int fromy, int tox, int toy) {
  int l1 = tox - fromx; //finding the difrence between the 2 points
  int l2 = toy - fromy; //aka fiding the leangth of each line
  float a  = (atan2(l1, l2));
  return a;
}

void appendToFile(String file, String line) {
  String[] lines = loadStrings(file);
  String[] added = new String[lines.length+1];
  arrayCopy(lines, added);
  added[lines.length] = line;
  saveStrings(file, added);
}

void createStars() {
  for (int i=0; i<stars.length  ; i++) {
    stars[i] = new Star(int(random(width)), int(random(height)));
  }
}


void blitScore() {
  fill(255);
  textSize(32);
  textAlign(LEFT, BOTTOM);
  text("Score: "+nf(player.score, 4), 0, height);
}


void blitList(Entity[] entities) {
  for (Entity entity : entities) {
    entity.blit();

    if (playerCollision(entity)) {
      entity.onPlayerCollision();
    }
  }
}

void blitEntity(ArrayList<Entity> entities) {
  for (Entity entity : entities) {
    entity.blit();


    if (playerCollision(entity)) {
      entity.onPlayerCollision();
    }
  }
}

void blitPowers() { //also handles colisions and other power realted stuff. This way I only need to go through the powers array once.
  ArrayList newPowers = new ArrayList(powers);

  for (PowerUp power : powers) {
    power.blit();

    if (!power.effective) {
      if (power.lifeCount >= power.lifeSpan) {
        newPowers.remove(power);
      }
      if (playerCollision(power)) { //power collision
        power.effective = true;
        power.effect();
      }
    }

    if (power.effectCount >= power.effectSpan) {
      power.defect();
      power.effective = false;
      newPowers.remove(power);
    }
  }

  powers = new ArrayList(newPowers);
}

void shuffleStars() { //faster than simply recreating the stars
  for (Star star : stars) {
    star.posx = int(random(width));
    star.posy = int(random(height));
  }
}

void createPowerUp () {
  if (int(random(100)) == 50) {
    int choice = int(random(8));
    switch (choice) {
      case 0:
        powers.add(new SpeedUp   (random(width), random(height))); break;
      case 1:
        powers.add(new SlowDown  (random(width), random(height))); break;
      case 2:
        powers.add(new Reverse   (random(width), random(height))); break;
      case 3:
        powers.add(new Shrink    (random(width), random(height))); break;
      case 4:
        powers.add(new Grow      (random(width), random(height))); break;
      case 5:
        powers.add(new Protect   (random(width), random(height))); break;
      case 6:
        powers.add(new ExtraBHole(random(width), random(height))); break;
      case 7:
        powers.add(new ExtraWHole(random(width), random(height))); break;
    }
  }
}

void checkCollisions() {
  //player collisions with the wormhole
  if (warp()) {
    wHoles.get(0).onPlayerCollision();
  }
}
boolean playerCollision(Entity entity) {
  return dist(player.posx, player.posy, entity.posx, entity.posy) < abs(player.size)/2+entity.size/2;
}

void ensureFile(String name) {
  File fi = new File(sketchPath(name));

  if (!fi.exists()){
    createOutput(name);
  }
}

void blitDiff(float posx, float posy, float sizex, float sizey) {
  fill(255, 255, 255, 0);
  stroke(255);
  strokeWeight(3);
  rect(posx-sizex/2, posy-sizey/2, sizex, sizey, 10);

  fill(255);
  textSize(40);
  textAlign(CENTER, CENTER);
  text(diffs[dificulty], posx, posy-7);
}

//difrent screens
void titleScreen() {
 textAlign(CENTER, TOP);
 textSize(60);
 text("Space Adventures!",              width/2,  height/4);
 new AgainButton("Play!").blit         (width/2,  height/2);
 new ScoreButton().blit                (width/2, (height/2)+70);
 new StateButton("How to", "howt").blit(width/2, (height/2)+140);
 new ExitButton().blit                 (width/2, (height/2)+210);

 blitDiff                      (width*(3/4.0)+40, height/2, 110, 50);
 new ChDiffButton(">", 1).blit (width*(3/4.0)+120, height/2);
 new ChDiffButton("<", -1).blit(width*(3/4.0)-40,  height/2);
}

void gameLoop() {
  player.blit();
  createPowerUp();
  blitEntity(wHoles);
  checkCollisions();
  blitPowers();
  blitScore();
  blitEntity(bHoles);
  blackHoleAt(100.0, 40.0);
  blackHoleAt(400.0, 500.0);

  if (keyPressed) {
    if (key == ESC) {
      key   = 0; //this is to stop it from exiting on escape press
      state = "paus";
    }
    if ("wasdWASD".indexOf(str(key)) == -1) { //don't affect the player when shifiting stars
      player.speed *= -1;
    }
  }
}

void gameOverScreen () {
  textSize(32);
  fill(255);
  textAlign(CENTER, CENTER);
  text("You died with a score of "+str(player.score), width/2, height/3);
  textSize(16);
  text("Type in a 4 letter name to submit a score, if you wish.", width/2, (height/3)+32);
  textSize(50);
  text(name, width/3, (height/2)+30);
  new AgainButton("Again!").blit(width/2,          height*(3/4.0));
  new StateButton("Menu",   "menu").blit (width/4-30,       height*(3/4.0));
  new ExitButton().blit (width*(3/4.0)+30, height*(3/4.0));
  if (submited) {text("Submitted!", width*(2/3.0), (height/2)+30);}
  else {new SubmitButton().blit(width*(2/3.0), (height/2)+30);}

  if (keyPressed) {
    if (key == '\n') {
      if (!submited) {new SubmitButton().exec();}
      else           {new AgainButton("Again!").exec();}
    }
    else if ("abcdefghijklmnopqrstuvwxyz1234567890-_".indexOf(str(key).toLowerCase()) != -1) {
      if (name.length() < 4) {
        name += str(key);
      }
    }
    else if (key == BACKSPACE && name.length() != 0) {
      name = name.substring(0, name.length()-1);
    }
  }
}

void showHighScores() {
  textSize(50);
  fill(255);
  textAlign(CENTER, CENTER);
  text("All scores:", width/4, height/2-50);
  new StateButton("Menu",   "menu").blit    (width/4, height/2+50);
  textSize(20);
  text("(Use arrow keys or scroll wheel)", width/4+3, height/2-10);
  scores.blit();

  if (keyPressed) {
    if (key == CODED) {
      if (keyCode == UP)   {scores.speed = -2;}
      if (keyCode == DOWN) {scores.speed = 2;}
    }
  }
}

void paused() {
  textSize(60);
  fill(255);
  textAlign(CENTER, CENTER);
  text("Game Paused", width/2, height/4);
  new StateButton("Back!", "game").blit(width/2,          height/2);
  new AgainButton("New").blit          (width/2,          height*(3/4.0));
  new StateButton("Menu", "menu").blit (width/4-30,       height*(3/4.0));
  new ExitButton().blit                (width*(3/4.0)+30, height*(3/4.0));

  if (keyPressed) {
    if (key == ESC) {
      key   = 0; //this is to stop it from exiting on escape press
      state = "game";
    }
  }
}

void howTo() {
  textSize(32);
  fill(255);
  textAlign(LEFT, CENTER);
  text("How to play Space Adventures!:", 10, 38);
  textSize(20);
  text(instruction, 10, height/2);
  new StateButton("Menu",   "menu").blit(width/2-100, height-35);
  new StateButton("Powers", "powu").blit(width/2+100, height-35);
}

void powerUpInstruction() {
  textSize(32);
  fill(255);
  textAlign(LEFT, CENTER);
  text("Power up:", 10, 38);
  new SpeedUp   (width/3, height-200).blit();
  new SlowDown  (width/3, height-250).blit();
  new Reverse   (width/3, height-300).blit();
  new Shrink    (width/3, height-350).blit();
  new Grow      (width/3, height-400).blit();
  new Protect   (width/3, height-450).blit();
  new ExtraBHole(width/3, height-500).blit();
  new ExtraWHole(width/3, height-550).blit();

  textSize(20);
  textAlign(LEFT, CENTER);
  fill(255);
  text("Wormhole: Adds a new wormhole", width/2-70, height-200);
  text("Black Hole: Ass a new black hole", width/2-70, height-250);
  text("Protect: Makes you immune to black holes", width/2-70, height-300);
  text("Grow: Makes you bigger", width/2-70, height-350);
  text("Decrease: Makes you smaller", width/2-70, height-400);
  text("Reverse: Reverses your direction", width/2-70, height-450);
  text("Slow: Slows you down", width/2-70, height-500);
  text("Faster: Speeds you up", width/2-70, height-550);

  new StateButton("Menu",  "menu").blit(width/2-100, height-35);
  new StateButton("<Back", "howt").blit(width/2+100, height-35);
}

//processing related functions
void keyPressed() {
  if ((state == "game" || state == "paus") && key == ESC) {
    key = 0; //this is to stop it from exiting ingame insteaed of pausing.
  }

  if (key == 'w') {for (Star star : stars) {star.speedy = 1;}}
  if (key == 'a') {for (Star star : stars) {star.speedx = 1;}}
  if (key == 's') {for (Star star : stars) {star.speedy = -1;}}
  if (key == 'd') {for (Star star : stars) {star.speedx = -1;}}
}

void keyReleased() {
  if (key == 'w') {for (Star star : stars) {star.speedy = 0;}}
  if (key == 'a') {for (Star star : stars) {star.speedx = 0;}}
  if (key == 's') {for (Star star : stars) {star.speedy = 0;}}
  if (key == 'd') {for (Star star : stars) {star.speedx = 0;}}

  if (state == "high" && key == CODED) {
    if (keyCode == UP || keyCode == DOWN) {scores.speed = 0;}
  }
}

void mouseWheel(MouseEvent event) {
  if (state == "high") {scores.posy += event.getCount()*7;}
}

void mouseClicked() {mouseClick = true;}

void setup() {
  frame.setTitle("Space Adventures!");
  smooth();
  size(600, 600);

  ensureFile("scores.txt");

  player   = new Player             (width/2,            height/2);
  wHoles.add(new WormHole(int(random(width)), int(random(height))));

  createStars();
}

void draw() {
  background (0);
  blitList(stars); //NOTE: You can move the stars in any screen ^_^

  if      (state == "game") {gameLoop();}
  else if (state == "dead") {gameOverScreen();}
  else if (state == "menu") {titleScreen();}
  else if (state == "high") {showHighScores();}
  else if (state == "paus") {paused();}
  else if (state == "howt") {howTo();}
  else if (state == "powu") {powerUpInstruction();}

  mouseClick = false;
  keyPressed = false;
}


//Thank you to Thilina's blog for this code snippet!
//https://thilinasameera.wordpress.com/2011/06/01/sorting-algorithms-sample-codes-on-java-c-and-matlab/#_Quick_Sort
//adapted to suit my Score type. Granted I could have done it myself, but why re-invent the wheel?

Score[] quickSort(Score[] data) {
  int lenD = data.length;
  Score pivot;
  int ind = lenD/2;
  int i, j = 0, k = 0;
  if (lenD<2) {
    return data;
  } else {
    Score[] L = new Score[lenD];
    Score[] R = new Score[lenD];
    Score[] sorted = new Score[lenD];
    pivot = new Score(data[ind].name, data[ind].score);
    for (i=0; i<lenD; i++) {
      if (i!=ind) {
        if (data[i].score>pivot.score) {
          L[j] = new Score(data[i].name, data[i].score);
          j++;
        } else {
          R[k] =new Score(data[i].name, data[i].score);
          k++;
        }
      }
    }
    Score[] sortedL = new Score[j];
    Score[] sortedR = new Score[k];
    arraycopy(L, 0, sortedL, 0, j);
    arraycopy(R, 0, sortedR, 0, k);
    sortedL = quickSort(sortedL);
    sortedR = quickSort(sortedR);
    arraycopy(sortedL, 0, sorted, 0, j);
    sorted[j] = pivot;
    arraycopy(sortedR, 0, sorted, j+1, k);
    return sorted;
  }
}