Projeto - Criando um Jogo Simples de 'Coleta' com Pygame Zero 🎮

Olá, futuros desenvolvedores de jogos! 👋 Sejam bem-vindos ao nosso primeiro projeto completo em Pygame Zero! 🎉

Nesta aula, vamos colocar em prática tudo o que aprendemos até agora para construir um jogo simples e divertido de 'coleta'. Nosso objetivo é criar um jogo onde um personagem (o jogador) se move pela tela para coletar itens, ganhando pontos a cada coleta.

Este projeto é uma excelente maneira de consolidar seus conhecimentos sobre:

• Actor: Como criar e manipular personagens e objetos.
• draw(): Como desenhar elementos na tela.
• update(): Como implementar a lógica do jogo, como movimento e detecção de colisão.
• Entrada do Usuário: Como fazer o jogador controlar o personagem usando o teclado.
• Lógica de Jogo: Como gerenciar pontuação e estados dos objetos.

Vamos mergulhar de cabeça e criar nosso próprio jogo! 🚀

1. Introdução ao Projeto: O Jogo de Coleta 🍎

Imagine que você é um pequeno explorador em busca de frutas mágicas. Seu objetivo é coletar o máximo de frutas possível antes que o tempo acabe (ou apenas coletar sem parar, por enquanto!).

Nosso jogo terá:

• Um jogador controlável pelo teclado.
• Um item coletável (uma fruta, por exemplo) que aparece em posições aleatórias.
• Um contador de pontos que aumenta a cada item coletado.
• A lógica para o item desaparecer e reaparecer após ser coletado.

Pronto para começar? Pegue sua IDE (Ambiente de Desenvolvimento Integrado) e vamos codificar! 💻

2. Configuração Inicial do Jogo 🛠️

Todo jogo Pygame Zero começa com algumas configurações básicas. Vamos definir o tamanho da tela, o título e carregar as imagens que usaremos.

Importante: Para este projeto, você precisará de duas imagens simples:

1. player.png (para o jogador)
2. collectible.png (para o item coletável)

Crie uma pasta chamada images no mesmo diretório do seu arquivo .py e coloque suas imagens lá. Você pode desenhar as suas próprias ou encontrar algumas bem simples na internet (certifique-se de que sejam pequenas, como 50x50 pixels).

# game.py
 
# 1. Configurações da Tela
WIDTH = 800  # Largura da tela em pixels
HEIGHT = 600 # Altura da tela em pixels
TITLE = "Coleta de Frutas Mágicas" # Título da janela do jogo
 
# Importar o módulo random para posicionamento aleatório
import random
 
# Definir a pontuação inicial
score = 0
 
# Cores (opcional, para texto ou fundo se não usar imagem)
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)
GREEN = (0, 255, 0)

Explicação:

• WIDTH e HEIGHT: Definem as dimensões da nossa janela de jogo.
• TITLE: O texto que aparecerá na barra de título da janela.
• import random: Precisaremos disso para fazer os itens coletáveis aparecerem em lugares aleatórios.
• score = 0: Inicializamos a pontuação do jogador.
• WHITE, BLACK, GREEN: São tuplas que representam cores no formato RGB. Úteis para desenhar texto ou preencher o fundo.

3. Criando o Jogador e o Item Coletável 🧑‍🚀🍎

Agora, vamos criar os nossos Actors para o jogador e o item. Lembre-se que um Actor precisa de um nome de imagem (que deve estar na pasta images).

# game.py (continue do código anterior)
 
# 2. Criando o Jogador
# O jogador será um Actor usando a imagem 'player.png'
# Ele começará no centro inferior da tela.
player = Actor("player")
player.pos = (WIDTH // 2, HEIGHT - 50) # Posição inicial: centro horizontal, perto da base
 
# 3. Criando o Item Coletável
# O item será um Actor usando a imagem 'collectible.png'
# Ele começará em uma posição aleatória.
collectible = Actor("collectible")
# A função place_collectible() será usada para posicionar o item aleatoriamente
def place_collectible():
    collectible.x = random.randint(50, WIDTH - 50) # Posição X aleatória
    collectible.y = random.randint(50, HEIGHT - 150) # Posição Y aleatória (evitando a parte inferior)
 
# Chame a função uma vez para posicionar o primeiro item
place_collectible()

Explicação:

• player = Actor("player"): Cria um objeto Actor chamado player usando a imagem player.png.
• player.pos = (WIDTH // 2, HEIGHT - 50): Define a posição inicial do jogador. WIDTH // 2 o coloca no centro horizontal, e HEIGHT - 50 o coloca a 50 pixels da borda inferior.
• collectible = Actor("collectible"): Cria um Actor para o item coletável.
• place_collectible(): Esta é uma função auxiliar que criamos para posicionar o item coletável em um local aleatório dentro dos limites da tela. Usamos random.randint() para gerar coordenadas X e Y.
• place_collectible(): Chamamos a função uma vez para garantir que o primeiro item já esteja na tela quando o jogo começar.

4. Desenhando na Tela (draw()) 🎨

A função draw() é onde tudo é desenhado na tela. Ela é chamada automaticamente várias vezes por segundo pelo Pygame Zero.

# game.py (continue do código anterior)
 
# 4. Função draw() - Desenhar todos os elementos na tela
def draw():
    screen.fill(BLACK) # Preenche a tela com a cor preta (ou qualquer outra cor/imagem de fundo)
 
    player.draw()       # Desenha o jogador
    collectible.draw()  # Desenha o item coletável
 
    # Desenha a pontuação na tela
    screen.draw.text(f"Pontuação: {score}", (10, 10), color=WHITE, fontsize=30)

Explicação:

• screen.fill(BLACK): Limpa a tela a cada frame, preenchendo-a com preto. Se você tivesse uma imagem de fundo, usaria screen.blit('background_image', (0,0)).
• player.draw(): Desenha o Actor do jogador em sua posição atual.
• collectible.draw(): Desenha o Actor do item coletável.
• screen.draw.text(...): Esta é uma função muito útil para exibir texto.
  • f"Pontuação: {score}": Usa uma f-string para formatar o texto com a pontuação atual.
  • (10, 10): As coordenadas (x, y) onde o texto começará a ser desenhado (canto superior esquerdo).
  • color=WHITE: Define a cor do texto.
  • fontsize=30: Define o tamanho da fonte.

5. Lógica do Jogo (update()) e Movimento do Jogador 🏃‍♀️

A função update() é onde a lógica do jogo acontece. Ela também é chamada automaticamente várias vezes por segundo. Aqui vamos:

1. Mover o jogador com base na entrada do teclado.
2. Verificar se o jogador colidiu com o item coletável.
3. Atualizar a pontuação e reposicionar o item se houver colisão.

# game.py (continue do código anterior)
 
# 5. Função update() - Lógica do jogo
PLAYER_SPEED = 5 # Velocidade do jogador
 
def update():
    global score # Precisamos usar 'global' para modificar a variável score
 
    # Movimento do Jogador
    if keyboard.left:
        player.x -= PLAYER_SPEED
    if keyboard.right:
        player.x += PLAYER_SPEED
    if keyboard.up:
        player.y -= PLAYER_SPEED
    if keyboard.down:
        player.y += PLAYER_SPEED
 
    # Limitar o jogador dentro da tela
    if player.left < 0:
        player.left = 0
    if player.right > WIDTH:
        player.right = WIDTH
    if player.top < 0:
        player.top = 0
    if player.bottom > HEIGHT:
        player.bottom = HEIGHT
 
    # Detecção de Colisão
    if player.colliderect(collectible):
        score += 1 # Aumenta a pontuação
        place_collectible() # Reposiciona o item coletável

Explicação:

• global score: Dentro de uma função, se você quiser modificar uma variável que foi definida fora dela (no escopo global), você precisa usar a palavra-chave global. Se você apenas lê a variável, não precisa.
• Movimento do Jogador: Pygame Zero facilita o acesso ao estado do teclado através do objeto keyboard. keyboard.left é True se a seta para a esquerda estiver sendo pressionada.
  • Alteramos as coordenadas x e y do jogador para movê-lo.
• Limitar o Jogador: As propriedades left, right, top, bottom de um Actor são muito úteis para verificar os limites.
  • Se o lado esquerdo do jogador for menor que 0 (saiu da tela pela esquerda), nós o ajustamos para 0. O mesmo para os outros lados.
• Detecção de Colisão:
  • player.colliderect(collectible): Este é um método super conveniente de Actor que verifica se o retângulo do player está se sobrepondo ao retângulo do collectible. Retorna True se houver colisão, False caso contrário.
  • Se houver colisão, score é incrementado e place_collectible() é chamado para mover o item para uma nova posição.

6. Código Completo do Projeto 🚀

Juntando todas as partes, aqui está o código completo para o nosso jogo de coleta!

# game.py
 
# --- 1. Configurações Iniciais ---
WIDTH = 800
HEIGHT = 600
TITLE = "Coleta de Frutas Mágicas"
 
import random
 
score = 0
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)
 
# --- 2. Criando o Jogador ---
player = Actor("player")
player.pos = (WIDTH // 2, HEIGHT - 50)
 
# --- 3. Criando o Item Coletável e Função de Posicionamento ---
collectible = Actor("collectible")
 
def place_collectible():
    collectible.x = random.randint(50, WIDTH - 50)
    collectible.y = random.randint(50, HEIGHT - 150) # Evita a parte inferior onde o player começa
    # Garante que o coletável não apareça muito perto do jogador no início
    if player.distance_to(collectible) < 100: # Se estiver muito perto, reposiciona
        place_collectible()
 
# Posiciona o primeiro item ao iniciar o jogo
place_collectible()
 
# --- 4. Função draw() - Desenhar todos os elementos na tela ---
def draw():
    screen.fill(BLACK) # Fundo preto
    player.draw()
    collectible.draw()
    screen.draw.text(f"Pontuação: {score}", (10, 10), color=WHITE, fontsize=30)
 
# --- 5. Função update() - Lógica do jogo e Movimento ---
PLAYER_SPEED = 5
 
def update():
    global score
 
    # Movimento do Jogador
    if keyboard.left:
        player.x -= PLAYER_SPEED
    if keyboard.right:
        player.x += PLAYER_SPEED
    if keyboard.up:
        player.y -= PLAYER_SPEED
    if keyboard.down:
        player.y += PLAYER_SPEED
 
    # Limitar o jogador dentro da tela
    if player.left < 0:
        player.left = 0
    if player.right > WIDTH:
        player.right = WIDTH
    if player.top < 0:
        player.top = 0
    if player.bottom > HEIGHT:
        player.bottom = HEIGHT
 
    # Detecção de Colisão
    if player.colliderect(collectible):
        score += 1
        place_collectible() # Reposiciona o item

Para rodar este jogo, salve o código como game.py (ou qualquer outro nome com .py) e certifique-se de ter as imagens player.png e collectible.png dentro de uma pasta images no mesmo diretório.

Abra seu terminal, navegue até o diretório onde salvou o arquivo e execute:

pgzrun game.py

Divirta-se jogando seu primeiro jogo de coleta! 🎉

7. Desafios e Próximos Passos (Exercícios) 💡

Parabéns por criar seu primeiro jogo completo! Mas a jornada de um desenvolvedor nunca para. Aqui estão alguns desafios e ideias para você expandir e melhorar seu jogo:

Lista de Tarefas do Projeto:

• Configuração inicial do jogo (tela, título, variáveis).
• Criação do Actor do jogador.
• Criação do Actor do item coletável.
• Função para posicionar o item coletável aleatoriamente.
• Desenho de todos os elementos na tela (draw()).
• Movimento do jogador usando o teclado (update()).
• Limitação do jogador dentro dos limites da tela.
• Detecção de colisão entre jogador e item.
• Aumento da pontuação e reposicionamento do item após a coleta.
• Exibição da pontuação na tela.

Desafios para Você:

1. Adicionar um Temporizador:
   • Crie uma variável time_left (tempo restante), por exemplo, 30 segundos.
   • Em update(), diminua time_left gradualmente (você pode usar clock.schedule_interval para isso, chamando uma função que diminui o tempo a cada segundo).
   • Exiba o tempo restante na tela.
   • Quando time_left chegar a 0, pare o jogo e exiba "Game Over!".
2. Múltiplos Itens Coletáveis:
   • Em vez de um único Actor para o item, crie uma lista de Actors (ex: collectibles = []).
   • Adicione vários itens à lista no início do jogo.
   • Modifique a lógica de colisão para verificar cada item na lista. Quando um item é coletado, remova-o da lista e adicione um novo, ou apenas reposicione-o.
3. Diferentes Tipos de Itens:
   • Crie itens que valem mais pontos ou que dão bônus (ex: um item que aumenta a velocidade do jogador temporariamente).
   • Isso exigirá diferentes imagens e talvez diferentes lógicas de colisão.
4. Sons do Jogo:
   • Adicione um som quando um item é coletado (sounds.collect.play(), se você tiver um arquivo collect.ogg ou collect.wav na pasta sounds).
   • Adicione uma música de fundo.
5. Tela de Início e Fim:
   • Crie diferentes "estados" para o jogo (ex: GAME_STATE = "MENU", GAME_STATE = "PLAYING", GAME_STATE = "GAME_OVER").
   • Modifique draw() e update() para exibir diferentes coisas e ter diferentes lógicas dependendo do GAME_STATE. Por exemplo, uma tela de menu com um botão "Iniciar" e uma tela de "Game Over" com a pontuação final.
6. Obstáculos:
   • Adicione Actors que o jogador deve evitar. Se colidir, perde pontos ou o jogo acaba.

8. Resumo e Próximos Passos 🌟

Parabéns! Você acaba de construir seu primeiro jogo completo de coleta com Pygame Zero! 🥳

Nesta aula, você:

• Reviu e aplicou conceitos essenciais como Actor, draw(), update().
• Implementou controle do jogador via teclado.
• Gerenciou a lógica de colisão e pontuação.
• Usou o módulo random para posicionar elementos dinamicamente.
• Exibiu texto na tela para feedback ao jogador.

Este projeto é a base para muitos outros jogos que você pode imaginar. A habilidade de quebrar um problema grande (criar um jogo) em partes menores e gerenciáveis é crucial na programação.

Continue experimentando com os desafios propostos. A melhor maneira de aprender é fazendo e modificando o código existente.

No próximo módulo, vamos explorar conceitos mais avançados e talvez até começar a pensar em como estruturar jogos maiores.

Até a próxima aula e divirta-se programando! ✨