Crie uma Animação de Chuva de Código com Pygame | Tutorial Python

Introdução

Neste projeto, você aprenderá como criar uma animação de chuva de código simples usando a biblioteca Pygame em Python. Animações de chuva de código, popularizadas por filmes como "Matrix", exibem caracteres caindo em uma tela, dando a impressão de uma chuva digital. Usaremos a biblioteca Pygame para criar a animação e exibi-la em uma janela.

👀 Pré-visualização

Code rain

🎯 Tarefas

Neste projeto, você aprenderá:

Como configurar a janela de animação no Pygame
Como definir uma classe "Raindrop" (Gota de Chuva) para representar cada caractere caindo
Como gerar e exibir múltiplas instâncias da classe Raindrop
Como implementar o loop principal para atualizar continuamente a animação
Como fechar a janela de animação corretamente

🏆 Conquistas

Após concluir este projeto, você será capaz de:

Usar a biblioteca Pygame para criar animações
Definir e usar uma classe em Python
Lidar com eventos do usuário no Pygame
Criar um loop de animação principal no Pygame
Fechar corretamente uma janela de animação no Pygame

Criar os Arquivos do Projeto

Antes de começar, certifique-se de ter o Pygame instalado. Se você não tiver o Pygame instalado, pode fazê-lo usando o pip:

sudo pip install pygame

Em seguida, crie um arquivo chamado code_rain.py no seu editor de código ou IDE preferido. Este será o arquivo principal onde você escreverá o código para o jogo de chuva de código.

cd ~/project
touch code_rain.py

Configurando a Janela da Animação

Dentro do arquivo code_rain.py, importe as bibliotecas necessárias no início do código:

import pygame
import random

Em seguida, inicialize o Pygame chamando pygame.init():

pygame.init()

Depois, configure a janela de animação definindo a largura, altura e legenda:

width, height = 800, 600
screen = pygame.display.set_mode((width, height))
pygame.display.set_caption("Code Rain")

Defina as cores usadas na animação:

background_color = (0, 0, 0)
text_color = (0, 255, 0)

Configurações da fonte:

font = pygame.font.Font(None, 36)

Definindo a Classe Raindrop (Gota de Chuva)

Em seguida, definimos a classe Raindrop, que representa cada caractere caindo na animação de chuva de código. A classe Raindrop contém atributos como a posição inicial, o texto e a velocidade de queda de cada gota de chuva.

class Raindrop:
    def __init__(self):
        self.x = random.randint(0, width)
        self.y = random.randint(0, height)
        self.text = chr(random.randint(33, 126))
        self.speed = random.randint(1, 5)

    def fall(self):
        self.y += self.speed
        if self.y > height:
            self.y = 0
            self.x = random.randint(0, width)

    def display(self):
        text_surface = font.render(self.text, True, text_color)
        screen.blit(text_surface, (self.x, self.y))

O método __init__ é chamado quando a classe é instanciada para inicializar as propriedades da gota de chuva, incluindo a posição inicial aleatória (x, y), caracteres de texto aleatórios (ASCII entre 33 e 126) e velocidade de queda aleatória (entre 1 e 5).

O método fall é usado para mover as gotas de chuva para baixo. Ele aumenta o valor de self.y de acordo com a velocidade da gota de chuva. Se a gota de chuva sair da tela (quando self.y é maior que a altura da tela), ela é reiniciada no topo da tela e uma nova posição x é selecionada aleatoriamente na tela.

O método display é usado para exibir as gotas de chuva. Ele usa a função font.render da biblioteca pygame para criar uma superfície de texto e renderizá-la na posição da gota de chuva (self.x, self.y) na tela.

Gerando e Exibindo Gotas de Chuva

Agora, criaremos e exibiremos múltiplas instâncias da classe Raindrop para simular os caracteres caindo. O código abaixo gera um número especificado de gotas de chuva e atualiza suas posições na tela.

num_raindrops = 100
raindrops = [Raindrop() for _ in range(num_raindrops)]

Manipulando o Loop Principal

Nesta etapa, implementamos o loop principal que gerencia a animação, atualizando continuamente a tela. Ele também escuta o evento de saída para fechar a janela corretamente.

running = True
while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

    screen.fill(background_color)

    for drop in raindrops:
        drop.fall()
        drop.display()

    pygame.display.flip()

pygame.quit()

O corpo principal do loop de animação é um loop while, onde a variável running controla o loop. O loop continuará sendo executado somente se running for True.

Dentro do loop de animação, use pygame.event.get() para obter uma lista de eventos pygame e examine cada evento iterando sobre a lista de eventos. Neste caso, a principal verificação é se existe um evento de saída pygame.QUIT, que é gerado quando o usuário fecha a janela de animação. Se um evento de saída for detectado, defina running como False para sair do loop de animação.

screen.fill(background_color) preenche a cor de fundo da janela de animação screen para cobrir o conteúdo do quadro anterior, em preparação para desenhar um novo quadro.

Itere pela lista raindrops, chamando o método fall() em cada objeto raindrop para fazê-lo cair e chamando o método display() para exibir a gota de chuva na janela do jogo.

pygame.display.flip() é usado para atualizar todas as operações de desenho acima na tela para animação.

Após o término do loop de animação, chame pygame.quit() para limpar a biblioteca pygame e sair da animação.

Executar o Projeto

Finalmente, mude para a área de trabalho (Desktop) e execute o projeto usando o seguinte comando:

python code_rain.py