Erstellen Sie ein 2048-Spiel mit Python Tkinter

Einführung

In diesem Projekt lernst du, wie du mithilfe von Python und der Tkinter-Bibliothek für die grafische Benutzeroberfläche ein einfaches 2048-Spiel erstellen kannst. 2048 ist ein beliebtes Schiebepuzzlespiel, bei dem du Kacheln zusammenfügst, um die Kachel mit dem Wert 2048 zu erreichen. Obwohl dieses Projekt keine modernste und schönste Benutzeroberfläche erstellen wird, bietet es eine solide Grundlage, auf der du aufbauen kannst, um die Ästhetik zu verbessern.

👀 Vorschau

🎯 Aufgaben

In diesem Projekt wirst du lernen:

• Wie man die notwendigen Bibliotheken für das Spiel importiert
• Wie man die Game2048-Klasse erstellt, um die Spiel Logik und die Benutzeroberfläche zu verwalten
• Wie man das Spielfeld mit Tkinter zeichnet
• Wie man die Anfangskacheln auf dem Spielfeld platziert
• Wie man die Benutzeroberfläche aktualisiert, um den aktuellen Zustand des Spielfelds widerzuspiegeln
• Wie man die Kachelfarben basierend auf ihren Werten definiert
• Wie man Tastendrücke verarbeitet, um die Kacheln zu bewegen
• Wie man Methoden definiert, um Kacheln in verschiedene Richtungen zu bewegen
• Wie man prüft, ob das Spiel vorbei ist

🏆 Errungenschaften

Nach Abschluss dieses Projekts kannst du:

• Die Tkinter-Bibliothek nutzen, um eine grafische Benutzeroberfläche zu erstellen
• Tastendrücke verarbeiten und entsprechende Aktionen auslösen
• Die Benutzeroberfläche basierend auf dem Spielzustand aktualisieren
• Spiel Logik für Kachelbewegungen und -zusammenführungen implementieren
• Prüfen, ob ein Spiel vorbei ist

Erstellen der Projekt Dateien

Zuerst erstelle eine neue Datei mit dem Namen 2048_game.py und öffne sie in deinem bevorzugten Code-Editor.

cd ~/project
touch 2048_game.py

Importieren der notwendigen Bibliotheken

Damit dein Spiel funktioniert, musst du die erforderlichen Bibliotheken importieren. In der Datei 2048_game.py füge die Python-Bibliothek random und Tkinter für die Erstellung der grafischen Benutzeroberfläche ein.

import random
import tkinter as tk

Diese Bibliotheken werden verwendet, um die Funktionalität des Spiels und die Benutzeroberfläche zu erstellen.

Erstellen der Game2048-Klasse

Definiere die Game2048-Klasse in deiner 2048_game.py-Datei. Diese Klasse wird die Spiel Logik und die Benutzeroberfläche verwalten.

class Game2048:
    def __init__(self, root):
        self.root = root
        self.root.title("2048 Game")
        self.root.geometry("400x400")

        ## Initialize the game grid and score
        self.grid = [[0 for _ in range(4)] for _ in range(4)]
        self.score = 0

        ## Create an empty list to store tile labels
        self.tiles = []

Hier erstellst du einen Klassenkonstruktor, der das Hauptfenster des Spiels initialisiert, seinen Titel und seine Größe festlegt, das Spielfeld initialisiert und eine Liste erstellt, um die Spielkacheln zu speichern.

Zeichnen des Spielfelds

Füge in der Game2048-Klasse eine Methode hinzu, um das Spielfeld mit Tkinter zu zeichnen. Diese Methode erstellt das anfängliche Benutzeroberflächen-Gitter.

    def draw_grid(self):
        for i in range(4):
            row = []
            for j in range(4):
                cell = tk.Label(self.root, text="", font=("Helvetica", 24), width=5, height=2, borderwidth=4, relief="ridge")
                cell.grid(row=i, column=j, padx=5, pady=5)
                row.append(cell)
            self.tiles.append(row)

Diese Methode erstellt ein 4x4-Gitter aus Labels, die die Spielkacheln anzeigen werden.

Platzieren der Anfangskacheln

Jetzt musst du eine Methode implementieren, die die Anfangskacheln platziert, wenn das Spiel startet. Diese Methode wird eine oder zwei Kacheln mit dem Wert 2 oder 4 auf dem Spielfeld platzieren.

    def spawn_tile(self):
        empty_cells = [(i, j) for i in range(4) for j in range(4) if self.grid[i][j] == 0]
        if empty_cells:
            i, j = random.choice(empty_cells)
            self.grid[i][j] = 2 if random.random() < 0.9 else 4
            self.update_tiles()

Diese Methode sucht nach leeren Zellen auf dem Spielfeld und platziert zufällig eine neue Kachel in einer dieser Zellen.

Aktualisieren der Benutzeroberfläche

Erstelle eine Methode, um die Benutzeroberfläche so zu aktualisieren, dass der aktuelle Zustand des Spielfelds widergespiegelt wird.

    def update_tiles(self):
        for i in range(4):
            for j in range(4):
                tile_value = self.grid[i][j]
                self.tiles[i][j]["text"] = str(tile_value) if tile_value > 0 else ""
                self.tiles[i][j]["background"] = self.get_tile_color(tile_value)

Diese Methode durchläuft das Spielfeld und aktualisiert die Labels in der grafischen Benutzeroberfläche, damit sie dem Zustand des Spielfelds entsprechen.

Definieren der Kachelfarben

Erstelle eine Methode, um den Kacheln basierend auf ihren Werten Hintergrundfarben zuzuweisen.

    def get_tile_color(self, value):
        colors = {
            0: "#CDC1B4",
            2: "#EEE4DA",
            4: "#EDE0C8",
            8: "#F2B179",
            16: "#F59563",
            32: "#F67C5F",
            64: "#F65E3B",
            128: "#EDCF72",
            256: "#EDCC61",
            512: "#EDC850",
            1024: "#EDC53F",
            2048: "#EDC22E"
        }
        return colors.get(value, "#FF0000")

Diese Methode gibt einen Farbcode basierend auf dem Wert der Kachel zurück.

Verarbeiten von Tastendrücken

Implementiere eine Methode, um Tastendrücke zu verarbeiten. In diesem Schritt fängst du die Drücke auf die Pfeiltasten ab und reagierst entsprechend.

    def key_pressed(self, event):
        if self.is_game_over():
            return

        if event.keysym == "Up":
            self.move("up")
        elif event.keysym == "Down":
            self.move("down")
        elif event.keysym == "Left":
            self.move("left")
        elif event.keysym == "Right":
            self.move("right")

        self.spawn_tile()
        self.update_tiles()

Diese Methode lauscht auf Drücke der Pfeiltasten und löst die entsprechende Bewegungsfunktion aus.

Bewegen von Kacheln

Implementiere Methoden, um Kacheln in die gewünschte Richtung zu bewegen: nach oben, unten, links oder rechts.

    def move(self, direction):
        if direction == "up":
            self.grid = list(map(list, zip(*self.grid)))
            self.move_left()
            self.grid = list(map(list, zip(*self.grid)))
        elif direction == "down":
            self.grid = list(map(list, zip(*self.grid)))
            self.move_right()
            self.grid = list(map(list, zip(*self.grid)))
        elif direction == "left":
            self.move_left()
        elif direction == "right":
            self.move_right()

Diese Methode bereitet das Spielfeld für die Bewegung vor, ruft die entsprechende Bewegungsfunktion auf und setzt dann das Spielfeld zurück.

Kacheln nach links bewegen

Definiere eine Methode, um Kacheln innerhalb einer Zeile nach links zu bewegen.

    def move_left(self):
        for i in range(4):
            row = self.grid[i]
            row = [value for value in row if value!= 0]
            while len(row) < 4:
                row.append(0)

            for j in range(3):
                if row[j] == row[j + 1] and row[j]!= 0:
                    row[j] *= 2
                    row[j + 1] = 0
                    self.score += row[j]

            row = [value for value in row if value!= 0]
            while len(row) < 4:
                row.append(0)
            self.grid[i] = row

Diese Methode verarbeitet die Bewegung der Kacheln nach links, verschmilzt benachbarte Kacheln, wenn möglich, und füllt leere Zellen auf.

Kacheln nach rechts bewegen

Definiere eine Methode, um Kacheln innerhalb einer Zeile nach rechts zu bewegen.

    def move_right(self):
        for i in range(4):
            row = self.grid[i]
            row = [value for value in row if value!= 0]
            while len(row) < 4:
                row.insert(0, 0)

            for j in range(3, 0, -1):
                if row[j] == row[j - 1] and row[j]!= 0:
                    row[j] *= 2
                    row[j - 1] = 0
                    self.score += row[j]

            row = [value for value in row if value!= 0]
            while len(row) < 4:
                row.insert(0, 0)
            self.grid[i] = row

Diese Methode ist für das Bewegen der Kacheln nach rechts, das Verschmelzen derselben bei Bedarf und das Füllen von leeren Feldern verantwortlich.

Überprüfen, ob das Spiel vorbei ist

Erstelle eine Methode, um zu überprüfen, ob das Spiel vorbei ist. Das Spiel ist vorbei, wenn keine weiteren Züge möglich sind.

    def is_game_over(self):
        for i in range(4):
            for j in range(4):
                if self.grid[i][j] == 0:
                    return False

        for i in range(4):
            for j in range(3):
                if self.grid[i][j] == self.grid[i][j + 1]:
                    return False

        for j in range(4):
            for i in range(3):
                if self.grid[i][j] == self.grid[i + 1][j]:
                    return False

        return True

Diese Methode überprüft, ob weitere Züge möglich sind, indem sie prüft, ob das Spielfeld (grid) leere Zellen oder benachbarte Zellen mit gleichem Wert enthält. Wenn keine weiteren Züge möglich sind, ist das Spiel vorbei.

Projekt ausführen

Schalte schließlich auf den Desktop und führe das Projekt mit dem folgenden Befehl aus:

python 2048_game.py

Zusammenfassung

In diesem Projekt haben Sie gelernt, wie man mit der Tkinter-Bibliothek ein einfaches 2048-Spiel in Python erstellt. Sie haben begonnen, indem Sie das Projekt eingerichtet, die Haupt-Python-Datei erstellt und die Game2048-Klasse definiert haben. Anschließend haben Sie die Verarbeitung von Tastendrücken, die Bewegung der Kacheln implementiert und die Bedingungen für das Spielende überprüft. Die Spieloberfläche mag nicht die modernste und schönste sein, aber Sie haben jetzt eine Grundlage, die Sie erweitern und anpassen können, um ein aufgeräumteres 2048-Spiel zu erstellen. Um das Projekt auszuführen, können Sie die folgenden Schritte befolgen.