Editions ENI Livres | Vidéos | e-Formations
Les modules secondaires Pygame
Introduction
Ce chapitre traite des modules de Pygame moins utilisés, qui peuvent être perçus comme secondaires. Il est possible que vos développements de jeux vidéo vous amènent toutefois à les manipuler. Le présent chapitre fera alors office de documentation très détaillée.
Les modules ou objets détaillés ici sont les suivants :
1. cursors
2. joystick
3. touch
4. math
5. surfarray
6. camera
Comme dans le chapitre précédent, on utilise la notation suivante. Celle-ci signifie que l’appel de la fonction Exemple1 qui prend en paramètre a et b renvoie un int :
Exemple1( a, b) -> int Autre exemple, la fonction Exemple2 qui prend en paramètres i, j et k renvoie un objet de type Color :
Exemple2( i, j, k) -> Color Le module cursors
Le module cursors permet de gérer le curseur lui-même. On entend par curseur le repère graphique qui est affiché à l’écran et qui correspond à « l’emplacement » courant de la souris. On a vu dans le chapitre Les principaux modules Pygame comment le module mouse permet de contrôler la position du curseur, mais c’est le module cursors qui permet de choisir l’apparence du curseur elle-même, qui peut être une autre représentation que celle par défaut.
Les apparences de curseur sont stockées sous un format graphique bitmap que le module permet de charger. Une fois l’apparence d’un curseur définie, elle est utilisable depuis le module mouse. Pour imposer cette nouvelle apparence de curseur, on utilise la fonction set_cursor du module mouse, comme ceci :
pygame.mouse.set_cursor(*pygame.cursors.arrow) On notera également que le module définit plusieurs curseurs tous utilisables d’emblée.
Signalons enfin que Pygame permet uniquement une apparence de curseur en noir et blanc (monochrome).
1. Les curseurs prédéfinis du module
Les curseurs suivants sont disponibles et utilisables immédiatement. C’est-à-dire qu’on peut les utiliser d’emblée avec set_cursor du module mouse.
pygame.cursors.arrow
pygame.cursors.diamond
pygame.cursors.broken_x
pygame.cursors.tri_left
pygame.cursors.tri_right Les chaînes de caractères suivantes correspondant à des apparences de curseur sont également disponibles, mais nécessitent préalablement l’action de la fonction compile du module cursors. Cette fonction est à même de les convertir en apparence de curseur, c’est-à-dire en un format bitmap.
pygame.cursors.thickarrow_strings ...Le module joystick
Le module joystick permet de gérer les périphériques de jeu de type joystick, y compris quand ils incluent des boules de commande et des contrôles divers et variés. L’ensemble des exemples du livre impliquent l’usage du clavier et celui de la souris. Il s’agit ici de voir comment on peut gérer un joystick avec Pygame.
Ce module inclut un objet Joystick dont une instance correspond à un joystick donné. On commence par étudier les fonctions du module avant d’étudier cet objet Joystick.
1. La fonction init
init() -> None La fonction init permet d’initialiser le module. Comme souvent, elle est automatiquement appelée par la fonction d’initialisation de Pygame pygame.init().
2. La fonction quit
quit() -> None Le fonction quit est la fonction réciproque de la fonction init. Elle permet de signifier que l’on cesse d’utiliser le module joystick.
3. La fonction get_init
get_init() -> bool La fonction get_init permet de savoir si la fonction init du module a effectivement été appelée ou non. Elle renvoie un booléen et donc la valeur True si c’est effectivement le cas.
4. La fonction get_count
get_count() -> count La fonction get_count permet d’obtenir le nombre de joysticks connectés au poste informatique courant, en tout cas les périphériques reconnus comme tels. Pour chacun des joysticks, on peut décider de les gérer et de les utiliser dans le jeu vidéo Pygame ; pour chaque joystick que l’on utilise dans le jeu, on instancie un objet Joystick dédié.
5. La classe Joystick
a. La fonction Joystick
Joystick(id) -> Joystick C’est le constructeur de cette classe. On le détaille ici car il a la particularité de prendre en paramètre un entier identifiant le joystick associé....
Le module touch
Ce module, qui nécessite obligatoirement SDL2, permet de gérer les périphériques tactiles.
1. La fonction get_num_devices
get_num_devices() -> int Cette fonction permet d’obtenir le nombre de périphériques tactiles effectivement disponibles.
2. La fonction get_device
get_device(index) -> touchid Cette fonction permet d’obtenir l’identifiant d’un périphérique tactile en passant en paramètre l’index de ce périphérique dans la collection. Il faut donc que l’index soit égal au moins à 0 et inférieur au nombre de périphériques tactiles.
3. La fonction get_num_fingers
get_num_fingers(touchid) -> int La fonction get_num_fingers permet d’obtenir le nombre de doigts actifs sur un périphérique tactile donné.
4. La fonction get_finger
get_finger(touchid, index) -> dict La fonction get_finger prend en paramètre le touchid d’un des périphériques tactiles et l’index d’un des doigts actifs sur ce périphérique. On obtient en retour un dictionnaire incluant les valeurs suivantes :
-
l’identifiant id du doigt,
-
la coordonnée x de la position du doigt,
-
la coordonnée y de la position du doigt,
-
la pression d’appui du doigt.
Le module math
Ce module permet de faire du calcul vectoriel au sein même de Pygame. Il autorise en effet la définition de vecteurs en dimension 2 ou 3. On peut alors appliquer un certain nombre d’opérations sur ces vecteurs.
Il existe deux classes dans ce module : Vector2 (vecteur en dimension 2) et Vector3 (vecteur en dimension 3).
1. La classe Vector2 - Création de vecteur
Vector2() -> Vector2
Vector2(int) -> Vector2
Vector2(float) -> Vector2
Vector2(Vector2) -> Vector2
Vector2(x, y) -> Vector2
Vector2((x, y)) -> Vector2 Les prototypes précédents permettent de créer un vecteur en dimension 2.
Ci-après un petit exemple :
vec = pygame.math.Vector2(150,180)
print(vec.x)
print(vec.y) 2. La classe Vector3 - Création de vecteur
Vector3() -> Vector3
Vector3(int) -> Vector3
Vector3(float) -> Vector3
Vector3(Vector3) -> Vector3
Vector3(x, y, z) -> Vector3
Vector3((x, y, z)) -> Vector3 Les prototypes précédents permettent de créer un vecteur en dimension 3.
Exemple
vec = pygame.math.Vector3(150,180, 210)
print(vec.x)
print(vec.y)
print(vec.z) 3. Les principales fonctions de Vector2 et Vector3
Toutes les fonctions de Vector2 ont leurs équivalents dans Vector3. Nous allons donc détailler les principales fonctions de Vector2 sachant que les fonctions correspondantes existent dans la classe gérant la dimension 3.
a. La fonction dot
dot(Vector2) -> float La fonction dot permet de calculer un produit scalaire entre deux vecteurs.
Exemple
vecA = pygame.math.Vector3(1, 2)
vecB = pygame.math.Vector3(3, 4)
dotAB = vecA.dot(vecB)
print(dotAB) b. La fonction length
length() -> float Cette fonction length permet de calculer la norme euclidienne du vecteur...
Le module surfarray
Il peut être intéressant parfois de sauvegarder les surfaces Pygame ou, du moins, de les stocker sous forme de tableaux. C’est le rôle du module surfarray, qui permet la conversion d’une surface en un tableau de pixels.
1. La fonction array2d
array2d(Surface) -> array Cette fonction array2d permet de convertir une surface Pygame en un tableau de pixels.
Exemple
surface = pygame.image.load("image.png").convert()
tableau = pygame.surfarray.array2d(surface) 2. La fonction pixels_red
pixels_red (Surface) -> array Cette fonction permet de créer un tableau qui référence toutes les valeurs rouges (RGB) de pixels d’une surface.
3. La fonction pixels_green
pixels_green (Surface) -> array Cette fonction permet de créer un tableau qui référence toutes les valeurs vertes (RGB) de pixels d’une surface.
4. La fonction pixels_blue
pixels_blue (Surface) -> array Cette fonction permet de créer un tableau qui référence toutes les valeurs bleues (RGB) de pixels d’une surface.
5. La fonction make_surface
make_surface(array) -> Surface La fonction make_surface permet de créer une surface Pygame à partir d’un tableau de pixels tel que créé par exemple avec la fonction array2d.
6. La fonction blit_array
blit_array(Surface, array) -> None La fonction blit_array prend en paramètre une surface Pygame et un tableau de pixels qui permet d’afficher directement la surface à partir des données dudit tableau.
Le module camera
Ce module expérimental permet de faire de la capture vidéo. On entend par capture vidéo la capacité de sauver chaque image du déroulement d’une partie, pour générer une vidéo, voire un flux vidéo, pour faire du streaming par exemple. Ainsi, la partie en cours peut être visionnée en temps réel.
Le module camera est expérimental dans la mesure où il n’y aucune garantie que ce module soit supporté dans les versions à venir de Pygame. Par ailleurs, il est pour le moment restreint à des environnements utilisant des API bien précises de capture vidéo (Video4Linux notamment).
Avant de détailler le contenu du module, voici un exemple très simple d’une capture vidéo effectuée sur une fenêtre de jeu (dans laquelle il ne se passe rien de spécial). La finalité est de générer une vidéo nommée output.avi.
import pygame, sys, os
import pygame.camera
pygame.init()
pygame.camera.init()
ECRAN = pygame.display.set_mode((400, 400))
cam = pygame.camera.Camera("/dev/video0", (400, 400))
cam.start()
NUM = 0
CAPTURE = False
while not CAPTURE:
NUM = NUM + 1
image = cam.get_image()
screen.blit(image, (0,0))
pygame.display.update()
NOM_FICHIER = "PHOTOS/%04d.png" % NUM
pygame.image.save(image, NOM_FICHIER)
for event in pygame.event.get():
if event.type == pygame.QUIT:
CAPTURE = True
os.system("avconv -r 8 -f image2 -i PHOTOS/%04d.png -y -qscale 0 -s 640x480 -
aspect 4:3 output.avi") 1. La fonction list_cameras
list_cameras()...
