/*
 * LifeGrid.java - Java class for the simulation grid in the jlife applet.
 *                 Utilizes the LifeCell class.
 *
 * Author : Jeff Mercer
 * Written: 7/23/99
 * Updated: 8/10/99
 * JDK Ver: 1.1.8
 *
 * Purpose: A relatively complex class for the grid that makes up the universe
 *          in a Life simulation. This provides the essential methods for
 *          managing the grid contents and the simulation itself. The LifeCell
 *          class is used for the contents of the simulation grid.
 * 
 * Copyright 1999 by Jeff C. Mercer. All rights reserved.
 * This program may be freely distributed and used for non-profit purposes.
 * For commercial or business usage, please contact the author.
 */

/************************************
 * Import necessary external classes.
 ************************************/

import java.awt.*;
import LifeCell;

public class LifeGrid
{
/**********************************
 * Data member for LifeGrid class.
 **********************************/

  final int DEAD=0;			// Constant for dead state value.
  final int ALIVE=1;		// Constant for living state value.
  final int MIN_GRIDSIZE=4;	// Minimum size for the grid.
  final int MAX_GRIDSIZE=512;	// Maximum size for the grid.
  final int DEFAULT_GRIDSIZE=64;	// Default size for the grid.

  private long popCount;		// Population counter.
  private long genCount;		// Generation counter.
  private int gridSize;		// Size of grid (for both dimensions).
  private LifeCell gridCell[][];	// Two-dimensional array of cells.

/***********************************
 * Constructors for LifeGrid class.
 ***********************************/

  // For when no parameter given.
  public LifeGrid()
  {
    // Generic indexer variables.
    int x, y;

    // Set size of grid to class default.
    gridSize=DEFAULT_GRIDSIZE;

    // Create space for two-dimensional array (grid) of cell objects. This
    // just reserves the space, the objects do not exist yet!
    gridCell=new LifeCell[gridSize][gridSize];

    // Go through grid array and create each element's object.
    for (x=0; x<gridSize; x++)
      for (y=0; y<gridSize; y++)
        gridCell[x][y]=new LifeCell();

    // Update grid's attributes.
    genCount=0;
    popCount=0;
  }

  // For when size parameter given.
  public LifeGrid(int sz)
  {
    // Generic indexer variables.
    int x, y;

    // Sanity check: Make sure the given size is within acceptable parameters...
    if (sz<MIN_GRIDSIZE || sz>MAX_GRIDSIZE)
      gridSize=DEFAULT_GRIDSIZE;	// If not, set grid size to class default.
    else
      gridSize=sz;			// Otherwise, set grid size to given value.

    // Create space for two-dimensional array (grid) of cell objects. This
    // just reserves the space, the objects do not exist yet!
    gridCell=new LifeCell[gridSize][gridSize];

    // Step through grid array...
    for (x=0; x<gridSize; x++)
      for (y=0; y<gridSize; y++)
        // ...and create each element's object.
        gridCell[x][y]=new LifeCell();

    // Update grid's attributes
    genCount=0;
    popCount=0;
  }

/********************************
 * Methods of the LifeGrid class
 ****************************************************************************/

  // Count the number of living neighbors of a specified cell in the grid
  // array. An integer value from 0 to 8 is returned.
  private int countNeighbors(int cellX, int cellY)
  {
    // Generic indexer variables.
    int cx, cy, x, y;

    // For counting neighbors.
    int count=0;

    // Go through the block of cells which are target is the center of.
    for (x=cellX-1; x<cellX+2; x++)
      for (y=cellY-1; y<cellY+2; y++)
      {
        // Copy current index values to holder variables.
        cx=x; cy=y;

        // If the X-axis co-ordinate is too low...
        if (cx<0)
          // ...wrap around to other side.
          cx=gridSize-1;
        else
          // If the X-axis co-ordinate is too high...
          if (cx>gridSize-1)
            // ...wrap around to other side.
            cx=0;

        // If the Y-axis co-ordinate is too low...
        if (cy<0)
          // ...wrap around to other side.
          cy=gridSize-1;
        else
          // If the Y-axis co-ordinate is too high...
          if (cy>gridSize-1)
            // ...wrap around to other side.
            cy=0;

        // Using corrected co-ordinate values, add the current cell's state
        // to the neighbor count.
        count+=gridCell[cx][cy].giveState();
      }

    // Subtract out the state of the target cell. We never count ourselves!
    count-=gridCell[cellX][cellY].giveState();

    // Return the final neighbor count.
    return count;
  }

/****************************************************************************/

  // Determine the fate for a given cell, based on given state and neighbor
  // count values.
  private int ponderFate(int state, int nCount)
  {
    // If cell is alive and has enough neighbors...
    if (state==ALIVE && (nCount==2 || nCount==3))
      return ALIVE;			// ...it survives.
    else
    // Otherwise, if cell is dead and has enough neighbors...
      if (state==DEAD && nCount==3)
        return ALIVE;			// ...it's reborn.

    // All other cases, cell dies.
    return DEAD;
  }

/****************************************************************************/

  // Kill ever single cell in the grid, wiping everything out.
  private void nukeGrid()
  {
    // Generic indexer variables.
    int x, y;

    // Sweep through entire grid array...
    for (x=0; x<gridSize; x++)
      for (y=0; y<gridSize; y++)
        // ...and kill each cell.
        gridCell[x][y].acceptFate(DEAD);

    // Reset population count for good measure.
    popCount=0;
  }

/****************************************************************************/

  // For seeding the grid with a random population of living cells.
  private void seedGrid()
  {
    // Generic indexer variables.
    int x, y;

    // Sweep through entire grid array...
    for (x=0; x<gridSize; x++)
      for (y=0; y<gridSize; y++)
        // If a forty percentile role succeeds...
        if (Math.random()<.40)
          // ...a new cell is born! :)
          gridCell[x][y].acceptFate(ALIVE);
  }

/****************************************************************************/

  // Force an update of the entire grid.
  private void updateGrid()
  {
    // Generic indexer variables.
    int x, y;

    // Reset population count.
    popCount=0;

    // Sweep through entire grid array...
    for (x=0; x<gridSize; x++)
      for (y=0; y<gridSize; y++)
        // ...and add the state of each cell to the population count.
        popCount+=gridCell[x][y].updateCell();
  }

/****************************************************************************/

  // Return the grid's size.
  public int giveGridSize()
  {
    return gridSize;
  }

/****************************************************************************/

  // Return the grid's current population count.
  public long givePopCount()
  {
    return popCount;
  }

/****************************************************************************/

  // Return the grid's current generation count.
  public long giveGenCount()
  {
    return genCount;
  }

/****************************************************************************/

  // Return the average age for the current generation.
  public float giveAvgAge()
  {
    // Generic indexer variables.
    int x, y;

    // Age counting and averaging variables.
    long totAge=0;
    float avg=0;

    // Sweep through entire grid array...
    for (x=0; x<gridSize; x++)
      for (y=0; y<gridSize; y++)
        // ...and add the age of each cell to the total.
        totAge+=gridCell[x][y].giveAge();

    // As long as the population is more than zero...
    if (givePopCount()!=0)
      // Compute the average age.
      avg=(float) totAge / (float) givePopCount();

    // Return the final result.
    return avg;
  }

/****************************************************************************/

  // Initialize the entire Life grid and reset all counters.
  public void remakeAll()
  {
    // Wipe everything out.
    nukeGrid();

    // Randomly create a bunch of live cells.
    seedGrid();

    // Update the grid.
    updateGrid();

    // Reset the generation count to zero.
    genCount=0;
  }

/****************************************************************************/

  // Perform a single generation sweep, updating all cells. Also update
  // the population counter and increment the generation counter.
  public void doGen()
  {
    // Generic indexer variables.
    int x, y;

    // Sweep through entire grid array...
    for (x=0; x<gridSize; x++)
      for (y=0; y<gridSize; y++)
        // ...and determine each cell's fate.
        gridCell[x][y].acceptFate( ponderFate( gridCell[x][y].giveState(),
        countNeighbors(x, y) ) );

    // Now update the entire grid.
    updateGrid();

    // Incremenet generation counter.
    genCount++;
  }

/****************************************************************************/

  // Draw the grid's contents to a pixel buffer. Buffer is assumed to be
  // the same size and dimensions as the grid array.
  public void drawGridIMG(byte[] pix)
  {
    // Generic indexer variables.
    int x, y;

    // Sweep through entire grid array...
    for (x=0; x<gridSize; x++)
      for (y=0; y<gridSize; y++)
        // ...and for every living cell...
        if (gridCell[x][y].giveState()==ALIVE)
          // ...set it's corresponding pixel on.
          pix[x+(y*gridSize)]=(byte) 255;
  }

// End of line
}