''''Ce fichier permet de dessiner deux formes à l'aide des deux fonctions suivantes
 
 triangle_equilateral(cote, infos, coordonnees)
 arc_de_cercle(rayon, angle, infos, coordonnees)
 rectangle(cote, infos, coordonnees)
 porte(cote, infos, coordonnees) 
Exemples d'utilisation :
infos_generales = {'écriture':'blue', 'fond':'#FF88FF', 'épaisseur':5}
 triangle_equilateral(50, infos_generales, (50,100))
 arc_de_cercle(75, 360, infos_generales, (200,-200))
 rectangle(50,50, infos_generales, (50,100))
 porte(50,40, infos_generales, (50,100))
'''
 
# Importation
 
import turtle as trt
import random as rd
 
# Pas de classes
 
# Déclaration des fonctions privées
 
def nouveau_stylo(ecriture, fond, largeur):
    '''Renvoie la référence d'un stylo configuré
 
    :: param ecriture(str)  :: la couleur d'écriture ('red', '#FF0000')
    :: param fond(str)      :: la couleur de fond pour ce stylo
    :: param largeur(int)   :: la largeur du trait
    :: return (Turtle)      :: renvoie un objet de la classe Turtle
 
    '''
    feutre = trt.Turtle()
    feutre.color(ecriture)
    feutre.fillcolor(fond)
    feutre.pensize(largeur)
    feutre.speed(5)
    return feutre
 
def deplacer(feutre, x, y):
    '''Lève le feutre, déplace le feutre et abaisse le feutre
 
    :: param feutre(Turtle) :: la référence de l'objet Turtle
    :: param x(int)         :: coordonnée horizontale (abscisse)
    :: param y(int)         :: coordonnée verticale (ordonnée)
    :: return (None)        :: c'est une fonction sans retour
    .. effet de bord        :: modifie l'état de feutre
 
    '''
    feutre.penup()       # On lève la pointe
    feutre.goto(x, y)  # On déplace le crayon
    feutre.pendown()     # On abaisse la pointe
 
def trace_triangle_equilateral(feutre, cote):
    '''Trace un triangle (equilatéral) à l'aide du crayon feutre
 
    :: param ftr(Turtle)    :: la référence de l'objet Turtle
    :: param cote(int)      :: la valeur en pixel des côtés 
    :: return (None)        :: fonction sans retour
    .. effet de bord        :: modifie l'état de feutre
 
    '''
    feutre.begin_fill()
    for x in range(3):
        feutre.forward(cote)
        feutre.left(120)
    feutre.end_fill()
    feutre.hideturtle()
 
def trace_arc(feutre, rayon, angle):
    '''Trace un arc de cercle à l'aide du crayon feutre
 
    :: param ftr(Turtle)    :: la référence de l'objet Turtle
    :: param rayon(int)     :: la valeur en pixel du rayon
    :: param angle(int)     :: l'angle à tracer (360 pour un cercle)
    :: return (None)        :: fonction sans retour
    .. effet de bord        :: modifie l'état de feutre
 
    '''
    feutre.begin_fill()
    feutre.circle(rayon, angle)
    feutre.end_fill()
    feutre.hideturtle()
 
# Déclarations des fonctions d'interface (aucun paramètre n'est lié au module Turtle)
 
def triangle_equilateral(cote, infos, coordonnees):
    '''Trace un triangle (equilatéral) à partir des infos et aux bonnees coordonnées
 
    :: param cote(int)                     :: la valeur en pixel des côtés
    :: param infos(dict)                   :: un dictionnaire {"écriture":str, "fond":str, "épaisseur":int}    
    :: param coordonnees(tuple (int,int) ) :: un tuple (x,y)
 
    '''
    ecriture = infos['écriture']
    fond = infos['fond']
    epaisseur = infos['épaisseur']
    x = coordonnees[0]                  # ou x,y = coordonnees
    y = coordonnees[1]
 
    feutre = nouveau_stylo(ecriture, fond, epaisseur)
    deplacer(feutre, x, y)
    trace_triangle_equilateral(feutre, cote)
 
    return feutre
 
def arc_de_cercle(rayon, angle, infos, coordonnees):
    '''Trace un arc de cercle à partir des infos et aux bonnees coordonnées
 
    :: param rayon(int)                    :: la valeur en pixel du rayon
    :: param angle(int)                    :: la valeur en ° de l'angle
    :: param infos(dict)                   :: un dictionnaire {"écriture":str, "fond":str, "épaisseur":int}    
    :: param coordonnees(tuple (int,int) ) :: un tuple (x,y)
 
    '''
    ecriture = infos['écriture']
    fond = infos['fond']
    epaisseur = infos['épaisseur']
    x = coordonnees[0]                  # ou x,y = coordonnees
    y = coordonnees[1]
 
    feutre = nouveau_stylo(ecriture, fond, epaisseur)
    deplacer(feutre, x, y)
    trace_arc(feutre, rayon, angle)
 
    return feutre
 
def trace_rectangle(feutre, largeur, hauteur):
    '''Trace un rectangle à l'aide du crayon feutre
 
    :: param ftr(Turtle)    :: la référence de l'objet Turtle
    :: param cote(int)      :: la valeur en pixel des côtés 
    :: return (None)        :: fonction sans retour
    .. effet de bord        :: modifie l'état de feutre
 
    '''
    feutre.begin_fill()
    for x in range(2):
        feutre.forward(largeur)
        feutre.left(90)
        feutre.forward(hauteur)
        feutre.left(90)
    feutre.end_fill()
    feutre.hideturtle()
    
def rectangle(largeur, hauteur,  infos, coordonnees):
    '''Trace un rectangle à partir des infos et aux bonnees coordonnées
 
    :: param largeur(int)                     :: la valeur en pixel de la largeur
    :: param hauteur(int)                     :: la valeur en pixel de la hauteur
    :: param infos(dict)                   :: un dictionnaire {"écriture":str, "fond":str, "épaisseur":int}    
    :: param coordonnees(tuple (int,int) ) :: un tuple (x,y)
 
    '''
    ecriture = infos['écriture']
    fond = infos['fond']
    epaisseur = infos['épaisseur']
    x = coordonnees[0]                  # ou x,y = coordonnees
    y = coordonnees[1]
 
    feutre = nouveau_stylo(ecriture, fond, epaisseur)
    deplacer(feutre, x, y)
    trace_rectangle(feutre, largeur, hauteur)
 
    return feutre
def trace_porte(feutre, largeur, hauteur):
    '''Trace une porte à l'aide du crayon feutre
 
    :: param ftr(Turtle)    :: la référence de l'objet Turtle
    :: param cote(int)      :: la valeur en pixel des côtés 
    :: return (None)        :: fonction sans retour
    .. effet de bord        :: modifie l'état de feutre
 
    '''
    feutre.begin_fill()
    for x in range(2):
        feutre.forward(largeur)
        feutre.left(90)
        feutre.forward(hauteur)
        feutre.left(90)
    feutre.end_fill()
    feutre.hideturtle()
def porte(largeur, hauteur,  infos, coordonnees):
    '''Trace un rectangle à partir des infos et aux bonnees coordonnées
 
    :: param largeur(int)                     :: la valeur en pixel de la largeur
    :: param hauteur(int)                     :: la valeur en pixel de la hauteur
    :: param infos(dict)                   :: un dictionnaire {"écriture":str, "fond":str, "épaisseur":int}    
    :: param coordonnees(tuple (int,int) ) :: un tuple (x,y)
 
    '''
    ecriture = infos['écriture']
    fond = infos['fond']
    epaisseur = infos['épaisseur']
    x = coordonnees[0]                  # ou x,y = coordonnees
    y = coordonnees[1]
 
    feutre = nouveau_stylo(ecriture, fond, epaisseur)
    deplacer(feutre, x, y)
    trace_porte(feutre, largeur, hauteur)
 
    return feutre


def trace_fenetre(feutre, largeur, hauteur):
    '''Trace une fenetre a l'aide du feutre
    
    :: param ftr(Turtle)    :: la référence de l'objet Turtle
    :: param cote(int)      :: la valeur en pixel des côtés 
    :: return (None)        :: fonction sans retour
    .. effet de bord        :: modifie l'état de feutre
 
    '''
    
    feutre.begin_fill()
    for x in range(2):
        feutre.forward(largeur)
        feutre.forward(hauteur)
        feutre.left()
    feutre.end_fill()
    feutre.hideturtle()
    
def fenetre(largeur, hauteur, infos, coordonnees):
    '''Trace une fenetre à partir des infos et aux bonnees coordonnées
 
    :: param largeur(int)                     :: la valeur en pixel de la largeur
    :: param hauteur(int)                     :: la valeur en pixel de la hauteur
    :: param infos(dict)                   :: un dictionnaire {"écriture":str, "fond":str, "épaisseur":int}    
    :: param coordonnees(tuple (int,int) ) :: un tuple (x,y)
 
    '''
    ecriture = infos['écriture']
    fond = infos['fond']
    epaisseur = infos['épaisseur']
    x = coordonnees[0]                  # ou x,y = coordonnees
    y = coordonnees[1]
 
    feutre = nouveau_stylo(ecriture, fond, epaisseur)
    deplacer(feutre, x, y)
 
    return feutre
    
 
 
# Corps du programme principal
 
if __name__ == '__main__':
 
    infos_generales = {'écriture':'blue', 'fond':'#FF88FF', 'épaisseur':5}
    triangle_equilateral(100, infos_generales, (-200,100))
    
    
    infos_generales = {'écriture':'blue', 'fond':'#FF88FF', 'épaisseur':5}
    triangle_equilateral(100, infos_generales, (-400,100))
   
    
    infos_generales = {'écriture':'blue', 'fond':'#FF88FF', 'épaisseur':5}
    triangle_equilateral(100, infos_generales, (-300,100))
    
    
    infos_generales = {'écriture':'blue', 'fond':'#FF88FF', 'épaisseur':5}
    triangle_equilateral(100, infos_generales, (-100,100))
                    
    infos_generales = {'écriture':'blue', 'fond':'#FF88FF', 'épaisseur':5}
    rectangle(100,400, infos_generales, (-100,-300))
    
    infos_generales = {'écriture':'blue', 'fond':'#FF88FF', 'épaisseur':5}
    rectangle(100,400, infos_generales, (-200,-300))
    
    infos_generales = {'écriture':'blue', 'fond':'#FF88FF', 'épaisseur':5}
    rectangle(100,400, infos_generales, (-400,-300))
    
    infos_generales = {'écriture':'blue', 'fond':'#FF88FF', 'épaisseur':5}
    rectangle(100,400, infos_generales, (-300,-300))
    
    infos_generales = {'écriture':'blue', 'fond':'#FF88FF', 'épaisseur':5}
    fenetre(100,400, infos_generales, (-100,-300))