BLoquer dans un Puissance 4 sous Python 3

Version imprimable

13/10/2018, 11h50
ElouanR

1 pièce(s) jointe(s)

BLoquer dans un Puissance 4 sous Python 3

Bonjour,
Je suis un étudiant dans un BTS SN IR et je dois créer dans l'occasion d'un mini-projet le jeu puissance 4 sous python. Mais voila je suis bloquer pour la vérification des 4 jetons alignés serais-ce possible d'avoir de l'aide ?
Voici mon programme au complet:
13/10/2018, 15h05
YCL-1

Bonjour,

vous pouvez vous servir des balises [CODE][/CODE] pour citer votre code plutôt qu'en pièce jointe.

La partie visuelle semble bien fonctionner mais juste une remarque pour le confort des joueurs ça serait mieux de commencer à 1 pour la première colonne, c'est simple de faire ensuite co - 1

Pour ce qui est de la vérification essayez d'écrire quelque chose on ne peut pas le faire pour vous.

Vous avez un tableau de 6 lignes commencez par vérifier les lignes c'est le plus simple : "for ligne in tableau:"

Ensuite il faut regrouper par groupe de 4 éléments en glissant de 1 tout le long, ligne[i:i + 4]

Essayez avec une ligne plus facile à lire comme : ligne = [0, 1, 2, 3, 4, 5, 6]

de manière à obtenir :

[0, 1, 2, 3]
[1, 2, 3, 4]
[2, 3, 4, 5]
[3, 4, 5, 6]

il ne reste plus qu'à compter les 'R' ou les 'B' et de faire ça en colonne et en diagonale.

Bon courage.
15/10/2018, 15h28
lg_53

A chaque fois qu'un jetons est placé vous n'avez pas besoin de vérifier toute la grille. Suffit de vérifier si le jeton que vous venez de place vous donne la victoire.

Pour cela commencer par extraire la ligne, colonne et diagonales dans lequel se trouve le pion joué. Ca vous donne donc 4 listes. Et dans ces 4 listes, regardez si vous avez 4 jaunes ou 4 rouges consécutifs.

avancement

Bonjour, j'ai vu que vaut message a l'instant ^^ je vous fait par de mon avancer. Il me reste les vérification en diagonale a faire. J'ai fait différents test mais rien fonctionne :/ voici mon nouveau programme au complet :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
 
 
# ------------------------------ variable globales --------------------------------
 
joueur1 = input("indiquer le nom du joueur 1 : ")
joueur2 = input("indiquer le nom du joueur 2 : ")
print(" ")
print("vous avez 21 pions max par personne")
print(" ")
print("le joueur 1 est : ", joueur1)
print("le joueur 2 est : ", joueur2)
pion1 = 'R'
pion2 = 'J'
# --------------------------------- constante ---------------------
 
COLONNE = 7
LIGNE = 6
 
 
tableau = [['.','.','.','.','.','.','.'],['.','.','.','.','.','.','.'],['.','.','.','.','.','.','.'],['.','.','.','.','.','.','.'],['.','.','.','.','.','.','.'],['.','.','.','.','.','.','.']]
 
# -------------------------------- fonction ----------------------------
 
def afficheTableau():
    for l in range (LIGNE):
        for c in range (COLONNE):
            print(tableau[l][c], end = " ")
        print()
 
def verificationligne():
    # vÃƒÂ©rification ligne
    for l in range (LIGNE):
        cpt=0
        for c in range (COLONNE-1):
            if (tableau[l][c] == tableau[l][c+1]) and tableau[l][c] !='.':
                cpt = cpt +1
                if cpt ==3:
                    print("c'est gagnÃƒÆ’Ã‚Â©")
                    break
            else:
                cpt = 0
    # VÃƒÂ©rification colonne
def verificationcolonne():
    for c in range (COLONNE):
        cpt=0
        for l in range (LIGNE-1):
            if (tableau[l][c] == tableau[l+1][c]) and tableau[l][c] !='.':
                cpt = cpt +1
                if cpt ==3:
                    print("c'est gagnÃƒÆ’Ã‚Â©")
                    break
            else:
                cpt = 0
 
def verificationdiagonale():
    # VÃƒÂ©rification en diagonale de la gauche haut ÃƒÂ* bas droite
    for l in range (LIGNE-3):
        cpt=0
        for c in range (COLONNE-l):
            if (tableau[l][c] == tableau[l+c][c]) and tableau[l][c] !='.':
                cpt = cpt+1
                if cpt == 3:
                    print("c'est gagnÃƒÂ©e")
                    break
            else:
                cpt = 0
 
    for c in range (COLONNE-3):
        cpt=0
        for l in range (LIGNE-c):
            if (tableau[l][c] == tableau[l][l+c]) and tableau[l][c] !='.':
                cpt = cpt+1
                if cpt == 3:
                    print("c'est gagnÃƒÂ©e")
                    break
            else:
                cpt = 0
 
def ajoutePion(colonne, pion):
    for i in range (LIGNE-1, -1, -1):
        if tableau[i][colonne]==".":
            tableau[i][colonne] = pion
            print("placee ligne",i)
            break
 
#-------------------------------------- jeu --------------------------
 
for i in range (21):
    afficheTableau()
    print(" ")
    print(joueur1,"a ton tour")
    print(" ")
    co = int(input("entrer une colonne "))
    ajoutePion(co, 'R')
    verificationligne()
    verificationcolonne()
    verificationdiagonale()
 
    afficheTableau()
    print(" ")
    print(joueur2,"a ton tour")
    print(" ")
    co = int(input("entrer une colonne "))
    ajoutePion(co, 'J')
    verificationligne()
    verificationcolonne()
    verificationdiagonale()
 
print("______________________")

Bonjour,

vous devriez tenter d'utiliser l'idée de lg_53 qui sera plus efficace et peut-être plus simple à mettre en place.

À chaque placement vous devez recréer 4 listes :

prenons L, C pour l'emplacement du pion qui a été placé, pour obtenir L, la hauteur/ligne ça nécessitera de compter la hauteur de chaque colonne, dans une liste de 7 éléments par exemple.

Code:

hauteur = [0, 0, 0, 0, 0, 0, 0]

puis de faire à chaque tour :

Code:

hauteur[co] += 1

pour vérifier la ligne il faut créer une liste de la hauteur correspondante à L puis de compter le nombre de pion consécutifs, cette deuxième partie peut être fait de la même manière pour les 4 cas lignes/colonnes et diagonales

Pas besoin de tout le code pour résoudre votre problème, créez un tableau déjà rempli et faite des essais, ça ira plus vite à tester.
Code:

1 2 3 4 5 6 7 8 9 10 tableau = [ ['.', '.', '.', '.', '.', '.', '.'], ['.', '.', '.', '.', '.', '.', '.'], ['.', '.', '.', '.', '.', '.', '.'], ['.', '.', '.', '.', '.', '.', 'J'], ['R', 'J', 'R', 'R', 'R', 'R', 'J'], ['R', 'J', 'R', 'J', 'R', 'J', 'J'] ] hauteur = [2, 2, 2, 2, 2, 2, 3]
supposons que le dernier pion placé est le Rouge en colonne/index 5

L vaudra : hauteur[co] - 1 soit 1

Ensuite il faut créer 4 listes, et la vérification de ces 4 listes peut être commune pour compter les pions côté-à-côté d'un tableau/liste à 1 dimension.

Essayez déjà de créer ces 4 listes et postez le code de la liste que vous n'arrivez pas à créer.

Sers toi d'une fonction que tu as déjà écrite sans t'en rendre compte. La fonction qui étant donné une liste (représentant une ligne verticale horizontale ou diagonale dans la grille) savoir s'il y a une configuration gagnante dans cette ligne ou non.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 def verificationliste(ligne): res = False cpt = 0 for i in range(len(ligne)-1): if (ligne[i] == ligne[i+1]) and ligne[i] !='.': cpt = cpt+1 if cpt == 3: res = True break else: cpt = 0 return res
Et cette brique fonctionne manifestement bien au vue des petits exemples :
Code:

1 2 3 4 5 verificationliste(['R','J','J','.','.','.','.']) Out[6]: False verificationliste(['R','J','J','J','J']) Out[7]: True
Maintenant ne te reste plus qu'à faire une fonction verification(x,y) qui :
- prend en paramètre la position x,y du dernier pion joué (x étant la colonne, y la ligne)
- va construire les 4 lignes droites passant par ce point
- Regarder pour chacune de ces lignes droites si ces lignes sont gagnantes grace à la fonction verifierlisteVous bloquez manifestement sur le second point, mais déjà ce découpage vous permettera de travailler sur un code bcp plus petit. Petit indice pour ce point : vous ne souhaitez pas forcément extraire la totalité de la ligne. Juste 3 éléments avant et 3 éléments après suffisent. Donc caler vous par rapport à x et y à plus ou moins 3 (attention au range qui inclu le premier paramètre mais exclu le dernier). Ensuite faire attention, car si on est dans un coin de la grille, et bien on ne pourra pas remonter de 3 crans dans certaines direction car on va arriver sur le bord. Dans ce cas, pas grave, on extrait une ligne plus courte (la fonction verificationliste prenant en paramètre des lignes de longueur arbitraire, ca ne pose aucun problème). Et pour faire ces lignes plus courtes correctement sans aller chercher des valeurs qui sont en dehors du tableau et bien vous allez user des min et des max pour définir les bornes de vos range. Du style
Code:

1 2 max(0,x-3) ### On n'est donc pas en dessous de 0 min(COLONNE, x+3) ### On ne dépasse donc pas le nombre de colonnes du tableau