Partage

probleme SNAKE

L'écran ne marche pas.

Le 8 janvier 2012 à 16:52:32

Bonjour à tous et à toutes.
Je suis en train de programmer un SNAKE mais un problème est survenu.
Lorsque je lance le programme:
-un menu s'affiche(prévu)
-si je clique sur aide l'aide s'affiche(prévu)
-si je clique sur jouer la fenetre se met a afficher des bandes marron(pas prévu)

Une vidéo : <object width="480" height="360" type="application/x-shockwave-flash" data="http://www.youtube.com/v/NUCwfV6BXxE"><param name="movie" value="http://www.youtube.com/v/NUCwfV6BXxE" /><param name="allowFullScreen" value="true" /><param name="wmode" value="transparent" /></object>


Maintenant les fichiers :

Le main.c:
#include <stdlib.h>
#include <stdio.h>
#include <SDL/SDL.h>
#include <SDL_image.h>
#include "aide.h"
#include "jeu.h"
#include "constantes.h"
int main ( int argc, char** argv )
{
    SDL_Surface *ecran = NULL, *menu = NULL, *selection = NULL;
    menu = IMG_Load("menu.png");
    SDL_Rect positionMenu, positionSelection;
    positionMenu.x = 0;
    positionMenu.y = 0;
    positionSelection.x = 260;
    positionSelection.y = 180;



    int continuer = 1, selectione = 0, selectioner = 0;

    SDL_Init(SDL_INIT_VIDEO |SDL_INIT_TIMER);
    ecran = SDL_SetVideoMode(LARGEUR_FENETRE, HAUTEUR_FENETRE, 32, SDL_HWSURFACE | SDL_DOUBLEBUF);
    selection = SDL_CreateRGBSurface(SDL_HWSURFACE, 150, 55, 32, 0, 0, 0, 0);
    SDL_BlitSurface(menu , NULL, ecran , &positionMenu);
    SDL_Flip(ecran);
    SDL_FillRect(selection, NULL, SDL_MapRGB(ecran->format, 255, 255, 255));

SDL_Event event;

    while (continuer)
    {
        SDL_WaitEvent(&event);
        selectione = 0;
        switch(event.type)
        {
            case SDL_QUIT:
                continuer = 0;
            case SDL_MOUSEMOTION:
              if(event.motion.x > 260)
              {
                  if(event.motion.x < 410)
                  {
                      if(event.motion.y > 180)
                      {
                          if(event.motion.y < 235)

                          selectione = 1;
                          else selectione = 0;
                      }else selectione = 0;
                  }
                  else selectione = 0;
              }
               if(event.motion.x > 270)
              {
                  if(event.motion.x < 405)
                  {
                      if(event.motion.y > 265)
                      {
                          if(event.motion.y < 315)

                          selectioner = 2;
                          else selectioner = 0;
                      }else selectioner = 0;
                  }
                  else selectioner = 0;
              }
              else selectioner = 0;
        }

        if(selectione == 1)
        {
        menu = IMG_Load("menujou.png");
            SDL_BlitSurface(menu , NULL, ecran , &positionMenu);
           SDL_Flip(ecran);
        }
        else if(selectioner == 2)
        {

         menu = IMG_Load("menuaid.png");
         SDL_BlitSurface(menu , NULL, ecran , &positionMenu);
         SDL_Flip(ecran);

        }
        else
        {

         menu = IMG_Load("menu.png");
         SDL_BlitSurface(menu , NULL, ecran , &positionMenu);
         SDL_Flip(ecran);

        }
switch(event.type)
        {
            case SDL_MOUSEBUTTONUP:
            if (event.button.button == SDL_BUTTON_LEFT)
            {

              if(event.button.x > 270)
              {
                  if(event.button.x < 405)
                  {
                      if(event.button.y > 265)
                      {
                          if(event.button.y < 315)
                          {
                       aiderjoueur(ecran);  SDL_Flip(ecran);
                         }

                      }
                  }

              }
if(event.button.x > 260)
              {
                  if(event.button.x < 410)
                  {
                      if(event.button.y > 180)
                      {
                                if(event.button.y < 235)
                                {

                              jouer(ecran);  SDL_Flip(ecran);
                                    }
                      }
                  }

              }

    }
        break;

        }


    }
    SDL_FreeSurface(menu);
    SDL_Quit();
    return EXIT_SUCCESS;
}


Le jeu.c :
#include <stdlib.h>
#include <stdio.h>
#include <SDL/SDL.h>
#include <SDL_image.h>
#include "aide.h"
#include "jeu.h"
#include "constantes.h"
void victoire(SDL_Surface *ecran)
{SDL_Event event;
    int continuer  = 1;
    SDL_Surface *victoiree;
    victoiree = IMG_Load("victoire.png");

    SDL_Rect victoire;
    victoire.x = 0;victoire.y = 0;
    SDL_BlitSurface(victoiree , NULL , ecran , &victoire);
    SDL_Flip(ecran);
    while(continuer)
    {


    switch(event.type)
{

        break;
    case SDL_KEYDOWN:
        switch(event.key.keysym.sym)
        {
            case SDLK_ESCAPE:
                continuer = 0;
                break;
        }}

    }
}
void gameover(SDL_Surface *ecran)
{SDL_Event event;
    int continuer = 1;
    SDL_Surface *victoiree;
    victoiree = IMG_Load("defaite.png");

    SDL_Rect victoire;
    victoire.x = 0;victoire.y = 0;
    SDL_BlitSurface(victoiree , NULL , ecran , &victoire);
    SDL_Flip(ecran);
        while(continuer)
    {


    switch(event.type)
{

        break;
    case SDL_KEYDOWN:
        switch(event.key.keysym.sym)
        {
            case SDLK_ESCAPE:
                continuer = 0;
                break;
        }}

    }
}

int deplacerJoueur(int carte[][NB_BLOCS_HAUTEUR], SDL_Rect *postete, SDL_Rect *posserp[50], int direction, int tailleserp, SDL_Surface *ecra)
{
    int i;
    SDL_Event event;
    switch(direction)
{
    case HAUT:
    if (postete->y - 1 < 0) // Si le joueur dépasse l'écran, on arrête
      {
    gameover(ecra);
    break;
      }
    if (carte[postete->x][postete->y - 1] == EAU) // S'il y a de l'eau, on arrête
      {
        gameover(ecra);
    break;
      }
    if (carte[postete->x][postete->y - 1] == SERPENT)// S'il y a son corp, on arrête
    {
        gameover(ecra);
    break;
      } if (carte[postete->x][postete->y - 1] == POMME)// S'il y a une pomme, on agrandi le serpent
          tailleserp++;
      postete->y--; // On peut enfin faire monter le joueur 
      posserp[0]->y = postete->y;
      posserp[0]->x = postete->x;

      for(i = 1; i < tailleserp ; i++)
      {
      posserp[i]->y = posserp[(i - 1)]->y;
      posserp[i]->x = posserp[(i - 1)]->x;
      }

      case BAS:
    if (postete->y + 1 > TAILLE_BLOC * NB_BLOCS_HAUTEUR) 
      {
    gameover(ecra);
    break;
      }
    if (carte[postete->x][postete->y + 1] == EAU) 
      {
        gameover(ecra);
    break;
      }
    if (carte[postete->x][postete->y + 1] == SERPENT)
    {
        gameover(ecra);
    break;
      } if (carte[postete->x][postete->y + 1] == POMME)
          tailleserp++;
            postete->y++; 
      posserp[0]->y = postete->y;
      posserp[0]->x = postete->x;
      for(i = 1; i < tailleserp ; i++)
      {
      posserp[i]->y = posserp[(i - 1)]->y;
      posserp[i]->x = posserp[(i - 1)]->x;
      }

            case DROITE:
    if (postete->x + 1 > TAILLE_BLOC * NB_BLOCS_HAUTEUR) 
      {
    gameover(ecra);
    break;
      }
    if (carte[postete->y][postete->x + 1] == EAU) 
      {
        gameover(ecra);
    break;
      }
    if (carte[postete->y][postete->x + 1] == SERPENT)
    {
        gameover(ecra);
    break;
      } if (carte[postete->x][postete->x + 1] == POMME)
          tailleserp++;
            postete->x++; 
      posserp[0]->y = postete->y;
      posserp[0]->x = postete->x;
      for( i = 1; i < tailleserp ; i++)
      {
      posserp[i]->y = posserp[(i - 1)]->y;
      posserp[i]->x = posserp[(i - 1)]->x;
      }

                  case GAUCHE:
    if (postete->x - 1 > TAILLE_BLOC * NB_BLOCS_HAUTEUR) 
      {
    gameover(ecra);
    break;
      }
    if (carte[postete->y][postete->x - 1] == EAU) 
      {
        gameover(ecra);
    break;
      }
    if (carte[postete->y][postete->x - 1] == SERPENT)
    {
        gameover(ecra);
    break;
      }

          if (carte[postete->x][postete->x - 1] == POMME)
          tailleserp++;



            postete->x--; 
      posserp[0]->y = postete->y;
      posserp[0]->x = postete->x;
      for(i = 1; i < tailleserp ; i++)
      {
      posserp[i]->y = posserp[(i - 1)]->y;
      posserp[i]->x = posserp[(i - 1)]->x;
      }


}
   return tailleserp;

}

void jouer(SDL_Surface *ecra)

{
int TAILLESERP = 4;
int continuer = 1, objectifsRestants = 0, i = 0, j = 0;
int carte[NB_BLOCS_LARGEUR][NB_BLOCS_HAUTEUR] = {0};

SDL_Surface *serpent = NULL;
SDL_Surface *eau = NULL, *vide = NULL, *pomme = NULL;
SDL_Rect positionSerpent[60], positiontete , position, positioncarte;
positioncarte.x = 0;
positioncarte.y = 0;
SDL_Event event;


serpent = IMG_Load("corp.png");

eau = IMG_Load("eau.png");
vide = IMG_Load("vide.png");

// Chargement du niveau

chargerNiveau(carte);




    // Recherche de la la tete du serpent
for (i = 0 ; i < NB_BLOCS_LARGEUR ; i++)
{
    for (j = 0 ; j < NB_BLOCS_HAUTEUR ; j++)
    {
        if (carte[i][j] == SERPENTTETE)
        {
            positiontete.x = i;
            positiontete.y = j;
            carte[i][j] = SERPENT;
        }
    }
}

while(continuer)
{


switch(event.type)
{
    case SDL_QUIT:
        continuer = 0;
        break;
    case SDL_KEYDOWN:
        switch(event.key.keysym.sym)
        {
            case SDLK_ESCAPE:
                continuer = 0;
                break;
            case SDLK_UP:

              TAILLESERP = deplacerJoueur(carte, &positiontete , &positionSerpent, HAUT ,TAILLESERP , ecra);

                break;
            case SDLK_DOWN:

                TAILLESERP = deplacerJoueur(carte, &positiontete , &positionSerpent, BAS,TAILLESERP,ecra);
                break;
            case SDLK_RIGHT:

                TAILLESERP = deplacerJoueur(carte, &positiontete , &positionSerpent , DROITE,TAILLESERP,ecra);
                break;
            case SDLK_LEFT:

                TAILLESERP = deplacerJoueur(carte, &positiontete,  &positionSerpent,GAUCHE,TAILLESERP,ecra);
                break;
        }
        break;
}
// Effacement de l'écran
SDL_FillRect(ecra, NULL, SDL_MapRGB(ecra->format, 255, 255, 255));

// Placement des objets à l'écran
objectifsRestants = 0;

for (i = 0 ; i < NB_BLOCS_LARGEUR ; i++)
{
    for (j = 0 ; j < NB_BLOCS_HAUTEUR ; j++)
    {
        position.x = i * TAILLE_BLOC;
        position.y = j * TAILLE_BLOC;

        switch(carte[i][j])
        {
            case EAU:
                SDL_BlitSurface(eau, NULL, ecra, &position);
                break;
            case VIDE:
                SDL_BlitSurface(vide, NULL, ecra, &position);
                break;

            case POMME:
                SDL_BlitSurface(pomme, NULL, ecra, &position);
                objectifsRestants ++;
                break;
                 case SERPENT:
                SDL_BlitSurface(serpent, NULL, ecra, &position);
                break;
        }

        if(objectifsRestants == 11)
        {
              victoire(ecra);
              continuer = 0;
        }

    }SDL_Flip(ecra);
}
}
SDL_Flip(ecra);
SDL_FreeSurface(eau);
SDL_FreeSurface(vide);
SDL_FreeSurface(pomme);
SDL_FreeSurface(SERPENT);





}


Le fichier.c :
#include <stdlib.h>
#include <stdio.h>
#include <SDL/SDL.h>
#include <SDL_image.h>
#include "aide.h"
#include "jeu.h"
#include "constantes.h"





int chargerNiveau(int niveau[][NB_BLOCS_HAUTEUR])
{
FILE* fichier = NULL;
    char ligneFichier[NB_BLOCS_LARGEUR * NB_BLOCS_HAUTEUR + 1] = {0};
    int i = 0, j = 0;

    fichier = fopen("niveaux.lvl", "r");



    fgets(ligneFichier, NB_BLOCS_LARGEUR * NB_BLOCS_HAUTEUR + 1, fichier);

    for (i = 0 ; i < NB_BLOCS_LARGEUR ; i++)
    {
        for (j = 0 ; j < NB_BLOCS_HAUTEUR ; j++)
        {
            switch (ligneFichier[(i * NB_BLOCS_LARGEUR) + j])
            {
                case '0':
                    niveau[j][i] = VIDE;
                    break;
                case '1':
                    niveau[j][i] = EAU;
                    break;
                case '2':
                    niveau[j][i] = POMME;
                    break;
                case '3':
                    niveau[j][i] = SERPENT;
                    break;
                    case '4':
                    niveau[j][i] = SERPENTTETE;
                    break;

            }
        }
    }

    fclose(fichier);

}


L'aide.c :
#include <stdlib.h>
#include <stdio.h>
#include <SDL/SDL.h>
#include <SDL_image.h>
#include "aide.h"
#include "jeu.h"
#include "constantes.h"


void aiderjoueur(SDL_Surface* ecran)
{

SDL_Surface *menu = NULL;
    menu = IMG_Load("aide.png");
    SDL_Rect positionMenu;
    positionMenu.x = 0;
    positionMenu.y = 0;


SDL_Event event;


    int continuer = 1;

    SDL_Init(SDL_INIT_VIDEO |SDL_INIT_TIMER);
    ecran = SDL_SetVideoMode(640, 480, 32, SDL_HWSURFACE | SDL_DOUBLEBUF);
    SDL_BlitSurface(menu , NULL, ecran , &positionMenu);
    SDL_Flip(ecran);
while (continuer)
{
    SDL_WaitEvent(&event);
    switch(event.type)
    {
        case SDL_QUIT:
            continuer = 0;
            break;
        case SDL_KEYDOWN:
            switch (event.key.keysym.sym)
            {
                case SDLK_ESCAPE: /* Appui sur la touche Echap, on arrête le programme */
                    continuer = 0;
                    break;
            }
            break;
    }
}




}


L'aide.h :
#ifndef AIDE_H_INCLUDED
#define AIDE_H_INCLUDED

void aiderjoueur(SDL_Surface* ecrane);

#endif // AIDE_H_INCLUDED


Le fichier.h :
#ifndef FICHIER_H_INCLUDED
#define FICHIER_H_INCLUDED

int chargerNiveau(int niveau[][NB_BLOCS_HAUTEUR]);

#endif // FICHIER_H_INCLUDED


Le jeu.h :

#ifndef DEF_JEU
#define DEF_JEU

    void jouer(SDL_Surface* ecran);

#endif // JEU_H_INCLUDED


Et les constantes.h :

#ifndef DEF_CONSTANTES
#define DEF_CONSTANTES

    #define TAILLE_BLOC         10 // Taille d'un bloc (carré) en pixels
    #define NB_BLOCS_LARGEUR    64
    #define NB_BLOCS_HAUTEUR    48
    #define LARGEUR_FENETRE     TAILLE_BLOC * NB_BLOCS_LARGEUR
    #define HAUTEUR_FENETRE     TAILLE_BLOC * NB_BLOCS_HAUTEUR


    enum {HAUT, BAS, GAUCHE, DROITE};
    enum {VIDE, EAU, POMME, SERPENT , SERPENTTETE};

#endif



merci à tous...
Publicité
Le 8 janvier 2012 à 16:52:32
Le 8 janvier 2012 à 17:01:05

tu connais pas les && et le || dans les if ?
Le 8 janvier 2012 à 17:30:29

Si si mais j'ai oubliée
Le 9 janvier 2012 à 17:13:09

A cause de la mauvaise indentation, il est dur de lire le code comme de la ligne 39 à la 60 et quelques ( et encore après ).
Corrige les condition comme placebo56 le suggère et reposte le code :).

probleme SNAKE

× Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
  • Editeur
  • Markdown