Réalisation d'un pendu en java

Bon comme aujourd’hui j’ai mon examen de java, je me suis dit que j’allais réaliser un petit jeu, un pendu en java.

Bien qu’est-ce qu’il nous faut pour réaliser un pendu en java ?

Il nous faut deux « class »:

• La première qui contient toutes les fonctions du pendu
• La seconde qui contient le Testeur (ou le main)

Hangman contiendra Cinq méthodes:
La première fonction est simple, elle va populer nos variables.
L’une qui nous retourne true ou false, si la lettre entrée est contenue dans le mot.
L’autre qui affichera le tableau avec les éléments trouvés, sinon des petites étoiles.
Encore une qui remplacera dans un espace tampon les étoiles par la lettre trouvée.
Une fonction pour savoir si le joueur gagne ou pas.
La dernière qui fera un décompte du nombre de coup possible.

Allez c’est parti mon kiki!!

class Hangman{
    private char word[] = new char[5];
    private char hidden[] = new char[5];
    private static int hanged = 10;
    public Hangman(){}
    public boolean isInside(char letter){}
    public boolean isHanged(){}
    public void displayWord(){}
    public void replaceChar(char letter){}
}

Voila comment je la voie la classe, plutôt simple à vrai dire.
Bien occupons-nous de la fonction contructeur en premier!
Alors pour ce faire, nous allons statiquement insérer notre mot dans le tableau « word », bon parce que je n’ai pas besoin de plus pour avancer. On pourra améliorer cela plus tard. J’ai choisi arbitrairement le mot « tatoo ».

Ensuite je crée une autre variable avec de la même taille que notre « word » mais je la remplie avec des étoiles ..

	public Hangman(){
		word[0] = 't';
		word[1] = 'a';
		word[2] = 't';
		word[3] = 'o';
		word[4] = 'o';
		for(int i = 0; i < word.length; i++){
			hidden[i] = '*';
		}
	}

La méthode isInside() va nous permettre de vérifier la lettre entrée par le joueur fait bien partie ou non du mot à trouver. Elle renverra simplement un boolean, true si tel est le cas, false dans le cas contraire. J’ai décidé par défault de mettre ma variable value à false pour dire, par default elle ne contient pas, et si lors de ma boucle je trouve ne fusse qu’une seule fois la lettre, je la remplace par true et je fais un break pour casser mon code et retourner le resultat.

    public boolean isInside(char letter){
        boolean value = false;
        for(int i = 0; i < word.length; i++){
            if(word[i] == letter){
                value = true;
                break;
            }
        }
        return value;
    }

Ma méthode isHanged() est juste un compteur, elle va servir à corser un peu la difficulté du jeu. Pour pas non plus que le joueur essaie toutes les lettres de l’alphabet pépère .. elle retourne true si le compteur est arrivé à 0 .. Dans ce cas il faudra lui dire qu’il a perdu.

    public boolean isHanged(){
        boolean value = false;
        if(hanged <= 0){
            value = true;
        }
        return value;
    }

displayWord() servira juste à afficher au joueur l'avancement de son jeu et lui permettre de voir les mots qu'il a découverts.

    public void displayWord(){
        System.out.print("The word is: ");
        for(int i = 0; i < hidden.length; i++){
            System.out.print(hidden[i]);
        }
    }

Evidemment lorsque la lettre de l'utilisateur fait partie du mot à trouver on dévoilera au joueur les cases dans lesquelles se trouve sa lettre. C'est bien le but de jeu n'est-ce pas ?

    public void replaceChar(char letter){
        for(int i = 0; i < word.length; i++){
            if(word[i] == letter){
                hidden[i] = letter;
            }
        }
    }

Et pis la fonction finale, elle permet de savoir si le joueur a gagné ou non! Et comment peut-on le savoir? Bin le joueur gagne quand "hidden" ne contient plus d'étoile. simple non?

    public boolean win(){
        int count = 0;
        boolean value = false;
        for(int i = 0; i < word.length; i++){
            if(hidden[i] == '*'){
                value = true;
                break;
            }
        }
        return value;
    }

On rentre dans le vif: Alors on décompose étape par étape les actions qu’on veut faire:

• On instancie notre classe
• On affiche à l'utilisateur le mot plein d'étoiles fraichement populées: le joueur sait
  alors plus ou moins combien de caractères il doit trouver
• On sait que le joueur jouera tant qu'il ne sera ni mort, ni que le nombre de tour max expiré
• On récupère la lettre de l'user après lui avoir demande 🙂
• On crée une condition:
• dans le premier cas la lettre est contenu dans le mot final, dans ce cas on affiche le message adéquat, et on remplace dans la variable que l'utilisateur peut voir l'endroit ou se trouve la lettre dans le "word"
• dans le second cas on affiche juste le message que rien ne s'est passé
• On affiche l'avancé du mot, et on décrémente de 1 le tour du joueur
• Quand on sort de la boucle on indique au joueur s'il a perdu ou s'il a gagné

public class TestHangman {
	public static void main(String[] args){
		Hangman hangman = new Hangman();
		hangman.displayWord();
		System.out.println("\n---------------------");
		do{
			System.out.print("\nEnter a letter: ");
			char letter = Clavier.lireChar();

			if(hangman.isInside(letter)){
				hangman.replaceChar(letter);
				System.out.print("### Exellent, the letter is inside! ###\n");
			}
			else{
				System.out.print("### The letter is not inside! ###\n");
			}
			System.out.println("");
			hangman.displayWord();
                        this.hanged--;
		}
		while(!hangman.isHanged() && !hangman.win());
		if(hangman.win()){
			System.out.print("\n#####################################\n");
			System.out.print("### Congratulations !! you won !! ###\n");
			System.out.print("#####################################\n\n");
		}
		else if(hangman.isHanged()){
			System.out.print("\n##########################################\n");
			System.out.print("### Sorry try again, the guy is dead.. ###\n");
			System.out.print("##########################################\n\n");
		}
	}
}

Voilà j’espère que ça vous a plu 😉