Piedra, papel, tijera es un juego de manos jugado por dos personas. Ambas personas dirían "piedra, papel, tijeras" y luego formarían simultáneamente uno de los tres objetos (piedra, papel o tijeras) con la mano extendida. El ganador está determinado por las formaciones de las manos. La tijera vence al papel, el papel vence a la piedra y la piedra vence a las tijeras. Si ambos jugadores juegan la misma formación de mano, se considera un empate. Escribiremos un juego simple en Java para simular Piedra, Papel, Tijeras donde un jugador es el usuario y el otro jugador es la computadora.
Pasos
Paso 1. Crea la clase principal y llámala
Piedra Papel tijeras
.
Esta será la clase donde escribiremos el juego. Puede elegir ponerle otro nombre, como
Juego
o
Principal
. Escriba declaraciones de método para el constructor y el método principal.
public class RockPaperScissors {public RockPaperScissors () {} public static void main (String args) {}}
Paso 2. Cree una enumeración para los gestos con las manos (piedra, papel o tijeras)
Podríamos usar cadenas para representar piedra, papel o tijeras, pero una enumeración nos permite predefinir nuestras constantes, lo que significa que usar la enumeración es un mejor diseño. Llamaremos a nuestro tipo de enumeración
Moverse
con los valores
ROCA
PAPEL
y
TIJERAS
private enum Move {ROCK, PAPER, SCISSORS}
Paso 3. Crea dos clases privadas
Usuario
y
Computadora
.
Estas clases representarán a nuestros jugadores en el juego. Puede optar por hacer públicas estas clases. los
Usuario
clase será la clase que solicita al usuario piedra, papel o tijeras, por lo que tendremos que escribir una
getMove ()
método. los
Computadora
la clase también necesitará tener un
getMove ()
método para que la computadora también pueda hacer un movimiento. Pondremos marcadores de posición en estos métodos y los implementaremos más tarde. los
Usuario
clase requerirá un constructor que configure el
Escáner
objeto a tomar en la entrada del usuario. Pondremos el
Escáner
como un campo privado para el usuario y luego iniciarlo en el constructor. Dado que estamos usando el
Escáner
class, necesitamos escribir una declaración de importación para ella en la parte superior de nuestro código. los
Computadora
la clase no requiere un constructor, por lo que no es necesario escribir uno; cuando iniciamos el
Computadora
object, solo llamaremos al constructor predeterminado. Esto es lo que nuestro
Piedra Papel tijeras
la clase se ve como ahora:
import java.util. Scanner; public class RockPaperScissors {private enum Move {ROCK, PAPER, SCISSORS} clase privada User {private Scanner inputScanner; Public User () {inputScanner = new Scanner (System.in); } public Move getMove () {// TODO: Implementar este método return null; }} clase privada Computer {public Move getMove () {// TODO: Implementar este método return null; }} public RockPaperScissors () {} public static void main (String args) {}}
Paso 4. Escribe el
getMove ()
método para el
Computadora
clase.
Este método devolverá un aleatorio
Moverse
. Podemos obtener una variedad de
Moverse
enumeraciones llamando al
valores()
método:
Move.values ()
. Para elegir al azar
Moverse
enumeración en esta matriz de valores, necesitamos generar un índice aleatorio que sea un número entero entre 0 y la longitud de nuestra matriz de valores. Para hacer esto, podemos usar el
nextInt ()
método del
Aleatorio
clase de la que necesitamos importar
java.util
. Una vez que hayamos obtenido el índice aleatorio, podemos devolver el
Moverse
de ese índice de nuestra matriz de valores.
public Move getMove () {Move mueve = Move.values (); Aleatorio aleatorio = nuevo Aleatorio (); int index = random.nextInt (se mueve.longitud); movimientos de retorno [índice]; }
Paso 5. Escribe el
getMove ()
método para el
Usuario
clase.
Este método devolverá un
Moverse
correspondiente a lo que el usuario ha introducido. Esperamos que el usuario escriba "piedra", "papel" o "tijeras". Primero, necesitamos pedirle al usuario una entrada:
System.out.print ("¿Piedra, papel o tijeras?")
. Entonces usa el
línea siguiente()
método del
Escáner
objeto para obtener la entrada del usuario como una cadena. Ahora necesitamos verificar si el usuario ha enviado un movimiento válido, pero podemos ser indulgentes si el usuario ha escrito mal una palabra. Por lo tanto, solo verificaremos si la primera letra de la entrada del usuario es "R" (para piedra), "P" (para papel) o "S" (para tijeras), y no nos importa el caso porque Primero usaremos el
toUpperCase ()
método del
Cuerda
class para convertir la cadena de entrada del usuario en mayúsculas. Si el usuario no ha ingresado una entrada correcta de forma remota, le preguntaremos nuevamente al usuario. Luego, dependiendo de lo que haya introducido el usuario, devolveremos un movimiento correspondiente.
public Move getMove () {// Preguntar al usuario System.out.print ("¿Piedra, papel o tijeras?"); // Obtener la entrada del usuario String userInput = inputScanner.nextLine (); userInput = userInput.toUpperCase (); char firstLetter = userInput.charAt (0); if (firstLetter == 'R' || firstLetter == 'P' || firstLetter == 'S') {// El usuario ha introducido un cambio de entrada válido (firstLetter) {case 'R': return Move. ROCK; caso 'P': return Move. PAPER; caso 'S': return Move. SCISSORS; }} // El usuario no ha introducido una entrada válida. Preguntar de nuevo. return getMove (); }
Paso 6. Escribe un
juega de nuevo()
método para el
Usuario
clase.
El usuario debería poder jugar el juego una y otra vez. Para determinar si el usuario quiere volver a jugar, necesitamos escribir un
juega de nuevo()
método que devuelve un booleano que indica al juego si el usuario ha decidido volver a jugar o no. En este método, estamos usando el
Escáner
que habíamos iniciado previamente en el constructor para obtener un "Sí" o un "No" del usuario. Solo comprobaremos si la primera letra es 'Y' para determinar si el usuario quiere volver a jugar. Cualquier otra entrada significará que el usuario no quiere volver a jugar.
public boolean playAgain () {System.out.print ("¿Quieres volver a jugar?"); String userInput = inputScanner.nextLine (); userInput = userInput.toUpperCase (); return userInput.charAt (0) == 'Y'; }
Paso 7. Conecte el
Usuario
y
Computadora
clases juntos en el
Piedra Papel tijeras
clase.
Ahora que hemos terminado de escribir el
Usuario
y
Computadora
clases, podemos concentrarnos en trabajar en nuestro juego real. Cree campos privados para el
Usuario
y
Computadora
clases en el
Piedra Papel tijeras
clase. Necesitaremos acceder a estos campos para acceder al
getMove ()
métodos cuando jugamos el juego. En el constructor de la
Piedra Papel tijeras
clase, inicie estos campos. También necesitaremos realizar un seguimiento de la puntuación en
userScore
y
computadora
fields, que debemos iniciar como 0 en el constructor. También debemos realizar un seguimiento del número de juegos, que también será un campo iniciado como 0.
Usuario usuario privado; computadora privada; private int userScore; private int computerScore; private int numberOfGames; public RockPaperScissors () {usuario = nuevo usuario (); computadora = nueva computadora (); userScore = 0; computerScore = 0; numberOfGames = 0; }
Paso 8. Extienda el
Moverse
enum para incluir un método que nos diga qué movimiento gana en cada caso.
Necesitamos escribir un
compareMoves ()
método que devuelve 0 si los movimientos son los mismos, 1 si el movimiento actual vence al otro movimiento y -1 si el movimiento actual pierde frente al otro movimiento. Esto será útil para determinar el ganador del juego. Para implementar este método, primero devolveremos 0 si los movimientos son los mismos y, por lo tanto, tenemos un empate. Luego, escriba una declaración de cambio para devolver 1 o -1.
private enum Move {ROCA, PAPEL, TIJERAS; / ** * Compara este movimiento con otro movimiento para determinar un empate, una victoria o * una derrota. * * @param otherMove * mover para comparar con * @return 1 si este movimiento vence al otro movimiento, -1 si este movimiento pierde con * el otro movimiento, 0 si estos movimientos empatan * / public int compareMoves (Move otherMove) {/ / Empate if (this == otherMove) return 0; cambiar (esto) {caso ROCA: retorno (otroMovimiento == TIJERAS? 1: -1); case PAPER: return (otherMove == ROCK? 1: -1); case TIJERAS: return (otherMove == PAPER? 1: -1); } // Nunca debería llegar aquí return 0; }}
Paso 9. Cree un
empezar juego()
método en el
Piedra Papel tijeras
clase.
Este método será el juego del juego. Empiece poniendo un simple
System.out.println
en el método.
public void startGame () {System.out.println ("¡ROCA, PAPEL, TIJERAS!"); }
Paso 10. Obtenga movimientos del usuario y la computadora
En el
empezar juego()
método, use el
getMove ()
métodos de la
Usuario
clase y el
Computadora
class para obtener el usuario y los movimientos de la computadora.
Mover userMove = user.getMove (); Mover computerMove = computer.getMove (); System.out.println ("\ nJugó" + userMove + "."); System.out.println ("Computadora reproducida" + computerMove + ". / N");
Paso 11. Compare los dos movimientos y determine si el usuario ganó o la computadora ganó
Utilizar el
compareMoves ()
método del
Moverse
enumeración para determinar si el usuario ganó o no. Si el usuario ganó, incremente la puntuación del usuario en 1. Si el usuario perdió, incremente la puntuación de la computadora en 1. Si hubo un empate, no incremente ninguna de las puntuaciones. Luego, incremente el número de juegos jugados en uno.
int compareMoves = userMove.compareMoves (computerMove); switch (compareMoves) {case 0: // Tie System.out.println ("¡Empate!"); rotura; caso 1: // El usuario gana System.out.println (userMove + "beats" + computerMove + ". ¡Usted ganó!"); userScore ++; rotura; case -1: // La computadora gana System.out.println (computerMove + "gana" + userMove + ". Perdiste."); computerScore ++; rotura; } numberOfGames ++;
Paso 12. Pregunte si el usuario quiere volver a jugar
Si el usuario quiere volver a jugar, llame
empezar juego()
de nuevo. De lo contrario, llame
printGameStats ()
que imprimirá las estadísticas del juego. Escribiremos este método en el siguiente paso.
if (user.playAgain ()) {System.out.println (); empezar juego(); } else {printGameStats (); }
Paso 13. Escribe el
printGameStats ()
método.
Este método mostrará las estadísticas del juego: número de victorias, número de derrotas, número de empates, número de juegos jugados y porcentaje de juegos ganados por el usuario. El porcentaje de juegos ganados se calcula por (# victorias + (# empates / 2)) / (# juegos jugados). Este método utiliza
System.out.printf
para imprimir texto formateado.
private void printGameStats () {int gana = userScore; pérdidas int = computerScore; int ties = numberOfGames - userScore - computerScore; double percentWon = (gana + ((dobles) empates) / 2) / numberOfGames; // Line System.out.print ("+"); printDashes (68); System.out.println ("+"); // Imprimir títulos System.out.printf ("|% 6s |% 6s |% 6s |% 12s |% 14s | / n", "GANANCIAS", "PÉRDIDAS", "EMPATES", "JUEGOS JUGADOS", "PORCENTAJE GANADO"); // Line System.out.print ("|"); printDashes (10); System.out.print ("+"); printDashes (10); System.out.print ("+"); printDashes (10); System.out.print ("+"); printDashes (16); System.out.print ("+"); printDashes (18); System.out.println ("|"); // Imprimir valores System.out.printf ("|% 6d |% 6d |% 6d |% 12d |% 13.2f %% | / n", victorias, derrotas, empates, numberOfGames, percentWon * 100); // Line System.out.print ("+"); printDashes (68); System.out.println ("+"); }
Paso 14. Inicie el juego en la clase principal
En la clase principal, inicialice una instancia del
Piedra Papel tijeras
clase y llame al
empezar juego()
método.
public static void main (String args) {Juego RockPaperScissors = new RockPaperScissors (); juego.startGame (); }
Paso 15. Prueba tu juego
Ahora que hemos realizado todo el esfuerzo de escribir el juego Piedra, papel, tijeras, ¡es hora de compilar y probar todo!
Programa de muestra
import java.util. Random; import java.util. Scanner; public class RockPaperScissors {usuario de usuario privado; computadora privada; private int userScore; private int computerScore; private int numberOfGames; enumeración privada Mover {ROCA, PAPEL, TIJERAS; / ** * Compara este movimiento con otro movimiento para determinar un empate, una victoria o * una derrota. * * @param otherMove * mover para comparar con * @return 1 si este movimiento vence al otro movimiento, -1 si este movimiento pierde con * el otro movimiento, 0 si estos movimientos empatan * / public int compareMoves (Move otherMove) {/ / Empate if (this == otherMove) return 0; cambiar (esto) {caso ROCA: retorno (otroMovimiento == TIJERAS? 1: -1); case PAPER: return (otherMove == ROCK? 1: -1); case TIJERAS: return (otherMove == PAPER? 1: -1); } // Nunca debería llegar aquí return 0; }} usuario de clase privada {escáner privado inputScanner; Usuario público () {inputScanner = new Scanner (System.in); } public Move getMove () {// Preguntar al usuario System.out.print ("¿Piedra, papel o tijeras?"); // Obtener la entrada del usuario String userInput = inputScanner.nextLine (); userInput = userInput.toUpperCase (); char firstLetter = userInput.charAt (0); if (firstLetter == 'R' || firstLetter == 'P' || firstLetter == 'S') {// El usuario ha introducido un cambio de entrada válido (firstLetter) {case 'R': return Move. ROCK; caso 'P': return Move. PAPER; caso 'S': return Move. SCISSORS; }} // El usuario no ha introducido una entrada válida. Preguntar de nuevo. return getMove (); } public boolean playAgain () {System.out.print ("¿Quieres volver a jugar?"); String userInput = inputScanner.nextLine (); userInput = userInput.toUpperCase (); return userInput.charAt (0) == 'Y'; }} computadora de clase privada {público Move getMove () {Move mueve = Move.values (); Aleatorio aleatorio = nuevo Aleatorio (); int index = random.nextInt (se mueve.longitud); movimientos de retorno [índice]; }} public RockPaperScissors () {usuario = nuevo Usuario (); computadora = nueva computadora (); userScore = 0; computerScore = 0; numberOfGames = 0; } public void startGame () {System.out.println ("¡ROCA, PAPEL, TIJERAS!"); // Obtener movimientos Move userMove = user.getMove (); Mover computerMove = computer.getMove (); System.out.println ("\ nJugaste" + userMove + "."); System.out.println ("Computadora reproducida" + computerMove + ". / N"); // Compara movimientos y determina el ganador int compareMoves = userMove.compareMoves (computerMove); switch (compareMoves) {case 0: // Tie System.out.println ("¡Empate!"); rotura; caso 1: // El usuario gana System.out.println (userMove + "beats" + computerMove + ". ¡Usted ganó!"); userScore ++; rotura; case -1: // La computadora gana System.out.println (computerMove + "gana" + userMove + ". Perdiste."); computerScore ++; rotura; } numberOfGames ++; // Pedir al usuario que vuelva a jugar if (user.playAgain ()) {System.out.println (); empezar juego(); } else {printGameStats (); }} / ** * Imprime las estadísticas del juego. Calcula los empates como 1/2 de una victoria en * porcentaje ganado. * / private void printGameStats () {int gana = userScore; pérdidas int = computerScore; int ties = numberOfGames - userScore - computerScore; double percentWon = (gana + ((dobles) empates) / 2) / numberOfGames; // Line System.out.print ("+"); printDashes (68); System.out.println ("+"); // Imprimir títulos System.out.printf ("|% 6s |% 6s |% 6s |% 12s |% 14s | / n", "GANANCIAS", "PÉRDIDAS", "EMPATES", "JUEGOS JUGADOS", "PORCENTAJE GANADO"); // Line System.out.print ("|"); printDashes (10); System.out.print ("+"); printDashes (10); System.out.print ("+"); printDashes (10); System.out.print ("+"); printDashes (16); System.out.print ("+"); printDashes (18); System.out.println ("|"); // Imprimir valores System.out.printf ("|% 6d |% 6d |% 6d |% 12d |% 13.2f %% | / n", victorias, derrotas, empates, numberOfGames, percentWon * 100); // Line System.out.print ("+"); printDashes (68); System.out.println ("+"); } printDashes vacío privado (int numberOfDashes) {for (int i = 0; i <numberOfDashes; i ++) {System.out.print ("-"); }} public static void main (String args) {RockPaperScissors juego = new RockPaperScissors (); juego.startGame (); }}
