fonctions du moteur pour verifier les cases accessibles

src/controleur.c

@@ -470,7 +470,7 @@ void obtenirPositionPersonnage(int numero, int * x, int * y){
 
   /*!
  * \fn Personnage * trouverPersonnage(Case * c)
- * \brief La fonction renvoie un pointeur vers le personnage présent sur la case en parrammetre.
+ * \brief La fonction renvoie un pointeur vers le personnage présent sur la case en parametre.
  *
  * \param Les coordonnées de la Case à tester
  * \return Un pointeur vers un personnage, NULL, s'il n'y a pas de personnage sur la case.
@@ -504,18 +504,13 @@ Personnage * trouverPersonnage(Case * c){
     return NULL;
 }
 
-  /*!
- * \fn char * obtenirNomJoueurCourant()
- * \brief La fonction renvoie le nom du Joueur dont c'est le tour.
+
+/*!
+ * \fn void deplacement_personnage(int numPerso, int x_pixel, int y_pixel)
+ * \brief La fonction permet de deplacer un personnage
  *
- * \return Un char * vers le nom du joueur dont c'est le tour.
+ * \param Le numero du personnage a deplacer, les coordonnees ou l'utilisateur a clique
  */
-char * obtenirNomJoueurCourant(){
-    return getNomJoueur(getCurrentJoueur(getListJoueur(partieGlobale)));
-}
-
-
-
 void deplacement_personnage(int numPerso, int x_pixel, int y_pixel){
     int x=x_case_cliquee(x_pixel, y_pixel);
     int y=y_case_cliquee(x_pixel, y_pixel);
@@ -528,6 +523,15 @@ void deplacement_personnage(int numPerso, int x_pixel, int y_pixel){
 }
 
 
+  /*!
+ * \fn char * obtenirNomJoueurCourant()
+ * \brief La fonction renvoie le nom du Joueur dont c'est le tour.
+ *
+ * \return Un char * vers le nom du joueur dont c'est le tour.
+ */
+char * obtenirNomJoueurCourant(){
+    return getNomJoueur(getCurrentJoueur(getListJoueur(partieGlobale)));
+}
 
   /*!
  * \fn char * obtenirNomClassePersonnage(int numero)

src/deplacements.c

@@ -37,7 +37,7 @@ boolean case_a_cote(Personnage * perso, Case * destination){
  * \brief déplace un personnage sur une case située à côté de la sienne, si cela est possible
  *
  * \param Un personnage, une case
- * \return Un entier.
+ * \return 0 si le deplacement est possible et a ete effectue, 1 si il n'est pas possible ou n'a pas fonctionne
  */
 int deplacement_unitaire(Personnage *perso,Case * destination){
     if (est_occupee(destination)==vrai){
@@ -62,21 +62,85 @@ int deplacement_unitaire(Personnage *perso,Case * destination){
     return 1;
 }
 
-
-
-/* Cette fonction devrait plutot renvoyer un tableau ou une liste de cases ou le
-deplacement est possible, pour la surbrillance on verra ca plus tard avec une
-fonction d'affichage specifique. */
-int affichage_deplacements_possibles(Personnage *perso, Carte *c){ /* Met en surbrillance les cases disponibles pour un déplacement */
+/*!
+ * \fn boolean case_a_cote_case(Case * depart, Case * destination)
+ * \brief verifie si deux cases sont cote-a-cote
+ *
+ * \param la case de depart, la case d'arrivee
+ * \return vrai ou faux
+ */
+boolean case_a_cote_case(Case * depart, Case * destination){
     int i;
-    int pd_max_x = get_PD(perso);
-//    int pd_max_y = get_PD(perso);
+    if (get_x(depart)>get_x(destination)+1||get_x(depart)<get_x(destination)-1||get_y(depart)>get_y(destination)+1||get_y(depart)<get_y(destination)-1){
+        return faux;
+    }
+    for(i=0;i<LARG_MAX_CARTE;i+=2){
+        if (get_y(depart)==get_y(destination)+1&&get_x(depart)!=get_x(destination)&&get_x(depart)==i+1)
+            return faux;
+        if (get_y(depart)==get_y(destination)-1&&get_x(depart)!=get_x(destination)&&get_x(depart)==i)
+            return faux;
+    }
+    return vrai;
+}
+
+/*!
+ * \fn boolean deplacement_unitaire_possible(Case* depart,Case* destination)
+ * \brief verifie si on peut de deplacer d'une cas e a une autre
+ *
+ * \param la case de depart, la case d'arrivee
+ * \return vrai si le deplacement est possible, faux si il n'est pas possible
+ */
+boolean deplacement_unitaire_possible(Case* depart,Case* destination){
+    if (est_occupee(destination)==vrai){
+        return faux;
+    }
+    if (case_franchissable(destination)==faux){
+        return faux;
+    }
+    if (case_a_cote_case(depart,destination)==vrai){
+        return vrai;
+       }
+    return faux;
+}
 
-    for(i=0;i<pd_max_x;i++){
-        if(1!=0){
-            /* ??? */
+/*!
+ * \fn boolean deplacement_possible(Personnage* perso, Case* c, Carte_Jeu* carte)
+ * \brief verifie si un personnage peut se rendre sur une case distante en fonction de ses points de mouvement
+ *
+ * \param le personnage, la case d'arrivee, la carte
+ * \return vrai si le deplacement est possible, faux si il n'est pas possible
+ */
+boolean deplacement_possible(Personnage* perso, Case* c, Carte_Jeu* carte){
+    int pts_mvt = perso->points_deplacement;
+    Case* depart=perso->position;
+    int x,y;
+    for(x=0;x<LARG_MAX_CARTE;x++){
+        for(y=0;y<HAUT_MAX_CARTE;y++){
+            if(deplacement_unitaire_possible(depart,&carte->Tab_Cases[x][y])==vrai){
+                return deplacement_possible_recursif(&carte->Tab_Cases[x][y],c, carte,pts_mvt-carte->Tab_Cases[x][y].terrain->PD_requis);
+            }
         }
     }
-    return 0;
+    return faux;
 }
 
+/*!
+ * \fn boolean deplacement_possible_recursif(Case* dep, Case* dest, Carte_Jeu* carte, int pts_restants)
+ * \brief fonction recursive appellee par deplacement_possible, elle a le meme role
+ *
+ * \param une case depart, une case arrivee, la carte, les points de mouvement du personnage
+ * \return vrai si le deplacement est possible, faux si il n'est pas possible
+ */
+boolean deplacement_possible_recursif(Case* dep, Case* dest, Carte_Jeu* carte, int pts_restants){
+    int x,y;
+    if(dep==dest) return vrai;
+    if(pts_restants<1) return faux;
+    for(x=0;x<LARG_MAX_CARTE;x++){
+            for(y=0;y<HAUT_MAX_CARTE;y++){
+                if(deplacement_unitaire_possible(dep,&carte->Tab_Cases[x][y])==vrai){
+                    return deplacement_possible_recursif(&carte->Tab_Cases[x][y],dest, carte,pts_restants-1);
+                }
+            }
+    }
+    return faux;
+}

src/deplacements.h

@@ -10,5 +10,13 @@ boolean case_a_cote(Personnage *perso,Case *destination);
 
 int deplacement_unitaire(Personnage *perso,Case * destination);
 
+boolean case_a_cote_case(Case * depart, Case * destination);
+
+boolean deplacement_unitaire_possible(Case* depart,Case * destination);
+
+boolean deplacement_possible(Personnage* perso, Case* c, Carte_Jeu* carte);
+
+boolean deplacement_possible_recursif(Case* dep, Case* dest, Carte_Jeu* carte, int pts_restants);
+
 
 #endif