Como implementar planos de fundo de rolagem no Pygame

Os fundos de rolagem podem aumentar muito o apelo visual e a profundidade de um jogo. Eles podem criar a ilusão de movimento, dando ao jogo uma sensação dinâmica e envolvente. Você pode implementar fundos de rolagem em apenas algumas etapas simples usando o Pygame.

Pygame é uma biblioteca Python popular que você pode usar para desenvolver jogos. Adicionar planos de fundo com rolagem aos seus projetos do Pygame dará vida a eles e proporcionará uma experiência mais envolvente para os jogadores.

Crie um jogo simples

Para entender o conceito de scrolling background no Pygame, comece criando um jogo simples onde o jogador pode se mover para a esquerda e para a direita. Você também pode incluir duas plataformas, representadas por retângulos, para servir como ambiente de jogo. Crie um novo arquivo chamado simple-game.py.

Primeiro, importe o módulo pygame e inicialize-o. Em seguida, defina a posição inicial do jogador e a velocidade de movimento. Crie plataformas usando pygame. rect objetos e definir suas posições e dimensões.

Dentro do loop do jogo, lide com eventos como sair do jogo. Você também pode lidar movimento do jogador com base em entradas de toque ou teclado.

Aqui está a saída do jogo simples:

Criar Camadas Diferentes

Para obter o efeito de rolagem, você pode criar várias camadas de planos de fundo com cores diferentes. Cada camada se moverá em uma velocidade diferente, criando um efeito de paralaxe. Este efeito dá a ilusão de profundidade e aumenta a sensação de movimento no jogo.

Defina duas camadas de plano de fundo, cada uma cobrindo toda a janela do jogo, usando pygame. Retifique objetos. Defina também as cores de cada camada no background_colors lista. O background_speeds lista determina a velocidade na qual cada camada se moverá.

# Adicione este código abaixo da seção anterior
background_layers = [
 pygame. Rect(0, 0, largura_tela, altura_tela), 
 pygame. Rect(0, 0, screen_width, screen_height) 
]
cores_fundo = [(30, 30, 30), (60, 60, 60)]
background_speeds = [0.1, 1.0]

Para criar o efeito de fundo de rolagem, você precisa atualizar as posições das camadas de fundo no loop do jogo. Você moverá cada camada horizontalmente com base na velocidade atribuída.

Crie um novo arquivo chamado scrolling-bg.py e adicione o código com as atualizações abaixo:

para eu em intervalo (len (background_layers)):
 background_layers[i].x -= background_speeds[i]
se background_layers[i].x <= -screen_width:
 background_layers[i].x = 0
 pygame.draw.rect (tela, background_colors[i], background_layers[i])

Iterar através de cada camada de plano de fundo. Subtraia a velocidade correspondente da coordenada x da camada, fazendo com que ela se mova para a esquerda. Se uma camada atingir a borda esquerda da tela, redefina sua posição para a direita, criando um efeito de rolagem contínua.

Finalmente, desenhe cada camada de fundo retangular na tela usando pygame.draw.rect() e passando a cor correspondente e pygame. Objeto reto.

Adicionando um efeito de paralaxe durante o movimento

Para aprimorar o efeito de paralaxe, você pode modificar o movimento da plataforma para ocorrer quando o jogador estiver se movendo. Isso criará uma forte sensação de profundidade e movimento dinâmico. Crie um novo arquivo chamado parallax.py e adicione o código com as atualizações abaixo:

# Defina as posições e velocidades da plataforma
rect1 = pygame. Rect(50, screen_height - 100, 200, 10)
rect2 = pygame. Rect (screen_width - 250, screen_height - 200, 200, 10)
plataformas = [
 {"reto": rect1, "velocidade": 3},
 {"reto": rect2, "velocidade": 1}
]
# Adicione este código dentro do loop do jogo
# Movimento do jogador
keys = pygame.key.get_pressed()
se keys[pygame. K_LEFT] e jogador_x > 0:
 jogador_x -= jogador_velocidade
para plataforma em plataformas:
 plataforma["reto"].x -= plataforma["velocidade"]
se keys[pygame. K_RIGHT] e player_x  jogador_x += jogador_velocidade
para plataforma em plataformas:
 plataforma["reto"].x += plataforma["velocidade"]
para plataforma em plataformas:
 pygame.draw.rect (tela, (0, 255, 0), plataforma["reto"])

Represente as plataformas como dicionários que contêm tanto o objeto retângulo (rect) quanto a velocidade na qual a plataforma deve se mover (speed). As plataformas são atualizadas no loop do jogo com base no movimento do jogador.

Ao implementar essa modificação, o efeito de rolagem só estará ativo quando o jogador estiver se movendo ativamente, aumentando ainda mais a ilusão de profundidade e movimento.

Incluindo Recursos Adicionais

Você pode implementar vários recursos adicionais para aprimorar os planos de fundo de rolagem em seu jogo. Aqui estão alguns exemplos.

Randomizar cores de fundo

Para adicionar variação às camadas de fundo, você pode randomizar suas cores. Você pode fazer isso modificando o background_colors lista:

importar aleatório
# Adicione este código antes do loop do jogo
cores_fundo = [
 (random.randint(0, 255), randint(0, 255), randint(0, 255)),
 (random.randint(0, 255), randint(0, 255), randint(0, 255)),
 (random.randint(0, 255), randint(0, 255), randint(0, 255))
]

Adicione mais camadas de plano de fundo

Você pode experimentar adicionar mais camadas de fundo para criar um efeito de paralaxe mais rico. Basta definir adicionais pygame. rect objetos, cores e velocidades:

# Adicione este código antes do loop do jogo
background_layers = [
 pygame. Rect(0, 0, largura_tela, altura_tela), 
 pygame. Rect(0, 0, largura_tela, altura_tela), 
 pygame. Rect(0, 0, largura_tela, altura_tela), 
 pygame. Rect(0, 0, screen_width, screen_height) 
]
cores_fundo = [
 (30, 30, 30),
 (60, 60, 60),
 (90, 90, 90),
 (120, 120, 120)
]
background_speeds = [1, 2, 3, 4]

Use imagens para planos de fundo

Em vez de cores sólidas, você pode usar arquivos de imagem como plano de fundo. Pygame fornece funções para carregar e renderizar imagens.

Carregar os arquivos de imagem background_0.png, plano de fundo_1.png, e plano de fundo_2.png usando pygame.image.load(). Use o método convert() para melhorar o desempenho e dimensionar as imagens para corresponder às dimensões da tela com pygame.transform.scale().

# Adicione este código antes do loop do jogo
background_images = [
 pygame.image.load("background_0.png").converter(),
 pygame.image.load("background_1.png").converter(),
 pygame.image.load("background_2.png").converter()
]
background_speeds = [1, 2, 3]
para eu em intervalo (len (background_images)):
 tamanho = (screen_width, screen_height)
 background_images[i] = pygame.transform.scale (background_images[i], tamanho)

Finalmente, atualize o loop onde você desenha as camadas de fundo para usar as imagens:

# Atualize este código dentro do loop do jogo
para eu em intervalo (len (background_layers)):
 background_layers[i].x -= background_speeds[i]
se background_layers[i].x <= -screen_width:
 background_layers[i].x = 0
 screen.blit (background_images[i], background_layers[i])

Aqui estão algumas práticas recomendadas a serem consideradas ao implementar planos de fundo de rolagem em seus projetos Pygame.

Otimize o desempenho

A rolagem de fundos envolve renderização e atualização contínuas. Para garantir uma jogabilidade suave, considere otimizar seu código e minimizar cálculos desnecessários.

Experimente com velocidades de camada

Ajustar as velocidades das camadas de fundo pode criar diferentes efeitos. Brinque com diferentes valores para encontrar o equilíbrio certo e obter o impacto visual desejado.

Teste em diferentes tamanhos de tela

Certifique-se de que seus fundos de rolagem funcionem bem em várias resoluções de tela. Considere a implementação de dimensionamento dinâmico ou o uso de diferentes imagens de plano de fundo para diferentes proporções.

Use formatos de imagem apropriados

Se você decidir usar imagens para seus planos de fundo, escolha o formato de imagem apropriado (por exemplo, PNG, JPEG) para equilibrar o tamanho do arquivo e a qualidade da imagem. Você também pode reduzir o tempo de carregamento compactando e otimizando suas imagens.

Considere o uso de memória

Se você planeja usar muitas imagens de alta resolução para seus planos de fundo, esteja atento aos requisitos de memória. Imagens grandes podem consumir uma quantidade significativa de memória, afetando potencialmente o desempenho e a capacidade de resposta do seu jogo.

Ao incorporar planos de fundo com rolagem, você pode criar diferentes ambientes, como paisagens em movimento, paisagens urbanas futuristas ou mundos subaquáticos. O efeito de paralaxe adiciona um toque dinâmico, tornando o mundo do jogo vivo e interativo.

Lembre-se de experimentar, iterar e explorar possibilidades criativas com planos de fundo de rolagem para tornar seus jogos mais divertidos e cativantes para os jogadores.