From bf74632047438d3707b6e947e956de60e3c66574 Mon Sep 17 00:00:00 2001
From: Mylloon <kennel.anri@tutanota.com>
Date: Thu, 14 Dec 2023 17:09:27 +0100
Subject: [PATCH] update * add const identifiers * expose category for children
 * documentation * helper for ignoring arguments * reduce useless imports *
 use enum for categories * refactor Dames instanciation

---
 includes/Butin/Butin.hpp        |  8 +++-----
 includes/Butin/PieceButin.hpp   | 16 ++++++++++++----
 includes/Dames/Dames.hpp        | 11 ++++++-----
 includes/Dames/PieceDames.hpp   | 15 +++++++++++----
 includes/Ecran.hpp              |  2 +-
 includes/Mouvement.hpp          |  4 ++++
 includes/Piece.hpp              |  1 +
 includes/Plateau.hpp            |  8 ++++----
 includes/Safari/PieceSafari.hpp | 15 ++++++++++++---
 includes/Safari/Safari.hpp      | 11 +++++++----
 includes/utils.hpp              |  4 ++++
 src/Butin/Butin.cpp             |  6 ++++--
 src/Butin/PieceButin.cpp        | 27 +++++++++++++++++----------
 src/Butin/PlateauButin.cpp      | 12 +++++++-----
 src/Dames/Dames.cpp             | 20 ++++++++++----------
 src/Dames/PieceDames.cpp        | 17 +++++++++++++++--
 src/Dames/PlateauDames.cpp      |  4 ++--
 src/Ecran.cpp                   |  2 +-
 src/Plateau.cpp                 |  7 +++----
 src/Safari/PieceSafari.cpp      | 20 ++++++++++++++++++--
 src/Safari/PlateauSafari.cpp    |  3 +++
 src/Safari/Safari.cpp           | 14 ++++++++++----
 22 files changed, 155 insertions(+), 72 deletions(-)
 create mode 100644 includes/utils.hpp

diff --git a/includes/Butin/Butin.hpp b/includes/Butin/Butin.hpp
index fa3d559..749a832 100644
--- a/includes/Butin/Butin.hpp
+++ b/includes/Butin/Butin.hpp
@@ -1,8 +1,5 @@
 #pragma once
 
-#include <iostream>
-
-#include "../Joueur.hpp"
 #include "PlateauButin.hpp"
 
 class Butin {
@@ -22,6 +19,7 @@ public:
 
   Butin(const Butin &);                  // copy constructor
   const Butin &operator=(const Butin &); // copy assignement
-};
 
-// Fonction d'initialisation du jeu
+  // Fonction d'initialisation du jeu
+  void init();
+};
diff --git a/includes/Butin/PieceButin.hpp b/includes/Butin/PieceButin.hpp
index d2a4307..b6ec275 100644
--- a/includes/Butin/PieceButin.hpp
+++ b/includes/Butin/PieceButin.hpp
@@ -2,10 +2,18 @@
 
 #include "../Piece.hpp"
 
-class PieceButin : public Piece {
+struct PieceButin : public Piece {
+  enum Categorie {
+    Jaune = 1,
+    Rouge = 2,
+    Noire = 3,
+  };
+
+  PieceButin(const enum Categorie);
+  virtual ~PieceButin();
+
+private:
   int points;
 
-public:
-  PieceButin(std::string categorie);
-  virtual ~PieceButin();
+  std::string to_string(const enum Categorie) const;
 };
diff --git a/includes/Dames/Dames.hpp b/includes/Dames/Dames.hpp
index 98ba149..09f5ebb 100644
--- a/includes/Dames/Dames.hpp
+++ b/includes/Dames/Dames.hpp
@@ -23,10 +23,11 @@ public:
   Dames(const Dames &);                  // copy constructor
   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
-  bool prisePossible(Piece *piece);
-
   // Fonction d'initialisation du jeu
+  void init();
+
+  // Vérifie si une prise est possible pour une pièce donnée
+  // TODO: J'ai des erreurs depuis que j'ai voulu faire cette fonction
+  // et je comprends pas pourquoi
+  bool prisePossible(const Piece *piece) const;
 };
diff --git a/includes/Dames/PieceDames.hpp b/includes/Dames/PieceDames.hpp
index 68d37ba..bb2c8d5 100644
--- a/includes/Dames/PieceDames.hpp
+++ b/includes/Dames/PieceDames.hpp
@@ -2,11 +2,18 @@
 
 #include "../Piece.hpp"
 
-class PieceDames : public Piece {
+struct PieceDames : public Piece {
+  enum Categorie {
+    Blanche,
+    Noire,
+  };
+
+  PieceDames(const enum Categorie);
+  virtual ~PieceDames();
+
+private:
   // True si la piece est une dame
   bool dame;
 
-public:
-  PieceDames(std::string categorie);
-  virtual ~PieceDames();
+  std::string to_string(const enum Categorie) const;
 };
diff --git a/includes/Ecran.hpp b/includes/Ecran.hpp
index 15f82b5..ee139df 100644
--- a/includes/Ecran.hpp
+++ b/includes/Ecran.hpp
@@ -11,5 +11,5 @@ struct Ecran {
         const std::string name = "Projet"); // constructor
   ~Ecran();                                 // destructor
 
-  void afficher(std::function<void()> f = {[]() {}});
+  void afficher(const std::function<void()> f = {[]() {}}) const;
 };
diff --git a/includes/Mouvement.hpp b/includes/Mouvement.hpp
index 67daec1..321af7d 100644
--- a/includes/Mouvement.hpp
+++ b/includes/Mouvement.hpp
@@ -2,6 +2,10 @@
 
 #include <iostream>
 
+/* Est ce que cette classe c'est pas mieux si on la déplace à l'intérieur de la
+ * classe Piece qui aurait une méthode "moveTo" par exemple et qui se
+ * déplacerait vers une case ? */
+
 class Mouvement {
   friend std::ostream &operator<<(std::ostream &, const Mouvement &);
 
diff --git a/includes/Piece.hpp b/includes/Piece.hpp
index 96d283d..8ba7a13 100644
--- a/includes/Piece.hpp
+++ b/includes/Piece.hpp
@@ -5,6 +5,7 @@
 class Piece {
   friend std::ostream &operator<<(std::ostream &, const Piece &);
 
+protected:
   // Couleur de la pièce ou type d'animal pour Safari par ex
   std::string categorie;
 
diff --git a/includes/Plateau.hpp b/includes/Plateau.hpp
index 99322a4..9c1d735 100644
--- a/includes/Plateau.hpp
+++ b/includes/Plateau.hpp
@@ -13,8 +13,8 @@ protected:
   int taille;
 
 public:
-  Plateau(int taille); // constructor
-  virtual ~Plateau();  // destructor
+  Plateau(const int taille); // constructor
+  virtual ~Plateau();        // destructor
 
   // Fonction pour initialiser le plateau (selon le jeu)
   // Seulement deux joueurs pour le jeu de dame uniquement, je suis pas sûre de
@@ -22,8 +22,8 @@ public:
   virtual void initialiserPlateau(Joueur &j1, Joueur &j2) = 0;
 
   // Fonction pour afficher le plateau (selon le jeu)
-  void afficherPlateau(const bool debug = false);
+  void afficherPlateau(const bool debug = false) const;
 
   // Fonction pour modifier le plateau
-  void modifierPlateau(int x, int y, Piece *piece);
+  void modifierPlateau(const int x, const int y, Piece *piece) const;
 };
diff --git a/includes/Safari/PieceSafari.hpp b/includes/Safari/PieceSafari.hpp
index 912e80f..c073957 100644
--- a/includes/Safari/PieceSafari.hpp
+++ b/includes/Safari/PieceSafari.hpp
@@ -2,8 +2,17 @@
 
 #include "../Piece.hpp"
 
-class PieceSafari : public Piece {
-public:
-  PieceSafari(std::string categorie);
+struct PieceSafari : public Piece {
+  enum Categorie {
+    Barriere,
+    Elephant,
+    Rhinoceros,
+    Lion,
+  };
+
+  PieceSafari(const enum Categorie);
   virtual ~PieceSafari();
+
+private:
+  std::string to_string(const enum Categorie) const;
 };
diff --git a/includes/Safari/Safari.hpp b/includes/Safari/Safari.hpp
index 736afe2..8584dad 100644
--- a/includes/Safari/Safari.hpp
+++ b/includes/Safari/Safari.hpp
@@ -12,15 +12,15 @@ class Safari {
   // Plateau de jeu
   PlateauSafari plateau;
 
-  // Barrières
-  std::vector<PieceSafari *> barrieres;
-
   // Joueurs
   Joueur &joueur1;
   Joueur &joueur2;
   Joueur &joueur3;
   Joueur &joueurCourant;
 
+  // Barrières
+  std::vector<PieceSafari *> barrieres;
+
 public:
   Safari(Joueur &joueur1, Joueur &joueur2, Joueur &joueur3); // constructor
   virtual ~Safari();                                         // destructor
@@ -29,5 +29,8 @@ public:
   const Safari &operator=(const Safari &); // copy assignement
 
   // Fonction d'initialisation du jeu
-  void choixAnimal(std::string animal);
+  void init();
+
+  // Fonction d'initialisation du jeu
+  void choixAnimal(const PieceSafari::Categorie animal) const;
 };
diff --git a/includes/utils.hpp b/includes/utils.hpp
new file mode 100644
index 0000000..39b42f0
--- /dev/null
+++ b/includes/utils.hpp
@@ -0,0 +1,4 @@
+#pragma once
+
+template <typename T>
+void ignore(T &&) {}
diff --git a/src/Butin/Butin.cpp b/src/Butin/Butin.cpp
index 6b2e0ad..13ce5a3 100644
--- a/src/Butin/Butin.cpp
+++ b/src/Butin/Butin.cpp
@@ -2,7 +2,7 @@
 
 Butin::Butin(Joueur &j1, Joueur &j2)
     : plateau(PlateauButin()), joueur1{j1}, joueur2{j2}, joueurCourant{j1} {
-  plateau.initialiserPlateau(j1, j2);
+  init();
 }
 
 Butin::~Butin() {}
@@ -10,7 +10,7 @@ Butin::~Butin() {}
 Butin::Butin(const Butin &src)
     : plateau(PlateauButin()), joueur1{src.joueur1}, joueur2{src.joueur2},
       joueurCourant{src.joueurCourant} {
-  plateau.initialiserPlateau(joueur1, joueur2);
+  init();
 }
 
 const Butin &Butin::operator=(const Butin &src) {
@@ -20,3 +20,5 @@ const Butin &Butin::operator=(const Butin &src) {
 
   return *this;
 }
+
+void Butin::init() { plateau.initialiserPlateau(joueur1, joueur2); }
diff --git a/src/Butin/PieceButin.cpp b/src/Butin/PieceButin.cpp
index fd19348..bccd638 100644
--- a/src/Butin/PieceButin.cpp
+++ b/src/Butin/PieceButin.cpp
@@ -1,16 +1,23 @@
 #include "../../includes/Butin/PieceButin.hpp"
 
-PieceButin::PieceButin(const std::string cat) : Piece(cat) {
+PieceButin::PieceButin(const enum Categorie cat)
+    : Piece(to_string(cat)), points(cat) {
   std::cout << "pièce - " << cat << "\n";
-  if (cat == "jaune") {
-    this->points = 1;
-  }
-  if (cat == "rouge") {
-    this->points = 2;
-  }
-  if (cat == "noire") {
-    this->points = 3;
-  }
+  this->points = cat;
 }
 
 PieceButin::~PieceButin() {}
+
+std::string PieceButin::to_string(const enum Categorie cat) const {
+  switch (cat) {
+  case Jaune:
+    return "Jaune";
+  case Rouge:
+    return "Rouge";
+  case Noire:
+    return "Noire";
+
+  default:
+    exit(EXIT_FAILURE);
+  }
+}
diff --git a/src/Butin/PlateauButin.cpp b/src/Butin/PlateauButin.cpp
index 989b102..4cac33f 100644
--- a/src/Butin/PlateauButin.cpp
+++ b/src/Butin/PlateauButin.cpp
@@ -1,5 +1,6 @@
 #include "../../includes/Butin/PlateauButin.hpp"
 #include "../../includes/Butin/PieceButin.hpp"
+#include "../../includes/utils.hpp"
 
 #include <algorithm>
 #include <random>
@@ -8,19 +9,20 @@ PlateauButin::PlateauButin() : Plateau(8) {}
 
 PlateauButin::~PlateauButin() {}
 
-// On utilise pas les arguments ici, à voir si il faut vraiment faire un
-// override
 void PlateauButin::initialiserPlateau(Joueur &j1, Joueur &j2) {
+  ignore(j1);
+  ignore(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"));
+    pieces.push_back(PieceButin(PieceButin::Jaune));
   }
   for (int i = 0; i < 20; i++) {
-    pieces.push_back(PieceButin("rouge"));
+    pieces.push_back(PieceButin(PieceButin::Rouge));
   }
   for (int i = 0; i < 10; i++) {
-    pieces.push_back(PieceButin("noire"));
+    pieces.push_back(PieceButin(PieceButin::Noire));
   }
 
   // Mélange le vecteur de pièces (j'ai jamais utilisé ça pour randomiser faudra
diff --git a/src/Dames/Dames.cpp b/src/Dames/Dames.cpp
index c4acb29..4fdd6df 100644
--- a/src/Dames/Dames.cpp
+++ b/src/Dames/Dames.cpp
@@ -6,16 +6,14 @@ Dames::Dames(Joueur &j1, Joueur &j2)
   int r = std::rand() % 2;
   if (r == 0) {
     joueurCourant = j1;
-    std::cout << j1.getNom()
-              << " 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;
   }
-  plateau.initialiserPlateau(j1, j2);
+  std::cout << joueurCourant.getNom()
+            << " jouera avec les pièces blanches et commencera la partie."
+            << std::endl;
+
+  init();
 }
 
 Dames::~Dames() {}
@@ -23,7 +21,7 @@ Dames::~Dames() {}
 Dames::Dames(const Dames &src)
     : plateau(PlateauDames()), joueur1{src.joueur1}, joueur2{src.joueur2},
       joueurCourant{src.joueurCourant} {
-  plateau.initialiserPlateau(joueur1, joueur2);
+  init();
 }
 
 const Dames &Dames::operator=(const Dames &src) {
@@ -34,8 +32,10 @@ const Dames &Dames::operator=(const Dames &src) {
   return *this;
 }
 
-// A continuer
-bool Dames::prisePossible(Piece *piece) {
+void Dames::init() { plateau.initialiserPlateau(joueur1, joueur2); }
+
+// TODO: A continuer
+bool Dames::prisePossible(const Piece *piece) const {
   /* if (!piece->dame)
     if () */
 
diff --git a/src/Dames/PieceDames.cpp b/src/Dames/PieceDames.cpp
index bc93fb6..e4dd8b9 100644
--- a/src/Dames/PieceDames.cpp
+++ b/src/Dames/PieceDames.cpp
@@ -1,7 +1,20 @@
 #include "../../includes/Dames/PieceDames.hpp"
 
-PieceDames::PieceDames(const std::string cat) : Piece(cat) {
-  std::cout << "pièce - " << cat << "\n";
+PieceDames::PieceDames(const enum Categorie cat)
+    : Piece(to_string(cat)), dame(false) {
+  std::cout << "pièce - " << categorie << "\n";
 }
 
 PieceDames::~PieceDames() {}
+
+std::string PieceDames::to_string(const enum Categorie cat) const {
+  switch (cat) {
+  case Blanche:
+    return "Blanche";
+  case Noire:
+    return "Noire";
+
+  default:
+    exit(EXIT_FAILURE);
+  }
+}
diff --git a/src/Dames/PlateauDames.cpp b/src/Dames/PlateauDames.cpp
index e62cebb..78d10cd 100644
--- a/src/Dames/PlateauDames.cpp
+++ b/src/Dames/PlateauDames.cpp
@@ -9,7 +9,7 @@ void PlateauDames::initialiserPlateau(Joueur &j1, Joueur &j2) {
   for (int i = 0; i < 4; i++) {
     for (int j = 0; j < 10; j++) {
       if ((i % 2 == 0 && j % 2 == 1) || (i % 2 == 1 && j % 2 == 0)) {
-        plateau[i][j] = new PieceDames("noire");
+        plateau[i][j] = new PieceDames(PieceDames::Noire);
         j1.ajoutPiece(plateau[i][j]);
       }
     }
@@ -18,7 +18,7 @@ void PlateauDames::initialiserPlateau(Joueur &j1, Joueur &j2) {
   for (int i = 6; i < 10; i++) {
     for (int j = 0; j < 10; j++) {
       if ((i % 2 == 0 && j % 2 == 1) || (i % 2 == 1 && j % 2 == 0)) {
-        plateau[i][j] = new PieceDames("blanche");
+        plateau[i][j] = new PieceDames(PieceDames::Blanche);
         j2.ajoutPiece(plateau[i][j]);
       }
     }
diff --git a/src/Ecran.cpp b/src/Ecran.cpp
index 61ccc83..d9bf46a 100644
--- a/src/Ecran.cpp
+++ b/src/Ecran.cpp
@@ -9,7 +9,7 @@ Ecran::Ecran(const uint w, const uint h, const std::string n) {
 
 Ecran::~Ecran() {}
 
-void Ecran::afficher(std::function<void()> dessin) {
+void Ecran::afficher(const std::function<void()> dessin) const {
   while (window.isOpen()) {
     sf::Event event;
     while (window.pollEvent(event)) {
diff --git a/src/Plateau.cpp b/src/Plateau.cpp
index 3fadb4b..4b55f26 100644
--- a/src/Plateau.cpp
+++ b/src/Plateau.cpp
@@ -1,8 +1,7 @@
 #include "../includes/Plateau.hpp"
-#include "../includes/Dames/PieceDames.hpp"
 #include "../includes/Ecran.hpp"
 
-Plateau::Plateau(int t) : plateau(new Piece **[t]), taille(t) {
+Plateau::Plateau(const int t) : plateau(new Piece **[t]), taille(t) {
   // Création du plateau vide
   for (int i = 0; i < t; i++) {
     plateau[i] = new Piece *[t];
@@ -19,7 +18,7 @@ Plateau::~Plateau() {
   delete[] plateau;
 }
 
-void Plateau::afficherPlateau(const bool d) {
+void Plateau::afficherPlateau(const bool d) const {
   const float tailleCellule =
       static_cast<float>(Ecran::window.getSize().x) / taille;
 
@@ -66,7 +65,7 @@ void Plateau::afficherPlateau(const bool d) {
   }
 }
 
-void Plateau::modifierPlateau(int x, int y, Piece *piece) {
+void Plateau::modifierPlateau(const int x, const int y, Piece *piece) const {
   if (x >= 0 && x < taille && y >= 0 && y < taille) {
     plateau[x][y] = piece;
   } else {
diff --git a/src/Safari/PieceSafari.cpp b/src/Safari/PieceSafari.cpp
index f363514..7a9af78 100644
--- a/src/Safari/PieceSafari.cpp
+++ b/src/Safari/PieceSafari.cpp
@@ -1,7 +1,23 @@
 #include "../../includes/Safari/PieceSafari.hpp"
 
-PieceSafari::PieceSafari(const std::string cat) : Piece(cat) {
-  std::cout << "pièce - " << cat << "\n";
+PieceSafari::PieceSafari(const enum Categorie cat) : Piece(to_string(cat)) {
+  std::cout << "pièce - " << categorie << "\n";
 }
 
 PieceSafari::~PieceSafari() {}
+
+std::string PieceSafari::to_string(const enum Categorie cat) const {
+  switch (cat) {
+  case Barriere:
+    return "Barrière";
+  case Elephant:
+    return "Éléphant";
+  case Rhinoceros:
+    return "Rhinocéros";
+  case Lion:
+    return "Lion";
+
+  default:
+    exit(EXIT_FAILURE);
+  }
+}
diff --git a/src/Safari/PlateauSafari.cpp b/src/Safari/PlateauSafari.cpp
index 98ead24..ef69e29 100644
--- a/src/Safari/PlateauSafari.cpp
+++ b/src/Safari/PlateauSafari.cpp
@@ -1,9 +1,12 @@
 #include "../../includes/Safari/PlateauSafari.hpp"
+#include "../../includes/utils.hpp"
 
 PlateauSafari::PlateauSafari() : Plateau(8) {}
 
 PlateauSafari::~PlateauSafari() {}
 
 void PlateauSafari::initialiserPlateau(Joueur &j1, Joueur &j2) {
+  ignore(j1);
+  ignore(j2);
   // TODO
 }
diff --git a/src/Safari/Safari.cpp b/src/Safari/Safari.cpp
index 0149540..fe9f6c8 100644
--- a/src/Safari/Safari.cpp
+++ b/src/Safari/Safari.cpp
@@ -4,7 +4,7 @@ Safari::Safari(Joueur &j1, Joueur &j2, Joueur &j3)
     : plateau(PlateauSafari()), joueur1{j1}, joueur2{j2}, joueur3{j3},
       joueurCourant{j1} {
   for (int i = 0; i < 50; i++) {
-    barrieres.push_back(new PieceSafari("barriere"));
+    barrieres.push_back(new PieceSafari(PieceSafari::Barriere));
   }
 }
 
@@ -14,7 +14,7 @@ Safari::Safari(const Safari &src)
     : plateau(PlateauSafari()), joueur1{src.joueur1}, joueur2{src.joueur2},
       joueur3{src.joueur3}, joueurCourant{src.joueurCourant} {
   for (int i = 0; i < 50; i++) {
-    barrieres.push_back(new PieceSafari("barriere"));
+    barrieres.push_back(new PieceSafari(PieceSafari::Barriere));
   }
 }
 
@@ -26,10 +26,16 @@ const Safari &Safari::operator=(const Safari &src) {
   return *this;
 }
 
-void Safari::choixAnimal(std::string animal) {
-  if (animal != "éléphant" || animal != "rhinocéros" || animal != "lion") {
+void Safari::init() {
+  // On peut donner que 2 joueurs ?
+  plateau.initialiserPlateau(joueur1, joueur2);
+}
+
+void Safari::choixAnimal(const PieceSafari::Categorie animal) const {
+  if (animal == PieceSafari::Barriere) {
     throw std::invalid_argument("Animal non valide");
   }
+
   if (joueurCourant.getPieces().empty()) {
     for (int i = 0; i < 3; i++) {
       joueurCourant.ajoutPiece(new PieceSafari(animal));