fmt

includes/Butin.hpp

@@ -17,8 +17,8 @@ class Butin {
   Joueur &joueurCourant;
 
 public:
-  Butin(Joueur &joueur1, Joueur &joueur2);          // constructor
+  Butin(Joueur &joueur1, Joueur &joueur2); // constructor
-  virtual ~Butin(); // destructor
+  virtual ~Butin();                        // destructor
 
   Butin(const Butin &);                  // copy constructor
   const Butin &operator=(const Butin &); // copy assignement

includes/Dames.hpp

@@ -1,7 +1,6 @@
 #pragma once
 
 #include <iostream>
-#include <ctime>
 
 #include "../includes/Joueur.hpp"
 #include "../includes/Plateau.hpp"
@@ -25,7 +24,8 @@ public:
   const Dames &operator=(const Dames &); // copy assignement
 
   // Vérifie si une prise est possible pour une pièce donnée
-  //J'ai des erreurs depuis que j'ai voulu faire cette fonction et je comprends pas pourquoi
+  // J'ai des erreurs depuis que j'ai voulu faire cette fonction et je comprends
+  // pas pourquoi
   bool prisePossible(Piece *piece);
 
   // Fonction d'initialisation du jeu

includes/Joueur.hpp

@@ -29,7 +29,7 @@ public:
   const std::vector<Piece *> getPieces() const { return pieces; }
 
   // Getter pour le nom du joueur
-  const std::string& getNom() const { return nom; }
+  const std::string &getNom() const { return nom; }
 
   // Fonction qui supprime une pièce de la liste de pièces du joueur
 };

includes/PieceDames.hpp

@@ -5,6 +5,7 @@
 class PieceDames : public Piece {
   // True si la piece est une dame
   bool dame;
+
 public:
   PieceDames(std::string categorie);
   virtual ~PieceDames();

includes/PieceSafari.hpp

@@ -6,4 +6,4 @@ class PieceSafari : public Piece {
 public:
   PieceSafari(std::string categorie);
   virtual ~PieceSafari();
-};
+};

includes/Plateau.hpp

@@ -7,6 +7,7 @@ class Plateau {
 
   // Taille du plateau
   int taille;
+
 protected:
   // Tableau représentant le plateau de jeu
   Piece ***plateau;

includes/PlateauButin.hpp

@@ -2,12 +2,11 @@
 
 #include "Plateau.hpp"
 
-
 class PlateauButin : public Plateau {
 public:
   PlateauButin(int taille);
   virtual ~PlateauButin();
 
-    // Initialise le plateau du Butin
+  // Initialise le plateau du Butin
   void initialiserPlateau(Joueur &j1, Joueur &j2) override;
-};
+};

includes/PlateauSafari.hpp

@@ -2,11 +2,8 @@
 
 #include "Plateau.hpp"
 
-
 class PlateauSafari : public Plateau {
 public:
   PlateauSafari(int taille);
   virtual ~PlateauSafari();
-
+};
-   
-};

includes/Safari.hpp

@@ -3,8 +3,8 @@
 #include <iostream>
 
 #include "../includes/Joueur.hpp"
-#include "../includes/PlateauSafari.hpp"
 #include "../includes/PieceSafari.hpp"
+#include "../includes/PlateauSafari.hpp"
 
 class Safari {
   friend std::ostream &operator<<(std::ostream &, const Safari &);
@@ -12,7 +12,7 @@ class Safari {
   // Plateau de jeu
   PlateauSafari plateau;
 
-  //Barrières
+  // Barrières
   std::vector<PieceSafari *> barrieres;
 
   // Joueurs
@@ -22,8 +22,8 @@ class Safari {
   Joueur &joueurCourant;
 
 public:
-  Safari(Joueur &joueur1, Joueur &joueur2, Joueur &joueur3);          // constructor
+  Safari(Joueur &joueur1, Joueur &joueur2, Joueur &joueur3); // constructor
-  virtual ~Safari(); // destructor
+  virtual ~Safari();                                         // destructor
 
   Safari(const Safari &);                  // copy constructor
   const Safari &operator=(const Safari &); // copy assignement
@@ -31,4 +31,3 @@ public:
   // Fonction d'initialisation du jeu
   void choixAnimal(std::string animal);
 };
-

src/Butin.cpp

@@ -1,17 +1,17 @@
 #include "../includes/Butin.hpp"
 
-Butin::Butin(Joueur &j1, Joueur &j2) 
+Butin::Butin(Joueur &j1, Joueur &j2)
-: plateau(PlateauButin(8)), joueur1{j1}, joueur2{j2}, joueurCourant{j1}{ 
+    : plateau(PlateauButin(8)), joueur1{j1}, joueur2{j2}, joueurCourant{j1} {
   plateau.initialiserPlateau(j1, j2);
 }
 
 Butin::~Butin() {}
 
-Butin::Butin(const Butin &src) 
+Butin::Butin(const Butin &src)
     : plateau(PlateauButin(8)), joueur1{src.joueur1}, joueur2{src.joueur2},
       joueurCourant{src.joueurCourant} {
   plateau.initialiserPlateau(joueur1, joueur2);
-      }
+}
 
 const Butin &Butin::operator=(const Butin &src) {
   if (this == &src) {

src/Dames.cpp

@@ -1,16 +1,19 @@
 #include "../includes/Dames.hpp"
-#include "Dames.hpp"
 
 Dames::Dames(Joueur &j1, Joueur &j2)
     : plateau(Plateau(10)), joueur1(j1), joueur2(j2), joueurCourant(j1) {
-  std::srand(static_cast<unsigned int>(std::time(0)));
+  std::srand(static_cast<unsigned int>(time(0)));
   int r = std::rand() % 2;
-  if(r==0){
+  if (r == 0) {
     joueurCourant = j1;
-    std::cout << j1.getNom() << " jouera avec les pièces blanches et commencera la partie." << std::endl;
+    std::cout << j1.getNom()
-  }else{
+              << " jouera avec les pièces blanches et commencera la partie."
+              << std::endl;
+  } else {
     joueurCourant = j2;
-    std::cout << j2.getNom() << " jouera avec les pièces blanches et commencera la partie." << std::endl;
+    std::cout << j2.getNom()
+              << " jouera avec les pièces blanches et commencera la partie."
+              << std::endl;
   }
   plateau.initialiserPlateau(j1, j2);
 }
@@ -31,10 +34,10 @@ const Dames &Dames::operator=(const Dames &src) {
   return *this;
 }
 
-//A continuer
+// A continuer
-bool Dames::prisePossible(Piece *piece){
+bool Dames::prisePossible(Piece *piece) {
-  if(!piece->dame)
+  /* if (!piece->dame)
-    if()
+    if () */
 
   return false;
 }

src/PieceButin.cpp

@@ -2,9 +2,15 @@
 
 PieceButin::PieceButin(const std::string cat) : Piece(cat) {
   std::cout << "pièce - " << cat << "\n";
-  if(cat=="jaune") this->points=1;
+  if (cat == "jaune") {
-  if(cat=="rouge") this->points=2;
+    this->points = 1;
-  if(cat=="noire") this->points=3;
+  }
+  if (cat == "rouge") {
+    this->points = 2;
+  }
+  if (cat == "noire") {
+    this->points = 3;
+  }
 }
 
 PieceButin::~PieceButin() {}

src/PlateauButin.cpp

@@ -8,25 +8,32 @@ PlateauButin::PlateauButin(int t) : Plateau(t) {}
 
 PlateauButin::~PlateauButin() {}
 
+// On utilise pas les arguments ici, à voir si il faut vraiment faire un
+// override
+void PlateauButin::initialiserPlateau(Joueur &j1, Joueur &j2) {
+  // Vecteur de toutes les pièeces du jeu
+  std::vector<PieceButin> pieces;
+  for (int i = 0; i < 34; i++) {
+    pieces.push_back(PieceButin("jaune"));
+  }
+  for (int i = 0; i < 20; i++) {
+    pieces.push_back(PieceButin("rouge"));
+  }
+  for (int i = 0; i < 10; i++) {
+    pieces.push_back(PieceButin("noire"));
+  }
 
-// On utilise pas les arguments ici, à voir si il faut vraiment faire un override
+  // Mélange le vecteur de pièces (j'ai jamais utilisé ça pour randomiser faudra
-void PlateauButin::initialiserPlateau(Joueur &j1, Joueur &j2){
+  // que je test que ça fonctionne bien)
-    // Vecteur de toutes les pièeces du jeu
+  std::random_device rd;
-    std::vector<PieceButin> pieces;
+  std::mt19937 g(rd());
-    for(int i=0;i<34;i++) pieces.push_back(PieceButin("jaune"));
+  std::shuffle(pieces.begin(), pieces.end(), g);
-    for(int i=0;i<20;i++) pieces.push_back(PieceButin("rouge"));
-    for(int i=0;i<10;i++) pieces.push_back(PieceButin("noire"));
 
-    // Mélange le vecteur de pièces (j'ai jamais utilisé ça pour randomiser faudra que je test que ça fonctionne bien)
+  // Place toutes les pieces sur le plateau
-    std::random_device rd;
+  int index = 0;
-    std::mt19937 g(rd());
+  for (int i = 0; i < 8; i++) {
-    std::shuffle(pieces.begin(), pieces.end(), g);
+    for (int j = 0; j < 8; j++) {
-
+      plateau[i][j] = &pieces[index++];
-    // Place toutes les pieces sur le plateau
-    int index=0;
-    for(int i=0;i<8;i++){
-        for(int j=0;j<8;j++){
-            plateau[i][j] = &pieces[index++];
-        }
     }
-}
+  }
+}

src/Safari.cpp

@@ -1,19 +1,22 @@
 #include "../includes/Safari.hpp"
 
-Safari::Safari(Joueur &j1, Joueur &j2, Joueur &j3) 
+Safari::Safari(Joueur &j1, Joueur &j2, Joueur &j3)
-: plateau(PlateauSafari(8)), joueur1{j1}, joueur2{j2}, joueur3{j3}, joueurCourant{j1}{
+    : plateau(PlateauSafari(8)), joueur1{j1}, joueur2{j2}, joueur3{j3},
-  for(int i=0;i<50;i++)
+      joueurCourant{j1} {
+  for (int i = 0; i < 50; i++) {
     barrieres.push_back(new PieceSafari("barriere"));
+  }
 }
 
 Safari::~Safari() {}
 
 Safari::Safari(const Safari &src)
-  : plateau(PlateauSafari(8)), joueur1{src.joueur1}, joueur2{src.joueur2}, joueur3{src.joueur3},
+    : plateau(PlateauSafari(8)), joueur1{src.joueur1}, joueur2{src.joueur2},
-      joueurCourant{src.joueurCourant} {
+      joueur3{src.joueur3}, joueurCourant{src.joueurCourant} {
-        for(int i=0;i<50;i++)
+  for (int i = 0; i < 50; i++) {
-          barrieres.push_back(new PieceSafari("barriere"));
+    barrieres.push_back(new PieceSafari("barriere"));
-      }
+  }
+}
 
 const Safari &Safari::operator=(const Safari &src) {
   if (this == &src) {
@@ -23,10 +26,13 @@ const Safari &Safari::operator=(const Safari &src) {
   return *this;
 }
 
-void Safari::choixAnimal(std::string animal){
+void Safari::choixAnimal(std::string animal) {
-  if(animal!="éléphant" || animal!="rhinocéros" || animal!="lion") 
+  if (animal != "éléphant" || animal != "rhinocéros" || animal != "lion") {
     throw std::invalid_argument("Animal non valide");
-  if(joueurCourant.getPieces().empty())
+  }
-    for(int i=0;i<3;i++)
+  if (joueurCourant.getPieces().empty()) {
+    for (int i = 0; i < 3; i++) {
       joueurCourant.ajoutPiece(new PieceSafari(animal));
-}
+    }
+  }
+}