butin now done:

* calcul points butin
* players CANT be const im crazy
* plateau cant return list of pieces
* joueurCourant is a pointer to a real player
* always show score but final score take in account the malus

includes/Butin/Butin.hpp

@@ -12,7 +12,7 @@ class Butin : private Jeu {
   PlateauButin plateau;
 
   // Joueurs
-  const Joueur &joueur2;
+  Joueur &joueur2;
 
   // Etape du jeu, pour savoir où on en est
   enum Etape {
@@ -34,6 +34,9 @@ class Butin : private Jeu {
   // Message à chaque tour du joueur
   const std::string msgTonTour() const;
 
+  // Message affichant le nombre de points
+  const std::string msgPoints(const std::pair<int, int> points) const;
+
   // Position curseur
   const std::pair<const int, const int> getPosition() const override;
 
@@ -41,8 +44,8 @@ class Butin : private Jeu {
   void changerJoueurCourant();
 
 public:
-  Butin(const Joueur &joueur1, const Joueur &joueur2); // constructor
+  Butin(Joueur &joueur1, Joueur &joueur2); // constructor
-  virtual ~Butin();                                    // destructor
+  virtual ~Butin();                        // destructor
 
   // Fonction d'initialisation du jeu
   void init() override;
@@ -52,4 +55,7 @@ public:
 
   // Fonction d'évènement
   void event(const int x, const int y) override;
+
+  // Renvoie le nombre de points des joueurs 1 et 2
+  std::pair<int, int> calculpoints(const bool finPartie = false) const;
 };

includes/Jeu.hpp

@@ -4,8 +4,8 @@
 
 struct Jeu {
   // Le joueur 1 est toujours celui qui commence
-  Jeu(const Joueur &j1); // constructor
+  Jeu(Joueur &j1); // constructor
-  virtual ~Jeu();        // destructor
+  virtual ~Jeu();  // destructor
 
   // Fonction d'initialisation d'un jeu
   virtual void init() = 0;
@@ -18,8 +18,8 @@ struct Jeu {
 
 protected:
   // Joueurs, au moins un joueur
-  const Joueur &joueur1;
+  Joueur &joueur1;
-  Joueur joueurCourant;
+  Joueur *joueurCourant;
 
   // Position du dernier clic du curseur sur l'écran
   std::pair<int, int> posCurseur;

includes/Plateau.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "../includes/Piece.hpp"
+#include <vector>
 
 class Plateau {
   friend std::ostream &operator<<(std::ostream &, const Plateau &);
@@ -46,4 +47,7 @@ public:
 
   // Change la pièce selectionnée
   void modifierSelection(const int x, const int y);
+
+  // Renvoie la liste des pièces du plateau
+  std::vector<const Piece *> getPieces() const;
 };

includes/Safari/Safari.hpp

@@ -18,9 +18,9 @@ class Safari : private Jeu {
   std::vector<PieceSafari *> barrieres;
 
 public:
-  Safari(const Joueur &joueur1, const Joueur &joueur2,
+  Safari(Joueur &joueur1, Joueur &joueur2,
-         const Joueur *joueur3 = nullptr); // constructor
+         Joueur *joueur3 = nullptr); // constructor
-  virtual ~Safari();                       // destructor
+  virtual ~Safari();                 // destructor
 
   // Fonction d'initialisation du jeu
   void init() override;

src/Butin/Butin.cpp

@@ -2,7 +2,7 @@
 #include "../../includes/Butin/PieceButin.hpp"
 #include "../../includes/Ecran.hpp"
 
-Butin::Butin(const Joueur &j1, const Joueur &j2)
+Butin::Butin(Joueur &j1, Joueur &j2)
     : Jeu(j1), plateau(PlateauButin()), joueur2{j2} {
   init();
 }
@@ -20,7 +20,7 @@ const PieceButin *Butin::getPiece(const int x, const int y) const {
 }
 
 const std::string Butin::msgPieceJaune(const bool erreur) const {
-  std::string res = "Joueur " + std::to_string(joueurCourant.getNum()) +
+  std::string res = "Joueur " + std::to_string(joueurCourant->getNum()) +
                     ", retirez une piece jaune en cliquant dessus.";
 
   if (erreur) {
@@ -31,8 +31,13 @@ const std::string Butin::msgPieceJaune(const bool erreur) const {
 }
 
 const std::string Butin::msgTonTour() const {
-  return "Joueur " + std::to_string(joueurCourant.getNum()) +
+  return "Joueur " + std::to_string(joueurCourant->getNum()) +
-         ", c'est votre tour.";
+         ", c'est votre tour. " + msgPoints(calculpoints());
+}
+
+const std::string Butin::msgPoints(const std::pair<int, int> points) const {
+  return "J1 : " + std::to_string(points.first) + " vs " +
+         std::to_string(points.second) + " : J2";
 }
 
 void Butin::init() {
@@ -131,15 +136,13 @@ void Butin::event(const int x, const int y) {
           plateau.modifierPlateau(pos.first, pos.second, nullptr);
 
           // Ajoute le point au joueur
-          joueurCourant.ajoutPiece(gain);
+          joueurCourant->ajoutPiece(gain);
         }
 
         // Vérification partie terminé = si plus aucun coup n'est possible
         if (!plateau.coupsPossible()) {
           etape = Fini;
-          Ecran::printMessage("Partie fini ! Joueur " +
+          Ecran::printMessage("Partie fini ! " + msgPoints(calculpoints(true)));
-                              std::to_string(joueurCourant.getNum()) +
-                              " remporte la victoire !");
         } else {
           // On donne la main à l'adversaire
           changerJoueurCourant();
@@ -171,9 +174,46 @@ const std::pair<const int, const int> Butin::getPosition() const {
 }
 
 void Butin::changerJoueurCourant() {
-  if (joueurCourant.getNum() == joueur1.getNum()) {
+  if (joueurCourant->getNum() == joueur1.getNum()) {
-    joueurCourant = joueur2;
+    joueurCourant = &joueur2;
   } else {
-    joueurCourant = joueur1;
+    joueurCourant = &joueur1;
   }
 }
+
+std::pair<int, int> Butin::calculpoints(const bool end) const {
+  // Nombre de points des joueurs
+  int j1 = 0, j2 = 0;
+  for (const Piece *it : joueur1.getPieces()) {
+    j1 += dynamic_cast<const PieceButin *>(it)->getPoints();
+  }
+  for (const Piece *it : joueur2.getPieces()) {
+    j2 += dynamic_cast<const PieceButin *>(it)->getPoints();
+  }
+
+  // Si c'est le calcul des points de la fin de partie
+  if (end) {
+    // Nombre de points sur le plateau restant
+    int malus = 0;
+    for (const Piece *it : plateau.getPieces()) {
+      malus += dynamic_cast<const PieceButin *>(it)->getPoints();
+    }
+
+    // C'est le joueur qui a joué le dernier coup qui reçoit le malus
+    if (joueurCourant->getNum() == joueur1.getNum()) {
+      // Joueur 1 reçoit le malus
+      j1 -= malus;
+      if (j1 < 0) {
+        j1 = 0;
+      }
+    } else {
+      // Joueur 2 reçoit le malus
+      j2 -= malus;
+      if (j2 < 0) {
+        j2 = 0;
+      }
+    }
+  }
+
+  return std::make_pair(j1, j2);
+}

src/Dames/Dames.cpp

@@ -6,11 +6,11 @@ Dames::Dames(Joueur &j1, Joueur &j2)
   std::srand(static_cast<unsigned int>(time(0)));
   const int r = std::rand() % 2;
   if (r == 0) {
-    joueurCourant = j1;
+    joueurCourant = &j1;
   } else {
-    joueurCourant = j2;
+    joueurCourant = &j2;
   }
-  std::cout << "Joueur " << joueurCourant.getNum()
+  std::cout << "Joueur " << joueurCourant->getNum()
             << " jouera avec les pièces blanches et commencera la partie."
             << std::endl;
 
@@ -60,7 +60,7 @@ bool Dames::prisePossible(Joueur &joueur) const {
       throw std::runtime_error("Cette pièce est.. étrange.");
     }
     if (!p->getDame()) {
-      //if(plateau.getPiece(pos.first-1, pos.second) == nullptr)
+      // if(plateau.getPiece(pos.first-1, pos.second) == nullptr)
     }
   }
   return false;

src/Jeu.cpp

@@ -1,5 +1,7 @@
 #include "../includes/Jeu.hpp"
 
-Jeu::Jeu(const Joueur &j1) : joueur1(j1), joueurCourant(Joueur(j1)) {}
+Jeu::Jeu(Joueur &j1) : joueur1(j1) {
+  joueurCourant = &j1;
+}
 
 Jeu::~Jeu() {}

src/Joueur.cpp

@@ -15,6 +15,13 @@ const Joueur &Joueur::operator=(const Joueur &src) {
     return *this;
   }
 
+  std::cout << "internally :\n";
+  std::cout << "id : " << id << "\n";
+  std::cout << "pieces(len) : " << pieces.size() << "\n";
+  std::cout << "\nwill be replaced by :\n";
+  std::cout << "id : " << src.id << "\n";
+  std::cout << "pieces(len) : " << src.pieces.size() << "\n";
+
   id = src.id;
   pieces = src.pieces;
 

src/Plateau.cpp

@@ -176,3 +176,16 @@ const std::pair<const int, const int> Plateau::moveSelection(const int x,
 
   return ancienneCoordonnees;
 }
+
+std::vector<const Piece *> Plateau::getPieces() const {
+  std::vector<const Piece *> pieces;
+  for (int i = 0; i < taille; i++) {
+    for (int j = 0; j < taille; j++) {
+      if (plateau[i][j]) {
+        pieces.push_back(plateau[i][j]);
+      }
+    }
+  }
+
+  return pieces;
+}

src/Safari/Safari.cpp

@@ -3,7 +3,7 @@
 /* Contrairement aux autres jeux ici on donne des pointeurs et pas des
  * références vu que j3 peut ne pas exister (default to nullptr)
  * Je sais pas trop si c'est une bonne idée, à méditer */
-Safari::Safari(const Joueur &j1, const Joueur &j2, const Joueur *j3)
+Safari::Safari(Joueur &j1, Joueur &j2, Joueur *j3)
     : Jeu(j1), plateau(PlateauSafari()), joueur2{j2}, joueur3{j3} {
   for (int i = 0; i < 50; i++) {
     // TODO: Les pièces ont des positions invalides, il faut penser à les
@@ -49,10 +49,10 @@ void Safari::choixAnimal(const PieceSafari::Categorie animal) {
     throw std::invalid_argument("Animal non valide");
   }
 
-  if (joueurCourant.getPieces().empty()) {
+  if (joueurCourant->getPieces().empty()) {
     for (int i = 0; i < 3; i++) {
       // Position invalide en attendant d'être ajouté au plateau de jeu
-      joueurCourant.ajoutPiece(new PieceSafari(animal, -1, -1));
+      joueurCourant->ajoutPiece(new PieceSafari(animal, -1, -1));
     }
   }
 }

src/main.cpp

@@ -35,7 +35,7 @@ int main(int argc, char const *argv[]) {
     }
 
     else if (arg.compare("butin") == 0) {
-      const Joueur j2(2);
+      Joueur j2(2);
 
       Butin b(j1, j2);
       b.init();
@@ -50,7 +50,7 @@ int main(int argc, char const *argv[]) {
     }
 
     else if (arg.compare("safari") == 0) {
-      const Joueur j2(2);
+      Joueur j2(2);
       Joueur *j3 = nullptr;
       // TODO: demander à l'utilisateur un 3e joueur
       {}