Lær å lage et enkelt Tic Tac Toe-spill med Python
La oss dykke ned i verden av spillutvikling og skape et grunnleggende Tic Tac Toe-spill ved hjelp av programmeringsspråket Python. Denne øvelsen vil gi deg en solid forståelse av spillogikk og kodeorganisering.
Spill er en populær form for underholdning, og vi finner dem i en rekke formater, fra nettleserspill til mobilapper og dataspill. I denne artikkelen fokuserer vi på å utvikle et tekstbasert (CLI) Tic Tac Toe-spill ved hjelp av Python.
Hvis du ikke er kjent med spillet Tic Tac Toe, kan du se en visuell demonstrasjon her for å forstå spillmekanikken. Men ikke bekymre deg, vi skal forklare det hele grundig.
En Innføring i Tre på Rad
Denne veiledningen er delt inn i tre hovedseksjoner. Først skal vi se på hvordan man spiller Tic Tac Toe. Deretter skal vi utforske en algoritme som hjelper oss med å lage spilllogikken. Til slutt går vi gjennom den strukturerte koden og gir detaljerte forklaringer.
Du kan hoppe over den første seksjonen hvis du allerede er kjent med spillet.
La oss komme i gang med den første delen.
Slik spiller du Tic Tac Toe
I Tic Tac Toe er det to spillere som deltar. Hver spiller representeres av et symbol, vanligvis X og O. Spillet foregår på et brett med 9 ruter.
Tenk deg et Tic Tac Toe-brett slik:
Visuelt: Tic Tac Toe-brett
Spillet fungerer som følger:
- Spiller 1 plasserer sitt symbol i en av de ledige rutene.
- Deretter plasserer spiller 2 sitt symbol i en annen ledig rute.
- Målet er å plassere sine symboler på en sammenhengende linje horisontalt, vertikalt eller diagonalt.
- Spillet fortsetter til en av spillerne har en vinnende kombinasjon, eller brettet er fullt uten vinner, noe som resulterer i uavgjort.
La oss se på et par eksempler:
Her vinner spiller X, da symbolene deres er plassert i en diagonal linje. Dette viser hvordan en spiller kan vinne ved å fylle en av de 8 mønstrene.
Det finnes totalt 8 måter å vinne spillet på, la oss se disse vinnerkombinasjonene.
I et tilfelle uten vinner, fylles alle rutene uten at noen av spillerne har oppnådd en vinnende kombinasjon. Nå skal du ha en god forståelse av hvordan Tic Tac Toe spilles.
Hvis du trenger å øve litt mer, kan du spille her. La oss nå gå videre til algoritmedelen.
Algoritmen Bak Spillet
Vi skal nå diskutere algoritmen for å kode spillet. Denne algoritmen vil fungere som et rammeverk uavhengig av hvilket programmeringsspråk du bruker. La oss se hvordan den fungerer:
- Opprett et brett ved hjelp av en 2-dimensjonal matrise. Initialiser alle elementene som tomme.
- Vi bruker symbolet «-« for å representere en tom rute, men du kan bruke et annet symbol om du ønsker.
- Lag en funksjon som sjekker om brettet er fylt.
- Iterer gjennom brettet. Hvis noen ruter er tomme (inneholder «-«), returneres `false`. Ellers returneres `true`.
- Skriv en funksjon som sjekker om en spiller har vunnet.
- Her må vi sjekke alle vinnermulighetene (horisontale, vertikale og diagonale linjer) som vi har beskrevet tidligere.
- Sjekk alle rader, kolonner og begge diagonaler for en vinnende kombinasjon.
- Lag en funksjon for å vise brettet til brukeren. Dette vil vi bruke flere ganger under spillet.
- Skriv en funksjon for å starte spillet.
- Velg en tilfeldig spiller som skal begynne.
- Start en uendelig løkke som avsluttes når spillet er over (seier eller uavgjort).
- Vis brettet for å gi spilleren informasjon om tilgjengelige ruter.
- Be spilleren om å angi rad- og kolonnenummer for det neste trekket.
- Oppdater ruten med spillerens symbol.
- Sjekk om spilleren har vunnet.
- Hvis spilleren vant, skriv ut en vinnermelding og avbryt løkken.
- Sjekk om brettet er fullt.
- Hvis brettet er fullt, skriv ut melding om uavgjort og avbryt løkken.
- Vis det endelige resultatet av spillet.
Nå bør du ha en bedre forståelse av hvordan spillet vil fungere. Ikke bekymre deg om du ikke helt forstår alt ennå. Det vil bli klarere når vi ser koden.
La oss se på koden. Antar du har Python installert på din PC.
Kodeimplementasjon i Python
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):
n = len(self.board)
# Sjekk rader
for i in range(n):
if all(self.board[i][j] == player for j in range(n)):
return True
# Sjekk kolonner
for i in range(n):
if all(self.board[j][i] == player for j in range(n)):
return True
# Sjekk diagonaler
if all(self.board[i][i] == player for i in range(n)):
return True
if all(self.board[i][n - 1 - i] == player for i in range(n)):
return True
return False
def is_board_filled(self):
return all(item != '-' for row in self.board for item in row)
def swap_player_turn(self, player):
return 'X' if player == 'O' else 'O'
def show_board(self):
for row in self.board:
print(' '.join(row))
def start(self):
self.create_board()
player = "X" if self.get_random_first_player() == 1 else 'O'
while True:
print(f"Spiller {player} sin tur")
self.show_board()
try:
row, col = map(int, input("Oppgi rad og kolonne for å plassere symbol (f.eks 1 1): ").split())
if 1 <= row <= 3 and 1 <= col <= 3:
self.fix_spot(row - 1, col - 1, player)
else:
print("Ugyldig input. Rad- og kolonnenummer må være mellom 1 og 3.")
continue
except ValueError:
print("Ugyldig input. Oppgi to tall atskilt med mellomrom.")
continue
if self.is_player_win(player):
print(f"Spiller {player} vant!")
break
if self.is_board_filled():
print("Uavgjort!")
break
player = self.swap_player_turn(player)
print("\nEndelig resultat:")
self.show_board()
# Starter spillet
tic_tac_toe = TicTacToe()
tic_tac_toe.start()
Her er et eksempel på hvordan spillet kan se ut i konsollen:
$ python tic_tac_toe.py Spiller X sin tur - - - - - - - - - Oppgi rad og kolonne for å plassere symbol (f.eks 1 1): 1 1 Spiller O sin tur X - - - - - - - - Oppgi rad og kolonne for å plassere symbol (f.eks 1 1): 2 1 Spiller X sin tur X - - O - - - - - Oppgi rad og kolonne for å plassere symbol (f.eks 1 1): 1 2 Spiller O sin tur X X - O - - - - - Oppgi rad og kolonne for å plassere symbol (f.eks 1 1): 1 3 Spiller X sin tur X X O O - - - - - Oppgi rad og kolonne for å plassere symbol (f.eks 1 1): 2 2 Spiller O sin tur X X O O X - - - - Oppgi rad og kolonne for å plassere symbol (f.eks 1 1): 3 3 Spiller X sin tur X X O O X - - - O Oppgi rad og kolonne for å plassere symbol (f.eks 1 1): 3 2 Spiller X vant! Endelig resultat: X X O O X - - X O
Her er noen viktige punkter som hjelper deg å forstå hvordan koden er strukturert:
- Vi har organisert all kode i en klasse, noe som gjør koden mer strukturert og gjenbrukbar.
- Hver funksjon har en spesifikk oppgave, noe som gjør koden lett å forstå og vedlikeholde.
- Denne strukturen gjør det enkelt å utvide spillet med flere funksjoner i fremtiden.
Du kan gjerne tilpasse denne koden etter behov. Måten du strukturerer koden er ikke begrenset, men det er viktig å ha en oversiktlig og lettforståelig kodebase.
Oppsummering
Gratulerer! Du har laget et enkelt spill fra bunnen av. Selv om dette ikke er et grafisk avansert spill, gir det deg en solid forståelse av spillogikk og strukturert programmering. Prøv å lage andre spill med lignende fremgangsmåter. Du kan finne inspirasjon fra enkle spill fra barndommen.
Lykke til med kodingen! 👩💻
Neste steg kan være å utforske mer avanserte spillkonsepter eller lære om enhetstesting i Python.
Hva synes du om artikkelen? Del den gjerne med andre som kan være interessert!