Hangman es un popular juego de adivinanzas de palabras en el que el jugador se esfuerza por construir una palabra perdida especulando una letra a la vez. Después de un cierto número de conjeturas fuera de base, el juego termina y el jugador pierde. El juego también termina cuando el jugador distingue con precisión todas las letras de la palabra perdida. La implementación de este juego en Java se muestra a continuación.
Ejemplo:
Salida :
Bienvenido al JUEGO DEL HANGMAN
, juguemos el juego
_ _ _ _ _ _
Su conjetura:
Entrada : s
Salida :
S no está presente en la palabra.
_ _ _ _ _ _
Te quedan 4 intentos.
Su conjetura:
Entrada : m
Salida :
M no está presente en la palabra.
_ _ _ _ _ _
Te quedan 3 intentos.
Su conjetura:
Entrada: d
Salida :
D no está presente en la palabra.
_ _ _ _ _ _
Te quedan 2 intentos.
Su conjetura:
Entrada : t
Salida :
T está presente en la palabra.
T_ _ _ T_
Te quedan 2 intentos.
Su conjetura:
Entrada : o
Salida :
O está presente en la palabra.
TO_ OT_
Te quedan 2 intentos.
Su conjetura:
Entrada : y
Salida :
Y está presente en la palabra.
TOYOT_
Te quedan 2 intentos.
Su conjetura:
Entrada : a
Salida :
A está presente en la palabra.
La palabra es: TOYOTA
¡Bien jugado, lo hiciste!
Java es un dialecto de programación informática de propósito general que es concurrente, basado en clases, orientado a objetos y especialmente diseñado para tener la menor cantidad de dependencias posible. Java ha dedicado una biblioteca completa a los números aleatorios al ver su importancia en la programación del día a día. nextInt() , una función, se usa en el código de este artículo. Este juego es para principiantes que están aprendiendo a codificar en Java y para darles un breve resumen sobre el uso de strings, bucles y sentencias condicionales.
Comprender el juego
El jugador debe adivinar una palabra. Entonces, la pantalla de salida mostrará la cantidad de guiones que representan las letras que quedan por adivinar. Entonces el jugador adivinará una letra. Si esa letra está presente en la palabra, el programa reemplazará los guiones con la letra en cada lugar donde aparezca. Si la letra no está presente en la palabra, se reduce el número de líneas de vida (que consiste en un número finito de posibilidades). El jugador gana el juego tan pronto como haya adivinado correctamente todas las letras de la palabra.
Plan de juego:
El usuario debe comenzar por adivinar las letras que aparecen más en la palabra que son vocales ( a , e , i , o , u ). Aparte de las vocales, las otras letras más utilizadas son t , n , s , h , r , d y l .
Implementación del juego.
En el programa, se ha creado un Class Game en el que se crea una lista de strings que consta de palabras. En la lista de palabras, se elegirá una palabra al azar usando un módulo aleatorio ( java.util.Random ) para que el usuario adivine sus letras. Después de elegir la palabra, todas las letras se escriben en mayúsculas usando la función toUpperCase() y luego esas letras se reemplazan por guiones. El número máximo de conjeturas incorrectas permitidas en el juego es 5, si el usuario va más allá, perderá el juego. En el ciclo while a medida que el usuario comienza a adivinar las letras, las conjeturas correctas reemplazarán los guiones por letras correctas, mientras que las conjeturas incorrectas aumentarán la variable contando el número de conjeturas incorrectas en 1 .
- La primera condición se utiliza para informar al usuario sobre las líneas de vida que quedan cuando el usuario ha adivinado la letra equivocada.
- La segunda condición se usa para decirle al usuario que las letras ingresadas ya han sido adivinadas.
- La tercera condición es verificar si la nueva letra adivinada está presente en la palabra o no, si son correctas, los guiones se reemplazan por las letras correctas.
- Si la letra no está presente en la palabra, la línea de vida se reduce en 1.
El juego termina si se cumple alguna de las condiciones:
- El usuario ha adivinado la palabra completa correctamente.
- Las líneas de vida del usuario han terminado.
Java
// Java program to implement
// Hangman game
import java.util.Scanner;
import java.util.Random;
class Game {
static Scanner input;
public static void hangman()
{
input = new Scanner(System.in);
// array of strings containing words
String[] company = { "Maruti", "Tata", "Suzuki",
"Ducati", "Toyota" };
System.out.println(
" Welcome to HANGMAN GAME ");
Random obj = new Random();
int Ran_num = obj.nextInt(5);
// takes input of the word
String word = (company[Ran_num]);
word = word.toUpperCase();
// To show the word in underscores
String word1 = word.replaceAll("[A-Z]", "_ ");
// play the game
System.out.println("let's play the game");
startGame(word, word1);
}
public static void startGame(String word, String word1)
{
// total guesses
int guess_ = 0;
// number of wrong guesses
int wrong = 0;
// for each guess
String guess;
// stores the guessed letter
char letter;
// stores if the letter was
// already guessed
boolean guessescontainsguess;
String guesses = "";
boolean guessinword;
// while loop starts here
while (wrong < 5 && word1.contains("_")) {
System.out.println(word1 + "\n");
int temp = 5 - wrong;
if (wrong != 0) {
// for picture 1
System.out.println("You have " + temp
+ " guesses left.");
}
System.out.print("Your Guess:");
// takes guess input
guess = input.nextLine();
// converts to uppercase
// for comparison
guess = guess.toUpperCase();
// gets the first letter
// as guessed letter
letter = guess.charAt(0);
guessescontainsguess
= (guesses.indexOf(letter)) != -1;
// stores every letter
// guessed in guesses
guesses += letter;
// converts to uppercase for
// comparison
letter = Character.toUpperCase(letter);
System.out.println();
// if letter already guessed
if (guessescontainsguess == true) {
// already guessed letter
System.out.println("You ALREADY guessed "
+ letter + ". \n");
}
// guessed letter is in the word
guessinword = (word.indexOf(letter)) != -1;
// if statement begins
if (guessinword == true) {
// print the letter
System.out.println(
letter + " is present in the word.");
System.out.print("\n");
// find the letter positions
// replace dashes with those
// letter at valid positions
for (int position = 0;
position < word.length(); position++) {
// guessed letter is equal to
// letter at position in word
// and word1 has previously does not
// have that letter
if (word.charAt(position) == letter
&& word1.charAt(position)
!= letter) {
word1 = word1.replaceAll("_ ", "_");
String word2;
word2 = word1.substring(0, position)
+ letter
+ word1.substring(position
+ 1);
word2 = word2.replaceAll("_", "_ ");
word1 = word2;
}
}
}
// if statement ends, else if begins
else {
// prints
// wrong = wrong + 1, after every
// wrong answer
System.out.println(
letter
+ " is not present in the word.");
wrong++;
}
// guess_ = guess_ + 1, after every
// attempt
guess_++;
} // while loop ends
// if the lifelines finishes
if (wrong == 5) {
System.out.println(
"YOU LOST!, maximum limit of incorrect guesses reached.");
}
else {
// when solved
System.out.print(
"The word is: " + word1
+ "\n Well Played, you did it!!");
}
}
public static void main(String[] args)
{
// play hangman game
hangman();
}
}
Producción:
Nota: Este es un juego interactivo, así que juega en la consola.
Publicación traducida automáticamente
Artículo escrito por shardul_singh_tomar y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA