Mise à jour de 'README.md'

Reviewed-on: #1

README.md

@@ -1,2 +1,73 @@
+ # Notation
+
++ Réalisation pratique du projet : 4/5
+    + Pas d'interpréteur valide mais un début
+
++ Bonnes pratiques de programmation : 4/5
+    + interpreteur.py : aucune fonction, tout est dans le programme principal...
+
++ Communication : 2/5
+    + pas de documentation ou presque.
+
++ Revue de projet : 4/5
+    + TB mais pas de jeux de tests permettant de valider la démarche
+
+
+
 # Premier_projet_Kylian_Louis
 
+## Mardi 13/09/2022 Louis 
+* prise en main 
+* groupe formes.py, réalisation de la fonction trace_rectangle() et de la fonction rectangle()
+* rajout de la documentation de rectangle et de trace_rectangle
+
+```python
+def trace_rectangle(feutre, cote) 
+def rectangle(cote, infos, coordonnees)
+```
+
+# Mardi 13/09/2022 Kylian
+* prise en main
+* groupe formes.py, réalisation de la fonction trace_triangle_isocele() et la fonction triangle_isocele()
+* rajout de la documentation de triangle_isocele et trace_triangle_isocele
+
+```python
+def trace_triangle_isocele(feutre, largeur, hauteur, x, y)
+def triangle_isocele(hauteur, largeur, infos, coordonnees)
+```
+
+# Mardi 13/09/2022 Kylian, Louis
+* 20 minutes de débug de programmes (espace en trop a la ligne 194 de formes.py)
+
+# Jeudi 15/09/2022 Kylian, Louis
+* correction de la fonction rectangle et trace_rectangle.
+
+```python
+def rectangle(largeur, hauteur, infos, coordonnees):
+def trace_rectangle(feutre, largeur, hauteur):
+```
+* creation de la façade de 4 immeubles avec leur hauteur générer aléatoirement.
+* Kylian: creation des toits
+
+# Dimanche 18/09/2022 Kylian
+
+* creation de la fonction dessiner_porte
+
+# Samedi 24/09/2022 Kylian
+
+* debut de creation des fenetres (premier etage)
+
+## Mardi 27/09/2022 Kylian/Louis
+
+* terminaison fonction creation des fenetres(tout les étages)
+* création variation de toit
+
+# Jeudi 06/10/2022 Louis
+
+* création de la fonction choisir_couleur qui permet de choisir une couleur aléatoirement
+
+## Jeudi 13/10/2022 Kylian/Louis
+
+* correction lignes de code en trop
+* documentation
+* debut interpreteur

fichier_enfant.txt

@@ -0,0 +1,4 @@
+red-6-3-1
+blue-4-1-1
+purple-2-3-2
+green-5-2-2

formes.py

@@ -80,24 +80,43 @@ def trace_arc(feutre, rayon, angle):
     feutre.end_fill()
     feutre.hideturtle()
  
-def trace_rectangle(feutre, cote):
+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 
+    :: param largeur(int)   :: la valeur en pixel de la largeur
+    :: param hauteur(int)   :: la valeur en pixel de la hauteur
     :: return (None)        :: fonction sans retour
     .. effet de bord        :: modifie l'état de feutre
     
     '''
     feutre.begin_fill()
     for x in range(2):
-        feutre.forward(cote)
+        feutre.forward(largeur)
         feutre.left(90)
-        feutre.forward(cote*2)
+        feutre.forward(hauteur)
         feutre.left(90)
     feutre.end_fill()
     feutre.hideturtle()
 
+def trace_triangle_isocele(feutre, largeur, hauteur, x, y):
+    '''Trace un triangle (isocele) à l'aide du crayon feutre
+ 
+    :: param ftr(Turtle)    :: la référence de l'objet Turtle
+    :: param largeur(int)      :: la valeur en pixel de la largeur
+    :: param hauteur(int) :: la valeur en pixel de la hauteur
+    :: param x(int) :: position de depart en x
+    :: param y(int) :: position de depart en y
+    :: return (None)        :: fonction sans retour
+    .. effet de bord        :: modifie l'état de feutre
+ 
+    '''
+    feutre.begin_fill()
+    feutre.goto(x + largeur//2, hauteur + y)
+    feutre.goto(x + largeur, y)
+    feutre.goto(x, y)
+    feutre.end_fill()
+    feutre.hideturtle()
     
 # Déclarations des fonctions d'interface (aucun paramètre n'est lié au module Turtle)
  
@@ -121,6 +140,27 @@ def triangle_equilateral(cote, infos, coordonnees):
  
     return feutre
 
+def triangle_isocele(hauteur, largeur, infos, coordonnees):
+    '''Trace un triangle (equilatéral) à partir des infos et aux bonnees coordonnées
+ 
+    :: param hauteur(int) :: la valeur en pixel de la hauteur
+    :: param largeur(int) :: la valeur en pixel de la largeur
+    :: 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_isocele(feutre, largeur, hauteur, x, y)
+
+    return feutre
+ 
 def arc_de_cercle(rayon, angle, infos, coordonnees):
     '''Trace un arc de cercle à partir des infos et aux bonnees coordonnées
  
@@ -144,10 +184,11 @@ def arc_de_cercle(rayon, angle, infos, coordonnees):
 
 
     
-def rectangle(cote, infos, coordonnees):
+def rectangle(largeur, hauteur, infos, coordonnees):
     '''Trace un rectangle à partir des infos et aux bonnees coordonnées
  
-    :: param cote(int)                     :: la valeur en pixel des côtés
+    :: 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)
     
@@ -160,13 +201,10 @@ def rectangle(cote, infos, coordonnees):
  
     feutre = nouveau_stylo(ecriture, fond, epaisseur)
     deplacer(feutre, x, y)
-    trace_rectangle(feutre, cote)
+    trace_rectangle(feutre, largeur, hauteur)
  
     return feutre
 
-    
-    
- 
 # Corps du programme principal
  
 if __name__ == '__main__':
@@ -174,4 +212,4 @@ if __name__ == '__main__':
     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(100, infos_generales, (-200,50))
+    rectangle(100, 200, infos_generales, (0,0))

interpreteur.py

@@ -0,0 +1,20 @@
+import rue 
+
+# 1 - Création de l'objet-fichier : ouverture en mode r (read)
+obj_fichier = open('fichier_enfant.txt', 'r', encoding="utf-8")
+ 
+# 2 - Lecture progressive du fichier
+immeuble_1  = obj_fichier.readline().replace('\n', '')
+immeuble_2  = obj_fichier.readline().replace('\n', '')
+immeuble_3  = obj_fichier.readline().replace('\n', '')
+immeuble_4  = obj_fichier.readline().replace('\n', '')
+ 
+# 3 - Fermeture de l'objet-fichier
+obj_fichier.close()
+
+print(immeuble_1.split('-'))
+print(immeuble_2.split('-'))
+print(immeuble_3.split('-'))
+print(immeuble_4.split('-'))
+ensemble = [immeuble_1, immeuble_2, immeuble_3, immeuble_4]
+rue.dessiner_rue_enfant(ensemble)

rue.py

@@ -1,32 +1,107 @@
 # Importation
  
 from formes import triangle_equilateral
+from formes import triangle_isocele
+from formes import rectangle
+import random
  
 # Fonction gestion des données
+lesCouleurs = ['red', 'blue', 'green', 'violet', 'yellow', 'orange', 'magenta']
  
 def determiner_immeuble(numero:int) -> dict:
     caracteristiques = {}
-    caracteristiques['couleur_facade'] = 'red'
+    caracteristiques['couleur_facade'] = choisir_couleur(lesCouleurs)
     caracteristiques['numero'] = numero
+    caracteristiques['coordonnees'] = -350 + numero * 170
+    caracteristiques['etage'] = random.randint(1,6)
+    caracteristiques['porte'] = random.randint(1,3)
+    caracteristiques['toit_variant'] = random.randint(1,2)
+    caracteristiques['fenetre'] = 1    
+        
     return caracteristiques
 
+def determiner_immeuble_enfant(numero:int, tab:list) -> dict:
+    caracteristiques = {}
+    caracteristiques['couleur_facade'] = tab[0]
+    caracteristiques['numero'] = numero
+    caracteristiques['coordonnees'] = -350 + numero * 170
+    caracteristiques['etage'] = tab=[1]
+    caracteristiques['porte'] = tab=[2]
+    caracteristiques['toit_variant'] = tab=[3]
+    caracteristiques['fenetre'] = 1    
+        
+    return caracteristiques
 # Fonctions d'interface graphique
  
 def dessiner_facade(informations:dict):
     facade = {}  # pour faire la "traduction" entre les clés de ce module et les clés du module formes
     facade['écriture'] = 'blue'
     facade['fond'] = informations['couleur_facade']
-    facade['épaisseur'] = 5 * informations['numero']
+    facade['épaisseur'] = 1
-    triangle_equilateral(50, facade, (0,0))
+    x0 = informations['coordonnees']
+    hauteur = informations['etage'] * 80
+    rectangle(140, hauteur, facade, (x0, -200))
  
 def dessiner_porte(informations:dict):
-    pass
+    porte = {}
+    porte['écriture'] = 'brown'
+    porte['fond'] = 'brown'
+    porte['épaisseur'] = 1
+    x0 = informations['coordonnees']
+    position = informations['porte']
+    rectangle(30, 50, porte, (x0 + (position * 40) -25, -200))
+    
+def dessiner_fenetres(informations:dict):
+    fenetre = {} 
+    fenetre['écriture'] = 'black' 
+    fenetre['fond'] = 'cyan' 
+    fenetre['épaisseur'] = 1
+    x0 = informations['coordonnees'] 
+    position = informations['fenetre'] 
+    for etage in range(0,informations['etage']): 
+        rectangle(30, 30, fenetre, (x0 + (position * 40) -25, -180 + etage*80))
+        rectangle(30, 30, fenetre, (x0 + (position * 80) -25, -180 + etage*80))
+        rectangle(30, 30, fenetre, (x0 + (position * 120) -25, -180 + etage*80))
+        
+def dessiner_toit(informations:dict):
+    toit = {}
+    toit['écriture'] = 'black'
+    toit['fond'] = 'black'
+    toit['épaisseur'] = 1
+    x0 = informations['coordonnees']
+    hauteur = informations['etage'] * 80
+    variant = random.randint(1,2)
+    if informations['toit_variant'] == 1:
+        triangle_isocele(50, 140, toit,(x0,hauteur - 200))
+    else:
+        rectangle(180, 10, toit,(x0-20, hauteur - 200))
+        
+        
+        
+        
+def choisir_couleur(lesCouleurs:list)->int:
+    '''Choisi une couleur aléatoirement'''
+    i = random.randint(0,len(lesCouleurs)-1) #choisi unn couleur aléatoire dans le tableau lesCouleurs
+    return lesCouleurs[i]
+        
+    
+    
+    
+
+    
     
 def dessiner_immeuble(informations:dict):
     dessiner_facade(informations)
+    dessiner_toit(informations)
+    dessiner_fenetres(informations)
     dessiner_porte(informations)
     # à compléter avec d'autres fonctions pour le reste : toit, fenêtres...
     
+def dessiner_rue_enfant(ensemble:list):
+    for i in range(len(ensemble)):
+        infos_immeuble = determiner_immeuble_enfant(i, ensemble[i])
+        dessiner_immeuble(infos_immeuble)    
+ 
 # Programme principal
  
 if __name__ == '__main__':
@@ -34,3 +109,7 @@ if __name__ == '__main__':
     for x in range(4):
         infos_immeuble = determiner_immeuble(x)
         dessiner_immeuble(infos_immeuble)
+
+
+    # à compléter avec d'autres fonctions pour le reste : toit, fenêtres...
+