Les objets en mouvement aléatoire peuvent apporter de l’excitation et de l’imprévisibilité aux jeux. Ils les rendent plus attrayants et plus stimulants pour les joueurs. La bibliothèque Arcade de Python fournit un moyen simple et efficace d’incorporer des objets aléatoires dans vos jeux.
Créer un jeu simple
Avant de commencer, assurez-vous que pip est installé sur votre appareil. Utilisez cette commande pour installer le programme arcade bibliothèque :
pip install arcade Ensuite, créez une fenêtre à l’aide de la commande arcade.Window et définir la couleur d’arrière-plan à blanc.
Le code utilisé dans cet article est disponible dans ce dépôt GitHub et est libre d’utilisation sous la licence MIT.
Définissez la position du joueur au milieu de l’écran horizontalement et ajoutez une petite distance par rapport au haut de l’écran. Vous pouvez contrôler le mouvement du joueur en utilisant les touches fléchées.
Voici le code de notre jeu de base :
import arcade
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
PLAYER_RADIUS = 15
class MyGame(arcade.Window):
def __init__(self, width, height):
super().__init__(width, height)
arcade.set_background_color(arcade.color.WHITE)
self.player_x = SCREEN_WIDTH // 2
self.player_y = PLAYER_RADIUS + 10
def on_draw(self):
arcade.start_render()
arcade.draw_circle_filled(self.player_x, self.player_y, PLAYER_RADIUS, arcade.color.BLUE)
def update(self, delta_time):
pass
def on_key_press(self, key, modifiers):
if key == arcade.key.LEFT:
self.player_x -= 5
elif key == arcade.key.RIGHT:
self.player_x += 5
if __name__ == "__main__":
game = MyGame(SCREEN_WIDTH, SCREEN_HEIGHT)
arcade.run() Ajout d’objets multiples
Pour ajouter des objets mobiles aléatoires à votre jeu, créez une liste pour stocker les positions de l’objet et mettez-les à jour à chaque image. Vous pouvez également utiliser des sprites comme objets.
Dans le code de votre jeu, ajoutez une liste appelée objets pour stocker les positions des objets mobiles aléatoires. Ensuite, on génère le nombre d’objets (NUM_OBJECTS) avec des coordonnées x et y aléatoires à l’intérieur des limites de l’écran. Les objets sont dessinés sous forme de cercles rouges à l’aide de la fonction arcade.draw_circle_filled fonction.
import arcade
import random
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
PLAYER_RADIUS = 15
OBJECT_RADIUS = 10
NUM_OBJECTS = 10
class MyGame(arcade.Window):
def __init__(self, width, height):
super().__init__(width, height)
arcade.set_background_color(arcade.color.WHITE)
self.player_x = SCREEN_WIDTH // 2
self.player_y = PLAYER_RADIUS + 10
self.objects = []
for _ in range(NUM_OBJECTS):
x = random.randint(0, SCREEN_WIDTH)
y = random.randint(0, SCREEN_HEIGHT)
self.objects.append((x, y))
def on_draw(self):
arcade.start_render()
arcade.draw_circle_filled(self.player_x, self.player_y, PLAYER_RADIUS, arcade.color.BLUE)
for obj in self.objects:
x, y = obj
arcade.draw_circle_filled(x, y, OBJECT_RADIUS, arcade.color.RED)
def update(self, delta_time):
pass
def on_key_press(self, key, modifiers):
if key == arcade.key.LEFT:
self.player_x -= 5
elif key == arcade.key.RIGHT:
self.player_x += 5
if __name__ == "__main__":
game = MyGame(SCREEN_WIDTH, SCREEN_HEIGHT)
arcade.run() Voici le résultat :
Implémentation de l’algorithme de mouvement aléatoire
Pour que les objets se déplacent de manière aléatoire, il faut mettre à jour leurs positions dans la base de données mise à jour en utilisant un algorithme de mouvement aléatoire.
Itérer à travers chaque objet et générer des valeurs aléatoires pour dx et dyreprésentant la modification des coordonnées x et y. Mettez ensuite à jour la position de l’objet en ajoutant ces valeurs. Voici le code modifié :
def update(self, delta_time):
for i in range(NUM_OBJECTS):
x, y = self.objects[i]
dx = random.randint(-5, 5)
dy = random.randint(-5, 5)
x += dx
y += dy
self.objects[i] = (x, y) Voici le résultat :
Objets se déplaçant vers le joueur
Pour ajouter plus d’interaction, faites en sorte que les objets se déplacent vers le joueur. Pour ce faire, calculez le vecteur de direction entre l’objet et le joueur et ajustez la position de l’objet en conséquence.
Pour cela, calculez les différences de coordonnées x et y entre l’objet et le joueur. En normalisant ces valeurs, vous obtenez un vecteur de direction. Multipliez ensuite ce vecteur par un facteur de vitesse (3 dans ce cas) et ajoutez-le à la position de l’objet. Voici le vecteur mis à jour mise à jour méthode :
def update(self, delta_time):
for i in range(NUM_OBJECTS):
x, y = self.objects[i]
dx = self.player_x - x
dy = self.player_y - y
distance = math.sqrt(dx ** 2 + dy ** 2)
dx /= distance
dy /= distance
x += dx * 3
y += dy * 3
self.objects[i] = (x, y) Voici le résultat :
Les objets commencent à se déplacer lorsque le joueur entre dans son environnement
Pour ajouter une dynamique supplémentaire, modifiez le code pour que les objets ne commencent à bouger que lorsque le joueur entre dans leur zone environnante. Ajoutez le code pour le mouvement du joueur et définissez un rayon dans lequel les objets deviennent actifs.
def update(self, delta_time):
for i in range(NUM_OBJECTS):
x, y = self.objects[i]
dx = self.player_x - x
dy = self.player_y - y
distance = math.sqrt(dx ** 2 + dy ** 2)
if distance < 100: # Adjust the radius as needed
dx /= distance
dy /= distance
x += dx * 3
y += dy * 3
self.objects[i] = (x, y) Détection des collisions et interaction
Maintenant, ajoutez la détection de collision entre le joueur et les objets, et définissez le comportement lorsqu’une collision se produit. Modifiez l’élément mise à jour Méthode de gestion des collisions :
def update(self, delta_time):
for i in range(NUM_OBJECTS):
x, y = self.objects[i]
dx = self.player_x - x
dy = self.player_y - y
distance = math.sqrt(dx ** 2 + dy ** 2)
if distance < PLAYER_RADIUS + OBJECT_RADIUS:
# if collision occurred, handle it here
self.objects.pop(i)
self.objects.append((random.randint(0, SCREEN_WIDTH), random.randint(0, SCREEN_HEIGHT)))
elif distance < 100:
dx /= distance
dy /= distance
x += dx * 3
y += dy * 3
self.objects[i] = (x, y) Équilibrer le hasard
Pour créer une expérience de jeu équilibrée, il est important d’ajuster le mouvement aléatoire et l’apparition des objets. Voici quelques exemples de la façon dont vous pouvez ajuster le code pour obtenir un meilleur équilibre dans votre jeu :
Limitation de la vitesse maximale
Pour éviter que les objets ne se déplacent trop vite, vous pouvez introduire une limite de vitesse maximale. Modifier la mise à jour pour inclure les contraintes de vitesse :
def update(self, delta_time):
for i in range(NUM_OBJECTS):
x, y = self.objects[i]
dx = self.player_x - x
dy = self.player_y - y
distance = math.sqrt(dx ** 2 + dy ** 2)
if distance < PLAYER_RADIUS + OBJECT_RADIUS:
self.objects.pop(i)
self.objects.append((random.randint(0, SCREEN_WIDTH), random.randint(0, SCREEN_HEIGHT)))
elif distance < 100:
dx /= distance
dy /= distance
speed = 3 # Adjust the speed value as needed
dx = min(max(dx * speed, -MAX_SPEED), MAX_SPEED)
dy = min(max(dy * speed, -MAX_SPEED), MAX_SPEED)
x += dx
y += dy
self.objects[i] = (x, y) Contrôle du taux de reproduction
Vous pouvez également contrôler la vitesse à laquelle les nouveaux objets apparaissent dans le jeu. Ajustez le code pour inclure un délai entre l’apparition de nouveaux objets :
import time
class MyGame(arcade.Window):
def __init__(self, width, height):
super().__init__(width, height)
arcade.set_background_color(arcade.color.WHITE)
self.player_x = SCREEN_WIDTH // 2
self.player_y = PLAYER_RADIUS + 10
self.objects = []
self.last_spawn_time = time.time()
def update(self, delta_time):
# control the spawning rate here
if time.time() - self.last_spawn_time > SPAWN_DELAY:
if len(self.objects) < MAX_OBJECTS:
self.objects.append((random.randint(0, SCREEN_WIDTH), random.randint(0, SCREEN_HEIGHT)))
self.last_spawn_time = time.time()
for i in range(len(self.objects)):
x, y = self.objects[i]
dx = self.player_x - x
dy = self.player_y - y
distance = math.sqrt(dx ** 2 + dy ** 2)
if distance < PLAYER_RADIUS + OBJECT_RADIUS:
self.objects.pop(i)
self.objects.append((random.randint(0, SCREEN_WIDTH), random.randint(0, SCREEN_HEIGHT)))
elif distance < 100:
dx /= distance
dy /= distance
x += dx * 3
y += dy * 3
self.objects[i] = (x, y) Ajustez le code SPAWN_DELAY et MAX_OBJECTS Les valeurs de l’indicateur de performance permettent de trouver le bon équilibre pour votre jeu. Un délai plus long ou un nombre maximal d’objets plus faible rendra le jeu moins encombré. En revanche, un délai plus court ou un nombre maximal d’objets plus élevé augmentera la difficulté.
Rendre les jeux plus amusants en utilisant des objets en mouvement
L’ajout d’objets mobiles aléatoires dans les jeux peut améliorer considérablement l’expérience globale. Ils introduisent de l’imprévisibilité et du défi, ce qui rend le jeu plus intéressant et plus dynamique. Les joueurs devront s’adapter et réagir rapidement pour éviter les collisions ou attraper les objets, ce qui leur procurera un sentiment d’excitation et d’accomplissement.