Tp Labyrinthe

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <assert.h>

#pragma warning(disable: 4996)

// ESP : espace, MUR : mur
typedef enum {ESP, MUR} Cellule;

// Hauteur et largeur du terrain de jeu (il est carré).
enum {TAILLE = 4};

// Le terrain doit être initialisé conformément à la valeur de TAILLE.
const Cellule terrain[TAILLE][TAILLE] = {
    {ESP, ESP, ESP, ESP},
    {ESP, MUR, ESP, MUR},
    {ESP, ESP, MUR, ESP},
    {MUR, ESP, ESP, ESP}
};

// Coordonnée valide (i.e. dans le plan et cellule non occupée par un mur) ?
// Attention : x désigne le n° de ligne et y le n° de colonne
int estValide(int x, int y) {
    return ( x >= 0 && y>= 0 && x<TAILLE && y<TAILLE && !terrain[x][y] );
}

// Création d'une structure contenant un tableau
typedef int Dist[TAILLE][TAILLE];
// Création d'un enum qui sera attribué au case non visitée
enum {PAS_VISIT = -1};

int distance(int x, int y, int xa, int ya){
    Dist dst;
    int dmin=0, i, j, comp=1;
     for (i=0; i<TAILLE; ++i){
        for (j=0; j<TAILLE; ++j) dst[i][j]=PAS_VISIT;
     }
     dst[x][y]=dmin;
     do {
     for (i=0; i<TAILLE; ++i) {
         for (j=0; j<TAILLE; ++j) {
             if (dst[i][j]==dmin) {
                 if (estValide(i+1,j) && (dst[i+1][j]==PAS_VISIT)) {
                     ++comp;
                     dst[i+1][j]=dmin+1;
                 }
                 if (estValide (i-1,j) && (dst[i-1][j]==PAS_VISIT)) {
                     ++comp;
                     dst[i-1][j]=dmin+1;
                 }
                 if (estValide (i,j+1) && (dst[i][j+1]==PAS_VISIT) ) {
                     ++comp;
                     dst[i][j+1]=dmin+1;
                 }
                 if (estValide (i,j-1) && (dst[i][j-1]==PAS_VISIT)) {
                     ++comp;
                     dst[i][j-1]=dmin+1;
                 }
             }
         }
     }
     ++dmin;
     while(comp<=(TAILLE*TAILLE-4));}
     if (dst[xa][ya]!=PAS_VISIT)
            return dst[xa][ya];
     else return 6;
}

// Coordonnée valide (i.e. dans le plan et cellule non occupée par un mur) ?
// Attention : x désigne le n° de ligne et y le n° de colonne


// Constante et type utilitaires
// Nb de directions
enum {NB_DIR = 4};
// haut, bas, droite et gauche
const int dir[NB_DIR][2] = {{-1, 0}, {1, 0}, {0, 1}, {0, -1}};

// fonction utilitaire
int conversion(char c) {
    switch (c) {
    case 'h': return 0;
    case 'b': return 1;
    case 'd': return 2;
    case 'g': return 3;
    }
    return NB_DIR;
}

int main() {
    // Point de départ du joueur et point à atteindre.
    int x = 0, y = TAILLE - 1, xa = TAILLE - 1, ya = TAILLE - 1;
    // Nb minimal de déplacements nécessaires pour atteindre la cible à partir du point de départ.
    const int mindis = distance(x,y,xa,ya);
    // Nb de déplacements du joueur.
    int nbDep = 0;
    printf("vous pouvez gagner en %d deplacements\n", mindis);

    while (x != xa || y != ya) {
     char c;
     int d;
     printf("Vous etes en (%d, %d) et vous devez aller en (%d, %d)\n", x, y, xa, ya);
     printf("(h)aut, (b)as, (d)roite, (g)auche ? : ");
     scanf("\n%c", &c);
     d = conversion(tolower(c));
     if (d == NB_DIR)
         printf("direction inconnue");
     else {
         int x1 = x + dir[d][0], y1 = y + dir[d][1];
         if (estValide(x1, y1)) {
             x = x1;
             y = y1;
             ++nbDep;
         }
         else
             printf("il y a un mur\n");
     }
    }
    if (nbDep == mindis)
     printf("Bravo !!!\n");
    else if (nbDep > mindis)
     printf("Vous pouvez faire mieux\n");
    else
     printf("Vous etes plus fort que moi !!!\n");
    system("pause"); system("cls"); return 0;
}