Cette bibliothèque de jeux Python regorge de fonctionnalités, y compris des outils simples que vous pouvez utiliser pour créer un défilement fluide et parallaxe.
Le défilement des arrière-plans peut grandement améliorer l'attrait visuel et la profondeur d'un jeu. Ils peuvent créer l'illusion de mouvement, donnant au jeu une sensation dynamique et immersive. Vous pouvez implémenter des arrière-plans défilants en quelques étapes simples à l'aide de Pygame.
Pygame est une bibliothèque Python populaire que vous pouvez utiliser pour développer des jeux. L'ajout d'arrière-plans défilants à vos projets Pygame leur donnera vie et offrira une expérience plus attrayante aux joueurs.
Créer un jeu simple
Pour comprendre le concept de défilement des arrière-plans dans Pygame, commencez par créer un jeu simple où le joueur peut se déplacer à gauche et à droite. Vous pouvez également inclure deux plates-formes, représentées par des rectangles, pour servir d'environnement de jeu. Créer un nouveau fichier nommé jeu-simple.py.
Le code utilisé dans cet article est disponible dans ce Référentiel GitHub et est libre d'utilisation sous la licence MIT.
Tout d'abord, importez le module pygame et initialisez-le. Définissez ensuite la position de départ et la vitesse de déplacement du joueur. Créer des plates-formes à l'aide pygame. Rect objets et définir leurs positions et leurs dimensions.
À l'intérieur de la boucle de jeu, gérez des événements tels que quitter le jeu. Vous pouvez également gérer mouvement du joueur basé sur les entrées tactiles ou au clavier.
Voici la sortie du jeu simple :
Créer différentes couches
Pour obtenir l'effet de défilement, vous pouvez créer plusieurs couches d'arrière-plans avec des couleurs différentes. Chaque couche se déplacera à une vitesse différente, créant un effet de parallaxe. Cet effet donne l'illusion de profondeur et améliore la sensation de mouvement dans le jeu.
Définissez deux calques d'arrière-plan, chacun couvrant toute la fenêtre du jeu, à l'aide de pygame. Objets rectilignes. Définissez également les couleurs de chaque calque dans le background_colors liste. Le background_speeds list détermine la vitesse à laquelle chaque couche se déplacera.
# Ajoutez ce code sous la section précédentebackground_layers = [
pygame. Rect(0, 0, largeur_écran, hauteur_écran),
pygame. Rect(0, 0, largeur_écran, hauteur_écran)
]
background_colors = [(30, 30, 30), (60, 60, 60)]
background_speeds = [0.1, 1.0]
Pour créer l'effet d'arrière-plan défilant, vous devez mettre à jour les positions des calques d'arrière-plan dans la boucle de jeu. Vous déplacerez chaque couche horizontalement en fonction de sa vitesse assignée.
Créer un nouveau fichier nommé scrolling-bg.py et ajoutez le code avec les mises à jour ci-dessous :
pour je dans plage (len (background_layers)):
background_layers[i].x -= background_speeds[i]si background_layers[i].x <= -screen_width :
background_layers[i].x = 0
pygame.draw.rect (écran, background_colors[i], background_layers[i])
Parcourez chaque calque d'arrière-plan. Soustrayez la vitesse correspondante de la coordonnée x du calque, ce qui le fait se déplacer vers la gauche. Si un calque atteint le bord gauche de l'écran, réinitialisez sa position vers la droite, créant un effet de défilement continu.
Enfin, dessinez chaque calque d'arrière-plan rectangulaire à l'écran en utilisant pygame.draw.rect() et en passant la couleur et le pygame correspondants. Objet rect.
Ajout d'un effet de parallaxe lors du déplacement
Pour améliorer l'effet de parallaxe, vous pouvez modifier le mouvement de la plate-forme pour qu'il se produise lorsque le joueur se déplace. Cela créera une forte sensation de profondeur et de mouvement dynamique. Créer un nouveau fichier nommé parallaxe.py et ajoutez le code avec les mises à jour ci-dessous :
# Définir les positions et les vitesses de la plateforme
rect1 = pygame. Rect(50, hauteur_écran - 100, 200, 10)
rect2 = pygame. Rect (screen_width - 250, hauteur_écran - 200, 200, 10)plateformes = [
{"rectifier": rect1, "vitesse": 3},
{"rectifier": rect2, "vitesse": 1}
]# Ajoutez ce code dans la boucle du jeu
# Mouvement du joueur
clés = pygame.key.get_pressed()si clés[pygame. K_LEFT] et joueur_x > 0:
joueur_x -= vitesse_joueurpour plateforme dans plates-formes :
plateforme["rectifier"].x -= plateforme["vitesse"]si clés[pygame. K_RIGHT] et player_x < screen_width :
player_x += player_speedpour plateforme dans plates-formes :
plateforme["rectifier"].x += plateforme["vitesse"]
pour plateforme dans plates-formes :
pygame.draw.rect (écran, (0, 255, 0), plateforme["rectifier"])
Représentez les plates-formes sous forme de dictionnaires contenant à la fois l'objet rectangle (rect) et la vitesse à laquelle la plate-forme doit se déplacer (vitesse). Les plates-formes se mettent à jour dans la boucle de jeu en fonction des mouvements du joueur.
En mettant en œuvre cette modification, l'effet de défilement ne sera actif que lorsque le joueur se déplace activement, renforçant encore l'illusion de profondeur et de mouvement.
Inclure des fonctionnalités supplémentaires
Vous pouvez implémenter plusieurs fonctionnalités supplémentaires pour améliorer les arrière-plans de défilement dans votre jeu. Voici quelques exemples.
Randomiser les couleurs d'arrière-plan
Pour ajouter des variations aux calques d'arrière-plan, vous pouvez randomiser leurs couleurs. Vous pouvez le faire en modifiant le background_colors liste:
importer aléatoire# Ajoutez ce code avant la boucle de jeu
background_colors = [
(aléatoire.randint(0, 255), random.randint(0, 255), random.randint(0, 255)),
(aléatoire.randint(0, 255), random.randint(0, 255), random.randint(0, 255)),
(aléatoire.randint(0, 255), random.randint(0, 255), random.randint(0, 255))
]
Ajouter plus de couches d'arrière-plan
Vous pouvez essayer d'ajouter plus de calques d'arrière-plan pour créer un effet de parallaxe plus riche. Définissez simplement pygame. Rect objets, couleurs et vitesses :
# Ajoutez ce code avant la boucle de jeubackground_layers = [
pygame. Rect(0, 0, largeur_écran, hauteur_écran),
pygame. Rect(0, 0, largeur_écran, hauteur_écran),
pygame. Rect(0, 0, largeur_écran, hauteur_écran),
pygame. Rect(0, 0, largeur_écran, hauteur_écran)
]background_colors = [
(30, 30, 30),
(60, 60, 60),
(90, 90, 90),
(120, 120, 120)
]
background_speeds = [1, 2, 3, 4]
Utiliser des images pour les arrière-plans
Au lieu de couleurs unies, vous pouvez utiliser des fichiers image comme arrière-plan. Pygame fournit des fonctions pour charger et rendre des images.
Charger les fichiers image background_0.png, background_1.png, et background_2.png en utilisant pygame.image.load(). Utilisez la méthode convert() pour améliorer les performances et mettre à l'échelle les images pour qu'elles correspondent aux dimensions de l'écran avec pygame.transform.scale().
# Ajoutez ce code avant la boucle de jeuimages_fond = [
pygame.image.load("fond_0.png").convertir(),
pygame.image.load("fond_1.png").convertir(),
pygame.image.load("fond_2.png").convertir()
]background_speeds = [1, 2, 3]
pour je dans plage (len (background_images)):
taille = (screen_width, screen_height)
background_images[i] = pygame.transform.scale (background_images[i], taille)
Enfin, mettez à jour la boucle où vous dessinez les calques d'arrière-plan pour utiliser les images :
# Mettez à jour ce code dans la boucle du jeupour je dans plage (len (background_layers)):
background_layers[i].x -= background_speeds[i]si background_layers[i].x <= -screen_width :
background_layers[i].x = 0
screen.blit (background_images[i], background_layers[i])
Voici quelques bonnes pratiques à prendre en compte lors de l'implémentation d'arrière-plans de défilement dans vos projets Pygame.
Optimiser les performances
Les arrière-plans défilants impliquent un rendu et une mise à jour continus. Pour assurer un gameplay fluide, pensez à optimiser votre code et à minimiser les calculs inutiles.
Expérimentez avec les vitesses de couche
Le réglage de la vitesse des calques d'arrière-plan peut créer différents effets. Jouez avec différentes valeurs pour trouver le bon équilibre et obtenir l'impact visuel souhaité.
Test sur différentes tailles d'écran
Assurez-vous que vos arrière-plans de défilement fonctionnent bien sur différentes résolutions d'écran. Envisagez d'implémenter une mise à l'échelle dynamique ou d'utiliser différentes images d'arrière-plan pour différents rapports d'aspect.
Utiliser les formats d'image appropriés
Si vous décidez d'utiliser des images pour vos arrière-plans, choisissez le format d'image approprié (par exemple, PNG, JPEG) pour équilibrer la taille du fichier et la qualité de l'image. Vous pouvez également réduire les temps de chargement en compressant et en optimisant vos images.
Considérez l'utilisation de la mémoire
Si vous prévoyez d'utiliser de nombreuses images haute résolution pour vos arrière-plans, tenez compte des besoins en mémoire. Les images volumineuses peuvent consommer une quantité importante de mémoire, affectant potentiellement les performances et la réactivité de votre jeu.
En incorporant des arrière-plans défilants, vous pouvez créer différents environnements, tels que des paysages en mouvement, des paysages urbains futuristes ou des mondes sous-marins. L'effet de parallaxe ajoute une touche dynamique, rendant le monde du jeu vivant et interactif.
N'oubliez pas d'expérimenter, d'itérer et d'explorer les possibilités créatives avec des arrière-plans défilants pour rendre vos jeux plus amusants et captivants pour les joueurs.