CodeS-SourceS est hébergé par Frontier.fr

Ce site au démarrage

begin process at 2010 03 14 01:55:31

Accueil Codes Tutoriels Forum Livres Emploi Services Connexion

Trouver un code source :

dans

[ Dernières recherches ]

Accueil >

Maths & Algorithmes

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

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

Information sur la source

Note :

2,50 / 10

Catégorie :Maths & Algorithmes Niveau :Débutant Date de création :11/12/2001 Date de mise à jour :16/12/2001 14:16:09 Vu :3 037

Auteur : pornik

Ecrire un message privé

Site perso

Commentaire sur cette source (3)

Ajouter un commentaire et/ou une note

Description

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.

Source

#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;
}
}
/**********************************************************************/

#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;
	} 
}
/**********************************************************************/

Conclusion

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..

Sources de la même categorie

ALGORITHME DE TRI D'UN TABLEAU PAR ORDRE CROISSANT OU DÉCROI... par Thuzhen

CALCUL DE VARIANCE par Minilogus

GÉNÉRATEUR DE CLÉS SUR 26 DIGITS AU FORMAT HEXADÉCIMAL par besilent

ALGORITHME DE CRYPTAGE/DECRYPTAGE par besilent

CALCUL D'INCERTITUDE par Minilogus

Toutes les sources de la catégorie Maths & Algorithmes

Commentaires et avis

Commentaire de pornik le 16/12/2001 14:17:27

goldeneye> vala t contant pov type?

Commentaire de mastave le 06/03/2002 19:25:13

punaise, arrêtez de vous envoyer des clous!
Vous êtes carrément pas sympas entre vous!
Bon, je ne suis pas du genre hippie-cool-zen(au contraire!), mais quand même!
Bonne prog...(et pis arrêtez de vous insulter!)

Commentaire de recherchelesavoir le 13/03/2005 13:22:36

je débute en c (et j'utilise le builder 5.5 version gratuite)

j(ai une erreur lors de la compilation la variable "j" n'est pas définit.
Merci de donner la ligne de commande pour compiler chaque programmes, sinon on ne sans sort pas.

Ajouter un commentaire

Nos sponsors

Derniers Blogs

FAIRE APPARAITRE L'ONGLET 'DéVELOPPEUR' DANS OFFICE 2010 par neodante

[ASTUCE] PATCH POUR MICROSOFT FORUMS NNTP BRIDGE V1 par pierre

PB LORS DE L'INSTALLATION SHAREPOINT 2010. par Patrick Guimonet

[WF4] AJOUTER DES CONTRAINTES à UNE ACTIVITé (2/2) par JeremyJeanson

[WF4] AJOUTER DES CONTRAINTES à UNE ACTIVITé (1/2) par JeremyJeanson

Forum

RE : [LIEUR ERREUR] UNRESOLVED EXTERNAL VEHICULE::~VEHICULE() par Razily

CONVERTIR UN PROJET EN VISUAL C++ VERS C++ BUILDER par aligoogle2010

TABLEAU 2 DIMENSIONS OU 1 DIMENSION par gazelle100

RE : BELLMAN par affaf09

CONCEPTION D'UNE BIBLIOTHèQUE GRAPHIQUE par salma5

Côté IT

Offres d'emploi

Formations Video

Appels d'offres

Site internet php
Budget : 350€
site formation reiki distance
Budget : 900€
Banniere Flash Drupal
Budget : 150€

Logiciels

Xilisoft Convertisseur Vidéo Ultimate (5.1.39.0305)
XILISOFT CONVERTISSEUR VIDéO ULTIMATE (5.1.39.0305)

Xilisoft Convertisseur Vidéo Ultimate est un outil puissant de conversion vidéo, facile à utilise...

Cliquez pour télécharger Xilisoft Convertisseur Vidéo Ultimate
Xilisoft DVD Ripper Ultimate (5.0.64.0304)
XILISOFT DVD RIPPER ULTIMATE (5.0.64.0304)

Xilisoft DVD Ripper Ultimate est un logiciel excellent pour copier et convertir DVD vers presque ...

Cliquez pour télécharger Xilisoft DVD Ripper Ultimate
Axalot, logiciel de sauvegarde de données en ligne (1.10.108.1)
AXALOT, LOGICIEL DE SAUVEGARDE DE DONNéES EN LIGNE (1.10.108.1)

Perdre tout le contenu de votre disque dur, vous imaginez ? Vos photos, vos musiques, votre compt...

Cliquez pour télécharger Axalot, logiciel de sauvegarde de données en ligne
Rigs of Rods (63.3)
RIGS OF RODS (63.3)

c'est un jeu de multi-simulation camions,autobus voitures, avions, bateaux, hélicoptère avec défo...

Cliquez pour télécharger Rigs of Rods
Konvertor (4.00)
KONVERTOR (4.00)

Le logiciel est un gestionnaire multimedia affichant, jouant et convertissant plus de 2000 format...

Cliquez pour télécharger Konvertor