Gestion des erreurs en C

Télécharge l'IDE Code::Block et met ton programme dedans, il te dit les buggs

ll les dit où? par ce que c'est déjà celui la que j'ai...

OK mais c'est un peu brouillon... :S
C'est un snake

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

#define TAILLE_CASE 11
#define NB_CASE_H 15
#define NB_CASE_L 25

#define HAUT -1
#define BAS 1
#define DROITE 1
#define GAUCHE -1
#define STOP 0

enum{MUR, POMME, SNAKE, QUEUE_SNAKE, VIDE};

typedef struct DIRECTION DIRECTION;
struct DIRECTION
{
int vertical;
int horizontal;
int x;
int y;
};

int initialisation( int carte[NB_CASE_L][NB_CASE_H] );
void joue( int carte[NB_CASE_L][NB_CASE_H], SDL_Surface *ecran );

int main(int argc, char *argv[])
{
int continuer = 1;
int carte[NB_CASE_L][NB_CASE_H];
SDL_Surface *ecran = NULL;
SDL_Event event;

srand(time(NULL));

if ( SDL_Init(SDL_INIT_VIDEO) == -1 )
{ fprintf(stderr, "Erreur d'initialisation de la SDL"); exit(EXIT_FAILURE); }
if( TTF_Init() == -1 )
{ fprintf(stderr, "Erreur d'initialisation de TTF_Init : %s\n", TTF_GetError()); exit(EXIT_FAILURE); }

ecran = SDL_SetVideoMode(NB_CASE_L * TAILLE_CASE, NB_CASE_H * TAILLE_CASE, 32, SDL_HWSURFACE | SDL_DOUBLEBUF);
SDL_WM_SetCaption("< Snake>", NULL);

carte[NB_CASE_L][NB_CASE_H] = initialisation( carte );
joue( carte, 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:
continuer = 0;
break;

case SDLK_F2:
carte[NB_CASE_L][NB_CASE_H] = initialisation( carte );
joue( carte, ecran );
break;

default:
break;
}
}
}

SDL_Quit();
TTF_Quit();
return EXIT_SUCCESS;
}

/************************************************************************/

int initialisation(int carte[NB_CASE_L][NB_CASE_H])
{
int i = 0, j = 0;

for (i = 0; i < NB_CASE_L; i++)
{ for(j = 0; j < NB_CASE_H; j++)
{
carte[i][j] = VIDE;
}
}

carte[9][7] = SNAKE;

carte[0][0] = MUR;
carte[0][1] = MUR;
carte[1][0] = MUR;
carte[1][1] = MUR;

carte[NB_CASE_L-1][NB_CASE_H-1] = MUR;
carte[NB_CASE_L-2][NB_CASE_H-1] = MUR;
carte[NB_CASE_L-1][NB_CASE_H-2] = MUR;
carte[NB_CASE_L-2][NB_CASE_H-2] = MUR;

carte[NB_CASE_L-1][0] = MUR;
carte[NB_CASE_L-1][1] = MUR;
carte[NB_CASE_L-2][0] = MUR;
carte[NB_CASE_L-2][1] = MUR;

carte[0][NB_CASE_H-1] = MUR;
carte[1][NB_CASE_H-1] = MUR;
carte[0][NB_CASE_H-2] = MUR;
carte[1][NB_CASE_H-2] = MUR;

carte[(NB_CASE_L/2)][(NB_CASE_H/2)] = MUR;
carte[(NB_CASE_L/2)-1][(NB_CASE_H/2)-1] = MUR;
carte[(NB_CASE_L/2)+1][(NB_CASE_H/2)-1] = MUR;
carte[(NB_CASE_L/2)-1][(NB_CASE_H/2)+1] = MUR;
carte[(NB_CASE_L/2)+1][(NB_CASE_H/2)+1] = MUR;
carte[(NB_CASE_L/2)+1][(NB_CASE_H/2)] = MUR;
carte[(NB_CASE_L/2)-1][(NB_CASE_H/2)] = MUR;
carte[(NB_CASE_L/2)][(NB_CASE_H/2)+1] = MUR;
carte[(NB_CASE_L/2)][(NB_CASE_H/2)-1] = MUR;

return carte[NB_CASE_L][NB_CASE_H];
}

/************************************************************************/

void joue( int carte[NB_CASE_L][NB_CASE_H], SDL_Surface *ecran )
{
int i = 0, j = 0, k = 0, l = 0;
int nouvi = 0, nouvj = 0;
int x = 0, y = 0;
int continuer = 1;
int ContinuerBoucle = 1;
int DirectionVerticale = STOP;
int DirectionHorizontale = STOP;
int DirectionVerticaleFin = STOP;
int DirectionHorizontaleFin = STOP;
int TempsActuel = 0;
int TempsPrecedent = 0;
int SnakeTemp = 1128; // une valeur au hasard
DIRECTION QueueDeSnake[1000];
int TailleQueue = 1;
SDL_Event event;
SDL_Rect position;
SDL_Surface *Mur = IMG_Load("mur.png");
SDL_Surface *Snake = IMG_Load("snake.png");
SDL_Surface *Pomme = IMG_Load("pomme.png");

for (k = 0; k < 20; k++)
{
QueueDeSnake[ k ].horizontal = 0;
QueueDeSnake[ k].vertical = 0;
QueueDeSnake[ k ].x = -1;
QueueDeSnake[ k ].y = -1;
}

while ( ContinuerBoucle == 1 )
{
x = (rand() % (NB_CASE_L - 1)); // on calcule les coordonnées de la nouvelle pomme
y= (rand() % (NB_CASE_H - 1));

// test pour vérifier que la pomme est dans la fenêtre et qu'elle n'est pas dans un mur ou autre...
if ( carte[x][y] != MUR && carte[x][y] != SnakeTemp && x >= 0 && y >= 0 && x <= NB_CASE_L && y <= NB_CASE_H )
{ ContinuerBoucle = 0; }
}
carte[x][y] = POMME;

while (continuer)
{

TempsPrecedent = SDL_GetTicks();
while(TempsActuel - TempsPrecedent < 150)
{
SDL_Delay(50);
TempsActuel = SDL_GetTicks();
}

// là il y a un truc un peu étrange : comme c'était avant ça le faisait avancer 2 fois par boucle, maintenant c'est bon ça marche impec mais je sais pas trop comment... :P
ContinuerBoucle = 0;
do
{
event.type = SDL_KEYUP;
SDL_PollEvent(&event); // récupèration de l'évènement dans event

switch(event.type) // test du type d'évènement
{
case SDL_QUIT: // si c'est un évènement de type "Quitter"
continuer = 0;
break;

case SDL_KEYUP:
switch( event.key.keysym.sym )
{
case SDLK_UP:
if ( DirectionVerticale != BAS ) { DirectionVerticale = HAUT; DirectionHorizontale = STOP; }
break;

case SDLK_DOWN:
if ( DirectionVerticale != HAUT ) { DirectionVerticale = BAS; DirectionHorizontale = STOP; }
break;

case SDLK_RIGHT:
if ( DirectionHorizontale != GAUCHE ) { DirectionHorizontale = DROITE; DirectionVerticale = STOP; }
break;

case SDLK_LEFT:
if ( DirectionHorizontale != DROITE ) { DirectionHorizontale = GAUCHE; DirectionVerticale = STOP; }
break;

default:
break;
}
ContinuerBoucle = 0;
break;

case SDL_KEYDOWN:
ContinuerBoucle = 1;
break;

default:
ContinuerBoucle = 0;
break;
}

} while( ContinuerBoucle == 1 );

/** boucle pour faire déterminer les nouvelles coordonées de SNAKE**/
for(i = 0; i < NB_CASE_L; i++)
{for(j = 0; j < NB_CASE_H; j++)
{
if (carte[i][j] == SNAKE)
{
nouvi = i + DirectionHorizontale;
// si les nouvelles coordonées sortent de l'écran par un coté, snake réaparait de l'autre
if (nouvi >= NB_CASE_L)
{ nouvi = 0; }
else if (nouvi < 0)
{ nouvi = NB_CASE_L - 1; }

nouvj = j + DirectionVerticale;
// si les nouvelles coordonées sortent de l'écran par un coté, snake réaparait de l'autre
if (nouvj >= NB_CASE_H)
{ nouvj = 0; }
else if (nouvj < 0)
{ nouvj = NB_CASE_H -1; }

// si SNAKE mange un mur
if ( carte[ nouvi ][ nouvj ] == MUR )
{
continuer = 0; // pour sortir de la boucle
nouvi = i; // pour ne plus avancer
nouvj = j;
Snake = IMG_Load("snakerouge.png");
}

// si SNAKE mange une pomme
if ( carte[nouvi][nouvj] == POMME )
{
TailleQueue++;
ContinuerBoucle = 1;
while ( ContinuerBoucle == 1 )
{
carte[ nouvi ][ nouvj ] = SnakeTemp; // on le fait quand même avancer

x = (rand() % (NB_CASE_L - 1)); // on calcule les coordonnées de la nouvelle pomme
y= (rand() % (NB_CASE_H - 1));

// test pour vérifier que la pomme est dans la fenêtre et qu'elle n'est pas dans un mur ou autre...
if ( carte[x][y] != MUR && carte[x][y] != SnakeTemp && x >= 0 && y >= 0 && x <= NB_CASE_L && y <= NB_CASE_H )
{ ContinuerBoucle = 0; }
}
carte[x][y] = POMME;
}

/** on met snake aux nouvelles coordonnées **/
// si je met SNAKE tt de suite il va le retrouver au prochain tour de boucle, donc je met SnakeTemp
carte[ nouvi ][ nouvj ] = SnakeTemp;
//on met la queue de snake à sa précédente position pour qu'elle le suive
carte[ i ][ j ] = QUEUE_SNAKE;

for (k = TailleQueue - 1; k > 0; k--)
{
QueueDeSnake[ k ].vertical = QueueDeSnake[k-1].vertical;
QueueDeSnake[ k ].horizontal = QueueDeSnake[k-1].horizontal;
}

QueueDeSnake[0].vertical = DirectionVerticaleFin;
QueueDeSnake[0].horizontal = DirectionHorizontaleFin;

QueueDeSnake[0].x = i - QueueDeSnake[0].horizontal;
QueueDeSnake[0].y = j - QueueDeSnake[0].vertical;

for ( k = 1; k < TailleQueue; k++ )
{
QueueDeSnake[k].x = QueueDeSnake[k-1].x - QueueDeSnake[k].horizontal;
QueueDeSnake[k].y = QueueDeSnake[k-1].y - QueueDeSnake[k].vertical;

carte[QueueDeSnake[k].x][QueueDeSnake[k].y] = SnakeTemp;
}

QueueDeSnake[0].vertical = DirectionVerticale;
QueueDeSnake[0].horizontal = DirectionHorizontale;

if ( QueueDeSnake[TailleQueue-1].x < 0)
{
carte[ NB_CASE_L + QueueDeSnake[TailleQueue-1].x ][ QueueDeSnake[TailleQueue-1].y ] = VIDE;
}
if ( QueueDeSnake[TailleQueue-1].y < 0)
{
carte[ QueueDeSnake[TailleQueue-1].x ][ NB_CASE_H + QueueDeSnake[TailleQueue-1].y ] = VIDE;
}
{
carte[ QueueDeSnake[TailleQueue-1].x ][ QueueDeSnake[TailleQueue-1].y ] = VIDE;
}
}
}
}

// et maintenant qu'on est plus dans la boucle on peut remettre SNAKE
carte[ nouvi ][ nouvj ] = SNAKE;

for ( k = 0; k < NB_CASE_L; k++ )
{ for ( l = 0; l < NB_CASE_H; l++ )

if ( carte[ k ][ l ] == SnakeTemp )
{
carte[ k ][ l ] = QUEUE_SNAKE;
}
}

/** toute la partie pour l'affichage **/

SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 0, 0, 0));

for (i = 0; i < NB_CASE_L; i++)
{ for(j = 0; j < NB_CASE_H; j++)
{
position.x = i * TAILLE_CASE;
position.y = j * TAILLE_CASE;

switch (carte[i][j])
{
case MUR:
//surface = IMG_Load("mur2.png");
SDL_BlitSurface(Mur, NULL, ecran, &position);
break;
case POMME:
//surface = IMG_Load("pomme.png");
SDL_BlitSurface(Pomme, NULL, ecran, &position);
break;
case SNAKE:
//surface = IMG_Load("snake.png");
SDL_BlitSurface(Snake, NULL, ecran, &position);
break;
case QUEUE_SNAKE:
//surface = IMG_Load("snake.png");
SDL_BlitSurface(Snake, NULL, ecran, &position);
break;
}
}
}
SDL_Flip(ecran);
}
}

la librairies SDL est un fichier externe

oui je sais, je les ai toute installlées en suivant ce que diasait le site du zero de toute façon...
Mais sinon tu connais pas une façon de connaitre l'erreur qu'il a rencontré quand il se ferme d'un coup?

tu mette getchar() avant return 0; dans la fonction int main()

Ouais et ça l'affiche où l'erreur?

si tu met getchar()il va pas se fermer d'un coup
pour les erreur d'exécution je sait pas si il y a un méthode de la faire moi je fait des printf("") pour savoir quel est la boucle qui ne s'arrête pas

Mais j'ai mis getchar() et il se ferme pareil... :S
Et je croyais qu'on pouvais pas faire de printf() avec la sdl sous windows...

tu utilise code:blocks ?

SDL_Flip(ecran); 

il fait cette méthode ?

oui j'utilise codeblocks, qu'est ce que tu veux dire par "cette méthode"?

SDL_Flip(ecran);

il est a la fin du code source je sait pas se qu'il fait est je croit c'est elle qui ferme ton programme , utilise un printf(""); avant et après

Non ça c'est la commande pour rafraichir l'écran...
Et les printf ça marche pas sous windows avec la SDL...