# ############################################################################
#
# Programme : Puissance 4
# Version : 3
# Date : 16 octobre 2020
# Interpréteur : Python 3.2
# Environnement de développement : EduPython 2.5.3.0
# Auteur : Jean-Christophe MICHEL
#
# ----------------------------------------------------------------------------
#
# Dans cette version 3 :
# - pour jouer un pion les joueurs doivent cliquer à tour de rôle dans une colonne
# - pour recommencer une partie il faut appuyer sur la touche Echap
# - pour quitte immédiatement le programme il faut fermer la fenêtre de la tortue
# - la grille pleine est détectée
# - c'est toujours le joueur ROUGE qui commence
# - le programme détecte 4 pions alignés quelque soit la couleur et la direction
# - si 4 pions sont alignés la partie est finie : seul ESC permet de recommencer
#
# ############################################################################

from turtle import *

# ############################################################################
#   D E C L A R A T I O N     D E S     V A R I A B L E S     G L O B A L E S
# ############################################################################

# Structure de donnée mémorisant la grille : une liste à 2 dimensions (6 lignes et 7 colonnes) contenant :
# - un 0 si la case est vide
# - un 1 si un pion ROUGE est dans la case
# - un 2 si un pion BLEU est dans la case

grille=[7*[0], 7*[0], 7*[0], 7*[0], 7*[0], 7*[0]]

# liste_colonne mémorise le nombre de pions dans chacune des colonnes
liste_colonne=7*[0]

# joueur_courant indique le prochain joueur qui doit jouer : 1 pour ROUGE, 2 pour BLEU et 0 pour partie finie
joueur_courant=1

# ############################################################################
#    D E C L A R A T I O N      D E S      F O N C T I O N S
# ############################################################################

# ############################################################################
# La fonction test_grille(g) analyse chaque liste de la
# liste de liste g passée en paramètre à la recherche de 4 pions alignés :
def tester_grille(g):
    # utilise la variable globale joueur_courant :
    global joueur_courant

    for ligne in g:
        if ('1, '*4)[:-2] in str(ligne):
            print('\nFin de la partie : le joueur ROUGE a gagné !')
            print('\nAppuyez sur Echap pour recommencer une nouvelle partie.')
            joueur_courant=0
        elif ('2, '*4)[:-2] in str(ligne):
            print('\nFin de la partie : le joueur BLEU a gagné !')
            print('\nAppuyez sur Echap pour recommencer une nouvelle partie.')
            joueur_courant=0

# ############################################################################
# La fonction afficher_grille() affiche la grille sur la sortie standard
def afficher_grille():
    for i in range(6):
        print(grille[i])

    # affiche le repère des colonnes sous la grille :
    print('\n 0  1  2  3  4  5  6')


# ############################################################################
# La fonction grille_pleine() teste si la grille est pleine (aucun 0 dans la liste grille)
def grille_pleine():
    b_plein=True
    for i in range(6):
        for j in range(7):
            if grille[i][j]==0:
                # retourne False si au moins une case est vide
                b_plein=False
    return b_plein


# ############################################################################
# La fonction jouer(x,y) est appelé si on clique gauche sur le point (x,y)
def jouer(x,y):
    # utilise la variable globale joueur_courant :
    global joueur_courant

    # si joueur_courant=0 la partie est finie : il n'y a plus rien à jouer
    if joueur_courant==0:
        return 0

    # teste si la grille est pleine :
    if grille_pleine():
        print("Fin de la partie : la grille est pleine. Appuyez sur Echap pour recommencer une nouvelle partie.")
    else:
        # analyse la zone cliquée pour déterminer la colonne :
        if x_base<x<x_base+largeur:
            colonne=0
        elif x_base+largeur<x<x_base+2*largeur:
            colonne=1
        elif x_base+2*largeur<x<x_base+3*largeur:
            colonne=2
        elif x_base+3*largeur<x<x_base+4*largeur:
            colonne=3
        elif x_base+4*largeur<x<x_base+5*largeur:
            colonne=4
        elif x_base+5*largeur<x<x_base+6*largeur:
            colonne=5
        elif x_base+6*largeur<x<x_base+7*largeur:
            colonne=6
        else:
            print("Vous avez cliqué en dehors de la grille : cliquez dans une colonne")
            # quitte la fonction jouer() :
            return()

        # donne un nom au joueur courant :
        if joueur_courant==1:
            joueur='ROUGE'
        else:
            joueur='BLEU'

        # teste si la colonne cliquée est pleine :
        if liste_colonne[colonne]==6:
            print('La colonne %d est pleine ! %s jouez dans une colonne non pleine' % (colonne,joueur))
        else:
            # met à jour la liste à 2 dimensions grille[][] :"
            grille[5-liste_colonne[colonne]][colonne]=joueur_courant
            # dessine le pion sur la grille graphique :
            dessiner_pion(colonne,liste_colonne[colonne],joueur_courant)
            # met à jour la liste liste_colonne[] pour mémoriser le nombre de pions présents dans cette colonne :
            liste_colonne[colonne]+=1
            print('\nLe joueur %s vient de jouer dans la colonne %d :' % (joueur,colonne))
            # affiche le nouvelle grille sur la sortie standard :
            afficher_grille()
            # bascule le joueur courant :
            joueur_courant=3-joueur_courant

        # teste si la grille est pleine :
        if grille_pleine():
            print("Fin de la partie : la grille est pleine. Appuyez sur Echap pour recommencer une nouvelle partie.")

        # #######################################################################################
        # Nouveauté de la version 3 : on analyse la grille ici à chaque nouveau pion :

        # ================================================
        # Grille verticale :

        # 7 listes contenant chacune 6 éléments :
        grille_verticale=[6*[0],6*[0],6*[0],6*[0],6*[0],6*[0],6*[0]]
        for x in range(7):
            for y in range(6):
                grille_verticale[x][y]=grille[y][x]

        # ================================================
        # Grille des diagonales CROISSANTES :

        # 6 listes contenant chacune de 4 à 6 éléments
        grille_diagonale_1=[6*[0],6*[0],6*[0],6*[0],6*[0],6*[0]]

        # les 2 diagonales croissantes à 4 cases :
        for i in range(4):
            grille_diagonale_1[0][i]=grille[3-i][i]
            grille_diagonale_1[1][i]=grille[5-i][3+i]
        # les 2 diagonales croissantes à 5 cases :
        for i in range(5):
            grille_diagonale_1[2][i]=grille[4-i][i]
            grille_diagonale_1[3][i]=grille[5-i][2+i]
        # les 2 diagonales croissantes à 6 cases :
        for i in range(6):
            grille_diagonale_1[4][i]=grille[5-i][i]
            grille_diagonale_1[5][i]=grille[5-i][1+i]

        # ================================================
        # Grille des diagonales DECROISSANTES :

        # 6 listes contenant chacune de 4 à 6 éléments
        grille_diagonale_2=[6*[0],6*[0],6*[0],6*[0],6*[0],6*[0]]

        # les 2 diagonales décroissantes à 4 cases :
        for i in range(4):
            grille_diagonale_2[0][i]=grille[i][i+3]
            grille_diagonale_2[1][i]=grille[i+2][i]
        # les 2 diagonales décroissantes à 5 cases :
        for i in range(5):
            grille_diagonale_2[2][i]=grille[i][i+2]
            grille_diagonale_2[3][i]=grille[i+1][i]
        # les 2 diagonales décroissantes à 6 cases :
        for i in range(6):
            grille_diagonale_2[4][i]=grille[i][i+1]
            grille_diagonale_2[5][i]=grille[i][i]

        # ================================================
        # Test de chacune des 4 grilles :

        # Teste 4 pions alignés HORIZONTALEMENT :
        tester_grille(grille)
        # Teste 4 pions alignés VERTICALEMENT :
        tester_grille(grille_verticale)
        # Teste 4 pions alignés sur les diagonales CROISSANTES :
        tester_grille(grille_diagonale_1)
        # Teste 4 pions alignés sur les diagonales DECROISSANTES :
        tester_grille(grille_diagonale_2)

# ############################################################################
# La fonction dessiner_grille() dessine une grille vide dans la fenêtre de la tortue
def dessiner_grille():
    # cache le curseur de la tortue :
    hideturtle()

    # vitesse maximale :
    speed(0)

    # configure la taille et la position de la fenêtre de la tortue dans l'écran :
    setup(430,430,0,0)

    # part du point de coordonnées (x_base,y_base) :
    up()
    goto(x_base,y_base)
    down()

    # traits horizontaux :
    for i in range(8):
        forward(7*largeur)
        up()
        goto(x_base,y_base+i*largeur)
        down()

    # traits verticaux :
    up()
    goto(x_base,y_base)
    setheading(90)
    down()
    for i in range(9):
        forward(6*largeur)
        up()
        goto(x_base+i*largeur,y_base)
        down()

    # affiche le numéro des colonnes sous la grille :
    for i in range(7):
        up()
        goto(x_base+i*largeur+largeur//2,y_base-largeur//2)
        down()
        write(str(i))



# ############################################################################
# La fonction dessiner_pion(x,y,couleur) ajoute un pion dans la case (x,y)
def dessiner_pion(x,y,couleur):
    # x de 0 à 6 et y de 0 à 5
    up()
    goto(x_base+(x+1)*largeur-largeur//8,y_base+(y+1)*largeur-largeur//2)
    down()
    if couleur==1:
        # pion ROUGE si couleur=1 :
        color('red')
    else:
        # pion BLEU si couleur=2 :
        color('blue')
    begin_fill()
    circle(largeur/2.5)
    end_fill()

# ############################################################################
# La fonction recommencer est appelée si on appuie sur la touche Echap
def recommencer():
    # utilise les variables globales pour les modifier :
    global grille,liste_colonne,joueur_courant
    # efface la fenêtre de la tortue :
    reset()
    # dessine la grille vide :
    dessiner_grille()
    # ré-initialise les variables globales pour définir une grille vide :
    grille=[7*[0], 7*[0], 7*[0], 7*[0], 7*[0], 7*[0]]
    liste_colonne=7*[0]
    joueur_courant=1
    # Affiche le séparateur et le message dans la console :
    print('\n\n==========================================================\n\n')
    print("Vous venez d'appuyer sur Echap : la partie recommence à zéro")
    print('La grille est vide et le joueur ROUGE commence :')
    # affiche la grille dans la console :
    afficher_grille()

# ############################################################################
#    P R O G R A M M E      P R I N C I P A L
# ############################################################################

# initialise l'affichage graphique de la grille :
# Largeur règle la largeur des cases et la taille des pions
largeur=55

# x_base et y_base règle la position de la grille dans la fenêtre de la tortue
x_base=-200
y_base=-160

# dessine la grille vide :
dessiner_grille()

print('Cliquez dans une colonne pour jouer ou Appuyer sur Echap pour recommencer une partie.')
print('Le nom des joueurs sera ici ROUGE et BLEU. Le joueur ROUGE commence.')
print('Début de la partie (la grille est vide) :')

# affiche la grille dans la console :
afficher_grille()

# fonction à lancer si on clique avec un bouton de la souris :
onscreenclick(jouer) # clic gauche

# fonctions à lancer si on appuie sur une touche :
onkeypress(recommencer,"Escape")

# lance le gestionnaire d'évènement qui détecte les évèvements de la souris :
listen()

# lance la boucle principale :
done()

# ############################################################################
#    F I N     D U     P R O G R A M M E
# ############################################################################