Cómo hacer un juego de Piedra, Papel y Tijeras en Java

Descargar el PDF
Descargar el PDF

Piedra, Papel y Tijeras es un juego de manos para dos personas. Ambos jugadores deben decir “piedra, papel, tijeras” y simultáneamente formar uno de los tres objetos (piedra, papel o tijeras) con una mano extendida. El ganador se determina por las formaciones de las manos. Las tijeras le ganan al papel, el papel le gana a la piedra, y la piedra le gana a las tijeras. Si ambos jugadores presentan la misma formación de manos, se considera un empate. Escribiremos un juego sencillo en Java para simular Piedra, Papel, Tijeras en el que un jugador es el usuario y el otro es la computadora.

Pasos

Descargar el PDF
  1. 1
    Crea la clase principal y llámala PiedraPapelTijeras . Ésta será la clase en la que escribiremos el juego. Puedes escoger nombrarla de alguna otra manera, como Juego o Principal . Escribe las declaraciones de método para el constructor y para el método principal.

     public 
 class 
 PiedraPapelTijeras 
 { 
 public 
 PiedraPapelTijeras 
 () 
 { 
 } 
 public 
 static 
 void 
 main 
 ( 
 String 
 [] 
 args 
 ) 
 { 
 } 
 }
  2. 2
    Crea una enumeración para los gestos de mano (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 resulta en un mejor diseño. Llamaremos a nuestro tipo de enumeración Move con los valores ROCA , PAPEL , y TIJERAS .

     private 
 enum 
 Move 
 { 
 ROCA 
 , 
 PAPEL 
 , 
 TIJERAS 
 }
  3. 3
    Crea dos clases privadas Usuario y Computadora . Estas clases representarán a nuestros jugadores en el juego. La clase Usuario será la clase que le solicite al usuario que escoja entre roca, papel o tijeras, por lo que deberemos escribir un método getMove() . La clase Computadora también deberá tener un método getMove() para que la computadora también pueda hacer su jugada. Colocaremos marcadores de posición en estos métodos para implementarlos más tarde. La clase Usuario requerirá un constructor que configure el objeto Scanner que tomará la entrada del usuario. Pondremos el Scanner como un campo privado para el usuario, y luego lo iniciaremos en el constructor. Como estamos usando la clase Scanner , necesitamos escribirle una declaración de importación en la parte de arriba de nuestro código. La clase Computadora no requiere de un constructor, por lo que no necesitaremos escribir uno; cuando iniciemos el objeto Computadora , simplemente estaremos llamando al constructor por defecto. Así es como se ve ahora nuestra clase PiedraPapelTijeras :

     import 
 java.util.Scanner 
 ; 
 public 
 class 
 PiedraPapelTijeras 
 { 
 private 
 enum 
 Move 
 { 
 ROCA 
 , 
 PAPEL 
 , 
 TIJERAS 
 } 
 private 
 class 
 Usuario 
 { 
 private 
 Scanner 
 inputScanner 
 ; 
 public 
 Usuario 
 () 
 { 
 inputScanner 
 = 
 new 
 Scanner 
 ( 
 System 
 . 
 in 
 ); 
 } 
 public 
 Move 
 getMove 
 () 
 { 
 // PORHACER: Implementar este método 
 return 
 null 
 ; 
 } 
 } 
 private 
 class 
 Computadora 
 { 
 public 
 Move 
 getMove 
 () 
 { 
 // POR HACER: Implementar este método 
 return 
 null 
 ; 
 } 
 } 
 public 
 PiedraPapelTijeras 
 () 
 { 
 } 
 public 
 static 
 void 
 main 
 ( 
 String 
 [] 
 args 
 ) 
 { 
 } 
 }
  4. 4
    Escribe el método getMove() para la clase Computadora . Este método te devolverá un Move aleatorio. Podemos obtener un array de las enumeraciones de Move llamando al método values() : Move.values() . Para escoger una enumeración aleatoria de Move en este array de valores necesitamos generar un índice aleatorio que sea un entero de entre 0 y la longitud de nuestro array de valores. Para hacer esto podemos usar el método nextInt() de la clase Random , la que debemos importar desde java.util . Después de haber obtenido el índice aleatorio, podemos devolver el Move para ese índice de nuestro array de valores.

     public 
 Move 
 getMove 
 () 
 { 
 Move 
 [] 
 moves 
 = 
 Move 
 . 
 values 
 (); 
 Random 
 random 
 = 
 new 
 Random 
 (); 
 int 
 index 
 = 
 random 
 . 
 nextInt 
 ( 
 moves 
 . 
 length 
 ); 
 return 
 moves 
 [ 
 index 
 ]; 
 }
  5. 5
    Escribe el método getMove() para la clase Usuario . Este método devolverá un Move correspondiente a lo que el usuario haya ingresado. Supondremos que el usuario escribirá roca , papel o tijeras . Primero debemos solicitarle una entrada al usuario: System.out.print("Roca, papel o tijeras?") . Luego usaremos el método nextLine() del objeto Scanner para tomar la entrada del usuario como una cadena. Ahora debemos revisar si el usuario ha ingresado una jugada válida, pero podemos ser tolerantes con respecto a la ortografía. Así que sólo revisaremos si la primer letra que ingresa el usuario es una R (para roca), una P (para papel) o una T (para tijeras), independientemente de si son mayúsculas o minúsculas ya que usaremos el método toUpperCase() de la clase String para poner en mayúsculas todas las entradas del usuario. Si el usuario ingresa una entrada incorrecta, le pediremos nuevamente que ingrese. Luego, dependiendo de lo que haya ingresado el usuario, devolveremos una jugada correspondiente.

     public 
 Move 
 getMove 
 () 
 { 
 // Solicitarle al usuario 
 System 
 . 
 out 
 . 
 print 
 ( 
 "Roca, papel o tijeras? " 
 ); 
 // Obtener la entrada del usuario 
 String 
 usuarioInput 
 = 
 inputScanner 
 . 
 nextLine 
 (); 
 usuarioInput 
 = 
 usuarioInput 
 . 
 toUpperCase 
 (); 
 char 
 firstLetter 
 = 
 usuarioInput 
 . 
 charAt 
 ( 
 0 
 ); 
 if 
 ( 
 firstLetter 
 == 
 'R' 
 || 
 firstLetter 
 == 
 'P' 
 || 
 firstLetter 
 == 
 'T' 
 ) 
 { 
 // Usuario ha ingresado un dato válido 
 switch 
 ( 
 firstLetter 
 ) 
 { 
 case 
 'R' 
 : 
 return 
 Move 
 . 
 ROCA 
 ; 
 case 
 'P' 
 : 
 return 
 Move 
 . 
 PAPEL 
 ; 
 case 
 'T' 
 : 
 return 
 Move 
 . 
 TIJERAS 
 ; 
 } 
 } 
 // Usuario no ha ingresado un dato válido. Solicitar nuevamente. 
 return 
 getMove 
 (); 
 }
  6. 6
    Escribe un método playAgain() para la clase Usuario . El usuario debería poder jugar una y otra vez. Para determinar si el usuario quiere jugar nuevamente, necesitamos escribir un método playAgain() que devuelva un valor booleano que diga si el usuario ha determinado jugar nuevamente o no. En este método usamos el Scanner que habíamos iniciado previamente en el constructor para obtener un Sí o un No del usuario. Sólo revisaremos si la primera letra es una 'S' para determinar si el usuario desea jugar nuevamente. Cualquier otra entrada significará que el usuario no desea jugar nuevamente.

     public 
 boolean 
 playAgain 
 () 
 { 
 System 
 . 
 out 
 . 
 print 
 ( 
 "Quieres jugar nuevamente? " 
 ); 
 String 
 usuarioInput 
 = 
 inputScanner 
 . 
 nextLine 
 (); 
 usuarioInput 
 = 
 usuarioInput 
 . 
 toUpperCase 
 (); 
 return 
 usuarioInput 
 . 
 charAt 
 ( 
 0 
 ) 
 == 
 'S' 
 ; 
 }
  7. 7
    Conecta las clases Usuario y Computadora juntas en la clase PiedraPapelTijeras . Ahora que hemos terminado de escribir las clases Usuario y Computadora , podemos concentrarnos en el juego en sí. Crea campos privados para las clases Usuario y Computadora en la clase PiedraPapelTijeras . Deberemos acceder a estos campos para acceder a los métodos getMove() cuando estemos jugando. En el constructor para la clase PiedraPapelTijeras , inicia estos campos. También deberemos llevar la cuenta de los puntos en los campos usuarioPuntos y computadoraPuntos , los que debemos iniciar en 0 en el constructor. También necesitamos llevar la cuenta de la cantidad de juegos, lo que también será un campo iniciado en 0.

     private 
 Usuario 
 usuario 
 ; 
 private 
 Computadora 
 computadora 
 ; 
 private 
 int 
 usuarioPuntos 
 ; 
 private 
 int 
 computadoraPuntos 
 ; 
 private 
 int 
 cantidadDeJuegos 
 ; 
 public 
 PiedraPapelTijeras 
 () 
 { 
 usuario 
 = 
 new 
 Usuario 
 (); 
 computadora 
 = 
 new 
 Computadora 
 (); 
 usuarioPuntos 
 = 
 0 
 ; 
 computadoraPuntos 
 = 
 0 
 ; 
 cantidadDeJuegos 
 = 
 0 
 ; 
 }
  8. 8
    Extiende la enumeración Move para incluir un método que nos diga quién ganará en cada caso. Debemos escribir un método compareMoves() que devuelva 0 si las jugadas son la misma, 1 si la jugada actual le gana a la otra, y -1 si la jugada actual pierde frente a la otra. Esto será útil para determinar el ganador del juego. Para implementar este método, primero devolveremos 0 si las jugadas son la misma, y por lo tanto tendremos un empate. Luego escribe una declaración de switch para devolver 1 o -1.

     private 
 enum 
 Move 
 { 
 ROCA 
 , 
 PAPEL 
 , 
 TIJERAS 
 ; 
 /** 
 * Compara esta jugada con otra jugada para determinar empate, victoria o 
 * derrota. 
 * 
 * @param otherMove 
 *            jugada a comparar con 
 * @return 1 si esta jugada le gana a la otra, -1 si esta jugada pierde frente a 
 *         la otra, 0 si las jugadas empatan 
 */ 
 public 
 int 
 compareMoves 
 ( 
 Move 
 otherMove 
 ) 
 { 
 // Empate 
 if 
 ( 
 this 
 == 
 otherMove 
 ) 
 return 
 0 
 ; 
 switch 
 ( 
 this 
 ) 
 { 
 case 
 ROCA 
 : 
 return 
 ( 
 otherMove 
 == 
 TIJERAS 
 ? 
 1 
 : 
 - 
 1 
 ); 
 case 
 PAPEL 
 : 
 return 
 ( 
 otherMove 
 == 
 ROCA 
 ? 
 1 
 : 
 - 
 1 
 ); 
 case 
 TIJERAS 
 : 
 return 
 ( 
 otherMove 
 == 
 PAPEL 
 ? 
 1 
 : 
 - 
 1 
 ); 
 } 
 // Nunca debería llegar hasta aquí 
 return 
 0 
 ; 
 } 
 }
  9. 9
    Crea un método startGame() en la clase PiedraPapelTijeras . Este método será el desarrollo del juego. Comienza poniendo un sencillo System.out.println en el método.

     public 
 void 
 startGame 
 () 
 { 
 System 
 . 
 out 
 . 
 println 
 ( 
 "ROCA, PAPEL, TIJERAS!" 
 ); 
 }
  10. 10
    Obtén las jugadas del usuario y de la computadora. En el método startGame() , usa los métodos getMove() de la clase Usuario y de la clase Computadora para obtener las jugadas del usuario y de la computadora.

     Move 
 usuarioMove 
 = 
 usuario 
 . 
 getMove 
 (); 
 Move 
 computadoraMove 
 = 
 computadora 
 . 
 getMove 
 (); 
 System 
 . 
 out 
 . 
 println 
 ( 
 "\nYou played " 
 + 
 usuarioMove 
 + 
 "." 
 ); 
 System 
 . 
 out 
 . 
 println 
 ( 
 "Computadora played " 
 + 
 computadoraMove 
 + 
 ".\n" 
 );
  11. 11
    Compara las dos jugadas y determina si ganó el usuario o la computadora. Usa el método compareMoves() de la enum Move para determinar si el usuario ganó o no. Si ganó el usuario, incrementa el puntaje de los usuarios en 1. Si el usuario perdió, incrementa el puntaje de la computadora en 1. Si hubo un empate, no incrementes ninguno de los puntajes. Luego incrementa la cantidad de juegos en uno.

     int 
 compareMoves 
 = 
 usuarioMove 
 . 
 compareMoves 
 ( 
 computadoraMove 
 ); 
 switch 
 ( 
 compareMoves 
 ) 
 { 
 case 
 0 
 : 
 // Empate 
 System 
 . 
 out 
 . 
 println 
 ( 
 "Empate!" 
 ); 
 break 
 ; 
 case 
 1 
 : 
 // Gana Usuario 
 System 
 . 
 out 
 . 
 println 
 ( 
 usuarioMove 
 + 
 " le gana a " 
 + 
 computadoraMove 
 + 
 ". Ganaste!" 
 ); 
 usuarioPuntos 
 ++; 
 break 
 ; 
 case 
 - 
 1 
 : 
 // Gana Computadora 
 System 
 . 
 out 
 . 
 println 
 ( 
 computadoraMove 
 + 
 " le gana a " 
 + 
 usuarioMove 
 + 
 ". Perdiste." 
 ); 
 computadoraPuntos 
 ++; 
 break 
 ; 
 } 
 cantidadDeJuegos 
 ++;
  12. 12
    Pregúntale al usuario si quiere jugar de nuevo. Si el usuario quiere jugar nuevamente, llama otra vez a startGame() . De otra manera, llama a printGameStats() que imprimirá las estadísticas del juego. Escribiremos este método en el paso siguiente.

     if 
 ( 
 usuario 
 . 
 playAgain 
 ()) 
 { 
 System 
 . 
 out 
 . 
 println 
 (); 
 startGame 
 (); 
 } 
 else 
 { 
 printGameStats 
 (); 
 }
  13. 13
    Escribe el método printGameStats() . Este método mostrará las estadísticas del juego: cantidad de victorias, cantidad de derrotas, cantidad de empates, cantidad de juegos, yy porcentaje de triunfos del usuario. El porcentaje de juegos ganados se calcula por (# voctorias + (# empates/2))/(# juegos). Este método usa System.out.printf para imprimir texto con formato.

     private 
 void 
 printGameStats 
 () 
 { 
 int 
 wins 
 = 
 usuarioPuntos 
 ; 
 int 
 losses 
 = 
 computadoraPuntos 
 ; 
 int 
 ties 
 = 
 cantidadDeJuegos 
 - 
 usuarioPuntos 
 - 
 computadoraPuntos 
 ; 
 double 
 percentageWon 
 = 
 ( 
 wins 
 + 
 (( 
 double 
 ) 
 ties 
 ) 
 / 
 2 
 ) 
 / 
 cantidadDeJuegos 
 ; 
 // Línea 
 System 
 . 
 out 
 . 
 print 
 ( 
 "+" 
 ); 
 printDashes 
 ( 
 68 
 ); 
 System 
 . 
 out 
 . 
 println 
 ( 
 "+" 
 ); 
 // Imprime títulos 
 System 
 . 
 out 
 . 
 printf 
 ( 
 "|  %6s  |  %6s  |  %6s  |  %12s  |  %14s  |\n" 
 , 
 "VICTORIAS" 
 , 
 "DERROTAS" 
 , 
 "EMPATES" 
 , 
 "JUEGOS" 
 , 
 "PORCENTAJE DE TRIUNFOS" 
 ); 
 // Línea 
 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 
 ( 
 "|" 
 ); 
 // Imprime valores 
 System 
 . 
 out 
 . 
 printf 
 ( 
 "|  %6d  |  %6d  |  %6d  |  %12d  |  %13.2f%%  |\n" 
 , 
 wins 
 , 
 losses 
 , 
 ties 
 , 
 cantidadDeJuegos 
 , 
 percentageWon 
 * 
 100 
 ); 
 // Línea 
 System 
 . 
 out 
 . 
 print 
 ( 
 "+" 
 ); 
 printDashes 
 ( 
 68 
 ); 
 System 
 . 
 out 
 . 
 println 
 ( 
 "+" 
 ); 
 }
  14. 14
    Comienza el juego en la clase principal. En la clase principal, inicializa una instancia de la clase PiedraPapelTijeras y llama al método startGame() .

     public 
 static 
 void 
 main 
 ( 
 String 
 [] 
 args 
 ) 
 { 
 PiedraPapelTijeras 
 game 
 = 
 new 
 PiedraPapelTijeras 
 (); 
 game 
 . 
 startGame 
 (); 
 }
  15. {"smallUrl":"https:\/\/www.wikihow.com\/images_en\/thumb\/e\/e1\/Screen-Shot-2013-06-23-at-2.27.50-AM.png\/460px-Screen-Shot-2013-06-23-at-2.27.50-AM.png","bigUrl":"https:\/\/www.wikihow.com\/images\/thumb\/e\/e1\/Screen-Shot-2013-06-23-at-2.27.50-AM.png\/604px-Screen-Shot-2013-06-23-at-2.27.50-AM.png","smallWidth":460,"smallHeight":426,"bigWidth":604,"bigHeight":560,"licensing":"<div class=\"mw-parser-output\"><\/div>"}
    15
    Prueba tu juego. Ahora que hemos hecho todo el esfuerzo de escribir el juego de Piedra, Papel, Tijeras, ¡es hora de compilarlo y probar todo!
    Anuncio

Programa de Muestra 

 import 
 java.util.Random 
 ; 
 import 
 java.util.Scanner 
 ; 
 public 
 class 
 PiedraPapelTijeras 
 { 
 private 
 Usuario 
 usuario 
 ; 
 private 
 Computadora 
 computadora 
 ; 
 private 
 int 
 usuarioPuntos 
 ; 
 private 
 int 
 computadoraPuntos 
 ; 
 private 
 int 
 cantidadDeJuegos 
 ; 
 private 
 enum 
 Move 
 { 
 ROCA 
 , 
 PAPEL 
 , 
 TIJERAS 
 ; 
 /** 
 * Compara esta jugada con otra para determinar si es un empate, un triunfo o 
 * una derrota. 
 * 
 * @param otherMove 
 *            jugada a comparar 
 * @return 1 si esta jugada le gana a la otra, -1 se esta jugada pierde frente a 
 *         la otra, 0 si las jugadas empatan 
 */ 
 public 
 int 
 compareMoves 
 ( 
 Move 
 otherMove 
 ) 
 { 
 // Empate 
 if 
 ( 
 this 
 == 
 otherMove 
 ) 
 return 
 0 
 ; 
 switch 
 ( 
 this 
 ) 
 { 
 case 
 ROCA 
 : 
 return 
 ( 
 otherMove 
 == 
 TIJERAS 
 ? 
 1 
 : 
 - 
 1 
 ); 
 case 
 PAPEL 
 : 
 return 
 ( 
 otherMove 
 == 
 ROCA 
 ? 
 1 
 : 
 - 
 1 
 ); 
 case 
 TIJERAS 
 : 
 return 
 ( 
 otherMove 
 == 
 PAPEL 
 ? 
 1 
 : 
 - 
 1 
 ); 
 } 
 // Nunca debería llegar hasta aquí 
 return 
 0 
 ; 
 } 
 } 
 private 
 class 
 Usuario 
 { 
 private 
 Scanner 
 inputScanner 
 ; 
 public 
 Usuario 
 () 
 { 
 inputScanner 
 = 
 new 
 Scanner 
 ( 
 System 
 . 
 in 
 ); 
 } 
 public 
 Move 
 getMove 
 () 
 { 
 // Solicitarle al usuario 
 System 
 . 
 out 
 . 
 print 
 ( 
 "Roca, papel o tijeras? " 
 ); 
 // Obtener la entrada del usuario 
 String 
 usuarioInput 
 = 
 inputScanner 
 . 
 nextLine 
 (); 
 usuarioInput 
 = 
 usuarioInput 
 . 
 toUpperCase 
 (); 
 char 
 firstLetter 
 = 
 usuarioInput 
 . 
 charAt 
 ( 
 0 
 ); 
 if 
 ( 
 firstLetter 
 == 
 'R' 
 || 
 firstLetter 
 == 
 'P' 
 || 
 firstLetter 
 == 
 'T' 
 ) 
 { 
 // Usuario ha ingresado un dato válido 
 switch 
 ( 
 firstLetter 
 ) 
 { 
 case 
 'R' 
 : 
 return 
 Move 
 . 
 ROCA 
 ; 
 case 
 'P' 
 : 
 return 
 Move 
 . 
 PAPEL 
 ; 
 case 
 'T' 
 : 
 return 
 Move 
 . 
 TIJERAS 
 ; 
 } 
 } 
 // Usuario no ha ingresado un dato válido. Solicitar nuevamente. 
 return 
 getMove 
 (); 
 } 
 public 
 boolean 
 playAgain 
 () 
 { 
 System 
 . 
 out 
 . 
 print 
 ( 
 "Quieres jugar de nuevo? " 
 ); 
 String 
 usuarioInput 
 = 
 inputScanner 
 . 
 nextLine 
 (); 
 usuarioInput 
 = 
 usuarioInput 
 . 
 toUpperCase 
 (); 
 return 
 usuarioInput 
 . 
 charAt 
 ( 
 0 
 ) 
 == 
 'S' 
 ; 
 } 
 } 
 private 
 class 
 Computadora 
 { 
 public 
 Move 
 getMove 
 () 
 { 
 Move 
 [] 
 moves 
 = 
 Move 
 . 
 values 
 (); 
 Random 
 random 
 = 
 new 
 Random 
 (); 
 int 
 index 
 = 
 random 
 . 
 nextInt 
 ( 
 moves 
 . 
 length 
 ); 
 return 
 moves 
 [ 
 index 
 ]; 
 } 
 } 
 public 
 PiedraPapelTijeras 
 () 
 { 
 usuario 
 = 
 new 
 Usuario 
 (); 
 computadora 
 = 
 new 
 Computadora 
 (); 
 usuarioPuntos 
 = 
 0 
 ; 
 computadoraPuntos 
 = 
 0 
 ; 
 cantidadDeJuegos 
 = 
 0 
 ; 
 } 
 public 
 void 
 startGame 
 () 
 { 
 System 
 . 
 out 
 . 
 println 
 ( 
 "ROCA, PAPEL, TIJERAS!" 
 ); 
 // Obtener jugadas 
 Move 
 usuarioMove 
 = 
 usuario 
 . 
 getMove 
 (); 
 Move 
 computadoraMove 
 = 
 computadora 
 . 
 getMove 
 (); 
 System 
 . 
 out 
 . 
 println 
 ( 
 "\nYou played " 
 + 
 usuarioMove 
 + 
 "." 
 ); 
 System 
 . 
 out 
 . 
 println 
 ( 
 "Computadora played " 
 + 
 computadoraMove 
 + 
 ".\n" 
 ); 
 // Comparar jugadas y determinar ganador 
 int 
 compareMoves 
 = 
 usuarioMove 
 . 
 compareMoves 
 ( 
 computadoraMove 
 ); 
 switch 
 ( 
 compareMoves 
 ) 
 { 
 case 
 0 
 : 
 // Empate 
 System 
 . 
 out 
 . 
 println 
 ( 
 "Empate!" 
 ); 
 break 
 ; 
 case 
 1 
 : 
 // Gana Usuario 
 System 
 . 
 out 
 . 
 println 
 ( 
 usuarioMove 
 + 
 " le gana a " 
 + 
 computadoraMove 
 + 
 ". Ganaste!" 
 ); 
 usuarioPuntos 
 ++; 
 break 
 ; 
 case 
 - 
 1 
 : 
 // Gana Computadora 
 System 
 . 
 out 
 . 
 println 
 ( 
 computadoraMove 
 + 
 " le gana a " 
 + 
 usuarioMove 
 + 
 ". Perdiste." 
 ); 
 computadoraPuntos 
 ++; 
 break 
 ; 
 } 
 cantidadDeJuegos 
 ++; 
 // Preguntar al usuario si jugar nuevamente 
 if 
 ( 
 usuario 
 . 
 playAgain 
 ()) 
 { 
 System 
 . 
 out 
 . 
 println 
 (); 
 startGame 
 (); 
 } 
 else 
 { 
 printGameStats 
 (); 
 } 
 } 
 /** 
 * Imprimir las estadísticas del juego. Calcular un empate como ½ victoria en 
 * el porcentaje de victorias. 
 */ 
 private 
 void 
 printGameStats 
 () 
 { 
 int 
 wins 
 = 
 usuarioPuntos 
 ; 
 int 
 losses 
 = 
 computadoraPuntos 
 ; 
 int 
 ties 
 = 
 cantidadDeJuegos 
 - 
 usuarioPuntos 
 - 
 computadoraPuntos 
 ; 
 double 
 percentageWon 
 = 
 ( 
 wins 
 + 
 (( 
 double 
 ) 
 ties 
 ) 
 / 
 2 
 ) 
 / 
 cantidadDeJuegos 
 ; 
 // Línea 
 System 
 . 
 out 
 . 
 print 
 ( 
 "+" 
 ); 
 printDashes 
 ( 
 68 
 ); 
 System 
 . 
 out 
 . 
 println 
 ( 
 "+" 
 ); 
 // Imprimir títulos 
 System 
 . 
 out 
 . 
 printf 
 ( 
 "|  %6s  |  %6s  |  %6s  |  %12s  |  %14s  |\n" 
 , 
 "VICTORIAS" 
 , 
 "DERROTAS" 
 , 
 "EMPATES" 
 , 
 "JUEGOS" 
 , 
 "PORCENTAJE VICTORIAS" 
 ); 
 // Línea 
 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" 
 , 
 wins 
 , 
 losses 
 , 
 ties 
 , 
 cantidadDeJuegos 
 , 
 percentageWon 
 * 
 100 
 ); 
 // Línea 
 System 
 . 
 out 
 . 
 print 
 ( 
 "+" 
 ); 
 printDashes 
 ( 
 68 
 ); 
 System 
 . 
 out 
 . 
 println 
 ( 
 "+" 
 ); 
 } 
 private 
 void 
 printDashes 
 ( 
 int 
 numberOfDashes 
 ) 
 { 
 for 
 ( 
 int 
 i 
 = 
 0 
 ; 
 i 
 < 
 numberOfDashes 
 ; 
 i 
 ++) 
 { 
 System 
 . 
 out 
 . 
 print 
 ( 
 "-" 
 ); 
 } 
 } 
 public 
 static 
 void 
 main 
 ( 
 String 
 [] 
 args 
 ) 
 { 
 PiedraPapelTijeras 
 game 
 = 
 new 
 PiedraPapelTijeras 
 (); 
 game 
 . 
 startGame 
 (); 
 } 
 }

wikiHows relacionados

Cómo
ejecutar un programa desde el símbolo del sistema en Linux
Cómo
hacer un programa usando Bloc de notas
Cómo
formatear texto como código en Discord
Cómo
usar el comando net send
Cómo cambiar un código de cerradura de Kwikset
Cómo
convertir de decimal a hexadecimal
Cómo
alinear textos e imágenes en HTML
Cómo
ejecutar un archivo Python desde el Símbolo del sistema de Windows
Cómo comentar múltiples líneas en Python: formato y accesos directos
Cómo
establecer el ancho y la altura de una imagen en HTML
Cómo
crear un archivo EXE
Cómo
calcular porcentaje en Java
Cómo cambiar códigos de usuario de 4 dígitos en cerraduras Schlage
Cómo
centrar un texto en lenguaje HTML
Anuncio

Acerca de este wikiHow

En otros idiomas
Esta página ha recibido 31 050 visitas.

¿Te ayudó este artículo?

Anuncio