probleme jeu du labyrinthe (SDL)

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

#include "constante_jeu.h"

void jeu(SDL_Surface *ecran);
void deplaceplayer (int carte[][NB_BLOCS_HAUTEUR], SDL_Rect *posi, int direction);

int main(int argc, char **argv)
{
  SDL_Surface *ecran = NULL, *menu = NULL;
  SDL_Rect positionMenu;
  SDL_Event event;
  
  int continuer = 1;
  
  SDL_Init(SDL_INIT_VIDEO);
  
  SDL_WM_SetIcon(SDL_LoadBMP("labyrinthe.bmp"), NULL);
  ecran = SDL_SetVideoMode(LARGEUR_FENETRE, HAUTEUR_FENETRE, 32, SDL_HWSURFACE | SDL_DOUBLEBUF);
  SDL_WM_SetCaption("Labyrinthe", NULL);
  
  menu = SDL_LoadBMP("labyrinthe2.bmp");
  positionMenu.x = 0;
  positionMenu.y = 0;
  
  while (continuer)
    {
      
      
      SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 0, 0, 0));
      SDL_BlitSurface(menu, NULL, ecran, &positionMenu);
      SDL_Flip(ecran);
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_KP1:
	      SDL_FreeSurface(menu);
	      jeu(ecran);
	      break;
	    }
	  break;
        }
      
    }
  
  SDL_FreeSurface(menu);
  SDL_Quit();
  
  return EXIT_SUCCESS;
}

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

#include "constante_jeu.h"

void jeu(SDL_Surface *ecran);
void deplaceplayer (int carte[][NB_BLOCS_HAUTEUR], SDL_Rect *posi, int direction);

void jeu(SDL_Surface *ecran)
{
  SDL_Surface *player[4] = {NULL};
  SDL_Surface *mur = NULL;
  SDL_Surface *player_actu = NULL;
  SDL_Rect position;//pos image a blitter
  SDL_Rect posplayer;
  SDL_Event event;
  int carte[NB_BLOCS_LARGEUR][NB_BLOCS_HAUTEUR] = {0};
  int continuer;
  int i;
  int j;
  continuer = 1;
  i = 0;
  j = 0;
 

  mur = SDL_LoadBMP("mur.bmp");
  player[B] = SDL_LoadBMP("player_bas.bmp");
  player[G] = SDL_LoadBMP("player_gauche.bmp");
  player[H] = SDL_LoadBMP("player_haut.bmp");
  player[D] = SDL_LoadBMP("player_droite.bmp");
  player_actu = player[D];

  posplayer.x = 0;
  posplayer.y = 0;


  SDL_EnableKeyRepeat(100, 100);

      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;
	      SDL_BlitSurface (mur, NULL, ecran, &position);
	      switch(carte[i][j])
		{
		case MUR:
		  SDL_BlitSurface (mur, NULL, ecran, &position);
		  SDL_Flip(ecran);
		  break;
		  }
	      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:
	      continuer = 0;
	      break;
	    case SDLK_UP:
	      player_actu = player[H];
	      deplaceplayer(carte, &posplayer, H);
	      break;
	    case SDLK_DOWN:
	      player_actu = player[B];
	      deplaceplayer(carte, &posplayer, B);
	      break;
	    case SDLK_RIGHT:
	      player_actu = player[D];
	      deplaceplayer(carte, &posplayer, D);
	      break;
	    case SDLK_LEFT:
	      player_actu = player[G];
	      deplaceplayer(carte, &posplayer, G);
	      break;
	    }
	  break;
	}
      
      //SDL_FillRect(ecran, NULL, SDL_MapRGB (ecran ->format, 255, 255, 255));
       
      //SDL_BlitSurface (mur, NULL, ecran, &position);


      if (carte[20][20]== player);
	continuer = 0;
      
      position.x = posplayer.x * TAILLE_BLOC;
      position.y = posplayer.y * TAILLE_BLOC;
      SDL_BlitSurface (player_actu, NULL, ecran, &position);
      
      SDL_Flip(ecran);
    }

  SDL_Delay(7000);

  SDL_EnableKeyRepeat(0, 0);
  SDL_FreeSurface(mur);
  for (i = 0; i < 4; i++)
    SDL_FreeSurface(player[i]);
}
  
void deplaceplayer (int carte[][NB_BLOCS_HAUTEUR], SDL_Rect *posi, int direction)
{
  while (1)
    {
      switch (direction)
	{
	case H:
	  if (posi -> y - 1 < 0
	    break;
	  if (carte[posi ->x][posi->y - 1] == MUR)
	    break;
	  posi ->y--;
	  break;
	  
	case B:
	  if (posi -> y + 1 >= NB_BLOCS_HAUTEUR)
	    break;
	  if (carte[posi ->x][posi->y + 1] == MUR)
	    break;
	  
	  posi ->y++;
	  break;
	  
	case G:
	  if (posi -> x - 1 < 0)
	    break;
	  if (carte[posi ->x - 1][posi->y] == MUR)
	    break;
	  
	  posi ->x--;
	  break;
	  
	case D:
	  if (posi -> x + 1 >= NB_BLOCS_LARGEUR)
	    break;
	  if (carte[posi ->x][posi->y] == MUR)
	    break;
	  
	  posi ->x++;
	  break;
	}
    }
}

#ifndef DEF_CONSTANTES
#define DEF_CONSTANTES

    #define TAILLE_BLOC         34
    #define NB_BLOCS_LARGEUR    12
    #define NB_BLOCS_HAUTEUR    12
    #define LARGEUR_FENETRE     TAILLE_BLOC * NB_BLOCS_LARGEUR
    #define HAUTEUR_FENETRE     TAILLE_BLOC * NB_BLOCS_HAUTEUR


    enum {H, B, G, D};
    enum {VIDE, MUR, MARIO};

#endif