Partage
  • Partager sur Facebook
  • Partager sur Twitter

Probleme SDL jeu du serpent

Foujv
    24 septembre 2007 à 19:25:03

    Bonjour,
    j'ai commence a coder un jeu du serpent en utilisant la SDL . J'ai fini mon code et ca ne renvoie aucune erreur au moment de compiler, mais voila le jeu ne marche pas comme prevu, l'image du menu reste affichee alors qu'elle ne doit pas l'etre. Voici le code de la fonction main :
    1. #include <iostream>
    2. #include <string>
    3. #include <SDL/SDL_image.h>
    4. #include <SDL/SDL_ttf.h>
    5. #include <SDL/SDL.h>
    6. #include <time.h>
    7. #include "constantes.h"
    8. #include "jeu.h"
    9. using namespace std;
    10. int main(int argc, char *argv[])
    11. {
    12.     SDL_Surface *ecran = NULL, *menu = NULL;
    13.     SDL_Rect positionMenu;
    14.     SDL_Event event;
    15.     bool continuer = true;
    16.     SDL_Init(SDL_INIT_VIDEO);
    17.     ecran = SDL_SetVideoMode(HAUTEUR_FENETRE, LARGEUR_FENETRE, 32, SDL_HWSURFACE | SDL_DOUBLEBUF);
    18.     SDL_WM_SetIcon(IMG_Load("sprites/icone.ico"), NULL);
    19.     SDL_WM_SetCaption("Jeu du Serpent", NULL);
    20.     SDL_ShowCursor(SDL_DISABLE);
    21.     menu = IMG_Load("sprites/menu.jpg");
    22.     positionMenu.x = 0;
    23.     positionMenu.y = 0;
    24.     while (continuer)
    25.     {
    26.         SDL_PollEvent(&event);
    27.         switch(event.type)
    28.         {
    29.             case SDL_QUIT :
    30.                 continuer = false;
    31.             break;
    32.            case SDL_KEYDOWN :
    33.                 switch(event.key.keysym.sym)
    34.                 {
    35.                     case SDLK_ESCAPE : // Veut arrêter le jeu
    36.                         continuer = false;
    37.                     break;
    38.                     case SDLK_j :  // Demande à jouer
    39.                         jouer(ecran);
    40.                     break;
    41.                 }
    42.            break;
    43.         }
    44.         // Effacement de l'écran
    45.         SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 255, 255, 255));
    46.         SDL_BlitSurface(menu, NULL, ecran, &positionMenu);
    47.         SDL_Flip(ecran);
    48.     }
    49.     SDL_FreeSurface(menu);
    50.     SDL_Quit();
    51.     return EXIT_SUCCESS;
    52. }

    et puis le code de la fonction qui permet de jouer :
    1. #include <iostream>
    2. #include <string>
    3. #include <SDL/SDL_image.h>
    4. #include <SDL/SDL_ttf.h>
    5. #include <SDL/SDL.h>
    6. #include <time.h>
    7. #include "constantes.h"
    8. #include "jeu.h"
    9. using namespace std;
    10. void jouer(SDL_Surface *ecran)
    11. {
    12.     SDL_Surface *teteSnake = NULL, *pomme = NULL, *partieSnake = NULL, *gameOver = NULL;
    13.     SDL_Rect positionPomme, positionTete, position;
    14.     SDL_Rect positionSnake[100];
    15.     SDL_Event event;
    16.     int tailleSnake = 4;
    17.     bool continuer = true;
    18.     int i = 0, j = 0;
    19.     int carte[NB_BLOCS_LARGEUR][NB_BLOCS_HAUTEUR] = {0};
    20.     int rapidite = 100;
    21.     int tempsPrecedent = 0, tempsActuel = 0, directionActuel = HAUT;
    22.     teteSnake = IMG_Load("sprites/tete_snake.png");
    23.     partieSnake = IMG_Load("sprites/partie_snake.png");
    24.     pomme = IMG_Load("sprites/pomme.png");
    25.     gameOver = IMG_Load("sprites/game_over.png");
    26.     positionTete.x = ecran->w / 2 - teteSnake->w / 2;
    27.     positionTete.y = ecran->h / 2 - teteSnake->h / 2;
    28.     for (int i = 0 ; i < 100 ; i++)
    29.         {
    30.             positionSnake[i].x = 0;
    31.             positionSnake[i].x = 0;
    32.         }
    33.         positionSnake[1].x = positionTete.x;
    34.         positionSnake[1].y = positionTete.y;
    35.     positionPomme.x = nombreHazard(38, 5);
    36.     positionPomme.y = nombreHazard(25, 5);
    37.         switch(event.type)
    38.         {
    39.             case SDL_QUIT:
    40.                 continuer = false;
    41.                 break;
    42.             case SDL_KEYUP :
    43.                 switch(event.key.keysym.sym)
    44.                 {
    45.                     case SDLK_ESCAPE:
    46.                         continuer = false;
    47.                         break;
    48.                     case SDLK_UP:
    49.                         if (directionActuel != BAS)
    50.                         {
    51.                             directionActuel = HAUT;
    52.                         }
    53.                         break;
    54.                     case SDLK_DOWN:
    55.                         if (directionActuel != HAUT)
    56.                         {
    57.                             directionActuel = BAS;
    58.                         }
    59.                         break;
    60.                     case SDLK_RIGHT:
    61.                         if (directionActuel != GAUCHE)
    62.                         {
    63.                             directionActuel = DROITE;
    64.                         }
    65.                         break;
    66.                     case SDLK_LEFT:
    67.                         if (directionActuel != DROITE)
    68.                         {
    69.                             directionActuel = GAUCHE;
    70.                         }
    71.                         break;
    72.                 }
    73.                 break;
    74.         }
    75.         tempsActuel = SDL_GetTicks();
    76.     if (tempsActuel - tempsPrecedent > rapidite)
    77.     {
    78.         switch (directionActuel)
    79.         {
    80.             case HAUT:
    81.                 if (carte[positionTete.y - 1][positionTete.x] < 0)
    82.                 {
    83.                     SDL_BlitSurface(gameOver, NULL, ecran, &position);
    84.                     break;
    85.                 }
    86.                 for (int i = 0 ; i < tailleSnake ; i++)
    87.                 {
    88.                     if (positionTete.y - 1 == positionSnake[i].y && positionTete.x == positionSnake[i].x)
    89.                     {
    90.                         SDL_BlitSurface(gameOver, NULL, ecran, &position);
    91.                     }
    92.                 }
    93.                 if (positionTete.y - 1 == positionPomme.y && positionTete.x == positionPomme.x)
    94.                 {
    95.                     tailleSnake++;
    96.                     positionPomme.x = nombreHazard(38, 5);
    97.                     positionPomme.y = nombreHazard(25, 5);
    98.                     rapidite = rapidite - 5;
    99.                 }
    100.                 for (int u = tailleSnake ; u > 0 ; u--)
    101.                 {
    102.                     int uv = u - 1;
    103.                     positionSnake[u].y = positionSnake[uv].y;
    104.                     positionSnake[u].x = positionSnake[uv].x;
    105.                     uv++;
    106.                 }
    107.                 positionSnake[1].y = positionTete.y;
    108.                 positionSnake[1].x = positionTete.x;
    109.                 positionTete.y--;
    110.                 break;
    111.             case BAS:
    112.                 if (carte[positionTete.y + 1][positionTete.x] > HAUTEUR_FENETRE)
    113.                 {
    114.                     SDL_BlitSurface(gameOver, NULL, ecran, &position);
    115.                     break;
    116.                 }
    117.                 for (int i = 0 ; i < tailleSnake ; i++)
    118.                 {
    119.                     if (positionTete.y + 1 == positionSnake[i].y && positionTete.x == positionSnake[i].x)
    120.                     {
    121.                         SDL_BlitSurface(gameOver, NULL, ecran, &position);
    122.                     }
    123.                 }
    124.                 if (positionTete.y + 1 == positionPomme.y && positionTete.x == positionPomme.x)
    125.                 {
    126.                     tailleSnake++;
    127.                     positionPomme.x = nombreHazard(38, 5);
    128.                     positionPomme.y = nombreHazard(25, 5);
    129.                     rapidite = rapidite - 5;
    130.                 }
    131.                 for (int u = tailleSnake ; u > 0 ; u--)
    132.                 {
    133.                     int uv = u - 1;
    134.                     positionSnake[u].y = positionSnake[uv].y;
    135.                     positionSnake[u].x = positionSnake[uv].x;
    136.                     uv++;
    137.                 }
    138.                 positionSnake[1].y = positionTete.y;
    139.                 positionSnake[1].x = positionTete.x;
    140.                 positionTete.y++;
    141.                 break;
    142.             case GAUCHE:
    143.                 if (carte[positionTete.y][positionTete.x - 1] < 0)
    144.                 {
    145.                     SDL_BlitSurface(gameOver, NULL, ecran, &position);
    146.                     break;
    147.                 }
    148.                 for (int i = 0 ; i < tailleSnake ; i++)
    149.                 {
    150.                     if (positionTete.y == positionSnake[i].y && positionTete.x - 1 == positionSnake[i].x)
    151.                     {
    152.                         SDL_BlitSurface(gameOver, NULL, ecran, &position);
    153.                     }
    154.                 }
    155.                 if (positionTete.y == positionPomme.y && positionTete.x - 1 == positionPomme.x)
    156.                 {
    157.                     tailleSnake++;
    158.                     positionPomme.x = nombreHazard(38, 5);
    159.                     positionPomme.y = nombreHazard(25, 5);
    160.                     rapidite = rapidite - 5;
    161.                 }
    162.                 for (int u = tailleSnake ; u > 0 ; u--)
    163.                 {
    164.                     int uv = u - 1;
    165.                     positionSnake[u].y = positionSnake[uv].y;
    166.                     positionSnake[u].x = positionSnake[uv].x;
    167.                     uv++;
    168.                 }
    169.                 positionSnake[1].y = positionTete.y;
    170.                 positionSnake[1].x = positionTete.x;
    171.                 positionTete.x--;
    172.                 break;
    173.             case DROITE:
    174.                 if (carte[positionTete.y - 1][positionTete.x + 1] > LARGEUR_FENETRE)
    175.                 {
    176.                     SDL_BlitSurface(gameOver, NULL, ecran, &position);
    177.                     break;
    178.                 }
    179.                 for (int i = 0 ; i < tailleSnake ; i++)
    180.                 {
    181.                     if (positionTete.y == positionSnake[i].y && positionTete.x + 1 == positionSnake[i].x)
    182.                     {
    183.                         continuer = false;
    184.                     }
    185.                 }
    186.                 if (positionTete.y == positionPomme.y && positionTete.x + 1 == positionPomme.x)
    187.                 {
    188.                     tailleSnake++;
    189.                     positionPomme.x = nombreHazard(38, 5);
    190.                     positionPomme.y = nombreHazard(25, 5);
    191.                     rapidite = rapidite - 5;
    192.                 }
    193.                 for (int u = tailleSnake ; u > 0 ; u--)
    194.                 {
    195.                     int uv = u - 1;
    196.                     positionSnake[u].y = positionSnake[uv].y;
    197.                     positionSnake[u].x = positionSnake[uv].x;
    198.                     uv++;
    199.                 }
    200.                 positionSnake[1].y = positionTete.y;
    201.                 positionSnake[1].x = positionTete.x;
    202.                 positionTete.x++;
    203.                 break;
    204.         }
    205.     tempsPrecedent = tempsActuel;
    206.     }
    207.     //Effacement de lecran
    208.     SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 255, 255, 255));
    209.     //Placement des sprites a l'ecran
    210.         for (int i = 0 ; i < NB_BLOCS_LARGEUR ; i++)
    211.         {
    212.             for (int j = 0 ; j < NB_BLOCS_HAUTEUR ; j++)
    213.             {
    214.                 position.x = i * TAILLE_BLOC;
    215.                 position.y = j * TAILLE_BLOC;
    216.                 if (i == positionTete.x && j == positionTete.y)
    217.                 {
    218.                     SDL_BlitSurface(teteSnake, NULL, ecran, &position);
    219.                 }
    220.                 if (i == positionPomme.x && j == positionPomme.y)
    221.                 {
    222.                     SDL_BlitSurface(pomme, NULL, ecran, &position);
    223.                 }
    224.                 for (int a = 0 ; a < tailleSnake ; a++)
    225.                 {
    226.                     if (i == positionSnake[a].x && j == positionSnake[a].y)
    227.                     {
    228.                         SDL_BlitSurface(partieSnake, NULL, ecran, &position);
    229.                     }
    230.                 }
    231.             }
    232.         }
    233.     SDL_Flip(ecran);
    234.     SDL_FreeSurface(teteSnake);
    235.     SDL_FreeSurface(pomme);
    236.     SDL_FreeSurface(partieSnake);
    237. }
    238. long nombreHazard(const long MAX, const long MIN)
    239. {
    240.     long nombreHazard;
    241.     srand(time(NULL));
    242.     nombreHazard = (rand() % (MAX - MIN + 1)) + MIN;
    243.     return nombreHazard;
    244. }

    Je suis conscient que ca fait beaucoup de ligne a scruter mais je sais vraiment plus quoi faire, vos suggestions pour ameliorer sont aussi les bienvenues .
    Merci a vous
    • Partager sur Facebook
    • Partager sur Twitter
    [Kansuu]
      24 septembre 2007 à 19:40:29

      Citation : kurt_



      1. blit(......)
      2. <...>
      3.     SDL_Flip(ecran);
      4.     SDL_FreeSurface(teteSnake);
      5.     SDL_FreeSurface(pomme);
      6.     SDL_FreeSurface(partieSnake);
      7. <...>




      À quoi ça sert de bliter les surface et tout, si pour a fin de la fonction tu les enlève?
      En plus qu'il n'y a pas de boucle... C'est comme si tu n'appelais qu'une fois ta fonction jouer, qu'elle blit et ensuite qu'elle libère et quitte la fonction pour retourner blitter ton menu.
      • Partager sur Facebook
      • Partager sur Twitter
      Anonyme
        24 septembre 2007 à 19:49:37

        Il faut faire une boucle dans la fonction jouer.

        Sinon j'ai deux conseils :
        - crées plus de classe (fais plus de C++ quoi).
        - Pas besoin de passer la surface 'ecran' à une fonction ; SDL_GetVideoSurface est là pour ça.

        • Partager sur Facebook
        • Partager sur Twitter
        Foujv
          27 septembre 2007 à 10:48:51

          voila j'ai mis une boucle et l'ecran du menu disparait pour laisser place a un ecran blanc (normal) avec la pomme seule qui bouge toute seule Oo aucun sprites de snake a l'écran.
          P-S : j'ai vu la doc pour SDL_GetVideoSurface mais j'ai pas tres bien compris comment ca fonctionnait un petit bout de code pour illustrer serait tres bien.
          re-P-S : je ne vois pas tres bien comment utiliser les classe dans ce jeu mais je vais essayer quand même.
          re-re-P-S : Je suis désolé pour mon temps de réponse mais je n'ai pas accès a internet très souvent ces temps-ci ...
          • Partager sur Facebook
          • Partager sur Twitter
          Anonyme
            27 septembre 2007 à 16:07:29

            1. void f()
            2. {
            3.     // Recherche de l'écran :
            4.     SDL_Surface* ecran = SDL_GetVideoSurface();
            5.     // Utilisation :
            6.     SDL_Blit(src, 0, ecran, 0);
            7.     SDL_Flip(ecran);
            8. }

            Pour les classe, tu peux par exemple en faire une pour le snake. (Qui gère affichage, déplacement, modification, ... tout ça facilement.)
            • Partager sur Facebook
            • Partager sur Twitter
            Foujv
              29 septembre 2007 à 16:14:12

              merci hiura pour tes exemples mais ca ne resout tjs pas mon probleme ^^" a savoir le serpent qui n'apparait pas ...
              • Partager sur Facebook
              • Partager sur Twitter
              Anonyme
                29 septembre 2007 à 16:56:00

                Fais des tests sur les valeurs des positions. Je ne sais pas d'où sa peut venir là...
                • Partager sur Facebook
                • Partager sur Twitter
                [Kansuu]
                  30 septembre 2007 à 2:50:21

                  Montre nous ton nouveau code.
                  • Partager sur Facebook
                  • Partager sur Twitter
                  Foujv
                    5 octobre 2007 à 21:54:05

                    ="de1">        SDL_Flip(ecran);
                        }
                        SDL_FreeSurface(menu);
                        SDL_Quit();
                        return EXIT_SUCCESS;
                    }

                    la je sais vraiment plus quoi faire ca me rend dingue :(
                    #include "constantes.h"
                    #include "jeu.h"
                    using namespace std;
                    void jouer(SDL_Surface *ecran)
                    {
                        bool continuer = true;
                        do
                        {
                            SDL_Surface *teteSnake = NULL, *pomme = NULL, *partieSnake = NULL, *gameOver = NULL;
                            SDL_Rect positionPomme, positionTete, position;
                            SDL_Rect positionSnake[100];
                            SDL_Event event;
                            int tailleSnake = 4;
                            bool continuer = true;
                            int i = 0, j = 0;
                            int carte[NB_BLOCS_LARGEUR][NB_BLOCS_HAUTEUR] = {0};
                            int rapidite = 100;
                            int tempsPrecedent = 0, tempsActuel = 0, directionActuel = HAUT;
                            teteSnake = IMG_Load("sprites/tete_snake.png");
                            partieSnake = IMG_Load("sprites/partie_snake.png");
                            pomme = IMG_Load("sprites/pomme.png");
                            gameOver = IMG_Load("sprites/game_over.png");
                            positionTete.x = ecran->w / 2 - teteSnake->w / 2;
                            positionTete.y = ecran->h / 2 - teteSnake->h / 2;
                            for (int i = 0 ; i < 100 ; i++)
                                {
                                    positionSnake[i].x = 0;
                                    positionSnake[i].x = 0;
                                }
                                positionSnake[1].x = positionTete.x;
                                positionSnake[1].y = positionTete.y;
                            positionPomme.x = nombreHazard(38, 5);
                            positionPomme.y = nombreHazard(25, 5);
                                switch(event.type)
                                {
                                    case SDL_QUIT:
                                        continuer = false;
                                        break;
                                    case SDL_KEYUP :
                                        switch(event.key.keysym.sym)
                                        {
                                            case SDLK_ESCAPE:
                                                continuer = false;
                                                break;
                                            case SDLK_UP:
                                                if (directionActuel != BAS)
                                                {
                                                    directionActuel = HAUT;
                                                }
                                                break;
                                            case SDLK_DOWN:
                                                if (directionActuel != HAUT)
                                                {
                                                    directionActuel = BAS;
                                                }
                                                break;
                                            case SDLK_RIGHT:
                                                if (directionActuel != GAUCHE)
                                                {
                                                    directionActuel = DROITE;
                                                }
                                                break;
                                            case SDLK_LEFT:
                                                if (directionActuel != DROITE)
                                                {
                                                    directionActuel = GAUCHE;
                                                }
                                                break;
                                        }
                                        break;
                                }
                                tempsActuel = SDL_GetTicks();
                            if (tempsActuel - tempsPrecedent > rapidite)
                            {
                                switch (directionActuel)
                                {
                                    case HAUT:
                                        if (carte[positionTete.y - 1][positionTete.x] < 0)
                                        {
                                            SDL_BlitSurface(gameOver, NULL, ecran, &position);
                                            break;
                                        }
                                        for (int i = 0 ; i < tailleSnake ; i++)
                                        {
                                            if (positionTete.y - 1 == positionSnake[i].y && positionTete.x == positionSnake[i].x)
                                            {
                                                SDL_BlitSurface(gameOver, NULL, ecran, &position);
                                            }
                                        }
                                        if (positionTete.y - 1 == positionPomme.y && positionTete.x == positionPomme.x)
                                        {
                                            tailleSnake++;
                                            positionPomme.x = nombreHazard(38, 5);
                                            positionPomme.y = nombreHazard(25, 5);
                                            rapidite = rapidite - 5;
                                        }
                                        for (int u = tailleSnake ; u > 0 ; u--)
                                        {
                                            int uv = u - 1;
                                            positionSnake[u].y = positionSnake[uv].y;
                                            positionSnake[u].x = positionSnake[uv].x;
                                            uv++;
                                        }
                                        positionSnake[1].y = positionTete.y;
                                        positionSnake[1].x = positionTete.x;
                                        positionTete.y--;
                                        break;
                                    case BAS:
                                        if (carte[positionTete.y + 1][positionTete.x] > HAUTEUR_FENETRE)
                                        {
                                            SDL_BlitSurface(gameOver, NULL, ecran, &position);
                                            break;
                                        }
                                        for (int i = 0 ; i < tailleSnake ; i++)
                                        {
                                            if (positionTete.y + 1 == positionSnake[i].y && positionTete.x == positionSnake[i].x)
                                            {
                                                SDL_BlitSurface(gameOver, NULL, ecran, &position);
                                            }
                                        }
                                        if (positionTete.y + 1 == positionPomme.y && positionTete.x == positionPomme.x)
                                        {
                                            tailleSnake++;
                                            positionPomme.x = nombreHazard(38, 5);
                                            positionPomme.y = nombreHazard(25, 5);
                                            rapidite = rapidite - 5;
                                        }
                                        for (int u = tailleSnake ; u > 0 ; u--)
                                        {
                                            int uv = u - 1;
                                            positionSnake[u].y = positionSnake[uv].y;
                                            positionSnake[u].x = positionSnake[uv].x;
                                            uv++;
                                        }
                                        positionSnake[1].y = positionTete.y;
                                        positionSnake[1].x = positionTete.x;
                                        positionTete.y++;
                                        break;
                                    case GAUCHE:
                                        if (carte[positionTete.y][positionTete.x - 1] < 0)
                                        {
                                            SDL_BlitSurface(gameOver, NULL, ecran, &position);
                                            break;
                                        }
                                        for (int i = 0 ; i < tailleSnake ; i++)
                                        {
                                            if (positionTete.y == positionSnake[i].y && positionTete.x - 1 == positionSnake[i].x)
                                            {
                                                SDL_BlitSurface(gameOver, NULL, ecran, &position);
                                            }
                                        }
                                        if (positionTete.y == positionPomme.y && positionTete.x - 1 == positionPomme.x)
                                        {
                                            tailleSnake++;
                                            positionPomme.x = nombreHazard(38, 5);
                                            positionPomme.y = nombreHazard(25, 5);
                                            rapidite = rapidite - 5;
                                        }
                                        for (int u = tailleSnake ; u > 0 ; u--)
                                        {
                                            int uv = u - 1;
                                            positionSnake[u].y = positionSnake[uv].y;
                                            positionSnake[u].x = positionSnake[uv].x;
                                            uv++;
                                        }
                                        positionSnake[1].y = positionTete.y;
                                        positionSnake[1].x = positionTete.x;
                                        positionTete.x--;
                                        break;
                                    case DROITE:
                                        if (carte[positionTete.y - 1][positionTete.x + 1] > LARGEUR_FENETRE)
                                        {
                                            SDL_BlitSurface(gameOver, NULL, ecran, &position);
                                            break;
                                        }
                                        for (int i = 0 ; i < tailleSnake ; i++)
                                        {
                                            if (positionTete.y == positionSnake[i].y && positionTete.x + 1 == positionSnake[i].x)
                                            {
                                                continuer = false;
                                            }
                                        }
                                        if (positionTete.y == positionPomme.y && positionTete.x + 1 == positionPomme.x)
                                        {
                                            tailleSnake++;
                                            positionPomme.x = nombreHazard(38, 5);
                                            positionPomme.y = nombreHazard(25, 5);
                                            rapidite = rapidite - 5;
                                        }
                                        for (int u = tailleSnake ; u > 0 ; u--)
                                        {
                                            int uv = u - 1;
                                            positionSnake[u].y = positionSnake[uv].y;
                                            positionSnake[u].x = positionSnake[uv].x;
                                            uv++;
                                        }
                                        positionSnake[1].y = positionTete.y;
                                        positionSnake[1].x = positionTete.x;
                                        positionTete.x++;
                                        break;
                                }
                            tempsPrecedent = tempsActuel;
                            }
                            //Effacement de lecran
                            SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 255, 255, 255));
                            //Placement des sprites a l'ecran
                                for (int i = 0 ; i < NB_BLOCS_LARGEUR ; i++)
                                {
                                    for (int j = 0 ; j < NB_BLOCS_HAUTEUR ; j++)
                                    {
                                        position.x = i * TAILLE_BLOC;
                                        position.y = j * TAILLE_BLOC;
                                        if (i == positionTete.x && j == positionTete.y)
                                        {
                                            SDL_BlitSurface(teteSnake, NULL, ecran, &position);
                                        }
                                        if (i == positionPomme.x && j == positionPomme.y)
                                        {
                                            SDL_BlitSurface(pomme, NULL, ecran, &position);
                                        }
                                        for (int a = 0 ; a < tailleSnake ; a++)
                                        {
                                            if (i == positionSnake[a].x && j == positionSnake[a].y)
                                            {
                                                SDL_BlitSurface(partieSnake, NULL, ecran, &position);
                                            }
                                        }
                                    }
                                }
                            SDL_Flip(ecran);
                            SDL_FreeSurface(teteSnake);
                            SDL_FreeSurface(pomme);
                            SDL_FreeSurface(partieSnake);
                        }
                        while(continuer = true);
                    }
                    long nombreHazard(const long MAX, const long MIN)
                    {
                        long nombreHazard;
                        srand(time(NULL));
                        nombreHazard = (rand() % (MAX - MIN + 1)) + MIN;
                        return nombreHazard;
                    }

                    fonction main :
                    1. #include <iostream>
                    2. #include <string>
                    3. #include <SDL/SDL_image.h>
                    4. #include <SDL/SDL_ttf.h>
                    5. #include <SDL/SDL.h>
                    6. #include <time.h>
                    7. #include "constantes.h"
                    8. #include "jeu.h"
                    9. using namespace std;
                    10. int main(int argc, char *argv[])
                    11. {
                    12.     SDL_Surface *ecran = NULL, *menu = NULL;
                    13.     SDL_Rect positionMenu;
                    14.     SDL_Event event;
                    15.     bool continuer = true;
                    16.     SDL_Init(SDL_INIT_VIDEO);
                    17.     ecran = SDL_SetVideoMode(HAUTEUR_FENETRE, LARGEUR_FENETRE, 32, SDL_HWSURFACE | SDL_DOUBLEBUF);
                    18.     SDL_WM_SetIcon(IMG_Load("sprites/icone.ico"), NULL);
                    19.     SDL_WM_SetCaption("Jeu du Serpent", NULL);
                    20.     SDL_ShowCursor(SDL_DISABLE);
                    21.     menu = IMG_Load("sprites/menu.jpg");
                    22.     positionMenu.x = 0;
                    23.     positionMenu.y = 0;
                    24.     while (continuer)
                    25.     {
                    26.         SDL_PollEvent(&event);
                    27.         switch(event.type)
                    28.         {
                    29.             case SDL_QUIT :
                    30.                 continuer = false;
                    31.             break;
                    32.            case SDL_KEYDOWN :
                    33.                 switch(event.key.keysym.sym)
                    34.                 {
                    35.                     case SDLK_ESCAPE : // Veut arrêter le jeu
                    36.                         continuer = false;
                    37.                     break;
                    38.                     case SDLK_j :  // Demande à jouer
                    39.                         jouer(ecran);
                    40.                     break;
                    41.                 }
                    42.            break;
                    43.         }
                    44.         // Effacement de l'écran
                    45.         SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 255, 255, 255));
                    46.         SDL_BlitSurface(menu, NULL, ecran, &positionMenu);
                    • Partager sur Facebook
                    • Partager sur Twitter
                    [Kansuu]
                      5 octobre 2007 à 22:26:30

                      Dans ta fonction jouer, tu a bien fait une boucle... mais la boucle ne doit pas tout englober, là, à chake tour de boucle tu reload les image les reblit refait tout... tu doit seulement faire la boucle autour du blit et du mouvement.
                      • Partager sur Facebook
                      • Partager sur Twitter

                      Probleme SDL jeu du serpent

                      × 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