//life-2_nt.cpp
//(c) 1997, Oguz Yetkin
//physics 505
//revised 2/1998 for phys499
//
//Implements "academic life" where cells interact with "colleagues"
//otherwise, rules are the same as life (unless otherwise specified)
//
//Game of life, and other good stuff
//
//version 2: self-neighbor not allowed 2/18/1998

//#include "graph.h"


//#include <graphics.h>	//will have to use borland c++ graphics directly :(
					//for getpixel and putpixel

//define one of these for appropriate platform!!!
//#define DOS 1
#define UNIX 1

#define FORCELOCAL 1	//define this to turn the game into the regular LIFE
//#define FORCELOCAL 0

#ifdef DOS

//for windows

//include<winbase.h>	//for windows sleep(), MUST ALSO LINK kernel32.lib

//#include <conio.h>
//#include <dos.h>
//#define CLEARCMD "cls"	//command to clear the screen
const unsigned char DEAD=255; //space
const unsigned char LIVE=221; //white block

void    SetGraphicsMode( void ) {
        __asm {
                //mov     ax,0x13
				mov eax, 13h
				//int 0x10
				int 10h
          }
}

void    SetTextMode( void ) {
        __asm {
        //mov     ax,0x03
		mov eax, 3h
		//int 0x10
		int 10h
		}
}


#endif

#ifndef DOS
const	char DEAD='-';
const 	char LIVE='*';
#endif

#ifdef UNIX
#define CLEARCMD "clear" 
//command to clear the screen under UNIX
#endif


#include <stdio.h>
#include <iostream.h>
#include <stdlib.h>		//for exit
#include <assert.h>
//#include <dos.h>		//for sound

//change to 1 in order to make it legal for self to be a neighbor
//#define SELF_NEIGHBOR 0

//#include <dos.h>

const int GEN=2;	//number of generations to keep+ 1 reserved layer
				//(the GENth layer) for neighbor index
//const int I=70;
//const int J=70;
const int I=75; //to fit on screen
const int J=48 ;
const int NEIGHBORS_PER_CELL=8;	//we are no longer limited by geometry

//#define NUM_CELLS I * J
const int NUM_CELLS=I*J;

const int offset=20;	//offset to plot

struct point{

	int i;
	int j;
};

struct neighlist{
	point list[NEIGHBORS_PER_CELL];
};

//const int ITER=300;


//remains unchanged in academic life
//GLOBAL FUNCTIONS
inline int fate(int value,int num_neighbors);		//return 0 or 1

inline int count_neighbor(neighlist neighbors[NUM_CELLS], int array[GEN+1][I][J], int i, int j,int gen); //assume I and J there

int count_alive(int world[GEN+1][I][J],int gen);	//how many alive?

void dump(int world[GEN+1][I][J],int gen);	//dump as text
void dump2(int world[GEN+1][I][J], int world2[GEN+1][I][J],int gen);	//dump 2 worlds side by side

/* GLOBALS */
extern void Sleep(double);	//defined in winbase.h, including it creates problems
double sleepvalue=0;
double sleepstep=200;
char ch='p';	//start out paused

int main(int argc, char** argv){

	int visual_output=0;

	//SetGraphicsMode();

	int self_neighbor_legal=0;

	int world[GEN+1][I][J];	//2 2-d arrays in a 3-d array
						//the extra layer (layer 3) is for neighbor index

	int world2[GEN+1][I][J];	//parallel universe

	neighlist neighbors[NUM_CELLS];	//virtual "neighbors" can be anywhere
							//on the grid (more like colleagues)
	//neighlist neighbors2[NUM_CELLS];
	long int neighboridx;

	int gen=0;	//either 0 or 1
	int iter=0;
	int curr_generation=0;

	int randx, randy, thisx, thisy;	//temp variables to hold randomly generated values
	int living_count=0;
	int living_count2=0;

	int maxcolor;
	long int i,j,k,m,n,o;	//for iterating up to millions
	char ch;
	float percentage, percentage2;	//for calculting # of cells alive


	cout<<"\nAcadLife 2.0, by Oguz Yetkin, oguz@writeme.com";
	cout<<"\npress q to stop the program";
	cout<<"\nThis is a non-straighforward implementation of LIFE,";
	cout<<"\nthis version (2.0), can preclude self as a neighbor";
	cout<<"\nThe code is probably on";
	cout<<"\nhttp://www.cs.wisc.edu/~yetkin/code/life\n"<<endl;
	cout<<"\n\nmax iterations: ";
	cin>>iter;
	cout<<"\nare self-neighbors legal? (y/n) ";
	cin>>ch;
	if(ch=='y'){
		self_neighbor_legal=1;
	}else{
		self_neighbor_legal=0;
	}
	cout<<"\ndisplay visual output? (y/n)";
	cin>>ch;
	if(ch=='y'){
		visual_output=1;
	}else{
		visual_output=0;
	}

	
	//SetTextMode();

	int maxx,maxy;

	//initialize graphics
	//************************************
	/*	
	int driver=DETECT;
	int mode;
	registerbgidriver(EGAVGA_driver);
	//int maxx, maxy;	//will be 640x480


	//**************INIT GRAPHICS**********************
	initgraph(&driver, &mode, "");	//driver linked in
	//mode=CGAC0;
	//initgraph(&driver, &mode,"h:\\borlandc\\bgi");

	maxx=getmaxx();
	maxy=getmaxy();
	maxcolor=getmaxcolor();
	//cout<<maxcolor<<endl;
	//getch();
	*/
	//**************END GRAPHICS SETUP*****************


	//zero out worlds
	//cout<<"\ngrafx init...";
	for(gen=0;gen<GEN+1;gen++){	//+1 accounts for neighbor layer
		for(i=0;i<I;i++){
			for(j=0;j<J;j++){
				world[gen][i][j]=0;
				world2[gen][i][j]=0;
			}
		}
	}

	//randomize();
	//fill main world with random nums;
	for(i=0;i<I;i++){
		for(j=0;j<J;j++){
			//world[0][i][j]=random(2);
			world[0][i][j]=(rand()%2);	//0 or 1
		}
	}
	//copy world into parallel universe

	for(i=0;i<I;i++){
		for(j=0;j<J;j++){
			world2[0][i][j]=world[0][i][j];
		}
	}
	//cout<<"\nworld copied...";
	//assign random neighbors across the grid in the 3rd layer
#ifndef FORCELOCAL
	for(i=0;i<I;i++){
		for(j=0;j<J;j++){
			//neighboridx=random(NUM_CELLS);
			neighboridx=rand()%NUM_CELLS;
			world[GEN][i][j]=neighboridx;
			world2[GEN][i][j]=neighboridx;

		}
	}
	//cout<<"\nrandom neighbors assigned...";
	//now alter one point in the parallel universe
	world2[0][15][25]=!world2[0][15][25];

	//now initialize the list of neighbors with random
	//values which are within the range.  For now,
	//both arrays have the same neighbor list.

	for(k=0;k<NUM_CELLS;k++){
		for(m=0;m<NEIGHBORS_PER_CELL;m++){
			//randx=random(I);
			randx=rand()%I;
			//randy=random(J);
			randy=rand()%J;
			if(self_neighbor_legal){
				neighbors[k].list[m].i=randx;
				neighbors[k].list[m].j=randy;
			}else{
				//find non-self neighbors
				//this probably wont' matter, except in
				//certain instances.  We'll see...

				//!!!!!!!!!! convert 1-D mtx to 2-D mtx!!!

				thisx=k%I;
				thisy=k-thisx*J;
				if(randx==thisx && randy==thisy){
					//sound(200);
					//delay(100);
					//nosound();
					while(randx==thisx){
						//cout<<"\nlooking for non-self x"<<endl;
						//randx=random(I);
						randx=rand()%I;
					}
					while(randy==thisy){
						//cout<<"\nlooking for non-self y"<<endl;
						//randy=random(J);
						randy=rand()%J;
					}
				}
				neighbors[k].list[m].i=randx;
				neighbors[k].list[m].j=randy;
			}//end else
		}//end for
	}//end the neighbor initializer for loop
#endif

#ifdef FORCELOCAL
	//initialize the neighbor list in such a way that it
	//forces this to be the regular game of life
	for(i=0;i<I;i++){
		for(j=0;j<J;j++){
			//neighboridx=random(NUM_CELLS);
			//neighboridx=rand()%NUM_CELLS;

			neighboridx=i+j*J;	//just an orderly way of selecting it
			world[GEN][i][j]=neighboridx;
			world2[GEN][i][j]=neighboridx;
			//enumeration is a pain, but it's relatively
			//the easiest thing to do (conceptually, at least)
			//code pasted from countneighbor() in the classical game of LIFE
			neighbors[neighboridx].list[0].i=(I+i+1)%I ;	//W
			neighbors[neighboridx].list[0].j=j ;
			neighbors[neighboridx].list[1].i=((I+i-1)%I);	//E
			neighbors[neighboridx].list[1].j=j;
			neighbors[neighboridx].list[2].i= i;
			neighbors[neighboridx].list[2].j= ((J+j+1)%J);	//S
			neighbors[neighboridx].list[3].i= i;
			neighbors[neighboridx].list[3].j=((J+j-1)%J) ;  //N
			neighbors[neighboridx].list[4].i= ((I+i+1)%I);	//NE, SE
			neighbors[neighboridx].list[4].j= ((J+j+1)%J);
			neighbors[neighboridx].list[5].i= ((I+i+1)%I);
			neighbors[neighboridx].list[5].j= ((J+j-1)%J);
			neighbors[neighboridx].list[6].i= ((I+i-1)%I);
			neighbors[neighboridx].list[6].j= ((J+j+1)%J);
			neighbors[neighboridx].list[7].i= ((I+i-1)%I);
			neighbors[neighboridx].list[7].j= ((J+j-1)%J);	//8 neighbors, not 9!!!
			
		}
	}
	//cout<<"\nnon-random neighbors assigned...";
	//now alter one point in the parallel universe
	world2[0][15][25]=!world2[0][15][25];

	 //To force this to be the regular game of life,
	//we initialize the list of neighbors so that
	//they will belocal,
	//both arrays have the same neighbor list.



	//end #ifdef FORCELOCAL
#endif

	//cout<<"\nneighbor list initialized, copying it...";
	//now copy the neighbors list into neighbors2
	/* let's skip this step for now

	for(k=0;k<NUM_CELLS;k++){
		for(m=0;m<NEIGHBORS_PER_CELL;m++){

			neighbors2[k].list[m].i=neighbors[k].list[m].i;
			neighbors2[k].list[m].j=neighbors[k].list[m].j;
		}
	}
	cout<<"\nneighbor list copied, starting life!\n";
	*/
	//cout<<"\nskipped copying neighbors, starting life!\n";


	//start LIFE
	if(!visual_output){
		printf("\ntotal: %d",NUM_CELLS);
		printf("\nsize: %d by %d\n",I,J);
		printf("\nWorld1\t\t\t\tWorld2\n");
		printf("\niter\tlive\tdead\t%%live\t\t\tlive\tdead\t%%live\n");
	}
	for(curr_generation=0;curr_generation<iter;curr_generation++){

		gen=curr_generation%2;

		for(i=0;i<I;i++){
			for(j=0;j<J;j++){
				//put whatever we want in next generation's array
				world[((gen+1)%2)][i][j]=
					fate(world[gen][i][j],
						count_neighbor(neighbors, world,i,j,gen));

				world2[((gen+1)%2)][i][j]=
					fate(world2[gen][i][j],
						count_neighbor(neighbors, world2,i,j,gen));
			}//end inner for
		}//end outer for

		//cout<<"\ngen: "<<curr_generation<<endl;
		/*	
		for(i=0;i<I;i++){
			for(j=0;j<J;j++){

				if(world[((gen+1)%2)][i][j]==1){
					putpixel(i,j,WHITE);

				}else{
					putpixel(i,j,BLACK);
				}//end if,then,else
			}//end inner for
		}//end outer for 
		*/	
		
		if(visual_output){	
			system(CLEARCMD);
		
		cout<<"\ngeneration: "<<curr_generation<<endl;
		//dump(world,gen);
			dump2(world, world2, gen);
		}	
		living_count=count_alive(world,gen);
		living_count2=count_alive(world2,gen);
		
		percentage=((float)living_count/(float)NUM_CELLS)*100;
		percentage2=((float)living_count2/(float)NUM_CELLS)*100;
		if(visual_output){	
		 printf("\nw1:: total: %d living: %d dead: %d percent alive: %f",
			NUM_CELLS,living_count, NUM_CELLS-living_count,
			percentage);
		

		printf("\nw2:: total: %d living: %d dead: %d percent alive: %f",
			NUM_CELLS, living_count2,NUM_CELLS-living_count2,
			percentage2);
		}//end if visual_output
		if(!visual_output){
			printf("\n%d\t%d\t%d\t%f\t\t%d\t%d\t%f",
			 curr_generation,living_count,NUM_CELLS-living_count,percentage,
			 living_count2,NUM_CELLS-living_count2,percentage2);
		}

#ifdef DOS
		if(_kbhit()||iter==0){	//stop in the beginning
			ch=_getch();
			switch(ch){
				case '+':	//increase time
					sleepvalue+=sleepstep;
				break;

				case '-':
					if(sleepvalue>0){
						sleepvalue-=sleepstep;
						if(sleepvalue<0){
							sleepvalue=0;	//just in case
						}
					}
				break;
				
				case 'p':
					//cout<<endl<<"paused"<<endl;
					_getch();
				break;

				case 'q':
					cout<<"\nquitting!!!"<<endl;
					exit(1);
				break;

				ch='\0';	//reset ch
			}//end switch

		}//end if
		//cout<<"\npress p to pause"<<endl;
		_sleep(sleepvalue);


#endif
		//cin>>ch;
		/* commented out VERY temporarily ???
		if(curr_generation%100==0){
			cout<<"\ngeneration: "<<curr_generation<<" world1: "<<endl;
			dump(world,gen);
			cout<<"\nworld2: "<<endl;
			dump(world2,gen);
			
		}
		*/
		//paint the parallel universe
		/*	
		for(i=0;i<I;i++){
			for(j=0;j<J;j++){

				if(world2[((gen+1)%2)][i][j]==1){
					putpixel(i+I+offset,j,WHITE);

				}else{
					putpixel(i+I+offset,j,BLACK);
				}//end if,then,else
			}//end inner for
		}//end outer for
		*/
		//clrscr();
	}//end huge for loop

	//getch();
	//closegraph();
	cout<<"\nwe hope you have enjoyed life\n";
	return 1;

}//end main



inline int fate(int value,int num_neighbors){



	if(value==1){

		if((num_neighbors==2)||(num_neighbors==3)){
			return 1;	//stays alive
		}else{
			return 0;	//dies of loneliness or overcrowding
		}
	}else{

		if(num_neighbors==3){
			return 1;		//we have a new baby!!!
		}else{
			return 0;		//stay dead
		}
	}//end outer else


	cout<<"\nwe should never get here in fate()!!!\n"<<endl;
	return 0;


}


//changed for acadlife
//neighbors is an array of virtual neighbors
//that need not be adjacent.  point.i and point.j contain actual location
//in world.  array[GEN][i][j] specifies index into neighbors.
//
//
inline int count_neighbor(neighlist neighbors[NUM_CELLS], int array[GEN+1][I][J], int i, int j,int gen){



	assert(gen<3);	//we don't want neigh index treated as a world
	//don't want any negatives
	int num=0;
	long int neighidx;
	neighlist current;
	int neighi, neighj;

	//new code for acadlife
	neighidx=array[GEN][i][j];
	for(int k=0;k<NEIGHBORS_PER_CELL;k++){
		neighi=neighbors[neighidx].list[k].i;
		neighj=neighbors[neighidx].list[k].j;

		num+=array[gen][neighi][neighj];		//later we'll have to make
										//sure we're not our own neighbor

	}




	/* code from classical life
	num=array[gen][((I+i+1)%I)][j]+array[gen][((I+i-1)%I)][j]	//W,E
		+array[gen][i][((J+j+1)%J)]+array[gen][i][((J+j-1)%J)] //N,S
		+array[gen][((I+i+1)%I)][((J+j+1)%J)]+array[gen][((I+i+1)%I)][((J+j-1)%J)]	//NE,SE
		+array[gen][((I+i-1)%I)][((J+j+1)%J)]+array[gen][((I+i-1)%I)][((J+j-1)%J)];

	*/

	return num;

}

void dump(int world[GEN+1][I][J],int gen){	//dump as text
	
		/*
		char black='-';
		char white='*';
		*/
		unsigned char black=DEAD;
		unsigned char white=LIVE;
		int i,j;
		cout<<endl;
		for(i=0;i<I;i++){
			cout<<endl;
			for(j=0;j<J;j++){

				if(world[((gen+1)%2)][i][j]==1){
					//putpixel(i,j,WHITE);
					cout<<white;

				}else{
					//putpixel(i,j,BLACK);
					cout<<black;
				}//end if,then,else
			}//end inner for
		}//end outer for
}


//dump2 is more of a display function than a "dump" function.  It displays
//2 worlds side by side.  This works best on a high-resolution text
//screen under windows NT.  You should set up a command prompt
//by right-clicking on it and setting it to be 100x80 characters
//using fonts 8x8 pixels big (this takes care of the aspect ratio problem).
//

void dump2(int world[GEN+1][I][J], int world2[GEN+1][I][J],int gen){	//dump 2 worlds side by side
       /*
		char black='-';
		char white='*';
		*/
		unsigned char black=DEAD;
		unsigned char white=LIVE;
		int i,j;
		cout<<"------------------------------------------------------------------------------------------"<<endl;
		//assuming worlds are the same size!
		for(i=0;i<I;i++){
			cout<<endl;
			for(j=0;j<J;j++){

				if(world[((gen+1)%2)][i][j]==1){
					//putpixel(i,j,WHITE);
					cout<<white;

				}else{
					//putpixel(i,j,BLACK);
					cout<<black;
				}//end if,then,else
			}//end first for
			
			cout<<"||";	//spacer
			//now do the same thing for world2
			for(j=0;j<J;j++){
			//now do a row of world 2
				if(world2[((gen+1)%2)][i][j]==1){
					//putpixel(i,j,WHITE);
					cout<<white;

				}else{
					//putpixel(i,j,BLACK);
					cout<<black;
				}//end if,then,else for world 2 :)

			}//end inner for
		}//end outer for
}//end dump2()


int count_alive(int world[GEN+1][I][J],int gen){	//how many alive?


	long returnval=0;
	int i,j;

	for(i=0;i<I;i++){
		for(j=0;j<J;j++){

			if(world[((gen+1)%2)][i][j]==1){
				//putpixel(i,j,WHITE);
				returnval++;
			}
		}
	}

	return returnval;
}