Verifique suas habilidades cognitivas construindo este jogo de blocos de memória.

O bloco de memória ou jogo de correspondência é uma maneira excelente e divertida de aumentar as habilidades cognitivas, melhorar a memória e melhorar o foco. O jogo tem um conjunto de peças que você deve virar uma a uma, memorizar e selecionar as que combinam. Ao combinar todas as peças corretamente, você ganha o jogo.

Então, como você pode desenvolver este incrível jogo usando Python?

Os Módulos Tkinter e Random

Você pode construir o jogo de blocos de memória usando os módulos Tkinter e Random. Tkinter permite que você crie aplicativos de desktop. Ele oferece uma variedade de widgets como botões, rótulos e caixas de texto que facilitam a desenvolver aplicativos como calendários, calculadoras e listas de tarefas. Para instalar o Tkinter, abra o terminal e execute:

pip instalar tkinter

O módulo Random é um módulo interno do Python usado para gerar números pseudo-aleatórios. Usando isso, você pode construir um gerador de senha aleatório

instagram viewer
, um aplicativo de simulação de rolagem de dados ou um embaralhador de lista. Além disso, você também pode desenvolver jogos interessantes como hand cricket e jogos de adivinhação de números.

Como construir o jogo Memory Tile usando Python

Você pode encontrar o código-fonte para construir o jogo de bloco de memória usando Python neste Repositório GitHub.

Comece importando o Tkinter e o módulo Random. Inicialize a janela raiz e defina o título e as dimensões em pixels.

de tkinter importar *
importar aleatório
de tkinter importar caixa de mensagem
raiz = Tk()
root.title('Jogo de Blocos de Memória')
raiz.geometria("760x550")

Defina duas variáveis ​​globais e inicialize a variável vencedora como zero. Declare uma lista de itens que aparecerão nos ladrilhos. Reordene a lista usando o módulo aleatório embaralhar() método. Defina um quadro na janela raiz e adicione um preenchimento de 10 na direção vertical.

Inicialize uma variável de contagem como 0 e declare uma lista de respostas e um dicionário, respectivamente.

global vencedor, partidas
vencedor = 0
partidas = ["maçã","maçã","banana","banana", "laranja","laranja", "mirtilo","mirtilo","amoreira","amoreira", "uvas","uvas"]
random.shuffle (correspondências)
my_frame = Quadro (raiz)
my_frame.pack (pady=10)
contagem = 0
lista_resposta = []
resposta_dict = {}

Defina uma função, reiniciar(). Defina o texto do rótulo como uma string vazia usando o config() função. Defina uma lista de botões, uma para cada um dos blocos. Repita a lista e defina o texto no bloco do botão como uma string vazia, a cor de fundo como padrão (SystemButtonFace) e o estado para normal.

defreiniciar():
 my_label.config (texto="")
 lista_de_botões = [b0,b1,b2,b3,b4,b5,b6,b7,b8,b9,b10,b11]
para botão em lista de botões:
 button.config (texto=" ", bg ="SystemButtonFace", estado="normal")

Defina uma função, ganhar(). Defina uma mensagem vencedora no parâmetro de texto do rótulo usando o config() função. Defina a lista de botões como anteriormente e percorra-a para definir a cor de fundo do ladrilho como verde claro.

defganhar():
 my_label.config (texto="Parabéns! Você ganha!")
 lista_de_botões = [b0,b1,b2,b3,b4,b5,b6,b7,b8,b9,b10,b11]
para botão em lista de botões:
 button.config (bg="#90EE90")

Defina uma função, botão_clique() que leva o botão e seu número como parâmetros de entrada. Faça referência às variáveis ​​globais, lista e dicionário. Se o texto do botão for igual a um espaço e a contagem for menor que dois, insira e exiba o texto do botão. Anexe o número do botão à lista de respostas e o nome ao dicionário de respostas. Incremente a variável de contagem em um.

defbotão_clique(b, número):
global contagem, answer_list, answer_dict, vencedor
se b["texto"] == ' 'e contar < 2:
 b["texto"] = correspondências[número]
 answer_list.append (número)
 answer_dict[b] = correspondências[número]
 contar += 1

Se o comprimento da lista de respostas for dois, significa que o usuário selecionou dois blocos. Se o texto do primeiro bloco corresponder ao outro, configure o rótulo para exibir que ambos correspondem corretamente. Transforme o estado do botão em desativado. Defina a contagem como zero e esvazie a lista e o dicionário. Incremente a variável vencedora em um e se chegar a seis, chame a função win declarada anteriormente.

se len (lista_resposta) == 2:
se correspondências[lista_resposta[0]] == correspondências[answer_list[1]]:
 my_label.config (texto="É uma combinação!")
para chave em resposta_dito:
 chave["estado"] = "desabilitado"
 contagem = 0
 lista_resposta = []
 resposta_dict = {}
 vencedor += 1
se vencedor == 6:
 ganhar()

Caso contrário, redefina a variável de contagem e a lista. Exiba uma caixa de mensagem com o título e o conteúdo descrevendo-a como uma correspondência incorreta. Repita a lista de respostas e defina o texto do bloco como um espaço. Redefina o rótulo e esvazie o dicionário. Isso garante que não haja texto visível no botão e no rótulo depois que o usuário selecionar blocos incorretos.

outro:
 contagem = 0
 lista_resposta = []
 messagebox.showinfo("Incorreta!", "Incorreta")
para chave em resposta_dito:
 chave["texto"] = " "
 my_label.config (texto=" ")
 resposta_dict = {}

Defina 12 botões. Defina a janela pai na qual deseja colocá-los, o texto que devem exibir, o estilo de fonte que devem ter, sua altura e largura e o comando a ser executado quando clicado. Lembre-se de usar a função lambda para passar os dados para o botão_clique() função. Colocou o alívio parâmetro para sulco para criar um efeito de profundidade 3D ao redor do botão.

b0 = Botão (meu_quadro, texto=' ', fonte=("Helvética", 20), altura =4, largura=8, comando=lambda: botão_clique (b0, 0), relevo="sulco")
b1 = Botão (meu_quadro, texto=' ', fonte=("Helvética", 20), altura =4, largura=8, comando=lambda: botão_clique (b1, 1), relevo="sulco")
b2 = Botão (meu_quadro, texto=' ', fonte=("Helvética", 20), altura =4, largura=8, comando=lambda: botão_clique (b2, 2), relevo="sulco")
b3 = Botão (meu_quadro, texto=' ', fonte=("Helvética", 20), altura =4, largura=8, comando=lambda: botão_clique (b3, 3), relevo="sulco")
b4 = Botão (meu_quadro, texto=' ', fonte=("Helvética", 20), altura =4, largura=8, comando=lambda: botão_clique (b4, 4), relevo="sulco")
b5 = Botão (meu_quadro, texto=' ', fonte=("Helvética", 20), altura =4, largura=8, comando=lambda: botão_clique (b5, 5), relevo="sulco")
b6 = Botão (meu_quadro, texto=' ', fonte=("Helvética", 20), altura =4, largura=8, comando=lambda: botão_clique (b6, 6), relevo="sulco")
b7 = Botão (meu_quadro, texto=' ', fonte=("Helvética", 20), altura =4, largura=8, comando=lambda: botão_clique (b7, 7), relevo="sulco")
b8 = Botão (meu_quadro, texto=' ', fonte=("Helvética", 20), altura =4, largura=8, comando=lambda: botão_clique (b8, 8), relevo="sulco")
b9 = Botão (meu_quadro, texto=' ', fonte=("Helvética", 20), altura =4, largura=8, comando=lambda: botão_clique (b9, 9), relevo="sulco")
b10 = Botão (meu_quadro, texto=' ', fonte=("Helvética", 20), altura =4, largura=8, comando=lambda: botão_clique (b10, 10), relevo="sulco")
b11 = Botão (meu_quadro, texto=' ', fonte=("Helvética", 20), altura =4, largura=8, comando=lambda: botão_clique (b11, 11), relevo="sulco")

Organize os botões em um formato tabular composto por três linhas e quatro colunas usando o gerenciador de grade do Tkinter. Para isso, ligue para o grade() e passe a linha junto com o número da coluna em que deseja colocá-la.

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

Defina um rótulo que mostre uma string vazia e adicione um preenchimento de 20 na direção vertical. Defina um menu de nível superior na janela raiz e anexe-o girando o arrancar parâmetro para Falso. Adicionar um item de submenu, Opções usando o add_cascade parâmetro.

Adicione dois itens de menu junto com os comandos que eles devem executar quando clicados no submenu chamado Reiniciar jogo e Sair do jogo. Adicione um separador entre eles para demarcação.

meu_rótulo = Rótulo (raiz, texto="")
my_label.pack (pady=20)
meu_menu = Menu (raiz)
root.config (menu=meu_menu)
option_menu = Menu (meu_menu, tearoff=Falso)
my_menu.add_cascade (label="Opções", menu=menu_opção)
option_menu.add_command (label="Redefinir jogo", comando=redefinir)
option_menu.add_separator()
option_menu.add_command (label="Sair do jogo", comando=root.quit)

O circuito principal() A função diz ao Python para executar o loop de eventos Tkinter e escutar os eventos até que você feche a janela.

root.mainloop()

Junte todo o código. Agora o jogo de blocos de memória está pronto para jogar.

Saída do Jogo de Blocos de Memória

Ao executar o programa, 12 botões aparecem com texto vazio junto com o Opções cardápio. Ao clicar Reiniciar jogo, a janela aparece da mesma maneira.

Ao selecionar duas peças correspondentes, os botões aparecem desabilitados e o rótulo mostra que a escolha está correta.

Ao selecionar dois ladrilhos que não combinam, uma caixa de mensagem aparece indicando que a seleção foi incorreta. Os botões e o rótulo retornam ao seu estado vazio original.

Ao combinar com sucesso todas as opções, o programa torna todas as peças verdes e exibe a mensagem vencedora.

Jogos que você pode construir usando Python

Python oferece uma variedade de módulos para construir jogos. Para criar jogos simples baseados em palavras ou escolhas, como Hangman, Tic-Tac-Toe ou Rock Paper Scissors, você pode utilizar os módulos Tkinter e Random. Para desenvolver jogos que precisam de mais gráficos, você pode usar o Pygame.

Pygame é um conjunto de módulos Python que funciona em todas as plataformas. Inclui gráficos de computador e bibliotecas de som que tornam os jogos mais interativos. Alguns dos jogos que você pode criar usando o Pygame incluem o jogo Snake, o jogo de quebra-cabeça da memória e o Sudoku.