ereignisse
Deutsch   English   Français   

11. ÉVÉNEMENTS DE SOURIS

 

 

TU APPRENDS ICI...

 

que la programmation événementielle est un nouveau concept de programmation. Au lieu de donner des commandes à la Tortue avec votre programme, vous pouvez la contrôler avec des clics de souris.

 

 

EXEMPLES

 

Les événements de la souris sont utilisés pour déclencher des actions contrôlées par la souris. Les clics sont enregistrés par le système et déclenchent l'appel d'une fonction de rappel (callback function). Cette fonction retourne les coordonnées du clic et définit ce qui doit se passer lorsque la souris est cliquée. La fonction de rappel est enregistrée comme un paramètre nommé dans makeTurtle()

Dans ton exemple, la tortue se déplace à la position du clic de la souris à chaque clic et y dessine un point. Tu définis ce comportement dans la fonction callback onMousePressed(x, y). La fonction callback renvoie en outre les coordonnées du clic de souris.

La fonction callback est enregistrée via un paramètre de makeTurtle(). Tu indiques ainsi au système qu'il doit appeler cette fonction à chaque clic de souris.

 

Programme: 

from gturtle import *

def onMousePressed(x, y):
    moveTo(x, y)
    dot(20)

makeTurtle(mousePressed = onMousePressed)
hideTurtle()
setPenColor("blue")
dot(20)
►Copy to clipboard
 

 

Dans le deuxième exemple, une étoile est dessinée à chaque clic de souris. Pour cela, tu définis d'abord une fonction drawStar(), qui dessine une étoile. Ensuite, dans la fonction de rappel onMousePressed(x, y), tu définis ce que la Tortue doit faire lorsqu'un bouton de la souris est enfoncé. Ici, elle appelle à la position du clic de souris ta fonction drawStar(), qui dessine une étoile.

La fonction callback est enregistrée comme un paramètre de makeTurtle(). Tu indiques ainsi au système qu'il doit appeler cette fonction à chaque clic de souris. Les coordonnées x, y du clic de souris lui sont alors renvoyées.

 

Programme: 

from gturtle import *

def drawStar():
    repeat 9:
        forward(40)
        right(160)

def onMousePressed(x, y):
    setPos(x, y)
    drawStar()

makeTurtle(mousePressed = onMousePressed)
hideTurtle()
setPenColor("magenta")
►Copy to clipboard
 

 

Ici, un polygone rempli est dessiné avec des clics de souris. Pour cela, tu définis une fonction de rappel drawPoint(x, y), qui relie la position actuelle de la souris à la position du clic et y dessine un point. Tu peux saisir le nombre de sommets via une boîte de dialogue. Si le dernier clic correspond au point de départ, le polygone est rempli en rouge avec la fonction fillPath(). Sinon, le dernier point est relié au point de départ (0,0).

Le nombre de points déjà dessinés est consigné dans la variable n. Celle-ci est incrémentée de 1 à chaque clic de souris. Comme la variable n est utilisée à la fois dans le programme principal et dans la fonction drawPoint(), elle doit être définie global.

  

Programme: 

from gturtle import *

def drawFigure(x, y):
    global n
    if n == 1:
        setPos(x, y)        
        startPath()
    else:
        moveTo(x, y) 
    dot(5)
    if n == nbCorners:
        fillPath()  
    n += 1

makeTurtle(mousePressed = drawFigure)
hideTurtle()
setFillColor("red")
n = 1
nbCorners = inputInt("Gib die Eckenzahl ein:")
► Copy to clipboard

 

 

 

REMARQUE...
 

La nouvelle technique de programmation peut être reconnue par le fait que la fonction onMousePressed(x, y) n'est appelée nulle part dans votre programme. Elle est appelée par le système lorsqu'un événement se produit. Nous appelons cette fonction une fonction de rappel ou callback.

La variable n dans le dernier exemple est appelée variable globale, car elle est utilisée à la fois dans le programme principal et dans la fonction drawPoint(x,y). Une variable utilisée uniquement dans une fonction est appelée variable locale.

 

 

À FAIRE PAR TOI-MÊME

 

1.

Un cercle rempli (point) doit être dessiné à chaque clic de souris. Les couleurs de remplissage et le diamètre du cercle doivent être choisis de manière aléatoire. Tu peux voir comment créer des couleurs aléatoires dans le deuxième exemple du chapitre Nombres aléatoires.		  

2.
Sur un fond bleu foncé, une étoile remplie de jaune est dessinée à chaque clic de souris. Tu dessines le fond bleu avec la commande clear(“darkblue”)  

3.

Comme dans l'exercice précédent, les étoiles sont dessinées aux positions des clics de la souris. La couleur de remplissage des étoiles alterne entre rouge et bleu. (Après avoir dessiné une étoile rouge, tu dois mettre la couleur en bleu et vice versa).

  

 

 

 

MATERIEL SUPPLÉMENTAIRE
 

TON PREMIER JEU
 

Tic-tac-toe est un jeu bien connu dans lequel deux joueurs placent alternativement des croix ou des ronds dans les cases d'une grille 3x3, dans le but d'être le premier à avoir trois de ses propres signes sur une ligne horizontale, verticale ou sur l'une des diagonales.

 

Ici, au lieu de dessiner des croix et des cercles, tu dessines un point rouge ou vert selon le joueur.

Définis d'abord la fonction drawBoard() qui dessine la grille 3x3. Pour changer la couleur, tu introduis une variable player qui identifie le joueur (valeur 1 ou 2). Cette variable doit être déclarée global dans la fonction de rappel drawDot(), car elle est initialisée dans le programme principal et alterne entre les valeurs 1 et 2 après chaque clic de souris.

  


Programme: 
from gturtle import *

def square():
    for i in range(4):
        forward(60)
        right(90)

def drawBoard():
    for x in range(3):
        for y in range(3):
            setPos(60 * x, 60 * y)
            square()

def drawDot(x, y):
    global player
    if player == 1:
        setPenColor("red")
        player = 2
    elif player == 2:
        setPenColor("lime")
        player = 1
    setPos(x, y)
    dot(45)

player = 1        
makeTurtle(mousePressed = drawDot)
hideTurtle()
drawBoard()
► Copy to clipboard

Il serait intéressant d'étendre le jeu pour qu'il reconnaisse automatiquement quand un joueur a gagné ou si la partie est nulle.

 

 

À RÉSOUDRE PAR TOI-MÊME
 
4*.


Créez un jeu de Nim avec 15 pierres rouges. Chaque joueur peut retirer un maximum de 3 pierres avec un clic de souris, puis doit cliquer sur un bouton vert (bouton "OK"). C'est ensuite au tour de l'autre joueur. Celui qui enlève la dernière pierre a perdu. Pour savoir si un joueur a cliqué avec la souris sur la pierre rouge ou sur le bouton vert, tu utilises la commande getPixelColorStr(). Celle-ci renvoie la couleur de fond (par ex. « red » , « green »). Pour faire disparaître les pierres, il suffit de les peindre en blanc. Le jeu se joue généralement avec des allumettes.