Partage

zMorp SDL

1 2 3 4 >>

27 décembre 2010 à 0:08:03

Vu que le dernier exercice a intéressé quelques personnes, je me suis dis que ça pourrait être intéressant de l'étendre à une lib graphique -> la SDL.
La SDL, car c'est la bibliothèque qui est la plus connue sur ce forum, mais si vous êtes tentés par une autre bibliothèque, ne vous privez pas.

Le but de cet exercice est exactement le même que son homologue en console, à savoir réaliser un morpion 2 joueurs.

Les différences?
Le déroulement du jeu, et l'affichage.
Le déroulement:
Ici, plutôt que rentrer un numéro, ou les coordonnées de la case, le joueur doit cliquer sur la case désirée.
On affiche le nouvel état du plateau, et on passe au joueur suivant.
L'affichage:
On n'est pas en console, et vous avez 2 choix:
-vous dessinez vos croix et vos cercles avec un logiciel de dessin, et vous les importez.
-Vous dessinez ces formes dans votre programme(plus drôle : diable: )

Si vous avez besoin de précisions, sur l'énoncé, la méthode, la SDL(ou autre), vous pouvez les poser ici.

En espérant vous voir nombreux :-°

.

Si ce genre de topics vous intéresse on, pourrait voir à ponctuellement proposer la réalisation de jeux 2d simples.

edit:
Quelques conseil pour démarrer, si vraiment vous vous sentez bloqué.

- Se rappeler que l'utilisation d'une lib graphique ne change rien à la logique du jeu. La manière de tester une grille est identique à ce qu'on fait avec l'exercice zMorp en console.
- Pour afficher des messages, pensez à utiliser la barre de titre de la fenètre(SDL_WM_SetCaption).
- Le morpion n'est pas un jeu en temps réel(on attend des action utilisateurs), SDL_WaitEvent est très approprié ici.
- Pour représenter les joueurs, des rectangles de couleurs différentes suffisent

Zeste de Savoir, le site qui en a dans le citron !

coyote60

27 décembre 2010 à 0:37:58

ha je l attenté se lui la, je pensé que tu ferai un exo sur l'IA avant

Anonyme

27 décembre 2010 à 1:51:59

Malgré que je ne fais pas partis de la communauté des codeurs C en "mode graphique" ( >_<

) ce sujet est très intéressant pour les concernés.
De plus, proposer un exercice avec l'appel d'une librairie graphique est je pense plus qu'un bon entraînement.
(Parce que les Mario Sokoban tout ça, ras le bol hein :-°

)

darkipod

27 décembre 2010 à 8:12:47

Purée de purée ! J'ai pas encore fini en console
je me grouille

GurneyH

27 décembre 2010 à 8:14:47

Citation : darkipod

Purée de purée ! J'ai pas encore fini en console
je me grouille

Il n'y a pas le feu non plus.
Disons que pour celui ci, vous avez tout votre temps.
Et il sera très facile, après avoir réalisé le morpion en console.

Zeste de Savoir, le site qui en a dans le citron !

Pouet_forever

27 décembre 2010 à 11:42:43

coyote60 > L'IA n'a rien à voir avec le mode graphique ou console, tu peux très bien le faire à part.

Pour ceux qui ont fait un code console, c'est un bon moyen de voir si votre code est facilement transposable (bien découpé en fonctions) pour que vous n'ayez que quelques fonctions à changer sans changer tout le code.

coyote60

29 décembre 2010 à 22:12:11

j ai compris (un peut tare ) la remarque que tu ma fait sur l'autre sujet (zMorp 1ére partie). sur mai fonction qui font plusieurs chose, la je suis entrain de luté avec mai Fprint que j ai mi partout

GurneyH

30 décembre 2010 à 10:35:02

Est-ce qu'un squelette de programme vous aiderait à débuter(genre initialisation, boucle principale)?

Zeste de Savoir, le site qui en a dans le citron !

nasta

30 décembre 2010 à 10:52:44

Citation : GurneyH

Pour afficher des messages, pensez à utiliser la barre de titre de la fenêtre(SDL_WM_SetCaption).

Tu veux dire que dans le titre de la fenêtre, on écrit par exemple "Joueur 1, à vous" ou "Joueur 2 a "gagné"?

coyote60

30 décembre 2010 à 10:57:37

moi je suis partie sur la SDL_TTF pour les messages. est comme j ai encore du mal avec sa tombe bien.

nasta

30 décembre 2010 à 11:03:40

Moi, j'ai pas trop de problème avec, mais ça m'embête de devoir charger des surfaces. Peur-être que je mettrai ensuite en amélioration...

GurneyH

30 décembre 2010 à 11:30:19

Citation : Nasta

Tu veux dire que dans le titre de la fenêtre, on écrit par exemple "Joueur 1, à vous" ou "Joueur 2 a "gagné"?

Exactement.

Citation : Nasta

Moi, j'ai pas trop de problème avec, mais ça m'embête de devoir charger des surfaces.

Charger des surfaces n'est pas une obligation.
Avoir un truc qui tourne rapidement avec des SDL_FillRect est plus intéressant à mon avis. Après, il est facile, je mettre de l'enrobage.

Zeste de Savoir, le site qui en a dans le citron !

C159

30 décembre 2010 à 18:28:03

tu peux tout faire sans charger d'image : un fond noir avec 9 cases blanches + SDL_TTF

mais sinon penser à vérifier les retours des fonction sinon vous aurez de grave problème pour trouver l'erreur. mais encore c'est pas grand grand comme programme

sinon j'esserai si j'ai le temps

Nouveau site en constrution sur les mangas, anime, Visual novel

GurneyH

30 décembre 2010 à 18:51:33

Même pas besoin de SDL_TTF.

Comme ça on évite les problèmes habituels.
Une case rouge, une case verte.

Zeste de Savoir, le site qui en a dans le citron !

nasta

30 décembre 2010 à 19:55:30

Personnellement, j'ai préféré utiliser 3 image : la grille, la croix et le rond.
Quand je dis que je ne veux pas charger les surfaces, je parle de SDL_TTF. Je n'ai pas envie de devoir passer pas 3 fonctions juste pour afficher un message.
Je sais que je peut me faire une fonction perso, mais je pense que je ferais mieux de mettre ça en amélioration.
Sinon, je viens de me rendre compte que ma fenêtre est plus grande que mon écran... :-°

GurneyH

30 décembre 2010 à 20:08:33

Citation : nasta

Sinon, je viens de me rendre compte que ma fenêtre est plus grande que mon écran...

C'est effectivement un peu embêtant.

Perso, comme, je n'utilises pas d'image, j'ai déterminé la taille des cases en fonction de la taille de l'écran.
J'avoue, pour un morpion 100 x 100 les cases sont petites. :-°

Citation : Nasta

Quand je dis que je ne veux pas charger les surfaces, je parle de SDL_TTF. Je n'ai pas envie de devoir passer pas 3 fonctions juste pour afficher un message.

Tout à fait.

Afficher dans la barre de titre pour un morpion est suffisant, je pense.
Le but, est de ne pas avoir une usine à gaz.

Zeste de Savoir, le site qui en a dans le citron !

Pouet_forever

30 décembre 2010 à 22:05:57

J'me suis amusé à faire un truc en SDL.

#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#include "SDL.h"

enum {
  TAB_H = 5,              /* Hauteur  */
  TAB_W = 5,              /* Largeur  */
  TAB_T = TAB_H * TAB_W,  /* Nbre total de cases      */
  NBR_P = 3               /* Nbre de pions à aligner  */
};

enum {
  SCR_CEL = 50,
  SCR_H   = TAB_H * SCR_CEL,
  SCR_W   = TAB_W * SCR_CEL
};

enum {
  VIDE  = 0,
  J1    = 1,
  J2    = 2
};

typedef struct Coord_ {
  int x;
  int y;
} Coord;

int testerCoup(int * tab, Coord * c) {
  if ((unsigned) c->x >= TAB_W || (unsigned) c->y >= TAB_H ||
      tab[c->y * TAB_W + c->x] != VIDE)
    return 0;
  else
    return 1;
}

void attendreClic(void) {
  SDL_Event e;
  int done = 0;
  
  while (!done) {
    SDL_WaitEvent(&e);
    if (e.type == SDL_QUIT)
      exit(EXIT_SUCCESS);
    if (e.type == SDL_MOUSEBUTTONDOWN)
      done = 1;
  }
}

int saisieCoord(int * tab, Coord * c) {
  SDL_Event e;
  int done = 0;
  
  while (!done) {
    SDL_WaitEvent(&e);
    if (e.type == SDL_QUIT)
      exit(EXIT_SUCCESS);
    if (e.type == SDL_MOUSEBUTTONDOWN) {
      c->x = e.motion.x / SCR_CEL;
      c->y = e.motion.y / SCR_CEL;
      done = testerCoup(tab, c);
    }
  }
  
  return 0;
}

int jouerCoup(int * tab, Coord * c, int joueur) {
  tab[c->y * TAB_W + c->x] = joueur;
  return 0;
}

SDL_Surface * creerBckgrnd(void) {
  int i, j, pct;
  SDL_Surface * s = SDL_CreateRGBSurface(SDL_HWSURFACE,
                                         SCR_W, SCR_H, 32, 0, 0, 0, 0);
  SDL_Rect r, t;
  
  if (s == NULL) {
    fprintf(stderr, "%s\n", SDL_GetError());
    exit(EXIT_FAILURE);
  }
  
  SDL_FillRect(s, NULL, ~0U);
  pct = (SCR_CEL * 2) / 100;
  r.h = SCR_CEL;
  r.w = SCR_CEL;
  t.h = SCR_CEL - 2 * pct;
  t.w = SCR_CEL - 2 * pct;
  for (i = 0; i < TAB_H; i++) {
    for (j = 0; j < TAB_W; j++) {
      r.x = i * SCR_CEL;
      r.y = j * SCR_CEL;
      SDL_FillRect(s, &r, 0U);
      
      t.x = i * SCR_CEL + pct;
      t.y = j * SCR_CEL + pct;
      SDL_FillRect(s, &t, ~0U);
    }
  }
  return s;
}

/* affiche(NULL); pour free la surface static */
void affiche(int * tab) {
  static SDL_Surface * bckgrnd = NULL;
  SDL_Surface * scr = SDL_GetVideoSurface();
  SDL_Rect r;
  Uint32 c[2] = { 0x00FF00FF, 0x0000FF00 };
  int i, j;
  static int pct = (SCR_CEL * 2) / 100;
  
  if (tab == NULL) {
    free(bckgrnd);
    bckgrnd = NULL;
    return;
  }
  
  if (!bckgrnd)
    bckgrnd = creerBckgrnd();
  
  SDL_BlitSurface(bckgrnd, NULL, scr, NULL);
  
  r.h = SCR_CEL - 2 * pct;
  r.w = SCR_CEL - 2 * pct;
  for (i = 0; i < TAB_H; i++) {
    for (j = 0; j < TAB_W; j++) {
      if (tab[i * TAB_W + j] != VIDE) {
        r.x = j * SCR_CEL + pct;
        r.y = i * SCR_CEL + pct;
        SDL_FillRect(scr, &r, c[tab[i * TAB_W + j] - 1]);
      }
    }
  }
  
  SDL_Flip(scr);
}

int compterDir(int * tab, Coord * c, int x, int y, int joueur) {
  int cnt, i, j;
  
  cnt = 0;
  for (j = c->x + x, i = c->y + y;
       (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, 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);
    if (cnt + 1 >= NBR_P)
      return 1;
  }
  
  return 0;
}

int estGagnant(int ret, int joueur, int pce) {
  char s[50];
  
  if (ret) {
    sprintf(s, "J%d gagne !", joueur);
  }
  else if (pce >= TAB_T)
    sprintf(s, "Match nul !");
  else
    return 0;
  
  SDL_WM_SetCaption(s, NULL);
  attendreClic();
  return 1;
}

void jouer(int joueur) {
  int tab[TAB_T] = { 0 };
  int done, pce, ret;
  char s[50];
  Coord c;
  
  affiche(tab);
  
  pce = 0;
  done = 0;
  while (!done) {
    sprintf(s, "J%d joue", joueur);
    SDL_WM_SetCaption(s, NULL);
    saisieCoord(tab, &c);
    jouerCoup(tab, &c, joueur);
    pce++;
    ret = testerGrille(tab, &c, joueur);
    affiche(tab);
    done = estGagnant(ret, joueur, pce);
    joueur = 3 - joueur;
  }
  
  affiche(NULL);
}

int rejouer(void) {
  SDL_Event e;
  int c;
  
  SDL_WM_SetCaption("Voulez-vous rejouer (o)ui/(n)on ?", NULL);
  
  c = 0;
  do {
    SDL_WaitEvent(&e);
    if (e.type == SDL_QUIT)
      exit(EXIT_SUCCESS);
    if (e.type == SDL_KEYDOWN) {
      c = e.key.keysym.sym;
      c = toupper(c);
    }
  } while (c != 'N' && c != 'O');
  return c == 'O';
}

int init(void) {
  srand(time(NULL));
  if (SDL_Init(SDL_INIT_VIDEO) < 0) {
    fprintf(stderr, "%s\n", SDL_GetError());
    return -1;
  }
  atexit(SDL_Quit);
  if (SDL_SetVideoMode(SCR_W, SCR_H, 32, SDL_HWSURFACE) == NULL) {
    fprintf(stderr, "%s\n", SDL_GetError());
    return -1;
  }
  return 0;
}

int main(int argc, char ** argv) {
  int joueur;
  
  if (init() < 0)
    return EXIT_FAILURE;
  
  joueur = rand() % 2 + 1;
  do {
    jouer(joueur);
    joueur = 3 - joueur;
  } while (rejouer());
  
  return EXIT_SUCCESS;
}

Edit: petite correction.

GurneyH

30 décembre 2010 à 22:48:17

Bon, bah voilà...

TTf?
Autre chose?

Pouet ton morpion est trop beau!

On reste sur le basique!
Mais sérieux, encore plusieurs qui font ça, et c'est la crise cardiaque!

Zeste de Savoir, le site qui en a dans le citron !

nasta

30 décembre 2010 à 23:00:29

Fini le mien. Y'a sûrement des améliorations à faire mais il fonctionne normallement et je n'ai pas de warning...

main.c :

/**
    main.c
    Rôle : contient les fonctions "de base"
    Note : Dans tout le projet, les ligne suivies d'un double-slash '//' sont à modifier dans le cas d'un agrandissement de la grille
*/

#include <stdbool.h>
#include <SDL/SDL.h>
#include "constantes.h"

/* prototypes */
void jeu (Surfaces *surfs);

/* fonctions */
void freeSurfs (Surfaces *surfs) // Libère toutes les surfaces
{
    SDL_FreeSurface(surfs->grid);
    SDL_FreeSurface(surfs->cross);
    SDL_FreeSurface(surfs->circle);
}

void Quit (Surfaces *surfs)
{
    freeSurfs(surfs);
    SDL_Quit();
}

void initSurfs (Surfaces *surfs) // Initialise la structure surfaces
{
    // chargements
    surfs->grid = SDL_LoadBMP("Grille.bmp");
    surfs->cross = SDL_LoadBMP("croix.bmp");
    surfs->circle = SDL_LoadBMP("rond.bmp");
    // vérifications
    if (surfs->grid == NULL || surfs->cross == NULL || surfs->circle == NULL) // Si un des surfaces n'a pas été chargée
    {
        fprintf (stderr, "Erreur lors du chargement des images bmp : %s\n", SDL_GetError());
        exit (EXIT_FAILURE);
    }
    // Transparance
    SDL_SetColorKey(surfs->cross, SDL_SRCCOLORKEY, SDL_MapRGB(surfs->cross->format, 255, 255, 255));
    SDL_SetColorKey(surfs->circle, SDL_SRCCOLORKEY, SDL_MapRGB(surfs->circle->format, 255, 255, 255));
}

int main (int argc, char *argv[]) // Se charge de toutes les initialisations
{
    SDL_Surface *ecran = NULL;
    Surfaces surfs;

    /* Initialisation SDL */
    if (SDL_Init(SDL_INIT_VIDEO) < 0)
    {
        fprintf (stderr, "Erreur lors du chargement de la SDL : %s\n", SDL_GetError());
        exit (EXIT_FAILURE);
    }

    /* Création de la surface de rendu vidéo */
    ecran = SDL_SetVideoMode(L_FENETRE, H_FENETRE, 32, SDL_HWSURFACE | SDL_DOUBLEBUF );

    if (ecran == NULL)
    {
        fprintf (stderr, "Erreur lors de la création de la fenêtre avec 'SDL_SetVideoMode' : %s\n", SDL_GetError());
        exit (EXIT_FAILURE);
    }

    initSurfs(&surfs);

    jeu(&surfs);

    Quit(&surfs);
    return EXIT_SUCCESS;
}

bool gagne (const SDL_Rect lastPlayP, const Signe LastPlayS, Signe grille [][H_GRILLE]) // Cette fonction renvoie tru s'il y a une victoire. Le contexte d'appel permet de définir le gagnant
{
    /* On regarde si la ligne du dernier coup est remplie du dernier signe à avoir joué */
    if (grille[lastPlayP.x][0] == LastPlayS && grille[lastPlayP.x][1] == LastPlayS && grille[lastPlayP.x][2] == LastPlayS) //
    {
        return true;
    }

    if (grille[0][lastPlayP.y] == LastPlayS && grille[1][lastPlayP.y] == LastPlayS && grille[2][lastPlayP.y] == LastPlayS) //
    {
        return true;
    }

    /* test des diagnales */
    if (grille[0][0] == LastPlayS && grille[1][1] == LastPlayS  && grille[2][2] == LastPlayS) //
    {
        return true;
    }

    if (grille[0][2] == LastPlayS && grille[1][1] == LastPlayS && grille[2][0] == LastPlayS) //
    {
        return true;
    }

    return false;
}

void estGagnant (Signe joueur) // affiche le gagnant
{
    SDL_Surface *ecran = SDL_GetVideoSurface();

    if (joueur == Cross)
    {
        SDL_Flip(ecran); // Un flip pour montrer l'état du jeu avant la fermeture
        SDL_WM_SetCaption("Les croix ont gagnees ! Bravo !", NULL);
        SDL_Delay(2000);
    }
    else
    {
        SDL_Flip(ecran);
        SDL_WM_SetCaption("Les cercles ont gagnes ! Bravo !", NULL);
        SDL_Delay(2000);
    }
}

bool recommencer () // Retourne true si le joueur veut recommencer
{
    SDL_Event event;
    SDL_WM_SetCaption("Voulez-vous rejouer ? (o)ui/(n)on", NULL);

    while(1)
    {
        SDL_WaitEvent(&event);
        if (event.type == SDL_QUIT)
        return false;

        if (event.type == SDL_KEYDOWN)
        {
            if (event.key.keysym.sym == SDLK_o)
            return true;

            if (event.key.keysym.sym == SDLK_n)
            return false;

            if (event.key.keysym.sym == SDLK_ESCAPE) // Petite pensée à ceux qui n'ont pas de souris (sisi, ça arrive...)
            return false;
        }
    }
    return false; // pour éviter un warning
}

void jeu (Surfaces *surfs) // Fonction principale du jeu
{
    SDL_Rect posZero;
    SDL_Rect caseClique, caseBlit; // Indique sur quelle case on a cliqué et la position du blit d'un signe
    SDL_Surface *ecran = SDL_GetVideoSurface();
    SDL_Surface *signeActuel; // Cette surface est celle que l'on blittera sur l'ecran. Elle prendra une des valeurs des surfaces de notre structure
    SDL_Event event;
    Signe tourDeJeu = Cross; // Les croix jouent en premier
    bool continuer = true;
    int nbCoups = NB_CASES;
    Signe grille[L_GRILLE][H_GRILLE] = {{Vide, Vide, Vide},//
                                        {Vide, Vide, Vide},//
                                        {Vide, Vide, Vide}};//

    posZero.x = 0;
    posZero.y = 0;

    SDL_BlitSurface(surfs->grid, NULL, ecran, &posZero); // On blitte la grille à l'écran
    while (continuer)
    {
        if (tourDeJeu == Cross) // On dit qui doit jouer
        {
            SDL_WM_SetCaption("Aux croix de jouer", NULL);
            signeActuel = surfs->cross;
        }
        else
        {
            SDL_WM_SetCaption("Aux cercles de jouer", NULL);
            signeActuel = surfs->circle;
        }

        SDL_WaitEvent(&event); // On attend l'évênement

        if (event.type == SDL_QUIT)
        continuer = 0;

        else if ((event.type == SDL_KEYDOWN) && (event.key.keysym.sym == SDLK_ESCAPE)) // Toujours pour ceux qui n'ont pas de souris (voir plus haut^^)
        continuer = 0;

        else if ((event.type == SDL_MOUSEBUTTONDOWN) && (event.button.button == SDL_BUTTON_LEFT)) // Si on a cliqué
        {
            caseClique.x = event.button.x / TA_SIGNE;
            caseClique.y = event.button.y / TA_SIGNE;
            caseBlit.x = (caseClique.x * TA_SIGNE) + (LARG_LIGNE_GRILLE * caseClique.x); // Le deuxième terme permet de tenir compte de la ligne noire
            caseBlit.y = (caseClique.y * TA_SIGNE) + (LARG_LIGNE_GRILLE * caseClique.y);

            if(grille[caseClique.x][caseClique.y] == Vide) // Si la case cliquée est vide
            {
                grille[caseClique.x][caseClique.y] = tourDeJeu; // On la remplis avec le bon signe
                SDL_BlitSurface(signeActuel, NULL, ecran, &caseBlit);
                nbCoups --; // On a le doit à 1 coup de moins

                if (gagne(caseClique, tourDeJeu, grille))
                {
                    estGagnant(tourDeJeu);
                    continuer = 0;
                    if (recommencer())
                    jeu(surfs); // Si on veut recommencer, on fait un appel récursif
                }

                if (nbCoups == 0) // Si nbCoups est égal à 0, c'est que a grille est pleine
                {
                    SDL_Flip(ecran);
                    SDL_WM_SetCaption("Match nul...", NULL);
                    SDL_Delay(2000);
                    continuer = 0;
                    if (recommencer())
                    jeu(surfs);
                }
                /* On change la valeur de tourDeJeu */
                if (tourDeJeu == Cross)
                tourDeJeu = Circle;
                else
                tourDeJeu = Cross;
            }
            else
            {
                SDL_WM_SetCaption("Desole, cette case est prise", NULL);
                SDL_Delay(1000);
            }

        }
        SDL_Flip(ecran);
    }
}

constante.h

/**
    constantes.h
    Rôle : Contient toutes les constantes du jeu
*/

#define H_FENETRE 512
#define L_FENETRE 512
#define H_GRILLE 3//
#define L_GRILLE 3//
#define NB_CASES H_GRILLE*L_GRILLE
#define TA_GRILLE 512
#define TA_SIGNE 165 // taille de la croix et du rond
#define LARG_LIGNE_GRILLE 9 // Largeur de la ligne séparant les cases, à prendre en compte lors du blit

typedef enum {Vide, Cross, Circle} Signe; // Indique ce que contient une case du plateau ainsi que le joueur qui doit jouer

typedef struct
{
    SDL_Surface *grid;
    SDL_Surface *cross;
    SDL_Surface *circle;
} Surfaces;

Lien de téléchargement du code, de l'executable et des ressources :
zmorpsdl.zip

Pour info, j'avais pas codé le mode console. Ca m'a quand-même pas mal entrainé...

Sinon, Ouah !
J'adore les couleurs que tu as choisis pouet_forever.

Pouet_forever

30 décembre 2010 à 23:20:24

nasta > Tu vois, c'est pour ça que j'avais proposé le zMorp console avant celui graphique. :'(

Tu t'es concentré sur la partie graphique et du coup tu as laissé le reste du code. C'est le piège de beaucoup de gens, dommage que tu n'aies pas fait celui en console avant.
Tu peux refaire ton code en console sur le topic que j'ai créé histoire que je commente ton code ? une fois que ce sera fait, normalement ton passage console->graphique se fera rapidement si ton code est bien structuré.

Merci pour ta participation en tout cas.

GurneyH

31 décembre 2010 à 9:53:47

@Nasta: J'ai chargé ton projet pour essayer et chapeau, le résultat final est plutôt sympa.
Je ne regrette pas d'avoir conseillé d'afficher les messages avec SDL_WM_SetCaption, car à l'arrivée ça permet d'avoir une interface honorable sans trop s'embêter.

J'ai fait un screenshot de ton jeu, histoire de.

Après, pour le code, même remarque que celle faite par Pouet_Forever, la logique du jeu est mélangée avec des choses propres à la SDL.
Par exemple.

if(grille[caseClique.x][caseClique.y] == Vide) // Si la case cliquée est vide
 {
     grille[caseClique.x][caseClique.y] = tourDeJeu; // On la remplis avec le bon signe
     SDL_BlitSurface(signeActuel, NULL, ecran, &caseBlit);

Tu maintiens ta grille à jour, et tu blittes par la même occasion.
Selon moi, tu devrais maintenir ta grille à jour, et seulement au moment de l'affichage, blitter les bons signes.

@Pouet:
Je confirme mon enthousiasme, ton code est vraiment bien, j'ai pas grand chose à redire.
Juste, cette manière de faire.

/* affiche(NULL); pour free la surface static */

tu te prend un peu la tête en procédant ainsi, je pense...
Si tu créais tes(ta) surfaces à l'init de ton programme, tu n'aurais pas besoin de ce static.
Mais bon, peut être une question de gouts.

Merci à vous 2.

Zeste de Savoir, le site qui en a dans le citron !

Pouet_forever

31 décembre 2010 à 13:13:48

Bah, en fait, je voulais pas passer juste 1 surface à mes fonctions, ça aurait fait dégeux. J'aurais dû utiliser une variable globale, mais sur un forum pour débutant, il vaut mieux éviter de montrer cette pratique.

Mais je suis entièrement d'accord avec toi.

Edit : Et on peut aussi modifier la taille de la grille facilement, sympa, regardez :

nasta

31 décembre 2010 à 23:03:27

Le gagnant, c'est celui qui a la ligne en bas à droite ?
Je trouve que 5 cases, c'est pas assez.

Changement de mon programme pour bien séparer la SDL du reste.

/**
    main.c
    Rôle : contient les fonctions "de base"
    Note : Dans tout le projet, les ligne suivies d'un double-slash '//' sont à modifier dans le cas d'un agrandissement de la grille
*/

#include <stdbool.h>
#include <SDL/SDL.h>
#include "constantes.h"

/* prototypes */
void jeu (Surfaces *surfs);

/* fonctions */
void freeSurfs (Surfaces *surfs) // Libère toutes les surfaces
{
    SDL_FreeSurface(surfs->grid);
    SDL_FreeSurface(surfs->cross);
    SDL_FreeSurface(surfs->circle);
}

void Quit (Surfaces *surfs)
{
    freeSurfs(surfs);
    SDL_Quit();
}

void initSurfs (Surfaces *surfs) // Initialise la structure surfaces
{
    // chargements
    surfs->grid = SDL_LoadBMP("Grille.bmp");
    surfs->cross = SDL_LoadBMP("croix.bmp");
    surfs->circle = SDL_LoadBMP("rond.bmp");
    // vérifications
    if (surfs->grid == NULL || surfs->cross == NULL || surfs->circle == NULL) // Si un des surfaces n'a pas été chargée
    {
        fprintf (stderr, "Erreur lors du chargement des images bmp : %s\n", SDL_GetError());
        exit (EXIT_FAILURE);
    }
    // Transparance
    SDL_SetColorKey(surfs->cross, SDL_SRCCOLORKEY, SDL_MapRGB(surfs->cross->format, 255, 255, 255));
    SDL_SetColorKey(surfs->circle, SDL_SRCCOLORKEY, SDL_MapRGB(surfs->circle->format, 255, 255, 255));
}

int main (int argc, char *argv[]) // Se charge de toutes les initialisations
{
    SDL_Surface *ecran = NULL;
    Surfaces surfs;

    /* Initialisation SDL */
    if (SDL_Init(SDL_INIT_VIDEO) < 0)
    {
        fprintf (stderr, "Erreur lors du chargement de la SDL : %s\n", SDL_GetError());
        exit (EXIT_FAILURE);
    }

    /* Création de la surface de rendu vidéo */
    ecran = SDL_SetVideoMode(L_FENETRE, H_FENETRE, 32, SDL_HWSURFACE | SDL_DOUBLEBUF );

    if (ecran == NULL)
    {
        fprintf (stderr, "Erreur lors de la création de la fenêtre avec 'SDL_SetVideoMode' : %s\n", SDL_GetError());
        exit (EXIT_FAILURE);
    }

    initSurfs(&surfs);

    jeu(&surfs);

    Quit(&surfs);
    return EXIT_SUCCESS;
}

bool gagne (const SDL_Rect lastPlayP, const Signe LastPlayS, Signe grille [][H_GRILLE]) // Cette fonction renvoie tru s'il y a une victoire. Le contexte d'appel permet de définir le gagnant
{
    /* On regarde si la ligne du dernier coup est remplie du dernier signe à avoir joué */
    if (grille[lastPlayP.x][0] == LastPlayS && grille[lastPlayP.x][1] == LastPlayS && grille[lastPlayP.x][2] == LastPlayS) //
    {
        return true;
    }

    if (grille[0][lastPlayP.y] == LastPlayS && grille[1][lastPlayP.y] == LastPlayS && grille[2][lastPlayP.y] == LastPlayS) //
    {
        return true;
    }

    /* test des diagnales */
    if (grille[0][0] == LastPlayS && grille[1][1] == LastPlayS  && grille[2][2] == LastPlayS) //
    {
        return true;
    }

    if (grille[0][2] == LastPlayS && grille[1][1] == LastPlayS && grille[2][0] == LastPlayS) //
    {
        return true;
    }

    return false;
}

void estGagnant (Signe joueur) // affiche le gagnant
{

    if (joueur == Cross)
    {
        SDL_WM_SetCaption("Les croix ont gagnees ! Bravo !", NULL);
        SDL_Delay(2000);
    }
    else
    {
        SDL_WM_SetCaption("Les cercles ont gagnes ! Bravo !", NULL);
        SDL_Delay(2000);
    }
}

bool recommencer () // Retourne true si le joueur veut recommencer
{
    SDL_Event event;
    SDL_WM_SetCaption("Voulez-vous rejouer ? (o)ui/(n)on", NULL);

    while(1)
    {
        SDL_WaitEvent(&event);
        if (event.type == SDL_QUIT)
        return false;

        if (event.type == SDL_KEYDOWN)
        {
            if (event.key.keysym.sym == SDLK_o)
            return true;

            if (event.key.keysym.sym == SDLK_n)
            return false;

            if (event.key.keysym.sym == SDLK_ESCAPE) // Petite pensée à ceux qui n'ont pas de souris (sisi, ça arrive...)
            return false;
        }
    }
    return false; // pour éviter un warning
}

void affiche (Signe grille[][H_GRILLE], Surfaces *surfs)
{
    SDL_Surface *ecran = SDL_GetVideoSurface();
    SDL_Rect posBlit;
    int i, j;

    for (i = 0; i < L_GRILLE; i++)
    {
        for(j = 0; j < H_GRILLE; j++)
        {
            posBlit.x = (i * TA_SIGNE) + (i * LARG_LIGNE_GRILLE); // Le deuxième terme permet de tenir compte de la ligne noire
            posBlit.y = (j * TA_SIGNE) + (j * LARG_LIGNE_GRILLE);
            if (grille[i][j] == Cross)
            SDL_BlitSurface(surfs->cross, NULL, ecran, &(posBlit));
            else if (grille[i][j] == Circle)
            SDL_BlitSurface(surfs->circle, NULL, ecran, &(posBlit));
        }
    }
    SDL_Flip(ecran);
}

void jeu (Surfaces *surfs) // Fonction principale du jeu
{
    SDL_Rect posZero;
    SDL_Rect caseClique; // Indique sur quelle case on a cliqué
    SDL_Surface *ecran = SDL_GetVideoSurface();
    SDL_Surface *signeActuel; // Cette surface est celle que l'on blittera sur l'ecran. Elle prendra une des valeurs des surfaces de notre structure
    SDL_Event event;
    Signe tourDeJeu = Cross; // Les croix jouent en premier
    bool continuer = true;
    int nbCoups = NB_CASES;
    Signe grille[L_GRILLE][H_GRILLE] = {{Vide, Vide, Vide},//
                                        {Vide, Vide, Vide},//
                                        {Vide, Vide, Vide}};//

    posZero.x = 0;
    posZero.y = 0;

    SDL_BlitSurface(surfs->grid, NULL, ecran, &posZero); // On blitte la grille à l'écran
    while (continuer)
    {
        if (tourDeJeu == Cross) // On dit qui doit jouer
        {
            SDL_WM_SetCaption("Aux croix de jouer", NULL);
            signeActuel = surfs->cross;
        }
        else
        {
            SDL_WM_SetCaption("Aux cercles de jouer", NULL);
            signeActuel = surfs->circle;
        }

        SDL_WaitEvent(&event); // On attend l'évênement

        if (event.type == SDL_QUIT)
        continuer = 0;

        else if ((event.type == SDL_KEYDOWN) && (event.key.keysym.sym == SDLK_ESCAPE)) // Toujours pour ceux qui n'ont pas de souris (voir plus haut^^)
        continuer = 0;

        else if ((event.type == SDL_MOUSEBUTTONDOWN) && (event.button.button == SDL_BUTTON_LEFT)) // Si on a cliqué
        {
            caseClique.x = event.button.x / TA_SIGNE;
            caseClique.y = event.button.y / TA_SIGNE;
            if(grille[caseClique.x][caseClique.y] == Vide) // Si la case cliquée est vide
            {
                grille[caseClique.x][caseClique.y] = tourDeJeu; // On la remplis avec le bon signe
                nbCoups --; // On a le doit à 1 coup de moins

                if (gagne(caseClique, tourDeJeu, grille))
                {
                    affiche(grille, surfs); // On montre bien la situation
                    estGagnant(tourDeJeu);
                    continuer = 0;
                    if (recommencer())
                    jeu(surfs); // Si on veut recommencer, on fait un appel récursif
                }

                if (nbCoups == 0) // Si nbCoups est égal à 0, c'est que a grille est pleine
                {
                    affiche(grille, surfs);
                    SDL_WM_SetCaption("Match nul...", NULL);
                    SDL_Delay(2000);
                    continuer = 0;
                    if (recommencer())
                    jeu(surfs);
                }
                /* On change la valeur de tourDeJeu */
                if (tourDeJeu == Cross)
                tourDeJeu = Circle;
                else
                tourDeJeu = Cross;
            }
            else
            {
                SDL_WM_SetCaption("Desole, cette case est prise", NULL);
                SDL_Delay(1000);
            }

        }
        affiche(grille, surfs);
    }
}

J'ai pas trouvé d'autres endroits à changer. Le fichier constantes est le même que plus haut.
Maintenant, je vais voir si le passage en console sera difficile ou pas.
(Je sais, je fais tout à l'envers, mais le passage devrais se faire dans les 2 ses si j'ai bien fait non ? :-°

)

GurneyH

31 décembre 2010 à 23:21:53

@Nasta:
tu n'imagines même pas, comment je suis content te voir que tu proposes une seconde version!

Mais, plusieurs trucs ne vont pas.
Mon but pour cet exercice, c'est
->voir que si tu codes un truc console, tu sais le faire avec une autre lib

tu n'as pas séparé grand chose en fait.
Je vais essayé d'être concret, parce que je crois que tu ne vois pas l'intérêt de ce qu'on te dit.(et c'est compréhensible).
Je code pas mal de jeux(petits),et j'ai un objectif de programmeur du Dimanche, qui est :
Si je change de lib graphique:
-SDL
-SFML
-Conio
-etc, etc
mon code doit pouvoir le faire...
et là tu n'as pas le choix, tu dois séparer la logique du jeu, de tout l'enrobage.

j'aime pas la pub, mais regarde le code de Pouet_Forever, je pense, qu'il fait ça(sans être un killer en SDL!))

Encore une fois, je vois bien que je suis un peu sec, touça...
Mais je le répète, Nasta, je suis très content de te voir participer...
et, on va pas me changer en 2011!

Zeste de Savoir, le site qui en a dans le citron !

Pouet_forever

1 janvier 2011 à 13:46:43

Citation : nasta

Le gagnant, c'est celui qui a la ligne en bas à droite ?
Je trouve que 5 cases, c'est pas assez.

Ouais, mais tu peux modifier dans le code.

Mais bon pour aligner 5 cases sur un 10x10 c'est pas si simple que ça. :-°

nasta

1 janvier 2011 à 15:39:16

OK, j'ai compris maintenant.
Je repars sur un fichier vierge et je pars en console.

C159

1 janvier 2011 à 16:08:07

bon je poste le mien :

My_SDL.c

</h3>

#include                            <SDL/SDL.h>
#include                            "My_SDL.h"

static void erreurSDL(const char chaine[]);

//initialise la SDL
void My_SDL_initialise(Uint32 flags)
{
    if (SDL_Init(flags) != 0)
        erreurSDL ("Erreur SDL_Init");
    atexit(SDL_Quit);
}
//cré la fenetre
SDL_Surface* My_SDL_initialiserfenetre(int LARGEURFENETRE, int HAUTEURFENETRE, int NB_COULEUR, Uint32 flags, char *nomFenetre)
{
    SDL_WM_SetCaption(nomFenetre, NULL);
    SDL_Surface* screen = SDL_SetVideoMode(LARGEURFENETRE,HAUTEURFENETRE,NB_COULEUR, flags);
    if (screen == NULL)
        erreurSDL ("Erreur SDL_SetVideoMode");
    return screen;
}
//créer une surface et la colore
SDL_Surface* My_SDL_CreateRGBSurface(Uint32 flags, int X, int Y, int NB_COULEUR, Uint32 couleur)
{
    SDL_Surface* SURFACE = SDL_CreateRGBSurface(flags, X, Y, NB_COULEUR, 0, 0, 0, 0);
    if (SURFACE == NULL)
        erreurSDL("Erreur SDL_CreateRGBSurface");
    My_SDL_FillRect(SURFACE, couleur);
    return SURFACE;
}
Uint32 couleur(int R, int V, int B)
{
    return SDL_MapRGB(SDL_GetVideoSurface()->format, R, V, B);
}
//Colore une surface
void My_SDL_FillRect(SDL_Surface* SURFACE, 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, SDL_GetVideoSurface(), position) != 0)
        erreurSDL("Erreur SDL_BlitSurface");
}
//realise le SDL_Flip
void My_SDL_Flip(void)
{
    if (SDL_Flip(SDL_GetVideoSurface()) != 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);
}

</span>

My_SDL.h

</h3>

void My_SDL_initialise(Uint32 flags);

SDL_Surface* My_SDL_initialiserfenetre(int LARGEURFENETRE,int HAUTEURFENETRE,int NB_COULEUR,Uint32 flags,char *nomFenetre);

SDL_Surface* My_SDL_CreateRGBSurface(Uint32 flags,int X,int Y,int NB_COULEUR,Uint32 couleur);

Uint32 couleur(int r, int v, int b);

void My_SDL_FillRect(SDL_Surface* SURFACE, Uint32 couleur);

void My_SDL_BlitSurface(SDL_Surface* SURFACE, SDL_Rect *SURFACE_BLITTE, SDL_Rect *position);

void My_SDL_Flip(void);

</span>

main.c

</h3>

#include                            <stdio.h>
#include                            <time.h>
//bolleen
#include                            <stdbool.h>

#include                            <SDL/SDL.h>

#define LARGEUR                     2 * TAILLEBORDURE + 3 * TAILLECASE
#define HAUTEUR                     2 * TAILLEBORDURE + 3 * TAILLECASE
#define NOMBREDECOULEUR             32
#define TAILLECASE                  200
#define TAILLEBORDURE               2
#define ALLIGNE(X, Y, Z)            (X == Y && X == Z && X != VIDE)

//ma lib
#include                            "My_SDL.h"

typedef enum {VIDE, JOUEUR1, JOUEUR2} Signe; // Indique ce que contient une case du plateau ainsi que le joueur qui doit jouer

typedef struct
{
    SDL_Surface *V0;
    SDL_Surface *J1;
    SDL_Surface *J2;
} Surfaces;

SDL_Surface *ecran;

bool gagner(Signe Grille[3][3], int JOUEUR, int nombreCoups);
void AfficherGrille(Signe Grille[3][3], Surfaces surface);
void choix(Signe Grille[3][3], int JOUEUR);

void programme(void)
{
    Signe Grille[3][3] = {{VIDE, VIDE, VIDE},
        {VIDE, VIDE, VIDE},
        {VIDE, VIDE, VIDE}
    };
    Surfaces surface = {NULL, NULL, NULL};
    const Uint32 couleurs[3] = {couleur(255,255,255), couleur(255,0,0), couleur(255,255,0)};
    surface.V0 = My_SDL_CreateRGBSurface(SDL_HWSURFACE, TAILLECASE, TAILLECASE, NOMBREDECOULEUR, couleurs[0]);
    surface.J1 = My_SDL_CreateRGBSurface(SDL_HWSURFACE, TAILLECASE, TAILLECASE, NOMBREDECOULEUR, couleurs[1]);
    surface.J2 = My_SDL_CreateRGBSurface(SDL_HWSURFACE, TAILLECASE, TAILLECASE, NOMBREDECOULEUR, couleurs[2]);
    int JOUEUR = 2;
    int nombreCoups = 0;
    do
    {
        JOUEUR = 3 - JOUEUR;
        AfficherGrille(Grille, surface);
        choix(Grille, JOUEUR);
        AfficherGrille(Grille, surface);
        nombreCoups++;
    }
    while(!gagner(Grille, JOUEUR, nombreCoups));
}

bool gagner(Signe Grille[3][3], int JOUEUR, int nombreCoups)
{
    char *chaine[] = {"- MORPION - J1 gagne", "- MORPION - J2 gagne", "- MORPION - MATCH NUL"};
    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]))
    {
        SDL_WM_SetCaption((JOUEUR == 1)? chaine[0] : chaine[1], NULL);
        SDL_Delay(2000);
        return true;
    }
    if (nombreCoups == 9)
    {
        SDL_WM_SetCaption(chaine[2], NULL);
        SDL_Delay(2000);
        return true;
    }
    return false;
}

void choix(Signe Grille[3][3], int JOUEUR)
{
    char *chaine[] = {"- MORPION - J1 choix", "- MORPION - J2 choix"};
    int i = -1, j = -1;
    SDL_Event event;
    SDL_WM_SetCaption((JOUEUR == 1)?chaine[0] : chaine[1], NULL);
    do
    {
        SDL_WaitEvent(&event);
        switch(event.type)
        {
        case SDL_QUIT:
            exit(EXIT_SUCCESS);
            break;
        case SDL_MOUSEBUTTONUP:
            switch(event.button.button)
            {
            case SDL_BUTTON_LEFT:
                i = event.button.y / (TAILLEBORDURE+TAILLECASE);
                j = event.button.x / (TAILLEBORDURE+TAILLECASE);
                break;
            }
            break;
        }
    }
    while(Grille[i][j] != VIDE || i == -1);
    Grille[i][j] = (JOUEUR == 1)?JOUEUR1 : JOUEUR2;
}

void AfficherGrille(Signe Grille[3][3], Surfaces surface)
{
#define BLIT(SIGNE, X, SURFACE, POSITION); if(SIGNE == X)\
                                                My_SDL_BlitSurface(SURFACE, NULL, POSITION);
    SDL_Rect position;
    int i, j;
    for (i = 0, position.y = 0 ; i < 3 ; i++ , position.y += (TAILLEBORDURE+TAILLECASE))
        for (j = 0, position.x = 0 ; j < 3 ; j++ , position.x += (TAILLEBORDURE+TAILLECASE))
        {
            BLIT(Grille[i][j], VIDE, surface.V0, &position);
            BLIT(Grille[i][j], JOUEUR1, surface.J1, &position);
            BLIT(Grille[i][j], JOUEUR2, surface.J2, &position);
        }
    My_SDL_Flip();
}

int main(int argc, char *argv[])
{
    My_SDL_initialise(SDL_INIT_VIDEO);
    ecran = My_SDL_initialiserfenetre(LARGEUR,
                                      HAUTEUR,
                                      NOMBREDECOULEUR,
                                      SDL_DOUBLEBUF| SDL_HWSURFACE/* | SDL_FULLSCREEN*/,
                                      "- MORPION -");
    programme();
    return EXIT_SUCCESS;
}

</span>

Nouveau site en constrution sur les mangas, anime, Visual novel

reino

1 janvier 2011 à 17:02:44

Je me joigne a vous

# 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 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};
    int tab2_p[8] = {0};

    Pos now,now2;
    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;

                if ( now2.x >=0 && now2.x < TABW && now2.y >=0 && now2.y < TABH )
                    if ( tab[now2.x  + now2.y *TABW] == role)
                        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;
}

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

            return last_clic;

        }
    }
    return last_clic;
}

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)
{

    Pos last = {NONE,NONE};
    if ( in->clicked)
    {
        last = 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;
}

Ps: Il me reste un petit problème a résoudre quand on quitte

, j'ai pas voulu utiliser exit ,puisqu'elle ne marche pas sur linux.

Pouet_forever

1 janvier 2011 à 17:10:06

C159 >

"_My_SDL_ChargerImage", referenced from:

reino > Mets ton code entre balises secret stp.

Edit: Quand je quitte le jeu j'ai un segfault. :-°

reino

1 janvier 2011 à 17:13:35

Citation : Pouet_forever

reino > Mets ton code entre balises secret stp.
Edit: Quand je quitte le jeu j'ai un segfault.

voila c'est fait

Citation : Reino

Ps: Il me reste un petit problème a résoudre quand on quitte , j'ai pas voulu utiliser exit ,puisqu'elle ne marche pas sur linux.

1 2 3 4 >>

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.

zMorp SDL

zMorp SDL

Supprimer

Modérer

Signaler le message aux modérateurs