//==========================
class Transmitter extends Defense{
  Transmitter(int gridx, int gridy){
    super( gridx, gridy );
    this.fxZ = 25;
    loadDefense("transmitter");
  }
  //---------------
  void fire(Enemy e){
    cooldownTimer = cooldown + (int)( cooldown*random(-0.2,0.2) );
    e.inflictDamage( attack );
    game.objs.add( new Lightning(this,e) );
  }
}
//==========================
class Trinary extends Defense{
  Trinary(int gridx, int gridy){
    super( gridx, gridy );
    this.fxZ = 25;
    loadDefense("trinary");
  }
  //---------------
  void fire(Enemy e){
    cooldownTimer = cooldown + (int)( cooldown*random(-0.2,0.2) );
    game.objs.add( new Seeker(x,y,z+fxZ,e,attack,splash) );
  }
}
//==========================
class Tesseract extends Defense{
  int seed = 103;
  boolean[][] targetMask;
  Tesseract(int gridx, int gridy){
    super( gridx, gridy );
    this.fxZ = 30;
    loadDefense("tesseract");
    description.technical[1][0] = "coverage";
    description.technical[1][1] = range+"%";
    generateTargetMask();
  }
  //---------------
  void generateTargetMask(){
    // the Tesseract can only hit enemies that are inside the targetMask
    targetMask = new boolean[2*game.terrain.w][2*game.terrain.h];
    randomSeed(seed);
    for(int x=0;x<2*game.terrain.w;x++)
      for(int y=0;y<2*game.terrain.h;y++)
        targetMask[x][y] = random(0,1) < range*0.01;
    // the number in the inequality decides the masks density
  }
  //---------------
  boolean attemptUpgradeRange(){
    if(game.cycles >= 20 && game.memory >= 20){
      game.cycles -= 20;
      game.memory -= 20;
      range += (int)(10 - 0.1*range);
      generateTargetMask();
      return true;
    }
    return false;
  }
  //---------------
  void fire(Enemy e){
    cooldownTimer = cooldown;
    e.inflictDamage( attack );
    game.objs.add( new PhotonicPillar(e.x,e.y) );
    game.objs.add( new PhotonicPillar(x,y) );
  }
  //---------------
  void drawRange(float x, float y){
    fill(255,0,0,64);
    stroke(255,0,0,128);
    fill(192,192,255,64);
    stroke(192,192,255,128);
    int gx = game.terrain.xGrid(x);
    int gy = game.terrain.yGrid(y);
    
    // do not draw if cursor is outside board
    if(gx<1 || gx>=game.terrain.w-1 || gy<1 || gy>=game.terrain.h-1) return;
    
    float x2 = game.terrain.xPos( gx );
    float y2 = game.terrain.yPos( gy );
    pushMatrix();
    translate(0,0,2);
    float cellSize = game.terrain.cellSize;
    Terrain t = game.terrain;
    
    for(int i=0;i<t.w;i++)
      for(int j=0;j<t.h;j++)
        if(targetMask[t.w+i-gx][t.h+j-gy])
          rect( t.xPos(i)-cellSize/2, t.yPos(j)-cellSize/2, t.cellSize, t.cellSize);
    
    popMatrix();
  }
  //---------------
  boolean isWithinRange(Enemy e){
    Terrain t = game.terrain;
    return targetMask[ t.w + t.xGrid(e.x)-gridx ][ t.h + t.yGrid(e.y)-gridy ];
  }
}
//==========================
class Constant extends Defense{
  Constant(int gridx, int gridy){
    super( gridx, gridy );
    this.fxZ = 48;
    loadDefense("constant");
  }
  //---------------
  void fire(Enemy e){
    cooldownTimer = cooldown + (int)( cooldown*random(-0.2,0.2) );
    game.objs.add( new Missile(x,y,z+fxZ,e,attack,splash) );
  }
}
//==========================
class Defense extends Entity{
  int gridx, gridy;
  int range, cooldown, cooldownTimer, cycleValue, memoryValue, cycleCost, memoryCost;
  int attack, slow, splash;
  Defense(int gridx, int gridy){
    this.x = (int) game.terrain.xPos(gridx);
    this.y = (int) game.terrain.yPos(gridy);
    this.gridx = gridx;
    this.gridy = gridy;
    isDefense = true;
    cycleCost = memoryCost = 10;
    cycleValue = memoryValue = 5;
  }
  //---------------
  void update(){
    cooldownTimer = constrain( cooldownTimer-1, 0, cooldown );
    if(cooldownTimer == 0){
      try{
        Enemy e = getEnemyWithinRange() ;
        fire(e);
      } catch(NoEnemyInRangeException noe){}
    }
  }
  //---------------
  Enemy getEnemyWithinRange() throws NoEnemyInRangeException{
    // first get the prioritized enemies
    for(int i=0;i<game.objs.length;i++)
      if( game.objs.get(i).isMarker ){
        Marker mark = (Marker) game.objs.get(i);
          if( isWithinRange( (Enemy) mark.target) )
            return (Enemy) mark.target;
      }
    // secondly get any enemy within range
    for(int i=0;i<game.objs.length;i++)
      if( game.objs.get(i).isEnemy )
        if( isWithinRange( (Enemy) game.objs.get(i)) )
          return (Enemy) game.objs.get(i);
          
    throw new NoEnemyInRangeException();
  }
  //---------------
  boolean isWithinRange(Enemy e){
    return dist(x,y,e.x,e.y)<range;
  }
  //---------------
  void fire(Enemy e){
  }
  //---------------
  void drawRange(){
    drawRange( x, y);
  }
  //---------------
  void drawRange(float x, float y){
    float x2 = game.terrain.xPos( game.terrain.xGrid(x) );
    float y2 = game.terrain.yPos( game.terrain.yGrid(y) );
    fill(0,128,255,32);
    stroke(192,192,255,128);
    pushMatrix();
    translate( x2,y2, 2 );
    ellipse(0,0,range*2,range*2);
    popMatrix();
  }
  //---------------
  void kill(){
    super.kill();
    game.objs.add( new Death(this) );
    game.terrain.groundEntity[gridx][gridy] = null;
  }
  //---------------
  boolean attemptUpgradeAttack(){
    if(game.cycles >= 20 && game.memory >= 10){
      game.cycles -= 20;
      game.memory -= 20;
      attack += attack/5;
      return true;
    }
    return false;
  }
  //---------------
  boolean attemptUpgradeRange(){
    if(game.cycles >= 20 && game.memory >= 20){
      game.cycles -= 20;
      game.memory -= 20;
      range += ((int) sqrt(range)*2 );
      return true;
    }
    return false;
  }
  //---------------
  boolean attemptUpgradeFirerate(){
    if(game.cycles >= 20 && game.memory >= 20){
      game.cycles -= 20;
      game.memory -= 20;
      cooldown -= (cooldown+9)/10;
      return true;
    }
    return false;
  }
  //---------------
  Description getDescription(){
    return description;
  }
  //---------------
  void loadDefense(String filename){
    String[] file = loadStrings("defenses/"+filename+".txt");
    String descAbout="", descHeading="";
    fillColor = color(192,192);
    lineStrokeColor = polyStrokeColor = color(255);

    for(int i=0 ; i<file.length ; i++){
      String[] tmp = split( file[i] , ':' );
      if( tmp[0].equals("name") ) descHeading = trim(tmp[1]);
      if( tmp[0].equals("description") ) descAbout = trim(tmp[1]);
      if( tmp[0].equals("geometry") ) setGeometry( trim(tmp[1]) );
      if( tmp[0].equals("attack") ) attack = Integer.parseInt( trim(tmp[1]) );
      if( tmp[0].equals("slow") ) slow = Integer.parseInt( trim(tmp[1]) );
      if( tmp[0].equals("splash") ) splash = Integer.parseInt( trim(tmp[1]) );
      if( tmp[0].equals("cooldown") ) cooldown = Integer.parseInt( trim(tmp[1]) );
      if( tmp[0].equals("range") ) range = Integer.parseInt( trim(tmp[1]) );
      if( tmp[0].equals("cyclecost") ) cycleCost = Integer.parseInt( trim(tmp[1]) );
      if( tmp[0].equals("memorycost") ) memoryCost = Integer.parseInt( trim(tmp[1]) );
      if( tmp[0].equals("cyclevalue") ) cycleValue = Integer.parseInt( trim(tmp[1]) );
      if( tmp[0].equals("memoryvalue") ) memoryValue = Integer.parseInt( trim(tmp[1]) );
    }
    
    description = new Description();
    description.heading = descHeading;
    description.about = descAbout;
    description.technical = new String[4][2];
    description.technical[0] = new String[]{"attack:", ""+attack};
    description.technical[1] = new String[]{"range:", ""+range};
    description.technical[2] = new String[]{"cooldown:", ""+cooldown};
    description.technical[3] = new String[]{"splash:", ""+splash};
    description.cycleCost = cycleCost;
    description.memoryCost = memoryCost;
    description.cycleValue = cycleValue;
    description.memoryValue = memoryValue;
    description.showAbout = true;
    description.showTechnical = true;
    description.showPrice = true;
  }
}

class NoEnemyInRangeException extends Exception{
}