class StaticField/*************************************************************/
{
  float value;
  float maxDistance;
  float[][]sField;
  ArrayList doorList;
  ObstacleField oField;
  ArrayList cellsToStartCheck;
  ArrayList cellsWhichHaveToBeChecked;
  
  /************constructor************************************/
  StaticField(int gridColumns, 
              int gridLines,
              ArrayList doorList,
              ObstacleField oField
             )
  {
    this.oField=oField;
    this.doorList=doorList;
    sField = new float[gridColumns][gridLines];
    if (doorList.size()==0)
    {
      for (int i=0; i<getGridColumns(); i++)
      {
        for(int j=0; j<getGridLines(); j++)
        {
        sField[i][j]=1;
        }
      }
    }
    else
    {
    Cell[][] cells = setBeginningCells();
    calculateDistanceToDoors(cellsToStartCheck, cellsWhichHaveToBeChecked);
    sField =getDistancesFromCells(cells);
    }
  }
  
/**************methods***********************************************************************
Cell[][] setBeginningCells()
float[][] getDistancesFromCells( Cell[][] cells )
void setNormalizedDistances( Cell[][] cells )
void calculateDistanceToDoors(ArrayList startCells, ArrayList neighborCells)
Cell[][] generateCellsWithConnections()
void printlnValues()
int getGridColumns()
int getGridLines()
color getBrightness(int i,int j)
float getValue(int x,int y)
*/
 
  Cell[][] setBeginningCells()// *****all cells stored in array************************
  {
    Cell[][] cellArray = generateCellsWithConnections();
    cellsWhichHaveToBeChecked = new ArrayList();
    for (int i=0; i<cellArray.length; i++) 
    {
      for (int k=0; k<cellArray[0].length; k++) {
        // wenn hier eine zelle ist
        if (cellArray[i][k] != null) {
          //nimm sie in die liste auf
          cellsWhichHaveToBeChecked.add( cellArray[i][k] );
        }
      }
    }
  // von diesen zellen wird beim 'füllen' ausgegangen
    cellsToStartCheck = new ArrayList();
    for (int i = 0; i < doorList.size(); i++) 
    {
      Door newDoor= (Door) doorList.get(i);
      int x= newDoor.getX();
      int y= newDoor.getY();
      Cell doorCell=cellArray[x][y];
      
      doorCell.setDistanceToDoor(0);
      cellsToStartCheck.add(doorCell);
      cellsWhichHaveToBeChecked.remove(doorCell);
    }
    
    return cellArray;
  }

  float[][] getDistancesFromCells( Cell[][] cells ) // ***************************************************
  {
    setNormalizedDistances(cells);
    float[][] dist = new float[cells.length][cells[0].length];
    for (int i=0; i<cells.length; i++) 
    {
      for (int k=0; k<cells[0].length; k++) 
      {
        Cell cell = cells[i][k];
        if (cell != null) 
        {
          dist[i][k] = cell.getNormalizedDistanceToDoor();
        } 
        else
        {
          dist[i][k] = -1;
        }
      }
    }
  return dist;
  }
  
  void setNormalizedDistances( Cell[][] cells )// ***************************************************
  {
    maxDistance=-1;                            //calculate maximum distance
    float[][] dist = new float[cells.length][cells[0].length];
    for (int i=0; i<cells.length; i++) 
    {
      for (int k=0; k<cells[0].length; k++) 
      {
        Cell cell = cells[i][k];
        if (cell != null) 
        {
          dist[i][k] = cell.getDistanceToDoor();
          if (dist[i][k]>maxDistance)
          {
          maxDistance=dist[i][k];
          }
        } 
      }
    }
    for (int i=0; i<cells.length; i++)        //set normalized distances for every cell
    {
      for (int k=0; k<cells[0].length; k++) 
      {
        Cell cell = cells[i][k];
        if (cell != null) 
        {
          cell.setNormalizedDistanceToDoor(maxDistance);
        } 
      }
    }
  }

  void calculateDistanceToDoors(ArrayList startCells, ArrayList neighborCells) //*********************
  {
    // wieviele zellen waren beim letzten durchgang noch ungeprŸft
    int uncheckedCellsInLastRound = -1;

    // solange noch zellen nicht geprüft wurden
    // und keine endlosschleife entstanden ist
    while (neighborCells.size() > 0 
      && uncheckedCellsInLastRound!=neighborCells.size()) 
      {

      // speichern der anzahl ungeprüfter zellen
      // stellt sicher, dass keine endlosschleife entsteht
      uncheckedCellsInLastRound = neighborCells.size();
  
      // liste für die Überprüfung im nächsten durchgang
      ArrayList cellsToCheckNext = new ArrayList();

      // alle zellen, die jetzt überprüft werden sollen
      while (startCells.size() > 0) {
        // nimmt die erste zelle aus der liste
        Cell cell = (Cell) startCells.remove(0);
        // nimmt alle nachbarn dieser zelle
        ArrayList neighbours = cell.getNeighbours();
        for (int i = 0; i < neighbours.size(); i++) {
          Cell neighbour = (Cell) neighbours.get(i);
          // wenn der nachbar noch nicht überprüft wurde
          if (neighbour.isInList(neighborCells)) 
          {
            // berechnung türabstand
            float distance = cell.getDistanceToDoor() + 1;
            neighbour.setDistanceToDoor(distance);
            // diese zelle gilt als geprüft
            neighborCells.remove(neighbour);
            // ihre nachbarn werden aber im nächsten durchgang gechecked
            cellsToCheckNext.add(neighbour);
          }
        }
      }

      // cellsToCheck ist jetzt leer
      // alle zellen aus dem 'nachbarCheck' sollen im nächsten
      // durchgang gechecked werden
      startCells.addAll(cellsToCheckNext);
    }
  }


  Cell[][] generateCellsWithConnections() //***********************************************************
  {
    Cell[][] cellArray = new Cell[gridColumns][gridLines];
    for (int i=0; i<gridColumns; i++) 
    {
      for (int k=0; k<gridLines; k++) 
      {
        if (oField.isObstacle(i,k) == false) 
        {
          Cell c = new Cell();
          cellArray[i][k] = c;
        }
      }
    }
    // creating the connections
    // jede zelle wird über ihre unmittelbaren nachbarn informiert
    // ist neben ihr ein obstacle, oder das array-ende
    // hat sie auf dieser seite keinen nachbarn
    for (int i=0; i<cellArray.length; i++) 
    {
      for (int k=0; k<cellArray[0].length; k++) 
      {
        // wenn an dieser stelle im array keine zelle liegt
        // => obstacle
        // dann überspringe diese runde im 'k'-loop
        if (cellArray[i][k] == null) continue;
        Cell cell = cellArray[i][k];
        // loop through directions east, west, north, south
        // add cells to the neighbour list
         int[][] coord = 
        { 
          {-1,  0},
          { 1,  0},
          { 0, -1},
          { 0,  1}
       };
        for (int m=0; m<coord.length; m++) 
        {
        int x = i + coord[m][0];
        int y = k + coord[m][1];
        boolean outOfBounds = (x < 0) || 
                              (x >= cellArray.length) || 
                              (y < 0) || 
                              (y >= cellArray[0].length);
          if ( !outOfBounds ) 
          {
            if (cellArray[x][y] != null) 
            {
              cell.addNeighbour(cellArray[x][y]);
            }
          }
        }
      }
    }
    return cellArray;
  }
  
  
 void printlnValues()//**********************************************************
 {
   NumberFormat nf = NumberFormat.getNumberInstance();
   nf.setMaximumFractionDigits(3);
   nf.setMinimumFractionDigits(3);
   
   for(int i=0; i<gridLines; i++)
   {
     for(int j=0; j<gridColumns; j++)
     {
     print(  nf.format(  sField[j][i]+1 )  +"  ");
     }
     println();
   }
 }
 
 int getGridColumns()//**********************************************************
 {
   return sField.length;
 }
 
 int getGridLines()//**********************************************************
 {
   return sField[0].length;
 }
 
 color getBrightness(int i,int j)//********************************************
 {
   color colour = (color) ((getValue(i,j)/maxDistance*.7+.3)*255);
   return colour;
 }
 
 float getValue(int x,int y)//*************************************************
 {
   return sField[x][y];
 }
  
}