StreetProject/rue.py

"""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()