Rendez vos jeux d'arcade encore plus agréables et excitants en ajoutant des objets mobiles aléatoires.

Les objets en mouvement aléatoires peuvent apporter de l'excitation et de l'imprévisibilité aux jeux. Cela les rend plus attrayants et stimulants pour les joueurs. La bibliothèque Arcade de Python offre un moyen simple et efficace d'incorporer des objets mobiles aléatoires dans vos jeux.

Créer un jeu simple

Avant de commencer, assurez-vous d'avoir pip installé sur votre appareil. Utilisez cette commande pour installer le arcade bibliothèque:

pip installer arcade

Après cela, créez une fenêtre en utilisant le arcade. Fenêtre classe et définissez la couleur d'arrière-plan sur blanc.

Le code utilisé dans cet article est disponible dans ce Référentiel GitHub et est libre d'utilisation sous la licence MIT.

Réglez la position du joueur au milieu de l'écran horizontalement et ajoutez une petite distance à partir du haut. Vous pouvez contrôler le mouvement du joueur en utilisant les touches fléchées.

instagram viewer

Voici le code de notre jeu de base :

importer arcade
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
PLAYER_RADIUS = 15


classeMon jeu(arcade. Fenêtre):
définitivement__init__(soi, largeur, hauteur):
 super().__init__(largeur, hauteur)
 arcade.set_background_color (arcade.color. BLANC)


 self.player_x = SCREEN_WIDTH // 2
 self.player_y = PLAYER_RADIUS + 10


définitivementon_draw(soi):
 arcade.start_render()
 arcade.draw_circle_filled (self.player_x, self.player_y, PLAYER_RADIUS, arcade.color. BLEU)


définitivementmise à jour(soi, delta_time):
passer


définitivementon_key_press(soi, clé, modificateurs):
si clé == arcade.clé. GAUCHE:
 self.player_x -= 5
elif clé == arcade.clé. DROITE:
 self.player_x += 5
si __nom__ == "__principal__":
 jeu = MonJeu (SCREEN_WIDTH, SCREEN_HEIGHT)
 arcade.run()

Ajout de plusieurs objets

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 aussi utiliser sprites en tant qu'objets.

Dans votre code de jeu, ajoutez une liste appelée objets pour stocker les positions des objets mobiles aléatoires. Après cela, générez le nombre d'objets (NUM_OBJETS) avec des coordonnées x et y aléatoires dans les limites de l'écran. Les objets sont dessinés sous forme de cercles rouges à l'aide de la arcade.draw_circle_filled fonction.

importer arcade
importer aléatoire
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
PLAYER_RADIUS = 15
OBJET_RAYON = 10
NUM_OBJETS = 10


classeMon jeu(arcade. Fenêtre):
définitivement__init__(soi, largeur, hauteur):
 super().__init__(largeur, hauteur)
 arcade.set_background_color (arcade.color. BLANC)


 self.player_x = SCREEN_WIDTH // 2
 self.player_y = PLAYER_RADIUS + 10


 self.objects = []
pour _ dans plage (NUM_OBJECTS) :
 x = aléatoire.randint(0, SCREEN_WIDTH)
 y = aléatoire.randint(0, SCREEN_HEIGHT)
 self.objects.append((x, y))


définitivementon_draw(soi):
 arcade.start_render()
 arcade.draw_circle_filled (self.player_x, self.player_y, PLAYER_RADIUS, arcade.color. BLEU)


pour obj dans self.objects :
 x, y = obj
 arcade.draw_circle_filled (x, y, OBJECT_RADIUS, arcade.color. ROUGE)


définitivementmise à jour(soi, delta_time):
passer


définitivementon_key_press(soi, clé, modificateurs):
si clé == arcade.clé. GAUCHE:
 self.player_x -= 5
elif clé == arcade.clé. DROITE:
 self.player_x += 5
si __nom__ == "__principal__":
 jeu = MonJeu (SCREEN_WIDTH, SCREEN_HEIGHT)
 arcade.run()

Ci-dessous la sortie :

Implémentation de l'algorithme de mouvement aléatoire

Pour faire bouger les objets de manière aléatoire, mettez à jour leurs positions dans le mise à jour méthode utilisant un algorithme de mouvement aléatoire.

Parcourez chaque objet et générez des valeurs aléatoires pour dx et mourir, représentant le changement des coordonnées x et y. Mettez ensuite à jour la position de l'objet en ajoutant ces valeurs. Voici le code modifié :

définitivementmise à jour(soi, delta_time):
pour je dans plage (NUM_OBJECTS) :
 x, y = soi.objets[i]
 dx = aléatoire.randint(-5, 5)
 dy = aléatoire.randint(-5, 5)
 x += dx
 y += dy
 self.objects[i] = (x, y)

Ci-dessous la sortie :

Objets se déplaçant vers le joueur

Pour ajouter plus d'interaction, déplacez les objets vers le joueur. Vous pouvez y parvenir en calculant le vecteur de direction entre l'objet et le joueur et en ajustant 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 directeur. Multipliez ensuite ce vecteur par un facteur de vitesse (3 dans ce cas) et ajoutez-le à la position de l'objet. Voici la mise à jour mise à jour méthode:

définitivementmise à jour(soi, delta_time):
pour je dans plage (NUM_OBJECTS) :
 x, y = soi.objets[i]
 dx = self.player_x - x
 dy = self.player_y - y
 distance = math.sqrt (dx ** 2 + je ** 2)
 dx /= distance
 dy /= distance
 x += dx * 3
 y += dy * 3
 self.objects[i] = (x, y)

Ci-dessous la sortie :

Les objets commencent à se déplacer lorsque le joueur entre dans les environs

Pour ajouter une dynamique supplémentaire, modifiez le code afin que les objets ne commencent à se déplacer que lorsque le joueur entre dans leur zone environnante. Ajouter le code pour le mouvement du joueur et définir un rayon dans lequel les objets deviennent actifs.

définitivementmise à jour(soi, delta_time):
pour je dans plage (NUM_OBJECTS) :
 x, y = soi.objets[i]
 dx = self.player_x - x
 dy = self.player_y - y
 distance = math.sqrt (dx ** 2 + je ** 2)

si distance < 100: # Ajustez le rayon au besoin
 dx /= distance
 dy /= distance
 x += dx * 3
 y += dy * 3
 self.objects[i] = (x, y)

Détection de collision et interaction

Maintenant, ajoutez la détection de collision entre le joueur et les objets, et définissez le comportement en cas de collision. Modifier le mise à jour méthode pour gérer les collisions :

définitivementmise à jour(soi, delta_time):
pour je dans plage (NUM_OBJECTS) :
 x, y = soi.objets[i]
 dx = self.player_x - x
 dy = self.player_y - y
 distance = math.sqrt (dx ** 2 + je ** 2)

si distance < RAYON_JOUEUR + RAYON_OBJET :
# si une collision s'est produite, gérez-la ici
 self.objects.pop (i)
 self.objects.append((random.randint(0, SCREEN_WIDTH), random.randint(0, ÉCRAN_HAUTEUR)))

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'affiner le mouvement aléatoire et l'apparition d'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 empêcher les objets de se déplacer trop rapidement, vous pouvez introduire une limite de vitesse maximale. Modifier le mise à jour méthode pour inclure les contraintes de vitesse :

définitivementmise à jour(soi, delta_time):
pour je dans plage (NUM_OBJECTS) :
 x, y = soi.objets[i]
 dx = self.player_x - x
 dy = self.player_y - y
 distance = math.sqrt (dx ** 2 + je ** 2)
si distance < RAYON_JOUEUR + RAYON_OBJET :
 self.objects.pop (i)
 self.objects.append((random.randint(0, SCREEN_WIDTH), random.randint(0, ÉCRAN_HAUTEUR)))
elif distance < 100:
 dx /= distance
 dy /= distance


 vitesse = 3# Ajustez la valeur de la vitesse au besoin
 dx = min (max (dx * vitesse, -VITESSE_MAX), VITESSE_MAX)
 dy = min (max (dy * vitesse, -VITESSE_MAX), VITESSE_MAX)
 x += dx
 y += dy
 self.objects[i] = (x, y)

Contrôler le taux d'apparition

Vous pouvez également contrôler la vitesse à laquelle de nouveaux objets apparaissent dans le jeu. Ajustez le code pour inclure un délai entre la création de nouveaux objets :

importer temps
classeMon jeu(arcade. Fenêtre):
définitivement__init__(soi, largeur, hauteur):
 super().__init__(largeur, hauteur)
 arcade.set_background_color (arcade.color. BLANC)


 self.player_x = SCREEN_WIDTH // 2
 self.player_y = PLAYER_RADIUS + 10


 self.objects = []
 self.last_spawn_time = time.time()


définitivementmise à jour(soi, delta_time):
# contrôler le taux de reproduction ici
si time.time() - self.last_spawn_time > SPAWN_DELAY :
si len (self.objects) < MAX_OBJECTS :
 self.objects.append((random.randint(0, SCREEN_WIDTH), random.randint(0, ÉCRAN_HAUTEUR)))
 self.last_spawn_time = time.time()


pour je dans plage (len (self.objects)):
 x, y = soi.objets[i]
 dx = self.player_x - x
 dy = self.player_y - y
 distance = math.sqrt (dx ** 2 + je ** 2)


si distance < RAYON_JOUEUR + RAYON_OBJET :
 self.objects.pop (i)
 self.objects.append((random.randint(0, SCREEN_WIDTH), random.randint(0, ÉCRAN_HAUTEUR)))
elif distance < 100:
 dx /= distance
 dy /= distance
 x += dx * 3
 y += dy * 3
 self.objects[i] = (x, y)

Ajuste le SPAWN_DELAY et MAX_OBJETS valeurs pour trouver le bon équilibre pour votre jeu. Un délai plus long ou un nombre maximum d'objets plus petit rendra le jeu moins encombré. Alors qu'un délai plus court ou un maximum plus grand augmentera la difficulté.

Rendre les jeux plus amusants en utilisant des objets en mouvement

L'ajout d'objets mobiles aléatoires aux jeux peut améliorer considérablement l'expérience globale. Ils introduisent l'imprévisibilité et le défi, rendant le gameplay plus engageant et dynamique. Les joueurs devront s'adapter et réagir rapidement pour éviter les collisions ou attraper des objets, ce qui procurera un sentiment d'excitation et d'accomplissement.