You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
220 lines
7.0 KiB
220 lines
7.0 KiB
"""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() |
|
|
|
|
|
|
|
|
|
|
|
|
|
|