//==========================
class Terrain{
  int w, h;
  int terrainScale, cellSize;
  Entity[][] groundEntity;
  int[][] CPUDist;
  int[][] wallBreakerCPUDist;
  float[][] shading;
  boolean[][] isPath, isCPU, isBoard;
  color pathColor, dmzColor, cpuColor;
  //---------------
  Terrain(String filepath){
    pathColor = color(0,96,128);
    dmzColor = color(32,128,32);
    cpuColor = color(128);

    PImage map = loadImage( filepath );
    w = map.width;
    h = map.height;
    cellSize = 400/16;
    terrainScale = cellSize*w;

    groundEntity = new Entity[w][h];
    shading = new float[w][h];
    CPUDist = new int[w][h];
    wallBreakerCPUDist = new int[w][h];
    isPath = new boolean[w][h];
    isCPU = new boolean[w][h];
    isBoard = new boolean[w][h];

    for(int x=0;x<w;x++)
      for(int y=0;y<h;y++){
        shading[x][y] = random(0.75,1)*0.35;
        isPath[x][y] = ( map.pixels[x+y*w] == color(0) );
        if( map.pixels[x+y*w] == color(255,0,0) ) buildCPU(x,y);
        isBoard[x][y] = ( map.pixels[x+y*w] != color(0,0,255) );
      }

    calculateAIPath();

    for(int x=1;x<w-1;x++)
      for(int y=1;y<h-1;y++)
        shading[x][y] *= 2;//CPUDist[x][y]/16f;
  }
  //---------------
  void setBoardColor(color c){
    dmzColor = c;
  }
  //---------------
  void setPathColor(color c){
    pathColor = c;
  }
  //---------------
  void setCPUColor(color c){
    cpuColor = c;
  }
  //---------------
  void buildCPU(int x, int y){
    CPU c = new CPU( xPos(x),yPos(y), x,y);
    groundEntity[x][y] = c;
    game.objs.add( c );
    isPath[x][y] = true;
    isCPU[x][y] = true;
    CPUDist[x][y] = 0;
  }
  //---------------
  float xPos(int gx){
    return gx*cellSize - cellSize*w/2;
  }
  //---------------
  float yPos(int gy){
    return gy*cellSize - cellSize*h/2;
  }
  //---------------
  int xGrid(float x){
    return (int)( 0.5 + ( x + cellSize*w/2f ) / (float)cellSize );
  }
  //---------------
  int yGrid(float y){
    return (int)( 0.5 + ( y + cellSize*h/2f ) / (float)cellSize );
  }
  //---------------
  boolean isCellBuildable(int gx,int gy){
    if( isCellInsideMap(gx,gy) )
      return !isPath[gx][gy] && groundEntity[gx][gy] == null;
    else
      return false;
  }
  //---------------
  boolean isCellInsideMap(int gx,int gy){
    return (gx>0 && gx<w-1 && gy>0 && gy<h-1);
  }
  //---------------
  void calculateAIPath(){

    // set the borders to infinity+1
    for(int x=0;x<w;x++)
      for(int y=0;y<h;y++)
        if( !isCPU[x][y] ) CPUDist[x][y] = wallBreakerCPUDist[x][y] = 100001;
        
    // initially set all distances to "infinity"
    for(int x=1;x<w-1;x++)
      for(int y=1;y<h-1;y++)
        if( !isCPU[x][y] ) CPUDist[x][y] = wallBreakerCPUDist[x][y] = 100000;

    // first loop, only the paths
    boolean changing = true;
    while( changing ){
      changing = false;
      for(int x=1;x<w-1;x++)
        for(int y=1;y<h-1;y++)
          if( isPath[x][y] ){
            int minDist = min( CPUDist[x][y], CPUDist[x  ][y+1] );
            minDist = min( CPUDist[x  ][y-1], minDist );
            minDist = min( CPUDist[x-1][y  ], minDist );
            minDist = min( CPUDist[x+1][y  ], minDist );

            if( CPUDist[x][y] > minDist+1 ){
              CPUDist[x][y] = minDist+1;
              changing = true;
            }
          }
    }

    // separate loop for the distance matrix for wall-breaking enemies
    changing = true;
    while( changing ){
      changing = false;
      for(int x=1;x<w-1;x++)
        for(int y=1;y<h-1;y++){
          int minDist = min( wallBreakerCPUDist[x][y], wallBreakerCPUDist[x  ][y+1] );
          minDist = min( wallBreakerCPUDist[x  ][y-1], minDist );
          minDist = min( wallBreakerCPUDist[x-1][y  ], minDist );
          minDist = min( wallBreakerCPUDist[x+1][y  ], minDist );

          if( isPath[x][y] ){
            if( wallBreakerCPUDist[x][y] > minDist+1 ){
              wallBreakerCPUDist[x][y] = minDist+1;
              changing = true;
            }
          }
          else if( isBoard[x][y] )
            if( wallBreakerCPUDist[x][y] > minDist+4 ){
              wallBreakerCPUDist[x][y] = minDist+4;
              changing = true;
            }
        }
    }

  }
  //---------------
  void visualize(){
    fill(dmzColor);
    noStroke();

    float offset = -terrainScale/(2f*h);

    for(int x=0;x<w;x++)
      for(int y=0;y<h;y++)
        if(isBoard[x][y]){

        if(isPath[x][y]){
          float s = 0.5+shading[x][y];
          fill( color(s*red(pathColor),s*green(pathColor),s*blue(pathColor) ) );
        }
        else
          fill( color(shading[x][y]*red(dmzColor),shading[x][y]*green(dmzColor),shading[x][y]*blue(dmzColor) ) );

        if(isCPU[x][y])   fill( color(shading[x][y]*red(cpuColor),shading[x][y]*green(cpuColor),shading[x][y]*blue(cpuColor) ) );

        rect( xPos(x)-cellSize/2, yPos(y)-cellSize/2, cellSize, cellSize );

        //fill(255);
        //text( wallBreakerCPUDist[x][y], xPos(x), yPos(y), 2 );

      }

  }
}