Partage
  • Partager sur Facebook
  • Partager sur Twitter

zMorp SDL

    1 janvier 2011 à 17:22:40

    Tu as des bugs aussi, quand un joueur à cliqué sur la case de gauche, pour cliquer sur celle juste à droite il faut cliquer genre 15 pixels plus loin. :-°
    Si je ramène ta grille sur 3x3 ça bug :

    Image utilisateur

    Pour ton problème de segfault, c'est que tu fais des SDL_Quit un peu n'importe où, du coup quand tu appelles les fonctions ça ne va pas. Et, si la fonction exit fonctionne sous linux, c'est standard. ;)

    Edit: Et tu as noté gange et pas gagne. ^^
    • Partager sur Facebook
    • Partager sur Twitter
      1 janvier 2011 à 17:43:34

      C'est bizarre, car chez moi ça marche :
      <object width="480" height="360" type="application/x-shockwave-flash" data="http://www.youtube.com/v/PVWm_OAepCo"><param name="movie" value="http://www.youtube.com/v/PVWm_OAepCo" /><param name="allowFullScreen" value="true" /><param name="wmode" value="transparent" /></object>


      Citation : Pouet_forever


      Edit: Et tu as noté gange et pas gagne. ^^


      :lol: je corrige ça tout de suite .

      # include <stdlib.h>
      # include <stdio.h>
      # include <SDL.h>
      # define ecran SDL_GetVideoSurface()
      # define TABW 3
      # define TABH 3
      # define CASEW 200
      # define NONE -1
      
      typedef struct
      {
          int quit, clicked;
          char key[SDLK_LAST];
          SDL_Rect clic;
      } Input;
      
      typedef struct
      {
          int x,y;
      } Pos;
      
      enum {DRAW,KEEP};
      enum {YES,NO};
      
      void UpdateEvents(Input* in)
      {
          SDL_Event event;
          SDL_WaitEvent(&event);
          switch (event.type)
          {
          case SDL_KEYDOWN:
              in->key[event.key.keysym.sym]=1;
              break;
          case SDL_KEYUP:
              in->key[event.key.keysym.sym]=0;
              break;
          case SDL_QUIT:
              in->quit = 1;
              break;
          case SDL_MOUSEBUTTONDOWN:
              if ( event.button.button == SDL_BUTTON_LEFT)
              {
                  in->clicked = 1;
                  in->clic.x = event.button.x;
                  in->clic.y = event.button.y;
              }
      
              break;
      
          default:
              break;
          }
      
      }
      void replay (int *tab, int *role,int who_won);
      void draw (int* tab)
      {
          Uint32 colors[] = {SDL_MapRGB(ecran->format,255,255,255),
                             SDL_MapRGB(ecran->format,200,0,40),
                             SDL_MapRGB(ecran->format,0,200,40)
                            };
          int i,j;
          SDL_Rect p;
          SDL_FillRect(ecran,NULL,SDL_MapRGB(ecran->format,0,0,0));
          for ( i = 0; i < TABW; i++)
              for ( j = 0; j < TABH; j++)
              {
                  p.x = i * CASEW + i * 10;
                  p.y = j * CASEW + j * 10;
                  p.w = CASEW;
                  p.h = CASEW;
                  SDL_FillRect(ecran,&p,colors[tab[i + j*TABW]]);
              }
          SDL_Flip(ecran);
      }
      
      int grille ( int *tab,int role, Pos l)
      {
          int i;
          Pos test[] =
          {
              {l.x -1, l.y},{l.x+1,l.y},
              {l.x,l.y -1},{l.x,l.y+1},
              {l.x -1, l.y +1},{l.x -1, l.y -1},
              {l.x +1, l.y +1},{l.x +1, l.y -1},
          };
          Pos test2[] =
          {
              {l.x -2, l.y},{l.x+2,l.y},
              {l.x,l.y -2},{l.x,l.y+2},
              {l.x -2, l.y +2},{l.x -2, l.y -2},
              {l.x +2, l.y +2},{l.x +2, l.y -2}
          };
      
          int tab_p[8] = {0};
      
      
          Pos now,now2;
          for ( i = 0; i < 4; i++)
          {
              now = test[i];
              if ( now.x >=0 && now.x < TABW && now.y >=0 && now.y < TABH )
              {
                  if ( tab[now.x  + now.y *TABW] == role)
                  {
                      tab_p[i] = 1;
                      now2 = test2[i];
                      if ( (tab_p[2] == 1 && tab_p[3] == 1)
                              || ((tab_p[6] == 1 && tab_p[7] == 1))
                              || (tab_p[0] == 1 && tab_p[1] == 1)
                              || (tab_p[4] == 1 && tab_p[7] == 1)
                              || (tab_p[5] == 1 && tab_p[6] == 1))
                          return 1;
      
                      if ( now2.x >=0 && now2.x < TABW && now2.y >=0 && now2.y < TABH )
                          if ( tab[now2.x  + now2.y *TABW] == role)
                              return 1;
                  }
              }
          }
      
          for ( i = 0; i < 8; i++)
          {
              now = test[i];
              if ( now.x >=0 && now.x < TABW && now.y >=0 && now.y < TABH )
              {
                  if ( tab[now.x  + now.y *TABW] == role)
                  {
                      tab_p[i] = 1;
                      now2 = test2[i];
                      if ( (tab_p[2] == 1 && tab_p[3] == 1)
                              || ((tab_p[6] == 1 && tab_p[7] == 1))
                              || (tab_p[0] == 1 && tab_p[1] == 1)
                              || (tab_p[4] == 1 && tab_p[7] == 1)
                              || (tab_p[5] == 1 && tab_p[6] == 1))
                          return 1;
                  }
              }
          }
          return 0;
      }
      int check_winner (int *tab, Pos *last)
      {
          int i,j, cpt = TABW * TABH;
          for ( i = 0; i < TABW; i++)
              for ( j = 0; j < TABH; j++)
              {
                  if ( tab[i + j * TABW] != 0)
                      cpt --;
              }
          if ( cpt == 0)
              return DRAW;
          return KEEP;
      }
      
      void check_clic (int *tab,int *role,SDL_Rect *c)
      {
          int i,j,r;
      
          i = c->x / CASEW;
          j = c->y / CASEW;
          Pos last_clic = {NONE,NONE};
          if ( i >= 0 && i < TABW && j >= 0 && j < TABH)
          {
              if (tab[i + j*TABW]  == 0 )
              {
                  tab[i + j*TABW] = *role;
                  (*role) ++;
                  if ( *role > 2)
                      *role = 1;
      
      
                  last_clic.x = i;
                  last_clic.y = j;
      
                  r = *role;
      
                  if ( r == 2)
                      r = 1;
      
                  else if ( r == 1)
                      r = 2;
      
                  if (grille(tab,r,last_clic) == 1)
                  {
                      draw(tab);
                      replay(tab,role,r);
                  }
      
                  if (check_winner(tab,&last_clic) == DRAW)
                  {
                      draw(tab);
                      replay(tab,role,0);
                  }
      
              }
          }
      }
      
      void reset ( int *tab, int *role)
      {
          int i,j;
          for ( i = 0; i < TABW; i++)
              for ( j = 0; j < TABH; j++)
                  tab[i + j *TABW] =0;
          *role = 1;
      
      }
      
      int wait (void)
      {
          SDL_Event ev;
          int done = 0;
          while (!done)
          {
              SDL_WaitEvent(&ev);
              if ( ev.type == SDL_KEYDOWN)
              {
                  if (ev.key.keysym.sym == SDLK_y)
                      return YES;
                  if ( ev.key.keysym.sym == SDLK_n)
                      return NO;
              }
              if ( ev.type == SDL_QUIT)
              {
                  SDL_Quit();
                  exit(EXIT_SUCCESS);
              }
      
          }
      }
      
      void replay (int *tab, int *role,int who_won)
      {
          char ch[80] = "";
          if ( who_won == 0)
          {
              SDL_WM_SetCaption("Egalite ! Voulez vous recommencez ? (Oui : y, Non : n)",NULL);
              if ( wait() == YES)
                  reset(tab,role);
              else
              {
                  SDL_Quit();
                  exit(EXIT_SUCCESS);
              }
          }
          else
          {
              sprintf(ch,"Joueur %d a gagne, Voulez vous recommencez ? (Oui : y, Non : n)",who_won);
              SDL_WM_SetCaption(ch,NULL);
              if ( wait() == YES)
                  reset(tab,role);
      
              else
              {
                  SDL_Quit();
                  exit(EXIT_SUCCESS);
              }
          }
      
      }
      
      void events (int *tab, int *role, Input *in)
      {
      
          if ( in->clicked)
          {
              check_clic(tab,role,&in->clic);
              in->clicked = 0;
          }
      
      }
      
      void info (int *role)
      {
          char ch[30] = "";
          sprintf(ch,"C'est au joueur %d de jouer",*role);
          SDL_WM_SetCaption(ch,NULL);
      }
      
      int main (int argc, char **argv)
      {
          Input in;
          int tab[TABH*TABW] = {0}, role = 1;
      
          putenv("SDL_VIDEO_CENTERED=1");
          SDL_Init(SDL_INIT_VIDEO);
          SDL_SetVideoMode(TABW*CASEW + 10,TABH*CASEW + 10,32,SDL_HWSURFACE|SDL_DOUBLEBUF);
      
          memset(&in,0,sizeof(in));
      
      
          while ( !in.key[SDLK_ESCAPE]&&!in.quit)
          {
              UpdateEvents(&in);
              info(&role);
              events(tab,&role,&in);
              draw(tab);
          }
      
          return EXIT_SUCCESS;
      }
      
      • Partager sur Facebook
      • Partager sur Twitter
        1 janvier 2011 à 18:12:06

        Citation : Pouet_forever

        C159 >

        "_My_SDL_ChargerImage", referenced from:
        ça je m'en occupe : j'edite
        -> c'est parce que d'habitude je charge l'icone mais j'ai pensé que vous avais pas besoin de la fonction.

        sinon normalement ça doit marcher maintenant, j'ai supprimé l'appel à la fonction, modifié le prototype, modifié la fonction pour ne pas mettre d'icone

        si un autre probleme dis le moi
        • Partager sur Facebook
        • Partager sur Twitter
          1 janvier 2011 à 22:03:35

          @Reino: chouette code... ;)
          Mais bon, pour toi, je sais que tu es déjà bien à l'aise avec la SDL.
          Au premier regard, c'est séparé de la logique, bravo...

          @c159:
          pareil, tu as tes fonctions utilitaires SDL, et tu construis à coté.j'aime bien...

          Je vais regarder plus en détail, mais à première vue, j'ai peu de choses à reprocher...

          Merci à vous, pour la participation.

          :)
          • Partager sur Facebook
          • Partager sur Twitter
          Zeste de Savoir, le site qui en a dans le citron !
            1 janvier 2011 à 22:04:20

            Je pense que cet exercice est une bonne idée pour les novices de SDL :)
            • Partager sur Facebook
            • Partager sur Twitter

            Recueil de codes en C et C++ http://fvirtman.free.fr/recueil/index.html

              2 janvier 2011 à 1:36:25

              Voilà pour moi :) :

              #include <SDL.h>
              #include <IMG/SDL_image.h>
              
              #define SCR_W 320
              #define SCR_H 320
              
              #define NUM_CELL 3
              
              enum
              {
                  VOID,
                  ROND,
                  CROIX
              };
              
              typedef struct Input Input;
              struct Input
              {
                  int key[SDLK_LAST];
                  int mouse[6];
                  int mouse_x,
                      mouse_y,
                      mouse_xrel,
                      mouse_yrel;
                  int quit;
              };
              
              int update(Input* in)
              {
                  SDL_Event event;
                  if(!SDL_PollEvent(&event))
                      return 0;
              
                  switch (event.type)
                  {
                      case SDL_KEYDOWN:
                          in->key[event.key.keysym.sym] = 1;
                          break;
              
                      case SDL_KEYUP:
                          in->key[event.key.keysym.sym] = 0;
                          break;
              
                      case SDL_MOUSEBUTTONDOWN:
                          in->mouse[event.button.button] = 1;
                          break;
              
                      case SDL_MOUSEBUTTONUP:
                          in->mouse[event.button.button] = 0;
                          break;
              
                      case SDL_MOUSEMOTION:
                          in->mouse_x = event.motion.x;
                          in->mouse_y = event.motion.y;
                          in->mouse_xrel = event.motion.xrel;
                          in->mouse_yrel = event.motion.yrel;
                          break;
              
                      case SDL_QUIT:
                          in->quit = 1;
                          break;
                  }
              
                  return 1;
              }
              
              void SDL_SetPixel32(SDL_Surface* img, int x, int y, Uint32 pixel)
              {
                  *((Uint32*)(img->pixels) + x + y * img->w) = pixel;
              }
              
              void drawAlignedAxisLine(SDL_Surface* img, int x1, int y1, int l, int vertical, Uint32 color)
              {
                  if (!vertical)
                      for (int i = x1 ; i < l ; i++)
                          SDL_SetPixel32(img, i, y1, color);
                  else
                      for (int i = y1 ; i < l ; i++)
                          SDL_SetPixel32(img, x1, i, color);
              }
              
              void drawRect(SDL_Surface* img, int x1, int y1, int w, int h, Uint32 color)
              {
                  for (int i = x1 ; i < x1+w ; i++)
                      drawAlignedAxisLine(img, i, y1, y1+h, 1, color);
              }
              
              int main(int argc, char** argv)
              {
                  SDL_Surface* screen = NULL, *rond = NULL, *croix = NULL;
                  Input in;
                  bool done = false;
              
                  int plateau[NUM_CELL][NUM_CELL] = {{VOID},{VOID}};
                  int joueur = CROIX;
                  int victory = 0;
              
                  SDL_Init(SDL_INIT_VIDEO);
                  screen = SDL_SetVideoMode(SCR_W, SCR_H, 32, SDL_HWSURFACE);
                  SDL_WM_SetCaption("Morpion", NULL);
              
                  rond = IMG_Load("rond.png");
                  croix = IMG_Load("croix.png");
              
                  memset(&in, 0, sizeof(Input));
              
                  SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 255, 255, 255));
              
                  drawRect(screen, (SCR_W-8)/3, 0, 4, SCR_H, SDL_MapRGB(screen->format, 0, 0, 0));
                  drawRect(screen, ((SCR_W-8)/3)*2+4, 0, 4, SCR_H, SDL_MapRGB(screen->format, 0, 0, 0));
                  drawRect(screen, 0, ((SCR_H-8)/3), SCR_W, 4, SDL_MapRGB(screen->format, 0, 0, 0));
                  drawRect(screen, 0, ((SCR_H-8)/3)*2+4, SCR_W, 4, SDL_MapRGB(screen->format, 0, 0, 0));
              
                  while (!done)
                  {
                      if(update(&in)) // s'il y a eu un nouvel évènement
                      {
                          if (in.quit)
                              done = true;
              
                          if (in.mouse[SDL_BUTTON_LEFT] && !victory)
                          {
                              int num_x = in.mouse_x/((SCR_W)/3);
                              int num_y = in.mouse_y/((SCR_H)/3);
                              if (plateau[num_x][num_y] != VOID)
                                  continue;
                              SDL_Rect pos;
                              pos.x = num_x*(SCR_W-8)/3 + num_x*4;
                              pos.y = num_y*(SCR_H-8)/3 + num_y*4;
                              SDL_BlitSurface((joueur == CROIX) ? croix : rond, NULL, screen, &pos);
                              plateau[num_x][num_y] = joueur;
                              joueur = (joueur == CROIX) ? ROND : CROIX;
              
                              // test de victoire
                              for (int type = ROND ; type <= CROIX ; type++)
                              {
                                  for (int i = 0 ; i < 3 ; i++)
                                      if (plateau[i][0] == type && plateau[i][1] == type && plateau[i][2] == type
                                      ||  plateau[0][i] == type && plateau[1][i] == type && plateau[2][i] == type)
                                          victory = 1;
              
                                      if (plateau[0][0] == type && plateau[1][1] == type && plateau[2][2] == type
                                      ||  plateau[0][2] == type && plateau[1][1] == type && plateau[2][0] == type)
                                          victory = 1;
                              }
                          }
              
                      }
              
                      if (victory)
                      {
                          // petite animation de victoire
                          SDL_Rect pos;
                          pos.x = (rand() % SCR_W-croix->w - 0 + 1) + 0;
                          pos.y = (rand() % SCR_H-croix->h - 0 + 1) + 0;
                          SDL_BlitSurface((joueur == CROIX) ? rond : croix, NULL, screen, &pos);
                          SDL_Delay(10);
                      }
              
                      SDL_Flip(screen);
                  }
              
                  SDL_FreeSurface(rond);
                  SDL_FreeSurface(croix);
              
                  SDL_Quit();
                  return EXIT_SUCCESS;
              }
              


              screenshot:

              Image utilisateur

              Le design laisse un peu à désirer mais bon :-°
              • Partager sur Facebook
              • Partager sur Twitter
                2 janvier 2011 à 11:23:14

                Citation : Rom1-27


                Le design laisse un peu à désirer mais bon :-°


                Tu sais, ça reste un morpion, aussi.

                On peut te reprocher d'avoir toute la logique de ton jeu dans la fonction main.

                Sinon, ta fonction.

                drawAlignedAxisLine
                

                La fonction SDL_FillRect de la SDL peut faire le même travail, avec(w ou h à 1), et ça t'évites de devoir sortir un putpixel.

                La gestion des events façon, Fvirtman, complique un peu le code (dans le cas d'un morpion), j'ai l'impression.

                La fonction SDL_GetMouseState, permet de récupérer la position de la souris, ainsi que l'état des boutons en un seul appel de fonction.
                • Partager sur Facebook
                • Partager sur Twitter
                Zeste de Savoir, le site qui en a dans le citron !
                  2 janvier 2011 à 15:12:48

                  Petite question : Est-ce que vous voulez qu'on commente votre code ?

                  reino > Ce n'est pas parce que ça fonctionne chez toi que ça fonctionne partout. C'est qu'il y a un problème dans ton code quelque part. ;)
                  • Partager sur Facebook
                  • Partager sur Twitter
                    2 janvier 2011 à 15:41:49

                    Citation

                    reino > Ce n'est pas parce que ça fonctionne chez toi que ça fonctionne partout. C'est qu'il y a un problème dans ton code quelque part. ;)

                    forcément :) Mais je doute qu'il est toujours d'actualité, puisque je viens de modifier mon code ^^ .
                    • Partager sur Facebook
                    • Partager sur Twitter
                      2 janvier 2011 à 15:45:06

                      Les problèmes cités sont toujours là, sauf le segfault. :(

                      Image utilisateur

                      Et tu as pas répondu, tu veux qu'on commente ton code ? :)
                      • Partager sur Facebook
                      • Partager sur Twitter
                        2 janvier 2011 à 15:52:44

                        Humm...
                        Si c'est possible est ce que tu peux lancer le débogueur et me dire (a l'aide des breakpoints) quelle ligne renvoie 1 ,est ce celle la ?

                        if ( (tab_p[2] == 1 && tab_p[3] == 1)
                                            || ((tab_p[6] == 1 && tab_p[7] == 1))
                                            || (tab_p[0] == 1 && tab_p[1] == 1)
                                            || (tab_p[4] == 1 && tab_p[7] == 1)
                                            || (tab_p[5] == 1 && tab_p[6] == 1))
                                            return 1;
                        


                        ou :
                        if ( tab[now2.x  + now2.y *TABW] == role)
                                                return 1;
                        


                        Citation : Pouet_forever

                        Et tu as pas répondu, tu veux qu'on commente ton code ? :)


                        J'aimerais bien, oui ^^
                        Merci ^^
                        • Partager sur Facebook
                        • Partager sur Twitter
                          2 janvier 2011 à 15:56:10

                          La 2ème.

                          if ( now2.x >=0 && now2.x < TABW && now2.y >=0 && now2.y < TABH )
                                    if ( tab[now2.x  + now2.y *TABW] == role)
                                      return 1;
                          

                          Je commenterai ton code plus tard. ;)
                          • Partager sur Facebook
                          • Partager sur Twitter
                            2 janvier 2011 à 18:39:02

                            Citation : C159

                            tu pourrais commenter le mien aussi ?



                            Je me permet de le faire ;)
                            ces lignes
                            if (ALLIGNE(Grille[0][0], Grille[0][1], Grille[0][2])||
                                        ALLIGNE(Grille[1][0], Grille[1][1], Grille[1][2])||
                                        ALLIGNE(Grille[2][0], Grille[2][1], Grille[2][2])||
                                        ALLIGNE(Grille[0][0], Grille[1][0], Grille[2][0])||
                                        ALLIGNE(Grille[0][1], Grille[1][1], Grille[2][1])||
                                        ALLIGNE(Grille[0][2], Grille[1][2], Grille[2][2])||
                                        ALLIGNE(Grille[0][0], Grille[1][1], Grille[2][2])||
                                        ALLIGNE(Grille[0][2], Grille[1][1], Grille[2][0]))
                            


                            Le jour ou tu change la taille de ta grille, tu vas souffrir. :D

                            Mais c'est un problème que tu avais déjà dans la version console.
                            • Partager sur Facebook
                            • Partager sur Twitter
                            Zeste de Savoir, le site qui en a dans le citron !
                              2 janvier 2011 à 20:50:51

                              va faloir que je réfléchisse à un algorytme mais j'en ai aucune idée donc si tu veux m'ider un petit peu ça serait pas de refus :euh:
                              • Partager sur Facebook
                              • Partager sur Twitter
                                2 janvier 2011 à 21:00:13

                                Mon code sur zMorp, ou le code de pouet...

                                Après on devra expliquer, surement...
                                Mais on gère des grilles de toutes les tailles. ;)
                                • Partager sur Facebook
                                • Partager sur Twitter
                                Zeste de Savoir, le site qui en a dans le citron !
                                  2 janvier 2011 à 21:15:59

                                  Image utilisateur
                                  Pour vérifier si on a gagné: il faut que y reste constant, y = last_clic.y, et on va modifier la valeur de x vers la droite (x += 1) et vers la gauche ( x -= 1), si on retrouve le signe du joueur actuelle on incrémente un compteur.
                                  Dans le code suivant :
                                  int compterDir(int * tab, Coord * c, int x, int y, int joueur) {
                                    int cnt, i, j;
                                    
                                    cnt = 0; // le compteur
                                    for (j = c->x + x, i = c->y + y; // pour notre cas i doit être constat, don on l'affecte a c->y(last_clic.y) et on lui ajoute y qui vaut 0. tandis que j doit être altérer, pour vérifier a droite on lui ajoute x qui vaut 1 et pour vérifier vers la droite on lui ajoute x et qui vaut dans ce cas -1.
                                         (unsigned) j < TAB_W && (unsigned) i < TAB_H &&
                                         tab[i * TAB_W + j] == joueur; i += y, j += x)
                                      cnt++;
                                    
                                    return cnt;
                                  }
                                  
                                  int testerGrille(int * tab, Coord * c, int joueur) {
                                    Coord dir[4] = {
                                      { 0, 1 }, { 1,  0 }, //  { 1,  0 } ce couple représente notre cas ou on vérifie vers la droite 
                                      { 1, 1 }, { 1, -1 }
                                    };
                                    int cnt, i;
                                    
                                    for (i = 0; i < 4; i++) {
                                      cnt =  compterDir(tab, c, dir[i].x,  dir[i].y,  joueur);
                                      cnt += compterDir(tab, c, -dir[i].x, -dir[i].y, joueur); // ici c'est le contraire de { 1,  0 } donc on vérifie vers la gauche { -1,  0 } 
                                      if (cnt + 1 >= NBR_P) //
                                        return 1;
                                    }
                                    
                                    return 0;
                                  }
                                  


                                  le reste c'est la même chose ^^ . Le mieux c'est de prendre un papier est schématisé le tout, tu verras certainement comment faire ^^
                                  • Partager sur Facebook
                                  • Partager sur Twitter
                                    3 janvier 2011 à 7:23:53

                                    ok merci je vais y réffléchir

                                    EDIT voila j'avais fais ça :

                                    bool NEWgagner(Signe Grille[NOMBRECASE][NOMBRECASE], int JOUEUR, int nombreCoups)
                                    {
                                        char *chaine[] = {"- MORPION - J1 gagne", "- MORPION - J2 gagne", "- MORPION - MATCH NUL"};
                                        int x, y;
                                        int i,j;
                                        int nombreAlignementV = 0, nombreAlignementH = 0, nombreAlignementD1 = 0, nombreAlignementD2 = 0;
                                        for (x = 0 ; x < NOMBRECASE ; x++)
                                        {
                                            for (y = 0 ; y < NOMBRECASE ; y++)
                                            {
                                                if (Grille[x][y] == VIDE)continue;
                                                //on vérifie ceux qui sont horisontaux
                                                for (i = x , j = y ; i < NOMBRECASE ; i++)
                                                {
                                                    if(Grille[i][j] == VIDE)break;
                                                    if(Grille[x][y] == Grille[i][j])nombreAlignementH++;
                                                }
                                                //on vérifie ceux qui sont verticaux
                                                for (j = y , i = x ; j < NOMBRECASE ; j++)
                                                {
                                                    if(Grille[i][j] == VIDE)break;
                                                    if(Grille[x][y] == Grille[i][j])nombreAlignementV++;
                                                }
                                            }
                                        }
                                        if(nombreAlignementV == NOMBRECASEALIGNEPOURGAGNER ||
                                           nombreAlignementH == NOMBRECASEALIGNEPOURGAGNER)
                                            return true;
                                        return false;
                                    }
                                    
                                    mais j'ai un problème : quand j'ai mis 3 cases dans la grille(J1, J2, J1)je pense que ça doit venir des conditions qui incrémente les variables mais j'ai aucune idée pour le résoudre
                                    EDIT 2 : j'ai corrigé et la fonction marche : voila la nouvelle :
                                    bool NEWgagner(Signe Grille[NOMBRECASE][NOMBRECASE], int JOUEUR, int nombreCoups)
                                    {
                                        char *chaine[] = {"- MORPION - J1 gagne", "- MORPION - J2 gagne", "- MORPION - MATCH NUL"};
                                        int x, y;
                                        int i,j;
                                        int nombreAlignementV = 0, nombreAlignementH = 0, nombreAlignementD1 = 0, nombreAlignementD2 = 0;
                                        for (x = 0 ; x < NOMBRECASE ; x++)
                                        {
                                            for (y = 0 ; y < NOMBRECASE ; y++)
                                            {
                                                if (Grille[x][y] == VIDE)continue;
                                                //on vérifie ceux qui sont horisontaux
                                                for (i = x , j = y ; i < NOMBRECASE ; i++)
                                                {
                                                    if(Grille[x][y] == Grille[i][j] && Grille[i][j] != VIDE)nombreAlignementH++;
                                                }
                                                if(nombreAlignementV == NOMBRECASEALIGNEPOURGAGNER)
                                                {
                                                    SDL_WM_SetCaption((JOUEUR == 1)? chaine[0] : chaine[1], NULL);
                                                    SDL_Delay(1000);
                                                    return true;
                                                }
                                                nombreAlignementV = 0;
                                                //on vérifie ceux qui sont verticaux
                                                for (j = y , i = x ; j < NOMBRECASE ; j++)
                                                {
                                                    if(Grille[x][y] == Grille[i][j] && Grille[i][j] != VIDE)nombreAlignementV++;
                                                }
                                                if(nombreAlignementH == NOMBRECASEALIGNEPOURGAGNER)
                                                {
                                                    SDL_WM_SetCaption((JOUEUR == 1)? chaine[0] : chaine[1], NULL);
                                                    SDL_Delay(1000);
                                                    return true;
                                                }
                                                nombreAlignementH = 0;
                                            }
                                        }
                                        if (nombreCoups == NOMBRECOUPMAX)
                                        {
                                            SDL_WM_SetCaption(chaine[2], NULL);
                                            SDL_Delay(1000);
                                            return true;
                                        }
                                        return false;
                                    }
                                    
                                    oui jze sais il me reste les diagonnales
                                    • Partager sur Facebook
                                    • Partager sur Twitter
                                      3 janvier 2011 à 19:44:18

                                      C159 >
                                      Le 3ème paramètre de SDL_SetVideoMode c'est pas le nombre de couleurs, mais le nombre de bits à utiliser pour afficher 1 pixel (bpp -> bits per pixel)
                                      Les noms de variable en majuscules sont généralement 'réservées' aux constantes. Je dis 'réservées' parce que tu n'as aucune obligation, mais c'est un style de codage que la plupart des gens utilisent.
                                      C'est pas trop mal ta fonction erreurSDL mais le problème c'est que si t'as le moindre écart dans ton programme tu le quittes, tu pourrais faire en sorte d'afficher un message et remédier au problème. Genre, si SDL_BlitSurface n'a pas réussi, tu attends un peu (SDL_Delay(1)) et tu recommences.
                                      Comme tu as fait un fichier spécial SDL, tu pourrais sauvegarder le pointeur retourné par SDL_GetVideoSurface dans une variable static globale à ton fichier.
                                      Tu pourrais protéger ton header contre l'inclusion infinie
                                      Tu pourrais faire en sorte d'avoir des noms de variable moins long (question de goût, mais c'est plus facile et rapide à lire d'avoir des noms courts)
                                      Quand tu déclares ta grille, comme VIDE est égal à 0 tu n'as pas besoin d'initialiser tous les champs
                                      Tu pourrais déclarer toutes tes variables en débugt de bloc
                                      Tu pourrais tirer le joueur qui commence aléatoirement, là c'est toujours le joueur 1 qui commence
                                      My_SDL_CreateRGBSurface ton nom est incorrect, tu 'fill' aussi ta surface
                                      Pareil pour 'couleur', ton nom est mal choisi
                                      ALIGNE ne prend qu'un seul L
                                      Tu pourrais utiliser un tableau pour tes surfaces de pions, ça te permettrait d'avoir un accès direct à ton tableau en fonction de la valeur de Grille[...][...]
                                      Tu pourrais enlever ton #define dans ta fonction AfficherGrille, il aurait mieux valu mettre le if dans la fonction, ça éclaircirait le code
                                      Dans ta fonction 'choix', le ternaire dans l'appel de fonction SDL_WM_SetCaption, je suis pas fan. Tu aurais pu faire un accès direct à ton tableau en fonction de la variable JOUEUR. Genre :


                                      char *chaine[] = { "", "- MORPION - J1 choix", "- MORPION - J2 choix"}; 
                                      SDL_WM_SetCaption(chaine[JOUEUR], NULL);
                                      

                                      Quand tu demandes à quitter (SDL_QUIT), tu fermes ton programme direct, tu pourrais libérer tes surfaces et pourquoi pas revenir dans le main si jamais tu ajoutes une fonction de fin d'exécution (genre comme SDL_Quit mais que tu ne peux pas appeler avec atexit).
                                      Grille[i][j] = (JOUEUR == 1)?JOUEUR1 : JOUEUR2; => inutile, il suffit de faire une affectation avec JOUEUR
                                      Dans ta fonction gagner, même remarque que plus haut pour le WM_SetCaption
                                      Je ne suis pas du tout fan de ta macro ALLIGNE pour tester ta grille, tu pourrais soit utiliser une fonction, soit tout mettre dans la même condition ou encore changer de technique pour tester un gagnant
                                      Tu pourrais faire une fonction 'rejouer'
                                      Tu pourrais plutôt attendre le clic de l'utilisateur plutôt que mettre une tempo, parce que la fenêtre qui se ferme quand le jeu est terminé, c'est pas très agréable. :x
                                      Quand nombreCoups == 9 tu as gagné ? je ne pense pas, le nom de ta fonction est mal choisie dans ce cas là
                                      Dans tes #define, tu devrais (dois?) mettre des parenthèses

                                      reino >
                                      Tu devrais modifier le nom de ta fonction 'wait', ça fait conflit avec la fonction wait de unistd.h qui est inclus par la SDL sur mac
                                      Ta fonction wait fait une boucle infinie (done n'est jamais modifié), tu pourrais mettre while(1) dans ce cas là
                                      Ta fonction wait retourne un int, mais en fin de fonction elle ne retourne rien (bien que ça ne serve à rien avec ta boucle infinie)
                                      Tu fais les procédures pour quitter dans ta fonction wait, tu devrais modifier le nom de la fonction dans ce cas là ; tu pourrais aussi ne pas quitter en plein milieu mais revenir au main au cas où tu voudrais rajouter des choses à ton jeu
                                      Tu ne vérifies pas l'initialisation de la SDL + la création de ta surface principale
                                      Pourquoi passer un pointeur à ta fonction info ?
                                      Tu pourrais tirer le joueur qui commence aléatoirement
                                      Ta fonction info est une fonction 'jetable' tu pourrais essayer de la modifier pour t'en servir plus souvent dans ton programme (replay par ex.)
                                      Le nom de tes fonctions sont mal choisies. Tu as une fonction UpdateEvents et une fonction events. Ta fonction events fait tout, elle appelle check_clic et ta fonction check_clic fait tout (tester si quelqu'un gagne, rejouer, 'fin bref...). Une fonction doit avoir 1 fonction pas 30. ;)
                                      D'ailleurs, à cause de ça t'es obligé de passer un pointeur sur 'role' à tes fonctions
                                      Dans ta fonction check_clic tu fais 2 ifs imbriqués, tu pourrais n'en utiliser qu'un seul
                                      Le nom de ta fonction grille est mal choisi. Qu'est-ce qu'elle fait ? à première vue j'en sais rien
                                      Pourquoi utiliser une variable intermédiaire 'r' ? tu peux t'en passer
                                      Je peux changer la taille de la grille mais pas le nombre de pions à poser. :-°
                                      Dans ta fonction 'grille', tu fais plusieurs ifs imbriqués, tu peux les raccourcir. Les opérateurs && || s'évaluent de gauche à droite.
                                      Tu pourrais simplifier ta fonction 'grille'. Avec simplement des if tu gagnerais en lisibilité et en rapidité
                                      Pareil que plus haut pour ta fonction 'replay'. Tu pourrais fusionner tes 2 if aussi.
                                      Dans ta fonction reset, c'est encore le joueur 1 qui commence.
                                      Tu pourrais fusionner tes fonctions check_winner et grille.
                                      Masquer une fonction avec un #define n'est pas très idiomatique. :-°
                                      De plus, à chaque fois que tu appelles 'ecran' tu appelles la fonctoin, tu pourrais la mémoriser
                                      Tu pourrais modifier le problème dont je te parlais en modifier la récupération de la case à partir des coordonnées comme suit :

                                      /* Hé oui, tu as oublié les bordures */
                                        i = c->x / (CASEW + 10);
                                        j = c->y / (CASEW + 10);
                                      


                                      Merci de votre participation. :)
                                      • Partager sur Facebook
                                      • Partager sur Twitter
                                        3 janvier 2011 à 22:24:55

                                        @ Pouet_forever : merci bien, je l'attendais le commentaire. j'essairé de le compléter et de l'améliorer avec ce que tu as dis mais je n'ais pas compris :

                                        Citation

                                        Quand nombreCoups == 9 tu as gagné ? je ne pense pas, le nom de ta fonction est mal choisie dans ce cas là
                                        Dans tes #define, tu devrais (dois?) mettre des parenthèses

                                        • Partager sur Facebook
                                        • Partager sur Twitter
                                          3 janvier 2011 à 22:33:15

                                          *) Ta fonction s'appelle 'gagner', mais quand tu as match nul tu retournes 'true' ce qui veut dire que tu as gagné, or ce n'est pas le cas. :)
                                          *) Pour les parenthèses, je pense notamment à ceux-là :

                                          #define LARGEUR                     2 * TAILLEBORDURE + 3 * TAILLECASE
                                          #define HAUTEUR                     2 * TAILLEBORDURE + 3 * TAILLECASE
                                          
                                          • Partager sur Facebook
                                          • Partager sur Twitter
                                            4 janvier 2011 à 17:53:55

                                            bon je pense avoir tout corriger sauf des petits trucs que je veux garder intact(ou que je ne vois pas comment modifier) :

                                            Citation

                                            • My_SDL_CreateRGBSurface ton nom est incorrect, tu 'fill' aussi ta surface
                                            • C'est pas trop mal ta fonction erreurSDL mais le problème c'est que si t'as le moindre écart dans ton programme tu le quittes, tu pourrais faire en sorte d'afficher un message et remédier au problème. Genre, si SDL_BlitSurface n'a pas réussi, tu attends un peu (SDL_Delay(1)) et tu recommences.
                                            donc voila le code :

                                            main.c

                                            #define NOMBRECASE                  5
                                            #define NOMBRECASEALIGNEPOURGAGNER  3
                                            
                                            #include                            <stdio.h>
                                            #include                            <time.h>
                                            
                                            //bolleen
                                            #include                            <stdbool.h>
                                            
                                            #include                            <SDL/SDL.h>
                                            
                                            #define LARGEUR                     (NOMBREBORDURE * TAILLEBORDURE + NOMBRECASE * TAILLECASE)
                                            #define HAUTEUR                     (NOMBREBORDURE * TAILLEBORDURE + NOMBRECASE * TAILLECASE)
                                            
                                            #define BPP                         32
                                            
                                            #define TAILLECASE                  (500/NOMBRECASE)
                                            
                                            #define TAILLEBORDURE               2
                                            #define NOMBREBORDURE               (NOMBRECASE-1)
                                            
                                            
                                            #define NOMBRECOUPMAX               NOMBRECASE*NOMBRECASE
                                            
                                            #define ALEA(MIN, MAX)              (rand() % (MAX - MIN + 1)) + MIN;
                                            
                                            //ma lib
                                            #include                            "My_SDL.h"
                                            
                                            typedef enum {VIDE = 0, JOUEUR1 = 1, JOUEUR2 = 2} Signe; // Indique ce que contient une case du plateau ainsi que le joueur qui doit jouer
                                            
                                            SDL_Surface *ecran;
                                            
                                            bool gagner(Signe Grille[NOMBRECASE][NOMBRECASE], int JOUEUR, int nombreCoups);
                                            void AfficherGrille(Signe Grille[NOMBRECASE][NOMBRECASE], SDL_Surface* surface[]);
                                            void choix(Signe Grille[NOMBRECASE][NOMBRECASE], int JOUEUR);
                                            bool FinMatch(Signe Grille[NOMBRECASE][NOMBRECASE], int JOUEUR, int nombreCoups);
                                            bool ReJouer(void);
                                            void My_SDL_Pause(void);
                                            
                                            void programme(void)
                                            {
                                                Signe Grille[NOMBRECASE][NOMBRECASE];
                                                int i, j;
                                                int JOUEUR = 2;
                                                int nombreCoups = 0;
                                                SDL_Surface *surface[3] = {NULL, NULL, NULL};
                                                const Uint32 couleurs[3] = {My_SDL_MapRGB(255,255,255), My_SDL_MapRGB(255,0,0), My_SDL_MapRGB(255,255,0)};
                                            
                                                surface[0] = My_SDL_CreateRGBSurface(SDL_HWSURFACE, TAILLECASE, TAILLECASE, BPP, couleurs[0]);
                                                surface[1] = My_SDL_CreateRGBSurface(SDL_HWSURFACE, TAILLECASE, TAILLECASE, BPP, couleurs[1]);
                                                surface[2] = My_SDL_CreateRGBSurface(SDL_HWSURFACE, TAILLECASE, TAILLECASE, BPP, couleurs[2]);
                                                do
                                                {
                                                    JOUEUR = ALEA(1, 2);
                                                    for (i = 0 ; i < NOMBRECASE ; i++)
                                                        for (j = 0 ; j < NOMBRECASE ; j++)
                                                            Grille[i][j] = VIDE;
                                                    do
                                                    {
                                                        JOUEUR = 3 - JOUEUR;
                                                        AfficherGrille(Grille, surface);
                                                        choix(Grille, JOUEUR);
                                                        AfficherGrille(Grille, surface);
                                                        nombreCoups++;
                                                    }
                                                    while(!FinMatch(Grille, JOUEUR, nombreCoups));
                                                }
                                                while(ReJouer());
                                                for ( i = 0 ; i < 3 ; i++)
                                                    SDL_FreeSurface(surface[i]);
                                            }
                                            
                                            void AfficherGrille(Signe Grille[NOMBRECASE][NOMBRECASE], SDL_Surface* surface[])
                                            {
                                                SDL_Rect position;
                                                int i, j;
                                                for (i = 0, position.y = 0 ; i < NOMBRECASE ; i++ , position.y += (TAILLEBORDURE+TAILLECASE))
                                                    for (j = 0, position.x = 0 ; j < NOMBRECASE ; j++ , position.x += (TAILLEBORDURE+TAILLECASE))
                                                        My_SDL_BlitSurface(surface[Grille[i][j]], NULL, &position);
                                                My_SDL_Flip();
                                            }
                                            
                                            void choix(Signe Grille[NOMBRECASE][NOMBRECASE], int JOUEUR)
                                            {
                                                char *chaine[] = {"- MORPION - J1 choix", "- MORPION - J2 choix"};
                                                int i = -1, j = -1;
                                                SDL_Event event;
                                                SDL_WM_SetCaption(chaine[JOUEUR-1], NULL);
                                                do
                                                {
                                                    SDL_WaitEvent(&event);
                                                    if (event.button.button == SDL_BUTTON_LEFT && event.type == SDL_MOUSEBUTTONUP)
                                                    {
                                                        i = event.button.y / (TAILLEBORDURE+TAILLECASE);
                                                        j = event.button.x / (TAILLEBORDURE+TAILLECASE);
                                                    }
                                                }
                                                while(Grille[i][j] != VIDE || i == -1);
                                                Grille[i][j] = JOUEUR;
                                            }
                                            
                                            bool FinMatch(Signe Grille[NOMBRECASE][NOMBRECASE], int JOUEUR, int nombreCoups)
                                            {
                                                char *chaine[] = {"- MORPION - MATCH NUL", "- MORPION - J1 gagne", "- MORPION - J2 gagne"};
                                                int x, y;
                                                int i,j;
                                                int nombreAlignementV = 0, nombreAlignementH = 0, nombreAlignementD1 = 0, nombreAlignementD2 = 0;
                                                for (x = 0 ; x < NOMBRECASE ; x++)
                                                {
                                                    for (y = 0 ; y < NOMBRECASE ; y++)
                                                    {
                                                        if (Grille[x][y] != VIDE)
                                                        {
                                                            //on vérifie ceux qui sont verticaux
                                                            for (i = x , j = y ; i < NOMBRECASE && Grille[i][j] == Grille[x][y]; i++)
                                                                if(Grille[x][y] == Grille[i][j])
                                                                    nombreAlignementH++;
                                                            //on vérifie ceux qui sont horisontaux
                                                            for (j = y , i = x ; j < NOMBRECASE && Grille[i][j] == Grille[x][y]; j++)
                                                                if(Grille[x][y] == Grille[i][j])
                                                                    nombreAlignementH++;
                                                            //on vérifie ceux qui sont en diagonnale : bas et gauche
                                                            for (j = y , i = x ; i < NOMBRECASE && j < NOMBRECASE && Grille[i][j] == Grille[x][y]; i++, j++)
                                                                if(Grille[x][y] == Grille[i][j])
                                                                    nombreAlignementD1++;
                                                            //on vérifie ceux qui sont en diagonnale : bas et droite
                                                            for (j = y , i = x ; i < NOMBRECASE && j < NOMBRECASE && Grille[i][j] == Grille[x][y]; i++, j--)
                                                                if(Grille[x][y] == Grille[i][j])
                                                                    nombreAlignementD2++;
                                                            if(nombreAlignementH == NOMBRECASEALIGNEPOURGAGNER+1 ||
                                                                    nombreAlignementV == NOMBRECASEALIGNEPOURGAGNER+1 ||
                                                                    nombreAlignementD1 == NOMBRECASEALIGNEPOURGAGNER ||
                                                                    nombreAlignementD2 == NOMBRECASEALIGNEPOURGAGNER)
                                                            {
                                                                SDL_WM_SetCaption(chaine[JOUEUR], NULL);
                                                                My_SDL_Pause();
                                                                return true;
                                                            }
                                                        }
                                                        nombreAlignementH = 0;
                                                        nombreAlignementV = 0;
                                                        nombreAlignementD1 = 0;
                                                        nombreAlignementD2 = 0;
                                                    }
                                                }
                                                if (nombreCoups == NOMBRECOUPMAX)
                                                {
                                                    SDL_WM_SetCaption(chaine[0], NULL);
                                                    My_SDL_Pause();
                                                    return true;
                                                }
                                                return false;
                                            }
                                            
                                            bool ReJouer(void)
                                            {
                                                char chaine[] = "- MORPION - Recommencer O/N";
                                                char car = '\0';
                                                SDL_Event event;
                                                SDL_WM_SetCaption(chaine, NULL);
                                                do
                                                {
                                                    SDL_WaitEvent(&event);
                                                    if (event.type == SDL_KEYDOWN)
                                                        car = event.key.keysym.sym;
                                                }
                                                while(car != 'o' && car != 'n');
                                                return (car == 'o')? true : false;
                                            }
                                            
                                            void My_SDL_Pause(void)
                                            {
                                                SDL_Event event;
                                                do
                                                    SDL_WaitEvent(&event);
                                                while(event.type != SDL_KEYDOWN);
                                            }
                                            
                                            int main(int argc, char *argv[])
                                            {
                                                My_SDL_initialise(SDL_INIT_VIDEO);
                                                ecran = My_SDL_initialiserfenetre(LARGEUR,
                                                                                  HAUTEUR,
                                                                                  BPP,
                                                                                  SDL_DOUBLEBUF| SDL_HWSURFACE/* | SDL_FULLSCREEN*/,
                                                                                  "- MORPION -",
                                                                                  NULL);
                                                programme();
                                                SDL_Quit();
                                                return EXIT_SUCCESS;
                                            }
                                            

                                            My_SDL.h

                                            /*
                                            My_SDL.h
                                            ------
                                            
                                            Par Cyril, pour tester les retours des fonctions en SDL
                                            
                                            Rôle : Une grande majorité des fonctions les plus importantes en SDL pour vérifier les fonctions
                                            */
                                            #ifndef My_SDL
                                            #define My_SDL
                                            //initialise la SDL
                                            void My_SDL_initialise(const Uint32 flags);
                                            //cré la fenetre
                                            SDL_Surface* My_SDL_initialiserfenetre(const int LARGEURFENETRE, const int HAUTEURFENETRE, const int NB_COULEUR, const Uint32 flags, char *nomFenetre, SDL_Surface *imageDeLaFenetre);
                                            //créer une surface et la colore
                                            SDL_Surface* My_SDL_CreateRGBSurface(const Uint32 flags, const int X, const int Y, const int NB_COULEUR, const Uint32 couleur);
                                            //charge une image
                                            SDL_Surface* My_SDL_ChargerImage(const char* fichier);
                                            //renvoi une couleur de type uint32
                                            Uint32 My_SDL_MapRGB(const int R, const int V, const int B);
                                            //Colore une surface
                                            void My_SDL_FillRect(SDL_Surface* SURFACE, const Uint32 couleur);
                                            //blitte une surface sur l'ecran
                                            void My_SDL_BlitSurface(SDL_Surface* SURFACE, SDL_Rect *SURFACE_BLITTE, SDL_Rect *position);
                                            //realise le SDL_Flip
                                            void My_SDL_Flip(void);
                                            #endif
                                            

                                            My_SDL.c

                                            /*
                                            My_SDL.c
                                            ------
                                            
                                            Par Cyril, pour tester les retours des fonctions en SDL
                                            
                                            Rôle : Une grande majorité des fonctions les plus importantes en SDL pour vérifier les fonctions
                                            */
                                            
                                            #include                            <SDL/SDL.h>
                                            #include                            <SDL/SDL_image.h>
                                            #include                            "My_SDL.h"
                                            
                                            static SDL_Surface* screen;
                                            
                                            static void erreurSDL(const char chaine[]);
                                            
                                            //initialise la SDL
                                            void My_SDL_initialise(const Uint32 flags)
                                            {
                                                if (SDL_Init(flags) != 0)
                                                    erreurSDL ("Erreur SDL_Init");
                                            }
                                            //cré la fenetre
                                            SDL_Surface* My_SDL_initialiserfenetre(const int LARGEURFENETRE, const int HAUTEURFENETRE, const int BPP, const Uint32 flags, char *nomFenetre, SDL_Surface *imageDeLaFenetre)
                                            {
                                                SDL_WM_SetIcon(imageDeLaFenetre, NULL);
                                                SDL_WM_SetCaption(nomFenetre, NULL);
                                                screen = SDL_SetVideoMode(LARGEURFENETRE,HAUTEURFENETRE,BPP, flags);
                                                if (screen == NULL)
                                                    erreurSDL ("Erreur SDL_SetVideoMode");
                                                return screen;
                                            }
                                            //créer une surface et la colore
                                            SDL_Surface* My_SDL_CreateRGBSurface(const Uint32 flags, const int X, const int Y, const int BPP, const Uint32 couleur)
                                            {
                                                SDL_Surface* SURFACE = SDL_CreateRGBSurface(flags, X, Y, BPP, 0, 0, 0, 0);
                                                if (SURFACE == NULL)
                                                    erreurSDL("Erreur SDL_CreateRGBSurface");
                                                My_SDL_FillRect(SURFACE, couleur);
                                                return SURFACE;
                                            }
                                            //charge une image
                                            SDL_Surface* My_SDL_ChargerImage(const char* fichier)
                                            {
                                                char chaine[100];
                                                sprintf(chaine, "ressources\\image\\%s", fichier);
                                                SDL_Surface* img = IMG_Load(chaine);
                                                if (img == NULL)
                                                    erreurSDL("Erreur IMG_Load");
                                                return img;
                                            }
                                            Uint32 My_SDL_MapRGB(const int R, const int V, const int B)
                                            {
                                                return SDL_MapRGB(screen->format, R, V, B);
                                            }
                                            //Colore une surface
                                            void My_SDL_FillRect(SDL_Surface* SURFACE, const Uint32 couleur)
                                            {
                                                if(SDL_FillRect(SURFACE, NULL, couleur) != 0)
                                                    erreurSDL("Erreur SDL_FillRect");
                                            }
                                            //blitte une surface sur l'ecran
                                            void My_SDL_BlitSurface(SDL_Surface* SURFACE, SDL_Rect *SURFACE_BLITTE, SDL_Rect *position)
                                            {
                                                if (SDL_BlitSurface(SURFACE, SURFACE_BLITTE, screen, position) != 0)
                                                    erreurSDL("Erreur SDL_BlitSurface");
                                            }
                                            //realise le SDL_Flip
                                            void My_SDL_Flip(void)
                                            {
                                                if (SDL_Flip(screen) != 0)erreurSDL("Erreur SDL_Flip");
                                            }
                                            //ecris dans le fichier l'erreur
                                            static void erreurSDL(const char chaine[])
                                            {
                                                fprintf(stderr,"%s : %s\n", chaine, SDL_GetError());
                                                exit (EXIT_FAILURE);
                                            }
                                            
                                            • Partager sur Facebook
                                            • Partager sur Twitter
                                              5 janvier 2011 à 19:03:54

                                              C159 >
                                              Tu as un fichier My_SDL.c, pourquoi mettre My_SDL_Pause dans ton main.c ?
                                              Tes noms de variable sont 100 fois trop long. Un nom de variable doit être concis et explicite, grand maximum 8 caractères est bien.
                                              Pour le nom des variables en majuscule, même remarque.
                                              Essaye d'avoir sur une ligne au maximum 80 caractères, ça évite de scroller inutilement de droite à gauche, on a déjà assez à faire de haut en bas. ^^
                                              La doc ne mentionne rien à propos d'envoyer NULL à SDL_WM_SetIcon (mais les sources si... :p )
                                              Ta surface 'ecran' dans ton main.c ne sert à rien
                                              Les commentaires inutiles sont... inutiles :p Un commentaire doit servir à éclaircir les parties sombre du code, pas à l'encombrer
                                              Ton ; est en trop dans ta macro ALEA. De plus tu as oublié des parenthèses.
                                              Tu n'as pas initialisé ta graine pour le rand, du coup il ne sert à rien. :-°
                                              Dans ta fonction FinMatch tu vérifies ta grille à l'envers, i != x et j != y c'est l'inverse i = y et j = x
                                              Tu ferais mieux d'initialiser tes variables avant ton 'if'
                                              Dans ta fonction Rejouer, tu n'as pas besoin de ternaire, return carr == 'o'; suffit.
                                              Et pour finir, tu as un problème quelque part :

                                              Image utilisateur


                                              Merci pour ta participation. :)
                                              • Partager sur Facebook
                                              • Partager sur Twitter
                                                5 janvier 2011 à 21:06:18

                                                On peut le faire en C++ ? ^^
                                                • Partager sur Facebook
                                                • Partager sur Twitter
                                                  5 janvier 2011 à 21:16:10

                                                  Tu peux toujours, mais ton code ne sera pas commenté (du moins pas par moi). :)
                                                  • Partager sur Facebook
                                                  • Partager sur Twitter
                                                    9 janvier 2011 à 14:03:34

                                                    Salut, c'est moi, je viens vous proposez mon code SDL, fait un peu rapidement, mais bon ^^

                                                    Il fonctionne plus ou moins, j'ai un peu fait comme Pouet pour les cases ^^, j'avais la flemme d'uploader des images, et ou de les mettres directement dans le header.

                                                    Voici mon code.

                                                    tool.h
                                                    #ifndef TOOL_H_INCLUDED
                                                    #define TOOL_H_INCLUDED
                                                    
                                                    #define SIZE_SQUARE 100
                                                    
                                                    #define WHITE (Uint32) 0x00FFFFFF
                                                    
                                                    #define SDL_Flags SDL_SWSURFACE | SDL_RLEACCEL | SDL_DOUBLEBUF
                                                    
                                                    #define BLUE 0x000000FF
                                                    #define RED 0x00FF0000
                                                    
                                                    typedef Uint8 bool;
                                                    enum{false, true};
                                                    
                                                    enum{EMPTY, J1, J2};
                                                    
                                                    typedef struct
                                                    {
                                                        int *grid;
                                                        int width, height, align;
                                                        SDL_Surface *grid_Src;
                                                    }Grid;
                                                    
                                                    typedef struct
                                                    {
                                                        Uint32 key[SDLK_LAST];/*KeyBoad*/
                                                    
                                                        /*Mouse*/
                                                        bool left_Click;
                                                    
                                                        Uint16 pos_MouseX;
                                                        Uint16 pos_MouseY;/*Pos Mouse*/
                                                    
                                                        bool done;/*Exit?*/
                                                    }Event;
                                                    
                                                    void updateEvent(Event *in);/*Update Event*/
                                                    void *my_malloc(size_t n);/*Malloc verificate*/
                                                    
                                                    #endif
                                                    


                                                    tool.c
                                                    #include <SDL.h>
                                                    #include "tool.h"
                                                    
                                                    void updateEvent(Event *in)/*Update Event*/
                                                    {
                                                        SDL_Event event_Sdl;/*event*/
                                                    
                                                        while(SDL_PollEvent(&event_Sdl))
                                                        {
                                                            switch(event_Sdl.type)
                                                            {
                                                                /*KEYBOARD*/
                                                                case SDL_KEYDOWN:
                                                                    in->key[event_Sdl.key.keysym.sym] = true;;
                                                                break;
                                                    
                                                                /*Red Cross for Quit*/
                                                                case SDL_QUIT:
                                                                    in->done = true;
                                                                break;
                                                    
                                                                /*MOUSE*/
                                                                case SDL_MOUSEMOTION:
                                                                    in->pos_MouseX = event_Sdl.button.x;
                                                                    in->pos_MouseY = event_Sdl.button.y;
                                                                break;
                                                    
                                                                case SDL_MOUSEBUTTONDOWN:
                                                                    if(event_Sdl.button.button == SDL_BUTTON_LEFT)
                                                                        in->left_Click = true;
                                                                break;
                                                    
                                                                default:
                                                                    break;
                                                            }
                                                        }
                                                    }
                                                    
                                                    void *my_malloc(size_t n)
                                                    {
                                                        void *p;
                                                    
                                                        if((p = malloc(n)) == NULL)
                                                            fprintf(stderr, "Erreur sur le malloc"), exit(1);
                                                    
                                                        return p;
                                                    }
                                                    


                                                    #include <SDL.h>
                                                    #include "tool.h"
                                                    
                                                    Event event = {{0}, 0, 0, 0, 0};
                                                    
                                                    SDL_Surface *create_Grid_Surface(int width, int height);
                                                    Grid *create_Grid(unsigned width, unsigned height, unsigned align);
                                                    void delete_Grid(Grid *(*grid));
                                                    
                                                    Grid *create_Grid(unsigned width, unsigned height, unsigned align)
                                                    {
                                                        unsigned x, y;
                                                    
                                                        Grid *grid =  my_malloc(sizeof *grid);
                                                        grid->grid =  my_malloc(sizeof *(grid->grid) * width * height);
                                                    
                                                        grid->width = (int) width;
                                                        grid->height = (int) height;
                                                        grid->align = (int) align;
                                                    
                                                        for(y = 0; y < height; y++)
                                                            for(x = 0; x < width; x++)
                                                                grid->grid[y * width + x] = EMPTY;
                                                    
                                                        grid->grid_Src = create_Grid_Surface((int) width, (int) height);
                                                    
                                                        SDL_SetColorKey(grid->grid_Src, SDL_RLEACCEL | SDL_SRCCOLORKEY, WHITE);
                                                    
                                                        return grid;
                                                    }
                                                    
                                                    SDL_Surface *create_Grid_Surface(int width, int height)
                                                    {
                                                        int x, y;
                                                        SDL_Rect pos;
                                                        SDL_Surface *src;
                                                    
                                                        width *= SIZE_SQUARE;
                                                        height *= SIZE_SQUARE;
                                                    
                                                        if((src = SDL_CreateRGBSurface(SDL_Flags,
                                                                                       width, height, 32, 0, 0, 0, 0)) == NULL)
                                                        {
                                                            fprintf(stderr, "Error create grid : %s\n", SDL_GetError());
                                                            exit(1);
                                                        }
                                                    
                                                        SDL_FillRect(src, NULL, WHITE);
                                                    
                                                        pos.w = (Uint16) (width * SIZE_SQUARE);
                                                        pos.h = 4;
                                                        pos.x = 0;
                                                    
                                                        for(y = 0; y <= height; y += 100)
                                                        {
                                                            pos.y = (Sint16) (y - 2);
                                                            SDL_FillRect(src, &pos, 0);
                                                        }
                                                    
                                                        pos.w = 4;
                                                        pos.h = (Uint16) (height * SIZE_SQUARE);
                                                        pos.y = 0;
                                                    
                                                        for(x = 0; x <= width; x += 100)
                                                        {
                                                            pos.x = (Sint16) (x - 2);
                                                            SDL_FillRect(src, &pos, 0);
                                                        }
                                                    
                                                        return src;
                                                    }
                                                    
                                                    void delete_Grid(Grid *(*grid))
                                                    {
                                                        free((*grid)->grid);
                                                        SDL_FreeSurface((*grid)->grid_Src);
                                                    
                                                        free(*grid);
                                                        *grid = NULL;
                                                    }
                                                    
                                                    void print_Grid(Grid *grid);
                                                    
                                                    void print_Grid(Grid *grid)
                                                    {
                                                        SDL_Surface *screen = SDL_GetVideoSurface();
                                                        int xS, yS, n;
                                                        Uint16 xT, yT;
                                                        SDL_Rect rect;
                                                    
                                                        rect.w = 100;
                                                        rect.h = 100;
                                                    
                                                        for(yS = yT = 0; yT < grid->height; yT++, yS += SIZE_SQUARE)
                                                        {
                                                            for(xS = xT = 0; xT < grid->width; xT++, xS += SIZE_SQUARE)
                                                            {
                                                                rect.x = (Sint16) xS;
                                                                rect.y = (Sint16) yS;
                                                                n = grid->grid[yT * grid->width + xT];
                                                    
                                                                if(n == EMPTY)
                                                                    SDL_FillRect(screen, &rect, WHITE);
                                                    
                                                                else if(n == J1)
                                                                    SDL_FillRect(screen, &rect, RED);
                                                    
                                                                else
                                                                    SDL_FillRect(screen, &rect, BLUE);
                                                            }
                                                        }
                                                    
                                                        SDL_BlitSurface(grid->grid_Src, NULL, screen, NULL);
                                                    
                                                        SDL_UpdateRect(screen, 0, 0, 0, 0);
                                                    
                                                    }
                                                    
                                                    bool win(Grid *grid, int numCase, int player);
                                                    bool end_Play(Grid *grid);
                                                    void play(Grid *grid);
                                                    bool test_Case(Grid *grid, int numCase);
                                                    
                                                    int ask_Case(Grid *grid);
                                                    
                                                    int ask_Case(Grid *grid)
                                                    {
                                                        int n;
                                                        int x, y;
                                                    
                                                        x = n = y = 0;
                                                    
                                                        while(!event.done && !event.left_Click)
                                                        {
                                                            updateEvent(&event);
                                                    
                                                            x = event.pos_MouseX;
                                                            y = event.pos_MouseY;
                                                    
                                                            print_Grid(grid);
                                                        }
                                                    
                                                        event.left_Click = false;
                                                    
                                                        y /= SIZE_SQUARE;
                                                        x /= SIZE_SQUARE;
                                                        n = y * grid->width + x;
                                                    
                                                        return n;
                                                    }
                                                    
                                                    void play(Grid *grid)
                                                    {
                                                        int numCase;
                                                        int player = J1;
                                                        int x, y;
                                                    
                                                        while(1)
                                                        {
                                                            if(player == J1)
                                                                SDL_WM_SetCaption("A vous de jouez joueur 1", NULL);
                                                    
                                                            else
                                                                SDL_WM_SetCaption("A vous de jouez joueur 2", NULL);
                                                            do
                                                            {
                                                                numCase = ask_Case(grid);
                                                    
                                                                if(event.done)
                                                                    return;
                                                    
                                                            }while(test_Case(grid, numCase) == false);
                                                    
                                                            x = numCase % grid->width;
                                                            y = numCase / grid->width;
                                                    
                                                            grid->grid[y * grid->width + x] = player;
                                                    
                                                            if(win(grid, numCase, player) == true)
                                                            {
                                                                if(player == J1)
                                                                    SDL_WM_SetCaption("Le joueur 1 a gagne", NULL);
                                                    
                                                                else
                                                                    SDL_WM_SetCaption("Le joueur 2 a gagne", NULL);
                                                    
                                                                print_Grid(grid);
                                                                break;
                                                            }
                                                    
                                                            if(end_Play(grid) == true)
                                                            {
                                                                SDL_WM_SetCaption("Il y a match Nul", NULL);
                                                    
                                                                print_Grid(grid);
                                                                break;
                                                            }
                                                    
                                                            if(player == J1)
                                                                player = J2;
                                                    
                                                            else
                                                                player = J1;
                                                        }
                                                    }
                                                    
                                                    bool win(Grid *grid, int numCase, int player)
                                                    {
                                                        int xMin, xMax, yMin, yMax, x, y, xBase, yBase,
                                                            n = 0;
                                                    
                                                        x = numCase % grid->width;
                                                        y = numCase / grid->width;
                                                    
                                                        xMin = (x - grid->align + 1);
                                                        xMax = (x + grid->align);
                                                        yMin = (y - grid->align + 1);
                                                        yMax = (y + grid->align);
                                                    
                                                        if(xMin < 0)
                                                            xMin = 0;
                                                    
                                                        if(yMin < 0)
                                                            yMin = 0;
                                                    
                                                        if(xMax >= grid->width)
                                                            xMax = grid->width;
                                                    
                                                        if(yMax >= grid->height)
                                                            yMax = grid->height;
                                                    
                                                        xBase = x;
                                                        yBase = y;
                                                    
                                                        for(x = xMin; x < xMax; x++)
                                                        {
                                                            if(grid->grid[y * grid->width + x] == player)
                                                                n++;
                                                            else
                                                                n = 0;
                                                            if(n == grid->align)
                                                                return true;
                                                        }/*Line*/
                                                    
                                                        x = xBase;
                                                        n = 0;
                                                    
                                                        for(y = yMin; y < yMax; y++)
                                                        {
                                                            if(grid->grid[y * grid->width + x] == player)
                                                                n++;
                                                            else
                                                                n = 0;
                                                            if(n == grid->align)
                                                                return true;
                                                        }/*Col*/
                                                    
                                                        x = xMin;
                                                        n = 0;
                                                    
                                                        for(y = yMin; y < yMax; y++)
                                                        {
                                                            if(grid->grid[y * grid->width + x] == player)
                                                                n++;
                                                            else
                                                                n = 0;
                                                            if(n == grid->align)
                                                                return true;
                                                    
                                                            x++;
                                                            if(x >= grid->width)
                                                                x = xMax - 1;
                                                        }/*left right*/
                                                    
                                                        x = xMax - 1;
                                                        n = 0;
                                                    
                                                        for(y = yMin; y < yMax; y++)
                                                        {
                                                            if(grid->grid[y * grid->width + x] == player)
                                                                n++;
                                                            else
                                                                n = 0;
                                                            if(n == grid->align)
                                                                return true;
                                                    
                                                            x--;
                                                            if(x < 0)
                                                                x = xMin;
                                                        }/*right left*/
                                                    
                                                        return false;/*Else not win, return 0;*/
                                                    }
                                                    
                                                    bool test_Case(Grid *grid, int numCase)
                                                    {
                                                        int x, y;
                                                    
                                                        x = numCase % grid->width;
                                                        y = numCase / grid->width;
                                                    
                                                        if(x < 0 || x >= grid->width || y < 0 || y >= grid->height)
                                                            return false;
                                                    
                                                        return (grid->grid[y * grid->width + x] == 0);
                                                    }
                                                    
                                                    bool end_Play(Grid *grid)
                                                    {
                                                        bool end = true;
                                                        int x, y;
                                                    
                                                        for(y = 0; y < grid->height; y++)
                                                        {
                                                            for(x = 0; x < grid->width; x++)
                                                            {
                                                                if(grid->grid[y * grid->width + x] > 0)
                                                                {
                                                                    end = false;
                                                                    return end;
                                                                }
                                                            }
                                                        }
                                                    
                                                        return end;
                                                    }
                                                    
                                                    int main(int argc, char *argv[])
                                                    {
                                                        int width, height, align;
                                                        SDL_Surface *screen;
                                                        Grid *grid;
                                                        bool end = false;
                                                    
                                                        width = 3;
                                                        height = 3;
                                                        align = 3;
                                                    
                                                        if(SDL_Init(SDL_INIT_VIDEO) < 0)
                                                        {
                                                            fprintf(stderr, "Error in the SDL_Init video mode\n%s",
                                                                            SDL_GetError());
                                                            exit(1);
                                                        }
                                                    
                                                        if((screen = SDL_SetVideoMode(width * SIZE_SQUARE, height * SIZE_SQUARE,
                                                                                      32, SDL_Flags)) == NULL)
                                                        {
                                                            fprintf(stderr, "Error display\n%s", SDL_GetError());
                                                            exit(1);
                                                        }
                                                    
                                                        grid = create_Grid((unsigned) width, (unsigned) height, (unsigned) align);
                                                    
                                                        while(!event.done)
                                                        {
                                                            updateEvent(&event);
                                                    
                                                            if(end == false)
                                                            {
                                                                play(grid);
                                                                end = true;
                                                            }
                                                        }
                                                    
                                                        delete_Grid(&grid);
                                                        SDL_Quit();
                                                    
                                                        (void)argc, (void)argv;
                                                        return 0;
                                                    }
                                                    


                                                    Voilà voilà, pas très très propre mais bon ^^
                                                    • Partager sur Facebook
                                                    • Partager sur Twitter
                                                    http://cpp-rendering.io : Vous trouverez tout ce dont vous avez besoin sur Vulkan / OpenGL et le rendu 3D !
                                                      9 janvier 2011 à 15:42:01

                                                      Salut,

                                                      Bon j'ai pas fait avec SDL mais avec Allegro.

                                                      Le code :
                                                      main.c
                                                      #include <stdio.h>
                                                      #include <time.h>
                                                      #include "grille.h"
                                                      
                                                      int main (void)
                                                      {
                                                      	Case grille[LONGUEUR][LARGEUR];
                                                      	int joueur = 1;
                                                      	int continuer = 1;
                                                      	int nbCoups = 0;
                                                      	int gagne = 0;
                                                          int termine = 0;
                                                         	int coupPasJoue = 1;
                                                      	int clavier;
                                                      	int souris = 0;
                                                          coord position_souris;
                                                      
                                                      	/* Allegro */
                                                      	BITMAP *vide = NULL;
                                                      	BITMAP *rouge = NULL;
                                                      	BITMAP *bleu = NULL;
                                                      	BITMAP *buffer = NULL;
                                                      
                                                          srand(time(NULL));
                                                      
                                                      	allegro_init();
                                                      	install_keyboard();
                                                      	install_timer();
                                                      	souris = install_mouse();
                                                      
                                                      	if (set_gfx_mode(GFX_AUTODETECT_WINDOWED, 640, 480, 0, 0) != 0)
                                                      	{
                                                      		set_gfx_mode(GFX_TEXT, 0, 0, 0, 0);
                                                      		allegro_message("Echec de l'initialisation du mode graphique !\n");
                                                      		return EXIT_FAILURE;
                                                      	}
                                                      	rouge = create_bitmap(COTECASE, COTECASE);
                                                      	bleu = create_bitmap(COTECASE, COTECASE);
                                                      	vide = create_bitmap(COTECASE, COTECASE);
                                                      	buffer = create_bitmap(SCREEN_W, SCREEN_H);
                                                      
                                                      	clear_to_color(vide, makecol(255, 255, 255));
                                                      	clear_to_color(rouge, makecol(255, 0, 0));
                                                      	clear_to_color(bleu, makecol(0, 0, 255));
                                                      
                                                      	while (continuer == 1)
                                                      	{
                                                              show_mouse(screen);
                                                      	    clear_to_color(buffer, makecol(0, 0, 0));
                                                      		gagne = 0;
                                                             	nbCoups = 0;
                                                      		prepare_Grille(grille);
                                                      	
                                                      		while (!(termine) && !(gagne))
                                                      		{
                                                      			afficherGrille(grille, joueur, termine, gagne, buffer, vide, rouge, bleu);
                                                                  if (keypressed())
                                                                  {
                                                                      clear_keybuf();
                                                                  }
                                                                  if (nbCoups == 0)
                                                                  {
                                                                      joueur = rand();
                                                                      if ((joueur % 2) == 0)
                                                                      {
                                                                          joueur = 1;
                                                                      }
                                                                      else
                                                                      {
                                                                          joueur = 2;
                                                                      }
                                                                  }
                                                                  coupPasJoue = 1;
                                                      			while (coupPasJoue)
                                                      			{
                                                      				coupPasJoue = placerPion(joueur, grille, &position_souris);
                                                      			}
                                                      			nbCoups++;
                                                      			gagne = verifierGrille(grille, &position_souris, joueur);
                                                      			if (gagne)
                                                      			{
                                                      			    afficherGrille(grille, joueur, termine, gagne, buffer, vide, rouge, bleu);
                                                      				clavier = readkey() >> 8;
                                                      				if (clavier == KEY_Q)
                                                      				{
                                                      					continuer = 0;
                                                      				}
                                                      			}
                                                      			if (joueur == 1)
                                                      			{
                                                      				joueur = 2;
                                                      			}
                                                      			else
                                                      			{
                                                      				joueur = 1;
                                                      			}
                                                      		}
                                                      	}
                                                      	destroy_bitmap(rouge);
                                                      	destroy_bitmap(bleu);
                                                      	destroy_bitmap(vide);
                                                      	destroy_bitmap(buffer);
                                                      
                                                      	rouge = NULL;
                                                      	bleu = NULL;
                                                      	vide = NULL;
                                                      	buffer = NULL;
                                                      	allegro_exit();
                                                      	return 0;
                                                      }
                                                      END_OF_MAIN()
                                                      


                                                      grille.c
                                                      #include <stdio.h>
                                                      #include "grille.h"
                                                      
                                                      void recupCoord(coord *position_souris)
                                                      {
                                                          poll_mouse(); /* Necessaire à chaque fois que l'on veut lire la souris : actualise la souris */
                                                          position_souris->colonne = mouse_x / (COTECASE + ESPACEMENT); 
                                                          position_souris->ligne = mouse_y / (COTECASE + ESPACEMENT); 
                                                      }
                                                      
                                                      int placerPion (int joueur, Case grille[LONGUEUR][LARGEUR], coord *position_souris)
                                                      {
                                                          int pasPlace = 1;
                                                          recupCoord(position_souris);
                                                          if (mouse_b & 1)
                                                          {
                                                        	    if (grille[position_souris->ligne][position_souris->colonne] == VIDE)
                                                         	    {
                                                                  if (joueur == 1)
                                                           	    {
                                                               	    grille[position_souris->ligne][position_souris->colonne] = PIONJOUEUR1;
                                                             	    }
                                                             	    else
                                                             	    {
                                                              	    grille[position_souris->ligne][position_souris->colonne] = PIONJOUEUR2;
                                                             	    }
                                                           	    pasPlace = 0;
                                                         		}
                                                         }
                                                          return pasPlace;
                                                      }
                                                      
                                                      void prepare_Grille(Case Grille[LONGUEUR][LARGEUR])
                                                      {
                                                      	/* Met toute la grille en paramètre à vide */
                                                      
                                                      	int i = 0;
                                                      	int j = 0;
                                                      
                                                      	while (i < LONGUEUR)
                                                      	{
                                                      		while (j < LARGEUR)
                                                      		{
                                                      			Grille[i][j] = VIDE;
                                                      			j++;
                                                      		}
                                                      		i++;
                                                      		j = 0;
                                                      	}
                                                      }
                                                      
                                                      int verifierLigne(Case Grille[LONGUEUR][LARGEUR], int ligne, unsigned int pion)
                                                      {
                                                      	/* Retourne 1 si gagnant, 0 sinon */
                                                      
                                                      	int colonne = 0;
                                                      	int alignes = 0;
                                                          int gagnant = 0;
                                                      	
                                                      	while (colonne != LARGEUR && alignes != NBPIONS)
                                                      	{
                                                      		if (Grille[ligne][colonne] == pion)
                                                      		{
                                                      			alignes++;
                                                      		}
                                                      		else
                                                      		{
                                                      			alignes = 0;
                                                      		}
                                                      		colonne++;
                                                      	}
                                                          if (alignes == NBPIONS)
                                                          {
                                                              gagnant = 1;
                                                          }
                                                      	return gagnant;
                                                      }
                                                      
                                                      int verifierColonne(Case Grille[LONGUEUR][LARGEUR], int colonne, unsigned int pion)
                                                      {
                                                      	/* Renvoie 1 si gagnant, 0 sinon */
                                                      
                                                      	int ligne = 0;
                                                      	int alignes = 0;
                                                          int gagnant = 0;
                                                      
                                                      	while (ligne != LONGUEUR && alignes != NBPIONS)
                                                      	{
                                                      		if (Grille[ligne][colonne] == pion)
                                                      		{
                                                      			alignes++;
                                                      		}
                                                      		else
                                                      		{
                                                      			alignes = 0;
                                                      		}
                                                      		ligne++;
                                                      	}
                                                          if (alignes == NBPIONS)
                                                          {
                                                              gagnant = 1;
                                                          }
                                                      	return gagnant;
                                                      }
                                                      
                                                      int verifDiagBasDroite(Case Grille[LONGUEUR][LARGEUR], int ligne, int colonne, unsigned int pion)
                                                      {
                                                          int alignes = 0;
                                                          int gagne = 0;
                                                          while (Grille[ligne][colonne] == pion && alignes != NBPIONS && (ligne != LONGUEUR && colonne != LARGEUR))
                                                          {
                                                              alignes++;
                                                              ligne++;
                                                              colonne++;
                                                          }
                                                          if (alignes == NBPIONS)
                                                          {
                                                              gagne = 1;
                                                          }
                                                          return gagne;
                                                      }
                                                      
                                                      int verifDiagBasGauche(Case Grille[LONGUEUR][LARGEUR], int ligne, int colonne, unsigned int pion)
                                                      {
                                                          int alignes = 0;
                                                          int gagnant = 0;
                                                          while (Grille[ligne][colonne] == pion && alignes != NBPIONS)
                                                          {
                                                              alignes++;
                                                              ligne++;
                                                              colonne--;
                                                              if (ligne == LONGUEUR || colonne < 0)
                                                              {
                                                                  break;
                                                              }
                                                          }
                                                          if (alignes == NBPIONS)
                                                          {
                                                              gagnant = 1;
                                                          }
                                                          return gagnant;
                                                      }
                                                      
                                                      int verifDiagHautGauche(Case Grille[LONGUEUR][LARGEUR], int ligne, int colonne, unsigned int pion)
                                                      {
                                                          int alignes = 0;
                                                          int gagnant = 0;
                                                          while (Grille[ligne][colonne] == pion && alignes != NBPIONS)
                                                          {
                                                              alignes++;
                                                              ligne--;
                                                              colonne--;
                                                              if (ligne < 0 || colonne < 0)
                                                              {
                                                                  break;
                                                              }
                                                          }
                                                          if (alignes == NBPIONS)
                                                          {
                                                              gagnant = 1;
                                                          }
                                                          return gagnant;
                                                      }
                                                      int verifDiagHautDroite(Case Grille[LONGUEUR][LARGEUR], int ligne, int colonne, unsigned int pion)
                                                      {
                                                          int alignes = 0;
                                                          int gagnant = 0;
                                                          while (Grille[ligne][colonne] == pion && alignes != NBPIONS)
                                                          {
                                                              alignes++;
                                                              ligne--;
                                                              colonne++;
                                                              if (ligne < 0 || colonne == LARGEUR)
                                                              {
                                                                  break;
                                                              }
                                                          }
                                                          if (alignes == NBPIONS)
                                                          {
                                                              gagnant = 1;
                                                          }
                                                          return gagnant;
                                                      }
                                                      
                                                      int verifierDiagonales(Case Grille[LONGUEUR][LARGEUR], int ligne, int colonne, unsigned int pion)
                                                      {
                                                      	/* Renvoie le nb de pions alignés en diagonale. Si égal à NBPIONS on a un gagnant.
                                                      	Vérifie d'abord en haut à droite puis en haut à gauche avant de faire le bas dans le même ordre */
                                                      
                                                          int gagne = 0;
                                                      
                                                          gagne = verifDiagHautGauche(Grille, ligne, colonne, pion) || verifDiagHautDroite(Grille, ligne, colonne, pion) ||
                                                          verifDiagBasGauche(Grille, ligne, colonne, pion) || verifDiagBasDroite(Grille, ligne, colonne, pion);
                                                      
                                                          return gagne;
                                                      }
                                                      
                                                      int verifierGrille(Case Grille[LONGUEUR][LARGEUR], coord *position_souris, int joueur)
                                                      {
                                                      	/* Vérifie s'il y a un gagnant en utilisant les fonctions précédentes */ 
                                                      
                                                      	int gagne = 0;
                                                      	unsigned int pion;
                                                      
                                                          if (joueur == 1)
                                                          {
                                                              pion = PIONJOUEUR1;
                                                          }
                                                          else
                                                          {
                                                              pion = PIONJOUEUR2;
                                                          }
                                                      	if (!(gagne = verifierLigne(Grille, position_souris->ligne, pion)
                                                               || !(gagne == verifierColonne(Grille, position_souris->colonne, pion))))
                                                          {
                                                              gagne = verifierDiagonales(Grille, position_souris->ligne, position_souris->colonne, pion);
                                                          }
                                                      	return gagne; 
                                                      }
                                                      
                                                      
                                                      void afficherGrille (Case grille[LONGUEUR][LARGEUR], int joueur, int termine,
                                                      int gagne, BITMAP *buffer, BITMAP *vide, BITMAP *rouge, BITMAP *bleu)
                                                      {
                                                      	int positionWBlit = 0;
                                                      	int positionHBlit = 0;
                                                      	int nbCasesLigne = 0;
                                                      	int nbCasesColonne = 0;
                                                      
                                                      	while (nbCasesLigne < LONGUEUR)
                                                      	{
                                                      		while (nbCasesColonne < LARGEUR)
                                                      		{
                                                      			if (grille[nbCasesLigne][nbCasesColonne] == VIDE)
                                                      			{
                                                      				blit(vide, buffer, 0, 0, positionWBlit, positionHBlit, COTECASE, COTECASE);
                                                      			}
                                                      			else if (grille[nbCasesLigne][nbCasesColonne] == PIONJOUEUR1)
                                                      			{
                                                      				blit(rouge, buffer, 0, 0, positionWBlit, positionHBlit, COTECASE, COTECASE);
                                                      			}
                                                      			else
                                                      			{
                                                      				blit(bleu, buffer, 0, 0, positionWBlit, positionHBlit, COTECASE, COTECASE);
                                                      			}
                                                      			nbCasesColonne++;
                                                      			positionWBlit = positionWBlit + COTECASE + ESPACEMENT;
                                                      		}
                                                      		nbCasesColonne = 0;
                                                      		nbCasesLigne++;
                                                      		positionWBlit = 0;
                                                      		positionHBlit = positionHBlit + COTECASE + ESPACEMENT; 
                                                      	}
                                                      	positionWBlit = COTECASE * LARGEUR + ESPACEMENT * LARGEUR + 8; /* 8 : hauteur de la police des messages */
                                                      		if (termine||gagne)
                                                      		{
                                                                  if (gagne)
                                                                  {
                                                      			    if (joueur == 1)
                                                      	 		    {
                                                      				    textout_ex(buffer, font, "le joueur 1 a gagné !", 0, positionWBlit, makecol(255, 0, 0), -1);
                                                      	 		    }
                                                      	 		    else
                                                      	 		    {
                                                      				    textout_ex(buffer, font, "le joueur 2 a gagné !", 0, positionWBlit, makecol(255, 0, 0), -1);
                                                      	 		    }
                                                                  }
                                                      		    else
                                                      		    {
                                                      			    textout_ex(buffer, font, "Match nul", 0, positionWBlit, makecol(255, 0, 0), -1);
                                                      		    }
                                                      		}
                                                      		textout_ex(buffer, font, "Une fois la partie terminée, q pour quitter, une autre touche pour rejouer.",
                                                               0, positionWBlit + 20, makecol(255, 0, 0), -1);
                                                      	blit(buffer, screen, 0, 0, 0, 0, SCREEN_W, SCREEN_H);
                                                      }
                                                      


                                                      grille.h
                                                      #ifndef head_grille
                                                      #define head_grille
                                                      #include <allegro.h>
                                                      enum Case
                                                       {
                                                      	VIDE,
                                                      	PIONJOUEUR1,
                                                      	PIONJOUEUR2
                                                       };
                                                      typedef enum Case Case;
                                                      
                                                      struct Coordonnees
                                                      {
                                                          int ligne;
                                                          int colonne;
                                                      };
                                                      typedef struct Coordonnees coord; 
                                                      
                                                      #define LONGUEUR 7
                                                      #define LARGEUR 7
                                                      #define NBPIONS 5
                                                      #define COTECASE 25
                                                      #define ESPACEMENT 3
                                                      
                                                      int placerPion (int joueur, Case grille[LONGUEUR][LARGEUR], coord *test);
                                                      void prepare_Grille(Case Grille[LONGUEUR][LARGEUR]);
                                                      void afficher_ligne(void);
                                                      int verifierLigne(Case Grille[LONGUEUR][LARGEUR], int ligne, unsigned int pion);
                                                      int verifierColonne(Case Grille[LONGUEUR][LARGEUR], int colonne, unsigned int pion);
                                                      int verifDiagBasDroite(Case Grille[LONGUEUR][LARGEUR], int ligne, int colonne, unsigned int pion);
                                                      int verifDiagBasGauche(Case Grille[LONGUEUR][LARGEUR], int ligne, int colonne, unsigned int pion);
                                                      int verifDiagHautGauche(Case Grille[LONGUEUR][LARGEUR], int ligne, int colonne, unsigned int pion);
                                                      int verifDiagHautDroite(Case Grille[LONGUEUR][LARGEUR], int ligne, int colonne, unsigned int pion);
                                                      int verifierDiagonales(Case Grille[LONGUEUR][LARGEUR], int ligne, int colonne, unsigned int pion);
                                                      int verifierGrille(Case Grille[LONGUEUR][LARGEUR], coord *test, int joueur);
                                                      void recupCoord(coord *position_souris);
                                                      void afficherGrille (Case grille[LONGUEUR][LARGEUR], int joueur, int termine,
                                                      int gagne, BITMAP *buffer, BITMAP *vide, BITMAP *rouge, BITMAP *bleu);
                                                      #endif
                                                      


                                                      Si vous avez des commentaires à faire, je suis preneur. :)
                                                      • Partager sur Facebook
                                                      • Partager sur Twitter
                                                        9 janvier 2011 à 17:10:16

                                                        Ah, Allegro. :)

                                                        l'avantage par rapport à la SDL, c'est que tu as, en standard, des fonctions pour faire de l'affichage de texte basique, ainsi que le tracé de primitives.

                                                        Je vois que tu crées et libère tes bitmaps à chaque appel de ta fonction afficherGrille.
                                                        L'idéal, c'est de créer les ressources au débuts du programme, et de tout libérer à la fin.

                                                        Dans ta fonction, placerPion, tu utilises des fonctions Allegro et tu met à jour ta grille qui n'a rien à voir avec l'affichage.
                                                        Le mieux serait de retourner les coordonnées de la case cliquée.
                                                        Après c'est à la partie logique de ton jeu de gérer ces coordonnées.

                                                        Merci, de montrer qu'Allegro n'est pas mort. ;)
                                                        • Partager sur Facebook
                                                        • Partager sur Twitter
                                                        Zeste de Savoir, le site qui en a dans le citron !
                                                          10 janvier 2011 à 13:22:14

                                                          Alors alors...

                                                          Citation : GurneyH

                                                          Je vois que tu crées et libère tes bitmaps à chaque appel de ta fonction afficherGrille.
                                                          L'idéal, c'est de créer les ressources au débuts du programme, et de tout libérer à la fin.



                                                          C'est sûr que ça limite les allocations et libérations de la mémoire. Mais en fait j'ai fait comme ça parce que je n'avais besoin des bitmaps nulle part ailleurs. :-°
                                                          Cela dit je suis d'accord, c'est (bien) mieux de tout faire une seule fois.

                                                          Citation : GurneyH


                                                          Dans ta fonction, placerPion, tu utilises des fonctions Allegro et tu met à jour ta grille qui n'a rien à voir avec l'affichage.
                                                          Le mieux serait de retourner les coordonnées de la case cliquée.
                                                          Après c'est à la partie logique de ton jeu de gérer ces coordonnées.



                                                          Là je suis pas sûr d'avoir bien compris ce que tu proposes. Je vais essayer d'implémenter ça sous forme de structure, mais je risque encore de mélanger les fonctions non ?

                                                          Enfin, s'il y a d'autres commentaires, je veux bien.
                                                          • Partager sur Facebook
                                                          • Partager sur Twitter
                                                            10 janvier 2011 à 22:17:06

                                                            qnope >
                                                            Mêmes remarques qu'en console. :-°
                                                            Initialiser toutes tes cases de structure est inutile, tu initialises la première et le reste sera initialisé à 0.
                                                            D'autres trucs, mais la flème de commenter. :-°

                                                            Magicneo >
                                                            La flème de commenter ton code en fait. :-°
                                                            J'le ferai plus tard, mais quelques trucs histoire de dire que j'ai pas posté pour rien :
                                                            Tu pourrais plus découper ton code en fonctions.
                                                            Ton #ifndef au début de chaque .c ne sert à rien, il aurait fallut le faire sur ton .h
                                                            Tes fonctions de vérification sont très redondantes, tu pourrais essayer de raccourcir. :)
                                                            Faire un pointeur sur une variable qui existe dans le 'scope' ne sert à rien : int *ptrColonne = &colonne; autant passer le pointeur directement aux fonctions

                                                            Sinon, sympa allegro, j'aime bien. ^^

                                                            Merci pour votre participation. :-)
                                                            • Partager sur Facebook
                                                            • Partager sur Twitter

                                                            zMorp SDL

                                                            × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
                                                            × Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
                                                            • Editeur
                                                            • Markdown