Partage

[FAIT][Défis] #2 : Le jeu de la vie !

SDL

1 2 3 >>

9 septembre 2011 à 18:29:06

Bonjour à tous les zéros,

Cette semaine, nous vous proposons de réaliser à l'aide de la SDL, le jeu de la vie. Ne vous inquiétez pas si vous ne savez pas ce que c'est, le principe et les règles vous seront expliqués.

Si vous souhaitez plus de renseignements sur les défis, rendez vous sur le topic de recensement des défis, vous y trouverez également les règles principales.

Jeu de la vie

Cet exercice a été écrit par _Fender_ et GuilOooo, un grand merci à eux !

Le jeu de la vie... c'est quoi ?

Le jeu de la vie n'est pas un jeu au sens ludique du terme, car le "joueur" reste passif une fois l'animation lancée. C'est en réalité un automate cellulaire qui passione les mathématiciens depuis son invention en 1970 par John Horton Conway.

Un automate cellulaire se base sur une grille de cases (cellules) qui sont chacune dans un certain état, à un certain instant. Un tel automate comporte des règles qui disent comment les états des cellules évoluent dans le temps. Dans le cas du jeu de la vie, les cellules peuvent être dans 2 états différents : vivantes ou mortes.

Les règles sont plutôt simples :

Si une cellule morte à exactement trois voisines vivantes, elle devient alors vivante à son tour.
Si une cellule vivante à deux ou trois voisines vivantes, elle le reste. Elle meurt dans tous les autres cas.

Une image vaudra mieux que tout discours, alors voici un lien qui vous permettra de voir a quoi ressemble une simulation du jeu de la vie. Il est également possible de faire des choses encore plus fascinantes, comme ce canon, qui fonctionne uniquement avec les règles citées plus haut.

Notre fenêtre sera donc une grille 2D de cellules. Au départ, certaines seront vivantes, et d'autres mortes.

Vous êtes curieux ? En savoir plus sur :

Consignes

Notre objectif sera donc de réaliser un simulateur du jeu de la vie.

Vous pouvez, par exemple, représenter les cellules vivantes par des cases noires et les cellules mortes par des cases blanches. Au lancement du jeu, l'utilisateur doit pouvoir changer l'état de chaque cellule en cliquant dessus pour la faire vivre/mourir. Une fois le jeu lancé, la grille évolue selon les règles définies plus haut.

Objectifs

Premier contact avec le monde des automates cellulaires.
Application pratique de l'apprentissage de la SDL.
Manipulation des tableaux à deux dimensions.

Enoncé

Niveau 1

Mettre en place les fonctionnalités de base : choisir les cellules mortes/vivantes en début d'animation et lancer l'animation à l'appui d'une touche.

Niveau 2

Pouvoir mettre en pause/relancer l'animation et changer l'état de cellules pendant la pause.

Niveau 3

Vous avez trouvé une belle séquence et vous voulez l'envoyer à vos amis ?

Mettez donc en place un système de sauvegarde dans des fichiers, ou vous pouvez charger/sauvegarder une disposition de cellules.

Et après... ?

Si ce jeu vous passionne autant que moi, pourquoi ne pas vous amuser à changer les règles ?

Modifiez les conditions de naissance et de mort, ajoutez des couleurs, etc... Encore une fois, laissez parler votre imagination et votre créativité !

Bon courage.

S'il y a quelque chose que vous ne comprenez pas, n'hésitez pas à poser vos questions sur ce sujet, nous vous répondrons avec plaisir !

Participants

Participants	Code
Loadware	Le jeu de la vie
axelorque	Le jeu de la vie - niveau 2
Mon ouïe	Le jeu de la vie
Damien7877	Le jeu de la vie - niveau 2
lucas-84	Le jeu de la vie - niveau 3
yoch	Le jeu de la vie - niveau 2
florent m	Le jeu de la vie
drx	Le jeu de la vie - niveau 2
MaitreZur	Le jeu de la vie - niveau 2
kaka551	Le jeu de la vie - niveau 2

Lucas-84

9 septembre 2011 à 18:53:01

Je m'y met demain !

Bonne chance à tous.

Staff désormais retraité.

Mr21

9 septembre 2011 à 19:16:29

Si quelqu'un à soif d'un niveau 4, j'trouve que ça serait trop énorme de mettre dans le programme deux molettes pour accélérer; ralentir; mettre en arrière l'animation.

Exactement comme ce qu'il y a en dessous du bouton play ici:
http://www.maxiorel.cz/files/pictures/ [...] e_Pro_CS5.png

La molette permet de se déplacer dans l'anim avant arrière à la vitesse qu'on veut, et le bouton juste au dessus permet de fixer la vitesse pour de bon sans que nous ayons a garder le bouton enfoncé.

Bon finalement c'est peut être niveau 7 ou 8 là du coup, mais si ça n'a pas déjà été fait sur le net, ça serait géant de tester

Pouet_forever

9 septembre 2011 à 19:25:57

La taille du tableau n'est pas précisée, normalement avec un 'vrai' jeu de la vie, il faudrait avoir un tableau de taille infinie. :-°

dark-lord

9 septembre 2011 à 19:55:23

Salut,

bon sujet par contre je crois que je vais pas avoir la motivation de le coder la sdl me rebute un peu xd. Je vais peut etre le faire en console. Enfin a voir.... On sait jamais si je m'ennuis vraiment.

schadocalex

9 septembre 2011 à 20:12:20

Franchement, côté SDL, c'est vraiment pas dur, le plus dur c'est l'algo et la gestion de toutes les cases.

"If debbugging is the process of removing bugs, then programming must be the process of putting them in." (Edsger Dijkstra)

dark-lord

9 septembre 2011 à 20:26:13

Le problème n'est pas de coder ce 'jeu'. C'est vraiment la SDL, je l'aime plus :s

paraze

9 septembre 2011 à 20:29:27

sfml ?

Faellan

9 septembre 2011 à 20:34:58

C'est sur que quand on a gouté à la simplicité de SFML, dur de repasser en SDL.

Citation : Pouet_forever

La taille du tableau n'est pas précisée, normalement avec un 'vrai' jeu de la vie, il faudrait avoir un tableau de taille infinie.

J'ai pensé qu'on pourrait laisser ce choix à l'appréciation de chaque personne, autant laisser le moins de contraintes possibles, non ?

Bla bla bla

dark-lord

9 septembre 2011 à 20:36:49

ouai en fait je crois que c'est le mode graphique que j'aime pas :'(

ca me gonfle, j'arrive pas a avoir un code propre. On ma pas appris à coder correctement, et tout seul j'arrive pas a mettre en place un MVC.

schadocalex

9 septembre 2011 à 20:38:26

Il a dit "normalement". Après, oui tout le monde est libre de faire ce qu'il veut, c'est pas une corvée, c'est un entrainement.
Sinon, pas de débat SDL/SFML ici. C'est SDL et pis c'est tout.

Merci.

dark-lord -> Un MVC ? :lol:

Tu fais un jeu de la vie hin.

"If debbugging is the process of removing bugs, then programming must be the process of putting them in." (Edsger Dijkstra)

dark-lord

9 septembre 2011 à 20:41:24

Je sais que c'est une jeu de la vie mais je parle pour d'autre projet. Pfff et la je commence à coder le jeu de la vie en C on dirait que je fais de la POO Oo, je suis pervertis

Loadware

9 septembre 2011 à 20:53:19

Edit 3 : Donc voici ma participation. Désolé d'avoir enlevé ce code pendant un moment :-°

Edit 4 : J'ai corrigé le bug trouvé par Twisted Destiny.

/*-ansi -O -Wall -Wextra -Wswitch-default -Wwrite-strings -Wstrict-prototypes -std=c89 -lmingw32 -lSDLmain -lSDL*/
#include <time.h>
#include <stdio.h>
#include <stdlib.h>
#include <SDL/SDL.h>

#define PIX 2 /*Taille en pixels d'une cellule.*/

int main(int argc, char *argv[])
{
    int recommencer = 1, continuer = 1, permutation = 0; /*Booléens.*/
    int **grille, **grilleModif, **grilleTest; /*Grilles de cellules.*/
    int i = 0, j = 0, somme = 0, compteur = 0, lngX = 640, lngY = 480;
    SDL_Surface *ecran = NULL, *vie = NULL, *mort = NULL;
    SDL_Event event;
    SDL_Rect position, **taille;
    
    srand(time(NULL));
    
    SDL_Init(SDL_INIT_VIDEO); /*Lancement de la SDL.*/
    
    SDL_ShowCursor(SDL_DISABLE);
    
    taille = SDL_ListModes(NULL, SDL_HWSURFACE | SDL_DOUBLEBUF | SDL_FULLSCREEN);
    lngX = taille[0]->w; /*Récupération de la résolution maximale de l'écran.*/
    lngY = taille[0]->h;
    
    grille = malloc((lngX / PIX + 2) * sizeof(int*));
    grilleModif = malloc((lngX / PIX + 2) * sizeof(int*));
    grilleTest = malloc((lngX / PIX + 2) * sizeof(int*));
    
    for(i = 0 ; i <= lngX / PIX + 1 ; i++) /*Allocation dynamique des tableaux en fonction de la résolution.*/
    {
        grille[i] = malloc((lngY / PIX + 2) * sizeof(int));
        grilleModif[i] = malloc((lngY / PIX + 2) * sizeof(int));
        grilleTest[i] = malloc((lngY / PIX + 2) * sizeof(int));
    }
    
    ecran = SDL_SetVideoMode(lngX, lngY, 32, SDL_HWSURFACE | SDL_DOUBLEBUF | SDL_FULLSCREEN);    
    SDL_WM_SetCaption("Jeu de la vie par Loadware", NULL); /*Création de la fenêntre en plein écran.*/
    SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 0, 128, 0));
    
    vie = SDL_CreateRGBSurface(SDL_HWSURFACE, PIX, PIX, 32, 0, 0, 0, 0);
    SDL_FillRect(vie, NULL, SDL_MapRGB(ecran->format, 128, 0, 0)); /*Création de la cellule vivante rouge.*/
    
    mort = SDL_CreateRGBSurface(SDL_HWSURFACE, PIX, PIX, 32, 0, 0, 0, 0);
    SDL_FillRect(mort, NULL, SDL_MapRGB(ecran->format, 0, 0, 0)); /*Création de la cellule morte noire.*/
    
    while(recommencer) /*Boucle permettant de recommencer une simulation.*/
    {
        for(i = 1 ; i <= lngX / PIX ; i++) /*Remplissage de la grille principale et de la grille des modifications.*/
            for(j = 1 ; j <= lngY / PIX ; j++)
                grille[i][j] = (grilleModif[i][j] = rand() % 2);
        
        while(continuer) /*Boucle principale de la simulation*/
        {
            SDL_Delay(80);
            
            SDL_PollEvent(&event);
            
            if(event.type == SDL_KEYDOWN)
            {
                recommencer = 0;
                continuer = 0; /*N'importe quelle touche du clavier arrête la simulation.*/
            }
            
            for(i = 1 ; i <= lngX / PIX ; i++)
            {
                for(j = 1 ; j <= lngY / PIX ; j++)
                {
                    position.x = (i - 1) * PIX;
                    position.y = (j - 1) * PIX;
                    
                    SDL_BlitSurface(grille[i][j] ? vie : mort, NULL, ecran, &position); /*Affichage de chaque cellule morte ou vivante suivant la grille principale.*/
                }
            }
            
            SDL_Flip(ecran); /*Mise à jour de l'écran.*/
            
            for(i = 1 ; i <= lngX / PIX ; i++)
            {
                for(j = 1 ; j <= lngY / PIX ; j++)
                {
                    somme = grille[i-1][j-1] + grille[i][j-1] + grille[i+1][j-1] + grille[i-1][j] + grille[i+1][j] + grille[i-1][j+1] + grille[i][j+1] + grille[i+1][j+1];
                    
                    if(grille[i][j]) /*Coeur de la simulation : suivant le nombre de cellules adjacentes à la cellule courante, celle-ci meurt ou vie.*/
                        grilleModif[i][j] = (somme < 2 || somme > 3) ? 0 : 1;
                    else
                        grilleModif[i][j] = (somme == 3) ? 1 : 0;
                }
            }
            
            for(i = 1 ; i <= lngX / PIX ; i++) /*Application des modifications à la grille principale.*/
                for(j = 1 ; j <= lngY / PIX ; j++)
                    grille[i][j] = grilleModif[i][j];
            
            if(permutation) /*Condition vraie tous les deux tours.*/
            {
                for(i = 0 ; i <= lngX / PIX + 1 ; i++)
                    for(j = 0 ; j <= lngY / PIX + 1 ; j++)
                        if(grilleTest[i][j] == grille[i][j])
                            compteur++; /*On compte le nombre de cellules identiques entre la grille principale et la grille précédente de deux tours.*/
                
                if(compteur == (lngX / PIX + 2) * (lngY / PIX + 2))
                    continuer = 0; /*Si les grilles sont identiques la simulation recommence.*/
                else
                    for(i = 0 ; i <= lngX / PIX + 1 ; i++)
                        for(j = 0 ; j <= lngY / PIX + 1 ; j++)
                            grilleTest[i][j] = grille[i][j]; /*Sinon on copie la grille principale dans la grille précédente.*/
                
                compteur = 0; /*On réinitialise le compteur.*/
            }
            
            permutation = !permutation;
        }
        
        continuer = 1; /*On réinitialise la boucle principale.*/
    }
    
    for(i = 0 ; i <= lngX / PIX + 1 ; i++)
    {
        free(grille[i]); /*Libération des tableaux alloués dynamiquement.*/
        free(grilleModif[i]);
        free(grilleTest[i]);
    }
    
    free(grille);
    free(grilleModif);
    free(grilleTest);
    
    SDL_FreeSurface(vie); /*Libération des cellules.*/
    SDL_FreeSurface(mort);
    
    SDL_Quit(); /*Arrêt de la SDL*/
    
    return EXIT_SUCCESS; /*Fin du programme.*/
}

Lucas-84

10 septembre 2011 à 10:24:15

Elles sont où les fonctions ?

Staff désormais retraité.

schadocalex

10 septembre 2011 à 11:14:48

Mais pourquoi tu mets une licence sur un code bourrin non optimisé et personnel ? Qui aurait envie de le copier ? Bienvenue dans le monde de la pop-programmation.

"If debbugging is the process of removing bugs, then programming must be the process of putting them in." (Edsger Dijkstra)

Loadware

10 septembre 2011 à 11:39:48

@lucas-84 : Pour un code aussi court, je ne vois pas l'intérêt de créer des fonctions.

@schadocalex : Etant contre la pop-programmation je trouve ça insultant de dire que mettre une licence sur un projet est de la pop-programmation...

Lucas-84

10 septembre 2011 à 11:44:05

128 lignes le main quand même.

(enfin je dis ça, je dis rien... :-°)

Staff désormais retraité.

Loadware

10 septembre 2011 à 11:52:35

@lucas-84 : Je suis d'accord, mais pour moi une fonction est quelque chose qui doit être appelée plusieurs fois dans le code, or ici aucun morceau de code ne se répéte plusieurs fois...

paraze

10 septembre 2011 à 11:53:55

Citation : lucas-84

128 lignes le main quand même. (enfin je dis ça, je dis rien... :-°)

+1

Moi, c'est ce qui est avant la boucle principale qui me dérange un peu plus que le reste, c'est trop lourd.
En fait, en utilisant juste une fonction d'initialisation et de libération; ça irait déjà mieux.

Sinon, le code est bien commenté et tout ça.

Lucas-84

10 septembre 2011 à 11:58:31

Citation : Loadware

@lucas-84 : Je suis d'accord, mais pour moi une fonction est quelque chose qui doit être appelée plusieurs fois dans le code, or ici aucun morceau de code ne se répéte plusieurs fois...

Pas pour moi. :euh:

Si tu as une fonction de 10 000 lignes sans répétition, tu ne divises pas ?

Staff désormais retraité.

Loadware

10 septembre 2011 à 12:02:28

J'avoue

, je pourrais faire comme paraze "en utilisant juste une fonction d'initialisation et de libération" mais ma fonction main ne fait pas 10000 lignes, juste 128

Pouet_forever

10 septembre 2011 à 12:58:00

Loadware > Un code à trou comme ça avec une license ? alalalala, le monde est tombé bien bas. Je vais poster un code whil(i++) et je vais mettre une licence tiens !

Anonyme

10 septembre 2011 à 12:59:45

lucas-84> C'est marrant il y a eu un sujet à ce propos, il y a quelques jours. Tu devrais jeter un coup d'oeil à la réponse de Renault.

Twisted Destiny

10 septembre 2011 à 13:04:14

Citation : schadocalex

Mais pourquoi tu mets une licence sur un code bourrin non optimisé et personnel ? Qui aurait envie de le copier ? Bienvenue dans le monde de la pop-programmation.

Citation : Pouet_forever

Loadware > Un code à trou comme ça avec une license ? alalalala, le monde est tombé bien bas. Je vais poster un code whil(i++) et je vais mettre une licence tiens !

Il me semble que le but de ce topic c'est de donner des réponses constructives non?

J'ai remarqué un petit bug ici :

grille = malloc((lngX / PIX + 2) * sizeof(int));
    grilleModif = malloc((lngX / PIX + 2) * sizeof(int));
    grilleTest = malloc((lngX / PIX + 2) * sizeof(int));
    
    for(i = 0 ; i <= lngX / PIX + 1 ; i++) /*Allocation dynamique des tableaux en fonction de la résolution.*/
    {
        grille[i] = malloc((lngY / PIX + 2) * sizeof(int*));
        grilleModif[i] = malloc((lngY / PIX + 2) * sizeof(int*));
        grilleTest[i] = malloc((lngY / PIX + 2) * sizeof(int*));
    }

Tu dois inverser, mettre sizeof int* avant la boucle et sizeof int dans la boucle.

Mr21

10 septembre 2011 à 13:06:25

Alors déjà une fonction n'est pas censé faire plus de 30 lignes.
Et de deux on ne code pas dans le main, parce que si tu veux intégrer ce mini projet à un autre programme tu fais comment?
Y'aura deux main() du coup?

Un programme avec deux main() à du mal à compiler.

Loadware, peut être que ton code marche bien mais ils ont raison, il est pas propre...

schadocalex

10 septembre 2011 à 13:11:46

Citation : Mr21

Alors déjà une fonction n'est pas censé faire plus de 30 lignes.

Mais lol ! Mais ce n'est pas le sujet. Juste pour dire qu'en plus le nombre de lignes n'est pas significatif, ça dépend de l'indentation toussa. On continue sur un autre topic.

"If debbugging is the process of removing bugs, then programming must be the process of putting them in." (Edsger Dijkstra)

Lucas-84

10 septembre 2011 à 14:23:49

Citation : neowillow

lucas-84> C'est marrant il y a eu un sujet à ce propos, il y a quelques jours. Tu devrais jeter un coup d'oeil à la réponse de Renault.

Oui, justement j'avais suivi de loin le sujet en question. C'est peut-être une question subjective, mais de manière générale, vous ne pouvez nier que voir une fonction main de 128 lignes, c'est pas trop agréable. On s'y perd vite.

Citation : schadocalex

Citation : Mr21

Alors déjà une fonction n'est pas censé faire plus de 30 lignes.

Mais lol ! Mais ce n'est pas le sujet. Juste pour dire qu'en plus le nombre de lignes n'est pas significatif, ça dépend de l'indentation toussa. On continue sur un autre topic.

Bah si on est dans le sujet, on essaie de débattre sur l'optimisation d'un code...
Ah, en fait, après avoir regardé ci-dessus, je viens de remarquer que l'auteur du code a supprimé ce dernier. Là, effectivement, on est dans le hors sujet... :-°

Staff désormais retraité.

Loadware

10 septembre 2011 à 14:31:52

@lucas-84 : J'ai supprimé mon code car le but de ce sujet n'est pas de débattre dessus, d'autant plus qu'il n'intervient pas de le défi.

Pouet_forever

10 septembre 2011 à 14:42:01

Mais non, c'est instructif. Je remets ton code sans la pollution que tu avais mise :

#include <time.h>
#include <stdio.h>
#include <stdlib.h>
#include <SDL/SDL.h>

#define PIX 2 /*Taille en pixels d'une cellule.*/

int main(int argc, char *argv[])
{
  int recommencer = 1, continuer = 1, permutation = 0; /*Booléens.*/
  int **grille, **grilleModif, **grilleTest; /*Grilles de cellules.*/
  int i = 0, j = 0, somme = 0, compteur = 0, lngX = 640, lngY = 480;
  SDL_Surface *ecran = NULL, *vie = NULL, *mort = NULL;
  SDL_Event event;
  SDL_Rect position, **taille;
  
  srand(time(NULL));
  
  SDL_Init(SDL_INIT_VIDEO); /*Lancement de la SDL.*/
  
  SDL_ShowCursor(SDL_DISABLE);
  
  taille = SDL_ListModes(NULL, SDL_HWSURFACE | SDL_DOUBLEBUF | SDL_FULLSCREEN);
  lngX = taille[0]->w; /*Récupération de la résolution maximale de l'écran.*/
  lngY = taille[0]->h;
  
  grille = malloc((lngX / PIX + 2) * sizeof(int));
  grilleModif = malloc((lngX / PIX + 2) * sizeof(int));
  grilleTest = malloc((lngX / PIX + 2) * sizeof(int));
  
  for(i = 0 ; i <= lngX / PIX + 1 ; i++) /*Allocation dynamique des tableaux en fonction de la résolution.*/
  {
    grille[i] = malloc((lngY / PIX + 2) * sizeof(int*));
    grilleModif[i] = malloc((lngY / PIX + 2) * sizeof(int*));
    grilleTest[i] = malloc((lngY / PIX + 2) * sizeof(int*));
  }
  
  ecran = SDL_SetVideoMode(lngX, lngY, 32, SDL_HWSURFACE | SDL_DOUBLEBUF | SDL_FULLSCREEN);    
  SDL_WM_SetCaption("Jeu de la vie par Loadware", NULL); /*Création de la fenêntre en plein écran.*/
  SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 0, 128, 0));
  
  vie = SDL_CreateRGBSurface(SDL_HWSURFACE, PIX, PIX, 32, 0, 0, 0, 0);
  SDL_FillRect(vie, NULL, SDL_MapRGB(ecran->format, 128, 0, 0)); /*Création de la cellule vivante rouge.*/
  
  mort = SDL_CreateRGBSurface(SDL_HWSURFACE, PIX, PIX, 32, 0, 0, 0, 0);
  SDL_FillRect(mort, NULL, SDL_MapRGB(ecran->format, 0, 0, 0)); /*Création de la cellule morte noire.*/
  
  while(recommencer) /*Boucle permettant de recommencer une simulation.*/
  {
    for(i = 1 ; i <= lngX / PIX ; i++) /*Remplissage de la grille principale et de la grille des modifications.*/
      for(j = 1 ; j <= lngY / PIX ; j++)
        grille[i][j] = (grilleModif[i][j] = rand() % 2);
    
    while(continuer) /*Boucle principale de la simulation*/
    {
      SDL_Delay(80);
      
      SDL_PollEvent(&event);
      
      if(event.type == SDL_KEYDOWN)
      {
        recommencer = 0;
        continuer = 0; /*N'importe quelle touche du clavier arrête la simulation.*/
      }
      
      for(i = 1 ; i <= lngX / PIX ; i++)
      {
        for(j = 1 ; j <= lngY / PIX ; j++)
        {
          position.x = (i - 1) * PIX;
          position.y = (j - 1) * PIX;
          
          SDL_BlitSurface(grille[i][j] ? vie : mort, NULL, ecran, &position); /*Affichage de chaque cellule morte ou vivante suivant la grille principale.*/
        }
      }
      
      SDL_Flip(ecran); /*Mise à jour de l'écran.*/
      
      for(i = 1 ; i <= lngX / PIX ; i++)
      {
        for(j = 1 ; j <= lngY / PIX ; j++)
        {
          somme = grille[i-1][j-1] + grille[i][j-1] + grille[i+1][j-1] + grille[i-1][j] + grille[i+1][j] + grille[i-1][j+1] + grille[i][j+1] + grille[i+1][j+1];
          
          if(grille[i][j]) /*Coeur de la simulation : suivant le nombre de cellules adjacentes à la cellule courante, celle-ci meurt ou vie.*/
            grilleModif[i][j] = (somme < 2 || somme > 3) ? 0 : 1;
          else
            grilleModif[i][j] = (somme == 3) ? 1 : 0;
        }
      }
      
      for(i = 1 ; i <= lngX / PIX ; i++) /*Application des modifications à la grille principale.*/
        for(j = 1 ; j <= lngY / PIX ; j++)
          grille[i][j] = grilleModif[i][j];
      
      if(permutation) /*Condition vraie tous les deux tours.*/
      {
        for(i = 0 ; i <= lngX / PIX + 1 ; i++)
          for(j = 0 ; j <= lngY / PIX + 1 ; j++)
            if(grilleTest[i][j] == grille[i][j])
              compteur++; /*On compte le nombre de cellules identiques entre la grille principale et la grille précédente de deux tours.*/
        
        if(compteur == (lngX / PIX + 2) * (lngY / PIX + 2))
          continuer = 0; /*Si les grilles sont identiques la simulation recommence.*/
        else
          for(i = 0 ; i <= lngX / PIX + 1 ; i++)
            for(j = 0 ; j <= lngY / PIX + 1 ; j++)
              grilleTest[i][j] = grille[i][j]; /*Sinon on copie la grille principale dans la grille précédente.*/
        
        compteur = 0; /*On réinitialise le compteur.*/
      }
      
      permutation = !permutation;
    }
    
    continuer = 1; /*On réinitialise la boucle principale.*/
  }
  
  for(i = 0 ; i <= lngX / PIX + 1 ; i++)
  {
    free(grille[i]); /*Libération des tableaux alloués dynamiquement.*/
    free(grilleModif[i]);
    free(grilleTest[i]);
  }
  
  free(grille);
  free(grilleModif);
  free(grilleTest);
  
  SDL_FreeSurface(vie); /*Libération des cellules.*/
  SDL_FreeSurface(mort);
  
  SDL_Quit(); /*Arrêt de la SDL*/
  
  return EXIT_SUCCESS; /*Fin du programme.*/
}

Lucas-84

10 septembre 2011 à 15:10:09

Citation : Loadware

@lucas-84 : J'ai supprimé mon code car le but de ce sujet n'est pas de débattre dessus, d'autant plus qu'il n'intervient pas de le défi.

Bah si, le but du sujet c'est d'améliorer les codes des participants. De plus, ton code représentait un jeu de la vie, ce qui correspond au sujet...

Staff désormais retraité.

1 2 3 >>