Crée un jeu en Python et Pygame : Collecteur de fruit

Développer un mini-jeu en python avec Pygame

Bienvenue dans cet article où nous allons voir la création d’un Jeu en Python et pygame appelé Collecteur de fruit en utilisant Pygame, une bibliothèque Python puissante et amusante pour le développement de jeux. Dans ce tutoriel, tu apprendras à créer un jeu simple mais captivant où le but est d’éviter des bombes qui tombent du haut de l’écran tout en ramassant des fruits qui apparaissent à divers endroits.

Qu’est-ce que Pygame ?

Pygame est une bibliothèque Python qui te permet de développer des jeux vidéo de manière simple et intuitive. Elle te fournit toutes les fonctionnalités nécessaires pour créer des jeux, y compris la gestion des graphismes, du son et des entrées utilisateur. Avec Pygame, tu peux te concentrer sur la logique de jeu sans avoir à te soucier des détails techniques complexes.

Développer un jeu de collecteur de fruit

Dans ce tutoriel, nous allons développer un jeu où le joueur doit :

Ramasser les Fruits : Des fruits apparaîtront à divers endroits sur l’écran. Le joueur devra les attraper pour augmenter son score.

Éviter les Bombes : Des bombes tomberont du haut de l’écran et il faudra les esquiver pour ne pas perdre de points ou mettre fin au jeu.

Voici les étapes principales que nous allons suivre pour créer ce jeu :

  1. Installation et Configuration : Nous commencerons par installer Pygame et préparer notre environnement de développement.
  2. Préparation des Ressources : Nous téléchargerons ou créerons les images et les sons nécessaires pour notre jeu.
  3. Initialisation du Jeu : Nous configurerons la fenêtre du jeu, chargerons les ressources, et définirons les variables de base.
  4. Affichage des Éléments : Nous coderons la façon dont les éléments du jeu (joueur, bombes, fruits) seront affichés à l’écran.
  5. Gestion des Événements : Nous programmerons les contrôles pour permettre au joueur de se déplacer et interagir avec les objets du jeu.
  6. Logique de Jeu : Nous implémenterons la logique pour générer aléatoirement les bombes et les fruits, gérer les collisions, et mettre à jour le score.
  7. Boucle Principale : Nous écrirons la boucle principale du jeu pour rafraîchir l’écran et gérer le temps de jeu.
  8. Ajout des Sons et Musique : Nous ajouterons des effets sonores et éventuellement une musique de fond pour enrichir l’expérience de jeu.

Avant de plonger dans la création de ton jeu avec Pygame, tu dois d’abord préparer ton environnement de développement. Dans cette section, nous allons passer en revue l’installation de Pygame, vérifier que tout fonctionne correctement, et configurer la structure de ton projet.

Installation de Pygame

Pour commencer, tu dois installer la bibliothèque Pygame, qui est essentielle pour créer des jeux en Python. Voici les étapes pour installer Pygame :

  1. Ouvre ton terminal ou invite de commandes : Sur Windows, tu peux utiliser l’invite de commandes (cmd) ou PowerShell. Sur macOS ou Linux, utilise le terminal.
  2. Installe Pygame avec pip :
Installation de Pygame

Si tu utilise Pycharm tu peux utiliser le gestionnaire de paquet !

Crée le Répertoire du Projet :

  • Choisis un emplacement sur ton ordinateur où tu veux créer ton projet, puis crée un nouveau dossier pour ton jeu. Par exemple, nomme-le mon_jeu_pygame.

Crée les Sous-Dossiers :

  • À l’intérieur du dossier principal, crée les sous-dossiers suivants pour organiser tes ressources :
    • images : pour stocker les fichiers d’image (comme les sprites pour le joueur, les bombes et les fruits).
    • sons : pour stocker les fichiers audio (comme les effets sonores et la musique de fond).
    • scripts : pour stocker les fichiers de code Python (.py).
Répertoire du projet du mini jeu en Python.
  1. Crée un Fichier de Code de Base :
    • Dans le dossier scripts, crée un fichier Python pour ton jeu. Par exemple, nomme-le jeu.py. Ce fichier contiendra le code principal de ton jeu.
  2. Prépare un Fichier README :
    • Dans le dossier principal, tu peux ajouter un fichier README.md pour documenter ton projet. Ce fichier peut contenir des informations sur le jeu, les instructions d’installation et d’utilisation.

Voici à quoi pourrait ressembler le début de ton fichier jeu.py pour t’assurer que tout est prêt :

Debut du code pour la creation d'un mini-jeu avec Python et Pygame
pour la création d'un mini-jeu avec Pygame
partie 3 boucle principal du jeu de base pour la creation d'un mini-jeu en Python

Dans ce fichier de base :

  • Nous avons initialisé Pygame, défini la taille de la fenêtre et configuré quelques variables.
  • Nous avons préparé le code pour ajouter les images et les sons plus tard.
  • La boucle principale du jeu est mise en place pour gérer les événements et mettre à jour l’affichage.

En suivant ces étapes, tu seras prêt à commencer à développer ton jeu avec une structure bien organisée. Passe à l’étape suivante pour ajouter des éléments au jeu et le rendre interactif !

Préparation des Ressources du Jeu collecteur de fruit

Pour donner vie à ton jeu, tu auras besoin de ressources telles que des images et des sons. Dans cette section, nous allons te guider à travers le processus de préparation et d’intégration de ces ressources dans ton projet Pygame.

Graphiques du Jeu

Les graphismes sont essentiels pour rendre ton jeu visuellement attrayant. Nous allons créer ou télécharger des images pour les éléments suivants :

  1. Joueur : L’image représentant le personnage contrôlé par le joueur.
  2. Bombes : Les images des bombes qui tomberont du haut de l’écran.
  3. Fruits : Les images des fruits que le joueur devra ramasser.
Téléchargement ou Création des Images
  • Télécharger des Images : Tu peux trouver des images libres de droits en ligne. Assure-toi qu’elles sont au format PNG pour conserver la transparence.
  • Créer des Images : Si tu préfères créer tes propres images, tu peux utiliser des outils comme GIMP, Photoshop, ou même des outils en ligne comme Canva. Crée des images simples pour le joueur, les bombes et les fruits.
Exemple d’Image

Voici un exemple d’image pour un joueur (le fichier joueur.png) :

  • Dimensions : 50×50 pixels
  • Couleur : Vert

Voici les images que j’ai utilisé tu peux faire un clique doit enregistrer sous et tu pourras utilisé les sprites dans ton propre projet !

Sprites pour la creation du mini-jeu

Enregistre ce fichier dans le dossier images.

Sons du Jeu

Les effets sonores et la musique enrichissent l’expérience de jeu en ajoutant de l’ambiance et du dynamisme. Tu auras besoin des types de sons suivants :

  1. Effets Sonores : Pour les collisions avec les bombes, la collecte de fruits, etc.
  2. Musique de Fond : Pour ajouter une ambiance musicale tout au long du jeu.
Téléchargement ou Création des Sons
  • Télécharger des Sons : Comme pour les images, il existe de nombreux sites proposant des effets sonores libres de droits, comme Freesound ou ZapSplat.
  • Créer des Sons : Tu peux utiliser des outils comme Audacity pour enregistrer et éditer tes propres sons.
Exemple de Son

Pour les effets sonores, tu pourrais utiliser un fichier nommé collision.wav pour le bruit de collision. Place-le dans le dossier sons.

Intégration des Ressources dans ton Projet Python et Pygame

Une fois que tu as préparé les ressources, tu dois les intégrer dans ton code Pygame. Voici comment charger et utiliser ces ressources :

Chargement des Images

Dans ton fichier jeu.py, ajoute les lignes suivantes pour charger les images des ressources :

Intégrer dans notre jeu les images avec Pygame

Chargement des sons du jeu

Juste avant ou juste après avoir intégré tes images tu peux intégrer tes sons de cette manière.

intégration des sons dans le code du mini-jeu

Dans ce code :

  • Nous avons intégré les images et les sons que tu as préparés.
  • Les ressources sont chargées au début, et tu peux les utiliser pour afficher les éléments du jeu et jouer les sons.

En suivant ces étapes, tu seras prêt à enrichir ton jeu avec des graphismes et des sons captivants. Passe à l’étape suivante pour implémenter la logique de jeu et rendre ton jeu interactif !

Maintenant que nous avons configuré notre jeu, il est temps de mettre en place l’affichage des éléments essentiels tels que le joueur, les bombes et les fruits. Cette étape est cruciale pour rendre ton jeu visuellement interactif et engageant. Nous allons aborder comment dessiner ces éléments à l’écran et mettre en place leur logique d’affichage.

Affichage du Joueur en Python

Le joueur sera représenté par une image que tu as chargée précédemment. Nous devons maintenant dessiner cette image à la position du joueur dans la fenêtre du jeu.

Code pour Afficher le Joueur

Voici comment afficher le joueur à l’écran et mettre à jour sa position en fonction des mouvements :

ur l'affichage du joueur
  • fenetre.fill(blanc) : Efface l’écran en remplissant toute la fenêtre avec la couleur blanche.
  • fenetre.blit(image_joueur, position_joueur) : Dessine l’image du joueur à la position spécifiée.

Affichage des Bombes

Les bombes doivent apparaître aléatoirement au sommet de l’écran et descendre vers le bas. Nous allons créer une fonction pour générer des bombes et les afficher à l’écran.

Code pour Générer et Afficher les Bombes

Voici un exemple de code pour ajouter et afficher les bombes :

Affichages des bombes dans notre mini- jeu en Python avec Pygame
  • Ajouter une Bombe : ajouter_bombe() crée une nouvelle bombe à une position aléatoire en haut de l’écran.
  • Afficher les Bombes : afficher_bombes() dessine chaque bombe à sa position actuelle et les fait descendre.

Affichage des Fruits en Python

Les fruits doivent apparaître à des positions aléatoires sur l’écran et être ramassés par le joueur. De la même manière que pour les bombes, nous allons créer des fonctions pour gérer les fruits.

Code pour Générer et Afficher les Fruits

Voici un exemple de code pour ajouter et afficher les fruits :

Intégration des fruit dans notre jeu de collecteur de fruit en Pygame et Python

Ajouter un Fruit : ajouter_fruit() crée un fruit à une position aléatoire en haut de l’écran.Afficher les Fruits : afficher_fruits() dessine chaque fruit à sa position actuelle et les fait descendre.

Dans ce code :

  • Les fonctions ajouter_bombe() et ajouter_fruit() ajoutent des bombes et des fruits à l’écran.
  • Les fonctions afficher_bombes() et afficher_fruits() dessinent les éléments et les déplacent vers le bas.
  • La boucle principale ajoute des bombes et des fruits de manière aléatoire et les affiche à l’écran.

Avec cette configuration en place, ton jeu affichera les éléments essentiels. Passons maintenant à la gestion des événements pour rendre le jeu interactif et réactif aux actions du joueur !

Gestion des Événements et Logique de Jeu

Pour rendre ton jeu interactif et réactif aux actions du joueur, nous devons implémenter la gestion des événements. Cela inclut les mouvements du joueur, les collisions avec les bombes, et la collecte des fruits. Nous allons également gérer le score et les conditions de fin de jeu.

Gestion des Mouvements du Joueur

Le joueur se déplace à gauche ou à droite en fonction des touches pressées. Nous avons déjà inclus une partie de ce code dans l’exemple précédent. Voici comment tu peux affiner la gestion des mouvements du joueur :

Code pour les Mouvements du Joueur
Gestion des déplacements du joueurs  avec Pygame pour la programmation de notre  mini jeu
  • Déplacement du Joueur : Le joueur se déplace à gauche avec pygame.K_LEFT et à droite avec pygame.K_RIGHT.
  • Limitation des Mouvements : Les limites sont appliquées pour éviter que le joueur sorte de l’écran.

Détection des Collisions

Pour que le jeu soit intéressant, tu dois détecter les collisions entre le joueur et les bombes, ainsi que la collecte des fruits. Voici comment tu peux gérer ces interactions :

Code pour Détecter les Collisions
Ajout des colisions dans le mini-jeu
  • Détection des Collisions : Les fonctions verifier_collision_bombes() et verifier_collecte_fruits() détectent les collisions en comparant les positions des éléments.
  • Gestion des Sons : Les sons sont joués lorsque des collisions ou des collectes se produisent.
  • Mise à Jour du Score : Le score est mis à jour lorsqu’un fruit est collecté.

Mise à Jour de la Logique du Jeu

En plus de gérer les mouvements et les collisions, il est important de mettre à jour régulièrement l’état du jeu, ajouter des bombes et des fruits, et vérifier les conditions de fin de jeu.

Code pour Mettre à Jour le Jeu

Voici comment intégrer la logique de mise à jour dans la boucle principale du jeu :

Intégration des étapes précédentes dans notre code du mini-jeu en Python avec le framexork Pygame
  • Mise à Jour des Positions : Les fonctions afficher_bombes() et afficher_fruits() mettent à jour les positions des bombes et des fruits.
  • Gestion des Collisions : Les fonctions verifier_collision_bombes() et verifier_collecte_fruits() vérifient les collisions et les collectes.
  • Affichage du Score : Le score est affiché à l’écran à l’aide de la bibliothèque pygame.font.

Conclusion

Avec cette gestion des événements et cette logique de jeu, ton jeu devient interactif et réactif aux actions du joueur. Les éléments du jeu sont affichés, les collisions sont détectées, et le score est mis à jour. Tu peux maintenant peaufiner le jeu en ajoutant des fonctionnalités supplémentaires ou en améliorant les graphismes et les sons.

Code complet du projet

tu trouveras le code complet du projet ici !

Mes articles

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *