class automateDim1Fonction{ 

/****************variables globales************************************************/

static int[] regle = new int[8];
static int[] etatActuel = new int[100];
static int[] etatSuivant = new int[100]; 

/******************définitions des fonctions ****************************************/

//A partir d'un nombre décimal entré au clavier crée un tableau d'entiers de taille 8 
// le tableau de la règle correspondante

static int[] affecterRegle(int nombre ){

		int[] rule = new int[8];
		int quotient = nombre;
		int indice = 0;
		int reste;
		while(quotient > 0){
			reste = quotient % 2;
			rule[indice] = reste;
			quotient = quotient/2;
			indice = indice + 1;
		}
		for(int i = indice;i <= 7;i = i+1){
			rule[i] = 0;
		}
		return rule;
}


//crée une fenêtre de taille 1000x200  placé à l'écran en (0,20) pour l'évolution de la colonie

static void creerFenetre(String s){
		Isn.initDrawing (s,0,20,1000,200);
}


//dessine dans la fenêtre créée des droites verticales et horizontales pour créer un réseau de carrés de taille 10


static void dessinerGrille(){

//Attention (0;0) est le coin supérieur gauche de la fenêtre en cours
		
		for(int i = 1; i <= 19; i = i+1){
			Isn.drawLine(0,10*i,1000,10*i,0,0,0);
		}
		for(int i = 1; i <= 99; i = i+1){
			Isn.drawLine(10*i,0,10*i,1000,0,0,0);
		}
}


		
//peint les cases d'une ligne numérotée par generationNum, pour la colonie

static void peindreColonie(int[] colonie,int generationNum){
		for(int i = 0;i <= 99;i = i+1){
								if(colonie[i] != 0){
								Isn.paintRect(10*i+1,10*(generationNum-1)+1,8,8,255,0,0);
								}
		}
	
}

//retourne une colonie engendrée à partir de la colonie etatActuel en tenant compte de la règle regle

static int[] generationEtatSuivant(int[] etatActuel){

		int d;
		int[] etatS = new int[100];
	
			
		for(int i = 1;i <= 98;i = i+1){
		
		// Hérédité: Construction de etatSuivant[i] à partir de etatActuel[i]  
		//on parcourt le tableau etatActuel du deuxième élément à l'avant dernier 
		//et on regarde pour chaque élément e = etatActuel[i] 
		//les voisins a = etatActuel[i-1] et b = etatActuel[i+1] de cet élément
		//aeb forme un nombre entier en binaire on convertit ce nombre en décimal d. 
		//Ce nombre d est l'indice dans le tableau regle de l'état suivant de la case repérée par i
		//etatSuivant[i] = regle[d]
								
								d = 4*etatActuel[i-1]+2*etatActuel[i]+etatActuel[i+1];
								etatS[i] = regle[d];
										
		}
		
		// aux extrémités du tableau : On considère que la colonie ne peut pas dépasser les "parois" etatActuel[-1] = etatActuel[100] = 0
		
		//pour l'indice i=0
		
		d = 2*etatActuel[0]+etatActuel[1];
		etatS[0] = regle[d];
		
		//pour l'indice i = 99	
		
		d = 4*etatActuel[98]+2*etatActuel[99];
		etatS[99] = regle[d];
		
		return etatS;
}

//Essayez cette fonction elle n'échange pas les tableaux entrés en paramètres (voir manuel  )

static void echanger(int[] x,int[] y){
		int[] echange;
		echange = x;
		x = y;
		y = echange;
}


/*********************Programme Principal ********************************/

public static void main (String[] args) {
		
		
		int[] echange;
		
		//Création de la règle
		
		System.out.println("Entrez un entier entre 1 et 255");
		int dec = Isn.readInt();
	    regle = affecterRegle(dec);
		
		
		//ETAT INITIAL: UNE SEULE CELLULE
		
		etatActuel[50] = 1;
		
		//Création de la fenêtre et du quadrillage
		
		creerFenetre("Rule "+ String.valueOf(dec));
		dessinerGrille();
		Isn.paintRect(501,0,8,8,255,0,0);
		
		
		// On suit l'évolution de la colonie sur une vingtaine de générations
		// La variable num numérote le nombre de générations
		
		for(int num = 2;num <= 20;num = num+1){
		
					etatSuivant = generationEtatSuivant(etatActuel);
					peindreColonie(etatSuivant,num);			
					//echanger(etatSuivant,etatActuel);
					echange = etatActuel;
					etatActuel = etatSuivant;
					etatSuivant = echange;
					
		}
		
		
		
		
}
}