Démarrer avec pygame

Un “jeu” simple

Importer et initialiser

Chaque module doit être importé et pygame ne fait pas exception. Bien que nous devions appeler la fonction pygame.init() pour que tous les modules importés dans pygame soient initialisés correctement. Si nous oublions cela, certains modules ne fonctionneront pas. La fonction renvoie également un tuple de toutes les initialisations réussies et échouées (elle ne déclenchera pas d’erreur si un module ne parvient pas à s’initialiser).

import pygame
successes, failures = pygame.init()
print("{0} successes and {1} failures".format(successes, failures))

Créer des nécessités

Nous devons également créer un affichage. Pygame a déjà créé un affichage (caché), il nous suffit donc de définir le mode d’affichage (dans cet exemple, nous ne définissons que la résolution). C’est aussi une bonne idée de créer une horloge pour s’assurer que notre programme se met à jour à une vitesse fixe (sinon il fonctionnerait à une vitesse différente selon la vitesse de l’ordinateur).

screen = pygame.display.set_mode((720, 480))  # Notice the tuple! It's not 2 arguments.
clock = pygame.time.Clock()
FPS = 60  # This variable will define how many frames we update per second.

Pour un peu de lisibilité plus loin dans notre code, nous allons créer deux constantes de couleur, qui représentent un tuple de rouge, vert et bleu (RVB). Les valeurs vont de 0 (pas de lumière) à 255 (pleine lumière).

BLACK = (0, 0, 0)
WHITE = (255, 255, 255)

Dans pygame, nous utilisons généralement une Surface pour représenter l’apparence d’un objet et un Rect (rectangle) pour représenter la position d’un objet. Une Surface est comme une feuille de papier vierge qui contient des couleurs ou des images. Si vous créez une classe, vous devez nommer les attributs image et rect car de nombreuses fonctions rechercheront et utiliseront ces attributs. De telles classes gagneraient à hériter de la classe pygame.sprite.Sprite pour des raisons que vous pouvez lire sur [ici][1].

rect = pygame.Rect((0, 0), (32, 32))  # First tuple is position, second is size.
image = pygame.Surface((32, 32))  # The tuple represent size.
image.fill(WHITE)  # We fill our surface with a nice white color (by default black).

La boucle du jeu

Maintenant, tout est prêt pour notre boucle de jeu. Il s’agit d’une boucle qui fonctionnera pendant tout le jeu, où nous gérons les événements et mettons à jour l’écran et les positions de nos objets.

Nous allons d’abord nous assurer que notre boucle s’exécute à un FPS donné. Nous avons défini le FPS et créé notre horloge au début du programme. Le code suivant s’assurera que notre programme dort suffisamment de temps pour que notre boucle répète le montant que nous avons défini comme étant notre FPS. Dans cet exemple, 60 fois par seconde.

clock.tick(FPS)

Ensuite, nous gérerons les événements. Un événement est essentiellement une action de l’utilisateur, telle que déplacer la souris ou appuyer sur une touche. Pygame enregistrera tous ces événements dans une file d’attente que nous obtenons en appelant pygame.event.get(). Nous pouvons parcourir cela et vérifier s’il y a un événement que nous aimerions gérer. Les événements ont un attribut type que nous pouvons comparer aux constantes du module pygame pour déterminer de quel type d’événement il s’agit.

for event in pygame.event.get():
    if event.type == pygame.QUIT:  # The user pressed the close button in the top corner of the window.
        quit()
        # Close the program. Other methods like 'raise SystemExit' or 'sys.exit()'.
        # Calling 'pygame.quit()' won't close the program! It will just uninitialize the modules.

Nous pouvons également vérifier if event.type == pygame.KEYDOWN pour voir si l’utilisateur a appuyé sur une touche. Dans ce cas, l’événement a un attribut key que nous pouvons vérifier pour voir quelle clé il représente.

for event in pygame.event.get():
    if event.type == pygame.QUIT:
        quit()
    elif event.type == pygame.KEYDOWN:
        if event.key == pygame.K_w:
            rect.move_ip(0, -2)  # Changes the rect's position.
        elif event.key == pygame.K_s:
            rect.move_ip(0, 2)
        elif event.key == pygame.K_a:
            rect.move_ip(-2, 0)
        elif event.key == pygame.K_d:
            rect.move_ip(2, 0)

Maintenant, nous devons afficher notre image. D’abord, nous voudrions peut-être effacer notre écran du rendu précédent. Nous le faisons en remplissant tout notre écran de noir (supprimez le code pour voir pourquoi nous voulons l’effacer). Ensuite, nous devons * blit * notre * image * à l’écran. Blitter signifie essentiellement copier l’image sur une autre surface (dans notre cas, l’écran). Enfin, nous * retournons * ou * mettons à jour * l’écran.

Lorsque nous blittons, nous n’affichons rien à l’utilisateur. Imaginez-le comme l’ordinateur d’un côté et l’utilisateur de l’autre. L’ordinateur dessine (blits) sur le côté de l’écran, le retourne vers l’utilisateur, puis répète.

screen.fill(BLACK)
screen.blit(image, rect)
pygame.display.update()  # Or 'pygame.display.flip()'.

Nous avons maintenant un jeu de base ! Assez ennuyeux, oui, mais l’essentiel est là ! Combiné avec vos connaissances Python actuelles, vous devriez être capable de créer quelque chose de génial.

Code complet

import pygame
successes, failures = pygame.init()
print("{0} successes and {1} failures".format(successes, failures))


screen = pygame.display.set_mode((720, 480))
clock = pygame.time.Clock()
FPS = 60  # Frames per second.

BLACK = (0, 0, 0)
WHITE = (255, 255, 255)
# RED = (255, 0, 0), GREEN = (0, 255, 0), BLUE = (0, 0, 255).

rect = pygame.Rect((0, 0), (32, 32))
image = pygame.Surface((32, 32))
image .fill(WHITE)  

while True:
    clock.tick(FPS)

    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            quit()
        elif event.type == pygame.KEYDOWN:
            if event.key == pygame.K_w:
                rect.move_ip(0, -2)
            elif event.key == pygame.K_s:
                rect.move_ip(0, 2)
            elif event.key == pygame.K_a:
                rect.move_ip(-2, 0)
            elif event.key == pygame.K_d:
                rect.move_ip(2, 0)

    screen.fill(BLACK)
    screen.blit(image, rect)
    pygame.display.update()  # Or pygame.display.flip()

Mécanique de jeu légèrement améliorée

Notez que le programme vérifie quand nous appuyons sur la touche et non quand nous maintenons la touche enfoncée. Pour résoudre ce problème, nous pourrions introduire une variable velocity. Nous pouvons créer une classe de joueurs pour la garder plus organisée. Pour éviter un mouvement dépendant de l’image (si nous modifions le FPS à 30, les objets se déplaceraient à la moitié de la vitesse), nous introduisons un mouvement dépendant du temps en faisant passer le temps entre les ticks à nos objets mobiles.

import pygame

successes, failures = pygame.init()
print("Initializing pygame: {0} successes and {1} failures.".format(successes, failures))

screen = pygame.display.set_mode((720, 480))
clock = pygame.time.Clock()
FPS = 60

BLACK = (0, 0, 0)
WHITE = (255, 255, 255)


class Player(pygame.sprite.Sprite):
    def __init__(self):
        super().__init__()
        self.image = pygame.Surface((32, 32))
        self.image.fill(WHITE)
        self.rect = self.image.get_rect()  # Get rect of some size as 'image'.
        self.velocity = [0, 0]

    def update(self):
        self.rect.move_ip(*self.velocity)


player = Player()
running = True
while running:
    dt = clock.tick(FPS) / 1000  # Returns milliseconds between each call to 'tick'. The convert time to seconds.
    screen.fill(BLACK)  # Fill the screen with background color.

    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False
        elif event.type == pygame.KEYDOWN:
            if event.key == pygame.K_w:
                player.velocity[1] = -200 * dt  # 200 pixels per second
            elif event.key == pygame.K_s:
                player.velocity[1] = 200 * dt
            elif event.key == pygame.K_a:
                player.velocity[0] = -200 * dt
            elif event.key == pygame.K_d:
                player.velocity[0] = 200 * dt
        elif event.type == pygame.KEYUP:
            if event.key == pygame.K_w or event.key == pygame.K_s:
                player.velocity[1] = 0
            elif event.key == pygame.K_a or event.key == pygame.K_d:
                player.velocity[0] = 0

    player.update()

    screen.blit(player.image, player.rect)
    pygame.display.update()  # Or pygame.display.flip()

print("Exited the game loop. Game will quit...")
quit()  # Not actually necessary since the script will exit anyway.

Il y a encore beaucoup de choses à améliorer sur ce code. Je vous recommande de lire le pygame [tutoriel][2] et cette [discussion][3] de Richard Jones pour plus de détails.

[1] : http://www.pygame.org/docs/tut/SpriteIntro.html [2] : http://www.pygame.org/docs/ [3] : https://www.youtube.com/watch?v=bMt47wvK6u0&list=PL4Yp6gRH-R1Birdm-Gs-SdBFWLUC1q3Fa&index=4

Installer pygame

Sur les fenêtres

Accédez à http://www.lfd.uci.edu/~gohlke/pythonlibs/#pygame - un site non officiel fournissant des binaires Windows de packages python open source pour le [CPython] officiel (https://en.wikipedia .org/wiki/CPython) distribué par Christoph Gohlke.
Téléchargez le fichier pygame .whl approprié en fonction de votre version de python installée. (Le fichier est nommé quelque chose comme pygame -<pygame version> - <python version>- win32.whl)
Courir
```
 pip install your-pygame-package.whl
```

dans votre terminal, bash ou console.
Remarque : si pip n’est pas trouvé dans PATH, essayez d’exécuter python -m pip install your-pygame-package.whl

Vérifiez si vous pouvez importer pygame en tant que module python
```
import pygame
```

Si vous n’obtenez pas d’erreur, vous avez correctement installé pygame sur votre ordinateur :)

Sous linux

Ouvrez votre terminal et exécutez
```
sudo apt-get install python-pygame
```

Remarque : Cela installera pygame pour python2 2) Essayez d’importer pygame à l’intérieur

   import pygame

Si vous n’obtenez pas d’erreur, vous avez correctement installé pygame sur votre système Linux :)

Sur macOS

Il y a deux façons de l’installer sur mac :

Méthode 1

Accédez à la [page de téléchargement de Pygame][1] et téléchargez le programme d’installation mac. Exécutez-le et il devrait installer Pygame sur votre Mac.

Méthode 2

Installez [Homebrew][2] :

/usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"

Utilisez ensuite Homebrew pour installer Python 2.7.12 et Pygame :

brew install python; brew install homebrew/python/pygame

Maintenant, lancez Python dans votre terminal et essayez import pygame. S’il ne dit rien, il est installé avec succès.

[1] : http://www.pygame.org/download.shtml [2] : http://brew.sh

Importation de pygame et dessin sur un écran

Commencer

Vous devez faire ce qui suit pour démarrer avec Pygame :

import pygame

Cela ouvre une fenêtre de taille 640 480 et la stocke dans une variable appelée screen.

Configuration d’un nom de fenêtre

La configuration d’un nom pour la fenêtre pygame nécessite la syntaxe suivante :

pygame.display.set_caption('Name')

À propos de l’écran

Le point (0,0) se trouve dans le coin supérieur gauche de l’écran.
Les coordonnées x augmentent de gauche à droite, les coordonnées y augmentent de haut en bas. C’est-à-dire que les coordonnées du côté droit sur le plan cartésien sont positives et le côté gauche est négatif. Cependant, les coordonnées du côté supérieur sur le plan cartésien sont négatives en haut et positif en bas. (Remarque : Ceci est pris en compte si les points sont pris à partir de l’origine.)

Mise à jour de l’écran

Les modifications que vous apportez à l’écran, par ex. remplissez-le de couleur ou dessinez dessus, ne vous présentez pas immédiatement ! Alors comment faire ? Vous devez appeler cette fonction :

pygame.display.update()

Couleurs

La coloration dans pygame fonctionne en mode RVB. Le code de coloration est :

color_Name = (r,g,b)

R signifie rouge.
G signifie vert
B signifie bleu.
Tous les trois doivent être des nombres entiers compris entre 0 et 255, 255 étant le plus clair et 0 le plus sombre

Dessin

Pour tracer des lignes

 pygame.draw.lines(screen, color, closed, pointlist, thickness)

Pour dessiner un rectangle

 pygame.draw.rect(screen, color, (x,y,width,height), thickness)

Pour dessiner un cercle

pygame.draw.circle(screen, color, (x,y), radius, thickness)

Tout mettre en boucle

Pour faire une boucle, utilisez le code suivant :

running = True
while running:
  for event in pygame.event.get():
    if event.type == pygame.QUIT:
      running = False
      pygame.quit()

Dessiner un rectangle sur la fenêtre de pygame (code)

import pygame
background_colour = (255,255,255) # White color
(width, height) = (300, 200) # Screen size
color=(0,0,0) #For retangle
screen = pygame.display.set_mode((width, height)) #Setting Screen
pygame.display.set_caption('Drawing') #Window Name
screen.fill(background_colour)#Fills white to screen
pygame.draw.rect(screen, color, (100,50,30,40), 1) #Drawing the rectangle
pygame.display.update()

#Loop
running = True
while running:
  for event in pygame.event.get():
    if event.type == pygame.QUIT:
      running = False
      pygame.quit()

Démarrer avec pygame

Un “jeu” simple #

Importer et initialiser #

Créer des nécessités #

La boucle du jeu #

Code complet #

Mécanique de jeu légèrement améliorée #

Installer pygame #

Sur les fenêtres #

Sous linux #

Sur macOS #

Importation de pygame et dessin sur un écran #

Commencer #

Configuration d’un nom de fenêtre #

À propos de l’écran #

Mise à jour de l’écran #

Couleurs #

Dessin #

** Tout mettre en boucle ** #

Dessiner un rectangle sur la fenêtre de pygame (code) #