Tris Java: come realizzarlo passaggio per passaggio

Ecco un esempio di codice Java per implementare il gioco del tris contro il computer. Ci sono molti modi per farlo, quindi questa è solo una possibile soluzione.

Il gioco del tris è un classico passatempo che tutti conosciamo, spesso giocato su un foglio di carta. In questo articolo vedremo come implementare il gioco del tris in Java, includendo una modalità di gioco contro il computer. Il nostro programma utilizzerà una griglia 3×3, in cui due giocatori (il giocatore umano e il computer) si sfideranno per ottenere tre simboli in linea (orizzontale, verticale o diagonale). Ogni giocatore potrà inserire il proprio simbolo (X per il giocatore umano e O per il computer) alternativamente, finché non verrà raggiunto un risultato (una vittoria o un pareggio). Vedremo in dettaglio come implementare le funzionalità principali del gioco, inclusa la validazione delle mosse, la verifica della vittoria e la scelta della mossa del computer.

ALLA FINE DI QUESTO ARTICOLO TROVERETE IL CODICE COMPLETO

Tris java: analizziamo i passaggi

La prima cosa che facciamo è definire alcune costanti utilizzate nel gioco, come la dimensione della griglia (che è 3×3) e i simboli utilizzati dai due giocatori (‘X’ per il giocatore umano e ‘O’ per il computer):

public class Tris {
private static final int DIMENSIONE_GRIGLIA = 3;
private static final char GIOCATORE_UMANO = 'X';
private static final char GIOCATORE_COMPUTER = 'O';
…
}

Inizializziamo poi la griglia con i simboli ‘-‘ in ogni cella:

char[][] griglia = new char[DIMENSIONE_GRIGLIA][DIMENSIONE_GRIGLIA];
for (int i = 0; i < DIMENSIONE_GRIGLIA; i++) {
    for (int j = 0; j < DIMENSIONE_GRIGLIA; j++) {
        griglia[i][j] = '-';
    }
}

Il gioco inizia con il giocatore umano, quindi inizializziamo la variabile giocatoreCorrente con il valore del simbolo del giocatore umano:

char giocatoreCorrente = GIOCATORE_UMANO;

Inizia quindi il ciclo principale del gioco, che continua finché non ci sono più mosse disponibili o finché non c’è un vincitore. Ad ogni turno, stampiamo la griglia, chiediamo al giocatore corrente di fare una mossa e controlliamo se la mossa è valida. Se la mossa è valida, aggiorniamo la griglia, incrementiamo il numero di mosse effettuate e cambiamo il giocatore corrente. Se la mossa non è valida, stampiamo un messaggio di errore e chiediamo al giocatore di fare un’altra mossa:

while (mosseEffettuate < DIMENSIONE_GRIGLIA * DIMENSIONE_GRIGLIA) {
    stampaGriglia(griglia);
    if (giocatoreCorrente == GIOCATORE_UMANO) {
        System.out.println("E' il turno del giocatore umano.");
        System.out.print("Inserisci la riga della tua mossa (0-2): ");
        int riga = scanner.nextInt();
        System.out.print("Inserisci la colonna della tua mossa (0-2): ");
        int colonna = scanner.nextInt();
        if (mossaValida(griglia, riga, colonna)) {
            griglia[riga][colonna] = GIOCATORE_UMANO;
            mosseEffettuate++;
            giocatoreCorrente = GIOCATORE_COMPUTER;
        } else {
            System.out.println("Mossa non valida. Riprova.");
        }
    } else {
        System.out.println("E' il turno del computer.");
        // ...
    }
}

Quando il ciclo termina, stampiamo la griglia finale e controlliamo il vincitore utilizzando il metodo haVinto:

stampaGriglia(griglia);
if (haVinto(griglia, GIOCATORE_UMANO)) {
System.out.println("Il giocatore umano ha vinto!");
} else if (haVinto(griglia, GIOCATORE_COMPUTER)) {
System.out.println("Il computer ha vinto!");
} else {
System.out.println("Pareggio!");
}
``

Per quanto riguarda il turno del computer, utilizziamo un algoritmo molto semplice che sceglie una mossa casuale finché non trova una mossa valida:

if (giocatoreCorrente == GIOCATORE_COMPUTER) {
System.out.println("E' il turno del computer.");
int riga, colonna;
do {
riga = random.nextInt(DIMENSIONE_GRIGLIA);
colonna = random.nextInt(DIMENSIONE_GRIGLIA);
} while (!mossaValida(griglia, riga, colonna));
griglia[riga][colonna] = GIOCATORE_COMPUTER;
mosseEffettuate++;
giocatoreCorrente = GIOCATORE_UMANO;
}

Il metodo mossaValida controlla se la mossa inserita dal giocatore è valida, cioè se la cella corrispondente è vuota:

private static boolean mossaValida(char[][] griglia, int riga, int colonna) {
return griglia[riga][colonna] == '-';
}

Il metodo haVinto controlla se un giocatore ha vinto il gioco, controllando tutte le possibili combinazioni di tre simboli uguali in linea:

private static boolean haVinto(char[][] griglia, char giocatore) {
// Controllo le righe
for (int i = 0; i < DIMENSIONE_GRIGLIA; i++) {
if (griglia[i][0] == giocatore && griglia[i][1] == giocatore && griglia[i][2] == giocatore) {
return true;
}
}
// Controllo le colonne
for (int j = 0; j < DIMENSIONE_GRIGLIA; j++) {
if (griglia[0][j] == giocatore && griglia[1][j] == giocatore && griglia[2][j] == giocatore) {
return true;
}
}
// Controllo le diagonali
if (griglia[0][0] == giocatore && griglia[1][1] == giocatore && griglia[2][2] == giocatore) {
return true;
}
if (griglia[0][2] == giocatore && griglia[1][1] == giocatore && griglia[2][0] == giocatore) {
return true;
}
return false;
}

Infine, il metodo stampaGriglia stampa la griglia con i simboli attuali dei giocatori:

private static void stampaGriglia(char[][] griglia) {
System.out.println("Griglia:");
for (int i = 0; i < DIMENSIONE_GRIGLIA; i++) {
for (int j = 0; j < DIMENSIONE_GRIGLIA; j++) {
System.out.print(griglia[i][j] + " ");
}
System.out.println();
}
}

Questo è solo un esempio molto semplice di come si può implementare il gioco del tris in Java contro il computer. Ci sono molte varianti e miglioramenti che si possono apportare, come ad esempio un algoritmo più sofisticato per la mossa del computer o l’implementazione di un’interfaccia grafica per rendere il gioco più user-friendly.

Tris JAVA: programma completo

import java.util.Scanner;

public class TrisControIlComputer {
// Definiamo la costante per la dimensione della griglia
private static final int DIMENSIONE_GRIGLIA = 3;
// Definiamo le costanti per i segni dei giocatori
private static final char GIOCATORE_UMANO = 'X';
private static final char GIOCATORE_COMPUTER = 'O';

public static void main(String[] args) {
    // Inizializziamo la griglia vuota
    char[][] griglia = new char[DIMENSIONE_GRIGLIA][DIMENSIONE_GRIGLIA];
    for (int i = 0; i < DIMENSIONE_GRIGLIA; i++) {
        for (int j = 0; j < DIMENSIONE_GRIGLIA; j++) {
            griglia[i][j] = '-';
        }
    }

    // Inizializziamo il giocatore umano come il primo giocatore
    char giocatoreCorrente = GIOCATORE_UMANO;

    // Inizializziamo il numero di mosse effettuate a 0
    int mosseEffettuate = 0;

    // Creiamo uno scanner per leggere l'input dall'utente
    Scanner input = new Scanner(System.in);

    // Continuiamo finché non abbiamo un vincitore o la griglia è piena
    while (!haVinto(griglia, GIOCATORE_UMANO) && !haVinto(griglia, GIOCATORE_COMPUTER) && mosseEffettuate < DIMENSIONE_GRIGLIA * DIMENSIONE_GRIGLIA) {
        // Stampiamo la griglia corrente
        stampaGriglia(griglia);

        if (giocatoreCorrente == GIOCATORE_UMANO) {
            // Chiediamo all'utente di fare una mossa
            System.out.println("Turno del giocatore umano");
            System.out.print("Inserisci la riga (da 1 a " + DIMENSIONE_GRIGLIA + "): ");
            int riga = input.nextInt() - 1;
            System.out.print("Inserisci la colonna (da 1 a " + DIMENSIONE_GRIGLIA + "): ");
            int colonna = input.nextInt() - 1;

            // Controlliamo che la mossa sia valida
            if (mossaValida(griglia, riga, colonna)) {
                // Aggiorniamo la griglia
                griglia[riga][colonna] = GIOCATORE_UMANO;
                mosseEffettuate++;
                // Cambiamo il giocatore corrente
                giocatoreCorrente = GIOCATORE_COMPUTER;
            } else {
                System.out.println("Mossa non valida, riprova.");
            }
        } else {
            // È il turno del computer, facciamo una mossa casuale
            System.out.println("Turno del computer");
            int riga = (int) (Math.random() * DIMENSIONE_GRIGLIA);
            int colonna = (int) (Math.random() * DIMENSIONE_GRIGLIA);

            // Controlliamo che la mossa sia valida
            if (mossaValida(griglia, riga, colonna))
                // Aggiorniamo la griglia
                griglia[riga][colonna] = GIOCATORE_COMPUTER;
                mosseEffettuate++;
                // Cambiamo il giocatore corrente
                giocatoreCorrente = GIOCATORE_UMANO;
            }
        }
    }

    // Stampiamo la griglia finale
    stampaGriglia(griglia);

    // Controlliamo il vincitore
    if (haVinto(griglia, GIOCATORE_UMANO)) {
        System.out.println("Il giocatore umano ha vinto!");
    } else if (haVinto(griglia, GIOCATORE_COMPUTER)) {
        System.out.println("Il computer ha vinto!");
    } else {
        System.out.println("Pareggio!");
    }
}

// Metodo per controllare se una mossa è valida
private static boolean mossaValida(char[][] griglia, int riga, int colonna) {
    return riga >= 0 && riga < DIMENSIONE_GRIGLIA &&
            colonna >= 0 && colonna < DIMENSIONE_GRIGLIA &&
            griglia[riga][colonna] == '-';
}

// Metodo per controllare se un giocatore ha vinto
private static boolean haVinto(char[][] griglia, char giocatore) {
    // Controlliamo le righe
    for (int i = 0; i < DIMENSIONE_GRIGLIA; i++) {
        boolean rigaVinta = true;
        for (int j = 0; j < DIMENSIONE_GRIGLIA; j++) {
            if (griglia[i][j] != giocatore) {
                rigaVinta = false;
                break;
            }
        }
        if (rigaVinta) {
            return true;
        }
    }

    // Controlliamo le colonne
    for (int j = 0; j < DIMENSIONE_GRIGLIA; j++) {
        boolean colonnaVinta = true;
        for (int i = 0; i < DIMENSIONE_GRIGLIA; i++) {
            if (griglia[i][j] != giocatore) {
                colonnaVinta = false;
                break;
            }
        }
        if (colonnaVinta) {
            return true;
        }
    }

    // Controlliamo le diagonali
    boolean diagonale1Vinta = true;
    boolean diagonale2Vinta = true;
    for (int i = 0; i < DIMENSIONE_GRIGLIA; i++) {
        if (griglia[i][i] != giocatore) {
            diagonale1Vinta = false;
        }
        if (griglia[i][DIMENSIONE_GRIGLIA - 1 - i] != giocatore) {
            diagonale2Vinta = false;
        }
    }
    if (diagonale1Vinta || diagonale2Vinta) {
        return true;
    }

    // Nessun vincitore
    return false;
}

// Metodo per stampare la griglia
private static void stampaGriglia(char[][] griglia) {
    for (int i = 0; i < DIMENSIONE_GRIGLIA; i++) {
        for (int j = 0; j < DIMENSIONE_GRIGLIA; j++) {
            System.out.print(griglia[i][j] + " ");
        }
        System.out.println();
    }
}
}