Come Creare il Gioco Sasso, Carta, Forbici in Java

Sasso, carta, forbici è un gioco che si esegue fra due persone utilizzando le mani. Entrambi i giocatori dovranno pronunciare la formula “Sasso, carta, forbici”, dopodiché simultaneamente sceglieranno e faranno con una mano uno dei tre oggetti disponibili nel gioco (appunto sasso, carta o forbici). Il vincitore verrà determinato in base alla combinazione di oggetti risultante. Le forbici battono la carta, il sasso batte le forbici, e la carta batte il sasso. Se entrambi i giocatori hanno scelto lo stesso oggetto, il turno di gioco viene considerato in parità. Questo tutorial mostra come scrivere un programma in Java che replichi le dinamiche di questo gioco. Un giocatore sarà rappresentato dall'utente, mentre il secondo verrà controllato dal computer.

Passaggi

Scarica PDF

1
Crea la classe principale del programma e chiamala RockPaperScissors. Questa sarà la classe principale dove inseriremo il codice dell'intero programma. Puoi scegliere un nome diverso per questa classe, come ad esempio Game o Main. Scrivi al suo interno la dichiarazione dei metodi relativi al costruttore e al metodo principale “main”.
```
public class RockPaperScissors {    public RockPaperScissors() {            }        public static void main(String[] args) {            }}
```
2
Crea un'enumerazione che descriva i tre oggetti presenti nel gioco (sasso, carta, forbici). Potremmo usare tre semplici stringhe per rappresentare il sasso, la carta e le forbici, ma un'enumerazione ci permette di definire le nostre costanti; utilizzare un'enumerazione è dunque una scelta migliore a livello di progettazione del codice. La nostra enumerazione chiamata Move avrà i seguenti valori: ROCK (sasso), PAPER (carta) e SCISSORS (forbici).
```
private enum Move {    ROCK, PAPER, SCISSORS}
```
3
Crea due classi di tipo “private”, una chiamata User e l'altra Computer. Queste classi rappresentano i giocatori che si affrontano nel gioco reale. Se lo desideri puoi scegliere di dichiarare queste classi come “public”. La classe User è quella che chiederà all'utente di scegliere l'oggetto della sua mossa fra sasso, carta o forbici, quindi avremo la necessità di scrivere il metodo getMove() per eseguire la nostra mossa. Anche la classe Computer avrà la necessità di avere un metodo getMove(), perché anche il computer dovrà eseguire la sua mossa. Il codice di questi due metodi lo implementeremo in seguito, per il momento ci limiteremo alla loro dichiarazione. La classe User richiede un costruttore che crei l'oggetto Scanner adibito a leggere l'input dell'utente. Il campo Scanner verrà dichiarato come privato per la classe “User” e verrà inizializzato all'interno del costruttore della classe. Dato che stiamo utilizzando la classe predefinita di Java, Scanner, avremo la necessità di importarla nel nostro programma inserendo la relativa linea di “import” all'inizio del nostro codice. La classe Computer non richiede l'uso di un costruttore, quindi non dovremo scrivere codice per questo elemento. Quando inizializzeremo l'oggetto Computer, Java utilizzerà il costruttore predefinito. Di seguito trovi il codice della nostra classe RockPaperScissors scritto fino ad ora:
```
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() {         // Codice del metodo da implementare in seguito            return null;        }    }        private class Computer {        public Move getMove() {            // Codice del metodo da implementare in seguito            return null;        }    }        public RockPaperScissors() {            }        public static void main(String[] args) {            }}
```
4
Crea il metodo getMove() relativo alla classe Computer. Questo metodo restituirà il valore di una mossa casuale scelta all'interno dell'enumerazione Move. Possiamo creare un “array” di enumerazioni Move richiamando il metodo values() in questo modo: Move.values(). Per scegliere un'enumerazione Move casuale fra quelle presenti nel nostro “array” abbiamo la necessità di generare un indice casuale, che sarà rappresentato da un intero compreso fra 0 e il numero di tutti gli elementi contenuti nel nostro “array”. Per fare questo possiamo utilizzare il metodo nextInt() della classe Random che possiamo importare dal package java.util. Dopo aver ottenuto l'indice casuale, possiamo restituire il valore dell'enumerazione Move corrispondente, presente all'interno del nostro “array”.
```
public Move getMove() {    Move[] moves = Move.values();    Random random = new Random();    int index = random.nextInt(moves.length);    return moves[index];}
```
5
Scrivi il codice del metodo getMove() per la classe User. Questo metodo dovrà restituire il valore corrispondente alla mossa inserita dall'utente. Ci aspettiamo che l'utente scriva uno dei seguenti valori: “sasso”, “carta” o “forbici”. Il primo passo consiste nel chiedere all'utente di inserire un valore. Per farlo utilizziamo il seguente codice: System.out.print("Sasso, carta o forbici?"). Dopodiché utilizziamo il metodo nextLine() dell'oggetto Scanner per leggere l'input dell'utente e memorizzarlo in un oggetto di tipo “string”. Adesso dobbiamo controllare se l'utente ha inserito una mossa valida, pur rimanendo indulgenti nel caso di un errore di battitura. Quindi ci limiteremo a verificare che la prima lettera digitata corrisponda a “S” (nel caso del “sasso”), “C” (nel caso della “carta”) o “F” (nel caso delle “forbici”). Non ci preoccupiamo che l'utente abbia digitato una lettera maiuscola o minuscola, dato che utilizzeremo il metodo toUpperCase() della classe String per rendere maiuscoli tutti i caratteri inseriti dell'utente. Se l'utente non ha inserito una mossa valida, gli chiederemo nuovamente di eseguire la sua mossa. Dopodiché, in base all'input dell'utente, restituiremo il valore corrispondente alla mossa scelta.
```
public Move getMove() {    // Chiediamo l'input all'utente    System.out.print("Sasso, carta o forbici? ");    // Leggiamo l'input inserito dall'utente    String userInput = inputScanner.nextLine();    userInput = userInput.toUpperCase();    char firstLetter = userInput.charAt(0);    if (firstLetter == 'S' || firstLetter == 'C' || firstLetter == 'F') {        // Validiamo l'input inserito dall'utente        switch (firstLetter) {        case 'S':            return Move.ROCK;        case 'C':            return Move.PAPER;        case 'F':            return Move.SCISSORS;        }    }        // L'utente non ha inserito una mossa valida, chiediamo nuovamente di inserire una mossa    return getMove();}
```
6
Scrivi il metodo playAgain() per la classe User. L'utente dovrà essere in grado di giocare all'infinito. Per poter determinare se l'utente desidera giocare ancora, abbiamo la necessità di scrivere il metodo playAgain() che dovrà restituire un valore booleano in grado di rivelarci se l'utente vuole proseguire nel gioco oppure no. All'interno di questo metodo, utilizzeremo l'oggetto Scanner che abbiamo precedentemente creato nel costruttore della classe “User” per ottenere dall'utente un “Sì” o un “No”. Anche in questo caso controlleremo solo se la prima lettera inserita è una “Y”, per determinare se l'utente desidera giocare ancora. Qualsiasi altro carattere, numero o simbolo inserito corrisponderà alla volontà del giocatore di interrompere il gioco.
```
public boolean playAgain() {    System.out.print("Desideri giocare ancora? ");    String userInput = inputScanner.nextLine();    userInput = userInput.toUpperCase();    return userInput.charAt(0) == 'Y';}
```
7
Collega insieme le classi User e Computer all'interno della classe RockPaperScissors. Adesso che abbiamo terminato di scrivere il codice delle classi User e Computer, possiamo focalizzarci sul codice del gioco vero e proprio. All'interno della classe RockPaperScissors, dichiara due oggetti privati, uno di tipo User e uno di tipo Computer. Durante l'esecuzione del gioco, avremo la necessità di accedere ai due metodi getMove() delle rispettive classi “User” e “Computer”. Questi due oggetti verranno inizializzati all'interno del costruttore della classe RockPaperScissors. Avremo anche la necessità di tenere traccia del punteggio. Per farlo utilizzeremo i campi userScore e computerScore che inizializzeremo a 0 all'interno del costruttore della classe. Infine, avremo l'ulteriore necessità di tenere traccia del numero di partite il cui campo numberOfGames verrà inizializzato a 0 all'interno del costruttore della classe.
```
private User user;private Computer computer;private int userScore;private int computerScore;private int numberOfGames;public RockPaperScissors() {    user = new User();    computer = new Computer();    userScore = 0;    computerScore = 0;    numberOfGames = 0;}
```

8

Estendi l'enumerazione Move in modo che includa il metodo che ci dica quale sia la mossa vincente di ogni turno di gioco. Per farlo dobbiamo scrivere il metodo compareMoves() che restituisce il valore 0 se le mosse sono uguali, 1 se la mossa attuale batte la precedente e -1 se la mossa precedente batte l'attuale. Questo schema ci è utile per determinare chi sarà il vincitore del gioco. Nell'implementazione di questo metodo, per prima cosa, restituiremo il valore 0 se le mosse sono uguali e ci troviamo quindi in una situazione di parità. Dopodiché scriveremo il blocco di codice relativo alla restituzione dei valori 1 e -1.

private enum Move {    ROCK, PAPER, SCISSORS;    /**     * Confrontiamo la mossa corrente con la mossa precedente per determinare se è un pareggio, se      * vince o se perde     *      * @parametro otherMove     *           per eseguire il confronto     * @return 1 se questa mossa batte l'altra, -1 se questa mossa viene battuta dall'altra     *   0 se si tratta di un pareggio     */    public int compareMoves(Move otherMove) {        // Caso di parità        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);        }        // Il programma non dovrebbe mai raggiungere questo punto        return 0;    }}

9
All'interno della classe RockPaperScissors, crea il metodo startGame(). Questo è il metodo che permette di giocare al nostro gioco. Inizia il codice del metodo semplicemente inserendo la seguente linea System.out.println.
```
public void startGame() {        System.out.println("Sasso, Carta, Forbici!");}
```
10
Leggi le mosse eseguite dall'utente e dal computer. All'interno del metodo startGame(), richiama il metodo getMove() delle classi User e Computer. In questo modo farai eseguire una mossa all'utente e una al computer.
```
Move userMove = user.getMove();Move computerMove = computer.getMove();System.out.println("\nHai giocato " + userMove + ".");System.out.println("Il computer ha giocato " + computerMove + ".\n");
```

11

Confronta le due mosse scelte per determinare chi ha vinto il turno fra l'utente e il computer. Per farlo utilizza il metodo compareMoves() dell'enumerazione Move. Se è l'utente a vincere, incrementa di 1 il suo punteggio. Se l'utente ha perso, incrementa di 1 il punteggio del computer. Se si tratta di un pareggio, non modificare i punteggi dei giocatori. Al termine del confronto incrementa di 1 il numero di partite giocate.

int compareMoves = userMove.compareMoves(computerMove);switch (compareMoves) {case 0: // Pareggio    System.out.println("Pareggio!");    break;case 1: // Vince l'utente    System.out.println(userMove + " batte " + computerMove + ". Hai vinto!");    userScore++;    break;case -1: // Vince il computer    System.out.println(computerMove + " batte " + userMove + ". Hai perso.");    computerScore++;    break;}numberOfGames++;

12
Chiedi all'utente se desidera giocare ancora. In caso affermativo, richiama nuovamente il metodo startGame(). In caso negativo richiama il metodo printGameStats() per stampare a video le statistiche della partita. Creeremo questo metodo nel prossimo passaggio.
```
if (user.playAgain()) {    System.out.println();    startGame();} else {    printGameStats();}
```

13

Scrivi il codice del metodo printGameStats(). Questo metodo deve stampare a video le statistiche della partita: numero di vittorie, numero di sconfitte, numero di pareggi, numero di turni giocati e percentuale di turni vinti dall'utente. La percentuale di vittorie viene calcolato in questo modo (# di vittorie + (# numero di pareggi / 2)) / (# di turni giocati). Questo metodo utilizza il codice System.out.printf per visualizzare a video il testo formattato.

private void printGameStats() {    int wins = userScore;    int losses = computerScore;    int ties = numberOfGames - userScore - computerScore;    double percentageWon = (wins + ((double) ties) / 2) / numberOfGames;    // Stampa le linee    System.out.print("+");    printDashes(68);    System.out.println("+");    // Stampa i titoli    System.out.printf("|  %6s  |  %6s  |  %6s  |  %12s  |  %14s  |\n",            "VITTORIE", "SCONFITTE", "PAREGGI", "PARTITE GIOCATE", "PERCENTUALE DI VITTORIE");    // Stampa le linee    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("|");    // Stampa i valori delle statistiche    System.out.printf("|  %6d  |  %6d  |  %6d  |  %12d  |  %13.2f%%  |\n",            wins, losses, ties, numberOfGames, percentageWon * 100);    // Stampa la linea di chiusura    System.out.print("+");    printDashes(68);    System.out.println("+");}

14
All'interno della classe “main” scrivi il codice per dare inizio al gioco. All'interno della classe “main” verrà inizializzata un'istanza della classe RockPaperScissors e verrà richiamato il metodo startGame().
```
public static void main(String[] args) {    RockPaperScissors game = new RockPaperScissors();    game.startGame();}
```
15
Esegui un test del tuo programma. Adesso abbiamo terminato di scrivere tutto il codice relativo al nostro programma che replica il gioco “Sasso, carta, forbici”. È tempo di compilare e verificare che tutto funzioni correttamente.
Pubblicità

Programma di Esempio

import java.util.Random;import java.util.Scanner;public class RockPaperScissors {    private User user;    private Computer computer;    private int userScore;    private int computerScore;    private int numberOfGames;    private enum Move {        ROCK, PAPER, SCISSORS;        /**      * Confrontiamo la mossa corrente con la mossa precedente per determinare se è un pareggio, se      * vince o se perde     *      * @parametro otherMove     *           per eseguire il confronto     * @return 1 se questa mossa batte l'altra, -1 se questa mossa viene battuta dall'altra     *   0 se si tratta di un pareggio     */        public int compareMoves(Move otherMove) {            // Pareggio            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);            }            // Il programma non dovrebbe mai raggiungere questo punto            return 0;        }    }    private class User {        private Scanner inputScanner;        public User() {            inputScanner = new Scanner(System.in);        }        public Move getMove() {            // Chiedi all'utente di eseguire una mossa            System.out.print("Sasso, carta o forbici? ");            // Leggi l'input dell'utente            String userInput = inputScanner.nextLine();            userInput = userInput.toUpperCase();            char firstLetter = userInput.charAt(0);            if (firstLetter == 'S' || firstLetter == 'C' || firstLetter == 'F') {                // User has entered a valid input                switch (firstLetter) {                case 'S':                    return Move.ROCK;                case 'C':                    return Move.PAPER;                case 'F':                    return Move.SCISSORS;                }            }            // L'utente non ha inserito una mossa valida. Richiedi l'inserimento di una nuova mossa.            return getMove();        }        public boolean playAgain() {            System.out.print("Vuoi giocare ancora? ");            String userInput = inputScanner.nextLine();            userInput = userInput.toUpperCase();            return userInput.charAt(0) == 'Y';        }    }    private class Computer {        public Move getMove() {            Move[] moves = Move.values();            Random random = new Random();            int index = random.nextInt(moves.length);            return moves[index];        }    }    public RockPaperScissors() {        user = new User();        computer = new Computer();        userScore = 0;        computerScore = 0;        numberOfGames = 0;    }    public void startGame() {        System.out.println("SASSO, CARTA, FORBICI!");        // Esegui le mosse        Move userMove = user.getMove();        Move computerMove = computer.getMove();        System.out.println("\nHai giocato " + userMove + ".");        System.out.println("Il Computer ha giocato " + computerMove + ".\n");        // Confronta le mosse fatte per determinare il vincitore        int compareMoves = userMove.compareMoves(computerMove);        switch (compareMoves) {        case 0: // Pareggio            System.out.println("Pareggio!");            break;        case 1: // Vince l'utente            System.out.println(userMove + " batte " + computerMove + ". Hai vinto!");            userScore++;            break;        case -1: // Vince il Computer            System.out.println(computerMove + " batte " + userMove + ". Hai perso.");            computerScore++;            break;        }        numberOfGames++;        // Chiedi all'utente se vuole giocare ancora        if (user.playAgain()) {            System.out.println();            startGame();        } else {            printGameStats();        }    }    /**     * Stampa le statistiche della partita. La percentuale di vittorie tiene conto dei pareggi come      * fossero 1/2 punto.     */    private void printGameStats() {        int wins = userScore;        int losses = computerScore;        int ties = numberOfGames - userScore - computerScore;        double percentageWon = (wins + ((double) ties) / 2) / numberOfGames;            // Stampa una linea        System.out.print("+");        printDashes(68);        System.out.println("+");            // Stampa le intestazioni         System.out.printf("|  %6s  |  %6s  |  %6s  |  %12s  |  %14s  |\n",                "VITTORIE", "SCONFITTE", "PAREGGI", "PARTITE GIOCATE", "PERCENTUALE DI VITTORIE");            // Stampa le linee di separazione        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("|");            // stampa i valori        System.out.printf("|  %6d  |  %6d  |  %6d  |  %12d  |  %13.2f%%  |\n",                wins, losses, ties, numberOfGames, percentageWon * 100);            // stampa la linea di chiusura        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();    }}