"""Ce fichier permet de dessiner une rue à l'aide des fonctions suivantes : + dessiner_rue_aleatoire() + dessiner_rue_decrite(rue:dict) """ # Importation from dessiner import triangle_equilateral from dessiner import rectangle from dessiner import rectangle_arrondi from random import choice # Constantes LARGEUR_IMMEUBLE = 140 # Fonction privées def immeuble_aleatoire(numero: int) -> dict: """Génère un immeuble avec des caractéristiques aléatoires. :: param numero(int) :: numéro de l'immeuble pour positionner sa façade :: return (dict) :: dictionnaire contenant les attributs de l'immeuble, comme couleur de façade, numéro, nombre d'étages, position de la porte, type et couleur du toit """ informations = {} informations['couleur_facade'] = couleur_aleatoire() informations['numero'] = numero informations['etages'] = etage_aleatoire() # Ajout de la hauteur des étages informations['porte'] = coordonnees_porte # Coordonées portes pour les fenêtres informations['toit_type'] = toit_aleatoire() informations['toit_couleur'] = 'Black' return informations def couleur_aleatoire() -> str: """Sélectionne une couleur aléatoire pour la façade. :: return (str) :: couleur aléatoire choisie pour la façade """ return choice(['red','light green','grey','sky blue','olive','seagreen','mediumaquamarine','peachpuff']) def toit_aleatoire() -> str: """Sélectionne un type de toit aléatoire pour l'immeuble. :: return (str) :: type de toit, 'pointu' ou 'arrondi' """ return choice(['pointu','arrondi']) def etage_aleatoire() -> str: """Choisit un nombre d'étages aléatoire pour l'immeuble. :: return (int) :: hauteur de l'immeuble en pixels, en multiple de 80 """ return choice([80,160,240,320]) def coordonnees_facade(immeuble:dict) -> tuple: """Calcule les coordonnées de la base de la façade de l'immeuble. :: param immeuble(dict) :: dictionnaire avec les informations de l'immeuble :: return (tuple) :: coordonnées de la façade de l'immeuble (x, y) """ x_gauche = -400+ 200 * immeuble['numero'] y_bas = -200 return (x_gauche, y_bas) def coordonnees_porte(immeuble:dict) -> tuple: """Calcule les coordonnées de la porte de l'immeuble. :: param immeuble(dict) :: dictionnaire avec les informations de l'immeuble :: return (tuple) :: coordonnées de la porte (x, y) en fonction de la position choisie """ x_gauche = -400+ 200 * immeuble['numero'] + choice([12.5,55,97.5]) y_bas = -200 return (x_gauche, y_bas) def coordonnees_fenetres(immeuble:dict) -> tuple: """Calcule les coordonnées de la base des fenêtres de l'immeuble. :: param immeuble(dict) :: dictionnaire avec les informations de l'immeuble :: return (tuple) :: coordonnées de la base des fenêtres (x, y) """ x_gauche = -400+ 200 * immeuble['numero'] y_bas = -200 return (x_gauche, y_bas) def dessiner_facade(immeuble: dict) -> None: """Dessine la façade de l'immeuble avec la couleur et les dimensions fournies. :: param immeuble(dict) :: dictionnaire avec les informations de l'immeuble :: return (None) :: fonction sans retour """ # Traduction des données de rue vers dessiner crayon = {} crayon['écriture'] = "black" crayon['fond'] = immeuble['couleur_facade'] crayon['épaisseur'] = 1 x, y = coordonnees_facade(immeuble) # désempaquatage du couple cote = LARGEUR_IMMEUBLE etages = immeuble['etages'] # Utiliser la hauteur des étages depuis le dictionnaire # Demande d'affichage rectangle(cote, etages, crayon, (x, y)) def dessiner_porte(immeuble:dict) -> None: """Dessine la porte de l'immeuble avec une couleur aléatoire. :: param immeuble(dict) :: dictionnaire avec les informations de l'immeuble :: return (None) :: fonction sans retour """ # Traduction des données de rue vers dessiner crayon = {} crayon['écriture'] = "black" crayon['fond'] = couleur_aleatoire() crayon['épaisseur'] = 1 x, y = coordonnees_porte(immeuble) # Demande d'affichage rectangle(30,50, crayon, (x,y)) def dessiner_toit(immeuble: dict) -> None: """Dessine le toit de l'immeuble selon son type ('pointu' ou 'arrondi'). :: param immeuble(dict) :: dictionnaire avec les informations de l'immeuble :: return (None) :: fonction sans retour """ crayon = { 'écriture': "black", 'fond': immeuble['toit_couleur'], 'épaisseur': 1 } x, y = coordonnees_facade(immeuble) cote = LARGEUR_IMMEUBLE hauteur = immeuble['etages'] y_toit = y + hauteur if immeuble['toit_type'] == 'pointu': triangle_equilateral(cote, crayon, (x, y_toit)) else: rectangle_arrondi(cote, 20, crayon, (x, y_toit)) def dessiner_fenetres(immeuble: dict) -> None: """Dessine les fenêtres de l'immeuble sur chaque étage. :: param immeuble(dict) :: dictionnaire avec les informations de l'immeuble :: return (None) :: fonction sans retour """ # Traduction des données de rue vers dessiner crayon = {} crayon['écriture'] = "black" crayon['fond'] = 'white' # Vous pouvez choisir une autre couleur si vous le souhaitez crayon['épaisseur'] = 1 x, y = coordonnees_fenetres(immeuble) cote = LARGEUR_IMMEUBLE hauteur = immeuble['etages'] # Utiliser la hauteur des étages depuis le dictionnaire etages = int(hauteur / 80) # Conversion en nombre d'étages (80 pixels par étage) # Calcul du décalage vertical pour chaque étage for i in range(etages): y_fenetre = y + (i * 80) + 20 # Chaque fenêtre est à 80 pixels de distance en hauteur, avec un décalage de 20 # Trois fenêtres par étage rectangle(30, 30, crayon, (x + 12.5, y_fenetre)) rectangle(30, 30, crayon, (x + 55, y_fenetre)) rectangle(30, 30, crayon, (x + 97.5, y_fenetre)) def dessiner_immeuble(immeuble: dict) -> None: """Dessine l'ensemble de l'immeuble (façade, fenêtres, porte, toit). :: param immeuble(dict) :: dictionnaire avec les informations de l'immeuble :: return (None) :: fonction sans retour """ dessiner_facade(immeuble) dessiner_fenetres(immeuble) dessiner_porte(immeuble) dessiner_toit(immeuble) # à compléter avec d'autres fonctions pour le reste : toit, fenêtres... # Fonction publiques def dessiner_rue_aleatoire() -> None: """Dessine une rue de quatre immeubles, chacun généré avec des caractéristiques aléatoires. :: return (None) :: fonction sans retour """ for n in range(4): informations_immeuble = immeuble_aleatoire(n) dessiner_immeuble(informations_immeuble) # Programme principal if __name__ == '__main__': dessiner_rue_aleatoire()