Come creare un gioco Tic-Tac-Toe in Python?

Creiamo un semplice gioco Tic Tac Toe in Python. Ti aiuterà a costruire la logica del gioco e a capire come strutturare il codice.

Il gioco è uno degli intrattenimenti che gli umani hanno. Possiamo trovare diversi tipi di giochi sul web, mobile, desktop, ecc. Non siamo qui per creare uno di quei giochi pesanti ora. Creeremo un gioco tris CLI usando Python.

Se non hai familiarità con Tic Tac Toe, riproducilo visivamente qui per capire. Non preoccuparti, anche se non lo capisci, lo vedremo.

Tic Tac Toe

Il tutorial è diviso in tre diverse sezioni. Nella prima sezione imparerai a giocare al gioco del tris. Successivamente, vedremo un algoritmo che ci aiuta a elaborare la logica del gioco. Infine, vedremo il codice strutturato e la sua spiegazione.

Puoi saltare la prima sezione se sai già come giocare a Tic Tac Toe.

Quindi, senza ulteriori indugi, tuffiamoci nella nostra prima sezione.

Giocare a Tic Tac Toe

Ci saranno due giocatori in una partita. Due segni rappresentano ogni giocatore. I segni generali utilizzati nel gioco sono X e O . Infine, ci sarà un tabellone con 9 scatole.

Guarda visivamente il tabellone del tris.

Il gameplay sarà il seguente.

• Innanzitutto, un utente inserirà il proprio segno in una delle caselle vuote disponibili.
• Successivamente, il secondo utente inserirà il proprio segno in una delle caselle vuote disponibili.
• L'obiettivo dei giocatori è posizionare i rispettivi segni completamente in senso riga o colonna o in diagonale.
• Il gioco continua fino a quando un giocatore non vince la partita o finisce in pareggio riempiendo tutte le caselle senza una partita vincente.

Vediamo alcuni gameplay visivamente.

Il giocatore X vince la partita nel gameplay di cui sopra. Tutte le caselle si riempiono diagonalmente di segni X. Quindi, il rispettivo giocatore vince la partita.

Ci sono un totale di 8 modi per organizzare lo stesso segno e vincere la partita. Vediamo tutti gli 8 arrangiamenti che possono vincere la partita.

E infine, un pareggio riempie il tabellone senza alcun accordo vincente. Spero che tu capisca come fare Tic Tac Toe ora.

Ora è tempo di giocare per te. Puoi andare qui e giocarci per capire completamente il gameplay. Lascialo se l'hai già preso.

Ora è il momento di spostare la sezione dell'algoritmo.

Algoritmo

Discuteremo ora l'algoritmo per scrivere il codice. Questo algoritmo ti aiuterà a scrivere codice in qualsiasi linguaggio di programmazione di tua scelta. Vediamo come si fa.

• Crea una scheda utilizzando un array bidimensionale e inizializza ogni elemento come vuoto.
  • Puoi rappresentare il vuoto usando qualsiasi simbolo che ti piace. Qui, useremo un trattino. '-' .
• Scrivi una funzione per verificare se la bacheca è piena o meno.
  • Itera sulla scacchiera e restituisce false se la scheda contiene un segno vuoto oppure restituisce true .
• Scrivi una funzione per verificare se un giocatore ha vinto o meno.
  • Dobbiamo verificare tutte le possibilità che abbiamo discusso nella sezione precedente.
  • Controlla tutte le righe, le colonne e le due diagonali.
• Scrivi una funzione per mostrare il tabellone poiché mostreremo il tabellone più volte agli utenti mentre stanno giocando.
• Scrivi una funzione per avviare il gioco.
  • Seleziona casualmente il primo turno del giocatore.
  • Scrivi un ciclo infinito che si interrompe quando il gioco è finito (vinci o pareggia).
    • Mostra la scacchiera all'utente per selezionare il punto per la prossima mossa.
    • Chiedi all'utente di inserire il numero di riga e colonna.
    • Aggiorna lo spot con il rispettivo segno del giocatore.
    • Controlla se il giocatore attuale ha vinto o meno.
    • Se il giocatore attuale ha vinto la partita, stampa un messaggio vincente e interrompi il ciclo infinito.
    • Quindi, controlla se la scheda è piena o meno.
    • Se il tabellone è pieno, stampa il messaggio di estrazione e interrompi il ciclo infinito.
  • Infine, mostra all'utente la vista finale della scheda.

Potresti essere in grado di visualizzare cosa sta succedendo. Non preoccuparti, anche se non l'hai capito completamente. Avrai più chiarezza una volta che vedrai il codice.

Quindi, passiamo alla sezione del codice. Presumo che tu abbia installato Python sul tuo PC per provare il codice.

Codice

Passa attraverso il codice sottostante.

 import random class TicTacToe: def __init__(self): self.board = [] def create_board(self): for i in range(3): row = [] for j in range(3): row.append('-') self.board.append(row) def get_random_first_player(self): return random.randint(0, 1) def fix_spot(self, row, col, player): self.board[row][col] = player def is_player_win(self, player): win = None n = len(self.board) # checking rows for i in range(n): win = True for j in range(n): if self.board[i][j] != player: win = False break if win: return win # checking columns for i in range(n): win = True for j in range(n): if self.board[j][i] != player: win = False break if win: return win # checking diagonals win = True for i in range(n): if self.board[i][i] != player: win = False break if win: return win win = True for i in range(n): if self.board[i][n - 1 - i] != player: win = False break if win: return win return False for row in self.board: for item in row: if item == '-': return False return True def is_board_filled(self): for row in self.board: for item in row: if item == '-': return False return True def swap_player_turn(self, player): return 'X' if player == 'O' else 'O' def show_board(self): for row in self.board: for item in row: print(item, end=" ") print() def start(self): self.create_board() player = 'X' if self.get_random_first_player() == 1 else 'O' while True: print(f"Player {player} turn") self.show_board() # taking user input row, col = list( map(int, input("Enter row and column numbers to fix spot: ").split())) print() # fixing the spot self.fix_spot(row - 1, col - 1, player) # checking whether current player is won or not if self.is_player_win(player): print(f"Player {player} wins the game!") break # checking whether the game is draw or not if self.is_board_filled(): print("Match Draw!") break # swapping the turn player = self.swap_player_turn(player) # showing the final view of board print() self.show_board() # starting the game tic_tac_toe = TicTacToe() tic_tac_toe.start()

Controlla l'output di esempio del codice.

 $ python tic_tac_toe.py Player X turn - - - - - - - - - Enter row and column numbers to fix spot: 1 1 Player O turn X - - - - - - - - Enter row and column numbers to fix spot: 2 1 Player X turn X - - O - - - - - Enter row and column numbers to fix spot: 1 2 Player O turn XX - O - - - - - Enter row and column numbers to fix spot: 1 3 Player X turn XXO O - - - - - Enter row and column numbers to fix spot: 2 2 Player O turn XXO OX - - - - Enter row and column numbers to fix spot: 3 3 Player X turn XXOOX - - - O Enter row and column numbers to fix spot: 3 2 Player X wins the game! XXO OX - - XO

Alcuni punti importanti che aiutano a comprendere la struttura del codice.

• Abbiamo usato una classe per avere tutti i metodi in un unico posto. Può essere facilmente un pacchetto riutilizzabile anche in qualche altro codice.
• Successivamente, abbiamo definito diverse funzioni per ogni responsabilità, anche se è un compito piccolo. Aiuta a mantenere il codice con facilità.
• I due approcci precedenti ci aiutano ad aggiornare l'app senza sforzo se vogliamo aggiornare il gioco.

Sentiti libero di adattare la struttura e migliorarla in base al tuo progetto. La strutturazione del codice non è limitata.

Parole finali

evviva! Hai creato un gioco completamente da zero. Non è uno dei giochi visivi a cui giochiamo ogni giorno. Ma ti aiuta a scrivere la logica e a mantenere una struttura pulita nel codice. Segui linee guida simili per creare alcuni giochi interessanti come questo. Puoi trovare giochi simili se torni indietro di alcuni anni alla tua infanzia.

Buona codifica!

Successivamente, esplora come creare un gioco di ipotesi numerica e Unit Testing con Python unittest Module.