Cómo crear un juego 2D con Python y una biblioteca arcade

Hola Habr! Te presento la traducción del artículo Cómo crear un juego 2D con Python y la biblioteca Arcade de Paul Vincent Craven

Cómo crear un juego 2D con Python y una biblioteca arcade

Aprende cómo comenzar con Arcade, una biblioteca de Python fácil de usar para crear videojuegos en 2D.

Phython es un gran lenguaje para las personas que aprenden programación, y es ideal para aquellos que quieren "hacer algo" y no pasar mucho tiempo en código repetitivo. Arcade es una biblioteca de Python para crear videojuegos en 2D que es fácil de usar y muy efectiva cuando adquieres experiencia. En este artículo, explicaré cómo comenzar a usar Python y Arcade para programar videojuegos.

Comencé el desarrollo en Arcade después de enseñar a los estudiantes a usar la biblioteca PyGame . Enseñé personalmente usando PyGame durante casi 10 años, y desarrollé ProgramArcadeGames .com para enseñar en línea. PyGame es genial, pero al final sentí que estaba perdiendo el tiempo cubriendo errores que nunca se corrigieron .
Me preocupaba enseñar cosas como el bucle de eventos , que ya no era la forma en que codificamos. Tenía una sección completa en la que explicaba por qué se voltearon las coordenadas Y. Dado que PyGame rara vez se actualizaba, y se basa en la antigua biblioteca SDL 1, y no en algo más moderno, como OpenGL , no tenía muchas esperanzas para el futuro.

Quería crear una biblioteca que fuera más fácil de usar, más potente y utilizara algunas de las nuevas características de Python 3, como decoradores y sugerencias de tipo. Esta es una sala de juegos. Y aquí está cómo comenzar.

Instalación

Arcade, como muchos otros paquetes, está disponible a través de PyPi , lo que significa que puede instalar Arcade usando el comando pip (o el comando pipenv). Si ya tiene Python instalado, probablemente pueda abrir un símbolo del sistema en Windows y escribir:

pip install arcade 

O en MacOS y Linux:

 pip3 install arcade 

Para obtener instrucciones de instalación más detalladas, puede consultar la documentación de instalación de Arcade .

Dibujo simple

Puede abrir la ventana y crear dibujos simples con solo unas pocas líneas de código. Creemos un ejemplo que dibuje un smiley, como se muestra en la imagen a continuación:

El siguiente algoritmo muestra cómo puede usar los comandos de dibujo de Arcade para hacer esto. Tenga en cuenta que no necesita saber cómo usar clases o incluso definir funciones. La programación con retroalimentación visual rápida es excelente para aquellos que desean comenzar a aprender programación.

 import arcade # Set constants for the screen size SCREEN_WIDTH = 600 SCREEN_HEIGHT = 600 # Open the window. Set the window title and dimensions (width and height) arcade.open_window(SCREEN_WIDTH, SCREEN_HEIGHT, "Drawing Example") # Set the background color to white. # For a list of named colors see: # http://arcade.academy/arcade.color.html # Colors can also be specified in (red, green, blue) format and # (red, green, blue, alpha) format. arcade.set_background_color( arcade.color.WHITE) # Start the render process. This must be done before any drawing commands. arcade.start_render() # Draw the face x = 300 y = 300 radius = 200 arcade.draw_circle_filled( x, y, radius, arcade.color.YELLOW) # Draw the right eye x = 370 y = 350 radius = 20 arcade.draw_circle_filled( x, y, radius, arcade.color.BLACK) # Draw the left eye x = 230 y = 350 radius = 20 arcade.draw_circle_filled( x, y, radius, arcade.color.BLACK) # Draw the smile x = 300 y = 280 width = 120 height = 100 start_angle = 190 end_angle = 350 arcade.draw_arc_outline( x, y, width, height, arcade.color.BLACK, start_angle, end_angle, 10) # Finish drawing and display the result arcade.finish_render() # Keep the window open until the user hits the 'close' button arcade.run() 

Uso de la función

Por supuesto, escribir código en un contexto global no es una buena forma. Afortunadamente, mejorar su programa con funciones es fácil. Aquí podemos ver un ejemplo de dibujo de pino en un lugar específico (x, y) usando la función:

 def draw_pine_tree(x, y) : """ This function draws a pine tree at the specified location. """ # Draw the triangle on top of the trunk. # We need three x, y points for the triangle. arcade.draw_triangle_filled( x + 40, y, # Point 1 x, y - 100, # Point 2 x + 80, y - 100, # Point 3 arcade.color.DARK_GREEN) # Draw the trunk arcade.draw_lrtb_rectangle_filled( x + 30, x + 50, y - 100, y - 140 , arcade.color.DARK_BROWN) 

Para un ejemplo completo, vea dibujar con funciones .

Un programador más experimentado sabrá que los programas gráficos modernos primero cargan información gráfica en la tarjeta de video y luego le piden a la tarjeta de video que la dibuje más tarde como un paquete. Arcade también es compatible con esto. Dibujar 10,000 rectángulos individualmente toma alrededor de .800 segundos. Dibujarlos como un paquete lleva menos de 0.001 segundos.

clase de ventana

Los programas más grandes generalmente heredan de la clase Window o usan decoradores . Esto le permite al programador escribir código para manejar el dibujo, la actualización y el procesamiento de la entrada del usuario. La plantilla para iniciar el programa de ventana se muestra a continuación.

 import arcade SCREEN_WIDTH = 800 SCREEN_HEIGHT = 600 class MyGame( arcade.Window): """ Main application class. """ def __init__(self, width, height) : super( ) .__init__(width, height) arcade.set_background_color( arcade.color.AMAZON) def setup( self) : # Set up your game here pass def on_draw(self) : """ Render the screen. """ arcade.start_render() # Your drawing code goes here def update(self, delta_time) : """ All the logic to move, and the game logic goes here. """ pass def main( ) : game = MyGame( SCREEN_WIDTH, SCREEN_HEIGHT) game.setup( ) arcade.run() if __name__ = = "__main__": main() 

La clase Window tiene varios métodos que sus programas pueden anular para proporcionar la funcionalidad del programa. Estos son algunos de los más utilizados:

on_draw: todo el código para dibujar una pantalla va aquí.
Actualización: todo el código para mover tus elementos y ejecutar la lógica del juego está aquí. Esto se llama aproximadamente 60 veces por segundo.
on_key_press: maneja eventos cuando se presiona una tecla, por ejemplo, dale velocidad al jugador.
on_key_release: procesa cuando se suelta la clave, aquí puedes detener el movimiento del jugador.
on_mouse_motion: se llama cada vez que se mueve el mouse.
on_mouse_press: se llama cuando se hace clic en el botón del mouse.
set_viewport: esta función se usa en juegos de desplazamiento cuando su mundo es mucho más grande de lo que puede ver en una pantalla. La llamada set_viewport permite al programador establecer qué parte de este mundo está visible actualmente.

Sprites

Los sprites son una manera fácil de crear un objeto ráster bidimensional en Arcade. Arcade tiene métodos que hacen que dibujar, mover y animar sprites sea más fácil. También puede usar fácilmente sprites para detectar colisiones entre objetos.

Creación de sprites

Crear una instancia de la clase Sprite Arcade a partir de gráficos es fácil. El programador solo necesita el nombre del archivo de imagen para que el sprite se base y, opcionalmente, un número, para escalar la imagen hacia arriba o hacia abajo. Por ejemplo:

 SPRITE_SCALING_COIN = 0,2 coin = arcade.Sprite("coin_01.png", SPRITE_SCALING_COIN) 

Este código creará un sprite usando la imagen almacenada en coin_01.png. La imagen se reducirá al 20% de su altura y anchura originales.

Listas de sprites

Los sprites generalmente se organizan en listas. Estas listas facilitan el manejo de los sprites. Los sprites de la lista usarán OpenGL para dibujar sprites por lotes como grupo. El siguiente código configura un juego con un jugador y un montón de monedas que el jugador recoge. Usamos dos listas, una para el jugador y otra para las monedas.

 def setup(self): """ Set up the game and initialize the variables. """ # Create the sprite lists self.player_list = arcade.SpriteList() self.coin_list = arcade.SpriteList() # Score self.score = 0 # Set up the player # Character image from kenney.nl self. player_sprite = arcade.Sprite("images/character.png", SPRITE_SCALING_PLAYER) self.player_sprite.center_x = 50 # Starting position self.player_sprite.center_y = 50 self.player_list.append(self.player_sprite) # Create the coins for i in range( COIN_COUNT): # Create the coin instance # Coin image from kenney.nl coin = arcade.Sprite("images/coin_01.png", SPRITE_SCALING_COIN) # Position the coin coin.center_x = random.randrange(SCREEN_WIDTH) coin.center_y = random.randrange(SCREEN_HEIGHT) # Add the coin to the lists self.coin_list.append(coin) 

Podemos dibujar fácilmente todas las monedas en las listas de monedas:

 def on_draw(self): """ Draw everything """ arcade.start_render() self.coin_list.draw() self.player_list.draw() 

Detección de colisión de sprites

Detección de colisión de sprites
La función check_for_collision_with_list nos permite ver si un sprite se encuentra con otro sprite en la lista. Podemos usar esto para ver todas las monedas con las que el sprite del jugador está en contacto. Usando un bucle for simple, podemos deshacernos de la moneda del juego y aumentar nuestra puntuación.

 def update(self, delta_time): # Generate a list of all coin sprites that collided with the player. coins_hit_list = arcade.check_for_collision_with_list(self.player_sprite, self.coin_list) # Loop through each colliding sprite, remove it, and add to the score. for coin in coins_hit_list: coin.kill() self.score += 1 

Para un ejemplo completo, vea collect_coins.py .

Juego de física

Muchos juegos incluyen algún tipo de física. Los más simples son los programas de arriba hacia abajo que evitan que el jugador atraviese paredes. Los plataformas agregan más complejidad a la gravedad y a las plataformas móviles. Algunos juegos usan un motor de física 2D completo con masa, fricción, resortes y más.

Juegos de arriba hacia abajo

Para juegos simples de arriba hacia abajo, el programa arcade necesita una lista de paredes a través de las cuales el jugador (o cualquier otra cosa) no puede pasar. Normalmente lo llamo wall_list. Luego, el motor de física se crea en el código de instalación de la clase Window usando:

 self.physics_engine = arcade.PhysicsEngineSimple(self.player_sprite, self.wall_list) 

Player_sprite recibe un vector de movimiento con dos atributos: change_x y change_y. Un ejemplo simple de esto es mover a un jugador usando el teclado. Por ejemplo, esto podría estar en un hijo personalizado de la clase Window:

 MOVEMENT_SPEED = 5 def on_key_press(self, key, modifiers) : """Called whenever a key is pressed. """ if key = = arcade.key.UP: self.player_sprite.change_y = MOVEMENT_SPEED elif key = = arcade.key.DOWN: self.player_sprite.change_y = -MOVEMENT_SPEED elif key = = arcade.key.LEFT: self.player_sprite.change_x = -MOVEMENT_SPEED elif key = = arcade.key.RIGHT: self.player_sprite.change_x = MOVEMENT_SPEED def on_key_release(self, key, modifiers) : """Called when the user releases a key. """ if key = = arcade.key.UP or key = = arcade.key.DOWN: self.player_sprite.change_y = 0 elif key = = arcade.key.LEFT or key = = arcade.key.RIGHT: selfplayer_sprite.change_x = 0 

Aunque este código establece la velocidad del jugador, no lo mueve. En el método de actualización de la clase Window, al llamar a Physics_engine.update (), el jugador se moverá, pero no a través de las paredes.

 def update(self, delta_time): """ Movement and game logic """ self.physics_engine.update() 

Para un ejemplo completo, vea sprite_move_walls.py .

Plataformas

Cambiar a un juego de plataformas con una vista lateral es bastante simple. El programador solo necesita cambiar el motor de física a PhysicsEnginePlatformer y agregar la constante gravitacional.

 self.physics_engine = arcade.PhysicsEnginePlatformer(self.player_sprite, self.wall_list, gravity_constant= GRAVITY) 

Puedes usar un programa como Mosaico para colocar los mosaicos / bloques que componen tu nivel.

Para ver un ejemplo, vea sprite_tiled_map.py .

Para una física 2D completa, puede integrar la biblioteca PyMunk.

Aprende de un ejemplo

Una de las mejores formas de aprender es un ejemplo. La Biblioteca Arcade tiene una larga lista de ejemplos de programas que las personas pueden usar para crear juegos. Cada uno de estos ejemplos muestra el concepto de un juego que los estudiantes han pedido en mis lecciones o en Internet a lo largo de los años.

Ejecutar cualquiera de estas demostraciones es fácil después de instalar Arcade. Cada uno de los ejemplos tiene un comentario al comienzo del programa con un comando que puede ingresar en la línea de comando para ejecutar el ejemplo, por ejemplo:

 python -m arcade.examples.sprite_moving_platforms 

Breve informacion

Arcade te permite comenzar a programar gráficos y juegos con un código fácil de entender. Muchos programadores nuevos crearon grandes juegos poco después del comienzo. ¡Pruébalo!