Você conhece o jogo da cobrinha? Nesta aula vamos aprender a fazer o jogo Snake em Python começando do Zero!
Caso prefira esse conteúdo no formato de vídeo-aula, assista ao vídeo abaixo ou acesse o nosso canal do YouTube!
Para receber por e-mail o(s) arquivo(s) utilizados na aula, preencha:
Fala Impressionadores! Você já deve ter jogado o famoso jogo da cobrinha no celular não é mesmo?
E se eu te disser que hoje nós vamos criar esse jogo usando o Python? Isso mesmo, nós vamos criar o jogo da cobrinha em Python com PyGame, que é uma biblioteca de jogos.
Nós vamos criar esse jogo do absoluto zero, então vamos criar a tela do jogo, as comidas, a cobra e as regras para que o jogo funcione da forma correta.
E aí, quer começar na criação de jogos em Python com esse jogo nostálgico?
Então vem comigo que eu vou te mostrar todo o passo a passo para criar o jogo do início ao fim!
Vale lembrar que você pode fazer qualquer modificação que quiser dentro do jogo. O que eu vou mostrar é o “básico” do jogo, mas pode personalizar do jeito que quiser!
Para fazer este projeto vou usar o editor de código PyCharm, mas você pode utilizar o que você já está acostumado, o importante, independente do editor que você vá usar é criar um ambiente virtual para o seu projeto.
Então, clique em Novo projeto e dê um nome ao projeto, neste caso vou nomear como JogoSnake e criar.
Quando estamos criando jogos muito complexos geralmente precisamos de vários arquivos, este jogo nós poderíamos criar com vários arquivos, mas a princípio vamos criar com um arquivo só.
Sempre que se cria um jogo existem alguns códigos padrão para a criação do jogo:
Configurações iniciais
O primeiro passo é importar as bibliotecas, neste caso vamos usar:
Import pygame (é necessário rodar no terminal -> pip install pygame)
Import Randon (permite colocar uma comida na tela de forma aleatória)Vamos agora, iniciar o PyGame:
Pygame.init()Criando a tela
Vamos criar a tela, dar nome ao jogo com set_caption e definir as dimensões da tela.
pygame.init()
pygame.display.set_caption(“jogo Snake Python”)
largura, altura = 1200, 800 (escolha as dimensões de acordo com a sua tela)
tela = pygame.display.set_mode((largura, altura))
relógio = pygame.time.Clock()
Definindo as cores
preta = (0, 0, 0)
branca = (255, 255, 255)
vermelho = (255, 0, 0)
verde = (0, 255, 0)Parâmetros da cobrinha
tamanho_quadrado = 20 (Esse quadrado que estamos estabelecendo o tamanho vai estar em volta do ponto na tela que representa a cobrinha, isso porque sem este quadrado seria difícil ver onde ela está).
Velocidade_jogo = 15 (entre uma execução e outra do loop a cabra vai andar 15)Observe que para o PyGame executar o loop infinito precisa dar uma leve pausa entre em loop e outro, isso é feito para que o jogo não trave.
Para controlar essa pausa criamos o relógio no código acima e a velocidade da cobra vai ditar o tempo para esse relógio, então quanto mais lenta a cobrinha menor é o valor que você deve colocar na Velocidade_cobra e vice-versa.
Feito isso, podemos partir para a construção do jogo que se dá todo em um loop infinito, vamos começar uma função que vou chamar de Rodar jogo:
Def rodar_jogo():
Fim_jogo = False
While not fim_jogo:
PassNote que na função atribuímos a variável Fim_jogo o False, então o jogo está parado.
Na linha abaixo temos o While indicando que se o jogo não tiver terminado então -> pass = continua.
Pegando as interações do usuário
Def rodar_jogo():
Fim_jogo = False
While not fim_jogo:
For evento in pygame.event.get():Então a última linha está dizendo que para cada evento dentro do PyGame, ou seja, cada vez que o usuário clica em um botão na tela, esse evento é passado para essa lista de itens.
Agora, vamos continuar da seguinte forma, se o evento for igual a Quit (fim de jogo) então vamos fechar o jogo.
Def rodar_jogo():
Fim_jogo = False
While not fim_jogo:
For evento in pygame.event.get():
If evento.type == pygame.QUIT:
fim_jogo = truePara vermos essa estrutura funcionando precisamos criar a nossa tela, vamos criar este código antes do evento.
Criando a nossa tela
Vamos colocar o código para a tela antes do evento e atribuir a ela uma cor:
Def rodar_jogo():
Fim_jogo = False
While not fim_jogo:
Tela.fill(preta)
For evento in pygame.event.get():
If evento.type == pygame.QUIT:
fim_jogo = trueNote que, no jogo da cobrinha, assim que ele se inicia já temos a cobrinha e a comida certo?
No nosso jogo a única coisa que temos até agora é uma tela preta que podemos abrir e fechar, então vamos criar os elementos que faltam…
Para definir a posição inicial da cobrinha, precisamos entender que na tela o eixo X está em cima começando em zero do lado esquerdo e o Y na vertical começando em zero da parte superior, como na imagem abaixo:
Então a posição inicial da cobrinha vai ser igual a x = largura / 2 e y = altura / 2.
Em relação à velocidade tanto o eixo x quanto o y começam zerados:
tamanho_quadrado = 20
Velocidade_jogo = 15
Def rodar_jogo():
Fim_jogo = False
x = largura / 2
y = altura / 2
velocidade_x = 0
velocidade_y = 0
While not fim_jogo:
PassComo é a lógica por trás dos movimentos da cobrinha?
A velocidade da cobrinha se dá a cada execução e outra do loop, mas temos também a interação do usuário, ou seja, se o usuário está apontando a cobrinha para cima ou para baixo, então:
Se for para a direita andará no eixo x, então -> a velocidade em x vai ser atualizada.
Se for para baixo -> a velocidade em x vira zero e a velocidade em y começa a ganhar valor.
De início essas posições vão estar zeradas, mas logo vamos voltar para programar essa velocidade e direção.
Vamos agora criar uma variável que define o tamanho da cobra e os pixels que inicialmente vão começar vazios.
Também vamos definir a função e variáveis que correspondem as comidas, esta função vai gerar para nós as duas posições da comida -> x e y.
Def_gerar_comida():
Return comida_x, comida_y
Def rodar_jogo():
Fim_jogo = False
x = largura / 2
y = altura / 2
velocidade_x = 0
velocidade_y = 0
tamanho_cobra = 1
pixels = []
comida_x, comida_y = gerar_comida()
While not fim_jogo:
PassEssencialmente a função gerar comida deve gerar uma posição aleatória de x e y a cada vez que rodar. Vamos fazer isso usando o Randon:
Def_gerar_comida():
Comida_x = Random.randrange(0, largura – tamanho_quadrado)
Comida_y = Random.randrange(0, altura – tamanho_quadrado)
Return comida_x, comida_yObservações importantes sobre o código acima
Colocamos nos parênteses que a comida pode aparecer até a largura e altura total da tela (–) “menos” o tamanho de um quadrado.
Fazemos isso para evitar que a comida gerada no último pixels da tela não ultrapasse a margem porque estamos colocando um quadrado para representar um pixels lembra? Fizemos isso para torná-lo legível, então o tamanho da comida pode ultrapassar a tela.
Para evitar isso colocamos todo o tamanho da tela menos o tamanho de um quadrado, assim garantimos que não vai sobressair as margens.
Outro ponto é que a função que define os números aleatórios que geram a posição das comidas pode gerar números quebrados. Isso faz com que a comida não esteja completamente alinhada com a cobrinha:
Você pode fazer o jogo das duas formas, com a comida alinhada ou não, porém, acredito que este é um nível de complexidade desnecessário agora, então neste projeto vamos colocar a comida alinhada.
O que vamos fazer então é definir um tamanho na tela que tanto a cobrinha quanto a comida deverão aparecer dentro desses espaços que vamos delimitar.
Def_gerar_comida():
Comida_x = round(random.randrange(0, largura – tamanho_quadrado) / 20.0) * 20.0
Comida_y = round(random.randrange(0, altura – tamanho_quadrado) / 20.0) * 20.0
Return comida_x, comida_yOs cálculos acima vão garantir que independente de onde o pixel for gerado no espaço que temos, as comidinhas não vão sair do espaço que delimitamos.
Def_gerar_comida():
Comida_x = round(random.randrange(0, largura – tamanho_quadrado) / 20.0) * 20.0
Comida_y = round(random.randrange(0, altura – tamanho_quadrado) / 20.0) * 20.0
Return comida_x, comida_y
Def desenhar_comida(tamanho, comida_x, comida_y):
Pygame.draw.rect(tela, verde, [comida_x, comida_y, tamanho, tamanho])
Desenhar Comida
While not fim_jogo:
Tela.fill(preta)
For evento in pygame.event.get():
If evento.type == pygame.QUIT:
fim_jogo = true
desenhar_comida (tamanho_quadrado, comida, comida_x, comida_y)Quando desenhamos algo na tela, isso não aparece automaticamente, para podermos visualizar o desenho temos que fazer uma atualização.
desenhar_comida (tamanho_quadrado, comida, comida_x, comida_y)
Pygame.display.update()Para que essa atualização não fique acontecendo muito rápido vamos colocar o tempo com o relógio que criamos.
desenhar_comida (tamanho_quadrado, comida, comida_x, comida_y)
Pygame.display.update()
Relógio.tick(velocidade_jogo)Se rodarmos o código, já vai aparecer um quadradinho verde na tela, que será o início da cobrinha que vamos terminar de desenhar.
Para criar a cobrinha temos que definir algumas regras de atualização:
Quando a cobrinha não vai aumentar de tamanho:
Antes de fazer o código para quando a cobrinha não deve aumentar de tamanho vamos entender o que de fato acontece quando a cobrinha anda.
Se a cobrinha estiver andando da esquerda para a direita sem crescer isso significa que estamos sempre excluindo o último pixel do corpo da cobra e acrescentando um na frente. Isso faz com que tenhamos a impressão de que ela caminha sobre o a tela sem aumentar de tamanho.
Dito isso vamos escrever o código começando por adicionar a posição da cobrinha na lista do pixel.
#desenhar_comida
desenhar_comida (tamanho_quadrado, comida, comida_x, comida_y)
#desenhar_cobra
Pixels.append([x, y])
If len(pixels) > tamanho_cobra:
Del pixel [0]
// para construir a lógica que mostrei na imagem acima vamos usar o if, então se a quantidade(len) pixels for maior que o tamanho da cobra então vamos deletar o primeiro pixel que colocamos.Já definimos como a cobra anda, mas, pode ocorrer de ela andar e bater nela mesma, neste caso o jogo tem que terminar.
Então vamos escrever isso no código:
#desenhar_cobra
Pixels.append([x, y])
If len(pixels) > tamanho_cobra:
Del pixel [0]
#se a cobrinha bateu no próprio corpo
For pixel in pixels[:-1]:
If pixel == [x, y]:
Fim_jogo = true
Desenhar_cobra(tamanho_quadrado, pixels)
//Então, se algum pixel for igual a [x, y] que é o início da cobrinha, então o jogo termina.
Pygame.display.update()
Relógio.tick(velocidade_jogo)Feito isso, vamos definir a função desenhar_cobra:
Def desenhar_comida(tamanho, comida_x, comida_y):
Pygame.draw.rect(tela, verde, [comida_x, comida_y, tamanho, tamanho])
Def desenhar_cobra(tamanho, pixels):
For pixel in pixels:
Pygame.draw.rect(tela, branca, [pixel[0], pixel[1], tamanho, tamanho])
Desenhando os pontos
#se a cobrinha bateu no próprio corpo
For pixel in pixels[:-1]:
If pixel == [x, y]:
Fim_jogo = true
Desenhar_cobra(tamanho_quadrado, pixels)
#desenhar pontos
Desenhar_pontuação(tamanho_cobra -1)Função da pontuação
Essa função vai escrever um texto na tela para isso vamos ter que definir uma fonte para o texto e inserir na tela:
Def desenhar_cobra(tamanho, pixels):
For pixel in pixels:
Pygame.draw.rect(tela, branca, [pixel[0], pixel[1], tamanho, tamanho])
Def desenhar_pontuacao(pontuação):
Fonte = pygame.font.SysFont(“Helvetica”, 35)
Texto = fonte.render(f”Pontos: {pontuação}”, True, vermelha)
Tela.blit(texto, [1, 1])
Criando uma comida
#desenhar pontos
Desenhar_pontuação(tamanho_cobra -1)
#atualização da tela
Pygame.display.update()
#criar uma nova comida
If x == comida_x and y == comida_y:
Tamanho_cobra += 1
Comida_x, comida_y = gerar_comida()Observe que no código acima estamos dizendo que, se a posição da cobrinha for igual a da comida, isso significa que a cobrinha comeu a comida que havia naquela posição, então temos que chamar a função para criar outra comidinha.
Feito isso vamos começar a movimentar a nossa cobrinha!
For evento in pygame.event.get():
If evento.type == pygame.QUIT:
fim_jogo = true
elif evento.type == pygame.KEYDOWN:
velocidade_x, velocidade_y = selecionar_velocidade(evento.key)O que acabamos de fazer é definir que caso o jogo não tenha terminado, vamos ter um evento (apertar uma tecla) que vai resultar em uma velocidade, então vamos criar essa função para a velocidade:
Def desenhar_pontuacao(pontuação):
Fonte = pygame.font.SysFont(“Helvetica”, 35)
Texto = fonte.render(f”Pontos: {pontuação}”, True, vermelha)
Tela.blit(texto, [1, 1])
Def selecionar_velocidade(tecla):
If tecla == pygame.K_DOWN:
Velocidade_x = 0
Velocidade_y = tamanho_quadrado
elif tecla == pygame.K_UP:
Velocidade_x = 0
Velocidade_y = -tamanho_quadrado
elif tecla == pygame.K_RIGHT:
Velocidade_x = tamanho_quadrado
Velocidade_y = 0
elif tecla == pygame.K_LEFT:
Velocidade_x = -tamanho_quadrado
Velocidade_y = 0
Return velocidade_x, velocidade_yAgora que definimos como a cobrinha vai andar para cima, para baixo, para a direita e esquerda vamos atualizar a posição da cobra conforme o que ela andou.
#desenhar_comida
desenhar_comida (tamanho_quadrado, comida, comida_x, comida_y)
#atualizar a posição da cobra
X += velocidade_x
Y += velocidade_ySe você rodar o jogo agora, vai ver que a cobrinha já aparece, ela já obedece aos botões de direção, se alimenta e aumenta de tamanho, se ela bater nela mesma o jogo também é encerrado, a única coisa que falta é encerrar caso bata na parede.
Vamos fazer isso:
#atualizar a posição da cobra
If x < 0 or x >= largura or y < 0 or y >= altura:
Fim_jogo = true
X += velocidade_x
Y += velocidade_yProntinho, agora que você já recebeu a explicação para cada parte do código, vou deixar aqui o código completo aqui para você!
# configurações iniciais
import pygame
import random
pygame.init()
pygame.display.set_caption("Jogo Snake Python")
largura, altura = 1200, 800
tela = pygame.display.set_mode((largura, altura))
relogio = pygame.time.Clock()
# cores RGB
preta = (0, 0, 0)
branca = (255, 255, 255)
vermelha = (255, 0, 0)
verde = (0, 255, 0)
# parametros da cobrinha
tamanho_quadrado = 20
velocidade_jogo = 15
def gerar_comida():
comida_x = round(random.randrange(0, largura - tamanho_quadrado) / float(tamanho_quadrado)) * float(tamanho_quadrado)
comida_y = round(random.randrange(0, altura - tamanho_quadrado) / float(tamanho_quadrado)) * float(tamanho_quadrado)
return comida_x, comida_y
def desenhar_comida(tamanho, comida_x, comida_y):
pygame.draw.rect(tela, verde, [comida_x, comida_y, tamanho, tamanho])
def desenhar_cobra(tamanho, pixels):
for pixel in pixels:
pygame.draw.rect(tela, branca, [pixel[0], pixel[1], tamanho, tamanho])
def desenhar_pontuacao(pontuacao):
fonte = pygame.font.SysFont("Helvetica", 35)
texto = fonte.render(f"Pontos: {pontuacao}", True, vermelha)
tela.blit(texto, [1, 1])
def selecionar_velocidade(tecla):
if tecla == pygame.K_DOWN:
velocidade_x = 0
velocidade_y = tamanho_quadrado
elif tecla == pygame.K_UP:
velocidade_x = 0
velocidade_y = -tamanho_quadrado
elif tecla == pygame.K_RIGHT:
velocidade_x = tamanho_quadrado
velocidade_y = 0
elif tecla == pygame.K_LEFT:
velocidade_x = -tamanho_quadrado
velocidade_y = 0
return velocidade_x, velocidade_y
def rodar_jogo():
fim_jogo = False
x = largura / 2
y = altura / 2
velocidade_x = 0
velocidade_y = 0
tamanho_cobra = 1
pixels = []
comida_x, comida_y = gerar_comida()
while not fim_jogo:
tela.fill(preta)
for evento in pygame.event.get():
if evento.type == pygame.QUIT:
fim_jogo = True
elif evento.type == pygame.KEYDOWN:
velocidade_x, velocidade_y = selecionar_velocidade(evento.key)
# desenhar_comida
desenhar_comida(tamanho_quadrado, comida_x, comida_y)
# atualizar a posicao da cobra
if x < 0 or x >= largura or y < 0 or y >= altura:
fim_jogo = True
x += velocidade_x
y += velocidade_y
# desenhar_cobra
pixels.append([x, y])
if len(pixels) > tamanho_cobra:
del pixels[0]
# se a cobrinha bateu no proprio corpo
for pixel in pixels[:-1]:
if pixel == [x, y]:
fim_jogo = True
desenhar_cobra(tamanho_quadrado, pixels)
# desenhar_pontos
desenhar_pontuacao(tamanho_cobra - 1)
# atualizacao da tela
pygame.display.update()
# criar uma nova comida
if x == comida_x and y == comida_y:
tamanho_cobra += 1
comida_x, comida_y = gerar_comida()
relogio.tick(velocidade_jogo)
rodar_jogo()Você já tinha feito um jogo do zero em Python? Preparei esta aula para te mostrar passo a passo como fazer o famoso jogo da cobrinha do zero!
Enquanto você estiver escrevendo o código do jogo, também vai aprender conceitos muito importantes em Python!
Se você quiser aprender mais, temos também uma aula ensinando como criar sites usando Python, aproveite e clique no link!
Eu fico por aqui! Espero que gostem! Um abraço,
Para acessar outras publicações de Python, clique aqui!
Expert em conteúdos da Hashtag Treinamentos. Auxilia na criação de conteúdos de variados temas voltados para aqueles que acompanham nossos canais.
Quer sair do zero no Python e virar uma referência na sua empresa? Inscreva-se agora mesmo no Python Impressionador