Programme sobokan en C (SDL) ne marche pas

Bonjour, j'ai programmé un jeu de sobokan en C avec SDL mais il y a encore plusieurs problèmes que je n'arrive pas à résoudre seul:

1- dans je jeu, la gestion des collisions ne fonctionne pas (et je ne sais pas du tout pourquoi)
2- dans mon éditeur de niveaux, quand je met la mollette de la souris vers le haut l'objet sélectionné ne change pas (ça je sais que le problème viens de l'incrémentation mais je ne sais pas pourquoi)

maintenant mes fichiers sources:

/*  
   main.cpp  
---------------------------------------------------------------------------------  
                    Par: G.Alex (Alexandre Garreau)  
                Créé le: 25/02/2011 à 14:50  
Dernière modifiction le: 26/02/2011 à 13:56  
                   Rôle: Menu du jeu, permet de choisir entre le jeu et l'éditeur  
*/  


#ifdef __cplusplus  
#include <cstdlib>  
#else  
#include <stdlib.h>  
#endif  
#include <stdio.h>  
#ifdef __APPLE__  
#include <SDL/SDL.h>  
#else  
#include <SDL.h>  
#endif  
#include <SDL_image.h>  

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



int main ( int argc, char** argv )  
{  
    // Surfaces de main.cpp (menu,images de boutons etc)  
    SDL_Surface *ecran = NULL, *menu = NULL, *boutonJouer = NULL, *boutonJouerActif = NULL, *boutonJouerPresse = NULL, *boutonEditeur = NULL, *boutonEditeurActif = NULL, *boutonEditeurPresse = NULL;  
    SDL_Event event;// Variable pour stocker les evenement  
    SDL_Rect positionMenu, positionBoutonJouer, positionBoutonEditeur; // Variables de position (le menu, les boutons etc)  
    int continuer = 1; // booléens de la boucle principale  
    int ClicGaucheEnCours = 0; // booléens indiquant l'état (pressé ou non) du bouton gauche de la souris  
    int quitter = 0;  
    int *pointeurQuitter = &quitter;  


    // Initialisation de la SDL  
    if ( SDL_Init( SDL_INIT_VIDEO ) < 0 )  
    {  
        fprintf(stderr, "Erreur lors de l'initialisation de la SDL: %s\n", SDL_GetError()); // !!!! ERREUR !!!!!  
        return 1;  
    }  

    // Chargement de l'icone de la fenêtre  
    SDL_WM_SetIcon(IMG_Load("caisse.jpg"), NULL);  

    // Ouverture de la fenêtre  
    ecran = SDL_SetVideoMode(LARGEUR_FENETRE, HAUTEUR_FENETRE, 32, SDL_HWSURFACE | SDL_DOUBLEBUF);  
    if (ecran == NULL)  
    {  
        fprintf(stderr, "Erreur lors de l'ouverture de la fenêtre: %s\n", SDL_GetError()); // !!!! ERREUR !!!!  
        return 1;  
    }  

    // nom de la fenêtre  
    SDL_WM_SetCaption("Mario Sobokan", NULL);  

    // placement des coordonnées  

    //coordonées du menu  
    positionMenu.x = 0;  
    positionMenu.y = 0;  
    //coordonées du bouton jouer  
    positionBoutonJouer.w = 84;  
    positionBoutonJouer.h = 34;  
    positionBoutonJouer.x = LARGEUR_FENETRE / 2 - positionBoutonJouer.w / 2;  
    positionBoutonJouer.y = HAUTEUR_FENETRE / 2 - positionBoutonJouer.h / 2;  
    // coordonnées du boutton editeur  
    positionBoutonEditeur.w = 101;  
    positionBoutonEditeur.h = 34;  
    positionBoutonEditeur.x = LARGEUR_FENETRE / 2 - positionBoutonEditeur.w / 2 ;  
    positionBoutonEditeur.y = HAUTEUR_FENETRE / 2 - positionBoutonEditeur.h / 2 + 60;  


    // Chargement des images  

    //image du menu  
    menu = IMG_Load("menu.jpg");  
    if (menu == NULL)  
    {  
        fprintf(stderr, "Erreur lors du chargement de l'image du menu: %s\n", SDL_GetError()); // !!!! ERREUR !!!!  
        return 1;  
    }  

    //image du nouton jouer  
    boutonJouer = IMG_Load("jouer.png");  
    if (boutonJouer == NULL)  
    {  
        fprintf(stderr, "Erreur lors du chargement de l'image du bouton jouer: %s\n", SDL_GetError()); // !!!! ERREUR !!!!  
        return 1;  
    }  

    //image du bouton jouer actif  
    boutonJouerActif = IMG_Load("ajouer.png");  
    if (boutonJouerActif == NULL)  
    {  
        fprintf(stderr, "Erreur lors du chargement de l'image du bouton jouer actif: %s\n", SDL_GetError()); // !!!! ERREUR !!!!  
        return 1;  
    }  

    //image du bouton jouer pressé  
    boutonJouerPresse = IMG_Load("pjouer.png");  
    if (boutonJouerPresse == NULL)  
    {  
        fprintf(stderr, "Erreur lors du chargement de l'image du bouton jouer pressé: %s\n", SDL_GetError()); // !!!! ERREUR !!!!  
        return 1;  
    }  

    // image du bouton editeur  
    boutonEditeur = IMG_Load("editeur.png");  
    if (boutonEditeur == NULL)  
    {  
        fprintf(stderr, "Erreur lors du chargement de l'image du bouton editeur: %s\n", SDL_GetError()); // !!!! ERREUR !!!!  
        return 1;  
    }  

    // image du bouton editeur actif  
    boutonEditeurActif = IMG_Load("aediteur.png");  
    if (boutonEditeurActif == NULL)  
    {  
        fprintf(stderr, "Erreur lors du chargement de l'image du bouton editeur actif: %s\n", SDL_GetError()); // !!!! ERREUR !!!!  
        return 1;  
    }  

    // image du bouton editeur pressé  
    boutonEditeurPresse = IMG_Load("pediteur.png");  
    if (boutonEditeurPresse == NULL)  
    {  
        fprintf(stderr, "Erreur lors du chargement de l'image du bouton editeur pressé: %s\n", SDL_GetError()); // !!!! ERREUR !!!!  
        return 1;  
    }  





    // Boucle principale du programme  
    while (continuer)  
    {  
        ClicGaucheEnCours = 0;  
        SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 0, 0, 0)); // effacement de l'écran  
        SDL_BlitSurface(menu, NULL, ecran, &positionMenu);// blit de l'image du menu  


        // attente d'un évènement  
        SDL_WaitEvent(&event);  
        // switch des évenements  
        switch (event.type)  
        {  
        case SDL_QUIT: // Si on appuie sur la croix  
            continuer = 0;  
            break;  
        case SDL_KEYDOWN:  
            switch(event.key.keysym.sym) // Switch des touches appuyées  
            {  
            case SDLK_ESCAPE: // Si on appuie sur echap  
                continuer = 0; // On met continuer à 0 ce qui arrête le programme  
                break;  
            }  
            break;  
        case SDL_MOUSEBUTTONDOWN: // Si on presse le bouton de la souris  
            if(event.button.button == SDL_BUTTON_LEFT) // Si c'est le bouton gauche  
            {  
                ClicGaucheEnCours = 1; // ClicGaucheEnCours = 1  
            }  
            break;  
        case SDL_MOUSEBUTTONUP: // Si on relache le bouton de la souris  
            if(event.button.button == SDL_BUTTON_LEFT)// Si c'est le bouton gauche  
            {  
                ClicGaucheEnCours = 0; // ClicGaucheEnCours = 0  
            }  
            break;  
        } // Fin du switch des évènements  


        // Si la souris passe sur le bouton "Jouer"  
        if(event.button.y > positionBoutonJouer.y && event.button.y < (positionBoutonJouer.y + positionBoutonJouer.h) && event.button.x > positionBoutonJouer.x && event.button.x < (positionBoutonJouer.x + positionBoutonJouer.w)) // Si la souris passe sur le bouton "Jouer"  
        {  
            if(ClicGaucheEnCours) // Si le bouton gauche de la souris est pressé  
            {  
                SDL_BlitSurface(boutonJouerPresse, NULL, ecran, &positionBoutonJouer); // on bitte l'image du bouton jouer pressé  
                SDL_BlitSurface(boutonEditeur, NULL, ecran, &positionBoutonEditeur);  
                SDL_Flip(ecran);  
                SDL_Delay(150);  
                jouer(ecran, &quitter); // Et on démarre le jeu  
                SDL_BlitSurface(menu, NULL, ecran, &positionMenu);// blit de l'image du menu  
                SDL_BlitSurface(boutonJouer, NULL, ecran, &positionBoutonJouer); // on blitte l'image du bouton jouer normal  

            }  
            else // Sinon, le bouton gauche de la souris n'est pas pressé  
            {  
                SDL_BlitSurface(boutonJouerActif, NULL, ecran, &positionBoutonJouer); // Alors on blitte l'image du bouton actif  

            }  

        }  
        else // et si le curseur n'est pas sur le bouton jouer  
        {  
            SDL_BlitSurface(boutonJouer, NULL, ecran, &positionBoutonJouer); // on blitte l'image du bouton jouer normal  
        }  


        // Si la souris passe sur le bouton "Editeur"  
        if(event.button.y > positionBoutonEditeur.y && event.button.y < (positionBoutonEditeur.y + positionBoutonEditeur.h) && event.button.x > positionBoutonEditeur.x && event.button.x < (positionBoutonEditeur.x + positionBoutonEditeur.w))  
        {  
            if(ClicGaucheEnCours && !quitter) // Si le bouton gauche de la souris est pressé  
            {  
                SDL_BlitSurface(boutonEditeurPresse, NULL, ecran, &positionBoutonEditeur); // on bitte l'image du bouton Editeur pressé  
                SDL_Flip(ecran);  
                SDL_Delay(150);  
                editeur(ecran, &quitter); // et on démare l'éditeur  
            }  
            else //Sinon le bouton gauche de la souris n'est pas appuyé  
            {  
                SDL_BlitSurface(boutonEditeurActif, NULL, ecran, &positionBoutonEditeur); // on bitte l'image du bouton Editeur actif  
            }  

        }  
        else // Sinon le curseur n'est pas sur le bouton Editeur  
        {  
            SDL_BlitSurface(boutonEditeur, NULL, ecran, &positionBoutonEditeur); // on bitte l'image du bouton Editeur normal  
        }  
        SDL_Flip(ecran);  
        if(quitter == 1)  
        {  
            continuer = 0;  
        }  
    }// Fin de la boucle principale  

    SDL_FreeSurface(menu);  
    SDL_FreeSurface(boutonJouer);  
    SDL_FreeSurface(boutonJouerActif);  
    SDL_FreeSurface(boutonJouerPresse);  
    SDL_FreeSurface(boutonEditeur);  
    SDL_FreeSurface(boutonEditeurActif);  
    SDL_FreeSurface(boutonEditeurPresse);  
    SDL_Quit();  

    return EXIT_SUCCESS;  



}// Fin de la fonction main  

bon là il n'y a pas de problème

et voici le fichier constantes.h

/*  
constantes.h  
-------------------------------------------------------------------------------------------------------  

                    Par: G.Alex (Alexandre Garreau)  
                Créé le: 25/02/2011 à 15:10  
Dernière modifiction le: 25/02/2011 à 15:20  
                   Rôle: définit des constantes communes à tout le programme (taille de la fenêtre...)  
*/  

#ifdef __cplusplus  
#include <cstdlib>  
#else  
#include <stdlib.h>  
#endif  
#include <stdio.h>  
#ifdef __APPLE__  
#include <SDL/SDL.h>  
#else  
#include <SDL.h>  
#endif  
#include <SDL_image.h>  


#ifndef DEF_CONSTANTES  
#define DEF_CONSTANTES  

#define TAILLE_BLOC         34 // Taille d'un bloc (carré, case) en pixels  
#define NB_BLOCS_LARGEUR    12 // Nombre de blocs en largeur  
#define NB_BLOCS_HAUTEUR    12 // Nombre de blocs en hauteur  
#define NB_BLOCS            NB_BLOCS_LARGEUR * NB_BLOCS_HAUTEUR // Nombre de blocs  
#define LARGEUR_FENETRE     TAILLE_BLOC * NB_BLOCS_LARGEUR // Largeur de la fenêtre en pixel (taille d'un bloc en pixel fois le nombre de blocs en largeur)  
#define HAUTEUR_FENETRE     TAILLE_BLOC * NB_BLOCS_HAUTEUR // Hauteur de la fenêtre en pixel (taille d'un bloc en pixel fois le nombre de blocs en hauteur)  


enum {HAUT, BAS, GAUCHE, DROITE}; // Enumération des variables d'action HAUT, BAS, GAUCHE et DROIRE  
enum {VIDE, MUR, CAISSE, OBJECTIF, MARIO, CAISSE_OK}; // Enumération des valeurs possible d'une case (sans compter le vide)  

#endif  

ici toujours pas de problème

désolé pour tout ces code mais je crois nécessaire de vous les donner
et maintenant le premier fichier qui a un problème (et un gros)
jeu.c:

/*  
jeu.c  
-------------------------------------------------------------------------------------------------------  

                    Par: G.Alex (Alexandre Garreau)  
                Créé le: 25/02/2011 à 17:37  
Dernière modifiction le: 25/02/2011 à 20:27  
                   Rôle: contient les fonction permettant de jouer (jouer(), deplacerJoueur(), deplacerCaisse(), etc...)  
*/  

#ifdef __cplusplus  
#include <cstdlib>  
#else  
#include <stdlib.h>  
#endif  
#include <stdio.h>  
#ifdef __APPLE__  
#include <SDL/SDL.h>  
#else  
#include <SDL.h>  
#endif  
#include <SDL_image.h>  

#include "constantes.h"  
#include "jeu.h"  


void jouer(SDL_Surface* ecran, int *quitter)  
{  
    SDL_ShowCursor(SDL_DISABLE);  
    SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 255, 255, 255));  
    SDL_Flip(ecran);  
    SDL_Surface* Mario[4] = {NULL};  
    SDL_Surface *caisse = NULL, *caisse_OK = NULL, *mur = NULL, *objectif = NULL, *MarioActuel = NULL, *Gagne = NULL;  
    SDL_Event event;  
    SDL_Rect position, positionJoueur;  

    Mario[BAS] = IMG_Load("mario_bas.gif");  
    if(Mario[BAS] == NULL)  
    {  
        fprintf(stderr, "Impossible de charger l'image de mario tourné vers le bas: Vérifiez qu'il existe un fichier mario_bas.gif", NULL);  
    }  
    Mario[HAUT] = IMG_Load("mario_haut.gif");  
    if(Mario[HAUT] == NULL)  
    {  
        fprintf(stderr, "Impossible de charger l'image de mario tourné vers le haut: Vérifiez qu'il existe un fichier mario_haut.gif", NULL);  
    }  
    Mario[GAUCHE] = IMG_Load("mario_gauche.gif");  
    if(Mario[GAUCHE] == NULL)  
    {  
        fprintf(stderr, "Impossible de charger l'image de mario tourné vers la gauche: Vérifiez qu'il existe un fichier mario_gauche.gif", NULL);  
    }  
    Mario[DROITE] = IMG_Load("mario_droite.gif");  
    if(Mario[DROITE] == NULL)  
    {  
        fprintf(stderr, "Impossible de charger l'image de mario tourné vers la droite: Vérifiez qu'il existe un fichier mario_droite.gif", NULL);  
    }  
    caisse = IMG_Load("caisse.jpg");  
    if(caisse == NULL)  
    {  
        fprintf(stderr, "Impossible de charger l'image de la caisse: Vérifiez qu'il existe un fichier caisse.jpg", NULL);  
    }  
    caisse_OK = IMG_Load("caisse_ok.jpg");  
    if(caisse_OK == NULL)  
    {  
        fprintf(stderr, "Impossible de charger l'image de la caisse bien placée: Vérifiez qu'il existe un fichier caisse.jpg", NULL);  
    }  
    mur = IMG_Load("mur.jpg");  
    if(mur == NULL)  
    {  
        fprintf(stderr, "Impossible de charger l'image du mur: Vérifiez qu'il existe un fichier mur.jpg", NULL);  
    }  
    objectif = IMG_Load("objectif.png");  
    if(objectif == NULL)  
    {  
        fprintf(stderr, "Impossible de charger l'image de l'objectif: Vérifiez qu'il existe un fichier objectif.png", NULL);  
    }  
    Gagne = IMG_Load("Gagne.png");  
    if(Gagne == NULL)  
    {  
        fprintf(stderr, "Impossible de charger l'image annonçant la victoire: Vérifiez qu'il existe un fichier Gagne.png", NULL);  
    }  
    int continuer = 1, objectifsRestants = 0, x = 0, y = 0;  
    int carte[NB_BLOCS_LARGEUR][NB_BLOCS_HAUTEUR] = {0};  

    // Chargement du niveau  
    if (!chargerNiveau(carte))  
    {  
        exit(EXIT_FAILURE); // On arrête le jeu si on n'a pas pu charger le niveau  
        fprintf(stderr, "Impossible de charger les niveaux: vérifiez si il y a un fichier niveau.lvl\n", NULL);  

    }  


    for(y = 0 ; y < NB_BLOCS_HAUTEUR ; y++)  
    {  
        for(x = 0 ; x < NB_BLOCS_LARGEUR ; x++)  
        {  
            if(carte[x][y] == MARIO)  
            {  
                positionJoueur.x = x;  
                positionJoueur.y = y;  
                carte[x][y] == VIDE;  
            }  

        }  
    }  

    MarioActuel = Mario[BAS];  
    // Activation de la répétition des touches  
    SDL_EnableKeyRepeat(100, 100);  
    while(continuer)  
    {  









        SDL_WaitEvent(&event);  

        switch(event.type)  
        {  
        case SDL_QUIT:  
            continuer = 0; // continuer = 0 arrête la fonction jouer.  
            *quitter = 1;  // *quitter = 1 met continuer à 0 dans la fonction main  
            break;  

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

            case SDLK_UP:  
                MarioActuel = Mario[HAUT];  
                deplacerJoueur(carte[NB_BLOCS_LARGEUR][NB_BLOCS_HAUTEUR], &positionJoueur, HAUT);  
                break;  

            case SDLK_DOWN:  
                MarioActuel = Mario[BAS];  
                deplacerJoueur(carte[NB_BLOCS_LARGEUR][NB_BLOCS_HAUTEUR], &positionJoueur, BAS);  
                break;  

            case SDLK_LEFT:  
                MarioActuel = Mario[GAUCHE];  
                deplacerJoueur(carte[NB_BLOCS_LARGEUR][NB_BLOCS_HAUTEUR], &positionJoueur, GAUCHE);  
                break;  

            case SDLK_RIGHT:  
                MarioActuel = Mario[DROITE];  
                deplacerJoueur(carte[NB_BLOCS_LARGEUR][NB_BLOCS_HAUTEUR], &positionJoueur, DROITE);  
                break;  

            }  
            break;  
        }  
        SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 255, 255, 255));  
        for(y = 0 ; y < NB_BLOCS_HAUTEUR ; y++)  
        {  
            for(x = 0 ; x < NB_BLOCS_LARGEUR ; x++)  
            {  

                position.x = x * TAILLE_BLOC;  
                position.y = y * TAILLE_BLOC;  

                switch(carte[x][y])  
                {  
                case MUR:  
                    SDL_BlitSurface(mur, NULL, ecran, &position);  
                    break;  
                case CAISSE:  
                    SDL_BlitSurface(caisse, NULL, ecran, &position);  
                    break;  
                case CAISSE_OK:  
                    SDL_BlitSurface(caisse_OK, NULL, ecran, &position);  
                    break;  
                case OBJECTIF:  
                    SDL_BlitSurface(objectif, NULL, ecran, &position);  
                    objectifsRestants = 1;  
                    break;  
                }  
            }  
        }  
        position.x = positionJoueur.x * TAILLE_BLOC;  
        position.y = positionJoueur.y * TAILLE_BLOC;  
        SDL_BlitSurface(MarioActuel, NULL, ecran, &position);  
        SDL_Flip(ecran);  
        if(!objectifsRestants)  
        {  
            continuer = 0;  

        }  

        SDL_Flip(ecran);  

    }  
    SDL_ShowCursor(SDL_ENABLE);  
}  

void deplacerJoueur(int carte[][NB_BLOCS_HAUTEUR], SDL_Rect *pos, int direction)  
{  
    switch(direction)  
    {  
    case HAUT:  
        if((pos->y - 1) < 0)  
        {  

        }  
        else if(carte[pos->x][pos->y - 1] == MUR)  
        {  

        }  
        else if((carte[pos->x][pos->y - 1] == CAISSE || carte[pos->x][pos->y - 1] == CAISSE_OK) && (carte[pos->x][pos->y - 2] == CAISSE || carte[pos->x][pos->y - 2] == CAISSE_OK || pos->y - 2 < 0 ) )  
        {  

        }  
        else  
        {  
            deplacerCaisse(&carte[pos->x][pos->y - 1], &carte[pos->x][pos->y - 2]);  
            pos->y--;  
        }  

        break;  


    case BAS:  
        if((pos->y + 1) >= HAUTEUR_FENETRE )  
        {  

        }  
        else if(carte[pos->x][pos->y + 1] == MUR)  
        {  

        }  
        else if((carte[pos->x][pos->y + 1] == CAISSE || carte[pos->x][pos->y + 1] == CAISSE_OK) && (carte[pos->x][pos->y + 2] == CAISSE || carte[pos->x][pos->y + 2] == CAISSE_OK || pos->y + 2 < 0))  
        {  

        }  
        else  
        {  
            deplacerCaisse(&carte[pos->x][pos->y + 1], &carte[pos->x][pos->y + 2]);  
            pos->y++;  
        }  

        break;  


    case GAUCHE:  
        if((pos->x - 1) < 0 )  
        {  

        }  
        else if(carte[pos->y][pos->x - 1] == MUR)  
        {  

        }  
        else if((carte[pos->y][pos->x - 1] == CAISSE || carte[pos->y][pos->x - 1] == CAISSE_OK) && (carte[pos->y][pos->x - 2] == CAISSE || carte[pos->y][pos->x - 2] == CAISSE_OK || pos->x - 2 < 0))  
        {  

        }  
        else  
        {  
            deplacerCaisse(&carte[pos->y][pos->x - 1], &carte[pos->y][pos->x - 2]);  
            pos->x--;  
        }  

        break;  


    case DROITE:  
        if((pos->x + 1) >= LARGEUR_FENETRE )  
        {  

        }  
        else if(carte[pos->y][pos->x + 1] == MUR)  
        {  

        }  
        else if((carte[pos->y][pos->x + 1] == CAISSE || carte[pos->y][pos->x + 1] == CAISSE_OK) && (carte[pos->y][pos->x + 2] == CAISSE || carte[pos->y][pos->x + 2] == CAISSE_OK || pos->x + 2 < 0))  
        {  

        }  
        else  
        {  
            deplacerCaisse(&carte[pos->y][pos->x + 1], &carte[pos->y][pos->x + 2]);  
            pos->x++;  
        }  

        break;  


    }  
}  

void deplacerCaisse(int *premiereCase, int *secondeCase)  
{  

    if(*premiereCase == CAISSE)  
    {  
        *premiereCase = VIDE;  
    }  

    if(*premiereCase == CAISSE_OK)  
    {  
        *premiereCase = OBJECTIF;  
    }  

    if(*secondeCase == VIDE);  
    {  
        *secondeCase = CAISSE;  
    }  

    if(*secondeCase == OBJECTIF);  
    {  
        *secondeCase = CAISSE_OK;  
    }  

}  

et son headers contenant ses prototypes jeu.h:

/*  
jeu.h  
-------------------------------------------------------------------------------------------------------  

                    Par: G.Alex (Alexandre Garreau)  
                Créé le: 25/02/2011 à 17:40  
Dernière modifiction le: 25/02/2011 à 17:45  
                   Rôle: contient les prototypes nécéssaires à jeu.c et à main.c  
*/  

#ifdef __cplusplus  
#include <cstdlib>  
#else  
#include <stdlib.h>  
#endif  
#include <stdio.h>  
#ifdef __APPLE__  
#include <SDL/SDL.h>  
#else  
#include <SDL.h>  
#endif  
#include <SDL_image.h>  


#ifndef DEF_JEU  
#define DEF_JEU  

void jouer(SDL_Surface* ecran, int *quitter);  
void deplacerJoueur(int [][NB_BLOCS_HAUTEUR], SDL_Rect *pos, int direction);  
void deplacerCaisse(int *premiereCase, int *secondeCase);  

#endif  

et voilà le deuxième fichier qui pose problème éditeur.c
(le problème est dans l'incrémentation de la ligne 100)

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

                    Par: G.Alex (Alexandre Garreau)  
                Créé le: 25/02/2011 à 17:46  
Dernière modifiction le: 25/02/2011 à 17:47  
                   Rôle: contient les fonction necessaires à l'éditeur ( chargerNiveau() et sauverNiveau() )  
*/  
#ifdef __cplusplus  
#include <cstdlib>  
#else  
#include <stdlib.h>  
#endif  
#include <stdio.h>  
#ifdef __APPLE__  
#include <SDL/SDL.h>  
#else  
#include <SDL.h>  
#endif  
#include <SDL_image.h>  

#include "constantes.h"  
#include "editeur.h"  

void editeur(SDL_Surface* ecran, int *quitter)  
{  
    SDL_ShowCursor(SDL_DISABLE);  
    SDL_Surface *mur = NULL, *caisse = NULL, *caisse_OK, *objectif = NULL, *mario = NULL; // Chargement des surfaces servant à contenir les images  
    SDL_Rect position;  
    SDL_Event event, test;  

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

    // Chargement des images des objets  
    mur = IMG_Load("mur.jpg"); // image du mur  
    if(mur == NULL)  
    {  
        fprintf(stderr, "Erreur lors du chargement de l'image du mur: Vérifier qu'il existe une image mur.jpg", NULL);  
    }  
    caisse = IMG_Load("caisse.jpg"); // image des caisse  
    if(caisse == NULL)  
    {  
        fprintf(stderr, "Erreur lors du chargement de l'image des caisse: Vérifier qu'il existe une image caisse.jpg", NULL);  
    }  
    caisse_OK = IMG_Load("caisse_ok.jpg"); // image des caisse bien placée  
    if(caisse_OK == NULL)  
    {  
        fprintf(stderr, "Erreur lors du chargement de l'image des caisse bien placée: Vérifier qu'il existe une image caisse_ok.jpg", NULL);  
    }  
    objectif = IMG_Load("objectif.png"); // image des objectifs  
    if(objectif == NULL)  
    {  
        fprintf(stderr, "Erreur lors du chargement de l'image des objectifs: Vérifier qu'il existe une image objectif.jpg", NULL);  
    }  
    mario = IMG_Load("mario_bas.gif"); // image de mario dans sa position de départ (vers le bas)  
    if(mario == NULL)  
    {  
        fprintf(stderr, "Erreur lors du chargement de l'image du mario: Vérifier qu'il existe une image mario_bas.jpg", NULL);  
    }  


    // Chargement du niveau  
    if (!chargerNiveau(carte))  
        exit(EXIT_FAILURE);  

    while(continuer)  
    {  




        SDL_PollEvent(&event);  
        switch(event.type)  
        {  
        case SDL_QUIT:  
            continuer = 0;  
            *quitter = 1;  
            break;  
        case SDL_MOUSEBUTTONDOWN:  
            if (event.button.button == SDL_BUTTON_LEFT)  
            {  
                // On met l'objet choisi (mur, caisse, objectif etc...) à la position à la quelle on à cliqué  
                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é  
            }  
            else if (event.button.button == SDL_BUTTON_RIGHT) // Le clic droit sert à remplacer la valeur d'une case par VIDE  
            {  
                carte[event.button.x / TAILLE_BLOC][event.button.y /TAILLE_BLOC] = VIDE;  
                clicDroitEnCours = 1;  
            }  
            switch(event.button.button)  
            {  
            case SDL_BUTTON_WHEELUP:  
                if(nombreObjetActuel <= 5)  
                {  
                    nombreObjetActuel++;  
                }  
                else  
                {  
                    nombreObjetActuel = 1;  
                }// Boucle de la roulette de la souris vers le haut  
            case SDL_BUTTON_WHEELDOWN:  
                if(nombreObjetActuel >= 1)  
                {  
                    nombreObjetActuel--;  
                }  
                else  
                {  
                    nombreObjetActuel = 5;  
                }// Boucle de la roulette de la souris vers le bas  
                break;  
            }// Boucle de la roulette de la souris  
            break;  

            break;  

        case SDL_MOUSEBUTTONUP: // On désactive le booléen qui disait qu'un bouton était enfoncé  
            if (event.button.button == SDL_BUTTON_LEFT)  
            {  
                clicGaucheEnCours = 0;  
            }  

            else if (event.button.button == SDL_BUTTON_RIGHT)  
            {  
                clicDroitEnCours = 0;  
            }  

            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;  
            }  
            else if (clicDroitEnCours) // Pareil pour le bouton droit de la souris  
            {  
                carte[event.motion.x / TAILLE_BLOC][event.motion.y / TAILLE_BLOC] = VIDE;  
            }  
            break;// Case des clic  
        case SDL_KEYDOWN:  
            switch(event.key.keysym.sym)  
            {  
            case SDLK_ESCAPE:  
                continuer = 0;  
                break;  
            case SDLK_RETURN:  
                sauvegarderNiveau(carte);  
                break;  
            case SDLK_SPACE:  
                chargerNiveau(carte);  
                break;  
            case SDLK_KP1:  
                objetActuel = MUR;  
                break;  
            case SDLK_KP2:  
                objetActuel = CAISSE;  
                break;  
            case SDLK_KP3:  
                objetActuel = OBJECTIF;  
                break;  
            case SDLK_KP4:  
                objetActuel = CAISSE_OK;  
                break;  
            case SDLK_KP5:  
                objetActuel = MARIO;  
                break;  
            case SDLK_DOWN:  
                if(nombreObjetActuel >= 0)  
                {  
                    nombreObjetActuel--;  
                }  
                else  
                {  
                    nombreObjetActuel = 5;  
                }  

                break;  
            case SDLK_UP:  
                if(nombreObjetActuel <= 5)  
                {  
                    nombreObjetActuel++;  
                }  
                else  
                {  
                    nombreObjetActuel = 0;  
                }  
                break;  
            }// Boucle des touche du clavier  
            break;  

        }// Boucle des évènements  

        switch(nombreObjetActuel)  
        {  
        case 1:  
            objetActuel = MUR;  
            break;  
        case 2:  
            objetActuel = CAISSE;  
            break;  
        case 3:  
            objetActuel = CAISSE_OK;  
            break;  
        case 4:  
            objetActuel = OBJECTIF;  
            break;  
        case 5:  
            objetActuel = MARIO;  
            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 MUR:  
                    SDL_BlitSurface(mur, NULL, ecran, &position);  
                    break;  
                case CAISSE:  
                    SDL_BlitSurface(caisse, NULL, ecran, &position);  
                    break;  
                case CAISSE_OK:  
                    SDL_BlitSurface(caisse_OK, NULL, ecran, &position);  
                    break;  
                case OBJECTIF:  
                    SDL_BlitSurface(objectif, NULL, ecran, &position);  
                    break;  
                case MARIO:  
                    SDL_BlitSurface(mario, NULL, ecran, &position);  
                    break;  
                }  
            }  
        }  

        position.x = event.button.x - 34 / 2;  
        position.y = event.button.y - 34 / 2;  


        switch(objetActuel)  
        {  
        case MUR:  
            SDL_BlitSurface(mur, NULL, ecran, &position);  
            break;  
        case CAISSE:  
            SDL_BlitSurface(caisse, NULL, ecran, &position);  
            break;  
        case CAISSE_OK:  
            SDL_BlitSurface(caisse_OK, NULL, ecran, &position);  
            break;  
        case OBJECTIF:  
            SDL_BlitSurface(objectif, NULL, ecran, &position);  
            break;  
        case MARIO:  
            SDL_BlitSurface(mario, NULL, ecran, &position);  
            break;  
        }  

// Mise à jour de l'écran  
        SDL_Flip(ecran);  
    }  
    SDL_FreeSurface(mur);  
    SDL_FreeSurface(caisse);  
    SDL_FreeSurface(caisse_OK);  
    SDL_FreeSurface(objectif);  
    SDL_FreeSurface(mario);  

    SDL_ShowCursor(SDL_ENABLE);  
}  

voici son headers avec ses prototypes editeur.h

/*  
editeur.h  
-------------------------------------------------------------------------------------------------------  

                    Par: G.Alex (Alexandre Garreau)  
                Créé le: 25/02/2011 à 17:49  
Dernière modifiction le: 25/02/2011 à 19:23  
                   Rôle: contient les prototypes nécéssaires à editeur.c et main.c  
*/  
#ifdef __cplusplus  
#include <cstdlib>  
#else  
#include <stdlib.h>  
#endif  
#include <stdio.h>  
#ifdef __APPLE__  
#include <SDL/SDL.h>  
#else  
#include <SDL.h>  
#endif  
#include <SDL_image.h>  

#ifndef DEF_EDITEUR  
#define DEF_EDITEUR  

void editeur(SDL_Surface* ecran, int *quitter);  

#endif  

maintenant le fichier qui charge le niveau
fichier.c

/*  
fichiers.c  
-------------------------------------------------------------------------------------------------------  

                    Par: G.Alex (Alexandre Garreau)  
                Créé le: 25/02/2011 à 17:51  
Dernière modifiction le: 25/02/2011 à 17:53  
                   Rôle: contient les fonctions necesaires à editeur.c  
*/  

#ifdef __cplusplus  
#include <cstdlib>  
#else  
#include <stdlib.h>  
#endif  
#include <stdio.h>  
#ifdef __APPLE__  
#include <SDL/SDL.h>  
#else  
#include <SDL.h>  
#endif  
#include <SDL_image.h>  

#include "constantes.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 x = 0, y = 0;  

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


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

    for(y = 0 ; y < NB_BLOCS_HAUTEUR ; y++)  
    {  
        for(x = 0 ; x < NB_BLOCS_LARGEUR ; x++)  
        {  
            switch(ligneFichier[(y * NB_BLOCS_LARGEUR) + x])  
            {  
            case '0':  
                niveau[x][y] = 0;  
                break;  
            case '1':  
                niveau[x][y] = 1;  
                break;  
            case '2':  
                niveau[x][y] = 2;  
                break;  
            case '3':  
                niveau[x][y] = 3;  
                break;  
            case '4':  
                niveau[x][y] = 4;  
                break;  
            case '5':  
                niveau[x][y] = 5;  
            }  
        }  
    }  

    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;  
}  

et son headers fichier.h

/*  
fichiers.h  
-------------------------------------------------------------------------------------------------------  

                    Par: G.Alex (Alexandre Garreau)  
                Créé le: 25/02/2011 à 18:00  
Dernière modifiction le: 25/02/2011 à 18:01  
                   Rôle: contient les prototypes nécéssaires à fichiers.c  
*/  
#ifdef __cplusplus  
#include <cstdlib>  
#else  
#include <stdlib.h>  
#endif  
#include <stdio.h>  
#ifdef __APPLE__  
#include <SDL/SDL.h>  
#else  
#include <SDL.h>  
#endif  
#include <SDL_image.h>  

#ifndef DEF_FICHIERS  
#define DEF_FICHIERS  

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

#endif  

et le dernier le fichier ressource

/*  
ressources.rc  
-------------------------------------------------------------------------------------------------------  

                    Par: G.Alex (Alexandre Garreau)  
                Créé le: 25/02/2011 à 18:12  
Dernière modifiction le: 25/02/2011 à 18:  
                   Rôle: fichiers ressources  
*/  

1 ICON "caisse.ico"  

bon je suis désolé de vous poster tout mon projet mais on ne sais jamais, si je me trompe et que c'est du à autre chose...
Et si vous trouvez vraiment que c'est trop et inutile dites le moi je modifierais.