Vom dezvolta un joc simplu de X și 0 (Tic Tac Toe) în Python. Acest demers vă va familiariza cu construirea logicii unui joc și cu structurarea adecvată a codului.
Jocurile sunt o formă comună de divertisment. O gamă variată de jocuri sunt disponibile pe web, mobil, desktop și alte platforme. Scopul nostru aici nu este să creăm un joc complex. Vom construi un joc Tic Tac Toe bazat pe linia de comandă (CLI) folosind Python.
Dacă nu sunteți familiarizat cu jocul Tic Tac Toe, puteți vizualiza aici pentru o înțelegere rapidă. Nu vă îngrijorați dacă conceptul nu este complet clar acum, îl vom clarifica în cele ce urmează.
Tic Tac Toe
Acest tutorial este segmentat în trei părți distincte. Prima parte vă va introduce în modul de joc al Tic Tac Toe. În secțiunea următoare, vom analiza un algoritm care ne va ajuta să creăm logica jocului. În final, vom studia codul structurat și explicațiile sale.
Dacă știți deja cum se joacă Tic Tac Toe, puteți trece direct la secțiunea a doua.
Acum, să începem cu prima secțiune.
Cum se joacă Tic Tac Toe
Un joc implică doi jucători, fiecare reprezentat de un simbol. Simbolurile uzuale sunt X și O. Jocul se desfășoară pe o tablă formată din 9 căsuțe.
Observați vizual structura tablei de Tic Tac Toe.
Tabla de joc Tic Tac Toe
Modul de desfășurare al jocului este următorul:
- Primul jucător își va plasa simbolul într-o căsuță goală.
- Apoi, al doilea jucător își va plasa simbolul într-o altă căsuță goală.
- Obiectivul jucătorilor este de a alinia complet propriile simboluri pe orizontală, verticală sau diagonală.
- Jocul se continuă până când un jucător câștigă sau până când toate căsuțele sunt ocupate, rezultând o remiză.
Să analizăm câteva exemple vizuale de desfășurare a jocului.
Exemplu de victorie în Tic Tac Toe
În exemplul de mai sus, jucătorul X a câștigat jocul. Toate căsuțele de pe diagonală sunt ocupate cu simbolul X. Prin urmare, acest jucător a obținut victoria.
Există un total de 8 modalități de a aranja același simbol pentru a câștiga. Să vedem toate cele 8 configurații posibile care duc la victorie.
Într-o remiză, toate căsuțele sunt completate fără ca niciun jucător să realizeze o configurație câștigătoare. Sperăm că înțelegeți cum se joacă Tic Tac Toe acum.
Acum, e timpul să exersați. Puteți merge aici pentru a juca și a înțelege complet mecanica jocului. Dacă deja cunoașteți jocul, puteți trece mai departe.
Acum, haideți să trecem la secțiunea despre algoritm.
Algoritmul
Vom discuta despre algoritmul pentru scrierea codului. Acest algoritm vă va ajuta să scrieți codul în orice limbaj de programare. Să vedem cum se procedează.
- Creați o tablă de joc folosind o matrice bidimensională și inițializați fiecare element ca fiind gol.
- Puteți utiliza orice simbol pentru a reprezenta golul. În acest caz, vom folosi caracterul liniuță (‘-‘).
- Creați o funcție pentru a verifica dacă tabla este complet ocupată sau nu.
- Iterați prin tablă. Dacă întâlniți un simbol gol, returnați false; în caz contrar, returnați true.
- Creați o funcție pentru a determina dacă un jucător a câștigat.
- Trebuie să verificăm toate configurațiile posibile care duc la victorie, așa cum am discutat anterior.
- Verificați toate rândurile, coloanele și cele două diagonale.
- Creați o funcție pentru a afișa tabla de joc. Vom afișa tabla de mai multe ori jucătorilor în timpul jocului.
- Creați o funcție pentru a începe jocul.
- Selectați aleatoriu primul jucător.
- Inițializați o buclă infinită care se va încheia când jocul se termină (fie victorie, fie remiză).
- Afișați tabla de joc pentru ca jucătorul să-și aleagă următoarea mutare.
- Solicitați jucătorului să introducă numerele rândului și coloanei.
- Actualizați poziția aleasă cu simbolul jucătorului.
- Verificați dacă jucătorul curent a câștigat jocul.
- Dacă jucătorul curent a câștigat, afișați un mesaj de victorie și încheiați bucla.
- Verificați dacă tabla este complet ocupată.
- Dacă tabla este complet ocupată, afișați un mesaj de remiză și încheiați bucla.
- În final, afișați vizualizarea finală a tablei.
Probabil vă puteți imagina desfășurarea algoritmului. Nu vă faceți griji dacă nu ați înțeles totul perfect. Veți înțelege mai bine odată ce veți vedea codul.
Așadar, haideți să trecem la secțiunea de cod. Presupun că aveți Python instalat pe computer pentru a putea testa codul.
Codul
Analizați codul de mai jos.
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)
# verificarea rândurilor
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
# verificarea coloanelor
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
# verificarea diagonalelor
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
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"Este rândul jucătorului {player}")
self.show_board()
# obținerea inputului de la utilizator
row, col = list(
map(int, input("Introduceți numărul rândului și al coloanei: ").split()))
print()
# marcarea poziției
self.fix_spot(row - 1, col - 1, player)
# verificarea dacă jucătorul a câștigat
if self.is_player_win(player):
print(f"Jucătorul {player} a câștigat!")
break
# verificarea dacă jocul este remiză
if self.is_board_filled():
print("Remiză!")
break
# schimbarea jucătorului
player = self.swap_player_turn(player)
# afișarea tablei finale
print()
self.show_board()
# inițierea jocului
tic_tac_toe = TicTacToe()
tic_tac_toe.start()
Vedeți un exemplu de rezultat al execuției codului.
$ python tic_tac_toe.py Este rândul jucătorului X - - - - - - - - - Introduceți numărul rândului și al coloanei: 1 1 Este rândul jucătorului O X - - - - - - - - Introduceți numărul rândului și al coloanei: 2 1 Este rândul jucătorului X X - - O - - - - - Introduceți numărul rândului și al coloanei: 1 2 Este rândul jucătorului O X X - O - - - - - Introduceți numărul rândului și al coloanei: 1 3 Este rândul jucătorului X X X O O - - - - - Introduceți numărul rândului și al coloanei: 2 2 Este rândul jucătorului O X X O O X - - - - Introduceți numărul rândului și al coloanei: 3 3 Este rândul jucătorului X X X O O X - - - O Introduceți numărul rândului și al coloanei: 3 2 Jucătorul X a câștigat! X X O O X - - X O
Câteva aspecte importante care vă pot ajuta să înțelegeți structura codului:
- Am folosit o clasă pentru a organiza toate metodele într-un singur loc. Astfel, codul devine un modul reutilizabil în alte aplicații.
- Am creat funcții separate pentru fiecare responsabilitate, chiar și pentru cele minore. Acest lucru ajută la menținerea clarității codului.
- Cele două abordări de mai sus facilitează actualizarea aplicației dacă dorim să adăugăm noi funcționalități la joc.
Nu ezitați să adaptați structura codului pentru a se potrivi mai bine cu proiectul dumneavoastră. Nu există o limită în ceea ce privește structurarea codului.
Concluzii
Felicitări! 😎 Ați creat un joc complet de la zero. Acesta nu este un joc vizual complex, dar vă ajută să înțelegeți logica unui joc și să mențineți o structură curată a codului. Utilizați aceleași instrucțiuni pentru a crea și alte jocuri interactive. Puteți găsi inspirație în jocurile copilăriei.
Spor la codat! 👩💻
Vă recomandăm să explorați cum să dezvoltați un joc de ghicit numere și să efectuați teste unitare folosind modulul Python unittest.
V-a plăcut acest articol? Vă încurajăm să-l distribuiți și cu alții!