Lass uns gemeinsam ein simples Tic-Tac-Toe-Spiel mit Python programmieren. Dies wird dir helfen, die Grundlagen der Spielmechanik zu verstehen und zu lernen, wie man Code sinnvoll strukturiert.
Videospiele sind eine beliebte Form der Unterhaltung. Wir finden unzählige Spiele online, auf Mobilgeräten und Computern. Unser Ziel ist es heute nicht, ein hochkomplexes Spiel zu entwickeln. Stattdessen erschaffen wir ein textbasiertes Tic-Tac-Toe-Spiel mit Python.
Solltest du mit Tic-Tac-Toe nicht vertraut sein, kannst du dich hier visuell damit auseinandersetzen. Aber keine Sorge, wir werden es auch so verstehen.
Tic-Tac-Toe
Dieses Tutorial ist in drei Abschnitte unterteilt. Im ersten Teil erklären wir die Spielregeln von Tic-Tac-Toe. Danach betrachten wir einen Algorithmus, der uns bei der Entwicklung der Spiellogik unterstützt. Abschließend untersuchen wir den strukturierten Code und dessen Erläuterung.
Du kannst den ersten Abschnitt überspringen, falls du die Regeln von Tic-Tac-Toe bereits kennst.
Beginnen wir nun ohne Umschweife mit dem ersten Abschnitt.
Spielregeln von Tic-Tac-Toe
Es spielen zwei Personen gegeneinander. Jeder Spieler wird durch ein eigenes Symbol repräsentiert. Üblicherweise werden die Zeichen X und O verwendet. Das Spielfeld besteht aus einem 3×3 Raster mit 9 Feldern.
Hier ist eine visuelle Darstellung des Tic-Tac-Toe-Feldes:
Tic Tac Toe-Spielfeld
Der Spielablauf ist wie folgt:
- Zuerst setzt ein Spieler sein Symbol in eines der freien Felder.
- Danach setzt der zweite Spieler sein Symbol in ein anderes freies Feld.
- Das Ziel der Spieler ist es, ihre eigenen Symbole entweder horizontal, vertikal oder diagonal in einer Linie anzuordnen.
- Das Spiel geht solange weiter, bis ein Spieler gewinnt oder ein Unentschieden erreicht wird, wenn alle Felder ohne Gewinner belegt sind.
Lass uns ein paar Spielsituationen visuell betrachten.
Tic Tac Toe-Gewinnsituation
Im obigen Beispiel gewinnt Spieler X. Alle Felder sind diagonal mit X-Symbolen belegt. Somit hat dieser Spieler das Spiel gewonnen.
Es gibt insgesamt acht Möglichkeiten, das gleiche Symbol in einer Reihe zu platzieren und so das Spiel zu gewinnen. Wir schauen uns alle acht Gewinnmöglichkeiten an.
Ein Unentschieden entsteht, wenn das Spielfeld vollständig gefüllt ist, ohne dass eine Gewinnkonstellation eintritt. Ich hoffe, du hast jetzt ein Verständnis für die Spielregeln von Tic-Tac-Toe.
Nun ist es Zeit für dich zu spielen. Du kannst hier das Spiel ausprobieren, um das Gameplay besser zu verstehen. Wenn du bereits damit vertraut bist, können wir fortfahren.
Jetzt ist es Zeit, uns dem Algorithmusabschnitt zu widmen.
Algorithmus
Wir werden nun den Algorithmus zum Programmieren des Spiels besprechen. Dieser Algorithmus hilft dir, den Code in jeder gewünschten Programmiersprache zu schreiben. Schauen wir uns an, wie das funktioniert.
- Erstelle ein Spielfeld mit einem zweidimensionalen Array und initialisiere jedes Element als leer.
- Du kannst ein beliebiges Symbol für leer verwenden. Wir verwenden hier einen Bindestrich ‚-‚.
- Erstelle eine Funktion, die überprüft, ob das Spielfeld gefüllt ist oder nicht.
- Gehe durch das Spielfeld und gib false zurück, wenn ein freies Feld vorhanden ist, ansonsten gib true zurück.
- Schreibe eine Funktion, die überprüft, ob ein Spieler gewonnen hat oder nicht.
- Wir müssen alle Gewinnmöglichkeiten, die wir im vorherigen Abschnitt besprochen haben, prüfen.
- Überprüfe alle Zeilen, Spalten und die beiden Diagonalen.
- Erstelle eine Funktion, um das Spielfeld anzuzeigen, da wir das Feld den Spielern mehrmals während des Spiels zeigen.
- Schreibe eine Funktion, um das Spiel zu starten.
- Wähle zufällig aus, welcher Spieler den ersten Zug macht.
- Erstelle eine Endlosschleife, die beendet wird, wenn das Spiel vorbei ist (entweder Sieg oder Unentschieden).
- Zeige dem Spieler das Spielfeld, damit er den Platz für seinen nächsten Zug auswählen kann.
- Fordere den Spieler auf, die Zeilen- und Spaltennummer anzugeben.
- Aktualisiere das Feld mit dem Symbol des entsprechenden Spielers.
- Überprüfe, ob der aktuelle Spieler das Spiel gewonnen hat.
- Wenn der aktuelle Spieler gewonnen hat, gib eine Gewinnmeldung aus und beende die Endlosschleife.
- Überprüfe dann, ob das Spielfeld voll ist.
- Wenn das Feld voll ist, gib eine Unentschiedenmeldung aus und beende die Endlosschleife.
- Zeige dem Spieler am Ende das finale Spielfeld.
Vielleicht hast du jetzt eine Vorstellung, was geschieht. Mach dir keine Sorgen, wenn du es noch nicht ganz verstanden hast. Es wird klarer, wenn du den Code siehst.
Springen wir also zum Codeabschnitt. Ich gehe davon aus, dass du Python auf deinem Computer installiert hast, um den Code auszuprobieren.
Code
Hier ist der Programmcode:
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"Spieler {player} ist an der Reihe")
self.show_board()
# taking user input
row, col = list(
map(int, input("Gib Zeilen- und Spaltennummer ein: ").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"Spieler {player} hat das Spiel gewonnen!")
break
# checking whether the game is draw or not
if self.is_board_filled():
print("Unentschieden!")
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()
Hier ist eine Beispielausgabe des Codes:
$ python tic_tac_toe.py Spieler X ist an der Reihe - - - - - - - - - Gib Zeilen- und Spaltennummer ein: 1 1 Spieler O ist an der Reihe X - - - - - - - - Gib Zeilen- und Spaltennummer ein: 2 1 Spieler X ist an der Reihe X - - O - - - - - Gib Zeilen- und Spaltennummer ein: 1 2 Spieler O ist an der Reihe X X - O - - - - - Gib Zeilen- und Spaltennummer ein: 1 3 Spieler X ist an der Reihe X X O O - - - - - Gib Zeilen- und Spaltennummer ein: 2 2 Spieler O ist an der Reihe X X O O X - - - - Gib Zeilen- und Spaltennummer ein: 3 3 Spieler X ist an der Reihe X X O O X - - - O Gib Zeilen- und Spaltennummer ein: 3 2 Spieler X hat das Spiel gewonnen! X X O O X - - X O
Hier sind einige wichtige Punkte, die dir helfen, die Struktur des Codes zu verstehen:
- Wir haben eine Klasse verwendet, um alle Methoden an einem Ort zu sammeln. So kann es einfach in anderen Codes wiederverwendet werden.
- Wir haben für jede Funktion eine spezifische Verantwortlichkeit definiert, selbst wenn es sich um eine kleine Aufgabe handelt. Dies hilft, den Code einfacher zu pflegen.
- Diese beiden oben genannten Ansätze helfen uns, die Anwendung problemlos zu erweitern, wenn wir das Spiel verbessern möchten.
Du kannst die Struktur des Codes nach Belieben anpassen und basierend auf deinem Projekt optimieren. Es gibt keine Einschränkungen bei der Strukturierung des Codes.
Fazit
Gratulation! 😎 Du hast ein Spiel von Grund auf neu programmiert. Es ist zwar kein visuell anspruchsvolles Spiel, aber es hilft dir, Logik zu entwickeln und eine klare Struktur im Code beizubehalten. Verwende ähnliche Richtlinien, um weitere interessante Spiele wie dieses zu entwickeln. Du kannst ähnliche Spiele finden, wenn du etwas in deine Kindheit zurückgehst.
Viel Spaß beim Programmieren! 👩💻
Als Nächstes kannst du dich damit beschäftigen, wie man ein Zahlenratespiel erstellt und mit dem Python-Unittest-Modul Unit-Tests durchführt.
Hat dir der Artikel gefallen? Dann teile ihn doch mit der Welt!