Cómo agregar objetos en movimiento al azar usando la biblioteca Arcade de Python

Los objetos que se mueven al azar pueden traer emoción e imprevisibilidad a los juegos. Los hace más atractivos y desafiantes para los jugadores. La biblioteca Arcade de Python proporciona una manera simple y eficiente de incorporar objetos en movimiento aleatorio en sus juegos.

Crea un juego simple

Antes de comenzar, asegúrese de tener pip instalado en su dispositivo. Use este comando para instalar el arcada biblioteca:

pip instalar arcade

Después de eso, crea una ventana usando el arcada. Ventana clase y establezca el color de fondo en blanco.

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

Establezca la posición del jugador en el centro de la pantalla horizontalmente y agregue una pequeña distancia desde la parte superior. Puedes controlar el movimiento del jugador usando las teclas de flecha.

Aquí está el código para nuestro juego básico:

importar arcada
ANCHO_PANTALLA = 800
PANTALLA_ALTURA = 600
RADIO_JUGADOR = 15
claseMi juego(arcada. Ventana):
definitivamente__en eso__(uno mismo, ancho, alto):
 super().__init__(ancho, alto)
 arcade.set_background_color (arcade.color. BLANCO)
 self.jugador_x = ANCHO_PANTALLA // 2
 self.player_y = PLAYER_RADIUS + 10
definitivamenteen_dibujar(ser):
 arcade.start_render()
 arcade.draw_circle_filled (self.player_x, self.player_y, PLAYER_RADIUS, arcade.color. AZUL)
definitivamenteactualizar(uno mismo, delta_time):
aprobar
definitivamenteon_key_press(auto, clave, modificadores):
si clave == arcade.clave. IZQUIERDA:
 self.jugador_x -= 5
elif clave == arcade.clave. BIEN:
 self.jugador_x += 5
si __nombre__ == "__principal__":
 juego = MiJuego (PANTALLA_ANCHO, PANTALLA_ALTO)
 arcade.ejecutar()

Adición de varios objetos

Para agregar objetos en movimiento al azar a su juego, cree una lista para almacenar las posiciones de los objetos y actualícelos en cada cuadro. También puedes usar sprites como objetos.

En el código de tu juego, agrega una lista llamada objetos para almacenar las posiciones de los objetos en movimiento aleatorio. Después de eso, genere la cantidad de objetos (NUM_OBJECTS) con coordenadas x e y aleatorias dentro de los límites de la pantalla. Los objetos se dibujan como círculos rojos usando el arcade.draw_circle_filled función.

importar arcada
importar aleatorio
ANCHO_PANTALLA = 800
PANTALLA_ALTURA = 600
RADIO_JUGADOR = 15
OBJETO_RADIO = 10
NUM_OBJETOS = 10
claseMi juego(arcada. Ventana):
definitivamente__en eso__(uno mismo, ancho, alto):
 super().__init__(ancho, alto)
 arcade.set_background_color (arcade.color. BLANCO)
 self.jugador_x = ANCHO_PANTALLA // 2
 self.player_y = PLAYER_RADIUS + 10
 self.objetos = []
para _ en rango (NUM_OBJECTS):
 x = aleatorio.randint(0, ANCHO_PANTALLA)
 y = aleatorio.randint(0, ALTURA_PANTALLA)
 self.objetos.append((x, y))
definitivamenteen_dibujar(ser):
 arcade.start_render()
 arcade.draw_circle_filled (self.player_x, self.player_y, PLAYER_RADIUS, arcade.color. AZUL)
para objeto en self.objetos:
 x, y = objeto
 arcade.draw_circle_filled (x, y, OBJECT_RADIUS, arcade.color. ROJO)
definitivamenteactualizar(uno mismo, delta_time):
aprobar
definitivamenteon_key_press(auto, clave, modificadores):
si clave == arcade.clave. IZQUIERDA:
 self.jugador_x -= 5
elif clave == arcade.clave. BIEN:
 self.jugador_x += 5
si __nombre__ == "__principal__":
 juego = MiJuego (PANTALLA_ANCHO, PANTALLA_ALTO)
 arcade.ejecutar()

A continuación se muestra la salida:

Implementación del algoritmo de movimiento aleatorio

Para hacer que los objetos se muevan al azar, actualice sus posiciones en el actualizar utilizando un algoritmo de movimiento aleatorio.

Iterar a través de cada objeto y generar valores aleatorios para dx y dy, que representa el cambio en las coordenadas x e y. Luego actualice la posición del objeto agregando estos valores. Aquí está el código modificado:

definitivamenteactualizar(uno mismo, delta_time):
para i en rango (NUM_OBJECTS):
 x, y = self.objetos[i]
 dx = random.randint(-5, 5)
 dy = random.randint(-5, 5)
 x += dx
 y += día
 self.objetos[i] = (x, y)

A continuación se muestra la salida:

Objetos que se mueven hacia el jugador

Para agregar más interacción, haga que los objetos se muevan hacia el jugador. Puede lograr esto calculando el vector de dirección entre el objeto y el jugador y ajustando la posición del objeto en consecuencia.

Para ello, calcula las diferencias en las coordenadas x e y entre el objeto y el jugador. Al normalizar estos valores, obtiene un vector de dirección. Luego multiplique este vector por un factor de velocidad (3 en este caso) y súmelo a la posición del objeto. Aquí está la actualización actualizar método:

definitivamenteactualizar(uno mismo, delta_time):
para i en rango (NUM_OBJECTS):
 x, y = self.objetos[i]
 dx = self.jugador_x - x
 dy = self.jugador_y - y
 distancia = matemáticas.sqrt (dx ** 2 + dí ** 2)
 dx /= distancia
 dy /= distancia
 x += dx * 3
 y += dy * 3
 self.objetos[i] = (x, y)

A continuación se muestra la salida:

Los objetos comienzan a moverse cuando el jugador ingresa a los alrededores

Para agregar más dinámicas, modifique el código para que los objetos comiencen a moverse solo cuando el jugador ingrese a su área circundante. Añade el código para el movimiento del jugador y defina un radio dentro del cual los objetos se vuelven activos.

definitivamenteactualizar(uno mismo, delta_time):
para i en rango (NUM_OBJECTS):
 x, y = self.objetos[i]
 dx = self.jugador_x - x
 dy = self.jugador_y - y
 distancia = matemáticas.sqrt (dx ** 2 + dí ** 2)

si distancia < 100: # Ajuste el radio según sea necesario
 dx /= distancia
 dy /= distancia
 x += dx * 3
 y += dy * 3
 self.objetos[i] = (x, y)

Detección e interacción de colisiones

Ahora, agregue detección de colisión entre el jugador y los objetos, y defina el comportamiento cuando ocurra una colisión. Modificar el actualizar método para manejar colisiones:

definitivamenteactualizar(uno mismo, delta_time):
para i en rango (NUM_OBJECTS):
 x, y = self.objetos[i]
 dx = self.jugador_x - x
 dy = self.jugador_y - y
 distancia = matemáticas.sqrt (dx ** 2 + dí ** 2)

si distancia < PLAYER_RADIUS + OBJECT_RADIUS:
# si ocurrió una colisión, manejarlo aquí
 self.objetos.pop (i)
 self.objetos.append((random.randint(0, ANCHO_PANTALLA), aleatorio.randint(0, PANTALLA_ALTURA)))

elif distancia < 100:
 dx /= distancia
 dy /= distancia
 x += dx * 3
 y += dy * 3
 self.objetos[i] = (x, y)

Equilibrar la aleatoriedad

Para crear una experiencia de juego equilibrada, es importante afinar el movimiento aleatorio y la generación de objetos. Aquí hay algunos ejemplos de cómo puede ajustar el código para lograr un mejor equilibrio en su juego:

Limitación de la velocidad máxima

Para evitar que los objetos se muevan demasiado rápido, puede introducir un límite de velocidad máxima. Modificar el actualizar método para incluir restricciones de velocidad:

definitivamenteactualizar(uno mismo, delta_time):
para i en rango (NUM_OBJECTS):
 x, y = self.objetos[i]
 dx = self.jugador_x - x
 dy = self.jugador_y - y
 distancia = matemáticas.sqrt (dx ** 2 + dí ** 2)
si distancia < PLAYER_RADIUS + OBJECT_RADIUS:
 self.objetos.pop (i)
 self.objetos.append((random.randint(0, ANCHO_PANTALLA), aleatorio.randint(0, PANTALLA_ALTURA)))
elif distancia < 100:
 dx /= distancia
 dy /= distancia
 velocidad = 3# Ajuste el valor de la velocidad según sea necesario
 dx = min (máx (dx * velocidad, -MAX_SPEED), MAX_SPEED)
 dy = min (máx (dy * velocidad, -MAX_SPEED), MAX_SPEED)
 x += dx
 y += día
 self.objetos[i] = (x, y)

Control de la tasa de generación

También puedes controlar la velocidad a la que aparecen nuevos objetos en el juego. Ajuste el código para incluir un retraso entre la generación de nuevos objetos:

importar tiempo
claseMi juego(arcada. Ventana):
definitivamente__en eso__(uno mismo, ancho, alto):
 super().__init__(ancho, alto)
 arcade.set_background_color (arcade.color. BLANCO)
 self.jugador_x = ANCHO_PANTALLA // 2
 self.player_y = PLAYER_RADIUS + 10
 self.objetos = []
 self.last_spawn_time = tiempo.tiempo()
definitivamenteactualizar(uno mismo, delta_time):
# controlar la tasa de desove aquí
si time.time() - self.last_spawn_time > SPAWN_DELAY:
si len (self.objetos) < MAX_OBJECTS:
 self.objetos.append((random.randint(0, ANCHO_PANTALLA), aleatorio.randint(0, PANTALLA_ALTURA)))
 self.last_spawn_time = tiempo.tiempo()
para i en rango (len (auto.objetos)):
 x, y = self.objetos[i]
 dx = self.jugador_x - x
 dy = self.jugador_y - y
 distancia = matemáticas.sqrt (dx ** 2 + dí ** 2)
si distancia < PLAYER_RADIUS + OBJECT_RADIUS:
 self.objetos.pop (i)
 self.objetos.append((random.randint(0, ANCHO_PANTALLA), aleatorio.randint(0, PANTALLA_ALTURA)))
elif distancia < 100:
 dx /= distancia
 dy /= distancia
 x += dx * 3
 y += dy * 3
 self.objetos[i] = (x, y)

Ajustar el APAGAR_DELAY y MAX_OBJETOS valores para encontrar el equilibrio adecuado para su juego. Un retraso mayor o un número máximo de objetos menor hará que el juego esté menos concurrido. Considerando que, un retraso más corto o un máximo más grande aumentará la dificultad.

Haz que los juegos sean más divertidos usando objetos en movimiento

Agregar objetos en movimiento aleatorio a los juegos puede mejorar significativamente la experiencia general. Presentan imprevisibilidad y desafío, lo que hace que el juego sea más atractivo y dinámico. Los jugadores tendrán que adaptarse y reaccionar rápidamente para evitar colisiones o atrapar objetos, y eso proporcionará una sensación de emoción y logro.