Menu menu;
Game game;
int mode;
final int MENU=0, GAME=1;
PFont font;
SkanaarKey sk;
void setup(){
  size(600,350,P3D);
  sk = new SkanaarKey();
  menu = new Menu();
  font = loadFont("silkscreen.vlw");
  textFont( font );
  frameRate(20);
}
void initGame(){
  game = new Game();
  game.loadMedia();
  game.loadBoard(0);
  game.loadTemplates();
  game.initGUI();
}
void startGame(){
  mode = GAME;
}
void draw(){
  if(mode==MENU)
    menu.visualize();
  else{
    game.update();
    game.visualize();
  }
}
void mouseReleased(){
  if(mode==MENU)
    menu.mouseReleased( mouseX, mouseY );
  else
    game.mouseReleased( mouseX, mouseY );
}
void keyPressed(){
  sk.keyPressed(key,keyCode);
}
void keyReleased(){
  if(mode==MENU) menu.keyReleased(key, keyCode);
  if(mode==GAME) game.keyReleased(key, keyCode);
  sk.keyReleased(key,keyCode);
}

//==========================
class Game{
  Terrain terrain;
  EntityList objs;
  MediaBank mediabank;
  Button pauseButton, selectButton, defenseCategoryButton, toolCategoryButton, researchCategoryButton, nextBoardButton, restartButton;
  Button[] buttons, masterButtons, defenseButtons, toolButtons, researchButtons;
  Defense transmitter, tesseract, trinary, constant;
  PartialFormatRangeDrawer partialFormat;
  int timer, resourceTimer=0, messageTimer=0, messageFlashTimer=0;
  String message="";
  float rotZ = -PI/8-12*PI/16;
  float rotX = PI/4;
  int cycles, memory, cpus=0, enemySum, enemyCount, boardNumber;
  boolean gameover, victory, paused, lastboard;
  int toolbarX = 580, toolbarY = 35;
  //---------------
  Game(){
  }
  //---------------
  void loadMedia(){
    mediabank = new MediaBank();
    mediabank.loadGeometries();
    mediabank.loadEnemies();
  }
  //---------------
  void initGUI(){
    masterButtons = new Button[7];
    pauseButton = masterButtons[0] = new PauseButton(490,5);
    selectButton = masterButtons[1] = new SelectButton(1580,5);
    defenseCategoryButton = masterButtons[2] = new DefenseButton(toolbarX-20,toolbarY-5);
    toolCategoryButton = masterButtons[3] = new ToolButton(toolbarX-20,toolbarY+16);
    researchCategoryButton = masterButtons[4] = new ResearchButton(toolbarX-20,toolbarY+37);
    nextBoardButton = masterButtons[5] = new NextBoardButton(width/2+75,height/2-11);
    restartButton = masterButtons[6] = new RestartButton(width/2+75,height/2-11);
    restartButton.hide();
    nextBoardButton.hide();

    defenseButtons = new Button[4];
    defenseButtons[0] = new TransmitterButton(toolbarX,toolbarY);
    defenseButtons[1] = new TrinaryButton(toolbarX,toolbarY+20);
    defenseButtons[2] = new TesseractButton(toolbarX,toolbarY+40);
    defenseButtons[3] = new ConstantButton(toolbarX,toolbarY+60);

    toolButtons = new Button[3];
    toolButtons[0] = new RecycleButton(toolbarX,toolbarY);
    toolButtons[1] = new PrioritizeButton(toolbarX,toolbarY+20);
    toolButtons[2] = new PartialFormatButton(toolbarX,toolbarY+40);

    researchButtons = new Button[3];
    researchButtons[0] = new UpgradeAttackButton(toolbarX,toolbarY);
    researchButtons[1] = new UpgradeRangeButton(toolbarX,toolbarY+20);
    researchButtons[2] = new UpgradeFirerateButton(toolbarX,toolbarY+40);

    buttons = new Button[ masterButtons.length + defenseButtons.length + toolButtons.length + researchButtons.length ];
    int i,j,k;
    for(i=0;i<masterButtons.length;i++)
      buttons[i] = masterButtons[i];
    for(j=0;j<defenseButtons.length;j++)
      buttons[i+j] = defenseButtons[j];
    for(k=0;k<toolButtons.length;k++)
      buttons[i+j+k] = toolButtons[k];
    for(int l=0;l<researchButtons.length;l++)
      buttons[i+j+k+l] = researchButtons[l];

    defenseCategoryButton.click();
  }
  //---------------
  void loadTemplates(){
    // the templates contain useful copies of the structures for reference
    transmitter = new Transmitter(0,0);
    trinary = new Trinary(0,0);
    tesseract = new Tesseract(0,0);
    constant = new Constant(0,0);
    partialFormat = new PartialFormatRangeDrawer();
  }
  //---------------
  void loadBoard(int number){
    
    String[] maplist = loadStrings("maps/_maplist.txt");
    String mapname = maplist[ number ];
    if(maplist.length == number+1) lastboard = true;
    
    game.cpus = 0;
    objs = new EntityList();
    terrain = new Terrain("maps/"+mapname+".gif");
    boardNumber = number;
    victory = false;
    enemySum = 0;
    enemyCount = 0;
    
    String mapTitle = "board number "+number;

    int[] enemyList = new int[6];
    int frequency=0,wait=0,x=0,y=0;
    boolean visible = true;
    final int ant=0, spider=1, scorpion=2, mother=3, centipede=4, millipede=5;

    String[] file = loadStrings("maps/"+mapname+".txt");
    int delaySum = 0;

    for(int i=0 ; i<file.length ; i++){
      String[] tmp = split( file[i] , ':' );

      if( tmp[0].equals("title") ) mapTitle = trim(tmp[1]);

      if( tmp[0].equals("initial cycles") ) cycles = Integer.parseInt( trim(tmp[1]) );
      if( tmp[0].equals("initial memory") ) memory = Integer.parseInt( trim(tmp[1]) );

      if( tmp[0].equals("board color") ) {
        int r = Integer.parseInt( trim(tmp[1]) );
        int g = Integer.parseInt( trim(tmp[2]) );
        int b = Integer.parseInt( trim(tmp[3]) );
        terrain.setBoardColor( color(r,g,b) );
      }
      if( tmp[0].equals("path color") ) {
        int r = Integer.parseInt( trim(tmp[1]) );
        int g = Integer.parseInt( trim(tmp[2]) );
        int b = Integer.parseInt( trim(tmp[3]) );
        terrain.setPathColor( color(r,g,b) );
      }
      if( tmp[0].equals("cpu color") ) {
        int r = Integer.parseInt( trim(tmp[1]) );
        int g = Integer.parseInt( trim(tmp[2]) );
        int b = Integer.parseInt( trim(tmp[3]) );
        terrain.setCPUColor( color(r,g,b) );
      }

      if( tmp[0].equals("begin spawnpoint") ) {
        enemyList = new int[6];
        frequency=0;
        wait=0;
        x=0;
        y=0;
        visible = false;
      }
      if( tmp[0].equals("enemy") ) enemyList[ game.mediabank.getEnemyIndex(trim(tmp[1])) ] = Integer.parseInt( trim(tmp[2]) );
      if( tmp[0].equals("1/frequency") ) frequency = Integer.parseInt( trim(tmp[1]) );
      if( tmp[0].equals("delay") ) wait = Integer.parseInt( trim(tmp[1]) );
      if( tmp[0].equals("visible") ) visible = true;
      if( tmp[0].equals("x") ) x = Integer.parseInt( trim(tmp[1]) );
      if( tmp[0].equals("y") ) y = Integer.parseInt( trim(tmp[1]) );

      if( tmp[0].equals("end spawnpoint") ){
        objs.add( new Spawnpoint(x,y,frequency,delaySum,enemyList,visible) );
        // calculate how long it takes to empty the spawnpoint
        // adjust the timers according to how long previous spawnpoints have been active
        int enemyAmount=0;
        for(int j=0;j<enemyList.length;j++)
          enemyAmount += enemyList[j];
        delaySum += wait+frequency*enemyAmount;
        enemySum += enemyAmount;
      }
    }

    postMessage( mapTitle, 1000 );
    //pause();
    //postMessage( "game paused. press play to commence ->", 1000 );
  }
  //---------------
  boolean attemptConstruction(Defense d, int gridx, int gridy){
    if(game.cycles >= d.cycleCost && game.memory >= d.memoryCost){
      if( game.terrain.isCellInsideMap( gridx,gridy ) ){
        if( game.terrain.isCellBuildable( gridx,gridy ) ){
          game.objs.add( d );
          game.terrain.groundEntity[ d.gridx ][ d.gridy ] = d;
          game.cycles -= d.cycleCost;
          game.memory -= d.memoryCost;
          return true;
        }
        else
          postMessage("construction impossible at designated coordinates");
      }
    }
    else
      postMessage("insufficent resources availible for construction");
    return false;
  }
  //---------------
  void pause(){
    paused = true;
    postMessage( "game paused", 15000 );
  }
  //---------------
  void unpause(){
    paused = false;
    postMessage( "game commencing", 30 );
  }
  //---------------
  void gameover(){
    gameover = true;
    restartButton.show();
  }
  //---------------
  void victory(){
    victory = true;
    if(!lastboard) nextBoardButton.show();
  }
  //---------------
  void rewardResources(int cycles, int memory){
    this.cycles += cycles;
    this.memory += memory;
    // the resourceTimer allows the resource-HUD to flash
    if(cycles>0 || memory>0) resourceTimer = 20;
  }
  //---------------
  void postMessage(String msg){
    postMessage(msg, 40);
  }
  //---------------
  void postMessage(String msg, int duration){
    messageFlashTimer = 20;
    messageTimer = duration+20;
    message = msg;
  }
  //---------------
  void update(){
    if(!gameover && !paused && !victory){
      objs.updateAll();
      for(int i=0;i<buttons.length;i++)
        buttons[i].update();
    }

    float rot = PI/64;
    if(sk.keyDown('w')) game.rotX = constrain( game.rotX-rot, 0, HALF_PI);
    if(sk.keyDown('s')) game.rotX = constrain( game.rotX+rot, 0, HALF_PI*15/16);
    if(sk.keyDown('a')) game.rotZ += rot;
    if(sk.keyDown('d')) game.rotZ -= rot;

    // victory and defeat conditions
    enemyCount=0;
    for(int i=0;i<game.objs.objs.size();i++){
      if( game.objs.get(i).isEnemy ) enemyCount++;
      if( game.objs.get(i).isSpawnpoint ) enemyCount+=((Spawnpoint)game.objs.get(i)).amount;
    }
    
    if( cpus<=0 ) gameover();
    else if( enemyCount<=0 ) victory();
  }
  //---------------
  void visualize(){
    if(resourceTimer>0) resourceTimer--;
    if(messageTimer>0) messageTimer--;
    if(messageFlashTimer>0) messageFlashTimer--;

    draw3D();

    if(gameover) drawPopup( "game over" );
    if(victory) drawPopup( "victory" );
    //if(paused) drawPopup( "paused" );

    drawHUD();
  }
  //---------------
  void draw3D(){

    float[] planePoint = game.screenToPlaneCoords(mouseX,mouseY);
    int xGrid = terrain.xGrid(planePoint[0]);
    int yGrid = terrain.yGrid(planePoint[1]);

    pushMatrix();
    translate(width/2,height/2,0);
    rotateX(rotX);
    rotateZ(rotZ);
    //translate(0,0,50);
    background(0);
    terrain.visualize();
    objs.visualizeAll();

    if( terrain.isCellInsideMap(xGrid,yGrid) ){

      if( terrain.isCellBuildable(xGrid,yGrid) ){
        if(defenseButtons[0].selected || defenseButtons[1].selected || defenseButtons[2].selected || defenseButtons[3].selected ){
          float x2 = terrain.xPos( xGrid );
          float y2 = terrain.yPos( yGrid );
          fill(255,128);
          stroke(255,128);
          pushMatrix();
          translate(x2,y2,terrain.cellSize/2-1);
          box(game.terrain.cellSize);
          popMatrix();
        }

        if(defenseButtons[0].selected) transmitter.drawRange(planePoint[0],planePoint[1]);
        else if(defenseButtons[1].selected) trinary.drawRange(planePoint[0],planePoint[1]);
        else if(defenseButtons[2].selected) tesseract.drawRange(planePoint[0],planePoint[1]);
        if(defenseButtons[3].selected) constant.drawRange(planePoint[0],planePoint[1]);
      }
      
      if(toolButtons[2].selected) partialFormat.drawRange(planePoint[0],planePoint[1]);

      else if( terrain.groundEntity[xGrid][yGrid] != null )
        if( terrain.groundEntity[xGrid][yGrid].isDefense )
          ((Defense) terrain.groundEntity[xGrid][yGrid]).drawRange();

    }

    popMatrix();
  }
  //---------------
  void drawHUD(){
    // this function presumes that the transform matrix has been reset
    // hint the renderer to show the hud on top of everything else
    hint(DISABLE_DEPTH_TEST);
    textMode(SCREEN);
    fill(192);
    textAlign( LEFT );

    //HUD level info readout
    roundRect(-1,-1,82,27);
    fill(192);
    text("Board "+boardNumber,5,10);
    text("progress "+(int)(100-enemyCount*100/enemySum)+"%",5,20);

    //message popup
    if(messageTimer>0){
      int msgY = constrain( messageTimer-21, -21, -1 );
      roundRect(130, msgY ,width-2*130,20, lerpColor(color(64), color(192,192,10), messageFlashTimer/20f), color(128) );
      fill(192);
      textAlign( CENTER );
      text(message,width/2,msgY+13);
    }

    //HUD data readout
    textAlign( LEFT );
    roundRect(width-115,-1,150,27, lerpColor(color(64), color(192,192,10), resourceTimer/20f), color(128));
    fill(192);
    text("cycles: "+cycles,width-80,10);
    text("memory: "+memory,width-80,20);

    // the tab menu
    if(defenseCategoryButton.selected) roundRect(toolbarX-5,toolbarY-5,27,6+20*defenseButtons.length);
    if(toolCategoryButton.selected) roundRect(toolbarX-5,toolbarY-5,27,6+20*toolButtons.length);
    if(researchCategoryButton.selected) roundRect(toolbarX-5,toolbarY-5,27,6+20*researchButtons.length);

    for(int i=0;i<masterButtons.length;i++)
      masterButtons[i].visualize();

    for(int i=0;i<defenseButtons.length;i++)
      defenseButtons[i].visualize();

    for(int i=0;i<toolButtons.length;i++)
      toolButtons[i].visualize();

    for(int i=0;i<researchButtons.length;i++)
      researchButtons[i].visualize();
  }
  //---------------
  void roundRect(int x, int y, int w, int h){
    roundRect(x, y, w, h, color(64), color(128));
  }
  //---------------
  void roundRect(int x, int y, int w, int h, color solid, color rim){
    noStroke();
    fill(rim);
    rect(x+1,y,w-2,h);
    rect(x,y+1,w,h-2);
    fill(solid);
    rect(x+1,y+1,w-2,h-2);
  }
  //---------------
  void drawPopup(String s){
    // this function presumes that the transform matrix has been reset
    // hint the renderer to show the hud on top of everything else
    roundRect(width/2-100,height/2-20,200,35);
    fill(192);
    textAlign( LEFT );
    text(s,width/2-(int)textWidth(s)/2,height/2);
  }
  //---------------
  void drawInfowindow(Description description){
    if( description.visible ){

      int yPos = 45, xPos = width-135;
      int winHeight = 20;
      if( description.hotkey!='!' ) winHeight += 20;
      if( description.showTechnical ) winHeight += 10+9*description.technical.length;
      if( description.showPrice ) winHeight += 20;
      if( description.showAbout || !"".equals(description.about) ) winHeight += 80;

      noStroke();
      //fill(0,128);
      //rect(xPos-10,yPos-15,120,200);
      roundRect(xPos-10,yPos-15,100,winHeight);
      textLeading(8);

      fill(255);
      text( description.heading, xPos, yPos);
      yPos += 10;

      fill(192);

      if( description.hotkey!='!' ){
        text( "hotkey: "+description.hotkey, xPos, yPos, 100, height);
        yPos += 20;
      }

      if( description.showTechnical ){
        text( "-- specs -------", xPos, yPos);
        yPos += 10;
        for(int i=0;i<description.technical.length;i++){
          textAlign(LEFT);
          text( description.technical[i][0], xPos, yPos);
          textAlign(RIGHT);
          text( description.technical[i][1], xPos+80, yPos);
          yPos += 9;
        }
        yPos += 10;
      }

      if( description.showPrice ){
        textAlign(LEFT);
        text( "-- cost --------", xPos, yPos);
        text( "cycles: ", xPos, yPos+10);
        textAlign(RIGHT);
        text( description.cycleCost, xPos+80, yPos+10);
        textAlign(LEFT);
        text( "memory: ", xPos, yPos+20);
        textAlign(RIGHT);
        text( description.memoryCost, xPos+80, yPos+20);
        yPos += 30;
      }
      
      if( description.showAbout ){
        textAlign(LEFT);
        text( description.about, xPos, yPos, 80, height);
        yPos += 50;
      }
    }
  }
  //---------------
  void keyReleased(char k, int kc){
    for(int i=0;i<buttons.length;i++)
      buttons[i].keyInput(key);
    if(key=='_') victory();
    if(key=='*') cycles = memory = 1000;
  }
  //---------------
  void mouseReleased(int mx, int my){
    float[] planePoint = game.screenToPlaneCoords(mx,my);
    int gx = game.terrain.xGrid( planePoint[0] );
    int gy = game.terrain.yGrid( planePoint[1] );

    if(mouseButton==LEFT)
      for(int i=0;i<buttons.length;i++)
        buttons[i].mouseInput(mouseX,mouseY);

    if(mouseButton==RIGHT){
      Enemy e = objs.getEnemyAtPoint(planePoint[0],planePoint[1]);
      if(e!=null) objs.add( new Marker(e) );
    }
  }
  //---------------
  float[] screenToPlaneCoords(int mx, int my){
    float[] dir   = vector( 0,0,height/(2*tan(PI/6)) );
    float[] right = vector( width/2, 0, 0 );
    float[] down  = vector( 0,height/2, 0 );

    dir   = rotZ( rotX( dir  , -rotX ), rotZ );
    right = rotZ( rotX( right, -rotX ), rotZ );
    down  = rotZ( rotX( down , -rotX ), rotZ );

    float canvasX = (2*mx-width)/(float)width;
    float canvasY = (2*my-height)/(float)height;
    float vx = dir[0] + canvasX*right[0] + canvasY*down[0];
    float vy = dir[1] + canvasX*right[1] + canvasY*down[1];
    float vz = dir[2] + canvasX*right[2] + canvasY*down[2];

    float t = dir[2] / vz;
    float x = t*vx-dir[0];
    float y = t*vy-dir[1];

    return new float[]{
      x,y                                                                                                  };
  }
  //------------
  float[] vector(float x, float y, float z){
    return new float[]{ 
      x,y,z                                                                                                   };
  }
  //------------
  float[] rotX(float[] v, float angle){
    return vector( v[0], v[1]*cos(angle)+v[2]*sin(angle) , v[1]*-sin(angle)+v[2]*cos(angle) );
  }
  //------------
  float[] rotY(float[] v, float angle){
    return vector( v[0]*cos(angle)+v[2]*sin(angle) , v[1] , v[0]*-sin(angle)+v[2]*cos(angle) );
  }
  //------------
  float[] rotZ(float[] v, float angle){
    return vector( v[0]*cos(angle)+v[1]*sin(angle), v[0]*-sin(angle)+v[1]*cos(angle) , v[2]  );
  }
}