Fase 2 8 horas Básico

# A Curva da Paineira

A Paineira exigia embalo: velocidade acumulada antes da curva. Aqui você aprende Pygame — e o jogo Pong nasce na pista.

Progresso: 0/10 (0%)

## Objetivos da Fase

#### O que você vai aprender:

- Instalação e configuração do Pygame
- Sistema de coordenadas e janela gráfica
- Loop principal do jogo (game loop)
- Eventos de teclado e mouse
- Detecção de colisões com `Rect`
- FPS e controle de velocidade
- Classes Python aplicadas a objetos do jogo

#### O que você vai criar:

- Uma janela Pygame funcional com fundo verde-pista
- Uma bola que se move e rebate nas paredes
- Duas raquetes controladas por teclado
- Placar de pontos em tempo real
- O jogo Pong da Pista completo

## 2.1 — O Embalo da Paineira

Na pista de Palotina, a Paineira era a curva mais temida. Para virá-la sem cair, o piloto precisava de embalo: velocidade acumulada metros antes. No Pygame, o embalo é o loop principal — ele roda 60 vezes por segundo, acumulando frames, atualizando posições e redesenhando a tela.

#### 🏁 Metáfora do loop

Cada frame é uma pedalada. O loop não para enquanto o jogo estiver rodando — assim como o piloto não para de pedalar enquanto está no circuito. `clock.tick(60)` = 60 pedaladas por segundo.

    # Estrutura base do game loop — a "pedalada" do Pygame
    import pygame

    pygame.init()
    tela = pygame.display.set_mode((800, 600))
    pygame.display.set_caption("Circuito Ferradura — Pong da Pista")
    clock = pygame.time.Clock()
    rodando = True

    while rodando:
        # 1. Eventos (o piloto olha para a pista)
        for evento in pygame.event.get():
            if evento.type == pygame.QUIT:
                rodando = False

        # 2. Lógica (calcular velocidade e posição)
        bola.mover()
        bola.verificar_colisao(raquete_esq, raquete_dir)

        # 3. Desenho (o piloto entra na curva)
        tela.fill((26, 122, 60))   # verde-pista
        bola.desenhar(tela)
        pygame.display.flip()

        clock.tick(60)   # 60 FPS = 60 pedaladas/segundo

## 2.2 — Colisões: a Física da Pista

A bola rebate nas paredes e nas raquetes. A física é simples: quando a bola toca uma borda, o sinal da velocidade se inverte. Isso é a programação da curva da Paineira: o piloto dobra a direção.

    # Classe Bola — objeto com estado e comportamento
    class Bola:
        def __init__(self):
            self.x, self.y = 400, 300
            self.vx, self.vy = 5, 5
            self.raio = 10

        def mover(self):
            self.x += self.vx
            self.y += self.vy

            # Rebater nas paredes superior e inferior
            if (
                self.y - self.raio <= 0
                or self.y + self.raio >= 600
            ):
                self.vy *= -1  # inverte — a curva da Paineira

## ✅ Checklist da Fase 2

Instalei Pygame e criei a janela verde-pista 800×600
Implementei o game loop com `clock.tick(60)`
Criei a classe `Bola` com `mover()` e `desenhar()`
Fiz a bola rebater nas 4 paredes corretamente
Criei a classe `Raquete` controlada pelo teclado
Implementei colisão bola-raquete com `pygame.Rect.colliderect()`
Adicionei placar com `pygame.font`
Criei tela de game over ao atingir 5 pontos
O jogo Pong da Pista está completo e jogável
Fiz code review: meu código tem funções, classes e comentários

#### 🏎 Projeto da Fase 2

Crie o jogo Pong da Pista completo: duas raquetes, uma bola, placar, rebatimento nas paredes e detecção de ponto. Use as cores do Circuito Ferradura: verde-pista `#1a7a3c` e amarelo-palotina `#f4c430`.

🔒 LGPD — Usamos localStorage para salvar progresso. Política de Privacidade.