/*
 * Paul Garrett, 29 Sept 98
 *
 * Conway's "life" game
 *
 * For now, wrap-around geometry...
 *
 */

import java.awt.*;
import java.util.*;

public class Life extends java.applet.Applet implements Runnable {

	 boolean initial_state = true; // to remember initial config
	 boolean running = false;
	 Stack newly_drawn = new Stack();
	 boolean drawing = false;

	 final int cell_size = 8; // in pixels: should be divisor of width and height
	 final int cell_padding = 1; // interstices thickness...

	 int nwx = 0; // current nw corner of box to paint
	 int ix = 0; // current i-index in array
	 int nwy = 0; // current nw corner of box to paint
	 int iy = 0; // current j-index in array

	 // all 4 of the following must be non-zero:
	 final int big_i_inc = 1; // horizontal increment in outer loop
	 final int big_j_inc = 1; // vertical increment in outer loop

	 final int small_i_inc = 1; // horizontal increment in outer loop
	 final int small_j_inc = 1; // vertical increment in outer loop

	 final int big_x_inc = big_i_inc * cell_size; 
	 final int big_y_inc = big_j_inc * cell_size; 
	 final int small_x_inc = small_i_inc * cell_size; // within paint() inner loop
	 final int small_y_inc = small_j_inc * cell_size; // within paint() inner loop

	 final static int width = 704; // of whole picture
	 final static int height = 520; // of whole picture
	 final int horiz = width/cell_size; // number of cells horizontally
	 final int vert = height/cell_size; // number of cells vertically
	 final int number_of_cells = horiz * vert;

	 // number of cells to color in a single paint()
	 int tick_length = vert * horiz; // should be multiple of "horiz"

	 Thread th; // to run the animation
	 int time = 0; // counts generations

	 int[][] states = new int[horiz][vert]; // states of cells
	 int[][] orig_states = new int[horiz][vert]; // states of cells
	 int[][] next_states = new int[horiz][vert]; // states of cells

	 // tells which color/population it will draw in
	 int mouseState = 0; // clicking should change it...

	 Color[] colors = { Color.gray, Color.black };

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

	 public static void main(String[] argv) {

		  Frame fr = new Frame();
		  fr.addNotify();
		  fr.setLayout(null);
		  //		  Insets insets = fr.getInsets();
		  Insets insets = fr.insets(); // 1.0 api
		  //  fr.setSize(insets.left+insets.right+width, insets.top+insets.bottom+height);
		  fr.resize(insets.left+insets.right+width, insets.top+insets.bottom+height);
		  fr.show();
		  fr.setBackground(new Color(0x999999));

		  Life se = new Life();
		  fr.add(se);
		  se.init(); // have to initialize some stuff before drawing it...

		  //		  se.setLocation(insets.left, insets.top); // 1.1 api
		  se.move(insets.left, insets.top); // 1.0 api
		  se.resize(width, height); // 1.0 api
	 }

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

	 final public void generation() {
		  int neighbors; // from 0 to 8
		  int iless, imore, jless, jmore;
		  for (int i=0; i<horiz; i++) {
				iless = ( i - 1 + horiz) % horiz;
				imore = ( i + 1 ) % horiz;
				for (int j=0; j<vert; j++) {
					 jless = ( j - 1 + vert) % vert;
					 jmore = ( j + 1 ) % vert;
					 neighbors = states[iless][jless] + states[i][jless] + 
						  states[imore][jless] + // that was top row of nbrs
						  states[iless][j] + states[imore][j] + // middle row of nbrs
						  states[iless][jmore] + states[i][jmore] + states[imore][jmore];
					 // last bottom row of nbrs
					 switch ( neighbors ) {
					 case 3:
						  next_states[i][j] = 1;
						  break;
					 case 2:
						  // status quo
						  next_states[i][j] = states[i][j];
						  break;
					 default:
						  next_states[i][j] = 0;
						  break;
					 }
				}
		  }
		  for (int i=0; i<horiz; i++) {
				for (int j=0; j<vert; j++) {
					 states[i][j] = next_states[i][j];
				}
		  }
	 }

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

	 public void init() {
		  for (int i=0; i<horiz; i++) {
				for (int j=0; j<vert; j++) {
					 states[i][j] = 0; // empty
					 orig_states[i][j] = 0; // empty
				}
		  }
	 }

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

    public void _start() {
		  if (th == null) {
				th = new Thread(this);
				th.start();
		  }
    }

	 public void start() {
		  if (running == true) {
				repaint();
				_start();
		  }
	 }

	 public void update(Graphics g) {
		  paint(g);
	 }

	 public void stop() {
		  _stop(); // better do it this way unless asked otherwise!
	 }

    public void _stop() {
		  if (th != null) {
				th.stop();
				th = null;
		  }
    }

    void pause(int time) {
		  try { Thread.sleep(time); }
		  catch ( InterruptedException e) { }
    }

    public void run() {
		  while ( true ) {
				pause(100);
				generation();
				time++;
				repaint();
		  }
    }	

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

	 final public void paint(Graphics g) {
		  if (running == true) {
				nwx = (nwx + big_x_inc) % width;
				ix = (ix + big_i_inc) % horiz;
				nwy = (nwy + big_y_inc) % height;
				iy = (iy + big_j_inc) % vert;
				
				for (int tick = 0; tick < tick_length; tick++) {
					 g.setColor(colors[ states[ix][iy] ]);
					 g.fillRect( nwx, nwy, cell_size - cell_padding, 
									 cell_size - cell_padding );
					 nwx = (nwx + small_x_inc) % width;
					 nwy = (nwy + small_y_inc) % height;
					 ix = (ix + small_i_inc) % horiz ;
					 iy = (iy + small_j_inc) % vert;
				}  
				g.setColor( Color.gray );
				g.fillRect( 0, 0, 35, 20 );
				g.setColor( Color.white );
				g.drawString("" + time, 3, 18);
		  }
		  else {
				if ( drawing == true ) {
					 while ( newly_drawn.empty() == false ) {
						  int[] indices = ( int[] ) newly_drawn.pop();
						  g.setColor(colors[ states[ indices[0] ][ indices[1] ] ]);
						  g.fillRect(indices[0] * cell_size, indices[1] * cell_size, 
										 cell_size - cell_padding, cell_size - cell_padding );
					 }
					 drawing = false;
				}
				else { // external repaint case
					 int x = 0;
					 for (int i=0; i < horiz; i++) {
						  int y = 0;
						  for (int j=0; j < vert; j++ ) {
								g.setColor(colors[ states[i][j] ]);
								g.fillRect(x, y, cell_size - cell_padding, 
										 cell_size - cell_padding );
								y += cell_size;
						  }
						  x += cell_size;
					 }
					 g.setColor( Color.gray );
					 g.fillRect( 0, 0, 50, 20 );
					 g.setColor( Color.white );
					 g.drawString("" + time, 3, 18);
				}
		  }
	 }

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

	 public boolean mouseDrag(Event e, int x, int y) {
		  if ( x > 0 && x < width && y > 0 && y < height ) {
				int i = x/cell_size;
				int j = y/cell_size;
				states[i][j] = mouseState;
				if ( initial_state == true ) {
					 orig_states[i][j] = mouseState;
				}
				int[] indices = {i, j};
				newly_drawn.push( indices );
				drawing = true;
				repaint();
		  }
		  return true;
	 }

	 public boolean mouseDown(Event e, int x, int y) {
		  mouseState = 1 - mouseState; // just 0 or 1
		  int i = x/cell_size;
		  int j = y/cell_size;
		  states[i][j] = 1 - states[i][j];
		  if ( initial_state == true ) {
				orig_states[i][j] = 1 - orig_states[i][j];
		  }
		  int[] indices = {i, j};
		  newly_drawn.push( indices );
		  drawing = true;
		  repaint();
		  return true;
	 }

	 public boolean keyDown(Event e, int k) {
		  if ( k == 103 && running == false ) { // == 'g' for 'go'
				initial_state = false;
				repaint();
				running = true;
				_start();
				return true;
		  }
		  else if ( k == 115 && running == true ) { // == 's' for 'stop'
				running = false;
				_stop();
				repaint();
				return true;
		  }
		  else if ( k == 114 && running == false ) { // == 'r' for 'reset'
				for (int i=0; i<horiz; i++) {
					 for (int j=0; j<vert; j++) {
						  states[i][j] = orig_states[i][j];
						  time = 0;
						  repaint();
					 }
				}
				return true;
		  }
		  else if ( k == 99 && running == false ) { // == 'c' for 'clear'
				for (int i=0; i<horiz; i++) {
					 for (int j=0; j<vert; j++) {
						  states[i][j] = 0;
						  orig_states[i][j] = 0;
						  time = 0;
						  repaint();
					 }
				}
				return true;
		  }
		  else if ( k == 49 && running == false ) { // == 'c' for 'clear'
				generation();
				time++;
				repaint();
				return true;
		  }
		  else {
				return false;
		  }
	 }

} // end of class Life