LE JEU DE LA VIE (PEUT-ÊTRE OPTIMISABLE) [BORLAND C++ COMPILER 5.5]

---

Commentaire sur cette source (3)
Ajouter un commentaire et/ou une note

On a une matrice de dimensions quelconques, dans chacune des cases il peut y avoir un habitant. Le but du jeu est de savoir quand un habitant va survivre, et quand un autre va naitre, de voir l'évolution de la vie dans cette ville virtuelle formée de cellules de la matrices ;-) tout cela en respectant les deux règles suivantes :<BR>-un habitant naît dans une case innocupée à la génération d'après seulement si le nombre de voisins est 3<BR>-un habitant reste vivant seulement dans le cas ou il est entouré de deux ou trois habitants.  

#include <iostream.h>
#include <dos.h>
#include <conio.h>
#define LARGEUR 15
#define HAUTEUR 6
/**********************************************************************/
int Matrice[LARGEUR][HAUTEUR];
/**********************************************************************/
void InitDos()
{
	textbackground(1);
	textcolor(14);
	_setcursortype(_NOCURSOR);
}
/**********************************************************************/
void VideMatrice()
{
	for(int i=0;i<LARGEUR;i++) {
		for(int j=0;j<HAUTEUR;j++) Matrice[i][j]=0;
	j=0;
	}
}
/**********************************************************************/
void InitMatriceInitiale()
{
	Matrice[6][0]=1;
	Matrice[1][1]=1; Matrice[2][1]=1; Matrice[5][1]=1; Matrice[7][1]=1; Matrice[8][1]=1; Matrice[11][1]=1;
	Matrice[9][2]=1; Matrice[10][2]=1; Matrice[12][2]=1; Matrice[14][2]=1;
	Matrice[2][3]=1; Matrice[3][3]=1; Matrice[6][3]=1; Matrice[8][3]=1; Matrice[9][3]=1; Matrice[13][3]=1;
	Matrice[7][4]=1; 
	Matrice[11][5]=1;
}
/**********************************************************************/
int Evolution(int i, int j,int Survivre0Naitre1)
{
	int NbVoisins=0;

	switch(i) {
	case 0:
		switch(j) {
		case 0:			
			if(Matrice[i+1][j+0]) NbVoisins++;
			if(Matrice[i+1][j+1]) NbVoisins++;
			if(Matrice[i+0][j+1]) NbVoisins++;
			break;

			case HAUTEUR-1:
			if(Matrice[i+0][j-1]) NbVoisins++;
			if(Matrice[i+1][j-1]) NbVoisins++;
			if(Matrice[i+1][j+0]) NbVoisins++;
			break;

			default:
			if(Matrice[i+0][j-1]) NbVoisins++;
			if(Matrice[i+1][j-1]) NbVoisins++;
			if(Matrice[i+1][j+0]) NbVoisins++;
			if(Matrice[i+1][j+1]) NbVoisins++;
			if(Matrice[i+0][j+1]) NbVoisins++;
			break;
		}	
		break;

		case LARGEUR-1:
		switch(j) {
		case 0:			
			if(Matrice[i-1][j+0]) NbVoisins++;
			if(Matrice[i-1][j+1]) NbVoisins++;
			if(Matrice[i-0][j+1]) NbVoisins++;
			break;

			case HAUTEUR-1:
			if(Matrice[i+0][j-1]) NbVoisins++;
			if(Matrice[i-1][j-1]) NbVoisins++;
			if(Matrice[i-1][j+0]) NbVoisins++;
			break;

			default:
			if(Matrice[i+0][j-1]) NbVoisins++;
			if(Matrice[i-1][j-1]) NbVoisins++;
			if(Matrice[i-1][j+0]) NbVoisins++;
			if(Matrice[i-1][j+1]) NbVoisins++;
			if(Matrice[i+0][j+1]) NbVoisins++;
			break;
		}		
		break;

		default:
		switch(j) {
		case 0:
			if(Matrice[i-1][j+0]) NbVoisins++;
			if(Matrice[i-1][j+1]) NbVoisins++;
			if(Matrice[i+0][j+1]) NbVoisins++;
			if(Matrice[i+1][j+1]) NbVoisins++;
			if(Matrice[i+1][j+0]) NbVoisins++;				
			break;
		
		case HAUTEUR-1:
			if(Matrice[i-1][j+0]) NbVoisins++;
			if(Matrice[i-1][j-1]) NbVoisins++;
			if(Matrice[i+0][j-1]) NbVoisins++;
			if(Matrice[i+1][j-1]) NbVoisins++;
			if(Matrice[i+1][j+0]) NbVoisins++;	
			break;

			default:
			if(Matrice[i-1][j-1]) NbVoisins++;
			if(Matrice[i-1][j+0]) NbVoisins++;
			if(Matrice[i-1][j+1]) NbVoisins++;
			if(Matrice[i+0][j+1]) NbVoisins++;
			if(Matrice[i+1][j+1]) NbVoisins++;
			if(Matrice[i+1][j+0]) NbVoisins++;
			if(Matrice[i+1][j-1]) NbVoisins++;
			if(Matrice[i+0][j-1]) NbVoisins++;
			break;
		}
		break;
	}

	if(!Survivre0Naitre1) 
		switch(NbVoisins) {
		case 2:
		case 3:
			return 1;
		default:
			return 0;	
		}

	else
		switch(NbVoisins) {
		case 3:
			return 1;
		default:
			return 0;	
		}
}
/**********************************************************************/
void AfficheResult(char CaractOUI, char CaractNON)
{
//	static int Generation=1;
	for(int i=0; i<LARGEUR; i++) {
		for(int j=0; j<HAUTEUR; j++) {
		gotoxy((i*2)+1,(j*2)+1);
			if(Matrice[i][j]) cout << CaractOUI;
			else cout << CaractNON;
 		}
	j=0;
	}
}
/**********************************************************************/
void NewGeneration()
{
	AfficheResult('*','-');
	int MatriceTemp[LARGEUR][HAUTEUR];

	for(int i=0;i<LARGEUR;i++) {
		for(int j=0;j<HAUTEUR;j++) {
			if(Matrice[i][j]) MatriceTemp[i][j]=Evolution(i,j,0);
			else 		  MatriceTemp[i][j]=Evolution(i,j,1);
		}
	j=0;
	}

	for(    i=0;i<LARGEUR;i++) {
		for(int j=0;j<HAUTEUR;j++) Matrice[i][j]=MatriceTemp[i][j];
	j=0;
	}
}
/**********************************************************************/
void main(void)
{
	VideMatrice();
	InitMatriceInitiale();
	InitDos();
	clrscr();

	while(1) {
		NewGeneration();
		if(getch()==27) break;
	} 
}
/**********************************************************************/ 

Voila, dans la fonction InitMatriceInitiale() j'ai initialisé la matrice case par case. on pourrait très bien procéder différemment en allant par exemple lire dans un fichier texte externe les case habitées ou non initialement, pour que l'utilisateur puisse changer ca a sa guise ;-)<BR>bon hum je sais pas si c hyper optimisé mais on voit au moins comment procéder..

• CLASS MATRICE EFFICACE
• PRÉDICTION ET MODELISATION DE SERIES TEMPORELLES PAR RESEAUX DE NEURONES ARTIFICIELS MULTICOUCHES(PARTIE 1)
• COLORATION SYNTAXIQUE
• ALGORITHME GÉNÉTIQUE RCPSP
• CALCULETTE (PEUT ÊTRE GRAPHIQUE UN JOURS ^^)