SDL_Surface *mine; // une seule surface que l'on blittera plusieur fois
        mine = SDL_CreateRGBSurface(SDL_HWSURFACE, 3, 3, 32, 0, 0, 0, 0);
        SDL_FillRect(mine, NULL, SDL_MapRGB(ecran->format, 255, 0, 0));

        SDL_Rect positionMine[NOMBREMINE]; // un tableaa contenant la position des mines
        SDL_Rect temp[NOMBREMINE]; // le même tableau mais temporaire pour vérifier que les mines ne se trouve pas deux fois au même endroit

        srand(time(NULL)); // on initialyse l'alea


        int i, j; // les variables de parcours de boucle for
        long nombreAleatoireX, nombreAleatoireY;

        for(i=0; i<NOMBREMINE; i++)
        {
                for(j=0; j<=i; j++) // cette boucle sert à comparer les valeurs pour zapper les redondance dans les positions des mines
                {
                        do
                        {
                                nombreAleatoireX = (rand() % (MAX - MIN + 1)) + MIN;
                        }while(nombreAleatoireX == temp[j].x);
       
                        do
                        {
                                nombreAleatoireY = (rand() % (MAX - MIN + 1)) + MIN;

                        }while(nombreAleatoireY == temp[j].y);

                }

                        temp[i].x = nombreAleatoireX;
                        temp[i].y = nombreAleatoireY;
        }
       

        for(i=0; i<NOMBREMINE; i++)
        {
                positionMine[i].x = ((23 * temp[i].x) + (TAILLECASE / 2));
                positionMine[i].y = ((23 * temp[i].y) + (TAILLECASE / 2));
                SDL_BlitSurface(mine, NULL, ecran, &positionMine[i]); // a la fin on ne les blittera qu'en certain cas mais la c'est pour vérifier ...
        }
               

       
       
       
        SDL_Flip(ecran);

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


// ----------------- Settings --------------- //
#define NOMBRECASE 10
#define TAILLECASE 21 // les cases feront 25x25 px
#define HAUTEUR (NOMBRECASE * (TAILLECASE + 2) + 2)
#define LARGEUR (NOMBRECASE * (TAILLECASE + 2) + 2)
#define NOMBREMINE 10
#define MIN 1
#define MAX 10
// ---------------- **Settings** -------------- //




int main(int argc, char *argv[])
{
        // ------------------------- Init SDL ------------------------ //
        SDL_Init(SDL_INIT_VIDEO);
        SDL_WM_SetCaption("Démineur", NULL);

                // --------------- écran --------------- //
                SDL_Surface *ecran;
                ecran = SDL_SetVideoMode(LARGEUR, HAUTEUR, 32, SDL_HWSURFACE|SDL_DOUBLEBUF);
                SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 0, 0, 0));
                // -------------- **ecran** -------------- //
                //
                // -------------- Les cases ------------ //
                SDL_Surface *cases;
                cases = SDL_CreateRGBSurface(SDL_HWSURFACE, TAILLECASE, TAILLECASE, 32, 0, 0, 0, 0);
                SDL_FillRect(cases, NULL, SDL_MapRGB(ecran->format, 150, 150, 150));
               
                SDL_Rect positionCase;
                int x, y;
                for(x=0; x<NOMBRECASE; x++)
                {
                        for(y=0; y<NOMBRECASE; y++)
                        {
                                positionCase.x = (x * (TAILLECASE + 2)) + 2;
                                positionCase.y = (y * (TAILLECASE + 2)) + 2;
                                SDL_BlitSurface(cases, NULL, ecran, &positionCase);
                               
                        }
                }
                SDL_Flip(ecran);
                // -------------- **les cases** ----------- //

        // ------------------------- **Init SDL** ------------------------- //
       

        // ---------------------------- Les mines -------------------------- //
        SDL_Surface *mine; // une seule surface que l'on blittera plusieur fois
        mine = SDL_CreateRGBSurface(SDL_HWSURFACE, 3, 3, 32, 0, 0, 0, 0);
        SDL_FillRect(mine, NULL, SDL_MapRGB(ecran->format, 255, 0, 0));

        SDL_Rect positionMine[NOMBREMINE]; // un tableaa contenant la position des mines
        SDL_Rect temp[NOMBREMINE]; // le même tableau mais temporaire pour vérifier que les mines ne se trouve pas deux fois au même endroit

        srand(time(NULL)); // on initialyse l'alea


        int i, j; // les variables de parcours de boucle for
        long nombreAleatoireX, nombreAleatoireY;

        for(i=0; i<NOMBREMINE; i++)
        {
                for(j=0; j<=i; j++) // cette boucle sert à comparer les valeurs pour zapper les redondance dans les positions des mines
                {
                        do
                        {
                                nombreAleatoireX = (rand() % (MAX - MIN + 1)) + MIN;
                        }while(nombreAleatoireX == temp[j].x);
       
                        do
                        {
                                nombreAleatoireY = (rand() % (MAX - MIN + 1)) + MIN;

                        }while(nombreAleatoireY == temp[j].y);

                }

                        temp[i].x = nombreAleatoireX;
                        temp[i].y = nombreAleatoireY;
        }
       

        for(i=0; i<NOMBREMINE; i++)
        {
                positionMine[i].x = ((23 * temp[i].x) + (TAILLECASE / 2));
                positionMine[i].y = ((23 * temp[i].y) + (TAILLECASE / 2));
                SDL_BlitSurface(mine, NULL, ecran, &positionMine[i]); // a la fin on ne les blittera qu'en certain cas mais la c'est pour vérifier ...
        }
               

       
       
       
        SDL_Flip(ecran);
               
        // ------------------------ **Les mines** ------------------------//
       
       
       

        // --------------------- boucle ppale --------------------- //

        SDL_Event event;
        int bouclePrincipale = 1;
        while(bouclePrincipale)
        {
                SDL_WaitEvent(&event);
                switch(event.type)
                {
                        case SDL_QUIT:
                                bouclePrincipale = 0;
                                break;
                        case SDL_KEYDOWN:
                                switch(event.key.keysym.sym)
                                {
                                        case SDLK_ESCAPE:
                                                bouclePrincipale = 0;
                                                break;
                                        default:
                                                break;
                                }
                        default:
                                break;
                }
        }

        // ------------------- **Boucle ppale**----------------------- //
       
        // ------------------- Phase de Nettoyage ---------------------- //
        SDL_FreeSurface(cases);
                                       
        SDL_Quit();
        return EXIT_SUCCESS;
        // ------------------------- **phase de nettoyage** ----------------- //
}

   

/* Énumération */
   enum{VIDE = 0, FLAG = 1, BOMB = 2, CLICKER = 3, ONCLICK = 4};

     srand(time(NULL));
     int nbBomb = 0;
     int i = 0, j = 0;
     nbBomb = ((NB_BLOC_HAUTEUR * NB_BLOC_LARGEUR) / 10);
     int NbBomb = 0;
     
     int placeBombX = 0;
     int placeBombY = 0;

 do{
     placeBombX = rand() % NB_BLOC_LARGEUR;
     placeBombY = rand() % NB_BLOC_HAUTEUR;
     
     if(carte[placeBombX][placeBombY].case == BOMB)//si il y a déja une bombe
         continue;
     else
      carte[placeBombX][placeBombY].case = BOMB;
     
     NbBomb++;       
     }while(NbBomb != nbBomb);//tant que le nombre de bomb n'Est pas égale au nombre de bomb voulu