/*-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.*/
}

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*));
    }

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