Introdução ao Pygame

Pygame é uma biblioteca Python para criação de jogos 2D, construída sobre a SDL. Ela facilita o mnauseio de gráficos, sons e eventos de entrada, permitindo o desenvolvimento de jogos interativos. Este guia cobre desde a instalação até a implementação de um jogo completo, incluindo conceitos essenciais como quadros de animação, detecção de colisões e lógica de pontuação.

Instalação da Biblioteca

Para instalar o Pygame, utilize o gerenciador de pacotes pip com o seguinte comando no terminal:

pip install pygame

Módulos Principais do Pygame

O Pygame oferece diversos módulos para funcionalidades específicas:

• pygame.display: Controla a janela de exibição.
• pygame.image: Carrega e salva imagens.
• pygame.event: Processa eventos como teclado e mouse.
• pygame.draw: Renderiza primitivas gráficas.
• pygame.sprite: Gerencia sprites para objetos do jogo.
• pygame.mixer: Reproduz áudio.
• pygame.font: Renderiza texto.
• pygame.time: Controla temporização e taxas de quadros.

Exemplo Básico de Aplicação

Abaixo, um código simples que abre uma janela e desenha um círculo animado:

import pygame
import sys

# Configuração inicial
pygame.init()
janela = pygame.display.set_mode((800, 600))
pygame.display.set_caption("Exemplo Pygame Básico")

# Variáveis de controle
rodando = True
pos_x = 400
velocidade_x = 3
cor_fundo = (30, 30, 30)
cor_circulo = (0, 200, 150)

while rodando:
    for evento in pygame.event.get():
        if evento.type == pygame.QUIT:
            rodando = False

    # Atualizar posição
    pos_x += velocidade_x
    if pos_x > 780 or pos_x < 20:
        velocidade_x *= -1

    # Desenhar na tela
    janela.fill(cor_fundo)
    pygame.draw.circle(janela, cor_circulo, (pos_x, 300), 30)
    pygame.display.flip()
    pygame.time.delay(16)

pygame.quit()
sys.exit()

Etapas de Desenvolvimento de um Jogo

O processo de criação de jogos gearlmente envolve:

• Conceituação: Definir mecânicas e objetivos.
• Design: Planejar interfaces, personagens e regras.
• Implementação: Codificar a lógica e os elementos visuais.
• Teste: Verificar funcionalidade e desempenho.
• Distribuição: Empacotar e lançar o jogo.

Análise para um Jogo Estilo Flappy Bird

Para criar um clone simplificado, considere:

• Controle do jogador: tecla de espaço para impulsionar o pássaro.
• Física: gravidade constante puxando o objeto para baixo.
• Obstáculos: tubos gerados aleatoriamente com aberturas variáveis.
• Pontuação: incremento ao atravessar cada tubo.
• Colisões: detecção contra tubos e limites da tela.

Estrutura Principal do Jogo

Inicialize o Pygame, configure a janela e implemente o loop principal:

import pygame
import sys
import random

pygame.init()
tela = pygame.display.set_mode((800, 600))
pygame.display.set_caption("Clone Flappy Bird")
relogio = pygame.time.Clock()
fps = 60

# Definição de cores
BRANCO = (255, 255, 255)
PRETO = (10, 10, 10)
VERDE_ESCURO = (0, 180, 60)

# Loop principal
executando = True
while executando:
    for evento in pygame.event.get():
        if evento.type == pygame.QUIT:
            executando = False

    tela.fill(PRETO)
    pygame.display.flip()
    relogio.tick(fps)

pygame.quit()
sys.exit()

Criação da Classe Pássaro

Defina uma classe para o pássaro com propriedades de movimentação física:

class Passaro:
    def __init__(self, coordenada_x, coordenada_y):
        self.pos_x = coordenada_x
        self.pos_y = coordenada_y
        self.velocidade_y = 0
        self.gravidade = 0.6
        self.impulso = -12
        self.superficie = pygame.Surface((40, 40))
        self.superficie.fill(BRANCO)
        self.retangulo = self.superficie.get_rect(center=(coordenada_x, coordenada_y))

    def atualizar(self):
        self.velocidade_y += self.gravidade
        self.pos_y += self.velocidade_y
        self.retangulo.centery = self.pos_y

    def saltar(self):
        self.velocidade_y = self.impulso

    def desenhar(self, tela):
        tela.blit(self.superficie, self.retangulo)

Criação da Classe Tubo

Implemente os obstáculos como tubos com uma abertura fixa ou variável:

class Tubo:
    def __init__(self, posicao_x, abertura=150, largura_abertura=100):
        self.posicao_x = posicao_x
        self.abertura = abertura
        self.largura_abertura = largura_abertura
        self.tubo_superior = pygame.Surface((40, self.abertura))
        self.tubo_inferior = pygame.Surface((40, 600 - self.abertura - self.largura_abertura))
        self.tubo_superior.fill(VERDE_ESCURO)
        self.tubo_inferior.fill(VERDE_ESCURO)
        self.rect_sup = self.tubo_superior.get_rect(topleft=(posicao_x, 0))
        self.rect_inf = self.tubo_inferior.get_rect(topleft=(posicao_x, self.abertura + self.largura_abertura))

    def atualizar(self):
        self.posicao_x -= 2.5
        self.rect_sup.x = self.posicao_x
        self.rect_inf.x = self.posicao_x

    def desenhar(self, tela):
        tela.blit(self.tubo_superior, self.rect_sup)
        tela.blit(self.tubo_inferior, self.rect_inf)

Implemantação da Pontuação

Adicione um sistema de pontuação exibido na tela durante o jogo:

pontuacao = 0
fonte_pontuacao = pygame.font.Font(None, 40)

def mostrar_pontuacao(tela, pontos):
    texto = fonte_pontuacao.render(f"Pontos: {pontos}", True, BRANCO)
    tela.blit(texto, (15, 15))

Detecção de Colisões

Crie uma função para verificar colisões entre o pássaro e os tubos ou bordas da tela:

def verificar_colisao(passaro, lista_tubos):
    for tubo in lista_tubos:
        if passaro.retangulo.colliderect(tubo.rect_sup) or passaro.retangulo.colliderect(tubo.rect_inf):
            return True
    if passaro.retangulo.top <= 0 or passaro.retangulo.bottom >= 600:
        return True
    return False

Exemplo Completo Integrado

Combine todas as partes em um jogo funcional:

import pygame
import sys
import random

# Inicialização
pygame.init()
tela = pygame.display.set_mode((800, 600))
pygame.display.set_caption("Jogo Flappy Bird Simples")
relogio = pygame.time.Clock()
fps = 60

# Cores
BRANCO = (255, 255, 255)
PRETO = (10, 10, 10)
VERDE_ESCURO = (0, 180, 60)

# Fonte
fonte = pygame.font.Font(None, 40)

# Classes
class Passaro:
    def __init__(self, x, y):
        self.x = x
        self.y = y
        self.velocidade = 0
        self.gravidade = 0.5
        self.impulso = -11
        self.imagem = pygame.Surface((35, 35))
        self.imagem.fill(BRANCO)
        self.rect = self.imagem.get_rect(center=(x, y))

    def atualizar(self):
        self.velocidade += self.gravidade
        self.y += self.velocidade
        self.rect.centery = self.y

    def saltar(self):
        self.velocidade = self.impulso

    def desenhar(self, superficie):
        superficie.blit(self.imagem, self.rect)

class Tubo:
    def __init__(self, x, abertura=140, gap=110):
        self.x = x
        self.abertura = abertura
        self.gap = gap
        self.tubo_sup = pygame.Surface((40, self.abertura))
        self.tubo_inf = pygame.Surface((40, 600 - self.abertura - self.gap))
        self.tubo_sup.fill(VERDE_ESCURO)
        self.tubo_inf.fill(VERDE_ESCURO)
        self.rect_sup = self.tubo_sup.get_rect(topleft=(x, 0))
        self.rect_inf = self.tubo_inf.get_rect(topleft=(x, self.abertura + self.gap))

    def atualizar(self):
        self.x -= 3
        self.rect_sup.x = self.x
        self.rect_inf.x = self.x

    def desenhar(self, superficie):
        superficie.blit(self.tubo_sup, self.rect_sup)
        superficie.blit(self.tubo_inf, self.rect_inf)

def checar_colisao(passaro, tubos):
    for tubo in tubos:
        if passaro.rect.colliderect(tubo.rect_sup) or passaro.rect.colliderect(tubo.rect_inf):
            return True
    if passaro.rect.top <= 0 or passaro.rect.bottom >= 600:
        return True
    return False

# Função principal
def jogo():
    global pontuacao
    pontuacao = 0
    ave = Passaro(150, 300)
    lista_tubos = []
    intervalo_tubos = 250
    contador_frames = 0

    rodando = True
    while rodando:
        for evento in pygame.event.get():
            if evento.type == pygame.QUIT:
                rodando = False
            if evento.type == pygame.KEYDOWN and evento.key == pygame.K_SPACE:
                ave.saltar()

        # Atualizar lógica
        ave.atualizar()
        contador_frames += 1

        # Gerar novos tubos
        if contador_frames % intervalo_tubos == 0:
            alt_abertura = random.randint(100, 400)
            lista_tubos.append(Tubo(800, alt_abertura))
            pontuacao += 1

        # Atualizar tubos
        for tubo in lista_tubos:
            tubo.atualizar()

        # Remover tubos fora da tela
        lista_tubos = [t for t in lista_tubos if t.x > -50]

        # Verificar colisões
        if checar_colisao(ave, lista_tubos):
            print(f"Fim de jogo! Pontuação: {pontuacao}")
            break

        # Desenhar
        tela.fill(PRETO)
        ave.desenhar(tela)
        for tubo in lista_tubos:
            tubo.desenhar(tela)

        # Mostrar pontuação
        texto = fonte.render(f"Pontos: {pontuacao}", True, BRANCO)
        tela.blit(texto, (15, 15))

        pygame.display.flip()
        relogio.tick(fps)

    pygame.quit()
    sys.exit()

if __name__ == "__main__":
    jogo()