# ############################################################################
#
# Programme : Puissance 4
# Version : 1
# Date : 20 avril 2020
# Interpréteur : Python 3.2
# Environnement de développement : EduPython 2.5.3.0
# Auteur : Jean-Christophe MICHEL
#
# ----------------------------------------------------------------------------
#
# Cette version 1 :
# - demande aux joueurs à tour de rôle dans quelle colonne il veulent jouer
# - filtre la saisie de l'utilisateur et envoie un message sur la sortie standard si la saisie est erronée
# - affiche la grille graphiquement dans une fenêtre de la tortue (module turtle)
# - détecte la grille pleine
# - quitte immédiatement le programme si l'utilisateur saisie f (comme Fin)
#
# ############################################################################

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]]

""" Repérage des éléments dans la grille :

élément grille[0][0] (coin supérieur gauche) :
[[X, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0]]

élément grille[0][6] (coin supérieur droit) :
[[0, 0, 0, 0, 0, 0, X],
 [0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0]]

élément grille[5][0] (coin inférieur gauche) :
[[0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0],
 [X, 0, 0, 0, 0, 0, 0]]

élément grille[5][6] (coin inférieur droit):
[[0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, X]]

 """

# 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 et 2 pour BLEU
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 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 tester_saisie demande au joueur de saisir un nombre entre 0 et 6,
# et réitère la demande tant que la valeur saisie n'est pas un entier dans cet intervale
def tester_saisie(joueur_courant):
    if joueur_courant==1:
        joueur='ROUGE'
    else:
        joueur='BLEU'
    saisie_correct=False
    # gestion des erreurs et filtrage des entrées : demande une saisie jusqu'à ce que la valeur entrée soit un chiffre entre 0 et 6
    # Les messages d'erreurs orientant l'utilisateur sont affichés sur la sortie standard (sans provoquer d'erreur)
    while not saisie_correct:
        s_colonne=input("%s : entrez la colonne où jouer (de 0 à 6) :" % joueur)
        # quitte le programme et ferme la fenêtre de la tortue si l'utilisateur saise f (comme fin)
        if s_colonne.upper()=='F':
            print("Fin du programme car l'utilisateur a saisie F")
            bye()
            exit()
        # teste si la chaine saise est un entier :
        if not s_colonne.isdigit():
            print("Erreur de saise : la valeur entrée par le joueur %s n'est pas un nombre entier. Recommencez." % joueur)
        # teste si la valeur numérique est comprise entre 0 et 6 :
        elif int(s_colonne)<0 or int(s_colonne)>6:
            print("Erreur de saise : la valeur numérique entrée par le joueur %s n'est pas comprise entre 0 et 6. Recommencez." % joueur)
        else:
            saisie_correct=True
    # la chaine s_colonne est un chiffre entre 0 et 6 : on la convertit en entier et on la renvoie
    return int(s_colonne)


# ############################################################################
# La fonction jouer() demande au joueur courant dans quelle colonne (de 0 à 6) il veut jouer
def jouer(joueur_courant):
    if joueur_courant==1:
        joueur='ROUGE'
    else:
        joueur='BLEU'
    # La fonction tester_saisie renvoie forcément un chiffre entre 0 et 6 :
    colonne=tester_saisie(joueur_courant)
    while liste_colonne[colonne]==6:
        print('La colonne %d est pleine ! %s jouez dans une colonne non pleine' % (colonne,joueur))
        colonne=tester_saisie(joueur_courant)
    # 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))


# ############################################################################
# La fonction dessiner_grille() dessine une grille vide dans la fenêtre de la tortue
def dessiner_grille():
    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()


# ############################################################################
#    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

# 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)

# dessine la grille vide :
dessiner_grille()

print('Entrez F pour quitter le programme.')
print('Le nom des joueurs sera ici ROUGE et BLEU. Le joueur ROUGE commence.')
print('Début de la partie (la grille est vide) :')

# demande aux joueurs où ils veulent mettre un pion tant que la grille n'est pas pleine :
while not grille_pleine():
    afficher_grille()
    jouer(joueur_courant)
    # permute le joueur courant entre 1 (joueur ROUGE) et 2 (joueur BLEU) :
    joueur_courant=3-joueur_courant

# la grille est pleine : on l'affiche et on quitte le programme
afficher_grille()
print("Fin de la partie : la grille est pleine")

done()

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