#=============================================================================#
#                           Projet de terminale NSI
#=============================================================================#
# Thème : Dames
# Version 1
# Date : 06/05/2025
# Tâche de chacun :
#
# Mzé :
# - création du plateau
# - création & placement des pions
# - INTERACTION AVEC LES JOUEURS
# - BASCULE J1 à J2
# - Sauvegarde de jeu
# Patrick :
# - Programme principal
# - INTERACTION AVEC LES JOUEURS
# - STRUCTURE DU PLATEAU
# - Manger les pions adverses
# - Dame
# - Dépacements des dames
# Nathanan :
# - création & placement des pions
# - IDENTIFICATION DES CASES
# - BASCULE J1 à J2
# - Interface module turtle
#
# Fonctions réalisées par cette version du programme :
# -


from turtle import *
from string import ascii_uppercase

#=============================================================================#
                        # PROGRAMME PRINCIPAL #
#=============================================================================#

speed(0)
hideturtle()
title("Jeu de Dames")
penup()
color(0, 0, 0)
goto(-132,326)
write("Jeu de Dames", font=("Arial Unicode Ms", 36, "normal"))
pendown()
setup(800,800)
x = -300
y = 300
up()
goto(x, y)
down()

#=============================================================================#
                        # CREATION DU PLATEAU #
#=============================================================================#

for b in range(10):
    for j in range(10):
        up()
        goto(x + j * 60, y - b * 60)
        down()

        if (b + j) % 2 == 0:
            begin_fill()
            color("gray")
        else:
            color("black")

        for i in range(4):
            forward(60)
            right(90)
        forward(60)

        if (b + j) % 2 == 0:
            end_fill()

    up()
    goto(x, y - (60 * b))
    down()

#=============================================================================#
                     # CREATION & PLACEMENT DES PIONS #
#=============================================================================#

def dessiner_pion(x, y, symbole, couleur):
    up()
    goto(x + 10, y - 60 + 5)
    down()
    color(couleur)
    write(symbole, font=("ArialUnicode MS", 36, "normal"))

for ligne in range(10):
    for colonne in range(10):
        if (ligne + colonne) % 2 == 0:
            x_case = x + colonne * 60
            y_case = y - ligne * 60

            if ligne < 4:
                dessiner_pion(x_case, y_case, "\u26C0", "black")
            elif ligne > 5:
                dessiner_pion(x_case, y_case, "\u26C2", "red")

#=============================================================================#
                        # INTERACTION AVEC LES JOUEURS #
#=============================================================================#

# Création d'une variable qui va nous permettre
# de sauvegarder la position d'un pion que le joueur a selectionné
case_selectionnee = None

def deplacement_pion(x, y):
    global case_selectionnee

    print(x, y)

    if x < -300 or x > 300 or y < -300 or y > 300:
        print("HORS PLATEAU")
        return

    colonne = int((x + 300) // 60)
    ligne = int((300 - y) // 60)

    lettres_colonnes = "ABCDEFGHIJ"
    case = print(lettres_colonnes[colonne], ligne)
    print("Tu as cliqué dans la case :", case)

    if case_selectionnee is None:      # Si aucun pion n'est sélectionné
        pion = plateau[ligne][colonne]
        if pion in [1, 2, 3, 4]:  # Si la case contient un pion
            print("Pion sélectionné")
            case_selectionnee = (ligne, colonne)
        else:
            print("Pas de pion ici")

    else:
        ligne_depart, colonne_depart = case_selectionnee
        pion = plateau[ligne_depart][colonne_depart]

        deplacement_valide = False

        # Si le pion sélectionné est rouge (1), il peut avancer vers le bas en diagonale
        if pion == 1:
            if ligne == ligne_depart + 1 and abs(colonne - colonne_depart) == 1:
                deplacement_valide = True
            elif abs(ligne - ligne_depart) == 2 and abs(colonne - colonne_depart) == 2:
                ligne_mangee = (ligne + ligne_depart) // 2
                colonne_mangee = (colonne + colonne_depart) // 2
                pion_mange = plateau[ligne_mangee][colonne_mangee]

                if pion_mange == 2 and plateau[ligne][colonne] == 0:
                    deplacement_valide = True
                    plateau[ligne_mangee][colonne_mangee] = 0  # Mange le pion
                    # Effacer visuellement le pion mangé
                    x_mange = -300 + colonne_mangee * 60
                    y_mange = 300 - ligne_mangee * 60
                    color("gray" if (ligne_mangee + colonne_mangee) % 2 == 0 else "black")
                    up()
                    goto(x_mange, y_mange)
                    down()
                    begin_fill()
                    for _ in range(4):
                        forward(60)
                        right(90)
                    end_fill()

        # Si c'est un pion noir (2), il peut avancer vers le haut en diagonale
        elif pion == 2:
            if ligne == ligne_depart - 1 and abs(colonne - colonne_depart) == 1:
                deplacement_valide = True
            elif abs(ligne - ligne_depart) == 2 and abs(colonne - colonne_depart) == 2:
                ligne_mangee = (ligne + ligne_depart) // 2
                colonne_mangee = (colonne + colonne_depart) // 2
                pion_mange = plateau[ligne_mangee][colonne_mangee]

                if pion_mange == 1 and plateau[ligne][colonne] == 0:
                    deplacement_valide = True
                    plateau[ligne_mangee][colonne_mangee] = 0  # Mange le pion
                    # Effacer visuellement le pion mangé
                    x_mange = -300 + colonne_mangee * 60
                    y_mange = 300 - ligne_mangee * 60
                    color("gray" if (ligne_mangee + colonne_mangee) % 2 == 0 else "black")
                    up()
                    goto(x_mange, y_mange)
                    down()
                    begin_fill()
                    for _ in range(4):
                        forward(60)
                        right(90)
                    end_fill()

        # Si c’est une dame rouge
        elif pion == 3:
            delta_ligne = ligne - ligne_depart
            delta_colonne = colonne - colonne_depart

            if abs(delta_ligne) == abs(delta_colonne):  # diagonale
                direction_ligne = 1 if delta_ligne > 0 else -1
                direction_colonne = 1 if delta_colonne > 0 else -1

                ligne_temp = ligne_depart + direction_ligne
                colonne_temp = colonne_depart + direction_colonne
                pions_adverses = 0
                ligne_mangee = colonne_mangee = None

                while ligne_temp != ligne and colonne_temp != colonne:
                    pion_temp = plateau[ligne_temp][colonne_temp]
                    if pion_temp != 0:
                        if pion_temp in [2, 4]:  # ennemi
                            pions_adverses += 1
                            ligne_mangee = ligne_temp
                            colonne_mangee = colonne_temp
                        else:  # pion allié
                            pions_adverses = 2
                            break
                    ligne_temp += direction_ligne
                    colonne_temp += direction_colonne

                if pions_adverses == 0 and plateau[ligne][colonne] == 0:
                    deplacement_valide = True
                elif pions_adverses == 1 and plateau[ligne][colonne] == 0:
                    deplacement_valide = True
                    plateau[ligne_mangee][colonne_mangee] = 0

                    # Efface visuellement le pion mangé
                    x_mange = -300 + colonne_mangee * 60
                    y_mange = 300 - ligne_mangee * 60
                    color("gray" if (ligne_mangee + colonne_mangee) % 2 == 0 else "black")
                    up()
                    goto(x_mange, y_mange)
                    down()
                    begin_fill()
                    for _ in range(4):
                        forward(60)
                        right(90)
                    end_fill()

# Si c’est une dame noire
        elif pion == 4:
            delta_ligne = ligne - ligne_depart
            delta_colonne = colonne - colonne_depart

            if abs(delta_ligne) == abs(delta_colonne):  # diagonale
                direction_ligne = 1 if delta_ligne > 0 else -1
                direction_colonne = 1 if delta_colonne > 0 else -1

                ligne_temp = ligne_depart + direction_ligne
                colonne_temp = colonne_depart + direction_colonne
                pions_adverses = 0
                ligne_mangee = colonne_mangee = None

                while ligne_temp != ligne and colonne_temp != colonne:
                    pion_temp = plateau[ligne_temp][colonne_temp]
                    if pion_temp != 0:
                        if pion_temp in [1, 3]:  # ennemi
                            pions_adverses += 1
                            ligne_mangee = ligne_temp
                            colonne_mangee = colonne_temp
                        else:
                            pions_adverses = 2
                            break
                    ligne_temp += direction_ligne
                    colonne_temp += direction_colonne

                if pions_adverses == 0 and plateau[ligne][colonne] == 0:
                    deplacement_valide = True
                elif pions_adverses == 1 and plateau[ligne][colonne] == 0:
                    deplacement_valide = True
                    plateau[ligne_mangee][colonne_mangee] = 0

                    # Efface visuellement le pion mangé
                    x_mange = -300 + colonne_mangee * 60
                    y_mange = 300 - ligne_mangee * 60
                    color("gray" if (ligne_mangee + colonne_mangee) % 2 == 0 else "black")
                    up()
                    goto(x_mange, y_mange)
                    down()
                    begin_fill()
                    for _ in range(4):
                        forward(60)
                        right(90)
                    end_fill()


        if deplacement_valide:
            if plateau[ligne][colonne] == 0:
                print("Déplacement accepté")
                plateau[ligne][colonne] = pion
                plateau[ligne_depart][colonne_depart] = 0

                # Promotion avant dessin
                if pion == 1 and ligne == 9:
                    plateau[ligne][colonne] = 3
                elif pion == 2 and ligne == 0:
                    plateau[ligne][colonne] = 4

                nouveau_pion = plateau[ligne][colonne]
                x_case = -300 + colonne * 60
                y_case = 300 - ligne * 60

                if nouveau_pion == 1:
                    dessiner_pion(x_case, y_case, "\u26C2", "black")   # pion noir
                elif nouveau_pion == 2:
                    dessiner_pion(x_case, y_case, "\u26C0", "red") # pion rouge
                elif nouveau_pion == 3:
                    dessiner_pion(x_case, y_case, "\u26C3", "black")   # dame noire
                elif nouveau_pion == 4:
                    dessiner_pion(x_case, y_case, "\u26C1", "red") # dame rouge



                # Effacer la case d'origine
                x_old = -300 + colonne_depart * 60
                y_old = 300 - ligne_depart * 60
                color("gray" if (ligne_depart + colonne_depart) % 2 == 0 else "black")
                up()
                goto(x_old, y_old)
                down()
                begin_fill()
                for _ in range(4):
                    forward(60)
                    right(90)
                end_fill()

            else:
                print("La case est occupée")
        else:
            print("Déplacement non autorisé")

        # Vider la sélection
        case_selectionnee = None

#=============================================================================#
                        # IDENTIFICATION DES CASES #
#=============================================================================#

for i in range(10):
    penup()
    color(0, 0, 0)
    goto(-315, 260 - i * 60)
    write(str(9 - i))
    pendown()

for i in range(10):
    penup()
    color(0, 0, 0)
    goto(-270 + i * 60, -320)
    write(ascii_uppercase[i])
    pendown()


#=============================================================================#
                        # STRUCTURE DU PLATEAU #
#=============================================================================#

# 0: Case vide, 1: Pions noire, 2: Pions rouge
plateau = [
    [1, 0, 1, 0, 1, 0, 1, 0, 1, 0],
    [0, 1, 0, 1, 0, 1, 0, 1, 0, 1],
    [1, 0, 1, 0, 1, 0, 1, 0, 1, 0],
    [0, 1, 0, 1, 0, 1, 0, 1, 0, 1],
    [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
    [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
    [2, 0, 2, 0, 2, 0, 2, 0, 2, 0],
    [0, 2, 0, 2, 0, 2, 0, 2, 0, 2],
    [2, 0, 2, 0, 2, 0, 2, 0, 2, 0],
    [0, 2, 0, 2, 0, 2, 0, 2, 0, 2]
]

#=============================================================================#
                            # BASCULE J1 à J2 #
#=============================================================================#

joueur_actuel = 2  # 1 pour rouge, 2 pour noir

def gestion_tour_par_joueur(fonction_originale):
    def wrapper(x, y):
        global joueur_actuel
        ligne = int((300 - y) // 60)
        colonne = int((x + 300) // 60)

        # Ne pas interférer si le clic est hors plateau
        if ligne not in range(10) or colonne not in range(10):
            return fonction_originale(x, y)

        pion = plateau[ligne][colonne]

        # Si c'est à toi de jouer (le pion appartient au joueur actuel ou une case vide après sélection)
        if (case_selectionnee is None and pion in ([joueur_actuel, joueur_actuel + 2])) or (case_selectionnee is not None):
            # Appeler la vraie fonction
            fonction_originale(x, y)

            # Si le déplacement a bien eu lieu (case_selectionnee remise à None), on change de tour
            if case_selectionnee is None:
                joueur_actuel = 2 if joueur_actuel == 1 else 1
                print("➡️ Au tour du joueur", joueur_actuel, 'Noir' if joueur_actuel == 1 else 'Rouge')
        else:
            print("❌ Ce n'est pas à vous de jouer ! C'est au joueur", joueur_actuel)
    return wrapper


#=============================================================================#
                        # SAUVEGARDE DE JEU  #
#=============================================================================#
# Connexion à la base de données (ou création si elle n'existe pas)
"""connexion = sqlite3.connect('jeu_dames.db')
cursor = connexion.cursor()


# Création d'une table
cursor.execute('''
CREATE TABLE IF NOT EXISTS users (
    id INTEGER PRIMARY KEY,
    PLATEAU TEXT NOT NULL,
    TOUR_JOUEUR TEXT NOT NULL
)
''')

sauvegarde_plateau = str(plateau)
cursor.execute('INSERT INTO users (PLATEAU, TOUR_JOUEUR) VALUES (?, ?)', (sauvegarde_plateau, " 1" ))

# Validation des modifications
connexion.commit()"""



#=============================================================================#
                        # EVENEMENTS UTILISATEUR #
#=============================================================================#
deplacement_pion = gestion_tour_par_joueur(deplacement_pion)
onscreenclick(deplacement_pion)
onkeypress(bye, "Escape")
listen()

done()