class Water extends Terrain{
  float[][][] flow;
  float[][] froth;
  float step = 0.9;
  float flowDecay = 0.85;
  float addedVolume,volume;
  Terrain terrain;
  final int U=0, L=1;
  //------------
  Water( Terrain t, float pillarHeight ){
    super(t);
    this.terrain = t;
    wireframe = false;
    gouraud = false;
    dynamicTexture = true;
    
    // initialize arrays
    flow = new float[res][res][2];
    for(int x=0;x<res;x++)
      for(int y=0;y<res;y++)
        vertexColor[x][y] = color(0,0,255);

    for(int x=0;x<terrain.res;x++)
      for(int y=0;y<terrain.res;y++)
        heightMap[x][y] = terrain.heightMap[x][y];

    addMoreWater(pillarHeight);
  }
  //------------
  void randomWater(float pillarHeight){
    int spread = 1;
    int px = (int) random(spread,res-spread);
    int py = (int) random(spread,res-spread);
    addMoreWater(px,py,spread,pillarHeight);
  }
  //------------
  void addMoreWater(float pillarHeight){
    addMoreWater( res/2, res/2 ,2,pillarHeight);
  }
  //------------
  void addMoreWater(int px, int py, int spread, float pillarHeight){
    for( int x=px-spread ; x<px+spread ; x++ )
      for( int y=py-spread ; y<py+spread ; y++ ){
        heightMap[x][y] += pillarHeight*spread/(spread+dist(px,py,x,y));
        addedVolume += pillarHeight*spread/(spread+dist(px,py,x,y));
      }
  }
  //------------
  void removeWater(){
    int spread = 5;
    for(int x=res/2-spread;x<res/2+spread;x++)
      for(int y=res/2-spread;y<res/2+spread;y++){
        addedVolume += heightMap[x][y]-terrain.heightMap[x][y];
        heightMap[x][y] = terrain.heightMap[x][y];
      }
  }
  //------------
  float getLevel(int i, int j){
    return max( heightMap[i][j], terrain.heightMap[i][j] );
  }
  //------------
  float getWaterHeight(int x, int y){
    return heightMap[x][y] - terrain.heightMap[x][y];
  }
  //------------
  float getDiff(int x, int y, int dx, int dy){
    return heightMap[x][y] - heightMap[dx][dy];
  }
  //------------
  float sgn(float x){
    return ( x>0 ? 1 : -1 );
  }
  //------------
  void update(){
    volume = 0;
    float diff;
    
    for(int x=0; x<res-1; x++){
      for(int y=0; y<res-1; y++){
        flow[x][y][U] *= flowDecay;
        flow[x][y][L] *= flowDecay;
      }
    }

    // gravity flow
    for(int x=1; x<res-1; x++){
      for(int y=1; y<res-1; y++){
        if( getWaterHeight(x,y) > 0 ){ // water cell
          
          volume += getWaterHeight(x,y); // calculate total volume

          if( 0 < (diff = getDiff(x,y,x,y-1)) )  flow[x][y  ][U] += step*diff/4;
          if( 0 < (diff = getDiff(x,y,x,y+1)) )  flow[x][y+1][U] -= step*diff/4;
          if( 0 < (diff = getDiff(x,y,x-1,y)) )  flow[x  ][y][L] += step*diff/4;
          if( 0 < (diff = getDiff(x,y,x+1,y)) )  flow[x+1][y][L] -= step*diff/4;

        }// endif
      }
    }

    // correct flow
    for(int x=1; x<res-1; x++){
      for(int y=1; y<res-1; y++){
        if( getWaterHeight(x,y)-flow[x][y][U] < 0 || getWaterHeight(x,y-1)+flow[x][y][U] < 0 )
          flow[x][y][U] = sgn(flow[x][y][L]) * min( getWaterHeight(x,y), getWaterHeight(x,y-1) );
        if( getWaterHeight(x,y)-flow[x][y][L] < 0 || getWaterHeight(x-1,y)+flow[x][y][L] < 0 )
          flow[x][y][L] = sgn(flow[x][y][L]) * min( getWaterHeight(x,y), getWaterHeight(x-1,y) );
      }
    }

    // apply flow
    for(int x=1; x<res-1; x++){
      for(int y=1; y<res-1; y++){
        heightMap[x][y  ] -= flow[x][y][U];
        heightMap[x][y-1] += flow[x][y][U];
        heightMap[x  ][y] -= flow[x][y][L];
        heightMap[x-1][y] += flow[x][y][L];
      }
    }
    
    // correct flows and levels
    for(int x=0; x<res-1; x++){
      for(int y=0; y<res-1; y++){
        if( getWaterHeight(x,y) < 0 ){
          heightMap[x][y] = terrain.heightMap[x][y];
          if( flow[x][y][U]>0 ) flow[x][y][U] = 0;
          if( flow[x][y][L]>0 ) flow[x][y][L] = 0;
          if( flow[x][y+1][U]<0 ) flow[x][y+1][U] = 0;
          if( flow[x+1][y][L]>0 ) flow[x+1][y][L] = 0;
        }
      }
    }

    if(gouraud) makeNormals();
  }
  //------------
  float getHeight(int x, int y){
    return ( getWaterHeight(x,y)>0 ? heightMap[x][y] : heightMap[x][y]-4 );
  }
  //------------
  float neighbourWaterVolume(int x, int y){
    return getWaterHeight(x,y-1) + getWaterHeight(x,y+1) + getWaterHeight(x+1,y) + getWaterHeight(x-1,y);
  }
  //------------
  void buildVertexColors(){
    for(int x=1;x<res;x++){
      for(int y=1;y<res;y++){
        if( getWaterHeight(x,y)>0 ){
          float flowSum = abs(flow[x][y][U]) + abs(flow[x][y][L]);
          //shallow streams should be more frothy
          float whiteness = (flowSum) * 512 / min(30,1+getWaterHeight(x,y));
          vertexColor[x][y] = color( whiteness,whiteness,255 );
        }else {
          vertexColor[x][y] = terrain.vertexColor[x][y];
        }
      }
    }
  }
}