Programme en C avec SDL qui plante!!!

Bonjour,
J'ai fait un jeu ou l'on voit le jeu a la premiere personne et on se deplace dans des labyrinthe. Quand on demarre le jeu on choisit le 1 pour jouer ou 2 pour l'editeur de niveau mais peut importe ce que je choisit, le jeu plante. Si c'est jouer que je prend, le jeux ferme en exit failure sans rien afficher dans STDERR et si je prend l'editeur de niveaux, il affiche le niveau a modifier et ensuite se ferme a la vitesse de l'eclair encore en EXIT_FAILURE mais sans toute fois afficher quoi que ce soit dans STDERR! o_O

La je galre au maximum,!

Voici le code (les fichiers .h je les ai pas mis pour alleger le msg):

main.c

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

#include "constantes.h"
#include "jeu.h"
#include "editeur.h"
#include "fichiers.h"



int main(int argc, char *argv[])
{
SDL_Surface *ecran = NULL, *texte = NULL;
SDL_Event event;
TTF_Font *menu = NULL;
SDL_Rect positionTexte;
SDL_Color couleurTexte = {255 , 0 , 0 };

int continuer = 1;

SDL_Init(SDL_INIT_VIDEO);
TTF_Init();

SDL_WM_SetIcon(IMG_Load("images/icon.png"), NULL); // L'icône doit être chargée avant SDL_SetVideoMode
ecran = SDL_SetVideoMode(800, 600, 32, SDL_HWSURFACE | SDL_DOUBLEBUF);

menu = TTF_OpenFont("bloody.ttf", 28);


SDL_FillRect( ecran, NULL, SDL_MapRGB(ecran -> format, 52, 105, 105));

positionTexte.x = 25;
positionTexte.y = 100;
texte = TTF_RenderText_Blended(TTF_OpenFont("bloody.ttf", 38), "Bienvenu dans le labyrinthe de la mort!", couleurTexte);
SDL_BlitSurface (texte, NULL, ecran, &positionTexte);

positionTexte.x = 100;
positionTexte.y = 250;
texte = TTF_RenderText_Blended(menu, "Pour jouer vous aurez besoin des lettres de ", couleurTexte);
SDL_BlitSurface (texte, NULL, ecran, &positionTexte);

positionTexte.x = 100;
positionTexte.y = 300;
texte = TTF_RenderText_Blended(menu, "votre claviers et des fleches.", couleurTexte);
SDL_BlitSurface (texte, NULL, ecran, &positionTexte);


positionTexte.x = 100;
positionTexte.y = 350;
texte = TTF_RenderText_Blended(menu, "Pour jouer maintenant, appuyer sur 1 sinon sur ", couleurTexte);
SDL_BlitSurface (texte, NULL, ecran, &positionTexte);

positionTexte.x = 100;
positionTexte.y = 400;
texte = TTF_RenderText_Blended(menu, "echap (esc) pour quitter.", couleurTexte);
SDL_BlitSurface (texte, NULL, ecran, &positionTexte);


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: // Veut arrêter le jeu
continuer = 0;
break;
case SDLK_1: // Demande à jouer
jouer(ecran);
break;
case SDLK_2: // Demande l'éditeur de niveaux
editeur(ecran);
break;
}
break;
}

}

TTF_CloseFont(menu);
TTF_Quit();

SDL_Quit();

return EXIT_SUCCESS;
}


jeu.c


*
jeu.c
-----

Par Exporta22

Rôle : fonctions du jeu.
*/

#include <stdlib.h>
#include <stdio.h>
#include <SDL.h>
#include <SDL_image.h>

#include "constantes.h"
#include "jeu.h"
#include "editeur.h"
#include "fichiers.h"

void jouer(SDL_Surface* ecran)
{
SDL_Surface *decor[8] = {NULL}; // 8 surfaces pour chacun des decor possible
SDL_Surface *monstreS = NULL, *loupS = NULL;
SDL_Rect position, positionJoueur, positionMonstre, positionLoup;
SDL_Event event;

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

// Chargement des sprites (décors, personnage...)
monstreS = IMG_Load("images/monstre.gif");
loupS = IMG_Load("images/loup.gif");
decor[GAUCHEDROITE] = IMG_Load("images/2way_g_d.png");
decor[GAUCHEDROITEDEVANT] = IMG_Load("images/3way.png");
decor[DEVANT] = IMG_Load("images/devant.png");
decor[DEVANTDROITE] = IMG_Load("images/devant_droite.png");
decor[DEVANTGAUCHE] = IMG_Load("images/devant_gauche.png");
decor[A_DROITE] = IMG_Load("images/droite.png");
decor[A_GAUCHE] = IMG_Load("images/gauche.png");
decor[POINTENTRER]= IMG_Load("images/3way.png");

positionMonstre.x = (ecran-> w/2 - monstreS-> w/2);
positionMonstre.y = (ecran-> h/2 - monstreS-> h/2);
positionLoup.x = (ecran -> w/2 - loupS-> w/2);
positionLoup.y = (ecran -> h/2 - loupS -> h/2);

// Chargement du niveau
if (!chargerNiveau(carte))
{
fprintf(stderr, "Erreur d'initialisation de la SDL : %s\n", SDL_GetError()); // Ecriture de l'erreur
exit(EXIT_FAILURE); // On quitte le programme
}
// Recherche de la position de depart
for (i = 0 ; i < NB_BLOCS_LARGEUR ; i++)
{
for (j = 0 ; j < NB_BLOCS_HAUTEUR ; j++)
{
if (carte[i][j] == DEPART) // Si le depart se trouve à cette position sur la carte
{
positionJoueur.x = i;
positionJoueur.y = j;
}
}
}

while (continuer)
{
SDL_WaitEvent(&event);
switch(event.type)
{
case SDL_QUIT:
continuer = 0;
break;
{
case SDLK_ESCAPE:
continuer = 0;
break;
case SDLK_UP:
deplacerJoueur(carte, &positionJoueur, HAUT);
break;
case SDLK_RIGHT:
deplacerJoueur(carte, &positionJoueur, DROITE);
break;
case SDLK_LEFT:
deplacerJoueur(carte, &positionJoueur, GAUCHE);
break;
}
break;
}

// Effacement de l'écran
SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->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 = 0;
position.y = 0;

if (carte[i][j] == 0)
SDL_BlitSurface(monstreS, NULL, ecran, &positionMonstre);

else if (carte[i][j] == 1)
SDL_BlitSurface(loupS, NULL, ecran, &positionLoup);
//else if (carte[i][j] == 2)
//else if (carte[i][j] == 3)
else if (carte[i][j] == 4)
SDL_BlitSurface(GAUCHE_DROITE, NULL, ecran, &position);
else if (carte[i][j] == 5)
SDL_BlitSurface(GAUCHE_DROITE_DEVANT, NULL, ecran, &position);
else if (carte[i][j] == 6)
SDL_BlitSurface(DEVANT, NULL, ecran, &position);
else if (carte[i][j] == 7)
SDL_BlitSurface(DEVANT_DROITE, NULL, ecran, &position);
else if (carte[i][j] == 8)
SDL_BlitSurface(DEVANT_GAUCHE, NULL, ecran, &position);
else if (carte[i][j] == 9)
SDL_BlitSurface(DROITE, NULL, ecran, &position);
else if (carte[i][j] == 10)
SDL_BlitSurface(GAUCHE, NULL, ecran, &position);

}
}
}

SDL_Flip(ecran);



// Libération des surfaces chargées
SDL_FreeSurface(monstreS);
SDL_FreeSurface(loupS);
for (i = 0 ; i < 4 ; i++)
SDL_FreeSurface(decor[i]);
}

void deplacerJoueur(int carte[][NB_BLOCS_HAUTEUR], SDL_Rect *pos, int direction)
{
switch(direction)
{
case HAUT:
if (carte[pos->x][pos->y] == GAUCHE_DROITE)
break;
if (carte[pos->x][pos->y] == ADROITE)
break;
if (carte[pos->x][pos->y] == AGAUCHE)
break;

pos->y--; // On peut enfin faire monter le joueur (oufff !)
break;

case GAUCHE:
if (carte[pos->x][pos->y] == DEVANT)
break;
if (carte[pos->x][pos->y] == DEVANT_DROITE)
break;
if (carte[pos->x][pos->y] == ADROITE)
break;

pos->x--;
break;


case DROITE:
if (carte[pos->x ][pos->y] == DEVANT)
break;
if (carte[pos->x ][pos->y] == DEVANT_GAUCHE)
break;
if (carte[pos->x ][pos->y] == AGAUCHE)
break;

pos->x++;
break;
}
}


editeur.c


/*
editeur.c
---------

Par Exporta22

Rôle : gestion de l'éditeur de niveaux.
*/

#include <stdlib.h>
#include <stdio.h>
#include <SDL.h>
#include <SDL_image.h>

#include "constantes.h"
#include "jeu.h"
#include "editeur.h"
#include "fichiers.h"

void editeur(SDL_Surface* ecran)
{
SDL_Surface *monstre = NULL, *loup = NULL, *objectif = NULL, *depart = NULL, *gauche_Droite = NULL;
SDL_Surface *gauche_Droite_Devant = NULL, *devant = NULL, *devant_Droite = NULL, *devant_Gauche = NULL;
SDL_Surface *aDroite = NULL, *aGauche = NULL;
SDL_Rect position;
SDL_Event event;

int continuer = 1, clicGaucheEnCours = 0, clicDroitEnCours = 0;
int objetActuel = gauche_Droite_Devant, i = 0, j = 0;
int carte[NB_BLOCS_LARGEUR][NB_BLOCS_HAUTEUR] = {0};

// Chargement des objets et du niveau
monstre = IMG_Load("imagesediteur/monstre.gif");
loup = IMG_Load("imagesediteur/loup.gif");
gauche_Droite= IMG_Load("imagesediteur/2way_g_d.png");
gauche_Droite_Devant = IMG_Load("imagesediteur/3way.png");
devant = IMG_Load("imagesediteur/devant.png");
devant_Droite = IMG_Load("imagesediteur/devant_droite.png");
devant_Gauche = IMG_Load("imagesediteur/devant_gauche.png");
aDroite = IMG_Load("imagesediteur/droite.png");
aGauche= IMG_Load("imagesediteur/gauche.png");
depart = IMG_Load("imagesediteur/x.jpg");
objectif = IMG_Load("imagesediteur/obj.png");


if (!chargerNiveau(carte))
{
fprintf(stderr, "Erreur d'initialisation de la SDL : %s\n", SDL_GetError()); // Ecriture de l'erreur
exit(EXIT_FAILURE); // On quitte le programme
}


// Boucle infinie de l'éditeur
while (continuer)
{
SDL_WaitEvent(&event);
switch(event.type)
{
case SDL_QUIT:
continuer = 0;
break;
case SDL_MOUSEBUTTONDOWN:
if (event.button.button == SDL_BUTTON_LEFT)
{
// On met l'objet actuellement choisi à l'endroit du clic
carte[event.button.x / TAILLE_BLOC][event.button.y / TAILLE_BLOC] = objetActuel;
clicGaucheEnCours = 1; // On active un booléen pour retenir qu'un bouton est enfoncé
}

break;
case SDL_MOUSEMOTION:
if (clicGaucheEnCours) // Si on déplace la souris et que le bouton gauche de la souris est enfoncé
{
carte[event.motion.x / TAILLE_BLOC][event.motion.y / TAILLE_BLOC] = objetActuel;
}
break;
case SDL_KEYDOWN:
switch(event.key.keysym.sym)
{
case SDLK_ESCAPE:
continuer = 0;
break;
case SDLK_s:
sauvegarderNiveau(carte);
break;
case SDLK_c:
chargerNiveau(carte);
break;
case SDLK_KP1:
objetActuel = gauche_Droite;
break;
case SDLK_KP2:
objetActuel = gauche_Droite_Devant;
break;
case SDLK_KP3:
objetActuel = devant;
break;
case SDLK_KP4:
objetActuel = devant_Droite;
break;
case SDLK_KP5:
objetActuel = devant_Gauche;
break;
case SDLK_KP6:
objetActuel = aDroite;
break;
case SDLK_KP7:
objetActuel = aGauche;
break;
case SDLK_KP8:
objetActuel = monstre;
break;
case SDLK_KP9:
objetActuel = loup;
break;
case SDLK_KP0:
objetActuel = depart;
break;
case SDLK_KP_PERIOD:
objetActuel = objectif;
break;
}
break;
}

// Effacement de l'écran
SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 255, 255, 255));

// Placement des objets à l'écran
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 GAUCHE_DROITE:
SDL_BlitSurface(gauche_Droite, NULL, ecran, &position);
break;
case GAUCHE_DROITE_DEVANT:
SDL_BlitSurface(gauche_Droite_Devant, NULL, ecran, &position);
break;
case DEVANT:
SDL_BlitSurface(devant, NULL, ecran, &position);
break;
case DEVANT_DROITE:
SDL_BlitSurface(devant_Droite, NULL, ecran, &position);
break;
case DEVANT_GAUCHE:
SDL_BlitSurface(devant_Gauche, NULL, ecran, &position);
break;
case ADROITE:
SDL_BlitSurface(aDroite, NULL, ecran, &position);
break;
case AGAUCHE:
SDL_BlitSurface(aGauche, NULL, ecran, &position);
break;
case MONSTRE:
SDL_BlitSurface(monstre, NULL, ecran, &position);
break;
case LOUP:
SDL_BlitSurface(loup, NULL, ecran, &position);
break;
case DEPART:
SDL_BlitSurface(depart, NULL, ecran, &position);
break;
case OBJECTIF:
SDL_BlitSurface(objectif, NULL, ecran, &position);
break;

}
}
}

// Mise à jour de l'écran
SDL_Flip(ecran);


SDL_FreeSurface(gauche_Droite);
SDL_FreeSurface(gauche_Droite_Devant);
SDL_FreeSurface(devant);
SDL_FreeSurface(devant_Droite);
SDL_FreeSurface(devant_Gauche);
SDL_FreeSurface(aDroite);
SDL_FreeSurface(aGauche);
SDL_FreeSurface(monstre);
SDL_FreeSurface(loup);
SDL_FreeSurface(depart);
SDL_FreeSurface(objectif);

}
}


fichier.c


#include "jeu.h"
#include "editeur.h"
#include "fichiers.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");
if (fichier == NULL)
return 0;

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] = 0;
break;
case '1':
niveau[j][i] = 1;
break;
case '2':
niveau[j][i] = 2;
break;
case '3':
niveau[j][i] = 3;
break;
case '4':
niveau[j][i] = 4;
break;
case '5':
niveau[j][i] = 5;
break;
case '6':
niveau[j][i] = 6;
break;
case '7':
niveau[j][i] = 7;
break;
case '8':
niveau[j][i] = 8;
break;
case '9':
niveau[j][i] = 9;
break;
case '10':
niveau[j][i] = 10;
break;

}
}
}

fclose(fichier);
return 1;
}

int sauvegarderNiveau(int niveau[][NB_BLOCS_HAUTEUR])
{
FILE* fichier = NULL;
int i = 0, j = 0;

fichier = fopen("niveaux.lvl", "w");
if (fichier == NULL)
return 0;

for (i = 0 ; i < NB_BLOCS_LARGEUR ; i++)
{
for (j = 0 ; j < NB_BLOCS_HAUTEUR ; j++)
{
fprintf(fichier, "%d", niveau[j][i]);
}
}

fclose(fichier);
return 1;
}


<souligne>et finalement le fichier constante.h</souligne>


------------

Par exporta22

Rôle : définit des constantes communes à tout le programme (taille de la fenêtre...)
*/

#ifndef DEF_CONSTANTES
#define DEF_CONSTANTES

#define TAILLE_BLOC 34 // Taille d'un bloc (carré) en pixels
#define NB_BLOCS_LARGEUR 22
#define NB_BLOCS_HAUTEUR 16
#define LARGEUR_FENETRE TAILLE_BLOC * NB_BLOCS_LARGEUR
#define HAUTEUR_FENETRE TAILLE_BLOC * NB_BLOCS_HAUTEUR


enum {HAUT, BAS, GAUCHE, DROITE};
enum {GAUCHEDROITE, GAUCHEDROITEDEVANT, DEVANTDROITE, DEVANTGAUCHE, A_DROITE, A_GAUCHE, POINTENTRER};
enum {MONSTRE, LOUP, OBJECTIF, DEPART, GAUCHE_DROITE, GAUCHE_DROITE_DEVANT, DEVANT, DEVANT_DROITE, DEVANT_GAUCHE, ADROITE, AGAUCHE};

#endif