Code des fonction du controleur pour le début et la fin du tour d'un Joueur

src/controleur.c

@@ -493,6 +493,16 @@ Personnage * trouverPersonnage(Case * c){
     return NULL;
 }
 
+  /*!
+ * \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)
  * \brief La fonction renvoie le nom de la classe du Personnage en parrametre.
@@ -731,6 +741,44 @@ int obtenirPDMaxPersonnage(int numero){
     return tabNomsAttPerso;
 }*/
 
+  /*!
+ * \fn void debutDuTour()
+ * \brief La fonction effectue les opération de début de tour.
+ *        Les points de déplacements des personnages sont remis au maximum
+ *        Les Personnages récupèrent une partie de leur mana.
+ *        Note : Pour l'instant, les personnages récupère 10% de leur mana total au début du tour.
+                 (Ils ne peuvent pas avoir un mana supérieur à leur mana maximum définit par la classe.)
+ *               Si vous voulez changer ça, dites moi.
+ */
+void debutDuTour(){
+    debutTour(partieGlobale);
+}
+
+  /*!
+ * \fn int finDuTour()
+ * \brief La fonction teste si un Joueur est victorieux et sinon termine le tour du Joueur actuel.
+ *
+ * \return 1 si un joueur a remporté la partie, 0 sinon, dans ce cas, la main est donnée au joueur suivant.
+ */
+int finDuTour(){
+    // La fin du tour est possible si la partie n'est pas gagnée par un Joueur
+    return finTour(partieGlobale);
+}
+
+void personnageSuivant();
+
+  /*!
+ * \fn char * joueurVictorieux()
+ * \brief La fonction retourne le nom du Joueur qui a remporté la partie.
+ *        Cette fonction doit être appellée seulement si la fonction finDuTour a renvoyé 1.
+ *        Sinon la fonction renvoie seulement le nom du joueur dont c'est le tour.
+ *
+ * \return Une chaine de caractère vers le nom d'un Joueur.
+ */
+char * joueurVictorieux(){
+    return getNomJoueur(getCurrentJoueur(getListJoueur(partieGlobale)));
+}
+
 // Je met ici mes tests réalisés dans le main pour éviter de les réécrire si jamais il y a un problème.
 // Si vous voulez tester aussi, à recopier dans le main avant l'appel à initJeu().
 void testControlleurConsole(){

src/controleur.h

@@ -41,6 +41,7 @@ void obtenirPositionPersonnage(int numero, int * x, int * y);
 
 Personnage * trouverPersonnage(Case * c);
 
+char * obtenirNomJoueurCourant();
 char * obtenirNomClassePersonnage(int numero);
 int obtenirPVPersonnage(int numero);
 int obtenirPVMaxPersonnage(int numero);
@@ -50,6 +51,11 @@ int obtenirPDPersonnage(int numero);
 int obtenirPDMaxPersonnage(int numero);
 char ** obtenirNomsAttaquesPersonnage(int numero);
 
+void debutDuTour();
+int finDuTour();
+void personnageSuivant();
+char * joueurVictorieux();
+
 void testControlleurConsole();
 #endif // CONTROLEUR_H
 

src/partie.c

@@ -11,6 +11,7 @@
 #include "joueur.h"
 #include "case.h"
 #include "personnage.h"
+#include "classe.h"
 
 /*!
  * \fn Partie * initPartie()
@@ -121,15 +122,29 @@ int removeParticipant(Partie * p, Joueur * j){
     return deleteNodeJoueurFromList(p->participants,j);
 }
 
+  /*!
+ * \fn void debutTour(Partie * p)
+ * \brief La fonction effectue les opérations de début de Tour du Joueur actuel.
+ *
+ * \param Un pointeur vers la Partie où appliquer les changements.
+ */
+ void debutTour(Partie * p){
+    int i,mana,manaMAX;
+    for(i=0;i<TAILLE_MAX_GROUPE;i++){
+        setPD(getPersonnage(getCurrentJoueur(getListJoueur(p)),i),getPDMax(getClasse(getPersonnage(getCurrentJoueur(getListJoueur(p)),i))));
+        manaMAX = getManaMax(getClasse(getPersonnage(getCurrentJoueur(getListJoueur(p)),i)));
+        mana = get_mana(getPersonnage(getCurrentJoueur(getListJoueur(p)),i));
+        setMana(getPersonnage(getCurrentJoueur(getListJoueur(p)),i),(mana+(0.1*manaMAX)));
+    }
+ }
    /*!
  * \fn int finTour(Partie * p)
  * \brief La fonction effectue les operations de fin de tour.
  *        On teste si un joueur a gagne la partie.
  *        Le curseur de participant est deplace sur le joueur suivant.
- *        On pourra ajouter d'autre operations de fin de tour dans les prochaines versions.
  *
  * \param La Partie p a a modifier.
- * \return 1 si un Joueur est victorieux, 0 sinon
+ * \return 1 si un Joueur est victorieux, 0 sinon.
  */
 int finTour(Partie * p){
     if(!victoire(p)){
@@ -139,10 +154,12 @@ int finTour(Partie * p){
         }
         else{
             setOnFirstJoueur(p->participants);
+            augmenterNbTour(p);
             return 0;
         }
     }
     else{
+        setOnFirstJoueur(getListJoueur(p));
         return 1;
     }
 }

src/partie.h

@@ -19,7 +19,7 @@ void augmenterNbTour(Partie * p);
 int addParticipant(Partie * p, Joueur * j);
 int removeParticipant(Partie * p, Joueur * j);
 
-void debutTour(Partie * p, Joueur * j);
+void debutTour(Partie * p);
 int finTour(Partie * p);
 
 int isTurn(Partie * p, Joueur * j);

src/personnage.c

@@ -4,6 +4,7 @@
 #include "case.h"
 #include "personnage.h"
 #include "deplacements.h"
+#include "classe.h"
 
 /*!
 * \file personnage.c
@@ -127,7 +128,7 @@ void setPosition(Personnage * p, Case * c){
 }
 
 /*!
- * \fn Classe * get_PV(Personnage *p)
+ * \fn int * get_PV(Personnage *p)
  * \brief La fonction renvoie les points de vie d'un personnage.
  *
  * \param Un personnage.
@@ -138,7 +139,7 @@ int get_PV(Personnage *p){
 }
 
 /*!
- * \fn Classe * get_mana(Personnage *p)
+ * \fn int * get_mana(Personnage *p)
  * \brief La fonction renvoie les points de mana d'un personnage.
  *
  * \param Un personnage.
@@ -149,7 +150,7 @@ int get_mana(Personnage *p){
 }
 
 /*!
- * \fn Classe * get_PD(Personnage *p)
+ * \fn int * get_PD(Personnage *p)
  * \brief La fonction renvoie les points de vie d'un personnage.
  *
  * \param Un personnage.
@@ -159,6 +160,60 @@ int get_PD(Personnage *p){
     return p->points_deplacement;
 }
 
+/*!
+ * \fn void setPV(Personnage * p, int n)
+ * \brief La fonction modifie les points de vie d'un personnage si n est infrieur au PV max de la Classe.
+ *
+ * \param Un personnage, un entier reprsentant les nouveaux PV du personnage.
+ */
+void setPV(Personnage * p, int n){
+    if((n<=getPVMax(getClasse(p)))&&(n>=0)){
+        p->PV=n;
+    }
+    else if(n<0){
+        p->PV=0;
+    }
+    else{
+        p->PV=getPVMax(getClasse(p));
+    }
+}
+
+/*!
+ * \fn int * get_PD(Personnage *p, int n)
+ * \brief La fonction modifie le mana d'un personnagen est infrieur au mana max de la Classe.
+ *
+ * \param Un personnage.
+ */
+void setMana(Personnage * p, int n){
+    if((n<=getManaMax(getClasse(p)))&&(n>=0)){
+        p->mana=n;
+    }
+    else if(n<0){
+        p->mana=0;
+    }
+    else{
+        p->mana=getManaMax(getClasse(p));
+    }
+}
+
+/*!
+ * \fn int * get_PD(Personnage *p, int n)
+ * \brief La fonction modifie les points de dplacement d'un personnage n est infrieur au PD max de la Classe.
+ *
+ * \param Un personnage.
+ */
+void setPD(Personnage * p, int n){
+    if((n<=getPDMax(getClasse(p)))&&(n>=0)){
+        p->points_deplacement=n;
+    }
+    else if(n<0){
+        p->points_deplacement=0;
+    }
+    else{
+        p->points_deplacement=getPDMax(getClasse(p));
+    }
+}
+
 /* Cette fonction ne fonctionne plus, il faut une fonction qui accede aux effets.
 boolean est_paralyse(Personnage *p){
     return p->paralyse;

src/personnage.h

@@ -28,6 +28,10 @@ int get_PD(Personnage *p);
 
 int get_mana(Personnage *p);
 
+void setPV(Personnage * p, int n);
+void setMana(Personnage * p, int n);
+void setPD(Personnage * p, int n);
+
 Classe * getClasse(Personnage *p);
 
 char * getNomPersonnage(Personnage * p);