A maioria dos jogos de plataforma usa algum tipo de salto, com variações que incluem salto duplo e salto de altura variável. Descubra as técnicas por trás desses movimentos.

A mecânica de salto desempenha um papel crucial no aprimoramento da experiência de jogo de um jogo de plataforma. Ao implementar várias mecânicas de salto com a Biblioteca Arcade do Python, você pode adicionar profundidade e emoção aos seus jogos.

A biblioteca Arcade fornece uma estrutura intuitiva e fácil de usar para criar jogos, tornando-a a escolha ideal para criar seu jogo de plataforma.

Crie um jogo simples

Antes de começar, instale o pip no seu dispositivo e use este comando para instalar o videogames módulo:

pip instalar fliperama

Para explorar como a mecânica de salto funciona, comece criando um jogo simples onde o jogador pode se mover para a esquerda e para a direita com a gravidade e uma plataforma estática.

O código usado neste artigo está disponível neste Repositório GitHub e é gratuito para você usar sob a licença do MIT.

instagram viewer

No jogo, o jogador irá colidir com a plataforma e ficar em cima dela. Crie um novo arquivo chamado simple-game.py e adicione o código abaixo:

importar videogames
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
PLAYER_RADIUS = 20
PLATAFORMA_WIDTH = 200
PLATAFORMA_HEIGHT = 20
GRAVIDADE = 0.5
azul = arcade.color. AZUL
verde = arcade.color. VERDE


aulaGameWindow(videogames. Janela):
def__iniciar__(auto):
 super().__init__(SCREEN_WIDTH, SCREEN_HEIGHT, "Mecânica de salto")
 self.player_x = SCREEN_WIDTH // 2
 self.player_y = SCREEN_HEIGHT // 2
 self.player_dy = 0
 self.platform_x = SCREEN_WIDTH // 2
 self.platform_y = SCREEN_HEIGHT // 4


defon_draw(auto):
 arcade.start_render()


 arcade.draw_circle_filled (self.player_x, self.player_y, 
 PLAYER_RADIUS, azul)


 arcade.draw_rectangle_filled (self.platform_x, self.platform_y, 
 PLATFORM_WIDTH, PLATFORM_HEIGHT, verde)


defon_update(auto, delta_time):
 self.player_dy -= GRAVIDADE
 self.player_y += self.player_dy
 dist = PLAYER_RADIUS + self.platform_y + PLATFORM_HEIGHT / 2


se self.player_y < dist:
 self.player_y = dist
 self.player_dy = 0
jogo = GameWindow()
arcade.run()

Ao executar o programa, você verá o objeto do jogador cair rapidamente na plataforma e permanecer em cima dela.

Adicionando um recurso de salto simples

Agora, adicione um recurso de salto simples ao jogo. Verifique a colisão entre o jogador e a plataforma e acione a ação de salto quando o jogador pressionar a tecla de seta para cima. Para conseguir isso, crie um novo arquivo chamado jump.py e o código com as atualizações abaixo:

aulaGameWindow(videogames. Janela):
def__iniciar__(auto):
# ...
defon_key_press(auto, chave, modificadores):
 on_ground = PLAYER_RADIUS + self.platform_y + PLATFORM_HEIGHT / 2


se chave == arcade.key. ACIMA e self.player_y == on_ground:
 self.player_dy = 10

defon_update(auto, delta_time):
 self.player_dy -= GRAVIDADE
 self.player_y += self.player_dy
 dist = PLAYER_RADIUS + self.platform_y + PLATFORM_HEIGHT / 2
se self.player_y < dist:
 self.player_y = dist
 self.player_dy = 0
 self.jump_count = 0

Adicionando um recurso de salto duplo

Para adicionar um recurso de salto duplo, estenda a lógica de salto existente. Quando o jogador estiver na plataforma e pressionar a tecla de seta para cima pela primeira vez, ele executará um salto normal. No entanto, se pressionar a tecla de seta para cima novamente enquanto estiver no ar, o jogador executará um salto duplo.

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

aulaGameWindow(videogames. Janela):
def__iniciar__(auto):
 self.jump_count = 0# Acompanhe o número de saltos
defon_key_press(auto, chave, modificadores):
 on_ground = PLAYER_RADIUS + self.platform_y + PLATFORM_HEIGHT / 2
se chave == arcade.key. ACIMA:
se self.player_y == on_ground ou self.jump_count < 2:
 self.player_dy = 10
 self.jump_count += 1

Incluindo Recursos Adicionais

Além dos saltos simples e duplos, há muitos recursos que você pode adicionar para aprimorar a mecânica de salto do seu jogo.

Implementando Altura de Salto Variável

Permitir que o jogador controle a altura de seus saltos com base em quanto tempo eles seguram o botão de salto pode adicionar mais controle e estratégia ao jogo. Aqui está um exemplo de como você pode implementar altura de salto variável. Crie um novo arquivo chamado variável-jump.py e o código com as atualizações abaixo:

GRAVIDADE = 0.5
JUMP_POWER_INCREMENT = 0.2
MAX_JUMP_POWER = 100
aulaGameWindow(videogames. Janela):
def__iniciar__(auto):
 super().__init__(SCREEN_WIDTH, SCREEN_HEIGHT, "Mecânica de salto")
 self.jump_pressed = Falso
 self.jump_power = 0


defon_key_press(auto, chave, modificadores):
 on_ground = PLAYER_RADIUS + self.platform_y + PLATFORM_HEIGHT / 2


se chave == arcade.key. ACIMA e self.player_y == on_ground:
 self.jump_pressed = Verdadeiro


defon_key_release(auto, chave, modificadores):
se chave == arcade.key. ACIMA:
 self.jump_pressed = Falso


defupdate_jump_power(auto):
# Aumente a potência do salto enquanto o botão de salto é pressionado
se self.jump_pressed:
 self.jump_power += JUMP_POWER_INCREMENT


se self.jump_power > MAX_JUMP_POWER:
 self.jump_power = MAX_JUMP_POWER
outro:
se self.jump_power > 0:
 self.jump_power -= 1


defon_update(auto, delta_time):
 self.player_dy -= GRAVIDADE
 dist = PLAYER_RADIUS + self.platform_y + PLATFORM_HEIGHT / 2


se self.player_y == dist e self.jump_power > 0:
 self.player_dy = self.jump_power
 self.player_y += self.player_dy
 self.update_jump_power()

Implementando o recurso Air Dash

Adicionar uma mecânica de corrida aérea pode dar ao jogador opções adicionais de mobilidade enquanto estiver no ar. Crie um novo arquivo chamado air-dash.py e o código com as atualizações abaixo:

AIR_DASH_DISTANCE = 100
MAX_AIR_DASHES = 2
aulaGameWindow(videogames. Janela):
def__iniciar__(auto):
 super().__init__(SCREEN_WIDTH, SCREEN_HEIGHT, "Mecânica de salto")
 self.on_ground = Falso
 self.air_dashes = 0
 self.can_air_dash = Verdadeiro


defon_key_press(auto, chave, modificadores):
se chave == arcade.key. ACIMA e self.on_ground:
 self.player_dy = 10
elif chave == arcade.key. ACIMA e \
 self.air_dashes < MAX_AIR_DASHES e \
 self.can_air_dash:
 self.player_dx = AIR_DASH_DISTANCE 
 self.air_dashes += 1
 self.can_air_dash = Falso


defon_update(auto, delta_time):
 self.player_dy -= GRAVIDADE
 self.player_y += self.player_dy


 dist = PLAYER_RADIUS + self.platform_y + PLATFORM_HEIGHT / 2


se self.player_y <= dist:
 self.player_y = dist
 self.player_dy = 0
 self.on_ground = Verdadeiro
outro:
 self.on_ground = Falso


 self.player_x += self.player_dx


se self.player_x < PLAYER_RADIUS:
 self.player_x = PLAYER_RADIUS
 self.player_dx = 0
elif self.player_x > SCREEN_WIDTH - PLAYER_RADIUS:
 self.player_x = SCREEN_WIDTH - PLAYER_RADIUS
 self.player_dx = 0
se self.on_ground:
 self.air_dashes = 0
 self.can_air_dash = Verdadeiro

Quando você executar o air dash, seu personagem se moverá para longe da plataforma:

Melhores práticas para mecânica de salto

A implementação da mecânica de salto em um jogo requer consideração cuidadosa para garantir uma experiência de jogo suave e agradável. Aqui estão algumas práticas recomendadas a serem lembradas:

Altura e duração do salto de equilíbrio

Para manter a sensação de realismo e dificuldade do jogo, é importante equilibrar a altura e a duração do salto. Um salto muito alto ou muito curto pode afetar negativamente a jogabilidade. Experimente diferentes alturas e durações de salto para encontrar o equilíbrio certo para o seu jogo.

Considere a física do jogo, as habilidades dos personagens e o design geral do nível ao determinar a mecânica de salto apropriada.

Forneça feedback visual e de áudio

O feedback visual e de áudio é crucial para fazer os saltos parecerem responsivos e satisfatórios. Use animações ou efeitos de partículas para representar o movimento de salto e aterrissagem do jogador.

Além disso, considere adicionar efeitos sonoros ou música de fundo que melhora a experiência de salto. Essas dicas visuais e de áudio contribuem para a imersão e engajamento dos jogadores.

Detecção de colisão de ajuste fino

A detecção precisa de colisão entre o jogador e as plataformas é essencial para uma mecânica de salto precisa e confiável. Certifique-se de que o algoritmo de detecção de colisão seja robusto e lide adequadamente com vários cenários, como pousar em uma plataforma, colidir com obstáculos ou deslizar ao longo de paredes.

Teste e repita seu código de detecção de colisão para eliminar quaisquer falhas ou inconsistências que possam afetar a mecânica do salto.

Torne os jogos mais divertidos com a mecânica de salto

A adição de mecânica de salto pode aumentar muito o envolvimento e a diversão de um jogo. Ele abre novas possibilidades para design de níveis, quebra-cabeças e obstáculos desafiadores. Ao implementar diferentes mecânicas de salto na Biblioteca de Jogos Arcade do Python, você pode criar jogos de plataforma cativantes que mantêm os jogadores entretidos por horas.

Lembre-se, experimentar diferentes mecânicas de salto e incorporar recursos exclusivos pode diferenciar seu jogo e torná-lo uma experiência imersiva e memorável para os jogadores.