const keyword, everywhere all at once

includes/Butin/Butin.hpp

@@ -12,7 +12,7 @@ class Butin : private Jeu {
   PlateauButin plateau;
 
   // Joueurs
-  Joueur &joueur2;
+  const Joueur &joueur2;
 
   // Etape du jeu, pour savoir où on en est
   enum Etape {
@@ -26,23 +26,23 @@ class Butin : private Jeu {
   enum Etape etape;
 
   // Permet de transformer une Piece en PieceButin
-  PieceButin *getPiece(const int x, const int y) const;
+  const PieceButin *getPiece(const int x, const int y) const;
 
   // Message quand les joueurs retirent les pièces au début du jeu
-  std::string msgPieceJaune(const bool erreur = false) const;
+  const std::string msgPieceJaune(const bool erreur = false) const;
 
   // Message à chaque tour du joueur
-  std::string msgTonTour() const;
+  const std::string msgTonTour() const;
 
   // Position curseur
-  std::pair<int, int> getPosition() const override;
+  const std::pair<const int, const int> getPosition() const override;
 
   // Change de joueur courant
   void changerJoueurCourant();
 
 public:
-  Butin(Joueur &joueur1, Joueur &joueur2); // constructor
+  Butin(const Joueur &joueur1, const Joueur &joueur2); // constructor
-  virtual ~Butin();                        // destructor
+  virtual ~Butin();                                    // destructor
 
   // Fonction d'initialisation du jeu
   void init() override;

includes/Butin/PieceButin.hpp

@@ -14,7 +14,7 @@ struct PieceButin : public Piece {
   virtual ~PieceButin();
 
   // Couleur sur l'écran
-  sf::Color getScreenColor() const override;
+  const sf::Color getScreenColor() const override;
 
   // Récupère le nombre de points que la pièce vaut
   int getPoints() const;
@@ -22,5 +22,5 @@ struct PieceButin : public Piece {
 private:
   int points;
 
-  std::string to_string(const enum Categorie) const;
+  const std::string to_string(const enum Categorie) const;
 };

includes/Butin/PlateauButin.hpp

@@ -12,7 +12,8 @@ struct PlateauButin : public Plateau {
   void initialiserPlateau() override;
 
   // Renvoie la liste des pièces entre la pièce sélectionné et une position
-  std::vector<Piece *> cheminPieces(const int destX, const int destY) const;
+  const std::vector<const Piece *> cheminPieces(const int destX,
+                                                const int destY) const;
 
   // Vrai si la pièce sélectionnée est jaune
   bool selectionJaune() const;
@@ -22,6 +23,7 @@ struct PlateauButin : public Plateau {
 
 private:
   // Renvoie la liste des pièces entre deux position
-  std::vector<Piece *> cheminPieces(const int depX, const int depY,
+  const std::vector<const Piece *> cheminPieces(const int depX, const int depY,
-                                    const int destX, const int destY) const;
+                                                const int destX,
+                                                const int destY) const;
 };

includes/Dames/Dames.hpp

@@ -10,7 +10,7 @@ class Dames : private Jeu {
   PlateauDames plateau;
 
   // Joueurs
-  Joueur &joueur2;
+  const Joueur &joueur2;
 
 public:
   Dames(Joueur &joueur1, Joueur &joueur2); // constructor
@@ -26,7 +26,7 @@ public:
   void event(const int x, const int y) override;
 
   // Position curseur
-  std::pair<int, int> getPosition() const override;
+  const std::pair<const int, const int> getPosition() const override;
 
   // Vérifie si une prise est possible pour une pièce donnée
   bool prisePossible(Joueur &joueur) const;

includes/Dames/PieceDames.hpp

@@ -12,7 +12,7 @@ struct PieceDames : public Piece {
   virtual ~PieceDames();
 
   // Couleur sur l'écran
-  sf::Color getScreenColor() const override;
+  const sf::Color getScreenColor() const override;
 
   // Getter pour la piece (dame ou non)
   bool getDame() const;
@@ -24,5 +24,5 @@ private:
   // True si la piece est une dame
   bool dame;
 
-  std::string to_string(const enum Categorie) const;
+  const std::string to_string(const enum Categorie) const;
 };

includes/Jeu.hpp

@@ -4,8 +4,8 @@
 
 struct Jeu {
   // Le joueur 1 est toujours celui qui commence
-  Jeu(Joueur &j1); // constructor
+  Jeu(const Joueur &j1); // constructor
-  virtual ~Jeu();  // destructor
+  virtual ~Jeu();        // destructor
 
   // Fonction d'initialisation d'un jeu
   virtual void init() = 0;
@@ -18,7 +18,7 @@ struct Jeu {
 
 protected:
   // Joueurs, au moins un joueur
-  Joueur &joueur1;
+  const Joueur &joueur1;
   Joueur joueurCourant;
 
   // Position du dernier clic du curseur sur l'écran
@@ -27,5 +27,5 @@ protected:
   // Récupère la position du curseur
   // Virtuelle car on aimerais vérifier que le curseur n'est pas en dehors du
   // plateau et on accès à aucun plateau ici
-  virtual std::pair<int, int> getPosition() const = 0;
+  virtual const std::pair<const int, const int> getPosition() const = 0;
 };

includes/Joueur.hpp

@@ -13,7 +13,7 @@ class Joueur {
   // Pour le butin, tout simplement les pièces que le joueur gagne.
   // Pour les dames, peut être uniquement les pieces sur le plateau.
   // Pour le safari, les animaux du joueur
-  std::vector<Piece *> pieces;
+  std::vector<const Piece *> pieces;
 
 public:
   Joueur(const int numeroJoueur); // constructor
@@ -23,10 +23,10 @@ public:
   const Joueur &operator=(const Joueur &); // copy assignement
 
   // Ajoute une pièce à la liste de pièces du joueur
-  void ajoutPiece(Piece *piece);
+  void ajoutPiece(const Piece *piece);
 
   // Getter pour les pièces du joueur
-  const std::vector<Piece *> getPieces() const;
+  const std::vector<const Piece *> getPieces() const;
 
   // Getter pour le nom du joueur
   int getNum() const;

includes/Piece.hpp

@@ -19,7 +19,7 @@ class Piece {
 
 protected:
   // Couleur de la pièce ou type d'animal pour Safari par ex
-  std::string categorie;
+  const std::string categorie;
 
   // Indices où sont placés les pièces sur le plateau
   int x;
@@ -33,8 +33,8 @@ public:
   void moveTo(const int destX, const int destY);
 
   // Renvoie la couleur de la pièce pour l'affichage
-  virtual sf::Color getScreenColor() const = 0;
+  virtual const sf::Color getScreenColor() const = 0;
 
   // Renvoie la position de la pièce
-  std::pair<int, int> getPos() const;
+  const std::pair<const int, const int> getPos() const;
 };

includes/Plateau.hpp

@@ -10,7 +10,7 @@ protected:
   Piece ***plateau;
 
   // Taille du plateau
-  int taille;
+  const int taille;
 
   // Piece actuellement selectionnée
   Piece *selection;
@@ -32,13 +32,14 @@ public:
 
   // Fonction pour bouger une pièce, renvoie les anciennes coordonnées de la
   // pièce bougée (TODO: est-ce utile de renvoyer les anciennes coordonnées ?)
-  std::pair<int, int> moveSelection(const int x, const int y);
+  const std::pair<const int, const int> moveSelection(const int x, const int y);
 
   // Renvoie une pièce à une position donnnée
   Piece *getPiece(const int x, const int y) const;
 
   // Prend des coordonnées-écran et renvoie des coordonnées-jeu
-  std::pair<int, int> trouveCoordonnees(const int x, const int y) const;
+  const std::pair<const int, const int> trouveCoordonnees(const int x,
+                                                          const int y) const;
 
   // Renvoie la taille du plateau
   int getTaille() const;

includes/Safari/PieceSafari.hpp

@@ -14,8 +14,8 @@ struct PieceSafari : public Piece {
   virtual ~PieceSafari();
 
   // Couleur sur l'écran
-  sf::Color getScreenColor() const override;
+  const sf::Color getScreenColor() const override;
 
 private:
-  std::string to_string(const enum Categorie) const;
+  const std::string to_string(const enum Categorie) const;
 };

includes/Safari/Safari.hpp

@@ -11,16 +11,16 @@ class Safari : private Jeu {
   PlateauSafari plateau;
 
   // Joueurs
-  Joueur &joueur2;
+  const Joueur &joueur2;
-  Joueur *joueur3;
+  const Joueur *joueur3;
 
   // Barrières
   std::vector<PieceSafari *> barrieres;
 
 public:
-  Safari(Joueur &joueur1, Joueur &joueur2,
+  Safari(const Joueur &joueur1, const Joueur &joueur2,
-         Joueur *joueur3 = nullptr); // constructor
+         const Joueur *joueur3 = nullptr); // constructor
-  virtual ~Safari();                 // destructor
+  virtual ~Safari();                       // destructor
 
   // Fonction d'initialisation du jeu
   void init() override;
@@ -32,7 +32,7 @@ public:
   void event(const int x, const int y) override;
 
   // Position curseur
-  std::pair<int, int> getPosition() const override;
+  const std::pair<const int, const int> getPosition() const override;
 
   // Fonction d'initialisation du jeu
   void choixAnimal(const PieceSafari::Categorie animal);

includes/utils.hpp

@@ -4,9 +4,9 @@
 #include <vector>
 
 template <typename T>
-void print_vec(std::vector<T> vec) {
+void print_vec(const std::vector<const T> vec) {
   std::cout << "[ (" << vec.size() << ")\n";
-  for (auto it : vec) {
+  for (const T it : vec) {
     std::cout << "  " << it << "\n";
   }
   std::cout << "]\n";

src/Butin/Butin.cpp

@@ -2,7 +2,7 @@
 #include "../../includes/Butin/PieceButin.hpp"
 #include "../../includes/Ecran.hpp"
 
-Butin::Butin(Joueur &j1, Joueur &j2)
+Butin::Butin(const Joueur &j1, const Joueur &j2)
     : Jeu(j1), plateau(PlateauButin()), joueur2{j2} {
   init();
 }
@@ -15,11 +15,11 @@ std::ostream &operator<<(std::ostream &out, const Butin &data) {
   return out;
 }
 
-PieceButin *Butin::getPiece(const int x, const int y) const {
+const PieceButin *Butin::getPiece(const int x, const int y) const {
-  return dynamic_cast<PieceButin *>(plateau.getPiece(x, y));
+  return dynamic_cast<const PieceButin *>(plateau.getPiece(x, y));
 }
 
-std::string Butin::msgPieceJaune(const bool erreur) const {
+const std::string Butin::msgPieceJaune(const bool erreur) const {
   std::string res = "Joueur " + std::to_string(joueurCourant.getNum()) +
                     ", retirez une piece jaune en cliquant dessus.";
 
@@ -30,7 +30,7 @@ std::string Butin::msgPieceJaune(const bool erreur) const {
   return res;
 }
 
-std::string Butin::msgTonTour() const {
+const std::string Butin::msgTonTour() const {
   return "Joueur " + std::to_string(joueurCourant.getNum()) +
          ", c'est votre tour.";
 }
@@ -72,7 +72,7 @@ void Butin::event(const int x, const int y) {
   switch (etape) {
   // Clic du J1
   case (Etape::ChoixJ1): {
-    PieceButin *p = getPiece(posCurseur.first, posCurseur.second);
+    const PieceButin *p = getPiece(posCurseur.first, posCurseur.second);
     // Vérifier que la pièce est jaune
     if (p->getPoints() == PieceButin::Jaune) {
 
@@ -93,7 +93,7 @@ void Butin::event(const int x, const int y) {
   // Clic du J2
   case ChoixJ2: {
     // Vérifier que la pièce existe et est jaune
-    PieceButin *p = getPiece(posCurseur.first, posCurseur.second);
+    const PieceButin *p = getPiece(posCurseur.first, posCurseur.second);
     if (p && p->getPoints() == PieceButin::Jaune) {
       // Retire la pièce
       plateau.modifierPlateau(posCurseur.first, posCurseur.second, nullptr);
@@ -109,11 +109,11 @@ void Butin::event(const int x, const int y) {
     break;
   }
   case EnJeu: {
-    Piece *p = getPiece(posCurseur.first, posCurseur.second);
+    const Piece *p = getPiece(posCurseur.first, posCurseur.second);
     // Vérifie que la pièce sélectionnée = Jaune et que la case choisie = vide
     if (plateau.selectionJaune() && p == nullptr) {
       // Récupère la liste des pièces sur le chemin
-      std::vector<Piece *> chemin =
+      const std::vector<const Piece *> chemin =
           plateau.cheminPieces(posCurseur.first, posCurseur.second);
 
       // Si le chemin est valide == Si des pièces sont sur le chemin
@@ -122,9 +122,9 @@ void Butin::event(const int x, const int y) {
         plateau.moveSelection(posCurseur.first, posCurseur.second);
 
         // Mange les pièces sur le chemin
-        for (auto it : chemin) {
+        for (const Piece *it : chemin) {
           // Récupère la pièce
-          std::pair<int, int> pos = it->getPos();
+          const std::pair<const int, const int> pos = it->getPos();
           Piece *gain = plateau.getPiece(pos.first, pos.second);
 
           // Retire la pièce
@@ -161,7 +161,7 @@ void Butin::event(const int x, const int y) {
   }
 }
 
-std::pair<int, int> Butin::getPosition() const {
+const std::pair<const int, const int> Butin::getPosition() const {
   if (posCurseur.second > plateau.getTaille() - 1) {
     std::cerr << "Position inconnu du plateau.\n";
     return std::make_pair(-1, -1);

src/Butin/PieceButin.cpp

@@ -8,7 +8,7 @@ PieceButin::PieceButin(const enum Categorie cat, const int posX, const int posY)
 
 PieceButin::~PieceButin() {}
 
-std::string PieceButin::to_string(const enum Categorie cat) const {
+const std::string PieceButin::to_string(const enum Categorie cat) const {
   switch (cat) {
   case Jaune:
     return "Jaune";
@@ -22,7 +22,7 @@ std::string PieceButin::to_string(const enum Categorie cat) const {
   }
 }
 
-sf::Color PieceButin::getScreenColor() const {
+const sf::Color PieceButin::getScreenColor() const {
   switch (points) {
   case Jaune:
     return sf::Color::Yellow;

src/Butin/PlateauButin.cpp

@@ -46,15 +46,15 @@ void PlateauButin::initialiserPlateau() {
   }
 }
 
-std::vector<Piece *> PlateauButin::cheminPieces(const int destX,
+const std::vector<const Piece *>
-                                                const int destY) const {
+PlateauButin::cheminPieces(const int destX, const int destY) const {
-  std::pair<int, int> posSelection = selection->getPos();
+  const std::pair<const int, const int> posSelection = selection->getPos();
   return cheminPieces(posSelection.first, posSelection.second, destX, destY);
 }
 
-std::vector<Piece *> PlateauButin::cheminPieces(const int depX, const int depY,
+const std::vector<const Piece *>
-                                                const int destX,
+PlateauButin::cheminPieces(const int depX, const int depY, const int destX,
-                                                const int destY) const {
+                           const int destY) const {
   // Distances
   const int deltaX = destX - depX;
   const int deltaY = destY - depY;
@@ -63,7 +63,7 @@ std::vector<Piece *> PlateauButin::cheminPieces(const int depX, const int depY,
   const int stepX = (deltaX > 0) ? 1 : -1;
   const int stepY = (deltaY > 0) ? 1 : -1;
 
-  std::vector<Piece *> chemin;
+  std::vector<const Piece *> chemin;
 
   // Déplacement vertical
   if (deltaX == 0) {
@@ -105,10 +105,10 @@ bool PlateauButin::selectionJaune() const {
 
 bool PlateauButin::coupsPossible() const {
   // Liste des cases vides
-  std::vector<std::pair<int, int>> casesVides;
+  std::vector<std::pair<const int, const int>> casesVides;
 
   // Liste des pièces jaunes
-  std::vector<std::pair<int, int>> piecesJaunes;
+  std::vector<std::pair<const int, const int>> piecesJaunes;
 
   for (int i = 0; i < taille; ++i) {
     for (int j = 0; j < taille; ++j) {
@@ -125,9 +125,9 @@ bool PlateauButin::coupsPossible() const {
       }
     }
 
-    for (std::pair<int, int> p : piecesJaunes) {
+    for (std::pair<const int, const int> p : piecesJaunes) {
       // Parmis toutes les pièces jaunes
-      for (std::pair<int, int> it : casesVides) {
+      for (std::pair<const int, const int> it : casesVides) {
         // Si le déplacement vers une case vide peut donner des points
         if (!cheminPieces(p.first, p.second, it.first, it.second).empty()) {
           return true;

src/Dames/Dames.cpp

@@ -4,7 +4,7 @@
 Dames::Dames(Joueur &j1, Joueur &j2)
     : Jeu(j1), plateau(PlateauDames(j1, j2)), joueur2(j2) {
   std::srand(static_cast<unsigned int>(time(0)));
-  int r = std::rand() % 2;
+  const int r = std::rand() % 2;
   if (r == 0) {
     joueurCourant = j1;
   } else {
@@ -35,7 +35,7 @@ void Dames::play() {
 
 void Dames::event(const int, const int) {}
 
-std::pair<int, int> Dames::getPosition() const {
+const std::pair<const int, const int> Dames::getPosition() const {
   if (posCurseur.first > plateau.getTaille() - 1) {
     std::cerr << "Position inconnu du plateau.\n";
     return std::make_pair(-1, -1);
@@ -50,11 +50,11 @@ std::pair<int, int> Dames::getPosition() const {
 // les pièces aient des attributs pour leur position (comme proposé dans Piece)
 // ?
 bool Dames::prisePossible(Joueur &joueur) const {
-  const std::vector<Piece *> &pieces = joueur.getPieces();
+  const std::vector<const Piece *> &pieces = joueur.getPieces();
   int x = 1;
   int y = 1;
   for (uint i = 0; i < pieces.size(); i++) {
-    PieceDames *p = dynamic_cast<PieceDames *>(pieces[i]);
+    const PieceDames *p = dynamic_cast<const PieceDames *>(pieces[i]);
     if (!p) {
       throw std::runtime_error("Cette pièce est.. étrange.");
     }

src/Dames/PieceDames.cpp

@@ -15,7 +15,7 @@ void PieceDames::setDame(const bool d) {
   dame = d;
 }
 
-std::string PieceDames::to_string(const enum Categorie cat) const {
+const std::string PieceDames::to_string(const enum Categorie cat) const {
   switch (cat) {
   case Blanche:
     return "Blanche";
@@ -27,7 +27,7 @@ std::string PieceDames::to_string(const enum Categorie cat) const {
   }
 }
 
-sf::Color PieceDames::getScreenColor() const {
+const sf::Color PieceDames::getScreenColor() const {
   // TODO
   return sf::Color::White;
 }

src/Ecran.cpp

@@ -71,7 +71,7 @@ void Ecran::afficher(
 
     // Affichage des FPS
     if (fps) {
-      float currentTime = fpsClock.restart().asSeconds();
+      const float currentTime = fpsClock.restart().asSeconds();
 
       // Toutes les 2 secondes
       if (printFpsclock.getElapsedTime().asSeconds() >= 2.f) {

src/Jeu.cpp

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

src/Joueur.cpp

@@ -28,7 +28,7 @@ std::ostream &operator<<(std::ostream &out, const Joueur &data) {
     out << "[]";
   } else {
     out << "[\n";
-    for (Piece *p : data.pieces) {
+    for (const Piece *p : data.pieces) {
       out << "  " << *p << ",\n";
     }
     out << ']';
@@ -37,11 +37,11 @@ std::ostream &operator<<(std::ostream &out, const Joueur &data) {
   return out;
 }
 
-void Joueur::ajoutPiece(Piece *piece) {
+void Joueur::ajoutPiece(const Piece *piece) {
   pieces.push_back(piece);
 }
 
-const std::vector<Piece *> Joueur::getPieces() const {
+const std::vector<const Piece *> Joueur::getPieces() const {
   return pieces;
 }
 
@@ -50,7 +50,7 @@ int Joueur::getNum() const {
 }
 
 bool Joueur::retirePiece(Piece *piece) {
-  auto it = std::find(pieces.begin(), pieces.end(), piece);
+  const auto it = std::find(pieces.begin(), pieces.end(), piece);
   const bool found = it != pieces.end();
 
   if (found) {

src/Piece.cpp

@@ -32,6 +32,6 @@ bool Piece::isSelectionnee() const {
   return selected;
 }
 
-std::pair<int, int> Piece::getPos() const {
+const std::pair<const int, const int> Piece::getPos() const {
   return std::make_pair(x, y);
 }

src/Plateau.cpp

@@ -67,7 +67,7 @@ void Plateau::afficherPlateau(std::ostream &out, const bool d) const {
       Ecran::window.draw(cell);
 
       // Dessine la pièce
-      Piece *p = plateau[i][j];
+      const Piece *p = plateau[i][j];
       if (p != nullptr) {
         if (p->isSelectionnee()) {
           piece.setOutlineColor(sf::Color::Green);
@@ -117,12 +117,12 @@ Piece *Plateau::getPiece(const int x, const int y) const {
   }
 }
 
-std::pair<int, int> Plateau::trouveCoordonnees(const int x, const int y) const {
+const std::pair<const int, const int>
+Plateau::trouveCoordonnees(const int x, const int y) const {
   const float tailleCellule = static_cast<float>(Ecran::largeur()) / taille;
 
-  int xPlateau = static_cast<int>(x / tailleCellule);
+  return std::make_pair(static_cast<int>(x / tailleCellule),
-  int yPlateau = static_cast<int>(y / tailleCellule);
+                        static_cast<int>(y / tailleCellule));
-  return std::make_pair(xPlateau, yPlateau);
 }
 
 int Plateau::getTaille() const {
@@ -151,14 +151,15 @@ void Plateau::modifierSelection(const int x, const int y) {
   }
 }
 
-std::pair<int, int> Plateau::moveSelection(const int x, const int y) {
+const std::pair<const int, const int> Plateau::moveSelection(const int x,
+                                                             const int y) {
   if (selection == nullptr) {
     // Ne fais rien si on a rien a bouger
     return std::make_pair(-1, -1);
   }
 
   // Récupère les coordonnées
-  std::pair<int, int> ancienneCoordonnees =
+  const std::pair<const int, const int> ancienneCoordonnees =
       std::make_pair(selection->x, selection->y);
 
   // Retire la pièce de là où elle est pour le plateau

src/Safari/PieceSafari.cpp

@@ -8,7 +8,7 @@ PieceSafari::PieceSafari(const enum Categorie cat, const int posX,
 
 PieceSafari::~PieceSafari() {}
 
-std::string PieceSafari::to_string(const enum Categorie cat) const {
+const std::string PieceSafari::to_string(const enum Categorie cat) const {
   switch (cat) {
   case Barriere:
     return "Barrière";
@@ -24,7 +24,7 @@ std::string PieceSafari::to_string(const enum Categorie cat) const {
   }
 }
 
-sf::Color PieceSafari::getScreenColor() const {
+const sf::Color PieceSafari::getScreenColor() const {
   // TODO
   return sf::Color::White;
 }

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(Joueur &j1, Joueur &j2, Joueur *j3)
+Safari::Safari(const Joueur &j1, const Joueur &j2, const 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
@@ -35,7 +35,7 @@ void Safari::play() {
 
 void Safari::event(const int, const int) {}
 
-std::pair<int, int> Safari::getPosition() const {
+const std::pair<const int, const int> Safari::getPosition() const {
   if (posCurseur.first > plateau.getTaille() - 1) {
     std::cerr << "Position inconnu du plateau.\n";
     return std::make_pair(-1, -1);

src/main.cpp

@@ -20,14 +20,14 @@ void help(char const *progName) {
 }
 
 int main(int argc, char const *argv[]) {
-  Ecran e;
+  const Ecran e;
   Ecran::toggleFps();
 
   // Interface cli
   if (argc >= 2) {
     Joueur j1(1);
 
-    std::string arg = argv[1];
+    const std::string arg = argv[1];
     if (arg.compare("help") == 0) {
       help(argv[0]);
 
@@ -35,7 +35,7 @@ int main(int argc, char const *argv[]) {
     }
 
     else if (arg.compare("butin") == 0) {
-      Joueur j2(2);
+      const 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) {
-      Joueur j2(2);
+      const Joueur j2(2);
       Joueur *j3 = nullptr;
       // TODO: demander à l'utilisateur un 3e joueur
       {}