Crie seu primeiro jogo de corrida: 10 etapas

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:38

Se você já fez alguma programação em Python e deseja escrever um jogo, pode ter encontrado no Pygame Zero.

Neste tutorial, escreveremos um jogo de corrida simples.

Etapa 1: A ampla visão geral

O módulo Pygame adiciona muitas funções que ajudam você a escrever jogos em Python.

O Pygame Zero vai um passo além para permitir que você ignore o complicado processo de fazer todos os loops do jogo e configurar a estrutura do programa.

Pygame Zero é uma ótima escolha para quem deseja começar a escrever jogos de computador no Raspberry Pi ou em qualquer máquina Linux.

Você precisará:

• Máquina que executa o sistema operacional Linux
• Editor para escrever programa python
• Teclado
• Alguma imaginação

Arquivos:

github.com/AhmNouira/-Racing-Game

Etapa 2: Pré-requisitos

Primeiro vou usar meu laptop com o sistema operacional Ubuntu 18.04. Em seguida, executaremos o jogo no Raspberry Pi na etapa 8.

Antes de continuar com este tutorial, certifique-se de estar conectado como um usuário com privilégios sudo.

Instalando o pip para Python 3

Comece atualizando a lista de pacotes usando o seguinte comando:

atualização do apt sudo

Use o seguinte comando para instalar o pip para Python 3:

sudo apt install python3-pip

verifique a instalação verificando a versão do pip:

pip3 - versão

Instalando Pygame Zero

pip3 install pgzero --user

Isso também instalará o Pygame. Pacotes Pygame pré-compilados

Portanto, a primeira etapa da sua jornada será abrir o Python 3 IDLE ou seu editor Python favorito.

Etapa 3: "Hello World" no Pygame Zero

Por padrão, a janela Pygame Zero abre no tamanho de 800 pixels de largura por 600 pixels de altura. Você pode personalizar

o tamanho de sua janela, existem duas variáveis predefinidas que você pode definir, se incluir WIDTH = 700 HIGH = 800.

O Pygame zero fornece funções predefinidas para lidar com o loop do jogo que normalmente executa:

A função draw ()

Podemos escrever essa função em nosso programa da mesma forma que normalmente definiríamos uma função em Python.

O Pygame Zero segue as mesmas regras de formatação do Python, portanto, você precisará ter cuidado para indentar seu código corretamente.

#! / usr / bin / python3 # definir o interpretador

import pgzrun # import pgzero module WIDTH = 700 # largura da janela HEIGHT = 800 # altura da janela def draw (): # pygame zero draw function screen.fill ((128, 128, 128)) # preencher a tela com RGB color screen.draw.text ("Hello World!", (270, 320), # draw "Hello World!" color = (255, 255, 255), fontsize = 40) pgzrun.go ()

Em primeiro lugar, você precisa salvar o arquivo do programa e dar um nome a ele.

Em seguida, abra uma janela do Terminal, vá até o local do arquivo e digite:

./.py

Etapa 4: desenhando seu ator

Agora que temos nosso cenário definido, podemos criar nossos Atores, eles são objetos dinâmicos no Pygame Zero.

Podemos carregar um ator digitando no topo do programa:

carro = Ator ("carro de corrida")

No Pygame Zero nossas imagens precisam ser armazenadas em um diretório chamado imagens, próximo ao nosso arquivo de programa. Portanto, nosso Ator estaria procurando por um arquivo de imagem na pasta de imagens chamado racecar.png. Pode ser um arquivo-g.webp

Você pode definir sua posição na tela digitando:

car.pos = 350, 560

Depois disso, em nossa função draw (), podemos digitar

car.draw () # desenha nosso carro de corrida em sua posição definida

O programa completo será assim:

#! / usr / bin / python3

import pgzrun WIDTH = 700 # largura da janela HEIGHT = 800 # altura da janela car = Actor ("racecar") car.pos = 350, 560 def draw (): # pygame zero draw function screen.fill ((128, 128, 128)) # preencha a tela com car.draw () pgzrun.go ()

Teste seu programa para ter certeza de que está funcionando.

Etapa 5: controlar o ator

Assim que tivermos nosso carro desenhado na tela, o próximo estágio é permitir que o jogador o mova.

Podemos fazer isso pressionando as teclas. Podemos ler o estado dessas chaves dentro de outra função predefinida chamada update ().

A função update ()

Esta função é verificada continuamente durante o jogo.

Precisamos escrever algum código para detectar pressionamentos de teclas de setas e também fazer algo a respeito.

Então, vamos adicionar esta função ao nosso programa

def update ():

if keyboard.left: car.x - = 2 if keyboard.right: car.x + = 2 if keyboard.up: car.y - = 2 if keyboard.down: car.y + = 2

Essas linhas de código moverão o ator do carro para a esquerda, direita, para frente e para trás.

Etapa 6: construindo o trilho

Agora que temos um carro que podemos dirigir, precisamos de uma pista para ele dirigir.

Vamos construir nossa trilha de Atores, uma linha de cada vez. Precisaremos fazer algumas listas para rastrear os atores que criamos.

Também precisaremos configurar mais algumas variáveis para a pista.

Então vamos fazer uma nova função chamada makeTrack (). A função irá adicionar um ator de trilha à esquerda e outro à direita, ambos usando a imagem bare-p.webp

trackLeft = # lista para armazenar barris esquerdos

trackRight = # lista para armazenar barries direito trackCount = 0 # contar o número de barries trackPosition = 350 trackWidth = 150 # largura entre barries esquerdo e direito def makeTrack (): # função para criar um barrie nos limites globais esquerdo e direito do trackCount, trackLeft, trackRight, trackPosition, trackWidth trackLeft.append (Actor ("bare", pos = (trackPosition-trackWidth, 0))) trackRight.append (Actor ("bare", pos = (trackPosition + trackWidth, 0))) trackCount + = 1

A próxima coisa que precisamos fazer é mover as seções da pista para baixo na tela em direção ao carro.

Vamos escrever uma nova função chamada updateTrack (). Esta função atualiza onde os blocos da trilha aparecerão. As peças da trilha são criadas por números aleatórios para que cada jogada seja diferente.

trackDriction = False

SPEED = 4 # define a velocidade do jogo da importação aleatória randint # importa a classe randint do módulo aleatório def updateTrack (): global trackCount, trackPosition, trackDirection, trackWidth, SPEED b = 0 enquanto b 32: if trackDirection == False: trackPosition + = 16 if trackDirection == True: trackPosition - = 16 se randint (0, 4) == 1: trackDirection = não trackDirection se trackPosition> 700 - trackWidth: trackDirection = True se trackPosition < trackWidth: trackDirection = False makeTrack () # cria uma nova trilha na parte superior da tela

Consulte o arquivo zip abaixo denominado "RaceGameDemo".

Se executarmos nosso código no momento, devemos ver uma trilha serpenteando em direção ao carro. O único problema é que podemos mover o carro sobre as barreiras da pista e queremos manter o carro dentro delas com alguma detecção de colisão.

Etapa 7: acidente de carro

Precisamos ter certeza de que nosso carro não toque nos atores da pista.

podemos também testar colisões usando o método colliderect () em nossa função updateTrack ().

Neste jogo, teremos três estados diferentes para o jogo armazenados em nossa variável gameStatus:

• gameStatus == 0 # jogo em execução
• gameStatus == 1 # acidente de carro
• gameStatus == 2 # jogo finalizado

Precisaremos mudar nossa função draw () e nossa função update () para responder à variável gameStatus.

Toques finais

Tudo o que precisamos fazer agora é exibir algo se gameStatus estiver definido como 1 ou 2, por exemplo, devemos exibir um vermelho

bandeira, se o carro bateu. Podemos fazer isso com o código abaixo:

screen.blit ("redflag", (230, 230))

Para ver se o carro chegou ao fim, devemos contar quantas seções de pista foram criadas e então, talvez, quando chegarmos a 200, defina gameStatus como 2. Em seguida, exiba a bandeira quadriculada:

screen.blit ("finishflag", (230, 230))

Também exibiremos algum texto na tela como a pontuação atual do jogo.

Dê uma olhada na lista completa de códigos para ver como tudo isso se encaixa.

Etapa 8: execute o jogo no Raspberry Pi

No Raspberry Pi, o pgzero foi instalado por padrão desde o lançamento do Raspbian Jessie em setembro de 2015.

Basta atualizar seu Raspberry Pi usando o comando:

sudo apt-get update

Vá até o local do arquivo e digite no Terminal.

pgzrun.py

Etapa 9: Você venceu?

Você pode tornar o jogo mais fácil ou mais difícil alterando a variável trackWidth para tornar a faixa de largura diferente. Você pode alterar o valor de SPEED para fazer a faixa se mover mais rápido ou mais devagar.

Etapa 10: Conclusão

Pygame Zero é uma ótima escolha para quem deseja começar a escrever jogos de computador.

Se você tiver alguma dúvida, é claro, pode deixar um comentário. Para ver mais sobre meus trabalhos, visite meu canal:

myYouTube

meu Twitter

myLinkedin

Obrigado por ler este instrutível ^^ e tenha um bom dia. Até mais. Ahmed Nouira.