Bonjour!

Je me suis mis à la programmation en C++ il y a deux mois et je me suis lancé comme défi de coder le jeu de la vie.

J'ai créé une classe Cellule et dans mon main j'ai créé un tableau de Cellules que je manipule de la manière suivante:

INITIALISATION

- on créé un tableau de Cellules

- on initialise la valeur de chaque attributs de chaque cellule du tableau (toutes les cellules sont dead au départ)

- on insère à ce tableau un modèle (qui fait passer de l'état dead à alive les cellules dont les coordonnées sont contenues dans le modèle)

- on initialise l'attribut "nombre de voisins vivants" de toutes les cellules du tableau

BOUCLE PRINCIPALE

- On scanne le tableau et on teste pour chaque cellule l'état de la cellule et son nombre de voisins vivants puis, suivant les règles du jeu de la vie, on remplit les attributs des cellules d'un tableau tampon

- On copie le tableau tampon dans le tableau cellule

- On affiche le tableau

MON PROBLEME:

le défilement n'est pas fluide lors de l'exécution du programme: il y a des saccades irrégulières. J'ai remarqué que lorsque je bougeait le curseur de ma souris sur la fenêtre, alors tout fonctionnait bien. Je pense que le programme attend un évènement pour faire tourner la boucle (le fait de bouger ma souris créé cet évènement) mais je voudrais que la boucle tourne sans que je n'ai rien à faire et de manière fluide. 

Voici le main mon code:

#include <iostream>
#include <string>
#include <SFML/Graphics.hpp>
#include <cstdlib>
#include <cstdio>
#include "Cellule.h"
#include <vector>

// VARIABLES

int nombreColonnesTableau = 0;
int nombreLignesTableau = 0;
int largeurCellule = 0;
int hauteurCellule = 0;
int hauteurGrille = 0;
int largeurGrille = 0;
sf::RectangleShape fondGrille;
sf::Vector2i positionSouris;
int couleurCelluleDead[3] = {0};
int *ptr_ccd = &couleurCelluleDead[0];
int couleurCelluleAlive[3] = {0};
int *ptr_cca = &couleurCelluleAlive[0];

// COULEURS (R,G,B)

int noir[3] = { 0,0,0 };
int *ptr_noir = &noir[0];
int rouge[3] = { 255,0,0 };
int *ptr_rouge = &rouge[0];
int jaune[3] = { 255,255,0 };
int *ptr_jaune = &jaune[0];
int orange[3] = { 255,128,64 };
int *ptr_orange = &orange[0];
int rose[3] = { 255,0,255 };
int *ptr_rose = &rose[0];

// FONCTIONS

// SAISIE DES DIMENSIONS INITIALES + COULEURS INITIALES
void saisir_les_valeurs_initiales(int *ptr_nct, int *ptr_nlt, int *ptr_lc, int *ptr_hc, int *ptr_lg, int *ptr_hg, int *ptr_cd, int *ptr_ca) {

	int choix_couleur = 0;

	std::cout << "Veuillez saisir le nombre de colonnes de votre tableau (largeur): ";
	std::cin >> *ptr_nct;
	std::cout << "Veuillez saisir le nombre de lignes de votre tableau (hauteur): ";
	std::cin >> *ptr_nlt;
	std::cout << "Veuillez saisir la largeur des cellules (en pixels): ";
	std::cin >> *ptr_lc;
	std::cout << "Veuillez saisir la hauteur des cellules (en pixels): ";
	std::cin >> *ptr_hc;
	std::cout << "\n" << std::endl;
	*ptr_lg = *ptr_lc * *ptr_nct;
	*ptr_hg = *ptr_hc * *ptr_nlt;

	std::cout << "Veuillez saisir la couleur d'une cellule morte:\n-1 noir\n-2 rouge\n-3 jaune\n-4 orange\n-5 rose\n";
	std::cin >> choix_couleur;
	std::cout << "choix couleur - couleur dead: " << choix_couleur << std::endl;

	switch (choix_couleur) {
	case 1:
		for (int i = 0; i < 3; i++) { *(ptr_ccd + i) = *(ptr_noir + i);} break;
	case 2:
		for (int i = 0; i < 3; i++) { *(ptr_ccd + i) = *(ptr_rouge + i);} break;
	case 3:
		for (int i = 0; i < 3; i++) { *(ptr_ccd + i) = *(ptr_jaune + i);} break;
	case 4:
		for (int i = 0; i < 3; i++) { *(ptr_ccd + i) = *(ptr_orange + i);} break;
	case 5:
		for (int i = 0; i < 3; i++) { *(ptr_ccd + i) = *(ptr_rose + i);} break;
	default:
		for (int i = 0; i < 3; i++) { *(ptr_ccd + i) = *(ptr_noir + i); }
		std::cout << "votre choix ne correspond a aucune couleur. La cellule a ete initialise a NOIR\n" << std::endl;
		break;
	}

	std::cout << "Veuillez saisir la couleur d'une cellule vivante:\n-1 noir\n-2 rouge\n-3 jaune\n-4 orange\n-5 rose\n";
	std::cin >> choix_couleur;
	std::cout << "choix couleur - couleur alive: " << choix_couleur << std::endl;

	switch (choix_couleur) {
	case 1:
		for (int i = 0; i < 3; i++) { *(ptr_cca + i) = *(ptr_noir + i); } break;
	case 2:
		for (int i = 0; i < 3; i++) { *(ptr_cca + i) = *(ptr_rouge + i); } break;
	case 3:
		for (int i = 0; i < 3; i++) { *(ptr_cca + i) = *(ptr_jaune + i); } break;
	case 4:
		for (int i = 0; i < 3; i++) { *(ptr_cca + i) = *(ptr_orange + i); } break;
	case 5:
		for (int i = 0; i < 3; i++) { *(ptr_cca + i) = *(ptr_rose + i); } break;
	default:
		for (int i = 0; i < 3; i++) { *(ptr_cca + i) = *(ptr_rouge + i); }
		std::cout << "votre choix ne correspond a aucune couleur. La cellule a ete initialise a NOIR\n" << std::endl;
		break;
	}
}

// ____________FT - AFFICHAGE DES DIMENSIONS INITIALES
void afficher_les_valeurs_initiales(int *ptr_nct, int *ptr_nlt, int *ptr_lc, int *ptr_hc, int *ptr_lg, int *ptr_hg) {

	std::cout << "Largeur du tableaux: " << *ptr_nct << " cellules" << std::endl;
	std::cout << "Hauteur du tableaux: " << *ptr_nlt << " cellules" << std::endl;
	std::cout << "Largeur de la cellule: " << *ptr_lc << " pixels" << std::endl;
	std::cout << "Hauteur de la cellule: " << *ptr_hc << " pixels" << std::endl;
	std::cout << "Largeur de la grille: " << *ptr_lg << " pixels" << std::endl;
	std::cout << "Hauteur de la grille: " << *ptr_hg << " pixels" << std::endl;
	std::cout << std::endl;
}

// ____________FT - INITIALISE LE RECTANGLE POUR LE FOND DE LA GRILLE
void initialiser_rectangle_fond_grille(sf::RectangleShape *fg) {
	(*fg).setFillColor(sf::Color(255, 128, 64));
	(*fg).setPosition(0, 0);
	(*fg).setSize(sf::Vector2f((float)largeurGrille, (float)hauteurGrille));
}

// INITIALISER LES VALEURS DES ATTRIBUTS D'UNE CELLULE - A DEAD
void initialiser_cellule(Cellule *ptr_cel, int pc_X, int pc_Y) {

	(*(ptr_cel)).set_largeurCellule(largeurCellule);
	(*(ptr_cel)).set_hauteurCellule(hauteurCellule);
	(*(ptr_cel)).set_etatCellule(dead);
	(*(ptr_cel)).set_positionCellule_X(pc_X * largeurCellule);
	(*(ptr_cel)).set_positionCellule_Y(pc_Y * hauteurCellule);
	(*(ptr_cel)).set_couleur_dead(ptr_ccd);
	(*(ptr_cel)).set_couleur_alive(ptr_cca);
	(*(ptr_cel)).set_nombreVoisinsCellule(0);
	(*(ptr_cel)).initialiser_rectangle((*(ptr_cel)).get_etatCellule());

}

// SWITCHER L'ETAT D'UNE CELLULE
void switcher_cellule(Cellule *ptr_cel) {
	if ((*ptr_cel).get_etatCellule() == dead) {
		(*ptr_cel).set_couleur_alive(ptr_cca);
		(*ptr_cel).set_etatCellule(alive);
		(*ptr_cel).initialiser_rectangle((*ptr_cel).get_etatCellule());
	}
	else if ((*ptr_cel).get_etatCellule() == alive) {
		(*ptr_cel).set_couleur_alive(ptr_ccd);
		(*ptr_cel).set_etatCellule(dead);
		(*ptr_cel).initialiser_rectangle((*ptr_cel).get_etatCellule());
	}
}

// SWITCHER L'ETAT DE TOUTES LES CELLULES D'UN TABLEAU
void switcher_tableau_cellules(Cellule *ptr_tabCel) {
	for (int i = 0; i < nombreColonnesTableau; i++) {
		for (int j = 0; j < nombreLignesTableau; j++) {
			switcher_cellule(&(*(ptr_tabCel + i * nombreColonnesTableau + j)));
		}
	}
}

// INITIALISER LES VALEURS DES ATTRIBUTS DE CHAQUE CELLULE D'UN TABLEAU DE CELLULES
void initialiser_tableau_cellules(Cellule *ptr_tabCel, int nct, int nlt) {
	for (int i = 0; i < nct; i++) {
		for (int j = 0; j < nlt; j++) {
			initialiser_cellule( &(*(ptr_tabCel + i * nct + j)) ,i,j);
		}
	}
}

// REMPLIR ALEATOIREMENT L'ETAT D'UNE CELLULE
void remplir_aleatoirement_cellule(Cellule *ptr_cel) {

	int etatAleatoire = (int)(rand()%10);
	if (etatAleatoire%2 == alive) {
		(*ptr_cel).set_couleur_alive(ptr_cca);
		(*ptr_cel).set_etatCellule(alive);
		(*ptr_cel).initialiser_rectangle((*ptr_cel).get_etatCellule());
	}
	else if (etatAleatoire % 2 == dead) {
		(*ptr_cel).set_couleur_alive(ptr_ccd);
		(*ptr_cel).set_etatCellule(dead);
		(*ptr_cel).initialiser_rectangle((*ptr_cel).get_etatCellule());
	}
}

// REMPLIR ALEATOIREMENT UN TABLEAU DE CELLULE
void remplir_aleatoirement_tableau(Cellule *ptr_tabCel) {
	for (int i = 0; i < nombreColonnesTableau; i++) {
		for (int j = 0; j < nombreLignesTableau; j++) {
			remplir_aleatoirement_cellule(&(*(ptr_tabCel + i * nombreColonnesTableau + j)));
		}
	}
}

// SCANNE LE NOMBRE DE VOISINS VIVANTS D'UNE CELLULE DONNEE DANS UN TABLEAU DONNE
int scanne_tableau_cellules(Cellule *ptr_tabCel, int xCel, int yCel) {

	int compteur_alive = 0;

	// CAS 0,0
	if (xCel == 0 && yCel == 0) {
		//std::cout << " CAS 0,0 " << std::endl;
		for (int i = xCel; i <= xCel + 1; i++) {
			for (int j = yCel; j <= yCel + 1; j++) {
				if ((*(ptr_tabCel + i * nombreColonnesTableau + j)).get_etatCellule() == alive) {
					compteur_alive++;
				}
				//std::cout << "i: " << i << " / j: " << j << " / Compteur_alive: " << compteur_alive << std::endl;
			}
		}
	}
	// CAS 1,0
	else if (xCel == nombreColonnesTableau - 1 && yCel == 0) {
		//std::cout << " CAS 1,0 " << std::endl;
		for (int i = xCel - 1; i <= xCel + 1; i++) {
			for (int j = yCel; j <= yCel + 1; j++) {
				if ((*(ptr_tabCel + i * nombreColonnesTableau + j)).get_etatCellule() == alive) {
					compteur_alive++;
				}
			}
		}
	}
	// CAS 0,1
	else if (xCel == 0 && yCel == nombreLignesTableau - 1) {
		//std::cout << " CAS 0,1 " << std::endl;
		for (int i = xCel; i <= xCel + 1; i++) {
			for (int j = yCel - 1; j <= yCel; j++) {
				if ((*(ptr_tabCel + i * nombreColonnesTableau + j)).get_etatCellule() == alive) {
					compteur_alive++;
				}
			}
		}
	}
	// CAS 1,1
	else if (xCel == nombreColonnesTableau - 1 && yCel == nombreLignesTableau - 1) {
		//std::cout << " CAS 1,1 " << std::endl;
		for (int i = xCel - 1; i <= xCel; i++) {
			for (int j = yCel - 1; j <= yCel; j++) {
				if ((*(ptr_tabCel + i * nombreColonnesTableau + j)).get_etatCellule() == alive) {
					compteur_alive++;
				}
			}
		}
	}
	// CAS LIGNE GAUCHE
	else if (xCel == 0 && yCel >= 1 && yCel <= nombreLignesTableau - 2) {
		//std::cout << " CAS LIGNE GAUCHE " << std::endl;
		for (int i = xCel; i <= xCel + 1; i++) {
			for (int j = yCel - 1; j <= yCel + 1; j++) {
				if ((*(ptr_tabCel + i * nombreColonnesTableau + j)).get_etatCellule() == alive) {
					compteur_alive++;
				}
			}
		}
	}
	// CAS LIGNE DROITE
	else if (xCel == nombreColonnesTableau - 1 && yCel >= 1 && yCel <= nombreLignesTableau - 2) {
		//std::cout << " CAS LIGNE DROITE " << std::endl;
		for (int i = xCel - 1; i <= xCel; i++) {
			for (int j = yCel - 1; j <= yCel + 1; j++) {
				if ((*(ptr_tabCel + i * nombreColonnesTableau + j)).get_etatCellule() == alive) {
					compteur_alive++;
				}
			}
		}
	}
	// CAS LIGNE DESSUS
	else if (yCel == 0 && xCel >= 1 && xCel <= nombreColonnesTableau - 2) {
		//std::cout << " CAS LIGNE DESSUS " << std::endl;
		for (int i = xCel - 1; i <= xCel + 1; i++) {
			for (int j = yCel; j <= yCel + 1; j++) {
				if ((*(ptr_tabCel + i * nombreColonnesTableau + j)).get_etatCellule() == alive) {
					compteur_alive++;
				}
			}
		}
	}
	// CAS LIGNE DESSOUS
	else if (yCel == nombreLignesTableau - 1 && xCel >= 1 && xCel <= nombreColonnesTableau - 2) {
		//std::cout << " CAS LIGNE DESSOUS " << std::endl;
		for (int i = xCel - 1; i <= xCel + 1; i++) {
			for (int j = yCel - 1; j <= yCel; j++) {
				if ((*(ptr_tabCel + i * nombreColonnesTableau + j)).get_etatCellule() == alive) {
					compteur_alive++;
				}
			}
		}
	}
	// CAS GENERAL
	else if (xCel >= 1 && xCel <= nombreColonnesTableau - 2 && yCel >= 1 && yCel <= nombreLignesTableau - 2) {
		//std::cout << " CAS GENERAL " << std::endl;
		for (int i = xCel - 1; i <= xCel + 1; i++) {
			for (int j = yCel - 1; j <= yCel + 1; j++) {
				if ((*(ptr_tabCel + i * nombreColonnesTableau + j)).get_etatCellule() == alive) {
					compteur_alive++;
				}
			}
		}
	}
	//RETOUR DU NOMBRE DE VOISINS
	if ((*(ptr_tabCel + xCel * nombreColonnesTableau + yCel)).get_etatCellule() == alive) {
		return (compteur_alive - 1);
	}
	else {
		return compteur_alive;
	}
}

// INITIALISE LE NOMBRE DE VOISINS DANS LE TABLEAU
void initialiser_nombre_voisins_tableau(Cellule *ptr_tabCel) {

	for (int i = 0; i < nombreColonnesTableau; i++) {
		for (int j = 0; j < nombreLignesTableau; j++) {
			int nv = scanne_tableau_cellules(ptr_tabCel, i, j);
			(*(ptr_tabCel + i * nombreColonnesTableau + j)).set_nombreVoisinsCellule(nv);
		}
	}
}

// COPIE UN TABLEAU DE CELLULE DANS UN AUTRE
void copier_tableau_cellules(Cellule *ptr_tabCel_1, Cellule *ptr_tabCel_2) {
	for (int i = 0; i < nombreColonnesTableau; i++) {
		for (int j = 0; j < nombreLignesTableau; j++) {
			*(ptr_tabCel_1 + i * nombreColonnesTableau + j) = *(ptr_tabCel_2 + i * nombreColonnesTableau + j);

		}
	}
}

// SCANNE LE NOMBRE DE VOISINS DU TABLEAU ET REMPLIT LE TAMPON EN FONCTION

void regles_jeu_de_la_vie(Cellule *ptr_tabCel, Cellule *ptr_tabTamCel) {
	for (int i = 0; i < nombreColonnesTableau; i++) {
		for (int j = 0; j < nombreLignesTableau; j++) {
			if ((*(ptr_tabCel + i * nombreColonnesTableau + j)).get_etatCellule() == alive && (*(ptr_tabCel + i * nombreColonnesTableau + j)).get_nombreVoisinsCellule() != 2 && (*(ptr_tabCel + i * nombreColonnesTableau + j)).get_nombreVoisinsCellule() != 3) {
				(*(ptr_tabTamCel + i * nombreColonnesTableau + j)).set_etatCellule(dead);
				(*(ptr_tabTamCel + i * nombreColonnesTableau + j)).initialiser_rectangle(dead);
			}
			else if ((*(ptr_tabCel + i * nombreColonnesTableau + j)).get_etatCellule() == dead && (*(ptr_tabCel + i * nombreColonnesTableau + j)).get_nombreVoisinsCellule() == 3) {
				(*(ptr_tabTamCel + i * nombreColonnesTableau + j)).set_etatCellule(alive);
				(*(ptr_tabTamCel + i * nombreColonnesTableau + j)).initialiser_rectangle(alive);
			}
			else { *(ptr_tabTamCel + i * nombreColonnesTableau + j) = *(ptr_tabCel + i * nombreColonnesTableau + j); }	
		}
	}
	initialiser_nombre_voisins_tableau(ptr_tabTamCel);
}

// INITIALISE LES RECTANGLES DES CELLULES D'UN TABLEAU
void initialise_rectangles_tableau(Cellule *ptr_tabCel) {
	for (int i = 0; i < nombreColonnesTableau; i++) {
		for (int j = 0; j < nombreLignesTableau; j++) {
			(*(ptr_tabCel + i * nombreColonnesTableau + j)).initialiser_rectangle((*(ptr_tabCel + i * nombreColonnesTableau + j)).get_etatCellule());
		}
	}
}

// REMPLISSAGE TABLEAU - MODELE CANON
void modele_1(Cellule *ptr_modele) {
	for (int i = 0; i < nombreColonnesTableau; i++) {
		for (int j = 0; j < nombreLignesTableau; j++) {
			(*(ptr_modele + 24 * nombreColonnesTableau + 0)).set_etatCellule(alive);
			(*(ptr_modele + 24 * nombreColonnesTableau + 0)).initialiser_rectangle(alive);
			(*(ptr_modele + 22 * nombreColonnesTableau + 1)).set_etatCellule(alive);
			(*(ptr_modele + 22 * nombreColonnesTableau + 1)).initialiser_rectangle(alive);
			(*(ptr_modele + 24 * nombreColonnesTableau + 1)).set_etatCellule(alive);
			(*(ptr_modele + 24 * nombreColonnesTableau + 1)).initialiser_rectangle(alive);
			(*(ptr_modele + 12 * nombreColonnesTableau + 2)).set_etatCellule(alive);
			(*(ptr_modele + 12 * nombreColonnesTableau + 2)).initialiser_rectangle(alive);
			(*(ptr_modele + 13 * nombreColonnesTableau + 2)).set_etatCellule(alive);
			(*(ptr_modele + 13 * nombreColonnesTableau + 2)).initialiser_rectangle(alive);
			(*(ptr_modele + 20 * nombreColonnesTableau + 2)).set_etatCellule(alive);
			(*(ptr_modele + 20 * nombreColonnesTableau + 2)).initialiser_rectangle(alive);
			(*(ptr_modele + 21 * nombreColonnesTableau + 2)).set_etatCellule(alive);
			(*(ptr_modele + 21 * nombreColonnesTableau + 2)).initialiser_rectangle(alive);
			(*(ptr_modele + 34 * nombreColonnesTableau + 2)).set_etatCellule(alive);
			(*(ptr_modele + 34 * nombreColonnesTableau + 2)).initialiser_rectangle(alive);
			(*(ptr_modele + 35 * nombreColonnesTableau + 2)).set_etatCellule(alive);
			(*(ptr_modele + 35 * nombreColonnesTableau + 2)).initialiser_rectangle(alive);
			(*(ptr_modele + 11 * nombreColonnesTableau + 3)).set_etatCellule(alive);
			(*(ptr_modele + 11 * nombreColonnesTableau + 3)).initialiser_rectangle(alive);
			(*(ptr_modele + 15 * nombreColonnesTableau + 3)).set_etatCellule(alive);
			(*(ptr_modele + 15 * nombreColonnesTableau + 3)).initialiser_rectangle(alive);
			(*(ptr_modele + 21 * nombreColonnesTableau + 3)).set_etatCellule(alive);
			(*(ptr_modele + 21 * nombreColonnesTableau + 3)).initialiser_rectangle(alive);
			(*(ptr_modele + 20 * nombreColonnesTableau + 3)).set_etatCellule(alive);
			(*(ptr_modele + 20 * nombreColonnesTableau + 3)).initialiser_rectangle(alive);
			(*(ptr_modele + 34 * nombreColonnesTableau + 3)).set_etatCellule(alive);
			(*(ptr_modele + 34 * nombreColonnesTableau + 3)).initialiser_rectangle(alive);
			(*(ptr_modele + 35 * nombreColonnesTableau + 3)).set_etatCellule(alive);
			(*(ptr_modele + 35 * nombreColonnesTableau + 3)).initialiser_rectangle(alive);
			(*(ptr_modele + 0 * nombreColonnesTableau + 4)).set_etatCellule(alive);
			(*(ptr_modele + 0 * nombreColonnesTableau + 4)).initialiser_rectangle(alive);
			(*(ptr_modele + 1 * nombreColonnesTableau + 4)).set_etatCellule(alive);
			(*(ptr_modele + 1 * nombreColonnesTableau + 4)).initialiser_rectangle(alive);
			(*(ptr_modele + 10 * nombreColonnesTableau + 4)).set_etatCellule(alive);
			(*(ptr_modele + 10 * nombreColonnesTableau + 4)).initialiser_rectangle(alive);
			(*(ptr_modele + 16 * nombreColonnesTableau + 4)).set_etatCellule(alive);
			(*(ptr_modele + 16 * nombreColonnesTableau + 4)).initialiser_rectangle(alive);
			(*(ptr_modele + 20 * nombreColonnesTableau + 4)).set_etatCellule(alive);
			(*(ptr_modele + 20 * nombreColonnesTableau + 4)).initialiser_rectangle(alive);
			(*(ptr_modele + 21 * nombreColonnesTableau + 4)).set_etatCellule(alive);
			(*(ptr_modele + 21 * nombreColonnesTableau + 4)).initialiser_rectangle(alive);
			(*(ptr_modele + 0 * nombreColonnesTableau + 5)).set_etatCellule(alive);
			(*(ptr_modele + 0 * nombreColonnesTableau + 5)).initialiser_rectangle(alive);
			(*(ptr_modele + 1 * nombreColonnesTableau + 5)).set_etatCellule(alive);
			(*(ptr_modele + 1 * nombreColonnesTableau + 5)).initialiser_rectangle(alive);
			(*(ptr_modele + 10 * nombreColonnesTableau + 5)).set_etatCellule(alive);
			(*(ptr_modele + 10 * nombreColonnesTableau + 5)).initialiser_rectangle(alive);
			(*(ptr_modele + 14 * nombreColonnesTableau + 5)).set_etatCellule(alive);
			(*(ptr_modele + 14 * nombreColonnesTableau + 5)).initialiser_rectangle(alive);
			(*(ptr_modele + 16 * nombreColonnesTableau + 5)).set_etatCellule(alive);
			(*(ptr_modele + 16 * nombreColonnesTableau + 5)).initialiser_rectangle(alive);
			(*(ptr_modele + 17 * nombreColonnesTableau + 5)).set_etatCellule(alive);
			(*(ptr_modele + 17 * nombreColonnesTableau + 5)).initialiser_rectangle(alive);
			(*(ptr_modele + 22 * nombreColonnesTableau + 5)).set_etatCellule(alive);
			(*(ptr_modele + 22 * nombreColonnesTableau + 5)).initialiser_rectangle(alive);
			(*(ptr_modele + 24 * nombreColonnesTableau + 5)).set_etatCellule(alive);
			(*(ptr_modele + 24 * nombreColonnesTableau + 5)).initialiser_rectangle(alive);
			(*(ptr_modele + 10 * nombreColonnesTableau + 6)).set_etatCellule(alive);
			(*(ptr_modele + 10 * nombreColonnesTableau + 6)).initialiser_rectangle(alive);
			(*(ptr_modele + 16 * nombreColonnesTableau + 6)).set_etatCellule(alive);
			(*(ptr_modele + 16 * nombreColonnesTableau + 6)).initialiser_rectangle(alive);
			(*(ptr_modele + 24 * nombreColonnesTableau + 6)).set_etatCellule(alive);
			(*(ptr_modele + 24 * nombreColonnesTableau + 6)).initialiser_rectangle(alive);
			(*(ptr_modele + 11 * nombreColonnesTableau + 7)).set_etatCellule(alive);
			(*(ptr_modele + 11 * nombreColonnesTableau + 7)).initialiser_rectangle(alive);
			(*(ptr_modele + 15 * nombreColonnesTableau + 7)).set_etatCellule(alive);
			(*(ptr_modele + 15 * nombreColonnesTableau + 7)).initialiser_rectangle(alive);
			(*(ptr_modele + 12 * nombreColonnesTableau + 8)).set_etatCellule(alive);
			(*(ptr_modele + 12 * nombreColonnesTableau + 8)).initialiser_rectangle(alive);
			(*(ptr_modele + 13 * nombreColonnesTableau + 8)).set_etatCellule(alive);
			(*(ptr_modele + 13 * nombreColonnesTableau + 8)).initialiser_rectangle(alive);
		}
	}
}

// ____________FT - INITIALISER LES VALEURS DES ATTRIBUTS D'UNE CELLULE
void test_initialiser_cellule(Cellule *ptr_tabCel) {
	int xCel = 0;
	int yCel = 0;
	std::cout << "Saisir la valeur en X de la cellule: "; // !!! FAIRE UN TEST DE DEPASSEMENT DE TABLEAU
	std::cin >> xCel;
	std::cout << "Saisir la valeur en X de la cellule: ";
	std::cin >> yCel;
	std::cout << "Cellule [" << xCel << "][" << yCel << "]\n" << std::endl;

	std::cout << "\n ATTRIBUTS DE LA CELLULE AVANT INITIALISATION:" << std::endl;
	(*(ptr_tabCel + xCel * nombreColonnesTableau + yCel)).afficher_attributs_cellule();
	initialiser_cellule(&(*(ptr_tabCel + xCel * nombreColonnesTableau + yCel)), xCel, yCel);

	std::cout << "\n ATTRIBUTS DE LA CELLULE APRES INITIALISATION:" << std::endl;
	(*(ptr_tabCel + xCel * nombreColonnesTableau + yCel)).afficher_attributs_cellule();
}

// ____________FT - INITIALISER LE NOMBRE DE VOISINS VIVANTS D'UNE CELLULE
void test_initialiser_nombre_voisins_vivants(Cellule *ptr_tabCel) {
	int xCel = 0;
	int yCel = 0;
	std::cout << "Saisir la valeur en X de la cellule: "; // !!! FAIRE UN TEST DE DEPASSEMENT DE TABLEAU
	std::cin >> xCel;
	std::cout << "Saisir la valeur en X de la cellule: ";
	std::cin >> yCel;
	std::cout << "Cellule [" << xCel << "][" << yCel << "]\n" << std::endl;

	std::cout << "\n ATTRIBUTS DE LA CELLULE AVANT CALCUL DU NOMBRE DE VOISINS VIVANTS:" << std::endl;
	(*(ptr_tabCel + xCel * nombreColonnesTableau + yCel)).afficher_attributs_cellule();
	int nv = scanne_tableau_cellules(ptr_tabCel, xCel, yCel);
	(*(ptr_tabCel + xCel * nombreColonnesTableau + yCel)).set_nombreVoisinsCellule(nv);

	std::cout << "\n ATTRIBUTS DE LA CELLULE APRES CALCUL DU NOMBRE DE VOISINS VIVANTS:" << std::endl;
	(*(ptr_tabCel + xCel * nombreColonnesTableau + yCel)).afficher_attributs_cellule();
}

// FONCTION PRINCIPALE
int main() {

	srand(time(NULL));

	saisir_les_valeurs_initiales(&nombreColonnesTableau, &nombreLignesTableau, &largeurCellule, &hauteurCellule, &largeurGrille, &hauteurGrille, ptr_ccd, ptr_cca);
	afficher_les_valeurs_initiales(&nombreColonnesTableau, &nombreLignesTableau, &largeurCellule, &hauteurCellule, &largeurGrille, &hauteurGrille);


	std::vector<Cellule> tableauCellules(nombreColonnesTableau * nombreLignesTableau);
	Cellule *ptr_tableauCellules = &tableauCellules[0];
	std::vector<Cellule> tableauTamponCellules(nombreColonnesTableau * nombreLignesTableau);
	Cellule *ptr_tableauTamponCellules = &tableauTamponCellules[0];
	
	initialiser_tableau_cellules(ptr_tableauCellules, nombreColonnesTableau, nombreLignesTableau);
	initialiser_tableau_cellules(ptr_tableauTamponCellules, nombreColonnesTableau, nombreLignesTableau);

	modele_1(ptr_tableauCellules);

	initialiser_nombre_voisins_tableau(ptr_tableauCellules);

	static sf::RenderWindow grille(sf::VideoMode(largeurGrille, hauteurGrille), "___Le jeu de la vie___");
	initialiser_rectangle_fond_grille(&fondGrille);

	//OUVERTURE DE LA FENETRE
	while (grille.isOpen()) {
		sf::Event evenement;
		while (grille.pollEvent(evenement)) {

			// Boucle du jeu
			if (evenement.type == sf::Event::Closed) {
				grille.close();
			}
				/*if (sf::Mouse::isButtonPressed(sf::Mouse::Left)) {
					positionSouris = sf::Mouse::getPosition(grille);
					std::cout << "souris_x: " << positionSouris.x << " souris_y: " << positionSouris.y << std::endl;
				}*/

				// AFFICHE LE TABLEAU
				for (int i = 0; i < nombreColonnesTableau; i++) {
					for (int j = 0; j < nombreLignesTableau; j++) {
						grille.draw((*(ptr_tableauCellules + i * nombreColonnesTableau + j)).get_rectangleCellule());
					}
				}
				regles_jeu_de_la_vie(ptr_tableauCellules, ptr_tableauTamponCellules);

				copier_tableau_cellules(ptr_tableauCellules, ptr_tableauTamponCellules);

				sf::sleep(sf::milliseconds(10));

				grille.display();
				grille.clear();
				// Fin de la boucle du jeu

			
		}
	}

	// FIN MAIN
	return 0;
}

Voici ma classe Cellule:

enum {
	dead,
	alive
};

class Cellule
{

public:

	//CONSTRUCTEUR
	Cellule();
	Cellule(int hc, int lc, int ec, int nvc, int pcX, int pcY, int *ptr_cd, int *ptr_ca);

	//GETTERS
	int get_hauteurCellule();
	int get_largeurCellule();
	int get_etatCellule();
	int get_nombreVoisinsCellule();
	int get_positionCellule_X();
	int get_positionCellule_Y();
	int *get_couleur_dead();
	int *get_couleur_alive();
	sf::RectangleShape get_rectangleCellule();

	//SETTERS
	void set_hauteurCellule(int hc);
	void set_largeurCellule(int lc);
	void set_etatCellule(int ec);
	void set_nombreVoisinsCellule(int nvc);
	void set_positionCellule_X(int pcX);
	void set_positionCellule_Y(int pcY);
	void set_couleur_dead(int *cd);
	void set_couleur_alive(int *ca);
	void set_rectangleCellule(sf::RectangleShape);



	//METHODES
	void afficher_attributs_cellule();
	void initialiser_rectangle(int ec);


private:

	int hauteurCellule;
	int largeurCellule;
	int etatCellule;
	int nombreVoisinsCellule;
	int positionCellule_X;
	int positionCellule_Y;
	int couleur[6];
	int* ptr_couleur_dead = &couleur[0];
	int* ptr_couleur_alive = &couleur[3];
	sf::RectangleShape rectangleCellule;
};

et voici Cellule.cpp:

#include <SFML/Graphics.hpp>
#include "Cellule.h"
#include <iostream>
#include <string>

//CONSTRUCTEURS
Cellule::Cellule() {};

Cellule::Cellule(int hc, int lc, int ec, int nvc, int pcX, int pcY, int *ptr_cd, int *ptr_ca) {
	hauteurCellule = hc;
	largeurCellule = lc;
	etatCellule = ec;
	nombreVoisinsCellule = nvc;
	positionCellule_X = pcX;
	positionCellule_Y = pcY;
	for (int i = 0; i < 3; i++) { *(ptr_couleur_dead + i) = *(ptr_cd + i); }
	for (int i = 0; i < 3; i++) { *(ptr_couleur_alive + i) = *(ptr_ca + i); }
	if (etatCellule == dead){
		rectangleCellule.setFillColor(sf::Color(couleur[0], couleur[1], couleur[2]));
	}
	else if (etatCellule == alive) {
		rectangleCellule.setFillColor(sf::Color(couleur[3], couleur[4], couleur[5]));
	}
	rectangleCellule.setPosition(sf::Vector2f((float)pcX, (float)pcY));
	rectangleCellule.setSize(sf::Vector2f((float)lc, (float)hc));
};

//GETTERS
int Cellule::get_hauteurCellule() { return hauteurCellule; }
int Cellule::get_largeurCellule() { return largeurCellule; }
int Cellule::get_etatCellule() { return etatCellule; }
int Cellule::get_nombreVoisinsCellule() { return nombreVoisinsCellule; }
int Cellule::get_positionCellule_X() { return positionCellule_X; }
int Cellule::get_positionCellule_Y() { return positionCellule_Y; }
int *Cellule::get_couleur_dead() { return ptr_couleur_dead; }
int *Cellule::get_couleur_alive() { return ptr_couleur_alive; }
sf::RectangleShape Cellule::get_rectangleCellule() { return rectangleCellule; }


//SETTERS
void Cellule::set_hauteurCellule(int hc) { hauteurCellule = hc; }
void Cellule::set_largeurCellule(int lc) { largeurCellule = lc; }
void Cellule::set_etatCellule(int ec) { etatCellule = ec; }
void Cellule::set_nombreVoisinsCellule(int nvc) { nombreVoisinsCellule = nvc; }
void Cellule::set_positionCellule_X(int pcX) { positionCellule_X = pcX; }
void Cellule::set_positionCellule_Y(int pcY) { positionCellule_Y = pcY; }
void Cellule::set_couleur_dead(int *ptr_cd) { for (int i = 0; i < 3; i++) { *(ptr_couleur_dead + i) = *(ptr_cd + i); } }
void Cellule::set_couleur_alive(int *ptr_ca) { for (int i = 0; i < 3; i++) { *(ptr_couleur_alive + i) = *(ptr_ca + i); } }
void Cellule::set_rectangleCellule(sf::RectangleShape rc) { rectangleCellule = rc; }


//METHODES
void Cellule::afficher_attributs_cellule() {
	std::cout << "\nDIMENSIONS DE LA CELLULE (h x l) EN PIXELS: " << hauteurCellule << " x " << largeurCellule << std::endl;
	std::cout << "ETAT DE LA CELLULE (dead ou alive): " << etatCellule << std::endl;
	std::cout << "NOMBRE DE VOISINS DE LA CELLULE: " << nombreVoisinsCellule << std::endl;
	std::cout << "POSITION DE LA CELLULE DANS LA GRILLE (x,y): " << positionCellule_X << ", " << positionCellule_Y << std::endl;
	if (etatCellule == dead){
	std::cout << "LE CODE COULEUR DE LA CELLULE EST (R,G,B): " << "(" << couleur[0] << ", " << couleur[1] << ", " << couleur[2] << ")" << std::endl;
	}
	else if (etatCellule == alive) {
		std::cout << "LE CODE COULEUR DE LA CELLULE EST (R,G,B): " << "(" << couleur[3] << ", " << couleur[4] << ", " << couleur[5] << ")" << std::endl;
	}
	std::cout << "L'ADRESSE DE rectangleCellule EST: " << &rectangleCellule << std::endl;
}
void Cellule::initialiser_rectangle(int ec) {
	if (etatCellule == dead) {
	rectangleCellule.setFillColor(sf::Color(couleur[0], couleur[1], couleur[2]));
	}
	if (etatCellule == alive ) {
		rectangleCellule.setFillColor(sf::Color(couleur[3], couleur[4], couleur[5]));
	}
	rectangleCellule.setPosition(sf::Vector2f((float)positionCellule_X, (float)positionCellule_Y));
	rectangleCellule.setSize(sf::Vector2f((float)largeurCellule, (float)hauteurCellule));
}

Merci infiniment par avance pour vos retours :)!

-
Edité par MatthieuVitrac 17 juin 2021 à 1:33:16

Bonjour, Merci de retirer toutes les lettres en capitales de votre titre.

Majuscules abusives

L'écriture en majuscules est considérée comme une parole criée et diminue autant la lisibilité du texte que sa compréhension. Les majuscules abusives sont donc interdites aussi bien dans les titres que dans les messages.

Liens conseillés

• Règles générales du forum

Hello

Le problème viens du fait que tu gères l'affichage dans la boucle d'evenements...
La doc de la SFML donne ce modèle:

while (Running)
{
    sf::Event Event;
    while (App.GetEvent(Event))
    {
        // Process event
    }

    App.Display();
}

Tu remarquera que l'affichage se fait dans la boucle principale après la boucle de gestion des events.

Sinon, je te conseille de relire un cours de C++ moderne (on point généralement vers celui de Zestes de savoir) car ton code est truffe de mauvaises pratiques (variables globales, tableaux a la C, etc...) Et son design est très étrange...