ENIB S5-OBJ_Rust - Exemple d'examen

{} Étape 0 : Prise en main du code fourni

{} Étape 1 : Création de la structure Card

Commencez par compléter le module card (fichier card.rs) en fournissant la classe Card représentant une carte.
Aidez-vous avec le diagramme en figure. Appliquez l’encapsulation.

Les instances de cette classe recevront à leur construction leur emplacement sur le plateau (row et column).
Conseil : row et column doivent être de type usize.
Ces données membres, une fois affectées, ne devront plus être modifiées.
Offrez toutefois la possibilité de consulter ces deux membres ; ce sera utile pour la suite (méthodes row() et column()).
La classe Card doit aussi contenir une donnée membre booléenne (hidden) qui indique si la carte a été retirée ou pas du plateau.
À la création d'une carte cette donnée doit évidemment valoir false.
Fournissez une fonction membre hidden() pour la consulter et une autre fonction membre hide() qui permet de modifier sa valeur en lui affectant true.
Cette dernière fonction sera invoquée lorsque la carte devra être retirée du plateau.
Enfin, ajoutez une dernière donnée membre booléenne flipped à la classe Card.
Elle indique si la carte est retournée (elle montre sa face) ou pas (elle montre son dos), à la création d'une carte cette donnée doit évidemment valoir false.
Fournissez une fonction membre flipped() pour la consulter et une fonction membre flip() pour inverser sa valeur (si elle vaut false elle devient true, si elle vaut true elle devient false).

Permettez aux cartes de se dessiner sur le plateau lorsque celui-ci le demandera.
À cet effet, ajoutez une fonction membre draw(). Voici le code pour le dessin de la carte, à adapter, bien évidemment.

let pos = s5::Point {
  x: Board::CARD_SIDE * (0.5 + /* column de la carte */ ),
  y: Board::CARD_SIDE * (0.5 + /* row de la carte */ ),
};
let rect = s5::Rect {
  w: Board::CARD_SIDE * 0.85,
  h: Board::CARD_SIDE * 0.85,
};
//let color = ???;
screen.rectangle(&pos, &rect, None, 0.0, color);

Remarquez, à partir du diagramme de classes, que la variable screen est de type Screen, fourni par le module s5. La couleur de la carte dépend du côté visible. Le dos doit être d'un gris foncé (50, 50, 50), la face doit être presque blanche (200, 200, 200).
Attention ! Évidemment, le dessin de la carte se fait seulement si elle n'a pas été retirée du plateau, dans ce cas le dessin ne fait tout simplement rien.

La fonction is_like() sera implémentée à l’étape 4. Pour le moment, vous pouvez ne pas la mettre du tout ou juste l’implémenter de façon très triviale, par exemple en lui faisant renvoyer tout simplement false.

Assurez-vous du fait que la compilation de votre code ne produit pas d'erreur avant de passer à l’étape suivante.

{} Étape 2 : Un plateau de cartes. Modification de la classe Board.

{} Étape 3 : On clique sur les cartes... et on les retourne.

{} Étape 4 : Diversification des comportements. Introduction de l’interface CardBehavior.

{} Étape 5 : Les carreaux et les cœurs.

Pour exploiter la possibilité introduite à l’étape précédente, nous allons réaliser, dans le module behaviors.rs, des implémentations de l’interface CardBehavior.
Ces implémentations complètent le diagramme de classes simplifié comme suit :

La classe Diamond doit implémenter l’interface CardBehavior.
Elle mémorise un objet Color qui lui est transmis à sa construction.

Sa définition de la fonction draw() doit dessiner, au centre de la carte, un losange ayant la couleur mémorisée.
Voici le code, bien évidemment à adapter à votre cas :

let pos = s5::Point {
  x: Board::CARD_SIDE * (0.5 + /* column de la carte */ ),
  y: Board::CARD_SIDE * (0.5 + /* row de la carte */ ),
};
let rect = s5::Rect {
  w: Board::CARD_SIDE * 0.35,
  h: Board::CARD_SIDE * 0.35,
};
screen.rectangle(&pos, &rect, None, 0.25 * std::f64::consts::PI, color);

Enfin, la définition de la fonction kind() doit renvoyer la string obtenue comme suit :

  format!("D{:?}", color)

Attention ! On parle bien de la couleur du diamant ! Adaptez le code à votre cas.

La classe Heart doit aussi implémenter l’interface CardBehavior.
Elle mémorise également un objet Color qui lui est transmis à sa construction.
Sa définition de la fonction draw() doit dessiner, au centre le carte, un disque ayant la couleur mémorisée.
Inspirez-vous de ce que vous venez de faire pour le type Diamond, en sachant que pour dessiner un cercle le type Screen fournit une fonction ellipse().
Si vous ne vous souvenez pas de comment invoquer cette fonction (vous l’avez vu en labo), n’hésitez pas à regarder son prototype dans le module s5.

Enfin, la définition de la fonction kind() de la classe Heart doit renvoyer la string obtenue comme suit :

  format!("H{:?}", color)

Attention ! On parle bien de la couleur du cœur ! Adaptez le code à votre cas.

Il ne reste plus qu’à faire usage de ces comportements.
Intervenez à nouveau dans le constructeur de Board afin de prendre en compte les commentaires qui vous indiquent quand un Diamond ou un Heart doit être construit pour le transmettre à la carte sur le point d’être créée.
La couleur à transmettre est déjà déclarée dans le code, utilisez-la.
Cette dernière modification, résoudra l’erreur dans le constructeur de la classe Board introduite à l’étape précédente.

En fabriquant et en relançant votre programme, vous devriez constater que, lorsqu'on retourne une carte, elle peut montrer un cercle rouge ou un cercle bleu, un losange vert ou un losange jaune.

{} Étape 6 : Le cœur du jeu