follow up of fd8ceba929

includes/Mouvement.hpp

@@ -1,29 +0,0 @@
-#pragma once
-
-#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 ? */
-/*+====> Oui on peut faire ça  je suis d'accord !!*/
-
-class Mouvement {
-  friend std::ostream &operator<<(std::ostream &, const Mouvement &);
-
-  // Coordonnées du déplacement, source
-  int sourceX, sourceY;
-
-  // Coordonnées du déplacement, destination
-  int destX, destY;
-
-public:
-  Mouvement();          // constructor
-  virtual ~Mouvement(); // destructor
-
-  Mouvement(const Mouvement &);                  // copy constructor
-  const Mouvement &operator=(const Mouvement &); // copy assignement
-
-  // Fonction de déplacement
-
-  // Fonction de prise de pièce
-};

includes/Piece.hpp

@@ -15,4 +15,9 @@ public:
 
   Piece(const Piece &);                  // copy constructor
   const Piece &operator=(const Piece &); // copy assignement
+
+  // Fonction de déplacement
+  bool moveTo(const int destX, const int destY);
+
+  // Fonction de prise de pièce
 };

includes/Safari/Safari.hpp

@@ -11,17 +11,18 @@ class Safari {
   PlateauSafari plateau;
 
   // Joueurs
-  Joueur &joueur1;
-  Joueur &joueur2;
-  Joueur &joueur3;
+  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
+  Safari(Joueur *joueur1, Joueur *joueur2,
+         Joueur *joueur3 = nullptr); // constructor
+  virtual ~Safari();                 // destructor
 
   Safari(const Safari &);                  // copy constructor
   const Safari &operator=(const Safari &); // copy assignement

src/Mouvement.cpp

@@ -1,23 +0,0 @@
-#include "../includes/Mouvement.hpp"
-
-Mouvement::Mouvement() {
-  std::cout << "mouvement\n";
-}
-
-Mouvement::~Mouvement() {}
-
-Mouvement::Mouvement(const Mouvement &) {}
-
-const Mouvement &Mouvement::operator=(const Mouvement &src) {
-  if (this == &src) {
-    return *this;
-  }
-
-  return *this;
-}
-
-std::ostream &operator<<(std::ostream &out, const Mouvement &data) {
-  out << "source: (" << data.sourceX << ", " << data.sourceY
-      << "), destination: (" << data.destX << ", " << data.destY << ")";
-  return out;
-}

src/Safari/Safari.cpp

@@ -1,8 +1,11 @@
 #include "../../includes/Safari/Safari.hpp"
 
-Safari::Safari(Joueur &j1, Joueur &j2, Joueur &j3)
+/* 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(Joueur *j1, Joueur *j2, Joueur *j3)
     : plateau(PlateauSafari()), joueur1{j1}, joueur2{j2}, joueur3{j3},
-      joueurCourant{j1} {
+      joueurCourant{*j1} {
   for (int i = 0; i < 50; i++) {
     barrieres.push_back(new PieceSafari(PieceSafari::Barriere));
   }
@@ -27,19 +30,17 @@ const Safari &Safari::operator=(const Safari &src) {
 }
 
 std::ostream &operator<<(std::ostream &out, const Safari &data) {
-  out << "j1: " << data.joueur1 << "\nj2: " << data.joueur2
-      << "\nj3: " << data.joueur3 << "\nPlateau:\n"
-      << data.plateau;
+  out << "j1: " << data.joueur1 << "\nj2: " << data.joueur2;
+  if (data.joueur3 != nullptr) {
+    out << "\nj3: " << data.joueur3;
+  }
+
+  out << "\nPlateau:\n" << data.plateau;
+
   return out;
 }
 
 void Safari::init() {
-  // On peut donner que 2 joueurs ?
-  /* ===> dsl je sais pas si la question est pour moi et je suis pas sûre de
-   comprendre mais : Le safari est le seul jeu qui peut se jouer à 3, mais il
-   peut également se jouer à 2. Je ne sais pas comment faire le constructeur
-   pour qu'il ne prenne que 2 joueurs. Donc hésite pas à me détailler ce qui va
-   pas exactement j'ai peut-être fait un truc chelou*/
   plateau.initialiserPlateau();
 }