Jeux vidéo pygame

Pygame est un module de Python utilisé pour la conception de jeux vidéo; Ces jeux vidéo vont d'un simple Tic Tac Toe aux combattants de l'espace. Que vous souhaitiez concevoir un jeu simple ou compliqué, vous devez commencer par les bases du fonctionnement de Pygame. Dans ce tutoriel, nous passerons en revue les bases de Pygame en créant un jeu vidéo.

Installez Pygame en utilisant:

pip install pygame

Étape 1: Création de la fenêtre initiale

La première étape de la création d'un jeu vidéo consiste à initialiser le pygame à l'aide de la méthode init (). Ensuite, nous définissons la géométrie de l'écran à l'aide de Pygame.afficher.set_mode (), où nous passons la largeur et la hauteur de l'écran (dans cet ordre). Ces deux lignes de code créeront une fenêtre qui disparaîtra rapidement, nous avons donc besoin d'un mainloop pour faire fonctionner la fenêtre. Dans ce mainloop, nous ajouterons une stratégie de sortie. La stratégie de sortie est créée en sélectionnant un événement dans la liste des événements (cette liste d'événements se situe dans Pygame.événement.get () qui abrite tous les événements disponibles). Ensuite, nous déclarons que si l'événement que nous avons sélectionné est pygame.Arrêtez, puis sortez. Ce dernier créera un mainloop pour la fenêtre, qui maintiendra la fenêtre en cours d'exécution jusqu'à ce que vous appuyez sur le bouton de quitte.

importer pygame
importer sys
pygame.init ()
taille = largeur, hauteur = 800, 600
écran = pygame.afficher.set_mode (taille)
Bien que vrai:
pour l'événement à Pygame.événement.obtenir():
Si l'événement.type == pygame.ARRÊTER:
système.sortie()

Étape 2: Ajout de titres, icônes, couleurs d'arrière-plan et images

Dans cette section, nous ajouterons des titres, des couleurs et des images d'arrière-plan et des icônes à la fenêtre.

(a) Le titre est ajouté en utilisant:

# définir le titre de fenêtre
pygame.afficher.set_caption ("jeu vidéo")

(b) J'ai obtenu mon logo de https: // icons8.com / icône / set / ordinateur-hardware / doodle. Si vous utilisez PyCharm, veuillez placer l'icône que vous téléchargez dans le dossier approprié (dans mon cas, c'était C: \ Users \ Never \ pyCharmProjects \ PythonProject2 \ icône.png). Le logo est ajouté en utilisant:

# Définissez l'icône
image = pygame.image.chargement ("icône.png ")
pygame.afficher.set_icon (image)

(c) Vous pouvez également modifier la couleur du back-borgon. Pour cela, nous utilisons l'écran.rempli () qui prend une couleur RVB. Dans mon cas, je l'ai mis sur (0,0,0). Une fois que vous avez défini la couleur, vous devez également mettre à jour le pygame pour le changement de couleur pour prendre effet.

# Remplissez l'arrière-plan
filtrer.remplir ((0, 0, 0))
pygame.afficher.mise à jour()

(d) Et si vous vouliez définir une image d'arrière-plan sur votre écran? C'est possible aussi. Puisque vous voulez que l'image fonctionne tout le temps, elle doit être placée dans la boucle while. En fait, tout ce qui doit fonctionner constamment doit être placé dans le mainloop. Nous utilisons Pygame.image.charger () pour sélectionner une image que nous voulons charger et la méthode blit () pour la placer. Ici, écran.blit () prend deux arguments - l'image chargée, le tuple de l'emplacement où le coin supérieur gauche de l'image sera placé. De plus, Pygame.afficher.Update () doit être placé à la fin pour mettre à jour l'écran! Lors de la conception de jeux vidéo, l'ordre dans lequel vous placez le code compte!!! Par exemple, la mise à jour ne peut pas venir avant les photos!

# Créez l'image d'arrière-plan
bg_image = pygame.image.chargement ("bg_image.jpg ")
filtrer.blit (bg_image, (-15, -25))
pygame.afficher.mise à jour()

Alternativement, nous pouvons également le jeter dans une fonction d'arrière-plan (qui sera utile plus tard), nous réécrivons donc l'arrière-plan comme suit:

# Créez l'image d'arrière-plan
bg_image = pygame.image.charger ("bg_image_3.jpg ")
fond de fond ():
filtrer.blit (bg_image, (-15, -25))

Veuillez noter que nous avons placé l'arrière-plan dans une fonction appelée fond (), que nous activerons dans la boucle while plus tard.

Étape 3: Ajouter des images du lecteur sur la fenêtre

Ensuite, créons une personne. Cela se fait en chargeant d'abord l'image puis en utilisant l'écran.blit () pour placer l'image.

# image de personne
image_person = pygame.image.Charge (".png ")
filtrer.blit (image_person, (400, 550))

Veuillez noter que la commande dans laquelle vous placez le code compte également! Si vous placez le code pour l'arrière-plan après le code de l'ennemi, ni la personne ni l'ennemi ne seront visibles!

Cependant, encore une fois, à des fins de code entier, nous le placerons dans une fonction. Ainsi, le code peut être réécrit comme suit:

# image de personne
personne_x = 400
Person_y = 550
image_person = pygame.image.Charge ("fille.png ")
Def Person (x, y):
filtrer.blit (image_person, (x, y))

Cette fonction peut être activée dans la boucle while comme suit:

Person (Person_x, Person_y)

Étape 4: Déplacer la personne ()

Maintenant, ça devient délicat alors faites attention. Nous devons appuyer sur des clés pour déplacer la personne correcte, nous les entrons donc dans la boucle while comme suit:

pressé_keys = pygame.clé.get_preressed ()
Si pressé_KEYS [pygame.K_right]:
person_x + = 0.1
Si pressé_KEYS [pygame.K_left]:
person_x + = -0.1

Nous utilisons Pygame.clé.get_preressed () pour obtenir la touche appuyée, puis vérifier. Si la touche appuyée est la touche flèche droite (pygame.K_right), alors notre variable Person_x est incrémentée d'une valeur de 0.1. Si, d'un autre côté, la touche enfoncée est la flèche gauche (pygame.K_left), alors nous diminuons de 0.1. Ce que nous faisons, c'est changer l'emplacement de l'image sur la console. Si la flèche droite est enfoncée, le tuple initial de (400, 550) deviendra (400.1, 550) - et c'est l'emplacement de l'image!

Nous devons également activer les deux fonctions - fond () et personne (). Le fond de fonction () effacera l'écran chaque fois que la boucle commence, et sans elle, vous aurez un «glisser».

Le code dans son ensemble à ce stade ressemblerait à ceci:

importer pygame
importer sys
# Initialiser
pygame.init ()
# Définir la géométrie de l'écran
taille = largeur, hauteur = 800, 600
écran = pygame.afficher.set_mode (taille)
# définir le titre de fenêtre
pygame.afficher.set_caption ("jeu vidéo")
# Définissez l'icône
image = pygame.image.chargement ("icône.png ")
pygame.afficher.set_icon (image)
# Créez l'image d'arrière-plan
bg_image = pygame.image.charger ("bg_image_3.jpg ")
fond de fond ():
filtrer.blit (bg_image, (-15, -25))
# image de personne
personne_x = 400
Person_y = 550
image_person = pygame.image.Charge ("fille.png ")
Def Person (x, y):
filtrer.blit (image_person, (x, y))
# boucle principale
Bien que vrai:
pour l'événement à Pygame.événement.obtenir():
Si l'événement.type == pygame.ARRÊTER:
système.sortie()
# Vérifiez les touches pressées
pressé_keys = pygame.clé.get_preressed ()
# Si la touche appuyée est la flèche droite,
# alors déplacez-vous vers la droite
Si pressé_KEYS [pygame.K_right]:
person_x + = 0.1
# Si la touche appuyée est la flèche gauche,
# alors déplacez-vous vers la gauche
Si pressé_KEYS [pygame.K_left]:
person_x + = -0.1
# activer la fonction d'arrière-plan
arrière-plan()
# activer la fonction personne
Person (Person_x, Person_y)
# Mettez à jour tout
pygame.afficher.mise à jour()

Étape 5: fixer les limites de bordure

Lorsque nous appuyons sur la touche flèche droite ou gauche, pour le moment, la personne (ou le personnage principal) de notre jeu continuera de bouger et de se déplacer même hors de portée ou à l'extérieur de la fenêtre de la console. Donc la prochaine chose que nous devons faire est de fixer des limites au mouvement.

Le réglage des limites est facile. Nous allons sur nos pressed_keys [pygame.K_right] argument et ajouter une condition. Nous ajoutons la condition que X doit être inférieur à notre largeur d'écran - Largeur du caractère.

Dans mon cas, la largeur du personnage était de 50 pixels, et la largeur X de mon écran était de 800. J'ai donc réglé mon côté droit à 800 - 50 = 750 pixels. Ce que cela fait, c'est limiter le mouvement de mon personnage. Mon personnage ne peut pas aller au-delà de 750 pixels et restera donc sur l'écran de la console en tout temps.

pressé_keys = pygame.clé.get_preressed ()
# Si la touche appuyée est la flèche droite,
# alors déplacez-vous vers la droite
Si pressé_KEYS [pygame.K_right] et person_x < 750:
person_x + = 0.1
# Si la touche appuyée est la flèche gauche,
# alors déplacez-vous vers la gauche
Si pressé_KEYS [pygame.K_left] et person_x> 0:
person_x + = -0.1

Étape 6: Création de l'ennemi

La création de l'ennemi est la partie facile. Nous le faisons de la même manière dans laquelle nous avons créé le personnage principal. Ici, nous aimerions randomiser l'emplacement dans lequel l'ennemi apparaît, nous utiliserons donc le module aléatoire pour le faire. Nous utilisons aléatoire.randint () pour définir un emplacement aléatoire.

Importer au hasard
# Image ennemie
ennemi_x = aléatoire.Randint (0, 750)
ennemi_y = aléatoire.Randint (0, 300)
image_enemy = pygame.image.Charge ("ennemi.png ")
def ennemi (x, y):
filtrer.blit (image_enemy, (x, y))

N'oubliez pas d'activer l'ennemi dans la boucle while:

# activer l'ennemi
ennemi (ennemi_x, ennemi_y)

Étape 7: Déplacer l'ennemi

Déplacer l'ennemi nécessite un peu d'imagination. Nous initialisons les variables (en dehors de la boucle while):

#Initialiser les variables
ennemi_diff = 0.6
ennemi_x = 0

Et dans la boucle while, nous écrivons:

# déplacer l'ennemi
ennemi_x + = ennemi_diff
Si ennemi_x <= 0:
ennemi_x = 0
ennemi_diff = 0.6
Si ennemi_x> = 730:
ennemi_x = 730
ennemi_diff = -0.6

Ce que cela fait, c'est que si l'image de l'ennemi est à l'intérieur des limites (dans ce cas, entre 0 et 730), elle calculera l'équation ennemi_x = ennemi_x + ennemi_diff et le déplacera. Si, en revanche, l'emplacement de l'ennemi est supérieur à 730, alors nous définissons l'emplacement ennemi_x sur 730 et inversons la vitesse en écrivant -0.6 au lieu de 0.6. Si l'emplacement de l'ennemi est inférieur à 0, alors nous définissons la variable ennemi_x sur 0 et disons-le d'avancer de 0.6 pixels. Parce que nous avons affaire à une boucle de temps, chaque fois que la boucle recommence, cela fait changer la variable ennemi_x et, par conséquent, l'emplacement de l'ennemi change. En fin de compte, tout cela fera l'affaire est de déplacer l'ennemi d'avant en arrière à gauche et à droite pour toujours.

Étape 8: Créer et tirer plusieurs balles

Dans mon cas, je vais jeter des livres sur la boule de feu. Donc ma balle est un livre ou plusieurs livres. Initialisons d'abord toutes les variables dont nous avons besoin:

#Initialiser les variables
books_diff = 4
books_y = 520
books_x = 420

Books_x et Books_y sont leur emplacement initial; Je les ai placés près du personnage principal. Books_diff est sa vitesse. Ensuite, nous initialisons son état, qui est «ne bouge pas» et chargeons l'image.

# Image des livres
books_state = "ne pas bouger"
image_books = pygame.image.Charge ("livres.png ")

Nous créons ensuite une fonction qui prend les livres_state. Si nous plaçons le livre sur la grille, alors nous changeons son état en «déménageant». Cette fonction est la fonction principale qui placera la balle sur la carte / la console. De plus, dans les livres de fonctions (), j'ai écrit x + 15 et y + 1 pour centrer l'image. Sans ce dernier, les livres regardent d'un côté.

Def Books (X, Y):
Global Books_State
books_state = "Moving"
filtrer.blit (image_books, (x + 15, y + 1))

Et dans la boucle principale, vous écririez:

# Mouvement des livres
Si livres_y <= 0:
books_y = 420
books_state = "ne pas bouger"
Si Books_State est "en mouvement":
books_x = person_x
livres (livres_x, livres_y)
books_y - = books_diff
# feu si le bouton d'espace est appuyé
Si pressé_KEYS [pygame.K_space]:
books_x = person_x
livres (livres_x, livres_y)

Nous définissons d'abord ce qui se passe lorsque la balle / les livres s'éloigne de la grille ou sommes en position y<0. In this case, we change the state back to “not moving” and place the books back on the y-axis at 420. If, on the other hand, the state of the book is “moving”, we say that we want it to move (books_y -= books_diff where books_diff is its speed). Next, we also state that if the key is pressed, we want the books() function to be activated, placing the books' image onto the console grid.

Le code dans son ensemble à ce stade ressemblerait à ceci:

importer pygame
importer sys
# Initialiser
pygame.init ()
# Initialiser l'horloge
horloge = pygame.temps.Horloge()
# Définir la géométrie de l'écran
taille = largeur, hauteur = 800, 600
écran = pygame.afficher.set_mode (taille)
# définir le titre de fenêtre
pygame.afficher.set_caption ("jeu vidéo")
# Définissez l'icône
image = pygame.image.chargement ("icône.png ")
pygame.afficher.set_icon (image)
# Créez l'image d'arrière-plan
bg_image = pygame.image.charger ("bg_image_3.jpg ")
fond de fond ():
filtrer.blit (bg_image, (-15, -25))
# image de personne
personne_x = 400
Person_y = 550
image_person = pygame.image.Charge ("fille.png ")
Def Person (x, y):
filtrer.blit (image_person, (x, y))
Importer au hasard
# Image ennemie
ennemi_x = aléatoire.Randint (0, 750)
ennemi_y = aléatoire.Randint (0, 300)
image_enemy = pygame.image.Charge ("ennemi.png ")
def ennemi (x, y):
filtrer.blit (image_enemy, (x, y))
#Initialiser les variables ennemies
ennemi_diff = 0.6
ennemi_x = 0
#Initialiser les variables
books_diff = 4
books_y = 520
books_x = 420
# Image des livres
books_state = "ne pas bouger"
image_books = pygame.image.Charge ("livres.png ")
Def Books (X, Y):
Global Books_State
books_state = "Moving"
filtrer.blit (image_books, (x + 15, y + 1))
# boucle principale
Bien que vrai:
pour l'événement à Pygame.événement.obtenir():
Si l'événement.type == pygame.ARRÊTER:
système.sortie()
# Vérifiez les touches pressées
pressé_keys = pygame.clé.get_preressed ()
# Si la touche appuyée est la flèche droite,
# alors déplacez-vous vers la droite
Si pressé_KEYS [pygame.K_right] et person_x < 750:
person_x + = 0.8
# Si la touche appuyée est la flèche gauche,
# alors déplacez-vous vers la gauche
Si pressé_KEYS [pygame.K_left] et person_x> 0:
person_x + = -0.8
# activer la fonction d'arrière-plan
arrière-plan()
# activer la fonction personne
Person (Person_x, Person_y)
# déplacer l'ennemi
ennemi_x + = ennemi_diff
Si ennemi_x <= 0:
ennemi_x = 0
ennemi_diff = 0.6
Si ennemi_x> = 730:
ennemi_x = 730
ennemi_diff = -0.6
# Mouvement des livres
Si livres_y <= 0:
books_y = 420
books_state = "ne pas bouger"
Si Books_State est "en mouvement":
books_x = person_x
livres (livres_x, livres_y)
books_y - = books_diff
# feu si le bouton d'espace est appuyé
Si pressé_KEYS [pygame.K_space]:
books_x = person_x
livres (livres_x, livres_y)
# activer l'ennemi
ennemi (ennemi_x, ennemi_y)
# Mettez à jour tout
pygame.afficher.mise à jour()
horloge.Tick ​​(60)

Ce code tirera plusieurs livres l'un après l'autre lorsque la touche d'espace sera enfoncée.

Étape 9: détection de collision

L'étape suivante consiste à détecter une collision, et cela semble assez simple. Vous utiliseriez le pygame.Rect (x, y, largeur, hauteur) pour définir un rectangle. Ensuite, utilisez la méthode Colliderect () pour détecter la collision entre deux rectangles. Nous disons également que si elle détecte une collision, nous incrémentons le score de 1, remanions l'ennemi et supprimons la balle en la réinitialisant.

# Détection de collision
ennemi_rect = pygame.Recul (ennemi_x, ennemi_y, 64, 64)
books_rect = pygame.RECT (Books_X, Books_Y, 64, 64)
Si books_rect.Colliderrect (ennemi_rect):
ennemi_x = aléatoire.RandRange (0, 800)
ennemi_y = aléatoire.RandRange (0, 300)
score + = 1
Bullet_state = "Not Move"
ennemi (ennemi_x, ennemi_y)
books_y = 0

Étape 10: Affichage du texte

En dehors du mainloop, vous écririez:

score = 0
#Initialiser la police
pygame.Police de caractère.init ()
myfont = pygame.Police de caractère.Sysfont («Comic Sans MS», 50)
def Text_score (x, y):
text_score = myfont.Render ('score:' + str (score), true, (0, 0, 0)))
filtrer.blit (text_score, (x, y))

Dans la boucle principale, vous écririez:

# Activer le score du texte
text_score (6, 6)

Ici, les polices doivent être initialisées, alors initialisez-la à l'aide de pygame.Police de caractère.init (). Ensuite, vous choisissez votre police en utilisant Pygame.Police de caractère.Sysfont () où vous passez la police et la taille. Ensuite, définissons une fonction où nous utilisons la méthode de rendu pour le rendre. Ici, puisque le score est un entier, nous utilisons STR (score). Et puis, nous les plaçons sur l'écran en utilisant la méthode Blit ().

À ce stade, l'ensemble du code ressemblerait à ceci:

importer pygame
importer sys
# Initialiser
pygame.init ()
# Initialiser l'horloge
horloge = pygame.temps.Horloge()
# Définir la géométrie de l'écran
taille = largeur, hauteur = 800, 600
écran = pygame.afficher.set_mode (taille)
# définir le titre de fenêtre
pygame.afficher.set_caption ("jeu vidéo")
# Définissez l'icône
image = pygame.image.chargement ("icône.png ")
pygame.afficher.set_icon (image)
# Créez l'image d'arrière-plan
bg_image = pygame.image.charger ("bg_image_3.jpg ")
fond de fond ():
filtrer.blit (bg_image, (-15, -25))
# image de personne
personne_x = 400
Person_y = 550
image_person = pygame.image.Charge ("fille.png ")
Def Person (x, y):
filtrer.blit (image_person, (x, y))
Importer au hasard
# Image ennemie
ennemi_x = aléatoire.Randint (0, 750)
ennemi_y = aléatoire.Randint (0, 300)
image_enemy = pygame.image.Charge ("ennemi.png ")
def ennemi (x, y):
filtrer.blit (image_enemy, (x, y))
#Initialiser les variables ennemies
ennemi_diff = 0.6
ennemi_x = 0
#Initialiser les variables
books_diff = 4
books_y = 520
books_x = 420
# Image des livres
books_state = "ne pas bouger"
image_books = pygame.image.Charge ("livres.png ")
Def Books (X, Y):
Global Books_State
books_state = "Moving"
filtrer.blit (image_books, (x + 15, y + 1))
score = 0
#Initialiser la police
pygame.Police de caractère.init ()
myfont = pygame.Police de caractère.Sysfont («Comic Sans MS», 50)
def Text_score (x, y):
text_score = myfont.Render ('score:' + str (score), true, (0, 0, 0)))
filtrer.blit (text_score, (x, y))
# boucle principale
Bien que vrai:
pour l'événement à Pygame.événement.obtenir():
Si l'événement.type == pygame.ARRÊTER:
système.sortie()
# Vérifiez les touches pressées
pressé_keys = pygame.clé.get_preressed ()
# Si la touche appuyée est la flèche droite,
# alors déplacez-vous vers la droite
Si pressé_KEYS [pygame.K_right] et person_x < 750:
person_x + = 0.8
# Si la touche appuyée est la flèche gauche,
# alors déplacez-vous vers la gauche
Si pressé_KEYS [pygame.K_left] et person_x> 0:
person_x + = -0.8
# activer la fonction d'arrière-plan
arrière-plan()
# activer la fonction personne
Person (Person_x, Person_y)
# déplacer l'ennemi
ennemi_x + = ennemi_diff
Si ennemi_x <= 0:
ennemi_x = 0
ennemi_diff = 0.6
Si ennemi_x> = 730:
ennemi_x = 730
ennemi_diff = -0.6
# Mouvement des livres
Si livres_y <= 0:
books_y = 420
books_state = "ne pas bouger"
Si Books_State est "en mouvement":
books_x = person_x
livres (livres_x, livres_y)
books_y - = books_diff
# feu si le bouton d'espace est appuyé
Si pressé_KEYS [pygame.K_space]:
books_x = person_x
livres (livres_x, livres_y)
# activer l'ennemi
ennemi (ennemi_x, ennemi_y)
# Détection de collision
ennemi_rect = pygame.Recul (ennemi_x, ennemi_y, 64, 64)
books_rect = pygame.RECT (Books_X, Books_y, 64, 64)
Si books_rect.Colliderrect (ennemi_rect):
ennemi_x = aléatoire.RandRange (0, 800)
ennemi_y = aléatoire.RandRange (0, 300)
score + = 1
Bullet_state = "Not Move"
ennemi (ennemi_x, ennemi_y)
books_y = 0
# Activer le score du texte
text_score (6, 6)
# Mettez à jour tout
pygame.afficher.mise à jour()
horloge.Tick ​​(60)

Étape 11: Ajouter des sons

L'ajout de sons est super duper facile!

En dehors de la boucle principale, vous écririez:

# Initialiser les sons
pygame.mixer.init ()
pygame.mixer.musique.Charge ("Gun-Cocking-01.wav ")

Dans le mainloop, je vais activer le son s'il y a une collision! Ici, nous utilisons Pygame.mixer.musique.jouer().

# Détection de collision
ennemi_rect = pygame.Recul (ennemi_x, ennemi_y, 64, 64)
books_rect = pygame.RECT (Books_X, Books_y, 64, 64)
Si books_rect.Colliderrect (ennemi_rect):
ennemi_x = aléatoire.RandRange (0, 800)
ennemi_y = aléatoire.RandRange (0, 300)
score + = 1
Bullet_state = "Not Move"
ennemi (ennemi_x, ennemi_y)
books_y = 0
pygame.mixer.musique.jouer()

Étape 12: terminer le jeu

Je vais définir ce jeu sur une victoire si le score est supérieur à 5. Donc, en dehors de la boucle principale, nous écrivons le code suivant:

text_game_over = pygame.Police de caractère.Sysfont («Comic Sans MS», 80)
# jeu sur fonction
def game_over (x, y):
text_game_over_2 = myfont.Render ('vous avez gagné', vrai, (0, 0, 0))
filtrer.blit (text_game_over_2, (x, y))

Et dans la boucle principale, vous écririez:

# Vérifiez la victoire
Si score> 5:
Game_over (400, 300)
pygame.afficher.retourner()
temps.sommeil (5)
casser
# Activer le score du texte
text_score (6, 6)
minuterie (500, 6)

Cela signifie que si le score est supérieur à 5.

L'ensemble du code ressemblerait à ceci:

importer pygame
importer sys
heure d'importation
# Initialiser
pygame.init ()
# Initialiser l'horloge
horloge = pygame.temps.Horloge()
# Définir la géométrie de l'écran
taille = largeur, hauteur = 800, 600
écran = pygame.afficher.set_mode (taille)
# définir le titre de fenêtre
pygame.afficher.set_caption ("jeu vidéo")
# Définissez l'icône
image = pygame.image.chargement ("icône.png ")
pygame.afficher.set_icon (image)
# Créez l'image d'arrière-plan
bg_image = pygame.image.charger ("bg_image_3.jpg ")
fond de fond ():
filtrer.blit (bg_image, (-15, -25))
# image de personne
personne_x = 400
Person_y = 550
image_person = pygame.image.Charge ("fille.png ")
Def Person (x, y):
filtrer.blit (image_person, (x, y))
Importer au hasard
# Image ennemie
ennemi_x = aléatoire.Randint (0, 750)
ennemi_y = aléatoire.Randint (0, 300)
image_enemy = pygame.image.Charge ("ennemi.png ")
def ennemi (x, y):
filtrer.blit (image_enemy, (x, y))
#Initialiser les variables ennemies
ennemi_diff = 0.6
ennemi_x = 0
#Initialiser les variables
books_diff = 4
books_y = 520
books_x = 420
# Image des livres
books_state = "ne pas bouger"
image_books = pygame.image.Charge ("livres.png ")
Def Books (X, Y):
Global Books_State
books_state = "Moving"
filtrer.blit (image_books, (x + 15, y + 1))
score = 0
#Initialiser la police
pygame.Police de caractère.init ()
myfont = pygame.Police de caractère.Sysfont («Comic Sans MS», 50)
def Text_score (x, y):
text_score = myfont.Render ('score:' + str (score), true, (0, 0, 0)))
filtrer.blit (text_score, (x, y))
# Initialiser les sons
pygame.mixer.init ()
pygame.mixer.musique.Charge ("Gun-Cocking-01.wav ")
text_game_over = pygame.Police de caractère.Sysfont («Comic Sans MS», 80)
# jeu sur fonction
def game_over (x, y):
text_game_over_2 = myfont.Render ('vous avez gagné', vrai, (0, 0, 0))
filtrer.blit (text_game_over_2, (x, y))
Def Timer (x, y):
text_timer = myfont.Render ('Time:' + Str (Pygame.temps.get_ticks ()), true, (0, 0, 0)))
filtrer.blit (text_timer, (x, y))
# boucle principale
Bien que vrai:
pour l'événement à Pygame.événement.obtenir():
Si l'événement.type == pygame.ARRÊTER:
système.sortie()
# Vérifiez les touches pressées
pressé_keys = pygame.clé.get_preressed ()
# Si la touche appuyée est la flèche droite,
# alors déplacez-vous vers la droite
Si pressé_KEYS [pygame.K_right] et person_x < 750:
person_x + = 0.8
# Si la touche appuyée est la flèche gauche,
# alors déplacez-vous vers la gauche
Si pressé_KEYS [pygame.K_left] et person_x> 0:
person_x + = -0.8
# activer la fonction d'arrière-plan
arrière-plan()
# activer la fonction personne
Person (Person_x, Person_y)
# déplacer l'ennemi
ennemi_x + = ennemi_diff
Si ennemi_x <= 0:
ennemi_x = 0
ennemi_diff = 0.6
Si ennemi_x> = 730:
ennemi_x = 730
ennemi_diff = -0.6
# Mouvement des livres
Si livres_y <= 0:
books_y = 420
books_state = "ne pas bouger"
Si Books_State est "en mouvement":
books_x = person_x
livres (livres_x, livres_y)
books_y - = books_diff
# feu si le bouton d'espace est appuyé
Si pressé_KEYS [pygame.K_space]:
books_x = person_x
livres (livres_x, livres_y)
# activer l'ennemi
ennemi (ennemi_x, ennemi_y)
# Détection de collision
ennemi_rect = pygame.Recul (ennemi_x, ennemi_y, 64, 64)
books_rect = pygame.RECT (Books_X, Books_Y, 64, 64)
Si books_rect.Colliderrect (ennemi_rect):
ennemi_x = aléatoire.RandRange (0, 800)
ennemi_y = aléatoire.RandRange (0, 300)
score + = 1
Bullet_state = "Not Move"
ennemi (ennemi_x, ennemi_y)
books_y = 0
pygame.mixer.musique.jouer()
# Vérifiez la victoire
Si score> 5:
Game_over (400, 300)
pygame.afficher.retourner()
temps.sommeil (5)
casser
# Activer le score du texte
text_score (6, 6)
minuterie (500, 6)
# Mettez à jour tout
pygame.afficher.mise à jour()
horloge.Tick ​​(60)

Bien sûr, c'est le plus simple de tous les jeux que vous pouvez créer! Cependant, c'est un début pour ceux qui veulent apprendre le pygame et concevoir de meilleurs jeux vidéo.

Jeux heureux!