Introdução#

Instalação#

Nas aulas de Python básico só usamos pacotes que já estão inclusos na instalação padrão. A pygame é uma biblioteca extra desenvolvida por um grupo diferente de pessoas e precisa ser instalada manualmente.

Instalamos bibliotecas externas com o comando pip. Abra o terminal do seu VSCode e digite o seguinte comando.

pip install pygame

Verifique se tudo está correto executando o programa jogo.py (que foi aberto pelo exercício deste handout). Ao executá-lo o terminal não deverá mostrar nenhuma mensagem, mas também não deve ocorrer nenhum erro.

Traceback (most recent call last):
File "jogo.py", line 1,
ModuleNotFoundError: No module named 'pygame'

Com o ambiente configurado vamos iniciar a atividade prática de hoje.

Criando uma janela#

Para criar uma janela com Pygame precisamos implementar todas aquelas etapas da organização básica do jogo que vimos acima. Ou seja, será necessário utilizarmos muitos comandos para fazer coisas aparentemente simples, como mostrar uma janela em branco. Não se assuste. Essa estrutura básica se repete de maneira muito semelhante em qualquer jogo que você for desenvolver. Vamos começar então com o exemplo que acabamos de comentar: como mostrar uma janela do pygame.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

# ===== Inicialização =====
# ----- Importa e inicia pacotes
import pygame

pygame.init()

# ----- Gera tela principal
window = pygame.display.set_mode((500, 400))
pygame.display.set_caption('Hello World!')

# ----- Inicia estruturas de dados
game = True

# ===== Loop principal =====
while game:
    # ----- Trata eventos
    for event in pygame.event.get():
        # ----- Verifica consequências
        if event.type == pygame.QUIT:
            game = False

    # ----- Gera saídas
    window.fill((255, 255, 255))  # Preenche com a cor branca

    # ----- Atualiza estado do jogo
    pygame.display.update()  # Mostra o novo frame para o jogador

# ===== Finalização =====
pygame.quit()  # Função do PyGame que finaliza os recursos utilizados

Para entender melhor este código extenso iremos separá-lo nas partes da estrutura básica que mostramos no início. Ou seja, nos próximos exercícios iremos criar as seguintes funções:

• inicializa: inicializa pygame e recursos necessários para o jogo
• desenha: atualiza a tela, desenhando figuras e escrevendo texto na tela
• recebe_eventos: recebe interação do usuário
• gameloop: roda até que o jogador feche o jogo. Chama as funções desenha e recebe_eventos.
• finaliza: finaliza a pygame e salva possíveis resultados do jogo.

Nossas próximas atividades de pygame estarão organizadas usando estas funções.

A etapa de inicialização consiste em configurar a pygame, definindo o tamanho da janela desejada e seu título. As linhas onde isto é feito são apontadas abaixo.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

# ===== Inicialização =====
# ----- Importa e inicia pacotes
import pygame

pygame.init()

# ----- Gera tela principal
window = pygame.display.set_mode((500, 400))
pygame.display.set_caption('Hello World!')

# ----- Inicia estruturas de dados
game = True

# ===== Loop principal =====
while game:
    # ----- Trata eventos
    for event in pygame.event.get():
        # ----- Verifica consequências
        if event.type == pygame.QUIT:
            game = False

    # ----- Gera saídas
    window.fill((255, 255, 255))  # Preenche com a cor branca

    # ----- Atualiza estado do jogo
    pygame.display.update()  # Mostra o novo frame para o jogador

# ===== Finalização =====
pygame.quit()  # Função do PyGame que finaliza os recursos utilizados

• pygame.init() (linha 5): o framework pygame é iniciado. Apenas após este comando é que os recursos do pygame podem ser utilizados;
• pygame.display.set_mode((500, 400)) (linha 8): cria uma janela com 500 pixels de largura e 400 pixels de altura;
• pygame.display.set_caption('Hello World!') (linha 9): define o título da janela (que aparece na barra superior) como o texto 'Hello World!';

Como só mostramos uma janela simples não fazemos muito por aqui, mas tarefas comuns nesta seção são

• carregar imagens, sons e outros recursos necessários;
• definir os valores iniciais de todas as variáveis do jogo

Vamos iniciar nossa versão "organizada" deste código agora.

Vamos agora para nossa função de tratamento de eventos. As linhas que fazem este trabalho estão explicadas abaixo.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

# ===== Inicialização =====
# ----- Importa e inicia pacotes
import pygame

pygame.init()

# ----- Gera tela principal
window = pygame.display.set_mode((500, 400))
pygame.display.set_caption('Hello World!')

# ----- Inicia estruturas de dados
game = True

# ===== Loop principal =====
while game:
    # ----- Trata eventos
    for event in pygame.event.get():
        # ----- Verifica consequências
        if event.type == pygame.QUIT:
            game = False

    # ----- Gera saídas
    window.fill((255, 255, 255))  # Preenche com a cor branca

    # ----- Atualiza estado do jogo
    pygame.display.update()  # Mostra o novo frame para o jogador

# ===== Finalização =====
pygame.quit()  # Função do PyGame que finaliza os recursos utilizados

• for event in pygame.event.get(): (linha 17): pygame.event.get() devolve uma lista com todos os eventos (cliques/movimentos de mouse, teclas apertadas, botões da janela apertados, etc.) que ocorreram desde a última vez que essa função foi chamada. O for percorre cada um desses eventos, aplicando as consequências necessárias a cada caso;
• if event.type == pygame.QUIT: (linha 19): verifica se o tipo do evento é pygame.QUIT, ou seja, se o usuário clicou no botão de fechar a janela (consulte a documentação para ver mais eventos possíveis);
• game = False (linha 20): muda o valor para False para que a próxima iteração do loop principal não seja mais executada. Depois disso o programa termina;

Agora vamos trabalhar com a função de desenho. Vejamos quais linhas do jogo_v0.py desenham na tela.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

# ===== Inicialização =====
# ----- Importa e inicia pacotes
import pygame

pygame.init()

# ----- Gera tela principal
window = pygame.display.set_mode((500, 400))
pygame.display.set_caption('Hello World!')

# ----- Inicia estruturas de dados
game = True

# ===== Loop principal =====
while game:
    # ----- Trata eventos
    for event in pygame.event.get():
        # ----- Verifica consequências
        if event.type == pygame.QUIT:
            game = False

    # ----- Gera saídas
    window.fill((255, 255, 255))  # Preenche com a cor branca

    # ----- Atualiza estado do jogo
    pygame.display.update()  # Mostra o novo frame para o jogador

# ===== Finalização =====
pygame.quit()  # Função do PyGame que finaliza os recursos utilizados

• window.fill((255, 255, 255)) (linha 23): preenche a janela com a cor branca. As cores são valores RGB (Red, Green, Blue) que variam entre 0 e 255. Note que existe um parênteses ao redor dos três valores. Esse parênteses é muito importante, pois define uma tupla (uma sequência de valores, semelhante a uma lista);
• pygame.display.update() (linha 26): tudo o que é feito na tela (window) não é mostrado para o usuário imediatamente, assim é possível desenhar várias coisas e somente depois de terminar de desenhar mostramos a nova tela (ou frame) para o usuário. Essa função é responsável por mostrar a nova tela que foi desenhada;

Para fazer o próximo exercício você deverá consultar a documentação da função fill() neste link. Com ela em mãos, clique em continuar

A variável window é do tipo pygame.Surface, que representa um superfície 2D que pode ser desenhada na tela. A função fill preenche a tela toda com a cor passada. Do jeito que chamamos ela recebe só um argumento, mas a documentação mostra ela recebendo três!

Esse parâmetros extra possuem valores padrão, então podemos não passá-los e eles receberão o valor declarado. Vamos agora interpretar isso.

Agora consulte a documentação de pygame.Rect para descobrir como construir retângulos válidos.

Vamos juntar tudo agora.

Nossas duas últimas tarefas são implementar as funções de loop do jogo e de finalização.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

# ===== Inicialização =====
# ----- Importa e inicia pacotes
import pygame

pygame.init()

# ----- Gera tela principal
window = pygame.display.set_mode((500, 400))
pygame.display.set_caption('Hello World!')

# ----- Inicia estruturas de dados
game = True

# ===== Loop principal =====
while game:
    # ----- Trata eventos
    for event in pygame.event.get():
        # ----- Verifica consequências
        if event.type == pygame.QUIT:
            game = False

    # ----- Gera saídas
    window.fill((255, 255, 255))  # Preenche com a cor branca

    # ----- Atualiza estado do jogo
    pygame.display.update()  # Mostra o novo frame para o jogador

# ===== Finalização =====
pygame.quit()  # Função do PyGame que finaliza os recursos utilizados

O loop do jogo é feito entre as linhas 12 e 26. Note que boa parte desse código já está contido nas funções recebe_eventos e desenha. Falta só chamá-las em loop enquanto o jogo não for fechado.

A finalização do jogo é feita pela função pygame.quit() (linha 29). É importante chamar essa função para que ele feche todos os recursos que abriu (por exemplo a janela).

Agora todos os testes devem estar passando. Vamos então criar a função que vai realmente rodar nosso jogo! Ela se chamará roda_jogo e deverá ser escrita usando as funções que vocês já escreveram. Lembre-se a organização do jogo, em que primeiro inicializamos os recursos, depois rodamos o loop do jogo e por último finalizamos o pygame.

if __name__ == '__main__':
    roda_jogo()

Para finalizar esse exercício, execute seu jogo e veja se o resultado foi o esperado. Você deverá ver uma tela retangular com título "Jogo do ...." e um fundo vermelho.