La mayoría de los juegos de plataformas usan algún tipo de salto, con variaciones que incluyen doble salto y salto de altura variable. Descubre las técnicas detrás de estos movimientos.
La mecánica de salto juega un papel crucial en la mejora de la experiencia de juego de un juego de plataformas. Al implementar varias mecánicas de salto con la Biblioteca Arcade de Python, puede agregar profundidad y emoción a sus juegos.
La biblioteca Arcade proporciona un marco intuitivo y fácil de usar para crear juegos, por lo que es una opción ideal para crear su juego de plataformas.
Crea un juego simple
Antes de empezar, instala pip en tu dispositivo y use este comando para instalar el arcada módulo:
pip instalar arcadePara explorar cómo funcionan las mecánicas de salto, comience creando un juego simple en el que el jugador pueda moverse hacia la izquierda y hacia la derecha con la gravedad y una plataforma estática.
El código utilizado en este artículo está disponible en este repositorio GitHub y es gratis para su uso bajo la licencia MIT.
En el juego, el jugador chocará con la plataforma y se parará encima de ella. Crear un nuevo archivo llamado juego-simple.py y agregue el siguiente código:
importar arcadaANCHO_PANTALLA = 800
PANTALLA_ALTURA = 600
RADIO_JUGADOR = 20
PLATAFORMA_ANCHO = 200
PLATAFORMA_ALTURA = 20
GRAVEDAD = 0.5
azul = arcada.color. AZUL
verde = arcada.color. VERDEclaseventana de juego(arcada. Ventana):
definitivamente__en eso__(ser):
super().__init__(PANTALLA_ANCHO, PANTALLA_ALTO, "Mecánica de salto")
self.jugador_x = ANCHO_PANTALLA // 2
self.player_y = SCREEN_HEIGHT // 2
self.jugador_dy = 0
self.plataforma_x = ANCHO_PANTALLA // 2
self.plataforma_y = ALTURA_PANTALLA // 4definitivamenteen_dibujar(ser):
arcade.start_render()arcade.draw_circle_filled (self.player_x, self.player_y,
PLAYER_RADIUS, azul)arcade.draw_rectangle_filled (self.plataforma_x, self.plataforma_y,
PLATAFORMA_ANCHO, PLATAFORMA_ALTURA, verde)definitivamenteon_update(uno mismo, delta_time):
self.player_dy -= GRAVEDAD
self.jugador_y += self.jugador_dy
dist = PLAYER_RADIUS + self.platform_y + PLATAFORMA_HEIGHT / 2si self.jugador_y < dist:
self.jugador_y = dist
self.jugador_dy = 0
juego = ventana de juego()
arcade.ejecutar()
Cuando ejecute el programa, verá que el objeto del jugador cae rápidamente sobre la plataforma y luego se queda descansando sobre ella.
Agregar una función de salto simple
Ahora, agregue una función de salto simple al juego. Comprueba la colisión entre el jugador y la plataforma. y activa la acción de salto cuando el jugador presiona la tecla de flecha hacia arriba. Para lograr esto, cree un nuevo archivo llamado saltar.py y el código con las siguientes actualizaciones:
claseventana de juego(arcada. Ventana):
definitivamente__en eso__(ser):
# ...definitivamenteon_key_press(auto, clave, modificadores):
on_ground = PLAYER_RADIUS + self.platform_y + PLATAFORMA_HEIGHT / 2si clave == arcade.clave. ARRIBA y self.jugador_y == en_tierra:
self.jugador_dy = 10
definitivamenteon_update(uno mismo, delta_time):
self.player_dy -= GRAVEDAD
self.jugador_y += self.jugador_dy
dist = PLAYER_RADIUS + self.platform_y + PLATAFORMA_HEIGHT / 2
si self.jugador_y < dist:
self.jugador_y = dist
self.jugador_dy = 0
self.jump_count = 0
Adición de una función de doble salto
Para agregar una función de doble salto, extienda la lógica de salto existente. Cuando el jugador está en la plataforma y presiona la tecla de flecha hacia arriba por primera vez, realizará un salto normal. Sin embargo, si presiona la tecla de flecha hacia arriba nuevamente mientras está en el aire, el jugador ejecutará un doble salto.
Crear un nuevo archivo llamado salto-doble.py y el código con las siguientes actualizaciones:
claseventana de juego(arcada. Ventana):
definitivamente__en eso__(ser):
self.jump_count = 0# Seguimiento del número de saltosdefinitivamenteon_key_press(auto, clave, modificadores):
on_ground = PLAYER_RADIUS + self.platform_y + PLATAFORMA_HEIGHT / 2
si clave == arcade.clave. ARRIBA:
si self.jugador_y == en_suelo o self.jump_count < 2:
self.jugador_dy = 10
self.jump_count += 1
Incluyendo características adicionales
Además de los saltos simples y dobles, hay muchas características que puedes agregar para mejorar la mecánica de salto de tu juego.
Implementación de altura de salto variable
Permitir que el jugador controle la altura de sus saltos en función de cuánto tiempo mantenga presionado el botón de salto puede agregar más control y estrategia al juego. Aquí hay un ejemplo de cómo puede implementar una altura de salto variable. Crear un nuevo archivo llamado salto-variable.py y el código con las siguientes actualizaciones:
GRAVEDAD = 0.5
SALTO_PODER_INCREMENTO = 0.2
MAX_JUMP_POWER = 100claseventana de juego(arcada. Ventana):
definitivamente__en eso__(ser):
super().__init__(PANTALLA_ANCHO, PANTALLA_ALTO, "Mecánica de salto")
self.jump_pressed = FALSO
self.jump_power = 0definitivamenteon_key_press(auto, clave, modificadores):
on_ground = PLAYER_RADIUS + self.platform_y + PLATAFORMA_HEIGHT / 2si clave == arcade.clave. ARRIBA y self.jugador_y == en_tierra:
self.jump_pressed = Verdaderodefinitivamenteon_key_release(auto, clave, modificadores):
si clave == arcade.clave. ARRIBA:
self.jump_pressed = FALSOdefinitivamenteactualizar_jump_power(ser):
# Aumente la potencia de salto mientras se mantiene presionado el botón de salto
si self.jump_pressed:
self.jump_power += JUMP_POWER_INCREMENTsi self.jump_power > MAX_JUMP_POWER:
self.jump_power = MAX_JUMP_POWER
demás:
si self.jump_power > 0:
self.jump_power -= 1definitivamenteon_update(uno mismo, delta_time):
self.player_dy -= GRAVEDAD
dist = PLAYER_RADIUS + self.platform_y + PLATAFORMA_HEIGHT / 2si self.jugador_y == distancia y self.jump_power > 0:
self.jugador_dy = self.jump_power
self.jugador_y += self.jugador_dy
self.update_jump_power()
Implementación de la función Air Dash
Agregar una mecánica de carrera aérea puede brindarle al jugador opciones de movilidad adicionales mientras está en el aire. Crear un nuevo archivo llamado air-dash.py y el código con las siguientes actualizaciones:
AIRE_DASH_DISTANCIA = 100
MAX_AIR_DASHES = 2claseventana de juego(arcada. Ventana):
definitivamente__en eso__(ser):
super().__init__(PANTALLA_ANCHO, PANTALLA_ALTO, "Mecánica de salto")
self.on_ground = FALSO
self.air_dashes = 0
self.can_air_dash = Verdaderodefinitivamenteon_key_press(auto, clave, modificadores):
si clave == arcade.clave. ARRIBA y self.on_ground:
self.jugador_dy = 10
elif clave == arcade.clave. ARRIBA y \
self.air_dashes < MAX_AIR_DASHES y \
self.can_air_dash:
self.player_dx = AIR_DASH_DISTANCE
self.air_dashes += 1
self.can_air_dash = FALSOdefinitivamenteon_update(uno mismo, delta_time):
self.player_dy -= GRAVEDAD
self.jugador_y += self.jugador_dydist = PLAYER_RADIUS + self.platform_y + PLATAFORMA_HEIGHT / 2
si self.jugador_y <= dist:
self.jugador_y = dist
self.jugador_dy = 0
self.on_ground = Verdadero
demás:
self.on_ground = FALSOself.jugador_x += self.jugador_dx
si self.jugador_x < RADIO_JUGADOR:
self.player_x = PLAYER_RADIUS
self.jugador_dx = 0
elif self.player_x > SCREEN_WIDTH - PLAYER_RADIUS:
self.player_x = SCREEN_WIDTH - PLAYER_RADIUS
self.jugador_dx = 0
si self.on_ground:
self.air_dashes = 0
self.can_air_dash = Verdadero
Cuando realices la carrera aérea, tu personaje de jugador se alejará de la plataforma:
Mejores prácticas para la mecánica de salto
La implementación de la mecánica de salto en un juego requiere una cuidadosa consideración para garantizar una experiencia de juego fluida y agradable. Estas son algunas de las mejores prácticas a tener en cuenta:
Equilibrar la altura y la duración del salto
Para mantener una sensación de realismo y dificultad en el juego, es importante equilibrar la altura y la duración del salto. Un salto demasiado alto o demasiado corto puede afectar negativamente al juego. Experimente con diferentes alturas y duraciones de salto para encontrar el equilibrio adecuado para su juego.
Tenga en cuenta la física del juego, las habilidades de los personajes y el diseño general de niveles al determinar la mecánica de salto adecuada.
Proporcione comentarios visuales y de audio
La retroalimentación visual y de audio es crucial para que los saltos se sientan receptivos y satisfactorios. Use animaciones o efectos de partículas para representar el movimiento de salto y el aterrizaje del jugador.
Además, considere añadir efectos de sonido o música de fondo que mejora la experiencia de salto. Estas señales visuales y de audio contribuyen a la inmersión y el compromiso de los jugadores.
Detección precisa de colisiones
La detección precisa de colisiones entre el jugador y las plataformas es esencial para una mecánica de salto precisa y confiable. Asegúrese de que el algoritmo de detección de colisiones sea sólido y maneje adecuadamente varios escenarios, como aterrizar en una plataforma, chocar con obstáculos o deslizarse a lo largo de las paredes.
Pruebe e itere su código de detección de colisiones para eliminar cualquier falla o inconsistencia que pueda afectar la mecánica de salto.
Haz que los juegos sean más divertidos con la mecánica de salto
La adición de mecánicas de salto puede mejorar en gran medida la participación y el disfrute de un juego. Abre nuevas posibilidades para el diseño de niveles, rompecabezas y obstáculos desafiantes. Al implementar diferentes mecanismos de salto en la Biblioteca de juegos de arcade de Python, puede crear juegos de plataformas cautivadores que mantendrán a los jugadores entretenidos durante horas.
Recuerda, experimentar con diferentes mecánicas de salto e incorporar características únicas puede diferenciar tu juego y convertirlo en una experiencia inmersiva y memorable para los jugadores.
