Etapes guidées de développement

Un chemin balisé vers votre premier jeu Rust

Pour vous assurer une progression fluide et didactique dans la création de votre jeu de devinette en Rust, nous allons suivre une série d'étapes guidées de développement. Cette approche structurée permet de décomposer le projet global en tâches plus petites et plus gérables, facilitant ainsi la compréhension et l'implémentation de chaque composant du jeu. Chaque étape s'appuiera sur la précédente, construisant progressivement l'application complète.

L'objectif de ce guide pas à pas n'est pas seulement de vous fournir le code final, mais de vous faire comprendre la logique derrière chaque décision et chaque ligne écrite. Nous mettrons en lumière les concepts Rust spécifiques utilisés à chaque phase, renforçant ainsi votre apprentissage théorique par une application pratique immédiate.

Suivre ces étapes vous permettra de voir concrètement comment un projet Rust prend forme, depuis la configuration initiale jusqu'au programme fonctionnel. C'est une méthode éprouvée pour acquérir de la confiance et développer de bonnes habitudes de développement.

Etape 1 : initialisation du projet avec Cargo et structure de base

Tout projet Rust commence par sa création avec Cargo, l'outil de gestion de projet et de build de Rust. Ouvrez votre terminal ou invite de commandes et naviguez jusqu'au répertoire où vous souhaitez créer votre projet. Ensuite, exécutez la commande suivante :

cargo new guessing_game
cd guessing_game

Cette commande crée un nouveau répertoire nommé guessing_game contenant une structure de projet Rust minimale, incluant un fichier Cargo.toml (le manifeste du projet) et un répertoire src avec un fichier main.rs contenant un "Hello, world!".

Ouvrez le fichier src/main.rs. Pour l'instant, il devrait ressembler à ceci :

fn main() {
    println!("Hello, world!");
}

Nous allons commencer par afficher un message de bienvenue pour notre jeu. Modifiez src/main.rs pour qu'il contienne :

fn main() {
    println!("Devinez le nombre !");
    // D'autres étapes viendront ici
}

Vous pouvez compiler et exécuter ce squelette avec cargo run. Cette première étape valide que votre environnement est fonctionnel et que la structure de base du projet est en place.

Etape 2 : génération du nombre secret à deviner

Le coeur du jeu est le nombre secret que l'utilisateur doit deviner. Nous allons utiliser la crate rand pour le générer. Assurez-vous d'abord d'ajouter rand à vos dépendances dans Cargo.toml :

[dependencies]
rand = "0.8.5" # Ou la version la plus récente

Ensuite, modifiez votre fichier src/main.rs pour générer un nombre aléatoire entre 1 et 100 :

use rand::Rng;

fn main() {
    println!("Devinez le nombre !");

    let secret_number = rand::thread_rng().gen_range(1..=100);

    // Pour le moment, affichons le nombre secret pour faciliter le test
    // Vous supprimerez cette ligne plus tard
    println!("Le nombre secret est : {}", secret_number);

    // La suite du jeu viendra ici
}

Compilez et exécutez (cargo run). Vous devriez voir le message de bienvenue suivi du nombre secret généré. Relancez plusieurs fois pour vérifier que le nombre change.

Etape 3 : lecture de la proposition de l'utilisateur

Maintenant, nous devons permettre à l'utilisateur de saisir sa proposition. Nous utiliserons le module std::io. Modifiez src/main.rs comme suit :

use std::io;
use rand::Rng;

fn main() {
    println!("Devinez le nombre !");

    let secret_number = rand::thread_rng().gen_range(1..=100);
    // println!("Le nombre secret est : {}", secret_number); // Optionnel pour le débogage

    println!("Veuillez entrer votre proposition.");

    let mut guess = String::new(); // `mut` car son contenu va changer

    io::stdin()
        .read_line(&mut guess)
        .expect("Echec de la lecture de l'entrée utilisateur");

    println!("Vous avez proposé : {}", guess.trim()); // .trim() pour enlever le \n final
}

Exécutez le programme. Il devrait maintenant attendre que vous entriez une valeur et appuyiez sur Entrée, puis afficher ce que vous avez tapé. La méthode trim() est utilisée ici pour enlever les espaces blancs et le caractère de nouvelle ligne à la fin de la saisie, ce qui est souvent souhaitable.

Etape 4 : comparaison des nombres et introduction de la boucle de jeu

La proposition de l'utilisateur est une chaîne de caractères (String). Pour la comparer au secret_number (qui est un entier), nous devons la convertir en nombre. Nous allons aussi introduire une boucle loop pour permettre plusieurs tentatives.

Modifions src/main.rs :

use std::io;
use rand::Rng;
use std::cmp::Ordering; // Pour comparer

fn main() {
    println!("Devinez le nombre !");

    let secret_number = rand::thread_rng().gen_range(1..=100);
    // println!("Le nombre secret est : {}", secret_number); // Optionnel

    loop { // Boucle pour plusieurs tentatives
        println!("Veuillez entrer votre proposition.");

        let mut guess_str = String::new();

        io::stdin()
            .read_line(&mut guess_str)
            .expect("Echec de la lecture de l'entrée utilisateur");

        // Conversion de la chaîne en nombre u32
        // Et gestion d'une entrée invalide
        let guess: u32 = match guess_str.trim().parse() {
            Ok(num) => num,
            Err(_)  => {
                println!("Veuillez entrer un nombre valide !");
                continue; // Passe à la prochaine itération de la boucle
            }
        };

        println!("Vous avez proposé : {}", guess);

        match guess.cmp(&secret_number) {
            Ordering::Less    => println!("Trop petit !"),
            Ordering::Greater => println!("Trop grand !"),
            Ordering::Equal   => {
                println!("Bravo, vous avez trouvé !");
                break; // Sort de la boucle `loop`
            }
        }
    }
}

Nous avons ajouté :

• Une boucle loop.
• La conversion de guess_str en u32 avec parse(). La méthode parse() retourne un Result, que nous gérons avec un match. Si la conversion échoue (par exemple, si l'utilisateur tape du texte), nous affichons un message et utilisons continue pour recommencer la boucle.
• La comparaison de guess avec secret_number en utilisant cmp() et un match sur Ordering.
• Un break pour sortir de la boucle lorsque l'utilisateur trouve le bon nombre.

Testez votre jeu ! Il devrait maintenant fonctionner complètement. Essayez de gagner, et essayez aussi d'entrer des valeurs non numériques pour voir comment la gestion d'erreur réagit. N'oubliez pas de supprimer ou commenter la ligne qui affiche le nombre secret si vous l'aviez laissée pour le débogage.

Etape 5 (Optionnelle) : raffinements et bonnes pratiques

A ce stade, votre jeu est fonctionnel. Voici quelques pistes pour aller plus loin ou améliorer le code :

• Meilleure gestion des erreurs de read_line : Actuellement, nous utilisons .expect(). Dans une application plus robuste, vous pourriez vouloir gérer cette erreur plus gracieusement.
• Nombre de tentatives : Vous pourriez compter et afficher le nombre de tentatives que l'utilisateur a mis pour trouver le nombre.
• Proposer de rejouer : Une fois la partie terminée, demandez à l'utilisateur s'il veut rejouer et relancez le jeu si c'est le cas.
• Clarté du code : Si le code de la boucle devient trop long, vous pourriez envisager de le découper en plus petites fonctions.

Ces étapes guidées vous ont permis de construire votre premier programme Rust interactif. Félicitations ! Vous avez mis en pratique de nombreux concepts clés du langage. Prenez le temps de bien comprendre chaque partie du code. N'hésitez pas à expérimenter et à modifier le jeu pour le personnaliser.