Gestion des erreurs en C

Docteur Cox Messages postés 105 Date d'inscription   Statut Membre Dernière intervention   -  
Docteur Cox Messages postés 105 Date d'inscription   Statut Membre Dernière intervention   -
Bonjour,
Je suis en train d'essayer de faire un petit programme en C mais quand je l'execute de temps en temps il se ferme tout seul sans que j'ai pu définir pourquoi...
J'aimerais donc trouver un moyen d'afficher les erreurs que rencontrent mon programme...
A voir également:

13 réponses

Réponse 1 / 13
geekrémi
 
Télécharge l'IDE Code::Block et met ton programme dedans, il te dit les buggs
0
Réponse 2 / 13
Docteur Cox Messages postés 105 Date d'inscription   Statut Membre Dernière intervention   4
 
ll les dit où? par ce que c'est déjà celui la que j'ai...
0
nobie-cs Messages postés 155 Date d'inscription   Statut Membre Dernière intervention   17
 
tu peut poster ton programme
0
Réponse 3 / 13
Docteur Cox Messages postés 105 Date d'inscription   Statut Membre Dernière intervention   4
 
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);
}
}
0
nobie-cs Messages postés 155 Date d'inscription   Statut Membre Dernière intervention   17
 
c'est quoi sa ?
#include <SDL/SDL.h>
#include <SDL/SDL_image.h>
#include <SDL/SDL_ttf.h>
0
Docteur Cox Messages postés 105 Date d'inscription   Statut Membre Dernière intervention   4 > nobie-cs Messages postés 155 Date d'inscription   Statut Membre Dernière intervention  
 
Ben j'inclue les librairies SDL, celle pour les images compressées et celle pour écrire...
0
nobie-cs Messages postés 155 Date d'inscription   Statut Membre Dernière intervention   17 > Docteur Cox Messages postés 105 Date d'inscription   Statut Membre Dernière intervention  
 
je peut pas exécute ton programme car je l'ai pas
0
Docteur Cox Messages postés 105 Date d'inscription   Statut Membre Dernière intervention   4 > nobie-cs Messages postés 155 Date d'inscription   Statut Membre Dernière intervention  
 
Comment ça tu l'as pas? j'ai copié collé...
0
Réponse 4 / 13
nobie-cs Messages postés 155 Date d'inscription   Statut Membre Dernière intervention   17
 
la librairies SDL est un fichier externe
0

Vous n’avez pas trouvé la réponse que vous recherchez ?

Posez votre question
Réponse 5 / 13
Docteur Cox Messages postés 105 Date d'inscription   Statut Membre Dernière intervention   4
 
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?
0
Réponse 6 / 13
nobie-cs Messages postés 155 Date d'inscription   Statut Membre Dernière intervention   17
 
tu mette getchar() avant return 0; dans la fonction int main()
0
Réponse 7 / 13
Docteur Cox Messages postés 105 Date d'inscription   Statut Membre Dernière intervention   4
 
Ouais et ça l'affiche où l'erreur?
0
Réponse 8 / 13
nobie-cs Messages postés 155 Date d'inscription   Statut Membre Dernière intervention   17
 
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
0
Réponse 9 / 13
Docteur Cox Messages postés 105 Date d'inscription   Statut Membre Dernière intervention   4
 
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...
0
Réponse 10 / 13
nobie-cs Messages postés 155 Date d'inscription   Statut Membre Dernière intervention   17
 
tu utilise code:blocks ? 
SDL_Flip(ecran);
il fait cette méthode ?
0
Réponse 11 / 13
Docteur Cox Messages postés 105 Date d'inscription   Statut Membre Dernière intervention   4
 
oui j'utilise codeblocks, qu'est ce que tu veux dire par "cette méthode"?
0
Réponse 12 / 13
nobie-cs Messages postés 155 Date d'inscription   Statut Membre Dernière intervention   17
  
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
0
Réponse 13 / 13
Docteur Cox Messages postés 105 Date d'inscription   Statut Membre Dernière intervention   4
 
Non ça c'est la commande pour rafraichir l'écran...
Et les printf ça marche pas sous windows avec la SDL...
0

Discussions similaires

Table des matières dont les titres n'apparaissent pas..
Synua -
ggg -

10 réponses