Jeu échec déplacements

Version imprimable

salut
je reviens sur le programme du jeu d'échec
voilà ce dont j'ai compris
Python 3.0

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
from random import randrange
 
x=int(input("x pos = "))
y=int(input("y pos = "))
b = randrange (1,2)
if b==1:
    while 1:
            a = randrange(-7,7)
            x = x+a
            y = y+a
            if x>0 and x<9 and y>0 and y<9:
                print("x= ",x,"y= ",y)
                break
if b==2:
    while 1:
            a = randrange(-7,7)
            x = x+a
            y = y-a
            if x>0 and x<9 and y>0 and y<9:
                print("x= ",x,"y= ",y)
                break

j'aimerais comprendre :
x est ce horizontal et y est ce vertical ou l'inverse
pourquoi 9 dans x<9 et y<9
un échiquier c'est 8x8
type :

Code:

1
2
3
4
5
6
7
8
9
10
coord=[
    'a8','b8','c8','d8','e8','f8','g8','h8',
    'a7','b7','c7','d7','e7','f7','g7','h7',
    'a6','b6','c6','d6','e6','f6','g6','h6',
    'a5','b5','c5','d5','e5','f5','g5','h5',
    'a4','b4','c4','d4','e4','f4','g4','h4',
    'a3','b3','c3','d3','e3','f3','g3','h3',
    'a2','b2','c2','d2','e2','f2','g2','h2',
    'a1','b1','c1','d1','e1','f1','g1','h1',
    ]

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
tab120 = (
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1,  0,  1,  2,  3,  4,  5,  6,  7, -1,
    -1,  8,  9, 10, 11, 12, 13, 14, 15, -1,
    -1, 16, 17, 18, 19, 20, 21, 22, 23, -1,
    -1, 24, 25, 26, 27, 28, 29, 30, 31, -1,
    -1, 32, 33, 34, 35, 36, 37, 38, 39, -1,
    -1, 40, 41, 42, 43, 44, 45, 46, 47, -1,
    -1, 48, 49, 50, 51, 52, 53, 54, 55, -1,
    -1, 56, 57, 58, 59, 60, 61, 62, 63, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1

je dois faire cela pour chaque pièce d'un jeu
faire le déplacement pour chaque pièce, déplacement autorisé

j'ai un peu besoin d'Aide
merci d'avance

29/10/2015, 18h07
fred1599

Citation:

pourquoi 9 dans x<9 et y<9

Peut-être parce-que sur un échiquier la première lettre est le A et le premier chiffre est le 1 ??? (même déduction pour la dernière lettre et le dernier chiffre)
29/10/2015, 18h42
Intrepid13

euh en quoi la première est A et 9
peux-tu être plus explicite ?
car entre toi et moi pour aller de A à H c'est 8 ou de 0 à 7 en python
alors le 9 il vient d'où

et autre question
le a et le b, c'est quoi exactement
merci les amis

ah j'ai compris
je croyais que 9 était une coordonnée
mais non, ok, alors x rangée de 1 à 8 d'où x>0 à x<9
et idem pour y

merci
et a et b c'est quoi

j'ai compris aussi
b nombre de coups pour faire le déplacement
a nombre pris au hasard entre -7 et 7

Déplacement du fou

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
from random import randint
R=int(input("la position de la rangée, donnez une valeur entre 1 et 8 = "))
C=int(input("la position de la colonne, donnez une valeur entre 1 et 8 = "))
Deplace=int(input("Déplacement vers la droite (1) ou vers la gauche (2) = "))
b = randint (1,2)   # b correspond au nombre de coups autorisés pour faire un déplacement du fou :  se déplaçant en diagonale,
                    # d’un nombre quelconque de positions. Un fou ne peut pas sauter par dessus une autre pièce.
if Deplace==1: # Déplacement vers la droite
    if b==1: # Premier déplacement : même colonne mais une ligne au dessus, ici on change de ligne donc la rangée
        while 1:
            a = randint(-7,7)
            R = R+a # x+a vers le haut
            C = C+a # y bouge pas, même colonne
            if R>0 and R<9 and C>0 and C<9:
                print("Pour un déplacement vers la droite, la rangée est de = ",R,"la colonne est de ",C) # Affiche les coordonnées du premier déplacement
                break
 
    if b==2: # Second déplacement : même ligne, colonne d'avant, donc ici on change le colonne
        while 1:
            a = randint(-7,7)
            R = R+a # x+a vers le haut
            C = C+a # y bouge pas, même colonne
            if R>0 and R<9 and C>0 and C<9:
                print("Pour un déplacement vers la droite, la rangée est de = ",R,"la colonne est de ",C) # Affiche les coordonnées du premier déplacement
                break
 
if Deplace==2: # Déplacement vers la gauche
    if b==1: # Premier déplacement vers la : même colonne mais une ligne au dessus, ici on change de ligne donc la rangée
        while 1:
            a = randint(-7,7)
            R = R+a # x+a vers le haut
            C = C-a # y bouge pas, même colonne
            if R>0 and R<9 and C>0 and C<9:
                print("Pour un déplacement vers la gauche, la rangée est de = ",R,"la colonne est de ",C) # Affiche les coordonnées du premier déplacement
                break
 
    if b==2: # Second déplacement : même ligne, colonne d'avant, donc ici on change le colonne
        while 1:
            a = randint(-7,7)
            R = R+a # x+a vers le haut
            C = C-a # y bouge pas, même colonne
            if R>0 and R<9 and C>0 and C<9:
                print("Pour un déplacement vers la gauche, la rangée est de = ",R,"la colonne est de ",C) # Affiche les coordonnées du premier déplacement
                break

maintenant si le fou doit aller à droite ou à gauche : mais en faisant "run", il me remet les mêmes nombres
où ai-je fait une erreur
et est-ce que ce genre d'idée est bonne (déplacement gauche et droite) ou c'est inutile ? et comment faire si cela sort du damier ??? Comment l'éviter

30/10/2015, 16h38
fred1599

Je pense que la situation actuelle du code présente de très grosses lacunes de conception, et que si tu continues sur cette base tu risques d'aller très vite droit dans le mur. Pour faire un jeu d'échecs, il faut être un minimum organisé, ce n'est absolument pas le cas de l'auteur de ce code.

en fait le prof nous demande de faire les déplacements (primaires, c'est-à-dire les premiers au début d'une partie) de chaque pièce d'un jeu d'échec
voici le devoir

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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
# -*- coding: utf-8 -*-
"""Module contenant la classe de base Piece, ainsi qu'une classe fille pour chacun des types de pièces du jeu d'échecs.

"""
# TODO: Si votre système n'affiche pas correctement les caractères unicodes du jeu d'échecs,
# mettez cette constante (variable globale) à False. Un tutoriel est présent sur le site Web
# du cours pour vous aider à faire fonctionner les caractères Unicoe sous Windows.
UTILISER_UNICODE = True


class Piece:
    """Une classe de base représentant une pièce du jeu d'échecs. C'est cette classe qui est héritée plus bas pour fournir
    une classe par type de pièce (Pion, Tour, etc.).

    Attributes:
        couleur (str): La couleur de la pièce, soit 'blanc' ou 'noir'.
        peut_sauter (bool): Si oui ou non la pièce peut "sauter" par dessus d'autres pièces sur un échiquier.

    Args:
        couleur (str): La couleur avec laquelle créer la pièce.
        peut_sauter (bool): La valeur avec laquelle l'attribut peut_sauter doit être initialisé.

    """
    def __init__(self, couleur, peut_sauter):
        # Validation si la couleur reçue est valide.
        assert couleur in ('blanc', 'noir')

        # Création des attributs avec les valeurs reçues.
        self.couleur = couleur
        self.peut_sauter = peut_sauter

    def est_blanc(self):
        """Retourne si oui ou non la pièce est blanche.

        Returns:
            bool: True si la pièce est blanche, et False autrement.

        """
        if self.couleur == 'blanc':
            print("True")
        else:
            print("False")

    def est_noir(self):
        """Retourne si oui ou non la pièce est noire.

        Returns:
            bool: True si la pièce est noire, et False autrement.

        """
        if self.couleur == 'noire':
            print("True")
        else:
            print("False")

    def peut_se_deplacer_vers(self, position_source, position_cible):
        """Vérifie si, selon les règles du jeu d'échecs, la pièce peut se déplacer d'une position à une autre.

        Une position est une chaîne de deux caractères.
            Le premier caractère est une lettre entre a et h, représentant la colonne de l'échiquier.
            Le second caractère est un chiffre entre 1 et 8, représentant la rangée de l'échiquier.

        Args:
            position_source (str): La position source, suivant le format ci-haut. Par exemple, 'a8', 'f3', etc.
            position_cible (str): La position cible, suivant le format ci-haut. Par exemple, 'b6', 'h1', etc.

        Warning:
            Comme nous sommes dans la classe de base et non dans l'une des classes filles, nous ne savons pas
            (encore) comment cette pièce se déplace. Cette méthode est donc à redéfinir dans chacune des
            classes filles.

        Warning:
            Comme la classe Piece est indépendante de l'échiquier (et donc on ne sait pas si une pièce est "dans le
            chemin"), on doit ignorer le contenu de l'échiquier : on ne se concentre que sur les règles de mouvement
            des pièces.

        Returns:
            bool: True si le déplacement est valide en suivant les règles de la pièce, et False autrement.

        """
        # On lance une exception (on y reviendra) indiquant que ce code n'a pas été implémenté. Ne touchez pas
        # à cette méthode : réimplémentez-la dans les classes filles!
        raise NotImplementedError

    def peut_faire_une_prise_vers(self, position_source, position_cible):
        """Vérifie si, selon les règles du jeu d'échecs, la pièce peut "manger" (faire une prise) une pièce ennemie.
        Pour la plupart des pièces, la règle est la même, on appelle donc la méthode peut_se_deplacer_vers.

        Si ce n'est pas le cas pour une certaine pièce, on peut simplement redéfinir cette méthode pour programmer
        la règle.

        Args:
            position_source (str): La position source, suivant le format ci-haut. Par exemple, 'a8', 'f3', etc.
            position_cible (str): La position cible, suivant le format ci-haut. Par exemple, 'b6', 'h1', etc.

        Returns:
            bool: True si la prise est valide en suivant les règles de la pièce, et False autrement.

        """
        return self.peut_se_deplacer_vers(position_source, position_cible)

class Pion(Piece):
    def __init__(self, couleur):
        super().__init__(couleur, False)

    def peut_se_deplacer_vers(self, position_source, position_cible):
        # TODO: À compléter, pour définir comment un pion se déplace. Vous devez implémenter cette méthode
        # pour chacune des autres classes filles, ci-bas. Nous ne vous demandons pas de documenter ces méthodes,
        # puisque la documentation est déjà ci-haut, dans la classe mère.
        self.position_source=='position source'
        self.position_cible=='position cible'
        self.couleur=='couleur'
        Colonne=int(input("la position de la colonne, donnez une valeur entre a et h = "))
        Rangee=int(input("la position de la rangée, donnez une valeur entre 1 et 8 = "))
        # Dans le cas présent, le pion ne se déplace que vers l'avant donc uniquement avec les rangées, donc demeure
        # dans la même colonne : exemple : a2 vers a3 (vers le bas pour pions noirs, vers le haut pions blancs.
        if self.couleur == 'blanc':
            self.position_source='position source'
            self.position_cible='position cible'
            Rangee=Rangee+1
            Colonne=Colonne+0
            print("La position cible est = ",Rangee,Colonne) # Affiche les coordonnées du pion blanc
        elif self.couleur == 'noire':
            self.position_source='position source'
            self.position_cible='position cible'
            Rangee=Rangee-1
            Colonne=Colonne+0
            print("La position cible est = ",Rangee,Colonne) # Affiche les coordonnées du pion blanc


    def peut_faire_une_prise_vers(self, position_source, position_cible):
        # TODO: À compléter, pour définir comment un pion mange une pièce adverse.
        self.position_source=='position source'
        self.postion_cible=='position cible'
        self.couleur=='couleur'
        Colonne=int(input('la position de la colonne, donnez une valeur entre a et h = '))
        Rangee=int(input("la position de la rangée, donnez une valeur entre 1 et 8 = "))
        Deplace=int(input("Déplacement du pion en diagonale selon sa couleur vers la droite (1) ou vers la gauche(2)"))
        # Dans le cas présent, le pion ne se déplace que vers l'avant donc uniquement avec les rangées, donc demeure
        # dans la même colonne : exemple : a2 vers a3 (vers le bas pour pions noirs, vers le haut pions blancs.
        if self.couleur == 'blanc':
            self.position_source='position source'
            if Deplace==1:
                self.position_cible='position cible'
                Rangee = Rangee-1
                Colonne = Colonne+1
                print("La position cible est = ",Rangee,Colonne) # Affiche les coordonnées du déplacement du pion blanc vers la droite en diagonale

            if Deplace==2:
                self.position_cible='position cible'
                Rangee = Rangee-1
                Colonne = Colonne-1
                print("La position cible est = ",Rangee,Colonne) # Affiche les coordonnées du déplacement du pion blanc vers la gauche en diagonale

        if self.couleur== 'noire':
            self.position_source='position source'
            if Deplace==1:
                self.position_cible='position cible'
                Rangee = Rangee+1
                Colonne = Colonne+1
                print("La position cible est = ",Rangee,Colonne) # Affiche les coordonnées du déplacement du pion noir vers la droite en diagonale

            if Deplace==2:
                self.position_cible='position cible'
                Rangee = Rangee+1
                Colonne = Colonne-1
                print("La position cible est = ",Rangee,Colonne) # Afffiche les coordonnées du déplacement du pion noir vers la gauche en diagonale

def __repr__(self):
        """Redéfinit comment on affiche un pion à l'écran. Nous utilisons la constante UTILISER_UNICODE
        pour déterminer comment afficher le pion.

        Returns:
            str: La chaîne de caractères représentant le pion.

        """
        if self.est_blanc():
            if UTILISER_UNICODE:
                return '\u2659'
            else:
                return 'PB'
        else:
            if UTILISER_UNICODE:
                return '\u265f'
            else:
                return 'PN'



class Tour(Piece):
    def __init__(self, couleur):
        super().__init__(couleur, False)

    def __repr__(self):
        if self.est_blanc():
            if UTILISER_UNICODE:
                return '\u2656'
            else:
                return 'TB'
        else:
            if UTILISER_UNICODE:
                return '\u265c'
            else:
                return 'TN'


class Cavalier(Piece):
    def __init__(self, couleur):
        super().__init__(couleur, True)

    def __repr__(self):
        if self.est_blanc():
            if UTILISER_UNICODE:
                return '\u2658'
            else:
                return 'CB'
        else:
            if UTILISER_UNICODE:
                return '\u265e'
            else:
                return 'CN'




class Fou(Piece):
    def __init__(self, couleur):
        super().__init__(couleur, False)

    def __repr__(self):
        if self.est_blanc():
            if UTILISER_UNICODE:
                return '\u2657'
            else:
                return 'FB'
        else:
            if UTILISER_UNICODE:
                return '\u265d'
            else:
                return 'FN'



class Roi(Piece):
    def __init__(self, couleur):
        super().__init__(couleur, False)

    def __repr__(self):
        if self.est_blanc():
            if UTILISER_UNICODE:
                return '\u2654'
            else:
                return 'RB'
        else:
            if UTILISER_UNICODE:
                return '\u265a'
            else:
                return 'RN'


class Dame(Piece):
    def __init__(self, couleur):
        super().__init__(couleur, False)

    def __repr__(self):
        if self.est_blanc():
            if UTILISER_UNICODE:
                return '\u2655'
            else:
                return 'DB'
        else:
            if UTILISER_UNICODE:
                return '\u265b'
            else:
                return 'DN'

J'ai donc remplacé ce qui était demandé jusqu'à la section : déplacement du pion (voir dans le devoir, section en gras) et aussi définition des parties en gras

Ma question est d'abord si vous pourriez en des mots simples me réexpliquer la notion de self.xxxx
Ensuite, me dire si ce que j'ai fait répond à l'intitulé, en somme, l'ai-je bien compris !

Voilà, je vous demande pas de faire les programmes pour les autres pièces du jeu d'échec mais simplement vérifier et me dire si ce que j'ai fait pour les déplacements du pion et des définitions de self.xxxx vous semblent corrects, et si cela n'est pas le cas, pourriez-vous m'aider ?
Merci

PS : Au fait, merci pour les Cours et tutoriels pour apprendre Python , en particulier celui la est extra : Apprendre à programmer avec Python 3 par Gérard Swinnen ;)

31/10/2015, 09h04
fred1599
Citation:

Ma question est d'abord si vous pourriez en des mots simples me réexpliquer la notion de self.xxxx

Une petite recherche et hop !

Citation:

Ensuite, me dire si ce que j'ai fait répond à l'intitulé, en somme, l'ai-je bien compris !

Il faut déjà bien comprendre le jeu d'échecs, par exemple :
- Seul le cavalier permet de sauter des pièces
- Les déplacements des pions ne peuvent qu'avancer soit normalement, soit en prenant une pièce
- Les autres pièces ont la possibilité de soit avancer, soit reculer
- ...
Faire comme si au début de partie me semble difficile, sachant que par la suite il demandera dans tous les cas possibles, et qu'on modifiera de nouveau le code, ça me paraît pas forcément une étape importante.

Dans le code des choses me choquent un peu
Code:

1 2 3 self.position_source=='position source' self.position_cible=='position cible' self.couleur=='couleur'
Je ne vois pas pourquoi faire des tests, qui puis est que l'on utilise pas par la suite ???

Si on prend par exemple le cas d'un pion, je peux avancer qu'à la condition où je n'ai pas de pion en face (il faut le vérifier)...
Code:

1 2 3 4 def deplacer(self): valeur = 1 if self.color == "white" else -1 if jeu[self.x, self.y+valeur].est_vide(): self.y += valeur
et là je ne prend pas en compte le fait de pouvoir prendre une figure.

En fait tout est dans la connaissance du jeu, le reste n'est que traduction.