//acadlife.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
//version 3: neighbors are symmetric

//#include "graph.h"


#include <graphics.h>	//will have to use borland c++ graphics directly :(
					//for getpixel and putpixel
#include <conio.h>
#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


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=40;
const int J=30;
const int NEIGHBORS_PER_CELL=8;	//we are no longer limited by geometry

#define NUM_CELLS I * J

const int offset=20;	//offset to plot

struct point{

	int i;
	int j;
};

class neighlist{
	public:
	point list[NEIGHBORS_PER_CELL];
	int curr_neighbors;
	neighlist(){curr_neighbors=0;};
};

//const int ITER=300;


//remains unchanged in academic life
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

void dump(int world[GEN+1][I][J],int gen);	//dump as text

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


	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;
							//new in version 3
	int assigned_neighbors=0;	//must not exceed NUM_CELLS*NUM_NEIGHBORS

	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 maxcolor;
	int maxx, maxy;
	long int i,j,k,m,n,o;	//for iterating up to millions
	char ch;

		//initialize graphics
	//************************************
	int driver=DETECT;
	int mode;

	if(registerbgidriver(EGAVGA_driver)<0){
		cout<<"\nunable to register grafx driver!!!"<<endl;
	}
	//int maxx, maxy;	//will be 640x480


	//**************INIT GRAPHICS**********************
	mode=CGAC0;
	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*****************

	cout<<"\nAcadLife 3.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 (3.0), can preclude self as a neighbor";
	cout<<"\nand has symmetric neighbors";
	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;
	}

	//int maxx,maxy;



	//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);
		}
	}
	//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

	//this code changed in version 3, now neighbors are symmetric
	//OY, 2/18/1998

	for(i=0;i<I;i++){
		for(j=0;j<J;j++){
			neighboridx=random(NUM_CELLS);
			//thisx=neighboridx%I;	//x,y coords of random neighbor
			//thisy=thisx=J*i;
			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.

	int newk=0; 	//new k value for the neighbor
	int newm=0;	//we are the newm'th neighbor of our neighbor
	for(k=0;k<NUM_CELLS;k++){

		thisx=k%I;
		thisy=k-thisx*J;

		while(neighbors[(world[GEN][thisx][thisy])].curr_neighbors<8){

		 cout<<neighbors[(world[GEN][thisx][thisy])].curr_neighbors<<endl;
		 //we only fill in the number of neighbors we have to, since
		 //our neighbors may already have been filled in
		 for(m=neighbors[k].curr_neighbors;m<NEIGHBORS_PER_CELL; m++){
			//neighbors[k].curr_neighbors++

			randx=random(I);
			randy=random(J);
			//!!!!!!!!!! convert 1-D mtx to 2-D mtx!!!

			if(!self_neighbor_legal){
				//find non-self neighbors
				//this probably wont' matter, except in
				//certain instances.  We'll see...


				if(randx==thisx && randy==thisy){
					sound(200);
					delay(5);
					nosound();
					while(randx==thisx){
						//cout<<"\nlooking for non-self x"<<endl;
						randx=random(I);
					}
					while(randy==thisy){
						//cout<<"\nlooking for non-self y"<<endl;
						randy=random(J);
					}
				}


			}//end outer if
			newk=J*randx+randy;	//index to our new neighbor in neighbors[]
			newm=neighbors[newk].curr_neighbors;

			neighbors[k].list[m].i=randx;
			neighbors[k].list[m].j=randy;
			neighbors[k].curr_neighbors++;
			//now make _us_ _their_ neighbor
			//this might not be 100% accurate, as there might
			//be some special cases I'm forgetting about OY 2/18/1998
			if(neighbors[newk].curr_neighbors<8){
				neighbors[newk].list[newm].i=thisx;
				neighbors[newk].list[newm].j=thisy;
				neighbors[newk].curr_neighbors++;
			}


		 }//end for
	    }//end while
	}//end outer for

	//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
	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(curr_generation%100==0){
			cout<<"\ngeneration: "<<curr_generation<<endl;
			dump(world,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='*';
		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
}