# ###########################################################################
# Projet : Mastermind
# Programmeurs : Lucas, Léandro et Morgane
# Mai 2026
# nsi.gecif.net
# ###########################################################################

from turtle import *
import  random
import time

# -------------------------
# Fenêtre
# -------------------------
"""
fonction menu ,
choisir entre pvp et ia
"""
hideturtle()
def lancer_menu():
    bgcolor("black")
    title("Mastermind")
    onscreenclick(clic)
    speed(0)
    tracer(0)
    hideturtle()


    # -------------------------
    # Titre
    # -------------------------
    penup()
    goto(0, 150)

    color("white")

    write(
    "MASTERMIND",
    align="center",
    font=("Arial", 36, "bold")
    )

    # -------------------------
    # Bouton PLAY
    # -------------------------
    global bx,by,largeur,hauteur,cx,cy
    bx = -75
    by = 20
    cx = -75
    cy = -50

    largeur = 150
    hauteur = 50

    goto(bx, by)

    pendown()

    for _ in range(2):

       forward(largeur)
       right(90)

       forward(hauteur)
       right(90)

    penup()

    # texte bouton
    goto(0, -20)

    write(
        "? VS ?",
        align="center",
        font=("Arial", 20, "bold")
    )
    #----------------------------
    # Bouton robot
    #----------------------------

    goto(-75,-50)

    pendown()

    for _ in range(2):

        forward(largeur)
        right(90)

        forward(hauteur)
        right(90)

    penup()

    # texte bouton

    goto(0,-90)

    write(
        "? VS IA",
        align="center",
        font=("Arial", 20, "bold")
        )

# -------------------------
# Fonction lancer jeu
# -------------------------
"""
fonction lancement du jeu
"""
def lancer_jeu():
    clear()
    penup()
    goto(0, 0)
    color("white")
    write(
        "Le jeu démarre...",
        align="center",
        font=("Arial", 24, "bold")
    )
    time.sleep(1)
    clear()
    bgcolor("#C0C0C0")
    speed(0)
    tracer(0)
    onscreenclick(clic2)
    up()
    color("white","white")
    palette_de_couleur()
    if mode_jeu == "ia":
        generer_combinaison_ia()
    else:
        combinaison_secrete()
    dessiner_bouton_effacer()
    dessiner_bouton_afficher_masquer()
    dessiner_bouton_rejouer()
    dessiner_bouton_Menu()
    dessiner_bouton_sauvegarder()
    global case_actuelle
    global ligne_actuelle
    ligne_actuelle=0
    case_actuelle=0
    global grille
    grille = Grille()



# -------------------------
# Gestion clic
# -------------------------
cx = -75
cy = -50
bx = -75
by = 20
largeur = 150
hauteur = 50

"""
Fonction qui gère les clic
dans le menu.
pvp ou ia
"""

def clic(x, y):
    global mode_jeu

    if bx < x < bx + largeur and by - hauteur < y < by:
        mode_jeu = "pvp"
        dessiner_choix_difficulte()

    if cx < x < cx + largeur and cy - hauteur < y < cy:
        mode_jeu = "ia"
        dessiner_choix_difficulte()


"""
Fonction qui gère les clic
dans la page difficulté.
3 difficulté (facile,moyen,difficile)
"""
def clic_difficulté(x,y):
    global mode_jeu

    if -270 < x < -120:
        choisir_difficulte(1)
    elif -75 < x < 75:
        choisir_difficulte(2)
    elif 120 < x < 270:
        choisir_difficulte(3)

    lancer_jeu()


"""
Fonction qui gère les clic
dans la page jeu.
"""

def clic2(x,y):

    if -320 < x < 230 and 310 < y < 350 :
        clear()
        lancer_menu()

    if 200 < x < 320 and 210 < y < 250:
        effacer()

    if 200 < x < 320 and 260 < y < 300 :
        afficher_masquer()

    if 200 < x < 320 and 310 < y < 350 :
        rejouer()

    global couleur_selectionnee
    # Première ligne de la palette
    if 250 < x < 290 and -250 < y < -210 :
        if creation_du_code:
            ajouter_combinaison('red')
        else:
            placer_couleur('red')

    elif 200 < x < 240 and -250 < y < -210 :
        if creation_du_code:
            ajouter_combinaison('blue')
        else:
            placer_couleur('blue')

    elif 150 < x < 190 and -250 < y < -210 :
       if creation_du_code:
            ajouter_combinaison('pink')
       else:
            placer_couleur('pink')

    elif 100 < x < 140 and -250 < y < -210 :
        if creation_du_code:
            ajouter_combinaison('green')
        else:
            placer_couleur('green')

    # Deuxième ligne de la palette
    elif 250 < x < 290 and -310 < y < -270 :
        if creation_du_code:
            ajouter_combinaison('yellow')
        else:
            placer_couleur('yellow')

    elif 200 < x < 240 and -310 < y < -270 :
        if creation_du_code:
            ajouter_combinaison('cyan')
        else:
            placer_couleur('cyan')
    elif 150 < x < 190 and -310 < y < -270 :
        if creation_du_code:
            ajouter_combinaison('orange')
        else:
            placer_couleur('orange')

    elif 100 < x < 140 and -310 < y < -270 :
        if creation_du_code:
            ajouter_combinaison('purple')
        else:
            placer_couleur('purple')




ligne_actuelle = 0
case_actuelle = 0



"""
Foncion qui dessine les
boutons de difficulte
"""
def dessiner_choix_difficulte():
    onscreenclick(clic_difficulté)
    clear()
    bgcolor("black")
    title("Mastermind")
    penup()
    goto(0, 150)
    color("white")
    write(
    "MASTERMIND",
    align="center",
    font=("Arial", 36, "bold"))
    goto(0,75)
    write(
    "Choisissez la difficuté :",
    align="center",
    font=("Arial", 17, "bold"))
    pencolor("green")
    goto(-195, -43)
    write(
    "Facile",
    align="center",
    font=("Arial", 20, "bold"))
    goto(-270,0)
    pendown()
    for _ in range(2):
        forward(largeur)
        right(90)
        forward(hauteur)
        right(90)
    penup()
    pencolor("orange")
    goto(0, -43)
    write(
    "Moyen",
    align="center",
    font=("Arial", 20, "bold"))
    goto(-75,0)
    pendown()
    for _ in range(2):
        forward(largeur)
        right(90)
        forward(hauteur)
        right(90)
    penup()
    pencolor("red")
    goto(195, -43)
    write(
    "Difficile",
    align="center",
    font=("Arial", 20, "bold"))
    goto(120,0)
    pendown()
    for _ in range(2):
        forward(largeur)
        right(90)
        forward(hauteur)
        right(90)
    penup()

"""
Fonction qui clear la page
et relance les fonction pour rejouer
"""

def rejouer():
    # Remise à 0
    global ligne_actuelle
    global case_actuelle
    global grille
    global creation_du_code
    global combinaison

    ligne_actuelle = 0
    case_actuelle = 0
    combinaison = []
    if mode_jeu == "ia":
        creation_du_code = False
    else:
        creation_du_code = True
    clear()
    bgcolor("#C0C0C0")
    speed(0)
    tracer(0)
    up()
    color("white", "white")
    palette_de_couleur()
    if mode_jeu == "ia":
        generer_combinaison_ia()
    else:
        combinaison_secrete()
    dessiner_bouton_effacer()
    dessiner_bouton_afficher_masquer()
    dessiner_bouton_rejouer()
    dessiner_bouton_Menu()
    dessiner_bouton_sauvegarder()
    grille = Grille()
    update()


combinaison_visible = True
"""
Fonction qui permet d'afficer
et masquer la combinaison
"""
def afficher_masquer():
    global combinaison_visible

    combinaison_visible = not combinaison_visible

    x_depart = 100

    for i in range(longueur_combinaison):

        x = x_depart + i * 50

        up()
        goto(x, -90)
        setheading(0)

        if combinaison_visible:
            fillcolor(combinaison[i])
        else:
            fillcolor("white")

        begin_fill()
        down()

        for _ in range(4):
            forward(40)
            right(90)

        end_fill()
        up()

    dessiner_bouton_afficher_masquer()
    update()



"""
fonction qui efface seulement la grille
"""

def effacer():
    global grille
    global ligne_actuelle
    global case_actuelle

    # Remet le curseur au début
    ligne_actuelle = 0
    case_actuelle = 0

    # Redessine une nouvelle grille vide
    grille = Grille()

    update()

"""
classe qui gere les case pour la grille,
la combinaison et la palette de couleur
"""

class Case:
    def __init__(self, x, y, taille=40):
        self.x = x
        self.y = y
        self.taille = taille
        self.couleur = 'white'
        self.dessiner()

    def dessiner(self):
        goto(self.x, self.y)
        fillcolor(self.couleur)
        begin_fill()
        pencolor("black")
        down()
        for _ in range(4):
            forward(self.taille)
            right(90)
        up()
        end_fill()

    def contient(self,x,y):
        return (
            self.x < x < self.x + self.taille
            and
            self.y - self.taille < y < self.y
        )


"""
classe qui gere les lignes pour la grille,
la combinaison et la palette de couleur
"""

class Ligne:
    def __init__(self, y):
        self.y=y
        self.cases = []
        self.resultats = []

        # Cases principales
        for i in range(longueur_combinaison):
            case = Case(-350 + i * 50, y)
            self.cases.append(case)

        # Petits points résultats
        for i in range(longueur_combinaison):
            pencolor("white")
            down()
            hideturtle()
            penup()
            goto(-80 + i * 15, y - 10)
            dot(15)
            up()

"""
classe qui gere la grille
"""

class Grille:
    def __init__(self):
        self.lignes = []

        for i in range(nb_lignes):
            ligne = Ligne(200 - i * 50)
            self.lignes.append(ligne)



toutes_les_couleurs = [
    'red','blue','pink','green',
    'yellow','cyan','orange','purple'
]

longueur_combinaison = 4
nb_couleurs_max = 6
nb_lignes = 10

couleur_selectionnee=None






combinaison = []
creation_du_code = True

def ajouter_combinaison(couleur):
    global combinaison
    global creation_du_code

    if len(combinaison) >= longueur_combinaison:
        return
    combinaison.append(couleur)

    # position du carre a colorier
    x_depart = 100
    x = x_depart + (len(combinaison)-1) * 50
    setheading(0)
    up()
    goto(x,-90)
    fillcolor(couleur)
    begin_fill()
    down()
    for _ in range(4):
        forward(40)
        right(90)
    end_fill()
    up()
    update()
    # quand 4 couleur choisies
    if len(combinaison) == longueur_combinaison:
        creation_du_code = False




def placer_couleur(couleur):
    global ligne_actuelle
    global case_actuelle
    # securité pour fin de la grille
    if ligne_actuelle >= nb_lignes:
        return
    # Récupere la ligne actuelle
    ligne = grille.lignes[ligne_actuelle]
    # Récupere la case actuelle
    case = ligne.cases[case_actuelle]
    # applique la couleur
    case.couleur = couleur
    # Redessine
    case.dessiner()
    update()
    # passe a la case suivante
    case_actuelle += 1
    # si fin de ligne

    # si fin de ligne
    if case_actuelle == longueur_combinaison:
    # Vérifie la combinaison du joueur
        proposition = []
        for c in ligne.cases:
            proposition.append(c.couleur)
    # Vérification
        verifier_combinaison(proposition, ligne)
    # Si gagné
        if proposition == combinaison:
            afficher_victoire()
        else:
        # Ligne suivante
            ligne_actuelle += 1
            case_actuelle = 0
        # Défaite
            if ligne_actuelle >= nb_lignes:
                afficher_defaite()

    """if case_actuelle == longueur_combinaison:
        # Vérifie la combinaison du joueur
        proposition = []
        for c in ligne.cases:
            proposition.append(c.couleur)
        #Vérification
        verifier_combinaison(proposition,ligne)
        # Si gagné
        if proposition == combinaison:
            afficher_victoire()
        else:
            if ligne_actuelle>= nb_lignes:
                afficher_defaite
        case_actuelle = 0
        ligne_actuelle += 1"""


def palette_de_couleur():
    up()
    pencolor('black')
    x_depart = 250
    y_depart = -210
    c = 0
    for ligne in range(2):
        goto(x_depart, y_depart - ligne * 60)
        for col in range(4):
            if c >= nb_couleurs_max:
                return
            down()
            fillcolor(toutes_les_couleurs[c])
            begin_fill()
            for _ in range(4):
                forward(40)
                right(90)
            end_fill()
            up()
            back(50)
            c += 1



def dessiner_bouton_rejouer():
    up()
    pencolor('black')
    goto(200, 350)
    down()
    fillcolor("white")
    begin_fill()
    for _ in range(2):
        forward(120)
        right(90)
        forward(40)
        right(90)
    end_fill()

    up()
    goto(225, 320)
    down()
    pencolor("black")
    write("Rejouer", font=("Arial", 15 , "bold"))
    up()


def dessiner_bouton_afficher_masquer():
    up()
    pencolor('black')
    goto(200, 300)
    down()
    # Bleu si caché
    if combinaison_visible:
        fillcolor("white")
    else:
        fillcolor("deepskyblue")
    begin_fill()
    for _ in range(2):
        forward(120)
        right(90)
        forward(40)
        right(90)
    end_fill()
    up()
    goto(210, 272)
    down()
    pencolor("black")
    write("Afficher/Masquer", font=("Arial", 10, "bold"))
    up()

def dessiner_bouton_effacer():
    up()
    pencolor('black')
    goto(200, 250)
    down()
    fillcolor("salmon")
    begin_fill()
    for _ in range(2):
        forward(120)
        right(90)
        forward(40)
        right(90)
    end_fill()

    up()
    goto(225, 217)
    down()
    pencolor("black")
    write("Effacer", font=("Arial", 15, "bold"))
    up()

def generer_combinaison_ia():

    global combinaison
    global creation_du_code
    global combinaison_visible

    couleurs_disponibles=toutes_les_couleurs[:nb_couleurs_max]

    combinaison = []

    # Génération de la combinaison secrète
    for i in range(longueur_combinaison):

        couleur = random.choice(couleurs_disponibles)
        combinaison.append(couleur)

    # Au début la combinaison est cachée
    combinaison_visible = False

    # Dessine des cases blanches
    x_depart = 100

    for i in range(longueur_combinaison):

        x = x_depart + i * 50

        penup()
        goto(x, -90)
        setheading(0)

        fillcolor("white")
        pencolor("black")

        pendown()
        begin_fill()

        for _ in range(4):
            forward(40)
            right(90)

        end_fill()
        penup()

    creation_du_code = False
    update()

def combinaison_secrete():
    up()
    pencolor('black')
    x_depart = 100
    for i in range(longueur_combinaison):
        goto(x_depart + i * 50, -90)
        setheading(0)
        down()
        fillcolor("white")
        begin_fill()
        for _ in range(4):
            forward(40)
            right(90)
        end_fill()
        up()

def dessiner_bouton_Menu():
    up()
    pencolor('white')
    goto(-320, 350)
    down()
    fillcolor("black")
    begin_fill()
    for _ in range(2):
        forward(120)
        right(90)
        forward(40)
        right(90)
    end_fill()

    up()
    goto(-300, 317)
    down()
    pencolor("white")
    write("<-- Menu", font=("Arial", 15, "bold"))
    up()

def dessiner_bouton_sauvegarder():
    up()
    pencolor('black')
    goto(-320, 300)
    down()
    fillcolor("white")
    begin_fill()
    for _ in range(2):
        forward(120)
        right(90)
        forward(40)
        right(90)
    end_fill()

    up()
    goto(-307, 270)
    down()
    pencolor("black")
    write("Sauvegarder", font=("Arial", 12, "bold"))
    up()

def afficher_defaite():

    penup()
    goto(0, 260)

    color("red")

    write(
        "? Vous avez perdu ! ?",
        align="center",
        font=("Arial", 18, "bold")
    )

    goto(0, 230)

    write(
        "Combinaison : " + " - ".join(combinaison),
        align="center",
        font=("Arial", 12, "bold")
    )

    update()

def afficher_victoire():
   # haut milieu de la page
    penup()
    goto(0, 260)

    color("green")

    write(
        " Vous avez gagner ! ",
        align="center",
        font=("Arial", 18, "bold")
    )

    goto(0, 230)

    write(
        "Combinaison : " + " - ".join(combinaison),
        align="center",
        font=("Arial", 12, "bold")
    )

    update()


def choisir_difficulte(niveau):
    global longueur_combinaison
    global nb_couleurs_max
    global nb_lignes

    if niveau == 1:  # Facile
        longueur_combinaison = 4
        nb_couleurs_max = 6
        nb_lignes = 7

    elif niveau == 2:  # Moyen
        longueur_combinaison = 4
        nb_couleurs_max = 8
        nb_lignes = 9

    elif niveau == 3:  # Difficile
        longueur_combinaison = 5
        nb_couleurs_max = 8
        nb_lignes = 8

def verifier_combinaison(proposition, ligne):
    longueur_combinaison=len(combinaison)
    # Copies
    secret = combinaison[:]
    prop = proposition[:]

    resultats = [""] * longueur_combinaison

    # -------------------------
    # Bien placés
    # -------------------------
    for i in range(longueur_combinaison):

        if prop[i] == secret[i]:

            resultats[i] = "green"

            # On retire les éléments déjà utilisés
            secret[i] = None
            prop[i] = None

    # -------------------------
    #
    # -------------------------
    for i in range(longueur_combinaison):

        # Ignore déjà validés
        if prop[i] is not None:

            if prop[i] in secret:

                resultats[i] = "orange"

                # Supprime UNE seule occurrence
                index = secret.index(prop[i])
                secret[index] = None

            else:
                resultats[i] = "red"

    # -------------------------
    #  Dessin des bulles
    # -------------------------
    for i in range(longueur_combinaison):

        up()
        goto(-80 + i * 15, ligne.y - 10)

        color(resultats[i])
        dot(15)

    update()

"""
# ne marche pas (encore)
def sauvegarder(): #pas fini,a completer
    nom_fichier = "mastermindsauvegardee.csv"


    with open(nom_fichier, 'w', newline='', encoding='utf-8') as fichier:
        writer = csv.writer(fichier)

        # donnes
        writer.writerow(['mode_jeu', mode_jeu])
        writer.writerow(['longueur_combinaison', longueur_combinaison])
        writer.writerow(['nb_couleurs_max', nb_couleurs_max])
        writer.writerow(['nb_lignes', nb_lignes])
        writer.writerow(['ligne_actuelle', ligne_actuelle])
        writer.writerow(['case_actuelle', case_actuelle])
        writer.writerow(['combinaison'] + combinaison)
        writer.writerow(['combinaison_visible', combinaison_visible])
"""

# ------------------------------------------------------------------------------
# Programme principal
# ------------------------------------------------------------------------------
lancer_menu()
# clic gauche

done()