Jogo de Corrida com Pygame

Introdução

Neste projeto, você aprenderá como criar um jogo de corrida simples usando a biblioteca Pygame. O jogo envolve um carro do jogador e vários carros inimigos. O carro do jogador pode ser movido para a esquerda e para a direita usando as setas do teclado, enquanto os carros inimigos se movem para baixo na tela. O objetivo é evitar colisões com os carros inimigos o maior tempo possível. O jogo exibirá uma tela de "Game Over" quando uma colisão ocorrer e permitirá que o jogador reinicie o jogo pressionando a tecla "R".

👀 Pré-visualização

🎯 Tarefas

Neste projeto, você aprenderá:

• Como configurar a janela do jogo e importar as bibliotecas necessárias
• Como definir cores e carregar imagens de carros
• Como definir o carro do jogador
• Como definir os carros inimigos
• Como definir variáveis de "Game Over" e fonte
• Como implementar a lógica do jogo
• Como exibir a tela de "Game Over"
• Como sair do jogo

🏆 Conquistas

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

• Usar a biblioteca Pygame para criar uma janela de jogo
• Carregar e exibir imagens em um jogo
• Lidar com colisões entre objetos do jogo
• Implementar um loop de jogo para jogabilidade contínua
• Lidar com a entrada do usuário para controlar objetos do jogo
• Exibir texto na tela usando o módulo de fonte do Pygame

Criar os arquivos do projeto

1. Crie um novo arquivo chamado racing_game.py.

cd ~/project
touch racing_game.py

Configurar a janela do jogo e importar as bibliotecas necessárias

import pygame
import random

## Initialize Pygame
pygame.init()

## Set up the game window
window_width = 800
window_height = 600
window = pygame.display.set_mode((window_width, window_height))
pygame.display.set_caption("Racing Game")

Nesta etapa, importamos a biblioteca pygame e a inicializamos. Em seguida, configuramos a janela do jogo com uma largura de 800 pixels e uma altura de 600 pixels. Também definimos o título da janela como "Racing Game".

Instale a biblioteca pygame executando o seguinte comando no terminal:

sudo pip install pygame

Definir cores e carregar imagens de carros

## Define colors
background_color = (30, 30, 30)
player_car_color = (255, 255, 255)
enemy_car_color = (255, 0, 0)
text_color = (255, 255, 255)

## Load car images
player_car_img = pygame.image.load("player_car.png").convert_alpha()
enemy_car_img = pygame.image.load("enemy_car.png").convert_alpha()

Nesta etapa, definimos algumas cores usadas no jogo: background_color, player_car_color, enemy_car_color e text_color. Também carregamos as imagens para o carro do jogador e o carro inimigo usando a função pygame.image.load().

As imagens player_car.png e enemy_car.png estão incluídas no diretório ~/project.

Definir o carro do jogador

## Define the player car
player_car_width = player_car_img.get_width()
player_car_height = player_car_img.get_height()
player_car_x = window_width // 2 - player_car_width // 2
player_car_y = window_height - player_car_height - 10
player_car_speed = 5

Nesta etapa, definimos as propriedades do carro do jogador: player_car_width e player_car_height são definidos para as dimensões da imagem do carro do jogador. player_car_x e player_car_y representam a posição inicial do carro do jogador na tela. player_car_speed determina a velocidade com que o carro do jogador pode se mover.

Definir os carros inimigos

## Define the enemy cars
enemy_cars = []
num_enemy_cars = 3
enemy_car_width = 80
enemy_car_height = 160
for _ in range(num_enemy_cars):
    enemy_car_x = random.randint(0, window_width - enemy_car_width)
    enemy_car_y = random.randint(-window_height, -enemy_car_height)
    enemy_car_speed = random.randint(2, 5)
    enemy_cars.append({"x": enemy_car_x, "y": enemy_car_y, "speed": enemy_car_speed})

Nesta etapa, definimos as propriedades dos carros inimigos: enemy_cars é uma lista que armazenará os objetos dos carros inimigos. num_enemy_cars determina o número de carros inimigos no jogo. enemy_car_width e enemy_car_height representam as dimensões da imagem do carro inimigo. Usamos um loop para gerar posições e velocidades aleatórias para cada carro inimigo e adicioná-los à lista enemy_cars.

Definir variáveis e fonte de 'Game Over'

## Define game over variables
game_over = False
font = pygame.font.Font(None, 50)
game_over_text = font.render("Game Over", True, text_color)
restart_text = font.render("Press R to Restart", True, text_color)

Nesta etapa, definimos as variáveis relacionadas à tela de "Game Over": game_over é uma variável booleana que indica se o jogo acabou ou não. font é um objeto de fonte Pygame com um tamanho de 50. Renderizamos o texto "Game Over" e o texto "Press R to Restart" usando a fonte e os armazenamos nas variáveis game_over_text e restart_text.

Loop do jogo

## Game loop
running = True
clock = pygame.time.Clock()

while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False
        if event.type == pygame.KEYDOWN:
            if event.key == pygame.K_r and game_over:
                game_over = False
                player_car_x = window_width // 2 - player_car_width // 2
                player_car_y = window_height - player_car_height - 10
                for enemy_car in enemy_cars:
                    enemy_car["x"] = random.randint(0, window_width - enemy_car_width)
                    enemy_car["y"] = random.randint(-window_height, -enemy_car_height)

    if not game_over:
        ## Game logic code goes here...

        ## Refresh the window
        window.fill(background_color)
        window.blit(player_car_img, (player_car_x, player_car_y))
        for enemy_car in enemy_cars:
            window.blit(enemy_car_img, (enemy_car["x"], enemy_car["y"]))
    else:
        ## Game over screen code goes here...

    pygame.display.update()
    clock.tick(60)

Nesta etapa, configuramos o loop do jogo usando um loop while. O loop é executado enquanto a variável running for True. Lidamos com os eventos, como sair do jogo e reiniciá-lo, verificando os tipos de eventos e as teclas. Quando o jogo não acabou, o código dentro do bloco if not game_over é executado, o qual inclui a lógica do jogo e o desenho do carro do jogador e dos carros inimigos na tela. Quando o jogo termina, o código dentro do bloco else é executado, que exibe a tela de "Game Over". Finalmente, atualizamos a tela e definimos a taxa de quadros para 60 quadros por segundo.

Código da lógica do jogo

if not game_over:
    ## Move the player car
    keys = pygame.key.get_pressed()
    if keys[pygame.K_LEFT] and player_car_x > player_car_speed:
        player_car_x -= player_car_speed
    if (
        keys[pygame.K_RIGHT]
        and player_car_x < window_width - player_car_width - player_car_speed
    ):
        player_car_x += player_car_speed

    ## Move the enemy cars
    for enemy_car in enemy_cars:
        enemy_car["y"] += enemy_car["speed"]
        if enemy_car["y"] > window_height:
            enemy_car["x"] = random.randint(0, window_width - enemy_car_width)
            enemy_car["y"] = random.randint(-window_height, -enemy_car_height)
            enemy_car["speed"] = random.randint(2, 5)

        ## Check for collision
        if player_car_y < enemy_car["y"] + enemy_car_height:
            if (
                player_car_x < enemy_car["x"] + enemy_car_width
                and player_car_x + player_car_width > enemy_car["x"]
            ):
                game_over = True

Nesta etapa, implementamos o código da lógica do jogo dentro do loop do jogo. Verificamos a entrada do usuário para mover o carro do jogador para a esquerda e para a direita. Atualizamos as posições dos carros inimigos e verificamos se alguma colisão ocorreu entre o carro do jogador e os carros inimigos. Se uma colisão ocorrer, definimos a variável game_over como True.

Código da tela de Game Over

else:
    ## Game over screen
    window.fill(background_color)
    game_over_rect = game_over_text.get_rect(
        center=(window_width // 2, window_height // 2 - 50)
    )
    restart_rect = restart_text.get_rect(
        center=(window_width // 2, window_height // 2 + 50)
    )
    window.blit(game_over_text, game_over_rect)
    window.blit(restart_text, restart_rect)

Nesta etapa, implementamos o código da tela de "Game Over" dentro do loop do jogo. Exibimos o texto de "Game Over" e o texto de reinício na tela usando a função window.blit(). O texto é centralizado na tela usando as propriedades get_rect() e center.

Sair do jogo

## Quit the game
pygame.quit()

Nesta etapa final, saímos do jogo e fechamos a janela do Pygame quando o loop do jogo termina.

Agora, você pode executar o jogo usando o seguinte comando:

python racing_game.py

Resumo

Parabéns! Você criou com sucesso um jogo de corrida simples usando a biblioteca Pygame. O jogo inclui um carro do jogador que pode ser movido para a esquerda e para a direita, bem como vários carros inimigos. O objetivo é evitar colisões com os carros inimigos pelo maior tempo possível. O jogo também apresenta uma tela de "Game Over" e a capacidade de reiniciar o jogo pressionando a tecla "R". Continue praticando e experimentando para aprimorar suas habilidades de desenvolvimento de jogos.