Evénements¶
Quand tu utilises le clavier ou la souris de ton ordinateur, tu t’y attends qu’il réagit immédiatement. En informatique on appelle un telle action de l’utilisateur un event. Un programme est toujours à l’écoute des événements et répond par des actions.
Utiliser les touches¶
Beaucoup de jeux utilisent des touches pour faire bouger le personnage du jeu. Souvent ce sont les touches WASD du clavier.
Tu peux programmer ta tortue pour la bouger avec ces touches.
La fonction onkey(move_forward, 'w') associe la touche W avec la fonction move_forward.
Tu dois définir cette fonction, par exemple avancer de 30 pixels:
def move_forward():
forward(30)
On appelle ça de définir une fonction de callback pour l’événement. Voici la définition des 4 fonctions de callback pour les 4 touches de direction WASD:
onkey(move_forward, 'w')
onkey(move_backward, 's')
onkey(turn_left, 'a')
onkey(turn_right, 'd')
Pour que la tortue commence à écouter aux événements, tu dois appeler listen().
Essaye maintenant de contrôler la tortue avec les touches WASD et de faire un dessin.
from turtle import *
def move_forward():
forward(30)
def move_backward():
backward(30)
def turn_left():
left(30)
def turn_right():
right(30)
onkey(move_forward, 'w')
onkey(move_backward, 's')
onkey(turn_left, 'a')
onkey(turn_right, 'd')
listen()
forward(0)
done()
Utiliser les flèches¶
Si tu préfère les flèches, tu peux aussi programmer ta tortue pour la bouger avec les touches de direction.
Les 4 touches de direction ont les noms Up, Down, Left, Right. Voici la défintion des 4 fonctions callback:
onkey(move_forward, 'Up')
onkey(move_backward, 'Down')
onkey(turn_left, 'Left')
onkey(turn_right, 'Right')
Tu peux combiner les touche WASD avec les flèches. Ceci te donne deux méthodes différentes pour bouger la tortue.
from turtle import *
def move_forward():
forward(30)
def move_backward():
backward(30)
def turn_left():
left(30)
def turn_right():
right(30)
onkey(move_forward, 'Up')
onkey(move_backward, 'Down')
onkey(turn_left, 'Left')
onkey(turn_right, 'Right')
listen()
forward(0)
done()
Effacer l’écran¶
Tu peux ajouter d’autres fonctions, comme:
- effacer l’écran (clear)
- retourner la tortue à la position initiale (home)
- remettre en situation initial (reset)
- quitter (bye)
Comme ces fonctions n’ont pas d’argument, tu n’as pas besoin de redéfinir séparément ces fonctions. Tu peux directement mettre leur nom (sans les parenthèses) dans la définition des fonctions callback:
onkey(home, 'h')
onkey(clear, 'c')
onkey(reset, 'r')
onkey(bye, 'q')
Tu peux également ajouter des raccourcis pour faire monter et descendre le stylo:
onkey(up, 'u')
onkey(down, 'd')
Ceci te permet de dessiner des lignes séparées.
Voici le programme en entier.
from turtle import *
def move_forward():
forward(30)
def move_backward():
backward(30)
def turn_left():
left(30)
def turn_right():
right(30)
onkey(move_forward, 'Up')
onkey(move_backward, 'Down')
onkey(turn_left, 'Left')
onkey(turn_right, 'Right')
onkey(home, 'h')
onkey(clear, 'c')
onkey(reset, 'r')
onkey(bye, 'q')
onkey(up, 'u')
onkey(down, 'd')
listen()
forward(0)
done()
La fonction lambda¶
La fonction lambda est une courte fonction définit définit en une seul ligne. Cette fonction ne porte pas de nom, et on l’appelle aussi fonction anonyme. Au lieu d’écrire
def move_forward():
forward(30)
tu peux écrire
lambda : forward(30)
Avec les fonctions lambda notre programme devient très court.
from turtle import *
onkey(lambda: forward(30), 'Up')
onkey(lambda: backward(30), 'Down')
onkey(lambda: left(30), 'Left')
onkey(lambda: right(30), 'Right')
listen()
forward(0)
done()
Contrôler deux tortues¶
Dans la programmation orienté-objet on modélise le monde par
- des classes,
- des objets, et
- des méthodes.
Notre tortue est un objet de la classe Turtle. Jusqu’à maintenant tu as toujours
travaillé avec un seul objet. Mais tu peux créer plusieurs objets (tortues)
et leur donner des noms différents.
Ceci définit deux objets différents: une tortue Alice et une tortue Bob:
alice = Turtle()
bob = Turtle()
Un objet a des attributs tel que sa couleur. Tu peux donner une couleur différente à Alice et à Bob:
alice.color('red')
bob.color('blue')
Tu as déjà vu les méthodes (forward, left, right, etc.)
que tu as utilisé pour l’objet par défaut turtle.
Pour contrôler une tortue spécifique tu ajoute la méthode à son nom. Par exemple:
alice.forward(30)
bob.left(30)
Tu peux utiliser les touches WASD pour contrôler le mouvement d’Alice et les touches de direction pour contrôler le mouvement de Bob.
from turtle import *
alice = Turtle()
bob = Turtle()
alice.color('red')
bob.color('blue')
onkey(lambda: alice.forward(30), 'w')
onkey(lambda: alice.backward(30), 's')
onkey(lambda: alice.left(30), 'a')
onkey(lambda: alice.right(30), 'd')
onkey(lambda: bob.forward(30), 'Up')
onkey(lambda: bob.backward(30), 'Down')
onkey(lambda: bob.left(30), 'Left')
onkey(lambda: bob.right(30), 'Right')
listen()
done()
Coordonnées absolues¶
Les commandes left, right, forward, backward se référent à la position et l’orientation actuelle de la tortue. Quand la tortue est tourné vers le bas, les directions pour nous sont invérsés, et c’est difficile de la controler.
Une autre façon de controler la tortue est d’utiliser des coordonnées (x, y).
Nous les définissons au début du programme, ainsi qu’une distance de déplacement d
x = 0
y = 0
d = 20
A l’intérieur des 4 fonctions nous voulons accéder à ces variables globales.
Pour ne pas créer une nouvelle variable locale de même nom,
nous devons declarer les valeurs que nous affectons avec le mot-clés global:
global x
global y
Avec la touche Up/Down nous incrémentons ou décrémentons la variable y. Avec la touche Left/Right nous incrémentons ou décrémentons la variable x.
from turtle import *
x = 0
y = 0
d = 20
def up():
global y
y = y + d
setposition(x, y)
def down():
global y
y = y - d
setposition(x, y)
def left():
global x
x = x - d
setposition(x, y)
def right():
global x
x = x + d
setposition(x, y)
onkey(up, 'Up')
onkey(down, 'Down')
onkey(left, 'Left')
onkey(right, 'Right')
listen()
forward(0)
done()
Allers vers la souris¶
Tu peux aussi reagir au clic de la souris. Utilise la fonction
onscreenclick(move)
pour désigner la fonction move comme fonction de callback pour le clic de la souris.
def move(x, y):
setposition(x, y)
Tu pourrais encore raccourcir ceci et directement déclarer:
onscreenclick(setposition)
Toutes les lignes sont des segments droit, et la tortue ne change pas d’orientation.
from turtle import *
def move(x, y):
setposition(x, y)
onscreenclick(move)
listen()
forward(0)
done()