Hoe het Memory Tile-spel te bouwen met behulp van Python

De geheugentegel of het bijpassende spel is een uitstekende en leuke manier om cognitieve vaardigheden te stimuleren, het geheugen te verbeteren en de focus te verbeteren. De game heeft een set tegels die je één voor één moet omdraaien, onthouden en degene selecteren die overeenkomen. Als je alle tegels correct matcht, win je het spel.

Dus hoe kun je dit geweldige spel ontwikkelen met behulp van Python?

De Tkinter- en willekeurige modules

Je kunt het geheugentegelspel bouwen met behulp van de Tkinter- en Random-modules. Met Tkinter kunt u desktop-applicaties maken. Het biedt een verscheidenheid aan widgets zoals knoppen, labels en tekstvakken die het gemakkelijker maken om toepassingen zoals kalenders ontwikkelen, rekenmachines en takenlijsten. Om Tkinter te installeren, opent u de terminal en voert u uit:

pip installeer tkinter

De Random-module is een ingebouwde Python-module die wordt gebruikt voor het genereren van pseudo-willekeurige getallen. Dit gebruiken,

je kunt een willekeurige wachtwoordgenerator bouwen, een simulatietoepassing voor het gooien van dobbelstenen of een lijstschudder. Verder kan je ook interessante spellen ontwikkelen zoals handcricket en getallen raden.

Hoe het Memory Tile-spel te bouwen met behulp van Python

Hierin vind je de broncode voor het bouwen van het geheugentegelspel met behulp van Python GitHub-opslagplaats.

Begin met het importeren van de Tkinter- en de Random-module. Initialiseer het hoofdvenster en stel de titel en afmetingen in pixels in.

van tkinter importeren *
importeren willekeurig
van tkinter importeren berichten box
wortel = Tk()
hoofdmap.titel('Geheugentegelspel')
root.geometry("760x550")

Definieer twee globale variabelen en initialiseer de winnaarvariabele op nul. Declareer een lijst met items die op de tegels zullen verschijnen. Herschik de lijst met behulp van de willekeurige modules schudden() methode. Definieer een frame in het hoofdvenster en voeg een opvulling van 10 toe in verticale richting.

Initialiseer een telvariabele op 0 en declareer respectievelijk een antwoordlijst en woordenboek.

globaal winnaar, wedstrijden
winnaar = 0
wedstrijden = ["appel","appel","banaan","banaan", "oranje","oranje", "bosbes","bosbes","moerbei","moerbei", "druiven","druiven"]
random.shuffle (overeenkomsten)
mijn_frame = Frame (root)
mijn_frame.pack (pady=10)
tel = 0
antwoord_lijst = []
antwoord_dict = {}

Definieer een functie, opnieuw instellen(). Stel de tekst van het label in op een lege tekenreeks met behulp van de configuratie() functie. Definieer een knoppenlijst, één voor elk van de tegels. Herhaal de lijst en stel de tekst op de knoptegel in op een lege tekenreeks, de achtergrondkleur op standaard (SystemButtonFace), en de toestand naar normaal.

defresetten():
 mijn_label.config (tekst="")
 knoppenlijst = [b0,b1,b2,b3,b4,b5,b6,b7,b8,b9,b10,b11]
voor knop in knop_lijst:
 knop.config (tekst=" ", bg="SystemButtonFace", staat="normaal")

Definieer een functie, winnen(). Stel een winnend bericht in de tekstparameter van het label in met behulp van de configuratie() functie. Definieer de lijst met knoppen zoals eerder en herhaal deze om de achtergrondkleur van de tegel in te stellen op lichtgroen.

defwinnen():
 mijn_label.config (tekst="Gefeliciteerd! Jij wint!")
 knoppenlijst = [b0,b1,b2,b3,b4,b5,b6,b7,b8,b9,b10,b11]
voor knop in knop_lijst:
 knop.config (bg="#90EE90")

Definieer een functie, knop_klik() dat neemt de knop en het nummer ervan als invoerparameters. Verwijs naar de globale variabelen, lijst en woordenboek. Als de tekst van de knop gelijk is aan een spatie en het aantal is minder dan twee, voeg dan de tekst van de knop in en geef deze weer. Voeg het knopnummer toe aan de antwoordenlijst en de naam aan het antwoordenwoordenboek. Verhoog de count-variabele met één.

defknop_klik(b, getal):
globaal graaf, antwoord_lijst, antwoord_dict, winnaar
als B["tekst"] == ' 'En tel < 2:
 B["tekst"] = komt overeen met[getal]
 answer_list.append (nummer)
 answer_dict[b] = komt overeen met[nummer]
 tel += 1

Als de lengte van de antwoordlijst twee is, betekent dit dat de gebruiker twee tegels heeft geselecteerd. Als de tekst van de eerste tegel overeenkomt met de andere, configureert u het label om weer te geven dat beide correct overeenkomen. Zet de status van de knop op uitgeschakeld. Zet de telling op nul en maak de lijst en het woordenboek leeg. Verhoog de winnaarvariabele met één en als het zes wordt, roep dan de eerder gedeclareerde winfunctie aan.

als len (answer_list) == 2:
als komt overeen met[answer_list[0]] == komt overeen met[answer_list[1]]:
 mijn_label.config (tekst="Het is een wedstrijd!")
voor sleutel in antwoord_dict:
 sleutel["staat"] = "gehandicapt"
 tel = 0
 antwoord_lijst = []
 antwoord_dict = {}
 winnaar += 1
als winnaar == 6:
 winnen()

Stel anders de count-variabele en de lijst opnieuw in. Geef een berichtvenster weer met de titel en inhoud waarin wordt aangegeven dat het een onjuiste overeenkomst is. Herhaal de antwoordenlijst en stel de tekst van de tegel in op een spatie. Reset het label en maak het woordenboek leeg. Dit zorgt ervoor dat er geen zichtbare tekst op de knop en het label staat nadat de gebruiker onjuiste tegels heeft geselecteerd.

anders:
 tel = 0
 antwoord_lijst = []
 berichtenbox.showinfo("Niet correct!", "Niet correct")
voor sleutel in antwoord_dict:
 sleutel["tekst"] = " "
 mijn_label.config (tekst=" ")
 antwoord_dict = {}

Definieer 12 knoppen. Stel het bovenliggende venster in waarin u ze wilt plaatsen, de tekst die ze moeten weergeven, de lettertypestijl die ze moeten hebben, hun hoogte en breedte, en de opdracht die moet worden uitgevoerd wanneer erop wordt geklikt. Vergeet niet om de lambda-functie te gebruiken om de gegevens door te geven aan de knop_klik() functie. Stel de opluchting parametreren naar groef om een ​​3D-diepte-effect rond de knop te creëren.

b0 = knop (mijn_frame, tekst=' ', lettertype=("Helvetica", 20), hoogte=4, breedte=8, opdracht=lambda: knop_klik (b0, 0), opluchting="groef")
b1 = Knop (mijn_frame, tekst=' ', lettertype=("Helvetica", 20), hoogte=4, breedte=8, opdracht=lambda: knop_klik (b1, 1), opluchting="groef")
b2 = Knop (mijn_frame, tekst=' ', lettertype=("Helvetica", 20), hoogte=4, breedte=8, opdracht=lambda: knop_klik (b2, 2), opluchting="groef")
b3 = Knop (mijn_frame, tekst=' ', lettertype=("Helvetica", 20), hoogte=4, breedte=8, opdracht=lambda: knop_klik (b3, 3), opluchting="groef")
b4 = Knop (mijn_frame, tekst=' ', lettertype=("Helvetica", 20), hoogte=4, breedte=8, opdracht=lambda: knop_klik (b4, 4), opluchting="groef")
b5 = Knop (mijn_frame, tekst=' ', lettertype=("Helvetica", 20), hoogte=4, breedte=8, opdracht=lambda: knop_klik (b5, 5), opluchting="groef")
b6 = Knop (mijn_frame, tekst=' ', lettertype=("Helvetica", 20), hoogte=4, breedte=8, opdracht=lambda: knop_klik (b6, 6), opluchting="groef")
b7 = Knop (mijn_frame, tekst=' ', lettertype=("Helvetica", 20), hoogte=4, breedte=8, opdracht=lambda: knop_klik (b7, 7), opluchting="groef")
b8 = Knop (mijn_frame, tekst=' ', lettertype=("Helvetica", 20), hoogte=4, breedte=8, opdracht=lambda: knop_klik (b8, 8), opluchting="groef")
b9 = Knop (mijn_frame, tekst=' ', lettertype=("Helvetica", 20), hoogte=4, breedte=8, opdracht=lambda: knop_klik (b9, 9), opluchting="groef")
b10 = Knop (mijn_frame, tekst=' ', lettertype=("Helvetica", 20), hoogte=4, breedte=8, opdracht=lambda: knop_klik (b10, 10), opluchting="groef")
b11 = Knop (mijn_frame, tekst=' ', lettertype=("Helvetica", 20), hoogte=4, breedte=8, opdracht=lambda: knop_klik (b11, 11), opluchting="groef")

Organiseer de knoppen in een tabelformaat bestaande uit drie rijen en vier kolommen met behulp van Tkinter's grid manager. Bel hiervoor naar de rooster() methode en geef de rij door samen met het kolomnummer waarin u het wilt plaatsen.

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

Definieer een label dat een lege tekenreeks weergeeft en voeg een opvulling van 20 toe in verticale richting. Definieer een menu op het hoogste niveau in het hoofdvenster en voeg het toe door de afscheuren parametreren naar Vals. Voeg een submenu-item toe, Opties de... gebruiken add_cascade parameter.

Voeg twee menu-items toe samen met de opdrachten die ze moeten uitvoeren wanneer erop wordt geklikt in het genoemde submenu Spel resetten En Sluit het spel af. Voeg een scheidingsteken tussen hen toe voor afbakening.

mijn_label = Label (hoofdmap, tekst="")
mijn_label.pack (pady=20)
mijn_menu = Menu (hoofdmap)
root.config (menu=mijn_menu)
option_menu = Menu (mijn_menu, afscheuren=Vals)
mijn_menu.add_cascade (label="Opties", menu=option_menu)
optie_menu.add_command (label="Spel resetten", commando=reset)
optie_menu.add_separator()
optie_menu.add_command (label="Verlaat het spel", commando=root.quit)

De Hoofdlus() functie vertelt Python om de Tkinter-gebeurtenislus uit te voeren en te luisteren naar gebeurtenissen totdat u het venster sluit.

root.mainloop()

Zet alle code bij elkaar. Nu is het geheugentegelspel klaar om te spelen.

Uitvoer van het Memory Tile-spel

Bij het uitvoeren van het programma verschijnen 12 knoppen met lege tekst samen met de Opties menu. Aan het klikken Spel resetten, verschijnt het venster op dezelfde manier.

Bij het selecteren van twee overeenkomende tegels, lijken de knoppen uitgeschakeld en geeft het label aan dat de keuze correct is.

Bij het selecteren van twee tegels die niet overeenkomen, verschijnt er een berichtvenster dat aangeeft dat de selectie onjuist was. De knoppen en het label keren terug naar hun oorspronkelijke lege staat.

Als alle keuzes met succes zijn gecombineerd, kleurt het programma alle tegels groen en wordt het winnende bericht weergegeven.

Games die je kunt bouwen met Python

Python biedt verschillende modules om games te bouwen. Om eenvoudige woord- of keuzegebaseerde spellen te maken, zoals Hangman, Tic-Tac-Toe of Rock Paper Scissors, kun je de Tkinter- en Random-modules gebruiken. Om games te ontwikkelen die meer graphics nodig hebben, kun je Pygame gebruiken.

Pygame is een set Python-modules die op alle platforms werkt. Het bevat computergraphics en geluidsbibliotheken die de spellen interactiever maken. Enkele van de spellen die u met Pygame kunt bouwen, zijn onder meer het Snake-spel, het geheugenpuzzelspel en Sudoku.