So erstellen Sie das Memory Tile-Spiel mit Python

Das Gedächtnisplättchen oder das Zuordnungsspiel ist eine hervorragende und unterhaltsame Möglichkeit, die kognitiven Fähigkeiten zu steigern, das Gedächtnis zu verbessern und die Konzentration zu verbessern. Das Spiel besteht aus einer Reihe von Spielsteinen, die Sie einzeln umdrehen, auswendig lernen und die passenden auswählen müssen. Wenn Sie alle Spielsteine ​​richtig zusammenlegen, gewinnen Sie das Spiel.

Wie können Sie dieses erstaunliche Spiel mit Python entwickeln?

Die Tkinter- und Random-Module

Sie können das Memory-Kachelspiel mit den Modulen Tkinter und Random erstellen. Mit Tkinter können Sie Desktop-Anwendungen erstellen. Es bietet eine Vielzahl von Widgets wie Schaltflächen, Beschriftungen und Textfelder, die es einfacher machen Anwendungen wie Kalender entwickeln, Taschenrechner und To-Do-Listen. Um Tkinter zu installieren, öffnen Sie das Terminal und führen Sie Folgendes aus:

pip install tkinter

Das Random-Modul ist ein integriertes Python-Modul, das zum Generieren von Pseudozufallszahlen verwendet wird. Mit dieser, Sie können einen Zufallspasswortgenerator erstellen, eine Würfelwurf-Simulationsanwendung oder ein Listen-Shuffler. Darüber hinaus können Sie auch Entwickeln Sie interessante Spiele wie Hand Cricket und Zahlen-Ratespiele.

So erstellen Sie das Memory Tile-Spiel mit Python

Den Quellcode zum Erstellen des Memory-Kachel-Spiels mit Python finden Sie hier GitHub-Repository.

Beginnen Sie mit dem Importieren des Tkinter- und des Random-Moduls. Initialisieren Sie das Stammfenster und legen Sie den Titel und die Abmessungen in Pixel fest.

aus tkinter importieren *
importieren willkürlich
aus tkinter importieren Nachrichtenbox
root = Tk()
root.title(„Memory Tile Game“)
root.geometry(„760x550“)

Definieren Sie zwei globale Variablen und initialisieren Sie die Gewinnervariable auf Null. Deklarieren Sie eine Liste von Elementen, die auf den Kacheln angezeigt werden. Ordnen Sie die Liste mithilfe der Zufallsmodule neu Mischen() Methode. Definieren Sie einen Rahmen im Stammfenster und fügen Sie einen Abstand von 10 in vertikaler Richtung hinzu.

Initialisieren Sie eine Zählvariable auf 0 und deklarieren Sie eine Antwortliste bzw. ein Wörterbuch.

global Gewinner, Spiele
Gewinner = 0
Übereinstimmungen = ["Apfel","Apfel","Banane","Banane", "orange","orange", "Blaubeere","Blaubeere","Maulbeere","Maulbeere", "Trauben","Trauben"]
random.shuffle (Übereinstimmungen)
my_frame = Frame (root)
my_frame.pack (pady=10)
zählen = 0
Antwortliste = []
answer_dict = {}

Definieren Sie eine Funktion, zurücksetzen(). Setzen Sie den Text des Etiketts mithilfe von auf eine leere Zeichenfolge config() Funktion. Definieren Sie eine Schaltflächenliste, eine für jede Kachel. Durchlaufen Sie die Liste und setzen Sie den Text auf der Schaltflächenkachel auf eine leere Zeichenfolge und die Hintergrundfarbe auf die Standardeinstellung (SystemButtonFace) und der Zustand auf Normal.

defzurücksetzen():
 my_label.config (text="")
 button_list = [b0,b1,b2,b3,b4,b5,b6,b7,b8,b9,b10,b11]
für Taste In button_list:
 button.config (text=" ", bg=„SystemButtonFace“, Zustand="normal")

Definieren Sie eine Funktion, gewinnen(). Legen Sie im Textparameter des Etiketts eine erfolgreiche Botschaft fest, indem Sie die verwenden config() Funktion. Definieren Sie die Schaltflächenliste wie zuvor und durchlaufen Sie sie, um die Hintergrundfarbe der Kachel auf Hellgrün festzulegen.

defgewinnen():
 my_label.config (text="Glückwunsch! Du gewinnst!")
 button_list = [b0,b1,b2,b3,b4,b5,b6,b7,b8,b9,b10,b11]
für Taste In button_list:
 button.config (bg=„#90EE90“)

Definieren Sie eine Funktion, button_click() das die Schaltfläche und ihre Nummer als Eingabeparameter verwendet. Referenzieren Sie die globalen Variablen, die Liste und das Wörterbuch. Wenn der Text der Schaltfläche einem Leerzeichen entspricht und die Anzahl kleiner als zwei ist, fügen Sie den Text der Schaltfläche ein und zeigen Sie ihn an. Hängen Sie die Schaltflächennummer an die Antwortliste und den Namen an das Antwortwörterbuch an. Erhöhen Sie die Zählvariable um eins.

defbutton_click(b, Zahl):
global Anzahl, Antwortliste, Antwortdikt, Gewinner
Wenn B["Text"] == ' 'Und zählen < 2:
 B["Text"] = Treffer[Anzahl]
 answer_list.append (Nummer)
 answer_dict[b] = entspricht[Anzahl]
 zählen += 1

Wenn die Länge der Antwortliste zwei beträgt, bedeutet dies, dass der Benutzer zwei Kacheln ausgewählt hat. Wenn der Text der ersten Kachel mit dem anderen übereinstimmt, konfigurieren Sie die Beschriftung so, dass angezeigt wird, dass beide korrekt übereinstimmen. Schalten Sie den Status der Schaltfläche auf „Deaktiviert“ um. Setzen Sie die Anzahl auf Null und leeren Sie die Liste und das Wörterbuch. Erhöhen Sie die Gewinnervariable um eins, und wenn sie sechs wird, rufen Sie die zuvor deklarierte Win-Funktion auf.

Wenn len (answer_list) == 2:
Wenn Treffer[Antwortliste[0]] == entspricht[Antwortliste[1]]:
 my_label.config (text=„Es ist ein Match!“)
für Taste In Antwort_Dikt:
 Taste["Zustand"] = "Behinderte"
 zählen = 0
 Antwortliste = []
 answer_dict = {}
 Gewinner += 1
Wenn Gewinner == 6:
 gewinnen()

Andernfalls setzen Sie die Zählvariable und die Liste zurück. Zeigt ein Meldungsfeld an, dessen Titel und Inhalt darauf hinweisen, dass es sich um eine falsche Übereinstimmung handelt. Gehen Sie die Antwortliste durch und setzen Sie den Text der Kachel auf ein Leerzeichen. Setzen Sie die Beschriftung zurück und leeren Sie das Wörterbuch. Dadurch wird sichergestellt, dass kein Text auf der Schaltfläche und der Beschriftung sichtbar ist, nachdem der Benutzer falsche Kacheln ausgewählt hat.

anders:
 zählen = 0
 Antwortliste = []
 messagebox.showinfo("Falsch!", "Falsch")
für Taste In Antwort_Dikt:
 Taste["Text"] = " "
 my_label.config (text=" ")
 answer_dict = {}

Definieren Sie 12 Schaltflächen. Legen Sie das übergeordnete Fenster fest, in dem Sie sie platzieren möchten, den Text, den sie anzeigen sollen, den Schriftstil, den sie haben sollen, ihre Höhe und Breite sowie den Befehl, der beim Klicken ausgeführt werden soll. Denken Sie daran, die Lambda-Funktion zu verwenden, um die Daten an zu übergeben button_click() Funktion. Stellen Sie die ein Erleichterung Parameter zu Rille um einen 3D-Tiefeneffekt um die Schaltfläche herum zu erzeugen.

b0 = Schaltfläche (my_frame, text=' ', Schriftart=(„Helvetica“, 20), Höhe=4, Breite=8, Befehl=Lambda: button_click (b0, 0), Erleichterung="Rille")
b1 = Schaltfläche (my_frame, text=' ', Schriftart=(„Helvetica“, 20), Höhe=4, Breite=8, Befehl=Lambda: button_click (b1, 1), Erleichterung="Rille")
b2 = Schaltfläche (my_frame, text=' ', Schriftart=(„Helvetica“, 20), Höhe=4, Breite=8, Befehl=Lambda: button_click (b2, 2), Erleichterung="Rille")
b3 = Schaltfläche (my_frame, text=' ', Schriftart=(„Helvetica“, 20), Höhe=4, Breite=8, Befehl=Lambda: button_click (b3, 3), Erleichterung="Rille")
b4 = Schaltfläche (my_frame, text=' ', Schriftart=(„Helvetica“, 20), Höhe=4, Breite=8, Befehl=Lambda: button_click (b4, 4), Erleichterung="Rille")
b5 = Schaltfläche (my_frame, text=' ', Schriftart=(„Helvetica“, 20), Höhe=4, Breite=8, Befehl=Lambda: button_click (b5, 5), Erleichterung="Rille")
b6 = Schaltfläche (my_frame, text=' ', Schriftart=(„Helvetica“, 20), Höhe=4, Breite=8, Befehl=Lambda: button_click (b6, 6), Erleichterung="Rille")
b7 = Schaltfläche (my_frame, text=' ', Schriftart=(„Helvetica“, 20), Höhe=4, Breite=8, Befehl=Lambda: button_click (b7, 7), Erleichterung="Rille")
b8 = Schaltfläche (my_frame, text=' ', Schriftart=(„Helvetica“, 20), Höhe=4, Breite=8, Befehl=Lambda: button_click (b8, 8), Erleichterung="Rille")
b9 = Schaltfläche (my_frame, text=' ', Schriftart=(„Helvetica“, 20), Höhe=4, Breite=8, Befehl=Lambda: button_click (b9, 9), Erleichterung="Rille")
b10 = Schaltfläche (my_frame, text=' ', Schriftart=(„Helvetica“, 20), Höhe=4, Breite=8, Befehl=Lambda: button_click (b10, 10), Erleichterung="Rille")
b11 = Schaltfläche (my_frame, text=' ', Schriftart=(„Helvetica“, 20), Höhe=4, Breite=8, Befehl=Lambda: button_click (b11, 11), Erleichterung="Rille")

Organisieren Sie die Schaltflächen mithilfe des Rastermanagers von Tkinter in einem Tabellenformat, das aus drei Zeilen und vier Spalten besteht. Rufen Sie dazu die an Netz() -Methode und übergeben Sie die Zeile zusammen mit der Spaltennummer, in der Sie sie platzieren möchten.

b0.grid (row=0, Spalte=0)
b1.grid (row=0, Spalte=1)
b2.grid (row=0, Spalte=2)
b3.grid (row=0, Spalte=3)
b4.grid (row=1, Spalte=0)
b5.grid (row=1, Spalte=1)
b6.grid (row=1, Spalte=2)
b7.grid (row=1, Spalte=3)
b8.grid (row=2, Spalte=0)
b9.grid (row=2, Spalte=1)
b10.grid (row=2, Spalte=2)
b11.grid (row=2, Spalte=3)

Definieren Sie eine Beschriftung, die eine leere Zeichenfolge anzeigt, und fügen Sie in vertikaler Richtung einen Abstand von 20 hinzu. Definieren Sie ein Menü der obersten Ebene im Stammfenster und hängen Sie es an, indem Sie das drehen abreißen Parameter zu FALSCH. Fügen Sie einen Untermenüpunkt hinzu, Optionen Verwendung der add_cascade Parameter.

Fügen Sie zwei Menüelemente zusammen mit den Befehlen hinzu, die ausgeführt werden sollen, wenn Sie im genannten Untermenü darauf klicken Spiel zurücksetzen Und Spiel verlassen. Fügen Sie zur Abgrenzung ein Trennzeichen dazwischen ein.

my_label = Label (root, text="")
my_label.pack (pady=20)
my_menu = Menü (root)
root.config (menu=my_menu)
option_menu = Menü (my_menu, Tearoff=FALSCH)
my_menu.add_cascade (label="Optionen", menu=option_menu)
option_menu.add_command (label="Spiel zurücksetzen", Befehl=Zurücksetzen)
option_menu.add_separator()
option_menu.add_command (label="Spiel verlassen", command=root.quit)

Der Hauptschleife() Die Funktion weist Python an, die Tkinter-Ereignisschleife auszuführen und auf Ereignisse zu warten, bis Sie das Fenster schließen.

root.mainloop()

Fügen Sie den gesamten Code zusammen. Jetzt ist das Memory-Spielstein spielbereit.

Ausgabe des Memory Tile Game

Beim Ausführen des Programms werden 12 Schaltflächen mit leerem Text zusammen mit dem angezeigt Optionen Speisekarte. Beim Klicken Spiel zurücksetzen, das Fenster erscheint auf die gleiche Weise.

Wenn Sie zwei übereinstimmende Kacheln auswählen, werden die Schaltflächen deaktiviert angezeigt und die Beschriftung zeigt an, dass die Auswahl richtig ist.

Wenn Sie zwei Kacheln auswählen, die nicht übereinstimmen, wird ein Meldungsfeld angezeigt, das darauf hinweist, dass die Auswahl falsch war. Die Schaltflächen und die Beschriftung kehren in ihren ursprünglichen leeren Zustand zurück.

Wenn alle Auswahlmöglichkeiten erfolgreich getroffen wurden, färbt das Programm alle Kacheln grün und zeigt die Gewinnernachricht an.

Spiele, die Sie mit Python erstellen können

Python bietet eine Vielzahl von Modulen zum Erstellen von Spielen. Um einfache wort- oder wahlbasierte Spiele wie Hangman, Tic-Tac-Toe oder Rock Paper Scissors zu erstellen, können Sie die Module Tkinter und Random verwenden. Um Spiele zu entwickeln, die mehr Grafik benötigen, können Sie Pygame verwenden.

Pygame ist eine Reihe von Python-Modulen, die auf allen Plattformen funktionieren. Es enthält Computergrafiken und Soundbibliotheken, die die Spiele interaktiver machen. Zu den Spielen, die Sie mit Pygame erstellen können, gehören das Snake-Spiel, das Memory-Puzzlespiel und Sudoku.