Les hooks d’évènements

Pygame Zero va automatiquement détecter et appeler les hooks (littéralement « crochet » ou « hameçon ») d’évènements que tu définis. Cette approche vous épargne d’écrire vous même la mécanique de boucle d’évènements.

Les hooks d’une boucle de jeu

Une boucle de jeu typique ressemble à peu près à ça:

while game_has_not_ended():
    process_input()
    update()
    draw()

Le traitement des entrées est un peu plus complexe, mais Pygame Zero te permet facilement d’écrire les fonctions update() et draw() dans ton programme de jeu.

draw()

Elle est appelée par Pygame Zero quand il a besoin de redessiner l’écran de jeu.

draw() ne prend aucun argument.

Pygame Zero tente de décider quand l’écran de jeu a besoin d’être redessiné afin d’éviter de le faire si rien n’a changé. À chaque pas de la boucle de jeu, il va dessiner l’écran dans les situations suivantes :

  • Si tu as défini une fonction update() (voir ci-dessous).
  • Si un événement d’horloge est émis.
  • Si un événement d’entrée a été déclenché.

Une façon de se faire piéger est lorsque tu tentes de modifier ou animer quelques chose dans la fonction draw. Par exemple, ce code est faux : l’extraterrestre n’est pas garanti de bouger tout le long de l’écran:

def draw():
    alien.left += 1
    alien.draw()

Le code correct utilise la fonction update() pour modifier ou animer les objets et draw simplement pour dessiner à l’écran:

def draw():
    alien.draw()

def update():
    alien.left += 1
update() ou update(dt)

Elle est appelée par Pygame Zero pour faire progresser ta logique de jeu. Elle va être appelée continuellement 60 fois par seconde.

Il y a deux façons d’écrire une fonction update.

Dans les jeux simples, tu peux supposer qu’un court laps de temps (une fraction de seconde) est passé entre chaque appel à update(). Peut être que la durée de ce laps n’a pas d’importance : tu peux juste bouger les objets d’un nombre constant de pixels par images (ou les accélérer par une constante, etc.)

Une approche plus sophistiquée est de baser le mouvement et les calculs physiques sur la quantité réelle de temps écoulée entre deux appels. Cela produit des animations plus fluides, mais les calculs induits peuvent être plus compliqués et tu dois être attentif à ne pas créer de comportements non-prédictibles lorsque le laps de temps écoulé devient plus grand.

Pour utiliser l’approche basée sur le temps, tu peux changer la fonction update en ajoutant un paramètre unique. Si ta fonction update prend un argument, Pygame Zero va lui passer le temps écoulé en secondes. tu peux l’utiliser pour adapter le calcul des mouvements.

Les hooks de gestion d’événements

Comme pour les hooks de la boucle de jeu, ton programme Pygame Zero peut répondre aux événements d’entrée en définissant des fonctions avec des noms spécifiques.

Comme pour la fonction update(), Pygame Zero va inspecter ta fonction de gestion d’événements pour déterminer comment l’appeler. Tu n’as donc pas besoin d’avoir d’arguments à ta fonction. Par exemple, Pygame Zero va être capable d’appeler toutes ces variantes de la fonction on_mouse_down:

def on_mouse_down():
    print("Mouse button clicked")

def on_mouse_down(pos):
    print("Mouse button clicked at", pos)

def on_mouse_down(button):
    print("Mouse button", button, "clicked")

def on_mouse_down(pos, button):
    print("Mouse button", button, "clicked at", pos)

Il le fait en regardant le nom des paramètres, ils doivent donc être épelés exactement comme ci-dessus. Chaque hook d’événements a un ensemble différent de paramètres que tu peux utiliser comme décrit ci-dessous.

on_mouse_down([pos][, button])

Appelée lorsqu’un bouton de la souris est pressé.

Paramètres:
  • pos – un tuple (x, y) donnant la position du pointeur de souris lorsque le bouton a été pressé.
  • button – une valeur de l’énumération mouse indiquant quel bouton a été pressé.
on_mouse_up([pos][, button])

Appelée lorsqu’un un bouton de la souris est relâché.

Paramètres:
  • pos – un tuple (x, y) donnant la position du pointeur de souris lorsque le bouton a été relâché.
  • button – une valeur de l’énumération mouse indiquant quel bouton a été relâché.
on_mouse_move([pos][, rel][, buttons])

Appelée lorsque la souris est bougée.

Paramètres:
  • pos – un tuple (x, y) donnant la position du pointeur de souris à laquelle la souris a bougé.
  • rel – un tuple (delta_x, delta_y) représentant le déplacement relatif du pointeur de souris.
  • buttons – un ensemble de valeurs de l’énumération mouse indiquant quels boutons étaient pressés durant le déplacement.

Pour gérer le glissement de la souris (mouvement avec bouton pressé), utilise un code tel que le suivant:

def on_mouse_move(rel, buttons):
    if mouse.LEFT in buttons:
        # la souris a été glissée, faire quelque chose avec `rel`
        ...
on_key_down([key][, mod][, unicode])

Appelée lorsqu’une touche est pressée.

Paramètres:
  • key – un entier indiquant quelle touche a été pressée (voir ci-dessous).
  • unicode – lorsque cela a du sens, le caractère qui a été entré. Toutes les touches ne produisent pas un caractère affichable - beaucoup sont des caractères de contrôle. Dans le cas où la touche ne correspond pas à un caractère Unicode, cela sera la chaîne vide.
  • mod – un masque de bits représentant les touches mortes également pressées.
on_key_up([key][, mod])

Appelée lorsqu’une touche est relâchée.

Paramètres:
  • key – un entier indiquant quelle touche a été relâchée (voir ci-dessous).
  • mod – un masque de bits représentant les touches mortes pressées.
on_music_end()

Appelée lorsque une piste de musique se termine.

Note qu’elle ne sera pas appelée si la piste audio est configurée pour boucler.

Boutons et touches

Les objets pré-définis mouse et keys peuvent être utilisés pour déterminer quels boutons ou touches étaient pressés dans les événements ci-dessus.

Note que les événements de la molette de la souris apparaissent comme des boutons pressés avec les constantes WHEEL_UP/WHEEL_DOWN.

class mouse

Une énumération pré-défini de boutons qui peut être reçue par les hooks on_mouse_*.

LEFT
MIDDLE
RIGHT
WHEEL_UP
WHEEL_DOWN
class keys

Une énumération pré-défini de touches qui peut être reçue par les hooks on_key_*.

BACKSPACE
TAB
CLEAR
RETURN
PAUSE
ESCAPE
SPACE
EXCLAIM
QUOTEDBL
HASH
DOLLAR
AMPERSAND
QUOTE
LEFTPAREN
RIGHTPAREN
ASTERISK
PLUS
COMMA
MINUS
PERIOD
SLASH
K_0
K_1
K_2
K_3
K_4
K_5
K_6
K_7
K_8
K_9
COLON
SEMICOLON
LESS
EQUALS
GREATER
QUESTION
AT
LEFTBRACKET
BACKSLASH
RIGHTBRACKET
CARET
UNDERSCORE
BACKQUOTE
A
B
C
D
E
F
G
H
I
J
K
L
M
N
O
P
Q
R
S
T
U
V
W
X
Y
Z
DELETE
KP0
KP1
KP2
KP3
KP4
KP5
KP6
KP7
KP8
KP9
KP_PERIOD
KP_DIVIDE
KP_MULTIPLY
KP_MINUS
KP_PLUS
KP_ENTER
KP_EQUALS
UP
DOWN
RIGHT
LEFT
INSERT
HOME
END
PAGEUP
PAGEDOWN
F1
F2
F3
F4
F5
F6
F7
F8
F9
F10
F11
F12
F13
F14
F15
NUMLOCK
CAPSLOCK
SCROLLOCK
RSHIFT
LSHIFT
RCTRL
LCTRL
RALT
LALT
RMETA
LMETA
LSUPER
RSUPER
MODE
HELP
PRINT
SYSREQ
BREAK
MENU
POWER
EURO
LAST

De plus, tu peux accéder a un ensemble de constantes représentant les touches mortes :

class keymods

Constantes représentant les touches mortes qui ont été pressées durant les événements on_key_up/on_key_down.

LSHIFT
RSHIFT
SHIFT
LCTRL
RCTRL
CTRL
LALT
RALT
ALT
LMETA
RMETA
META
NUM
CAPS
MODE