Mejore su experiencia de juego con los juegos Python Arcade incorporando una cámara.

La biblioteca Arcade de Python es un marco poderoso y fácil de usar para crear juegos 2D. Una característica clave que puede mejorar enormemente el juego y la experiencia del usuario es la adición de una cámara. Agregar una cámara a su juego permite la manipulación dinámica de la ventana gráfica, lo que permite al jugador explorar mundos de juego más grandes, enfocarse en áreas específicas o rastrear objetos en movimiento.

Al mover el punto de vista de la cámara, puede crear efectos visualmente atractivos, mejorar la mecánica del juego y brindar una experiencia de juego más inmersiva.

Crea un juego simple

Antes de empezar, instala pip en tu dispositivo y use el siguiente comando para instalar el arcada módulo:

pip instalar arcade

Ahora, comience creando un juego básico de desplazamiento lateral donde el jugador controla un personaje que puede moverse hacia la izquierda y hacia la derecha usando las teclas de flecha.

instagram viewer

El código utilizado en este artículo está disponible en este repositorio GitHub y es gratis para su uso bajo la licencia MIT.

Además, puede agregar un obstáculo para que el jugador navegue.

importar arcada
ANCHO_PANTALLA = 800
PANTALLA_ALTURA = 600
MOVIMIENTO_VELOCIDAD = 5


claseMi juego(arcada. Ventana):
definitivamente__en eso__(uno mismo, ancho, alto):
 super().__init__(ancho, alto)
 self.jugador_x = ancho // 2
 self.jugador_y = altura // 2


definitivamenteconfiguración(ser):
 arcade.set_background_color (arcade.color. CIELO AZUL)


definitivamenteen_dibujar(ser):
 arcade.start_render()
 arcade.draw_circle_filled (self.player_x, self.player_y, 20, arcade.color. ROJO)
 arcade.draw_rectangle_filled(400, 200, 80, 40, arcade.color. VERDE)


definitivamenteactualizar(uno mismo, delta_time):
aprobar


definitivamenteon_key_press(auto, clave, modificadores):
si clave == arcade.clave. IZQUIERDA:
 self.jugador_x -= VELOCIDAD_DE_MOVIMIENTO
elif clave == arcade.clave. BIEN:
 self.jugador_x += VELOCIDAD_DE_MOVIMIENTO
si __nombre__ == "__principal__":
 juego = MiJuego (PANTALLA_ANCHO, PANTALLA_ALTO)
 juego.setup()
 arcade.ejecutar()

Configuración de la cámara

Para agregar una cámara al juego, crea una Cámara clase que gestiona la posición y el movimiento de la cámara. Esta clase tendrá atributos tales como cámara_x y cámara_y para almacenar las coordenadas de la cámara.

claseCámara:
definitivamente__en eso__(ser):
 self.cámara_x = 0
 self.camera_y = 0

Movimiento de cámara con entradas de teclado

A continuación, modifique el juego on_key_press método para incluir cámara movimiento basado en las entradas del jugador. Cuando el jugador se mueve hacia la izquierda o hacia la derecha, puede actualizar la posición de la cámara en consecuencia. Además, ajuste el código de dibujo para tener en cuenta la posición de la cámara al representar los objetos del juego.

claseMi juego(arcada. Ventana):
definitivamente__en eso__(uno mismo, ancho, alto):
 super().__init__(ancho, alto)
 self.cámara = Cámara()
 self.jugador_x = ancho // 2
 self.jugador_y = altura // 2
definitivamenteon_key_press(auto, clave, modificadores):
si clave == arcade.clave. IZQUIERDA:
 self.jugador_x -= VELOCIDAD_DE_MOVIMIENTO
 self.camera.camera_x -= MOVIMIENTO_VELOCIDAD
elif clave == arcade.clave. BIEN:
 self.jugador_x += VELOCIDAD_DE_MOVIMIENTO
 self.camera.camera_x += MOVIMIENTO_VELOCIDAD
definitivamenteen_dibujar(ser):
 arcade.start_render()
 arcade.set_viewport(
 self.cámara.cámara_x,
 self.camera.camera_x + SCREEN_WIDTH,
 self.camera.camera_y,
 self.camera.camera_y + SCREEN_HEIGHT
 )
 arcade.draw_circle_filled (self.player_x, self.player_y, 20, arcade.color. ROJO)
 arcade.draw_rectangle_filled(400, 200, 80, 40, arcade.color. VERDE)

Movimiento de cámara con entradas de mouse

Además de las entradas del teclado, también puede habilitar el movimiento de la cámara en función de las entradas del mouse. Por ejemplo, puede permitir que el jugador mueva la cámara arrastrando la pantalla. Para lograr esto, modifique el on_mouse_drag método para actualizar la posición de la cámara en función del movimiento del ratón.

claseMi juego(arcada. Ventana):
definitivamenteon_mouse_drag(self, x, y, dx, dy, botones, modificadores):
si botones == arcada. MOUSE_BUTTON_IZQUIERDO:
 self.cámara.cámara_x -= dx
 self.cámara.cámara_y -= dy

Incluyendo características adicionales

Agregar una cámara a tu juego abre un mundo de posibilidades para funciones y efectos adicionales. Aquí hay algunos ejemplos de cómo puedes mejorar aún más tu juego usando el sistema de cámara.

Funcionalidad de zoom

Para implementar la funcionalidad de zoom, debe introducir un zoom variables en el Cámara clase y modificar la en_mouse_scroll método para actualizar el nivel de zoom basado en el movimiento de la rueda del ratón. También debe ajustar el set_viewport parámetros para considerar el nivel de zoom.

claseCámara:
definitivamente__en eso__(ser):
 self.cámara_x = 0
 self.camera_y = 0
 self.zoom = 1.0
claseMi juego(arcada. Ventana):


definitivamenteen_mouse_scroll(yo, x, y, scroll_x, scroll_y):
 self.cámara.zoom += scroll_y * 0.1
definitivamenteen_dibujar(ser):
 arcade.start_render()
 arcade.set_viewport(
 self.camera.camera_x * self.camera.zoom,
 (self.camera.camera_x + SCREEN_WIDTH) * self.camera.zoom,
 self.camera.camera_y * self.camera.zoom,
 (self.camera.camera_y + SCREEN_HEIGHT) * self.camera.zoom
 )
 arcade.draw_circle_filled (self.player_x, self.player_y, 20, arcade.color. ROJO)
 arcade.draw_rectangle_filled(400, 200, 80, 40, arcade.color. VERDE)

Movimiento suave de la cámara

Para lograr un movimiento de cámara más suave, puede introducir una técnica de interpolación llamada interpolación lineal (lerp). Modificar el actualizar método para mover gradualmente la cámara hacia una posición objetivo usando lerp. Esto crea un efecto de transición suave.

claseCámara:
definitivamente__en eso__(ser):
 self.cámara_x = 0
 self.camera_y = 0
 self.objetivo_x = 0
 self.objetivo_y = 0
 self.lerp_speed = 0.1
definitivamenteactualizar(ser):
 self.camera_x = arcade.lerp (self.camera_x, self.target_x, self.lerp_speed)
 self.camera_y = arcade.lerp (self.camera_y, self.target_y, self.lerp_speed)


claseMi juego(arcada. Ventana):


definitivamenteactualizar(uno mismo, delta_time):
 self.camera.target_x = self.player_x - SCREEN_WIDTH // 2
 self.camera.target_y = self.player_y - SCREEN_HEIGHT // 2
 self.camera.update()
definitivamenteen_dibujar(ser):
 arcade.start_render()
 arcade.set_viewport(
 self.cámara.cámara_x,
 self.camera.camera_x + SCREEN_WIDTH,
 self.camera.camera_y,
 self.camera.camera_y + SCREEN_HEIGHT
 )
 arcade.draw_circle_filled (self.player_x, self.player_y, 20, arcade.color. ROJO)
 arcade.draw_rectangle_filled(400, 200, 80, 40, arcade.color. VERDE)

Restricciones de la cámara

Para evitar que la cámara se mueva más allá de ciertos límites, puede introducir restricciones. Por ejemplo, puede definir una posición de cámara mínima y máxima y asegurarse de que la cámara permanezca dentro de esos límites.

claseCámara:
definitivamente__en eso__(ser):
 self.cámara_x = 0
 self.camera_y = 0
 self.min_x = 0
 self.max_x = 800
 self.min_y = 0
 self.max_y = 600
definitivamenteactualizar(ser):
 self.cámara_x = max (self.min_x, min (self.camera_x, self.max_x))
 self.camera_y = max (self.min_y, min (self.camera_y, self.max_y))


claseMi juego(arcada. Ventana):


definitivamenteactualizar(uno mismo, delta_time):
 self.camera.camera_x = self.player_x - SCREEN_WIDTH // 2
 self.camera.camera_y = self.player_y - SCREEN_HEIGHT // 2
 self.camera.update()
definitivamenteen_dibujar(ser):
 arcade.start_render()
 arcade.set_viewport(
 self.cámara.cámara_x,
 self.camera.camera_x + SCREEN_WIDTH,
 self.camera.camera_y,
 self.camera.camera_y + SCREEN_HEIGHT
 )
 arcade.draw_circle_filled (self.player_x, self.player_y, 20, arcade.color. ROJO)
 arcade.draw_rectangle_filled(400, 200, 80, 40, arcade.color. VERDE)

Estos son solo algunos ejemplos de cómo puede aprovechar el sistema de cámara para incluir funciones y efectos adicionales en sus juegos de Python Arcade.

También puede agregar muchas otras funciones adicionales a sus juegos basados ​​en Python. Por ejemplo, puede hacer que la cámara recuerde su posición cuando el el jugador se mueve a un nivel diferente. Esto garantiza que la vista siga siendo la misma al pasar de un nivel a otro, lo que proporciona una experiencia fluida y uniforme para el jugador.

Mejores prácticas para un sistema de cámara

Al implementar un sistema de cámara en su juego de Python Arcade, es esencial seguir las mejores prácticas para garantizar una funcionalidad óptima y una experiencia fluida para los jugadores. Aquí hay algunas pautas clave a tener en cuenta:

  • Evite el movimiento excesivo de la cámara: Si bien la cámara puede agregar elementos dinámicos a su juego, es crucial lograr un equilibrio y evitar el movimiento excesivo de la cámara. Cambiar constantemente la posición de la cámara puede desorientar a los jugadores y dificultarles la navegación por el mundo del juego.
  • Prueba a través de diferentes resoluciones y relaciones de aspecto: Es esencial probar su sistema de cámara en varias resoluciones de pantalla y relaciones de aspecto para asegurarse de que funcione bien en diferentes dispositivos y configuraciones. Esto lo ayudará a identificar cualquier problema relacionado con la escala de la ventana gráfica, el posicionamiento de objetos o los ajustes de la relación de aspecto.
  • Optimizar renderizado: El sistema de cámara puede afectar potencialmente el rendimiento del juego, especialmente cuando se renderizan mundos de juegos grandes o numerosos objetos. Para optimizar el renderizado, determine qué objetos están fuera de la vista de la cámara y exclúyalos del renderizado.
  • Manejar casos extremos: preste atención a los casos extremos en los que la cámara puede encontrar escenarios específicos, como límites, detección de colisiones u objetos superpuestos. Asegúrese de que el sistema de cámara maneje estos casos con gracia y proporcione transiciones suaves o señales visuales apropiadas para indicar limitaciones o interacciones con el entorno del juego.

Al seguir estas prácticas recomendadas, puede crear un sistema de cámara robusto y fácil de usar que se integre a la perfección en sus juegos de Python Arcade.

Haz que los juegos sean más divertidos usando la cámara

Al agregar una cámara a sus juegos de Python Arcade, puede mejorar en gran medida la inmersión y el compromiso del jugador. Ya sea que esté creando mundos de juegos expansivos, enfocándose en áreas críticas o rastreando objetos en movimiento, el sistema de cámara proporciona una herramienta poderosa para los desarrolladores de juegos.

Al aprovechar el movimiento de la cámara, el zoom y los efectos adicionales, puede crear experiencias fascinantes que cautiven a los jugadores y los hagan regresar por más.