ENIB S5-OBJ_Rust - Sujet d'entrainement

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

Un projet de départ est fourni : MatchCard.zip.
Il est accompagné du script run_s5obj.sh.

Compilez le projet (cargo build) et vérifiez qu'il ne produit aucune erreur.
Conservez cet état de compilation tout au long du développement.

Lancez ensuite l'application (./run_s5obj.sh).
Une fenêtre grise de 800 × 800 pixels s'ouvre.
Elle détecte les clics de la souris et se ferme automatiquement après 20 secondes (ou avec la touche Échap ou le bouton de fermeture de la fenêtre).

Le plateau de jeu est représenté par la structure Board (module simu).
Le module s5, déjà utilisé dans les laboratoires, fournit les principaux types graphiques (Color, Rect, Point, Screen, etc.).
Le fichier s5.rs ne doit pas être modifié.

Avant de commencer, prenez quelques minutes pour parcourir le code fourni.

Si nécessaire, exécutez la commande enib_rust_setup afin de configurer Sublime Text.

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

Complétez le module card (card.rs) en définissant la structure Card conformément au diagramme de classes.
Veillez à respecter l'encapsulation.

Chaque carte connaît sa position sur le plateau à travers les attributs row et column, initialisés lors de la construction de l'objet.
Ces valeurs ne doivent plus être modifiées par la suite, mais doivent pouvoir être consultées à l'aide des méthodes row() et column().

Ajoutez ensuite deux attributs booléens :

hidden, indiquant si la carte a été retirée du plateau ;
flipped, indiquant si la carte est retournée.

À la création d'une carte, ces deux attributs valent false.

Implémentez le constructeur, les méthodes permettant de consulter ces attributs ainsi que les opérations hide(), qui affecte true à hidden, et flip(), qui inverse la valeur de flipped.

Ajoutez enfin une méthode draw(), appelée par le plateau pour dessiner la carte.
Le code ci-dessous illustre le dessin du fond de la carte et devra être adapté à votre implémentation.

let pos = s5::Point {
  x: Board::CARD_SIDE * (0.5 + /* column de la carte */ as f64),
  y: Board::CARD_SIDE * (0.5 + /* row de la carte */ as f64),
};
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);

La couleur dépend de l'état de la carte :

le dos est gris foncé (50, 50, 50) ;
la face est presque blanche (200, 200, 200).

Une carte retirée du plateau ne doit plus être dessinée.

La méthode is_like() sera implémentée à l'étape 4.
Vous pouvez, pour l'instant, l'omettre ou lui faire simplement renvoyer false.

Avant de passer à l'étape suivante, vérifiez que votre code compile sans erreur.

{3 #etape_2 } Étape 2 : Un plateau de cartes

La structure Board doit être liée à Card par composition multiple, comme l'indique le diagramme suivant.

Implémentez cette composition.

Toutes les cartes étant créées par le plateau lors de sa construction, il n'est pas nécessaire de prévoir une méthode add().
Complétez le constructeur de Board, qui contient déjà deux boucles imbriquées permettant de créer les 16 emplacements du plateau.
Pour chaque couple (row, column), créez une nouvelle carte et ajoutez-la à la composition.

Les commentaires présents dans le constructeur vous guideront pour cette étape.
Ignorez pour l'instant ceux qui concernent le comportement des cartes ; ils seront utilisés aux étapes suivantes.

Les directives use nécessaires sont déjà présentes dans les fichiers, mais commentées.
Décommentez-les au fur et à mesure de vos besoins.

Complétez ensuite la méthode redraw() afin qu'elle dessine toutes les cartes du plateau.

À l'issue de cette étape, les 16 cartes doivent apparaître correctement alignées, toutes affichées de dos.

{4 #etape_3 } Étape 3 : Retourner les cartes.

Implémentez le code permettant de retourner une carte lorsqu'elle est cliquée.

La méthode Board::click() reçoit déjà les événements de la souris et calcule l'indice (index) de la carte sélectionnée.
Les commentaires présents dans cette méthode indiquent où compléter le code.

Une carte ne peut être retournée que si elle est encore présente sur le plateau et qu'elle est actuellement face cachée.

À cette étape, plusieurs cartes peuvent être retournées simultanément.
La limitation à deux cartes sera introduite lors de la dernière étape.

Les attributs card1 et card2 de la structure Board mémorisent les indices des deux cartes actuellement retournées, ou valent -1 lorsqu'aucune carte n'est enregistrée.

Vérifiez que les cartes se retournent correctement lorsqu'elles sont cliquées.
Si le comportement n'est pas celui attendu, contrôlez en priorité les conditions utilisées dans la méthode draw().

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

Nous souhaitons maintenant différencier les cartes en leur associant un comportement de dessin.

Déclarez, dans le module simu.rs, le trait CardBehavior conformément au diagramme de classes.
Il déclare deux méthodes :

draw(), qui dessine le symbole de la carte ;
kind(), qui identifie son type.

Pour rappel, une interface est représentée en Rust par un trait.

Implémentez ensuite une composition entre Card et CardBehavior, comme indiqué dans le diagramme.

Le constructeur de Card devra désormais recevoir un objet implémentant ce trait.

Modifiez la méthode draw() de Card : lorsqu'une carte est retournée, elle doit dessiner sa face puis déléguer le dessin du symbole à son comportement.

Implémentez également la méthode is_like().
Deux cartes sont considérées identiques si leurs comportements renvoient la même valeur avec kind().

Le constructeur de Board ne compile plus à ce stade, car il ne fournit pas encore de comportement aux cartes.
Ce problème sera résolu à l'étape suivante.

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

Implémentez, dans le module behaviors.rs, les deux types concrets Diamond et Heart, conformément au diagramme de classes.

Ces deux structures implémentent le trait CardBehavior et mémorisent une couleur transmise lors de leur construction.

Diamond
La méthode draw() dessine un losange de la couleur mémorisée au centre de la carte.
Le code ci-dessous illustre l'utilisation de l'API graphique et devra être adapté à votre implémentation.

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);

La méthode kind() renvoie :

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

en utilisant la couleur du losange.

Heart
Implémentez ensuite la structure Heart en vous inspirant de Diamond.

La méthode draw() dessine un disque coloré au centre de la carte.
Pour cela, utilisez la méthode ellipse() du type Screen.
Si nécessaire, consultez son prototype dans le module s5.

La méthode kind() renvoie :

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

en utilisant la couleur du cœur.

Utilisation des comportements
Modifiez enfin le constructeur de Board afin d'associer à chaque carte un comportement Diamond ou Heart, conformément aux commentaires présents dans le code fourni.

À l'issue de cette étape, les cartes retournées doivent afficher un cœur ou un losange de la couleur qui leur a été attribuée.

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

Il reste à implémenter la règle qui permet de retirer les paires de cartes.

La méthode Board::animate() est appelée en continu.
Elle gère déjà le temps de jeu et le nombre de paires découvertes.
La partie se termine lorsque 20 secondes se sont écoulées ou lorsque les 8 paires ont été trouvées.

Complétez cette méthode afin de vérifier si les deux cartes actuellement retournées sont identiques.
Si c'est le cas, retirez-les du plateau ; sinon, retournez-les à nouveau.

Pour rappel, les attributs card1 et card2 de Board contiennent les indices des deux cartes retournées, ou valent -1 lorsqu'aucune carte n'est enregistrée.

Les commentaires présents dans la méthode animate() indiquent où compléter le code.

Une fois cette dernière étape terminée, votre jeu doit être entièrement fonctionnel.

Et maintenant amusez-vous bien !