/*
 * jlife.java - A Java implementation of Conway's Life game.
 *
 * Author : Jeff Mercer <jcm@vaxer.net>
 * Written: 7/24/99
 * Updated: 8/10/99
 * JDK Ver: 1.1.8
 *
 * Purpose: Does a life simulation using the LifeGrid class. Displays the
 *          generation and population counts, as well as average cell age.
 *          User can start/stop simulation, single-step, and reset simulation.
 *
 * 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 needed classes and packages
 *************************************/
import java.applet.Applet;		// Of course, we need the applet class.
import java.awt.*;			// Need windowing functions.
import java.awt.event.*;		// Need event class for user interaction.
import java.awt.image.IndexColorModel;	// For creating images.
import java.awt.image.MemoryImageSource;	// For creating images, also.
import LifeGrid;			// Need the Life classes.

public class jlife extends Applet
                   implements Runnable, ActionListener
{
/******************************
 * Data members of this applet
 ******************************/
  final int LIFESIZE=128;		// Size of life grid (both dimensions).
  final int DISP_X=12;		// X-coord of display area.
  final int DISP_Y=96;		// Y-coord of display area.
  final int SCALE=2;		// Scale to draw grid image at.
  final int NAPTIME=75;		// Length of loop delay in milliseconds.

  LifeGrid theUniverse;		// The Conway arena.
  Thread jlifeThread;		// For this applet's thread.
  boolean stepRun, fullRun;	// Loop flags, for run control.
  boolean flameOn;			// Flame effect on|off flag.
  long startNap, endNap;		// For computing sleep time.

  byte[] pixels;			// Array of bytes for screen buffer.
  Image gridImg;			// Image object for grid display.
  IndexColorModel icm;		// ICM instance for creating images.

  // Button controls, for user input.
  Button startBtn, stopBtn, stepBtn, resetBtn, flameBtn;

  // Label controls for displaying stats, etc.
  Label genLabel, genValueLabel, popLabel, popValueLabel,
        avgAgeLabel, avgAgeValueLabel, titleLabel;

/**************************
 * Methods of this applet.
 ****************************************************************************/

  // Initialization method for the jlife applet, called when applet is first
  // loaded and primary execution has not started yet.
  public void init()
  {
    // Make a whole new life universe.
    theUniverse=new LifeGrid(LIFESIZE);

    // Reset the universe and re-populate it.
    theUniverse.remakeAll();

    // Initialize the user buttons.
    startBtn=new Button("Start"); startBtn.addActionListener(this);
    resetBtn=new Button("Reset"); resetBtn.addActionListener(this);
    stopBtn=new Button("Stop"); stopBtn.addActionListener(this);
    stepBtn=new Button("Step"); stepBtn.addActionListener(this);
    flameBtn=new Button("Flame!"); flameBtn.addActionListener(this);

    // Create and initialize the status display labels.
    popLabel=new Label("Population: ", Label.RIGHT);
    popValueLabel=new Label("00000", Label.LEFT);
    genLabel=new Label("Generation: ", Label.RIGHT);
    genValueLabel=new Label("00000", Label.LEFT);
    avgAgeLabel=new Label("Average age: ", Label.RIGHT);
    avgAgeValueLabel=new Label("00000.00000000", Label.LEFT);

    // Create and initialize title label.
    titleLabel=new Label("jlife - Conway's Life in Java by Jeff Mercer",
                         Label.CENTER);

    // Add the title to the applet display first.
    add (titleLabel);

    // Now add the user buttons to the applet display.
    add (startBtn); add (stopBtn);
    add (stepBtn); add (resetBtn);
    add (flameBtn);

    // Finally, add the labels to the applet display.
    add (popLabel); add (popValueLabel);
    add (genLabel); add (genValueLabel);
    add (avgAgeLabel); add (avgAgeValueLabel);

    // Make the screen display object.
    pixels=new byte[LIFESIZE*LIFESIZE];

    // Create the index color model for image production. This requires
    // setting up some RGB data, but that's only needed this once.
    byte[] red=new byte[256];	// Reds array.
    byte[] green=new byte[256];	// Blues array.
    byte[] blue=new byte[256];	// Greens array.

    // Step through 64 different palette values...
    for (int i=0; i<64; i++)
    {
      // Set red values.
      red[i]=(byte) (i*4); red[i+192]=(byte) (i*4);
      // Set green values.
      green[i+64]=(byte) (i*4); green[i+192]=(byte) (i*4);
      // Set blue values.
      blue [i+128]=(byte) (i*4); blue[i+192]=(byte) (i*4);
      // Remaining empty spaces are black by default...
    }

    // Create the ICM object from the RGB set that was just initialized.
    icm=new IndexColorModel(8, 256, red, green, blue);

    // Set run mode flags off, so simulation needs to be triggered by user.
    stepRun=false;
    fullRun=false;

    // By default the flame effect should be off.
    flameOn=false;
  }

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

  // Custom update method, which just jumps straight to the paint method.
  // This is done to prevent screen flickering.
  public void update(Graphics g)
  {
    // Just hop straight to the paint method.
    paint(g);
  }

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

  // Custom paint method for drawing/updating the display. Called when applet
  // first starts, a repaint is requested, or applet gets focus. This draws
  // the entire applet display as well as life simulation grid.
  public void paint(Graphics g)
  {
    // Display the current population.
    popValueLabel.setText(Long.toString(theUniverse.givePopCount()));

    // Display the current generation.
    genValueLabel.setText(Long.toString(theUniverse.giveGenCount()));

    // Display the average age of this generation.
    avgAgeValueLabel.setText(Float.toString(theUniverse.giveAvgAge()));

    // If the flame effect is not turned on, clear screen buffer...
    if (! flameOn)
      clearScreen();
    else
      // Otherwise, apply the flame effect.
      flame();

    // Have the life universe update the screen buffer for display.
    theUniverse.drawGridIMG(pixels);

    // Create a new image object from the screen buffer.
    gridImg=createImage(new MemoryImageSource(LIFESIZE, LIFESIZE,
                        icm, pixels, 0, LIFESIZE));

    // Draw the image in the applet display.
    g.drawImage(gridImg, DISP_X, DISP_Y+24, LIFESIZE*SCALE, LIFESIZE*SCALE,
                null);
  }

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

  // Start the applet thread running.
  public void start()
  {
    // If this applet's thread is dead...
    if (jlifeThread==null)
    {
      jlifeThread=new Thread(this, "jlife");	// Re-create the applet thread.
      jlifeThread.start();				// And start it up.
    }
  }

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

  // Applet's primary run loop, where all the action takes place. This
  // executes as a thread for better performance.
  public void run()
  {
    // Get ahold of the thread that this run() method belongs to.
    Thread thisThread=Thread.currentThread();

    // As long as this thread is the same as the applet thread (and
    // thus still alive)...
    while (thisThread==jlifeThread)
    {
      // Get the current time, to measure how long this iteration takes.
      startNap=System.currentTimeMillis();

      // Do a generation sweep, if run flags are true.
      if (fullRun || stepRun)
      {
        theUniverse.doGen();	// Everybody dance now.

        repaint();			// Update the display.

        if (stepRun)		// If this was a single-step run...
          stepRun=false;		// ...reset the flag.
      }

      // If that wiped everything out...
      if (theUniverse.givePopCount()==0)
        fullRun=false;		// turn off the full run flag.

      // So how long was that, anywho?
      endNap=System.currentTimeMillis();

      // Well, let's nap the differential.
      if (endNap-startNap<NAPTIME)
        try				    // ......oooooOO(ZZZZzzzzzzzz)
          { Thread.sleep(NAPTIME-(endNap-startNap)); }
        catch (InterruptedException e)	// (Unless something exciting happens)
          { break; }
    }
  }

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

  // Stop the jlife applet thread.
  public void stop()
  {
    // Toss the applet thread into limbo rather than telling it to actually
    // stop itself.
    jlifeThread=null;
  }

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

  // Process any user actions that have been caught. Called whenever the
  // user has clicked on one of the applet's buttons.
  public void actionPerformed(ActionEvent evnt)
  {
    // Get the name of whatever action triggered this method.
    String actName=evnt.getActionCommand();

    // Check against valid command actions. For a match, perform the
    // appropiate function.
    if (actName=="Start")			// If Start button pressed...
      fullRun=true;				// Run at constant rate.
    else
      if (actName=="Stop")			// If Stop button pressed...
      {
        stepRun=false; fullRun=false;	// Stop all running.
      }
      else
        if (actName=="Step")		// If Step button pressed...
        {
          fullRun=false;			// Stop constant running...
          stepRun=true;			// ...and do a single-step run.
        }
        else
          if (actName=="Reset")		// If Reset button pressed...
          {
            // Re-generate entire life grid.
            theUniverse.remakeAll();

            // Re-paint the display immediately.
            repaint();
          }
          else
            if (actName=="Flame!")	// If Flame button pressed...
              flameOn=! flameOn;		// Toggle the flame effect flag.
  }

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

  // Reset all the pixels in the screen buffer to zero, for a completely
  // blank screen.
  public void clearScreen()
  {
    // Generic indexer variable.
    int idx;

    for (idx=0; idx<LIFESIZE*LIFESIZE; idx++)
      pixels[idx]=0;
  }

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

  // Generate a "flame" effect in the screen buffer, based on its current
  // contents. This is based on code from jcthugha, but utilizes widely
  // known algorhythms to produce the effect.
  public void flame()
  {
    // Generic indexer variable.
    int idx;

    // Pixel value holders.
    int pix1, pix2, pix3, pix4;
    int pixavg;

    // Ending buffer values. Pre-calculated for faster looping.
    int end1=LIFESIZE*LIFESIZE;		// End of entire buffer.
    int end2=LIFESIZE*(LIFESIZE-1)-1;	// End of buffer except bottom edge.

    // Clear the bottom edge of the screen buffer. This prevents "build-up".
    for (idx=LIFESIZE*(LIFESIZE-1); idx<end1; idx++)
      pixels[idx]=0;

    // Step through entire buffer except for the bottom edge...
    for (idx=0; idx<end2; idx++)
    {
      // Get the values of the current pixel and it's three neighboring pixels
      // at the lower-right.
      pix1=pixels[idx];			// Current pixel
      pix2=pixels[idx+1];		// Just to the right...
      pix3=pixels[idx+LIFESIZE];	// Just below...
      pix4=pixels[idx+LIFESIZE+1];	// Lower right corner...

      // Convert negative values to positive compliments (since Java has no
      // unsigned data types or functions).
      if (pix1<0) pix1+=256;
      if (pix2<0) pix2+=256;
      if (pix3<0) pix3+=256;
      if (pix4<0) pix4+=256;

      // Compute the integer average of the four pixel values.
      pixavg=(pix1+pix2+pix3+pix4)/4;

      // As long as the average is more than zero, subtract for a fade.
      if (pixavg>0)
        pixavg--;

      // Set the current pixel to it's new value.
      pixels[idx]=(byte) pixavg;
    }
  }

  // End of applet.
}