pygameCommencer avec pygame

Remarques

Pygame est un wrapper Python pour SDL - une bibliothèque C multi-plateforme pour contrôler le multimédia -, écrite par Pete Shinners. Cela signifie qu'en utilisant pygame, vous pouvez écrire des jeux vidéo ou d'autres applications multimédias en Python qui s'exécuteront sans aucune modification sur les plateformes prises en charge par SDL (Windows, Unix, Mac, beOS et autres).


Cette section fournit une vue d'ensemble de ce qu'est pygame et pourquoi un développeur peut vouloir l'utiliser.

Il convient également de mentionner tous les grands sujets au sein de Pygame, et d'établir un lien avec les sujets connexes. La documentation de pygame étant nouvelle, vous devrez peut-être créer des versions initiales de ces rubriques connexes.

Versions

| Version | ==============> | Date de sortie |
| Pygame 1.9.0 | ========> | 1 août 2009 |
| Pygame 1.8.1 | ========> | 30 juillet 2008 |
| Pygame 1.8.0 | ========> | 29 mars 2008 |
| Pygame 1.7.1 | ========> | 16 août 2005 |
| Pygame 1.6.2 | ========> | - |
| Pygame 1.6 | =========> | 23 octobre 2003 |
| Pygame 1.5 | =========> | 30 mai 2002 |
| Pygame 1.4 | =========> | Jan 30, 2002 |
| Pygame 1.3 | =========> | 19 décembre 2001 |
| Pygame 1.2 | =========> | 4 septembre 2001 |
| Pygame 1.1 | =========> | 23 juin 2001 |
| Pygame 1.0 | =========> | 5 avril 2001 |
| Pygame 0.9 | =========> | Feb 13, 2001 |
| Pygame 0.5 | =========> | Jan 6 14, 2001 |
| Pygame 0.4 | =========> | 14 décembre 2000 |
| Pygame 0.3 | =========> | 20 novembre 2000 |
| Pygame 0.2 | =========> | 3 novembre 2000 |
| Pygame 0.1 | =========> | 28 octobre 2000 |

Un simple 'jeu'


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 correctement initialisés. Si nous oublions cela, certains modules ne fonctionneront pas. La fonction renvoie également un tuple de toutes les initialisations réussies et échouées (cela ne provoquera 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 suffit donc de définir le mode d'affichage (dans cet exemple, nous ne définissons que la résolution). Il est également judicieux de créer une horloge pour s’assurer que nos programmes sont mis à jour à une vitesse fixe (sinon, la vitesse serait 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 tard dans notre code, nous allons créer deux constantes de couleur, représentant 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 une rect (rectangle) pour représenter la position d'un objet. Une surface est comme une feuille de papier vierge contenant des couleurs ou des images. Si vous créez une classe, vous devez nommer les attributs image et rect car de nombreuses fonctions recherchent et utilisent ces attributs. De telles classes en tireraient avantage en héritant de la classe pygame.sprite.Sprite pour les raisons que vous pouvez lire ici .

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, nous avons tout prévu pour notre boucle de jeu. Ceci est une boucle qui fonctionnera pour tout le jeu, où nous gérons les événements et met à jour l'écran et les positions de nos objets.

D'abord, nous nous assurerons 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 dispose de suffisamment de temps pour que notre boucle répète la quantité que nous avons définie pour 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 pygame.event.get() appelant pygame.event.get() . Nous pouvons itérer 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 vérifier avec les constantes du module pygame pour déterminer le type d’événement.

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 possède une clé d' attribut 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 pourrions vouloir 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 le supprimer). Ensuite, il faut que notre image soit visible à l'écran. Blitting signifie essentiellement copier l' image sur une autre surface (dans notre cas, l'écran). Enfin, nous retournons ou mettons à jour l'écran.

Lorsque nous sommes en train de claquer, 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 ) de son côté de l'écran, le retourne vers l'utilisateur, puis le répète.

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

Maintenant, nous avons un jeu de base! Assez ennuyeux, oui, mais l'essentiel est là! Combiné avec votre connaissance actuelle de Python, vous devriez pouvoir 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écanismes de jeu légèrement améliorés

Notez que le programme vérifie quand on appuie sur la touche et pas pour quand on appuie sur la touche. Pour résoudre ce problème, nous pourrions introduire une variable de vitesse . Nous pouvons créer une classe de joueur pour la maintenir plus organisée. Pour éviter le mouvement dépendant du cadre (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 passant 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 concernant ce code. Je vous recommande de lire le tutoriel pygame et cette conférence de Richard Jones pour plus de détails.

Importation de pygame et dessin sur un écran

Commencer

Vous devez faire ce qui suit pour commencer avec Pygame:

import pygame
 

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

Configurer un nom de fenêtre

La configuration d'un nom pour la fenêtre Pygame requiert la syntaxe suivante:

pygame.display.set_caption('Name')
 

A 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. Ce sont les coordonnées du côté droit sur le plan cartésien qui sont positives et le côté gauche est négatif. en bas. ( Remarque : Ceci est considéré si les points sont pris à partir de l'origine.)

Mise à jour de l'écran

Les modifications que vous apportez à l'écran, par exemple en le remplissant de couleur ou en y dessinant, ne s'affichent pas immédiatement!
Alors, comment le faire?
Vous devez appeler cette fonction:

pygame.display.update()
 

Couleurs

La coloration dans Pygame fonctionne en mode RVB.
Le code pour la coloration est:

color_Name = (r,g,b)
 
  • R signifie rouge.
  • G signifie vert
  • B signifie bleu.
  • Les trois devraient être des entiers compris entre 0 et 255, 255 étant le plus clair et 0 le plus sombre

Dessin

  1. Dessiner des lignes

    pygame.draw.lines(screen, color, closed, pointlist, thickness)
     
  2. Dessiner un rectangle

    pygame.draw.rect(screen, color, (x,y,width,height), thickness)
     
  3. Dessiner un cercle

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

Mettre tout 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()
 

Installation de pygame

Sur les fenêtres

  1. Naviguez jusqu'à http://www.lfd.uci.edu/~gohlke/pythonlibs/#pygame - un site non officiel fournissant des binaires Windows de paquets python open-source pour la distribution officielle CPython par Christoph Gohlke .

  2. Téléchargez le fichier .whl pygame approprié en fonction de votre version de python installée. (Le fichier s'appelle quelque chose comme pygame - <pygame version> - <python version> - win32.whl )

  3. Courir

     pip install your-pygame-package.whl
     

    à l'intérieur de votre terminal, bash ou consoler.
    Remarque: si pip est introuvable dans PATH essayez d’exécuter python -m pip install your-pygame-package.whl

  4. Vérifiez si vous pouvez importer pygame en tant que module Python

    import pygame
     

    Si vous ne recevez pas d'erreur, vous avez correctement installé pygame sur votre ordinateur :)

Sur linux

  1. Ouvrez votre terminal et lancez

    sudo apt-get install python-pygame
     

    Note: Ceci installera pygame pour python2

  2. Essayez d'importer pygame à l'intérieur

    import pygame
     

    Si vous ne recevez pas d'erreur, vous avez correctement installé pygame sur votre système Linux :)

Sur macOS

Il y a deux manières de l'installer sur mac:

Méthode 1

Accédez à la page de téléchargement Pygame 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 :

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

Ensuite, utilisez 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 d' import pygame . S'il ne dit rien, il est installé avec succès.