affichage rudimentaire de safari + choix des animaux

includes/Safari/PieceSafari.hpp

@@ -10,12 +10,17 @@ struct PieceSafari : public Piece {
     Lion,
   };
 
+  const enum Categorie _category;
+
   PieceSafari(const enum Categorie, const int x, const int y);
   virtual ~PieceSafari();
 
   // Couleur sur l'écran
   const sf::Color getScreenColor() const override;
 
+  // Catégorie représentée par la pièce
+  enum Categorie getCategory() const;
+
 private:
   const std::string to_string(const enum Categorie) const;
 };

includes/Safari/PlateauSafari.hpp

@@ -1,8 +1,13 @@
 #pragma once
 
 #include "../Plateau.hpp"
+#include "PieceSafari.hpp"
 
 class PlateauSafari : public Plateau {
+
+  // Barrières
+  std::vector<PieceSafari *> barrieres;
+
 public:
   PlateauSafari();
   virtual ~PlateauSafari();

includes/Safari/Safari.hpp

@@ -11,8 +11,8 @@ class Safari : private Jeu {
   PlateauSafari plateau;
 
   // Joueurs
-  const Joueur &joueur2;
+  Joueur &joueur2;
-  const Joueur *joueur3;
+  Joueur *joueur3;
 
   // Etape du jeu, pour savoir où on en est
   enum Etape {
@@ -26,8 +26,8 @@ class Safari : private Jeu {
   // Où l'on se trouve dans le jeu, à quelle étape nous sommes
   enum Etape etape;
 
-  // Barrières
+  // Barrières posés
-  std::vector<PieceSafari *> barrieres;
+  int barrieres;
 
   // Permet de transformer une Piece en PieceSafari
   const PieceSafari *getPiece(const int x, const int y) const;
@@ -38,8 +38,11 @@ class Safari : private Jeu {
   // Change de joueur courant
   void changerJoueurCourant();
 
-  // Assignie un animal au joueur courant
+  // Message du choix des animaux
-  void choixAnimal(const PieceSafari::Categorie animal);
+  const std::string msgChoixAnimal() const;
+
+  // Auxilliaire pour le choix des pièces par le joueur
+  void choixJoueur(const Etape prochaineEtape);
 
 public:
   Safari(Joueur &joueur1, Joueur &joueur2,

src/Safari/PieceSafari.cpp

@@ -2,7 +2,7 @@
 
 PieceSafari::PieceSafari(const enum Categorie cat, const int posX,
                          const int posY)
-    : Piece(to_string(cat), posX, posY) {}
+    : Piece(to_string(cat), posX, posY), _category(cat) {}
 
 PieceSafari::~PieceSafari() {}
 
@@ -26,3 +26,7 @@ const sf::Color PieceSafari::getScreenColor() const {
   // TODO
   return sf::Color::White;
 }
+
+enum PieceSafari::Categorie PieceSafari::getCategory() const {
+  return _category;
+}

src/Safari/PlateauSafari.cpp

@@ -7,6 +7,13 @@ PlateauSafari::~PlateauSafari() {}
 
 void PlateauSafari::initialiserPlateau() {
   // Au début, le plateau est vide
+
+  // Les joueurs vont choisir leur animal, on place autant d'animal différent
+  // que de joueur différent sur le plateau, au centre parce que les joueurs
+  // vont cliquer dessus pour faire leur choix
+  plateau[2][3] = new PieceSafari(PieceSafari::Elephant, 2, 3);
+  plateau[3][3] = new PieceSafari(PieceSafari::Lion, 3, 3);
+  plateau[4][3] = new PieceSafari(PieceSafari::Rhinoceros, 4, 3);
 }
 
 void PlateauSafari::afficherPlateau(std::ostream &out, const bool d) const {
@@ -19,13 +26,31 @@ void PlateauSafari::afficherPlateau(std::ostream &out, const bool d) const {
   sf::Color jaune = sf::Color(255, 200, 40);
   sf::Color marron = sf::Color(155, 60, 40);
 
+  // Pièces
+  sf::CircleShape rhinoceros(tailleCellule / 3, 3);
+  // rhinoceros.setOutlineThickness(2.);
+  sf::CircleShape elephant(tailleCellule / 3, 6);
+  // elephant.setOutlineThickness(2.);
+  sf::CircleShape lion(tailleCellule / 3);
+  lion.setOutlineThickness(2.);
+
+  const float decalagePiece = tailleCellule / 6;
+
   for (int i = 0; i < taille; i++) {
     for (int j = 0; j < taille; j++) {
+      // Remet la couleur de l'outline par défaut
+      rhinoceros.setOutlineColor(sf::Color::Transparent);
+      elephant.setOutlineColor(sf::Color::Transparent);
+      lion.setOutlineColor(sf::Color::Transparent);
+
       const float x = i * tailleCellule;
       const float y = j * tailleCellule;
 
       // Position de la cellule et de la pièce
       cell.setPosition(x, y);
+      rhinoceros.setPosition(x + decalagePiece, y + decalagePiece);
+      elephant.setPosition(x + decalagePiece, y + decalagePiece);
+      lion.setPosition(x + decalagePiece, y + decalagePiece);
       if (d) {
         out << "(" << x << ", " << y;
       }
@@ -33,6 +58,7 @@ void PlateauSafari::afficherPlateau(std::ostream &out, const bool d) const {
       // Alternation des couleurs
       if ((i + j) % 2 == 0) {
         cell.setFillColor(jaune);
+        lion.setOutlineColor(sf::Color::Black);
         if (d) {
           out << ", J), ";
         }
@@ -47,7 +73,31 @@ void PlateauSafari::afficherPlateau(std::ostream &out, const bool d) const {
       Ecran::window.draw(cell);
 
       // Dessine la piece
-      // TODO
+      const Piece *p = plateau[i][j];
+      if (p != nullptr) {
+        if (p->isSelectionnee()) {
+          lion.setOutlineColor(sf::Color::Green);
+        }
+        switch (dynamic_cast<const PieceSafari *>(p)->getCategory()) {
+        case PieceSafari::Elephant: {
+          elephant.setFillColor(sf::Color::White);
+          Ecran::window.draw(elephant);
+          break;
+        }
+        case PieceSafari::Rhinoceros: {
+          rhinoceros.setFillColor(sf::Color::Red);
+          Ecran::window.draw(rhinoceros);
+          break;
+        }
+        case PieceSafari::Lion: {
+          lion.setFillColor(sf::Color::Yellow);
+          Ecran::window.draw(lion);
+          break;
+        }
+        default:
+          break;
+        }
+      }
     }
     if (d) {
       out << "\n";
@@ -55,7 +105,9 @@ void PlateauSafari::afficherPlateau(std::ostream &out, const bool d) const {
   }
 
   // Dessine les mur
-  // TODO
+  /* for (auto it : barrieres) {
+    // TODO
+  } */
 
   if (d) {
     out << "---\n";

src/Safari/Safari.cpp

@@ -1,21 +1,28 @@
 #include "../../includes/Safari/Safari.hpp"
+#include "../../includes/Ecran.hpp"
 
 /* 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)
-    : Jeu(j1), plateau(PlateauSafari()), joueur2{j2}, joueur3{j3} {
+    : Jeu(j1), plateau(PlateauSafari()), joueur2{j2}, joueur3{j3},
-  for (int i = 0; i < 50; i++) {
+      barrieres(0) {
-    // TODO: Les pièces ont des positions invalides, il faut penser à les
-    // définir quand on les rajoute au plateau
-    barrieres.push_back(new PieceSafari(PieceSafari::Barriere, -1, -1));
-  }
-
   plateau.initialiserPlateau();
+  Ecran::printMessage(msgChoixAnimal());
+  etape = ChoixJ1;
 }
 
 Safari::~Safari() {}
 
+const PieceSafari *Safari::getPiece(const int x, const int y) const {
+  return dynamic_cast<const PieceSafari *>(plateau.getPiece(x, y));
+}
+
+const std::string Safari::msgChoixAnimal() const {
+  return "Joueur " + std::to_string(joueurCourant->getNum()) +
+         ", choississez un animal.";
+}
+
 std::ostream &operator<<(std::ostream &out, const Safari &data) {
   out << "j1: " << data.joueur1 << "\nj2: " << data.joueur2;
   if (data.joueur3 != nullptr) {
@@ -29,9 +36,88 @@ std::ostream &operator<<(std::ostream &out, const Safari &data) {
 
 void Safari::play() {
   plateau.afficherPlateau(std::cout);
+
+  // Demander à J1 de choisir un animal
+  if (etape <= Etape::ChoixJ1) {
+    return;
+  }
+
+  // Demander à J2 de choisir un animal
+  if (etape <= Etape::ChoixJ2) {
+    return;
+  }
+
+  // Demander à J3 de choisir un animal
+  if (etape <= Etape::ChoixJ3) {
+    if (joueur3 == nullptr) {
+      // Pas de joueur 3
+      // On retire le dernier choix d'animal
+      const Piece *p = plateau.getPieces().at(0);
+      std::pair<const int, const int> pos = p->getPos();
+      plateau.modifierPlateau(pos.first, pos.second, nullptr);
+      delete p;
+
+      // On passe à l'étape suivante
+      etape = Etape::EnJeu;
+    }
+    return;
+  }
 }
 
-void Safari::event(const int, const int) {}
+void Safari::choixJoueur(const Etape next) {
+  const PieceSafari *p = getPiece(posCurseur.first, posCurseur.second);
+  // Vérifie qu'une pièce à été cliquée
+  if (p == nullptr) {
+    return;
+  }
+
+  // Donne la pièce au joueur, il est maintenant lié à cette animal
+  joueurCourant->ajoutPiece(p);
+
+  // Retire la pièce du plateau
+  plateau.modifierPlateau(posCurseur.first, posCurseur.second, nullptr);
+
+  // On passe à l'étape suivante
+  etape = next;
+  changerJoueurCourant();
+  Ecran::printMessage(msgChoixAnimal());
+}
+
+void Safari::event(const int x, const int y) {
+  // Update position
+  posCurseur = plateau.trouveCoordonnees(x, y);
+  posCurseur = getPosition();
+  if (posCurseur.first == -1) {
+    // Mauvaise position
+    return;
+  }
+
+  // Texte de debug
+  std::cout << "Clic souris @ (" << x << ", " << y << ") aka ("
+            << posCurseur.first << ", " << posCurseur.second << ")\n";
+
+  switch (etape) {
+  // Clic du J1
+  case ChoixJ1: {
+    choixJoueur(ChoixJ2);
+    break;
+  }
+  case ChoixJ2: {
+    choixJoueur(ChoixJ3);
+    break;
+  }
+  case ChoixJ3: {
+    choixJoueur(EnJeu);
+    break;
+  }
+  case EnJeu: {
+    break;
+  }
+  case Fini: {
+    break;
+  }
+  }
+}
 
 const std::pair<const int, const int> Safari::getPosition() const {
   if (posCurseur.second > plateau.getTaille() - 1) {
@@ -42,15 +128,16 @@ const std::pair<const int, const int> Safari::getPosition() const {
   return posCurseur;
 }
 
-void Safari::choixAnimal(const PieceSafari::Categorie animal) {
+void Safari::changerJoueurCourant() {
-  if (animal == PieceSafari::Barriere) {
+  if (joueurCourant->getNum() == joueur1.getNum()) {
-    throw std::invalid_argument("Animal non valide");
+    joueurCourant = &joueur2;
-  }
+  } else if (joueurCourant->getNum() == joueur2.getNum()) {
-
+    if (joueur3) {
-  if (joueurCourant->getPieces().empty()) {
+      joueurCourant = joueur3;
-    for (int i = 0; i < 3; i++) {
+    } else {
-      // Position invalide en attendant d'être ajouté au plateau de jeu
+      joueurCourant = &joueur1;
-      joueurCourant->ajoutPiece(new PieceSafari(animal, -1, -1));
     }
+  } else {
+    joueurCourant = &joueur1;
   }
 }