Erstellen eines Tic-Tac-Toe-Spiels mit Pygame

PythonPythonBeginner
Jetzt üben

💡 Dieser Artikel wurde von AI-Assistenten übersetzt. Um die englische Version anzuzeigen, können Sie hier klicken

Einführung

Dieses Projekt führt Sie durch die Schritte, um ein Tic-Tac-Toe-Spiel mit Pygame zu erstellen. Tic-Tac-Toe ist ein Zwei-Spieler-Spiel, bei dem das Ziel darin besteht, drei Ihrer Symbole in einer Reihe zu bekommen, entweder horizontal, vertikal oder diagonal. In diesem Projekt lernen Sie, wie Sie das Spielfenster einrichten, das Spielfeld zeichnen, die Züge von Spielern und der KI handhaben und den Gewinner bestimmen. Am Ende dieses Projekts werden Sie ein voll funktionsfähiges Tic-Tac-Toe-Spiel haben, gegen einen KI-Gegner spielen können.

👀 Vorschau

Tic-Tac-Toe Using Pygame

🎯 Aufgaben

In diesem Projekt lernen Sie:

  • Wie Sie die Projekt-Dateien erstellen und die erforderlichen Bibliotheken importieren
  • Wie Sie PyGame initialisieren und das Spielfenster einrichten
  • Wie Sie die Symbole, Farben und den Spielzustand definieren
  • Wie Sie die Button-Eigenschaften definieren und Hilfsfunktionen erstellen
  • Wie Sie die Hauptspielschleife erstellen und die Hilfsfunktionen implementieren
  • Wie Sie den verbleibenden Code in der Hauptspielschleife einfügen

🏆 Errungenschaften

Nach Abschluss dieses Projekts werden Sie in der Lage sein:

  • Pygame verwenden, um ein grafisches Spiel zu erstellen
  • Grafiken auf einem Fenster mit Pygame zeichnen
  • Benutzer-Eingaben verarbeiten und den Spielzustand aktualisieren
  • Spiellogik implementieren, wie das Überprüfen auf einen Gewinn-Zustand
  • Eine Spielschleife erstellen, um das Spiel in Betrieb zu halten

Erstellen Sie die Projekt-Dateien

Beginnen Sie mit dem Erstellen einer neuen Datei namens tic_tac_toe.py. Öffnen Sie die Datei in Ihrem bevorzugten Texteditor.

cd ~/project
touch tic_tac_toe.py
✨ Lösung prüfen und üben

Importieren Sie die erforderlichen Bibliotheken

In tic_tac_toe.py importieren Sie die erforderlichen Bibliotheken: pygame und random. Diese Bibliotheken werden jeweils zur Handhabung der Spielgrafiken und zum Generieren von zufälligen Zügen der KI verwendet.

import pygame
import random

Installieren Sie die pygame-Bibliothek mit dem folgenden Befehl:

sudo pip install pygame
✨ Lösung prüfen und üben

Initialisieren Sie PyGame und richten Sie das Spielfenster ein

In tic_tac_toe.py initialisieren Sie PyGame mit pygame.init(). Anschließend richten Sie das Spielfenster ein, indem Sie die Fensterbreite und -höhe, die Hintergrundfarbe, die Linienfarbe und die Zellgröße definieren. Erstellen Sie auch ein PyGame-Fenster mit der angegebenen Breite und Höhe und legen Sie die Fensterüberschrift fest.

pygame.init()

WIDTH = 600
HEIGHT = 600
BACKGROUND_COLOR = (40, 40, 40)
LINE_COLOR = (70, 70, 70)
CELL_SIZE = WIDTH // 3

win = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Tic-Tac-Toe")
✨ Lösung prüfen und üben

Definieren Sie die Symbole und Farben

In tic_tac_toe.py definieren Sie die Symbole und Farben für den Spieler und die KI. Diese Symbole und Farben werden verwendet, um die Züge des Spielers und der KI auf dem Spielfeld zu zeichnen.

PLAYER_SYMBOL = "X"
AI_SYMBOL = "O"
PLAYER_COLOR = (0, 255, 0)
AI_COLOR = (255, 0, 0)
EMPTY_COLOR = (0, 0, 0)
✨ Lösung prüfen und üben

Definieren Sie den Spielzustand

In tic_tac_toe.py definieren Sie den initialen Spielzustand. Dies umfasst das Spielfeld, den aktuellen Zug (entweder "spieler" oder "ki"), einen Flag, der angibt, ob das Spiel beendet ist, und den Gewinner des Spiels.

board = [["" for _ in range(3)] for _ in range(3)]
turn = "spieler"
game_over = False
winner = None
✨ Lösung prüfen und üben

Definieren Sie die Button-Eigenschaften

In tic_tac_toe.py definieren Sie die Eigenschaften für die Reset-Button, einschließlich der Button-Breite, -Höhe, -Farbe, -Textfarbe und -Schriftgröße. Erstellen Sie auch ein reset_button_rect-Objekt mithilfe der pygame.Rect-Klasse, um die Position und Größe des Buttons darzustellen.

BUTTON_WIDTH = 200
BUTTON_HEIGHT = 50
BUTTON_COLOR = (50, 50, 50)
BUTTON_TEXT_COLOR = (255, 255, 255)
BUTTON_FONT = pygame.font.Font(None, 30)

reset_button_rect = pygame.Rect(
    (WIDTH - BUTTON_WIDTH) // 2,
    (HEIGHT - BUTTON_HEIGHT) // 2,
    BUTTON_WIDTH,
    BUTTON_HEIGHT,
)
✨ Lösung prüfen und üben

Erstellen von Hilfsfunktionen

In tic_tac_toe.py definieren Sie mehrere Hilfsfunktionen, die während des gesamten Spiels verwendet werden.

  • draw_board(): Diese Funktion zeichnet das Spielfeld auf dem Fenster.

  • draw_symbols(): Diese Funktion zeichnet die Symbole des Spielers und der KI auf dem Spielfeld.

  • is_board_full(): Diese Funktion überprüft, ob das Spielfeld voll ist.

  • is_winner(): Diese Funktion überprüft, ob ein Spieler das Spiel gewonnen hat.

  • make_move(): Diese Funktion macht einen Zug auf dem Spielfeld.

  • player_move(): Diese Funktion behandelt den Zug des Spielers.

  • ai_move(): Diese Funktion behandelt den Zug der KI.

  • check_game_over(): Diese Funktion überprüft, ob das Spiel beendet ist.

  • draw_winner(): Diese Funktion zeichnet die Sieger-Nachricht auf dem Fenster.

  • draw_reset_button(): Diese Funktion zeichnet den Reset-Button auf dem Fenster.

  • reset_game(): Diese Funktion setzt den Spielzustand zurück.

## Hilfsfunktionen
def draw_board():
    ## Zeichnet das Spielfeld
    pass

def draw_symbols():
    ## Zeichnet die Symbole des Spielers und der KI auf dem Spielfeld
    pass

def is_board_full():
    ## Überprüft, ob das Spielfeld voll ist
    pass

def is_winner(symbol):
    ## Überprüft, ob ein Spieler das Spiel gewonnen hat
    pass

def make_move(x, y, symbol):
    ## Macht einen Zug auf dem Spielfeld
    pass

def player_move():
    ## Behandelt den Zug des Spielers
    pass

def ai_move():
    ## Behandelt den Zug der KI
    pass

def check_game_over():
    ## Überprüft, ob das Spiel beendet ist
    pass

def draw_winner():
    ## Zeichnet die Sieger-Nachricht auf dem Fenster
    pass

def draw_reset_button():
    ## Zeichnet den Reset-Button auf dem Fenster
    pass

def reset_game():
    ## Setzt den Spielzustand zurück
    pass
✨ Lösung prüfen und üben

Erstellen der Hauptspielschleife

In tic_tac_toe.py erstellen Sie die Hauptspielschleife mit einer while-Schleife. Diese Schleife wird so lange laufen, bis der Benutzer das Spielfenster schließt. Innerhalb der Spielschleife werden die Eingabeereignisse des Benutzers behandelt und der Spielzustand entsprechend aktualisiert.

## Hauptspielschleife
running = True
while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False
        elif event.type == pygame.MOUSEBUTTONDOWN:
            if reset_button_rect.collidepoint(event.pos):
                reset_game()
            elif not game_over and turn == "spieler":
                player_move()

    if not game_over and turn == "ki":
        ai_move()
        check_game_over()

    draw_board()
    draw_symbols()

    if game_over:
        draw_winner()
        draw_reset_button()

    pygame.display.flip()

## Beenden des Spiels
pygame.quit()
✨ Lösung prüfen und üben

Implementieren Sie die Hilfsfunktionen

Lassen Sie uns nun die Hilfsfunktionen implementieren, die wir zuvor definiert haben. Beginnen Sie mit der Fertigstellung der draw_board()-Funktion. Diese Funktion zeichnet das Spielfeld auf dem Fenster, indem vertikale und horizontale Linien mithilfe der pygame.draw.line()-Funktion gezeichnet werden.

## Hilfsfunktionen
def draw_board():
    win.fill(BACKGROUND_COLOR)

    ## Zeichnen Sie vertikale Linien
    for x in range(1, 3):
        pygame.draw.line(
            win, LINE_COLOR, (CELL_SIZE * x, 0), (CELL_SIZE * x, HEIGHT), 2
        )

    ## Zeichnen Sie horizontale Linien
    for y in range(1, 3):
        pygame.draw.line(win, LINE_COLOR, (0, CELL_SIZE * y), (WIDTH, CELL_SIZE * y), 2)
✨ Lösung prüfen und üben

Implementieren Sie die verbleibenden Hilfsfunktionen

Als nächstes implementieren Sie die verbleibenden Hilfsfunktionen: draw_symbols(), is_board_full(), is_winner(), make_move(), player_move(), ai_move(), check_game_over(), draw_winner(), draw_reset_button() und reset_game().

## Hilfsfunktionen
def draw_symbols():
    for x in range(3):
        for y in range(3):
            symbol = board[x][y]
            if symbol == PLAYER_SYMBOL:
                color = PLAYER_COLOR
            elif symbol == AI_SYMBOL:
                color = AI_COLOR
            else:
                color = EMPTY_COLOR
            if symbol!= "":
                pygame.draw.circle(
                    win,
                    color,
                    (x * CELL_SIZE + CELL_SIZE // 2, y * CELL_SIZE + CELL_SIZE // 2),
                    CELL_SIZE // 2 - 10,
                    2,
                )

def is_board_full():
    for row in board:
        if "" in row:
            return False
    return True

def is_winner(symbol):
    for row in board:
        if all(cell == symbol for cell in row):
            return True
    for col in range(3):
        if all(board[row][col] == symbol for row in range(3)):
            return True
    if all(board[i][i] == symbol for i in range(3)):
        return True
    if all(board[i][2 - i] == symbol for i in range(3)):
        return True
    return False

def make_move(x, y, symbol):
    if board[x][y] == "":
        board[x][y] = symbol
        return True
    return False

def player_move():
    global turn
    mouse_pos = pygame.mouse.get_pos()
    cell_x = mouse_pos[0] // CELL_SIZE
    cell_y = mouse_pos[1] // CELL_SIZE

    if make_move(cell_x, cell_y, PLAYER_SYMBOL):
        turn = "ai"

def ai_move():
    global turn
    empty_cells = []
    for x in range(3):
        for y in range(3):
            if board[x][y] == "":
                empty_cells.append((x, y))

    if empty_cells:
        x, y = random.choice(empty_cells)
        make_move(x, y, AI_SYMBOL)

    turn = "player"

def check_game_over():
    global game_over, winner
    if is_winner(PLAYER_SYMBOL):
        game_over = True
        return "player"
    elif is_winner(AI_SYMBOL):
        game_over = True
        return "ai"
    elif is_board_full():
        game_over = True
        return "tie"
    return None

def draw_winner():
    font = pygame.font.Font(None, 50)
    if winner == "player":
        text = font.render("Spieler gewinnt!", True, PLAYER_COLOR)
    elif winner == "ai":
        text = font.render("KI gewinnt!", True, AI_COLOR)
    else:
        text = font.render("Unentschieden!", True, (255, 255, 255))
    text_rect = text.get_rect(center=(WIDTH // 2, HEIGHT // 3))
    win.blit(text, text_rect)

def draw_reset_button():
    pygame.draw.rect(win, BUTTON_COLOR, reset_button_rect)
    button_text = BUTTON_FONT.render("Zurücksetzen", True, BUTTON_TEXT_COLOR)
    button_text_rect = button_text.get_rect(center=reset_button_rect.center)
    win.blit(button_text, button_text_rect)

def reset_game():
    global board, turn, game_over, winner
    board = [["" for _ in range(3)] for _ in range(3)]
    turn = "player"
    game_over = False
    winner = None

In obigem Code zeichnet die draw_symbols()-Funktion die Symbole auf dem Brett. Die is_board_full()-Funktion überprüft, ob das Brett voll ist. Die is_winner()-Funktion überprüft, ob das gegebene Symbol das Spiel gewonnen hat. Die make_move()-Funktion macht einen Zug auf dem Brett. Die player_move()-Funktion behandelt den Zug des Spielers. Die ai_move()-Funktion behandelt den Zug der KI. Die check_game_over()-Funktion überprüft, ob das Spiel beendet ist. Die draw_winner()-Funktion zeichnet die Sieger-Nachricht. Die draw_reset_button()-Funktion zeichnet den Reset-Button. Die reset_game()-Funktion setzt das Spiel zurück.

✨ Lösung prüfen und üben

Füllen Sie den verbleibenden Code aus

Schließlich füllen Sie den verbleibenden Code innerhalb der Hauptspielschleife aus, um die Hilfsfunktionen an den entsprechenden Stellen aufzurufen. Dies umfasst das Aufrufen der draw_board()- und draw_symbols()-Funktionen, um das Spielfeld und die Symbole zu zeichnen, das Aufrufen der check_game_over()-Funktion, um zu überprüfen, ob das Spiel beendet ist, und das Aufrufen der draw_winner()- und draw_reset_button()-Funktionen, um die Sieger-Nachricht und den Reset-Button respective zu zeichnen.

## Hauptspielschleife
running = True
while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False
        elif event.type == pygame.MOUSEBUTTONDOWN:
            if reset_button_rect.collidepoint(event.pos):
                reset_game()
            elif not game_over and turn == "spieler":
                player_move()

    if not game_over and turn == "ki":
        ai_move()
        winner = check_game_over()

    draw_board()
    draw_symbols()

    if game_over:
        draw_winner()
        draw_reset_button()

    pygame.display.flip()

## Beenden des Spiels
pygame.quit()

Führen Sie das Spiel mit dem folgenden Befehl aus:

python tic_tac_toe.py
tic tac toe game screenshot
✨ Lösung prüfen und üben

Zusammenfassung

Herzlichen Glückwunsch! Sie haben erfolgreich ein Tic-Tac-Toe-Spiel mit Pygame erstellt. In diesem Projekt haben Sie gelernt, wie Sie das Spielfenster einrichten, das Spielfeld zeichnen, die Züge von Spielern und KI handhaben und den Gewinner bestimmen. Sie haben auch gelernt, wie Sie Hilfsfunktionen implementieren, um den Code zu vereinfachen und modularer zu gestalten.