début, premières idées, etc

Co-authored-by: Emma <emmbotti@gmail.com>

includes/Dames.hpp

@@ -0,0 +1,23 @@
+#ifndef DAMES
+#define DAMES
+
+#include <iostream>
+
+class Dames {
+  friend std::ostream &operator<<(std::ostream &, const Dames &);
+
+  // Plateau de jeu
+
+  // Joueurs
+
+public:
+  Dames();          // constructor
+  virtual ~Dames(); // destructor
+
+  Dames(const Dames &);                  // copy constructor
+  const Dames &operator=(const Dames &); // copy assignement
+};
+
+// Fonction d'initialisation du jeu
+
+#endif

includes/Joueur.hpp

@@ -0,0 +1,20 @@
+#ifndef JOUEUR
+#define JOUEUR
+
+#include <iostream>
+
+class Joueur {
+  friend std::ostream &operator<<(std::ostream &, const Joueur &);
+
+  // Couleur des pièces du joueur (pour les dames)
+  std::string couleur;
+
+public:
+  Joueur();          // constructor
+  virtual ~Joueur(); // destructor
+
+  Joueur(const Joueur &);                  // copy constructor
+  const Joueur &operator=(const Joueur &); // copy assignement
+};
+
+#endif

includes/Mouvement.hpp

@@ -0,0 +1,24 @@
+#ifndef MOUVEMENT
+#define MOUVEMENT
+
+#include <iostream>
+
+class Mouvement {
+  friend std::ostream &operator<<(std::ostream &, const Mouvement &);
+
+  // (jeu des dames) Coordonnées du déplacement, source et destination. (Selon
+  // la modélisation du plateau ?)
+
+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
+};
+
+#endif

includes/Piece.hpp

@@ -0,0 +1,23 @@
+#ifndef PIECE
+#define PIECE
+
+#include <iostream>
+
+class Piece {
+  friend std::ostream &operator<<(std::ostream &, const Piece &);
+
+  // Couleur de la pièce (peut-être à formaliser, juste blanc ou noir pour les
+  // dames)
+  std::string couleur;
+  // Type de la pièce (pion ou dame pour les dames)
+  std::string type;
+
+public:
+  Piece();          // constructor
+  virtual ~Piece(); // destructor
+
+  Piece(const Piece &);                  // copy constructor
+  const Piece &operator=(const Piece &); // copy assignement
+};
+
+#endif

includes/Plateau.hpp

@@ -0,0 +1,27 @@
+#ifndef PLATEAU
+#define PLATEAU
+
+#include <iostream>
+
+class Plateau {
+  friend std::ostream &operator<<(std::ostream &, const Plateau &);
+
+  // Il faudrait sûrement un tableau pour initialiser le plateau, mais je suis
+  // pas sûr du type de l'attribut. J'avais pensé à un tableau de Piece (avec la
+  // case à null si aucune piece dessus), je sais pas si c'est une bonne idée.
+
+public:
+  Plateau();          // constructor
+  virtual ~Plateau(); // destructor
+
+  Plateau(const Plateau &);                  // copy constructor
+  const Plateau &operator=(const Plateau &); // copy assignement
+
+  // Fonction pour initialiser le plateau
+
+  // Fonction pour afficher le plateau
+
+  // Fonction pour modifier le plateau
+};
+
+#endif

src/Dames.cpp

@@ -0,0 +1,15 @@
+#include "../includes/Dames.hpp"
+
+Dames::Dames() { std::cout << "dames\n"; }
+
+Dames::~Dames() {}
+
+Dames::Dames(const Dames &) {}
+
+const Dames &Dames::operator=(const Dames &src) {
+  if (this == &src) {
+    return *this;
+  }
+
+  return *this;
+}

src/Joueur.cpp

@@ -0,0 +1,15 @@
+#include "../includes/Joueur.hpp"
+
+Joueur::Joueur() { std::cout << "joueur\n"; }
+
+Joueur::~Joueur() {}
+
+Joueur::Joueur(const Joueur &) {}
+
+const Joueur &Joueur::operator=(const Joueur &src) {
+  if (this == &src) {
+    return *this;
+  }
+
+  return *this;
+}

src/Mouvement.cpp

@@ -0,0 +1,15 @@
+#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;
+}

src/Piece.cpp

@@ -0,0 +1,15 @@
+#include "../includes/Piece.hpp"
+
+Piece::Piece() { std::cout << "pièce\n"; }
+
+Piece::~Piece() {}
+
+Piece::Piece(const Piece &) {}
+
+const Piece &Piece::operator=(const Piece &src) {
+  if (this == &src) {
+    return *this;
+  }
+
+  return *this;
+}

src/Plateau.cpp

@@ -0,0 +1,15 @@
+#include "../includes/Plateau.hpp"
+
+Plateau::Plateau() { std::cout << "plateau\n"; }
+
+Plateau::~Plateau() {}
+
+Plateau::Plateau(const Plateau &) {}
+
+const Plateau &Plateau::operator=(const Plateau &src) {
+  if (this == &src) {
+    return *this;
+  }
+
+  return *this;
+}