Rock, Paper, Scissors é um jogo de mão jogado por duas pessoas. Ambas as pessoas diriam "pedra, papel, tesoura" e então simultaneamente formariam um de três objetos (pedra, papel ou tesoura) com a mão estendida. O vencedor é determinado pelas formações de mãos. A tesoura vence o papel, o papel vence a pedra e a pedra vence a tesoura. Se ambos os jogadores jogarem a mesma formação de mão, é considerado empate. Vamos escrever um jogo simples em Java para simular Pedra, Papel, Tesoura onde um jogador é o usuário e o outro é o computador.
Passos
Etapa 1. Crie a classe principal e chame-a
Pedra Papel Tesoura
.
Esta será a aula onde escreveremos o jogo. Você pode escolher outro nome, como
Jogo
ou
Principal
. Escreva declarações de método para o construtor e o método principal.
public class RockPaperScissors {public RockPaperScissors () {} public static void main (String args) {}}
Etapa 2. Crie uma enumeração para os gestos das mãos (pedra, papel ou tesoura)
Poderíamos usar strings para representar pedra, papel ou tesoura, mas uma enumeração nos permite predefinir nossas constantes, o que significa que usar a enumeração é um design melhor. Chamaremos nosso tipo de enum
Mover
com os valores
PEDRA
PAPEL
e
TESOURA
enum privado Move {ROCK, PAPER, SCISSORS}
Etapa 3. Crie duas aulas particulares
Do utilizador
e
Computador
.
Essas classes representarão nossos jogadores no jogo. Você pode optar por tornar essas aulas públicas. o
Do utilizador
classe será a classe que solicita ao usuário uma pedra, papel ou tesoura, portanto, precisaremos escrever um
getMove ()
método. o
Computador
a classe também precisará ter um
getMove ()
método para que o computador também possa fazer um movimento. Colocaremos marcadores de posição nesses métodos e os implementaremos posteriormente. o
Do utilizador
classe exigirá um construtor que configure o
Scanner
objeto para receber a entrada do usuário. Vamos colocar o
Scanner
como um campo privado para o usuário e, em seguida, inicie-o no construtor. Uma vez que estamos usando o
Scanner
precisamos escrever uma instrução de importação para ela no topo do nosso código. o
Computador
classe não requer um construtor, portanto, não precisamos escrever um; quando iniciamos o
Computador
objeto, estaremos apenas chamando o construtor padrão. Aqui está o nosso
Pedra Papel Tesoura
a classe parece agora:
import java.util. Scanner; public class RockPaperScissors {private enum Move {ROCK, PAPER, SCISSORS} private class User {private Scanner inputScanner; public User () {inputScanner = new Scanner (System.in); } public Move getMove () {// TODO: Implementa este método return null; }} private class Computer {public Move getMove () {// TODO: Implementar este método return null; }} public RockPaperScissors () {} public static void main (String args) {}}
Etapa 4. Escreva o
getMove ()
método para o
Computador
classe.
Este método retornará um aleatório
Mover
. Podemos obter uma variedade de
Mover
enumerações chamando o
valores ()
método:
Move.values ()
. Para escolher um aleatório
Mover
enumeração nesta matriz de valores, precisamos gerar um índice aleatório que seja um número inteiro entre 0 e o comprimento de nossa matriz de valores. Para fazer isso, podemos usar o
nextInt ()
método do
Aleatória
classe da qual precisamos importar
java.util
. Depois de obter o índice aleatório, podemos retornar o
Mover
desse índice de nossa matriz de valores.
public Move getMove () {Move moves = Move.values (); Aleatório aleatório = novo Aleatório (); índice interno = random.nextInt (moves.length); movimentos de retorno [índice]; }
Etapa 5. Escreva o
getMove ()
método para o
Do utilizador
classe.
Este método retornará um
Mover
correspondente ao que o usuário inseriu. Esperamos que o usuário escreva "pedra", "papel" ou "tesoura". Primeiro, precisamos solicitar ao usuário uma entrada:
System.out.print ("Pedra, papel ou tesoura?")
. Então use o
nextLine ()
método do
Scanner
objeto para obter a entrada do usuário como uma string. Precisamos agora verificar se o usuário enviou um movimento válido, mas podemos ser tolerantes se o usuário digitou uma palavra incorretamente. Portanto, verificaremos apenas se a primeira letra da entrada do usuário é "R" (para pedra), "P" (para papel) ou "S" (para tesoura), e não nos importamos com o caso porque vamos primeiro usar o
toUpperCase ()
método do
Fragmento
classe para tornar a string de entrada do usuário toda em maiúsculas. Se o usuário não tiver inserido uma entrada correta remotamente, solicitaremos novamente ao usuário. Então, dependendo do que o usuário inseriu, retornaremos um movimento correspondente.
public Move getMove () {// Solicita ao usuário System.out.print ("Pedra, papel ou tesoura?"); // Obtenha a entrada do usuário String userInput = inputScanner.nextLine (); userInput = userInput.toUpperCase (); char firstLetter = userInput.charAt (0); if (firstLetter == 'R' || firstLetter == 'P' || firstLetter == 'S') {// O usuário inseriu uma chave de entrada válida (firstLetter) {case 'R': return Move. ROCK; case 'P': retorna Move. PAPER; case 'S': retorna Move. SCISSORS; }} // O usuário não inseriu uma entrada válida. Solicite novamente. return getMove (); }
Etapa 6. Escreva um
jogar de novo()
método para o
Do utilizador
classe.
O usuário deve ser capaz de jogar o jogo indefinidamente. A fim de determinar se o usuário deseja jogar novamente, precisamos escrever um
jogar de novo()
método que retorna um booleano informando ao jogo se o usuário decidiu jogar novamente ou não. Neste método, estamos usando o
Scanner
que iniciamos anteriormente no construtor para obter um "Sim" ou um "Não" do usuário. Verificaremos apenas se a primeira letra é 'Y' para determinar se o usuário deseja jogar novamente. Qualquer outra entrada significará que o usuário não deseja jogar novamente.
public boolean playAgain () {System.out.print ("Deseja jogar novamente?"); String userInput = inputScanner.nextLine (); userInput = userInput.toUpperCase (); return userInput.charAt (0) == 'Y'; }
Etapa 7. Conecte o
Do utilizador
e
Computador
aulas juntas no
Pedra Papel Tesoura
classe.
Agora que terminamos de escrever o
Do utilizador
e
Computador
classes, podemos nos concentrar em trabalhar em nosso jogo real. Crie campos privados para o
Do utilizador
e
Computador
aulas no
Pedra Papel Tesoura
classe. Precisaremos acessar esses campos para acessar o
getMove ()
métodos quando estamos jogando o jogo. No construtor para o
Pedra Papel Tesoura
classe, inicie esses campos. Também precisaremos acompanhar a pontuação em
userScore
e
computerScore
campos, que precisamos iniciar como 0 no construtor. Precisamos controlar o número de jogos também, que também será um campo iniciado como 0.
usuário usuário privado; computador privado; private int userScore; private int computerScore; private int numberOfGames; public RockPaperScissors () {user = new User (); computador = novo computador (); userScore = 0; computerScore = 0; numberOfGames = 0; }
Etapa 8. Estenda o
Mover
enum para incluir um método que nos diz qual movimento vence em cada caso.
Precisamos escrever um
compareMoves ()
método que retorna 0 se os lances forem iguais, 1 se o lance atual vencer o outro lance e -1 se o lance atual perder para o outro lance. Isso será útil para determinar o vencedor no jogo. Para implementar esse método, primeiro retornaremos 0 se os movimentos forem os mesmos e, portanto, tivermos um empate. Em seguida, escreva uma instrução switch para retornar 1 ou -1.
enum privado Move {ROCK, PAPER, SCISSORS; / ** * Compara este movimento com outro para determinar um empate, uma vitória ou * uma derrota. * * @param otherMove * move para comparar com * @return 1 se este movimento bater o outro movimento, -1 se este movimento perder para * o outro movimento, 0 se estes movimentos empatarem * / public int compareMoves (Move otherMove) {/ / Empate if (this == otherMove) return 0; switch (this) {case ROCK: return (otherMove == SCISSORS? 1: -1); case PAPER: return (otherMove == ROCK? 1: -1); case SCISSORS: return (otherMove == PAPER? 1: -1); } // Nunca deve chegar aqui return 0; }}
Etapa 9. Crie um
Começar o jogo()
método no
Pedra Papel Tesoura
classe.
Este método será o jogo. Comece colocando um simples
System.out.println
no método.
public void startGame () {System.out.println ("ROCK, PAPER, SCISSORS!"); }
Etapa 10. Obter movimentos do usuário e do computador
No
Começar o jogo()
método, use o
getMove ()
métodos do
Do utilizador
classe e o
Computador
classe para obter os movimentos do usuário e do computador.
Mover userMove = user.getMove (); Mover computerMove = computer.getMove (); System.out.println ("\ nVocê jogou" + userMove + "."); System.out.println ("Computador jogado" + computerMove + ". / N");
Etapa 11. Compare as duas jogadas e determine se o usuário venceu ou o computador venceu
Use o
compareMoves ()
método do
Mover
enum para determinar se o usuário venceu ou não. Se o usuário venceu, aumente a pontuação do usuário em 1. Se o usuário perder, aumente a pontuação do computador em 1. Se houver empate, não aumente nenhuma das pontuações. Em seguida, aumente o número de jogos jogados por um.
int compareMoves = userMove.compareMoves (computerMove); switch (compareMoves) {case 0: // Tie System.out.println ("Tie!"); pausa; caso 1: // O usuário ganha System.out.println (userMove + "bate" + computerMove + ". Você ganhou!"); userScore ++; pausa; case -1: // O computador ganha System.out.println (computerMove + "bate" + userMove + ". Você perdeu."); computerScore ++; pausa; } numberOfGames ++;
Etapa 12. Pergunte se o usuário deseja jogar novamente
Se o usuário quiser jogar novamente, ligue
Começar o jogo()
novamente. Caso contrário, ligue
printGameStats ()
que imprimirá as estatísticas do jogo. Vamos escrever esse método na próxima etapa.
if (user.playAgain ()) {System.out.println (); Começar o jogo(); } else {printGameStats (); }
Etapa 13. Escreva o
printGameStats ()
método.
Este método exibirá as estatísticas do jogo: número de vitórias, número de derrotas, número de empates, número de jogos disputados e porcentagem de jogos vencidos pelo usuário. A porcentagem de jogos ganhos é calculada por (# vitórias + (# empates / 2)) / (# jogos disputados). Este método usa
System.out.printf
para imprimir o texto formatado.
privado void printGameStats () {int wins = userScore; perdas int = computerScore; empates int = numberOfGames - userScore - computerScore; porcentagem duplaWon = (vitórias + (duplas) empates) / 2) / númeroOfGames; // Linha System.out.print ("+"); printDashes (68); System.out.println ("+"); // Imprimir títulos System.out.printf ("|% 6s |% 6s |% 6s |% 12s |% 14s | / n", "GANHA", "PERDAS", "TIES", "JOGOS JOGADOS", "PORCENTAGEM GANHOU"); // Linha 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", vitórias, derrotas, empates, numberOfGames, percentWon * 100); // Linha System.out.print ("+"); printDashes (68); System.out.println ("+"); }
Etapa 14. Inicie o jogo na classe principal
Na classe principal, inicialize uma instância do
Pedra Papel Tesoura
classe e ligue para o
Começar o jogo()
método.
public static void main (String args) {RockPaperScissors game = new RockPaperScissors (); game.startGame (); }
Etapa 15. Teste seu jogo
Agora que passamos por todos os esforços para escrever o jogo Pedra, Papel e Tesoura, é hora de compilar e testar tudo!
Programa de Amostra
import java.util. Random; import java.util. Scanner; public class RockPaperScissors {usuário usuário privado; computador privado; private int userScore; private int computerScore; private int numberOfGames; enum privado Move {ROCK, PAPER, SCISSORS; / ** * Compara este movimento com outro para determinar um empate, uma vitória ou * uma derrota. * * @param otherMove * move para comparar com * @return 1 se este movimento bater o outro movimento, -1 se este movimento perder para * o outro movimento, 0 se estes movimentos empatarem * / public int compareMoves (Move otherMove) {/ / Empate if (this == otherMove) return 0; switch (this) {case ROCK: return (otherMove == SCISSORS? 1: -1); case PAPER: return (otherMove == ROCK? 1: -1); case TESOURAS: return (otherMove == PAPER? 1: -1); } // Nunca deve chegar aqui return 0; }} private class User {private Scanner inputScanner; public User () {inputScanner = new Scanner (System.in); } public Move getMove () {// Solicita ao usuário System.out.print ("Pedra, papel ou tesoura?"); // Obtenha a entrada do usuário String userInput = inputScanner.nextLine (); userInput = userInput.toUpperCase (); char firstLetter = userInput.charAt (0); if (firstLetter == 'R' || firstLetter == 'P' || firstLetter == 'S') {// O usuário inseriu uma chave de entrada válida (firstLetter) {case 'R': return Move. ROCK; case 'P': retorna Move. PAPER; case 'S': retorna Move. SCISSORS; }} // O usuário não inseriu uma entrada válida. Solicite novamente. return getMove (); } public boolean playAgain () {System.out.print ("Deseja jogar novamente?"); String userInput = inputScanner.nextLine (); userInput = userInput.toUpperCase (); return userInput.charAt (0) == 'Y'; }} private class Computador {public Move getMove () {Move moves = Move.values (); Aleatório aleatório = novo Aleatório (); índice interno = random.nextInt (moves.length); movimentos de retorno [índice]; }} public RockPaperScissors () {user = new User (); computador = novo computador (); userScore = 0; computerScore = 0; numberOfGames = 0; } public void startGame () {System.out.println ("ROCK, PAPER, SCISSORS!"); // Obter movimentos Mover userMove = user.getMove (); Mover computerMove = computer.getMove (); System.out.println ("\ nVocê jogou" + userMove + "."); System.out.println ("Computador jogado" + computerMove + ". / N"); // Compare as jogadas e determine o vencedor int compareMoves = userMove.compareMoves (computerMove); switch (compareMoves) {case 0: // Tie System.out.println ("Tie!"); pausa; caso 1: // O usuário ganha System.out.println (userMove + "bate" + computerMove + ". Você ganhou!"); userScore ++; pausa; case -1: // O computador ganha System.out.println (computerMove + "bate" + userMove + ". Você perdeu."); computerScore ++; pausa; } numberOfGames ++; // Peça ao usuário para jogar novamente if (user.playAgain ()) {System.out.println (); Começar o jogo(); } else {printGameStats (); }} / ** * Imprime as estatísticas do jogo. Calcula o empate como 1/2 de vitória em * porcentagem ganha. * / private void printGameStats () {int wins = userScore; perdas internas = computerScore; empates int = numberOfGames - userScore - computerScore; porcentagem duplaWon = (vitórias + (duplas) empates) / 2) / númeroOfGames; // Linha System.out.print ("+"); printDashes (68); System.out.println ("+"); // Imprimir títulos System.out.printf ("|% 6s |% 6s |% 6s |% 12s |% 14s | / n", "GANHA", "PERDAS", "TIES", "JOGOS JOGADOS", "PORCENTAGEM GANHOU"); // Linha 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", vitórias, derrotas, empates, numberOfGames, percentWon * 100); // Linha 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) {RockPaperScissors game = new RockPaperScissors (); game.startGame (); }}
