Aller plus loin dans les configurations

Comme vous le savez désormais, le repère est initialement centré dans la fenêtre et ses limites à l’intérieur de celle-ci dépendent de la largeur et de la hauteur. Qu’on se le dise, ce n’est pas toujours très pratique !

Or justement, la fonction setworldcoordinates, nous permet de configurer le repère en lui donnant les coordonnées du point bas gauche et celle du coin haut droit du canvas. Notons que la maison reste le point (0, 0) quoiqu’il advienne. Voici des exemples à tester, qui seront sans doute plus parlants :

setworldcoordinates(0, 0, 100, 100)  #L'origine du repère est dans le coin bas gauche
setworldcoordinates(-50, -50, 50, 50)  #L'origine du repère est centré dans la fenêtre
setworldcoordinates(-100, 0, 0, 100)  #L'origine du repère est dans le coin bas droit
setworldcoordinates(-100, -100, -50, -50)  #L'origine du repère est en dehors de la fenêtre

Au passage, la fonction effectue un reset. Ainsi, s’il a des tracés, ceux-ci seront perdus à moins que nous soyons en mode "world" (nous étudierons cela un peu plus loin) auquel cas ils seront redessinés d’après les nouvelles coordonnées.

En paramétrant notre repère, il nous sera donc plus simple nous y déplacer. Voyons maintenant comment personnaliser notre crayon.

Il existe différentes façons de personnaliser notre crayon.

Changer la forme

Pour commencer, nous pouvons changer la forme de celui-ci grâce à la fonction shape. Pour ce faire, il nous suffit de lui passer la valeur d’une forme disponible en paramètre. Si nous ne lui passons aucun paramètre, celle-ci nous retourne la valeur actuelle de la forme. Les formes disponibles, que nous pouvons obtenir avec la fonction getshapes, qui ne prend aucun paramètre, sont :

Voici ci-dessous un programme se servant de ces fonctions et de ontimer, fonction étudiée dans la partie précédente, pour afficher les formes, les unes à la suite des autres :

import turtle
 
FORMES_DISPONIBLES = turtle.getshapes()  #Récupère les formes disponibles
 
def forme(index = 0):
    """Une fonction récursive pour afficher les formes disponibles
    les unes après les autres"""
    turtle.shape(FORMES_DISPONIBLES[index])  #Change la forme
    print(f"Forme actuelle : {turtle.shape()}")  #Affiche la forme actuelle
    if index < len(FORMES_DISPONIBLES)-1:
        turtle.ontimer(lambda : forme(index+1), 1000)
    else:
        return
 
if __name__ == "__main__":
    turtle.ontimer(forme)

À l’exécution de celui-ci, vous verrez enfin l’apparition de la fameuse tortue, icône discrète de ce tutoriel :

Pour vous entraîner, vous pouvez par exemple faire un programme qui tamponne ces formes de manière aléatoire dans la fenêtre, un peu comme l’exemple du ciel étoilé, et vous pouvez aussi faire en sorte de supprimer les tampons de telle ou telle forme avec l’appui sur telle ou telle touche.

Enregistrer une nouvelle forme

En plus des formes initiales, nous avons aussi la possibilité d’ajouter les nôtres (une image au format gif ou encore un polygone) avec register_shape en lui passant un nom et/ou un polygone de cette manière :

turtle.register_shape("triangle", ((-10, 15), (0, 0), (10, 15)))  #Enregistre d'après un polygone
turtle.register_shape("clem.gif")  #Enregistre d'après une image

Comme convenu, nous avons désormais accès à la forme enregistrée :

turtle.shape("clem.gif")

Incliner la forme sans impacter l’angle

Pour incliner la forme sans modifier l’angle, nous avons la fonction tilt qui permet de tourner d’un angle donné. De plus, nous avons aussi la fonction tiltangle pour modifier ou connaître l’orientation de la forme du crayon :

turtle.tilt(90)  #Pointe vers le Nord
print(turtle.tiltangle())  #Affiche '90.0'
turtle.tiltangle(270)  #Pointe vers le Sud
print(turtle.heading())  #Affiche '0.0'

Modifier la taille de la forme

Tout d’abord, il existe aussi un mode pour le redimensionnement et c’est la fonction resizemode qui nous permet de modifier ou connaître celui-ci. Les trois modes disponibles sont :

Nous connaissons la première fonction puisque nous nous en sommes déjà servis. Pour shapesize, celle-ci met le mode de redimensionnement à "user" si elle reçoit des arguments et redimensionne la forme avec possiblement deux dimensions, une perpendiculaire à l’orientation (stretch_wid) ainsi qu’une dans le sens de l’orientation (stretch_len), plus une largeur de contour (outline)

print(turtle.resizemode())  #Affiche 'noresize'
turtle.shapesize(5, 1)
print(turtle.shapesize())  #Affiche '(5, 1, 1)'
turtle.shapesize(1, 5)
turtle.shapesize(4, 2, 2)

Et ce n’est pas tout !

En effet, turtle nous permet aussi diverses configurations, sur lesquelles nous n’allons pas trop nous attarder.

Le mode

Pour commencer, nous pouvons changer le mode en passant une valeur à mode. Si l’on ne passe aucun paramètre, le mode actuel nous est retourné. Par défaut, nous avons travaillé avec le mode "standard", mais il y a au total trois valeurs possibles :

Par la même occasion, cette fonction effectue un reset. Voici un exemple :

turtle.showturtle()
print(turtle.mode())  #Affiche 'standard', pointe vers l'Est
turtle.setheading(90)  #Pointe vers le Nord
turtle.mode("logo")  #Modifie le mode, reset, pointe vers le Nord
turtle.setheading(90)  #Pointe vers l'Est

L’angle

En plus du changement de mode qui impacte l’orientation, nous avons aussi le choix de travailler en degrées ou en radians, respectivement avec les fonctions degrees et radians.

turtle.setheading(90)
turtle.radians()  #Change l'unité des angles à radians
print(turtle.heading())  #Affiche '1.5707963...'

Le mode couleur

Si vous vous rappelez, lorsque nous voulions fournir un tuple (R, G, B) pour les couleurs, nous étions obligés de travailler avec des valeurs entre 0 et 1. En fait, il y a deux modes possibles, le mode 1.0 et le mode 255. Nous pouvons modifier ou connaître ce dernier avec colormode.

print(turtle.colormode())  #Affiche '1.0'
turtle.colormode(255)  #Met le mode de couleur à 255
turtle.colormode(1.0)  #Remet le mode de couleur à 1.0

La vitesse

Au détour des programmes, vous avez dû apercevoir la fonction speed. Celle-ci nous permet de modifier et de connaître la vitesse de tracé comme ceci :

turtle.speed("fastest")  #Met la vitesse la plus rapide
print(turtle.speed())  #Affiche '0'

Nous pouvons lui passer une valeur entre 0 et 10. Au delà de 10 et en deçà de 0.5, la valeur attribuée sera 0. De 1 à 10, la vitesse augmente. Les valeurs clefs sont :

Nous pouvons aussi travailler sur l’animation et la vitesse de celle-ci à l’aide des fonctions delay et tracer. Si cela vous intéresse, je vous renvoie à la documentation pour vous renseigner sur celles-ci.

Le buffer d’annulation

Nous ne l’avons jamais vu, mais il est possible d’annuler une instruction à l’aide de la fonction undo. En fait, celles-ci sont stockées dans un buffer (un tampon mémoire) et nous pouvons faire varier la taille de celui-ci avec la fonction setundobuffer. Bon, à moins de vouloir en réduire la proportion, nous sommes larges puisque sa taille initiale est de 1000 ! Voici un exemple d’utilisation :

turtle.setheading(90)
turtle.undo()  #Annule l'instruction
print(turtle.heading())  #Affiche '0.0'
turtle.setundobuffer(0)  #Le buffer a désormais une taille de 0
turtle.setheading(90)
turtle.undo()  #Aucun effet, vu que le buffer ne peut rien contenir
print(turtle.heading())  #Affiche '90.0'

Voilà, nous avons fait le tour de ces configurations supplémentaires, c’est donc le moment de pratiquer !

C’est l’avant-dernier travaux pratiques et sans doute le plus simple. Comme pour le premier, il suffira de configurer notre fenêtre selon certains critères et de vérifier ces valeurs en les affichant.

Voici les critères en question, suivis du résultat obtenu :

• Mode = "world" ;
• Origine du repère dans coin haut gauche du canvas ;
• Mode de couleur : 255 ;
• Forme du crayon = tortue ;
• Orientation = Sud.

mode : world
position : (0.00,0.00)
mode de couleur : 255
forme : turtle
orientation : 270.0

La correction :

import turtle

def recapitule():
    """Fonction pour récapituler les informations"""
    print(f"mode : {turtle.mode()}")
    print(f"position : {turtle.position()}")
    print(f"mode de couleur : {turtle.colormode()}")
    print(f"forme : {turtle.shape()}")
    print(f"orientation : {turtle.heading()}")
  
if __name__ == "__main__":
    #On met le mode world
    turtle.mode("world")
    #On change l'origine du repère
    turtle.setworldcoordinates(0, -100, 100, 0)
    #On met le mode de couleur à 255
    turtle.colormode(255)
    #On change la forme du crayon à tortue
    turtle.shape("turtle")
    #On oriente le crayon vers le Sud
    turtle.setheading(270)
    #On récapitule
    recapitule()
    #Clique gauche pour quitter
    turtle.exitonclick()

Pas très compliqué, n’est-ce pas ?