Cómo construir el juego de fichas de memoria usando Python

El mosaico de memoria o el juego de combinación es una forma excelente y divertida de aumentar las habilidades cognitivas, mejorar la memoria y mejorar el enfoque. El juego tiene un conjunto de fichas que debes voltear una por una, memorizar y seleccionar las que coincidan. Al hacer coincidir todas las fichas correctamente, ganas el juego.

Entonces, ¿cómo puedes desarrollar este increíble juego usando Python?

Los módulos Tkinter y Random

Puedes construir el juego de fichas de memoria usando los módulos Tkinter y Random. Tkinter te permite crear aplicaciones de escritorio. Ofrece una variedad de widgets como botones, etiquetas y cuadros de texto que facilitan la desarrollar aplicaciones como calendarios, calculadoras y listas de tareas pendientes. Para instalar Tkinter, abre la terminal y ejecuta:

pip instalar tkinter

El módulo Random es un módulo integrado de Python que se utiliza para generar números pseudoaleatorios. Usando esto,

puedes construir un generador de contraseñas aleatorias, una aplicación de simulación de lanzamiento de dados o un barajador de listas. Además, también puede desarrollar juegos interesantes como el cricket de mano y juegos de adivinanzas.

Cómo construir el juego de fichas de memoria usando Python

Puede encontrar el código fuente para construir el juego de fichas de memoria usando Python en este repositorio GitHub.

Comience importando Tkinter y el módulo Random. Inicialice la ventana raíz y establezca el título y las dimensiones en píxeles.

de tkinter importar *
importar aleatorio
de tkinter importar buzon de mensaje
raíz = Tk()
raíz.título('Juego de fichas de memoria')
raíz.geometría("760x550")

Defina dos variables globales e inicialice la variable ganadora a cero. Declara una lista de elementos que aparecerán en los mosaicos. Reordenar la lista usando el módulo aleatorio barajar() método. Defina un marco en la ventana raíz y agregue un relleno de 10 en la dirección vertical.

Inicialice una variable de conteo a 0 y declare una lista de respuestas y un diccionario respectivamente.

global ganador, partidos
ganador = 0
coincidencias = ["manzana","manzana","banana","banana", "naranja","naranja", "arándano","arándano","mora","mora", "uvas","uvas"]
random.shuffle (coincidencias)
my_frame = Marco (raíz)
mi_marco.paquete (pady=10)
contar = 0
lista_respuestas = []
respuesta_dict = {}

Definir una función, reiniciar(). Establezca el texto de la etiqueta en una cadena vacía usando el configuración() función. Defina una lista de botones, uno para cada uno de los mosaicos. Repita la lista y establezca el texto en el mosaico del botón en una cadena vacía, el color de fondo predeterminado (SistemaBotónCara), y el estado a la normalidad.

definitivamentereiniciar():
 mi_etiqueta.config (texto="")
 lista_botones = [b0,b1,b2,b3,b4,b5,b6,b7,b8,b9,b10,b11]
para botón en lista_de_botones:
 botón.config (texto=" ", bg="Cara del botón del sistema", estado="normal")

Definir una función, ganar(). Establezca un mensaje ganador en el parámetro de texto de la etiqueta usando el configuración() función. Defina la lista de botones como antes e itérela para establecer el color de fondo del mosaico en verde claro.

definitivamenteganar():
 mi_etiqueta.config (texto="¡Felicidades! ¡Tú ganas!")
 lista_botones = [b0,b1,b2,b3,b4,b5,b6,b7,b8,b9,b10,b11]
para botón en lista_de_botones:
 botón.config (bg="# 90EE90")

Definir una función, botón_clic() que toma el botón y su número como parámetros de entrada. Haga referencia a las variables globales, la lista y el diccionario. Si el texto del botón es igual a un espacio y el recuento es inferior a dos, inserte y muestre el texto del botón. Agregue el número de botón a la lista de respuestas y el nombre al diccionario de respuestas. Incremente la variable de conteo en uno.

definitivamentebotón_clic(b, número):
global contar, answer_list, answer_dict, ganador
si b["texto"] == ' 'y contar < 2:
 b["texto"] = coincidencias[número]
 answer_list.append (número)
 answer_dict[b] = coincidencias[número]
 contar += 1

Si la longitud de la lista de respuestas es dos, significa que el usuario ha seleccionado dos fichas. Si el texto del primer mosaico coincide con el otro, configure la etiqueta para mostrar que ambos coinciden correctamente. Cambie el estado del botón a desactivado. Establezca el conteo en cero y vacíe la lista y el diccionario. Incremente la variable ganadora en uno y si se convierte en seis, llame a la función ganadora declarada anteriormente.

si len (lista_respuestas) == 2:
si coincidencias[lista_de_respuestas[0]] == coincidencias[lista_respuestas[1]]:
 mi_etiqueta.config (texto="¡Es un partido!")
para llave en respuesta_dict:
 llave["estado"] = "desactivado"
 contar = 0
 lista_respuestas = []
 respuesta_dict = {}
 ganador += 1
si ganador == 6:
 ganar()

De lo contrario, restablezca la variable de conteo y la lista. Muestre un cuadro de mensaje con el título y el contenido que lo represente como una coincidencia incorrecta. Repita la lista de respuestas y establezca el texto del mosaico en un espacio. Restablece la etiqueta y vacía el diccionario. Esto garantiza que no haya texto visible en el botón y la etiqueta después de que el usuario haya seleccionado mosaicos incorrectos.

demás:
 contar = 0
 lista_respuestas = []
 cuadromensaje.showinfo("¡Incorrecto!", "Incorrecto")
para llave en respuesta_dict:
 llave["texto"] = " "
 mi_etiqueta.config (texto=" ")
 respuesta_dict = {}

Defina 12 botones. Establezca la ventana principal en la que desea colocarlos, el texto que deben mostrar, el estilo de fuente que deben tener, su alto y ancho, y el comando que se ejecutará cuando se haga clic en ellos. Recuerde usar la función lambda para pasar los datos al botón_clic() función. Selecciona el alivio parámetro a ranura para crear un efecto de profundidad tridimensional alrededor del botón.

b0 = Botón (mi_fotograma, texto=' ', fuente=("Helvética", 20), altura=4, ancho=8, comando=lambda: botón_clic (b0, 0), relieve="ranura")
b1 = Botón (mi_fotograma, texto=' ', fuente=("Helvética", 20), altura=4, ancho=8, comando=lambda: botón_clic (b1, 1), relieve="ranura")
b2 = Botón (mi_marco, texto=' ', fuente=("Helvética", 20), altura=4, ancho=8, comando=lambda: botón_clic (b2, 2), relieve="ranura")
b3 = Botón (mi_fotograma, texto=' ', fuente=("Helvética", 20), altura=4, ancho=8, comando=lambda: botón_clic (b3, 3), relieve="ranura")
b4 = Botón (mi_fotograma, texto=' ', fuente=("Helvética", 20), altura=4, ancho=8, comando=lambda: botón_clic (b4, 4), relieve="ranura")
b5 = Botón (mi_fotograma, texto=' ', fuente=("Helvética", 20), altura=4, ancho=8, comando=lambda: botón_clic (b5, 5), relieve="ranura")
b6 = Botón (mi_fotograma, texto=' ', fuente=("Helvética", 20), altura=4, ancho=8, comando=lambda: botón_clic (b6, 6), relieve="ranura")
b7 = Botón (mi_fotograma, texto=' ', fuente=("Helvética", 20), altura=4, ancho=8, comando=lambda: botón_clic (b7, 7), relieve="ranura")
b8 = Botón (mi_fotograma, texto=' ', fuente=("Helvética", 20), altura=4, ancho=8, comando=lambda: botón_clic (b8, 8), relieve="ranura")
b9 = Botón (mi_fotograma, texto=' ', fuente=("Helvética", 20), altura=4, ancho=8, comando=lambda: botón_clic (b9, 9), relieve="ranura")
b10 = Botón (mi_fotograma, texto=' ', fuente=("Helvética", 20), altura=4, ancho=8, comando=lambda: botón_clic (b10, 10), relieve="ranura")
b11 = Botón (mi_marco, texto=' ', fuente=("Helvética", 20), altura=4, ancho=8, comando=lambda: botón_clic (b11, 11), relieve="ranura")

Organice los botones en un formato tabular que consta de tres filas y cuatro columnas utilizando el administrador de cuadrícula de Tkinter. Para ello, llame al red() y pase la fila junto con el número de columna en el que desea colocarlo.

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

Defina una etiqueta que muestre una cadena vacía y agregue un relleno de 20 en la dirección vertical. Defina un menú de nivel superior en la ventana raíz y adjúntelo girando el arrancar parámetro a FALSO. Agregar un elemento de submenú, Opciones utilizando el añadir_cascada parámetro.

Agregue dos elementos de menú junto con los comandos que deben ejecutar cuando se hace clic en el submenú llamado Reiniciar el juego y Salir del juego. Agregue un separador entre ellos para la demarcación.

my_label = Etiqueta (raíz, texto="")
mi_etiqueta.paquete (pady=20)
my_menu = Menú (raíz)
root.config (menu=mi_menu)
option_menu = Menú (my_menu, tearoff=FALSO)
mi_menu.add_cascade (etiqueta="Opciones", menú=opción_menú)
option_menu.add_command (etiqueta="Reiniciar el juego", comando=restablecer)
menú_opción.añadir_separador()
option_menu.add_command (etiqueta="Salir del juego", comando=raíz.salir)

El bucle principal() La función le dice a Python que ejecute el ciclo de eventos de Tkinter y escuche los eventos hasta que cierre la ventana.

raíz.mainloop()

Junta todo el código. Ahora el juego de fichas de memoria está listo para jugar.

Salida del juego de fichas de memoria

Al ejecutar el programa, aparecen 12 botones con texto vacío junto con el Opciones menú. Al hacer clic Reiniciar el juego, la ventana aparece de la misma manera.

Al seleccionar dos mosaicos iguales, los botones aparecen deshabilitados y la etiqueta muestra que la elección es correcta.

Al seleccionar dos mosaicos que no coinciden, aparece un cuadro de mensaje que indica que la selección fue incorrecta. Los botones y la etiqueta vuelven a su estado vacío original.

Al hacer coincidir con éxito todas las opciones, el programa convierte todas las fichas en verdes y muestra el mensaje ganador.

Juegos que puedes construir usando Python

Python ofrece una variedad de módulos para crear juegos. Para crear juegos sencillos basados ​​en palabras o elecciones, como Hangman, Tic-Tac-Toe o Rock Paper Scissors, puede utilizar los módulos Tkinter y Random. Para desarrollar juegos que necesitan más gráficos, puedes usar Pygame.

Pygame es un conjunto de módulos de Python que funciona en todas las plataformas. Incluye gráficos por computadora y bibliotecas de sonido que hacen que los juegos sean más interactivos. Algunos de los juegos que puede crear con Pygame incluyen el juego Snake, el juego de rompecabezas de memoria y el Sudoku.