From 2de810cd7e7f1dcda092eb558348170efa3a9d55 Mon Sep 17 00:00:00 2001 From: "Dorian.D" Date: Thu, 21 Sep 2023 16:04:34 +0200 Subject: [PATCH] Projet --- dessiner.py | 175 ++++++++++++++++++++++++++++++++++++++++++++++++++++ ma_rue.py | Bin 0 -> 1024 bytes rue.py | 90 +++++++++++++++++++++++++++ 3 files changed, 265 insertions(+) create mode 100644 dessiner.py create mode 100644 ma_rue.py create mode 100644 rue.py diff --git a/dessiner.py b/dessiner.py new file mode 100644 index 0000000..2eb539e --- /dev/null +++ b/dessiner.py @@ -0,0 +1,175 @@ +"""Ce fichier permet de dessiner des formes à l'aide des fonctions suivantes + ++ triangle_equilateral(cote, info_feutre, coordonnees) ++ arc_de_cercle(rayon, angle, info_feutre, coordonnees) + + +Exemples d'utilisation : +>>> informations_feutre = {'écriture':'blue', 'fond':'#FF88FF', 'épaisseur':5} +>>> triangle_equilateral(50, informations_feutre, (50,100)) +>>> arc_de_cercle(75, 360, informations_feutre, (200,-200)) +""" + + +# Importation + +import turtle as trt +import random as rd + + +# 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 feutre(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 feutre(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() + +def trace_rectangle(feutre, largeur, longueur): + """Trace un rectangle à l'aide du crayon feutre + + :: param feutre(Turtle) :: la référence de l'objet Turtle + :: param longueur(int) :: la valeur en pixel des cotés sur la longueur + :: param largeur(int) :: la valeur en pixel des cotés sur la largeur + :: return (None) :: fonction sans retour + """ + feutre.begin_fill() + feutre.right(180) + feutre.forward(longueur) + feutre.right(90) + feutre.forward(largeur) + feutre.right(90) + feutre.forward(longueur) + feutre.right(90) + feutre.forward(largeur) + feutre.end_fill() + feutre.hideturtle() + + +# Déclarations des fonctions publiques + +def triangle_equilateral(cote, info_feutre, coordonnees): + """Trace un triangle (equilatéral) à partir des info_feutre et aux bonnees coordonnées + + :: param cote(int) :: la valeur en pixel des côtés + :: param info_feutre(dict) :: un dictionnaire {"écriture":str, "fond":str, "épaisseur":int} + :: param coordonnees(tuple (int,int) ) :: un tuple (x,y) + + """ + ecriture = info_feutre['écriture'] + fond = info_feutre['fond'] + epaisseur = info_feutre['épaisseur'] + x = coordonnees[0] # ou x,y = coordonnees (par désempaquetage) + 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, info_feutre, coordonnees): + """Trace un arc de cercle à partir des info_feutre et aux bonnees coordonnées + + :: param rayon(int) :: la valeur en pixel du rayon + :: param angle(int) :: la valeur en ° de l'angle + :: param info_feutre(dict) :: un dictionnaire {"écriture":str, "fond":str, "épaisseur":int} + :: param coordonnees(tuple (int,int) ) :: un tuple (x,y) + + """ + ecriture = info_feutre['écriture'] + fond = info_feutre['fond'] + epaisseur = info_feutre['épaisseur'] + x = coordonnees[0] # ou x,y = coordonnees (par désempaquetage) + y = coordonnees[1] + + feutre = nouveau_stylo(ecriture, fond, epaisseur) + deplacer(feutre, x, y) + trace_arc(feutre, rayon, angle) + + return feutre + +def rectangle(largeur, longueur, info_feutre, coordonnees): + """Trace un rectangle à partir des info_feutre et aux bonnees coordonnées + + :: param largeur(int) :: la valeur en pixel des cotés de a largeur + :: param longueur(int) :: la valeur en pixel des cotés de la longueur + :: param info_feutre(dict) :: un dictionnaire {"écriture":str, "fond":str, "épaisseur":int} + :: param coordonnees(tuple (int,int) ) :: un tuple (x,y) + + """ + ecriture = info_feutre['écriture'] + fond = info_feutre['fond'] + epaisseur = info_feutre['épaisseur'] + x = coordonnees[0] # ou x,y = coordonnees (par désempaquetage) + y = coordonnees[1] + + feutre = nouveau_stylo(ecriture, fond, epaisseur) + deplacer(feutre, x, y) + trace_rectangle(feutre, largeur, longueur) + + return feutre + +# Instructions du programme principal + +if __name__ == '__main__': + + informations_feutre = {'écriture':"blue", 'fond':'#FF88FF', 'épaisseur':5} + triangle_equilateral(50, informations_feutre, (50,100)) + arc_de_cercle(75, 360, informations_feutre, (200,-200)) + rectangle(140, 80, informations_feutre, (300, -200)) \ No newline at end of file diff --git a/ma_rue.py b/ma_rue.py new file mode 100644 index 0000000000000000000000000000000000000000..06d7405020018ddf3cacee90fd4af10487da3d20 GIT binary patch literal 1024 ScmZQz7zLvtFd70QH3R?z00031 literal 0 HcmV?d00001 diff --git a/rue.py b/rue.py new file mode 100644 index 0000000..0f78b6a --- /dev/null +++ b/rue.py @@ -0,0 +1,90 @@ +"""Ce fichier permet de dessiner une rue à l'aide des fonctions suivantes : + ++ dessiner_rue_aleatoire() ++ dessiner_rue_decrite(rue:dict) +""" + + +# Importation + +import dessiner as ds +import turtle as trt +import random as rd + + +# Constantes + +LARGEUR_IMMEUBLE = 140 + + +# Fonction privées + +def immeuble_aleatoire(numero:int) -> dict: + informations = {} + informations['couleur_facade'] = couleur_aleatoire() + informations['numero'] = numero + informations['etages'] = rd.randint(2,6) + return informations + +def couleur_aleatoire() -> str: + liste = ["red","blue","yellow","black","orange","purple","brown","pink","green"] + couleur = rd.randint(0,len(liste)-1) + return liste[couleur] + +def coordonnees_facade(immeuble:dict) -> tuple: + x_gauche = -200 + 200 * immeuble['numero'] + y_bas = -100 + return (x_gauche, y_bas) + +def coordonees_fenetre(immeuble:dict) -> tuple: + x_gauche, y_bas = coordonnees_facade(immeuble) + x_gauche = x_gauche - 100 + y_bas = y_bas + 20 + return (x_gauche, y_bas) + +def dessiner_facade(immeuble:dict) -> None: + # Traduction des données de rue vers dessiner + crayon = {} + crayon['écriture'] = "grey" + crayon['fond'] = immeuble['couleur_facade'] + crayon['épaisseur'] = 3 + x, y = coordonnees_facade(immeuble) # désempaquatage du couple + cote = LARGEUR_IMMEUBLE + # Demande d'affichage + for i in range(immeuble['etages']): + ds.rectangle(80, cote, crayon, (x,y + i * 80)) + +def dessiner_porte(immeuble:dict) -> None: + # Traduction des données de rue vers dessiner + crayon = {} + pass + +def dessiner_fenetre(immeuble:dict) -> None: + crayon = {} + crayon['écriture'] = 'white' + crayon['fond'] = 'blue' + crayon['épaisseur'] = 2 + x, y = coordonees_fenetre(immeuble) + cote = 30 + ds.rectangle(cote, cote, crayon, (x,y)) + + +def dessiner_immeuble(immeuble:dict) -> None: + dessiner_facade(immeuble) + dessiner_porte(immeuble) + dessiner_fenetre(immeuble) + # à compléter avec d'autres fonctions pour le reste : toit, fenêtres... + +def dessiner_rue_aleatoire() -> None: + for n in range(4): + informations_immeuble = immeuble_aleatoire(n) + dessiner_immeuble(informations_immeuble) + +def dessiner_rue_decrite(rue:'?') -> None: + pass + + +# Programme principal + +if __name__ == '__main__': + dessiner_rue_aleatoire()