def load_fichier_lettres(nom_fichier_lettres):
    """Cette fonction ouvre et lit un fichier texte dont le nom est fourni en argument.
    Ce fichier contient 26 lignes (une pour
    chaque lettre de l'alphabet). Chaque ligne
    est composée d'une lettre, d'un nombre
    d'occurences de cette lettre dans le jeu
    et des points que la lettre rapporte au
    joueur s'il la place, chacun séparé par
    un espace. (cf fin de la page 2 de l'énoncé
    pour voir un extrait du fichier
    (lettres.txt)).
    Elle renvoie ensuite deux dictionnaires dont
    les clés sont les lettres contenues dans le
    fichier texte et les valeurs sont respectivement
    le nombre d'occurences et les points que la lettre
    rapporte.
    Arguments :
        - nom_fichier_lettres (str) : Un chaine de caractère
        qui représente le nom du fichier texte à ouvrir
    Valeurs de retour (dans cet ordre):
        - dict : un dictionnaire avec comme clés les lettres contenues dans le fichier et
        comme valeur le nombre d'occurences de
        cette lettre
        - dict : un dictionnaire avec comme clés
        les lettres contenues dans le fichier et
        comme valeur les points associés à chaque lettre
    """
    f = open(nom_fichier_lettres, "r")
    fichier = f.readlines()
    f.close()
    dict_occ = {}
    dict_pts = {}
    for i in range(len(fichier)):
        fichier[i] = fichier[i].split()
        dict_occ[fichier[i][0]] = int(fichier[i][1])
        dict_pts[fichier[i][0]] = int(fichier[i][2])
    return dict_occ, dict_pts


def load_fichier_dico(nom_fichier_dico):
    """ Renvoie une liste de 15 sets dont chaque set contient tous les mots de longueur (l+1)
    Arguments :
        - nom_fichier_dico (str) : Un chaine de caractère
        qui représente le nom du fichier texte à ouvrir
    Valeurs de retour (dans cet ordre):
        - list : une liste de 15 ensembles d'indice i tel que l'ensemble i contient tous les mots de longueur i+1
    """
    f = open(nom_fichier_dico, "r")
    fichier = f.readlines()
    f.close()
    mots_scrabble = list()
    for i in range(15):
        mots_scrabble.append(set())
    for i in range(len(fichier)):
        fichier[i] = fichier[i].strip()
        if len(fichier[i]) <= len(mots_scrabble):
            mots_scrabble[len(fichier[i]) - 1].add(str(fichier[i]))
    return mots_scrabble


def pioche_init(occurences_lettres):
    """ Cette fonction renvoie une chaine de
    caractères (str) contenant toutes les
    lettres disponibles lors de
    l'initialisation du jeu, classées dans l'ordre alphabétique.
          Arguments:
          - occurences_lettres (dict) : dictionnaire ayant comme clés
          toutes les lettres de l'alphabet
          et comme valeur, le nombre de fois (int)
          que chaque lettre devra être ajoutée
          à la pioche
          Valeur de retour:
          - str : une chaine de caractère contenant toutes les lettres de la pioche classées dans l'ordre
          alphabétique.
    """
    pioche = []
    lettres = list(occurences_lettres.keys())
    occurences = list(occurences_lettres.values())
    for i in range(len(occurences_lettres)):
        for j in range(occurences[i]):
            pioche.append(lettres[i])
    pioche.sort()
    return pioche


def remplir_chevalet(chevalet, sachet):
    """Cette fonction tire des lettres du sachet jusqu'a ce que le chevalet soit rempli ou jusqu'a ce qu'il n'y ait plus de lettres."""
    while len(chevalet) < 7 and len(sachet) > 0:
        chevalet.append(sachet[-1])
        del sachet[-1]
    return chevalet


def plateau_init(dimensions):
    """Cette fonction va créer le plateau
    de jeu. Le plateau de jeu consiste
    en une liste de nb_lignes sous-listes,
    chacune de longueur nb_colonnes, où
    chaque élément représente une case
    du plateau grâce à la valeur "_"
    (underscore).
    Si nb_lignes = nb_colonnes = 3, on aura
    par exemple:
    plateau = [["_", "_", "_"], ["_", "_", "_"],["_", "_", "_"]]
        Arguments:
              - dimensions (tuple) : un tuple de deux nombres
              entiers et positifs. Le premier élément est le
              nombre de lignes (nb_lignes (int)) et le deuxième
              élément est le nombre de colonnes (nb_colonnes (int))
        Valeur de retour:
              - liste: la liste de sous-listes qui représente le plateau"""
    return [['_'] * dimensions[1] for i in range(dimensions[0])]


def propose_mot(msg_position_ligne, msg_position_colonne, msg_direction, msg_mot):
    """Cette fonction demande au joueur où et quel mot
    il désire placer.
    La séquence d'inputs et de vérification
    est la suivante:
    1. Demander le numéro de la ligne de la
    première lettre du mot à placer. Utilisez comme
    argument de la fonction input() : msg_position_ligne
    1.1 Tant que le joueur n'entre pas un numéro de ligne valide
    (un caractère convertible en un nombre entier compris entre 0
    et NB_lIGNE-1), retourner en 1.
    2. Demander le numéro de la colonne de la
    première lettre du mot à placer. Utilisez comme
    argument de la fonction input() : msg_position_colonne
    2.1 Tant que le joueur n'entre pas un numéro de colonne valide(un caractère
    convertible en un nombre entier compris entre 0 et NB_COLONNE-1),
    retourner en 2.
    3. Demander la direction du mot à placer ("h" ou "v"). Utilisez comme
    argument de la fonction input() : msg_direction
    3.1 Tant que le joueur n'entre pas une direction valide(le caractère "h" ou "v"),
    retourner en 3.
    4. Demander le mot à placer. Utilisez comme
    argument de la fonction input() : msg_mot
    4.1 Tant que le joueur n'entre pas un mot valide(uniquement des lettres en majuscule
    ou minuscule), retourner en 4.
    Attention, si le mot à placer s'appuie sur une ou
    plusieurs lettres présentes sur le plateau, il faut
    préciser tout le mot qui sera formé et pas seulement
    les lettres à placer. Par exemple, partons de la situation
    initial suivante:
    plateau = [["_", "_", "_"], ["_", "_", "S"],["_", "_", "_"]]
    lettres = ['A','N','Z','Y','W','U','V']
    Si on veut placer le mot "ANS" avec les lettres "A", "N",
    à la position (1,0), avec comme direction "h"
    il faut proposer le mot "ANS" et non pas "AN" à placer.
    De même, imaginons que nous partons de la deuxième situation
    initiale suivante :
    plateau = [["_", "_", "_","_"], ["D", "_", "_", "_"],["E","_", "_", "_"]]
    lettres = ['A','N','S','Y','W','U','V']
    Si on veut placer le mot "ANS" avec les lettres "A", "N","S",
    à la position (1,1), avec comme direction "h". Le mot final sera "DANS".
    Il faut alors proposer "DANS" comme mot, et non pas "ANS".
    Arguments :
    - msg_position_ligne (str) : une chaine de caractère à afficher à l'écran
    du joueur lors de l'input pour lui demander quelle est le numéro
    de ligne de la première lettre de son   mot.
    - msg_position_colonne (str) : une chaine de caractère à afficher à l'écran
    du joueur lors de l'input pour lui demander quelle est le numéro
    de colonne de la première lettre de son mot.
    - msg_direction (str) : une chaine de caractère à afficher à l'écran
    du joueur lors de l'input pour lui demander quelle est la
    direction pour son mot ("h" = horizontale ou "v" = verticale)
    - msg_mot (str) :  une chaine de caractère à afficher à l'écran
    du joueur lors de l'input pour lui demander quel mot le joueur
    désire placer
    Valeurs de retour (dans cet ordre):
    - (str): une chaine de caractère en MAJUSCULE qui indique le mot à placer
    - tuple: un tuple d'entiers (l,c) qui indiquent le numéro de ligne (l),
    et le numéro de la colonne (c) de la première lettre du mot à placer
    - (str): un charactère ("h" ou "v") qui indique la direction du mot
    """
    l, c, d, m = '', '', '', ''
    while l.isdigit() == False or int(l) < 0 or 14 < int(l):
        l = input(msg_position_ligne)
    while c.isdigit() == False or int(c) < 0 or 14 < int(c):
        c = input(msg_position_colonne)
    while d != 'H' and d != 'h' and d != 'V' and d != 'v':
        d = input(msg_direction)
    while not m.isalpha():
        m = input(msg_mot)
    return m.upper(), (int(l), int(c)), d.lower()


def verif_premier_tour(coup):
    """Cette fonction retourne True si le mot à placer passe bien par la case (7,7).
    On considère que le mot à placer ne dépasse pas des bornes du plateau
    et ne fait pas plus de 7 lettres. On considère également que cette fonction ne
    sera appelée qu'au premier tour. Le plateau est donc totalement vide.

    Arguments :
    - coup (tuple): un tuple à 3 éléments:
            - mot (str): une chaine de caractère en majuscule qui indique le mot à placer
            - pos (tuple) : un tuple d'entiers (l,c) qui indiquent le numéro de ligne (l),
            et le numéro de la colonne (c) de la première lettre du mot à placer
            - dir (str) : un charactère (h ou v) qui indique la direction du mot
    Valeurs de retour :
    - bool : True ou False
    """
    mot = coup[0]
    l, c = coup[1]
    pos = [l, c]
    res = False
    if coup[2] == 'h' and pos[0] == 7:
        for i in range(len(mot)):
            if pos[1] == 7:
                res = True
            else:
                pos[1] += 1
    elif coup[2] == 'v' and pos[1] == 7:
        for i in range(len(mot)):
            if pos[0] == 7:
                res = True
            else:
                pos[0] += 1
    return res

def verif_bornes(coup, dimensions):
    """Cette fonction renvoie True si le mot à placer ne dépasse pas les des bornes du plateau de jeu. False, sinon.
    Arguments :
    - coup (tuple): un tuple à 3 éléments:
            - mot (str): une chaine de caractère en majuscule qui indique le mot à placer
            - pos (tuple) : un tuple d'entiers (l,c) qui indiquent le numéro de ligne (l),
            et le numéro de la colonne (c) de la première lettre du mot à placer
            - dir (str) : un charactère (h ou       v) qui indique la direction du mot
    - dimensions (tuple) : un tuple de deux nombres entiers et positifs. Le premier élément est le nombre de lignes (
    Valeurs de retour:
    - bool (True ou False)
    """
    mot = coup[0]
    l, c = coup[1]
    res = True
    if coup[2] == 'h' and c + len(mot) > dimensions[1]:
        res = False
    elif coup[2] == 'v' and l + len(mot) > dimensions[0]:
        res = False
    return res

def verif_mot(mot, dictionnaire):
    """Cette fonction renvoie True si le mot à placer est bien un mot du dictionnaire. False sinon.
    Arguments :
        - mot (str): une chaine de caractères en majuscule qui indique le mot à placer
        - dico (list) : une liste dont chaque élément d'indice i, est un set de mots du dictionnaire de
        longueur (i+1). Par exemple, dico[3] pointe vers un set de tous les mots à 4 lettres.
    Valeurs de retour :
        - bool (True ou False)"""
    return len(mot)-1 < len(dictionnaire) and mot in dictionnaire[len(mot) - 1]

def verif_emplacement(coup, plateau):
    """Cette fonction renvoie True si le mot à placer n'entre pas en conflit avec d'autres lettres déjà placées auparavant sur le plateau, qui ne correspondent pas aux lettres du mot.
    Sinon, la fonction renvoie False.
    On pré-suppose que le mot ne dépasse pas des bornes du plateau.
    Arguments :
    - coup (tuple): un tuple à 3 éléments:
            - mot (str): une chaine de caractère en majuscule qui indique le mot à placer
            - pos (tuple) : un tuple d'entiers (l,c) qui indiquent le numéro de ligne (l),
            et le numéro de la colonne (c) de la première lettre du mot à placer
            - dir (str) : un charactère (h ou       v) qui indique la direction du mot
    - plateau (liste): une liste de sous-listes qui représentent
    chacune une ligne du plateau de jeu.
    Elles contiennent chacune, soit un underscore pour
    indiquer que la case est vide, soit une lettre
    si elle a déjà été placée là auparavant.
    Valeurs de retour:
    - bool (True ou False)"""
    dimensions = (len(plateau), len(plateau[0]))
    mot = coup[0]
    l, c = coup[1]
    place = 0
    for i in range(len(mot)):
        if coup[2] == 'h' and verif_bornes(coup, dimensions):
            if plateau[l][c + i] == '_' or plateau[l][c + i] == mot[i]:
                place += 1
        elif coup[2] == 'v' and verif_bornes(coup, dimensions):
            if plateau[l + i][c] == '_' or plateau[l + i][c] == mot[i]:
                place += 1
    return place == len(mot)

def verif_lettres_joueur(plateau, lettres_joueur, coup):
    """
    Cette fonction renvoie True:
    - Si le mot à placer appartient au lettres du joueur (lettres_joueurs) ou
    - Si une ou plusieurs lettres manquent mais sont déjà placées à la place
    adéquate sur le plateau (plateau).
    Sinon, la fonction renvoie False.
    On pré-suppose que le mot ne dépasse pas des bornes du plateau
    Arguments :
    - plateau (liste) : une liste de sous-listes qui représentent
    chacune une ligne du plateau de jeu.
    Elles contiennent chacune, soit un underscore pour
    indiquer que la case est vide, soit une lettre
    si elle a déjà été placée là auparavant.
    - lettres_joueur (liste) : une liste qui contient chacune
    des lettres que le joueur possède sur son chevalet.
    Toutes ces lettres sont en MAJUSCULE.
    - coup (tuple): un tuple à 3 éléments:
            - mot (str): une chaine de caractère en majuscule qui indique le mot à placer
            - pos (tuple) : un tuple d'entiers (l,c) qui indiquent le numéro de ligne (l),
            et le numéro de la colonne (c) de la première lettre du mot à placer
            - dir (str) : un charactère (h ou v) qui indique la direction du mot
    Valeurs de retour:
    - bool (True ou False)
    """
    mot = coup[0]
    l, c = coup[1]
    string = str()
    lettres_a_placer= 0
    for i in range(len(mot)):
        if coup[2] == 'h':
            if mot[i] == plateau[l][c+i] or mot[i] in lettres_joueur:
                string += mot[i]
                if plateau[l][c+i] == '_':
                    lettres_a_placer += 1
        elif coup[2] == 'v':
            if mot[i] == plateau[l+i][c] or mot[i] in lettres_joueur:
                string += mot[i]
                if plateau[l+i][c] == '_':
                    lettres_a_placer += 1
    return string == mot and lettres_a_placer != 0

def mot_accepte(plateau, lettres_joueur, coup, dictionnaire, tour):
    """Cette fonction renvoie True si chacune des fonctions suivantes renvoient True:
    verif_premier_tour (uniquement au premier tour)
    verif_lettres_joueur
    verif_mot
    verif_bornes
    verif_emplacement
    Sinon, la fonction renvoie False. Vous devez donc également définir les 5 fonctions ci- dessus pour pouvoir les a
    Arguments :
    - lettres_joueur (liste) : une liste contenant les lettres du joueur
    - plateau (liste): une liste de sous-listes qui représentent
    chacune une ligne du plateau de jeu.
    Elles contiennent chacune, soit un underscore pour
    indiquer que la case est vide, soit une lettre
    si elle a déjà été placée là auparavant.
    - coup (tuple): un tuple à 3 éléments:
            - mot (str): une chaine de caractère en majuscule qui indique le mot à placer
            - pos (tuple) : un tuple d'entiers (l,c) qui indiquent le numéro de ligne (l),
            et le numéro de la colonne (c) de la première lettre du mot à placer
            - dir (str) : un charactère (h ou v) qui indique la direction du mot
    - tour (int) : un entier qui représente le tour du jeu (tour = 1 représente le premier tour)
    - dictionnaire (list) : une liste dont chaque élément d'indice i, est un set de mots du dictionnaire de
    longueur (i+1). Par exemple, dico[3] pointe vers un set de tous les mots à 4 lettres.
    Valeurs de retour:
            - bool (True ou False)
    """
    res = False
    mot = coup[0]
    tour_verifie = True
    if tour == 1:
        if verif_premier_tour(coup):
            if verif_emplacement(coup, plateau):
                if verif_lettres_joueur(plateau, lettres_joueur, coup):
                    if verif_mot(mot, dictionnaire):
                        res = True
    else:
        if verif_emplacement(coup, plateau):
            if verif_lettres_joueur(plateau, lettres_joueur, coup):
                if verif_mot(mot, dictionnaire):
                    if len(mots_perpendiculaires(coup, plateau, dico)) != 0 and (utilise_lettre_plateau(coup,plateau) or len(mots_perpendiculaires(coup, plateau, dico)) > 1):
                        res = True
    return res

def compte_points(mots, points_lettres):
    """Cette fonction calcule et renvoie le score associé à un mot
    Arguments :
    - mot (str) : une chaine de caractère en majuscule qui indique le mot à placer
    - points_lettres (dict) : un dictionnaire contenant
    comme clés les différentes lettres de l'alphabet,
    en majuscule; et comme valeur, les points
    associées à chaque lettre.
    Par exemple:
    points_lettres = {"A" : 1, "B": 3}, si on ne considère
    que les deux premières lettres de l'alphabet
    Valeur de retour:
    - int : points associés au mot placé.
    """
    score = 0
    for i in range(len(mots)):
        score += points_lettres[mots[i]]
    return score


def placer_mot(coup, plateau):
    """ Cette fonction modifie le plateau de
    sorte que les lettres du mot à placer soient insérées au bon endroit dans la liste de sous-listes qui représente le plateau;
    cette fonction renvoie ensuite les lettres du mot à placer qui sont déjà présentes sur le plateau
    à l'endroit exact où cette lettre devrait etre placée (et qu'il ne faut donc pas retirer du chevalet du joueur par la suite)
    Arguments:
            - coup (tuple): un tuple à 3 éléments:
                    - mot (str): une chaine de caractère en majuscule qui indique le mot à placer
                    - pos (tuple) : un tuple d'entiers (l,c) qui indiquent le numéro de ligne (l),
                    et le numéro de la colonne (c) de la première lettre du mot à placer
                                      - dir (str) : un charactère (h ou
    - plateau (liste) : une liste de sous-listes
    qui représentent chacune une ligne du plateau
    de jeu. Elles contiennent chacune, soit un
    underscore pour indiquer que la case est vide,
    soit une lettre si elle a déjà été placée là
    auparavant.
    v) qui indique la direction du mot
             Valeur de retour:
              - str : chaine de caractères contenant les lettres déjà présentes sur le plateau à
              l'emplacement du mot (qu'il ne faut donc pas retirer du chevalet du joueur)
      Exemple:
      >>> plateau = [["_", "_", "A","R"],
                      ["_", "_", "_","_"],
                      ["_", "_", "_","_"],
                      ["_", "_", "_","_"]]
      >>> mot = "BAR"
      >>> position = (0,1)
      >>> direction = "h"
      >>> coup = mot,position,direction
      >>> lettres_presentes = placer_mot(plateau,coup)
      >>> print(plateau)
      >>> [["_", "B", "A","R"],
      ["_", "_", "_","_"],
      ["_", "_", "_","_"],
      ["_", "_", "_","_"]]
      >>> print(lettres_presentes)
      >>> "AR"
    """
    deja_presentes = str()
    l, c = coup[1]
    if coup[2] == 'h':
        for i in range(len(coup[0])):
            if plateau[l][c + i] == coup[0][i]:
                deja_presentes += coup[0][i]
            else:
                plateau[l][c + i] = coup[0][i]
    elif coup[2] == 'v':
        for i in range(len(coup[0])):
            if plateau[l + i][c] == coup[0][i]:
                deja_presentes += coup[0][i]
            else:
                plateau[l + i][c] = coup[0][i]
    return deja_presentes


def mots_perpendiculaires(coup, plateau, dico):
    """
    Lorsqu'un mot est placé sur le plateau de jeu, il est possible qu'il soit adjacent à des lettres déjà
    présentes sur le plateau. De nouveaux mots perpendiculaires au mot à placer sont alors formés.
    3 cas sont possibles:
    - Si aucun mot perpendiculaire n'est formé, cette fonction
    renvoie une liste contenant un élément : le mot à placer.
    - S'il existe des mots perpendiculaires et qu'ils appartiennet
    TOUS au dictionnaire, cette fonction renvoie la liste contenant tous
    les nouveaux mots formés (le mot à placer et les nouveaux mots
    perpendiculaires), triés dans l'ordre alphabétique.
    - S'il existe des mots perpendiculaires et qu'au moins un d'entre
    eux n'existe pas dans le dictionnaire, la fonction renvoie une
    liste vide [].
    On considère que le mot à placer respecte bien les bornes du plateau et
    qu'il n'y a pas de conflit entre les lettres que le joueur veut placer
    sur le plateau et les lettres existantes, aux positions qui seront
    utilisées pour ces lettres. Autrement dit, pour chaque lettre à placer,
    soit la case est vide, soit la lettre à placer est déjà présente.
    Ceci n'est pas à tester dans la fonction, mais c'est un pré-requis à
    son utilisation.
    -Arguments:
    - coup (tuple): un tuple à 3 éléments:
          - mot (str): une chaine de caractère en majuscule qui indique le mot à placer
          - pos (tuple) : un tuple d'entiers (l,c) qui indiquent le numéro de ligne (l),
          et le numéro de la colonne (c) de la première lettre du mot à placer
          - dir (str) : un charactère ("h" ou "v") qui indique la direction du mot
    - plateau (liste) : une liste de 15 sous-listes
    qui représentent chacune une ligne du plateau
    de jeu. Elles contiennent chacune, soit un
    underscore pour indiquer que la case est vide,
    soit une lettre si elle a déjà été placée là
    auparavant.
    - dico (list) : une liste dont chaque élément d'indice i, est un set de mots du dictionnaire de
    longueur (i+1). Par exemple, dico[3] pointe vers un set de tous les mots à 4 lettres.
    - Valeurs de retour:
          - liste de chaine de caractères
    """
    l, c = coup[1]
    liste, liste_triee = list(), list()
    for i in range(len(coup[0])):
        x = 1
        mot_forme, contre_mot_forme = str(), str()
        if coup[2] == 'h':
            if plateau[l][c + i] == '_':
                while l + x <= 14 and plateau[l + x][c + i] != '_':
                    mot_forme += plateau[l + x][c + i]
                    x += 1
                x = 1
                while l - x >= 0 and plateau[l - x][c + i] != '_':
                    contre_mot_forme += plateau[l - x][c + i]
                    x += 1
                mot_forme = contre_mot_forme[::-1] + coup[0][i] + mot_forme
                if len(mot_forme) > 1:
                    liste.append(mot_forme)
        elif coup[2] == 'v':
            if plateau[l + i][c] == "_":
                while c + x <= 14 and plateau[l + i][c + x] != '_':
                    mot_forme += plateau[l + i][c + x]
                    x += 1
                x = 1
                while c - x >= 0 and plateau[l + i][c - x] != '_':
                    contre_mot_forme += plateau[l + i][c - x]
                    x += 1
                mot_forme = contre_mot_forme[::-1] + coup[0][i] + mot_forme
                if len(mot_forme) > 1:
                    liste.append(mot_forme)
    for i in liste:
        if i in dico[len(i) - 1]:
            liste_triee.append(i)
    if len(liste) == 0:
        res = [coup[0]]
    elif len(liste) == len(liste_triee):
        liste.append(coup[0])
        liste.sort()
        res = liste
    else:
        res = list()
    return res


def utilise_lettre_plateau(coup,plateau):
    """
    Cette fonction renvoie True si le mot à placer utilise une ou plusieurs lettres déjà présentes sur le plateau de jeu.
    Elle renvoie False sinon
      Arguments:
      - coup (tuple) : à 3 éléments :
              - mot (str) : une chaine de caractère en majuscule
              qui indique le mot à placer
              - direction (str) : un charactère (h ou v) qui
              indique la direction du mot
              - position (tuple) : un tuple d'entiers (l,c) qui
              indiquent le numéro de ligne (l),
              et le numéro de la colonne (c) de la première lettre
              du mot à placer
      - plateau (liste) : une liste de 15 sous-listes
      qui représentent chacune une ligne du plateau
      de jeu. Elles contiennent chacune, soit un
      underscore pour indiquer que la case est vide,
      soit une lettre si elle a déjà été placée là
      auparavant.
      - Valeurs de retour:
              - bool (True / False)
    """
    lettre_plateau_utilisees = 0
    l, c = coup[1]
    for i in range(len(coup[0])):
        if coup[2]=='h':
            if plateau[l][c+i]!='_':
                lettre_plateau_utilisees += 1
        if coup[2]=='v':
            if plateau[l+i][c]!='_':
                lettre_plateau_utilisees += 1
    return lettre_plateau_utilisees != 0


def play(partie_en_cours):
"""I. Intialisation des outils nécéssaires pour commencer une partie"""
    """1. Charger le dictionnaire, les lettres, leurs occurences, les points de chaque lettre, et le sachet"""
    dico = load_fichier_dico("dico.txt")
    occurences, points = load_fichier_lettres('lettres.txt')
    sachet = pioche_init(occurences)
    import random
    random.shuffle(sachet)

    """2. Initialiser le plateau de jeu"""
    plateau = plateau_init((15, 15))
    tour = 0

    """3. Nombre de joueurs, noms des joueurs et initialisation de leurs scores et chevalets"""
    nombre_de_joueurs = int(input("A combien veuillez vous jouer? "))
    noms = list()
    chevalets = list()
    scores = list()
    for i in range(nombre_de_joueurs):
        noms.append(input("Entrez le nom du joueur " + str(i + 1) + ':'+" "))
        chevalets.append(list())
        scores.append(0)


"""II. Code nécéssaire à chaque tour"""
    while partie_en_cours:
        """a. on affiche le plateau"""
        for i in range(len(plateau)):
            print(i,plateau[i])

        """b. on affiche le chevalet et le score du joueur qui doit jouer"""
        tour += 1
        joueur = (tour - 1) % nombre_de_joueurs  # joueur est un entier qui varie entre [0;nombre de joueurs] en fonction de la valeur de 'tour'
        remplir_chevalet(chevalets[joueur], sachet)
        print("C'est ton tour,", noms[joueur], " !")
        print("Ton score :", scores[joueur])
        print("Tes lettres :", chevalets[joueur])

        """c. on permet au joueur de placer son mot, tout en verifiant si son coup respecte les règles"""
        coup = propose_mot("Veuillez entrer la ligne de la première lettre de votre mot ","Veuillez entrer la colonne de la première lettre de votre mot ","Veuillez entrer la direction de votre mot (H ou V) ", "Veuillez entrer le mot à jouer ")
        while not mot_accepte(plateau, chevalets[joueur], coup, dico, tour):
            coup = propose_mot("Veuillez entrer la ligne de la première lettre de votre mot ","Veuillez entrer la colonne de la première lettre de votre mot ","Veuillez entrer la direction de votre mot (H ou V) ", "Veuillez entrer le mot à jouer ")

        """d. on vérifie si certains mots perpendiculaires sont formés"""
        mots_perp = mots_perpendiculaires(coup, plateau, dico)

        """e. on ajoute les points du coup du joueur à son score en tenant compte des mots perpendiculaires formés"""
        for i in range(len(mots_perp)):
            scores[joueur] += compte_points(mots_perp[i], points)

        """f. on place le mot"""
        print(noms[joueur]," : ",scores[joueur])
        deja_sur_plateau = placer_mot(coup, plateau)

        """g. on retire les lettres utilisées du chevalet"""
        for i in range(len(deja_sur_plateau)):
            chevalets[joueur].append(deja_sur_plateau[i])
        for i in range(len(coup[0])):
            if coup[0][i] in chevalets[joueur]:
                del chevalets[joueur][chevalets[joueur].index(coup[0][i])]

        """h. on rempli le chevalet"""
        remplir_chevalet(chevalets[joueur], sachet)

        """i. si le sachet est vide, la partie se termine"""
        if len(chevalets[joueur]) == 0:
            partie_en_cours = False
            print("FIN DE LA PARTIE, MERCI")
            for i in range(nombre_de_joueurs):
                print(noms[i],scores[i])